diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml index 41defedd00b8..a3fa4a2ea724 100644 --- a/.gitea/workflows/release.yml +++ b/.gitea/workflows/release.yml @@ -145,7 +145,7 @@ jobs: windows: name: Windows Build - runs-on: "win-11" + runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -155,24 +155,49 @@ jobs: go-version: 1.24 cache: false - # Note: gcc.exe only works properly if the corresponding bin/ directory is - # contained in PATH. + - name: Install cross toolchain + run: | + apt-get update + apt-get -yq --no-install-suggests --no-install-recommends install \ + gcc-mingw-w64-x86-64 gcc-mingw-w64-i686 nsis - name: "Build (amd64)" - shell: cmd run: | - set PATH=%GETH_MINGW%\bin;%PATH% - go run build/ci.go install -dlgo -arch amd64 -cc %GETH_MINGW%\bin\gcc.exe + go run build/ci.go install -dlgo -os windows -arch amd64 -cc x86_64-w64-mingw32-gcc + + - name: "Create/upload archive (amd64)" + run: | + go run build/ci.go archive -os windows -arch amd64 -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + env: + WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} + AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} + + - name: "Create/upload NSIS installer (amd64)" + run: | + go run build/ci.go nsis -arch amd64 -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + rm -f build/bin/* env: - GETH_MINGW: 'C:\msys64\mingw64' + WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} + AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} - name: "Build (386)" - shell: cmd run: | - set PATH=%GETH_MINGW%\bin;%PATH% - go run build/ci.go install -dlgo -arch 386 -cc %GETH_MINGW%\bin\gcc.exe + go run build/ci.go install -dlgo -os windows -arch 386 -cc i686-w64-mingw32-gcc + + - name: "Create/upload archive (386)" + run: | + go run build/ci.go archive -os windows -arch 386 -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + env: + WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} + AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} + + - name: "Create/upload NSIS installer (386)" + run: | + go run build/ci.go nsis -arch 386 -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + rm -f build/bin/* env: - GETH_MINGW: 'C:\msys64\mingw32' + WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} + AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} docker: name: Docker Image diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 4bc13aff9203..39554550c442 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -10,6 +10,7 @@ beacon/merkle/ @zsfelfoldi beacon/types/ @zsfelfoldi @fjl beacon/params/ @zsfelfoldi @fjl cmd/evm/ @MariusVanDerWijden @lightclient +cmd/keeper/ @gballet core/state/ @rjl493456442 crypto/ @gballet @jwasinger @fjl core/ @rjl493456442 diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml new file mode 100644 index 000000000000..8f58ebee9a3a --- /dev/null +++ b/.github/workflows/freebsd.yml @@ -0,0 +1,29 @@ +on: + push: + branches: + - freebsd-github-action + + workflow_dispatch: + +jobs: + build: + name: FreeBSD-build + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + submodules: false + + - name: Test in FreeBSD + id: test + uses: vmactions/freebsd-vm@v1 + with: + release: "15.0" + usesh: true + prepare: | + pkg install -y go + run: | + freebsd-version + uname -a + go version + go run ./build/ci.go test -p 8 diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 50c9fe7f7511..3e811072ff5b 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -69,8 +69,8 @@ jobs: - name: Install cross toolchain run: | - apt-get update - apt-get -yq --no-install-suggests --no-install-recommends install gcc-multilib + sudo apt-get update + sudo apt-get -yq --no-install-suggests --no-install-recommends install gcc-multilib - name: Build run: go run build/ci.go test -arch 386 -short -p 8 @@ -97,3 +97,44 @@ jobs: - name: Run tests run: go run build/ci.go test -p 8 + + windows: + name: Windows ${{ matrix.arch }} + needs: lint + runs-on: [self-hosted, windows, x64] + strategy: + fail-fast: false + matrix: + include: + - arch: amd64 + mingw: 'C:\msys64\mingw64' + test: true + - arch: '386' + mingw: 'C:\msys64\mingw32' + test: false + env: + GETH_MINGW: ${{ matrix.mingw }} + GETH_CC: ${{ matrix.mingw }}\bin\gcc.exe + steps: + - uses: actions/checkout@v4 + with: + submodules: true + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: '1.25' + cache: false + + - name: Build + shell: cmd + run: | + set PATH=%GETH_MINGW%\bin;%PATH% + go run build/ci.go install -arch ${{ matrix.arch }} -cc %GETH_CC% + + - name: Run tests + if: matrix.test + shell: cmd + run: | + set PATH=%GETH_MINGW%\bin;%PATH% + go run build/ci.go test -arch ${{ matrix.arch }} -cc %GETH_CC% -short -p 8 diff --git a/.github/workflows/validate_pr.yml b/.github/workflows/validate_pr.yml index 57e8c12b5ee2..aa3c74cc67c0 100644 --- a/.github/workflows/validate_pr.yml +++ b/.github/workflows/validate_pr.yml @@ -8,6 +8,45 @@ jobs: validate-pr: runs-on: ubuntu-latest steps: + - name: Check for Spam PR + uses: actions/github-script@v7 + with: + script: | + const prTitle = context.payload.pull_request.title; + const spamRegex = /^(feat|chore|fix)(\(.*\))?\s*:/i; + + if (spamRegex.test(prTitle)) { + // Leave a comment explaining why + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.payload.pull_request.number, + body: `## PR Closed as Spam + + This PR was automatically closed because the title format \`feat:\`, \`fix:\`, or \`chore:\` is commonly associated with spam contributions. + + If this is a legitimate contribution, please: + 1. Review our contribution guidelines + 2. Use the correct PR title format: \`directory, ...: description\` + 3. Open a new PR with the proper title format + + Thank you for your understanding.` + }); + + // Close the PR + await github.rest.pulls.update({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: context.payload.pull_request.number, + state: 'closed' + }); + + core.setFailed('PR closed as spam due to suspicious title format'); + return; + } + + console.log('✅ PR passed spam check'); + - name: Checkout repository uses: actions/checkout@v4 diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 000000000000..91032c8f17ed --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,102 @@ +# AGENTS + +## Guidelines + +- **Keep changes minimal and focused.** Only modify code directly related to the task at hand. Do not refactor unrelated code, rename existing variables or functions for style, or bundle unrelated fixes into the same commit or PR. +- **Do not add, remove, or update dependencies** unless the task explicitly requires it. + +## Pre-Commit Checklist + +Before every commit, run **all** of the following checks and ensure they pass: + +### 1. Formatting + +Before committing, always run `gofmt` and `goimports` on all modified files: + +```sh +gofmt -w +goimports -w +``` + +### 2. Build All Commands + +Verify that all tools compile successfully: + +```sh +make all +``` + +This builds all executables under `cmd/`, including `keeper` which has special build requirements. + +### 3. Tests + +While iterating during development, use `-short` for faster feedback: + +```sh +go run ./build/ci.go test -short +``` + +Before committing, run the full test suite **without** `-short` to ensure all tests pass, including the Ethereum execution-spec tests and all state/block test permutations: + +```sh +go run ./build/ci.go test +``` + +### 4. Linting + +```sh +go run ./build/ci.go lint +``` + +This runs additional style checks. Fix any issues before committing. + +### 5. Generated Code + +```sh +go run ./build/ci.go check_generate +``` + +Ensures that all generated files (e.g., `gen_*.go`) are up to date. If this fails, first install the required code generators by running `make devtools`, then run the appropriate `go generate` commands and include the updated files in your commit. + +### 6. Dependency Hygiene + +```sh +go run ./build/ci.go check_baddeps +``` + +Verifies that no forbidden dependencies have been introduced. + +## What to include in commits + +Do not commit binaries, whether they are produced by the main build or byproducts of investigations. + +## Commit Message Format + +Commit messages must be prefixed with the package(s) they modify, followed by a short lowercase description: + +``` +: description +``` + +Examples: +- `core/vm: fix stack overflow in PUSH instruction` +- `eth, rpc: make trace configs optional` +- `cmd/geth: add new flag for sync mode` + +Use comma-separated package names when multiple areas are affected. Keep the description concise. + +## Pull Request Title Format + +PR titles follow the same convention as commit messages: + +``` +: description +``` + +Examples: +- `core/vm: fix stack overflow in PUSH instruction` +- `core, eth: add arena allocator support` +- `cmd/geth, internal/ethapi: refactor transaction args` +- `trie/archiver: streaming subtree archival to fix OOM` + +Use the top-level package paths, comma-separated if multiple areas are affected. Only mention the directories with functional changes, interface changes that trickle all over the codebase should not generate an exhaustive list. The description should be a short, lowercase summary of the change. diff --git a/Dockerfile b/Dockerfile index 9b70e9e8a069..940e568cab24 100644 --- a/Dockerfile +++ b/Dockerfile @@ -4,7 +4,7 @@ ARG VERSION="" ARG BUILDNUM="" # Build Geth in a stock Go builder container -FROM golang:1.24-alpine AS builder +FROM golang:1.26-alpine AS builder RUN apk add --no-cache gcc musl-dev linux-headers git diff --git a/Dockerfile.alltools b/Dockerfile.alltools index ac9303c6784a..ae2ca931aed9 100644 --- a/Dockerfile.alltools +++ b/Dockerfile.alltools @@ -4,7 +4,7 @@ ARG VERSION="" ARG BUILDNUM="" # Build Geth in a stock Go builder container -FROM golang:1.24-alpine AS builder +FROM golang:1.26-alpine AS builder RUN apk add --no-cache gcc musl-dev linux-headers git diff --git a/SECURITY.md b/SECURITY.md index 0b497b44aece..d497248de559 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -21,7 +21,6 @@ Audit reports are published in the `docs` folder: https://github.com/ethereum/go To find out how to disclose a vulnerability in Ethereum visit [https://bounty.ethereum.org](https://bounty.ethereum.org) or email bounty@ethereum.org. Please read the [disclosure page](https://github.com/ethereum/go-ethereum/security/advisories?state=published) for more information about publicly disclosed security vulnerabilities. -Use the built-in `geth version-check` feature to check whether the software is affected by any known vulnerability. This command will fetch the latest [`vulnerabilities.json`](https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities.json) file which contains known security vulnerabilities concerning `geth`, and cross-check the data against its own version number. The following key may be used to communicate sensitive information to developers. diff --git a/accounts/abi/abigen/source2.go.tpl b/accounts/abi/abigen/source2.go.tpl index 3d98cbb70030..c517caf6f4a6 100644 --- a/accounts/abi/abigen/source2.go.tpl +++ b/accounts/abi/abigen/source2.go.tpl @@ -183,8 +183,11 @@ var ( // Solidity: {{.Original.String}} func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { event := "{{.Original.Name}}" - if len(log.Topics) == 0 || log.Topics[0] != {{ decapitalise $contract.Type}}.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != {{ decapitalise $contract.Type}}.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new({{$contract.Type}}{{.Normalized.Name}}) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/crowdsale.go.txt b/accounts/abi/abigen/testdata/v2/crowdsale.go.txt index b548b6cdaee2..f0bba246ab01 100644 --- a/accounts/abi/abigen/testdata/v2/crowdsale.go.txt +++ b/accounts/abi/abigen/testdata/v2/crowdsale.go.txt @@ -360,8 +360,11 @@ func (CrowdsaleFundTransfer) ContractEventName() string { // Solidity: event FundTransfer(address backer, uint256 amount, bool isContribution) func (crowdsale *Crowdsale) UnpackFundTransferEvent(log *types.Log) (*CrowdsaleFundTransfer, error) { event := "FundTransfer" - if len(log.Topics) == 0 || log.Topics[0] != crowdsale.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != crowdsale.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(CrowdsaleFundTransfer) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/dao.go.txt b/accounts/abi/abigen/testdata/v2/dao.go.txt index c246771d6d07..0e9adba31e41 100644 --- a/accounts/abi/abigen/testdata/v2/dao.go.txt +++ b/accounts/abi/abigen/testdata/v2/dao.go.txt @@ -606,8 +606,11 @@ func (DAOChangeOfRules) ContractEventName() string { // Solidity: event ChangeOfRules(uint256 minimumQuorum, uint256 debatingPeriodInMinutes, int256 majorityMargin) func (dAO *DAO) UnpackChangeOfRulesEvent(log *types.Log) (*DAOChangeOfRules, error) { event := "ChangeOfRules" - if len(log.Topics) == 0 || log.Topics[0] != dAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dAO.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DAOChangeOfRules) if len(log.Data) > 0 { @@ -648,8 +651,11 @@ func (DAOMembershipChanged) ContractEventName() string { // Solidity: event MembershipChanged(address member, bool isMember) func (dAO *DAO) UnpackMembershipChangedEvent(log *types.Log) (*DAOMembershipChanged, error) { event := "MembershipChanged" - if len(log.Topics) == 0 || log.Topics[0] != dAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dAO.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DAOMembershipChanged) if len(log.Data) > 0 { @@ -692,8 +698,11 @@ func (DAOProposalAdded) ContractEventName() string { // Solidity: event ProposalAdded(uint256 proposalID, address recipient, uint256 amount, string description) func (dAO *DAO) UnpackProposalAddedEvent(log *types.Log) (*DAOProposalAdded, error) { event := "ProposalAdded" - if len(log.Topics) == 0 || log.Topics[0] != dAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dAO.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DAOProposalAdded) if len(log.Data) > 0 { @@ -736,8 +745,11 @@ func (DAOProposalTallied) ContractEventName() string { // Solidity: event ProposalTallied(uint256 proposalID, int256 result, uint256 quorum, bool active) func (dAO *DAO) UnpackProposalTalliedEvent(log *types.Log) (*DAOProposalTallied, error) { event := "ProposalTallied" - if len(log.Topics) == 0 || log.Topics[0] != dAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dAO.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DAOProposalTallied) if len(log.Data) > 0 { @@ -780,8 +792,11 @@ func (DAOVoted) ContractEventName() string { // Solidity: event Voted(uint256 proposalID, bool position, address voter, string justification) func (dAO *DAO) UnpackVotedEvent(log *types.Log) (*DAOVoted, error) { event := "Voted" - if len(log.Topics) == 0 || log.Topics[0] != dAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dAO.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DAOVoted) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/eventchecker.go.txt b/accounts/abi/abigen/testdata/v2/eventchecker.go.txt index 8ad59e63b105..d0600d7c3e6a 100644 --- a/accounts/abi/abigen/testdata/v2/eventchecker.go.txt +++ b/accounts/abi/abigen/testdata/v2/eventchecker.go.txt @@ -72,8 +72,11 @@ func (EventCheckerDynamic) ContractEventName() string { // Solidity: event dynamic(string indexed idxStr, bytes indexed idxDat, string str, bytes dat) func (eventChecker *EventChecker) UnpackDynamicEvent(log *types.Log) (*EventCheckerDynamic, error) { event := "dynamic" - if len(log.Topics) == 0 || log.Topics[0] != eventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != eventChecker.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(EventCheckerDynamic) if len(log.Data) > 0 { @@ -112,8 +115,11 @@ func (EventCheckerEmpty) ContractEventName() string { // Solidity: event empty() func (eventChecker *EventChecker) UnpackEmptyEvent(log *types.Log) (*EventCheckerEmpty, error) { event := "empty" - if len(log.Topics) == 0 || log.Topics[0] != eventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != eventChecker.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(EventCheckerEmpty) if len(log.Data) > 0 { @@ -154,8 +160,11 @@ func (EventCheckerIndexed) ContractEventName() string { // Solidity: event indexed(address indexed addr, int256 indexed num) func (eventChecker *EventChecker) UnpackIndexedEvent(log *types.Log) (*EventCheckerIndexed, error) { event := "indexed" - if len(log.Topics) == 0 || log.Topics[0] != eventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != eventChecker.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(EventCheckerIndexed) if len(log.Data) > 0 { @@ -196,8 +205,11 @@ func (EventCheckerMixed) ContractEventName() string { // Solidity: event mixed(address indexed addr, int256 num) func (eventChecker *EventChecker) UnpackMixedEvent(log *types.Log) (*EventCheckerMixed, error) { event := "mixed" - if len(log.Topics) == 0 || log.Topics[0] != eventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != eventChecker.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(EventCheckerMixed) if len(log.Data) > 0 { @@ -238,8 +250,11 @@ func (EventCheckerUnnamed) ContractEventName() string { // Solidity: event unnamed(uint256 indexed arg0, uint256 indexed arg1) func (eventChecker *EventChecker) UnpackUnnamedEvent(log *types.Log) (*EventCheckerUnnamed, error) { event := "unnamed" - if len(log.Topics) == 0 || log.Topics[0] != eventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != eventChecker.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(EventCheckerUnnamed) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/nameconflict.go.txt b/accounts/abi/abigen/testdata/v2/nameconflict.go.txt index 3fbabee5a559..5e4a9ecaf092 100644 --- a/accounts/abi/abigen/testdata/v2/nameconflict.go.txt +++ b/accounts/abi/abigen/testdata/v2/nameconflict.go.txt @@ -134,8 +134,11 @@ func (NameConflictLog) ContractEventName() string { // Solidity: event log(int256 msg, int256 _msg) func (nameConflict *NameConflict) UnpackLogEvent(log *types.Log) (*NameConflictLog, error) { event := "log" - if len(log.Topics) == 0 || log.Topics[0] != nameConflict.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != nameConflict.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(NameConflictLog) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt b/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt index d962583e4890..0af31a1cfb77 100644 --- a/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt +++ b/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt @@ -136,8 +136,11 @@ func (NumericMethodNameE1TestEvent) ContractEventName() string { // Solidity: event _1TestEvent(address _param) func (numericMethodName *NumericMethodName) UnpackE1TestEventEvent(log *types.Log) (*NumericMethodNameE1TestEvent, error) { event := "_1TestEvent" - if len(log.Topics) == 0 || log.Topics[0] != numericMethodName.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != numericMethodName.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(NumericMethodNameE1TestEvent) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/overload.go.txt b/accounts/abi/abigen/testdata/v2/overload.go.txt index ddddd1018664..563edf784297 100644 --- a/accounts/abi/abigen/testdata/v2/overload.go.txt +++ b/accounts/abi/abigen/testdata/v2/overload.go.txt @@ -114,8 +114,11 @@ func (OverloadBar) ContractEventName() string { // Solidity: event bar(uint256 i) func (overload *Overload) UnpackBarEvent(log *types.Log) (*OverloadBar, error) { event := "bar" - if len(log.Topics) == 0 || log.Topics[0] != overload.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != overload.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(OverloadBar) if len(log.Data) > 0 { @@ -156,8 +159,11 @@ func (OverloadBar0) ContractEventName() string { // Solidity: event bar(uint256 i, uint256 j) func (overload *Overload) UnpackBar0Event(log *types.Log) (*OverloadBar0, error) { event := "bar0" - if len(log.Topics) == 0 || log.Topics[0] != overload.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != overload.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(OverloadBar0) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/token.go.txt b/accounts/abi/abigen/testdata/v2/token.go.txt index 6ebc96861b9c..3bd60a6cddd8 100644 --- a/accounts/abi/abigen/testdata/v2/token.go.txt +++ b/accounts/abi/abigen/testdata/v2/token.go.txt @@ -386,8 +386,11 @@ func (TokenTransfer) ContractEventName() string { // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) func (token *Token) UnpackTransferEvent(log *types.Log) (*TokenTransfer, error) { event := "Transfer" - if len(log.Topics) == 0 || log.Topics[0] != token.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != token.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(TokenTransfer) if len(log.Data) > 0 { diff --git a/accounts/abi/abigen/testdata/v2/tuple.go.txt b/accounts/abi/abigen/testdata/v2/tuple.go.txt index 4724fdd351db..10b634f3dbc9 100644 --- a/accounts/abi/abigen/testdata/v2/tuple.go.txt +++ b/accounts/abi/abigen/testdata/v2/tuple.go.txt @@ -193,8 +193,11 @@ func (TupleTupleEvent) ContractEventName() string { // Solidity: event TupleEvent((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) func (tuple *Tuple) UnpackTupleEventEvent(log *types.Log) (*TupleTupleEvent, error) { event := "TupleEvent" - if len(log.Topics) == 0 || log.Topics[0] != tuple.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != tuple.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(TupleTupleEvent) if len(log.Data) > 0 { @@ -234,8 +237,11 @@ func (TupleTupleEvent2) ContractEventName() string { // Solidity: event TupleEvent2((uint8,uint8)[] arg0) func (tuple *Tuple) UnpackTupleEvent2Event(log *types.Log) (*TupleTupleEvent2, error) { event := "TupleEvent2" - if len(log.Topics) == 0 || log.Topics[0] != tuple.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != tuple.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(TupleTupleEvent2) if len(log.Data) > 0 { diff --git a/accounts/abi/bind/old.go b/accounts/abi/bind/old.go index b09f5f3c7ac2..1fe1b1cca578 100644 --- a/accounts/abi/bind/old.go +++ b/accounts/abi/bind/old.go @@ -176,6 +176,13 @@ var ( // ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves // an empty contract behind. ErrNoCodeAfterDeploy = bind2.ErrNoCodeAfterDeploy + + // ErrNoEventSignature is returned when a log entry has no topics. + ErrNoEventSignature = bind2.ErrNoEventSignature + + // ErrEventSignatureMismatch is returned when a log's topic[0] does not match + // the expected event signature. + ErrEventSignatureMismatch = bind2.ErrEventSignatureMismatch ) // ContractCaller defines the methods needed to allow operating with a contract on a read diff --git a/accounts/abi/bind/v2/base.go b/accounts/abi/bind/v2/base.go index 4f2013b4a329..862175ee32c2 100644 --- a/accounts/abi/bind/v2/base.go +++ b/accounts/abi/bind/v2/base.go @@ -35,8 +35,8 @@ import ( const basefeeWiggleMultiplier = 2 var ( - errNoEventSignature = errors.New("no event signature") - errEventSignatureMismatch = errors.New("event signature mismatch") + ErrNoEventSignature = errors.New("no event signature") + ErrEventSignatureMismatch = errors.New("event signature mismatch") ) // SignerFn is a signer function callback when a contract requires a method to @@ -536,10 +536,10 @@ func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]any) func (c *BoundContract) UnpackLog(out any, event string, log types.Log) error { // Anonymous events are not supported. if len(log.Topics) == 0 { - return errNoEventSignature + return ErrNoEventSignature } if log.Topics[0] != c.abi.Events[event].ID { - return errEventSignatureMismatch + return ErrEventSignatureMismatch } if len(log.Data) > 0 { if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil { @@ -559,10 +559,10 @@ func (c *BoundContract) UnpackLog(out any, event string, log types.Log) error { func (c *BoundContract) UnpackLogIntoMap(out map[string]any, event string, log types.Log) error { // Anonymous events are not supported. if len(log.Topics) == 0 { - return errNoEventSignature + return ErrNoEventSignature } if log.Topics[0] != c.abi.Events[event].ID { - return errEventSignatureMismatch + return ErrEventSignatureMismatch } if len(log.Data) > 0 { if err := c.abi.UnpackIntoMap(out, event, log.Data); err != nil { diff --git a/accounts/abi/bind/v2/dep_tree_test.go b/accounts/abi/bind/v2/dep_tree_test.go index e686e3fec485..b2470d8a162e 100644 --- a/accounts/abi/bind/v2/dep_tree_test.go +++ b/accounts/abi/bind/v2/dep_tree_test.go @@ -158,10 +158,10 @@ func testLinkCase(tcInput linkTestCaseInput) error { overrideAddrs = make(map[rune]common.Address) ) // generate deterministic addresses for the override set. - rand.Seed(42) + rng := rand.New(rand.NewSource(42)) for contract := range tcInput.overrides { var addr common.Address - rand.Read(addr[:]) + rng.Read(addr[:]) overrideAddrs[contract] = addr overridesAddrs[addr] = struct{}{} } diff --git a/accounts/abi/bind/v2/internal/contracts/db/bindings.go b/accounts/abi/bind/v2/internal/contracts/db/bindings.go index 4ac1652ff7c4..2fc57fba6d4f 100644 --- a/accounts/abi/bind/v2/internal/contracts/db/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/db/bindings.go @@ -276,8 +276,11 @@ func (DBInsert) ContractEventName() string { // Solidity: event Insert(uint256 key, uint256 value, uint256 length) func (dB *DB) UnpackInsertEvent(log *types.Log) (*DBInsert, error) { event := "Insert" - if len(log.Topics) == 0 || log.Topics[0] != dB.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dB.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DBInsert) if len(log.Data) > 0 { @@ -318,8 +321,11 @@ func (DBKeyedInsert) ContractEventName() string { // Solidity: event KeyedInsert(uint256 indexed key, uint256 value) func (dB *DB) UnpackKeyedInsertEvent(log *types.Log) (*DBKeyedInsert, error) { event := "KeyedInsert" - if len(log.Topics) == 0 || log.Topics[0] != dB.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != dB.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(DBKeyedInsert) if len(log.Data) > 0 { diff --git a/accounts/abi/bind/v2/internal/contracts/events/bindings.go b/accounts/abi/bind/v2/internal/contracts/events/bindings.go index 40d2c44a44fe..2eb5751f2352 100644 --- a/accounts/abi/bind/v2/internal/contracts/events/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/events/bindings.go @@ -115,8 +115,11 @@ func (CBasic1) ContractEventName() string { // Solidity: event basic1(uint256 indexed id, uint256 data) func (c *C) UnpackBasic1Event(log *types.Log) (*CBasic1, error) { event := "basic1" - if len(log.Topics) == 0 || log.Topics[0] != c.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != c.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(CBasic1) if len(log.Data) > 0 { @@ -157,8 +160,11 @@ func (CBasic2) ContractEventName() string { // Solidity: event basic2(bool indexed flag, uint256 data) func (c *C) UnpackBasic2Event(log *types.Log) (*CBasic2, error) { event := "basic2" - if len(log.Topics) == 0 || log.Topics[0] != c.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") + if len(log.Topics) == 0 { + return nil, bind.ErrNoEventSignature + } + if log.Topics[0] != c.abi.Events[event].ID { + return nil, bind.ErrEventSignatureMismatch } out := new(CBasic2) if len(log.Data) > 0 { diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 11360fc7dddc..38dfa74dfa4f 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -379,16 +379,16 @@ func TestEventUnpackEmptyTopics(t *testing.T) { if err == nil { t.Fatal("expected error when unpacking event with empty topics, got nil") } - if err.Error() != "event signature mismatch" { - t.Fatalf("expected 'event signature mismatch' error, got: %v", err) + if err != bind.ErrNoEventSignature { + t.Fatalf("expected 'no event signature' error, got: %v", err) } _, err = c.UnpackBasic2Event(log) if err == nil { t.Fatal("expected error when unpacking event with empty topics, got nil") } - if err.Error() != "event signature mismatch" { - t.Fatalf("expected 'event signature mismatch' error, got: %v", err) + if err != bind.ErrNoEventSignature { + t.Fatalf("expected 'no event signature' error, got: %v", err) } } } diff --git a/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go index 90713c03ca22..90cfa686557e 100644 --- a/accounts/abi/unpack_test.go +++ b/accounts/abi/unpack_test.go @@ -910,7 +910,7 @@ func TestUnpackTuple(t *testing.T) { }, }, FieldT: T{ - big.NewInt(0), big.NewInt(1), + big.NewInt(0).SetBits([]big.Word{}), big.NewInt(1), }, A: big.NewInt(1), } @@ -919,7 +919,7 @@ func TestUnpackTuple(t *testing.T) { if err != nil { t.Error(err) } - if reflect.DeepEqual(ret, expected) { + if !reflect.DeepEqual(ret, expected) { t.Error("unexpected unpack value") } } diff --git a/accounts/accounts.go b/accounts/accounts.go index 7bd911577a11..6249beed0d3c 100644 --- a/accounts/accounts.go +++ b/accounts/accounts.go @@ -24,8 +24,8 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/event" - "golang.org/x/crypto/sha3" ) // Account represents an Ethereum account located at a specific location defined @@ -196,7 +196,7 @@ func TextHash(data []byte) []byte { // This gives context to the signed message and prevents signing of transactions. func TextAndHash(data []byte) ([]byte, string) { msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data) - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() hasher.Write([]byte(msg)) return hasher.Sum(nil), msg } diff --git a/accounts/keystore/account_cache_test.go b/accounts/keystore/account_cache_test.go index c9a8cdfcef3d..e49b110e7e1b 100644 --- a/accounts/keystore/account_cache_test.go +++ b/accounts/keystore/account_cache_test.go @@ -68,18 +68,27 @@ func waitWatcherStart(ks *KeyStore) bool { func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error { var list []accounts.Account + haveAccounts := false + haveChange := false for t0 := time.Now(); time.Since(t0) < 5*time.Second; time.Sleep(100 * time.Millisecond) { - list = ks.Accounts() - if reflect.DeepEqual(list, wantAccounts) { - // ks should have also received change notifications + if !haveAccounts { + list = ks.Accounts() + haveAccounts = reflect.DeepEqual(list, wantAccounts) + } + if !haveChange { select { case <-ks.changes: + haveChange = true default: - return errors.New("wasn't notified of new accounts") } + } + if haveAccounts && haveChange { return nil } } + if haveAccounts { + return errors.New("wasn't notified of new accounts") + } return fmt.Errorf("\ngot %v\nwant %v", list, wantAccounts) } diff --git a/accounts/keystore/presale.go b/accounts/keystore/presale.go index 0664dc2cdd05..6311e8d90a3a 100644 --- a/accounts/keystore/presale.go +++ b/accounts/keystore/presale.go @@ -81,6 +81,9 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error */ passBytes := []byte(password) derivedKey := pbkdf2.Key(passBytes, passBytes, 2000, 16, sha256.New) + if len(cipherText)%aes.BlockSize != 0 { + return nil, errors.New("ciphertext must be a multiple of block size") + } plainText, err := aesCBCDecrypt(derivedKey, cipherText, iv) if err != nil { return nil, err diff --git a/accounts/keystore/watch.go b/accounts/keystore/watch.go index 1bef321cd1f6..e2fcd1871aba 100644 --- a/accounts/keystore/watch.go +++ b/accounts/keystore/watch.go @@ -14,8 +14,8 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -//go:build (darwin && !ios && cgo) || freebsd || (linux && !arm64) || netbsd || solaris -// +build darwin,!ios,cgo freebsd linux,!arm64 netbsd solaris +//go:build (darwin && !ios && cgo) || freebsd || linux || netbsd || solaris +// +build darwin,!ios,cgo freebsd linux netbsd solaris package keystore diff --git a/accounts/keystore/watch_fallback.go b/accounts/keystore/watch_fallback.go index e3c133b3f6ad..ee1b989e63a9 100644 --- a/accounts/keystore/watch_fallback.go +++ b/accounts/keystore/watch_fallback.go @@ -14,8 +14,8 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -//go:build (darwin && !cgo) || ios || (linux && arm64) || windows || (!darwin && !freebsd && !linux && !netbsd && !solaris) -// +build darwin,!cgo ios linux,arm64 windows !darwin,!freebsd,!linux,!netbsd,!solaris +//go:build (darwin && !cgo) || ios || windows || (!darwin && !freebsd && !linux && !netbsd && !solaris) +// +build darwin,!cgo ios windows !darwin,!freebsd,!linux,!netbsd,!solaris // This is the fallback implementation of directory watching. // It is used on unsupported platforms. diff --git a/accounts/scwallet/hub.go b/accounts/scwallet/hub.go index 1b1899dc8e8e..185815365e5e 100644 --- a/accounts/scwallet/hub.go +++ b/accounts/scwallet/hub.go @@ -113,7 +113,7 @@ func (hub *Hub) readPairings() error { } func (hub *Hub) writePairings() error { - pairingFile, err := os.OpenFile(filepath.Join(hub.datadir, "smartcards.json"), os.O_RDWR|os.O_CREATE, 0755) + pairingFile, err := os.OpenFile(filepath.Join(hub.datadir, "smartcards.json"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755) if err != nil { return err } @@ -129,11 +129,8 @@ func (hub *Hub) writePairings() error { return err } - if _, err := pairingFile.Write(pairingData); err != nil { - return err - } - - return nil + _, err = pairingFile.Write(pairingData) + return err } func (hub *Hub) pairing(wallet *Wallet) *smartcardPairing { diff --git a/accounts/scwallet/securechannel.go b/accounts/scwallet/securechannel.go index b3a7be8df0bd..1e0230dc45d9 100644 --- a/accounts/scwallet/securechannel.go +++ b/accounts/scwallet/securechannel.go @@ -300,6 +300,10 @@ func (s *SecureChannelSession) decryptAPDU(data []byte) ([]byte, error) { return nil, err } + if len(data) == 0 || len(data)%aes.BlockSize != 0 { + return nil, fmt.Errorf("invalid ciphertext length: %d", len(data)) + } + ret := make([]byte, len(data)) crypter := cipher.NewCBCDecrypter(a, s.iv) diff --git a/accounts/usbwallet/hub.go b/accounts/usbwallet/hub.go index 81457b7da27a..cfa844b34569 100644 --- a/accounts/usbwallet/hub.go +++ b/accounts/usbwallet/hub.go @@ -26,7 +26,7 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/log" - "github.com/karalabe/hid" + "github.com/ethereum/hid" ) // LedgerScheme is the protocol scheme prefixing account and wallet URLs. @@ -43,6 +43,14 @@ const refreshCycle = time.Second // trashing. const refreshThrottling = 500 * time.Millisecond +const ( + // deviceUsagePage identifies Ledger devices by HID usage page (0xffa0) on Windows and macOS. + // See: https://github.com/LedgerHQ/ledger-live/blob/05a2980e838955a11a1418da638ef8ac3df4fb74/libs/ledgerjs/packages/hw-transport-node-hid-noevents/src/TransportNodeHid.ts + deviceUsagePage = 0xffa0 + // deviceInterface identifies Ledger devices by USB interface number (0) on Linux. + deviceInterface = 0 +) + // Hub is a accounts.Backend that can find and handle generic USB hardware wallets. type Hub struct { scheme string // Protocol scheme prefixing account and wallet URLs. @@ -82,6 +90,7 @@ func NewLedgerHub() (*Hub, error) { 0x0005, /* Ledger Nano S Plus */ 0x0006, /* Ledger Nano FTS */ 0x0007, /* Ledger Flex */ + 0x0008, /* Ledger Nano Gen5 */ 0x0000, /* WebUSB Ledger Blue */ 0x1000, /* WebUSB Ledger Nano S */ @@ -89,7 +98,8 @@ func NewLedgerHub() (*Hub, error) { 0x5000, /* WebUSB Ledger Nano S Plus */ 0x6000, /* WebUSB Ledger Nano FTS */ 0x7000, /* WebUSB Ledger Flex */ - }, 0xffa0, 0, newLedgerDriver) + 0x8000, /* WebUSB Ledger Nano Gen5 */ + }, deviceUsagePage, deviceInterface, newLedgerDriver) } // NewTrezorHubWithHID creates a new hardware wallet manager for Trezor devices. diff --git a/accounts/usbwallet/wallet.go b/accounts/usbwallet/wallet.go index f1597ca1a702..5da58a2ec2df 100644 --- a/accounts/usbwallet/wallet.go +++ b/accounts/usbwallet/wallet.go @@ -31,7 +31,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" - "github.com/karalabe/hid" + "github.com/ethereum/hid" ) // Maximum time between wallet health checks to detect USB unplugs. diff --git a/appveyor.yml b/appveyor.yml deleted file mode 100644 index aeafcfc8380b..000000000000 --- a/appveyor.yml +++ /dev/null @@ -1,39 +0,0 @@ -clone_depth: 5 -version: "{branch}.{build}" - -image: - - Visual Studio 2019 - -environment: - matrix: - - GETH_ARCH: amd64 - GETH_MINGW: 'C:\msys64\mingw64' - - GETH_ARCH: 386 - GETH_MINGW: 'C:\msys64\mingw32' - -install: - - git submodule update --init --depth 1 --recursive - - go version - -for: - # Windows builds for amd64 + 386. - - matrix: - only: - - image: Visual Studio 2019 - environment: - # We use gcc from MSYS2 because it is the most recent compiler version available on - # AppVeyor. Note: gcc.exe only works properly if the corresponding bin/ directory is - # contained in PATH. - GETH_CC: '%GETH_MINGW%\bin\gcc.exe' - PATH: '%GETH_MINGW%\bin;C:\Program Files (x86)\NSIS\;%PATH%' - build_script: - - 'echo %GETH_ARCH%' - - 'echo %GETH_CC%' - - '%GETH_CC% --version' - - go run build/ci.go install -dlgo -arch %GETH_ARCH% -cc %GETH_CC% - after_build: - # Upload builds. Note that ci.go makes this a no-op PR builds. - - go run build/ci.go archive -arch %GETH_ARCH% -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds - - go run build/ci.go nsis -arch %GETH_ARCH% -signer WINDOWS_SIGNING_KEY -upload gethstore/builds - test_script: - - go run build/ci.go test -dlgo -arch %GETH_ARCH% -cc %GETH_CC% -short diff --git a/beacon/blsync/engineclient.go b/beacon/blsync/engineclient.go index 9fc6a18a5773..6cac2bc5a82c 100644 --- a/beacon/blsync/engineclient.go +++ b/beacon/blsync/engineclient.go @@ -87,6 +87,10 @@ func (ec *engineClient) updateLoop(headCh <-chan types.ChainHeadEvent) { if status, err := ec.callForkchoiceUpdated(forkName, event); err == nil { log.Info("Successful ForkchoiceUpdated", "head", event.Block.Hash(), "status", status) } else { + if err.Error() == "beacon syncer reorging" { + log.Debug("Failed ForkchoiceUpdated", "head", event.Block.Hash(), "error", err) + continue // ignore beacon syncer reorging errors, this error can occur if the blsync is skipping a block + } log.Error("Failed ForkchoiceUpdated", "head", event.Block.Hash(), "error", err) } } diff --git a/beacon/engine/errors.go b/beacon/engine/errors.go index 62773a0ea9f6..80e13b11b9b9 100644 --- a/beacon/engine/errors.go +++ b/beacon/engine/errors.go @@ -81,6 +81,7 @@ var ( TooLargeRequest = &EngineAPIError{code: -38004, msg: "Too large request"} InvalidParams = &EngineAPIError{code: -32602, msg: "Invalid parameters"} UnsupportedFork = &EngineAPIError{code: -38005, msg: "Unsupported fork"} + TooDeepReorg = &EngineAPIError{code: -38006, msg: "Too deep reorg"} STATUS_INVALID = ForkChoiceResponse{PayloadStatus: PayloadStatusV1{Status: INVALID}, PayloadID: nil} STATUS_SYNCING = ForkChoiceResponse{PayloadStatus: PayloadStatusV1{Status: SYNCING}, PayloadID: nil} diff --git a/beacon/engine/gen_blockparams.go b/beacon/engine/gen_blockparams.go index b1f01b50ff8e..3a5d7ae593d0 100644 --- a/beacon/engine/gen_blockparams.go +++ b/beacon/engine/gen_blockparams.go @@ -21,6 +21,7 @@ func (p PayloadAttributes) MarshalJSON() ([]byte, error) { SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"` + SlotNumber *hexutil.Uint64 `json:"slotNumber"` } var enc PayloadAttributes enc.Timestamp = hexutil.Uint64(p.Timestamp) @@ -28,6 +29,7 @@ func (p PayloadAttributes) MarshalJSON() ([]byte, error) { enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient enc.Withdrawals = p.Withdrawals enc.BeaconRoot = p.BeaconRoot + enc.SlotNumber = (*hexutil.Uint64)(p.SlotNumber) return json.Marshal(&enc) } @@ -39,6 +41,7 @@ func (p *PayloadAttributes) UnmarshalJSON(input []byte) error { SuggestedFeeRecipient *common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"` + SlotNumber *hexutil.Uint64 `json:"slotNumber"` } var dec PayloadAttributes if err := json.Unmarshal(input, &dec); err != nil { @@ -62,5 +65,8 @@ func (p *PayloadAttributes) UnmarshalJSON(input []byte) error { if dec.BeaconRoot != nil { p.BeaconRoot = dec.BeaconRoot } + if dec.SlotNumber != nil { + p.SlotNumber = (*uint64)(dec.SlotNumber) + } return nil } diff --git a/beacon/engine/gen_ed.go b/beacon/engine/gen_ed.go index 0ae5a3b8f1f1..c733b3f35017 100644 --- a/beacon/engine/gen_ed.go +++ b/beacon/engine/gen_ed.go @@ -17,24 +17,24 @@ var _ = (*executableDataMarshaling)(nil) // MarshalJSON marshals as JSON. func (e ExecutableData) MarshalJSON() ([]byte, error) { type ExecutableData struct { - ParentHash common.Hash `json:"parentHash" gencodec:"required"` - FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` - StateRoot common.Hash `json:"stateRoot" gencodec:"required"` - ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` - LogsBloom hexutil.Bytes `json:"logsBloom" gencodec:"required"` - Random common.Hash `json:"prevRandao" gencodec:"required"` - Number hexutil.Uint64 `json:"blockNumber" gencodec:"required"` - GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` - ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"` - BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` - BlockHash common.Hash `json:"blockHash" gencodec:"required"` - Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` - ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"` + ParentHash common.Hash `json:"parentHash" gencodec:"required"` + FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` + StateRoot common.Hash `json:"stateRoot" gencodec:"required"` + ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` + LogsBloom hexutil.Bytes `json:"logsBloom" gencodec:"required"` + Random common.Hash `json:"prevRandao" gencodec:"required"` + Number hexutil.Uint64 `json:"blockNumber" gencodec:"required"` + GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Timestamp hexutil.Uint64 `json:"timestamp" gencodec:"required"` + ExtraData hexutil.Bytes `json:"extraData" gencodec:"required"` + BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` + BlockHash common.Hash `json:"blockHash" gencodec:"required"` + Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` + ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + SlotNumber *hexutil.Uint64 `json:"slotNumber,omitempty"` } var enc ExecutableData enc.ParentHash = e.ParentHash @@ -59,31 +59,31 @@ func (e ExecutableData) MarshalJSON() ([]byte, error) { enc.Withdrawals = e.Withdrawals enc.BlobGasUsed = (*hexutil.Uint64)(e.BlobGasUsed) enc.ExcessBlobGas = (*hexutil.Uint64)(e.ExcessBlobGas) - enc.ExecutionWitness = e.ExecutionWitness + enc.SlotNumber = (*hexutil.Uint64)(e.SlotNumber) return json.Marshal(&enc) } // UnmarshalJSON unmarshals from JSON. func (e *ExecutableData) UnmarshalJSON(input []byte) error { type ExecutableData struct { - ParentHash *common.Hash `json:"parentHash" gencodec:"required"` - FeeRecipient *common.Address `json:"feeRecipient" gencodec:"required"` - StateRoot *common.Hash `json:"stateRoot" gencodec:"required"` - ReceiptsRoot *common.Hash `json:"receiptsRoot" gencodec:"required"` - LogsBloom *hexutil.Bytes `json:"logsBloom" gencodec:"required"` - Random *common.Hash `json:"prevRandao" gencodec:"required"` - Number *hexutil.Uint64 `json:"blockNumber" gencodec:"required"` - GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` - ExtraData *hexutil.Bytes `json:"extraData" gencodec:"required"` - BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` - BlockHash *common.Hash `json:"blockHash" gencodec:"required"` - Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` - ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"` + ParentHash *common.Hash `json:"parentHash" gencodec:"required"` + FeeRecipient *common.Address `json:"feeRecipient" gencodec:"required"` + StateRoot *common.Hash `json:"stateRoot" gencodec:"required"` + ReceiptsRoot *common.Hash `json:"receiptsRoot" gencodec:"required"` + LogsBloom *hexutil.Bytes `json:"logsBloom" gencodec:"required"` + Random *common.Hash `json:"prevRandao" gencodec:"required"` + Number *hexutil.Uint64 `json:"blockNumber" gencodec:"required"` + GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Timestamp *hexutil.Uint64 `json:"timestamp" gencodec:"required"` + ExtraData *hexutil.Bytes `json:"extraData" gencodec:"required"` + BaseFeePerGas *hexutil.Big `json:"baseFeePerGas" gencodec:"required"` + BlockHash *common.Hash `json:"blockHash" gencodec:"required"` + Transactions []hexutil.Bytes `json:"transactions" gencodec:"required"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` + ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` + SlotNumber *hexutil.Uint64 `json:"slotNumber,omitempty"` } var dec ExecutableData if err := json.Unmarshal(input, &dec); err != nil { @@ -157,8 +157,8 @@ func (e *ExecutableData) UnmarshalJSON(input []byte) error { if dec.ExcessBlobGas != nil { e.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas) } - if dec.ExecutionWitness != nil { - e.ExecutionWitness = dec.ExecutionWitness + if dec.SlotNumber != nil { + e.SlotNumber = (*uint64)(dec.SlotNumber) } return nil } diff --git a/beacon/engine/types.go b/beacon/engine/types.go index ddb276ab0914..9b0b186df753 100644 --- a/beacon/engine/types.go +++ b/beacon/engine/types.go @@ -50,6 +50,13 @@ var ( // ExecutionPayloadV3 has the syntax of ExecutionPayloadV2 and appends the new // fields: blobGasUsed and excessBlobGas. PayloadV3 PayloadVersion = 0x3 + + // PayloadV4 is the identifier of ExecutionPayloadV4 introduced in amsterdam fork. + // + // https://github.com/ethereum/execution-apis/blob/main/src/engine/amsterdam.md#executionpayloadv4 + // ExecutionPayloadV4 has the syntax of ExecutionPayloadV3 and appends the new + // field slotNumber. + PayloadV4 PayloadVersion = 0x4 ) //go:generate go run github.com/fjl/gencodec -type PayloadAttributes -field-override payloadAttributesMarshaling -out gen_blockparams.go @@ -62,35 +69,37 @@ type PayloadAttributes struct { SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"` Withdrawals []*types.Withdrawal `json:"withdrawals"` BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"` + SlotNumber *uint64 `json:"slotNumber"` } // JSON type overrides for PayloadAttributes. type payloadAttributesMarshaling struct { - Timestamp hexutil.Uint64 + Timestamp hexutil.Uint64 + SlotNumber *hexutil.Uint64 } //go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go // ExecutableData is the data necessary to execute an EL payload. type ExecutableData struct { - ParentHash common.Hash `json:"parentHash" gencodec:"required"` - FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` - StateRoot common.Hash `json:"stateRoot" gencodec:"required"` - ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` - LogsBloom []byte `json:"logsBloom" gencodec:"required"` - Random common.Hash `json:"prevRandao" gencodec:"required"` - Number uint64 `json:"blockNumber" gencodec:"required"` - GasLimit uint64 `json:"gasLimit" gencodec:"required"` - GasUsed uint64 `json:"gasUsed" gencodec:"required"` - Timestamp uint64 `json:"timestamp" gencodec:"required"` - ExtraData []byte `json:"extraData" gencodec:"required"` - BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` - BlockHash common.Hash `json:"blockHash" gencodec:"required"` - Transactions [][]byte `json:"transactions" gencodec:"required"` - Withdrawals []*types.Withdrawal `json:"withdrawals"` - BlobGasUsed *uint64 `json:"blobGasUsed"` - ExcessBlobGas *uint64 `json:"excessBlobGas"` - ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"` + ParentHash common.Hash `json:"parentHash" gencodec:"required"` + FeeRecipient common.Address `json:"feeRecipient" gencodec:"required"` + StateRoot common.Hash `json:"stateRoot" gencodec:"required"` + ReceiptsRoot common.Hash `json:"receiptsRoot" gencodec:"required"` + LogsBloom []byte `json:"logsBloom" gencodec:"required"` + Random common.Hash `json:"prevRandao" gencodec:"required"` + Number uint64 `json:"blockNumber" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + GasUsed uint64 `json:"gasUsed" gencodec:"required"` + Timestamp uint64 `json:"timestamp" gencodec:"required"` + ExtraData []byte `json:"extraData" gencodec:"required"` + BaseFeePerGas *big.Int `json:"baseFeePerGas" gencodec:"required"` + BlockHash common.Hash `json:"blockHash" gencodec:"required"` + Transactions [][]byte `json:"transactions" gencodec:"required"` + Withdrawals []*types.Withdrawal `json:"withdrawals"` + BlobGasUsed *uint64 `json:"blobGasUsed"` + ExcessBlobGas *uint64 `json:"excessBlobGas"` + SlotNumber *uint64 `json:"slotNumber,omitempty"` } // JSON type overrides for executableData. @@ -105,6 +114,7 @@ type executableDataMarshaling struct { Transactions []hexutil.Bytes BlobGasUsed *hexutil.Uint64 ExcessBlobGas *hexutil.Uint64 + SlotNumber *hexutil.Uint64 } // StatelessPayloadStatusV1 is the result of a stateless payload execution. @@ -214,7 +224,7 @@ func encodeTransactions(txs []*types.Transaction) [][]byte { return enc } -func decodeTransactions(enc [][]byte) ([]*types.Transaction, error) { +func DecodeTransactions(enc [][]byte) ([]*types.Transaction, error) { var txs = make([]*types.Transaction, len(enc)) for i, encTx := range enc { var tx types.Transaction @@ -252,7 +262,7 @@ func ExecutableDataToBlock(data ExecutableData, versionedHashes []common.Hash, b // for stateless execution, so it skips checking if the executable data hashes to // the requested hash (stateless has to *compute* the root hash, it's not given). func ExecutableDataToBlockNoHash(data ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, requests [][]byte) (*types.Block, error) { - txs, err := decodeTransactions(data.Transactions) + txs, err := DecodeTransactions(data.Transactions) if err != nil { return nil, err } @@ -266,7 +276,7 @@ func ExecutableDataToBlockNoHash(data ExecutableData, versionedHashes []common.H if data.BaseFeePerGas != nil && (data.BaseFeePerGas.Sign() == -1 || data.BaseFeePerGas.BitLen() > 256) { return nil, fmt.Errorf("invalid baseFeePerGas: %v", data.BaseFeePerGas) } - var blobHashes = make([]common.Hash, 0, len(txs)) + var blobHashes = make([]common.Hash, 0, len(versionedHashes)) for _, tx := range txs { blobHashes = append(blobHashes, tx.BlobHashes()...) } @@ -314,10 +324,10 @@ func ExecutableDataToBlockNoHash(data ExecutableData, versionedHashes []common.H BlobGasUsed: data.BlobGasUsed, ParentBeaconRoot: beaconRoot, RequestsHash: requestsHash, + SlotNumber: data.SlotNumber, } return types.NewBlockWithHeader(header). - WithBody(types.Body{Transactions: txs, Uncles: nil, Withdrawals: data.Withdrawals}). - WithWitness(data.ExecutionWitness), + WithBody(types.Body{Transactions: txs, Uncles: nil, Withdrawals: data.Withdrawals}), nil } @@ -325,24 +335,24 @@ func ExecutableDataToBlockNoHash(data ExecutableData, versionedHashes []common.H // fields from the given block. It assumes the given block is post-merge block. func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.BlobTxSidecar, requests [][]byte) *ExecutionPayloadEnvelope { data := &ExecutableData{ - BlockHash: block.Hash(), - ParentHash: block.ParentHash(), - FeeRecipient: block.Coinbase(), - StateRoot: block.Root(), - Number: block.NumberU64(), - GasLimit: block.GasLimit(), - GasUsed: block.GasUsed(), - BaseFeePerGas: block.BaseFee(), - Timestamp: block.Time(), - ReceiptsRoot: block.ReceiptHash(), - LogsBloom: block.Bloom().Bytes(), - Transactions: encodeTransactions(block.Transactions()), - Random: block.MixDigest(), - ExtraData: block.Extra(), - Withdrawals: block.Withdrawals(), - BlobGasUsed: block.BlobGasUsed(), - ExcessBlobGas: block.ExcessBlobGas(), - ExecutionWitness: block.ExecutionWitness(), + BlockHash: block.Hash(), + ParentHash: block.ParentHash(), + FeeRecipient: block.Coinbase(), + StateRoot: block.Root(), + Number: block.NumberU64(), + GasLimit: block.GasLimit(), + GasUsed: block.GasUsed(), + BaseFeePerGas: block.BaseFee(), + Timestamp: block.Time(), + ReceiptsRoot: block.ReceiptHash(), + LogsBloom: block.Bloom().Bytes(), + Transactions: encodeTransactions(block.Transactions()), + Random: block.MixDigest(), + ExtraData: block.Extra(), + Withdrawals: block.Withdrawals(), + BlobGasUsed: block.BlobGasUsed(), + ExcessBlobGas: block.ExcessBlobGas(), + SlotNumber: block.SlotNumber(), } // Add blobs. diff --git a/beacon/light/request/server.go b/beacon/light/request/server.go index a06dec99ae75..d39570b8e539 100644 --- a/beacon/light/request/server.go +++ b/beacon/light/request/server.go @@ -438,14 +438,11 @@ func (s *serverWithLimits) fail(desc string) { // failLocked calculates the dynamic failure delay and applies it. func (s *serverWithLimits) failLocked(desc string) { log.Debug("Server error", "description", desc) - s.failureDelay *= 2 now := s.clock.Now() if now > s.failureDelayEnd { s.failureDelay *= math.Pow(2, -float64(now-s.failureDelayEnd)/float64(maxFailureDelay)) } - if s.failureDelay < float64(minFailureDelay) { - s.failureDelay = float64(minFailureDelay) - } + s.failureDelay = max(min(s.failureDelay*2, float64(maxFailureDelay)), float64(minFailureDelay)) s.failureDelayEnd = now + mclock.AbsTime(s.failureDelay) s.delay(time.Duration(s.failureDelay)) } diff --git a/beacon/light/sync/head_sync.go b/beacon/light/sync/head_sync.go index 5e4125805380..7189767d9c41 100644 --- a/beacon/light/sync/head_sync.go +++ b/beacon/light/sync/head_sync.go @@ -105,6 +105,7 @@ func (s *HeadSync) Process(requester request.Requester, events []request.Event) delete(s.serverHeads, event.Server) delete(s.unvalidatedOptimistic, event.Server) delete(s.unvalidatedFinality, event.Server) + delete(s.reqFinalityEpoch, event.Server) } } } diff --git a/beacon/light/sync/update_sync.go b/beacon/light/sync/update_sync.go index 9549ee599219..d84a3d64da4d 100644 --- a/beacon/light/sync/update_sync.go +++ b/beacon/light/sync/update_sync.go @@ -62,7 +62,6 @@ const ( ssNeedParent // cp header slot %32 != 0, need parent to check epoch boundary ssParentRequested // cp parent header requested ssPrintStatus // has all necessary info, print log message if init still not successful - ssDone // log message printed, no more action required ) type serverState struct { @@ -180,7 +179,8 @@ func (s *CheckpointInit) Process(requester request.Requester, events []request.E default: log.Error("blsync: checkpoint not available, but reported as finalized; specified checkpoint hash might be too old", "server", server.Name()) } - s.serverState[server] = serverState{state: ssDone} + s.serverState[server] = serverState{state: ssDefault} + requester.Fail(server, "checkpoint init failed") } } diff --git a/build/checksums.txt b/build/checksums.txt index 98ee3a91ef6e..454efa93c478 100644 --- a/build/checksums.txt +++ b/build/checksums.txt @@ -5,81 +5,102 @@ # https://github.com/ethereum/execution-spec-tests/releases/download/v5.1.0 a3192784375acec7eaec492799d5c5d0c47a2909a3cc40178898e4ecd20cc416 fixtures_develop.tar.gz -# version:golang 1.25.1 +# version:golang 1.25.10 # https://go.dev/dl/ -d010c109cee94d80efe681eab46bdea491ac906bf46583c32e9f0dbb0bd1a594 go1.25.1.src.tar.gz -1d622468f767a1b9fe1e1e67bd6ce6744d04e0c68712adc689748bbeccb126bb go1.25.1.darwin-amd64.tar.gz -68deebb214f39d542e518ebb0598a406ab1b5a22bba8ec9ade9f55fb4dd94a6c go1.25.1.darwin-arm64.tar.gz -d03cdcbc9bd8baf5cf028de390478e9e2b3e4d0afe5a6582dedc19bfe6a263b2 go1.25.1.linux-386.tar.gz -7716a0d940a0f6ae8e1f3b3f4f36299dc53e31b16840dbd171254312c41ca12e go1.25.1.linux-amd64.tar.gz -65a3e34fb2126f55b34e1edfc709121660e1be2dee6bdf405fc399a63a95a87d go1.25.1.linux-arm64.tar.gz -eb949be683e82a99e9861dafd7057e31ea40b161eae6c4cd18fdc0e8c4ae6225 go1.25.1.linux-armv6l.tar.gz -be13d5479b8c75438f2efcaa8c191fba3af684b3228abc9c99c7aa8502f34424 go1.25.1.windows-386.zip -4a974de310e7ee1d523d2fcedb114ba5fa75408c98eb3652023e55ccf3fa7cab go1.25.1.windows-amd64.zip -45ab4290adbd6ee9e7f18f0d57eaa9008fdbef590882778ed93eac3c8cca06c5 go1.25.1.aix-ppc64.tar.gz -2e3c1549bed3124763774d648f291ac42611232f48320ebbd23517c909c09b81 go1.25.1.dragonfly-amd64.tar.gz -dc0198dd4ec520e13f26798def8750544edf6448d8e9c43fd2a814e4885932af go1.25.1.freebsd-386.tar.gz -c4f1a7e7b258406e6f3b677ecdbd97bbb23ff9c0d44be4eb238a07d360f69ac8 go1.25.1.freebsd-amd64.tar.gz -7772fc5ff71ed39297ec0c1599fc54e399642c9b848eac989601040923b0de9c go1.25.1.freebsd-arm.tar.gz -5bb011d5d5b6218b12189f07aa0be618ab2002662fff1ca40afba7389735c207 go1.25.1.freebsd-arm64.tar.gz -ccac716240cb049bebfafcb7eebc3758512178a4c51fc26da9cc032035d850c8 go1.25.1.freebsd-riscv64.tar.gz -cc53910ffb9fcfdd988a9fa25b5423bae1cfa01b19616be646700e1f5453b466 go1.25.1.illumos-amd64.tar.gz -efe809f923bcedab44bf7be2b3af8d182b512b1bf9c07d302e0c45d26c8f56f3 go1.25.1.linux-loong64.tar.gz -c0de33679f6ed68991dc42dc4a602e74a666e3e166c1748ee1b5d1a7ea2ffbb2 go1.25.1.linux-mips.tar.gz -c270f7b0c0bdfbcd54fef4481227c40d41bb518f9ae38ee930870f04a0a6a589 go1.25.1.linux-mips64.tar.gz -80be871ba9c944f34d1868cdf5047e1cf2e1289fe08cdb90e2453d2f0d6965ae go1.25.1.linux-mips64le.tar.gz -9f09defa9bb22ebf2cde76162f40958564e57ce5c2b3649bc063bebcbc9294c1 go1.25.1.linux-mipsle.tar.gz -2c76b7d278c1d43ad19d478ad3f0f05e7b782b64b90870701b314fa48b5f43c6 go1.25.1.linux-ppc64.tar.gz -8b0c8d3ee5b1b5c28b6bd63dc4438792012e01d03b4bf7a61d985c87edab7d1f go1.25.1.linux-ppc64le.tar.gz -22fe934a9d0c9c57275716c55b92d46ebd887cec3177c9140705efa9f84ba1e2 go1.25.1.linux-riscv64.tar.gz -9cfe517ba423f59f3738ca5c3d907c103253cffbbcc2987142f79c5de8c1bf93 go1.25.1.linux-s390x.tar.gz -6af8a08353e76205d5b743dd7a3f0126684f96f62be0a31b75daf9837e512c46 go1.25.1.netbsd-386.tar.gz -e5d534ff362edb1bd8c8e10892b6a027c4c1482454245d1529167676498684c7 go1.25.1.netbsd-amd64.tar.gz -88bcf39254fdcea6a199c1c27d787831b652427ce60851ae9e41a3d7eb477f45 go1.25.1.netbsd-arm.tar.gz -d7c2eabe1d04ee47bcaea2816fdd90dbd25d90d4dfa756faa9786c788e4f3a4e go1.25.1.netbsd-arm64.tar.gz -14a2845977eb4dde11d929858c437a043467c427db87899935e90cee04a38d72 go1.25.1.openbsd-386.tar.gz -d27ac54b38a13a09c81e67c82ac70d387037341c85c3399291c73e13e83fdd8c go1.25.1.openbsd-amd64.tar.gz -0f4ab5f02500afa4befd51fed1e8b45e4d07ca050f641cc3acc76eaa4027b2c3 go1.25.1.openbsd-arm.tar.gz -d46c3bd156843656f7f3cb0dec27ea51cd926ec3f7b80744bf8156e67c1c812f go1.25.1.openbsd-arm64.tar.gz -c550514c67f22e409be10e40eace761e2e43069f4ef086ae6e60aac736c2b679 go1.25.1.openbsd-ppc64.tar.gz -8a09a8714a2556eb13fc1f10b7ce2553fcea4971e3330fc3be0efd24aab45734 go1.25.1.openbsd-riscv64.tar.gz -b0e1fefaf0c7abd71f139a54eee9767944aff5f0bc9d69c968234804884e552f go1.25.1.plan9-386.tar.gz -e94732c94f149690aa0ab11c26090577211b4a988137cb2c03ec0b54e750402e go1.25.1.plan9-amd64.tar.gz -7eb80e9de1e817d9089a54e8c7c5c8d8ed9e5fb4d4a012fc0f18fc422a484f0c go1.25.1.plan9-arm.tar.gz -1261dfad7c4953c0ab90381bc1242dc54e394db7485c59349428d532b2273343 go1.25.1.solaris-amd64.tar.gz -04bc3c078e9e904c4d58d6ac2532a5bdd402bd36a9ff0b5949b3c5e6006a05ee go1.25.1.windows-arm64.zip +20cf04a92e5af99748e341bc8996fa28090c9ac98765fa115ec5ddf41d7af41d go1.25.10.src.tar.gz +a194e767c2ab4216a60acc068b9dbe6bf4fae05c14bb52d6bbdcb5b3ea521308 go1.25.10.aix-ppc64.tar.gz +52321165a3146cd91865ef98371506a846ed4dc4f9f1c9323e5ad90d2a411e06 go1.25.10.darwin-amd64.tar.gz +795691a425de7e7cdba3544f354dcd2cebcf52e87dc6898193878f34eb6d634f go1.25.10.darwin-arm64.tar.gz +e37b4544ba9e9e9a7ab2ed3116b3fc4d39a88da854baa5a566d9d6d3a9de7d4c go1.25.10.dragonfly-amd64.tar.gz +2a70d1fdabab637aa442ca94599a56e381238efa20cb995d5433b8579bfe482c go1.25.10.freebsd-386.tar.gz +9cdf522d87d47d82fec4a313cc4f8c3c94a7770426e8d443e4150a1f330cba71 go1.25.10.freebsd-amd64.tar.gz +6da6183633e9e59ffd9edefab68b5059c89b605596d94aaba650b1681fccd35f go1.25.10.freebsd-arm.tar.gz +7adcefeebdd05331f4d45f1ad2dddb5c53537cff6552e82f6595b3b833b95371 go1.25.10.freebsd-arm64.tar.gz +285f80a1ace21a7d94035cd753196eeada8cacd48e6396fd116ad5eb67aea957 go1.25.10.freebsd-riscv64.tar.gz +de7461bf0e5068a4f6e7f8713026d70516be6dbd5de5d21f9ced1c182f2f326e go1.25.10.illumos-amd64.tar.gz +2f574f2e2e19ead5b280fec0e7af5c81b76632685f03b6ac42dfa34c4b773c52 go1.25.10.linux-386.tar.gz +42d4f7a32316aa66591eca7e89867256057a4264451aca10570a715b3637ba70 go1.25.10.linux-amd64.tar.gz +654da1f9b50a5d1c2a85ccf8ed405aa89c06e94d18384628bf186f7712677b08 go1.25.10.linux-arm64.tar.gz +39f168f158e693887d3ad006168af1b1a3007b19c5993cae4d9d57f82f52aaf8 go1.25.10.linux-armv6l.tar.gz +05401fe5ea50ad2bafb9c797ef9bf21574b0661f19ef4d0dd66af8a0fb7323f3 go1.25.10.linux-loong64.tar.gz +d5bc2d6155d394a3aae41f21eb7c60da5595a6147aa0f30ed6b27da25e06c3f7 go1.25.10.linux-mips.tar.gz +8c64e7493e5953c3ba3153487d2fddd7f8ed142392c77f138e6792a6c1930db4 go1.25.10.linux-mips64.tar.gz +bd53aa2d558b7c1eadfc6bf01132e1859203a92f458ed7ba75b7f3230f14b095 go1.25.10.linux-mips64le.tar.gz +120b254e2e2980bb06687175db5c4064a85696c53001dc9f59934ad18f74a6bc go1.25.10.linux-mipsle.tar.gz +8a6acb21295b0ec974a44608361920ea8dbff5666631a6f556bd7d5f1d56535f go1.25.10.linux-ppc64.tar.gz +778925fdcdf9a272f823d147fad51545c3334b7ccd8652b2ccaaf2b01800280a go1.25.10.linux-ppc64le.tar.gz +b4f04ad0db48bcfea946db5323919cd21034e0bd2821a557dacd29c1b1013a4b go1.25.10.linux-riscv64.tar.gz +936b953e43921a64c12da871f76871ebbeb6d2092a7b8bdc307f5246f3c662cc go1.25.10.linux-s390x.tar.gz +061470e0bc7132146a5925a3cc28d5bc498eb1b1ff09dedcfaae10f781ff2274 go1.25.10.netbsd-386.tar.gz +63b2d50d7f8f269a9c82d42a4060e90cffb7f9102299818bb071b067aac8da8f go1.25.10.netbsd-amd64.tar.gz +c35129f68796526aa4dc4b6f481e2d995ef312aedadc88b659b945cc00e1f8f0 go1.25.10.netbsd-arm.tar.gz +2f541da4e2b298154d992d1f11bbb38c89d0821d91cc50a46776d42bb5e63bca go1.25.10.netbsd-arm64.tar.gz +2d42e569b07f1b99fdbfd008e7c22f967d165e2ce02464f46818fbed2aec43f5 go1.25.10.openbsd-386.tar.gz +0ad05960e8c9f867328151308c87f938433bec8f22f6a9437a896e22169fc840 go1.25.10.openbsd-amd64.tar.gz +099cc11473f99461c77161912740945308f08f6834980afb262c72bdc915f2d7 go1.25.10.openbsd-arm.tar.gz +bdf3335d5008c1ddc81fa94892283e4f1fee22566f5351d4e726d9f55a67c838 go1.25.10.openbsd-arm64.tar.gz +0933d418da0a61e0f29de717a77498f16b9b5b50dbe2205e20b2ed7fd4067f75 go1.25.10.openbsd-ppc64.tar.gz +191e6f3e75712f8c13d189d53b668e2cac6449f26474c1d86fbd04f6e9846f9c go1.25.10.openbsd-riscv64.tar.gz +68c053c8acd76c50fc430e92f4a86110ec3d97dd03d27b9339b4eaf793caff5f go1.25.10.plan9-386.tar.gz +42e2c46638ae22d93402e79efb40faee5c42cf7c56a01bb3ab47c6bb2512b745 go1.25.10.plan9-amd64.tar.gz +3ef1d5838b1648da16724a07b72e839ccbd7cb8899c3e0426afd6b79d494b91c go1.25.10.plan9-arm.tar.gz +631e3716017fbec06500a628d97e1155daec3593f0a7812c2ebfe8fc8c96b2ab go1.25.10.solaris-amd64.tar.gz +ddc693d2d9d7cc671ebb72d1d50aa05670f95b059b7d90440611af57976871d5 go1.25.10.windows-386.zip +ca37af2dadd8544464f1a9ca7c3886499d1cdfcb263855d0a1d71f194b2bd222 go1.25.10.windows-amd64.zip +38be57e0398bd93673d65bcae6dc7ee3cf151d7038d0dba5c60a5153022872da go1.25.10.windows-arm64.zip -# version:golangci 2.4.0 +# version:golangci 2.10.1 # https://github.com/golangci/golangci-lint/releases/ -# https://github.com/golangci/golangci-lint/releases/download/v2.4.0/ -7904ce63f79db44934939cf7a063086ea0ea98e9b19eba0a9d52ccdd0d21951c golangci-lint-2.4.0-darwin-amd64.tar.gz -cd4dd53fa09b6646baff5fd22b8c64d91db02c21c7496df27992d75d34feec59 golangci-lint-2.4.0-darwin-arm64.tar.gz -d58f426ebe14cc257e81562b4bf37a488ffb4ffbbb3ec73041eb3b38bb25c0e1 golangci-lint-2.4.0-freebsd-386.tar.gz -6ec4a6177fc6c0dd541fbcb3a7612845266d020d35cc6fa92959220cdf64ca39 golangci-lint-2.4.0-freebsd-amd64.tar.gz -4d473e3e71c01feaa915a0604fb35758b41284fb976cdeac3f842118d9ee7e17 golangci-lint-2.4.0-freebsd-armv6.tar.gz -58727746c6530801a3f9a702a5945556a5eb7e88809222536dd9f9d54cafaeff golangci-lint-2.4.0-freebsd-armv7.tar.gz -fbf28c662760e24c32f82f8d16dffdb4a82de7726a52ba1fad94f890c22997ea golangci-lint-2.4.0-illumos-amd64.tar.gz -a15a000a8981ef665e971e0f67e2acda9066a9e37a59344393b7351d8fb49c81 golangci-lint-2.4.0-linux-386.tar.gz -fae792524c04424c0ac369f5b8076f04b45cf29fc945a370e55d369a8dc11840 golangci-lint-2.4.0-linux-amd64.tar.gz -70ac11f55b80ec78fd3a879249cc9255121b8dfd7f7ed4fc46ed137f4abf17e7 golangci-lint-2.4.0-linux-arm64.tar.gz -4acdc40e5cebe99e4e7ced358a05b2e71789f409b41cb4f39bbb86ccfa14b1dc golangci-lint-2.4.0-linux-armv6.tar.gz -2a68749568fa22b4a97cb88dbea655595563c795076536aa6c087f7968784bf3 golangci-lint-2.4.0-linux-armv7.tar.gz -9e3369afb023711036dcb0b4f45c9fe2792af962fa1df050c9f6ac101a6c5d73 golangci-lint-2.4.0-linux-loong64.tar.gz -bb9143d6329be2c4dbfffef9564078e7da7d88e7dde6c829b6263d98e072229e golangci-lint-2.4.0-linux-mips64.tar.gz -5ad1765b40d56cd04d4afd805b3ba6f4bfd9b36181da93c31e9b17e483d8608d golangci-lint-2.4.0-linux-mips64le.tar.gz -918936fb9c0d5ba96bef03cf4348b03938634cfcced49be1e9bb29cb5094fa73 golangci-lint-2.4.0-linux-ppc64le.tar.gz -f7474c638e1fb67ebbdc654b55ca0125377ea0bc88e8fee8d964a4f24eacf828 golangci-lint-2.4.0-linux-riscv64.tar.gz -b617a9543997c8bfceaffa88a75d4e595030c6add69fba800c1e4d8f5fe253dd golangci-lint-2.4.0-linux-s390x.tar.gz -7db027b03a9ba328f795215b04f594036837bc7dd0dd7cd16776b02a6167981c golangci-lint-2.4.0-netbsd-386.tar.gz -52d8f9393f4313df0a62b752c37775e3af0b818e43e8dd28954351542d7c60bc golangci-lint-2.4.0-netbsd-amd64.tar.gz -5c0086027fb5a4af3829e530c8115db4b35d11afe1914322eef528eb8cd38c69 golangci-lint-2.4.0-netbsd-arm64.tar.gz -6b779d6ed1aed87cefe195cc11759902b97a76551b593312c6833f2635a3488f golangci-lint-2.4.0-netbsd-armv6.tar.gz -f00d1f4b7ec3468a0f9fffd0d9ea036248b029b7621cbc9a59c449ef94356d09 golangci-lint-2.4.0-netbsd-armv7.tar.gz -3ce671b0b42b58e35066493aab75a7e2826c9e079988f1ba5d814a4029faaf87 golangci-lint-2.4.0-windows-386.zip -003112f7a56746feaabf20b744054bf9acdf900c9e77176383623c4b1d76aaa9 golangci-lint-2.4.0-windows-amd64.zip -dc0c2092af5d47fc2cd31a1dfe7b4c7e765fab22de98bd21ef2ffcc53ad9f54f golangci-lint-2.4.0-windows-arm64.zip -0263d23e20a260cb1592d35e12a388f99efe2c51b3611fdc66fbd9db1fce664d golangci-lint-2.4.0-windows-armv6.zip -9403c03bf648e6313036e0273149d44bad1b9ad53889b6d00e4ccb842ba3c058 golangci-lint-2.4.0-windows-armv7.zip +# https://github.com/golangci/golangci-lint/releases/download/v2.10.1 +66fb0da81b8033b477f97eea420d4b46b230ca172b8bb87c6610109f3772b6b6 golangci-lint-2.10.1-darwin-amd64.tar.gz +03bfadf67e52b441b7ec21305e501c717df93c959836d66c7f97312654acb297 golangci-lint-2.10.1-darwin-arm64.tar.gz +c9a44658ccc8f7b8dbbd4ae6020ba91c1a5d3987f4d91ced0f7d2bea013e57ca golangci-lint-2.10.1-freebsd-386.tar.gz +a513c5cb4e0f5bd5767001af9d5e97e7868cfc2d9c46739a4df93e713cfb24af golangci-lint-2.10.1-freebsd-amd64.tar.gz +2ef38eefc4b5cee2febacb75a30579526e5656c16338a921d80e59a8e87d4425 golangci-lint-2.10.1-freebsd-arm64.tar.gz +8fea6766318b4829e766bbe325f10191d75297dcc44ae35bf374816037878e38 golangci-lint-2.10.1-freebsd-armv6.tar.gz +30b629870574d6254f3e8804e5a74b34f98e1263c9d55465830d739c88b862ed golangci-lint-2.10.1-freebsd-armv7.tar.gz +c0db839f866ce80b1b6c96167aa101cfe50d9c936f42d942a3c1cbdc1801af68 golangci-lint-2.10.1-illumos-amd64.tar.gz +280eb56636e9175f671cd7b755d7d67f628ae2ed00a164d1e443c43c112034e5 golangci-lint-2.10.1-linux-386.deb +065a7d99da61dc7dfbfef2e2d7053dd3fa6672598f2747117aa4bb5f45e7df7f golangci-lint-2.10.1-linux-386.rpm +a55918c03bb413b2662287653ab2ae2fef4e37428b247dad6348724adde9d770 golangci-lint-2.10.1-linux-386.tar.gz +8aa9b3aa14f39745eeb7fc7ff50bcac683e785397d1e4bc9afd2184b12c4ce86 golangci-lint-2.10.1-linux-amd64.deb +62a111688e9e305032334a2cbc84f4d971b64bb3bffc99d3f80081d57fb25e32 golangci-lint-2.10.1-linux-amd64.rpm +dfa775874cf0561b404a02a8f4481fc69b28091da95aa697259820d429b09c99 golangci-lint-2.10.1-linux-amd64.tar.gz +b3f36937e8ea1660739dc0f5c892ea59c9c21ed4e75a91a25957c561f7f79a55 golangci-lint-2.10.1-linux-arm64.deb +36d50314d53683b1f1a2a6cedfb5a9468451b481c64ab9e97a8e843ea088074d golangci-lint-2.10.1-linux-arm64.rpm +6652b42ae02915eb2f9cb2a2e0cac99514c8eded8388d88ae3e06e1a52c00de8 golangci-lint-2.10.1-linux-arm64.tar.gz +a32d8d318e803496812dd3461f250e52ccc7f53c47b95ce404a9cf55778ceb6a golangci-lint-2.10.1-linux-armv6.deb +41d065f4c8ea165a1531abea644988ee2e973e4f0b49f9725ed3b979dac45112 golangci-lint-2.10.1-linux-armv6.rpm +59159a4df03aabbde69d15c7b7b3df143363cbb41f4bd4b200caffb8e34fb734 golangci-lint-2.10.1-linux-armv6.tar.gz +b2e8ec0e050a1e2251dfe1561434999d202f5a3f9fa47ce94378b0fd1662ea5a golangci-lint-2.10.1-linux-armv7.deb +28c9331429a497da27e9c77846063bd0e8275e878ffedb4eb9e9f21d24771cc0 golangci-lint-2.10.1-linux-armv7.rpm +818f33e95b273e3769284b25563b51ef6a294e9e25acf140fda5830c075a1a59 golangci-lint-2.10.1-linux-armv7.tar.gz +6b6b85ed4b7c27f51097dd681523000409dde835e86e6e314e87be4bb013e2ab golangci-lint-2.10.1-linux-loong64.deb +94050a0cf06169e2ae44afb307dcaafa7d7c3b38c0c23b5652cf9cb60f0c337f golangci-lint-2.10.1-linux-loong64.rpm +25820300fccb8c961c1cdcb1f77928040c079e04c43a3a5ceb34b1cb4a1c5c8d golangci-lint-2.10.1-linux-loong64.tar.gz +98bf39d10139fdcaa37f94950e9bbb8888660ae468847ae0bf1cb5bf67c1f68b golangci-lint-2.10.1-linux-mips64.deb +df3ce5f03808dcceaa8b683d1d06e95c885f09b59dc8e15deb840fbe2b3e3299 golangci-lint-2.10.1-linux-mips64.rpm +972508dda523067e6e6a1c8e6609d63bc7c4153819c11b947d439235cf17bac2 golangci-lint-2.10.1-linux-mips64.tar.gz +1d37f2919e183b5bf8b1777ed8c4b163d3b491d0158355a7999d647655cbbeb6 golangci-lint-2.10.1-linux-mips64le.deb +e341d031002cd09a416329ed40f674231051a38544b8f94deb2d1708ce1f4a6f golangci-lint-2.10.1-linux-mips64le.rpm +393560122b9cb5538df0c357d30eb27b6ee563533fbb9b138c8db4fd264002af golangci-lint-2.10.1-linux-mips64le.tar.gz +21ca46b6a96442e8957677a3ca059c6b93674a68a01b1c71f4e5df0ea2e96d19 golangci-lint-2.10.1-linux-ppc64le.deb +57fe0cbca0a9bbdf1547c5e8aa7d278e6896b438d72a541bae6bc62c38b43d1e golangci-lint-2.10.1-linux-ppc64le.rpm +e2883db9fa51584e5e203c64456f29993550a7faadc84e3faccdb48f0669992e golangci-lint-2.10.1-linux-ppc64le.tar.gz +aa6da0e98ab0ba3bb7582e112174c349907d5edfeff90a551dca3c6eecf92fc0 golangci-lint-2.10.1-linux-riscv64.deb +3c68d76cd884a7aad206223a980b9c20bb9ea74b560fa27ed02baf2389189234 golangci-lint-2.10.1-linux-riscv64.rpm +3bca11bfac4197205639cbd4676a5415054e629ac6c12ea10fcbe33ef852d9c3 golangci-lint-2.10.1-linux-riscv64.tar.gz +0c6aed2ce49db2586adbac72c80d871f06feb1caf4c0763a5ca98fec809a8f0b golangci-lint-2.10.1-linux-s390x.deb +16c285adfe1061d69dd8e503be69f87c7202857c6f4add74ac02e3571158fbec golangci-lint-2.10.1-linux-s390x.rpm +21011ad368eb04f024201b832095c6b5f96d0888de194cca5bfe4d9307d6364b golangci-lint-2.10.1-linux-s390x.tar.gz +7b5191e77a70485918712e31ed55159956323e4911bab1b67569c9d86e1b75eb golangci-lint-2.10.1-netbsd-386.tar.gz +07801fd38d293ebad10826f8285525a39ea91ce5ddad77d05bfa90bda9c884a9 golangci-lint-2.10.1-netbsd-amd64.tar.gz +7e7219d71c1bf33b98c328c93dc0560706dd896a1c43c44696e5222fc9d7446e golangci-lint-2.10.1-netbsd-arm64.tar.gz +92fbc90b9eec0e572269b0f5492a2895c426b086a68372fde49b7e4d4020863e golangci-lint-2.10.1-netbsd-armv6.tar.gz +f67b3ae1f47caeefa507a4ebb0c8336958a19011fe48766443212030f75d004b golangci-lint-2.10.1-netbsd-armv7.tar.gz +a40bc091c10cea84eaee1a90b84b65f5e8652113b0a600bb099e4e4d9d7caddb golangci-lint-2.10.1-windows-386.zip +c60c87695e79db8e320f0e5be885059859de52bb5ee5f11be5577828570bc2a3 golangci-lint-2.10.1-windows-amd64.zip +636ab790c8dcea8034aa34aba6031ca3893d68f7eda000460ab534341fadbab1 golangci-lint-2.10.1-windows-arm64.zip # This is the builder on PPA that will build Go itself (inception-y), don't modify! # diff --git a/build/ci.go b/build/ci.go index abb7c4997ff4..173a3280ce16 100644 --- a/build/ci.go +++ b/build/ci.go @@ -73,21 +73,9 @@ var ( "./cmd/keeper", } - // Files that end up in the geth*.zip archive. - gethArchiveFiles = []string{ - "COPYING", - executablePath("geth"), - } - - // Files that end up in the geth-alltools*.zip archive. - allToolsArchiveFiles = []string{ - "COPYING", - executablePath("abigen"), - executablePath("evm"), - executablePath("geth"), - executablePath("rlpdump"), - executablePath("clef"), - } + // Files that end up in the geth-alltools*.zip archive (and the NSIS installer + // dev-tools section). Order matches the historical layout produced by ci.go. + allToolsBinaries = []string{"abigen", "evm", "geth", "rlpdump", "clef"} // Keeper build targets with their configurations keeperTargets = []struct { @@ -107,17 +95,21 @@ var ( Tags: "ziren", Env: map[string]string{"GOMIPS": "softfloat", "CGO_ENABLED": "0"}, }, + { + Name: "womir", + GOOS: "wasip1", + GOARCH: "wasm", + Tags: "womir", + }, { Name: "wasm-js", GOOS: "js", GOARCH: "wasm", - Tags: "example", }, { Name: "wasm-wasi", GOOS: "wasip1", GOARCH: "wasm", - Tags: "example", }, { Name: "example", @@ -163,13 +155,11 @@ var ( // Distros for which packages are created debDistros = []string{ - "xenial", // 16.04, EOL: 04/2026 - "bionic", // 18.04, EOL: 04/2028 - "focal", // 20.04, EOL: 04/2030 - "jammy", // 22.04, EOL: 04/2032 - "noble", // 24.04, EOL: 04/2034 - "oracular", // 24.10, EOL: 07/2025 - "plucky", // 25.04, EOL: 01/2026 + "xenial", // 16.04, EOL: 04/2026 + "bionic", // 18.04, EOL: 04/2028 + "focal", // 20.04, EOL: 04/2030 + "jammy", // 22.04, EOL: 04/2032 + "noble", // 24.04, EOL: 04/2034 } // This is where the tests should be unpacked. @@ -178,13 +168,35 @@ var ( var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin")) -func executablePath(name string) string { - if runtime.GOOS == "windows" { +// executablePath returns the path to a built binary in GOBIN, applying the +// platform-specific extension for the given target OS. +func executablePath(name, targetOS string) string { + if targetOS == "windows" { name += ".exe" } return filepath.Join(GOBIN, name) } +// gethArchiveFiles returns the file list for the geth-{platform}-{ver}.zip +// archive, with binary paths resolved for the target OS. +func gethArchiveFiles(targetOS string) []string { + return []string{ + "COPYING", + executablePath("geth", targetOS), + } +} + +// allToolsArchiveFiles returns the file list for the +// geth-alltools-{platform}-{ver}.zip archive, with binary paths resolved for +// the target OS. +func allToolsArchiveFiles(targetOS string) []string { + files := []string{"COPYING"} + for _, name := range allToolsBinaries { + files = append(files, executablePath(name, targetOS)) + } + return files +} + func main() { log.SetFlags(log.Lshortfile) @@ -231,6 +243,7 @@ func main() { func doInstall(cmdline []string) { var ( dlgo = flag.Bool("dlgo", false, "Download Go and build with it") + targetOS = flag.String("os", runtime.GOOS, "Target OS to cross build for") arch = flag.String("arch", "", "Architecture to cross build for") cc = flag.String("cc", "", "C compiler to cross build with") staticlink = flag.Bool("static", false, "Create statically-linked executable") @@ -239,7 +252,7 @@ func doInstall(cmdline []string) { env := build.Env() // Configure the toolchain. - tc := build.GoToolchain{GOARCH: *arch, CC: *cc} + tc := build.GoToolchain{GOOS: *targetOS, GOARCH: *arch, CC: *cc} if *dlgo { csdb := download.MustLoadChecksums("build/checksums.txt") tc.Root = build.DownloadGo(csdb) @@ -253,7 +266,7 @@ func doInstall(cmdline []string) { } // Configure the build. - gobuild := tc.Go("build", buildFlags(env, *staticlink, buildTags)...) + gobuild := tc.Go("build", buildFlags(env, *staticlink, buildTags, *targetOS)...) // Show packages during build. gobuild.Args = append(gobuild.Args, "-v") @@ -268,7 +281,7 @@ func doInstall(cmdline []string) { // Do the build! for _, pkg := range packages { args := slices.Clone(gobuild.Args) - args = append(args, "-o", executablePath(path.Base(pkg))) + args = append(args, "-o", executablePath(path.Base(pkg), *targetOS)) args = append(args, pkg) build.MustRun(&exec.Cmd{Path: gobuild.Path, Args: args, Env: gobuild.Env}) } @@ -295,7 +308,13 @@ func doInstallKeeper(cmdline []string) { tc.GOARCH = target.GOARCH tc.GOOS = target.GOOS tc.CC = target.CC - gobuild := tc.Go("build", buildFlags(env, true, []string{target.Tags})...) + // An empty GOOS means "build for the host OS"; thread that through to + // buildFlags so platform-specific linker flags are picked correctly. + targetOS := target.GOOS + if targetOS == "" { + targetOS = runtime.GOOS + } + gobuild := tc.Go("build", buildFlags(env, true, []string{target.Tags}, targetOS)...) gobuild.Dir = "./cmd/keeper" gobuild.Args = append(gobuild.Args, "-v") @@ -305,14 +324,15 @@ func doInstallKeeper(cmdline []string) { outputName := fmt.Sprintf("keeper-%s", target.Name) args := slices.Clone(gobuild.Args) - args = append(args, "-o", executablePath(outputName)) + args = append(args, "-o", executablePath(outputName, targetOS)) args = append(args, ".") - build.MustRun(&exec.Cmd{Path: gobuild.Path, Args: args, Env: gobuild.Env}) + build.MustRun(&exec.Cmd{Path: gobuild.Path, Args: args, Env: gobuild.Env, Dir: gobuild.Dir}) } } -// buildFlags returns the go tool flags for building. -func buildFlags(env build.Environment, staticLinking bool, buildTags []string) (flags []string) { +// buildFlags returns the go tool flags for building. targetOS is the OS we +// are producing binaries for. +func buildFlags(env build.Environment, staticLinking bool, buildTags []string, targetOS string) (flags []string) { var ld []string // See https://github.com/golang/go/issues/33772#issuecomment-528176001 // We need to set --buildid to the linker here, and also pass --build-id to the @@ -324,10 +344,10 @@ func buildFlags(env build.Environment, staticLinking bool, buildTags []string) ( } // Strip DWARF on darwin. This used to be required for certain things, // and there is no downside to this, so we just keep doing it. - if runtime.GOOS == "darwin" { + if targetOS == "darwin" { ld = append(ld, "-s") } - if runtime.GOOS == "linux" { + if targetOS == "linux" { // Enforce the stacksize to 8M, which is the case on most platforms apart from // alpine Linux. // See https://sourceware.org/binutils/docs-2.23.1/ld/Options.html#Options @@ -680,12 +700,13 @@ func downloadProtoc(cachedir string) string { // Release Packaging func doArchive(cmdline []string) { var ( - arch = flag.String("arch", runtime.GOARCH, "Architecture cross packaging") - atype = flag.String("type", "zip", "Type of archive to write (zip|tar)") - signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. LINUX_SIGNING_KEY)`) - signify = flag.String("signify", "", `Environment variable holding the signify key (e.g. LINUX_SIGNIFY_KEY)`) - upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`) - ext string + targetOS = flag.String("os", runtime.GOOS, "Target OS the binaries were built for") + arch = flag.String("arch", runtime.GOARCH, "Architecture cross packaging") + atype = flag.String("type", "zip", "Type of archive to write (zip|tar)") + signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. LINUX_SIGNING_KEY)`) + signify = flag.String("signify", "", `Environment variable holding the signify key (e.g. LINUX_SIGNIFY_KEY)`) + upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`) + ext string ) flag.CommandLine.Parse(cmdline) switch *atype { @@ -699,15 +720,15 @@ func doArchive(cmdline []string) { var ( env = build.Env() - basegeth = archiveBasename(*arch, version.Archive(env.Commit)) + basegeth = archiveBasename(*targetOS, *arch, version.Archive(env.Commit)) geth = "geth-" + basegeth + ext alltools = "geth-alltools-" + basegeth + ext ) maybeSkipArchive(env) - if err := build.WriteArchive(geth, gethArchiveFiles); err != nil { + if err := build.WriteArchive(geth, gethArchiveFiles(*targetOS)); err != nil { log.Fatal(err) } - if err := build.WriteArchive(alltools, allToolsArchiveFiles); err != nil { + if err := build.WriteArchive(alltools, allToolsArchiveFiles(*targetOS)); err != nil { log.Fatal(err) } for _, archive := range []string{geth, alltools} { @@ -733,7 +754,11 @@ func doKeeperArchive(cmdline []string) { maybeSkipArchive(env) files := []string{"COPYING"} for _, target := range keeperTargets { - files = append(files, executablePath(fmt.Sprintf("keeper-%s", target.Name))) + targetOS := target.GOOS + if targetOS == "" { + targetOS = runtime.GOOS + } + files = append(files, executablePath(fmt.Sprintf("keeper-%s", target.Name), targetOS)) } if err := build.WriteArchive(keeper, files); err != nil { log.Fatal(err) @@ -743,8 +768,8 @@ func doKeeperArchive(cmdline []string) { } } -func archiveBasename(arch string, archiveVersion string) string { - platform := runtime.GOOS + "-" + arch +func archiveBasename(targetOS, arch, archiveVersion string) string { + platform := targetOS + "-" + arch if arch == "arm" { platform += os.Getenv("GOARM") } @@ -1198,7 +1223,7 @@ func doWindowsInstaller(cmdline []string) { var ( arch = flag.String("arch", runtime.GOARCH, "Architecture for cross build packaging") signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. WINDOWS_SIGNING_KEY)`) - signify = flag.String("signify key", "", `Environment variable holding the signify signing key (e.g. WINDOWS_SIGNIFY_KEY)`) + signify = flag.String("signify", "", `Environment variable holding the signify signing key (e.g. WINDOWS_SIGNIFY_KEY)`) upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`) workdir = flag.String("workdir", "", `Output directory for packages (uses temp dir if unset)`) ) @@ -1207,13 +1232,13 @@ func doWindowsInstaller(cmdline []string) { env := build.Env() maybeSkipArchive(env) - // Aggregate binaries that are included in the installer + // Aggregate binaries that are included in the installer. var ( devTools []string allTools []string gethTool string ) - for _, file := range allToolsArchiveFiles { + for _, file := range allToolsArchiveFiles("windows") { if file == "COPYING" { // license, copied later continue } @@ -1250,16 +1275,24 @@ func doWindowsInstaller(cmdline []string) { if env.Commit != "" { ver[2] += "-" + env.Commit[:8] } - installer, err := filepath.Abs("geth-" + archiveBasename(*arch, version.Archive(env.Commit)) + ".exe") + installer, err := filepath.Abs("geth-" + archiveBasename("windows", *arch, version.Archive(env.Commit)) + ".exe") if err != nil { log.Fatalf("Failed to convert installer file path: %v", err) } - build.MustRunCommand("makensis.exe", - "/DOUTPUTFILE="+installer, - "/DMAJORVERSION="+ver[0], - "/DMINORVERSION="+ver[1], - "/DBUILDVERSION="+ver[2], - "/DARCH="+*arch, + // makensis on Windows is "makensis.exe" with /D-style defines; on Linux + // (and other Unixes) the binary is "makensis" and accepts -D. + makensisCmd := "makensis" + defineFlag := "-D" + if runtime.GOOS == "windows" { + makensisCmd = "makensis.exe" + defineFlag = "/D" + } + build.MustRunCommand(makensisCmd, + defineFlag+"OUTPUTFILE="+installer, + defineFlag+"MAJORVERSION="+ver[0], + defineFlag+"MINORVERSION="+ver[1], + defineFlag+"BUILDVERSION="+ver[2], + defineFlag+"ARCH="+*arch, filepath.Join(*workdir, "geth.nsi"), ) // Sign and publish installer. diff --git a/circle.yml b/circle.yml deleted file mode 100644 index 39ff5d83c68e..000000000000 --- a/circle.yml +++ /dev/null @@ -1,32 +0,0 @@ -machine: - services: - - docker - -dependencies: - cache_directories: - - "~/.ethash" # Cache the ethash DAG generated by hive for consecutive builds - - "~/.docker" # Cache all docker images manually to avoid lengthy rebuilds - override: - # Restore all previously cached docker images - - mkdir -p ~/.docker - - for img in `ls ~/.docker`; do docker load -i ~/.docker/$img; done - - # Pull in and hive, restore cached ethash DAGs and do a dry run - - go get -u github.com/karalabe/hive - - (cd ~/.go_workspace/src/github.com/karalabe/hive && mkdir -p workspace/ethash/ ~/.ethash) - - (cd ~/.go_workspace/src/github.com/karalabe/hive && cp -r ~/.ethash/. workspace/ethash/) - - (cd ~/.go_workspace/src/github.com/karalabe/hive && hive --docker-noshell --client=NONE --test=. --sim=. --loglevel=6) - - # Cache all the docker images and the ethash DAGs - - for img in `docker images | grep -v "^" | tail -n +2 | awk '{print $1}'`; do docker save $img > ~/.docker/`echo $img | tr '/' ':'`.tar; done - - cp -r ~/.go_workspace/src/github.com/karalabe/hive/workspace/ethash/. ~/.ethash - -test: - override: - # Build Geth and move into a known folder - - make geth - - cp ./build/bin/geth $HOME/geth - - # Run hive and move all generated logs into the public artifacts folder - - (cd ~/.go_workspace/src/github.com/karalabe/hive && hive --docker-noshell --client=go-ethereum:local --override=$HOME/geth --test=. --sim=.) - - cp -r ~/.go_workspace/src/github.com/karalabe/hive/workspace/logs/* $CIRCLE_ARTIFACTS diff --git a/cmd/abigen/main.go b/cmd/abigen/main.go index c82358be4938..d9d1fa02ac3e 100644 --- a/cmd/abigen/main.go +++ b/cmd/abigen/main.go @@ -215,7 +215,7 @@ func generate(c *cli.Context) error { code string err error ) - if c.IsSet(v2Flag.Name) { + if c.Bool(v2Flag.Name) { code, err = abigen.BindV2(types, abis, bins, c.String(pkgFlag.Name), libs, aliases) } else { code, err = abigen.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), libs, aliases) diff --git a/cmd/devp2p/enrcmd.go b/cmd/devp2p/enrcmd.go index c9b692612f57..af2cf90a8124 100644 --- a/cmd/devp2p/enrcmd.go +++ b/cmd/devp2p/enrcmd.go @@ -194,7 +194,7 @@ func formatAttrString(v rlp.RawValue) (string, bool) { func formatAttrIP(v rlp.RawValue) (string, bool) { content, _, err := rlp.SplitString(v) - if err != nil || len(content) != 4 && len(content) != 6 { + if err != nil || len(content) != 4 && len(content) != 16 { return "", false } return net.IP(content).String(), true diff --git a/cmd/devp2p/internal/ethtest/chain.go b/cmd/devp2p/internal/ethtest/chain.go index 689667a56bc2..b44e6aa36a8a 100644 --- a/cmd/devp2p/internal/ethtest/chain.go +++ b/cmd/devp2p/internal/ethtest/chain.go @@ -51,6 +51,12 @@ type Chain struct { state map[common.Address]state.DumpAccount // state of head block senders map[common.Address]*senderInfo config *params.ChainConfig + + txInfo txInfo +} + +type txInfo struct { + LargeReceiptBlock *uint64 `json:"tx-largereceipt"` } // NewChain takes the given chain.rlp file, and decodes and returns @@ -74,12 +80,20 @@ func NewChain(dir string) (*Chain, error) { if err != nil { return nil, err } + + var txInfo txInfo + err = common.LoadJSON(filepath.Join(dir, "txinfo.json"), &txInfo) + if err != nil { + return nil, err + } + return &Chain{ genesis: gen, blocks: blocks, state: state, senders: accounts, config: gen.Config, + txInfo: txInfo, }, nil } diff --git a/cmd/devp2p/internal/ethtest/conn.go b/cmd/devp2p/internal/ethtest/conn.go index 5182d71ce19c..02579f8b55a9 100644 --- a/cmd/devp2p/internal/ethtest/conn.go +++ b/cmd/devp2p/internal/ethtest/conn.go @@ -66,9 +66,10 @@ func (s *Suite) dialAs(key *ecdsa.PrivateKey) (*Conn, error) { return nil, err } conn.caps = []p2p.Cap{ + {Name: "eth", Version: 70}, {Name: "eth", Version: 69}, } - conn.ourHighestProtoVersion = 69 + conn.ourHighestProtoVersion = 70 return &conn, nil } @@ -155,7 +156,7 @@ func (c *Conn) ReadEth() (any, error) { var msg any switch int(code) { case eth.StatusMsg: - msg = new(eth.StatusPacket69) + msg = new(eth.StatusPacket) case eth.GetBlockHeadersMsg: msg = new(eth.GetBlockHeadersPacket) case eth.BlockHeadersMsg: @@ -164,10 +165,6 @@ func (c *Conn) ReadEth() (any, error) { msg = new(eth.GetBlockBodiesPacket) case eth.BlockBodiesMsg: msg = new(eth.BlockBodiesPacket) - case eth.NewBlockMsg: - msg = new(eth.NewBlockPacket) - case eth.NewBlockHashesMsg: - msg = new(eth.NewBlockHashesPacket) case eth.TransactionsMsg: msg = new(eth.TransactionsPacket) case eth.NewPooledTransactionHashesMsg: @@ -229,7 +226,7 @@ func (c *Conn) ReadSnap() (any, error) { } // dialAndPeer creates a peer connection and runs the handshake. -func (s *Suite) dialAndPeer(status *eth.StatusPacket69) (*Conn, error) { +func (s *Suite) dialAndPeer(status *eth.StatusPacket) (*Conn, error) { c, err := s.dial() if err != nil { return nil, err @@ -242,7 +239,7 @@ func (s *Suite) dialAndPeer(status *eth.StatusPacket69) (*Conn, error) { // peer performs both the protocol handshake and the status message // exchange with the node in order to peer with it. -func (c *Conn) peer(chain *Chain, status *eth.StatusPacket69) error { +func (c *Conn) peer(chain *Chain, status *eth.StatusPacket) error { if err := c.handshake(); err != nil { return fmt.Errorf("handshake failed: %v", err) } @@ -315,7 +312,7 @@ func (c *Conn) negotiateEthProtocol(caps []p2p.Cap) { } // statusExchange performs a `Status` message exchange with the given node. -func (c *Conn) statusExchange(chain *Chain, status *eth.StatusPacket69) error { +func (c *Conn) statusExchange(chain *Chain, status *eth.StatusPacket) error { loop: for { code, data, err := c.Read() @@ -324,7 +321,7 @@ loop: } switch code { case eth.StatusMsg + protoOffset(ethProto): - msg := new(eth.StatusPacket69) + msg := new(eth.StatusPacket) if err := rlp.DecodeBytes(data, &msg); err != nil { return fmt.Errorf("error decoding status packet: %w", err) } @@ -339,10 +336,12 @@ loop: if have, want := msg.ForkID, chain.ForkID(); !reflect.DeepEqual(have, want) { return fmt.Errorf("wrong fork ID in status: have %v, want %v", have, want) } - if have, want := msg.ProtocolVersion, c.ourHighestProtoVersion; have != uint32(want) { - return fmt.Errorf("wrong protocol version: have %v, want %v", have, want) + for _, cap := range c.caps { + if cap.Name == "eth" && cap.Version == uint(msg.ProtocolVersion) { + break loop + } } - break loop + return fmt.Errorf("wrong protocol version: have %v, want %v", msg.ProtocolVersion, c.caps) case discMsg: var msg []p2p.DiscReason if rlp.DecodeBytes(data, &msg); len(msg) == 0 { @@ -363,7 +362,7 @@ loop: } if status == nil { // default status message - status = ð.StatusPacket69{ + status = ð.StatusPacket{ ProtocolVersion: uint32(c.negotiatedProtoVersion), NetworkID: chain.config.ChainID.Uint64(), Genesis: chain.blocks[0].Hash(), diff --git a/cmd/devp2p/internal/ethtest/protocol.go b/cmd/devp2p/internal/ethtest/protocol.go index af76082318fe..a21d1ca7a1d0 100644 --- a/cmd/devp2p/internal/ethtest/protocol.go +++ b/cmd/devp2p/internal/ethtest/protocol.go @@ -86,9 +86,3 @@ func protoOffset(proto Proto) uint64 { panic("unhandled protocol") } } - -// msgTypePtr is the constraint for protocol message types. -type msgTypePtr[U any] interface { - *U - Kind() byte -} diff --git a/cmd/devp2p/internal/ethtest/snap.go b/cmd/devp2p/internal/ethtest/snap.go index f4fce0931f12..07c75f6ced47 100644 --- a/cmd/devp2p/internal/ethtest/snap.go +++ b/cmd/devp2p/internal/ethtest/snap.go @@ -30,6 +30,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/protocols/snap" "github.com/ethereum/go-ethereum/internal/utesting" + "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie/trienode" ) @@ -86,9 +87,9 @@ func (s *Suite) TestSnapGetAccountRange(t *utesting.T) { root: root, startingHash: zero, limitHash: ffHash, - expAccounts: 67, + expAccounts: 68, expFirst: firstKey, - expLast: common.HexToHash("0x622e662246601dd04f996289ce8b85e86db7bb15bb17f86487ec9d543ddb6f9a"), + expLast: common.HexToHash("0x59312f89c13e9e24c1cb8b103aa39a9b2800348d97a92c2c9e2a78fa02b70025"), desc: "In this test, we request the entire state range, but limit the response to 4000 bytes.", }, { @@ -96,9 +97,9 @@ func (s *Suite) TestSnapGetAccountRange(t *utesting.T) { root: root, startingHash: zero, limitHash: ffHash, - expAccounts: 49, + expAccounts: 50, expFirst: firstKey, - expLast: common.HexToHash("0x445cb5c1278fdce2f9cbdb681bdd76c52f8e50e41dbd9e220242a69ba99ac099"), + expLast: common.HexToHash("0x4615e5f5df5b25349a00ad313c6cd0436b6c08ee5826e33a018661997f85ebaa"), desc: "In this test, we request the entire state range, but limit the response to 3000 bytes.", }, { @@ -106,9 +107,9 @@ func (s *Suite) TestSnapGetAccountRange(t *utesting.T) { root: root, startingHash: zero, limitHash: ffHash, - expAccounts: 34, + expAccounts: 35, expFirst: firstKey, - expLast: common.HexToHash("0x2ef46ebd2073cecde499c2e8df028ad79a26d57bfaa812c4c6f7eb4c9617b913"), + expLast: common.HexToHash("0x2de4bdbddcfbb9c3e195dae6b45f9c38daff897e926764bf34887fb0db5c3284"), desc: "In this test, we request the entire state range, but limit the response to 2000 bytes.", }, { @@ -177,9 +178,9 @@ The server should return the first available account.`, root: root, startingHash: firstKey, limitHash: ffHash, - expAccounts: 67, + expAccounts: 68, expFirst: firstKey, - expLast: common.HexToHash("0x622e662246601dd04f996289ce8b85e86db7bb15bb17f86487ec9d543ddb6f9a"), + expLast: common.HexToHash("0x59312f89c13e9e24c1cb8b103aa39a9b2800348d97a92c2c9e2a78fa02b70025"), desc: `In this test, startingHash is exactly the first available account key. The server should return the first available account of the state as the first item.`, }, @@ -188,9 +189,9 @@ The server should return the first available account of the state as the first i root: root, startingHash: hashAdd(firstKey, 1), limitHash: ffHash, - expAccounts: 67, + expAccounts: 68, expFirst: secondKey, - expLast: common.HexToHash("0x66192e4c757fba1cdc776e6737008f42d50370d3cd801db3624274283bf7cd63"), + expLast: common.HexToHash("0x59a7c8818f1c16b298a054020dc7c3f403a970d1d1db33f9478b1c36e3a2e509"), desc: `In this test, startingHash is after the first available key. The server should return the second account of the state as the first item.`, }, @@ -226,9 +227,9 @@ server to return no data because genesis is older than 127 blocks.`, root: s.chain.RootAt(int(s.chain.Head().Number().Uint64()) - 127), startingHash: zero, limitHash: ffHash, - expAccounts: 66, + expAccounts: 68, expFirst: firstKey, - expLast: common.HexToHash("0x729953a43ed6c913df957172680a17e5735143ad767bda8f58ac84ec62fbec5e"), + expLast: common.HexToHash("0x683b6c03cc32afe5db8cb96050f711fdaff8f8ff44c7587a9a848f921d02815e"), desc: `This test requests data at a state root that is 127 blocks old. We expect the server to have this state available.`, }, @@ -657,8 +658,8 @@ The server should reject the request.`, // It's a bit unfortunate these are hard-coded, but the result depends on // a lot of aspects of the state trie and can't be guessed in a simple // way. So you'll have to update this when the test chain is changed. - common.HexToHash("0x5bdc0d6057b35642a16d27223ea5454e5a17a400e28f7328971a5f2a87773b76"), - common.HexToHash("0x0a76c9812ca90ffed8ee4d191e683f93386b6e50cfe3679c0760d27510aa7fc5"), + common.HexToHash("0x4bdecec09691ad38113eebee2df94fadefdff5841c0f182bae1be3c8a6d60bf3"), + common.HexToHash("0x4178696465d4514ff5924ef8c28ce64d41a669634b63184c2c093e252d6b4bc4"), empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, @@ -678,8 +679,8 @@ The server should reject the request.`, // be updated when the test chain is changed. expHashes: []common.Hash{ empty, - common.HexToHash("0x0a76c9812ca90ffed8ee4d191e683f93386b6e50cfe3679c0760d27510aa7fc5"), - common.HexToHash("0x5bdc0d6057b35642a16d27223ea5454e5a17a400e28f7328971a5f2a87773b76"), + common.HexToHash("0x4178696465d4514ff5924ef8c28ce64d41a669634b63184c2c093e252d6b4bc4"), + common.HexToHash("0x4bdecec09691ad38113eebee2df94fadefdff5841c0f182bae1be3c8a6d60bf3"), }, }, @@ -937,10 +938,14 @@ func (s *Suite) snapGetTrieNodes(t *utesting.T, tc *trieNodesTest) error { } // write0 request + paths, err := rlp.EncodeToRawList(tc.paths) + if err != nil { + panic(err) + } req := &snap.GetTrieNodesPacket{ ID: uint64(rand.Int63()), Root: tc.root, - Paths: tc.paths, + Paths: paths, Bytes: tc.nBytes, } msg, err := conn.snapRequest(snap.GetTrieNodesMsg, req) diff --git a/cmd/devp2p/internal/ethtest/suite.go b/cmd/devp2p/internal/ethtest/suite.go index c23360bf821a..d710f9842803 100644 --- a/cmd/devp2p/internal/ethtest/suite.go +++ b/cmd/devp2p/internal/ethtest/suite.go @@ -34,6 +34,8 @@ import ( "github.com/ethereum/go-ethereum/internal/utesting" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/enode" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" "github.com/holiman/uint256" ) @@ -82,6 +84,7 @@ func (s *Suite) EthTests() []utesting.Test { // get history {Name: "GetBlockBodies", Fn: s.TestGetBlockBodies}, {Name: "GetReceipts", Fn: s.TestGetReceipts}, + {Name: "GetLargeReceipts", Fn: s.TestGetLargeReceipts}, // test transactions {Name: "LargeTxRequest", Fn: s.TestLargeTxRequest, Slow: true}, {Name: "Transaction", Fn: s.TestTransaction}, @@ -151,7 +154,11 @@ func (s *Suite) TestGetBlockHeaders(t *utesting.T) { if err != nil { t.Fatalf("failed to get headers for given request: %v", err) } - if !headersMatch(expected, headers.BlockHeadersRequest) { + received, err := headers.List.Items() + if err != nil { + t.Fatalf("invalid headers received: %v", err) + } + if !headersMatch(expected, received) { t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected, headers) } } @@ -237,7 +244,7 @@ concurrently, with different request IDs.`) // Wait for responses. // Note they can arrive in either order. - resp, err := collectResponses(conn, 2, func(msg *eth.BlockHeadersPacket) uint64 { + resp, err := collectHeaderResponses(conn, 2, func(msg *eth.BlockHeadersPacket) uint64 { if msg.RequestId != 111 && msg.RequestId != 222 { t.Fatalf("response with unknown request ID: %v", msg.RequestId) } @@ -248,17 +255,11 @@ concurrently, with different request IDs.`) } // Check if headers match. - resp1 := resp[111] - if expected, err := s.chain.GetHeaders(req1); err != nil { - t.Fatalf("failed to get expected headers for request 1: %v", err) - } else if !headersMatch(expected, resp1.BlockHeadersRequest) { - t.Fatalf("header mismatch for request ID %v: \nexpected %v \ngot %v", 111, expected, resp1) - } - resp2 := resp[222] - if expected, err := s.chain.GetHeaders(req2); err != nil { - t.Fatalf("failed to get expected headers for request 2: %v", err) - } else if !headersMatch(expected, resp2.BlockHeadersRequest) { - t.Fatalf("header mismatch for request ID %v: \nexpected %v \ngot %v", 222, expected, resp2) + if err := s.checkHeadersAgainstChain(req1, resp[111]); err != nil { + t.Fatal(err) + } + if err := s.checkHeadersAgainstChain(req2, resp[222]); err != nil { + t.Fatal(err) } } @@ -303,8 +304,8 @@ same request ID. The node should handle the request by responding to both reques // Wait for the responses. They can arrive in either order, and we can't tell them // apart by their request ID, so use the number of headers instead. - resp, err := collectResponses(conn, 2, func(msg *eth.BlockHeadersPacket) uint64 { - id := uint64(len(msg.BlockHeadersRequest)) + resp, err := collectHeaderResponses(conn, 2, func(msg *eth.BlockHeadersPacket) uint64 { + id := uint64(msg.List.Len()) if id != 2 && id != 3 { t.Fatalf("invalid number of headers in response: %d", id) } @@ -315,26 +316,35 @@ same request ID. The node should handle the request by responding to both reques } // Check if headers match. - resp1 := resp[2] - if expected, err := s.chain.GetHeaders(request1); err != nil { - t.Fatalf("failed to get expected headers for request 1: %v", err) - } else if !headersMatch(expected, resp1.BlockHeadersRequest) { - t.Fatalf("headers mismatch: \nexpected %v \ngot %v", expected, resp1) - } - resp2 := resp[3] - if expected, err := s.chain.GetHeaders(request2); err != nil { - t.Fatalf("failed to get expected headers for request 2: %v", err) - } else if !headersMatch(expected, resp2.BlockHeadersRequest) { - t.Fatalf("headers mismatch: \nexpected %v \ngot %v", expected, resp2) + if err := s.checkHeadersAgainstChain(request1, resp[2]); err != nil { + t.Fatal(err) + } + if err := s.checkHeadersAgainstChain(request2, resp[3]); err != nil { + t.Fatal(err) } } +func (s *Suite) checkHeadersAgainstChain(req *eth.GetBlockHeadersPacket, resp *eth.BlockHeadersPacket) error { + received2, err := resp.List.Items() + if err != nil { + return fmt.Errorf("invalid headers in response with request ID %v (%d items): %v", resp.RequestId, resp.List.Len(), err) + } + if expected, err := s.chain.GetHeaders(req); err != nil { + return fmt.Errorf("test chain failed to get expected headers for request: %v", err) + } else if !headersMatch(expected, received2) { + return fmt.Errorf("header mismatch for request ID %v (%d items): \nexpected %v \ngot %v", resp.RequestId, resp.List.Len(), expected, resp) + } + return nil +} + // collectResponses waits for n messages of type T on the given connection. // The messsages are collected according to the 'identity' function. -func collectResponses[T any, P msgTypePtr[T]](conn *Conn, n int, identity func(P) uint64) (map[uint64]P, error) { - resp := make(map[uint64]P, n) +// +// This function is written in a generic way to handle +func collectHeaderResponses(conn *Conn, n int, identity func(*eth.BlockHeadersPacket) uint64) (map[uint64]*eth.BlockHeadersPacket, error) { + resp := make(map[uint64]*eth.BlockHeadersPacket, n) for range n { - r := new(T) + r := new(eth.BlockHeadersPacket) if err := conn.ReadMsg(ethProto, eth.BlockHeadersMsg, r); err != nil { return resp, fmt.Errorf("read error: %v", err) } @@ -373,10 +383,8 @@ and expects a response.`) if got, want := headers.RequestId, req.RequestId; got != want { t.Fatalf("unexpected request id") } - if expected, err := s.chain.GetHeaders(req); err != nil { - t.Fatalf("failed to get expected block headers: %v", err) - } else if !headersMatch(expected, headers.BlockHeadersRequest) { - t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected, headers) + if err := s.checkHeadersAgainstChain(req, headers); err != nil { + t.Fatal(err) } } @@ -407,9 +415,8 @@ func (s *Suite) TestGetBlockBodies(t *utesting.T) { if got, want := resp.RequestId, req.RequestId; got != want { t.Fatalf("unexpected request id in respond", got, want) } - bodies := resp.BlockBodiesResponse - if len(bodies) != len(req.GetBlockBodiesRequest) { - t.Fatalf("wrong bodies in response: expected %d bodies, got %d", len(req.GetBlockBodiesRequest), len(bodies)) + if resp.List.Len() != len(req.GetBlockBodiesRequest) { + t.Fatalf("wrong bodies in response: expected %d bodies, got %d", len(req.GetBlockBodiesRequest), resp.List.Len()) } } @@ -424,6 +431,9 @@ func (s *Suite) TestGetReceipts(t *utesting.T) { // Find some blocks containing receipts. var hashes = make([]common.Hash, 0, 3) for i := range s.chain.Len() { + if s.chain.txInfo.LargeReceiptBlock != nil && uint64(i) == *s.chain.txInfo.LargeReceiptBlock { + continue + } block := s.chain.GetBlock(i) if len(block.Transactions()) > 0 { hashes = append(hashes, block.Hash()) @@ -432,25 +442,121 @@ func (s *Suite) TestGetReceipts(t *utesting.T) { break } } + if conn.negotiatedProtoVersion < eth.ETH70 { + // Create block bodies request. + req := ð.GetReceiptsPacket69{ + RequestId: 66, + GetReceiptsRequest: (eth.GetReceiptsRequest)(hashes), + } + if err := conn.Write(ethProto, eth.GetReceiptsMsg, req); err != nil { + t.Fatalf("could not write to connection: %v", err) + } + // Wait for response. + resp := new(eth.ReceiptsPacket69) + if err := conn.ReadMsg(ethProto, eth.ReceiptsMsg, &resp); err != nil { + t.Fatalf("error reading block receipts msg: %v", err) + } + if got, want := resp.RequestId, req.RequestId; got != want { + t.Fatalf("unexpected request id in respond", got, want) + } + if resp.List.Len() != len(req.GetReceiptsRequest) { + t.Fatalf("wrong receipts in response: expected %d receipts, got %d", len(req.GetReceiptsRequest), resp.List.Len()) + } + } else { + // Create block bodies request. + req := ð.GetReceiptsPacket70{ + RequestId: 66, + FirstBlockReceiptIndex: 0, + GetReceiptsRequest: (eth.GetReceiptsRequest)(hashes), + } + if err := conn.Write(ethProto, eth.GetReceiptsMsg, req); err != nil { + t.Fatalf("could not write to connection: %v", err) + } + // Wait for response. + resp := new(eth.ReceiptsPacket70) + if err := conn.ReadMsg(ethProto, eth.ReceiptsMsg, &resp); err != nil { + t.Fatalf("error reading block receipts msg: %v", err) + } + if got, want := resp.RequestId, req.RequestId; got != want { + t.Fatalf("unexpected request id in respond", got, want) + } + if resp.List.Len() != len(req.GetReceiptsRequest) { + t.Fatalf("wrong receipts in response: expected %d receipts, got %d", len(req.GetReceiptsRequest), resp.List.Len()) + } + } +} - // Create block bodies request. - req := ð.GetReceiptsPacket{ - RequestId: 66, - GetReceiptsRequest: (eth.GetReceiptsRequest)(hashes), +func (s *Suite) TestGetLargeReceipts(t *utesting.T) { + t.Log(`This test sends GetReceipts requests to the node for large receipt (>10MiB) in the test chain. + This test is meaningful only if the client supports protocol version ETH70 or higher + and LargeReceiptBlock is configured in txInfo.json.`) + conn, err := s.dialAndPeer(nil) + if err != nil { + t.Fatalf("peering failed: %v", err) } - if err := conn.Write(ethProto, eth.GetReceiptsMsg, req); err != nil { - t.Fatalf("could not write to connection: %v", err) + defer conn.Close() + + if conn.negotiatedProtoVersion < eth.ETH70 || s.chain.txInfo.LargeReceiptBlock == nil { + return } - // Wait for response. - resp := new(eth.ReceiptsPacket[*eth.ReceiptList69]) - if err := conn.ReadMsg(ethProto, eth.ReceiptsMsg, &resp); err != nil { - t.Fatalf("error reading block bodies msg: %v", err) + + // Find block with large receipt. + // Place the large receipt block hash in the middle of the query + start := max(int(*s.chain.txInfo.LargeReceiptBlock)-2, 0) + end := min(*s.chain.txInfo.LargeReceiptBlock+2, uint64(len(s.chain.blocks))) + + var blocks []common.Hash + var receiptHashes []common.Hash + var receipts []*eth.ReceiptList + + for i := uint64(start); i < end; i++ { + block := s.chain.GetBlock(int(i)) + blocks = append(blocks, block.Hash()) + receiptHashes = append(receiptHashes, block.Header().ReceiptHash) + receipts = append(receipts, ð.ReceiptList{}) } - if got, want := resp.RequestId, req.RequestId; got != want { - t.Fatalf("unexpected request id in respond", got, want) + + incomplete := false + lastBlock := 0 + + for incomplete || lastBlock != len(blocks)-1 { + // Create get receipt request. + req := ð.GetReceiptsPacket70{ + RequestId: 66, + FirstBlockReceiptIndex: uint64(receipts[lastBlock].Derivable().Len()), + GetReceiptsRequest: blocks[lastBlock:], + } + if err := conn.Write(ethProto, eth.GetReceiptsMsg, req); err != nil { + t.Fatalf("could not write to connection: %v", err) + } + // Wait for response. + resp := new(eth.ReceiptsPacket70) + if err := conn.ReadMsg(ethProto, eth.ReceiptsMsg, &resp); err != nil { + t.Fatalf("error reading block receipts msg: %v", err) + } + if got, want := resp.RequestId, req.RequestId; got != want { + t.Fatalf("unexpected request id in respond, want: %d, got: %d", got, want) + } + + receiptLists, _ := resp.List.Items() + for i, rc := range receiptLists { + receipts[lastBlock+i].Append(rc) + } + lastBlock += len(receiptLists) - 1 + + incomplete = resp.LastBlockIncomplete + } + + hasher := trie.NewStackTrie(nil) + hashes := make([]common.Hash, len(receipts)) + for i := range receipts { + hashes[i] = types.DeriveSha(receipts[i].Derivable(), hasher) } - if len(resp.List) != len(req.GetReceiptsRequest) { - t.Fatalf("wrong bodies in response: expected %d bodies, got %d", len(req.GetReceiptsRequest), len(resp.List)) + + for i, hash := range hashes { + if receiptHashes[i] != hash { + t.Fatalf("wrong receipt root: want %x, got %x", receiptHashes[i], hash) + } } } @@ -804,7 +910,11 @@ on another peer connection using GetPooledTransactions.`) if got, want := msg.RequestId, req.RequestId; got != want { t.Fatalf("unexpected request id in response: got %d, want %d", got, want) } - for _, got := range msg.PooledTransactionsResponse { + responseTxs, err := msg.List.Items() + if err != nil { + t.Fatalf("invalid transactions in response: %v", err) + } + for _, got := range responseTxs { if _, exists := set[got.Hash()]; !exists { t.Fatalf("unexpected tx received: %v", got.Hash()) } @@ -976,7 +1086,9 @@ func (s *Suite) TestBlobViolations(t *utesting.T) { if err := conn.ReadMsg(ethProto, eth.GetPooledTransactionsMsg, req); err != nil { t.Fatalf("reading pooled tx request failed: %v", err) } - resp := eth.PooledTransactionsPacket{RequestId: req.RequestId, PooledTransactionsResponse: test.resp} + + encTxs, _ := rlp.EncodeToRawList(test.resp) + resp := eth.PooledTransactionsPacket{RequestId: req.RequestId, List: encTxs} if err := conn.Write(ethProto, eth.PooledTransactionsMsg, resp); err != nil { t.Fatalf("writing pooled tx response failed: %v", err) } @@ -1104,7 +1216,8 @@ func (s *Suite) testBadBlobTx(t *utesting.T, tx *types.Transaction, badTx *types // the good peer is connected, and has announced the tx. // proceed to send the incorrect one from the bad peer. - resp := eth.PooledTransactionsPacket{RequestId: req.RequestId, PooledTransactionsResponse: eth.PooledTransactionsResponse(types.Transactions{badTx})} + encTxs, _ := rlp.EncodeToRawList([]*types.Transaction{badTx}) + resp := eth.PooledTransactionsPacket{RequestId: req.RequestId, List: encTxs} if err := conn.Write(ethProto, eth.PooledTransactionsMsg, resp); err != nil { errc <- fmt.Errorf("writing pooled tx response failed: %v", err) return @@ -1164,7 +1277,8 @@ func (s *Suite) testBadBlobTx(t *utesting.T, tx *types.Transaction, badTx *types return } - resp := eth.PooledTransactionsPacket{RequestId: req.RequestId, PooledTransactionsResponse: eth.PooledTransactionsResponse(types.Transactions{tx})} + encTxs, _ := rlp.EncodeToRawList([]*types.Transaction{tx}) + resp := eth.PooledTransactionsPacket{RequestId: req.RequestId, List: encTxs} if err := conn.Write(ethProto, eth.PooledTransactionsMsg, resp); err != nil { errc <- fmt.Errorf("writing pooled tx response failed: %v", err) return diff --git a/cmd/devp2p/internal/ethtest/testdata/chain.rlp b/cmd/devp2p/internal/ethtest/testdata/chain.rlp index 7d4f4b3efe5d..d5209ab0413a 100644 Binary files a/cmd/devp2p/internal/ethtest/testdata/chain.rlp and b/cmd/devp2p/internal/ethtest/testdata/chain.rlp differ diff --git a/cmd/devp2p/internal/ethtest/testdata/genesis.json b/cmd/devp2p/internal/ethtest/testdata/genesis.json index c8ed44b88550..a8963b30ea9b 100644 --- a/cmd/devp2p/internal/ethtest/testdata/genesis.json +++ b/cmd/devp2p/internal/ethtest/testdata/genesis.json @@ -37,7 +37,7 @@ "nonce": "0x0", "timestamp": "0x0", "extraData": "0x68697665636861696e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "difficulty": "0x20000", "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "coinbase": "0x0000000000000000000000000000000000000000", @@ -119,6 +119,10 @@ "balance": "0x1", "nonce": "0x1" }, + "8dcd17433742f4c0ca53122ab541d0ba67fc27ff": { + "code": "0x6202e6306000a0", + "balance": "0x0" + }, "c7b99a164efd027a93f147376cc7da7c67c6bbe0": { "balance": "0xc097ce7bc90715b34b9f1000000000" }, diff --git a/cmd/devp2p/internal/ethtest/testdata/headblock.json b/cmd/devp2p/internal/ethtest/testdata/headblock.json index bb5244be18d0..da18081d3446 100644 --- a/cmd/devp2p/internal/ethtest/testdata/headblock.json +++ b/cmd/devp2p/internal/ethtest/testdata/headblock.json @@ -1,24 +1,24 @@ { - "parentHash": "0x65151b101682b54cd08ba226f640c14c86176865ff9bfc57e0147dadaeac34bb", + "parentHash": "0x7e80093a491eba0e5b2c1895837902f64f514100221801318fe391e1e09c96a6", "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "miner": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce423ebc60fc7764a43f09f1fe3ae61eef25e3eb8d09b1108f7e7eb77dfff5e6", - "transactionsRoot": "0x7ec1ae3989efa75d7bcc766e5e2443afa8a89a5fda42ebba90050e7e702980f7", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x8fcfb02cfca007773bd55bc1c3e50a3c8612a59c87ce057e5957e8bf17c1728b", + "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "difficulty": "0x0", "number": "0x258", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1770", "extraData": "0x", "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "nonce": "0x0000000000000000", "baseFeePerGas": "0x7", - "withdrawalsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "withdrawalsRoot": "0x92abfda39de7df7d705c5a8f30386802ad59d31e782a06d5c5b0f9a260056cf0", "blobGasUsed": "0x0", "excessBlobGas": "0x0", "parentBeaconBlockRoot": "0xf5003fc8f92358e790a114bce93ce1d9c283c85e1787f8d7d56714d3489b49e6", "requestsHash": "0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", - "hash": "0xce8d86ba17a2ec303155f0e264c58a4b8f94ce3436274cf1924f91acdb7502d0" + "hash": "0x44e3809c9a3cda717f00aea3a9da336d149612c8d5657fbc0028176ef8d94d2a" } \ No newline at end of file diff --git a/cmd/devp2p/internal/ethtest/testdata/headfcu.json b/cmd/devp2p/internal/ethtest/testdata/headfcu.json index 9ab3a4de1a90..eeb2ea582993 100644 --- a/cmd/devp2p/internal/ethtest/testdata/headfcu.json +++ b/cmd/devp2p/internal/ethtest/testdata/headfcu.json @@ -4,9 +4,9 @@ "method": "engine_forkchoiceUpdatedV3", "params": [ { - "headBlockHash": "0xce8d86ba17a2ec303155f0e264c58a4b8f94ce3436274cf1924f91acdb7502d0", - "safeBlockHash": "0xce8d86ba17a2ec303155f0e264c58a4b8f94ce3436274cf1924f91acdb7502d0", - "finalizedBlockHash": "0xce8d86ba17a2ec303155f0e264c58a4b8f94ce3436274cf1924f91acdb7502d0" + "headBlockHash": "0x44e3809c9a3cda717f00aea3a9da336d149612c8d5657fbc0028176ef8d94d2a", + "safeBlockHash": "0x44e3809c9a3cda717f00aea3a9da336d149612c8d5657fbc0028176ef8d94d2a", + "finalizedBlockHash": "0x44e3809c9a3cda717f00aea3a9da336d149612c8d5657fbc0028176ef8d94d2a" }, null ] diff --git a/cmd/devp2p/internal/ethtest/testdata/headstate.json b/cmd/devp2p/internal/ethtest/testdata/headstate.json index 72c7ebd509e3..982015d0a567 100644 --- a/cmd/devp2p/internal/ethtest/testdata/headstate.json +++ b/cmd/devp2p/internal/ethtest/testdata/headstate.json @@ -1,8 +1,8 @@ { - "root": "ce423ebc60fc7764a43f09f1fe3ae61eef25e3eb8d09b1108f7e7eb77dfff5e6", + "root": "8fcfb02cfca007773bd55bc1c3e50a3c8612a59c87ce057e5957e8bf17c1728b", "accounts": { "0x0000000000000000000000000000000000000000": { - "balance": "30749363", + "balance": "121816101", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", @@ -35,599 +35,599 @@ "0x0000F90827F1C53a10cb7A02335B175320002935": { "balance": "1", "nonce": 0, - "root": "0xf6332d2b55fdf1c60c6e6a4f9605a08bc6ea545dd2753ba789d76c2669e3376d", + "root": "0x7634a52f9af21ce71ccbc57320cd906c09caca9db12fcfb8636cac62a928ca0c", "codeHash": "0x6e49e66782037c0555897870e29fa5e552daf4719552131a0abce779daec0a5d", "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604657602036036042575f35600143038111604257611fff81430311604257611fff9006545f5260205ff35b5f5ffd5b5f35611fff60014303065500", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000000b": "7167b82e4207928eb75fbe741b29d18fb5d469fa56c93941223667a07d183c44", - "0x000000000000000000000000000000000000000000000000000000000000000c": "23d7c4e274d71eee019119e9403d83ae181d9555d30a81aa0660c2103360f126", - "0x000000000000000000000000000000000000000000000000000000000000000d": "cbe5c6da730320128cc63a3c2454ede30738fa0d59a9e9de2e90f58b1938333a", - "0x000000000000000000000000000000000000000000000000000000000000000e": "ec7e5f7aada029114c5b556586e0e3c3ef3a39dde955f379ccea43ef93acabbc", - "0x000000000000000000000000000000000000000000000000000000000000000f": "7599aa2261eece5d6075f09401692a0ee37815ad63946cc80ab3ba29838c00f8", - "0x0000000000000000000000000000000000000000000000000000000000000010": "60576c148e7ac42f9d36ee36a7df5a89241609f624502b248b5cf710ed269a4c", - "0x0000000000000000000000000000000000000000000000000000000000000011": "8cd31f14889acd865b0ad0b2fd746586f29e87941166bf7087dc8bb429f01554", - "0x0000000000000000000000000000000000000000000000000000000000000012": "3e48b276f3b3209dda302780f9c8e4459d2c9378f4508c0fc4f9d26e6a5d173f", - "0x0000000000000000000000000000000000000000000000000000000000000013": "905f74a6377ead9037c78e9008bbb788c74c1fdb7f993b4820e24be5dde9c9af", - "0x0000000000000000000000000000000000000000000000000000000000000014": "35398f9b164bfdf8f4b4cde5181a9d96bb37947181332dc7977dc2360bee6300", - "0x0000000000000000000000000000000000000000000000000000000000000015": "4a4aef4730ba6155773a9e5c7e0c5f25a552d187687d59ad81b4a86c9f15a9fb", - "0x0000000000000000000000000000000000000000000000000000000000000016": "b3c7f4d24254129c2621485e664106ca2c2d08337672a2c8e484524b6e0dd0fb", - "0x0000000000000000000000000000000000000000000000000000000000000017": "25e8e33978b09de34a49b2595fd3dfe13d0f8c9a8939ca6c88376292459ec533", - "0x0000000000000000000000000000000000000000000000000000000000000018": "4f350577873216755df98391d69caf01ba646006d88459326e2f2bc2acbbf0e0", - "0x0000000000000000000000000000000000000000000000000000000000000019": "ec6593f4d6535e923dce8d47de08d98f8d751ea078f186072fe46b3b745d5274", - "0x000000000000000000000000000000000000000000000000000000000000001a": "c342e54f189bd6e3099871e6ecdb5f5b85a409299decd86a08e5564e42d22aa7", - "0x000000000000000000000000000000000000000000000000000000000000001b": "750dd92f162fd79de0f147a4a5a6928ea06463f04ce9ccd6f85d128f726d75c4", - "0x000000000000000000000000000000000000000000000000000000000000001c": "851dbf7f27a98cf2fc320a858b96e89bfe8af9551e4aa966cd6ed4d4b5d9dac8", - "0x000000000000000000000000000000000000000000000000000000000000001d": "95d530f6e64e5b60726d6f40f995fbcb099957cfaaf2765dc78684d4fccacb59", - "0x000000000000000000000000000000000000000000000000000000000000001e": "1da94a9b2bc22478c3c9e45591d3254ed48b2f15a68dcd86d272273bd362e1db", - "0x000000000000000000000000000000000000000000000000000000000000001f": "0776e32e33ee61a75147584501827f9a7cef40e1198d62791acf4d7f5c50a55a", - "0x0000000000000000000000000000000000000000000000000000000000000020": "39032e04806c95bf605cab0f493454b349e86b17808b4b019a6fc264c58e570b", - "0x0000000000000000000000000000000000000000000000000000000000000021": "7bfd33d91f0f065c4c0963ef3975dfacb13ebcd3b1d9433eeba5f26320bb453b", - "0x0000000000000000000000000000000000000000000000000000000000000022": "cbeea1d0322b931091bee7d7fd49ed48d09f35324c7837f3b51c1f9e017cdcc8", - "0x0000000000000000000000000000000000000000000000000000000000000023": "daecb35565efc8fe915c286637a2f664473681e90f9ab6e05d0aa02ecdcdc654", - "0x0000000000000000000000000000000000000000000000000000000000000024": "4accb52ae0491cfaed5866f5296d8d15233a16ffd73c91735040c58cebaf7ff9", - "0x0000000000000000000000000000000000000000000000000000000000000025": "a22225105655427813fb4e29887ef8ec1a18877bb441913fadce200903ba0f0f", - "0x0000000000000000000000000000000000000000000000000000000000000026": "6ad17c25de20d9f09aaff897681a87788d216791d9e33d2d4543b162f3c47423", - "0x0000000000000000000000000000000000000000000000000000000000000027": "5b65d43473b3132497d0fc75a2808f73a2808560785c6e7f55d2ac722047d291", - "0x0000000000000000000000000000000000000000000000000000000000000028": "ebf3316f9944a4d7686ca037353ab00ba9aba83839dbf6b81a1f17127bc97131", - "0x0000000000000000000000000000000000000000000000000000000000000029": "9a93da70b45233339e8a591567fec5e1fab43884f5b56bece2e795fb964942c3", - "0x000000000000000000000000000000000000000000000000000000000000002a": "4087ae9e71cbdae794c137d61684e08835fa8a6c13e9e5a001163eaccf6b842f", - "0x000000000000000000000000000000000000000000000000000000000000002b": "9eb1dcefdae7fc61fdacb218921236acad55350bda6c209931d89b65dcfd0eeb", - "0x000000000000000000000000000000000000000000000000000000000000002c": "c0fd1e13ad5b4c7102e278a96573f8cf66809bd6c3445f5c3650189596c0d680", - "0x000000000000000000000000000000000000000000000000000000000000002d": "84af2f9798e57abc0431d1f0156b45f6521c7720ff0215459af9fa0553eb47e5", - "0x000000000000000000000000000000000000000000000000000000000000002e": "cb33361cca9889678cb7c5fe9a4fe345d929cc71e8f6e53e5cd310820e01dff3", - "0x000000000000000000000000000000000000000000000000000000000000002f": "ef24d6293c96bd11abe059e96317856581f1736cf94786dbc0fc0d366df430af", - "0x0000000000000000000000000000000000000000000000000000000000000030": "95d87d14848a52aae340beecba232b70e909de98a3e2648fd44b66b73f7e12f8", - "0x0000000000000000000000000000000000000000000000000000000000000031": "b5e2e62689ca47b11879ba997cd532c410ab09f03719817fd33dc6923d990a03", - "0x0000000000000000000000000000000000000000000000000000000000000032": "56110ba58fe532a71688f5cb3ff7129f7e9636d4aaf69a4347f70299b6f21a22", - "0x0000000000000000000000000000000000000000000000000000000000000033": "2e693ca7593217b296154d482519dd780931e96b006b2deb05490fc2375c8c92", - "0x0000000000000000000000000000000000000000000000000000000000000034": "919d586bdedaf4fb38996e5a32eaa14f753a1babb1da62c6d0aa2035005b5d86", - "0x0000000000000000000000000000000000000000000000000000000000000035": "978425ebd54536bfd17945cf57726cd02fc25b083bc9332b7b4c8a94c37762bb", - "0x0000000000000000000000000000000000000000000000000000000000000036": "808ecd5038418740fc4b27954cdd2e4952569e8062b846b5cdd234b1eaaf7795", - "0x0000000000000000000000000000000000000000000000000000000000000037": "4313be4af809c236c319dbd5dad18e0d030f610e7e4cacef0ff8b26af563b046", - "0x0000000000000000000000000000000000000000000000000000000000000038": "cad24a57225330d06226b15cd3b5be7b0f2a42fef155e489994f7026f79924f4", - "0x0000000000000000000000000000000000000000000000000000000000000039": "16e634e48fc62762ce8fc1762c6bfd34e94b3533b98a5fb1bbd504b131a64a65", - "0x000000000000000000000000000000000000000000000000000000000000003a": "39f1c7f651e1970418fd8a5e0786c83e813744d55ea965e7902112bc02f190ec", - "0x000000000000000000000000000000000000000000000000000000000000003b": "ceccf9166834bac24869c590390335f72c85c59a1553be2d99db38b039bb4c99", - "0x000000000000000000000000000000000000000000000000000000000000003c": "b8c495461332ae67504ee899542ccf73e859f73c6682fad15415743f15b7f5e6", - "0x000000000000000000000000000000000000000000000000000000000000003d": "fe4445a66aeaa138c2045c340fffae7db7f7a49b7a31df8b8b5f5aa431c58546", - "0x000000000000000000000000000000000000000000000000000000000000003e": "0f13f717c99151d8b5b509af5cacb5313f1ebf813d7a6b37764cbe1ec0459beb", - "0x000000000000000000000000000000000000000000000000000000000000003f": "2e33aeb9f45e7cb955774b6b43df2c3a438c5aa03a69f90793f137ff5d2eb49e", - "0x0000000000000000000000000000000000000000000000000000000000000040": "f496b8d4d19037d646dcbc3796d2a28bf176488e2e238107feaa0b4b7f5ae6a5", - "0x0000000000000000000000000000000000000000000000000000000000000041": "49005c56e2c43c7d5d10026c97dce5b3b2e4a38eda72b6db3e544d2e92c12047", - "0x0000000000000000000000000000000000000000000000000000000000000042": "ae199d9dff48f9bc1202bd414078c175b977869bce215c79259cbed32e490b16", - "0x0000000000000000000000000000000000000000000000000000000000000043": "65ca2f730c7ef4ae37e81f916bfe2a89b86ee315d17796e0b8b5bb76c4127e", - "0x0000000000000000000000000000000000000000000000000000000000000044": "c091a79738ea695804fd7a370a3d24728d5d4523a047835b28fbe5790c914af0", - "0x0000000000000000000000000000000000000000000000000000000000000045": "c0dec6888ce6c75c575ce5ada6f3425cf1511b4d31b4f7ffeb63e93bf00ff243", - "0x0000000000000000000000000000000000000000000000000000000000000046": "fd1c5aae32a2ab886fbc6b5229bd30528f904fa67063d334e6428dfc94a9909b", - "0x0000000000000000000000000000000000000000000000000000000000000047": "537b75471b40aaa24670d4ed625d075165b59e4ab455236c14dedd7e99e65d34", - "0x0000000000000000000000000000000000000000000000000000000000000048": "509c406dedf930913cc53d51de88a6b34b0edf15d45c88deee154cdea0b35415", - "0x0000000000000000000000000000000000000000000000000000000000000049": "cd249ec42453922de5255c9b47ac76191e3cb60144ad0c4bd1b5e02d672c08a0", - "0x000000000000000000000000000000000000000000000000000000000000004a": "4b17336fdc9eccebc8c836ffcf41d077a956e9cf786521e9eb4d01db5de5a935", - "0x000000000000000000000000000000000000000000000000000000000000004b": "85784669b5e3b7ce03064984463c5c167f4c90bbc7731862bd5d6cdcbbe7dfaf", - "0x000000000000000000000000000000000000000000000000000000000000004c": "6d3b7ae474719d6929a8374bac361084a530941d9e9c8754bc8765a818704dc4", - "0x000000000000000000000000000000000000000000000000000000000000004d": "60ab9fa061b4a52ae93aac61a70a7049d5ace2d85ad81cd3ba18e5b6f9df5a90", - "0x000000000000000000000000000000000000000000000000000000000000004e": "8d76a11f766a753283cdebf3c0a4ada62f0a85333eadf13f5c94b5528b9a0bb8", - "0x000000000000000000000000000000000000000000000000000000000000004f": "70ed6c8dfbfd1a79453b1360fe0c9024d1c9a51b7e9ae491dc9f672c1495ee52", - "0x0000000000000000000000000000000000000000000000000000000000000050": "829bf1d587f5294d8ee978c07aa33af6df08dc44876e81c4f2d1d9403e6c0478", - "0x0000000000000000000000000000000000000000000000000000000000000051": "b57dc2887b5798442036ac860b372cb07b5858c460977c426b53bf780aee15ba", - "0x0000000000000000000000000000000000000000000000000000000000000052": "6793c6d579b24b7bfac5cfd619b7335aace2365f75cf5b0d1e1b5c367288b74b", - "0x0000000000000000000000000000000000000000000000000000000000000053": "ab38058baae4ce65fe734310ef852d1adb2eb0e5bce297e2dfb1f2aabb8155fe", - "0x0000000000000000000000000000000000000000000000000000000000000054": "c129c2d37fdd0defa0d0cdd7b27a95e5f17eb1beb11a8713bc4b398dff6f69a2", - "0x0000000000000000000000000000000000000000000000000000000000000055": "5e61412b6b77af36026fc83378b2aff64e52121621912d35061bf7db4e315657", - "0x0000000000000000000000000000000000000000000000000000000000000056": "06a3b3e77a4ecfa284cd0cbc5f563dafcebefcaa7e4610b0433f1da2353d65a5", - "0x0000000000000000000000000000000000000000000000000000000000000057": "096a5b9ce9899b40e70d721ead24b8da99a16bd9d115412a1e5d4ba2478ba276", - "0x0000000000000000000000000000000000000000000000000000000000000058": "a6b1b6fbde7fcc8c1c4b6b035835d839914b9d3ad21dedf946f5d91754d9a6c4", - "0x0000000000000000000000000000000000000000000000000000000000000059": "96d9997e171f41cd83e6829c097bd37f9c352553c0a1fb5a739d2766cd7b0772", - "0x000000000000000000000000000000000000000000000000000000000000005a": "70db0ab4ec61502d2a53b8faa0ffe5a45d7db6f562af25e6564d8d2669989d0a", - "0x000000000000000000000000000000000000000000000000000000000000005b": "a6aa03ee648578c9413c668ab9f6d2dc480a48bcf7b126dec17b85be35b28604", - "0x000000000000000000000000000000000000000000000000000000000000005c": "bec4f585aade8992655a98ecf32e5ad71245f864bb2c3987b0216bfcf2acb0c0", - "0x000000000000000000000000000000000000000000000000000000000000005d": "a75924e8dc804bc7d9588a41ae6545effa02c568f519abb7f109d76ae17442c0", - "0x000000000000000000000000000000000000000000000000000000000000005e": "c80ae577ac0e00ce2a417f069f0db47ca32ba3576ea6092273c623a035980fba", - "0x000000000000000000000000000000000000000000000000000000000000005f": "3e10fa0f7879c62f9eb6373a80bf6a0a2d4c16fee5ba96566d62488db5477e92", - "0x0000000000000000000000000000000000000000000000000000000000000060": "9ae8e852cab82414dd0762c67565523f30c9049a061c7c3b4a310cfcd4df9d2a", - "0x0000000000000000000000000000000000000000000000000000000000000061": "6c4fe4ae5fb8b2a347e58868bc6a741a6df75a83593b062869cacb7ce3a715af", - "0x0000000000000000000000000000000000000000000000000000000000000062": "6722daf402b94682af585921807783bb92e1957789399ed0e0be0e0faa5a8c87", - "0x0000000000000000000000000000000000000000000000000000000000000063": "651c869c9f62a753fa0c545a984f596d2068aa542234b109032b93a583442ffe", - "0x0000000000000000000000000000000000000000000000000000000000000064": "e93d89f5d6ab364e7c6597d99b6041f6c1d503a639f1265e8ffb1261f87fa2f3", - "0x0000000000000000000000000000000000000000000000000000000000000065": "0507a6937203ad4297bca7595e8e0d7715d59bb7296968aebd84c135b707c638", - "0x0000000000000000000000000000000000000000000000000000000000000066": "f08662ab38a7f4db3179eb425b28a2dd5d918c80b87740d1b88699ebe905a11b", - "0x0000000000000000000000000000000000000000000000000000000000000067": "122f9c89a20f0af63d4d5af9ac5e5ca3907ae256efa3d561f22b9288ad122f17", - "0x0000000000000000000000000000000000000000000000000000000000000068": "8cd5f4a012d4f51460556c04b7fc6f4a4d94d1203cb092d0297372a43fdf283d", - "0x0000000000000000000000000000000000000000000000000000000000000069": "eba87b6b36d970ede1071402e363515bfc524572febb086525b84c792093175f", - "0x000000000000000000000000000000000000000000000000000000000000006a": "1db257ebc3fdfbb6fe6fa8234fbc771becfee96128648eac4164773196acea99", - "0x000000000000000000000000000000000000000000000000000000000000006b": "2a5fd10344d681d2e72384382583b1a9fd82fd0125a1fc24b4296bf3e37cf096", - "0x000000000000000000000000000000000000000000000000000000000000006c": "647266d2cef5a6b13af790b1b0af42fae3962e80f0724115407e6ecf0b2a6556", - "0x000000000000000000000000000000000000000000000000000000000000006d": "52979d072bdf7bfb3fd707c0f83a4a3de1d1c8fb5380c240f858ed964aaa8106", - "0x000000000000000000000000000000000000000000000000000000000000006e": "7a86b91b59bbb2f833af91649b2cd1ba2b4e5f78e5775d78c03ab8b71045b3e3", - "0x000000000000000000000000000000000000000000000000000000000000006f": "4643bd6c3e1a9ac7a7ad650d12048b9e733e219b843f2b3d830f5da795852454", - "0x0000000000000000000000000000000000000000000000000000000000000070": "7c1fb25dc97d20bb97dce8d8343149b20a96180f46f4b771285546da9d3ef7d3", - "0x0000000000000000000000000000000000000000000000000000000000000071": "adf0cc4f267c585703d9e7403b046ab5ba320204592557eef982e4c409e3d2ea", - "0x0000000000000000000000000000000000000000000000000000000000000072": "2ee413006dcb6448fb5c37443102aae3575781369fa9cd34175c0f03e3ddb693", - "0x0000000000000000000000000000000000000000000000000000000000000073": "55487f68bbd481313212ae5cca520be32f0a54c44e77705e13518a9c8b1a54bf", - "0x0000000000000000000000000000000000000000000000000000000000000074": "d9fa2ad334f336af1b5f9fdb858c0ed6c956b7e0f9454c5e7ee8b64462725ec8", - "0x0000000000000000000000000000000000000000000000000000000000000075": "b7f7753236089ad38a8f5fc7d31811b521331e866eece20f7de934579ab95d1e", - "0x0000000000000000000000000000000000000000000000000000000000000076": "ed36126582b6287363b3cbc31b9c39d7afd4d97ee5e83c00b2cd5449c1d6848a", - "0x0000000000000000000000000000000000000000000000000000000000000077": "836c48482765990a0b394761a91ee93850aff87b82fac9b1def52375ed7535b3", - "0x0000000000000000000000000000000000000000000000000000000000000078": "f01e70ef5e688634e591415823fc7c898679659802e4db0de9ec3c3af735f664", - "0x0000000000000000000000000000000000000000000000000000000000000079": "c04cb16eda5544fcfa77e18ed2092981e834e71cabc2b61bd25153c830b660ff", - "0x000000000000000000000000000000000000000000000000000000000000007a": "41d260ba8d4501bbc92352b34daaaec17e3f3fc3652c9b92d87a587beaed96", - "0x000000000000000000000000000000000000000000000000000000000000007b": "d2331ab665bad7fa9a43bc09da232bb06c72bc79d817a9f1c5bb05f96b9646e6", - "0x000000000000000000000000000000000000000000000000000000000000007c": "43e6a0ed19de50761c59208a225a7f9bac091c3eb7dad46807998cf6ee69c7", - "0x000000000000000000000000000000000000000000000000000000000000007d": "f64f01561392db4d006de40b0c35b3b8b56204cbd89b734608d148d2ae629228", - "0x000000000000000000000000000000000000000000000000000000000000007e": "49e6318f4587a021ad50e32ccad223164e0cc1ba28e1be6ee01060d331ecebbf", - "0x000000000000000000000000000000000000000000000000000000000000007f": "51af93a015c8a1395fdf3030bfa74b3f7104037671ab930defa6eb75e222e1eb", - "0x0000000000000000000000000000000000000000000000000000000000000080": "7ca2f8c5a75e26ee5575e7d68fb5035c6a3ad57fb35b1308c19cf0c563e86b55", - "0x0000000000000000000000000000000000000000000000000000000000000081": "7614b81f123a279df0a712b8e9f0a9999add17fa9020ed9fabd1fd89315362cc", - "0x0000000000000000000000000000000000000000000000000000000000000082": "218dd8608e6cdb93545a3e1203979ab4ca55f0f5bccf76a533fdd191d19f708a", - "0x0000000000000000000000000000000000000000000000000000000000000083": "a5e002a44d498e7a40b8a36eeb8ce8101353c3d379a5955d5809fcaf559a2bfb", - "0x0000000000000000000000000000000000000000000000000000000000000084": "1f7613cc089d031344e77e764174fee74d4eb6f501f467664b12220179d10fac", - "0x0000000000000000000000000000000000000000000000000000000000000085": "ab82fa0386891a0f6590a93f3b0c6852f582a38757c1a32d1d37a8195830c9ef", - "0x0000000000000000000000000000000000000000000000000000000000000086": "b0d4b43954c092e02e74342616a87ee25e15dabb9ba4d94c0bd474a907dff210", - "0x0000000000000000000000000000000000000000000000000000000000000087": "f14886af3d36d40608acfeebf709b67d679146b86594eb7f3d717ec214cb423c", - "0x0000000000000000000000000000000000000000000000000000000000000088": "c310edfd4b8d1456b9d2f25ad392a0f409356115a0b6baa06c5055355e690380", - "0x0000000000000000000000000000000000000000000000000000000000000089": "eb26879fc8d9023ee720917ace6b9bfebe36c4b18c476581524c26ff6b1b1770", - "0x000000000000000000000000000000000000000000000000000000000000008a": "bc885f1dd76d6044edf950a00f65f8b7e09037b64694a8a5bf040a8f875df73d", - "0x000000000000000000000000000000000000000000000000000000000000008b": "3f8e6751bb589f71b4529f33b341be4bcbb64cc89a86ac00ba2ecd28b96843f4", - "0x000000000000000000000000000000000000000000000000000000000000008c": "53c40989ba0f74285db823aeb706fbdd2f34e53b65edf8edda6054f6fe0154f0", - "0x000000000000000000000000000000000000000000000000000000000000008d": "56aac6e61bbe149532c6f833c15bea8fd7739b35b114c63d0c81d1b6803a9324", - "0x000000000000000000000000000000000000000000000000000000000000008e": "20a194b00f602fcb1db01bb84014dda4654f7bbf59de521992100e4c90d95eae", - "0x000000000000000000000000000000000000000000000000000000000000008f": "6a7e2a65b2c12ddb337eef91aa0772eae0064f24028cbb5f8d4d7c0c8f1437f9", - "0x0000000000000000000000000000000000000000000000000000000000000090": "2f3f1707049c34f0ce4b2222d6cbe9f149d79a0e2c1ea6101058cefe33e9b3f6", - "0x0000000000000000000000000000000000000000000000000000000000000091": "b7332dcef7339e1aaf6fe2b41257738e00b916fbb030c919dafa065f36889886", - "0x0000000000000000000000000000000000000000000000000000000000000092": "03c384271631c83751232b695f032adf6fb4244c81cbebf3e6fdd030b61e384b", - "0x0000000000000000000000000000000000000000000000000000000000000093": "5d72bae0b85bb59e94d55b7f439c6c0a9a1a8a47fa242f5dc64a82b880260cfe", - "0x0000000000000000000000000000000000000000000000000000000000000094": "b3a80dd6748adaba8d2598da58441cc645b165d96de91b605122e82caff076d8", - "0x0000000000000000000000000000000000000000000000000000000000000095": "32305ca5493b007b7c591c7ea565ad705010ad747126202b191c78ffb49ea51e", - "0x0000000000000000000000000000000000000000000000000000000000000096": "11b82f7fbb7a781b00b4eb695a56aacd1a5477a2bc4e8167d4c08b95c4186e4c", - "0x0000000000000000000000000000000000000000000000000000000000000097": "7ad16d4c674b10a59ca3364904af33fa3713db2e963cf7c36da3f3172a917aaa", - "0x0000000000000000000000000000000000000000000000000000000000000098": "e756ee647aad508c521e5463abc774c9ad8d3ac6f25a52c4b6970a04f716331d", - "0x0000000000000000000000000000000000000000000000000000000000000099": "1a924af515c53c392afb3be5839f952f6495116f677ba7cc630c76d08fa12e24", - "0x000000000000000000000000000000000000000000000000000000000000009a": "0de1dee56d87848e4730dd05feae6c512a356a38bd52304e1e399e8d48be718b", - "0x000000000000000000000000000000000000000000000000000000000000009b": "de590f5a6aa2882e34cb6894bf54e16296d5abeb244c7df2c0b12ec627c41432", - "0x000000000000000000000000000000000000000000000000000000000000009c": "cf5949ad3562b8f632d82c9af77116a0b83b9b9806e86d0c2bce517c7be2e842", - "0x000000000000000000000000000000000000000000000000000000000000009d": "b158abf8e49c9fa6cf8103699f81039a82d085721e5cff677edec8c43bee073d", - "0x000000000000000000000000000000000000000000000000000000000000009e": "4c5f50016d24ab6a9b40d925d7b4be07d51679d2f5b12565958dfa80229031fa", - "0x000000000000000000000000000000000000000000000000000000000000009f": "dbbf71ab7420933453fd51ae3e6cdb95f05e1c25016e979fbe33deb794ea9ae2", - "0x00000000000000000000000000000000000000000000000000000000000000a0": "e2e850cb3176df3accc03247b8e9cdb15261ac3021c4911839aad275fe2a42ef", - "0x00000000000000000000000000000000000000000000000000000000000000a1": "5fd45fdf3f74bde3842258b46aec022feec7f5148302447a63b6e480d4444330", - "0x00000000000000000000000000000000000000000000000000000000000000a2": "639a8f45c9f9219f27cf4db4c33de2d346df8a09dcc770ac6044f60184330864", - "0x00000000000000000000000000000000000000000000000000000000000000a3": "45941317b4ff496cb5e8832d48f69c5f1d611cf609bf3d2933dba68dae211c49", - "0x00000000000000000000000000000000000000000000000000000000000000a4": "471066471af127a34b62c9f34c3fbfb26ba29d233f81d568f4d120d35d50ceaa", - "0x00000000000000000000000000000000000000000000000000000000000000a5": "e89e5d3756805d8458b5057f19b7d97faa7fa2351b2a08ddd75405c00af3a8c6", - "0x00000000000000000000000000000000000000000000000000000000000000a6": "8052bf3205c8803a64bb4cc52c4e86516db9734d9bf0ff47349a337e9bbe10e0", - "0x00000000000000000000000000000000000000000000000000000000000000a7": "dcf632311be8dfd6de736c05b4ae66e2aea72f7825fb23294bb8ccfeb218f486", - "0x00000000000000000000000000000000000000000000000000000000000000a8": "f4d88732713252e8ab1932ca55135b3819ef47a73a05002a338e5aa5617e7d9d", - "0x00000000000000000000000000000000000000000000000000000000000000a9": "5f5f3976768eaf850e525d41f05497af4731aa637d2b323dbc69154553943c50", - "0x00000000000000000000000000000000000000000000000000000000000000aa": "c1a9ccd5f651aa46a26433e521d6e7c4fcc6714f8fb9068ee4f1e0a8d043da0d", - "0x00000000000000000000000000000000000000000000000000000000000000ab": "9fb16206a35f8b4b9d8c30570c7010b5bc6a4149b5aa2ce42da9d60c92b5ea1d", - "0x00000000000000000000000000000000000000000000000000000000000000ac": "4d980e42bd8ab35744bf9b5aa58fbc8b71efd85b839b90e2e50584246a3831f8", - "0x00000000000000000000000000000000000000000000000000000000000000ad": "c9f402d074ac593ae2f09a8bb846b9e46963c305a8c33690c08ca0c8e0ac719f", - "0x00000000000000000000000000000000000000000000000000000000000000ae": "7c6e0e3b4dfc0728d41f7d5729a60d53758cafbab878bca3beed01bdc5ae9c56", - "0x00000000000000000000000000000000000000000000000000000000000000af": "36daac85c3d71809d96b04586cf5c50594ae2cafa74b9734491f6fb31b85142c", - "0x00000000000000000000000000000000000000000000000000000000000000b0": "edd306e502f0e098d70102017c0f33272d5934bbf766ef1c5ece71713d4f59c2", - "0x00000000000000000000000000000000000000000000000000000000000000b1": "1fdd1686c4e06bf2baf2287347ed95a45855aa4b546244e83e7aea4c6dd56a72", - "0x00000000000000000000000000000000000000000000000000000000000000b2": "a69441f08a1bef357d6f34fb74e4eeeaff0feb787f61e10879faf72609aeae24", - "0x00000000000000000000000000000000000000000000000000000000000000b3": "c37e2ca4253945c00e611fd26819875ef83d98dc20bb326a8e4ebbd804613214", - "0x00000000000000000000000000000000000000000000000000000000000000b4": "8564835e8d24f3fd01643847625fac3fa7bb13ba829c1a5ad7efd6ceda4f5bed", - "0x00000000000000000000000000000000000000000000000000000000000000b5": "c64398436144bb3196587e5ee9267e878400c5616f97cf97fd0921bae181bad4", - "0x00000000000000000000000000000000000000000000000000000000000000b6": "12d4a656b5b4d8d9c55515a7698a254fa74a397390a57167f785a2d3602539a6", - "0x00000000000000000000000000000000000000000000000000000000000000b7": "c858dea4bf702c29161d33ba7c02bfb4977169668843521b0df693d5eebcf5a3", - "0x00000000000000000000000000000000000000000000000000000000000000b8": "347ad864a477308c79cb4f766e8a6b62f4ece0a981cdfe49987e542acd89b5ac", - "0x00000000000000000000000000000000000000000000000000000000000000b9": "ac0c873a3d9942f92427ae37009ee280b326788fa803baba4dbbcc31736ff2ff", - "0x00000000000000000000000000000000000000000000000000000000000000ba": "5f67af973e604193cdcd68a80dea8ff0622ee1341330c1b8601502020617c2cd", - "0x00000000000000000000000000000000000000000000000000000000000000bb": "493bf6336f7b638f36a29952c86afbb58526152b62be20eb6433bee0474d62a8", - "0x00000000000000000000000000000000000000000000000000000000000000bc": "2febc2674bc628df6cde532fe9c598bfca92240c5f240d189aa372425c24487a", - "0x00000000000000000000000000000000000000000000000000000000000000bd": "341223f936840f7f6a33fd74e14e5ebe4300b215cfadf77a8f6e88bfed017dad", - "0x00000000000000000000000000000000000000000000000000000000000000be": "fcacae1b8715635bf3bbb10a375c44c799c2a882cab116306400381ff62e71f2", - "0x00000000000000000000000000000000000000000000000000000000000000bf": "ddb665db1612487f7e1e333fbb5f607b93bcfc618983de7dd61d76dac6f3d948", - "0x00000000000000000000000000000000000000000000000000000000000000c0": "cdeb0c3a06240f7f742c497bb142ac2477df943a878f8296b911b9f1169c1e46", - "0x00000000000000000000000000000000000000000000000000000000000000c1": "24b14515d27271ed944fd78cdea5855bbedf6cd84d65f925f8f06a426f7b1e4b", - "0x00000000000000000000000000000000000000000000000000000000000000c2": "d5f960e48e2767108920eba4e8e326c9fc3233c3a2fa349770f04debccc14826", - "0x00000000000000000000000000000000000000000000000000000000000000c3": "cbfad2a8bdfe5205c485383414e29d8e0a9c8b10812151d25bb51a74c95549a2", - "0x00000000000000000000000000000000000000000000000000000000000000c4": "078aa96db2936406a8d1d69a59f72bd60a908cbde5d2abb12166b41ff714977b", - "0x00000000000000000000000000000000000000000000000000000000000000c5": "c03fc9d4b6d49d1599717fbf75a9ad47496efb1ec6fafaa5b4bee2afae9bee30", - "0x00000000000000000000000000000000000000000000000000000000000000c6": "0fa887a20612f7ab9a00abfeb074c01ae4b509b4859c48c2e24abf27b7d7fed3", - "0x00000000000000000000000000000000000000000000000000000000000000c7": "bdc33ca00ea1641cf1ca2816913824999b73d47a92e7d5303c4104035ae78725", - "0x00000000000000000000000000000000000000000000000000000000000000c8": "44aa9401e0d5848c03c53c87cb883698f3a346340416803b666fce0eb7912595", - "0x00000000000000000000000000000000000000000000000000000000000000c9": "abf8b8c18e738be05befb8682083d8212b57c009c599b65535c4a7f47930bfa8", - "0x00000000000000000000000000000000000000000000000000000000000000ca": "c61c8872972b975d28191544f7200c3f3684a9e152c87f626b6c85aa56af4a22", - "0x00000000000000000000000000000000000000000000000000000000000000cb": "1e7e2004a340707d31625b7ac9ea03d7add6dddfa7c32922e6222147b86aa4b6", - "0x00000000000000000000000000000000000000000000000000000000000000cc": "13676db30bae04c5f3b7f190e44e72d1c1b1299567e9e3757603554f30ff45f5", - "0x00000000000000000000000000000000000000000000000000000000000000cd": "20836fb907f186aefcdcb5764e3d7c48fcd1b16bc98b967edd65b354e68a3e79", - "0x00000000000000000000000000000000000000000000000000000000000000ce": "5936f662e12c0f1b392611803d3cddbe33bb2d7605769956e334c560b372537a", - "0x00000000000000000000000000000000000000000000000000000000000000cf": "fa49b5f47466644348d75c491db8ff92813c96fb5b3f4a4deaa02bc92e3e134d", - "0x00000000000000000000000000000000000000000000000000000000000000d0": "6cedc591e85ed32d70655274734b636e3482105a5e9d416e62ef1dda2ddd4a9d", - "0x00000000000000000000000000000000000000000000000000000000000000d1": "53bfe21b477b2780bf2e1aa15b19710aa9bb5100cd7bb69c8cc3a881ae50ab54", - "0x00000000000000000000000000000000000000000000000000000000000000d2": "4c30c648a319319788200f7273f6de74e321f1796b01a2988f98840a11e307f1", - "0x00000000000000000000000000000000000000000000000000000000000000d3": "f490758a0266199a571a859efe170beefeb78de97d3a20328ac3d4bf07240fdb", - "0x00000000000000000000000000000000000000000000000000000000000000d4": "0a1e9c1d1ad91f4d574599fe8247974beb2ab68c78b43cdda303870ede057f49", - "0x00000000000000000000000000000000000000000000000000000000000000d5": "d89a67d59bfca6ef7942ef28cb121005dfd9c18b404a8dfb95e7c4d1b405a87e", - "0x00000000000000000000000000000000000000000000000000000000000000d6": "44e4a64750e4c9f6511df524c16e9cb23554a89325cf503b74f8f25f16253cec", - "0x00000000000000000000000000000000000000000000000000000000000000d7": "9a379148fa0512b767d90e2a9a20248c6c19441d7f9284b00f802de8d40c5404", - "0x00000000000000000000000000000000000000000000000000000000000000d8": "96ce02bc5a0630bbf7d4c1340ff68ba3cbc53a401d8ced01339937d2d764980e", - "0x00000000000000000000000000000000000000000000000000000000000000d9": "41eea349b7529f1465e872f4eeb3958da339bd18193b9055d1f77649b5b5a8b1", - "0x00000000000000000000000000000000000000000000000000000000000000da": "ecdbfed50e09e8bea9b23b0c056b9ef72bd724fd104590fdccfed99e26401a78", - "0x00000000000000000000000000000000000000000000000000000000000000db": "fa439516704748050ea45b059aad351048e40ae85f495fd0ec4e77c34a02325f", - "0x00000000000000000000000000000000000000000000000000000000000000dc": "8967b48c91a9a3ac039752dc1b0b5c091e38b28635f934949604b9ad0e2017e9", - "0x00000000000000000000000000000000000000000000000000000000000000dd": "4a6fe8bfb3d8209f060b20fd83362433e87e45b6059450ecd92207e5bb4bbdad", - "0x00000000000000000000000000000000000000000000000000000000000000de": "58f4f818948eb949af6ebbe9c9922a6742c45eb6c60cc272027488d0d0fb8207", - "0x00000000000000000000000000000000000000000000000000000000000000df": "75150cd02c717d33df03986668fca9287fa715ae9b3dc786e9a012689cbb4f2b", - "0x00000000000000000000000000000000000000000000000000000000000000e0": "4b087119094ef790b1981596fe9adfed930802ffbf33a9b5f91cf06b36aac5cf", - "0x00000000000000000000000000000000000000000000000000000000000000e1": "f7c7c5456af3ba05c94cd1d23c70ac90ea4b79b78e561045c649b08bfdaae321", - "0x00000000000000000000000000000000000000000000000000000000000000e2": "918ae7ac657fc84fc8cb10dcb3794f22ee74635bc3c48a09447f82525c8b4cff", - "0x00000000000000000000000000000000000000000000000000000000000000e3": "b77cf24f0c1fb354f7bf7c80e1804fdc2328774a1af50eb7959a46a8fe51a590", - "0x00000000000000000000000000000000000000000000000000000000000000e4": "b3317abdbcc0bdc256a422a5c333572f99ff8651f095922cdd5b995b44185a49", - "0x00000000000000000000000000000000000000000000000000000000000000e5": "3958180bd85edf4b17cf80881d40b68216a23a2dbadb92fff52757661070ec35", - "0x00000000000000000000000000000000000000000000000000000000000000e6": "b1503e5b89008f2ec7cf91492da840a6786f020d11cd33a8ebfd68ee824313ea", - "0x00000000000000000000000000000000000000000000000000000000000000e7": "74b7c334b7e246ba4cbdb9a91cf69bf72a3491ca4e39c2cda81e39c080bbe720", - "0x00000000000000000000000000000000000000000000000000000000000000e8": "5e06576f385d64e5475da19a55db8a1b49a905e54cdd00bc833f9a6e0d1821de", - "0x00000000000000000000000000000000000000000000000000000000000000e9": "cdf017d14aa10cc174c1f3f7d597eb085f52da7793e92fd8f84f0032009962df", - "0x00000000000000000000000000000000000000000000000000000000000000ea": "d85b3616680a40d04d64e6ee0d1b0dfbf1967634ca82b0a38be88513a556fce6", - "0x00000000000000000000000000000000000000000000000000000000000000eb": "aeb7dd5da8baa32aeb4a33f9d87914815fa0c941f5bc08e595d4e37bfdae7025", - "0x00000000000000000000000000000000000000000000000000000000000000ec": "d522a23cf0118178de9b0c94528f7161fa5f0e0c954ff141d86f7335fbed4276", - "0x00000000000000000000000000000000000000000000000000000000000000ed": "c24d834bba0307acaf2621819d979f535f972358a557d008cdd4374d6d7279e4", - "0x00000000000000000000000000000000000000000000000000000000000000ee": "bc7ccdf6cbccc29bfcb63055c8f06b26648f3b719434b29a74a477466fefaa5e", - "0x00000000000000000000000000000000000000000000000000000000000000ef": "84f81fe1c154c744c26786ae33b6ace4bc6e4e9318fd57b03a61e9d18ca64711", - "0x00000000000000000000000000000000000000000000000000000000000000f0": "ca2b42e197de583b704164d6db489ec43fe7394d38dd8a5752be70f52854ca58", - "0x00000000000000000000000000000000000000000000000000000000000000f1": "a09abb195168c21894826ccd65fa0c8549eb923a5b399c62cf9fd1011c465b69", - "0x00000000000000000000000000000000000000000000000000000000000000f2": "b4020e4b07dcf86bae80b8743a2ea666f6f3d45a5df2284109c25d7f51609ec5", - "0x00000000000000000000000000000000000000000000000000000000000000f3": "787fcaaf148ba19e63da9cd7d513303b2e8565baf64c4c28680996276e57c93c", - "0x00000000000000000000000000000000000000000000000000000000000000f4": "9d81061f02d7bf9a3a57e1b2b291bbe6100fdd34168fcc324a3e4c360168a058", - "0x00000000000000000000000000000000000000000000000000000000000000f5": "111ebb07018c6d7bf8df23b0454405dd991d7f8407d7c14f8bb86a0bd78032ac", - "0x00000000000000000000000000000000000000000000000000000000000000f6": "f0fff4c5758d8f5bc9e659c933b0267500c3dcd25916df0c0cd11f51a80057e4", - "0x00000000000000000000000000000000000000000000000000000000000000f7": "4063e7bd93501354cbef2184f7139559650a22eeca85d60bd62f4a468f2bd22c", - "0x00000000000000000000000000000000000000000000000000000000000000f8": "161049c951eaacfafd5b046be03ee813c9a9a6d3167fe4591f75673f0ff5097a", - "0x00000000000000000000000000000000000000000000000000000000000000f9": "f10eb78649d3c7dccd8a00576e460bed3eedf5e1e9b94e96cd2cdcf11c4171e7", - "0x00000000000000000000000000000000000000000000000000000000000000fa": "9d9c2b94a73067a8ba8736b77b159187bad6ce53b4372d3d0d0aa534aae1d7bd", - "0x00000000000000000000000000000000000000000000000000000000000000fb": "a4b169ebb5479f117266df73694d46f704685c3d756d411dcb5fc0b15f500f47", - "0x00000000000000000000000000000000000000000000000000000000000000fc": "205a14b20d2c13f174859295063f88da3779c22b3cd8cf8d3718cf014f8c0af9", - "0x00000000000000000000000000000000000000000000000000000000000000fd": "68ee7090901b0083e417d17e1e9eb637b50146077b32d5f3b63568a738220c98", - "0x00000000000000000000000000000000000000000000000000000000000000fe": "1d4e0daba7e6bdc87c5ecff530bca645bbe36a6a538e27b956c9c106607d982e", - "0x00000000000000000000000000000000000000000000000000000000000000ff": "adf3ad66db1c5384657a2b75a1753887c646c629bd10a8a50d15097b79c14cbc", - "0x0000000000000000000000000000000000000000000000000000000000000100": "9ae54ebf672230a7e3ae4ef423aacf24189f52e240c1356817cb32d767618063", - "0x0000000000000000000000000000000000000000000000000000000000000101": "ed093194e152b98e10d55a8db6403780d17346e9eff9c511712725e08c422381", - "0x0000000000000000000000000000000000000000000000000000000000000102": "cd35112597db3095f6c10b644aee930651c44a03d8c168581d8aff8d26050491", - "0x0000000000000000000000000000000000000000000000000000000000000103": "46728f520936c769482557b2d4d05386f030a3d9c03cca9d123940d3d3fc97be", - "0x0000000000000000000000000000000000000000000000000000000000000104": "65989a6ce9bd74150837c8f8feea080d86236e1706b2b1d9bb42ae329a212110", - "0x0000000000000000000000000000000000000000000000000000000000000105": "1244e39eddc59b8d38c3c9e609867b149bb1222e3087fcde4e60d1785f9ca6fb", - "0x0000000000000000000000000000000000000000000000000000000000000106": "9b11fa343fc18df51ad37fa94c9d6c17916786bbbab8bc10e3a3d1c0580e0b2f", - "0x0000000000000000000000000000000000000000000000000000000000000107": "6bd2bb001303e7dfb428c75ea4bd6dd7115d6ff61add2924cb23a0115c920884", - "0x0000000000000000000000000000000000000000000000000000000000000108": "db94bbffb05461e4f8a83c827cb5b0cc8e54ce71af9f4b57fd712c7bf245a67e", - "0x0000000000000000000000000000000000000000000000000000000000000109": "669d2fdcd20848e3f746c76753dac2763d798d43492e58e75eec82ef4fb156b3", - "0x000000000000000000000000000000000000000000000000000000000000010a": "8bc68b8a166d2b68a73be23ea20193dccd82a3bfedac661f969bdc32fcd454a4", - "0x000000000000000000000000000000000000000000000000000000000000010b": "f8160bbab91163c4b7120ab3c60606cc47ba1ec0e765daf1d68ca0dcf52d2787", - "0x000000000000000000000000000000000000000000000000000000000000010c": "3f4cebd4ebd414ba3710ad5eabfefa06fc5f007c62ef0900e07c263e1923889f", - "0x000000000000000000000000000000000000000000000000000000000000010d": "51a4821b633b80775e02a85aafd3a58ed2796e158c03aea46004e25ca138eaa1", - "0x000000000000000000000000000000000000000000000000000000000000010e": "6904e188fffed4cc41632df32452ec9bd4cafdee6f5d76c36e1b2efd33ad9079", - "0x000000000000000000000000000000000000000000000000000000000000010f": "f6354df3badf86b25e2f88f4630610c9c756a76eab5489bf84dc4b5faa5dfcad", - "0x0000000000000000000000000000000000000000000000000000000000000110": "a3f857458c4f8e850d17825dd663d51219737a227a157cb9f3eb21a7dabf3c12", - "0x0000000000000000000000000000000000000000000000000000000000000111": "a9e96ee23c11f8d5762340e128d2280d87ee788885951468baa9a384665b95f7", - "0x0000000000000000000000000000000000000000000000000000000000000112": "443c32584ab5e94cf1393eba7de764dcbf40a903572c0b1737a2198537886269", - "0x0000000000000000000000000000000000000000000000000000000000000113": "1910146905689fbbc61f374a7bde5325be084f307a5617b7bdb319691d7cbe7e", - "0x0000000000000000000000000000000000000000000000000000000000000114": "5d602bc5189b5a955faeb7842825c53c4cd335c0cac7756599e3a7d7a9b1e604", - "0x0000000000000000000000000000000000000000000000000000000000000115": "7cdd5d09a0af5e26bad74166fd6a4324185ee337b005e5df5f4f67f00155cce9", - "0x0000000000000000000000000000000000000000000000000000000000000116": "da06797d4ea9e2d242a7f1d77163e4cd0d18aa7e9ae04a2357c7a359c3a7897b", - "0x0000000000000000000000000000000000000000000000000000000000000117": "69c23b6cef19f994ec1120ebe41647daae8fc602ceeccb500bef3599ea8dc4d6", - "0x0000000000000000000000000000000000000000000000000000000000000118": "1be678ea3efa6308b7fb5b3102651a8493462715c6b09f6cd9697efd05fc7d0e", - "0x0000000000000000000000000000000000000000000000000000000000000119": "f776a4d1d5c352151872b684cb240fb3b7d163b655fd5939337a070a7c896d7a", - "0x000000000000000000000000000000000000000000000000000000000000011a": "9dc4808f611d1b29c89fe57085c64ec7815675f779d602734d45848babdaa5ce", - "0x000000000000000000000000000000000000000000000000000000000000011b": "e015df4bb2e84589a3bf64fa91b73091581910b42e0ee91f1d6cf25912d60027", - "0x000000000000000000000000000000000000000000000000000000000000011c": "9f3faf24dbf97542f5dcac91d35da491af51e24504e58f42c328ba2758b0b268", - "0x000000000000000000000000000000000000000000000000000000000000011d": "594c9091455bd0cd08631909cab257feeae3a05401a43544e423c759be125f77", - "0x000000000000000000000000000000000000000000000000000000000000011e": "1f1d279ca073fab2be1f425ff8c09696653b77632516524baee6171427d75532", - "0x000000000000000000000000000000000000000000000000000000000000011f": "c48ec13e43df85d25ae98c82d9ef4c2d1d09195aec3de87dd7b36f9cb530e234", - "0x0000000000000000000000000000000000000000000000000000000000000120": "082ba48558d19f6911b12db3e969c8f770871c5836cbd2a02d6686624c744c88", - "0x0000000000000000000000000000000000000000000000000000000000000121": "1e9ef85d67a81bd278cb21a68a068060358717f518aa9a31059b0ea52e9470f5", - "0x0000000000000000000000000000000000000000000000000000000000000122": "92ccd6105a6a3d6636516fc3de3d1d5b83476e27c6c15f0d1f0a4ac3cdb77f96", - "0x0000000000000000000000000000000000000000000000000000000000000123": "59eb05ad455dd8785b7a82a8ec0b14908b49b9b99b89438e48a64f2c35dbec5f", - "0x0000000000000000000000000000000000000000000000000000000000000124": "8aff95cd5730ce6970eca865968ba524b1e66c7688319793c6edaa11791b0a33", - "0x0000000000000000000000000000000000000000000000000000000000000125": "e9652de769d861b7ae1ff71d6086d0049ff01ee57126e7b37f8acb1009efdcb7", - "0x0000000000000000000000000000000000000000000000000000000000000126": "62defc14b1b4b19b963574f0ddbe0b887a8017d28661a9d889c55729a388a40b", - "0x0000000000000000000000000000000000000000000000000000000000000127": "98539ac0cea39c8cc5774cb783fa5993c03ab9e2dcc9e2e24ac18d9af67dacb6", - "0x0000000000000000000000000000000000000000000000000000000000000128": "84018a2df44823700329319d9aff27b73093f4284a45402e4a40958dde3ef298", - "0x0000000000000000000000000000000000000000000000000000000000000129": "e2c8b858ba858e6c7b73dbc23702f10a9a75117fbeaa447084be91921cfbe7f5", - "0x000000000000000000000000000000000000000000000000000000000000012a": "0a1092b8900b3db78271854ecef3b6b400f1fec980047d9ff07a130255a910f2", - "0x000000000000000000000000000000000000000000000000000000000000012b": "a1e26afee8565c8352f0dcc623e984f72d24e09e005aba99f916fdb7c3807ab7", - "0x000000000000000000000000000000000000000000000000000000000000012c": "dba21acb5043d419d3e972fad568d8e6179cffb0654e73c7f093a48877f38e9c", - "0x000000000000000000000000000000000000000000000000000000000000012d": "4d7b2d7c56da60a9b57c4210cdedba40311978ea1aebf519aac65867e16f6a3e", - "0x000000000000000000000000000000000000000000000000000000000000012e": "5ee998d96985103ae9e6f31a41ee0d44a4da62003a63b5ff4f29570aa42ddee4", - "0x000000000000000000000000000000000000000000000000000000000000012f": "81db24e85960807d0f347bacc0364a9327e64955fecca02ab5fcc55efdc4a37f", - "0x0000000000000000000000000000000000000000000000000000000000000130": "9cbca6aa8b06935a740ab85580674c5cd4b2a840d078c92e005294241a7eac81", - "0x0000000000000000000000000000000000000000000000000000000000000131": "5121438babb00581bb8862b84bfedfa4d586d59b08f7de67cad8988693061458", - "0x0000000000000000000000000000000000000000000000000000000000000132": "2c00478ccf60b7813adf88eae40d7f36cb2bb19d7d3a5e41904411d59f85b85a", - "0x0000000000000000000000000000000000000000000000000000000000000133": "bd2d25d7773172160974f1a8b6b790c629e44a011321c53a0cb08888b9cac459", - "0x0000000000000000000000000000000000000000000000000000000000000134": "a8a4ee8234dac48e460f619c77d02008ff818db6cf1a0a80de6a81af3e0d7e91", - "0x0000000000000000000000000000000000000000000000000000000000000135": "11ddcb0efb438a2965ba558170ed3ccb27ac43bc3f7028628edcb3406a1d4623", - "0x0000000000000000000000000000000000000000000000000000000000000136": "ccff97103894795edef27f3a29b05a2109a4f024d3c935233faff6be394b92f7", - "0x0000000000000000000000000000000000000000000000000000000000000137": "aac581c002035b4c80879f87a1418a3129921f493472482a52b09d0fb6233f04", - "0x0000000000000000000000000000000000000000000000000000000000000138": "7e3909c2f8ede6f928c0820363dbd9abb712eec9f7be844bfcf8d3d04a538bfe", - "0x0000000000000000000000000000000000000000000000000000000000000139": "bd1f3e51c77a927fc30973f8452ada7e030b8452273afd75dff18884af8a204c", - "0x000000000000000000000000000000000000000000000000000000000000013a": "f976366428e1f9e79b69a03a333c3ea2d57804cafad16ea0301def95480afa16", - "0x000000000000000000000000000000000000000000000000000000000000013b": "3752f226d6f4f227e0d59f153fcdefff90cc3aa9566c14b02bf86a5ba7e5f740", - "0x000000000000000000000000000000000000000000000000000000000000013c": "bd34ef105826797a46b3ccc8b4a82c61897bce87047aa90ca88d590887dcef52", - "0x000000000000000000000000000000000000000000000000000000000000013d": "a2689bec112dc66781dfbbfe0877f3b56c055872e331b6d45acd6e8d97e046e6", - "0x000000000000000000000000000000000000000000000000000000000000013e": "3f028560d99874cc15a76dd76b7da32cdb9548a9e262b5c986bc62ae920e643a", - "0x000000000000000000000000000000000000000000000000000000000000013f": "a0755b0908be2efd8534b105a279c0045087852b3c412f2d3a888988e4fa475c", - "0x0000000000000000000000000000000000000000000000000000000000000140": "dc88273a8339355e4c23b544329f1564ff0f17cda095b1ec2dff43d3dd0e39ed", - "0x0000000000000000000000000000000000000000000000000000000000000141": "ea4108c88374dcffd042b2fd53de46cc82aa3a0c1573c6228198529dd90ad350", - "0x0000000000000000000000000000000000000000000000000000000000000142": "89aa4d141def4c923b06aed9552126683bfb54e96f310d8fbc98bdef21e3b319", - "0x0000000000000000000000000000000000000000000000000000000000000143": "5e09d28a6f9e43be4a5f908f764b9c25db1fcb323d9af4d54a9a486721b6b766", - "0x0000000000000000000000000000000000000000000000000000000000000144": "a8e614e1553ea89015d1c2d2d90ef31794bacd4f661a9b8ca0e8f57cb8358a99", - "0x0000000000000000000000000000000000000000000000000000000000000145": "772516ae20b52f5521b3a703dd4fcecd98f348fa2f0523f85aa4b801d46b8a2d", - "0x0000000000000000000000000000000000000000000000000000000000000146": "40137062068c2bef8766bb8df571f0e0c341f3877dc1d7311c84177331165a5a", - "0x0000000000000000000000000000000000000000000000000000000000000147": "c10d42ae21c805f56d5f486087ab29e6c5f16d2743dceea53e68b4c4ec8c41de", - "0x0000000000000000000000000000000000000000000000000000000000000148": "f37ed9b3c15bebe2c65743e7013c97fa8b75f97e8791a353c033c16171a82fe8", - "0x0000000000000000000000000000000000000000000000000000000000000149": "8271d4efd4a54b038c0cc02e2a437d7cc3d96aed9148763fb2825fcc1ca58a1c", - "0x000000000000000000000000000000000000000000000000000000000000014a": "a9505142d5e8f2f3585f3d753c6cc615395b9694739c2aaebfdfbd52ea22d378", - "0x000000000000000000000000000000000000000000000000000000000000014b": "4d6b8d46d03208985e99ee7ca9d38e3ff54871672663c6a1cb4d8a558fe8b5fc", - "0x000000000000000000000000000000000000000000000000000000000000014c": "317d6cd8a8783099c05585ff4132c92fa56746ac04dc89d01f90a6087d95e3fa", - "0x000000000000000000000000000000000000000000000000000000000000014d": "1aa7fbd954a82016be127f3624a93bda8d45351191031f3671060abf2fbc7140", - "0x000000000000000000000000000000000000000000000000000000000000014e": "f0a0f1e9079642d9be82b1a2c786bf1c89f4e0bec03cbd6c1be96b92c47cbeeb", - "0x000000000000000000000000000000000000000000000000000000000000014f": "286ee500a7ccd24305014fc9ed773b472aa0e9de2005f98b0136bbba193e89f9", - "0x0000000000000000000000000000000000000000000000000000000000000150": "2f60754b89d3acfa2cd8e479e2b94e90c07bc5ca92f5e49b3d0280a30775893c", - "0x0000000000000000000000000000000000000000000000000000000000000151": "1d2172c03aa39bcb2ff80dc3a80b157ee311f01f1972c3ae61df2fbc08581df1", - "0x0000000000000000000000000000000000000000000000000000000000000152": "b5038ea078e022c5f7c97429a3f36c5b15ef525012266a78784315d5f5f8f742", - "0x0000000000000000000000000000000000000000000000000000000000000153": "b63287f903b3d2cd28cec281f1de235c85ed05ba3857e28cc86f9c29f39d57da", - "0x0000000000000000000000000000000000000000000000000000000000000154": "9c476efe697f7d3482e8a3a620811c6dc88ed3b98cdc752a53bb756d13a6dcb5", - "0x0000000000000000000000000000000000000000000000000000000000000155": "de9ba0e426dbd981f0ea6eb968d6f3a725b664f175d245e6e9e2478ff44afb72", - "0x0000000000000000000000000000000000000000000000000000000000000156": "36e28ee4cdd767038d87e898e8b59f777b31454f9960e87ab3fc258223c5b212", - "0x0000000000000000000000000000000000000000000000000000000000000157": "2955e6adbcf58ce3f34fc93da829c9c44a6641382ff92336f8cdedd1734669bd", - "0x0000000000000000000000000000000000000000000000000000000000000158": "4ef098ab7baa897a6c538545fe29382fbc85c59ac78a01b5428a0db58bb5bfca", - "0x0000000000000000000000000000000000000000000000000000000000000159": "ee27e318aea1e83eb7b252d701fc255f8a295bc048819b674977db2140507eaf", - "0x000000000000000000000000000000000000000000000000000000000000015a": "99c16f02cab4384eae354d510b84f49fb3cc77ac1a2deeaa87c7342894ce256b", - "0x000000000000000000000000000000000000000000000000000000000000015b": "38c75f8d455709c7dbb8ac586e04a2579d9e7d28a4d33a460588b70612a882e8", - "0x000000000000000000000000000000000000000000000000000000000000015c": "346083b60f44fd307e10d7e0f67b5da3d1230332adf26749cb5c80d00003300b", - "0x000000000000000000000000000000000000000000000000000000000000015d": "def08200cf595f64a706819f16a1c39b7409cbbc14fc29a87b50c95a3f9e0464", - "0x000000000000000000000000000000000000000000000000000000000000015e": "701b50b242d6e6062020d66c4134f678c49fc7887ba1f962f97863b7648626f2", - "0x000000000000000000000000000000000000000000000000000000000000015f": "3265fc38a6c5684461c72e9c03fe1ddd99a53cddb2d371d0fc1188a130d76e79", - "0x0000000000000000000000000000000000000000000000000000000000000160": "84bf2031465aeaaa042fc5f12c7cf61ce1cdb3225525bf961b115bffb477ba2d", - "0x0000000000000000000000000000000000000000000000000000000000000161": "95d03fc9c7ab7b1f91a38325076295ba7251541246ff6929d4c3b4d7af875705", - "0x0000000000000000000000000000000000000000000000000000000000000162": "d7e39656fea33b079d0fffa85665bda655e35ac8cd609b24db52fc10dd22030b", - "0x0000000000000000000000000000000000000000000000000000000000000163": "56f28aefa9c8a192e22bfd3ba9946ca3b8d1e96897d3599f8f7ce0af473662b6", - "0x0000000000000000000000000000000000000000000000000000000000000164": "a256e8a74e0d5f0db511d6df3d329492b15504f515278ff998d108a49902a8d6", - "0x0000000000000000000000000000000000000000000000000000000000000165": "fda145c2f89e067fcb82e98c5a201fb8f9949d578a1b87241e6f7c103fbda5d4", - "0x0000000000000000000000000000000000000000000000000000000000000166": "c60a413c6267e5f34ee8e27efcb89e2bbcdd4b839cb0c961f7dd37805181626f", - "0x0000000000000000000000000000000000000000000000000000000000000167": "9267c3d2e49d9a2fbb84a69db614d9fb33bae938ee4bd0fadcf5cc033562bd8c", - "0x0000000000000000000000000000000000000000000000000000000000000168": "f66d68a2b0dd9fbc45a5646cebcb99e8af641c8a372724264058493e141eaa46", - "0x0000000000000000000000000000000000000000000000000000000000000169": "cafa23b21dd847e0a6863e2d6a9e81749d2ae6174e340bf3ed6c27e030ed38fe", - "0x000000000000000000000000000000000000000000000000000000000000016a": "d6aca4fd2acf5ca563efa815897afcfaa175b8955931f699ae4018ac86eeea91", - "0x000000000000000000000000000000000000000000000000000000000000016b": "16b4cebad9f39a7db380791451d3a9dd9c35dbadc751254c41f94cae8280358e", - "0x000000000000000000000000000000000000000000000000000000000000016c": "505a6bf5ab0f40712af88078826c83c152e5ec99fd74ae718e47c0f1b6c7c0fb", - "0x000000000000000000000000000000000000000000000000000000000000016d": "0f15f04e28de513a6e468d22860d94e5389a07b5b630f8a8e7b84ed7bc0b8558", - "0x000000000000000000000000000000000000000000000000000000000000016e": "7371118bf9383f5e8b92bbb6cc9aaff94c06477228cde2abfffc48cabafc1bec", - "0x000000000000000000000000000000000000000000000000000000000000016f": "77d7c2eb0af7749896c1be40161508d650c019a8fdfdabab4b34b47f0caa5a80", - "0x0000000000000000000000000000000000000000000000000000000000000170": "c3c6a43b0a9fec6d3e9c232cd9048eb4b655f8c779ff7c510195e75d4c3cb3dc", - "0x0000000000000000000000000000000000000000000000000000000000000171": "024a6e084b404338002e6dd8b70331a3ad6d896cdedecd23db0c7db0cca13ea7", - "0x0000000000000000000000000000000000000000000000000000000000000172": "4ac493337944aac392f8ec72d0187775a98712347f2d3a8ce5e6dfade5fc88e1", - "0x0000000000000000000000000000000000000000000000000000000000000173": "53f13c2ada283dad19b4c6e1f5d01844ecdfce9b5e5cc064e025aafaa95c97fc", - "0x0000000000000000000000000000000000000000000000000000000000000174": "5aebb1a84a124ace93a6955bad2c1d3e26769ad5c4c8f7952bca62ffa6ecbb72", - "0x0000000000000000000000000000000000000000000000000000000000000175": "722cb497906813e0dac64a5e558aebc697f65a0929bdc4c9b763507b37d17442", - "0x0000000000000000000000000000000000000000000000000000000000000176": "86eef2cdfc7f44f813f99a5699adb200ac3e48a490a1e01656f2991f1655f387", - "0x0000000000000000000000000000000000000000000000000000000000000177": "f80b907a5268d198f59415e895a2dbd2d2f0ee499394f873bcaad64be35ba295", - "0x0000000000000000000000000000000000000000000000000000000000000178": "c4db6912f2653a9382b68bac827e5dd2eb40e3231f203a2f1f8eef0f72e6f02b", - "0x0000000000000000000000000000000000000000000000000000000000000179": "499ed1595f081f971a86fa5d465264ec4ebcf362ca75b566c64ed9e143779b92", - "0x000000000000000000000000000000000000000000000000000000000000017a": "b079707f805c9e021d3e353694af2c1295ff098e90f96b7e597f604df32d4f7d", - "0x000000000000000000000000000000000000000000000000000000000000017b": "07a887698ad470a92e0ea4b515f4e0c1eef4d02e005090f039ccad1f98dfa78e", - "0x000000000000000000000000000000000000000000000000000000000000017c": "37c51aeb36996d1204e1cc23f24fc8ce6a531230eac5fd95a0157afbae993408", - "0x000000000000000000000000000000000000000000000000000000000000017d": "fb7823c99d6a8cecf4576cccad394131869c27c19903241a4bac149e8a9df5cb", - "0x000000000000000000000000000000000000000000000000000000000000017e": "b43189b040f33d48780cb23517066fa7ef9be143f72926c776dd2a0deb74cdd8", - "0x000000000000000000000000000000000000000000000000000000000000017f": "36d98a00fa9cb5f2d23adaac16766bf86c534154016d362227b77a09e466ed03", - "0x0000000000000000000000000000000000000000000000000000000000000180": "864f50b8a89fc8049af6830206eeacfa26205d9ac2f1e9ef297c024532a57be4", - "0x0000000000000000000000000000000000000000000000000000000000000181": "a68dad1f5a2ca3fec7174293fb1eafeed1b3e1209dfc74ba1d4f67272530d1b9", - "0x0000000000000000000000000000000000000000000000000000000000000182": "b5d6be7351994263965ff5d6bec155497dfae4101d9fa6f7474f4346432cc94f", - "0x0000000000000000000000000000000000000000000000000000000000000183": "435041bdf7d03562f6cc28be67dd48e2a55cb6c36a8bde74217c78962fe35c04", - "0x0000000000000000000000000000000000000000000000000000000000000184": "74659e9bea0d8d39ee2966f14026731c00cfeac2addae8ab7440f3897752035a", - "0x0000000000000000000000000000000000000000000000000000000000000185": "8166e02057fbd66e2bdfdeb5e1b7348030fb8dcdf336c608186ecdf95a878d73", - "0x0000000000000000000000000000000000000000000000000000000000000186": "686342d6e14add1de361c209a4f097174472120c2649d4b1e3c0d69478c573a5", - "0x0000000000000000000000000000000000000000000000000000000000000187": "69ee2c164e201f10e82103b762fa299a98efcd3efb531d7f684cc93fe20877bc", - "0x0000000000000000000000000000000000000000000000000000000000000188": "977c2a14bc576911c691938eb8badf6a77843c4214b0613133fa356a23aa7f92", - "0x0000000000000000000000000000000000000000000000000000000000000189": "d9a295a0e39c94e3e9c9305b2e410aa89ee5380a8c343b901fc2ce60a19a431c", - "0x000000000000000000000000000000000000000000000000000000000000018a": "f2d8812d4f28578755d4229aef19bd2162c69cd9dbc684dd6a0b0b64c979bd73", - "0x000000000000000000000000000000000000000000000000000000000000018b": "c64105453f3f4a50ea7452760ca6066140fc6f2115e16065c397778756460d79", - "0x000000000000000000000000000000000000000000000000000000000000018c": "ff05bd7ed3a3f4e5abc2e5232c98d4343072bfd25121b241932703d33f875c0f", - "0x000000000000000000000000000000000000000000000000000000000000018d": "2fa9e1447264c03da65b930986c6c67078d887aa0b6252b49026c3bbc522ca59", - "0x000000000000000000000000000000000000000000000000000000000000018e": "10c9eb1115f231e7a50650aa52acc568532a80c7c1e0d695517fe4da1d493a8e", - "0x000000000000000000000000000000000000000000000000000000000000018f": "5abe00a7721db9dc1fbf458d49714c666ca2424e476099adfb77fd8dd54a0eab", - "0x0000000000000000000000000000000000000000000000000000000000000190": "ade4149b0375ad07777a88bf87a50426806e7e69c98719e63763ebf8585d39be", - "0x0000000000000000000000000000000000000000000000000000000000000191": "90544280b5a1c89044d0a9acf28015355e9f87f99cebb6e423a2429593805c3b", - "0x0000000000000000000000000000000000000000000000000000000000000192": "cbaec457a9bb83f627a46b321256873866c0a5c079315e1294328fc71b7d8529", - "0x0000000000000000000000000000000000000000000000000000000000000193": "888127ccf7a04b3ab6dc54a687036e7464c30e3fd813a0f4ddc69094cf250b90", - "0x0000000000000000000000000000000000000000000000000000000000000194": "08d7f2f015c06dee88d707cbc050021fd38afd6a253d3382a783e92ab30f22c8", - "0x0000000000000000000000000000000000000000000000000000000000000195": "729c0e22346bb677499d2b9af1da34dfaf7653ace58567673fc6894cf8d56289", - "0x0000000000000000000000000000000000000000000000000000000000000196": "d60f9025487642346d1ff6fcb21558a0b719524dda4fb773e50254be6ea5cb70", - "0x0000000000000000000000000000000000000000000000000000000000000197": "c2f378a6349f5ff2413494603a2bf9bf387182e0d7b2e042e0aa9bdde16b44e6", - "0x0000000000000000000000000000000000000000000000000000000000000198": "2332603e1b89c41adb97428017bd2297310b5deeca32af3d79c88a23090d5aaf", - "0x0000000000000000000000000000000000000000000000000000000000000199": "0b88f4a3ea4fe334e0f85983fc3ed8f0e5031f76642df83e9ffddff65637cf43", - "0x000000000000000000000000000000000000000000000000000000000000019a": "d5359ec7c8dbda34bbb1391a68ee130ee2fd94cdd86f2e6683e4ca680ef2ee43", - "0x000000000000000000000000000000000000000000000000000000000000019b": "e068d60356aae28f3154fa8f886f0f0067a7b74b524601c2f623610d258cbebb", - "0x000000000000000000000000000000000000000000000000000000000000019c": "650b963d47bb9f9b86c29b9d9e52c219bb70525460c04812bd6da741c0e4f90e", - "0x000000000000000000000000000000000000000000000000000000000000019d": "a36c2bf72d713f99a25528fb03aa69429831432f179f6c7c406918b542f76ea5", - "0x000000000000000000000000000000000000000000000000000000000000019e": "3987af76d0a00951e4513199ee41aec1071161b52151ce66934cda577c4336c6", - "0x000000000000000000000000000000000000000000000000000000000000019f": "7158030722716ed4b3153861925682677908d60a72f68d54c31732380dda9939", - "0x00000000000000000000000000000000000000000000000000000000000001a0": "fe58c2367f07005a8773b7faee91e02dbafcb140bc800a5145ee2e31dcca251e", - "0x00000000000000000000000000000000000000000000000000000000000001a1": "e75e1fff4381bbf11eaa336b11a4a79a82f0a39a8afeda3673bc6b98bf091f92", - "0x00000000000000000000000000000000000000000000000000000000000001a2": "7de3c0bd5e846119edcd858e4d51f0c0153974ea077bce8048eb3e7d191c3c65", - "0x00000000000000000000000000000000000000000000000000000000000001a3": "c6053e841c2e4bc75e4e959e1b74a9387b351bb4919ae295314e834c5d94e6ed", - "0x00000000000000000000000000000000000000000000000000000000000001a4": "404b549fee0787cefdf4065cb76e3a0e66aab2ad8c6a318e9adfe0bc4a73b85d", - "0x00000000000000000000000000000000000000000000000000000000000001a5": "1ef7fa7c852474808b71df44ef25db220e3dbbb3fd5e18cbb7445b0546b2dbb7", - "0x00000000000000000000000000000000000000000000000000000000000001a6": "c5e3d5218b2e1a652c2f2d9613df0b5e389b8695c73562332f4c3381d59faddc", - "0x00000000000000000000000000000000000000000000000000000000000001a7": "3bddbb879a8d46f692289da30f77e1ba669940bd42a1279d275b94c24dcaf9e0", - "0x00000000000000000000000000000000000000000000000000000000000001a8": "5ddb9e58b0ef297a051097bc988e136b1749d9f3445561b6b14a692fad23b8da", - "0x00000000000000000000000000000000000000000000000000000000000001a9": "36be5e83ae2b1baebbb956bc7c44f540745e5a78a59f3ca2aa088fb994fc62c8", - "0x00000000000000000000000000000000000000000000000000000000000001aa": "cd0da9da1e9b992dbbc4e98d488adea3b884852750ac79bde2b2ea2265a65d9f", - "0x00000000000000000000000000000000000000000000000000000000000001ab": "a5a646fb42670f9bb6782713ff7b2cdb24cd4bb3323b0586c5e2c03d03221d30", - "0x00000000000000000000000000000000000000000000000000000000000001ac": "ec2df5da5678a7b5ea6e5606f84879096c1b455ff0c9fe35679c9436c77953fd", - "0x00000000000000000000000000000000000000000000000000000000000001ad": "3b1fcf135ef30081e41bfa1d41b0fff91843274d326b76a81723c7cbcf81c7a5", - "0x00000000000000000000000000000000000000000000000000000000000001ae": "76c48fbe8881579636df3e68fe55621e99026e7d9810b74ff9cdb7557873d056", - "0x00000000000000000000000000000000000000000000000000000000000001af": "b0915a68a1ecb0bcafe6d483d3fddd6a93249d963db6e9650695570b2d494448", - "0x00000000000000000000000000000000000000000000000000000000000001b0": "fdda715666ca9712626e528f4570ffb24d48cdcc62e14571241d1a2f61576c46", - "0x00000000000000000000000000000000000000000000000000000000000001b1": "91bab78100c2b6909b533e246d772659957330f8ddfcf194087a8fb67bdfb6f7", - "0x00000000000000000000000000000000000000000000000000000000000001b2": "ad585c5a49c5db92630ed7c7b67fc367f3405060a0bff9de9dd64b996505a66d", - "0x00000000000000000000000000000000000000000000000000000000000001b3": "b8b4a3064cf8c569375764e5323ef7a03667dab6ea562bedcf67aeca7ad55e44", - "0x00000000000000000000000000000000000000000000000000000000000001b4": "53611bef1500f1568f35390b80eb6baf31ffaf9d8a4d34aab3932e5adffcecb5", - "0x00000000000000000000000000000000000000000000000000000000000001b5": "dd0f743e193c79a4a3ac080b01ed2ed15d9321300c002d70d74fb4c9b44564fb", - "0x00000000000000000000000000000000000000000000000000000000000001b6": "cfffe2d9251de471b21928c131be8ecb1b332ec4a9ffc226e64f041820caec47", - "0x00000000000000000000000000000000000000000000000000000000000001b7": "758647ab7f0d8935064c2c38ef6a2a34457df9c78297c2d42376ce18051a4a56", - "0x00000000000000000000000000000000000000000000000000000000000001b8": "1431bfb93a91538f50aebe4b46add424df29fddb8a479eb51c44539f7425d9c2", - "0x00000000000000000000000000000000000000000000000000000000000001b9": "f2d3d4be2e09a5499d838936b169c6ccf83a1dc510305e54e1e181243480bdcc", - "0x00000000000000000000000000000000000000000000000000000000000001ba": "9b8c6ecde0c9f7d3096db113472984400265c16b8f423527046f7c9cacec1c0d", - "0x00000000000000000000000000000000000000000000000000000000000001bb": "045aa374dc38d101b3846713180df1f69828e97bd630e2264149777bb19ece35", - "0x00000000000000000000000000000000000000000000000000000000000001bc": "e316b409f1472bfb043c4be4e9654a37e2a898850d9bdc815cb9ca1a44b29118", - "0x00000000000000000000000000000000000000000000000000000000000001bd": "5cf2998fd231bdc16bd2c20b02d58af1f81d846a058464ac2e74f75a0485a33b", - "0x00000000000000000000000000000000000000000000000000000000000001be": "576518015f61ddc9e28fcf964fa2a13490057c8f8ab669ad82dd2e6bfa19879b", - "0x00000000000000000000000000000000000000000000000000000000000001bf": "21d1d59bcf21cac072a2803938f6fd69d922d1e47a8b7049d8818266bfc27951", - "0x00000000000000000000000000000000000000000000000000000000000001c0": "e4e0607f25a8dcac8a8f7758373f3bbc1bc35176e239966d35a57925684b82fe", - "0x00000000000000000000000000000000000000000000000000000000000001c1": "8b744a371a22b4986eeceb8ee0f512ca44affb56ecd495cea9e6c66a490e1f9b", - "0x00000000000000000000000000000000000000000000000000000000000001c2": "ca1d7f951d628dd35b23cac8c21070a5740d64bba614089170c895a0ec8f57ef", - "0x00000000000000000000000000000000000000000000000000000000000001c3": "410876f7d8880a998a060adf663027422ab139d54e12e973c1bb8342844cb351", - "0x00000000000000000000000000000000000000000000000000000000000001c4": "b30c453a9fb88e026819b182903ff90738d44f4237cf66139fe010a93c83ffb4", - "0x00000000000000000000000000000000000000000000000000000000000001c5": "5588cd9a04aa1c7e5590c15bf201aa722f59c4aa952bedd1e0de2cd2026c016b", - "0x00000000000000000000000000000000000000000000000000000000000001c6": "ac273cc7933a2407ec16281e6c7e43bb9b24efd517f53122d265c0fd8e400e6b", - "0x00000000000000000000000000000000000000000000000000000000000001c7": "de0c3b47b2a8550abaebd952555b5a604916b2aa0c3516ac07f7cf9bf6d289b6", - "0x00000000000000000000000000000000000000000000000000000000000001c8": "305bd96c60a6435f5371739f23364940ac2ee253e9a6f8d3bd89a623112533e8", - "0x00000000000000000000000000000000000000000000000000000000000001c9": "322c4d0e57f585f032d5cbfff69c3adb7ac8084c95761a9bbad98b97f101327f", - "0x00000000000000000000000000000000000000000000000000000000000001ca": "721f94cdb4c6e847bfbc88d65c74a8eb476178d1fa868af25151fd17256aa5cb", - "0x00000000000000000000000000000000000000000000000000000000000001cb": "e98015589d78db8a32de341208e325d7613c6db8683c7d1376113589e15acf0f", - "0x00000000000000000000000000000000000000000000000000000000000001cc": "ca13a2bf7d0eb0db6335849b7706678ec18caf013540bf57873532d5bc5cced4", - "0x00000000000000000000000000000000000000000000000000000000000001cd": "4d93ae5d91ac6a55b6fe9e452210d4e60472cb09900262104063f91e1c4475fb", - "0x00000000000000000000000000000000000000000000000000000000000001ce": "4557b30a7674af7cbacde7748dff90a2d7b4b2a86f9d79d791e89d39f818a4b2", - "0x00000000000000000000000000000000000000000000000000000000000001cf": "07a8c620ead87a45afb4e0e815a54ca217e4054077635d1524710f1ce5ecea24", - "0x00000000000000000000000000000000000000000000000000000000000001d0": "87bca64e4e6c1a83cf43da1257fa59a376009b2c9f2f37487f85eb8013fb2f0f", - "0x00000000000000000000000000000000000000000000000000000000000001d1": "5984be6ef98b1e35c943bed4caf24066c34bea65dd09cf99762e7e3b6e41ae03", - "0x00000000000000000000000000000000000000000000000000000000000001d2": "223fd06ad6b3a95d0ca0b0fac2819ca9cc7abbcf53686cd3cc9ea9a7099aed2a", - "0x00000000000000000000000000000000000000000000000000000000000001d3": "bf9df0134a7722c090ee27e9061af8e32ba1f36de3561cf540aa19c1e0301694", - "0x00000000000000000000000000000000000000000000000000000000000001d4": "3426b1051fd2963cf74c091c9281236fec075e3b1a6207e0ea8bd590d234231f", - "0x00000000000000000000000000000000000000000000000000000000000001d5": "108535b032c23c831ea3f0e5e60b628b1653a8d4ff2a04f84ea0c28a5f7a334c", - "0x00000000000000000000000000000000000000000000000000000000000001d6": "c57d09bf4689a42694a8b98bb6ef2cb60c0af0446b6dbd1f55fb9d19743d0b6f", - "0x00000000000000000000000000000000000000000000000000000000000001d7": "62ec7b9a65be76bed69c2d1b89c7338fd99f11c52ce57d223d0978ad2623b666", - "0x00000000000000000000000000000000000000000000000000000000000001d8": "88fc2bd51129c6a76a5fc4d74e5bca399695ea9b272f65febb655c211ffecccf", - "0x00000000000000000000000000000000000000000000000000000000000001d9": "4a6fe7d7a0b3433c8c0017a34efcd408751e24ee224d865746e43ee5dbc6b72f", - "0x00000000000000000000000000000000000000000000000000000000000001da": "b4d421616ea7a4adc51abdc1eb68ae4517c83a7e65545ad5bd8570fea865bbe4", - "0x00000000000000000000000000000000000000000000000000000000000001db": "35ca0c82bbc6c2a282e04efd935ad91744a76f738b1a05f543f362089b077549", - "0x00000000000000000000000000000000000000000000000000000000000001dc": "a2e71dde107bc1f02f8f2303e84580a4061adb821347fd065dea806464488543", - "0x00000000000000000000000000000000000000000000000000000000000001dd": "8c2efd84e25c29636ce86228e1fa39045936581562d1d80d1273951d3a7e5b5b", - "0x00000000000000000000000000000000000000000000000000000000000001de": "ae195bb8f9a28f440a0a10bbf872db2c50aae4f08d49089e3b8783187b8b2d5b", - "0x00000000000000000000000000000000000000000000000000000000000001df": "d74fba51d365cdfe355295a9a9cb7470ab1ddb53070cc23dc84706d30a1c9d65", - "0x00000000000000000000000000000000000000000000000000000000000001e0": "586bfb94de868a094829593278f0059423d4b3a4fa381118368e866ac9ad174d", - "0x00000000000000000000000000000000000000000000000000000000000001e1": "ed9fa0da61fcefb49df7807a0e827069520dd2e1b7823c23b6c8316f261a1526", - "0x00000000000000000000000000000000000000000000000000000000000001e2": "2d4f68ab5cb1b7d5942ed325911da4de560c281bc4165f12e79b40896faf9240", - "0x00000000000000000000000000000000000000000000000000000000000001e3": "173ba1064b822d7fd886f79df09291855941c7e187348cb1be74b4f3853ac46a", - "0x00000000000000000000000000000000000000000000000000000000000001e4": "5fe23349b74796ea88667c124d31b7f83d1ea6c55888612d0546fcd8781469f0", - "0x00000000000000000000000000000000000000000000000000000000000001e5": "44b4ee4af4ea93cdc1f6d6a7600b78b1f18918e5adb36a95773fb69f0c95960b", - "0x00000000000000000000000000000000000000000000000000000000000001e6": "6e1a5f320d6c603aebe7b47c6f98bab7e6ca3f63648853117f90681ef82be343", - "0x00000000000000000000000000000000000000000000000000000000000001e7": "0e0736ecbc21d8283a34e648718dfde99dcf213778a19cbb385a528281994d02", - "0x00000000000000000000000000000000000000000000000000000000000001e8": "8d71815cf7e21c74cf91c9f2ff59fd941cbcf127084f929254498163c494f183", - "0x00000000000000000000000000000000000000000000000000000000000001e9": "bff2f568d9a26daaaedd8e26e46d3eecb122cfb8c091bc194d6326c88d058f1d", - "0x00000000000000000000000000000000000000000000000000000000000001ea": "509d2a2521abc4c30ba8b397d9e86976e6134a844bea08ebeac4a4b009bfdd32", - "0x00000000000000000000000000000000000000000000000000000000000001eb": "c73fe82ce95274c1aca827b1e2bcbdc56663f172a9a808e02fb03b594afd5494", - "0x00000000000000000000000000000000000000000000000000000000000001ec": "8e940db2d4e9688d0eac137008f26832b205e32c67877475cc0348c38be128ab", - "0x00000000000000000000000000000000000000000000000000000000000001ed": "c4686ab32da32550e9cc95adc86e731d96b3498f28c3454972b8647922a8c775", - "0x00000000000000000000000000000000000000000000000000000000000001ee": "2acc9875f08bf7c9185aea7dcce6c1163b303e620de25993fb494a866f831b9a", - "0x00000000000000000000000000000000000000000000000000000000000001ef": "e5e2de3cd1a2a8f6551e93be0ab3644c84c9653cae77d63caa4a10f5b805ffd4", - "0x00000000000000000000000000000000000000000000000000000000000001f0": "6413cdb135c067bf7c9894bc05cbef70350d5d2bcd089f661257b80a28d71a26", - "0x00000000000000000000000000000000000000000000000000000000000001f1": "e800f779e224dcc43b5c7bb57da2d643e20dbdb53e1cd60e41207b620a040b5c", - "0x00000000000000000000000000000000000000000000000000000000000001f2": "e3bd2dc0e6af6253299c175f22a860b34d75ee109faa0c7dc437c94c8e35643f", - "0x00000000000000000000000000000000000000000000000000000000000001f3": "44924c88d1ebadca339c20badf7e5e22ce7ec673cfcb7305d46487417a852cde", - "0x00000000000000000000000000000000000000000000000000000000000001f4": "7151d7993c13af657fb9afbcad9340ddb46fac82b873b64baf85f8f5780151df", - "0x00000000000000000000000000000000000000000000000000000000000001f5": "eb6625cb0981451d810c0172e25819ca3b6fc2035ea04542f3dee1dce7c516df", - "0x00000000000000000000000000000000000000000000000000000000000001f6": "efab54ac6e96aa6fc5d3270f7a928f03ab557ce9b7d2ed68f08825ca50c6307f", - "0x00000000000000000000000000000000000000000000000000000000000001f7": "f0591fc75f0711d3d9234011205cb9bd2c40a3477994d943e6d7a12c72e8d613", - "0x00000000000000000000000000000000000000000000000000000000000001f8": "df54b762c56706ef7861a0725b7fd4f01aaadcac614d3d3f39569cb8e621fd1a", - "0x00000000000000000000000000000000000000000000000000000000000001f9": "4effa3cb8383f0ece82c3391e95ce6a88be26f87bddcc62dfd99cd7a5a11dbfe", - "0x00000000000000000000000000000000000000000000000000000000000001fa": "2d903ece7c308b988d585304235cb0f3bacbafb64ec0b62da27c1f77aeb18d76", - "0x00000000000000000000000000000000000000000000000000000000000001fb": "5a1cd86c8a2bb05874d5fd341035e7228067175a1c757b91f442dc34922a1b", - "0x00000000000000000000000000000000000000000000000000000000000001fc": "9e7ffa6ebba334b9810de0937096a05f054a43eb03621ca8874411e5ddaf7543", - "0x00000000000000000000000000000000000000000000000000000000000001fd": "68b50078b3394b06d6ee3a3b12462a38eb85286023c07d90e290ba808b5da702", - "0x00000000000000000000000000000000000000000000000000000000000001fe": "bae08b3b1ac544135b3a06fbaafb931229a99d0e47434318580146086ce0dab3", - "0x00000000000000000000000000000000000000000000000000000000000001ff": "91711182ab4cdd63dfaac9e02b07f4d49016fe1ac744ff90843bd1f52f893761", - "0x0000000000000000000000000000000000000000000000000000000000000200": "fc6438ea7c3138aca8cf840a05aa7e627ecea40cec8d6166406f98449ba6182f", - "0x0000000000000000000000000000000000000000000000000000000000000201": "d7d6cfbe9f350fc0643592dbd7a2a98639f92b0183cee49ef6f5d99aba72b47a", - "0x0000000000000000000000000000000000000000000000000000000000000202": "e42d2c63e650101bc54d149c19d67b78ec05431cfc15134146790f1da71548b2", - "0x0000000000000000000000000000000000000000000000000000000000000203": "718c2451b8df916754650ca5d9a3fca98e0f9209d41cdafd30d3ee9343b12216", - "0x0000000000000000000000000000000000000000000000000000000000000204": "64f5dc426951c8d5c389bed1af605f9101235dbfaa4822f2ba83bbe9973be25b", - "0x0000000000000000000000000000000000000000000000000000000000000205": "1841a4c413f59d37b93421bc6d165288e0546f1261e25357feae9c96a66402e3", - "0x0000000000000000000000000000000000000000000000000000000000000206": "289f40c44da44e6d545900ecfab81d0d86b9756e74d6bfa2fb0095cf28a93cdd", - "0x0000000000000000000000000000000000000000000000000000000000000207": "b80db8759f920638458bd60e8f97e9a0773970c30941cf2744f4db475b5c53a8", - "0x0000000000000000000000000000000000000000000000000000000000000208": "4280ca715e955153245aa296395bd7f179a13606f4e909119b1d58b7b0457e34", - "0x0000000000000000000000000000000000000000000000000000000000000209": "56c95098c7c859b8b786bc2f776f739ba109a1d662beb8545294938b9ce5ef4f", - "0x000000000000000000000000000000000000000000000000000000000000020a": "ed614b855d979afefa3c40027ca4b6fff89a1467173e85302b48a478bfa7abad", - "0x000000000000000000000000000000000000000000000000000000000000020b": "f379747713313c3ef604ea0d5446066edf0b695213acfb86388ba46e6c926bae", - "0x000000000000000000000000000000000000000000000000000000000000020c": "71345ffec2ba388522c6703f19f24c5af1eb742a44d2ae6749276739d138912e", - "0x000000000000000000000000000000000000000000000000000000000000020d": "c73d56854a544ce56956bab6d4ffab7beca0ec861ff5cf5906aa2aec20682c75", - "0x000000000000000000000000000000000000000000000000000000000000020e": "d543d5b576ae572d9996cd3d05295368b201e3c618ae5da30fbec43cf24b52a3", - "0x000000000000000000000000000000000000000000000000000000000000020f": "dba4322406050555a1a8cfbae1c6fd627bee7757384059a41bfd5b6147543f53", - "0x0000000000000000000000000000000000000000000000000000000000000210": "9eadaf49e03a16c9c7cb8d2ea59c3285d7530750a462d6a9338e9a9e730b1055", - "0x0000000000000000000000000000000000000000000000000000000000000211": "eefa15b3aa7fbee117a78b61a365f6e38b6d8ae21482bc2eda241e637d43af8a", - "0x0000000000000000000000000000000000000000000000000000000000000212": "3c7d782eb5bbcdd254bbdb120e432c90d9b0510a3c7e64507ed2c82fc01a2a7a", - "0x0000000000000000000000000000000000000000000000000000000000000213": "56d781324e6bdab32f417adff9cc2b4c645f819184b323f47ec974574121b309", - "0x0000000000000000000000000000000000000000000000000000000000000214": "997c22b77767599b4d1f9f7d21ad9b34b1e13e5ba18986d4dee06d282e89e453", - "0x0000000000000000000000000000000000000000000000000000000000000215": "49223c27247cbb012c480dd78497ea761f0de37eab920e169067d710a6c697a6", - "0x0000000000000000000000000000000000000000000000000000000000000216": "09f9f3b73c653b5d3440ff550da397d5d6b4dd3e3297a2f2d3c5e67bb128afc9", - "0x0000000000000000000000000000000000000000000000000000000000000217": "6e277d1000baa83809de9f5f90fc8a3387d1ff660f9a7d7857ec4c3e66f70d57", - "0x0000000000000000000000000000000000000000000000000000000000000218": "eacee55ad16ffef8f34262dd2351947882b5c327565581fdaece63fe35c8044c", - "0x0000000000000000000000000000000000000000000000000000000000000219": "d13cb1082077f93cf162c8868d1e2ddfa3987c12f0b4d17de8f4e456ba9f646b", - "0x000000000000000000000000000000000000000000000000000000000000021a": "323fc2bb76f6f190369ed67f4eed60233e9ace45b6b77a8a545147f6e2a12826", - "0x000000000000000000000000000000000000000000000000000000000000021b": "1a26d12a9846cfa2af53cc33f21eadb49c2f39560b460bbb1d7c253025da7917", - "0x000000000000000000000000000000000000000000000000000000000000021c": "a68b828d73467b4edbb8f3a188d1d23b8de8113e1157ebe14ec188e8f266637e", - "0x000000000000000000000000000000000000000000000000000000000000021d": "46d5ce094294750e8d8c4508cea607a110ac887c6876460834bb7f944fb3cba0", - "0x000000000000000000000000000000000000000000000000000000000000021e": "8d3698f018ddc839a43997a360b3715b80f6f8fbf70836166601ecc42439b1df", - "0x000000000000000000000000000000000000000000000000000000000000021f": "bdaeadf6d9045a0a986c15262d81d49e1f12a3301035d7d7d03855f315498397", - "0x0000000000000000000000000000000000000000000000000000000000000220": "4466a1b8ce15a2b972b93d345e42e24d6c55e49e6e6b390daa111115737c8893", - "0x0000000000000000000000000000000000000000000000000000000000000221": "aac5449b0cee4d0ff7e6dc495061712400e5f908b5f5699bd489f8433c7f3ce6", - "0x0000000000000000000000000000000000000000000000000000000000000222": "bfc6905b39a1fd70f2d85dbd0ec084fc9bba34dd6bb89e4feae605de3472a46a", - "0x0000000000000000000000000000000000000000000000000000000000000223": "1320207357e4a928664d17895ca63c2e929115bf3078b13a0623a42b1361a27e", - "0x0000000000000000000000000000000000000000000000000000000000000224": "6988fc4983a5d91cb76203880fcb0be8d513013f9eda28c6db7c27d0e457f417", - "0x0000000000000000000000000000000000000000000000000000000000000225": "293913aa6fd6784e2dabfa7bdbf08dbcceac77ec746f2beaffe37f5c82ebd6e7", - "0x0000000000000000000000000000000000000000000000000000000000000226": "3c64be9f5fc05b3a06c21263201805872058b6dd89f5871f56126074937d7d69", - "0x0000000000000000000000000000000000000000000000000000000000000227": "9c0e5ad32b88aabd00d4e08f111128f36d2b3b9d00ec205b4deea450d7e20f52", - "0x0000000000000000000000000000000000000000000000000000000000000228": "ee8f988f3c18a72c2abea54699c856a15afdbaeae545924997985cb47210c6d7", - "0x0000000000000000000000000000000000000000000000000000000000000229": "90036a13de8b68ad7fa9658cb90a841951763c528de8a3891db006570d06760b", - "0x000000000000000000000000000000000000000000000000000000000000022a": "641e4d31a221b340b02dfbe9aa430eab15367721b41a224ad5aaf44d60bfb649", - "0x000000000000000000000000000000000000000000000000000000000000022b": "dfa68efde1f8c73371b729e119655153388ca5404df5f27cb8aef2d5dc49d472", - "0x000000000000000000000000000000000000000000000000000000000000022c": "e069e5bf125ec3bd85fc691a6e299363e03130bbbdcbb1d4c0e7ed74c44d19ae", - "0x000000000000000000000000000000000000000000000000000000000000022d": "7d4c7faff291a34dab9ad08cc22b38e3e0623fbd96e53041f1936aefea2d3d01", - "0x000000000000000000000000000000000000000000000000000000000000022e": "35fcbe1e362b97d634c17b08b78c253df56c0f4a52fdcc1da23c4c56871485aa", - "0x000000000000000000000000000000000000000000000000000000000000022f": "944867748f6677c888eeffa2f0ab037f72791f19d4957c1b015300f87e8f6946", - "0x0000000000000000000000000000000000000000000000000000000000000230": "e2a46fb9f878a562bb0392bec6634965964c742d80102bed78abf111455c1530", - "0x0000000000000000000000000000000000000000000000000000000000000231": "b229d60b67c1708d3994b81cb282f73ef6d2ae75438e401f4c8025562e2340fa", - "0x0000000000000000000000000000000000000000000000000000000000000232": "b3b6afe52f6d14dd44a71f1ff185ed96179409250f324659fa1d1abd1b232739", - "0x0000000000000000000000000000000000000000000000000000000000000233": "adafa5a8ecaf727c48b659ef4ab3204554e7cf7b27e69207926a5a62c24fcab6", - "0x0000000000000000000000000000000000000000000000000000000000000234": "dabd6ae95f5c2d68740f3001b8321ff60efcbd343b4c1d27e425b6e1d6dcbbef", - "0x0000000000000000000000000000000000000000000000000000000000000235": "bc4039fe1b1fe6767d379b48649f0208eedd6211fd09012c410e96231a70bd32", - "0x0000000000000000000000000000000000000000000000000000000000000236": "83db531e70791b6207c14af0b6321145a00614c977b70fd0668270988de4d5b6", - "0x0000000000000000000000000000000000000000000000000000000000000237": "d790766e32a204eba62eb8748875d63e58f290375cb77e1a8e06cee26be50aa0", - "0x0000000000000000000000000000000000000000000000000000000000000238": "5f7355f8b08daee6ee6be9e9522ecedee0db5282463952021b5eef1bf8fc6c7e", - "0x0000000000000000000000000000000000000000000000000000000000000239": "cd23cbad2ba375c546161adcaee6c4c81319c164b1ad8466811b7490b95e286b", - "0x000000000000000000000000000000000000000000000000000000000000023a": "f1357f71ed1cdbcf8c1a31552f1223403b9d85b44dd4ff2c9a3683ee440c95c8", - "0x000000000000000000000000000000000000000000000000000000000000023b": "b69086a5e21ff6ac0b0177b825eb4ac57307f19211d34d5d27f270d74ca07a17", - "0x000000000000000000000000000000000000000000000000000000000000023c": "d5c1878d16190ffce6abc0972a9250ab129a383fecf447dd5e1e5fe9c560e2b7", - "0x000000000000000000000000000000000000000000000000000000000000023d": "7adf3774b7bd3f89b0948e1ddbbf300835f06dcee2f437e09ee4473df6c8a07c", - "0x000000000000000000000000000000000000000000000000000000000000023e": "2dfc4f087156df89e8f26744590b923f3a81642defd298dd1a1db5bbce0b3d89", - "0x000000000000000000000000000000000000000000000000000000000000023f": "e58a461ab85b4e2208262ab6de81621a9fe3c96e4eadb9253e7baecdec571434", - "0x0000000000000000000000000000000000000000000000000000000000000240": "0bdeb401cf2ad8a1f33f3e6a71602b0720182bc5a290cbf92a20ad5a47b421df", - "0x0000000000000000000000000000000000000000000000000000000000000241": "29456e95da920f3dbc36b3dc0a926f2dec210b800550386ca672ed6110b169c6", - "0x0000000000000000000000000000000000000000000000000000000000000242": "ae6208b2d4c5f776a63eb1e4dc138b366387fe7ddecf72fd98130637bf65dfeb", - "0x0000000000000000000000000000000000000000000000000000000000000243": "bba5107c05a512e72c49b459b20a6ecdc1cfec225f866ef045c9a3693df05905", - "0x0000000000000000000000000000000000000000000000000000000000000244": "626d2bcb3645a3cab73403328051faad33be5e5f5f75ff38e195b77dfb0fba01", - "0x0000000000000000000000000000000000000000000000000000000000000245": "af6d014836a41c11af83a95a92d5324c0dd0e063a6feda19a05966c97cbeadf0", - "0x0000000000000000000000000000000000000000000000000000000000000246": "6268abdce6bb3bee101c9e848666f3522cf429cab4725f23a27a5eb9575ed2fe", - "0x0000000000000000000000000000000000000000000000000000000000000247": "5f5a1ffa3df60840b186c814fe10bee8d745a195f68174d5097067663eb692c8", - "0x0000000000000000000000000000000000000000000000000000000000000248": "b43bd5c412948cb43408ac47c85d080b9bcdcecc982ec14aa3a09dd531edbda6", - "0x0000000000000000000000000000000000000000000000000000000000000249": "fea440ef23de659e22508daedb4d4dd91a5bb39df9d3f039a24cde8ffa6527e4", - "0x000000000000000000000000000000000000000000000000000000000000024a": "5bda26af5e60d0a9bdccc94a59421b97f0d82cc828a117643b021ca4dbaa4372", - "0x000000000000000000000000000000000000000000000000000000000000024b": "bd1d9841873dd0a26419f9a183a78370dedd826f922adeff78afef05811f8f71", - "0x000000000000000000000000000000000000000000000000000000000000024c": "5f40f6bc01be52c0a6f0f800c4120e73ae430d2a0e2cc6cfd6958ef33aad54e6", - "0x000000000000000000000000000000000000000000000000000000000000024d": "5528f6ef151d9a9f71dae57e39b1cd2c5c6e5c7e0cd3a419afbee06e313d9f47", - "0x000000000000000000000000000000000000000000000000000000000000024e": "dff8f0703a0840e4d227f77f46348869d6c8b8c30b872137b26a9e2842914410", - "0x000000000000000000000000000000000000000000000000000000000000024f": "4ce9196d2fbc4bda9fcb9ab61e86167c9e1b547e873a7e5226f922b18db59953", - "0x0000000000000000000000000000000000000000000000000000000000000250": "5ba98af8b68bbf0d86879ec911858300293e7bbe347abc02548c5084ab5a0d3e", - "0x0000000000000000000000000000000000000000000000000000000000000251": "3d33f3036b1399cf00cc8966e85b8553b5d7d4127ad121f382df765661a6627a", - "0x0000000000000000000000000000000000000000000000000000000000000252": "3ed14e1e4d79669a7104b244f12d0dbbda1873230eddacca3ddf00d5e278be9b", - "0x0000000000000000000000000000000000000000000000000000000000000253": "93a7231507f57e163e3b2e48a47132fc1eff83375b041b46a35e61a090ded25e", - "0x0000000000000000000000000000000000000000000000000000000000000254": "42f57c5994becd0c778c625c4564b288f2ddd5523bf3505dcba11d4f31e317ea", - "0x0000000000000000000000000000000000000000000000000000000000000255": "05b8baa80ba3a0782ff6cade5129fb4e3cc8733de5d8da918d2338245ab76b6c", - "0x0000000000000000000000000000000000000000000000000000000000000256": "7d4219f429001b5f014e933f9a36aa865d09955de79a8292aac8a00e75ba0f03", - "0x0000000000000000000000000000000000000000000000000000000000000257": "65151b101682b54cd08ba226f640c14c86176865ff9bfc57e0147dadaeac34bb" + "0x000000000000000000000000000000000000000000000000000000000000000b": "c2edbf6987d529aeb53f0446650f0c76fd4aac53d87319bd3906700461531e28", + "0x000000000000000000000000000000000000000000000000000000000000000c": "0263c20a17979b8bab4b53b9a8b028faee4ae62a22fd604e17c72a1c5113c5ab", + "0x000000000000000000000000000000000000000000000000000000000000000d": "96767c27f1be95f86f185bdc4f2ad2b9d0cf8fe0179912270b9f09a56dd885db", + "0x000000000000000000000000000000000000000000000000000000000000000e": "998edaa40eab431c0cb0907adfbbc45bd0559758eda2cc11ac1d0142783db4f7", + "0x000000000000000000000000000000000000000000000000000000000000000f": "32c4b00fa9800092d28ee17d5a2941a100ed6ac3ec1514b774890b9b226ffd43", + "0x0000000000000000000000000000000000000000000000000000000000000010": "827cbc8dc6bd4a545993d61ce2833f7baa3ffafccf0c43da845780b2c60c4f0a", + "0x0000000000000000000000000000000000000000000000000000000000000011": "8be0f38f24af217357167bb37fa76e4bb07257cbdebbd7060c012dee3685a2b7", + "0x0000000000000000000000000000000000000000000000000000000000000012": "33cd3f00a5d4b4786f1028871a2431b2a5cc06abcc1f06d56f520c05c8d709aa", + "0x0000000000000000000000000000000000000000000000000000000000000013": "6d69508bcfee6a79ab1f9b2654eaa9767beabc4aabd0777b4d16a1c7fe2308d8", + "0x0000000000000000000000000000000000000000000000000000000000000014": "dccd539eebea31af7d83c77ba7b57529a1111630bf3eff5da9eaaf3bdb06cdc7", + "0x0000000000000000000000000000000000000000000000000000000000000015": "b4125effbc4875925712ea7af12b9b8efd356f9daf371e37982d9d80986500dc", + "0x0000000000000000000000000000000000000000000000000000000000000016": "153171ce62d3a05bfc910c2dc9dbfe08d0b674de9053c4ba50989d55ba75545c", + "0x0000000000000000000000000000000000000000000000000000000000000017": "631eb6b3e5d105379784bae7414c1a87100222dfaa82de3cbbd449cdbdddfda0", + "0x0000000000000000000000000000000000000000000000000000000000000018": "db9610ac987150d64e0c47bf2bf4b4b6c225f7c869a8a3c21a8b4ed42a779da7", + "0x0000000000000000000000000000000000000000000000000000000000000019": "484dfda7c0064b4361c5bb164ab29ab46b2f6e4ad1e4d08e054cf87092c301cc", + "0x000000000000000000000000000000000000000000000000000000000000001a": "b83ddbaec179e4a8ca479524a47d3ae87cf9d0d9cbf10f36e4cd27b095f03487", + "0x000000000000000000000000000000000000000000000000000000000000001b": "d17fa84bf309999af41acc3a1e006f5f9bc96a7c6bd8343f8dcd851171f89bbd", + "0x000000000000000000000000000000000000000000000000000000000000001c": "f95e9ebf1649ad621dce264eb56c4695b2c12bcfdff445f4081d42a1bf35cb93", + "0x000000000000000000000000000000000000000000000000000000000000001d": "ecb61d653cb6ebe9236bb36c31afd4637f6ebfaf9a84b53c8ab8d5557a177e57", + "0x000000000000000000000000000000000000000000000000000000000000001e": "d454d2e47ddd6508e26a8e6f5f7739c4816e682f72940004b983798e9874db24", + "0x000000000000000000000000000000000000000000000000000000000000001f": "cb4c113282733de5e500f67e1e2d34dcb1f5ba78d50fd1ee64f589985cbc2e79", + "0x0000000000000000000000000000000000000000000000000000000000000020": "279a30e5b6459ce8cbb11314c86ce121cd09ccfa94e8431da318c389ced90f1d", + "0x0000000000000000000000000000000000000000000000000000000000000021": "bfa427b49c4b9c8ac6629f2a2d1b62c0e2d3d4e793e603af64d9eb7438b694a1", + "0x0000000000000000000000000000000000000000000000000000000000000022": "8595bd36d4362be24f82626e410c5240689ad948822510812add6669c17e60bf", + "0x0000000000000000000000000000000000000000000000000000000000000023": "abaae2a5e966b2e2b1de55c4cd3ae9d8eed5a7a96994eb8627465ed0d9d15fa6", + "0x0000000000000000000000000000000000000000000000000000000000000024": "ebaf8a77d6fe68c176d3074a8f4b9c702c4b5e96b801a1410291fbe2cc6421e2", + "0x0000000000000000000000000000000000000000000000000000000000000025": "8a76724de35afb575efb81ef8ab58346825486d654168ef5aeb2f80912e61a78", + "0x0000000000000000000000000000000000000000000000000000000000000026": "9463185605c120f1bbec5549f567ffb50e0a4dd1bb5d202a312640cb3faf5e72", + "0x0000000000000000000000000000000000000000000000000000000000000027": "817c992ddaad0c33d972ff29048a8ec435e562707950ec4c0d9fb77dbdd84ae1", + "0x0000000000000000000000000000000000000000000000000000000000000028": "8d61211d9778e2315598b11c7b715f8a96a3e7b3f7242a280a590aa728a2c2cc", + "0x0000000000000000000000000000000000000000000000000000000000000029": "cb0a318ccf7de5604a9beb6772ba12ddde924fbf0e1074246c5a6864c203c020", + "0x000000000000000000000000000000000000000000000000000000000000002a": "9634b9df44977f0b85afbb35da1ffd571858e7ab44f2ab3e440f920031e57fe4", + "0x000000000000000000000000000000000000000000000000000000000000002b": "9f769468769e89b9dc650168649eb0c666f70c82600be471f072caefe08c9d55", + "0x000000000000000000000000000000000000000000000000000000000000002c": "4cb55e0dfa4d8e35270542ce0d83991a2b2fddd789475d675f8af1c7c9715594", + "0x000000000000000000000000000000000000000000000000000000000000002d": "5cda29c5e65864ba897efa8e61cbefabb0653e2c90aa6317cc66f8b7ea849855", + "0x000000000000000000000000000000000000000000000000000000000000002e": "4fab41210b0a89ad65ef56cccce7146b0c7792e631cb57f9d45f2c390c0930e8", + "0x000000000000000000000000000000000000000000000000000000000000002f": "7bab3d8b7342961697225b52e7d8bb83b46cc34903907b0e4661947eb109afdc", + "0x0000000000000000000000000000000000000000000000000000000000000030": "bfeba0d543fa88ab54802a9d5206fd41b5718136dfd21a9c821efb609698750b", + "0x0000000000000000000000000000000000000000000000000000000000000031": "50e8364ebc7a92e7caf312e0b10aa59f685d32073de47561185a14dfb3fce1", + "0x0000000000000000000000000000000000000000000000000000000000000032": "cf0550d9f0e956ea4aea8fd5d4412812acb72922b3c6bd47c8a0086bd0c4abf5", + "0x0000000000000000000000000000000000000000000000000000000000000033": "80994d3ef7108fd26e8124978fbad74e9223d3205785161c272f91311e7481b9", + "0x0000000000000000000000000000000000000000000000000000000000000034": "164df48af3dddb7478b82f0c716a3e991ce37c2c13a60959409e4e1ffd139f49", + "0x0000000000000000000000000000000000000000000000000000000000000035": "2c22e6b47f0dc7b95265f02e285984be0c2d2462a9646c69b0c7369b93ab859b", + "0x0000000000000000000000000000000000000000000000000000000000000036": "c11fc865b8f4414834cdc0b3d92d5ff380c8078f3b61eca63c3f05a33d0ed9b7", + "0x0000000000000000000000000000000000000000000000000000000000000037": "7f47b785f867aacca1b27d55186dbb6a7a9a6b83754e6d2d0d2b9f1698f32f27", + "0x0000000000000000000000000000000000000000000000000000000000000038": "c0df0d295b403cc825a0825f741923f806f603ff53aafcc04f6b91f39dd35198", + "0x0000000000000000000000000000000000000000000000000000000000000039": "9f7f274336bcfaf82e4f7696590eb831dee46dbe71821c14a197810edcb2834a", + "0x000000000000000000000000000000000000000000000000000000000000003a": "abc3fbe0c41b79c30f91b2834dfa28a2a3ca23aff7505b53ef5383f3fef45987", + "0x000000000000000000000000000000000000000000000000000000000000003b": "761bd27a0e51092eee4eaa4a545708b2df734d240ec2e5909e784e478752626f", + "0x000000000000000000000000000000000000000000000000000000000000003c": "fee26a4ca9c8d56be94795b13f522d026f47a749fb3969c5f5ffa7465acefd36", + "0x000000000000000000000000000000000000000000000000000000000000003d": "d99ba2e7fce99a98dec8caee0bf6422887042e79facfcb081e4c5d04a3f8fdb6", + "0x000000000000000000000000000000000000000000000000000000000000003e": "1ac60d9a0fbdd7d5779432344ddb1cc080b7d70d8049631e9a5767f94dfc0fb0", + "0x000000000000000000000000000000000000000000000000000000000000003f": "0592a18e16fdecf8028cfd0172fbd99a44287f9fa77970a947623c4305aff927", + "0x0000000000000000000000000000000000000000000000000000000000000040": "e276709cf0da03abbe0672cd6542c8823ba1a79ced1d077331d26a4bfbe4664b", + "0x0000000000000000000000000000000000000000000000000000000000000041": "dc32af56e34daa6037e96a2990d6485815b9dbb16ed0fd48e19e794b16d78d52", + "0x0000000000000000000000000000000000000000000000000000000000000042": "2256ff7bd7ede2f79b3392f7898790b3bfcc1dc7bb0143c654a33f2e2f5888ae", + "0x0000000000000000000000000000000000000000000000000000000000000043": "6163d0b7f02b214352ded0703f0e17a07ffd6b732cf37498e0ea7326863972eb", + "0x0000000000000000000000000000000000000000000000000000000000000044": "a5662af7bb63607ebbc0c5ba713be53a59b376199c9f702b141d4b2cf75571b8", + "0x0000000000000000000000000000000000000000000000000000000000000045": "c2f77b16764d5704a9c3fc3ccdc291c2301b512341ed07de3420e05814f38f44", + "0x0000000000000000000000000000000000000000000000000000000000000046": "0f684901e87fafdad7d7ffe9f324a534b06cfc52bb98cfd6937ad3373edbe050", + "0x0000000000000000000000000000000000000000000000000000000000000047": "7ac52282fa3642fe038111e06c27e42bb80e6687faff3a80802b98c0046cff14", + "0x0000000000000000000000000000000000000000000000000000000000000048": "6ac35d9c3afb594c2625d6aa43c248e7f1ebca6cbb3ab4381e8532390005e4d4", + "0x0000000000000000000000000000000000000000000000000000000000000049": "1e3f81c1be76102b47f9d823bb475a6061f72286e53a8d72abc2d363567498ba", + "0x000000000000000000000000000000000000000000000000000000000000004a": "b3633d86d73d0b3c8ee7b906a5a0d4bc5ea1bed0490eb0211164833cf5a4b3f4", + "0x000000000000000000000000000000000000000000000000000000000000004b": "502288a02dc23356064d1f98cd38f8e346943b6f6837f0bf98f63534c2027ca9", + "0x000000000000000000000000000000000000000000000000000000000000004c": "b2145a089c38b7db50fc671aa89fca64e00fa383f540f3c704ed51e7f2179f3a", + "0x000000000000000000000000000000000000000000000000000000000000004d": "f0c902bd6d37bdecc5d0b17b012dbabf6856efe771bc52c790be6127b8b8a9ed", + "0x000000000000000000000000000000000000000000000000000000000000004e": "0e065a7c1d66be9a7505eaa9846edba1efbc5a2643b0cde0dc11ab9b0e82d2fb", + "0x000000000000000000000000000000000000000000000000000000000000004f": "7a5a9823699ec0f335d977fc08ca50d0786b044c177fadab0f36957d5ee8a6ef", + "0x0000000000000000000000000000000000000000000000000000000000000050": "0c2f74470c7439c7e783de2e128f65e66d794d01c2bbabe225599eb81927f680", + "0x0000000000000000000000000000000000000000000000000000000000000051": "7489436084d1c2fbd1ef76bd84ee9ff43e054e6ca744fb1ad299f8fb6a5171c6", + "0x0000000000000000000000000000000000000000000000000000000000000052": "b535bb07496aa8764a751097afb4fda7881b9de41e6f3c4c329360a808caff31", + "0x0000000000000000000000000000000000000000000000000000000000000053": "1237af5eec8dabdae0efd403a87ef5588b2dbd724946f41c7e161df50328e468", + "0x0000000000000000000000000000000000000000000000000000000000000054": "7bb88dc7b037cc2aa86a83318f9e2db824f840e0c04526f61fd2921f327eab14", + "0x0000000000000000000000000000000000000000000000000000000000000055": "e8235717342e9768bf65d0600947b88bebc1d922822b1cc577075dd7ef002462", + "0x0000000000000000000000000000000000000000000000000000000000000056": "f321197dfc592eb856c14ffe0ed175cbb25105b435473559447d58154769bcc0", + "0x0000000000000000000000000000000000000000000000000000000000000057": "2b09c7fb6f54983fcee6cbcd8eef58ac886978c5ccf72edd52795a95ce956c1f", + "0x0000000000000000000000000000000000000000000000000000000000000058": "c39e1323f7b6949a21a1bb6f98d9ebd22d3e776e07676c4cce9fc4174deda0dd", + "0x0000000000000000000000000000000000000000000000000000000000000059": "8b79d25d91549e398a5fa94bf6f56b1837b11d042b65811411fe53100ee18c2e", + "0x000000000000000000000000000000000000000000000000000000000000005a": "5d33f0b59d254d470019eac98e38a2a90468e5873067bb5e3cf8e0ccb84ad048", + "0x000000000000000000000000000000000000000000000000000000000000005b": "ae8ff3f7d1bde73dbd36f2293e845fa059a425576be62bffdc4ba6a2e1be5afa", + "0x000000000000000000000000000000000000000000000000000000000000005c": "8d1fd7f00d80dd8d4c799dd381b71eb349e695d4190f97e206550ddde559adf4", + "0x000000000000000000000000000000000000000000000000000000000000005d": "16b224e441aa3817c03949a4e7930d87e0ff9240d0f2955fdebf23a7f410148a", + "0x000000000000000000000000000000000000000000000000000000000000005e": "cf191216637f378d2ee7f2dd47d9a330b3cdd0e20d7a27f8c8bbfb1df421a9eb", + "0x000000000000000000000000000000000000000000000000000000000000005f": "962e7b0b218852cf9c41bbb7fd8908baceece8e7e4c8b2b5d2ab5390f0561b02", + "0x0000000000000000000000000000000000000000000000000000000000000060": "13dc0c8daad8b71fc3f0e62a209b9710cc78934504a6c2e990549a2e473152ed", + "0x0000000000000000000000000000000000000000000000000000000000000061": "333cea669c831ec4b078f39fb05de11664b438741df8d8cd37ea771049dc1f30", + "0x0000000000000000000000000000000000000000000000000000000000000062": "e377c7a76084c79781cecc442ff79d5a76ab95710878ef19fbaa2ae3b3806d2e", + "0x0000000000000000000000000000000000000000000000000000000000000063": "583000818d360ecba85c0924bee169e64dc799c21d5e468711324c423ae1246c", + "0x0000000000000000000000000000000000000000000000000000000000000064": "89628d10b5c915f51b8def1dd2ea8a9b2e89b30da4435cbe0f5003651bb05e8a", + "0x0000000000000000000000000000000000000000000000000000000000000065": "0de163e9e16a0d88854f6e66f30e50d44d2e569f9f581e9a368adaf1f4a5ca6a", + "0x0000000000000000000000000000000000000000000000000000000000000066": "0220ce36b8436b0b234a97413f91bd64f6d41cf4b10fd0bd10e53d8b8f7d79ea", + "0x0000000000000000000000000000000000000000000000000000000000000067": "73d6ae295486e56af688dc96243f9841a3a40c4100ea132f2c0d3c7a92d7a724", + "0x0000000000000000000000000000000000000000000000000000000000000068": "c57eea72ca6da6fa23e48e0a02d56ccaa84b59f4f663d04d492ba107f6989475", + "0x0000000000000000000000000000000000000000000000000000000000000069": "38aa8a3150af9b19993b8d4cb3e670bb365853c341f1a24d57ba8e1328afb1ad", + "0x000000000000000000000000000000000000000000000000000000000000006a": "853b45ca33c271b321625535fbd242f5edd582be0056641890b66a2b1fbe0677", + "0x000000000000000000000000000000000000000000000000000000000000006b": "7bd34591adec12322873c046b6d45fc55defd4891f58e6f26970c14e964bce5e", + "0x000000000000000000000000000000000000000000000000000000000000006c": "8f288d915f33362322143bec0749279cdfb9f0b72e7a6c379af08c7b4f88b24c", + "0x000000000000000000000000000000000000000000000000000000000000006d": "6886974a4794aa2d984957964c2480cce1346776b180888a3777857b4405e26c", + "0x000000000000000000000000000000000000000000000000000000000000006e": "20e5954a1da37baa1f7446598fd7d4311241c09d4283fdec67782114693bdf99", + "0x000000000000000000000000000000000000000000000000000000000000006f": "48ccbd91a8643d6e270829515db0595bc97d123453e4a0bc7a1baea82ca1e736", + "0x0000000000000000000000000000000000000000000000000000000000000070": "ef397b238df4b06cf009bacffc969cdeb71e9d300c860286ca42ac367a950d15", + "0x0000000000000000000000000000000000000000000000000000000000000071": "9a191d0332521ea449a502780c73defd9d7726f61e22c2f527a03184a51364db", + "0x0000000000000000000000000000000000000000000000000000000000000072": "340fdec47cff7b492def7053fb1e31b0b185e4dbe7cd0f4b0d382a8dafed7ddd", + "0x0000000000000000000000000000000000000000000000000000000000000073": "821c99ea8afea16f7a10bfadfedd23466f35e9bbde9ec413c2c84b7c7dcc3856", + "0x0000000000000000000000000000000000000000000000000000000000000074": "5f07aa290e33f4c5f100362b8dfa284c93b910b9895f066fc2a6242698b6ed52", + "0x0000000000000000000000000000000000000000000000000000000000000075": "bbb17f7c60251f96dc948ee25b7afc5ee511eac82fe10ca186cb860349dacde2", + "0x0000000000000000000000000000000000000000000000000000000000000076": "29e7fcb64ad5f6c93603b4ce8d738253b71bc820c4d0ad9d5438ab5eacdd88c9", + "0x0000000000000000000000000000000000000000000000000000000000000077": "2021bdc5b47d00e0f11ec24e61aa59485311e5d98f657841de44e0d1750e0f2f", + "0x0000000000000000000000000000000000000000000000000000000000000078": "d169f3abbf7dd41949f941333a4920bc5246531e22d02fdbe8ed03361303bf13", + "0x0000000000000000000000000000000000000000000000000000000000000079": "9d39f6431f7fe252031d29d7ff4f65e9948d5fdc872709df7eee4e856c0a1a66", + "0x000000000000000000000000000000000000000000000000000000000000007a": "289c7906360262eebacaf52eae6931669dfb87141c14408ee41ccddb738dd7c7", + "0x000000000000000000000000000000000000000000000000000000000000007b": "8d2db945bede6e953aaaa66c1b859b0853a8a12cab8f9f88dc1439e1ff3ea600", + "0x000000000000000000000000000000000000000000000000000000000000007c": "66457f34ca4352d6bd07e3db8cfb4f37433c0f9e9d926d5fdbd1535974a28ee5", + "0x000000000000000000000000000000000000000000000000000000000000007d": "6afdc529eb5072bef6f94d783505d24465dbb564d90cd22e668c549929d19615", + "0x000000000000000000000000000000000000000000000000000000000000007e": "6d83bef72d2b5bae5824e9489cd9f98336df2e38500e48a8ef3664bcf9358374", + "0x000000000000000000000000000000000000000000000000000000000000007f": "16712d8be0e3f51b960bc8d1a39d96d79eb37a4c4ef736357367ea38a9287711", + "0x0000000000000000000000000000000000000000000000000000000000000080": "b97b02fd00e46ec8d5b47eac30dff86679166d19e3485e4b7f979bec91fa7e0f", + "0x0000000000000000000000000000000000000000000000000000000000000081": "c407ae41449bc17863646ffe04e7a8107b4a2145152c875a5f910fdb54cc2701", + "0x0000000000000000000000000000000000000000000000000000000000000082": "f2253cd37aa85a5a3332dd6d777d209db9644eb59806646a39dd5869cdc496cc", + "0x0000000000000000000000000000000000000000000000000000000000000083": "4185ee3fea8a5aef0c504563c6c4e08f4ebacc343720d6c179ab5cc24c15e1dc", + "0x0000000000000000000000000000000000000000000000000000000000000084": "a8c286786d85b5134461a58e930e24544971798fdb65aa5daf662cb224a9fe40", + "0x0000000000000000000000000000000000000000000000000000000000000085": "8ca47a4e017b39fcff33d45a2d8be59d4a66b73516c322c950a5d8ed77d29fc8", + "0x0000000000000000000000000000000000000000000000000000000000000086": "c4974092ba20d3c24becf83c675956c9f6602d500d594df532c50a50eb5b2191", + "0x0000000000000000000000000000000000000000000000000000000000000087": "d84d3edc5cce7692db143df3abed01f05fb1aa8a6e7b468cc55e46db10c821bd", + "0x0000000000000000000000000000000000000000000000000000000000000088": "dccdc1d4567294a4ad0281a7386e643435a612358a8687b79707541a0e572e58", + "0x0000000000000000000000000000000000000000000000000000000000000089": "9c338a73883a108eb3ac237422cc78ba03e073881d79758dccd91587b69164fb", + "0x000000000000000000000000000000000000000000000000000000000000008a": "cdd79ad9085d20d3fd31b042a53227c3760792c62e42f29a10400382b2d8dcc4", + "0x000000000000000000000000000000000000000000000000000000000000008b": "344657a467d897d67b16bf7bb922de11197ff1b4c1ea2749a82749b854f53e94", + "0x000000000000000000000000000000000000000000000000000000000000008c": "c34874c1c02df9d9f0f62ff0c9451be8623e01125af8abcdfb0a3e5fd39753b0", + "0x000000000000000000000000000000000000000000000000000000000000008d": "f26963dd24f2fddb0fcb041ffd520a4a8571622f70168563809051d1f78f5952", + "0x000000000000000000000000000000000000000000000000000000000000008e": "5b33c4a77a663f8420d206e8c8c677b306dd9dda3c549b73978c22385e064edb", + "0x000000000000000000000000000000000000000000000000000000000000008f": "c6e8d87cdf8be0370ba65cf1df31014d0ff6d70d4c63dec3968fd63c7fbaa74a", + "0x0000000000000000000000000000000000000000000000000000000000000090": "94fd8a5a17afb5aa4438bd72dddf23c73c0ed5059227e6d84a327e217593cb65", + "0x0000000000000000000000000000000000000000000000000000000000000091": "dbdf9af38beb3fa29d94941294bca3788732dcd92eb6b4bf2dbb822000cbc0b2", + "0x0000000000000000000000000000000000000000000000000000000000000092": "61355293082e8a9f906e7b52d9d7770877083021e6486ae90f63b2e4bccff11a", + "0x0000000000000000000000000000000000000000000000000000000000000093": "0e1c46da0dfdbdd801d7b76c10462b10a1ff579e5f26535bcd3ab1c482043abc", + "0x0000000000000000000000000000000000000000000000000000000000000094": "049cc427707b87414178123334cd9ccc891c192faddb16129b8d87dc945d4710", + "0x0000000000000000000000000000000000000000000000000000000000000095": "24e92a19adbe76129e31fa0e7968f3f65f230ea20152fa92bd8553a90040f415", + "0x0000000000000000000000000000000000000000000000000000000000000096": "34e0ff9f154ad49785b9a2220d5dcdb476e3cae2c513209d0dc88bc65a3a327b", + "0x0000000000000000000000000000000000000000000000000000000000000097": "a038ce1b4343a5466e32f10fc868b23f7ced36538dd115cdfe0deac9f6f21402", + "0x0000000000000000000000000000000000000000000000000000000000000098": "4f6d29ecc1150caa2e43a7837fc7fc577bcda7cceb9de4da0c2e9da8baf8733f", + "0x0000000000000000000000000000000000000000000000000000000000000099": "d34e3051d7184c6c18e3d51f0a693baf889da9ae98d6a5e777a22d2cb96697dd", + "0x000000000000000000000000000000000000000000000000000000000000009a": "eb5370ab05f5d8f13e2cc9a45d11eccc1ee7537478e749105b03631c2504d6cf", + "0x000000000000000000000000000000000000000000000000000000000000009b": "e9419065bedd423519028a6f39e599358596a72614880942181ef4d3fbff8807", + "0x000000000000000000000000000000000000000000000000000000000000009c": "076da0f0e01bfd4890f2134fd5df4b54a113439e488680ec9983b81de6178a43", + "0x000000000000000000000000000000000000000000000000000000000000009d": "1b765e0e7ef21700d430daf30c1fb898805cf27237768ae58dd82f68cd1cc26e", + "0x000000000000000000000000000000000000000000000000000000000000009e": "6dcc010b937b7e48545d5476b017e93f0baa2308ef3be862c1c6286911eb63c1", + "0x000000000000000000000000000000000000000000000000000000000000009f": "616a767f1417bf61770bdd4b9947a864fadcbda76a60ac901115b74f55948b81", + "0x00000000000000000000000000000000000000000000000000000000000000a0": "90f962233f21820cbfb476d1e7b58191e31a745b143fe000a7fdbfb636295ff5", + "0x00000000000000000000000000000000000000000000000000000000000000a1": "9c02e583208597dda2607d80ca5dced296b7245635677699871833053f4561b4", + "0x00000000000000000000000000000000000000000000000000000000000000a2": "b298175a8ca6852255acb5a528906d85a5d33fbf66c70cb786877f4ca844a7b6", + "0x00000000000000000000000000000000000000000000000000000000000000a3": "cdb49313f08242666708fd58106cd77d39cac694d5109d6292d5205f0eab8cad", + "0x00000000000000000000000000000000000000000000000000000000000000a4": "141eb84f21835812981ca866915b141c199b2a6e574624de1a35b28784d70e31", + "0x00000000000000000000000000000000000000000000000000000000000000a5": "ee6b0ee8c674e6c358ad14a9dc39c9ade98b944a4c3c97992bb882f536e976d5", + "0x00000000000000000000000000000000000000000000000000000000000000a6": "56a342018c122b38dda95d4590e3be13521d9b293a469b089eec358c040cca09", + "0x00000000000000000000000000000000000000000000000000000000000000a7": "e08d69283e46660cc7d2ec2297498bea4fc2d9e6be5a966fc62d8cc0bf79eb8c", + "0x00000000000000000000000000000000000000000000000000000000000000a8": "06cfd65e4ad3f00b853db8c0218f003e65ecdfa83b2cf36be05da03c9abd2b8d", + "0x00000000000000000000000000000000000000000000000000000000000000a9": "1eaa31322ebe3166d05d4aaecc37da61443ec14bb10abea11a0de6271ceaac31", + "0x00000000000000000000000000000000000000000000000000000000000000aa": "861e741db3d23647d8a9fc61ee8361b044ab5f6472a15e33e1347d26802ae652", + "0x00000000000000000000000000000000000000000000000000000000000000ab": "2cf03f61b899f9e1da26b010eec455dd52486700e03c7ac6dd5aef77e1d0ce4a", + "0x00000000000000000000000000000000000000000000000000000000000000ac": "63c823f9caa95abdf5aaeaea7d33753359ccd4b76e64155a760bf3355edcc73c", + "0x00000000000000000000000000000000000000000000000000000000000000ad": "8db5431f9466088e255da8a3ba2c8687e71836d5d1945b13c7f3d9ac7c89632b", + "0x00000000000000000000000000000000000000000000000000000000000000ae": "0233de4a61a9a43ed4501eedc83ae61cc6b2f31f7681bb1de10650f724635917", + "0x00000000000000000000000000000000000000000000000000000000000000af": "899b58ec03cb142e0b55e1fe0ef6c351291a27b9074344bc7e2cafa96373aef6", + "0x00000000000000000000000000000000000000000000000000000000000000b0": "13f99454d41f5ac10fd52abd046cde67bb8c0bf7d6010c6b17c465ecbb3ed540", + "0x00000000000000000000000000000000000000000000000000000000000000b1": "9a2024c4823f8c503a053ffba21d3d5b8aa44bd69e0e326a3dd861d5ebacbbc5", + "0x00000000000000000000000000000000000000000000000000000000000000b2": "97fc752f97b39827ba60179602671d30c1f05bf991650cac51f0346ee24d733d", + "0x00000000000000000000000000000000000000000000000000000000000000b3": "30a494978e0eac0abda5140961431834ace71b6251f4c533c823913efd652aff", + "0x00000000000000000000000000000000000000000000000000000000000000b4": "6b5d54fd2861b26dd7f2851d7e5370a10006dda6c3030e6d3ec4165516e939a9", + "0x00000000000000000000000000000000000000000000000000000000000000b5": "4b463a47e277fe903ef73f2504075e63194e03017c299bb340ca82383bc93110", + "0x00000000000000000000000000000000000000000000000000000000000000b6": "26fb93f17f20d3912165be93e6c74e30ce01bbd23b1050dc2b0e990810ad8ebe", + "0x00000000000000000000000000000000000000000000000000000000000000b7": "e08e97c0e494b917d5103858981ef94e7c83ae607274785cfa6e1d58fbeb5ac7", + "0x00000000000000000000000000000000000000000000000000000000000000b8": "de6bf1db842cb83446e36edc46014d23163fd84aebd1c03939eb0bd290767afd", + "0x00000000000000000000000000000000000000000000000000000000000000b9": "6bde1987ef5b8bb5fde73ccb7b722f060ce2d5f1f3cf0744498e2eded6ad2fbd", + "0x00000000000000000000000000000000000000000000000000000000000000ba": "02795b8afbf3b9cd3539cf5e1c373c07ef6e1be6f4deb1fdbbd6cbe365387dc5", + "0x00000000000000000000000000000000000000000000000000000000000000bb": "8e4c83e5e358f39de84987818cbd14c1a963ed5c8de83717bb6f89d11ed0ed65", + "0x00000000000000000000000000000000000000000000000000000000000000bc": "2f741c1a54dfde09c36f6f171be91f7cc50a184e29c875af602ef52ed58e6e89", + "0x00000000000000000000000000000000000000000000000000000000000000bd": "7d60f33d7e776182fce5bd0572f488cd429e742705eb78603179446152aaec20", + "0x00000000000000000000000000000000000000000000000000000000000000be": "822c072433cf13fa896fb579c98e53f0ff3d231f10168b07647d214b5e2a0c24", + "0x00000000000000000000000000000000000000000000000000000000000000bf": "c763e36a2d4a71b815dd3cf970327db148b6f24eb23522a4cd962848679f683a", + "0x00000000000000000000000000000000000000000000000000000000000000c0": "2ed48a4ebdefc743bcdbec0ecadc64fa641776a8ad70df8e58c6b29bf6c1a23a", + "0x00000000000000000000000000000000000000000000000000000000000000c1": "1e23bc483f7c371d9ebf493ba84b563479656771fe17f2846fd9c863fc9cfafe", + "0x00000000000000000000000000000000000000000000000000000000000000c2": "e61411b998dcbec97ad2ce9bca20014fa673980d1e884325c1075abef61f152d", + "0x00000000000000000000000000000000000000000000000000000000000000c3": "f24e0907bc9948667699c8f9094931f930f8617e5eafff2271656cfbde5c2956", + "0x00000000000000000000000000000000000000000000000000000000000000c4": "9587ef58a068fcb27daff28ee3da231caed47c7efa9371fb42b14fc9908767b5", + "0x00000000000000000000000000000000000000000000000000000000000000c5": "035aad19a0a2ed13bbbd78630f35c556bfe04d7a89bb2fdbe485ad344e6e81b3", + "0x00000000000000000000000000000000000000000000000000000000000000c6": "5124774422b19463745f7a5aa4c1399d3e8c13abdf68cd0eb70477ba79b3bfd4", + "0x00000000000000000000000000000000000000000000000000000000000000c7": "a467cc633a88b190c7c454be97d066a22527ccfa3784a6d0eaebb099363da22a", + "0x00000000000000000000000000000000000000000000000000000000000000c8": "4b395a1569a2995fc5ad6e079e367cd135ae61be2315a57336faec96ff6be4f2", + "0x00000000000000000000000000000000000000000000000000000000000000c9": "f3574c46ee7be2f327b4c968186b9cba6ce8bc43cac0917119e3226630ac2e40", + "0x00000000000000000000000000000000000000000000000000000000000000ca": "4b92c1e975dfdc44423fea09f15c0b0f6cd94b52f75eadaf500817dadfedc05e", + "0x00000000000000000000000000000000000000000000000000000000000000cb": "5f7c14e45a99709c6dd5b99043f115777e3fa2aff9baea04e819c8ea1d49ff4b", + "0x00000000000000000000000000000000000000000000000000000000000000cc": "a6a548359521b4b239f05fd8001e74c3cdec873dccbc6e9d558942720219436c", + "0x00000000000000000000000000000000000000000000000000000000000000cd": "2fda609eaf660679f823fb4376c4bd0cadade83e2fe577f82d1ab3d9f0f42699", + "0x00000000000000000000000000000000000000000000000000000000000000ce": "a8551de9ee0942059b85b3390a4a8e2b4717e843f5338062877d9a125e1c5d62", + "0x00000000000000000000000000000000000000000000000000000000000000cf": "1cd2293c5df7c51a36bc8527308cfde43dde547b42129799d3f9f94f4b2a5d8a", + "0x00000000000000000000000000000000000000000000000000000000000000d0": "bc42869ab3a2245d1c7a2d33a982c8696aab3d3c0f9dfa69d8be2d2cc9cf1d31", + "0x00000000000000000000000000000000000000000000000000000000000000d1": "8e8b607660e0016ba139872bc35730d2efe0426136dc7e32ef6091f2c72acf50", + "0x00000000000000000000000000000000000000000000000000000000000000d2": "85ad1ea8a6413676241be28adc37e9e9eafc7d7d92838f662f89e954b1946243", + "0x00000000000000000000000000000000000000000000000000000000000000d3": "43cc37e72c9060cd84480dc2b3ad47b73ae9d3153ef17aaee77426eaea98c979", + "0x00000000000000000000000000000000000000000000000000000000000000d4": "52cb7c3d0a4baf4b97c814f69a29ce7efd02b30063caeb4dd25182e4945f9443", + "0x00000000000000000000000000000000000000000000000000000000000000d5": "414140870ecffda2fd30789856025aeeeee6ed2d339c89b09142a80b5d02b2fc", + "0x00000000000000000000000000000000000000000000000000000000000000d6": "6d091cc14eb2771eda246d6c98884ca88b3e9c1193f9b1094786e7ac38615d0f", + "0x00000000000000000000000000000000000000000000000000000000000000d7": "c2c1970e54d67656e78c75f59b990d4a682800dac92f32e35bbf5c9f4123080e", + "0x00000000000000000000000000000000000000000000000000000000000000d8": "9869f9d317befc2be06e35c4bb421b2f70ee3a551da726ac450fbe5683e175e9", + "0x00000000000000000000000000000000000000000000000000000000000000d9": "6cd3151a665feb73ef2fd1c09b2ba1dd622e424cf8d437491f67d7acea386a25", + "0x00000000000000000000000000000000000000000000000000000000000000da": "f12671c7915ba944f549618aa1a618c58890d1bb1374ba0d5bfe9a1d219d4e10", + "0x00000000000000000000000000000000000000000000000000000000000000db": "2cc973d866118aeeb5d5a45bbda5f59f56d1824d01605eff38bde4ba082a2953", + "0x00000000000000000000000000000000000000000000000000000000000000dc": "633313f0428dac31c59a736f610f5da75f22d0c2ea8d112987c918c7405c0440", + "0x00000000000000000000000000000000000000000000000000000000000000dd": "ab9619afd1e6619dbab5761d6fc5da9a0fbf8b6489fb96eb864e687bbce7952a", + "0x00000000000000000000000000000000000000000000000000000000000000de": "827cf63f6f1bfebc2c18dc37c641eb9038174492ce580fc881027cbd447dde09", + "0x00000000000000000000000000000000000000000000000000000000000000df": "17c4a736b0ea52a0a4f64166d211b654d10c8a6b316b7a3d151c84f1afbe2cfc", + "0x00000000000000000000000000000000000000000000000000000000000000e0": "c7d92e27e6635446bbbf148991143322dfee51d0c6923abdfe69a9661aa51f3f", + "0x00000000000000000000000000000000000000000000000000000000000000e1": "7fd92767aad5a519ab7a1ee8f06e62a0869042dfaf4aba3b9e47037667137147", + "0x00000000000000000000000000000000000000000000000000000000000000e2": "508e549615fc6041f7c0737e69a19b2a78954a3b2e401c1e6cdfcd065f591170", + "0x00000000000000000000000000000000000000000000000000000000000000e3": "380fa604fda76b136b8d0cd29fdd1d4d947c90d328e70679c89d25fd46e30e20", + "0x00000000000000000000000000000000000000000000000000000000000000e4": "a3e71744d3faa5f9827963a5f0d659487a2d102a538122e75395ec771100c68c", + "0x00000000000000000000000000000000000000000000000000000000000000e5": "cf2f9ba00e585e8346fe60f6bd23d83f81f57b272f3d7ee803aec61e3b66973e", + "0x00000000000000000000000000000000000000000000000000000000000000e6": "66730b682308530fd5172418ae2100a58c0c78d8e2a4cf3962f74bb5d08a2ad1", + "0x00000000000000000000000000000000000000000000000000000000000000e7": "4138427f2aaf856de7604cae4193f96636c73e0a8984e967f88eeb9cb9868235", + "0x00000000000000000000000000000000000000000000000000000000000000e8": "ff6c572142173aee3cce05872637e9fa20576e126122f8f096b26c2d7ab562ca", + "0x00000000000000000000000000000000000000000000000000000000000000e9": "fc3daf2feab4448c624c2b6de75cee4ba8555bfedb236a6dabd08625ee75fb8a", + "0x00000000000000000000000000000000000000000000000000000000000000ea": "56a716225b0c189b6dfe04eb8dd9012e50bab4fde5c850b3ac032b0bb74c5916", + "0x00000000000000000000000000000000000000000000000000000000000000eb": "5fb1bbafb479d9b6bb8f0d6a832717b2d585af05d70edc9938597e9c349ccb1e", + "0x00000000000000000000000000000000000000000000000000000000000000ec": "520f6482328ec8e1a2d2f759d3718f9527046b4eec351d127b4d10920ae7c02c", + "0x00000000000000000000000000000000000000000000000000000000000000ed": "89d7de3b3cc3f788c75f502ad3c5194de01d53e6d01675bb8e7319084bb044e8", + "0x00000000000000000000000000000000000000000000000000000000000000ee": "ea6c0f8842754decf0722e63340f9ce8fbe8d0ad696225c4942eeff7c815cfe3", + "0x00000000000000000000000000000000000000000000000000000000000000ef": "ff641c571c4ee7c6ad4776d9e6a619e15a9e9c68173a576adeb39a4d6b7cbcf4", + "0x00000000000000000000000000000000000000000000000000000000000000f0": "c0c2d5bded8a29c205781c8126d07498355257ffe0b0a9c63513891158703356", + "0x00000000000000000000000000000000000000000000000000000000000000f1": "aee5da2562edc43aae63fdbfcc1ed4a3b9584d31b515a14b6c9e974cbdb8dd29", + "0x00000000000000000000000000000000000000000000000000000000000000f2": "6d56c50e850214cd81f339f0febfcb4874950f0a6e6c541f448c0dd83bbdec6a", + "0x00000000000000000000000000000000000000000000000000000000000000f3": "a0e695a82a49373c16acf2ecbd742c53ea37cadecc6dfd681e6b393bdca6c445", + "0x00000000000000000000000000000000000000000000000000000000000000f4": "ee14abc18ab909a3c3ff3afbccd5f0b3844727f10754428c44a7c8898f8343ad", + "0x00000000000000000000000000000000000000000000000000000000000000f5": "5964eed483298c980e3372a7adab0e90ac671c5bb0fcb80e481a6fd533851ed6", + "0x00000000000000000000000000000000000000000000000000000000000000f6": "9093cd0fdc936c5e1a1cde72e4327a8b042d0153d3b268b5441631496ab5b897", + "0x00000000000000000000000000000000000000000000000000000000000000f7": "123f2c0202f5d919d2376513b9d5c5c9dceda4b91e6fd70f386d0d88ec067885", + "0x00000000000000000000000000000000000000000000000000000000000000f8": "03599481645edb627d61df608525160e3ea5fc6081aa353bdd9828b21f314c63", + "0x00000000000000000000000000000000000000000000000000000000000000f9": "b70f87f8243cc700afc179251e201ce53395e86cb99d8f2de002488a632f765b", + "0x00000000000000000000000000000000000000000000000000000000000000fa": "c4bf5494f56bc45ce01dad37aee3ce9ffc45d83fdc000e12181f5f8acb8019cd", + "0x00000000000000000000000000000000000000000000000000000000000000fb": "4a451e3d5c50c59b8f500744456ddbc1305fd7d30a3088e18b63ab514e146a5a", + "0x00000000000000000000000000000000000000000000000000000000000000fc": "7e09bd28fdc45aa33de70b9cc577566820bcc691bb602bb4ea34c060240a3a34", + "0x00000000000000000000000000000000000000000000000000000000000000fd": "6b8f79e73655d6e6bf62130982a8130929598f06e537104557fafb585ef859aa", + "0x00000000000000000000000000000000000000000000000000000000000000fe": "2f59eb73c385708d16bfbdabd173a892b1aedb35aef605b39bf4ecb37e5f4d81", + "0x00000000000000000000000000000000000000000000000000000000000000ff": "dc795b259c72a03503f2caa5002867f7321785d36a0fc325f23c6a7f0b5bc910", + "0x0000000000000000000000000000000000000000000000000000000000000100": "271a4760953153009f96bed8d964dfa87d6893d05200beca8c28b05661a749a0", + "0x0000000000000000000000000000000000000000000000000000000000000101": "a01a3f6a72dc1967245123b06ac7eae459690d7ef3a4d07700c0e3745a74db71", + "0x0000000000000000000000000000000000000000000000000000000000000102": "e098e6bdfcbf458b4139ee1ebb140d43f6d606f540d989eba5b8b97435bff5ae", + "0x0000000000000000000000000000000000000000000000000000000000000103": "8820f152b3cff23de1f3b9447dd120cdc4db4b52be2289b8addfd158c2ad60b2", + "0x0000000000000000000000000000000000000000000000000000000000000104": "9055974f536a57910076dff54ffff9856ac72456315542541730ccbd2f24ea9e", + "0x0000000000000000000000000000000000000000000000000000000000000105": "7102af3da7876aa9cff2e92b872cae97f9eaca3f19c6b184a9000d27dbca4e74", + "0x0000000000000000000000000000000000000000000000000000000000000106": "d50ce3a9f526cc3f15e8938ea731693ca87130f6ea684d06e3df024c0c2d298b", + "0x0000000000000000000000000000000000000000000000000000000000000107": "e87cffe7581ce382f9231fd3e5f6c6dd15670fac36f758bcaf841c44459f882f", + "0x0000000000000000000000000000000000000000000000000000000000000108": "4b2ca2c24eb4cfff7f4ea2a8657efae77d1f12850557b1b3cedaf5326498a476", + "0x0000000000000000000000000000000000000000000000000000000000000109": "6442f9445011c3fabe60fa667b6d3312a035f8b31ba11d66784657a7b1610e67", + "0x000000000000000000000000000000000000000000000000000000000000010a": "957a973ad8b0b3e200ae375441704b26ce89fa5056a66550359b34ee91a2a0d4", + "0x000000000000000000000000000000000000000000000000000000000000010b": "714651f961e055fb12c089df6e5c83f279400bba685d20810303f77984712cd0", + "0x000000000000000000000000000000000000000000000000000000000000010c": "0b3f682d9d441ee52d4a38112d385f970973958bc4586ed97a2ef47a202aa38f", + "0x000000000000000000000000000000000000000000000000000000000000010d": "d6a33b58b1e38fe4ac1c3386de7de4d1db23f14871f1b0a6163750738a6844b4", + "0x000000000000000000000000000000000000000000000000000000000000010e": "7fc400f7b6c69771e1a1dd0fef6a7fcb25f9d4a2160f28c2c20ff5c8c5557396", + "0x000000000000000000000000000000000000000000000000000000000000010f": "d40c0450e901d3193859726272a91036198d0bb55438bb30e7e2ee747bf90d07", + "0x0000000000000000000000000000000000000000000000000000000000000110": "b56358c5f0686a2af5b2569179542237964b481269f589871f1d0a8494b22716", + "0x0000000000000000000000000000000000000000000000000000000000000111": "6db49261c82dcd68dbd907e9ae99e60e8b60a144e20fa40bc9760e6af5ae95ab", + "0x0000000000000000000000000000000000000000000000000000000000000112": "295a8e852bcd10264566f53a7c2b7010d082476d400aeee5d1067c6237964b33", + "0x0000000000000000000000000000000000000000000000000000000000000113": "59c54b1678dca13353be6cbe9090244300dafeeaf924758a74eccaf5d8e83cbe", + "0x0000000000000000000000000000000000000000000000000000000000000114": "62434faab09991ba4832b647e7260e305c48a47556068e84a5a0f8d1cd23ca0d", + "0x0000000000000000000000000000000000000000000000000000000000000115": "9852b90c33582df6fce102fb4e211a0e0b391b486dd80752560076c200aedf9a", + "0x0000000000000000000000000000000000000000000000000000000000000116": "65240654f94bde1e2d244ef74fc438f08b54b1e9faecc7ec1ca49a7ba83ce5ce", + "0x0000000000000000000000000000000000000000000000000000000000000117": "9f54ff65564ec9e51c194c32c07d73fa64f558ae0df769401105131d1f438d44", + "0x0000000000000000000000000000000000000000000000000000000000000118": "1e86080bc89bddf96fd5508dc58502c9062a2d3e496aa859dd0b10ed033ff085", + "0x0000000000000000000000000000000000000000000000000000000000000119": "5cb14068ec9e99fcb6e8e78e64cd2aea94f667888a9aa540844dfe0bc8a375dd", + "0x000000000000000000000000000000000000000000000000000000000000011a": "44aeef6943cd37a6ffff1de2e0904beb164a461631b591993ab85ccb86abf4f9", + "0x000000000000000000000000000000000000000000000000000000000000011b": "61e5376ab0b484c9dca320837e8bc9dada91f2d60b550767d26adf500f5df996", + "0x000000000000000000000000000000000000000000000000000000000000011c": "eb675d937511476e7fcc82eec7615c2910d74026ae57a3fd9e144ec4afc45a00", + "0x000000000000000000000000000000000000000000000000000000000000011d": "1cafd78ec641f4af5d4f70f2a69c94688dab74feb7d64115401f7cafec61c7e2", + "0x000000000000000000000000000000000000000000000000000000000000011e": "437f7e43e11d7d3c69a7449e6cf3bb70f85495c6f84326ec4300833a445c7d8e", + "0x000000000000000000000000000000000000000000000000000000000000011f": "28c467c36d5a76c1f47784655e0360553564b11d092613b84636d27c005a64d9", + "0x0000000000000000000000000000000000000000000000000000000000000120": "dcfb02fb51c962c7da9968cb094da0deead9be715cd80fe4edb15316afe5abd3", + "0x0000000000000000000000000000000000000000000000000000000000000121": "54e726c63980affe15f4fcbf0649b8839b2cec81fb03ff9d4885c49c0c13e49b", + "0x0000000000000000000000000000000000000000000000000000000000000122": "0d07c9bc86d9d0dd335a1d0b4af655218071687d5aa6a1bee5c9dcf69479624b", + "0x0000000000000000000000000000000000000000000000000000000000000123": "ee4bde5bb8d77b4d171c88650704849bc8308792022a9e0df731a264b6d986a7", + "0x0000000000000000000000000000000000000000000000000000000000000124": "ed908adb5661b69ea32366f362a10182a478af8b7ae01a870be3ae36c0a4138e", + "0x0000000000000000000000000000000000000000000000000000000000000125": "2aaf777b8b9baa765e6c315b77d2ed0bf12654e466a9f5d9a4b3892c34d346ef", + "0x0000000000000000000000000000000000000000000000000000000000000126": "833f91460ba1a4d3754963b49508167d180860494029996788dfe0a4b7c1898f", + "0x0000000000000000000000000000000000000000000000000000000000000127": "55415e30e330b78eea4143896ca20531aa466962f9e7c270892c0c82b9dc52e8", + "0x0000000000000000000000000000000000000000000000000000000000000128": "3fbfd523742f263285774e53c795a95cd422dfcab3af25a98440ef2d9eaded1b", + "0x0000000000000000000000000000000000000000000000000000000000000129": "360482b09341ef1eb6bd12fbc2290c17fbcc72f8f1128a1f0eaedd6da6350c60", + "0x000000000000000000000000000000000000000000000000000000000000012a": "e1a596d7fe5e0df44bd95f04d6e52f6942a3ca81f2c339e69436a1ab39b6cb96", + "0x000000000000000000000000000000000000000000000000000000000000012b": "ab15736f5f9a88b9ee82577680039c70f6ee7a1a45bcef23aa00ad68f2c4c3c1", + "0x000000000000000000000000000000000000000000000000000000000000012c": "b09555539b48721618134671e9f09ca11c3473b6c972eefc61f7bf6e59901843", + "0x000000000000000000000000000000000000000000000000000000000000012d": "fd0af364faeb502cd7a06b059c730040c89c4bb60af5f9e432062745c47a1c76", + "0x000000000000000000000000000000000000000000000000000000000000012e": "ccc479403433e4222f2c1886e3707712822a3ac130f37263b277d7f42fedf93c", + "0x000000000000000000000000000000000000000000000000000000000000012f": "cac6455fec57cb7705d097952412eaa1e3984c8a50f703d4dc84d990e099ce9e", + "0x0000000000000000000000000000000000000000000000000000000000000130": "c2497bf1f6196ab87d85a9b1ea008b60687721f7bc75ab3fbf8de50d455baf03", + "0x0000000000000000000000000000000000000000000000000000000000000131": "42690f0496662b95458544ff5fa9db8e9839a90c142ba6e211b2ad2fd19a8bfa", + "0x0000000000000000000000000000000000000000000000000000000000000132": "5dc6a2e4dea9a9151cfb8dc58b8ad3e2e2c590f73ef3659f24bbd1484f5f51ca", + "0x0000000000000000000000000000000000000000000000000000000000000133": "170d3dd10df213b71da46b8d94023a22e58c3366eac78c70b095fbceee126712", + "0x0000000000000000000000000000000000000000000000000000000000000134": "42e46e023d7d24d978c93644717729a7fdcb0e07c67e390a2c6699c4cb7fc7cd", + "0x0000000000000000000000000000000000000000000000000000000000000135": "a7c1b6d6c5d4fc516c4b7a9e6917a1929957edf45107e164fc0768578e4e555f", + "0x0000000000000000000000000000000000000000000000000000000000000136": "0762831f8a197faace5f89136d4e8fd2bdbcd634050bb8c28593c6f62769c2f6", + "0x0000000000000000000000000000000000000000000000000000000000000137": "b534a77d9471e828befa7adf86678b4a7a928e2a2db3e9ccb919eb0d2e2d7131", + "0x0000000000000000000000000000000000000000000000000000000000000138": "797081f69a1e07e62ab7d70958e3840489579027770db2acd79ab7da50c5684e", + "0x0000000000000000000000000000000000000000000000000000000000000139": "0ad3abab22df80481936bb2a0d8b50a807633495c41ede9d1570c25b59fdeaa8", + "0x000000000000000000000000000000000000000000000000000000000000013a": "5d7d1a0c180dbae5272ccc6e6c01b45960408a2205e36e897320813cc1627af5", + "0x000000000000000000000000000000000000000000000000000000000000013b": "457cf3e561354b6040afd9e0d386b3fea81719cc40b3fca29fc4d4f99be875f9", + "0x000000000000000000000000000000000000000000000000000000000000013c": "4e8f0489aada99804a9c89679ee1fd98cf0197713766bbb480c77970a95f3f5b", + "0x000000000000000000000000000000000000000000000000000000000000013d": "8df9fb79d5b59f66814970a325d025e1e059f33616840d45bc73ee25a40f10ee", + "0x000000000000000000000000000000000000000000000000000000000000013e": "1da2f81639c8614abf6f4720da2ffca4a5557ae2c62f68948a325f08dce60a71", + "0x000000000000000000000000000000000000000000000000000000000000013f": "378d38c1343aa2703f647894a5fb7330de9fc0e363c86f55beee5d8d66e1d714", + "0x0000000000000000000000000000000000000000000000000000000000000140": "a2f88ca8a8ab5ef26e33eb38b5f28edf9349afb29e5f1a8435c070fbc8df25ea", + "0x0000000000000000000000000000000000000000000000000000000000000141": "54dc888fd505259107b6574dd8a20a802deb1d07bb9728a54d74795789454270", + "0x0000000000000000000000000000000000000000000000000000000000000142": "e9b56ec487c3b9eda677017acd8c89f1a995b8edca20949d5492bd47f1278705", + "0x0000000000000000000000000000000000000000000000000000000000000143": "411ec72e0e4ba3c70825d4d76357e30b010815babbbc1837e2c70006d33e809b", + "0x0000000000000000000000000000000000000000000000000000000000000144": "f92cd7abdc875dece612e2568996c3d03cef02faaf7b0924665b97123207f9a6", + "0x0000000000000000000000000000000000000000000000000000000000000145": "445c164c66dbe2d97e415132e6519d7765d441454461655d1bc2fef9a5233720", + "0x0000000000000000000000000000000000000000000000000000000000000146": "fff2ffe2e7354436e669edcbb6301ebde9eb5d415e4dc27166e7a301463ead0a", + "0x0000000000000000000000000000000000000000000000000000000000000147": "3783621d2f500f95d6dd1f072a06f3cf7776c9b364a4d986b644f9084dc27e5d", + "0x0000000000000000000000000000000000000000000000000000000000000148": "c292d2df68caf410c52129638905a541d121618c637b4b6e401ae5783369b805", + "0x0000000000000000000000000000000000000000000000000000000000000149": "18c79f9a20b1eb4d040190838ad1ecb9401a4d7c6aafdff548163fa0e81a2312", + "0x000000000000000000000000000000000000000000000000000000000000014a": "079a82efae89bae7dc9f51d23fe219551e0e8dc8d8a1783163ce664741d77c9a", + "0x000000000000000000000000000000000000000000000000000000000000014b": "bf3d02ee23b46b03fe7a0cf3e5ab2709608d2d6c237357932b73caf7bd0e5962", + "0x000000000000000000000000000000000000000000000000000000000000014c": "8f34050bd77c450b1684065a6d47f74e03a13366670639e0ffc82ce56190e7ad", + "0x000000000000000000000000000000000000000000000000000000000000014d": "1dc2e1bdcaf6cbc04adf6f2a0bec9df3fb5148469ff491701db0d36a3ccb5561", + "0x000000000000000000000000000000000000000000000000000000000000014e": "03399daa6b9a5022b6c6ef393204ddd994dda29cc67998c0dbc1df5f2c7df9bd", + "0x000000000000000000000000000000000000000000000000000000000000014f": "ccc15fd8ddf55d7c8eb75b38f01938eab69a8286a525182fa302c34738c401a8", + "0x0000000000000000000000000000000000000000000000000000000000000150": "5f1a9c738684387b66a96f080ed4606ca3b54cc6ef8fbeac69197d9d0ebc18d4", + "0x0000000000000000000000000000000000000000000000000000000000000151": "fdee8c650dfb4cf5fce50480224694b856fde37082e78eb3c82971a2a010f62d", + "0x0000000000000000000000000000000000000000000000000000000000000152": "8b6e1a97ed0b60399797bc48fdc165d7bda6b855f94691276d2e5068d44e0aec", + "0x0000000000000000000000000000000000000000000000000000000000000153": "3f9354b48f2c7bcf684bcb6ed3a7635eaca6ba81654a3fc3e4c7273c61b28583", + "0x0000000000000000000000000000000000000000000000000000000000000154": "54553da46a588f6dc14580c6ccb5f2ca5c6f6a189dc465c0d4d84ad2c9749a4d", + "0x0000000000000000000000000000000000000000000000000000000000000155": "565a7651bb85599dd4e8bb9deea8c1068fc0525ef77a602875c0ee4c27ecdc3b", + "0x0000000000000000000000000000000000000000000000000000000000000156": "5a060514a5987fb5defacc69d60df530d84825bb7102f52665c197a5b7cf0d3d", + "0x0000000000000000000000000000000000000000000000000000000000000157": "37a95c1c4d8ae9548f7abf278b6d3c8fd6abce3ad831527a483b585ae5574496", + "0x0000000000000000000000000000000000000000000000000000000000000158": "02bf4c87617d99c78ee4061fcad0436ec41d1feb5768436917aad995dc1a5c46", + "0x0000000000000000000000000000000000000000000000000000000000000159": "1c88871de6d44ab71e79a3fdbe2e43604daf0194b3a02e1a90337e837201b57c", + "0x000000000000000000000000000000000000000000000000000000000000015a": "e65b0ebcbf8e53e362f198d5286b3be688e04b74109af7e41ba28fc4d7cb5df7", + "0x000000000000000000000000000000000000000000000000000000000000015b": "675cb4223640eb85c8810a74a6fb0820d86a138a1eef666f1a22d27ba1ce730c", + "0x000000000000000000000000000000000000000000000000000000000000015c": "05276dd8169c6699371aea9e2758f23c15c2739166b91fd5f8556101b4bb3f21", + "0x000000000000000000000000000000000000000000000000000000000000015d": "2bb6a28a333d633baef19929640188c26f70dfd798c0948bcb81f7b48b7e6f83", + "0x000000000000000000000000000000000000000000000000000000000000015e": "418ac48b8467db2e040a7b57b9f81e3f5295077d62988735ef5db301e4312d85", + "0x000000000000000000000000000000000000000000000000000000000000015f": "d97364746b3c009e86e4601ea8a4ec3eed223a070b3b343b33ad8a121708aad7", + "0x0000000000000000000000000000000000000000000000000000000000000160": "915b1161ecce056ce9b09ad20e535ee47578a868802d36a1bfa38ee437beca07", + "0x0000000000000000000000000000000000000000000000000000000000000161": "4f58b596ab05605431d3a936043301eeda09adbfa46a3c02e452abcd988f4b34", + "0x0000000000000000000000000000000000000000000000000000000000000162": "318aec788d4efe4aba9138446d6aa0e292c18554eb34a15b827c22188fbebb46", + "0x0000000000000000000000000000000000000000000000000000000000000163": "4401d3aa9f1ff873ad2aab1d705c874c41cb5bf206ee59eed2e5daee6c6410e0", + "0x0000000000000000000000000000000000000000000000000000000000000164": "ea7938e34260a926ccd50ce03f9d1f387948af9b961c6f48ceb76ebbecaa2658", + "0x0000000000000000000000000000000000000000000000000000000000000165": "08f4cc7edd04bd308dc6e7bf4cb07b806e7e2de61545abd1f51f9ad1d59cf75a", + "0x0000000000000000000000000000000000000000000000000000000000000166": "a00622d4741d5328d26df1a386bc743d636523cbfb4ae132ef9973770be54646", + "0x0000000000000000000000000000000000000000000000000000000000000167": "9f5cf2010cc5b11d8e26387a3dc7871353fc465161e0179d7a022e7fc216d894", + "0x0000000000000000000000000000000000000000000000000000000000000168": "7bae673e78c9468adcbc5af662fa1a64303269928a74faf206c36e8e90d39e9f", + "0x0000000000000000000000000000000000000000000000000000000000000169": "f5c8e55d5ccac994718819a5e84706912e3a13ed1138af213068a1dfee7333fc", + "0x000000000000000000000000000000000000000000000000000000000000016a": "5ce347e7492dc1fae5a790ee38bbae921fa4c33c12d9728102107ff2242037df", + "0x000000000000000000000000000000000000000000000000000000000000016b": "704f8986273e3ddd2829747071efe079b0ad626aa5ce53ab8b881fe2dae20407", + "0x000000000000000000000000000000000000000000000000000000000000016c": "8b372f1d731e91f9e3e65d489488e2f5256c2db193d27c80adfd7500930bfed8", + "0x000000000000000000000000000000000000000000000000000000000000016d": "8037a2e6778f5a2f86243f0f68e1dc27711a83e23f17dffeadba79650efdc061", + "0x000000000000000000000000000000000000000000000000000000000000016e": "83b55c0c81d1b9e925dd8ded23f5d620d5c90ff0669978808bafe0f9cf4fba4f", + "0x000000000000000000000000000000000000000000000000000000000000016f": "47d1a1fd87ce37b222c945a0926df5db04b51f7cb7bbab3b5038aa755aecd57d", + "0x0000000000000000000000000000000000000000000000000000000000000170": "05a64565e90b2488725a1682f087cb8eda679593d4163e606df37d717fa885f3", + "0x0000000000000000000000000000000000000000000000000000000000000171": "3340b09045d81928d5feb249588b82048aac136feda454dc13bfa778ddaa1405", + "0x0000000000000000000000000000000000000000000000000000000000000172": "327de227ff353f33e394e8d4000f33513c924ea807b747f3cc63bfb40d9c950c", + "0x0000000000000000000000000000000000000000000000000000000000000173": "fd5902869946c283cf714ba1369a87a419d2efaf809ffee5828138db3998941e", + "0x0000000000000000000000000000000000000000000000000000000000000174": "c2ef323c573205f1f1ba96da000d08c88d09b24c95389963a37a5b5f466b8ce8", + "0x0000000000000000000000000000000000000000000000000000000000000175": "29f8ae9fa882fecb82cac317d253adfc23ac083ac8a57f07aa14f450e6cc3a70", + "0x0000000000000000000000000000000000000000000000000000000000000176": "bc73c987e59da4fa66253e4e382bbc25daa551bcebaa40766218c84c249e2022", + "0x0000000000000000000000000000000000000000000000000000000000000177": "8f9e9db44c2a14d5e6f4c109568e1ed5220cbc09face49934d24593d20779eed", + "0x0000000000000000000000000000000000000000000000000000000000000178": "4cbf14ace7c97bbe835d0811871f9eef77d6fe81ece5eaa55e741a4dc1fdd3d0", + "0x0000000000000000000000000000000000000000000000000000000000000179": "6958b982b14e1cffdfc4bd059530efa2eafa98b8b7f5e4d52ea1bae428329660", + "0x000000000000000000000000000000000000000000000000000000000000017a": "ec74048a1581a2c5f60b21cd9e25bf9c356d64346df78fdd4d5ab6da471c09fd", + "0x000000000000000000000000000000000000000000000000000000000000017b": "96f61cc569a5cc077dab9be9396177a63a089524e4afbbf0ebeb09e357665e83", + "0x000000000000000000000000000000000000000000000000000000000000017c": "0ca41041aeed31cf7dbf302aad1a13f021cff17dc3b30ab3ab8fb5c109bf9965", + "0x000000000000000000000000000000000000000000000000000000000000017d": "f2198f4eac45134910f2f5c2f4f4bba2ee608c19e01728288f8f5c583df9b618", + "0x000000000000000000000000000000000000000000000000000000000000017e": "9ed60ccc2815f143b3776e728718019b7820044b0e8f1048fada365fefb130d4", + "0x000000000000000000000000000000000000000000000000000000000000017f": "9062dff550aa9077f3623061b2bfd2bd8d2c86e29909967d614bd4944d9775b4", + "0x0000000000000000000000000000000000000000000000000000000000000180": "d157f96d8cff964d61e492c245aa25b09c561e5c6336ed5452387454dd2936a1", + "0x0000000000000000000000000000000000000000000000000000000000000181": "b8edb732bc8eebb71c6b57b77061ba1acf052b420d919e5da1720abb3c7edb21", + "0x0000000000000000000000000000000000000000000000000000000000000182": "15266d7b9ec958793882168c6ecb5b92093f733c0e47fa9f9885dec39977e5e0", + "0x0000000000000000000000000000000000000000000000000000000000000183": "96ad738816a0c5035be9c01fbbed53998bc70a21a08bd0fa2427288c9d4b4cfa", + "0x0000000000000000000000000000000000000000000000000000000000000184": "d78dcce2b8cf4bd8d77c2e3212a31f5e1eb0c62184d07d2c0bd0dcfaf9258e67", + "0x0000000000000000000000000000000000000000000000000000000000000185": "53b455b1a2321612d4750d1cb5f2154662340f0596d839583ad50db5d90c42f9", + "0x0000000000000000000000000000000000000000000000000000000000000186": "e665360c7c8888bfa138a986f8ff7f890a44b9e8f80b7e736f5f43a7c8bc5349", + "0x0000000000000000000000000000000000000000000000000000000000000187": "e5efcbb043c2a94c768287dceb47dd6b9cb7a7cfa2d9af29222678ed900368c8", + "0x0000000000000000000000000000000000000000000000000000000000000188": "21f6741c735a5806078a1f39d17733b135210be8033a80be4fefc59d42c45bc7", + "0x0000000000000000000000000000000000000000000000000000000000000189": "d158907e25d23731ef6dce6a9d1614ba8b69f1080f78acecf9c403a853b3e7e1", + "0x000000000000000000000000000000000000000000000000000000000000018a": "6fab05257a0a012b2d7ae03c844ddece0883c3c319ac1396c86f6f0e136d034b", + "0x000000000000000000000000000000000000000000000000000000000000018b": "7c1553d1737048182d4b9d286bce8cfebcf1db592863dcdb04597d033557214e", + "0x000000000000000000000000000000000000000000000000000000000000018c": "b9a2df3ba23cf8289d6075dcaecd47b52b9fb750dee39aa9a93b6477e99b348c", + "0x000000000000000000000000000000000000000000000000000000000000018d": "8db428484b88609d95276b97bfc852bbad22b06dd7f40ac765e4e3333720ea83", + "0x000000000000000000000000000000000000000000000000000000000000018e": "d52069ed6df2e1d2f640f30f418cfdf95501b1c6085ac06093c891607b0032c3", + "0x000000000000000000000000000000000000000000000000000000000000018f": "7a253f0e42ca478ad6c4ae1e4892cbddb34294950e425582a85ae2da34f8a8c2", + "0x0000000000000000000000000000000000000000000000000000000000000190": "4e526a541914f396684974eafbce8e6b898a3330278c3e7626816d435a2ef4d0", + "0x0000000000000000000000000000000000000000000000000000000000000191": "03dc453bfc92a17cf81454eafdde515558d116047e9d2deb26e4d653df5960cb", + "0x0000000000000000000000000000000000000000000000000000000000000192": "7c28f6c5bd3f408616c4374f509a34b30c118bf5d1573a2093630f20e43f2117", + "0x0000000000000000000000000000000000000000000000000000000000000193": "930fac8adfdbe31343d02ff687fcb52da1c6e61bca71f0f4a0dac8bbdbe9f243", + "0x0000000000000000000000000000000000000000000000000000000000000194": "899574f6e851f799bb169b1b2ff31f51b11d500716847b660fbb717340b90f14", + "0x0000000000000000000000000000000000000000000000000000000000000195": "7310d47dc31a6bc3bcb6dbf90735258a092efc6fc83100937e73835ee2d70531", + "0x0000000000000000000000000000000000000000000000000000000000000196": "9096409d42e5525d369ed6637798f87763c39cded3d9b86b9428c86c93b61b86", + "0x0000000000000000000000000000000000000000000000000000000000000197": "12d88d0223ca1c9cf55b618b3c4874591d2ab50eedc5b7acb833cec3efc2c2c2", + "0x0000000000000000000000000000000000000000000000000000000000000198": "0f52fa7983ab74a3b8f29492272435381ef85bc78db04283ef614c1fed3aa454", + "0x0000000000000000000000000000000000000000000000000000000000000199": "84d0bb93eddee81c91f12a28c949b30782bd4e0edba3512ec7ece7930c060823", + "0x000000000000000000000000000000000000000000000000000000000000019a": "033fd8cb5296f3226b34e1dc1084b6a25480fa39cec6e680902d838135aa1fb9", + "0x000000000000000000000000000000000000000000000000000000000000019b": "737d7e54435171f7d4f1a31907fd2e6c53cce00b323b09de43222b5c27b78de2", + "0x000000000000000000000000000000000000000000000000000000000000019c": "a18e5315c6a7fc757c84bdcc6b663d717c0549aa53f913f05e2cffaf6d9f2227", + "0x000000000000000000000000000000000000000000000000000000000000019d": "b29d54443444ecf45ee00696aecb54c788d5bf75b57f20e5130c8a9233ca4c96", + "0x000000000000000000000000000000000000000000000000000000000000019e": "7c3805da218aa7f4e84fd775e7020c28243f7be58b18e624e447ac2905f40b08", + "0x000000000000000000000000000000000000000000000000000000000000019f": "fd605ccf0552f8e7b221992726e492451007e6c6fb9d16e9c9a34200886a04d1", + "0x00000000000000000000000000000000000000000000000000000000000001a0": "105a3b333d909958236b0da2089e6ab33cfd18fdcb2b7778c0c9d71db4298d8b", + "0x00000000000000000000000000000000000000000000000000000000000001a1": "a67f1ef534a72c18b935ecdd616dfc74353d87c9a17f605056f99194ca51affa", + "0x00000000000000000000000000000000000000000000000000000000000001a2": "9227d788b19ed84597de40bf0d549437fac98898f323c856512eb3e4ece9dded", + "0x00000000000000000000000000000000000000000000000000000000000001a3": "9ac08c74df2efa845713d7c48cb120f3974a7d70270d7e43f2e30651695453a0", + "0x00000000000000000000000000000000000000000000000000000000000001a4": "9c60b65b9e76366621f1355ea1e2e292c0f2f2be7bc0f402ad0095cf9b024598", + "0x00000000000000000000000000000000000000000000000000000000000001a5": "2198fa802b4c34aa089ce7b6ce1d7eeb5fc3c2dcc6f6db71ca3d15f8c586a230", + "0x00000000000000000000000000000000000000000000000000000000000001a6": "4df5952c9c5555bae758de89b1a4bef3107e63fe722a5e95161e02f4132faa78", + "0x00000000000000000000000000000000000000000000000000000000000001a7": "bf89f44ab29227a246931d0d96a52e7b788dcb2411625bca2d50be6a3797d8aa", + "0x00000000000000000000000000000000000000000000000000000000000001a8": "9d798f5f1806b22c73320500e5b0ecad6ce1e56f0bebd96df975eabd7e9307fc", + "0x00000000000000000000000000000000000000000000000000000000000001a9": "f0688b0ce2364b1c0e3d43325d3d3c8ccd63e530630a920664d49547169d0601", + "0x00000000000000000000000000000000000000000000000000000000000001aa": "08d303e510e1cc58b695d015fc2c2210daa94f0f3ff193d83ea43135bbb590b5", + "0x00000000000000000000000000000000000000000000000000000000000001ab": "b266835618e75e3292af2395d56e02a6e3e35264a596cb44f38148b1499ea0d6", + "0x00000000000000000000000000000000000000000000000000000000000001ac": "301512acf2893751ec72f15dce9fdfb887dccfa96c80d6580a3487dd7857087a", + "0x00000000000000000000000000000000000000000000000000000000000001ad": "22c0f9622864f960991a2027fa3b70d9941bdb21189e7aa09f68660e27be1dcd", + "0x00000000000000000000000000000000000000000000000000000000000001ae": "f6131b88cdb92ad5d8d74aa040be0cef999f2adfc6adc0b8c0f2748ea1aa2e22", + "0x00000000000000000000000000000000000000000000000000000000000001af": "558e886b4bbd77f53aa9a1a056e8e08481da9dc38b7a3859e498e410dcd973af", + "0x00000000000000000000000000000000000000000000000000000000000001b0": "2588de766ecc1af72b5f7b2a729453d703d85d9bfc027898833f2771039877e7", + "0x00000000000000000000000000000000000000000000000000000000000001b1": "dade7fc48d32dc68d41020ac79b868485abb3558e53bb63a2e8aa47932e39476", + "0x00000000000000000000000000000000000000000000000000000000000001b2": "8ceeb2afd3646d249dccab24330b4251a5ce2d7ad671541d746f5daef884bd41", + "0x00000000000000000000000000000000000000000000000000000000000001b3": "24c5b68530cc49171a66f1dc312ea1a15c3b234db8561a1fb08bf8c3adb972d4", + "0x00000000000000000000000000000000000000000000000000000000000001b4": "82f242525cebab571fe6e5fe6fcd838c55ca48eea1eb255ef7bba0fb43dea956", + "0x00000000000000000000000000000000000000000000000000000000000001b5": "413f11217c8822a00b8b8b614c7e438db97162345ea9d01d1b46bd859f589395", + "0x00000000000000000000000000000000000000000000000000000000000001b6": "37a642a12a17850ffc84a65efd942917d6c413e0623d9ed0dfd583f4a6dd280e", + "0x00000000000000000000000000000000000000000000000000000000000001b7": "2319866ae408c2c16def479454f550894284b65217d988c0f0346c8b788e6f50", + "0x00000000000000000000000000000000000000000000000000000000000001b8": "21cd372ca079c9c9a302ce46dd6604fe0dab8d1c4963735f200fa7aecf68723e", + "0x00000000000000000000000000000000000000000000000000000000000001b9": "95a47db05dc3a6043cd4a648e1838876d7814cdfc2acc03b6bfd228751a193a9", + "0x00000000000000000000000000000000000000000000000000000000000001ba": "e3b09d5570d946f2ab70308a08f0275c443d7ec9d9ef3c32df7c2320f790b4ec", + "0x00000000000000000000000000000000000000000000000000000000000001bb": "590060fc82b55361ca5d13db77f55b5a5cfef362ddb300440f0a48984c9a2e28", + "0x00000000000000000000000000000000000000000000000000000000000001bc": "a9b21f63b40981e09ca454b2739149666dc23a4d33f5a0014463766354cc19f6", + "0x00000000000000000000000000000000000000000000000000000000000001bd": "331d419065a5d0ffa904c435e9022d1e621315eff68f2201ec63a690fec3003e", + "0x00000000000000000000000000000000000000000000000000000000000001be": "44b075e106306c1ca24ca9dc1c5a27e68dbe86367904581bb3981acba06ce979", + "0x00000000000000000000000000000000000000000000000000000000000001bf": "6faa7c1f263480410463c1eaa2ff9a4471dee90cd7b440f9a7fffc7c49c1ab57", + "0x00000000000000000000000000000000000000000000000000000000000001c0": "027b707ded941bf200797c580cf2a73d3dba48794d0b2b198965ff9d0aa4b46b", + "0x00000000000000000000000000000000000000000000000000000000000001c1": "35c25ba5f49d95a411ef32426c443c91e887ca1dedf2a6356969292822c0d91e", + "0x00000000000000000000000000000000000000000000000000000000000001c2": "83e0cab914be2a9ba1c2be60f0ecdff76ee5c946daeef001af4b6a6aa47873dc", + "0x00000000000000000000000000000000000000000000000000000000000001c3": "c735802bd46c31c8a7e3e83c2605a218c92e66f7507e88f4cb1c0f351c0a71a3", + "0x00000000000000000000000000000000000000000000000000000000000001c4": "781d1e3fdabfafcea2fa6d4486634b6af94498fa3562407f4caa4c4294575417", + "0x00000000000000000000000000000000000000000000000000000000000001c5": "e516c9e13a00da98680afc3265f13e142ebdd467d12da151e6e5a9677a228c6e", + "0x00000000000000000000000000000000000000000000000000000000000001c6": "666ac8fcb85fe5025a7b996eb4f4d6411019124c819a009b7e0c7f0e0c4c4c3f", + "0x00000000000000000000000000000000000000000000000000000000000001c7": "3c141c08a245a3db335db0f6bb0cff5848f6425057c9961cb3bef827aa0ff53d", + "0x00000000000000000000000000000000000000000000000000000000000001c8": "63dcab73a746ec6c5ac8f1ff8ddbce7cd483c26548f86554fcc40c2ccc041262", + "0x00000000000000000000000000000000000000000000000000000000000001c9": "3aaec8ddc0224f4b084a8ccc04efefac99cbef0e503b8a7bebc3c7aa4fe46521", + "0x00000000000000000000000000000000000000000000000000000000000001ca": "4dbe3b6b04f679aa9677b3a64d1dcfabc5906a12c178e5ff54b7efbfc2c79b50", + "0x00000000000000000000000000000000000000000000000000000000000001cb": "457c3a83d0815833923bd48642d056782f5fd188041e8cd92f260e2383e0361b", + "0x00000000000000000000000000000000000000000000000000000000000001cc": "02522280a85179021caaa61d6482df93c045087417ba2191809b602832aa710c", + "0x00000000000000000000000000000000000000000000000000000000000001cd": "4d587bd01bcfa40e1795ad3ea5f77b546910c6870bc7e6657d40a1f2d8feede3", + "0x00000000000000000000000000000000000000000000000000000000000001ce": "961d29a7fc57915697ba5b2fae8d3771d8bd91576c32c05afee041ac17d848b0", + "0x00000000000000000000000000000000000000000000000000000000000001cf": "5c3884749debf301065e34263780232f327a57a85b4fe19376e62de3723aa5e6", + "0x00000000000000000000000000000000000000000000000000000000000001d0": "713463804bd20977b4cd34532f3d1168f0a49501d5408fb2877478a477a1f971", + "0x00000000000000000000000000000000000000000000000000000000000001d1": "461c8fd694ea0c1af8793266c605b6ceeaf7245cec97495903ea2a14ecac4380", + "0x00000000000000000000000000000000000000000000000000000000000001d2": "35e31088a1515e1ba6609d0950a16e8f35cde03fa07f46e18e4b86e2cca4edc2", + "0x00000000000000000000000000000000000000000000000000000000000001d3": "61ba03ccc0e0cf9cd98cdcba500e40e8129eb3eb85920d1fef44a05588d49c3c", + "0x00000000000000000000000000000000000000000000000000000000000001d4": "851f39c5ce5f4801b082523faa0cc03f2ff3568a0c243f620e5c339ea39da2b2", + "0x00000000000000000000000000000000000000000000000000000000000001d5": "448656736cc3a9a8e8ab0c5e548319b14a51b40e45f5de7eddaf25ca390c3530", + "0x00000000000000000000000000000000000000000000000000000000000001d6": "525d5448d96a5a36b6bd87c4599662f32304d64eeea5f5c07897724a91a4d8a9", + "0x00000000000000000000000000000000000000000000000000000000000001d7": "3e17e4473b4356e9cf755ce3275618fd3e3d4b82d193bdf6a57a2ecc4ddef386", + "0x00000000000000000000000000000000000000000000000000000000000001d8": "7e688056a77a5d6803174648e4a6d2e982a0e02677ae38261c21c6390e90a659", + "0x00000000000000000000000000000000000000000000000000000000000001d9": "e2f9a4e56ef10377498499f58bc152015a2db11f8b485232541dfde10f04591f", + "0x00000000000000000000000000000000000000000000000000000000000001da": "33287f7e4ff32b8a0e6c65d03e04ea27978409381ab031fb8b26d5fe4e14fb3c", + "0x00000000000000000000000000000000000000000000000000000000000001db": "f6073bc7c2255ed4e3365fe8668f9529aa2327e566eea8485e105fe80d0afa5b", + "0x00000000000000000000000000000000000000000000000000000000000001dc": "f8819d443db1143c7f37606b9cd6003db500b36f8059e0a1b42587b4b7f532fa", + "0x00000000000000000000000000000000000000000000000000000000000001dd": "e1dbbc3e7db42e01ee269badbb49ab349b05938d0fe3840f97a9cd6c51384a26", + "0x00000000000000000000000000000000000000000000000000000000000001de": "92e9256953269935a75a21cb3a31b1797564c37a20a104d622c188d6bbbdcf89", + "0x00000000000000000000000000000000000000000000000000000000000001df": "0d4b4ba377d471804631f61c131ff1829b09242afb36c667f66eb3a70677bec2", + "0x00000000000000000000000000000000000000000000000000000000000001e0": "a02fc5e98bc45d4a34dc34d16d71c95e6cdcac504157769ba0e41582d1c7c28e", + "0x00000000000000000000000000000000000000000000000000000000000001e1": "313563af27e7adf66fd7f2842209e0e0c325506fcac7f6dd3abc361d9e03d498", + "0x00000000000000000000000000000000000000000000000000000000000001e2": "337fb18e572e14e967fa54af1ce06a81e52ac2a3baf227d55bcd08499dd4117c", + "0x00000000000000000000000000000000000000000000000000000000000001e3": "497a904516fc0847ae8cadbe627a4c5999451d9c6fb9c407a20478c7f90c3820", + "0x00000000000000000000000000000000000000000000000000000000000001e4": "1683f93d623b43c0071b287a4f3bba01765e6a5fa591d80e140d2f709960d5a3", + "0x00000000000000000000000000000000000000000000000000000000000001e5": "47bb80c5043a6c8898d1006da95899d8814b8bdc8bc7f5df945418bc33d14616", + "0x00000000000000000000000000000000000000000000000000000000000001e6": "2365c3df9f22079331e7519296bf2f4115bee3a8fa70a357a4fbd4e21476581e", + "0x00000000000000000000000000000000000000000000000000000000000001e7": "5d5980aceee17c98188ebf3255e3b3e26b8a5d38f9a4ed95a36cdc818661b619", + "0x00000000000000000000000000000000000000000000000000000000000001e8": "a848e5ed65c70444a6d1fe529127abea702ad12603be4c42be221994762e0c08", + "0x00000000000000000000000000000000000000000000000000000000000001e9": "e98fe8994405578378ed95c1d4b9a45d743c652214e50ac48bc8b36a42d2a4d0", + "0x00000000000000000000000000000000000000000000000000000000000001ea": "2a67633e64cfd77fe6ce3386742cde79338e1a34f5c7c904ea3eb8f64696d35f", + "0x00000000000000000000000000000000000000000000000000000000000001eb": "5d1662243b6c9f6dbf53fe2b79a220453b883e9c80bb06e31f2295e68918aecd", + "0x00000000000000000000000000000000000000000000000000000000000001ec": "eafb3303dba8dc7f4b41bb7b37f3c93e95c8eabd33c392d88dfd0582aa88dc05", + "0x00000000000000000000000000000000000000000000000000000000000001ed": "8658952c14dcc2b8f15ed4f1f4e861e033bcdbe4b0b17671dd7984b29d1a8ba3", + "0x00000000000000000000000000000000000000000000000000000000000001ee": "9a4b8616c2ab2fd6d1d94a86a6e4a5ebe988708def10c935772e47bdaefe5b0c", + "0x00000000000000000000000000000000000000000000000000000000000001ef": "1987f5210117e3866820238e7be09c5b972ff01bc9d3062259ac73abc9fb5d1b", + "0x00000000000000000000000000000000000000000000000000000000000001f0": "ded42d295832ce8251701cc7582d068b37adcf17bf96e9728f49c7ee7dd93c7a", + "0x00000000000000000000000000000000000000000000000000000000000001f1": "b9244e48395116c8a53aabace93900c569c53b973a9e3687002cd218d807f608", + "0x00000000000000000000000000000000000000000000000000000000000001f2": "ca9205d2f444fffd9a22b3f45c1ae061924fe6b5d885079b4f215fd6da081c89", + "0x00000000000000000000000000000000000000000000000000000000000001f3": "d6d29225f2af2f42a875f8e69837b6abac59f79c06b12476351cf46b1f721268", + "0x00000000000000000000000000000000000000000000000000000000000001f4": "a006e393879b70cf602f0122a886d8167c8708f8e7feef6de52675f650f07b2e", + "0x00000000000000000000000000000000000000000000000000000000000001f5": "8698a5e929f6712d07c38692354fc0cd108829576fcf507d8249375bb4d34e60", + "0x00000000000000000000000000000000000000000000000000000000000001f6": "1e95d4fa85ff39313eed8480ff6f794da6cbdf6c865c33aa2c514fb097c6817d", + "0x00000000000000000000000000000000000000000000000000000000000001f7": "52eb082eb7be273f4d5280bbef49733796215c09a7c71ca1b20fcf9ec180affe", + "0x00000000000000000000000000000000000000000000000000000000000001f8": "d671e7ebad6a5828dbcc7932d67618bba676951ddc013cd528bf9b41a99f50b7", + "0x00000000000000000000000000000000000000000000000000000000000001f9": "1c10e60513c164ab7482d2c33062cbc0f8191dc03f48a211fb9ba5cc9687646e", + "0x00000000000000000000000000000000000000000000000000000000000001fa": "3a66ebe86f285009227283701e0bd5d1ef913636a7a1331799de1c1faa5e4c29", + "0x00000000000000000000000000000000000000000000000000000000000001fb": "062f4d4d65aba3e78d382b9f46e4d5542195003f96b51b865458dcc1f826bef4", + "0x00000000000000000000000000000000000000000000000000000000000001fc": "41870d7fcfb0ba5dd5425e3a3302b3e93025132d1a2776a249a88c572fb6be05", + "0x00000000000000000000000000000000000000000000000000000000000001fd": "7c13316eda73749098cf4575409649054e1835f58d626491b4a4b95f2a8a0564", + "0x00000000000000000000000000000000000000000000000000000000000001fe": "5fe375eb49f8ae346cfc274905e352f9d90b8e27a9557c111a4da925da1ec952", + "0x00000000000000000000000000000000000000000000000000000000000001ff": "b2e74edc8a1efbf6260ee1bab5e093a479e2f7e5cd4b857567c0f375363e9620", + "0x0000000000000000000000000000000000000000000000000000000000000200": "66e753584038f784cd85643a76dbb590005f0704537ac697c648abe7cff660cb", + "0x0000000000000000000000000000000000000000000000000000000000000201": "f4d20bce9d8457ff1dd755e1dfbbb89c7bd0ad0a4cbbd507a20a66a75ad9223a", + "0x0000000000000000000000000000000000000000000000000000000000000202": "8ccbef8f2661bcf3123cd1d94c22200a4ae5f196f22cc0a75a24a2eb88b18acd", + "0x0000000000000000000000000000000000000000000000000000000000000203": "bf528a0231aa3fc212ff82fbc410ffd8e8e2191e9af0a3fbc6b5c246cb7ac8aa", + "0x0000000000000000000000000000000000000000000000000000000000000204": "03938f3ef2d6d88872a92445d63c6617c2ad1c6729900a8263f19ec9d03d5106", + "0x0000000000000000000000000000000000000000000000000000000000000205": "76b268f5c2c12013dabdac36f0d7a87aeabf6d0b9c66afe989de308e9d8cb0ea", + "0x0000000000000000000000000000000000000000000000000000000000000206": "9025f8fd00f67b94a9b19712e0ff275ddddf0638f35bcd818639f440daf3d392", + "0x0000000000000000000000000000000000000000000000000000000000000207": "6d6253031c30b55f6529d6543f837195d883ed16bd214ae6b065668651295a7a", + "0x0000000000000000000000000000000000000000000000000000000000000208": "3d381099b916c9111f0a6ef929f91814a584f390a9032879d7e41c6eed3f4870", + "0x0000000000000000000000000000000000000000000000000000000000000209": "915d521f633b9e30bbb9abc8024728d9f1c69a3f06fe8f490c82143ea04d2e52", + "0x000000000000000000000000000000000000000000000000000000000000020a": "863e79fd3c6376662be319b3ef0eb05283fc9f713417b7856a7c8615f977d8c9", + "0x000000000000000000000000000000000000000000000000000000000000020b": "92017f3c5f46fc656d0b2279ed722c9ee2fefd6aaeef49a9b72a7f3988fda54b", + "0x000000000000000000000000000000000000000000000000000000000000020c": "5b54670c143ac7faa7dd65ddb7e3b7c85d6932c049e071be3a0f9f51ee3b889d", + "0x000000000000000000000000000000000000000000000000000000000000020d": "dcc13010415b57cb7729b370840b98797aff553ee150d53acc57944d6880476e", + "0x000000000000000000000000000000000000000000000000000000000000020e": "2d3c7ce06501bbf1916b0a41b645130ba77f69e25b150354934ea8ea0cb3b012", + "0x000000000000000000000000000000000000000000000000000000000000020f": "b8489443b8bb965ee7e0cc42e8ff8c2467d199cd09434fb394df3f34a2a985b7", + "0x0000000000000000000000000000000000000000000000000000000000000210": "c4194a2d7270901ff947af6ebd80fa701243344f704f832880455f4041285986", + "0x0000000000000000000000000000000000000000000000000000000000000211": "1d01c2348f9ac6b46cb793467df238a9f23c29c1d3de9e454bc61644705db054", + "0x0000000000000000000000000000000000000000000000000000000000000212": "7cdb5360f32a30019bf96d2ea2034810820d065f655f99482aa59696b371afa4", + "0x0000000000000000000000000000000000000000000000000000000000000213": "d17bc796f0ad66329bca1ca889a6c67406db80c0f43200fb0926495f409432b1", + "0x0000000000000000000000000000000000000000000000000000000000000214": "d8472a9633cefd2b65c8d169fdcc6737e60390ee74069eea5c6209c6e2ad1634", + "0x0000000000000000000000000000000000000000000000000000000000000215": "619efa7e75625a7ebedc7f3f9399965b08abf5834485d1db46a18e52f18c31ee", + "0x0000000000000000000000000000000000000000000000000000000000000216": "c2b62f015db1c1d98d0614179d0ce92635a62ab4922a2faa0139119d3d63e071", + "0x0000000000000000000000000000000000000000000000000000000000000217": "58bb373fbaddaa37a1fd35bfbaedfca10e720b9517932daa0041139db7285ac0", + "0x0000000000000000000000000000000000000000000000000000000000000218": "c9e6ff8c4334da9106046cf0aa6ada5653c1c7e4e04e2625132bdf77159440d7", + "0x0000000000000000000000000000000000000000000000000000000000000219": "d8c58761e29f93f85ed6cba366a7bf37793501e56beb1505083593cef82267c5", + "0x000000000000000000000000000000000000000000000000000000000000021a": "1d090490f42aa267658565f6ca68e0d230f7d6e2c2c850276c5428f2e6feac7e", + "0x000000000000000000000000000000000000000000000000000000000000021b": "f0867530c5e2d8e1e6f5e8fce7da42ed7d2b62d8f996ad93efabfdb12bd3cfba", + "0x000000000000000000000000000000000000000000000000000000000000021c": "b2db3d26bc5c38616a7acbaba0e72cbc0d27ddb96f8fe1f4f1437d6ea7c058f9", + "0x000000000000000000000000000000000000000000000000000000000000021d": "0dbddf3e586a2f5369ac360a4fee1273047238f16f2f4e8b6e16471b2455701a", + "0x000000000000000000000000000000000000000000000000000000000000021e": "a82749ce59055410613ad90d73c4fdfe715f9b60c665689c4c377125b1dadaef", + "0x000000000000000000000000000000000000000000000000000000000000021f": "5be3c764fef371841fdaca04c885c757d884f9ff8971250ae39d77c76e573636", + "0x0000000000000000000000000000000000000000000000000000000000000220": "b710b8559fdeaf52af97d3fcf0879011c37044dedb8f94dbbc338a85bfd7c61a", + "0x0000000000000000000000000000000000000000000000000000000000000221": "6eb711b67df8460994ec6d375c26a4209acae1a918f7a62392f2a562500980c5", + "0x0000000000000000000000000000000000000000000000000000000000000222": "1da9f51a070e2bf7a49e7631ac54fb0e79bf4034dd2b982f8929cf12c469a593", + "0x0000000000000000000000000000000000000000000000000000000000000223": "9d719d04326acbac551edf543d8f760e26c65609601f950dc8d7271cbf40a006", + "0x0000000000000000000000000000000000000000000000000000000000000224": "488537d78be3c43ce3232056b5e0b1ce2ca9a88d4d7d768f654e0698928743e0", + "0x0000000000000000000000000000000000000000000000000000000000000225": "04b7bb9acaf695da6f2e725c22098a6a6d2216ab3478a9e053526bb50e276afe", + "0x0000000000000000000000000000000000000000000000000000000000000226": "7181f0084b63db7479c003d7dd4291ca02dae8d4283f82becb53681d47398afb", + "0x0000000000000000000000000000000000000000000000000000000000000227": "026fb7db67bd230b10afa06b1c7b20edc1219887a13c0accd594f54aba577ca2", + "0x0000000000000000000000000000000000000000000000000000000000000228": "60596113f907eadfb5229325292e44044821a9e22f7e575b24cab3ea58fb5190", + "0x0000000000000000000000000000000000000000000000000000000000000229": "d168573695101511d7504d9d987c5a0fa7e64b52dbba520aece42e39e9b889b7", + "0x000000000000000000000000000000000000000000000000000000000000022a": "cde6e6e9437d8d53d9d119f59621d8af4aab0d36357ae361fc39100037289949", + "0x000000000000000000000000000000000000000000000000000000000000022b": "af7988749b7c275b2319bbe47c81260f8c3084d77e284db0b00237173851550f", + "0x000000000000000000000000000000000000000000000000000000000000022c": "e80952fe3298776700d0d5527b12772000caeafe16823a1d07d023c092aced4f", + "0x000000000000000000000000000000000000000000000000000000000000022d": "0462b045d5e548d1267a9124eede57927ff6653ee26e515e79484a37fa332fec", + "0x000000000000000000000000000000000000000000000000000000000000022e": "c2379dccca93cb7af1b9495cb45ff56200395f2d0f799afda2cf7d1a8dc2207c", + "0x000000000000000000000000000000000000000000000000000000000000022f": "a7614022dce29db83d3fdfda49d693584249cd3719f6981766ee013a59c53df5", + "0x0000000000000000000000000000000000000000000000000000000000000230": "a9a699c07f4409eab9ca244799436f35249c79448cfb16f1daac3ea84453ab62", + "0x0000000000000000000000000000000000000000000000000000000000000231": "25b92c413d927baecbcc7836cd6464336f0a89e2d65a9fa0cfbe8729fb3b2eb6", + "0x0000000000000000000000000000000000000000000000000000000000000232": "a57990630fd6f670bb7e9f46d7c3e913b5392a7b13a83e9e040118b5edce4bf1", + "0x0000000000000000000000000000000000000000000000000000000000000233": "1d6f6c4bfa2d734a2b4869d97a28ed74e5ac40595899853e85e98349788a9d58", + "0x0000000000000000000000000000000000000000000000000000000000000234": "e8c2b0ff9fe420948d5a90471748469f7cd018d8b62b156404626ee33a4f4edf", + "0x0000000000000000000000000000000000000000000000000000000000000235": "96419b60000d8e4e9815500d8e3d69eef3c19d36997bdaedd42cfabf174ae505", + "0x0000000000000000000000000000000000000000000000000000000000000236": "ffafac142daa1e5dfaa588553a29883ef5d6b9a56408401cc20dd60121467861", + "0x0000000000000000000000000000000000000000000000000000000000000237": "eb9bc3c34aeff870450eef73debeab5d6a4e853fd5e94794de8de70f3328400b", + "0x0000000000000000000000000000000000000000000000000000000000000238": "168cb5014662382595da9de5a5d07020a00f6871e24ec2f12e4d2c01200a1021", + "0x0000000000000000000000000000000000000000000000000000000000000239": "12d8f16244cd8fd6024d151e6a2070009c315dffa38ee8c5330e1bd3d4c3e550", + "0x000000000000000000000000000000000000000000000000000000000000023a": "ae534ee68fddcbb56a54e1389963b1b91f2bd81903668bc912fb38e8222616ee", + "0x000000000000000000000000000000000000000000000000000000000000023b": "d17d8c2fc653829318949d721e152c1578ac66a99c02fea2ed7e9902345888ca", + "0x000000000000000000000000000000000000000000000000000000000000023c": "8d7e0a0e7b3ae1c2af06dbe35c75cb89f39ee82eabdcc3dee776c4528e5f44ae", + "0x000000000000000000000000000000000000000000000000000000000000023d": "1d2cf4804fe3b07289794f1cb5227e51d697cad91934eb7c4705834e36100bb6", + "0x000000000000000000000000000000000000000000000000000000000000023e": "f90b5cc6dac74d3bc26ea436c5009c72a78b680483bba81d842d5500cf2cadcb", + "0x000000000000000000000000000000000000000000000000000000000000023f": "da50bf0b60a87259fb867f9ed72c9b70defa034f7579ef5d8b3b1fdc0dcef8fe", + "0x0000000000000000000000000000000000000000000000000000000000000240": "0ed725064a1263c0361d176ecc01bd8f3282fbf917f16c7acc8d74da1a076d5d", + "0x0000000000000000000000000000000000000000000000000000000000000241": "6c84eb9a9f855cc6e5d2e3a2e3745e58a19f3dc35dc4d4b87e03fd8be4541313", + "0x0000000000000000000000000000000000000000000000000000000000000242": "dfe776d8d16b551a7020bdb98ccfbed0c74ce701b7da68a2124088f2661a3592", + "0x0000000000000000000000000000000000000000000000000000000000000243": "ff3de971bda54ed67b27bd4b95e38b9045f21d23c4b3b1613def488d9826e293", + "0x0000000000000000000000000000000000000000000000000000000000000244": "689a76ccb80461e78e22e1997c949bb143882516f7db6ec6aeb1062342881540", + "0x0000000000000000000000000000000000000000000000000000000000000245": "179654e16a3900b68bb66927ab2e714430ee0eadadf1930eb6073454bfe66d72", + "0x0000000000000000000000000000000000000000000000000000000000000246": "7a4bcc5016b6d39420221e1206b50128e0efe3fee6a1c5eb573e6bedaab5f215", + "0x0000000000000000000000000000000000000000000000000000000000000247": "54d398355fd128ea6d1db1e790364b184845a3687dfa213ac446f7d298755717", + "0x0000000000000000000000000000000000000000000000000000000000000248": "c52e636696619f0055d30d50b17d0f5a62537fa775dcd349d3948956c57a578d", + "0x0000000000000000000000000000000000000000000000000000000000000249": "6c72dd1012068c32cf36641b1564e48296fb121ab7a9a9baefd5c28416d8d054", + "0x000000000000000000000000000000000000000000000000000000000000024a": "a9697418504b9f328eb3b4bb3c4a82ccdad93df60ba4f9666a9ed9d4b61215af", + "0x000000000000000000000000000000000000000000000000000000000000024b": "eccc52333b224ed9aa4a274c7c2e6ad7043da8fec8cbd1841c4df037d272a070", + "0x000000000000000000000000000000000000000000000000000000000000024c": "0e033ec5d1b65a42204e9caf992cf062bf74c8a309c9b2e769b858e366650d94", + "0x000000000000000000000000000000000000000000000000000000000000024d": "787a2bb58c6e1d4ac5d91e6fb7bbf1713c1e902ca3b86d920504167e9704e574", + "0x000000000000000000000000000000000000000000000000000000000000024e": "aa4611fb72fb0a85c2d1bc1083c160f1f316538c7f58ef556f4340ea20068ce1", + "0x000000000000000000000000000000000000000000000000000000000000024f": "5e35d6b8ace034f15f9ea52f7f1a6a1ec774e7a4234137c6c5bb913dfd733971", + "0x0000000000000000000000000000000000000000000000000000000000000250": "0a0ed30330099aaed4d9fc919882376e3624d21bc3b39691003081f575f6b27f", + "0x0000000000000000000000000000000000000000000000000000000000000251": "3f445c59eb76afc237ab0aff24e4afece553617597903e7c54e2e52535f5f69a", + "0x0000000000000000000000000000000000000000000000000000000000000252": "5b913043ae15b19475bdf3bce3000c885837ce744816ee34aa4c4fa13c29e273", + "0x0000000000000000000000000000000000000000000000000000000000000253": "cd4351d6d5b3636ccb5424b17c5a8b33e881f83ac158694c1f198b70290d93", + "0x0000000000000000000000000000000000000000000000000000000000000254": "84dfa1c19923082db1a37ae307ef33a005c1ae987763f3537078e44a91f72cef", + "0x0000000000000000000000000000000000000000000000000000000000000255": "4f62f1eb606efbd760b849b83f48b5080b0045364da18111e5f81faa74bdf648", + "0x0000000000000000000000000000000000000000000000000000000000000256": "6845189fc5fffc30575935e9f8db4c343bcf5001360241b5af6a10c91f5b1003", + "0x0000000000000000000000000000000000000000000000000000000000000257": "7e80093a491eba0e5b2c1895837902f64f514100221801318fe391e1e09c96a6" }, "address": "0x0000f90827f1c53a10cb7a02335b175320002935", "key": "0x6c9d57be05dd69371c4dd2e871bce6e9f4124236825bb612ee18a45e5675be51" @@ -1833,275 +1833,207 @@ "address": "0x000f3df6d732807ef1319fb7b8bb8522d0beac02", "key": "0x37d65eaa92c6bc4c13a5ec45527f0c18ea8932588728769ec7aecfe6d9f32e42" }, - "0x00F691CA9E1403D01344eBbaCa0201380caCC99C": { + "0x0042A98aB090F46F6F8d5d068580BAb43dF2fe00": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x414f775e04d169c219a5acda8227220896061f1edcf83d93e9ef0e036e6b07eb", - "code": "0xb8e894a6dd5121be9d2a29c2e1cf16ab2c760e3243306ce88e771a7860df9e85b1e225b71c59213e32f4bb29d456e874b9c97a51f77a8f958e9e475745869be7bb253242668f210ab37ea93841fe0d17a46e78879caed1b4f17f085c8a9963a6830bab64ca008c825ce6fee9d16d63427d5148d6bfa8237fc8acd3ea124b12c65cada8413107c6f4009d62c1355b55832bd0688b7023e5888115d596c1cc5e94da5898a2ce83fbb79921776bda0d9000fbb2244c87f580711e4e2863ca14b405b8c1b99a0a643c89a0443cb185772b972869cfa5fa581f8dc3f977b3df54a682e345b295cb7c8e9f4fa00470e4a0eeeb15892acde8fee168a1403d820087e73d", - "address": "0x00f691ca9e1403d01344ebbaca0201380cacc99c", - "key": "0x7c48e400de1f24b4de94c59068fcd91a028576d13a22f900a7fcbd8f4845bcf4" + "codeHash": "0xc1ae0ad6542a5c7dd593e75e1fcfeb2f5f6f275a4e9733206e8cea0f902b18c5", + "code": "0x580e8642a5018110af46b2595b11c6b7020b184eed4ca1923f4b7560c005d79721b4070496384c066e3afae3a2dc2688ae89d053eedf7f55f96f83c53f8b4b70f8bceeb37b98a3040a0d9f17323f96d8b10dbff6292e76e0bd6821526c2b6695f29a47cc56db769417bfe11e85c712aa9920cdd341de96305d778b58202ad75439ce2098b9fe07cab2942112323839e66c47b416dc15802a90e3a31ffdd0317df92d08284561ef9761634b888f908f45aa5356ab73a972474a956790b74a59c148b495e015ecace61929bf62c764f6ec24d5fbe97351dc5e7e813829bc54315fa0f6f0dbb29f6599bffa43edb3f2ce5e01769244b9cfc33f4ba781e3ae639ef7", + "address": "0x0042a98ab090f46f6f8d5d068580bab43df2fe00", + "key": "0x104b943e78540e4b0bf81e7ccada3f831857a325a06947412c1287ffaa284119" }, - "0x0175C17De53473bbf136e6aF7086B8700B43CF38": { + "0x017AAe1940B253E7afad292098eb59e6c64e9beE": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0175c17de53473bbf136e6af7086b8700b43cf38", - "key": "0xf045ac5237b17e93661fe75054f95cc76df4c3b668f0e4a1d8f5daebc12a85c5" + "codeHash": "0x2bf43f06b9f27c71498ec5b782da1259b2a6eb02fe7f9136c3d0b2858c0f6e09", + "code": "0x20d186469448ced763a24def3f3468c9b40577d59eac422c275a9576c439d86547d8af78512b204f644d8f13cc57c25ffeeb27f5044fd719cb9725d000fe6aac4851de8a4df83c855557329789c7e5ef967a3a084e4ae3784f2778aeb8b86084e46a11c5890976e15441eaf10504a1b4f452c682aba2316cc50045a1455c86e09a2621996aa68bc125b1cf3679db117591d94cbb32bed7853d075ac666de26906f4dd0040cdabb3e17c91cda6a1798a305913c9e276fa80b450a4dac0e46d04e056520d4601757791117f936edc6e5228e597c55498227034e003251987fdb0f6a7e37735eea420ba517b5284cd84328feb0209a3069f0ddbf84e94193c44f37", + "address": "0x017aae1940b253e7afad292098eb59e6c64e9bee", + "key": "0x08440b5468b3c640fa97a13fdaabbe5bf5fa0d0035a457b43aeba20442a9335d" }, - "0x022916D4E98bF4d48884Ad1cB9c4aA58CbfDc970": { + "0x03B745d7f28eCfd7903f746B9d3d36f56E004C73": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x022916d4e98bf4d48884ad1cb9c4aa58cbfdc970", - "key": "0xf80cab3980ad7df8c2fc9d0f457c7fa62e4a5a2e0e0057ad96302ecc3d1e6cd3" + "address": "0x03b745d7f28ecfd7903f746b9d3d36f56e004c73", + "key": "0x0af10a79f7cad0388da160fbb23ba70ad0093166ea4b5cfb620dd59bc84357f7" }, - "0x0242186831F57A6FC1177d96F18B31E8bF67E7AE": { + "0x04361123c6CBFc38F6Ee7B0202ecEFdaE36efEB4": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x34af31de538687879648eb811e76794299920242a507de08c946638fe1def18d", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0242186831f57a6fc1177d96f18b31e8bf67e7ae", - "key": "0x022c043e6e7e719985ea4071080e6532d25dc102f3fffa2d96db43eeae4e8dc6" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000035": "35", + "0x0000000000000000000000000000000000000000000000000000000000000036": "36", + "0x0000000000000000000000000000000000000000000000000000000000000037": "37" + }, + "address": "0x04361123c6cbfc38f6ee7b0202ecefdae36efeb4", + "key": "0x3960cb77ee8ce76e0a84773c1d222795fba838aa28edcca2045779467ef3fa27" }, - "0x0300100F529a704d19736A8714837adbc934db7F": { + "0x08D3B23DbFE8EF7965A8b5e4d9c21feDdBc11491": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x730f4b9a001161056466356bac602cec9aea791a93eee35887c5b445c1ba84d2", - "code": "0xa3460b9064575a01ae448ac16880d3d6297c3b1b3ed6401e5e55576437da869cb8268a6811e35185c888408dbd03c24dd26f48c3ed147cffb085165a9b915e99d9c7c9af5ae3bd9d3c51ae123d91d0a46beaa95906b5f109f17d5f466c68dbf5e7484af6bbc8157ed372968cb5ffae804c38bcbc5773bb07433d44bbcc6ebbf0599ef2d67d4a71e24d4f29210ed925ef54d64da410ce44512c56a7a472cfb0df80db63b10209d83bee8914a5717573d21b5817ca696e60bfa859102ac5a737f7e23d3626096a70b8a02737a3c2f960e5732ebae39d6a014de867a32a96f9bd4df5d6daae740c69c53563f540b21d345f00222698cc33e6e7a4196bed610744c1", - "address": "0x0300100f529a704d19736a8714837adbc934db7f", - "key": "0x97b25febb46f44607c87a3498088c605086df207c7ddcd8ee718836a516a9153" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x08d3b23dbfe8ef7965a8b5e4d9c21feddbc11491", + "key": "0x792cc9f20a61c16646d5b6136693e7789549adb7d8e35503d0004130ea6528b0" }, - "0x075dB7AB5778cd5491d3ED7Ab64c1Ec0818148F3": { + "0x0Aa79FD7C1C0e7E00c4ba9feE89F49D7daa0B61B": { "balance": "0", "nonce": 1, - "root": "0xd3f27d2eba503b1af71052fe41fe4073a680ebe483f428d3caf50e94dfff12ab", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000019f": "019f", - "0x00000000000000000000000000000000000000000000000000000000000001a0": "01a0", - "0x00000000000000000000000000000000000000000000000000000000000001a1": "01a1" - }, - "address": "0x075db7ab5778cd5491d3ed7ab64c1ec0818148f3", - "key": "0xf84223f460140ad56af9836cfa6c1c58c1397abf599c214689bc881066020ff7" + "address": "0x0aa79fd7c1c0e7e00c4ba9fee89f49d7daa0b61b", + "key": "0x5d09cbe91ea3932998d10a7c8106f1f4fca78689ff14cc078317a695f449ce14" }, - "0x0767637af7aeA66d876BAC94769Da962Bb4D93F6": { + "0x0EF32DeC5f88A96C2EB042126e8AB982406e0267": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0767637af7aea66d876bac94769da962bb4d93f6", - "key": "0x500b6c47c37153a6d5f95cb6503d4d6677f1b875ab80b7d12a3e15db75573930" + "codeHash": "0x5fbc8fe8138fab7ad184ea266f527d1893aab90dda28f7d24be94b959c96ebdc", + "code": "0x8a1b5c8cd5b7bd4a981a9c76dd66b7aa945dc8c3e0d495c4302436789fc22deb28c3ddba77ef852302eb67f6ce73e9c25e4571d861f77ad858cbfc3a8b54fb6f354d8a99986db445a0165d66c40c5165c1279120b31bd4c3c2f2481f7db470b9b2da59e7d1f8c6f5b402f26d36ed8613aa166b0402cb67bf66827eb445a0425c4b1129d94a51518e06a7990c71f442b0b66889854dcec1ddafaf1a71b43c7d0d973d75199dd705c0c68e8de5860d9d79de36c934e6e853a20e564b4cb3df71d70f7c04ea896bef7c7bf375a13ee362225e123d9012b8c6b13304e824fcd38751e836b707360d6a982410a47a44158b01d3eed14352c6353955a96cff8a983bb2", + "address": "0x0ef32dec5f88a96c2eb042126e8ab982406e0267", + "key": "0x181abdd5e212171007e085fdc284a84d42d5bfc160960d881ccb6a10005ff089" }, - "0x08B229256Ba635C4500B5bCd23C8df2E06FD2666": { + "0x0F228c3Ba41142e702Ee7306859026C99d3D2df5": { "balance": "0", "nonce": 1, - "root": "0x533722a718cdf4f4cd17633807044d1e14f967b005430f7aee50ae9a4844c16d", + "root": "0xd5b34d0d68ba3ef51e4b583574eb13c9d8736538df206a042faea02c65359fb7", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000020d": "020d", - "0x000000000000000000000000000000000000000000000000000000000000020e": "020e", - "0x000000000000000000000000000000000000000000000000000000000000020f": "020f" + "0x0000000000000000000000000000000000000000000000000000000000000056": "56", + "0x0000000000000000000000000000000000000000000000000000000000000057": "57", + "0x0000000000000000000000000000000000000000000000000000000000000058": "58" }, - "address": "0x08b229256ba635c4500b5bcd23c8df2e06fd2666", - "key": "0x2aae99477bd369e3478c1f1df2c669e8960d4583ded8d183f9578e36b301544e" - }, - "0x0E4aea2BBB2Ae557728f2661Ee3639360f1d787A": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0e4aea2bbb2ae557728f2661ee3639360f1d787a", - "key": "0x517bd5fbe28e4368b0b9fcba13d5e81fb51babdf4ed63bd83885235ee67a8fa0" + "address": "0x0f228c3ba41142e702ee7306859026c99d3d2df5", + "key": "0xedd9b1f966f1dfe50234523b479a45e95a1a8ec4a057ba5bfa7b69a13768197c" }, "0x0c2c51a0990AeE1d73C1228de158688341557508": { - "balance": "1000000000000000000000000400000000012", + "balance": "1000000000000000000000000300000000013", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x0c2c51a0990aee1d73c1228de158688341557508", "key": "0x28f25652ec67d8df6a2e33730e5d0983443e3f759792a0128c06756e8eb6c37f" }, - "0x0eD465f2D38113203793802EaFcFe2a302F5141F": { + "0x0cbCC08EEaAc7Eb46d905d8b8512baf9EcEFc06A": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0ed465f2d38113203793802eafcfe2a302f5141f", - "key": "0xcae77150ac0c4c8a134fd8b7c02b6e053e99a44f91db924f3033dff62033de25" + "address": "0x0cbcc08eeaac7eb46d905d8b8512baf9ecefc06a", + "key": "0x1789b3c99cc4ae75e9081577bb1487920f8f5356e7b6b8d367a98f4236f15e11" }, "0x0eE3aB1371c93E7c0c281cC0c2107cDebc8B1930": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x247cc3b27208cdf8036ec9c5aa16ae2aa005255b13aaf0e79824fc6d69e2df61", - "code": "0x60003515156036577f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fd5b7f08c379a0000000000000000000000000000000000000000000000000000000006000526020600452600a6024527f75736572206572726f7200000000000000000000000000000000000000000000604452604e6000fd", + "codeHash": "0x7ee785a86efed9c83a8caeb5665b7a1fc4ec3fb9204fef8bd60152994e522e84", + "code": "0x6000356142ff54501515603b577f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fd5b7f08c379a0000000000000000000000000000000000000000000000000000000006000526020600452600a6024527f75736572206572726f7200000000000000000000000000000000000000000000604452604e6000fd", "address": "0x0ee3ab1371c93e7c0c281cc0c2107cdebc8b1930", "key": "0x9afc282e9868fb95921af24218a3612a16ad8e7329530b5be184a6507bbddecc" }, - "0x112e887C13720ea0Ea8Ab3c2eE9639155Ff06e50": { + "0x0eF96A52f4510f82B049bA991c401a8F5eB823E5": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x02c382fe4494fbb1df7e05021bd783c68ee4d3d0c82baad3d7a91cd910f3dac2", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x112e887c13720ea0ea8ab3c2ee9639155ff06e50", - "key": "0x171124648329d6a061328d1189b14f64e3da43648255489dbc67168331936bc6" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000148": "0148", + "0x0000000000000000000000000000000000000000000000000000000000000149": "0149", + "0x000000000000000000000000000000000000000000000000000000000000014a": "014a" + }, + "address": "0x0ef96a52f4510f82b049ba991c401a8f5eb823e5", + "key": "0x59312f89c13e9e24c1cb8b103aa39a9b2800348d97a92c2c9e2a78fa02b70025" }, - "0x1218Cf397301c287Cfd4a2Bdbd922A3432457388": { + "0x10FA59f55E0876fd0742a892CdC28522a44d0Ac4": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x097d31b10fc018fa01b350d82033872d007057b464560cdc1afd34fcddb14501", - "code": "0x3568ac4853d98daec689c5f2aa7d3141dd0256607e02057f4de3da3f333907ff9b41fe675cf46e85813b95622c1329ddda8c317b528ee44b3cbf5c27b8b8f7e5759c070bd3698aa0ecb5628e2a94ee9c0fc87c120f625d01a781262556e517bada8419d7f831676b15592f36811aed673124b0b8123e5c73e1ea68245a6ccf6457969cb441519f4b2cd9b0a57d7e95a7eb2c5e3f719cad38e8c60697bef8a3c2e153613a7c973b978a2b720f5225dbf4b83bda7128b3fd13e56307208ddfe0c77c2ebe6bc91f70109fbacaade46e1cb5258e806c9970c9d5085c13d5e23751de34ee70246abe44a6ef3f9dc451e68ce7669b7393fc4538f9fc58aec8dbf5b825", - "address": "0x1218cf397301c287cfd4a2bdbd922a3432457388", - "key": "0x887e6e4c23e7a93a0c66f56b8ac9b5399d205063604ff2f093c5b2d30af481e3" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x10fa59f55e0876fd0742a892cdc28522a44d0ac4", + "key": "0xf1030dcbd8e148d0bb4baa102b98525fdff7fb308c789a245aa66a8402d2344e" }, - "0x132432ce1CE64304f1D145eBa1772F6edd6Cdd17": { + "0x123B4998651f811E46D2441aeFECfd2FacD29b36": { "balance": "0", "nonce": 1, - "root": "0xa8cbc3846808271a2bf0580ee9da43b36853292ce79dbe0bc785c62337eaec86", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000006b": "6b", - "0x000000000000000000000000000000000000000000000000000000000000006c": "6c", - "0x000000000000000000000000000000000000000000000000000000000000006d": "6d" - }, - "address": "0x132432ce1ce64304f1d145eba1772f6edd6cdd17", - "key": "0x729953a43ed6c913df957172680a17e5735143ad767bda8f58ac84ec62fbec5e" + "address": "0x123b4998651f811e46d2441aefecfd2facd29b36", + "key": "0x9024e9b7859e438367088a1d007cfd7ede3ee942414862a496b8f63601d6e615" }, - "0x13f3F31335881a7402955Dc3Bf0b4A62936b44aa": { + "0x12a0aB4dF31cfDf42713Dc3cEebFc710FE675b3d": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0xe2a164e2c30cf30391c88ff32a0e202194b08f2a61a9cd2927ea5ed6dfbf1056", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x13f3f31335881a7402955dc3bf0b4a62936b44aa", - "key": "0x6742b9f65e686fd1b9da73a3a29541cbb07afaaf51b5b5be682b462131709388" + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000e5": "e5", + "0x00000000000000000000000000000000000000000000000000000000000000e6": "e6", + "0x00000000000000000000000000000000000000000000000000000000000000e7": "e7" + }, + "address": "0x12a0ab4df31cfdf42713dc3ceebfc710fe675b3d", + "key": "0x59a7c8818f1c16b298a054020dc7c3f403a970d1d1db33f9478b1c36e3a2e509" }, "0x14e46043e63D0E3cdcf2530519f4cFAf35058Cb2": { - "balance": "1000000000000000000000000100000000009", + "balance": "1000000000000000000000000200000000008", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2", "key": "0x9feaf0bd45df0fbf327c964c243b2fbc2f0a3cb48fedfeea1ae87ac1e66bc02f" }, - "0x1534b43C6Dfa3695446AaF2aa07d123132Cceceb": { + "0x16032a66FC011DAB75416d2449Fe1a3D5F4319D8": { "balance": "0", "nonce": 1, - "root": "0x2eadda3a2ead59e184a6b073cdd8fbe4538eac19175e79833c3efb263ff9d09b", + "root": "0xca971614d31dd563a9aa6117aed4e85ee0e8a87276baa442e937cae4b9996949", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000d9": "d9", - "0x00000000000000000000000000000000000000000000000000000000000000da": "da", - "0x00000000000000000000000000000000000000000000000000000000000000db": "db" + "0x0000000000000000000000000000000000000000000000000000000000000098": "98", + "0x0000000000000000000000000000000000000000000000000000000000000099": "99", + "0x000000000000000000000000000000000000000000000000000000000000009a": "9a" }, - "address": "0x1534b43c6dfa3695446aaf2aa07d123132cceceb", - "key": "0x2a248c1755e977920284c8054fceeb20530dc07cd8bbe876f3ce02000818cc3a" - }, - "0x15B9118f5f6a91cC127c4AbcDDDa1FA08D6d41C2": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x15b9118f5f6a91cc127c4abcddda1fa08d6d41c2", - "key": "0xcb10ab6f495ae291b320182d2316da52c2b5a4bdfe13d7071d1c948461abbe49" + "address": "0x16032a66fc011dab75416d2449fe1a3d5f4319d8", + "key": "0xe3c79e424fd3a7e5bf8e0426383abd518604272fda87ecd94e1633d36f55bbb6" }, "0x16c57eDF7Fa9D9525378B0b81Bf8A3cEd0620C1c": { - "balance": "1000000000000000000000000000000000011", + "balance": "1000000000000000000000000300000000005", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", "key": "0xda81833ff053aff243d305449775c3fb1bd7f62c4a3c95dc9fb91b85e032faee" }, - "0x17e7EedCe4Ac02ef114a7eD9fE6E2F33Feba1667": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x975f732458c1f6c2dd22b866b031cc509c6d4f788b1f020e351c1cdba48dacca", - "code": "0x366002146022577177726f6e672d63616c6c6461746173697a656000526012600efd5b60003560f01c61ff01146047576d77726f6e672d63616c6c64617461600052600e6012fd5b61ffee6000526002601ef3", - "address": "0x17e7eedce4ac02ef114a7ed9fe6e2f33feba1667", - "key": "0x69bf6d72df9e6b88306eb4e4624996e919f0433ba63520aa9a1d3f9888e09b1f" - }, - "0x18291b5F568E45eF0f16709B20c810E08750791f": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x94d95e732733c801cf6c47d1092559b355b731663edf264cd56f1f8bf9643dde", - "code": "0x53e446b02877d67323538930ac023539909d7ae9c37d47c9041a36b516d7a895b9082031afe800ff4145d688a9aceb89c2035073c366644d7c1fa9b891d3a351f13c26c3380332c756c2535bb8be8673c2d150e01b15e31f73fa100e1f4968f5f1b5f43cfd58433d8089d74d4b0d048639a18b3e74e203da03a300c559157a05ac7a8c487ac9ae6a81f1a5f24686cb5abcc471ed89182a27eb411609d783592905ad14573d4f19affa497b220c03fe2d7d204eecd50d03e42c775d0bdb013b9951aa4fa60f2ae98ad35a8d9cb8bb757547523cdbf7ebaea966a3a6a229e3bbecb59ab80f5598cb65e185f83739c5b8a9f7ed18c2d44c1cfa8eb3fe5e47e30e9e", - "address": "0x18291b5f568e45ef0f16709b20c810e08750791f", - "key": "0x315ccc15883d06b4e743f8252c999bf1ee994583ff6114d89c0f3ddee828302b" - }, - "0x19129f84D987b13468846f822882DBa0C50cA07D": { - "balance": "0", - "nonce": 1, - "root": "0x5804411a83500245d7b0f6826a301fe8e9314c1a4407b78022cd212295dc60c0", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000105": "0105", - "0x0000000000000000000000000000000000000000000000000000000000000106": "0106", - "0x0000000000000000000000000000000000000000000000000000000000000107": "0107" - }, - "address": "0x19129f84d987b13468846f822882dba0c50ca07d", - "key": "0x2b8d12301a8af18405b3c826b6edcc60e8e034810f00716ca48bebb84c4ce7ab" - }, - "0x194E49Be24C1a94159F127aA9257DeD12A0027db": { + "0x17b917F9D79d922b33E41582984712e32b3AD366": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x194e49be24c1a94159f127aa9257ded12a0027db", - "key": "0xd57eafe6d4c5b91fe7114e199318ab640e55d67a1e9e3c7833253808b7dca75f" - }, - "0x196d4a4c50EB47562596429fDeCB4e3ac6b2a5fD": { - "balance": "0", - "nonce": 1, - "root": "0x5a25afca240ed3f1756a12b178c2875f75a1ebd4e7942a550856d04b61d424b1", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000013": "13", - "0x0000000000000000000000000000000000000000000000000000000000000014": "14", - "0x0000000000000000000000000000000000000000000000000000000000000015": "15" - }, - "address": "0x196d4a4c50eb47562596429fdecb4e3ac6b2a5fd", - "key": "0x4e258aa445a0e2a8704cbc57bbe32b859a502cd6f99190162236300fabd86c4a" - }, - "0x1B6eC89d00555BeBF7DEBE884b5A1b1FB5ef79B1": { - "balance": "0", - "nonce": 1, - "root": "0x29a3676b5776327effe8a01b0b824a04133fb3944d215d371d27817c7c7d0050", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000ce": "ce", - "0x00000000000000000000000000000000000000000000000000000000000000cf": "cf", - "0x00000000000000000000000000000000000000000000000000000000000000d0": "d0" - }, - "address": "0x1b6ec89d00555bebf7debe884b5a1b1fb5ef79b1", - "key": "0x622e662246601dd04f996289ce8b85e86db7bb15bb17f86487ec9d543ddb6f9a" + "address": "0x17b917f9d79d922b33e41582984712e32b3ad366", + "key": "0x13cfc46f6bdb7a1c30448d41880d061c3b8d36c55a29f1c0c8d95a8e882b8c25" }, - "0x1E8CE8258Fb47F55Bf2C1473aCb89a10074B9D0E": { + "0x17e7EedCe4Ac02ef114a7eD9fE6E2F33Feba1667": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd5daa3aec1f142e2b2059b675d676ccb42129d27d96f8e901df2dac6104b38e2", - "code": "0xf548adfdedfd2f8b2416994318306c690dadb026395430e32e9a141187933c8602d9f8353bca53bc9b195aa186ab6d98b49a9120c00257ee2c7d860c26f864ea7352bc45c8aa6995480780fe15a07c4daa795263b5e7a9d04d9ed979c93ca85e57023ef7fe58b878582140ea36f22723905ad724896eaf74090fba76c229bd2269bc8c08a6b955aec2072ca430bac7123bc3539264a736d1a23621b0f0c62f3166eeecffab615cf4c69d47d3aa51576e95b697767264fa754ea36f4e363ea19359149054a4189e9e52234a041160d0a984f6bcb43e7a9da69cfb168d147633650425d4cac564eade3739b18cff91bb2bc855f9c26bed98f6e089d895e00c3d5f", - "address": "0x1e8ce8258fb47f55bf2c1473acb89a10074b9d0e", - "key": "0xfb2ab315988de92dcf6ba848e756676265b56e4b84778a2c955fb2b3c848c51c" + "codeHash": "0x975f732458c1f6c2dd22b866b031cc509c6d4f788b1f020e351c1cdba48dacca", + "code": "0x366002146022577177726f6e672d63616c6c6461746173697a656000526012600efd5b60003560f01c61ff01146047576d77726f6e672d63616c6c64617461600052600e6012fd5b61ffee6000526002601ef3", + "address": "0x17e7eedce4ac02ef114a7ed9fe6e2f33feba1667", + "key": "0x69bf6d72df9e6b88306eb4e4624996e919f0433ba63520aa9a1d3f9888e09b1f" }, - "0x1F12d422bFb4444EdA416C805B0eBC9C9C5219b9": { + "0x19Ee2Fd8a16B0d5348CC43634E3015f5c4eC281d": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x2163e5f7425a961dedf4ab14d04cb5da552f71e6753f2ee5d0f757fa80557a72", - "code": "0x6d51b3e2fee37bb096ac27bcd2f51406f41ca898c8655c777eb566221b5c30ef0caf086fb5eddf1b4d11c4f0b807d5031fcc6c85a4bde491a90c50edc223e345203d2d2bdae77b6c59cc38f69817e60d54c7ca8eeca5cbd2727e9f9fb7a596a5ef8f912c2063a9c1079545513398425889f237200dbe31f704b550eedddec1553cb8dbdb71abce785b0d3ada500497411f9a35029bc9f0128fe99dbe40b831ed7092736705691e7fcb646542760fd0f452b1b0698662a4e52aa598cf52e0872bb29f850db3636ac0c738910696357ccf04bdcf9eecb591427ec2a19c4d0307382a9415d08c0c16e17c81d1ddd07c87b75cf5938c1315af07b6f3e822070a8512", - "address": "0x1f12d422bfb4444eda416c805b0ebc9c9c5219b9", - "key": "0x5e30d12ba0a17b9e1add523ccad77978516b91d2637cfa79061c848fd42dc002" + "codeHash": "0xb5b2354eb364d49102d246eb58335edc8ac8d96a3278e5ed4664bfcc652cd821", + "code": "0xd5794d64d075a72356722c9b36b106be1e75a5b1a18d43aeecf4b200527ff024182b14c38a1b998fe046c9dc6250ffd54c2a94a0889e1b069cd376c59eeafef21cc42237b0fb8f0a02adc3d03ce8e36f1c04cdd89283fe1c1b0481c9c7b7687facadc60d47b3ff7acda1f55244f2dd77100bd73c50fc73c02f9b2be85f5465f80c67a9b017d662d1bc9ac34b32ea15054da3fbc1fc745732ce7b22f51147ab60f564f8ac71e4f1e429c2f327374b1ff53ce2c4b40ba626852f969a70fa403fba5fa1b75531f2dde3e17219f3978fb05f66e88c2f47dbbac04ba5c54eb78a15b812265b62305fc5fb7e9c9b4551ac42738a1f9f04801ddc76097f8d952b6ae20c", + "address": "0x19ee2fd8a16b0d5348cc43634e3015f5c4ec281d", + "key": "0xf88f8f5e97f8c05caae26c7a8367f5e07f92daee1fb16cdff40ba1a250d6c521" }, "0x1F4924B14F34e24159387C0A4CdBaa32f3DDb0cF": { - "balance": "1000000000000000000000000200000000003", + "balance": "1000000000000000000000000300000000004", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", @@ -2109,116 +2041,68 @@ "key": "0x7963685967117ffb6fd019663dc9e782ebb1234a38501bffc2eb5380f8dc303b" }, "0x1F5BDe34B4afC686f136c7a3CB6EC376F7357759": { - "balance": "1000000000000000000000000100000000010", + "balance": "1000000000000000000000000200000000010", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", "key": "0xc3791fc487a84f3731eb5a8129a7e26f357089971657813b48a821f5582514b3" }, - "0x1F94C5D92A7cDA91E46258db39cd2080934cf401": { - "balance": "0", - "nonce": 1, - "root": "0x2ac8ab8e205b5f066caaf29772e71b8acc033fb2dd00aef81d58d5c6cf41393f", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000a2": "a2", - "0x00000000000000000000000000000000000000000000000000000000000000a3": "a3", - "0x00000000000000000000000000000000000000000000000000000000000000a4": "a4" - }, - "address": "0x1f94c5d92a7cda91e46258db39cd2080934cf401", - "key": "0xade3931ebf0e80c7ff1ef57f79e1a3bee133066fbc2f65c98bde9b9751c59fd5" - }, - "0x1aE59138Ad95812304b117eE7B0d502bCB885af5": { + "0x1bE75a06c0277c0ad20d2a7B537A4E3262ae544A": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x91229856266a08d68e2ba7fbe841ea0367eee39a9abbdf7fffa2e1fca5bf530a", - "code": "0x1a3539311f056efda55cfb638b48ceb0b16c46de7fdcfeece7c16dd10edb530a980802d84c4907cfb351be0c47b17b29e497879c00ff4207f841b525e59a4adb4dfcef122f40141197bd2add22dde2be0b18caf178af0e36baf2dbaca781064eb0aef7f62d67906ac495f365239649f69c785963deec1dc59e987ee4ff2c0aac26dc59d1574bbfa08847573f46e3a6a81f6dd471c94e177fd7e9d751b032632fafdc38a2d8170640ae476d556f5391a670c7dcea12fef53e3782b397413b8073ab5c193bc1e7e460f2a67a20e95e8eb487cb5c6e73e0a81f056b2ad06bca644804c56e6a6ea052548b58611dab35b25575fbe01e39f14d213e55204b97fe495f", - "address": "0x1ae59138ad95812304b117ee7b0d502bcb885af5", - "key": "0xf164775805f47d8970d3282188009d4d7a2da1574fe97e5d7bc9836a2eed1d5b" - }, - "0x1c991868B648141eFE0a1797d2E684f0E9D85f5D": { - "balance": "0", - "nonce": 1, - "root": "0xd5b837548792630f18e5e5860cb7c2e09d50f3e0bf633031a5266dc813e51722", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000fa": "fa", - "0x00000000000000000000000000000000000000000000000000000000000000fb": "fb", - "0x00000000000000000000000000000000000000000000000000000000000000fc": "fc" - }, - "address": "0x1c991868b648141efe0a1797d2e684f0e9d85f5d", - "key": "0xdaa5ac389919fe4309e82b1ec0173c579a91909e43606c075fffcd175d449bb1" + "codeHash": "0x721a89c9ec88bf5d831f58a8fc24ee302af110b17d80413835d06f29e56c24cb", + "code": "0x977b44b92ba69610c99ea306058ffef6449dfef2a9111a242e2487f3b67bd884e1c7dc25d93c8ca94ab03df899ffd8369f903d70f89208ea0f9216c56c311f65a7ab9585d176f7553243ab24f6ba2b1d026cba57011704693e8f7e688fc6c10272f499da03a12e0d69bedeb8af54720422e6a93707efd07a19d40b1693edd7746269a42f8721783686df7e2d53dfc3e449c24381e01837fc0db59bddaf4da17fe35f100537fc5a81611a171b65ec62698d902d6c24f0dca36213fbd791d816cad51254392213b26261c76c6dc24d6f095073d42a479d10d1abaf6cbc5679bb519651205dc817afac4f6b337402a37ee248db015896cb81056928573c24869cff", + "address": "0x1be75a06c0277c0ad20d2a7b537a4e3262ae544a", + "key": "0xc02a1a280bf5e9f8aee1a855dad87a7d58ba42d4d58909c683dd62e220cb917f" }, - "0x23946FCc6A6FC157F5fA71766920C05B3ca332A9": { + "0x20bcaA573F9D21A04b8434F31f23b146F3178cf7": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x9b8e6ae27d3f687d8da6c6cd00910988ee2f132e69a9039495349f53e5d420d4", - "code": "0x2200b384d5b1adb897ca35499aac189a6bc95554ae7cd569cff630ab95ab2408ec2ece864d596b2df3fda60d8ff3647904c8787bbcdca061ac2c3ced7ec882414e891f8214eefddacb67949285b4d8381359bda85deba8c8d1cd531fac277446250aa56d419d6944c75ef323c37456f10c8deae91a088f5266af04395bfb6f9f1d83040a41828888b050efc081f5d66c96d76f2436e80f14429fe3ba7679228b5d30ee1cebf81682922812857932b35925ce3b0005995d8dcc5cdc3ade024209b45d823cb873a82c40322caac58ec73ecb33fe985c8d73b5edc8c5bd10a32dacbd709dd7349a1e346060645a803266120e2ad65cd1489f355739a06ccb96006a", - "address": "0x23946fcc6a6fc157f5fa71766920c05b3ca332a9", - "key": "0xfb1f3c0b3adbfacce7162c4512f5e01da2e45f783d1d098d59478ba98579a943" + "codeHash": "0x3a53ca9ebc623f96f3c01edfc2cfea906df6afcdb46fd4cd0c5ef231dcb247b3", + "code": "0xa0154eb5d4f58d1845cc59d98da9dc0526a385100cab80e881cf68c5ddd774d6c83df05b39f04b0e32a580fb2457e5a805b04291544a17fa7d0673ae46aa593e16cf53eb5237943918e4520255055c6e4c38e4c0d88373b478ac80453df3aab44a5bde82e5995b6780e708038ec38d21cac5aa8ea437e42bbb7a345c96e77afef5e826823d1b521a059a638208df20ec7a83c69ba78f1fe2089269842362b6d9f6a2fe1e948cbfc587c2c82d46a9aef3b8bf6d2ef795f19d1a32a7aa457123ebb5875b78058b3879b3385f1925ff16e04250b3cad255a1746f02b5fd66a379ca2c0fb383035f53c87dbc233aba2b5c9852b97d153d9a9e79119bdea4a5918250", + "address": "0x20bcaa573f9d21a04b8434f31f23b146f3178cf7", + "key": "0xefe19584458047edddb6b4c43bb36ef63fb1d5b8d3c630c09a27580302790e80" }, - "0x23E7eCFEbfe3a69F17F90fE6AFF700c395C502A4": { + "0x21171D0AfFf7169E5692bf7bd5ADb43AF0f5F59E": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x23e7ecfebfe3a69f17f90fe6aff700c395c502a4", - "key": "0xed63eed77538b7d6aec65f20d6538407bb521bcc2049f5227f0ba7125f7e5246" + "address": "0x21171d0afff7169e5692bf7bd5adb43af0f5f59e", + "key": "0x2d425481284fbb1874a2c55d81564f371543b3b8f7450e860bc5381ba47b465f" }, - "0x23b17315554BD2928C1f86dD526F7ee065a9607d": { + "0x2AEB07Bf550A17EB782474376C0c1b6d1164d623": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x9a29a4ee31aaa09c1644e1fbb4f6daf087496185098474a6caf2128201e2ef26", - "code": "0x9e91c95f108ead30341468db9696e39ed81de6a68bc8c6702bcb66393fce6e75f7459e621ec1fc60fd62c436d4281de72cb9f48787dc9c8288a3050292b090046d00efa09a7071d855bc5fb7d93921fbf02f2c4e3992802f2a9b08050cf48ea83ba015d6b845e102ce2f76836007be82508e3543856f2a3c2ff4b56eb46d920eeaa72e3626d79eea854e214b64a34b95d0c9348f5b8df0b074d774f7dba83c65641a7e47c832ef1f4ef72e654761ca2c0b592dc5a9de41ec09261efc0afea2bed4c27e5d2ce7b7345f78d7f5ddc8b90697d63512e00b9f949b158a467d0bfffc759e22076818c4256545c2158d054d4904983321e7c2bbb6fe78c5cb62872764", - "address": "0x23b17315554bd2928c1f86dd526f7ee065a9607d", - "key": "0x12e394ad62e51261b4b95c431496e46a39055d7ada7dbf243f938b6d79054630" - }, - "0x25261A7e8395b6e798e9B411C962fcCc0Fb31E38": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xda6d4548d8504c1c6b93b3f8afa6a43ec3f393b4538817077e5c0d8a16ba37ae", - "code": "0x7789c5fe6d71025d8baaa82349a48bdecdf7d33796c5b62fb2e2709eecea43508c8f1d83c32f3a2c534b56bae7b22603ef0e0c3b7e11b1eef2bafb0da977e3dc1ced5e204c93c1fdad1d04ee5664dbf790f8db86241883cdde350ce907ad86ca1f61127137b2b334cc768fbb1f2c09bd3ffa8b4efe78fbac6f501d1ec08449daef188faeece6fe5db45dc7f5d168733c0c348bd006890ac720106e2aa22f60bc305ece2ab3243c04f78c036bbbc0c561f9d54db01bbb3dc7946b4979b6a40dbd68404147fdbb906e3359f7733cbd4345edc2b456718e75029e6a1f6ba819c54467dd4e7709cbc529012d23fcd661c8cc3327ec3cefbc12e02677a50c121eecc2", - "address": "0x25261a7e8395b6e798e9b411c962fccc0fb31e38", - "key": "0x1017b10a7cc3732d729fe1f71ced25e5b7bc73dc62ca61309a8c7e5ac0af2f72" - }, - "0x255F219878846c5893F664CFb2A35a381ec8C149": { - "balance": "0", - "nonce": 1, - "root": "0x5bec588324e6249140515272adc6b1f5b34ae0a4782db0a55a7481bbce20b6e8", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000244": "0244", - "0x0000000000000000000000000000000000000000000000000000000000000245": "0245", - "0x0000000000000000000000000000000000000000000000000000000000000246": "0246" - }, - "address": "0x255f219878846c5893f664cfb2a35a381ec8c149", - "key": "0x8adecfc09eaee180c4a23258a373d4f4c472a03eed1be91814ca315fdba5902b" + "codeHash": "0x59ea8e8394dd6ada740962707b3d7323a33209aa01c521f7633914c990dc4e72", + "code": "0x5d4702183e4406aa0103cf4e1193f621dd93a4fef034dfbf6d5fe2604aabfac75a13f6356acb2f32ad5f7b35e3b5cce60828c11d4777e62d521196ece8fb340983e3008e3af31fcc69e293b6825b3fef522aa83473e56e69122349586a735e2046df1ba032f7273adfb50869ef5a17a8fffe76f90e9f8294290a3c9b9484add5b21769473a98c1ba3e6d2bc72b8bbb799cd2c30a9cff3f1428f7037f772e03eda237ad7935dea2dae206a9f954a0b3f021aba3d29281f5d8e9d20fec92bc90bdf9909f4b035d96087c3a4a8df382d8d87641eb9e01c03c2f87643b292928b907b62e1dce1317f4e156490b590e91d0e333ceb760dac2ddef3bd251cf89fa8776", + "address": "0x2aeb07bf550a17eb782474376c0c1b6d1164d623", + "key": "0x81eb53bd3cdb01b239029a40c5362aa81a9017921981d1f188c2b7df594203c2" }, - "0x26e92A8D6eDBD0b9cED1dd80a920Ad0b796fCf93": { + "0x2B0c6fDcbEc5dc0e3a89e2Dc1f4f3E8e381E200f": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x26e92a8d6edbd0b9ced1dd80a920ad0b796fcf93", - "key": "0xa28e6adde4090652685168a269cb1141e28b0849487175237b9b32064788c2f9" + "address": "0x2b0c6fdcbec5dc0e3a89e2dc1f4f3e8e381e200f", + "key": "0x92e7a2e08d0b020127e08b5d531e73506805651f6cab173d836f43566dfffe0c" }, - "0x2C0cd3C60f41d56ED7664dbce39630395614Bf4b": { + "0x2BD85770Ed2Cc8d09f91a3C1b0F7197dfd8A8850": { "balance": "0", "nonce": 1, - "root": "0xa3e3987c498c56b398b12cf368a76f2d184dd1d77b4896f4626909e35a7536d2", + "root": "0xcbf1eba0bbd55dc6bf80b04aee815e20cb66ffea5a015c3fbd8ba5df2ccae82b", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000c3": "c3", - "0x00000000000000000000000000000000000000000000000000000000000000c4": "c4", - "0x00000000000000000000000000000000000000000000000000000000000000c5": "c5" + "0x00000000000000000000000000000000000000000000000000000000000001b6": "01b6", + "0x00000000000000000000000000000000000000000000000000000000000001b7": "01b7", + "0x00000000000000000000000000000000000000000000000000000000000001b8": "01b8" }, - "address": "0x2c0cd3c60f41d56ed7664dbce39630395614bf4b", - "key": "0x92d0f0954f4ec68bd32163a2bd7bc69f933c7cdbfc6f3d2457e065f841666b1c" + "address": "0x2bd85770ed2cc8d09f91a3c1b0f7197dfd8a8850", + "key": "0xabbe9e53a2f086a9c45b8e901f6e5bac26ce118257e4f60e34c74983f7aa0bbb" }, "0x2D389075BE5be9F2246Ad654cE152cF05990b209": { "balance": "1000000000000000000000000300000000006", @@ -2228,36 +2112,35 @@ "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", "key": "0xa9233a729f0468c9c309c48b82934c99ba1fd18447947b3bc0621adb7a5fc643" }, - "0x2b6D216387cc86BF46FA7202C36C4f40BF1d7A22": { + "0x2E5F413Fd8d378Ed081a76e1468DAD8cbf6e9eD5": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd0db10813ed93d8d4216b55bb44f28dbd8979334d17f96e96230067c22aa3d7d", - "code": "0x366a7b92acda364086cc991f618bf9f10b629ec0f7ae94543f96b691b69ec9922cc30221e0553428287371236269b4e2f6f11f95f33fb976fdb79b586bb6c342c0c96d13f150a4b457c3bd96e92c2a5ab695d3246c81b0c07a0503c31ecba4728bd72d705e704e96ab1fa5baf1ac8053f4ec008dca8cf0376ca60a5648fa9532aaef4f4d920c99352d192889a8613287b33396c3d6a14178bd3f0455af509e256c40122c67bd2f0cbd1c3fa8ee6656e600ea58ee13b4077687b98c5c145bddbefd91b674668e771a29edc7bd49406822c49336f642d316b2b9ba0c0ff145fb18c23152f459c8033d1c6b84df917f2b2519e4be6bb34595e1cf96f7c07f456725", - "address": "0x2b6d216387cc86bf46fa7202c36c4f40bf1d7a22", - "key": "0x3e442de3aafac6a255389001775f311d0fead71621ec597e7ea7f91bcba73e49" + "codeHash": "0x6cab722372e634ef5dca9b4dc1454cfeb4e9eb9269eb03d6824b7c997129776b", + "code": "0x7786f24ec8e68c1f537753be90a834aeb9797aa2ade11dc9f54973d24a879c0e2e000f2864695c298e3b798ebf646f507bc67e534235217f247e8aedeb44a286903029b2ccf2817560769df843ccef3b958197f563f97bbded0c9d6af426a1238a6b747e4193754f5887d456542feeee62a909f5cc32e46553fc5e84632ffaaf995dd2136839e505810de8baef08564621a4fa31c642ea16714d8c051234d3b1bb72a1128595dbb042fb7a341fba8d1012e8d5a83228532d7db5275249ae2c733e2405bc8eddcc2dec697d454ddca37a2f157a1cf34a6377970583fce6b49b6a1c03e9112a7ce53c99cca1e170b854d8dc90099ea369962ab98f8cde6c92fb57", + "address": "0x2e5f413fd8d378ed081a76e1468dad8cbf6e9ed5", + "key": "0xe69f40f00148bf0d4dfa28b3f3f5a0297790555eca01a00e49517c6645096a6c" }, - "0x2b8E14ACde4DC8f4dd1A6FC249a48323431c69DF": { + "0x2EB6dB4E06119Ab31A3aCf4F406CCBaA85E39C66": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x9f9a33401f113dceb7f8594ad6699ba7ef06665b11fe19c87f37e1c58d2eccc6", - "code": "0x66f4851715b29678b0cca267bfde816a0838d4b72ddc17590aadfd30fc1f1d13a6d5a907f2fd275a22b20a64111d18d562bc2b61aa65b44f5c83c1d6aac7d2e45db2aa293c68d8b2d991211b8aae5b6920d37ca709b36adc4d30eab3b5df163fef8374c201f52e9cadf0358fa9fe81d3b5dc6cfd55611ff392a0f6af5d359a1bff5cc1e3a6fb7e9faa08d225cdd564eed6d3c066f453d24f62b227f5b7a98674b0e5ed5015336e10965b0014527cad85307e5d111ca7afc3b5a60ce0021cc0a88dc3ccc90a5a484fa2a729ed5b473614aaeab270aa88d72534a542e99667eddc42fb786c069f6c2379a23a093b7909d15b477e8db52dacfeaae781f4c468708a", - "address": "0x2b8e14acde4dc8f4dd1a6fc249a48323431c69df", - "key": "0x448717f258267a130bd10b361c293b918047608106b21f4bdaff520b90586d4e" + "root": "0x1d5b0045e4bbf5ac05684b7f97ad373b57bfa9fc07e8c214c28624f7ce9a47a5", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000002a": "2a", + "0x000000000000000000000000000000000000000000000000000000000000002b": "2b", + "0x000000000000000000000000000000000000000000000000000000000000002c": "2c" + }, + "address": "0x2eb6db4e06119ab31a3acf4f406ccbaa85e39c66", + "key": "0xaeaf19d38b69be4fb41cc89e4888708daa6b9b1c3f519fa28fe9a0da70cd8697" }, - "0x2be6F9Ec5d4a0E79953570f06554FbFf9473B11E": { + "0x2Eba46D62F0C7DFCdc435769A2d5Bc73FC311ee9": { "balance": "0", "nonce": 1, - "root": "0x9e2e9c13c28b856f12884ebd17a330603ac2294d472aa7b0caab80761af0ae9d", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000076": "76", - "0x0000000000000000000000000000000000000000000000000000000000000077": "77", - "0x0000000000000000000000000000000000000000000000000000000000000078": "78" - }, - "address": "0x2be6f9ec5d4a0e79953570f06554fbff9473b11e", - "key": "0xc5a247c452045b83598d9bdb0bfc185eadffbc577e2f8bbafaa5339d2adac545" + "address": "0x2eba46d62f0c7dfcdc435769a2d5bc73fc311ee9", + "key": "0xf132caa2fde1cb1d7854da7631c474d928ae153b5ebedf16d262d5bd28a4ab48" }, "0x2c1287779024c3a2F0924b54816D79b7e378907d": { "balance": "0", @@ -2268,97 +2151,90 @@ "address": "0x2c1287779024c3a2f0924b54816d79b7e378907d", "key": "0x09d6e6745d272389182a510994e2b54d14b731fac96b9c9ef434bc1924315371" }, - "0x2fc7B26C1FD501C57E57dB3E876Dc6Ae7AF6979B": { + "0x2f30E977B0A8A60747789ee0F6B3cdC9C041FDEf": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x2fc7b26c1fd501c57e57db3e876dc6ae7af6979b", - "key": "0xb9cddc73dfdacd009e55f27bdfd1cd37eef022ded5ce686ab0ffe890e6bf311e" + "address": "0x2f30e977b0a8a60747789ee0f6b3cdc9c041fdef", + "key": "0x420a83d9891f19593cdda9b31bb3b450e960fa87042dd428a7fa5ee69db02c75" }, - "0x33aFD8244c9C1a37F5bDDb3254Cd08779a196458": { + "0x32F1C89Cc046227EcD93C2FCe5d3eC91db833c68": { "balance": "0", "nonce": 1, - "root": "0x18bb17163a640c960d76901ccac104f3b60f46c150c29584868b14229b97966f", + "root": "0xd8d478365c2dd43220eab798a1fdf01a2e41ed0c4b7ce1a6a649dc4b12f97259", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001b5": "01b5", - "0x00000000000000000000000000000000000000000000000000000000000001b6": "01b6", - "0x00000000000000000000000000000000000000000000000000000000000001b7": "01b7" + "0x000000000000000000000000000000000000000000000000000000000000001f": "1f", + "0x0000000000000000000000000000000000000000000000000000000000000020": "20", + "0x0000000000000000000000000000000000000000000000000000000000000021": "21" }, - "address": "0x33afd8244c9c1a37f5bddb3254cd08779a196458", - "key": "0x210ce6d692a21d75de3764b6c0356c63a51550ebec2c01f56c154c24b1cf8888" + "address": "0x32f1c89cc046227ecd93c2fce5d3ec91db833c68", + "key": "0x97d6688cffcba05e22d6940fd07a8b4e93670e2d8e0f8680b9a97865474e803f" }, - "0x36fedBB5CdA6a9924e5da9Ce388b3418E0cFae06": { + "0x32c417B98C3d9Bdd37550c0070310526347B4648": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x36fedbb5cda6a9924e5da9ce388b3418e0cfae06", - "key": "0xd9cf358f42d8836e892ab02529c9659d6fae5ea088bd936be43e28d85af28fbe" - }, - "0x38D0Bd409aBe8d78F9F0E0a03671e44e81c41C27": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x38d0bd409abe8d78f9f0e0a03671e44e81c41c27", - "key": "0xb58e67c536550fdf7140c8333ca62128df469a7270b16d528bc778909e0ac9a5" + "codeHash": "0xad3bcddc933488cbc5a30cf7295a338d57ecdbce88acef961e28fc0267fafee4", + "code": "0xb84e4298f3a6292774b798b43a202ce92291460f19fe80ed2d2d7e8e4674dcba31ff9da46623ded696608610c3749320b1cb2c2dfd644b1139da5367a8e616cf82fb8bdd0a53542a1f59046c16f7a1350c43d22db36425bb53f551e7c6a091814ba0d371c59a4c8176901cb7799ecdd8b41b974be3a1349b5d0a9ff9aaa230d9547911337f50119fe7598b1be3fa84d3d0506ffe5c730db17c43bc74040bbfce348e8fe0716b12afdd2e814ae0b8b1bb9b5c7a197ef418c73b8bdd93bee14de5c695a062ea1c0f75fd266ccc34c407f7d5229534fc96b1932c122008903fa35369a4526ee6c6fed706e20afa2cce030b28dbcbab5e4e2d1918c6e71839728400", + "address": "0x32c417b98c3d9bdd37550c0070310526347b4648", + "key": "0x80cd4a7b601d4ba0cb09e527a246c2b5dd25b6dbf862ac4e87c6b189bfce82d7" }, - "0x3A2C11526F95C05A5de3614E9c40666798C5F9b9": { + "0x3632D1763078069cA77B90E27061147a3b17Ddc3": { "balance": "0", "nonce": 1, - "root": "0x838d9383f5c87eea967abf79c12ce654a2472b04b35c0dacda9d7d4c992e3993", + "root": "0x34da204f60f9a40f3829dd9821b33acae3c08e6d627791dcaa05d10a60a34180", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000168": "0168", - "0x0000000000000000000000000000000000000000000000000000000000000169": "0169", - "0x000000000000000000000000000000000000000000000000000000000000016a": "016a" + "0x000000000000000000000000000000000000000000000000000000000000006c": "6c", + "0x000000000000000000000000000000000000000000000000000000000000006d": "6d", + "0x000000000000000000000000000000000000000000000000000000000000006e": "6e" }, - "address": "0x3a2c11526f95c05a5de3614e9c40666798c5f9b9", - "key": "0xec873ed51fb0822893b43c0fd08bd25d1c226a97f7ba073cd03b8fdbe380ed19" + "address": "0x3632d1763078069ca77b90e27061147a3b17ddc3", + "key": "0x0463e52cda557221b0b66bd7285b043071df4c2ab146260f4e010970f3a0cccf" }, - "0x3C48a562A0361236F28a17AAC65B9130a0316B71": { - "balance": "0", - "nonce": 1, - "root": "0xd8419536b78c13ef996838648ee38f89388fe1ffdca0b92bbbd78187a54c3f49", + "0x3aE75c08b4c907EB63a8960c45B86E1e9ab6123c": { + "balance": "1000000000000000000000000400000000011", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000034": "34", - "0x0000000000000000000000000000000000000000000000000000000000000035": "35", - "0x0000000000000000000000000000000000000000000000000000000000000036": "36" - }, - "address": "0x3c48a562a0361236f28a17aac65b9130a0316b71", - "key": "0x8ff8a4884137e983c0298ad24228193292b5f523869dc16eeb916cae8b09239c" + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "key": "0x878040f46b1b4a065e6b82abd35421eb69eededc0c9598b82e3587ae47c8a651" }, - "0x3Ee253436Fc50e5a136eE01489a318afe2bbD572": { + "0x3c204CcddfEBaE334988367B5cf372387dC49EBd": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x3ee253436fc50e5a136ee01489a318afe2bbd572", - "key": "0xaf7c37d08a73483eff9ef5054477fb5d836a184aa07c3edb4409b9eb22dd56ca" + "address": "0x3c204ccddfebae334988367b5cf372387dc49ebd", + "key": "0x5ec55391e89ac4c3cf9e61801cd13609e8757ab6ed08687237b789f666ea781b" }, - "0x3aDfbF5A4B4493AB10b6d695E5a6f7f91F768098": { + "0x3fBa9AE304c21d19f50c23dB133073f4f9665FC1": { "balance": "0", "nonce": 1, - "root": "0x98d78678d41a3fbfda98fdf2709727e38bb15bf11287e7204299ef5a125acf8f", + "root": "0xecba188c60d6fd06bba6dfad2fc6162c590d588ec0db0953b033ece234571816", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000022e": "022e", - "0x000000000000000000000000000000000000000000000000000000000000022f": "022f", - "0x0000000000000000000000000000000000000000000000000000000000000230": "0230" + "0x0000000000000000000000000000000000000000000000000000000000000040": "40", + "0x0000000000000000000000000000000000000000000000000000000000000041": "41", + "0x0000000000000000000000000000000000000000000000000000000000000042": "42" }, - "address": "0x3adfbf5a4b4493ab10b6d695e5a6f7f91f768098", - "key": "0x83d7634225a59c664f323c88bcfaff1cf73421ed036ccd2dbe44571312128db7" + "address": "0x3fba9ae304c21d19f50c23db133073f4f9665fc1", + "key": "0x0b564e4a0203cbcec8301709a7449e2e7371910778df64c89f48507390f2d129" }, - "0x3aE75c08b4c907EB63a8960c45B86E1e9ab6123c": { - "balance": "1000000000000000000000000100000000012", - "nonce": 0, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "0x402F57de890877dEf439A753FCc0c37ac7808eF5": { + "balance": "0", + "nonce": 1, + "root": "0x1255f3a2840f807a7966373c9961a98cb3257bcd1b5932ed04b5708ddb80f81a", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", - "key": "0x878040f46b1b4a065e6b82abd35421eb69eededc0c9598b82e3587ae47c8a651" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000106": "0106", + "0x0000000000000000000000000000000000000000000000000000000000000107": "0107", + "0x0000000000000000000000000000000000000000000000000000000000000108": "0108" + }, + "address": "0x402f57de890877def439a753fcc0c37ac7808ef5", + "key": "0x5c20f6ee05edbb60beeab752d87412b2f6e12c8feefa2079e6bd989f814ed4da" }, "0x4055CAe5c7d838cda10D40f9d07106C7f5f3be1c": { "balance": "0", @@ -2373,744 +2249,856 @@ "address": "0x4055cae5c7d838cda10d40f9d07106c7f5f3be1c", "key": "0x6b9ff41fb13fc66c4e1c4f85d59c52608698715472b7cce609bdbf75976a438b" }, - "0x417fE11f58B6A2d089826B60722fBeD1D2Db96dD": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x35e6505af3b8e9a18eefffd4dafa37f401469b1932fa2011ce72a78ea72721ab", - "code": "0x36156009575f355f555b305f525f5460205260405ff3", - "address": "0x417fe11f58b6a2d089826b60722fbed1d2db96dd", - "key": "0xd5e252ab2fba10107258010f154445cf7dffc42b7d8c5476de9a7adb533d73f1" - }, - "0x426Fcdc383c8bEcb38926EC0569Ec4a810105faB": { + "0x410EaCE40803A705AdF026fE52367EAfb8845639": { "balance": "0", "nonce": 1, - "root": "0x42e40009dbade0eeca64fbd7faef8c68145ca05516d238892f9caa271801f955", + "root": "0x2bfb9362eb6de5d4265fd2d19fcc52c7c8355e3fa62f22281261019a7d2afe43", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000173": "0173", - "0x0000000000000000000000000000000000000000000000000000000000000174": "0174", - "0x0000000000000000000000000000000000000000000000000000000000000175": "0175" + "0x00000000000000000000000000000000000000000000000000000000000000b9": "b9", + "0x00000000000000000000000000000000000000000000000000000000000000ba": "ba", + "0x00000000000000000000000000000000000000000000000000000000000000bb": "bb" }, - "address": "0x426fcdc383c8becb38926ec0569ec4a810105fab", - "key": "0x6bd9fb206b22c76b4f9630248940855b842c684db89adff0eb9371846ea625a9" + "address": "0x410eace40803a705adf026fe52367eafb8845639", + "key": "0xa54c01fadcbd4480f0ed0306c41dd4a1b517d5ba114bf95d6ee8ceb24ccfa65e" }, "0x4340Ee1b812ACB40a1eb561C019c327b243b92Df": { - "balance": "1000000000000000000000000300000000003", + "balance": "1000000000000000000000000400000000005", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", "key": "0xa13bfef92e05edee891599aa5e447ff2baa1708d9a6473a04ef66ab94f2a11e4" }, - "0x4392115B81B6B7CbFf42Cd14752B9e565f316A17": { + "0x44268f2fE37A01cbA6aC0FAff6c0D63a3c0FC006": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x9682130add2b4c6483edd1e2b4d49edd6fff4a990ccc237ff9f7edd0e7596926", + "code": "0x2c0b24745969ac267788bc13fed108253ed7710a84a4b5e0cb2637381569244de7a6c0da92676f1784fd425fc094854738fb34a8458fd48f427687acdcc14921b7251051db230d60ead6c5551fc23295d0b9f4a9b6b9d4516bb5a773a0aad102a3960dd7c34552418c18a3cd494f26fc721dc4f6372c2549ebddad6ee6c5cc040678b87d94b1149e8ff69033e23a03ed66c531ebd797403d371190f2009c619a96856d25f403bd90d02b952bf07bdb551710d34ec8a0d5c1314444b005b31208a99fd01747d314b3be7b8df9ff0d2939e002725deb6fb2b0f931ca7381b439ce45ca0c9c6221a50250c9b83bee6fb70454afe9efbc647a846f4fc1ee08f144ab", + "address": "0x44268f2fe37a01cba6ac0faff6c0d63a3c0fc006", + "key": "0x0b0fccd4d9dac0411a14b4150944c6d57b07590776e430592fa3d1800d7abb3b" + }, + "0x44c8303F391415Ea821c507eC89e054EcDe2eA64": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x4392115b81b6b7cbff42cd14752b9e565f316a17", - "key": "0x22a1c10e01e8ea21a3cb7e91945d881902b50c6adf4c0ea05d84031843e2926d" + "address": "0x44c8303f391415ea821c507ec89e054ecde2ea64", + "key": "0x02e6b8771694fc881303b1a0ecbd426c4a12c0467d95b739e5eaee0fbdbd25ac" }, - "0x452b949F5F7A7D6AC67548ec72e0094da846ea4b": { + "0x452705f08c621987B14D5F729cA81829041f6373": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x59e905c6f4910756e1c3d7a42a7f0112d5bbfbffc659d314844a4acc0887b80b", - "code": "0xd999b6a905cb253021254361eb51ac2428d229184f9dd8342bc05b348b9500fb36ade7bb9eee45f234519bd60a6fcadd441f23ab0372b0e186bc601b6ef1620fb65a1d54c4d5bc403446d3ef51b4c9b82eef10b13a26d6879a440e0632bbcc7cbb77812a8fa7fa6a572953fea9126358f3aec9cde938b0c1788d783c38ffd2cb5223396cf9abeb9b7dc4cfbacea4c512b02b65d83cdfbd6fd2dce335ed44bc52e9273958f1f266f4f9bc99c85e71ee2d69a5da24fcfd4d7f1afcc533bd57dec460ac682b9a49392840ac8f0ca7e6ca743398112599febf8b36c5b1bc3b8722e72fd80a925745c8e06fa027189d551200638c1edbf79c0b3fef833bbdd2036cad", - "address": "0x452b949f5f7a7d6ac67548ec72e0094da846ea4b", - "key": "0x2ef46ebd2073cecde499c2e8df028ad79a26d57bfaa812c4c6f7eb4c9617b913" + "codeHash": "0x8ca1f6492dfb54978c17e03bef3e8fdfd09d56eee360359d5a9e8ba640632761", + "code": "0xd97cbaa9a69d46aa3f57910da3a2981ddacb51cc9a918902a0ba29b879ca9213c0ae62c552dde5f7aa5d21eeff0a2cd0cc43221752feb6b89d384bbedef2ac5d752e6936a8cd4ef88d669a3b2f3f24ded135add737a4aaf9f0848bb5983792aab9c7405fdb60827a063770d15a9163cf3257eafb54d63ebc3245e8170763b9ae5de16b835935eb4be6c6f0702e7e3a97e730aa0eb58f22fdb243237a2a9cb7895b5a621cd8595b64a4441e50a02e05b3a232b6f460cb54ec7584348d3464c2f212b3fb03d27bd105ac57c8dbf000d94f61d3ffe73ff0c0035c97df04ce6bddce938d10d27e2ae4041659af0f20bfeb8ac07249c34c399e34ee50cc2270df04bf", + "address": "0x452705f08c621987b14d5f729ca81829041f6373", + "key": "0xac7183ebb421005a660509b070d3d47fc4e134cb7379c31dc35dc03ebd02e1cf" }, - "0x46BEEa1D87bA969470C758f1540e78e8C2A15C89": { + "0x476c7A42dB76a2fc8e0E45a50030a91842177118": { "balance": "0", "nonce": 1, - "root": "0x42839850cb45ac89303f87b0f4163a6f349a021dfce0397819b4008210e70556", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000e4": "e4", - "0x00000000000000000000000000000000000000000000000000000000000000e5": "e5", - "0x00000000000000000000000000000000000000000000000000000000000000e6": "e6" - }, - "address": "0x46beea1d87ba969470c758f1540e78e8c2a15c89", - "key": "0xae3a22c9b1610c3a9f8e0f71e2f5daa824be2a1e2de6b40da984e4e8bdb2df8d" + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x18cbd4dc359ae718dbdfdf40c3f64c3463893c62fe40b6e89648ab72ef3f4ce9", + "code": "0x5329d05362821f10195d873870ba7cafb9f4abd3c4b5cf094b6c3d0a9ce4181f75acecabf7c35075c5576ba3235a46de11915fec0a9fa650e2db767d1a7ec8136eb24d64209da9c47c52c495c2b18588f6910a4ce87f04f0f63a6a14d47b188257c0d0964870c24387de1cb96a1c0d1e031544394130654a48994b8a35b62a814716bacb694fc6525934a5003bf6962d21f5aa4897c0bb8c43e69a8e553c203d4a973a93a267550d9956907453eabea7e7e17cfe62c882db8772cb269a2cafeaabf21e34114eecce47a9ab5253b604ce8186e8c7410684d5f619466fa0d4051b81d59e8f63389d4228fc097230044c4967bce9312cf2786a42f1c1fceb6693bc", + "address": "0x476c7a42db76a2fc8e0e45a50030a91842177118", + "key": "0x1fb5af58bde5a42ef7dac764d42d1bff81c30fee0b280ab7e8c28368d311eb4d" }, - "0x46bFe8155134dcD7bB9baDEf1B2EF25AE86435C8": { + "0x4956238b9fb9C655c12478E219B3c1413fb2252A": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x46bfe8155134dcd7bb9badef1b2ef25ae86435c8", - "key": "0x59f49281260efa7511a50c95aebc610a48a19aeaa54f041e1373b81b698989d3" + "address": "0x4956238b9fb9c655c12478e219b3c1413fb2252a", + "key": "0x1f62f5e3469ffc96ded1141a64cda17ece2a9730c458417d4b6a6d84784ffdbf" + }, + "0x4DC5e971f8B11aCe4F21D40B0EdE74a07940F356": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x35e6505af3b8e9a18eefffd4dafa37f401469b1932fa2011ce72a78ea72721ab", + "code": "0x36156009575f355f555b305f525f5460205260405ff3", + "address": "0x4dc5e971f8b11ace4f21d40b0ede74a07940f356", + "key": "0x010c21d7a511db44071d870baf13ba54cbfc4937cae61371a71bcd5767e92822" }, - "0x47e37FB6Ade990175D502C02DA3Dc3607b9D0080": { + "0x4FFFb6FbD0372228CB5E4D1f033a29f30CB668C8": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x30cddb925e3f4db7ec9bb0259a1726f79627a71b97dfdbf8827cce2ff258fc64", - "code": "0xd6866844f1a8c30f9968e80fa46697288da4b41c675b67a51469639e5afc24352ad561dc52a39ba65c35d8ffc50780b2be420e6593582aa43068d94afe08aa0ba82effcee24f9d07d1b8ac005bd5c8627d3d8c14e389a86d3b62ee3d5f63ab8910f3a17841c6d818ccbb16e4596978865bb77ba586b583c9de26b166e55de864aaded8c7cb956d25d285cba29213c176ec5fc32f3996cb04804f6c9dc496ea728ec4d803bc2cd2bec8ceaf2e5a0dec14ca32ca78fa74656eb25549e85d5772b1a241f58d1f790a3686289a7a511e6884e534f73cfe21a83706dadf334c70edd8a42755a2e6766ad8a3c8e0dc6925c5b384a166afae805bfb4a3c3233012e5345", - "address": "0x47e37fb6ade990175d502c02da3dc3607b9d0080", - "key": "0x7842c57cd7a74b4a6b925c5db7c5953f7c65969fedc3f81c087d6ddf9322e6de" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x4fffb6fbd0372228cb5e4d1f033a29f30cb668c8", + "key": "0xf19ee923ed66b7b9264c2644aa20e5268a251b4914ca81b1dffee96ecb074cb1" + }, + "0x4a0f1452281bCec5bd90c3dce6162a5995bfe9df": { + "balance": "1000000000000000000000000100000000008", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", + "key": "0x5c1d92594d6377fe6423257781b382f94dffcde4fadbf571aa328f6eb18f8fcd" }, - "0x4816Ce9Dd68c07aB1e12b5dDC4dBEF38792751C5": { + "0x4ad186EC10047a207268c921FE2dD72A47747A73": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x68fe999031d902f2cc91d087a2598dbc4461ac613484a5e190363612bbb7b26a", - "code": "0xfcb16150feea765524e9631cb7d1c8fad9ef75bffc2b9555ecc778186e5f140839772aaac033ecb199d13e70c3b4f8460b29cb5c3706d73d2ca45ca99b4ca34eff4638b33a6cbf8dc1ce4956e292e68da624d971bbf286cb7b35f308cea1c92b25449fa2e7137906e514f13986232d0f39f369be718e81f160ca187154669ae03a9dbf973d57393fa007fb8bd8b707e68131e5350075a7173b126035e7d5ef0800865105d845ec42a1bb319d16dde04301a355a4a41c6bd516f7937fbef9e4a44afe6e90eec383b191ec32dadb5b4f777a12a1e05ead60984ca62aa5eb8c24a5cf02837130190a95dcc836111e3f8751322ffcf187e84483660b9878a189eb2f", - "address": "0x4816ce9dd68c07ab1e12b5ddc4dbef38792751c5", - "key": "0x93843d6fa1fe5709a3035573f61cc06832f0377544d16d3a0725e78a0fa0267c" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x4ad186ec10047a207268c921fe2dd72a47747a73", + "key": "0xa4f5c77c9bb083c10bb92b2824a1bee39bba3df29e8923cdec19e7c4804768c2" + }, + "0x4ddE844b71bcdf95512Fb4Dc94e84FB67b512eD8": { + "balance": "1000000000000000000000000300000000005", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", + "key": "0x5602444769b5fd1ddfca48e3c38f2ecad326fe2433f22b90f6566a38496bd426" }, - "0x49790702079905E7fF97976DB38b586cbC8d8f8F": { + "0x4f04694790aFe884d18dD822B979EC2C4aF9b3BB": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x9231a45606b88ef38e96170f698ef8b8598e49b17187c2e70bc225e6a310cc36", - "code": "0xe5f0063c1029cda3916753b401644c6cf5a2638073f3d047231d47d090ece5034da2fdba370917407bf27824b5e855154d59c9cf9fb85539d72027a97766a6847cddfe6ee35b633c2515d8bb92b0535385c25ce39e902fe4b910ed87a58a3b60cd3081b24d2bafaebfca188b94ec88c4e89cff1900493426655481a8976b4844bcc8f9a3b8acb6eaeffd4381f3d6cf8b3246ec37986171ade75dabece51a6f930482edbcb3ac47f314e74e8a59cbb23c7d36fd54f30d440cd1e2368bac348c0234d70136299f76a744ea8afda8ebddfe1632bb03a70f19f9a17b6d3d3ba5575326dae0c1fa21b43457f9f70b55c25fa5dbad768871d3a55b8d7fdbbe10bdd96f", - "address": "0x49790702079905e7ff97976db38b586cbc8d8f8f", - "key": "0x13fb7f6b6fcbfc3892b99fb37dfd04ecf3c8d56f2d14add9517b76ea9555c1a3" + "codeHash": "0x27222c12233093361570e05aefa71218f7dbc80fed9fcd3e5e354c03ca17de57", + "code": "0xd976efa78ad29ed9a36b7b646a8316d94e2c0992fc889454e231f704190e7a66ba83dad61dd09c4add2a92c161b549d6c2b3eb3bec381c11b2bb2115ce510dc42429aa244130f07134860db48fc78040f9f98eede7613d21acc0b07977d62e0b559614b4d580ed63d8a55cd6b8faddba8339f014c3d1f205f17c8d91908d9837bcd24d8c047e5063867d3e8b2ed6abca2a71b23ce541fb0a23b900d8552c1f0f363d3eca645461a89868e2d177d079dfa222f93ac92576c6a53e4dda614a7188c0220d7114abf7ccce953eee6e1de8cad09c9ecf565e0deb6789b009431ce7760cb142a4b2e6afdc2587853f87ce63d7e7240df143c620b87bc6ee166d70c5b8", + "address": "0x4f04694790afe884d18dd822b979ec2c4af9b3bb", + "key": "0x886873063fad8b6ba257121f5b9972a94b3edda692659880083b9bc85c75a929" }, - "0x4A5F072863f868E00D0039807EE1d00F783335A0": { + "0x4f85d16FF1523308530cDB76384f9eD09a143470": { "balance": "0", "nonce": 1, - "root": "0x4ba055b3d6ea2c0c46b8cb5ee08f6999487ff7d49e3e4fe566ae049608f647aa", + "root": "0xf4ddbfed83012b2b1bdfc64f088f12d9b9cd9b6b31e018c96afb602d15bf2794", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001aa": "01aa", - "0x00000000000000000000000000000000000000000000000000000000000001ab": "01ab", - "0x00000000000000000000000000000000000000000000000000000000000001ac": "01ac" + "0x000000000000000000000000000000000000000000000000000000000000017f": "017f", + "0x0000000000000000000000000000000000000000000000000000000000000180": "0180", + "0x0000000000000000000000000000000000000000000000000000000000000181": "0181" }, - "address": "0x4a5f072863f868e00d0039807ee1d00f783335a0", - "key": "0x8fa1ad571a8b9c6e679630b6e0d38d678311338dc0362f9303d10585aaf26d88" + "address": "0x4f85d16ff1523308530cdb76384f9ed09a143470", + "key": "0xe88893cfac9ee1250741f923dc7a2b2471fdca54afdf6272b3424a67b126b1d8" }, - "0x4BE1C90eB0389A67A16a0d3027AFbE68eB26Fa40": { + "0x534Df862ed8fD56F9e9F7A50451B81Ac308Fba3a": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1cb937eefd555a5cd91fcc756cc135b04866df6c4e79b7fadf8ee10c0e8c45a3", - "code": "0x6bf91e8d24ef545af6a807b0be29a4dd23c0aa47cf86b2cc206ca5ea23e055b2508079f55449251bb3bbdddb22a48768402fe704ba650632035ff2d1f076fe8ed4dd338702652a43f9ac2b2bb0a6113f819db6a79f2161642d6d00325b6004b409c221adb84d5771ff4acef6600bf4bcaae01c6e3b391a7a61d09dd98b033b4d5a720867e9fea2afb6fbd35e6fcef36c6937fcecdcc9d43dcf109be0eaf9b0f76f25c0a5b9213781766d43fd87d9b3c49063e227d41ca646f0041bc234e3f0b821cc2999d14cb884f78fd8d378149fefb96229f402ad786759cb00743d06a86d4128452ee0fadc2e40ee2c2df6066f44872006f24784df32eee9df0d59afcb65", - "address": "0x4be1c90eb0389a67a16a0d3027afbe68eb26fa40", - "key": "0xccf7b06a67d8943c3e6f1af42977144fdcd4e35c5935804dccfab975d22fafbb" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x534df862ed8fd56f9e9f7a50451b81ac308fba3a", + "key": "0x2cff8455579bc93ffe8b215568080eb6b15a62dc94b6465ed6eeda919eb9ec75" }, - "0x4Ba8273797F206A13B4d13239A9C7692951Ba5Dd": { + "0x565f012918C969574b4DD7aB1438078360FEDbAc": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x6bd773abf6bc040838521c9de345cfedbce33617c4c7dc7e28ff79ee67576911", - "code": "0x7c263fa0a5ccb147804e1651fd02a4a91952936ded9df2b9563f58d3237deb6a2d4d9a6ec39bf84ae0d7d0d9e45117cf3fa3d0fbb6e82c52a370dde3249feff83cde3efd24a4795570409a9e1b6dbf5422dfd717e5210b527266f77c827cdf45d903a9ee0bc20272238d57d8e5255e7e6042b6f02f15379507de7f4fd2d73e2efb5e2c639adf6f19556e762eea9953bf8c1f92c6a39651186429f581ab8068491845cf6ae7e4ea2bf7813e2b8bc2c114d32bd93817b2f113543c4e0ebc1f38d29c098d85f6b83561069bae1c5511a0bbd59215ff2718b423e828420534b07ce255f7fb2960e0b7d7b8eaaaeb07b847a0fcd209d4e050e30df0ea578f57d3dabd", - "address": "0x4ba8273797f206a13b4d13239a9c7692951ba5dd", - "key": "0x48c2282032e9f2a065de95c075888d04a8dede9499b3c4837179b81d6992c572" + "codeHash": "0x65c9fd8e4f80c595224432b2e8c5c5daa9938c20f3303d0b0b576f930c6e400c", + "code": "0x036d965cb9d0e83de4c353f95caf4ecf8ee07c3b7815487583c2320e4410a14a974020aad38fd296c46604163b1d9ac2824887d4512f177363b73ec3c7aa5acec108ef12f26b4ade44fe5ed2f32b5ef7630c67d90a9897364bf8e724599e3cc46826f3b2dc85a23ac29ae589df3f1bd4b838fb58b1fba29fe7bbe6ff9d23dac1785099b1161b577a98586b6a1e4f4377ee16e922ae82fe8e16636298a173aea19a5bffddecd82ad75cb64b02d7705d37a866810905387dcfac43b76b6b52dbf188f578fea244f4e9da815349e19db14e2fab4bbc9bb5a29958ac2714022c21ab0f3692613da04ee297f5ae7520d29a65c5bb0c654c692374a729420b0423c80f", + "address": "0x565f012918c969574b4dd7ab1438078360fedbac", + "key": "0xb890172948a324f9b9a7b7733028129f7303744d7abad5f78719f3e474c3d91b" }, - "0x4FdE47c424dddFb38606FEdaE5b6522D8aC6C3e3": { + "0x56abfD748156bc91D9A8E14F4AF42dbe3968F22a": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x314204915e2b98401a3ade8178f328eb28e28be295588c447b09b5ac4a782140", - "code": "0x825cb36b0f2510a04cf6a63d38fd27bab6d05658e3c7b75a8e0bc0433c0ad1d83254a08c6b1f2452e29dd01c1d0c85218d57ed34adaa4d9e3b5080f944b9bd85a0b82392ca930f909da3e8f1e1b75001281d70a8e3841b3b4dbad931d5554bd4fbca97ca5841cc7bc1e64c05a3e88ed0241af42ee1c0e65d806d2bfb6bb7fcde939a97a2cdf42f5b2accc7a97b393a7e41066fe584741a52b411280ec3e57603acafcf2c60bf92bccb8c65f5ccffb377b9ab5ab1e8283e2807c12a0c2ffc1ebeb63423a192f69a0ae0d422d5ecafd6a0773a3869d94cfcc860a907e75f293a84a569f999e0f44f33e77ec9059a51b9940e65c0f955f48a7dfe61f7c752a08a8e", - "address": "0x4fde47c424dddfb38606fedae5b6522d8ac6c3e3", - "key": "0xfb620e9421928a795a331d223b11ab476c45372f2c7c3dffc9b13f0e1812b05c" - }, - "0x4a0f1452281bCec5bd90c3dce6162a5995bfe9df": { - "balance": "1000000000000000000000000200000000010", - "nonce": 0, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0xb153956e166789ae49df7e053c4453e66ffa032f0ceb753fff0b86796f250913", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", - "key": "0x5c1d92594d6377fe6423257781b382f94dffcde4fadbf571aa328f6eb18f8fcd" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000195": "0195", + "0x0000000000000000000000000000000000000000000000000000000000000196": "0196", + "0x0000000000000000000000000000000000000000000000000000000000000197": "0197" + }, + "address": "0x56abfd748156bc91d9a8e14f4af42dbe3968f22a", + "key": "0x9961ac161049db66cea081d22a1b4aa9ce2c2cc8cc45f29f2d912d917ac6bb9a" }, - "0x4bA91E785d2361ddB198Bcd71D6038305021A9b8": { + "0x5820871100e656b0D84b950F0A557e37419bF17D": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd65f73004752376a8f043ec68c2c964e98926865f14775678b2aa84947a74e7b", - "code": "0x84420f67222b5641972786145b747b9f6b269166fdbd701129dc55eaa77148fe96259bc7ece823714bb3a8cdbaf7f384e05c267f2e16021d51fba05ac06151898b94fcf86dae9dd6026b2b824fa932e75c4b81a1e20209dc376bd215d0be1a551346e0df37ec385cdcfef5b73b13f4fa1b55be0c86f81fb5b3701ef64fc4df00f5349d815f3ca9782afe723f3eacee30c3464fc05e12638977843bb2183a16ade78ea91a221fb67f10aba14ba22dc39f780130b5cf7d2295f57a7414e295968ba005de1f4b235134f6a66019013c8498d7fe5d9c4a258bb57fe1485c0d4f3e3abd13a6863b607a386edab49cda39c0a4d9199a0f276cecc8aaa8f8c5a83f8170", - "address": "0x4ba91e785d2361ddb198bcd71d6038305021a9b8", - "key": "0x99ce1680f73f2adfa8e6bed135baa3360e3d17f185521918f9341fc236526321" + "codeHash": "0xbfd53712aaf28ce81b4ca4ab65774f50a244cab646979adb59df00e1943deb55", + "code": "0x6cec44c34efdba490f3ab1336603140e8c0c28cdc34b65964a9ac1f0bfec07dd6d7892ce866bb2c3e65cb18b34b9a11788bcb55274efbc45622aad07c7f85a36f4d6b0967b42b86b19b12197339035f1db3d03253fe3615cd3e99d15d3921db0fa137d319445e5cab57eeed640ea68859c23a54e370f0c92b86e7378db9f6717f7b22d72bb41f50e7619fe6009e692899723f40bdbefb4ae417e7031ff0bccd5446b3a55c06c80b51690681e337aa42dc6d1eaa19031355aa6f894fc549746131c96c8fe65efc95b3b88cf5d783a40ba92aaab0d52edbfcf0abf2b8c2c9cfb8068b17a0ae68dfa3f84a81023be55645133434b92210d7c095b98954ca0e3e37f", + "address": "0x5820871100e656b0d84b950f0a557e37419bf17d", + "key": "0x4615e5f5df5b25349a00ad313c6cd0436b6c08ee5826e33a018661997f85ebaa" }, - "0x4ddE844b71bcdf95512Fb4Dc94e84FB67b512eD8": { - "balance": "1000000000000000000000000000000000011", - "nonce": 0, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "0x58d77a134C11f45f9573D5c105FA6c8AE9b4237a": { + "balance": "0", + "nonce": 1, + "root": "0xa1b975fea88bcc79f5f339e687406fb39306b49b2efd0728846bbd04058ab607", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", - "key": "0x5602444769b5fd1ddfca48e3c38f2ecad326fe2433f22b90f6566a38496bd426" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000082": "82", + "0x0000000000000000000000000000000000000000000000000000000000000083": "83", + "0x0000000000000000000000000000000000000000000000000000000000000084": "84" + }, + "address": "0x58d77a134c11f45f9573d5c105fa6c8ae9b4237a", + "key": "0xd9f987fec216556304eba05bcdae47bb736eea5a4183eb3e2c3a5045734ae8c7" }, - "0x514772fb7F9ED5E54Ea9fdC34aA4dfC7bE594494": { + "0x58f8fe237b593C19546e1e758a2544561d04bfe0": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x899281cb5d4cbae8408193bbbaa6701ab3d6dc4c07df2c4212f3f64b31f00416", - "code": "0x6654c25418c9c9cdb53e9c7e15d751e46e03faf5fe299ca4ef6817467fb3bbbb02f99646d718504e95233737033d5f11cacb283e1a9b2d1ad1d2dcef08c6a40afbe158bb61721b4374c6cbf06c87d78138667de83e1f69f30893bb437dff0373ddcda9846e422308a606a70526455845f80d0b22327f98d8eaafcc7c9b60f26b3d112fe2cfc19c13b28ff9f53ecf385f288fca3c9a800e2826903f86442b3c692e2d51fab4d9c1610962d39452e3dbc097fb8114b50951fac0449fa7df26914402f56c3256756e82795f0244ca0a1b4c6ee21854c0a86342ad6bb8f8a2eb8a4067bc00cb24423cdb75e37549e0e845bf4e9d27038e3fbbeb29e8e99a1aa5c461", - "address": "0x514772fb7f9ed5e54ea9fdc34aa4dfc7be594494", - "key": "0xf02f9c16ca8e4ca4daf37afe833d6f9b50b934fcb50954792900ce943d6b5fc8" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x58f8fe237b593c19546e1e758a2544561d04bfe0", + "key": "0xedabf9f506b5170888ca458df9dab111fa2c708b88cc706659db520718be9d60" }, - "0x5259FD366E381590eD3d01cF2181726498eFdaA2": { + "0x59Af84F3e7C82fce2814D0d6a548A6511b78d2E5": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x5259fd366e381590ed3d01cf2181726498efdaa2", - "key": "0xb4ac940399ad74961d86385549af09654ff2fd37b19860ac2197cf0ede38fcbc" + "codeHash": "0xc158240d4f9b25991d0863ec1afcfff897c6aa11de437ff428198163f7ed1544", + "code": "0xf9cab2ea5fc2898ca670240c87501f552f715e74f50142c35920c55eb3c0ea1ace08be9c0c4b619a77d9aae0c356635893985acdb56f3ab9f0887a6e839e7b153e04681523725281e5522c3930409045daace340ba5584d6ce46fad8ff0ee17c3429d6fa9db26e5631128d8185584d24f10323af033be7ff252ec8822b07bae1d21de5f10f7da2cc11d7285aa1870cc63fc64f1607ff0e823e4786ac9df506e1df77777c28427b65a9d9118284c3b1167eb43cc55aaa62b9f7d4ced77b911b0fe88c6d20e10af62aabb42c56ecad3aa0e9a8ce42bb84e4e634e80a0ca98bd48c5d7fa289fe0cce3684f388c19bfa7a0aaa2c98a5c74839d3148ac362bccbc70b", + "address": "0x59af84f3e7c82fce2814d0d6a548a6511b78d2e5", + "key": "0xd0873c9513c278a9dcb764072f7e2477235e814ca74f2ee4ab76c246f5ad239f" }, - "0x52859c77dc11a2983F1eD3F9284f215c94FF354C": { + "0x59Fad703B903b1EC41FC5AbD42D277d69edd066f": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x38ec67839d530b6a89731615d891c92067632d4439c68e5ac4a823d0a6e4f567", - "code": "0x117de450db9ef19cde82383de3b55cb0a7965580517c7121000ae2f172c97cbc9e45afa898d1218177bd2c70d157dabd7c7e29f662fd9efaedfcbb325862d874ac7511a01df823fb51359303411b7e2f723cd4e10f128e3084b8ebbea214c26304bb3b4207ce82295d38e8bff9678c7ffab2d11ac7c8ae0afa11bb2d6b2ff7fc6a4cd983fbfa662ee9a9fcdd19aa030fb27b315fada4a7adf24555d0223dc4871c8533394fc1a3f2824e39d8ef04b7ac42ed1afab3eb82c41e5654726710177000cc4898feff114e317ec8cc5776eedd027135f826cc0a15a25d1f713a60e56f0d1052827618a31385863032e24ca36ed2081d363c7d531b6429ccd7f7fafb7b", - "address": "0x52859c77dc11a2983f1ed3f9284f215c94ff354c", - "key": "0xb8da07edfd4449f2c95df40fc5095b3e75a702fcbaac7b5f9dce232800cfac3e" + "codeHash": "0x72921c8e5b6ae768ecfcac7b214adcb6d129b1a27f01e3e53d5983b7172e3d99", + "code": "0xb0dd6ab64c91b13c13faf41aed0cf4d2ab8c259821710faa2ebcf849f80109e200f505a85dbdbde1426fd0a2214b8259b1ae4fcb9e18d53f06ec1b77e152797df7876b98fed9c448027081aa9a3e3a7d7052d18b7eea057b4def36c2fa47a12b0c5c7680cb1c40d05734a81289808b02f7180a420c18852dda2d5494a7f1afad66a8b3e51c9ef3016ee1d800e0aeb1de0aabe53158ecbd316dff51dbffe933a22944b9af8d962e2b5d171cd2b530c03b245945580d9e2a1c9efc472e2e5ec88bb5bc34a01e38ddc423f2e350462018e1f467d9168b2bb3690f0907c153557fceddf531d3aca5e6896fb90b841c9479873f9c1669c2ca84e3acb343f9c4daec0c", + "address": "0x59fad703b903b1ec41fc5abd42d277d69edd066f", + "key": "0x7c1d28615d0c377de4275a33b4f0ab75cbd2c397da5620caf1509a63564a806f" }, - "0x549ABF1AE8db6dE0D131A7B2b094C813EC1c6731": { + "0x5Cb874efC014fA0F7FB7331F29cc0b59973C6595": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x549abf1ae8db6de0d131a7b2b094c813ec1c6731", - "key": "0x910fb8b22867289cb57531ad39070ef8dbdbbe7aee941886a0e9f572b63ae9ee" + "codeHash": "0x7864bc18a660d9d01fbc0e4c106e46acb7845d67a68538a1169a2255af2498df", + "code": "0x6d8e62e97e5129d5cef2e9dc5714a6fa7cfd8bb0b2a30fbcd3bc76f51251d708c9c9d362b631fd1cf2a811476392bf4340a481940250c78d4e1a8ba601af1c0ca42a541cdcfe5eae324446eb151010137f37bbef104de95f2a946c2404849477f4a235ccdb54c513989f886387aec23f9bf80ade6bf8f128a86992a7069f7985be89b2b9c21da99020673067731702f61a06f1657a7bc439452ab88ee45c8f3d12375e8dbec105fbd47c977d99a60ca0d2bf8a8ad37fe84ac7d8350cdcc77770b140c83f89450527e0d9bfdbe42b2fde284574f0f05c92031f07f3f4d420a7925a41508a056f33ebc54916028c311d205604728c0f8fe1666ec11122b917bee3", + "address": "0x5cb874efc014fa0f7fb7331f29cc0b59973c6595", + "key": "0x4402ea95dba35ab4b25f25e5dd1da45f79ebd51cdbdcbcd437fd8b204afa0e15" }, - "0x591317752B32E45c9d44D925a4bCb4898f6b51Fb": { + "0x5E5F35d83E5485AA1006F6Ca478eC7507d0efad4": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x591317752b32e45c9d44d925a4bcb4898f6b51fb", - "key": "0x88a5635dabc83e4e021167be484b62cbed0ecdaa9ac282dab2cd9405e97ed602" + "address": "0x5e5f35d83e5485aa1006f6ca478ec7507d0efad4", + "key": "0x53ed76a58ca2fe13ebac69b866c007878047e8c418866ece50f947ddafc36321" }, - "0x5C04401B6F6a5e318c7B6f3106A6217d20008427": { + "0x5b35D3e1Ac7A2C61d247046D38773DeCF4f2839a": { "balance": "0", "nonce": 1, - "root": "0xfa8419ae99f4a7adefcfee0f90051b152ab94b0f2c5e8f40afa685eaedd48d0e", + "root": "0xcc48f8d1c0dd6ec8ab7bbd792d94f6a74c8876b41bc859cee2228e8dad8207a4", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000ad": "ad", "0x00000000000000000000000000000000000000000000000000000000000000ae": "ae", - "0x00000000000000000000000000000000000000000000000000000000000000af": "af" + "0x00000000000000000000000000000000000000000000000000000000000000af": "af", + "0x00000000000000000000000000000000000000000000000000000000000000b0": "b0" }, - "address": "0x5c04401b6f6a5e318c7b6f3106a6217d20008427", - "key": "0x6c37093a34016ae687da7aabb18e42009b71edff70a94733c904aea51a4853c1" - }, - "0x5c019738b38feAE2a8944BD644f7AcD5E6f40e5c": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x5c019738b38feae2a8944bd644f7acd5e6f40e5c", - "key": "0xbccd85b63dba6300f84c561c5f52ce08a240564421e382e6f550ce0c12f2f632" + "address": "0x5b35d3e1ac7a2c61d247046d38773decf4f2839a", + "key": "0x55cab9586acb40e66f66147ff3a059cfcbbad785dddd5c0cc31cb43edf98a5d5" }, - "0x5ddf897368f755b65a47c325558C5D1B6101D6AE": { + "0x5c272D741b74a8FEF2749FaE559C3900052ABBac": { "balance": "0", "nonce": 1, - "root": "0x8289b558865f2ca1f54c98b5ff5df95f07c24ec605e247b58c7798605dcd794f", + "root": "0xc1a33c69d45ec0d448590031a0f9322932282f502559174fda86c43fa3be61a3", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001cb": "01cb", - "0x00000000000000000000000000000000000000000000000000000000000001cc": "01cc", - "0x00000000000000000000000000000000000000000000000000000000000001cd": "01cd" + "0x0000000000000000000000000000000000000000000000000000000000000219": "0219", + "0x000000000000000000000000000000000000000000000000000000000000021a": "021a", + "0x000000000000000000000000000000000000000000000000000000000000021b": "021b" }, - "address": "0x5ddf897368f755b65a47c325558c5d1b6101d6ae", - "key": "0x411fbb986eebf586de3c9c5e658d280361302fb01b9c78a4ad377a1d22f48c30" + "address": "0x5c272d741b74a8fef2749fae559c3900052abbac", + "key": "0x806056ca2acf8c351ae196bbd3c8c0bf28d0a6acc5f15363316d9783530da9ac" }, - "0x5e028FC1Db7DEA67e88450a41E8a8C171a2D98af": { + "0x5e14eB6950734cB6D9D2235CB66ff1d7e58591b8": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x5dc1af1f023992aa3ade2c0acf296be3e1a81518a97051eb5f01441194d8933c", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x5e028fc1db7dea67e88450a41e8a8c171a2d98af", - "key": "0x093469a66063567a18434eb090355fdf9a1cda7b36496375c8ad5352490f37db" + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001f8": "01f8", + "0x00000000000000000000000000000000000000000000000000000000000001f9": "01f9", + "0x00000000000000000000000000000000000000000000000000000000000001fa": "01fa" + }, + "address": "0x5e14eb6950734cb6d9d2235cb66ff1d7e58591b8", + "key": "0x1039f5e5139335b89c26b535b353123c3fd4e0542fb64d85cbd001e344f7edba" }, "0x5f552da00dFB4d3749D9e62dCeE3c918855A86A0": { - "balance": "1000000000000000000000000200000000009", + "balance": "1000000000000000000000000300000000009", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", "key": "0xd52564daf6d32a6ae29470732726859261f5a7409b4858101bd233ed5cc2f662" }, - "0x6122a0F0099Cf6829a1A798C7d8194F3F1c767C6": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1cdd99d5886db6ad2fa95eae0e3dbbe46bfd4d76dd9fc071924bfbdfb5092df1", - "code": "0x5ebf747c75d0738c34413ae2d381abbe56223451ec9a8182acbb3c1b4cd303c36b426b81e25bfdca83dacfd6d1498cc9b779efa0e16c484b0a45c63e2a8ac0eb41338e7384edaf5f4b58e81789655568fca10ff473e1ae582e94707ba3b4af90ef1ae8d7b697e2fe5c14ab2301c3ae5fc2eb455e13fec873d608e25c13013abe76d086a43441006cc18880195fbac37baa9f0b926a479db4db18e84f5b93b3bdc27bef70534a73a3458fa13111419bdb863ccef9e14b21600ede3c5d6199ba547b426c558c84faa8521ed0fec4740eb270d0d68f28ebd25a3f457810c19e5e1d6c8fbe6ccd59976251666e62bf63684699437b1318f66f299d463a2a35e6cafc", - "address": "0x6122a0f0099cf6829a1a798c7d8194f3f1c767c6", - "key": "0x0e733ffe8353481b1a9ff5640302b8aea65c7d1863b432df95ccb2be96afa76b" - }, - "0x61774970e93c00A3E206a26c64707D3E33F89972": { + "0x6057FE92F331FDb8f9728160E857B920d7824ff6": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x0dd7fa1a6c3ee15039f57211a40021e727617dcf3396ad739b3a6bc0547039b8", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x61774970e93c00a3e206a26c64707d3e33f89972", - "key": "0x07b49045c401bcc408f983d91a199c908cdf0d646049b5b83629a70b0117e295" + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001d7": "01d7", + "0x00000000000000000000000000000000000000000000000000000000000001d8": "01d8", + "0x00000000000000000000000000000000000000000000000000000000000001d9": "01d9" + }, + "address": "0x6057fe92f331fdb8f9728160e857b920d7824ff6", + "key": "0x6aa85d4b187111f2c5ecf219bd89f549601ff55f5d81290f81a564ade80db911" }, - "0x62b519210D1152d05522eCD2786a0894Ef96711a": { + "0x6269E930EEe66e89863DB1FF8e4744d65E1Fb6bf": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x53e60f54205478067bd7871cc267787db82640762b903ae292cc4f7b1e034b2f", - "code": "0xd9dfa62431de8be2dbd2a3e48181600f1d9a369e648c27560dba1fbb3ad2b73f114d5534ea633c2a4fc65ce2157734e1ac5b006861db9b2fb713da83945f9b1644e6cc9ec0025107fead21d06dc3a721589436afc2b981a277584ae87017150697b8d5f3ffb17ab53746c00a9a5934cdc979817ec37b75a47e7116ebc0dc98bb39e54ab7b21fcfb47de39aee65760cb929603027794f0bcd7af8e3aad7c10b9511a5f8a2a2bf42740ed0a334377de2c3084e93c4f4d0a6c75576781b77d09917724e042275b7684cb97d5450ac014448187dcc8ad8eca739641820e932cead43c37c803fa400daf840edddd3bfd7134b4feb4e68c807934df6e79be380372de7", - "address": "0x62b519210d1152d05522ecd2786a0894ef96711a", - "key": "0x2439cfa77d7473700a4a2e1f646172781c057ed8562f05dd5d4262b33fd7861a" + "root": "0x75a2a5a81b84c4f6290edf5328f743c609fec3724db2187fa84fe11999b936c1", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000c4": "c4", + "0x00000000000000000000000000000000000000000000000000000000000000c5": "c5", + "0x00000000000000000000000000000000000000000000000000000000000000c6": "c6" + }, + "address": "0x6269e930eee66e89863db1ff8e4744d65e1fb6bf", + "key": "0x419809ad1512ed1ab3fb570f98ceb2f1d1b5dea39578583cd2b03e9378bbe418" }, - "0x6325c46e45d96F775754B39A17D733C4920d0038": { + "0x64259510073C9E180Db9a7D4A6e6752a52fEcFAD": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x005277275713c3dca04ab6c7e47c80280f192d40dbc42d4798ae13efafb012aa", - "code": "0x66ce4e8e12a5403828e3fb3176b429cb926ef9dc29fd04c1b3c13ed2787d98d63eae4e449535fef8fff684d6f73d890e306ee348ada8a418981c28d496bb7be350dfc491ab5c757ee78cfa27228f3a47882447741e862da671b4cb5afd51d95370d52b43b3e1f9a31ab6163a901e55133bd37da50c470c7ad07e6be9a4e139f4309f8175bdcf9b0c39a91eee31067537b925ed2b384eabdf80116866cc3ab80ddb57df9c1c4f68e2fa98244b87e0d27e04c99093c63e7983b367307c46863d3f3fc3eafd6666b4115f284754aee9ae5ecd0e309cfccdd979fc5507fff0213446ac2be92b45f4e420d0da2f410ca74328fa136fa304300cb98f3bfe380f244449", - "address": "0x6325c46e45d96f775754b39a17d733c4920d0038", - "key": "0x7c463797c90e9ba42b45ae061ffaa6bbd0dad48bb4998f761e81859f2a904a49" + "codeHash": "0xae2556f6467404d4960c0e82cb0549aa24b1b86d63e8916f4991b4aad90797c2", + "code": "0x7308fca2a3bc677778472f81a566eb92fd5c90e7fecfd7cfaccab39916d3dcf0f531e5b3d77d17a0ec1ff2986b8bc33d0c3e72c0453b9046ab0041949852d1fe279a12b9e4525aa676a2558adc8dde630f6552ec594fcfc6faed4dc25a43b154874e0e82c737fcd276046addf49cabb96bdde8128c11ad519f9fe60006c3a47a9febe27a7cca7c12f1344dd0fe9b564e4efcfd2da37f2bb9004affb93ba10be62403cb0c79227a6b79d68d83cc4f30f951ae106ed6e674d9b7492bcf06603be70464f185bbc7db7df2ca680828dc05691ca64c1fdd3c16ed64141e4ee71f7991f1719981d146cbcc1630a3b12228b0581a3cc54c736724b85bd467e0a7082217", + "address": "0x64259510073c9e180db9a7d4a6e6752a52fecfad", + "key": "0x68ccf188baffd6aea3b31029f80ea18836c629ac53500a7137268ce1512529bf" }, - "0x63EB2d6EC7c526Fd386631f71824baD098f39813": { + "0x64c725A9fC63B8e7C45985387094C9C7c6bca3dA": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1168db50d8c2d04754fa4490bbedbb9da7d8abaee13dbb166226184e43a2c230", - "code": "0x50f395cf935269ec6c0da54860a5c40e4a834461db1470816d90e1e42a72199933adcd84fdc27d3e867d7b3e99f37edf5e90974dafbd1ff1ab87448df87b1e8832c9847d10682bcdcec3f220294c4be920f5b07e4c9bd319b015ed2172b56db476f70a4b50e1ae7567d0cc5ac047a75e39b034ce3beb11fbcef92f4b009d5ac5d98acec5291ba9332e4780f7cbe1ffb2dd12ac35ed0a419e68c5bb25a3f36736406423470b595ffad93ccf38676da45f48a17fcf63343e5bfb15c88f71795d1135c961d63bca6edaaef30eb43d3e98ae2b23003091278d643f0b7d548887f0c1bbb0e6314a05b0c3773a37fe72e4dab42b2fabbc8cab6968d2bbb4760eccbeb9", - "address": "0x63eb2d6ec7c526fd386631f71824bad098f39813", - "key": "0xfdaf2549ea901a469b3e91cd1c4290fab376ef687547046751e10b7b461ff297" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x64c725a9fc63b8e7c45985387094c9c7c6bca3da", + "key": "0x23097429b7a1d1795cc8c2aff3fe23be242d1af03f234797d8fb4d7c443bbeb5" }, "0x654aa64f5FbEFb84c270eC74211B81cA8C44A72e": { - "balance": "1000000000000000000000000400000000008", + "balance": "1000000000000000000000000200000000010", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", "key": "0x00aa781aff39a8284ef43790e3a511b2caa50803613c5096bc782e8de08fa4c5" }, - "0x667Bb3a03733d43Ec28d2178c39DC8d8D62e48C2": { + "0x67A61A385416d9c31e4FaA3119a425d9cf1616A5": { + "balance": "0", + "nonce": 1, + "root": "0x2931f633d50c1479ed6fc7e6694773cc891359a82498d36c3a1ff6183e393f96", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001ab": "01ab", + "0x00000000000000000000000000000000000000000000000000000000000001ac": "01ac", + "0x00000000000000000000000000000000000000000000000000000000000001ad": "01ad" + }, + "address": "0x67a61a385416d9c31e4faa3119a425d9cf1616a5", + "key": "0x5a3e8a1207bb1a9c2d1265bed157f2af2b6a72714c6fbd2d88e54ac286edd612" + }, + "0x684bC6825e462FDB916de100633e6B6E7F24889E": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x684bc6825e462fdb916de100633e6b6e7f24889e", + "key": "0x4d21debd0e9f83b4968ba732fc45af8c777c93e880de876458fecec6ad7a1785" + }, + "0x6D8B8F27857e10B21C0FF227110d7533CEA03d0E": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xb7c056307dcfe4d5bf2de7d5ad1bde4bfcd7aaa0b8f809a5f281bf5c0ffc5ef3", - "code": "0x8287407dd86f9cd15823a62f56cae15d1cdb1d9dd2cfac15669fd1037cbd633fba04c9fd01e5135b6259852aa7338be61049b7b5f6b9bf8cbd858ccf50532c262f2120a9890bd4e58b07c28e03ff53234c375f6e9b60ef12bd3dd7fb6234e9bc2b664fbfedceaa9e368d36426d56ced624f761197dd7b96937cddcd7d4a8ca8d775b7a133f8641b4824710333c2c435f2413ef48954449113b6ed0576502adb9825fb6258ed58db931ef4a50b617f3b78cc886f5d1e09c7deb5b845bffeed38bb03cda5378747d2b3f6b4d23edbf03f046cbf5e0ec8cf1df19f2b28601c8cd810b1b62f1989f657b839db886f8749798d4c830427984730946a0d3525032d7c6", - "address": "0x667bb3a03733d43ec28d2178c39dc8d8d62e48c2", - "key": "0x184b9df2b6cae0dae7687488d9f738d1038720fb1c84aa74b880cea89d89ccdf" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x6d8b8f27857e10b21c0ff227110d7533cea03d0e", + "key": "0xfdbb8ddca8cecfe275da1ea1c36e494536f581d64ddf0c4f2e6dae9c7d891427" }, - "0x670DC376eCcA46823e13bAb90acAB2004fB1706C": { + "0x6E61C1930047f977205cc445234d627eaA0b6CEa": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x670dc376ecca46823e13bab90acab2004fb1706c", - "key": "0xdcda5b5203c2257997a574bdf85b2bea6d04829e8d7e048a709badc0fb99288c" + "address": "0x6e61c1930047f977205cc445234d627eaa0b6cea", + "key": "0xfc648c6bfa55dfd6dd1b2322a6c768637f88704e48325686ef2589f8e3b06a73" }, - "0x6741149452787eB4384ebbD8456643F246217034": { + "0x6F372e56E94825B6542Df4459Df1dA3aA52cf093": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xa0750f0af31158ef75bf1585ac49a9f036c3d1c824bc9cf85348eea1cd44c4e7", - "code": "0x2bdf3b387a25238ca107528ef613f0cda5e5fdc55d2a862a6772bc33c52e9bfa806416b7717fcc15b81108defcfbf29e72f55b2197fecde6e539ebee057989a401c50f6fac5dab042d56d6672b634cb37b505c5aae3d7ba4611136701b0571deb7b30a37f76c4fb5cd36b8aa4d39c72a853a8d4c2fa5b557a49cb235c2e1dafff37f59c4a66e94d1fca74ea62b6b8408510c029e65fdcd1df49d986c1b36dc7926564a9842445dc74d9f07ed82bf6b114b8b1d9caab12e4ffe452622666b49365b356955612a215e910dad02f366f8b9b52d08b78752c97e0f89f9efd40bcbdd49d68b6163ca37cddbba727f9683532a5f96ca0a6046c4d911e9c07656aba166", - "address": "0x6741149452787eb4384ebbd8456643f246217034", - "key": "0x37e51740ad994839549a56ef8606d71ace79adc5f55c988958d1c450eea5ac2d" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x6f372e56e94825b6542df4459df1da3aa52cf093", + "key": "0xb898e426a8614ef715b2e6ae0d473ccb71e1b40053fc0637134ebecc90c089a0" }, - "0x67b7C7F0A33D823099897812498d27F02641211C": { + "0x6F80f6A318Ea88BF0115D693F564139a5fb488f6": { "balance": "0", "nonce": 1, - "root": "0xa76e1579c7dc21902a22df113429d0ce1741c95e74724cb3380542329025d9f5", + "root": "0xbbb0506aae3a78c8ba163d88e1c7424c7af27bea7b2678235dadb60746261d37", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000152": "0152", - "0x0000000000000000000000000000000000000000000000000000000000000153": "0153", - "0x0000000000000000000000000000000000000000000000000000000000000154": "0154" + "0x0000000000000000000000000000000000000000000000000000000000000132": "0132", + "0x0000000000000000000000000000000000000000000000000000000000000133": "0133", + "0x0000000000000000000000000000000000000000000000000000000000000134": "0134" }, - "address": "0x67b7c7f0a33d823099897812498d27f02641211c", - "key": "0x32e29e5de456ade7b4d54018ccdb635ed75ef0f69d5012a5bc7940db8ad41c5a" + "address": "0x6f80f6a318ea88bf0115d693f564139a5fb488f6", + "key": "0xe73b3367629c8cb991f244ac073c0863ad1d8d88c2e180dd582cefda2de4415e" + }, + "0x6c49C19c40A44Bbf1Cf9d2d8741ec1126e815FC6": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x6c49c19c40a44bbf1cf9d2d8741ec1126e815fc6", + "key": "0x0304d8eaccf0b942c468074250cbcb625ec5c4688b6b5d17d2a9bdd8dd565d5a" + }, + "0x6eE3EC43e74798692dC62C162901f3a6cd9EEbC5": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xe1a25651a3d8a189057a6a9a63a50852944980a11345ac5be266f2183e4b55aa", + "code": "0x20a00a56ff464cf183cd5b79ce2126e3fa8017282b0399b1ebb45b8e0bd1068c20a5091f1b76bff1edd590d3f51c5c6379fc3d087cabc34446be903ecf6b06d97eceea9b3887b9baaf4c61a3e9ad95297e1afb387d0e34c121261d9b5eddad34b5bd17e250aec4f1e352b02f19b359d072378fcc0c4054789dd519e60e58f0dbe6c63e9737af59d8812856fef9882c5ee7d1bab39b82436e99dcdcb300d6afdabfc43fe3f72bd28010cc6d9b33b12358fe30fb86ec68b752edb7fd8a61da4e7ecd424289c3cf8fdc5c0af8700350c5e354154cce6a2807831fcef26e8175822872bc40aafb8d24fa3448adc4428b158f737f7177cf0a73e5e537b5ab72d04c4a", + "address": "0x6ee3ec43e74798692dc62c162901f3a6cd9eebc5", + "key": "0x2de4bdbddcfbb9c3e195dae6b45f9c38daff897e926764bf34887fb0db5c3284" + }, + "0x701975703F1660f083Cd05BFD8bDc14B76228408": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x701975703f1660f083cd05bfd8bdc14b76228408", + "key": "0x81cb192ca1717f4abca4377bdc7284b0d038a9e34b5a98db36b1359e641a83b9" + }, + "0x7021Bf21ecDBefcb33d09E4b812A47b273Aa1D5C": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xcbf4f7ede299ffc1080e11d0deef032fcfad102db354abfc55b40dec408de17c", + "code": "0x6b02e248a9e436441474617807e267a743af2dc77080985794afbc3a33c25d4befbce2a8ff2d467e309d9248a4b22cbaa3390df6f9ad4715abf30f5eeae1d193edaa9ac5d4440c772c7764df206a5b40169a23892684458a3f8b4bcc77ed9a9dd46460e0ec4be8776950adcf76016e20c1ae55682b188e96bab57b3cdf10a2236db827bf88420a37fa5ee8fb2a58106c670aa51c48673dd02dec0a24cb121905f2cf4f001b7751b7906e2fa0ceafcd025a53d63797880ae8c58702c57f3300404b5debc8ce0705e5e2d352225d31508d545c4d87f073b5ea5ff853237d333fe375a43ba0fdc2854916b0573b104f8f3b27e441d0274a726d97f7bafe2270ecde", + "address": "0x7021bf21ecdbefcb33d09e4b812a47b273aa1d5c", + "key": "0xb9400acf38453fd206bc18f67ba04f55b807b20e4efc2157909d91d3a9f7bed2" }, - "0x6e538D4e5B09ef72527C5f360A9eed7BdC78c013": { + "0x7029b7A1e1a0e17a08Ae0F5f58d06620fC0e22f7": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x6e538d4e5b09ef72527c5f360a9eed7bdc78c013", - "key": "0x8a9059b202d794382c3d775abd293c1e8a931a9e452cd405bce318655011be46" + "address": "0x7029b7a1e1a0e17a08ae0f5f58d06620fc0e22f7", + "key": "0x9bce292bc3ce4d49668cd47b99660bc8945283d39f7a7e6a621ce7367ddb9c3a" }, "0x717f8AA2b982BeE0e29f573D31Df288663e1Ce16": { - "balance": "1000000000000000000000000400000000004", + "balance": "1000000000000000000000000100000000007", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", "key": "0xc3c8e2dc64e67baa83b844263fe31bfe24de17bb72bfed790ab345b97b007816" }, - "0x71e7DffB120141296fC9cD4B605D2C3e91532320": { + "0x71a914D83ce265bcee9361574Fdee0DD14FCcaF4": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x71e7dffb120141296fc9cd4b605d2c3e91532320", - "key": "0x9c30e371e95f1eee489bdfa184e03da347fc67634e0563059d2ff4deb72ecfcd" + "address": "0x71a914d83ce265bcee9361574fdee0dd14fccaf4", + "key": "0xd202c35c34daca7a424f0e9ecf84e82223c90771a4e35af8521edf6cf31cf918" }, - "0x72488f954A3eB61484471640cBAEaF78CE76d3C0": { + "0x7212449475DCC75d408aD62a9acc121d94288f6d": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x29d4a41b515bc92289080c82736daf9be34e98756523c594c9fcbca9cb623601", - "code": "0x0d62091370673e8ccd6112f88e6cf83a7e262bdd01fbb39f2ad26dc1950ace20478420247b5400ed2ef8c9e82b364bd8588bb9b0f3d359f4eb07c15c2f2ace704689d4ccce42c0f0a53795099e826dae48c5e1990d368d17ddbf2a2a73c395a4d771cacdd43debfb6108ecc2af178721126880a13fe3c1a3eb78b982ac4bb9062ab704a4764a354b72c71784596f1ee2535c2159415177c6759c4aac4c0d6a35c035b7fd4ca3fb9e95fbb0270d7dcc45400ea942e0f1f7c81eab928d513d29259a4083a76373c129b3fc4a15974f8c405a4ae2d36a6502465cdefa34133101b918895f212d9030d8444c7d68dbfba2c3cbe3d4e7953a2b544ff4d6facabbee32", - "address": "0x72488f954a3eb61484471640cbaeaf78ce76d3c0", - "key": "0xacb2843c9c612c1164efb43e55701927b28291c14b6a950c9f658d687cf238f6" + "codeHash": "0x017dac995561f4ad38ea01f7cd0d0a599ad4fd54610ec4bbb0a022c6c25b0102", + "code": "0x3884095ca26754c19839d1d65ed3564b4558896672ae6763c55fd1245d56ef7b51c44284d952b00f7c584661b05f3b5ef462e7e5fa5fd8ff860e55075b3c69e100b80c4ff21059bea8fc1d75692dc11a282117d4df95e89684ca76663735d95b308b08755ec965f49e4d58d22ebbf80dc425791b553f8567a173e85e1abb76c3d59d36d9a2de213c9d9eb0f9211f3a0af11fcfbb0f65cfc9f3c7b45309667e2e354f9940ed6a1b290b3c1c5b50e9b42ff556724d10fadf83a38bec6611feca7d587d806a8d61a216518ddc9bce228cccdd621174b77f4d8d747c1064e65d14c8dd19496508bc227dc9b9d757c38132fb6956c14e9e9fa87b6fa13663f26722cf", + "address": "0x7212449475dcc75d408ad62a9acc121d94288f6d", + "key": "0xe333845edc60ed469a894c43ed8c06ec807dafd079b3c948077da56e18436290" }, - "0x73AACD67E1d72534a3D83D38b88026bE46ff2928": { + "0x7435ed30A8b4AEb0877CEf0c6E8cFFe834eb865f": { + "balance": "999999999999999999978502856567391250", + "nonce": 603, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "key": "0x4363d332a0d4df8582a84932729892387c623fe1ec42e2cfcbe85c183ed98e0e" + }, + "0x746a4A19f37986b4bDF4Aa856C13876Ba5d00885": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc6f019710802c277f20eebef107a03c7716f7cceb4e71e88a6362ea01d91b71e", + "code": "0xe6cf798baf210a542efc04b9a1d35b51bbf5e410ca16e05b2438d8aa878eb4cbfe979cac28aae02591b1e9a75c257b8ef0ce5a9b169c4326754f1a4cb4d5218def8ddbc0ff0e6cbcbe485109d3c044e9d7ecef5b93900570208a0441ce95e47f957c7b755145fcfcc61091a48f9327db65a575704887cd0deb33ea7d7c39a27ee818def27d07091d58213bf54017c19392db186502c3606e7f6f2cb35e780e920072714fb5796f380bf3a3e1f2a0bef653a1c86c2fdc99fb3e1ba6475976d081a30c04976f511ea0ed4105f3959ef4bfbac33edc0897e2ca235ed8ed37aaea85c6ea3000385ba405ac4a152ff53937c2fdc832eefb152314b376e57ba9bff1e7", + "address": "0x746a4a19f37986b4bdf4aa856c13876ba5d00885", + "key": "0xdf769ae3989fee7f1bf6e8ac9dd3569178d4099af14dad7fdf015ee0e4730f9a" + }, + "0x75BE2E16aB7d49356F016A57f5a389B18e361FdC": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1e68027de7f5bb2a9c63f83cc6107bfe71694dc9d086d845e1e3b1e97dacf2c5", - "code": "0xa81c3a5a553fab8c561679d85bb19e6a7eb0218b4839501a326c84cd4158b2d51161d849492e842dca32edceeb2630bc6d621f9dea3fdc78ca65f82bb844f4b139366d2e14b42d797be5fb2272e93ead41cec826548512dfa09eaadf5ba4c2a4a171e6dff2e291b2403638b36fa1900bfb6d28056b9cc28339adf04ff3e24b88f13a4de10a82cea8926787ad7534bdd0eeb85aaf1d4813cb0c9cf7e399b7ef0bc1e4ab78a93992ee6fa5897690163464c8f8afa9af264f2d83bf6e5bb209a73a84ff3eb04bac0a2190b4fb9ac6d0dbbdf1bb431847b8b7ccd4a0ae0968e179db7130ab3fdec6ebe33fbecf2e3fe7b06f5b02e4c74c7e44e42655d673012f1254", - "address": "0x73aacd67e1d72534a3d83d38b88026be46ff2928", - "key": "0x9dcac55a8e43a847f19e26fedaddad4c4b70f05633da984b95bc232a1289470b" + "codeHash": "0x306dded1de1f616ce99dc5c63dc6ff249af675ecd11cfa7704e3a1b1a20f0be4", + "code": "0xd66e2ad9c622d8fba62695dddfb1dae629a4779e0b6cb52d0a48eef9e5021d6f391130299419caa48b4a7a49a2cba7c0a42b146ec50747d93cfc4f54371597af93e1a7869b67d2b4edac36ff5bc7eeba517ff228f0aa77f525822d8334b69637a23430173c031a9aa170221f1b31469dc7fa6938a8b13413c9b8fd8421cf5e2c6eac71626d09a1fa3110436e2c6ede46c11ad87705148403bfee1ba7383277ff545737c28018ecb87363e183c16876d68b107616b0e56037a60eef9a6d6ae89dd77d6d8eeae66a03ce8ecdba82c6a0ce9cff76f7a4a6bc2bdc670680d37142738417624c20328f41fe28003645cb6736b72c1c0f9d860d2b376428c0d43492a0", + "address": "0x75be2e16ab7d49356f016a57f5a389b18e361fdc", + "key": "0x4527ec446456c7a0bb1da8a13c16defca121665a737b6158c7bfc933e95a1e3e" }, - "0x7419f9024b102E628c6d8Ae2178fc11edA4091cA": { + "0x788AdF954fc28A524008ea1f2d0E87aE8893AFdC": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x09fbbcbc642fb5612f9ac9f09d0d161b72b0bf49b75e1ce64b1faaf0c4acfd31", + "code": "0x901ca3aca1b292c5c6a1550922e912fc3d21ed9dbcca3b2c46ab298fe770ee3b13e5a15874e9a3e7dd9f127fc1fb68274ffc67bfb8815c72347bf40700a43bbe9aee76b26d20908f7067784d7f2849ef01392ed0c8c73614f0d0abc57c616d99ea1c8d9962659d05b79d2a74379c386e592caf47911721f070f5587a9f030ffa80a7350c7d2df5004042312cc8b0f6c346a2cd21b8d9f9e294d7aae0920bbe7e5f14e0ea4eb83b384b305c1689b771279ab2a8c55fa6b7e6e7ee2c6319a7a3490f56919ffb77bd5a8f0fcb974ff3cc1c168679ead71f5d3eb9998e03259f5840bd182d795b729397ae9083e3151cadb9d76b978ffb5289a94b2035691c01b655", + "address": "0x788adf954fc28a524008ea1f2d0e87ae8893afdc", + "key": "0x903f24b3d3d45bc50c082b2e71c7339c7060f633f868db2065ef611885abe37e" + }, + "0x7A9FE86BeAf9C94121dfa31144CA12CA061709f8": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x7419f9024b102e628c6d8ae2178fc11eda4091ca", - "key": "0xedad8de5342a46c07726160a648709be199da56fdbc92ea23f5bc51a32abd680" + "address": "0x7a9fe86beaf9c94121dfa31144ca12ca061709f8", + "key": "0xebdbbe3cfd9cc04fae47b7655833c19f42ada5e8ed76371e9ebe43cad66684c4" }, - "0x7435ed30A8b4AEb0877CEf0c6E8cFFe834eb865f": { - "balance": "999999999999999999999504116057851184", - "nonce": 548, + "0x7C28716a0503bC00725b3aef3D4eD4741555fB95": { + "balance": "0", + "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xeffe888f927bccce1cf9281bd54ff035d06523b2f8519818e29f6d05f4851d98", + "code": "0x7e5820c0761b14115fe6ea18abae67e05d6099871305166211e1f3758c4ff0a7655e312cedbc024eac269caedb1f8f41f06c7f8f0177eb4f3554a658d1589a9d4826094ebf8431e0f0afae13d5b994ffdf50eb0cc63e327bf379974c92f50c6df5647cf2573625ccbe9a0b30aa78a110d0e7ac736f8a0e5ccc4022496f1a33b36b6941afb4be291eddac0e5c0dbb129591aa625d268e37dd1c2f9e5df9c0ecb65f503c75b1697635d4fc43250a4d9729a209a9ef27041f1535e5fb1d180ab5bda1ac5b3292d22071387cd970203935d354b23b6bc6a826028cfb02fb0167851e847e2cd21f9334520ad3e61ef154438d3083f3cd0fbfe02ee2ecc3dba7f46ef4", + "address": "0x7c28716a0503bc00725b3aef3d4ed4741555fb95", + "key": "0x549db5d8918de0246040398fa51124081d010de247f37f06ed212bddc1b9984f" + }, + "0x7Dcd17433742F4c0Ca53122aB541D0Ba67fC27Df": { + "balance": "486", + "nonce": 0, + "root": "0x825a39b4466a4068d4dc731403a7a9631f29b4dd1b3bd1c609faf64305e0d55f", + "codeHash": "0xa3216dd3ef46a63d518ef54e482cecac68a077f70fca0e5fb900be63f41d54a2", + "code": "0x3680600080376000206000548082558060010160005560005263656d697460206000a2", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "d8", + "0x005c4510db462e3bc91da9b8d22c23873a9f44acfaa4c50c91af1d92652e2e34": "bf", + "0x00f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed": "1c", + "0x02bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f413": "21", + "0x039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a096": "81", + "0x04050d53dc4e38076a46f473ca2ccad11c6f0357bccc0d1fc7a16e0523892956": "a7", + "0x0678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab942": "64", + "0x09b79212fdf6dfcd322d6aabd5ba752b962d7e575cf299112bead28ab955f4c8": "be", + "0x0a2bc3fd72bd3f8bb7f1de9a7dc9e928a7c6a831237124e65c60c25f8348af19": "46", + "0x0a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb0": "b4", + "0x0c8e91bcf03d65aedba99f4f76d3ff8cd007668948ce12daf4dded4761c7b19d": "8e", + "0x0dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f2": "25", + "0x0e207a83fb16f4e1d86cdb18c78df10f272b8c9dfc773d8c636bf763e5d86ede": "67", + "0x0f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f": "29", + "0x1098fa447b36d691c6d8801147ed65b27ab8c9667e089b59f1a1cdbe54cddecb": "6b", + "0x10ed5dd66ac107d9c27405dd97b947d333696bb8749b7a6b0890b449d3bf2238": "3f", + "0x11f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa": "0d", + "0x142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f": "c4", + "0x165e0e0cc13ca53c5af4860637550364c5c90a512906490ace14efb534873741": "26", + "0x16bee816935475cd45501fc5fd01bf913f8ef54330a43d80ef73101a4c728b34": "2a", + "0x17f29f600f5128013ce183ac10efc609231aff556df37c8f5d6802c1240c22f4": "ae", + "0x18c688de10e38d70bcc478405df715df76bef7c2783e310b391dc958ab5b0901": "4f", + "0x18fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b56": "51", + "0x19fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c": "90", + "0x1f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e45": "8c", + "0x1f6ebf3e4d9c96ec86b866137bbec9bbb56d188e7126babfccc6394fdcc6a3d4": "62", + "0x1fac03facd67f44699ff86330a7f959ed3745add76d323f4832bc17c35be45c9": "9e", + "0x205bcc2489f954a3af7a16da4d6042a75fcd6eb69b848c52b3448acb24b23580": "42", + "0x228c9eabdaf185c57233f73fb31db8870dd1d46eef92c3d4c5a5eba1b8f73f00": "47", + "0x22bc306256606a63c7e6adbfdb53ac8a2579216b16bcdc452de151e042d02124": "8f", + "0x231eb803c34ec183e74b466c105b5518b554ce215bbc31bfa52c384138b8479a": "aa", + "0x23c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf6": "41", + "0x24562ede5125f88e7d44659502457e8632f0cd29dd768d7ce337e567830c6b90": "5f", + "0x24a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad69079": "19", + "0x250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a": "95", + "0x2724a489616bca201e7565382948f9832cbb927d030b1d2439c28ba1910c9bc6": "c3", + "0x27edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe3": "ad", + "0x2acfc92a1cc51397c95e434631e449d83a81de91964ed735a8c8b71b35e1a626": "0b", + "0x2aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f9": "a0", + "0x2daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c6": "2d", + "0x2dd51e8325001014c6845bc5ad51b134ab237f95ab18da55cabc4275b029bf3f": "5a", + "0x2df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f2984": "30", + "0x304daa529f8e4e88c6c20e572fd04f196d6a32a5a47361118b7f42b4602c44d0": "af", + "0x304f1607803b1445143f85e860e6837543043e4a7ce83fb6c4b98a2b57a5be44": "73", + "0x321c62425869f150c2cb7f489691c3e5cd49f7cd62d07ecbb7477c4148aaaa0b": "5e", + "0x32eac35ea119adcf265e25a03e27234688fd743982f4ea87940a85b601b4243f": "37", + "0x349c26db328204bd2527eb45003b0039d5a636f76c8849bca0b34e8fb134f505": "13", + "0x38570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e8": "6c", + "0x3c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e7": "45", + "0x3eb32abcff52bfdf0887e9aebaeeaee4a61b76f2fbc9a183c2afc8552d46c3f6": "6e", + "0x3f410a22d042d915c50f9269337a2bc7155f86d79bbff1721d83f44153635ac2": "86", + "0x40325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd": "7d", + "0x40c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b81938": "54", + "0x412379b7f583981ea6e84408cba75ced69039e07ce9cdaa32a8a9dac997aaafb": "16", + "0x41565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c": "18", + "0x415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce": "08", + "0x41b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a0718": "a4", + "0x427b8ffdff6454ea85c8251407144400ed4e693ffb6a74f319e0238c0e72afad": "56", + "0x4323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c4": "48", + "0x4348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c9": "5d", + "0x4632fe8e9579f33e2e42e68811d49a09ad1af1f01a68e7ae742f765e8e797ff8": "3e", + "0x46765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc97928010": "40", + "0x468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da8": "24", + "0x474ee39f920d2819e9ccf6080e9b95c49fc2dfc9841cb795583b81b7497c0425": "c7", + "0x48ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc": "d5", + "0x490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b26723": "80", + "0x4b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb3": "14", + "0x4b85d3d5e4e06787a4e7e6d00f4e2f6d7e0358d9e511177ab584553d4ca06038": "8a", + "0x4c3dffb6198347c61671fa1fafd5d80f384ab67a494f5c7bc7428bcb6ca5a445": "4a", + "0x4edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c": "60", + "0x506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda2": "a9", + "0x5b300d53be5798f53b472dadb8966674169ff3e8d08eccb3f065bd827abd7b77": "32", + "0x5b6618f0def0d634d51118d232eadc26ecbc8d54a7efaa225afc472f0a611c69": "0f", + "0x5cd04d660080fb51a0cc8df0d716e1bff4eff98c887cf3274aabe7ec53dc3615": "27", + "0x5d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f4": "49", + "0x611f5b5e5ee263412fed40f169d0727f4e6e1a2bc94caf668d2bcf22cddca8c1": "3a", + "0x63cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f": "02", + "0x6542b8fc06728a624d10d21d45cb3fc58b811a380547cab3d5bf9e8af0de6951": "97", + "0x6551251b96ca27f3af8a2c500d6dd1ea5b9ab7002b3d923b66db0493f4a7123e": "0e", + "0x656fd2851f3badaee7500720d14437294b0fcb76990f68895b487132860e635a": "53", + "0x6760889404c1143da18e9f066f1d68de75c9a16a9d10a280d41864fd7580456f": "9b", + "0x677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a7": "91", + "0x67f77810c4968b55b6ae34b927b213ced7c266fba0cf752957a861450bb43a7a": "cb", + "0x69626497767f58c222726a6a3c65050bcfdbb9346f9e5d146ef02bf59275b3d2": "d2", + "0x6a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf53": "39", + "0x6b5eaf5499e02713812d712b5b5d3ee95e185212f6a71cc9a583a971cd861a4f": "77", + "0x6c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a180874": "c1", + "0x6d8f3f1992b15fdc2a757b2b99a8a3721589fc2e31188ab7620ca2884102ece5": "3b", + "0x6df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f2": "79", + "0x6e2466f20ef20cb42d216dbf4a0d934199213e9b8d75bedc9c2d3e038a587474": "1e", + "0x6f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db": "a1", + "0x701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef": "d4", + "0x70fe2e29e879b5adeef12bf7a782c3fd7815b6fcd3defad6eea94b8fac090e8d": "57", + "0x73b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b28": "3c", + "0x74871a06c400033dfb8aee09db8282719447dc850ca097c5e240f67a2fd7fec2": "33", + "0x75eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de0": "9c", + "0x761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd": "20", + "0x780fa5a814a83baf682b2f170be956308be6ce1bf84ce68ca5f3c59cc41c7c28": "1b", + "0x7a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe81068": "cd", + "0x7a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea45003034": "2c", + "0x7c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d525": "1d", + "0x7e93ec1b055e40d91bd222d7a3d4b0e85d09dfd561b0cd47d09a25fe183a06da": "b3", + "0x7fffa2c61f6cad00c700b65e33937fcbab57dff84b2e792d81126626970905f1": "87", + "0x81260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f9": "65", + "0x81607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa5": "4c", + "0x82a4bb68f7522b711c9f22b00f9c5e050f52cb2bc5f0f50eadcb12a5f1c30839": "92", + "0x8348faa37f759999e3e7d161ca60aeee74b5c55075e626534a26da3aa8962a71": "43", + "0x8405cb4703a08e5160e343c37d42df5f045091f6b22664b0ec3f587df18d2d82": "b2", + "0x8460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba22": "11", + "0x85ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da97": "38", + "0x87dfa85154edde1626e3a09196eab4b60f71887ec7b50ccbbe7ec76c0be6bdff": "1a", + "0x881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a7": "01", + "0x88edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c570": "c9", + "0x89c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e56": "0c", + "0x8a38792846734575025e5114061b62006064b0636caf6733294eb26895bda2ac": "4e", + "0x8d866e9225b61c55bb3e8d27f9eed41faec221f3eb1ea322661ce1956885d021": "83", + "0x9038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce5": "10", + "0x9138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea58328": "59", + "0x9225354562a563158ba2ce0e86cfeed7fde0ed27c77342aaea09551b9c00ea19": "a6", + "0x927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d": "85", + "0x92da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a108": "8d", + "0x945c01f307d13fcdab0a2a3a4c4bd5ebb69a00c3dd59896a959664e01ce10695": "82", + "0x94605c950838b2b0b1ce76f58acfb91a94c2aba787d02add7187360989745a4e": "6a", + "0x95104e47e1982aba633477f377b1511396c3fe83600224bcb0c78949be705b33": "07", + "0x951b3b37c2a87b5a67918e750832a50c5565298a35390bad3ffffadb2f7b4afe": "76", + "0x9575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc1391308": "71", + "0x95eac6698d094a89aa0fbdbe4dfa56a92b928657bfd2a6374fdd5ffadfd8ebe5": "5b", + "0x970a64830f255bfc38886621b37a7f1a7284bad6c4a04b6a2442ad212e19a6a2": "36", + "0x9739ae7192ad23a41778719941582886701a0830589c7ebfc5db094037635d82": "1f", + "0x989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b": "b5", + "0x9a9b2b0f17eb8c44f3d00dc6cd8475e9783cc715b3779af9170ddeed0221bcf2": "a3", + "0x9ebbf91a66183d0d37b03faf46daf8fe238c1aa2b24e6663dc14e50557d432c7": "66", + "0x9f569f15edd7832cd57a6cff95e09ab162c23f3dda7e729a74b2f41624294998": "8b", + "0xa0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d75": "d1", + "0xa22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b8": "58", + "0xa344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d3": "c5", + "0xa3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c": "78", + "0xa41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b": "05", + "0xa6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c": "b0", + "0xa6d01173df2aa437fb0118d181e64a8f8e05713fc01c42fbfd2250516639ae95": "06", + "0xa791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce857": "75", + "0xa90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c82": "98", + "0xa99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc8237": "c8", + "0xab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df": "bd", + "0xab5140d25dce39c42d511dba633cde87b45465d48aa4ec211b27de998abbadfc": "ca", + "0xac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba": "5c", + "0xaf1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa": "61", + "0xaf1f0d50933e49dd24b61a24c670809a5b875e3b746862636288dead8579dc4e": "2e", + "0xafc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a": "88", + "0xb2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f970": "09", + "0xb296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed7": "c0", + "0xb36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a6": "50", + "0xb3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec0": "68", + "0xb50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e823": "b8", + "0xb5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac7541": "74", + "0xb66fab7dddd4d16174b227a6f958d7ba2ae8ebc52d763b02c1ff944362755e6e": "17", + "0xb8d28e7b703baf999848ecbba44026cb6479b3f0466037bcf2221ffc3f8549f9": "03", + "0xb9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f49883": "cc", + "0xbae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a19": "b1", + "0xbb8f646a16b72f34169bcd82f0c023b582d2ae9f395fb59f9e022e6caacd83a0": "ab", + "0xbdfccf10ce95236042860c90f84756794940d0d15da20833f8bdc1b921be3efa": "b7", + "0xbdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e": "3d", + "0xbefb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb546": "6d", + "0xc558392238c2d11cdd04a6ae37065f3541a22140500f92c0d8006ff95e8df595": "ce", + "0xc6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f18": "bc", + "0xca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b97": "a8", + "0xcb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d8": "84", + "0xcd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd": "7c", + "0xce285eb20810f2d026bc0b62faf3735df2193835ffd85df244ecc2df24f43b00": "c2", + "0xce87527a0ad3ddb4d0d57d8077e84d48a6f3810f2a5672143d3b6969b0f86d6e": "96", + "0xcea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb65": "99", + "0xd0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba": "44", + "0xd1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb": "ac", + "0xd314fafd686fcd729a24ff511ae5e19248bd6ac6de8c28c79918df72de20e63e": "72", + "0xd407a81a8c9c2573926ab54ecd5ee3eb6f1853de6b11142313df08897b6842e2": "bb", + "0xd5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f20423": "70", + "0xd73688caabee79f6ecf3a0b092d26e639b7e486e45c00031db80d3d7abe8c683": "7e", + "0xd75c9abb1414054ca164bba2f8c09917fb90c24789feaa311ee34a0b3f4a82f0": "22", + "0xdbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f5": "28", + "0xe067f85eba81feba79bf640415c11ab4448d5cc4a41652fc0a200be4d2661786": "7a", + "0xe0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a71": "d0", + "0xe207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b": "4d", + "0xe2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a": "89", + "0xe3cb3b98042d005e52e8bbbf49b25e11be63ec7c63ae5a5043e44c545fce633e": "9a", + "0xe4c7ff156c2f31d046217715d0f193c8a6b3a7af6341d6abe0e28c49d1210638": "a2", + "0xe5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd963": "9d", + "0xe6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c2": "35", + "0xe70ed54757ba10a0b95454f6483d3d2e11613828f13d57d50b8a3a98e2c8df1c": "52", + "0xe7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f": "15", + "0xe865c3418b47b88e94c28956b326a799298fb44c62a7a6bb55fd991f7c0442ca": "b6", + "0xe891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a": "b9", + "0xe8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d83463": "55", + "0xe94d0b2545ec05c3ce3431c4d45c3b62fcab156563e8308fae1ebd27a2810c1a": "0a", + "0xe9bc0af4e1917255f83262d4d61622be8b86fcb24a5810c7b592dd6da6861d56": "2f", + "0xec200bf1cc6a2c5d58960dc3476cc4794ba1a9fca2ac3d09b63e7811b7299c3d": "ba", + "0xecb9f805cd314a9aef8cf2c51ccee54704c5cdcb0cf745bd3411c0cfd1bb2381": "63", + "0xee0b894f33a9643c94e4e2237077260f4191c5bf6bb3c17a2212b86af6f67df4": "d6", + "0xee9be26249f0e23118ea14c2c58ab3fc7e42e888edb4b1de6de4a03e0b793b00": "4b", + "0xef03c0a4bb7099df0152e975b6c3172e7f47225648d2754efc7e81f2d1ed71c4": "93", + "0xef429d45b992d9e888f08c3038963cbf4aa2b1e5b209fff23a8299c595430277": "9f", + "0xf199b2d65bb711d578312320d210574bcc79d63c841d7dcf96ee3604140a7353": "2b", + "0xf26b2f780c4b92b3f15f1d6e90f7d5a176b58eefea6f0d9cf2f8a0d1f86a139f": "c6", + "0xf4770d7a56ee02b105688173dbb647939e9168262a4d14b9f6a6efe19b647388": "7b", + "0xf4c5c0fe94f1f62a752dc2b883078110c5753ac15ab5fe6f425821fb61963118": "7f", + "0xf5acd98a17a3425f113b869e0dd03f82ee696401d2e7f59e8902610150a95a20": "23", + "0xf77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e90355629": "04", + "0xf8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b": "34", + "0xf9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb1": "69", + "0xfa29cff134420b6526f434ab690a9c3a140aa27b8479ae3d8d83b6c799acbc23": "12", + "0xfaca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda7": "31", + "0xfb0e917bcfc6a3ba3c079d0f19d7f2ede25ac596e725d016e0c31dbc8b390508": "d7", + "0xfb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba": "94", + "0xfc4b6ee72c1b0e13d4d0c218aa48c6233d313507fb55d142e7a2951f0b7c07d5": "cf", + "0xfd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b5": "a5", + "0xfef2849e52369d74814504a0592be1651fc3581e54b57283fd34053344624f83": "6f", + "0xff442992eff2fa28cd13c50239c9e15f907488f574ade0e75cdba2cfdb26c480": "d3" + }, + "address": "0x7dcd17433742f4c0ca53122ab541d0ba67fc27df", + "key": "0xbf1f52c702c40589735c4b038bd94e04268a58c35afad63bb16c071d62d2e23d" + }, + "0x7FA65F7792d36FD0282DFd7398347317045DaD39": { + "balance": "0", + "nonce": 1, + "root": "0x2084e24f0110a0fd1c5b1283ba04925cf5bbfcba34c26c8f2ed36d80649fa105", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "key": "0x4363d332a0d4df8582a84932729892387c623fe1ec42e2cfcbe85c183ed98e0e" + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000a3": "a3", + "0x00000000000000000000000000000000000000000000000000000000000000a4": "a4", + "0x00000000000000000000000000000000000000000000000000000000000000a5": "a5" + }, + "address": "0x7fa65f7792d36fd0282dfd7398347317045dad39", + "key": "0xf7c5aded54c81097690f975dcb3cbfb114a997c0f5ce75d2e6acda54986b88b7" }, - "0x75F2A26625f08390f5b66C5238571de790b4D7cD": { + "0x7d53f4E89992aBf93C95467Cb2e0E1Be141eF844": { "balance": "0", "nonce": 1, - "root": "0xe0a82b671528878859d9895420b108b58cd0a4b529f64b68aba04b144fd8391c", + "root": "0x22330f48a508599789a782a57c07ba7f7fc9b9ca9ce9e3331ea36127d1a283cd", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000223": "0223", - "0x0000000000000000000000000000000000000000000000000000000000000224": "0224", - "0x0000000000000000000000000000000000000000000000000000000000000225": "0225" + "0x0000000000000000000000000000000000000000000000000000000000000169": "0169", + "0x000000000000000000000000000000000000000000000000000000000000016a": "016a", + "0x000000000000000000000000000000000000000000000000000000000000016b": "016b" }, - "address": "0x75f2a26625f08390f5b66c5238571de790b4d7cd", - "key": "0x0530f0a872be8e03883d9dcdf34c6243c8b077f5e1454dcba0b00ac41b1c4007" + "address": "0x7d53f4e89992abf93c95467cb2e0e1be141ef844", + "key": "0xc57a0482220d36c87a41479e62e55decd08ec51a10116b3284b90bbf5b2bcc2a" }, - "0x75b9236DFE7D0E12Eb21B6d175276A7c5D4e851D": { + "0x7e42Fed5f877BF877BfF6A6a5aa02f1dFf69a9d0": { "balance": "0", "nonce": 1, - "root": "0xb3f69d1bc520e1e6cb0c45736136f623265d1c97a183709d9171fb81e888d0b2", + "root": "0xbaebe83bb6a87dca34a07a0ee1da5c038e50ea59754f4c3027cda3ef209dc9fb", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000055": "55", - "0x0000000000000000000000000000000000000000000000000000000000000056": "56", - "0x0000000000000000000000000000000000000000000000000000000000000057": "57" + "0x00000000000000000000000000000000000000000000000000000000000001cc": "01cc", + "0x00000000000000000000000000000000000000000000000000000000000001cd": "01cd", + "0x00000000000000000000000000000000000000000000000000000000000001ce": "01ce" }, - "address": "0x75b9236dfe7d0e12eb21b6d175276a7c5d4e851d", - "key": "0xc54ffffcbaa5b566a7cf37386c4ce5a338d558612343caaa99788343d516aa5f" + "address": "0x7e42fed5f877bf877bff6a6a5aa02f1dff69a9d0", + "key": "0xbec5e51999dfacb259afcce7ae4a1d085bb27277793cda96a079bda642d15441" }, - "0x77EA772798792AE8A7A5Db1444c5a08422E61D70": { + "0x81bda6e29Da8c3e4806B64Dfa1cd32cd9C8Fa70e": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1d0c729cea26d0141bd5dbd789a82c2bf58858a1b7dd4afc84996e5664a9a4d6", - "code": "0xa29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790f7698ee4d3dd84c8d233a0ebef7c9a17d2b0b17eea62cca39002a128ccf419119b4a1a1f1e7428a4e0f4432e44d027a7b3f953940f096bca7a9bd910297cad2ba7c703c2b799d3fc111d09a6e2f0958402cbe16a5aef32c9d8ddb9a4df7271140de57bfed6525aac375bcb880242328180c23d4a918023a12a7caf7cf12b8c4074e4a3f39900a0b4e18992ad424cdedc46668609f2bafcf665a8d99577618d5923c69264d9cf5f84a4048ee77615560f9afb39551a46e123dd0dd6c928af241dc565271d0325697fecc9f0b925868a8c62ee842da0498074146a036d84a1041d9b5286786bbbf3", - "address": "0x77ea772798792ae8a7a5db1444c5a08422e61d70", - "key": "0xea65665779db5aff91565df8d1183c21fef505ef0568218063195936d02da2dd" + "codeHash": "0xfcc60211b6d08e046c0587a81331df89a1fbab58efa0b6acf075c2ded4ea62d9", + "code": "0xf5f4f145f249ec8fd417deb07ebba6ad75c6c8d3b9078a26ec16edbc5b4cb13241a2d376d1cc7cfee6058e74f6bf0c848c6567d84037dbd084e5b28dcf7825c22f13198cc353a2bcdeea8950fb4fa16e1bfa845cff6c4dacc918c492308fe106404cbace760d55701d2fa2fc1576ec2fb0de43f2334f9dcaf513296946815da2bc7fc19ff06ab7008e625df9a00cd9ca64bd66c2f214458996515c1bec5bd2dfbfda5199faa78deb0e4a0aea26d0cd85d6b8a20455bdf7dcc586341fa10c60391c2768f4ba3e934fd0e312a0beedb01d78534b2c4064bfbf23f299e3773d9eee9b46cd7f09bcd8d210c8707cabc088fc81dbe986970bb1ba06a73ce0520c5465", + "address": "0x81bda6e29da8c3e4806b64dfa1cd32cd9c8fa70e", + "key": "0xd5e5e7be8a61bb5bfa271dfc265aa9744dea85de957b6cffff0ecb403f9697db" }, - "0x789f8Bd19f7Dd88DE4C94662B7680AB685553728": { + "0x828a91Cb304a669DeFF703BB8506a19EbA28e250": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x789f8bd19f7dd88de4c94662b7680ab685553728", - "key": "0xeb4aae143f2a12481bedc1d5283378b5cdb0d04e0726fdb5735008d766a0a726" + "address": "0x828a91cb304a669deff703bb8506a19eba28e250", + "key": "0xea810ea64a420acfa917346a4a02580a50483890cba1d8d1d158d11f1c59ed02" }, - "0x7A19252e8C9b457Eb07f52D0dDBe16820B5b7830": { + "0x82C291Ed50c5F02D7E15E655C6353C9278E1bbec": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd9733b05a801246c9a6b8f04fb365284d2e15776e63ec367591211b31bac3d12", - "code": "0xff91e8593b941cc006a9af6dd29cf00c1d93d745cd30e13d28db6ad34229c727c0f9ae4ecbfaa81a3f2a4c9bb264c28cac2ae8853111c19109e83d6c1292e7a5db185bc3aea90f5e30861a799d320e0bb6de11723a5674bbbfb6409c8f47b8822023c3bd05b942cf6cbd5cd645de4d3fea19926fd4838b16303d2ed62750847284ea7badd9e8d390707dc2872182ac68c8c7a984bb7d1aac16736628a499083edb0e2bdd19b7b49c93d2d0d8a27fc83f2071eeb7608d02782d79ee059eccc097f09b457c15826396efb730bf67656e5debac76c904fafa6861ed5765cea4df444069a8200c657d770aa801936fc60d04a47893a564a93a09e064b483165beec1", - "address": "0x7a19252e8c9b457eb07f52d0ddbe16820b5b7830", - "key": "0xab7bdc41a80ae9c8fcb9426ba716d8d47e523f94ffb4b9823512d259c9eca8cd" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x82c291ed50c5f02d7e15e655c6353c9278e1bbec", + "key": "0xa9970b3744a0e46b248aaf080a001441d24175b5534ad80755661d271b976d67" }, - "0x7BBcF9B49875acdBaa5857fD596CAF6dF405939c": { + "0x82EF715853ef1959f9e4628C253F5582d5e8CbE6": { "balance": "0", "nonce": 1, - "root": "0x8dd6737b0207a31db75fbbc29063d72290aafa75f4164d85f3f4b6fbbba2fc74", + "root": "0x8291966c55b7b20309783e4ee760f8ec2e4082e14fb79435a395c4601f16cd6c", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000024f": "024f", - "0x0000000000000000000000000000000000000000000000000000000000000250": "0250", - "0x0000000000000000000000000000000000000000000000000000000000000251": "0251" + "0x00000000000000000000000000000000000000000000000000000000000000fb": "fb", + "0x00000000000000000000000000000000000000000000000000000000000000fc": "fc", + "0x00000000000000000000000000000000000000000000000000000000000000fd": "fd" }, - "address": "0x7bbcf9b49875acdbaa5857fd596caf6df405939c", - "key": "0xd82835359d9c4b09cad79be31a60ead5e421589b8cb2bfdd6e173d680176bf7e" + "address": "0x82ef715853ef1959f9e4628c253f5582d5e8cbe6", + "key": "0xcee41784a4f2beac87ec4f132d240d8147ab4f075e723ca30b11c150bec2b94b" }, - "0x7DB168B2537EcaAc90f67C14401fa36fD8980252": { - "balance": "0", - "nonce": 1, - "root": "0xc5913c221e08d61a0acf3d91886ae1dd3d00f640857b9abba5bb23639b95c015", + "0x83C7e323d189f18725ac510004fdC2941F8C4A78": { + "balance": "1000000000000000000000000100000000006", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000218": "0218", - "0x0000000000000000000000000000000000000000000000000000000000000219": "0219", - "0x000000000000000000000000000000000000000000000000000000000000021a": "021a" - }, - "address": "0x7db168b2537ecaac90f67c14401fa36fd8980252", - "key": "0x33f31989117f50a30bbd8bde69d2efcc6ea606102f7b3841a65a69fdb909f041" + "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", + "key": "0xb17ea61d092bd5d77edd9d5214e9483607689cdcc35a30f7ea49071b3be88c64" }, - "0x7Dcd17433742F4c0Ca53122aB541D0Ba67fC27Df": { - "balance": "486", + "0x84E75c28348fB86AceA1A93a39426d7D60f4CC46": { + "balance": "1000000000000000000000000400000000009", "nonce": 0, - "root": "0x735b3acfeefa3610e61d87c6927b5d712cedaa9fd722002c537b13d8619fe39c", - "codeHash": "0xa3216dd3ef46a63d518ef54e482cecac68a077f70fca0e5fb900be63f41d54a2", - "code": "0x3680600080376000206000548082558060010160005560005263656d697460206000a2", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000000": "d8", - "0x00f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed": "1d", - "0x02bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f413": "22", - "0x039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a096": "82", - "0x0678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab942": "65", - "0x075a739ccce514f063220aa4bb66f08a7966189b0f24a2c5ad4692133d7aa6cb": "bc", - "0x09b79212fdf6dfcd322d6aabd5ba752b962d7e575cf299112bead28ab955f4c8": "bf", - "0x0a2bc3fd72bd3f8bb7f1de9a7dc9e928a7c6a831237124e65c60c25f8348af19": "47", - "0x0a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb0": "b5", - "0x0c8e91bcf03d65aedba99f4f76d3ff8cd007668948ce12daf4dded4761c7b19d": "8f", - "0x0d968817f6ab6815faa1501ac1eafc810f4bc9b7423abc4f1bd5e65e791b4e0b": "18", - "0x0dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f2": "26", - "0x0f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f": "2a", - "0x11f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa": "0e", - "0x142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f": "c5", - "0x14ec3dfb63100132cf23ef71b80689146033fc6ceb9f8c0f0a65ef93cd18c2c7": "d0", - "0x165e0e0cc13ca53c5af4860637550364c5c90a512906490ace14efb534873741": "27", - "0x16bee816935475cd45501fc5fd01bf913f8ef54330a43d80ef73101a4c728b34": "2b", - "0x17f29f600f5128013ce183ac10efc609231aff556df37c8f5d6802c1240c22f4": "af", - "0x187c8bbc8cd3f478b5688bc03cf5eda82ee75aa605e946b39ed1898f0cc0e00f": "88", - "0x18fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b56": "52", - "0x19fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c": "91", - "0x1bf804b21bbd284f3f59e4862747fabb1d91cd202d99df811fbcd650c8916ef1": "58", - "0x1bf8eef1506aea16c94dd534ab271dfdae26648de569b3bf6fc8bf4c76bd1a99": "8c", - "0x1f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e45": "8d", - "0x1f6ebf3e4d9c96ec86b866137bbec9bbb56d188e7126babfccc6394fdcc6a3d4": "63", - "0x1fac03facd67f44699ff86330a7f959ed3745add76d323f4832bc17c35be45c9": "9f", - "0x205bcc2489f954a3af7a16da4d6042a75fcd6eb69b848c52b3448acb24b23580": "43", - "0x231eb803c34ec183e74b466c105b5518b554ce215bbc31bfa52c384138b8479a": "ab", - "0x23c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf6": "42", - "0x24a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad69079": "1a", - "0x250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a": "96", - "0x27edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe3": "ae", - "0x2aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f9": "a1", - "0x2daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c6": "2e", - "0x2dd51e8325001014c6845bc5ad51b134ab237f95ab18da55cabc4275b029bf3f": "5b", - "0x2df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f2984": "31", - "0x2ecc9be98f9a8adac6e6acc5f160b0d15439b3856f0dee2a3005db79076252a1": "98", - "0x30335bc132be5a5f3bf464e0eed03a3c74f180cb9906552e187e4c04f024b804": "c4", - "0x321c62425869f150c2cb7f489691c3e5cd49f7cd62d07ecbb7477c4148aaaa0b": "5f", - "0x32984cfbb954e0815427570f4ceaef21a3691026950e5ad80401232f687620e7": "44", - "0x35f96bc70aa62a539fa99d9153b0f8aaa4594abf70cc8a8d9018e04e39a17982": "0c", - "0x38570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e8": "6d", - "0x39410f5a8f450e0b7fe63aa93e214a7c5cbe78786c815ebc926f1e8a2a14f4bb": "b8", - "0x3982f6a73961b17f67a84959ebc42a5a3ebdd1faa925399f3f276cc2de65f2fb": "4c", - "0x3a970a6d07c991261dcb566f26d21a76c578d05d1565c47dbc1fc071934c8c43": "ac", - "0x3c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e7": "46", - "0x3eb32abcff52bfdf0887e9aebaeeaee4a61b76f2fbc9a183c2afc8552d46c3f6": "6f", - "0x3f410a22d042d915c50f9269337a2bc7155f86d79bbff1721d83f44153635ac2": "87", - "0x40325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd": "7e", - "0x40c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b81938": "55", - "0x412379b7f583981ea6e84408cba75ced69039e07ce9cdaa32a8a9dac997aaafb": "17", - "0x41565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c": "19", - "0x415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce": "09", - "0x41b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a0718": "a5", - "0x427b8ffdff6454ea85c8251407144400ed4e693ffb6a74f319e0238c0e72afad": "57", - "0x4323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c4": "49", - "0x4348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c9": "5e", - "0x434e2bcc5f4148668dd618144aac33ef5d463b292b3baad302a60aeb6be03b86": "90", - "0x44dc9099d91b074b843002013672df4de9f691cf60546fa74eccafa9044a75a2": "54", - "0x4632fe8e9579f33e2e42e68811d49a09ad1af1f01a68e7ae742f765e8e797ff8": "3f", - "0x46765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc97928010": "41", - "0x468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da8": "25", - "0x47cd31a1b89686fa610642222d2da6119e54ee8ca761bd01a649e3759e47746c": "28", - "0x48ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc": "d6", - "0x490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b26723": "81", - "0x492ae6c575840126917090c30d003aec0892cd6250f877b99f33b72133b94f23": "a4", - "0x4b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb3": "15", - "0x4b85d3d5e4e06787a4e7e6d00f4e2f6d7e0358d9e511177ab584553d4ca06038": "8b", - "0x4b916e15bdb0f5b4bccaa3447694db53cc34095b5bc26299c14a9f573bd6c758": "7c", - "0x4c3dffb6198347c61671fa1fafd5d80f384ab67a494f5c7bc7428bcb6ca5a445": "4b", - "0x4d4855c520c09f3435e2cb46ceb4d2a12df59c127a1f2e871e7e9e8203fd6ce1": "6c", - "0x4edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c": "61", - "0x50495437ee69f7b12c5d6eb55cdcd8f5ce12a2eac21a2a42a7549e9f5289b1fb": "20", - "0x506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda2": "aa", - "0x51524a498a88953303410a83d67c2b8c69ddafeb99b570accaaed774fbc8583e": "b0", - "0x5423899586eb1d932cb9da03e478e1dd5d4cbbcb66d24262c7d67e543185c2ef": "84", - "0x5571137d48f7d081e62051a6bbca9d1e25c93ac6f84b7a3bc146f126ac80928d": "d4", - "0x562f817652b4478bc1e434240cd21e00774a5a1210833cbf0225273e2b98bae2": "2c", - "0x59b1019e8b01471b1dd478e65c30667d2d1780ed0c8bf5fc784b1413789b2f82": "24", - "0x5b300d53be5798f53b472dadb8966674169ff3e8d08eccb3f065bd827abd7b77": "33", - "0x5d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f4": "4a", - "0x611f5b5e5ee263412fed40f169d0727f4e6e1a2bc94caf668d2bcf22cddca8c1": "3b", - "0x628887ea9304aeb7f3934543b9d14ab4e7e5cd422ba572d39d6ee10c33045345": "5c", - "0x63cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f": "02", - "0x6551251b96ca27f3af8a2c500d6dd1ea5b9ab7002b3d923b66db0493f4a7123e": "0f", - "0x677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a7": "92", - "0x69626497767f58c222726a6a3c65050bcfdbb9346f9e5d146ef02bf59275b3d2": "d3", - "0x6a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf53": "3a", - "0x6c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a180874": "c2", - "0x6df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f2": "7a", - "0x6e2466f20ef20cb42d216dbf4a0d934199213e9b8d75bedc9c2d3e038a587474": "1f", - "0x6f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db": "a2", - "0x701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef": "d5", - "0x72be914df22404e1ed45a8224b52201a77605d52065746a00af5f60980fa4c99": "34", - "0x73286395f2a86bb5537d9b45ca7c681044645f31475a11d49285d6a0f028b8f0": "08", - "0x73b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b28": "3d", - "0x75eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de0": "9d", - "0x761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd": "21", - "0x782a285a3a645a32202a71e713e4a813bbaef9f50ce10e4caa0122c110d86bf6": "50", - "0x7975cc1088361453b019ff19e2177b264cfea56f4c09b1a8a086f6c405dd516c": "80", - "0x7a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe81068": "ce", - "0x7a63090121e41c76eee07564883abe3bd839fb20a0d2513bc9bc524f6c16f88a": "74", - "0x7a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea45003034": "2d", - "0x7b95105ef96b105a85277c69993f6f56602d912fe712ddf6156cdfcd8c490607": "94", - "0x7c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d525": "1e", - "0x7eae9da1da48fe866f64de7ac5c70c8e43644867b917aa8461f84915396d3598": "a0", - "0x81260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f9": "66", - "0x81607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa5": "4d", - "0x82a4bb68f7522b711c9f22b00f9c5e050f52cb2bc5f0f50eadcb12a5f1c30839": "93", - "0x8405cb4703a08e5160e343c37d42df5f045091f6b22664b0ec3f587df18d2d82": "b3", - "0x8460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba22": "12", - "0x85c0042b81b23b846d1e4881b0131b4bbff774dd9bdece2e74fa92ebdb053c34": "40", - "0x85ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da97": "39", - "0x87dfa85154edde1626e3a09196eab4b60f71887ec7b50ccbbe7ec76c0be6bdff": "1b", - "0x87fc0239418406958902bcd8e059f9ddc08fb2683a4be0cfd47b1eb97418be1e": "3c", - "0x881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a7": "01", - "0x88edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c570": "ca", - "0x89c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e56": "0d", - "0x8a38792846734575025e5114061b62006064b0636caf6733294eb26895bda2ac": "4f", - "0x8a76d1e2fd58cc0018aa306e83990d74d16ba9aeab4794595fc72551f0465476": "70", - "0x9038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce5": "11", - "0x905cfe802dc4c667312ea08fdbe97798b88cfb11049ade2b18ad9001e8b6dd7c": "14", - "0x9138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea58328": "5a", - "0x9225354562a563158ba2ce0e86cfeed7fde0ed27c77342aaea09551b9c00ea19": "a7", - "0x927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d": "86", - "0x92da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a108": "8e", - "0x945c01f307d13fcdab0a2a3a4c4bd5ebb69a00c3dd59896a959664e01ce10695": "83", - "0x94605c950838b2b0b1ce76f58acfb91a94c2aba787d02add7187360989745a4e": "6b", - "0x951b3b37c2a87b5a67918e750832a50c5565298a35390bad3ffffadb2f7b4afe": "77", - "0x9575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc1391308": "72", - "0x96c0d209b0a5b8b06947cc4c7ca723df55c5b972711b6c08ec7b9c393fa6e8ea": "b4", - "0x970a64830f255bfc38886621b37a7f1a7284bad6c4a04b6a2442ad212e19a6a2": "37", - "0x989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b": "b6", - "0x9ebbf91a66183d0d37b03faf46daf8fe238c1aa2b24e6663dc14e50557d432c7": "67", - "0x9f5941a130f6c2ff98ec21bb2517998dc5c8512230dcb37ede3cb8a4694175ab": "c0", - "0xa0634d80c0a702c2b06dfe60ace0d8f788b99406f1d2ac44ad3a26faa3fc1464": "1c", - "0xa0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d75": "d2", - "0xa22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b8": "59", - "0xa344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d3": "c6", - "0xa3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c": "79", - "0xa41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b": "06", - "0xa6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c": "b1", - "0xa6d01173df2aa437fb0118d181e64a8f8e05713fc01c42fbfd2250516639ae95": "07", - "0xa791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce857": "76", - "0xa90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c82": "99", - "0xa99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc8237": "c9", - "0xab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df": "be", - "0xab5140d25dce39c42d511dba633cde87b45465d48aa4ec211b27de998abbadfc": "cb", - "0xac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba": "5d", - "0xaf1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa": "62", - "0xaf1f0d50933e49dd24b61a24c670809a5b875e3b746862636288dead8579dc4e": "2f", - "0xafc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a": "89", - "0xb2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f970": "0a", - "0xb296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed7": "c1", - "0xb36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a6": "51", - "0xb3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec0": "69", - "0xb50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e823": "b9", - "0xb5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac7541": "75", - "0xb8d28e7b703baf999848ecbba44026cb6479b3f0466037bcf2221ffc3f8549f9": "03", - "0xb9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f49883": "cd", - "0xb9f03edd278ccfc90e45785c1fea3f972618a32899f836dd4fe0e63eaf8c7c40": "30", - "0xbae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a19": "b2", - "0xbdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e": "3e", - "0xbefb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb546": "6e", - "0xc452b6d808f45af81c3310dcf94a1704359eafc34709c45b0c7b95adf4cd02af": "9c", - "0xc4f8d20ccba0b50d46d9c87f28cebf8c165fced694a2b34412a4b6153b987a17": "78", - "0xc558392238c2d11cdd04a6ae37065f3541a22140500f92c0d8006ff95e8df595": "cf", - "0xc668aa05d66c2f88a95db12354386f3b6a1722a98aade506e117201f2fd0511f": "c8", - "0xc6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f18": "bd", - "0xc8bbb420578d2d80897ca392a55fce5e4834f1d641472c0fd6a9698b7a8e7866": "a8", - "0xca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b97": "a9", - "0xcb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d8": "85", - "0xcb55d89f2ee070d017b426876d6072d91c2a7311ade9a1bed2f8200127ec380e": "04", - "0xcd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd": "7d", - "0xce285eb20810f2d026bc0b62faf3735df2193835ffd85df244ecc2df24f43b00": "c3", - "0xce87527a0ad3ddb4d0d57d8077e84d48a6f3810f2a5672143d3b6969b0f86d6e": "97", - "0xcea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb65": "9a", - "0xd0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba": "45", - "0xd1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb": "ad", - "0xd2dcfcdea157f70f8422558eb02bdc6a503cf24126f8f2dc2b52a644f5f02271": "68", - "0xd314fafd686fcd729a24ff511ae5e19248bd6ac6de8c28c79918df72de20e63e": "73", - "0xd34d30c2584168001b907965762f784cb4337381aa8090ae36bc66bd515849b5": "48", - "0xd5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f20423": "71", - "0xd73688caabee79f6ecf3a0b092d26e639b7e486e45c00031db80d3d7abe8c683": "7f", - "0xd75c9abb1414054ca164bba2f8c09917fb90c24789feaa311ee34a0b3f4a82f0": "23", - "0xdbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f5": "29", - "0xe067f85eba81feba79bf640415c11ab4448d5cc4a41652fc0a200be4d2661786": "7b", - "0xe0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a71": "d1", - "0xe207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b": "4e", - "0xe2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a": "8a", - "0xe3cb3b98042d005e52e8bbbf49b25e11be63ec7c63ae5a5043e44c545fce633e": "9b", - "0xe4c7ff156c2f31d046217715d0f193c8a6b3a7af6341d6abe0e28c49d1210638": "a3", - "0xe5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd963": "9e", - "0xe6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c2": "36", - "0xe70ed54757ba10a0b95454f6483d3d2e11613828f13d57d50b8a3a98e2c8df1c": "53", - "0xe7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f": "16", - "0xe865c3418b47b88e94c28956b326a799298fb44c62a7a6bb55fd991f7c0442ca": "b7", - "0xe891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a": "ba", - "0xe8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d83463": "56", - "0xe94d0b2545ec05c3ce3431c4d45c3b62fcab156563e8308fae1ebd27a2810c1a": "0b", - "0xec200bf1cc6a2c5d58960dc3476cc4794ba1a9fca2ac3d09b63e7811b7299c3d": "bb", - "0xee0b894f33a9643c94e4e2237077260f4191c5bf6bb3c17a2212b86af6f67df4": "d7", - "0xee181b97fd68754f6245c655a0a0686e8d12aa4eac5f1d059e7e3b8d6a924073": "60", - "0xefcb86facadbec33b8779888975eacca8f44a9073a845521617f1fb30e1ac818": "10", - "0xf0ca8a88096a033508993a424f4e40ee1d800f62390dfe4ed5dd74a0f6785e25": "64", - "0xf26b2f780c4b92b3f15f1d6e90f7d5a176b58eefea6f0d9cf2f8a0d1f86a139f": "c7", - "0xf77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e90355629": "05", - "0xf8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b": "35", - "0xf9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb1": "6a", - "0xfa29cff134420b6526f434ab690a9c3a140aa27b8479ae3d8d83b6c799acbc23": "13", - "0xfaca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda7": "32", - "0xfb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba": "95", - "0xfc6dfdea8f35e8af49faf38c0164a3deacd65c3927eeece6023868f32fd382a7": "cc", - "0xfd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b5": "a6", - "0xff5c526fc525d03cecce39f4ec167af09f80525e2d44e60ee4df33a357b24ed2": "38" - }, - "address": "0x7dcd17433742f4c0ca53122ab541d0ba67fc27df", - "key": "0xbf1f52c702c40589735c4b038bd94e04268a58c35afad63bb16c071d62d2e23d" + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "key": "0x5162f18d40405c59ef279ad71d87fbec2bbfedc57139d56986fbf47daf8bcbf2" }, - "0x830544a6A94aa496947fB7e0182d64FC90192AFc": { + "0x863AcCE24e84A75b149e91470591225488Aa202B": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x830544a6a94aa496947fb7e0182d64fc90192afc", - "key": "0xf1b58012b0f270cdd9c1add82f593179cef3f8360950aa5d1fe5de28677e73a2" + "codeHash": "0x5fc20dd0c1702289c1ebac32a00d38d5f3ab099aa4a62f756fc6740009dee488", + "code": "0xa00efdb534f3a036f288f1ed093d8ee3c505b1830f5e7bdcfba3bc6cef961d6725c7e231d8fa316d46e8b9b45ae34c96362447a0121688b5fc8977a621c28ef207353636cb00f21a886a8dbc179f462dc0eba7e397de30c4590b03532e23d3afc7e9ee3fcc756aafa61501a80648b24edd970a6d68f0424eebc857c57773f53e69a50b34f46ecf75aea648265eec0fff27688b0100a4a90d38989180db6ad3816b588810da3f66df779850de767250d6b354379a4ea55b612520748b864937ea6a37856c397693f1de1578faa1274997837d54cde3a4c322a3787c67642a2544338702c004713ec1a08e6b92548f894b51c234cd2945f4ef5e08199c618d1034", + "address": "0x863acce24e84a75b149e91470591225488aa202b", + "key": "0x5788e3a5115bdb419afcc4cc415404c53d8e15aa647bb459e6f01bbcbe80ee3e" }, - "0x838CD8572D61ec23308cfb4f1f243B796a7f310B": { + "0x8642821710100A9a3Ab10cd4223278A713318096": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x30bfd822c5b2b88f07fc3988e7e78f96e22799091c6d1ba6e7cd6664669dddbd", - "code": "0xdbacf0626d1d814fd5d504189e5d5800cfd88bcf349ba6ba602b922e791aad56ccfe5d2425df2e3cbe8d7f0532b0a6b9f9be4a330be5d04c4d5f0c47290ef43ed67c34e8612c0557ad77818f63b0e965e2a918f477c43c5c407335625c16a68dfc647ae7caefab63c0c1f704d0ea4ba636fcfdf39fd0af454789b76cbc52f42e66b0a0b12995e6441f9cb2914565120c2e684eba0fba8b96acd03665e0cd074866e8088a238d9e0c32ad5efd7ee9df89e732a9c593a90146e4811d165f76da25de0705a5a4491cc4250dfb52b96473113e661025e4c03285e60a4cabadf93d8d256808232eb07d2271c0909d50bea3c5ea7ccbf9eef8f2443bdaee0dcef83c94", - "address": "0x838cd8572d61ec23308cfb4f1f243b796a7f310b", - "key": "0xd6167bc4042666c07f4e56f51aabd2c4362fa4f6c83ca79a912bdf0a8e779475" + "codeHash": "0xb05730ba4681896d76c307f28a0744f22990f47580134eb2175db1f80bbabfa9", + "code": "0x5a13bb8468ff08ea1be5434a63d147aa9a75598c1472c6c3689ce0cc412fb137e2497937f87a756db742358161519471672c61e08459ad8650f94ad10a7dd95e33404a00df2797ca129732dcec6569f4fb1a987d4ec0b4118a6130ffa089264f2365e0ce0defc8344c79251e10c13bda9f60f98c7b76a120b28b1a0e8fcfc3610b452314837379af560040da1e59ab48282b9d8f6b5a9755a333ca81fef097517409e4ab0136215a31862fc94b13e16094495561fa1aa10a04fdf23371b35b72bf66e9c8a6f2fac97b772c6cb459729a5fda5bde7ee9c2761261bd7c12b4bf4018560b1f83759e5d4d88e0ae0bb6a6669899a83188652f373acd98f90e0e46a8", + "address": "0x8642821710100a9a3ab10cd4223278a713318096", + "key": "0x4fbc5fc8df4f0a578c3be3549f1cb3ef135cbcdf75f620c7a1d412462e9b3b94" }, - "0x83C7e323d189f18725ac510004fdC2941F8C4A78": { - "balance": "1000000000000000000000000100000000008", - "nonce": 0, + "0x86b59E8a12C2BB58142FE270c534eA0AB3aFEe2d": { + "balance": "0", + "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", - "key": "0xb17ea61d092bd5d77edd9d5214e9483607689cdcc35a30f7ea49071b3be88c64" + "address": "0x86b59e8a12c2bb58142fe270c534ea0ab3afee2d", + "key": "0x76f24004f2230993f7843ed74840da1c520917d1f6a2e19d74ba58e52bd60a26" }, - "0x84E75c28348fB86AceA1A93a39426d7D60f4CC46": { - "balance": "1000000000000000000000000300000000009", - "nonce": 0, + "0x87610688d55c08238eAcF52864B5a5920a00B764": { + "balance": "0", + "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "key": "0x5162f18d40405c59ef279ad71d87fbec2bbfedc57139d56986fbf47daf8bcbf2" + "address": "0x87610688d55c08238eacf52864b5a5920a00b764", + "key": "0x80a2c1f38f8e2721079a0de39f187adedcb81b2ab5ae718ec1b8d64e4aa6930e" }, "0x882e7e5d12617C267a72948e716f231Fa79e6d51": { "balance": "0", @@ -3120,49 +3108,31 @@ "address": "0x882e7e5d12617c267a72948e716f231fa79e6d51", "key": "0xd2501ae11a14bf0c2283a24b7e77c846c00a63e71908c6a5e1caff201bad0762" }, - "0x894a5b01c2d125723dC24027397b84fc2C12f98e": { + "0x891baAf101B07222bbCF62e7DC519199d09255b0": { "balance": "0", "nonce": 1, - "root": "0x74e31aae08ca993c66e057308da6ff98cfa7397ef38e32b8c80bc3d0b2feed44", + "root": "0xda6d6392c07f4f8ea202d6b89fa3df0438cbcec6ae5a3b4a1a46e961b50024a3", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000239": "0239", - "0x000000000000000000000000000000000000000000000000000000000000023a": "023a", - "0x000000000000000000000000000000000000000000000000000000000000023b": "023b" + "0x00000000000000000000000000000000000000000000000000000000000000cf": "cf", + "0x00000000000000000000000000000000000000000000000000000000000000d0": "d0", + "0x00000000000000000000000000000000000000000000000000000000000000d1": "d1" }, - "address": "0x894a5b01c2d125723dc24027397b84fc2c12f98e", - "key": "0xa0e89baa990383f786b92798b476b4168593965a50467398bc287826e453357f" - }, - "0x89755Db2D43ED07322030C44268CFa774A05213F": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x8bea63d78653a516d0f413b043e750eeb449d8f5945d8b4c99a31a180ebdbd92", - "code": "0x3cf37595cd499be52965dd5cca4dc7fd8080976ba95b4d20907743b4d3ecf9ffd77d0f489ce296cd5f8054a5bea29f38d5248debcffc93c173d3e97af0f5880eb9106f1081d00798476dd8912565c23630e501584be091d1b1a61107e4b43f0c7f6764beb2e7bda5d37196dccaaf19eedcfd75069c8ae61ff739b58f0245c006f6e0480bfd242c1f13584a18b56f00f714e95b7578def5b6fe8aa6fe2c7565cb880cf1e5ea91773c5662a51b8b5d0bcb364561c2a7d5f3dd16bb1e539e17a963c6bed01c788e26af9ba38008dbb606bf52075609b11bbf1ff2f92d9630a74dad5f42225f39926a4b2bfb3ebbfb8ad78d7118cb50f042eeb7c25d212650a9a4af", - "address": "0x89755db2d43ed07322030c44268cfa774a05213f", - "key": "0xaa0ee8e4dced0932f418b0f072a87b286e6fbff9a0fa8b8914bb99c64cf7f019" + "address": "0x891baaf101b07222bbcf62e7dc519199d09255b0", + "key": "0x1f45298df4f084a080ff705ba3b4b42ed8583bc310131bb496b4d2150c732e1e" }, - "0x89b589f62abaEEC1C5BeBB68E788Dfae838470A2": { + "0x8A7EA0e207F38aFCE6C3b2A1D42AA55af13edFE1": { "balance": "0", "nonce": 1, - "root": "0xc7bf2b34294065afb9a2c15f906cba1f7a1a9f0da34ea9c46603b52cae9028ec", + "root": "0x9c32ffd5059115bba9aed9174f5ab8b4352e3f51a85dde33000f703c9b9fe7c2", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000194": "0194", - "0x0000000000000000000000000000000000000000000000000000000000000195": "0195", - "0x0000000000000000000000000000000000000000000000000000000000000196": "0196" + "0x000000000000000000000000000000000000000000000000000000000000018a": "018a", + "0x000000000000000000000000000000000000000000000000000000000000018b": "018b", + "0x000000000000000000000000000000000000000000000000000000000000018c": "018c" }, - "address": "0x89b589f62abaeec1c5bebb68e788dfae838470a2", - "key": "0x2befff860dbde3744ff8ebca534b22fa4b34a87bf632b578ff4eb0685a0ab872" - }, - "0x8A2DC10DdfaE949F0810dc849F6195a74b290501": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x481f79f5082e69b26df9c2cd4e19599929555456c22e17e22f049e28eefb707b", - "code": "0xc2ced89aea6870645fec84643e7d808703ca38865c8c677d069f1a9aa44744d5d4ce3a3d4d5bbdf364c0d3c4eb9dfd5cd27b08e454db6df196e94ce85c8c64c6e513bcea0dcfdc2f60988fa782e2f91b05213e66c317b74d8828ed1b7b2d6f8140dd0cfefe152c0a4af45294b873b56135d6096f0d51077644850563ebdd18d5c5f542e7eba9a41bae99afbaf85429bd619c0a3f8e6a3abf870af45cfcb8fc3f9aac8525636c18ba20aa23afd65d3d23be8a3f9d95e71cd44833411e5e7afcb8ef888a6857569f16b358b116a33788c292ca4551ca7517600ee16822e6277fdd92676c0b232be4b423ebe93ca4f745d6c40b234da106081418f7687d28b0a21b", - "address": "0x8a2dc10ddfae949f0810dc849f6195a74b290501", - "key": "0xd66cce0c10db7db9dd3380c4eb64b6e3e150b592552454222c6fda7e17ae4610" + "address": "0x8a7ea0e207f38afce6c3b2a1d42aa55af13edfe1", + "key": "0xd6890c290f55a8677b4928e89c7b599f24b7e21751260276c3b659a993a20245" }, "0x8BEbc8Ba651AEE624937E7d897853AC30C95a067": { "balance": "1", @@ -3177,49 +3147,82 @@ "address": "0x8bebc8ba651aee624937e7d897853ac30c95a067", "key": "0x445cb5c1278fdce2f9cbdb681bdd76c52f8e50e41dbd9e220242a69ba99ac099" }, - "0x8Cb56A21fa72164941Cb0dbf29aeB768717854D6": { + "0x8E313AB0dCA2cedba8F0e00837576dC7089f8528": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x0c8bff548799dd135f3cb3e056bf566181e9108be2994a07f4d4794cedb7e552", - "code": "0x5bba6c3fee0b8124daca6363e92ecaf12fc7e679b7fa7011ec71097aa99d7c72ac4a0eaf77f84b961843673f6a295658373799f9f55eb8ad7739eeb7e7bb806b582a010d0a424aedb0a6e3b9b8c4d8ab900ba6a6eaaaee7fe1ca909c2a57c9362474d855c356a0fe098517bf1b7facee1d1f874bc27250eccd0f1415584ff2746ff3aaf1ca46bc5ca71f78d7eb78c5a5a10473d97581fc61b8f8d9e4738631cc2b47fd924568f9fb3e1cb8fb8c820469b32885a74104faa8542215bc59fe949d2fb0756fccf098e4766a8684e0acf250cbde9ac42fd27538d731ee65f3e37c574579d5daf3f336107fec35c60afae2c2eaaac8e901664ce44148f4fa015b29be", - "address": "0x8cb56a21fa72164941cb0dbf29aeb768717854d6", - "key": "0xa883489fab16a412983ab7d7bbaacb91c62548282def2f7b64ce8c475d619dfa" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x8e313ab0dca2cedba8f0e00837576dc7089f8528", + "key": "0xb2918453a8af8fcc00819e734545cf1364369a224cb90ce7e85fac5787ecbcef" }, - "0x8b1B7E36D89a957b4f8935113702804cfc65cFC4": { + "0x8ba7e4A56d8d4A4A2FD7D0c8B9E6f032dC76ceFb": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x89094b9a1487e37689f7f10ab8ff11eaeffc224fe768c9959e37559da47ad5fd", - "code": "0xba70091b59edd96ce7f20e2d9e4d1a8ff78ed58cf842ef9d3c4945ad51bac5a84463531b582656b98d060e631b75e28c2993b7cc42d2faedbefd233392cd85febfcfc796f25e532dc8d3e923c03fc20e0aee82035abb3854bdecaf0c14f777f5fdbe17e4b45e906c090608f319c93802261400cfc4bccf7a0240a7a87faf0787bfd682e324f5d3e09c19c4aca68dd3ebef5b70719e211c0cab7f523b82e023a5f8fc1612348518ed777bc0250e14254f3b6b88ed58bcd55709a312a4d201e704d7bace496d479a6b3b5ac73c7fb8b832ab5cd6dc13d81d0ff67a6e79f594c43313913426d545a8000c0ac5d0c18679db9c0933e838942bfeadc26a52312d2b5c", - "address": "0x8b1b7e36d89a957b4f8935113702804cfc65cfc4", - "key": "0x1a2fc8f747f8fd4e384ec9dc259383cd532f5c476383c3dd176a436b93b37299" + "codeHash": "0x39eec94f30ed1832e93fbb50cc013d15c6bbbb705e5c80fa0be78873b766111a", + "code": "0x363806242423d19f6cb56e019805eacfbc87c7b959d1032a5958652d03be30dec52ed38a2de7539d7e071eec93cfea8675a40357e03c2a5e4b8c2f49c5736f8d69ca8bb179a934da675e9d10bdb2224803424c4be75d77a8f6d887db9b1ebc91ef5e0849f239dbb5067e216b8ecbe8b6e9b8d5d1d458195d30e849b313afe11fb22954498c32d029ce6ccd8dfbde50e756509aff48ac6c695047056f577bb970fa7128b2801f6e9e54ed32971b77be04c6631b437384f3f5aedc042356efffc34a3bbc70edd2b1649cffaf81175391ad854d34dc59b54eb586c48f2c1793b995b30498b5a6f750a34a52ba949f9390f9f5850be279a9954bed79442679bd5974", + "address": "0x8ba7e4a56d8d4a4a2fd7d0c8b9e6f032dc76cefb", + "key": "0x72e962dfe7e2828809f5906996dedeba50950140555b193fceb94f12fd6f0a22" + }, + "0x8dcd17433742f4c0cA53122AB541d0BA67FC27ff": { + "balance": "0", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x8ce72a0ce7ef4a4ae413b96a758180236e818fbd3e65950a11efa82cdede9074", + "code": "0x6202e6306000a0", + "address": "0x8dcd17433742f4c0ca53122ab541d0ba67fc27ff", + "key": "0x5014f5ee2c5966afd3f28ea3e96073eb0f4213dedf42d4214aebdf1f179fb9bd" }, - "0x8cea358A7a343ac1142AAab4690DEE0572d28bc1": { + "0x8e2Ce0273730EFd640C818Aa3B834a5F1b7335fD": { "balance": "0", "nonce": 1, - "root": "0xd40c66b99a645b9b203a05d314f80d49242d015fc1dc68bba7a83fa42822987d", + "root": "0xa5fbcc798206950f7583914b883e0120c1cc698708a062b29580564401ec0030", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000017e": "017e", - "0x000000000000000000000000000000000000000000000000000000000000017f": "017f", - "0x0000000000000000000000000000000000000000000000000000000000000180": "0180" + "0x0000000000000000000000000000000000000000000000000000000000000250": "0250", + "0x0000000000000000000000000000000000000000000000000000000000000251": "0251", + "0x0000000000000000000000000000000000000000000000000000000000000252": "0252" }, - "address": "0x8cea358a7a343ac1142aaab4690dee0572d28bc1", - "key": "0x4e92c4f7b78ccc124d89bec7c7571034a98595ab1cb7a80092c2545d22cc694e" + "address": "0x8e2ce0273730efd640c818aa3b834a5f1b7335fd", + "key": "0x8187452b81bb48d9631d0e75c485e054d87fe04b8e649d298a26aa9e481e9357" + }, + "0x9103C21ffb25BB86EA67E2A55a82a3cee45F5882": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x5f648f090749c4f185cdfd503f551f6a139518ef3b43034af7a2b6ea5151e0d4", + "code": "0xfa180208e416b80964438d3c35d1cc392fa2306729e8d162378339e15452ec247ea39c3a1b472adb1a46b82f40de40bb7a9fa5ad3dbeac7da36175e48293187d80ab0009a43379585ef3a79a25eb8b1572a96a1872c34834f703ae9e75aa75615b8b05a5871be0d722857bea97754d7edb37140ff7f5ffaf755616aae77f9ee7ff5af8c6d0a01a7e08a3fc6755b1e203b13b017a37f29ba48e9d20c987ab01a447c79cba3f4a4cb401a74b9326948647c38eaca90838d64c42fe591a3970e60281cd6fd31e0e2075b20489038375b1268e8cc49cebd55fbf190199521e0b9268af8c5873f91d3f43478f15fdd9584a5f9afdb530ee1cc5e23e8ed7c5c37842b5", + "address": "0x9103c21ffb25bb86ea67e2a55a82a3cee45f5882", + "key": "0x0ddecb41d3585905401dec1427b10fddf452737202507201d54b12b41e58e1cf" + }, + "0x9167Bee148a782A1Ff58D1e87E2ba20F5171580B": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x9167bee148a782a1ff58d1e87e2ba20f5171580b", + "key": "0xb19edf94146a2973ecb69c4fcbec11b328d0827e2492aca625601728aec20a76" }, - "0x9025d2F24A1a23CB2B093823e52e1f90DAC60a95": { + "0x923F800Cf288500F8E53f04e4698c9B885DcF030": { "balance": "0", "nonce": 1, - "root": "0x5a937f34e712fd3198d9708e641383e8e45367b8fd1732b5d8a9f88835045af2", + "root": "0xcff2e33abcf2bbe2e2b7cd934bdaa5b278b3c560ea5447127c1f2d8c21d865e4", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000004a": "4a", - "0x000000000000000000000000000000000000000000000000000000000000004b": "4b", - "0x000000000000000000000000000000000000000000000000000000000000004c": "4c" + "0x000000000000000000000000000000000000000000000000000000000000015e": "015e", + "0x000000000000000000000000000000000000000000000000000000000000015f": "015f", + "0x0000000000000000000000000000000000000000000000000000000000000160": "0160" }, - "address": "0x9025d2f24a1a23cb2b093823e52e1f90dac60a95", - "key": "0x6e9e5296c3f88a6ee0f51246dc1237dec2b78db9938cd04f404f44bc0b70a479" + "address": "0x923f800cf288500f8e53f04e4698c9b885dcf030", + "key": "0xb91824b28183c95881ada12404d5ee8af8123689a98054d41aaf4dd5bec50e90" + }, + "0x93216E4a663E3A680A0FE006285935F47caa5738": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x93216e4a663e3a680a0fe006285935f47caa5738", + "key": "0x4c5038feb95f6ec5d7f882308ee48d7f51cd0f31fde9cfabc5f8a781ac6671df" }, "0x9344b07175800259691961298cA11c824e65032d": { "balance": "0", @@ -3230,677 +3233,674 @@ "address": "0x9344b07175800259691961298ca11c824e65032d", "key": "0x2e6fe1362b3e388184fd7bf08e99e74170b26361624ffd1c5f646da7067b58b6" }, - "0x9379ed0f7e4f0da2814dc50bbf895F239Be0e367": { + "0x93747F73C18356C6b202F527f552436A0e06116A": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0xb9e281bd4eeb831410eb18e4fd03a36f0e5977e0c76074b27d202f879f924c87", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9379ed0f7e4f0da2814dc50bbf895f239be0e367", - "key": "0x89cbf9be493866f796305912943ca6b0991e8ad18a2f5b4a2847c72aaa021fff" + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000f0": "f0", + "0x00000000000000000000000000000000000000000000000000000000000000f1": "f1", + "0x00000000000000000000000000000000000000000000000000000000000000f2": "f2" + }, + "address": "0x93747f73c18356c6b202f527f552436a0e06116a", + "key": "0x73cd1b7cd355f3f77c570a01100a616757408bb7abb78fe9ee1262b99688fcc4" }, - "0x9380b994c5738F68312f0E517902da81f63cDCfa": { + "0x96D9eB44cA2670Feee25Ddb1359B6d36e6fFBaf5": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9380b994c5738f68312f0e517902da81f63cdcfa", - "key": "0x50d83ef5194d06752cd5594b57e809b135f24eedd124a51137feaaf049bc2efd" + "address": "0x96d9eb44ca2670feee25ddb1359b6d36e6ffbaf5", + "key": "0x54f5ae26f0a76f1cb1f3f6d1677c1483d53e13f47e520a1583b31a61422c02c2" }, - "0x9539d142fbbdEa1A80522fEdfA5A8619b4fa1861": { + "0x98689EC73E856AA045d939b320765303666Df0B4": { "balance": "0", "nonce": 1, - "root": "0x9eda8eb6ca03d7c4afe47279acc90a45d1b2ca6a11afd95206f8868d20520d06", + "root": "0x52d6d2913ae44bca11b5a116021db97c91a13e385ed48ba06628e74201231dba", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000001e": "1e", - "0x000000000000000000000000000000000000000000000000000000000000001f": "1f", - "0x0000000000000000000000000000000000000000000000000000000000000020": "20" + "0x00000000000000000000000000000000000000000000000000000000000001c1": "01c1", + "0x00000000000000000000000000000000000000000000000000000000000001c2": "01c2", + "0x00000000000000000000000000000000000000000000000000000000000001c3": "01c3" }, - "address": "0x9539d142fbbdea1a80522fedfa5a8619b4fa1861", - "key": "0x9a57b0a587fc060d23e9d43445f3f75c10c91121e850e44ef1fd11e47afd5ba7" + "address": "0x98689ec73e856aa045d939b320765303666df0b4", + "key": "0xd5c9aa063e60e4cb577a1d645d09643c9074af8fa8677c78bd1240cac7b6749e" }, - "0x98618Af6804CBB0B95A2625850bdC390f3Df5792": { + "0x9BA269ed634782aE1fd4508A841B697DEAd12744": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1a78f610af853b8d5ead50bd031651dd1270a5b813d8b8bbe12be891d693bf48", - "code": "0xb2b734aa38ff5be8e3809aef093ad60f972a796d6f60e255580de9e9a1a5fb18bef76e95677125529feb51c7954bfde7834b036aab1e14449b02160892e908d960d9a2c4081113d70e03e5593f31ca97a5eb6efbf19cffdc881e02b429b9e44484284a16ccabc0709ac21718bc53daf6afa43ecd0fd1b02c884ad060803854db405765d7ae389012e16cc1e5275b26952f443a9ee40870dbc2cae0484b4929c8e1c54a86e002b6bdd7a5b8085479a79193c73096027f68ab35c38dc9cfed12090e9838fe1d2e639a62395f7e52a2d745fd5b0f7011b24ef0e937458897583a0c22872262be58395faccd44f164ce49ff825546056a0badb18b18b061da4f1238", - "address": "0x98618af6804cbb0b95a2625850bdc390f3df5792", - "key": "0x8e1a4d37ee935603b4bef1a0603bffd5f07b0c6a9b18ea4bb831d4fa6bc4e80d" - }, - "0x98f1772522fB7635C01709D834Df35F151Fd08eF": { - "balance": "0", - "nonce": 1, - "root": "0x2434bfc643ec364116cd71519a397662b20c52d1adcff0b830e80a738e19f30e", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000b8": "b8", - "0x00000000000000000000000000000000000000000000000000000000000000b9": "b9", - "0x00000000000000000000000000000000000000000000000000000000000000ba": "ba" - }, - "address": "0x98f1772522fb7635c01709d834df35f151fd08ef", - "key": "0x1b6dc4d3b5ec40115001f1d0225ddacec642f618d497090db5f88565b8be234c" + "codeHash": "0x5b8c99577256a15d06a28136692317076372b213abc4dff772cc8036c96d1084", + "code": "0x00caca6c725b2071171ea44f3346bf78f8d0b5597a2a408f011fa08aeebfdf2ab4b879bb3f11edf50695b610ae1ee979639a7ba524b1c699e0f89b9b31353fec6fb82ae3a889cf4e8d2c22a8349342b87eb518f9f05e15ad60fe6991d6c420cffd78ff3ecb67ba1b488f00413974097aa64512e6c708a2a6b96680df32343bb8cc5c8c706f8389f8e638c815d14b44781c79c9bd4b5aed387262c62c4249401d53be41676d5cc1f0a9d657b80dda9f476346bae3ba32459c3c42ff07ead14c2951409a2286f645e1dcaad586703c168893dccc02a1a9aad36a0076045dccedfc994a8886cc0e1ee9de6e5b5661a7c83f7243c5f0ad8c0d5c6016c5fbb8882983", + "address": "0x9ba269ed634782ae1fd4508a841b697dead12744", + "key": "0x3a8a079f2f9b3eb93f242e2d3e7158f0f6850302944c8752ac210c93463ff6ef" }, - "0x99D40A710cb552EAaee1599d4040055859b1610d": { + "0x9F50EC6C8a595869d71cE8C3B1C17C02599A5CC3": { "balance": "0", "nonce": 1, - "root": "0x9b3243375d54294b7f3e11b027fdfb57c63136fe58b679c0a227e2f55ad7c072", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000147": "0147", - "0x0000000000000000000000000000000000000000000000000000000000000148": "0148", - "0x0000000000000000000000000000000000000000000000000000000000000149": "0149" - }, - "address": "0x99d40a710cb552eaaee1599d4040055859b1610d", - "key": "0x946bfb429d90f1b39bb47ada75376a8d90a5778068027d4b8b8514ac13f53eca" + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x67d7afc302b0d54eb18853411f46998d05c8eaf4da3f2b77af1fb618626f2bdc", + "code": "0x3f1579c5434b902977fc1e0703af241fe080512fbb19dc21b0d08faa73050669a4eaa4181d8aa57552f668c2ff97a093341c3d011221f34a7505ed786b4bf2a7d6f9868dfb52c402e1d59c73c3f2f623c40a3db8774902d63940b3f50d6ef3848335fd41503dd7bc5aa80d8d618041fa501eb79009bbbf336978ac474a44ddf02e4f5055f95dbb749a90019f6e44beb69dd0487d79367dae3c2cb00571405a3eedf063063c2432b0daf4344815598e8dac7a678a6019d0efceef7dc21aa986ed588f4bad177fcafeb86bed8dfc1d9acf702e643163d5b6736d7bf35d937d255f86ceeafcdeafbc5fee426ab68fb25b6d7278bea8cc7dc7c6d8b22351c2a13639", + "address": "0x9f50ec6c8a595869d71ce8c3b1c17c02599a5cc3", + "key": "0x2705244734f69af78e16c74784e1dc921cb8b6a98fe76f577cc441c831e973bf" }, - "0x9DDDb8668AF4D3DC4746b64973d7961Cb7Ca83Fd": { + "0x9c6e13AE62C45c5af66061ae7d5bd7777bd73Fb3": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9dddb8668af4d3dc4746b64973d7961cb7ca83fd", - "key": "0xf251e6fdb71031f2b1cfc0e2189460c6b88783c30f5d8e84aa0bf5262b7064a5" + "codeHash": "0x920edc96a12889225908eaac095bcde16b6e5c8c252b15db65db90e1974251b6", + "code": "0xd6d11e3863c3c5c135c900a7a1f2145ef8955827c13fba8bb96e8ba136267217fa958e1be2d3d8d37da34f1c291dcec750fb1828e4bcff2846e36aa189960a9f00bc01de787f9aae8d65e5871bde106f5c7828b32fd415624a3d18da543a148d9c68d7404ea71965a39260214a95ed0602bd38a9bb003aaff75f9fef6859368a7a994dc0d23dbd6a674e00a2fecd717ed14fc668e1d60c12dd72df674ba0055d8dd1cc0c68bc6b297f58d399ad869ae785ae1f5878bb7c943cd5d51ef157568375a356d8f1fe1b56859f3da848bc73e306897a977d2988371232bbf4bf1e3f5ae5fc80b2bb06155477ca775440f681635a2010925a774478b3685b59b1c5d864", + "address": "0x9c6e13ae62c45c5af66061ae7d5bd7777bd73fb3", + "key": "0x255d91ddd310cc85afd19e6dae09c70558cca5fb7f1bb7a8ff074fc7e99cba61" }, - "0x9Ef0201350e14E23DEFbace3Df6C0582F1B7eAA0": { + "0x9f5CC913d1bB637b0cA3510A49BFAA0051deCC75": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9ef0201350e14e23defbace3df6c0582f1b7eaa0", - "key": "0x136a96313f35a3d9f3439a676c0780ca086c2638a6b92272afcc6e296b89935e" + "codeHash": "0x851cb461ed63af978778812e29b8438ce3f16aa94563d2da59fa0be03ac953e6", + "code": "0x42e4f963a3fa39ab69d625e264d630b7b8d02724b6965c3e5947a27d0128f6464e121f71c7387e782159a5ba74f560edf5f0a75236c9955a45a634893ccae10d5a6abfa0b523f1fbb68d45b199c8a459119750121cfa7e46c7afd4a8f9bb9b99ee067c1090ecd738876f3df0e706ba52760fc8dff34c0a82ab024434431f51deafdf7aaebcce7888b84b30340b3fd0b42f1628596c1a7bdf530b00a0e826bd8a0c8c25983c5dec62ddcff7ef6a7b6a0125a8e67abeacf43feb9033b61ef373d797d00f5e9af51f367376d3b4e378fe4451a9a7f795a2a7bab9aaea91f6031d6c83754adcbc6e45a35e984f70507c095d41bbef00afae3cb78028e9ccf3b0736b", + "address": "0x9f5cc913d1bb637b0ca3510a49bfaa0051decc75", + "key": "0xeceecfebcecb0c7cc1178556acca97a647ac263a51908fa44bfd209d82387baa" }, - "0x9b3cf956056937Dfb6F9E3dc02e3979A4E421c0A": { + "0x9ffACcB3fF3D37762a5a37C4255e47f524E2C975": { "balance": "0", "nonce": 1, - "root": "0xce2f545355cdd2106ac32f9929d2a421f2b50fa224d450fdbd6ce592eeec1222", + "root": "0xb856a374cf6edfda9a89ee543cc835161764cf5dba40a87c2748d5bd14a5dbe4", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000003f": "3f", - "0x0000000000000000000000000000000000000000000000000000000000000040": "40", - "0x0000000000000000000000000000000000000000000000000000000000000041": "41" + "0x0000000000000000000000000000000000000000000000000000000000000245": "0245", + "0x0000000000000000000000000000000000000000000000000000000000000246": "0246", + "0x0000000000000000000000000000000000000000000000000000000000000247": "0247" }, - "address": "0x9b3cf956056937dfb6f9e3dc02e3979a4e421c0a", - "key": "0xb1b2c1c59637202bb0e0d21255e44e0df719fe990be05f213b1b813e3d8179d7" + "address": "0x9ffaccb3ff3d37762a5a37c4255e47f524e2c975", + "key": "0x93dd6c4b1d18f757fc687bfe44d81ee7eb4fb269120f91e7bc6fe3f596be47f5" }, - "0x9bB981F592bC1f9c31dB67F30Bbf1FF44b649886": { + "0xA1164E71D16e9eEec97392A83B253438FB36C108": { "balance": "0", "nonce": 1, - "root": "0xd60ee4ad5abbe759622fca5c536109b11e85aa2b48c0be2aebf01df597e74dba", + "root": "0xda3f636d9768b5cc17d188469438245b9115ab2c12280c4185c3aa039792b3be", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000015d": "015d", - "0x000000000000000000000000000000000000000000000000000000000000015e": "015e", - "0x000000000000000000000000000000000000000000000000000000000000015f": "015f" + "0x000000000000000000000000000000000000000000000000000000000000013d": "013d", + "0x000000000000000000000000000000000000000000000000000000000000013e": "013e", + "0x000000000000000000000000000000000000000000000000000000000000013f": "013f" }, - "address": "0x9bb981f592bc1f9c31db67f30bbf1ff44b649886", - "key": "0x1ee7e0292fba90d9733f619f976a2655c484adb30135ef0c5153b5a2f32169df" + "address": "0xa1164e71d16e9eeec97392a83b253438fb36c108", + "key": "0x3c14ed4cc1c3cdeeb405fa351cfd8e2cabbbee07b9fe38828a2abd2eb9842cfa" }, - "0x9c06979A58c4E331F355883d1e893D13e3b7F341": { + "0xA90169ae859913CC39E0c24ADdAD3E74788276a3": { "balance": "0", "nonce": 1, - "root": "0x209641d47d9d587d8c732197fc36a51c1d24948f632742d213d0cb8763c7edf7", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001ec": "01ec", - "0x00000000000000000000000000000000000000000000000000000000000001ed": "01ed", - "0x00000000000000000000000000000000000000000000000000000000000001ee": "01ee" - }, - "address": "0x9c06979a58c4e331f355883d1e893d13e3b7f341", - "key": "0xa619a597342a62e6b3fbe3ab3d7933a82020342dd0f1520abfa4623d9bbbbb90" + "address": "0xa90169ae859913cc39e0c24addad3e74788276a3", + "key": "0x8c1e1a5ebeff0db0b6358fae0f6947ca7e092a3c6675d35381f2358a170eb0b3" }, - "0x9e59004e909fF011E5882332E421b6772E68ED10": { + "0xA961fF20323997A869Eb4D18E8a7Fb921690E793": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x2f69e37f59a31ef79d90459fccee2d365e354ad304c05e646cbf6b4a9f085eab", - "code": "0xb4c4e2b6245313ebc2e84fd30cd4004aef84bd2a40151a93462f49c26e7506fb2d24f5b2a624144cca8966ee8ebaaedd1ac3debcaece0f685b099077dfb2d70a0e75755c41adbb4f27053405d1410dcc6f39998c05961a8623aa6cb33b0be66f8195e934be8e1e1e67e36670679242f3eb3fe013d19203686902c1dc42dff3e49866e7eef0c92f888b29f2bed58ab872a91939249d76586c0b7412b6b577479e1d87c3377c62b76e969d2b0db015e24647df9fee4d414b11c6817618df8537f3098e5c8946c3f55aae04af8fe9c4589802eae2b11667f4dfa6883e23815c01edd65ecf137cd4f3b2d832c2d1201b08f864662ac72ecf52eb255eb7d0df1a1db6", - "address": "0x9e59004e909ff011e5882332e421b6772e68ed10", - "key": "0x3897cb9b6f68765022f3c74f84a9f2833132858f661f4bc91ccd7a98f4e5b1ee" + "codeHash": "0x672ac0692d0cc664ef0f82004a74014b2304cd08526c32826d91d6ca2e895070", + "code": "0xb2e2b84e9c287c35516c8c03da30b8438afb348d4d79934a428878aa29874ca0ad6f0c78bdaf95ef24d97b54420f40d55858cdd1fb13209f0d32e335a0c9e2bd7ec3c2f200843fc90126ba954586fc6de68c1a3d419d6f0667702fd695602f052f84c972fe68fabc45c457b4ff540e42699a4370cab6e165c8aa3ee904308975acaad697e97d6029fe86d542dad1d34ad3d6952dc1e276bca67b4305f914f2e385f617656293cf345cffb629940096100b80c9fbd7417ab664df65fbc8ab4ae3c3a4f9c0cd86a77a5f703bc4c9de9055aca230e85714684c3c974483c02b2238015395b57ebda58dc99e6864a8c8ae71ba95fcfb915d35ab1c5375564a181e19", + "address": "0xa961ff20323997a869eb4d18e8a7fb921690e793", + "key": "0x45a2591a446e24dacceeaa3302901481268f67a0c7a3f5e282dc54132ef54fee" }, - "0xA355a21C36De6b7218d21e119b60676b176704fc": { + "0xAB557835aB3e5c43bF34Ac9b2ab730c5E0Bc9967": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x733cb31bbb18e7b961481250f0ba1360594dc64d3e718fe7de2ec90d34c6098e", - "code": "0x1e294673971cfca694eb2b530effc46ed1a0e6951dc278025e8cc33a1b7920173741728d05b0ba6fc6794269449728dd17f14bc1b31e69610ecc42912ff0f4d20e2fb4e3c2ec2260f93ea3216765fbac4298665bf7377032a021f529b2e2d5222a16a5eea9d64b50e6e0c5b94e99bd7223c40366b3c0a4ea4fe6ffa3e3a0e6e1ed85464681cf13f1b75d78e7f27dcf6f81bcb07a6f89e5530327fe310424559eaa4c866d26f9e82356895b445c2e5df46dc3b43ac6c8b2c240632dc8221f3a766c72695df125cf92f136bb13fddea02c359a434c7ac841202aefd428779c63f889b65a10a48c13fa4f1a7fd615279159853638195bb5622212415f85f7b734e0", - "address": "0xa355a21c36de6b7218d21e119b60676b176704fc", - "key": "0x958facc25352ac71b19beae99e016548fa24d959f5e766b4f9348cd15b65d565" + "codeHash": "0x9716c463c09b065800e539fb1d0cec27d8237686c32b94b7c0da4e49e41c02a4", + "code": "0x30cd5015e58b9c24eb2595e46f57007c5ed8a4ec876a16d456573afa20d3e9f577ebf6665d47f78de8fd49ef0f2b9e56505597ecaabf21c3af83dd603fdf48673b77fbda46b9ec81be06aaa750123ed7df8486d593acd5a63efe1ee068667c8d95bece5f6b20131d5e81b5b1776a1207bfb0e442012d2877df319d49ae267d7d37cbb42e77be277901f199d496ec2cbd5a4a969935694ab27df77ec42914a258f282e2888c324df7cb75156822c2e77eb209598344e61a2f9e26eac48e8a1c0deaa54584ad2f8e3adb41715141f532d0309f2407f7fec73992b958422fb316a3fcc52bc06864b9e3d1f7f3445c632ab994c7b676fff2b07ce1895e6627a5e6bc", + "address": "0xab557835ab3e5c43bf34ac9b2ab730c5e0bc9967", + "key": "0xc9ea69dc9e84712b1349c9b271956cc0cb9473106be92d7a937b29e78e7e970e" }, - "0xA6a54695341F038ad15e9e32f1096f5201236512": { + "0xAB9025D4a9F93c65cD4Fe978D38526860aF0aa62": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xa6a54695341f038ad15e9e32f1096f5201236512", - "key": "0xa87387b50b481431c6ccdb9ae99a54d4dcdd4a3eff75d7b17b4818f7bbfc21e9" + "address": "0xab9025d4a9f93c65cd4fe978d38526860af0aa62", + "key": "0x17350c7adae7f08d7bbb8befcc97234462831638443cd6dfea186cbf5a08b7c7" }, - "0xAE6883d7bEE5Ac3a2B1B2687C64309d3a168fBE9": { + "0xABe2b033C497E091c1E494C98c178E8aA06Bcb00": { "balance": "0", "nonce": 1, - "root": "0xaff437d2f3b4a919f175d26053aae80fd53ae4901a9007925d621faa5d3024e8", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000202": "0202", - "0x0000000000000000000000000000000000000000000000000000000000000203": "0203", - "0x0000000000000000000000000000000000000000000000000000000000000204": "0204" - }, - "address": "0xae6883d7bee5ac3a2b1b2687c64309d3a168fbe9", - "key": "0x0e85ef0d4474e7938384fefcd97e2f3603fb0fa1d3efb98eddfa5ffff6679cc4" + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x95e57877cb77e5808a2bcdbd9a45d097c0b3dc68abb1f465ea48b008a3148556", + "code": "0x1120594d593e46ec980fa0e64ae4f1623f0418421709dc7d6fad68015af55d1d620578150f00fe0405f3d5666527df1cd988c5f1cb8f0c21d438b7905f0afa7e378a1747347d49ceae36de53193d9d8491e80e3a2fb11519a36bfcfac52a0538f66305a61ddb824256acb564f9115b8a40970c3a191cb25bf2239e3351c867ad7689a99680307812a025bfe2515f32064fcc60dd1f88561facecb27800c6e7d8d06a3dc40d36e90357739e5267c8f470c6aa505d386b9fbc86dd03bb7df3aac74e667e8bad4edde6f56bcaa3e55b50d51f169d5647b8943e923ba4e5d9251b30c0a91aeab3466ec13dc835dabc920debb7b08929ed570a9253107510cdb18f73", + "address": "0xabe2b033c497e091c1e494c98c178e8aa06bcb00", + "key": "0x2374954008440ca3d17b1472d34cc52a6493a94fb490d5fb427184d7d5fd1cbf" }, - "0xB565fF21AF37E44a5E8BC217D6B43C86419CF0F9": { + "0xAC4D51af4Cb7BAb4743Fa57Bc80B144d7a091268": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xb565ff21af37e44a5e8bc217d6b43c86419cf0f9", - "key": "0x66192e4c757fba1cdc776e6737008f42d50370d3cd801db3624274283bf7cd63" + "address": "0xac4d51af4cb7bab4743fa57bc80b144d7a091268", + "key": "0xe42a85d04a1d0d9fe0703020ef98fa89ecdeb241a48de2db73f2feeaa2e49b0f" }, - "0xBAC9D93678C9B032c393a23e4c013E37641AD850": { + "0xB0eE91BA61E8a3914A7eAB120786e9E61bFe4fAF": { "balance": "0", "nonce": 1, - "root": "0xfb79021e7fa54b9bd2df64f6db57897d52ae85f7c195af518de48200a1325e2c", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000ef": "ef", - "0x00000000000000000000000000000000000000000000000000000000000000f0": "f0", - "0x00000000000000000000000000000000000000000000000000000000000000f1": "f1" - }, - "address": "0xbac9d93678c9b032c393a23e4c013e37641ad850", - "key": "0x8a8266874b43f78d4097f27b2842132faed7e7e430469eec7354541eb97c3ea0" + "address": "0xb0ee91ba61e8a3914a7eab120786e9e61bfe4faf", + "key": "0x4bd8ef9873a5e85d4805dbcb0dbf6810e558ea175167549ef80545a9cafbb0e1" }, - "0xBd079b0337A29cCCD2EC95b395Ef5c01E992b6a5": { + "0xB39590ED5AFc0053c8546F42aDCA5103127101d0": { "balance": "0", "nonce": 1, - "root": "0xe478b9c7df7d530ab039ef863b6ee52df4c726c17ac895122343b51c45d5f18e", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000029": "29", - "0x000000000000000000000000000000000000000000000000000000000000002a": "2a", - "0x000000000000000000000000000000000000000000000000000000000000002b": "2b" - }, - "address": "0xbd079b0337a29cccd2ec95b395ef5c01e992b6a5", - "key": "0xf0877d51b7712e08f2a3c96cddf50ff61b8b90f80b8b9817ea613a8a157b0c45" - }, - "0xC7B99a164Efd027a93f147376Cc7DA7C67c6bbE0": { - "balance": "1000000000000000000000000500000000007", - "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "key": "0x8e11480987056c309d7064ebbd887f086d815353cdbaadb796891ed25f8dcf61" + "address": "0xb39590ed5afc0053c8546f42adca5103127101d0", + "key": "0xbd016cd87ac43eda3340965f21b4c4468864a7f5bd4924913e1f872c3043752b" }, - "0xD089C853b406be547d8e331D31CbD5C4D472A349": { + "0xBDda53a9729794D60e7555A0A9066b3aBCFc15a1": { "balance": "0", "nonce": 1, - "root": "0xa33259a022cf713371b64cf9305a032e8bf31d4245fe00f5dca4aaa19967abb4", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000097": "97", - "0x0000000000000000000000000000000000000000000000000000000000000098": "98", - "0x0000000000000000000000000000000000000000000000000000000000000099": "99" - }, - "address": "0xd089c853b406be547d8e331d31cbd5c4d472a349", - "key": "0x389093badcaa24c3a8cbb4461f262fba44c4f178a162664087924e85f3d55710" + "address": "0xbdda53a9729794d60e7555a0a9066b3abcfc15a1", + "key": "0x8b016cf0507d02b670f348014bfbbac4ddc6c327f162ad478a4d4658a11ed051" }, - "0xD68D1A62f58c6B8cceF66B50228Bb9163784F355": { + "0xC019b892751D14Fdaa6cF0435E7f52C957E9F11A": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xd68d1a62f58c6b8ccef66b50228bb9163784f355", - "key": "0xf7eaa0ae3d9e339e65e019d913513f53f3175e0b35c21f171cc04e6bb06e8c13" + "codeHash": "0x1d6fd9c82f1c83e2e756f73641224957124560dcc9047ba881d7c4f08bcd3866", + "code": "0x5bbfe49fc46bd3c0efd63509af9eb2a12636d52d97f4d1cf52bf53227ef389c271b77ca6c28942a6a5831a75c27e59515f05848f3eb905d816d90fe6792b6da75759ed2ce2b5d312af3edff82a4df858741988b1bddfcca1f32b72a28d1d70f0f787d5ff306ee7ea1d7b35b5cacd5a837646921c113945dbc3a3b6329ce400332b634da6ab875d88498f503820d9b51f6eb10d3d2f378c32aef2289b509f3def68ec43d1fa25ecab18a22465ce1f8255926468a3d494eb646e020d9745efacba95205ee1597333a2b36cc31b0a8c074c0c1fa2918672c4e3dde98e6eb3460fe407979f83feb91e6e71e734e272c56671bf06f2c8bf8067684cbe31f663fccc52", + "address": "0xc019b892751d14fdaa6cf0435e7f52c957e9f11a", + "key": "0xae30ad28b2c8aab0d3c983610429e60fc0073255d1c69e538d6ae7b5d9562b4f" }, - "0xD917458e88a37B9aE35F72d4CC315ef2020b2418": { + "0xC798205CF296141b777279868c635Cf7bb515510": { "balance": "0", "nonce": 1, - "root": "0x1b9e47810d5392418d38571a39fa5984e48e0f03b932d8b98f6aa771ccad65f2", + "root": "0x1bdb6449de127c6efa6829eef0c6b2188a66f104b5d1091f7dd3f419db0a8da6", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000131": "0131", - "0x0000000000000000000000000000000000000000000000000000000000000132": "0132", - "0x0000000000000000000000000000000000000000000000000000000000000133": "0133" + "0x0000000000000000000000000000000000000000000000000000000000000224": "0224", + "0x0000000000000000000000000000000000000000000000000000000000000225": "0225", + "0x0000000000000000000000000000000000000000000000000000000000000226": "0226" }, - "address": "0xd917458e88a37b9ae35f72d4cc315ef2020b2418", - "key": "0x4c2765139cace1d217e238cc7ccfbb751ef200e0eae7ec244e77f37e92dfaee5" + "address": "0xc798205cf296141b777279868c635cf7bb515510", + "key": "0xdf474a26cbbb578c227ea61f57b81c27ce1e9d917d32a818f4e13a84591d8af2" + }, + "0xC7B99a164Efd027a93f147376Cc7DA7C67c6bbE0": { + "balance": "1000000000000000000000000200000000009", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "key": "0x8e11480987056c309d7064ebbd887f086d815353cdbaadb796891ed25f8dcf61" }, - "0xD9D4095509b1ea9aDde0E42D4eed8A4bC01ce4F9": { + "0xCaE62C8E777eA0541A55B5Af15D59eECc71cE2ac": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xbbcdc1260a8c1207ed4df8f6aa53d86b13407470023e3d529bb2d34ee71739ef", - "code": "0x505a94e92091157a2b6c32cdb529e4e0fff70a56f15fdc98e76e3995f7d83843d5db31e9e7c32143fe3af51e3315d4786b187de82f0dfa39162c39200bde0914635ba9e622461ba1e5f620ca05d0e3903d2be7dd66af8da9796c6b26acd3b499fe480de640588828f4a109d5f0bce8c49ea257ed6d39a78cefb2cb82699ced8d0b68115d5c2b6ccaf79db212002dcc3d52944fdf04f672a09f6629e434f2646687ab7a5a3e42e9ce80c9bfd4beffdff114c758e71396b4ddbbdcc38c72c3a00cbf662de3bbc8b6d7b5786261d3e6f5e282baa7fdbd39fa16fa0c27c43972cc6e10e1d521b80b6a244f273da5d76441c35c86907c122c4d9bb88ab0ae851ea3f4", - "address": "0xd9d4095509b1ea9adde0e42d4eed8a4bc01ce4f9", - "key": "0x38978834c603c45c873fa267fe1b541694e9e55e9c59abd0c22489cd9eaef823" + "codeHash": "0xb18b045e361de70704dd8b0b76210e158bcf3cb17d01d32af071fdcc6f599b95", + "code": "0xf3261457f4fd0b7c00a1511877ab27b74183ac470be8db3a7ecdc64335f6f979dd2cb9885bc4a6b7d63bce617b9a4981fb4dfc6d1957489e794070560e4e930da145dac0d5853e9e18103395cfe86de32038064edbc272862280672e49bb93357b2f1db823434eb2c3257b921622f3b73c33ed78ab6344072b7d0d89829cce01e9e3d0af61c0577149d8fdf930c9e5cbb4ff7a5481b41229c7576f61f8f2ec08c6d78b22ca7ce0ed62fd1a46e03059e749d11a0ae0882853a9c6848594bb8508c612924e9d43860c38e1b79881d3d6b2fbf66e000a9d5170db882dc3f048dd6fbb59cc25b8b8d576949767a0b63e0aa0df84d25f2821a2ea8cbdfce970777b41", + "address": "0xcae62c8e777ea0541a55b5af15d59eecc71ce2ac", + "key": "0x3f6c9bea2a94e47b2694dda7576291a475e5e70977c0a71fedf363ea2cb652e9" }, - "0xDB25388D92FA7D824178bc472C0a5FD84A69d18D": { + "0xD1FFA9fF507492844818d0d91Bf35B93a7c95E4a": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xdb25388d92fa7d824178bc472c0a5fd84a69d18d", - "key": "0x9a36e49d6fa789abc112272965ccb529476471bc9584caf51bbf38cf818ecf57" + "codeHash": "0xde7b1b0e50a7d7bfc2941895dea4aa00ef5020617339bf6862b65a44fb9e3e7d", + "code": "0x5ee7521a899a1bbd499ad817e1d673d594eb84ef5130440e43abd9ab1110486735b47ec3f55b71d6589203440915d2ef7280ff31d26085f81a04730b0655d961b2c0f7f2035a27e69c9e7dbc21354039da07b465d84ab3b1eba23eace489d13e7bfa808024a5334b0a1e191d8e95f6724ea40d1a03d1286b6934e670f8c6924b6a1b1ef94f6deb640ab38caedbf44252d256d60e00dbeb774c18a4a570e050fc0e4439da0f5e13593fa65268ba122e984104c23e93195f67ae3ccd394337e11d8725003c645a213b2583d67f9bdc3f05a16873ac6edf6234e388904a6f2b0dde4a6beb59a7cd08dcb4592438190f4a5c641daeac5ab9b96006d018a6e01e04ee", + "address": "0xd1ffa9ff507492844818d0d91bf35b93a7c95e4a", + "key": "0x4885a02db06138818497f56f6ef6f9611b1fe93d81f6d4a03dd83ee80a119ed6" }, - "0xDD9ee108e8d5D2E8937E9FD029eC3A6640708af0": { + "0xD592d2BCa2E78Bf7f3Ef341A2f6B8F0BF96343c9": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xdd9ee108e8d5d2e8937e9fd029ec3a6640708af0", - "key": "0x2a39afbe88f572c23c90da2d059af3de125f1da5c3753c530dc5619a4857119f" + "address": "0xd592d2bca2e78bf7f3ef341a2f6b8f0bf96343c9", + "key": "0x07891c3045a0c538a419a3c93f75a612f61a0d8be29aa478f990555ede27620d" }, - "0xDE1c2fC2e4Ee50F61a0Ee3758Bb67Bc468467F03": { + "0xD7678E32ceAc078dc261D151aeC9b898159E913b": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x6ce8bcf63e7a26264045680ee93464c00c1029a197aacc749391b7a840cc8697", - "code": "0x24259e866b89e445290f514548cfa7341e867e1c75b75575d8008246d6bf88796e0cbff4014bd643fbb0707f5e2c1ad686153dae9f96a33de90a5cb2c73f01934107dbec03e25a3a7041ae16c199ebe0c15cdfc958612c5bc8a87d743449bee7e7b26963c6a46bc669ee69f5ec3ddaa2b4dba8fb6c66bbf247f3096d559f5641849d57e96537ad7e37a5709b12dd8ea54383e2864ba1d0d83e2ffbde7f8a5fb5f6ddcb15ef525982aac03ef65faf2cb3fcdd8eb6b2a2b58c6bc2acd57989ebb44362cdde8131eaf20d98617619b09146ce4f5f53fe563db99ef97b050183da81c5072f4eee335da8bb992dd71959a7534cd43bcc582c57ed9631abb2f4d7bcc4", - "address": "0xde1c2fc2e4ee50f61a0ee3758bb67bc468467f03", - "key": "0x0243011ec33679195dffcf94a02eed0e26b589f14af470e55e798647b537c46f" + "codeHash": "0xb4930a125627ac818615f09e52738e8bd19f268bdfddc69da23bd7b4fb356d06", + "code": "0xf078381c098d7f56dca8447e60d28e39dabf16c4904f8d5980026cc19a6afa0bc7c87573e3262dc947d048fbb918b7a15536786731da04effd045b5a3482a16f9440d37190611706c0e4201f46f8693282307e769f69845197a9beef60e5f566af4553fd35816720fe0f3fda7c1e71383dbf00831aabef83faf4be5b7112ed159eae233279988a43ad0a99b0d0230f245ba8453a0accc9af91185b1ecd1a7116f29da813564266cccd5dc5a3c1b701abfaf5ac71f45fde4e18fcf60d7c41d5846ad5557a6f35d40337b6890f3b6f15a1e64adcfbc425b4bcb28ee67b2b920da212520cb5bf4d324fac63d20e3230854765e952834555d0e102dd85ff0e57cade", + "address": "0xd7678e32ceac078dc261d151aec9b898159e913b", + "key": "0x9fb96451e98ab7803d6bff5c91f131133a99711978a9a2b3bd5af43252869882" }, - "0xDeF9100B4510C563B2532EDDfC5dCDc82bb541f2": { + "0xD9c364A44CEF789017B5bAD4F17e197D079c76aE": { "balance": "0", "nonce": 1, - "root": "0xd45ccd3dd6bb0efbcc59566edbba5873ffadaa694d76582ad5b876b88f39b461", + "root": "0xd91acf305934a60c960a93fb00f927ec79308b8a919d2449faede722c2324cb3", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000008c": "8c", - "0x000000000000000000000000000000000000000000000000000000000000008d": "8d", - "0x000000000000000000000000000000000000000000000000000000000000008e": "8e" + "0x0000000000000000000000000000000000000000000000000000000000000153": "0153", + "0x0000000000000000000000000000000000000000000000000000000000000154": "0154", + "0x0000000000000000000000000000000000000000000000000000000000000155": "0155" }, - "address": "0xdef9100b4510c563b2532eddfc5dcdc82bb541f2", - "key": "0x9b6e7bfcd9347b45c94947acb6ddd3df4d228807ea09100b7a60b8c1b2aede5a" + "address": "0xd9c364a44cef789017b5bad4f17e197d079c76ae", + "key": "0x51c07e7aa8b36d37d8094e2bb6a81f3f8f275acdf7620f893f933a9ffb7d6377" }, - "0xE06751015cf69396708198F9Fd3fAC98367847ae": { + "0xE3A8b633a20D3Bc82CFD6d6cB315dD9784b3EA41": { "balance": "0", "nonce": 1, - "root": "0xd39ad83d4fc3df3ce208b6c0779e4d1c0138867bdd0a6ba4e49ccb45419e540d", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000013c": "013c", - "0x000000000000000000000000000000000000000000000000000000000000013d": "013d", - "0x000000000000000000000000000000000000000000000000000000000000013e": "013e" - }, - "address": "0xe06751015cf69396708198f9fd3fac98367847ae", - "key": "0x0610ba7a05912ec56deae88974bcc177dbce70b079adc9db6212f83a093a91c2" + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x6a95d1532ea10e01c45c3852bd1dc75cde391adb68e4c49179dcf4594b7750bc", + "code": "0x252b89bf90b319923f6559e774e32f611a27a81d0f532f5b807532a98a9da5dff6346df2f890680af66f02884a3534996812dc8641475d151d43319ca32915acdfb3923e257006c00eb45b8fd73a3468e2d76d01d6f08434ec78404b1eb39275fd55fc2e9ef63e16e696580fa41a16b1359de042d9d894f9176ffec1c194a98623daade2992486e297dc206712cf2981a43df9a70de4d5f3b59dea984dc1135be8aa0c96d7827d7f81d506691cca1eef157279cd2b906ec7a6ae523f2e4aacf9fd0f0a9f6943052f202072825110d2e71fe4569f7a80872d4befddcab68faab64571c490b675f7c0c08a6af51968eed01a2a796f37061d16506458d1631c4af8", + "address": "0xe3a8b633a20d3bc82cfd6d6cb315dd9784b3ea41", + "key": "0xa3f8196fd37c836d7a5bfcdd9807147e8d74957f5125bed4c6fe6da4e348dcad" }, - "0xE153E75b139632f5d13F19d5C66579D5d6813259": { + "0xE4f62e66DfCeD3f18080ed3080b276edaEF0E1C6": { "balance": "0", "nonce": 1, - "root": "0xff687feaf8718db6ab0fc7f8d1e2cfd9ef45928488fc3d578477cdfdcc51dd09", + "root": "0xfe629ea231aa00b09ac842cd51a4c63ced36a60cbbc2fd49c2891b67b38cfe9f", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001f7": "01f7", - "0x00000000000000000000000000000000000000000000000000000000000001f8": "01f8", - "0x00000000000000000000000000000000000000000000000000000000000001f9": "01f9" + "0x0000000000000000000000000000000000000000000000000000000000000061": "61", + "0x0000000000000000000000000000000000000000000000000000000000000062": "62", + "0x0000000000000000000000000000000000000000000000000000000000000063": "63" }, - "address": "0xe153e75b139632f5d13f19d5c66579d5d6813259", - "key": "0x59aef4df4fe449a1f7048fe2bcb680f4591eae75f45efe3dfca5febfe54d38d8" + "address": "0xe4f62e66dfced3f18080ed3080b276edaef0e1c6", + "key": "0x4dee48db6b3b08cbac1e06a9a3ad1d0100541ec9eafa2a1fc82e5d47ab763aa4" + }, + "0xE7d13f7Aa2A838D24c59b40186a0aCa1e21CffCC": { + "balance": "1000000000000000000000000300000000005", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "key": "0xec3e92967d10ac66eff64a5697258b8acf87e661962b2938a0edcd78788f360d" }, - "0xE3A71B4CAf54dF7d2480743C5A6770A1a5a9BcDa": { + "0xE8ab29bE268a4a4447e4f7bF0B5DA4AA4734AC1A": { "balance": "0", "nonce": 1, - "root": "0xd9302d64a423861c7b3ffa4e25dd32c407f472bda0e75c4da719b77a4c9d7424", + "root": "0x9a976e308ba6adecbca552a318a503b3ad99fbe0ba03c079bfb6244d3cd0e86e", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000011b": "011b", - "0x000000000000000000000000000000000000000000000000000000000000011c": "011c", - "0x000000000000000000000000000000000000000000000000000000000000011d": "011d" + "0x000000000000000000000000000000000000000000000000000000000000022f": "022f", + "0x0000000000000000000000000000000000000000000000000000000000000230": "0230", + "0x0000000000000000000000000000000000000000000000000000000000000231": "0231" }, - "address": "0xe3a71b4caf54df7d2480743c5a6770a1a5a9bcda", - "key": "0xe4d9c31cc9b4a9050bbbf77cc08ac26d134253dcb6fd994275c5c3468f5b7810" + "address": "0xe8ab29be268a4a4447e4f7bf0b5da4aa4734ac1a", + "key": "0x2f3f84580f03d8a347fdaafc9b6f755f314030839efe0886fc804c610cb37933" }, - "0xE43cE33cdB88A2EFE8A3d652bfB252fd91A950a7": { + "0xE98D9997c3d04ed1538a05615C00A93cdbBD3b53": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x037e70d89f4b730aac959986dbbfe0af1a286ddb31e1de05bcee64135e5c17cb", - "code": "0xeef53c6ca945792f947138460881b8ce441c90705cebd2ac63082b1a9dbb6d1ef15659e3492137bbe7b2a548a5ff636574ffc69b4cd7e9919fa8f0121846b7587f8a4e01196c8d8e8d7fab5763f17afdd953e7fd375125594fe15f4147baa966b31f12b3ea8a692474f7a878f34a0093e7342405a33cd6974e35402ae55fdcccdf0fed250aa631da36a99e614c87fd768ef2946f5a4a62890303785aab8ccc70c9aadf72d8055a8681a6e3890308b25746e822fb40031daa81d0d225a722d0fbb0a0135deb29f445269723c8cde0b5434bcd83acff45693494d6a48dfe22d505d01e0763a645edda4d609886f87b822dc86d428442ef174eb0085b4a201be63d", - "address": "0xe43ce33cdb88a2efe8a3d652bfb252fd91a950a7", - "key": "0xc157e0d637d64b90e2c59bc8bed2acd75696ea1ac6b633661c12ce8f2bce0d62" + "codeHash": "0x2d5da89dbc1dd4a72b762b0f02be2b019621e4eff4ae05cde7765f59fa027625", + "code": "0x59177b3ac362dfed2f5f2a6bdf40ad57c106ed436858a6006d6ca83c5f346676a29a965f7460be4b61c6850bfc18ee18bf45c79a5c6dbb1c0c895fc557ef5cb4cb1732e48e4275b8843ef6d2c0a17588ad394b156ef59f4f2f771abe2307b3f752b9e2a36c35aa2b44ce6c4b89f2a7aaf2f3fa2a112b48803d5b977a94749881440ceb88230bf2fc4edf65d2bb9a74d227c8a62abedec268e550d793dd5334e8ccd6890ea7087c2546c4c3d5264f04f94346973886db02cfa8794a31b759885d34861d98f8dcef653538193bb0f515950c5a7c054bd7a960894da70594bb33c5e71ff1efb43d93f85854e953bee84c0621efb6a50c7756c8f9231166a4df67f7", + "address": "0xe98d9997c3d04ed1538a05615c00a93cdbbd3b53", + "key": "0xd806336c4f3fbb4aac21b0058a7a4fbe4470832dd35ea3d5ee8a52a3fa870fe0" }, - "0xE52C0F008957444c48Eba77467eaf2b7C127e3C5": { + "0xE9B17e54DBa3344a23160Cb2b64F88024648c53E": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1973f7c92cddb2e8e1b1a679e0ccc4228c832fa0881e126e99d8c153768fe417", - "code": "0x23aec33011cec136936404546e8d71610b1ea813717b1b6bf3b77b689326a34bff8631e720139e221f6f7436289600a293ec800074eefb6074c9c4d3d71451d44f3b95b4e5f87ebaefd8697e1beeac39c49315154dac40afc4471c173e106006158cf96e390593ec3d9db70f55562909ef65f4603e50b9bf4a3df75ee2795f3069934b3c578097dd99f0cb0d2c04136fd8095c48557144cc40a978589e45b612072a01774dff6b43d7101e6ad7d329fe9af3407ec1356a898458310d3114a95c20874b0c906c478f1952ec7ffbf9ccb55019a08fb7b7fe98adcb0bbcfe4c582b3173396d1c155446a89455c4997640738bf81f11b8e7aa00d59a627e170c021f", - "address": "0xe52c0f008957444c48eba77467eaf2b7c127e3c5", - "key": "0xb888c9946a84be90a9e77539b5ac68a3c459761950a460f3e671b708bb39c41f" - }, - "0xE7d13f7Aa2A838D24c59b40186a0aCa1e21CffCC": { - "balance": "1000000000000000000000000300000000004", - "nonce": 0, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0xb1d2896c079496c392d81871dc5e4a7e8a1c80c3e19d90b9ce2a74982e45ee5c", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", - "key": "0xec3e92967d10ac66eff64a5697258b8acf87e661962b2938a0edcd78788f360d" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000174": "0174", + "0x0000000000000000000000000000000000000000000000000000000000000175": "0175", + "0x0000000000000000000000000000000000000000000000000000000000000176": "0176" + }, + "address": "0xe9b17e54dba3344a23160cb2b64f88024648c53e", + "key": "0xb4f179efc346197df9c3a1cb3e95ea743ddde97c27b31ad472d352dba09ee1f5" }, - "0xED61c537F1B4f454c46B2352069Fa6b42623C110": { + "0xF0A279D2276DE583Ebcd7F69a6532f13349Ad656": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xfc7ac100da7ec6df53d378321dc20b34177cca47f5ce7d6f640a7d377dba751b", + "code": "0xbed52935ceac91f9e56488c9c56a4ef4668325f0a4b3c9d4f59d0ca1f55873d4bbe9cd6f2ec3bfaf65e3dedea335e6580be1b90f02a28ba4334c14331d83537d461fa69d479e93c39ece03263cf3188143876d720ddc370708f917dd5a84899be033ac067c55ffa15276c1e7e852433fbe5b06aff21c9e12052d01007cfb4f63bbdfb9fbd5a250e303de7582d54b86c5073c3b3f8b2a52103e1be92f6afa665fda42636e2a248443cf028fedd444727b22ed1346bb793d0c53ce70ab162113cab28fc5200528140e039cbf5bb18ca2a92163357f6f90819a1a81c4fb0b7930fdda11920abf8ace283badaa3b53848cae08e30f173a07c3429625c5529361fb05", + "address": "0xf0a279d2276de583ebcd7f69a6532f13349ad656", + "key": "0x11eb0304c1baa92e67239f6947cb93e485a7db05e2b477e1167a8960458fa8cc" + }, + "0xF2C93BECbB050bA17dc9a2811A4d0DB97d0B1295": { + "balance": "0", + "nonce": 1, + "root": "0x2fd7b839f5613c91ae241ba33e03e781c11b821250bae1aa3017b2fe75bac3fa", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xed61c537f1b4f454c46b2352069fa6b42623c110", - "key": "0xfbf3a1231e6625c304d124d07affe93eb8815d22b5fd75d546c09dc1cfda9e67" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000203": "0203", + "0x0000000000000000000000000000000000000000000000000000000000000204": "0204", + "0x0000000000000000000000000000000000000000000000000000000000000205": "0205" + }, + "address": "0xf2c93becbb050ba17dc9a2811a4d0db97d0b1295", + "key": "0xe3c90ccc988cd8abee77974903c16cf47988812f0f862dac3a11f06ae963d388" }, - "0xF9062429a0c38F2886bbc72EC59Eb41041caE478": { + "0xF687d9CA2aCAA4DEe5f4BA6C1eF0c0B89205B92E": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xf9062429a0c38f2886bbc72ec59eb41041cae478", - "key": "0x3de2ace05e9ea0f0318554327d9809e6706eadd51f104b1235f40712070503e5" + "codeHash": "0xe5e61fa1465f3b1eb6e74632116b3766e24c61087fef3dc7af43dbe4fb3189b0", + "code": "0x4115ab6dee63da78950ac0a3ed6bebb017d9a5fc2e00608c82a3571125cfc38f12ee62be373328a28b316ed050591a9eac96ceb924246f86a1c0bc4f37d75b72a6bae38b5fd06c5ea81391e321be657722acd828b3352148b27a1ee3ea751aff6afc6c4beef433610998248245abb3600b2c2559a49a1cc2f3bf575b0d7b342613010f2857e6ee9389ef1e3b0d0d0b88a9cfb6ae9c58a9247e15c7e9334961e1888ab0db3616b32b3d0f09c88e675f52fafb0e7bbc38c0163460269ae83e6703d5e2e4e2abf6a871a9749909d2e6d5bb201405296004cedafbe5629981c69e1bfdc92b9060d7f6c40c01ce432c46d932dfb344659169a47bb9778e9ac38134ea", + "address": "0xf687d9ca2acaa4dee5f4ba6c1ef0c0b89205b92e", + "key": "0xddfb897c68a043e82b8d4d7751e6dd639066efea80cd177409faa10ae576676e" }, - "0xFb7b49bc3178263F3a205349c0E8060F44584500": { + "0xF75b18c1a92C6C6659b3211D45Ee8E1BEFBD3a6C": { "balance": "0", "nonce": 1, - "root": "0x5b8cce34b1c8ca497abd9d4baa011f924fabb467a2d6617c9cfd83a2c32a1aee", + "root": "0x818eaf5adb56c6728889ba66b6980cd66b41199f0007cdd905ae739405e3c630", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000189": "0189", - "0x000000000000000000000000000000000000000000000000000000000000018a": "018a", - "0x000000000000000000000000000000000000000000000000000000000000018b": "018b" + "0x0000000000000000000000000000000000000000000000000000000000000077": "77", + "0x0000000000000000000000000000000000000000000000000000000000000078": "78", + "0x0000000000000000000000000000000000000000000000000000000000000079": "79" }, - "address": "0xfb7b49bc3178263f3a205349c0e8060f44584500", - "key": "0xa03fe040e4264070290e95ffe06bf9da0006556091f17c5df5abaa041de0c2f7" + "address": "0xf75b18c1a92c6c6659b3211d45ee8e1befbd3a6c", + "key": "0x6da4870a3dd2d5ee0dd0f235e6c07caaeea1e6fecf182b68a908462d1dae3edf" }, - "0xa6515a495Ec7723416665EBb54fC002BF1e9A873": { + "0xF89374e8646084BE4525B8Da2E64aF316b570458": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x4a027c1ef8411fa885c9fe4e5a504ec57076b475c72c4b0d150b8d97906de706", - "code": "0x91d04e206f89145185d7c0a82618aa78fe710bc8a1b4b414b377926cf5e3a66be28502ad67d33d7274b03e765dd18f1a1ab4ba1c827c6d3e7a0d3ca492e6b46315531e88bae16d971c335931052549d408d7d05a38b4dacc091f6db9dbbb6ddc38d21990164d4d7df1f1c3adadd435da81121ed3ccf04d07098021ef81b4663045d505cb6581b7f15e33d93b5bbad62cb60fb8a720b633d8cb1906954b0943f218fe2baba04b04b843cd138489dc125d2854aec75ebb8a449c914ba035cd57fe923334cd90d34656991c6938c9e0b8aa7a8fca68f889521f05af1a847e16ec0dd52427a773bf62425ab36cd77fb888038dcf97aeef30aa680c9fcd289221ae32", - "address": "0xa6515a495ec7723416665ebb54fc002bf1e9a873", - "key": "0xbbdc59572cc62c338fb6e027ab00c57cdeed233c8732680a56a5747141d20c7c" + "codeHash": "0xdc443b3e953eaa80fc5b5ae5ed28a3771bb30b13eed51dcc72ca2b3ee6f12441", + "code": "0x1cb7ce0668e72b96f704af9e1445a9dc6f6ac599eec355bfcfe4d3befbb001be40165e7164257b249280bf839a50283d248062ed7b0e6d8820cb6c506bfcf7d3c0c7c7c9a2a6655862feea3cc7ff13629582293fcfe0e1094efb20897bb02a656a2b6bffaca788160f671fa62d34758b717f75a90ad5a468757c50d61f33c4437f6fa3f34639ea1891363ca773619dbd5f652d7ab50411111dde2f57e3ae13add1ccbf1f9f869f51cd81e6f099f905636b057f682c706fe990614b1120516928ee4750d043edce57577a49a1f0c4b389e3b8c38c27dc693bc6b7154c07280771f2e2385bc2a5be32198cd1e425186910eb1a233b2b2a22be149cee4dc72d0162", + "address": "0xf89374e8646084be4525b8da2e64af316b570458", + "key": "0x8a501498b71c00ef30dfb420ca71d286546a057bb13d56eb0e175c0e42c2f3a6" }, - "0xa956ca63bf28E7dA621475D6b077dA1AB9812b3A": { + "0xa12B147dD542518f44f821a4d436066C64932b0d": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x0fd8e99b1b4ab4eb8c6c2218221ae6978cc67433341ed8a1ad6185d34fa82c61", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xa956ca63bf28e7da621475d6b077da1ab9812b3a", - "key": "0xaad7b91d085a94c11a2f7e77dc95cfcfc5daf4f509ca4e0c0e493b86c6cbff78" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000014": "14", + "0x0000000000000000000000000000000000000000000000000000000000000015": "15", + "0x0000000000000000000000000000000000000000000000000000000000000016": "16" + }, + "address": "0xa12b147dd542518f44f821a4d436066c64932b0d", + "key": "0xae88076d02b19c4d09cb13fca14303687417b632444f3e30fc4880c225867be3" }, - "0xaD9Dad8a45e691B45a09e2CE5a88594A08f4744A": { + "0xa474Ce23d592a232C3869513A64834b2e723Ccf9": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xad9dad8a45e691b45a09e2ce5a88594a08f4744a", - "key": "0x90c9be68ba7502086f74ff43be0a2f2dff9baa9073fbccf73690addc0d93ee20" + "codeHash": "0xf0477d2d7456a060329028971c32a1049d112839ad6b9a8e0d41444144926912", + "code": "0x994debe1129ece54bc3e58d0080c657e4b57b49bd13c22d7c016ed5f3a59f29b4a8f2534811696fb7ed42c0b67bc755be8c4b58555c78db94a4c7b3764768107e7be31a9c65c0ddf13f554a0804c3b81ee1c5361cd94c5b1b0d3d4b42f09361c9a5f52b0aa8b858876d6b4ca6afd4df27bc0b2c0203007b759c631d3cfff3fc13fd38f8530aa5fa5e7a7e3bbcbf778be060fcd7938f51ba61c29cfa2d7317a0ae7931a793ebad246669683fe0c2c3600ca9cee55528b0b323e7c261585a013906a6a5810011038c63a76db6bb2409835d8bbd31c9732bb760cbdfa75d621b09a5534f9be7d15052a6dc35949bed0cb4fd90ba01e43563e9b5123d82176259e2d", + "address": "0xa474ce23d592a232c3869513a64834b2e723ccf9", + "key": "0x83bdc30d3ea7e078f2d487a9110f41e0f3fe3a9f7eaf48b9b2284b23993b0d70" }, - "0xaF17b30f5Ab8e6a4D7A563bDB0194F3E0bD50209": { + "0xae3b97067d3F027E8011DfCF496dcD1079dd12d5": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x9ed156eb2e3d2c3ecdc5fc9e4f54a5ba305d7d1e475ebd55d1f0bf64cffe5c15", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xaf17b30f5ab8e6a4d7a563bdb0194f3e0bd50209", - "key": "0x26ce7d83dfb0ab0e7f15c42aeb9e8c0c5dba538b07c8e64b35fb64a37267dd96" + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000023a": "023a", + "0x000000000000000000000000000000000000000000000000000000000000023b": "023b", + "0x000000000000000000000000000000000000000000000000000000000000023c": "023c" + }, + "address": "0xae3b97067d3f027e8011dfcf496dcd1079dd12d5", + "key": "0xa5bc78ba16936293e296c3d3e919d76eb953b28dc00c9852ca4987ba0c82c761" }, - "0xaa53Ff4bb2334Faf9f4447197ef69c39c0BB1379": { + "0xb787c848479278cfdB56950Cda545Cd45881722D": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xaa53ff4bb2334faf9f4447197ef69c39c0bb1379", - "key": "0xed263a22f0e8be37bcc1873e589c54fe37fdde92902dc75d656997a7158a9d8c" + "codeHash": "0x58571002dc11e8a8698ab7f378670c332e6832b49dd44a7de317c87969aaca99", + "code": "0xa46c9a5e42ee711d67cec634bfb278f07133f8b3c236b826c53d763ec9766625f1c66cd5ac352bee1084e866f7ef3ef0a14c943b098d4776ee3af92a090e1db21f3740a279cf2d77f66bcbcd8ca9363a902fba240cc78bdb7fdc53f368015d5a533822937425fd8b485f29fe6819cabe96466337e03c8bcb1508e67c7a9c0675040df0cfdbe2439420993d589140042c9218e6e20c99578d1a137f827725261d5e9d47962747e01107e18234d09097958f3f7626c12966c952111c0776febce91bc34baf0bdc39cb35028662cf837c92de8adfcc490dc213b82c0a99a2de03013191183bb78cf07513f1832ebb64acd65d49101ab3bce7606c66025fac20ea90", + "address": "0xb787c848479278cfdb56950cda545cd45881722d", + "key": "0x1098f06082dc467088ecedb143f9464ebb02f19dc10bd7491b03ba68d751ce45" }, - "0xaaAF6A159065e1df8848bAD2123ce201f914651f": { + "0xb917B7f3D49770D3d2F0aD2F497E5bfe0f25Dc5F": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xaaaf6a159065e1df8848bad2123ce201f914651f", - "key": "0x77f9408520acfbb12b62b72ca755db32798673aa3f13a27d4d72b5e5d9dc394d" - }, - "0xb42f46FA28a45E5d7ED2C6FBcf264be09A84b35d": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xf4015a92c21a43971b9daccd6b117d4bda8d0352cb2dffa3d2c0efa501043c1a", - "code": "0xa64ecc77bab92b6155b22af00b12afb654597705e4fcedbdecf5dc7272cb0f1f27a10e596b57a3dae1dab1396485571e7fc51fd56683e8c6f8517abac4c25fbeff399588cfa8d511a211e40c93169611693b7927d66122c83d455700805304135dd20ad87799fcce6db776139c19c898b9fa778865daa59dbe0bcba6f687140a6f8d38651f1dcccb2ffd8cee889c99e454fc3ecb2116512ff23076dc2d265910b2ab2ee89b347143724a865a498c0e338ae104e581dbd5f935efa1f13c842808eed4ee5aa0ba661a4be59fe47e33a2878d27cbc9c92c7053456f79d7567252f05d4e160575fee9c3345b17a5540abdd97c833048d80099370b0a86e8fdb4ca4b", - "address": "0xb42f46fa28a45e5d7ed2c6fbcf264be09a84b35d", - "key": "0x8eaa3c641bf0bced203401b48cad74dc2e5b5eadab6b21a275a0c90a226ced77" + "address": "0xb917b7f3d49770d3d2f0ad2f497e5bfe0f25dc5f", + "key": "0x65e6b6521e4f1f97e80710581f42063392c9b33e0aeea4081a102a32238992ea" }, - "0xb5435eFdaf27d2d95A4074d8a202Fe8605e93bc6": { + "0xb9B85616Fc8ED95979a5e31b8968847e7518B165": { "balance": "0", "nonce": 1, - "root": "0x50c6f81d76e16573b6164ad984d3383e480986fb380b3b49aeb5ded831297fe2", + "root": "0x89bde89df7f2d83344a503944bb347b847f208df837228bb2cdfd6c3228ca3df", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000060": "60", - "0x0000000000000000000000000000000000000000000000000000000000000061": "61", - "0x0000000000000000000000000000000000000000000000000000000000000062": "62" + "0x000000000000000000000000000000000000000000000000000000000000011c": "011c", + "0x000000000000000000000000000000000000000000000000000000000000011d": "011d", + "0x000000000000000000000000000000000000000000000000000000000000011e": "011e" }, - "address": "0xb5435efdaf27d2d95a4074d8a202fe8605e93bc6", - "key": "0x7d3eeccfd59fb913b7c1da576a38811506589cb0c082898306ac97727104a41d" + "address": "0xb9b85616fc8ed95979a5e31b8968847e7518b165", + "key": "0x6a5e43139d88da6cfba857e458ae0b5359c3fde36e362b6e5f782a90ce351f14" }, - "0xb609BC528052Bd9669595a35f6eB6A4d7A30AC3D": { + "0xbce2408DA01DC215E427B012d1a68546F5ffcDFB": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1df52e345118c81b3e417faae2407169b7143b97665088704492ebe68918af5b", - "code": "0xb6c77d91e1853c9460797543e6950962a973fa1ff748bd1983124d001970f0fe86752f6f10cf905e418968184a6649df48e5bb4b03fe0c6c30d4a92846800ae5120d6850bf2577eddbd2ee4d37824e28eb8583bd541f524a671400c5a7a4d0d343101321f77bc643f5acb4f9e125b12553e936073cee8dc5591c518fbdd9b31bfd12ab6661c66aa507572bb762941842d549de49dae1e273c6eff4353793382663751fa9514f6f7fc44151fc96fb391df328691d6b6a3752c0e99a8013ceca8537ce7393bde93f10df15acd9635be2b3c297dc27a2b26e7c8a093e1e7b56ff6c46d267957117ed5d4464f4be9f8d0298d446fb30aa03ae79a281755983f162ef", - "address": "0xb609bc528052bd9669595a35f6eb6a4d7a30ac3d", - "key": "0xe6388bfcbbd6000e90a10633c72c43b0b0fed7cf38eab785a71e6f0c5b80a26a" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xbce2408da01dc215e427b012d1a68546f5ffcdfb", + "key": "0x4db0b9725504eefe9b12857cf35dca9d90d6d07bb09bdc03b7ec1974de752403" }, - "0xb911ABEEaD298d03C21c6C5fF397Cd80EB375D73": { + "0xc147eCDF75298b9970440371EC57161bc3B8309E": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xb911abeead298d03c21c6c5ff397cd80eb375d73", - "key": "0x873429def7829ff8227e4ef554591291907892fc8f3a1a0667dada3dc2a3eb84" + "codeHash": "0x882d5843dd5d7da734663209498b3277b9f3847fc5cae00f2f18f8265805c347", + "code": "0xae64a54e96e21d5e6e871f7870e8711620e9d630d04b7524844b2de5b466d08aa739a51387ece9d9b8e11b8bf7e5909dc8f9657225a2c6da44cad2fed408c2dd2b68a083e1b3a60cb87c92e2ce191ad4d75579ade9934fe0d4304f1604243b84b01818f3e9f0631d183410281d3672cfa0e4d82ad4d20b2f4def7db9466081919cbbcd6da79a96e2c00832bdfed8cb53fa1ef801d1db5928e9d3c2c3cbd15933362c6fb4abf103d18f0c520f9fe75352cd942e2ab332d796e53c82787d53ca68a701929b14ac2d3f52993bf388c7bd2787e5382631ced5ceb068ae34d2902a7cee0b9e9b585169fdbe97147eee724f92c9ea9274b51e7026b85feb6d32aa4a96", + "address": "0xc147ecdf75298b9970440371ec57161bc3b8309e", + "key": "0x5bf8b42134cc2ee0654bfb8cd3f7fb4c1bf368ca51f2cd923af8eb1d7c41598e" }, - "0xbA015A43CbAD870109287840657E509A8341430a": { + "0xc36e899Bc3c312869B146c3B2B28a0814FfAbad8": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1d14dc1aad6545eccef12200b1d83eeccb7348e9efd37e3746547dc73319afcf", - "code": "0x6e114c97b74d78d3fc0453a7d40bb97c3b4da8bb89f0980f5e4234e1f334ec84d4fbf7701c97d78140335cb7a734885ddc620514a15e05dbfac5539c2e57005b4b399fdd2bd107baa82b219995c39b6fc0ea647f084bf576820030b40ec5eb1cc5a384a96c46160234a4c0a6841ffd094db428a8c4daf7fd60b8b3a2ec664beb2e4a5db9f6476a273a6466f6797062bb465d865a212e1a73b871f554b9505f849b837c8b3dd4ff54aa4bc7a8e72175cdf3090b5f77b8bbf2a981c389876ba34efc97c68684fd6376bbc41389aefdca942921a4974c57e664af0fefd08944deed5a7db4128d556fcc54111e0c2d693821e2cc01fc3dcce8e3a8e72c6393e2e68c", - "address": "0xba015a43cbad870109287840657e509a8341430a", - "key": "0xe49c3e4a107c2ab2bb5eb9f7830765501c0d2ba62d3bbdd3893ad2c6c7988e1a" + "root": "0xc784c4978b7142c2f59d78be0ea1f14a39ffec9c512f9bbe75703ef7590970cc", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001e2": "01e2", + "0x00000000000000000000000000000000000000000000000000000000000001e3": "01e3", + "0x00000000000000000000000000000000000000000000000000000000000001e4": "01e4" + }, + "address": "0xc36e899bc3c312869b146c3b2b28a0814ffabad8", + "key": "0x01e4f3a112f7034fdcb78c6ab534de5391d2c0c3772d641f69d1465e7a0bfa1f" }, - "0xbA28562EAec75C2a24AddcdcB48b652a1D3d796a": { + "0xc48c3d6FA1afa2c203EBCe7d58f46CEE0c74AE2A": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xba28562eaec75c2a24addcdcb48b652a1d3d796a", - "key": "0xf4f027863d66e0e04cac2d1b0bab3ce723d96b75cba02adfd94ec1aaac5f2e4f" + "address": "0xc48c3d6fa1afa2c203ebce7d58f46cee0c74ae2a", + "key": "0xadc8fbbe07e1a1609c3b54342d036f018af4d93ae59dd4425f6244f5949cedc2" }, - "0xbE2b071590A1AEdbAe740BdA19589961eA8b90cb": { + "0xc7a0a19EA8Fc63cC6021Af2E11AC0584D75C97B7": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xbe2b071590a1aedbae740bda19589961ea8b90cb", - "key": "0x913a945d006f413415a63ff0e57fd2fad9ffbfe8857259722a0151b119f95e8e" + "address": "0xc7a0a19ea8fc63cc6021af2e11ac0584d75c97b7", + "key": "0x86d03d0f6bed220d046a4712ec4f451583b276df1aed33f96495d22569dc3485" }, - "0xc672A4A5736BF99939A58C779E8574426ec2cb51": { + "0xc9823569b2E62F92B406e70522aDEEe24E23a827": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x75de76446047b5ca099fe7a60a63ca86f78a280755e4b047d9e0f6ab5a3c8768", - "code": "0x03a2399dbeda27cb7b00f2bfdc46f625dc0d6ae1d1ae296eec64981420d7379f0f3712e63236af36733b72c796625945c9773de445465c4fc67079d0b2e58274ef975306a7f41285be2b1dbd58511cc28e1ba38da8aa9340702e3ef450eb792d74a58ce557b85901a0b85724f38fce3ea8b9f9a3989c57d19c477401a276956ceab7b9199383d8854ef3a3f8fee3f1e19d8bfc85e865c3273d04fc662b1ce3bdc3aa7b16422e3d10217b011900f49bacef88cb7c2a404a290e330e33c4bcfaeea29fc3afaacd35a28d15a491bc01bca5199d6323fa7cbb82b966837ee0fcb0c3a879e17a65faef645fad8f5e188dd2ff408303922ad6e8d1183345917dabbe25", - "address": "0xc672a4a5736bf99939a58c779e8574426ec2cb51", - "key": "0xb7ff380fe56a4b74a8253a904b912204c0421a68d57b0c2251eac54ee7d1edf3" + "codeHash": "0x84605622999eb7f957084085b52f1c7b7409059ca2e8b3560e3d02be973114d3", + "code": "0x538474d0f64483776ed44915f71ae7f0bb8a622d35cec6d7f58631c690c1e43e334c7786e3bf81676e3a0d3736526c15df34c509bc9c3d422872d2fcec03bb4c0ee5eb80d8d139aa8aaeff0e93c5d082f8a95ab74e45ba383f83aa303ed7b715851c0a6dcea6d9c0b20e1d693e72bc7e402b6eed6a9bc52d715e1495b07edd2e4ecaefe56730f3d4c9899e811fe6b6866094124a9e94dd77caa81d8bd4d8c1ad53e6bfe60438140020269ed9fe5e9e4479f1629f851a14a4608433a904faf5c8171873f192ebc553c77ac3d91f610d9b3b5d968c33b2894a4af1d74d93346ae36c531230b5ec6213920791b4b9121f927f751c23cec4b3ac966fd3d1d6d970fb", + "address": "0xc9823569b2e62f92b406e70522adeee24e23a827", + "key": "0x683b6c03cc32afe5db8cb96050f711fdaff8f8ff44c7587a9a848f921d02815e" }, - "0xcCF0b963A645abe7b67Aa6E95AEA73FF9E0576CC": { + "0xcC29d71a7dE378E9Cc11541B48a5F4E79157673A": { "balance": "0", "nonce": 1, - "root": "0x54d96c4ece0ea7b8fb4020944003566809100c43a61883d7edaf155e10e9c7cc", + "root": "0xf82bf2c4bf4eabb1dc579d5ba1f80bceb690e6d41bec710f78acffe87543f186", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001e1": "01e1", - "0x00000000000000000000000000000000000000000000000000000000000001e2": "01e2", - "0x00000000000000000000000000000000000000000000000000000000000001e3": "01e3" + "0x00000000000000000000000000000000000000000000000000000000000001a0": "01a0", + "0x00000000000000000000000000000000000000000000000000000000000001a1": "01a1", + "0x00000000000000000000000000000000000000000000000000000000000001a2": "01a2" }, - "address": "0xccf0b963a645abe7b67aa6e95aea73ff9e0576cc", - "key": "0x2c5f586f46056bc6b891f7ed71cbe787e6f4839646e44d67e5c0bd737ff7154b" + "address": "0xcc29d71a7de378e9cc11541b48a5f4e79157673a", + "key": "0xb545359603802ec567ddb83b02a16e420860ab3daea52f2530a94b02d9129bba" + }, + "0xcF26B3672851128B3d41e65C7c8563CA54837Ae1": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x8d694036b187e12b604aeaafd52aa967e7f7d184df20fcb1c8c234eea6631a69", + "code": "0xa3782a2fe6ea312a811ac4c42fe7783faf92d4cb89cfcb3782e3fa260888489023903e96f7ccc3c321ee90eaffc37f489d842d55a6c8ffa1ddb161af2d3fb72fda50f95f737dd96a2ff448425767f58b49e6bc691060be2dd7aee3b8374d3aa362d3caefc27072d8a29831635245f4b528ba9b3356b77b4a38e93725f0197aa02fb2ea1f5bff21afae24d3f3e60076cb2c3b5b5ab20a71202cf9d49fa1606d4a701b5d687eb62af0eb18eb02d71426f2205884f5e7acc1bcd7b47c1b498ea8c95ec353220bc9ea0f081d44c7fbe1f97d75f2b74a0c416d06ce7cc6ebc553754a26382593f450ee34359d1d633b07dd27a5a9c2d9d495db1f1762692243a2641d", + "address": "0xcf26b3672851128b3d41e65c7c8563ca54837ae1", + "key": "0xdaceea0041b683170f8d205a0ccd2c5e01ebe604b5731f89bb6c8b8a0f9ea776" }, - "0xd48171b7166F5E467AbCbA12698dF579328e637D": { + "0xd15ec528baFC44EbbA397415Ca5340a5C2B4f417": { "balance": "0", "nonce": 1, - "root": "0x944f095afbd1383e5d0f91ef02895d398f4f76fdb6d86adf4765f25bdc304f5f", + "root": "0xef3164f6238d01061c0559193be70618658b742eec056b27996308eef51b95a6", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000081": "81", - "0x0000000000000000000000000000000000000000000000000000000000000082": "82", - "0x0000000000000000000000000000000000000000000000000000000000000083": "83" + "0x00000000000000000000000000000000000000000000000000000000000001ed": "01ed", + "0x00000000000000000000000000000000000000000000000000000000000001ee": "01ee", + "0x00000000000000000000000000000000000000000000000000000000000001ef": "01ef" }, - "address": "0xd48171b7166f5e467abcba12698df579328e637d", - "key": "0x188111c233bf6516bb9da8b5c4c31809a42e8604cd0158d933435cfd8e06e413" + "address": "0xd15ec528bafc44ebba397415ca5340a5c2b4f417", + "key": "0xcde608490277d1ddfe34418396fab0c8a7bd0bf5a1bbe962ae0f5f13453c6213" }, - "0xd778467Da3D250d74009a0b24A77ec73fE459164": { + "0xd24EF00a6c137ecA8067377de36F76836B8c7EeE": { "balance": "0", "nonce": 1, - "root": "0xf120c3cc3618eef211a028a99d9f010cc498a79097042dff780391ec3563ad51", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001d6": "01d6", - "0x00000000000000000000000000000000000000000000000000000000000001d7": "01d7", - "0x00000000000000000000000000000000000000000000000000000000000001d8": "01d8" - }, - "address": "0xd778467da3d250d74009a0b24a77ec73fe459164", - "key": "0x6862961bf74f98147405d296a8f9d9147a02013a4bebb049a171715de1a58963" + "address": "0xd24ef00a6c137eca8067377de36f76836b8c7eee", + "key": "0xa3b7b9153d8f3262ef97bbfceab8bf6e2ee4e2a8d35a6042f6a5cee83415c53a" }, "0xd803681E487E6AC18053aFc5a6cD813c86Ec3E4D": { - "balance": "1000000000000000000000000500000000007", + "balance": "1000000000000000000000000200000000009", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", "key": "0xe5302e42ca6111d3515cbbb2225265077da41d997f069a6c492fa3fcb0fdf284" }, - "0xd9c035E32F69DaB32F382F4ECA08ac316CB4fa4d": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x91490c55fe9d257ab92ee7c14d7614e4ce7bac6f9bb136427a3c67df010b8761", - "code": "0x941a419570a1ac7361c777110e70919980aa20af68c061451b272502d1c7bf877d3fa8f5cca21f050296be6b1a18825e0663c16cf7abb5263fd97a7042f1a7019aead984481533ddc3e1804cd415af4859e5a9209b3e78027e9504b13edc4bf9726c0239d8143fcc34d30ac6ef3f6e3a51e31b0bb7a03ff559c40434071fd48d080207eb7481f12bdcb87a64d5eef86a69742a6e85ca5bc6cbd6493c6f955c00563116b304f60034ae594a61486cd49541585ff56c84c5873e3fccb3f79c188f93526f8eb108615ff025803e1a91a242013880017345c667ca5624ba4a4111579881b6eeebb8651e1bf8e3463186d9b28eb3683206809622f3c6655c5386ebe1", - "address": "0xd9c035e32f69dab32f382f4eca08ac316cb4fa4d", - "key": "0x52ee830cbf07cbdfef612efc7475e16c6988d86442e32f31308d7c52d509a394" - }, - "0xdeD53dD3E21f2A1F750807aFeF8c31053485bb28": { + "0xdA3802907F850f9b6672fc38512ae47A5778d8F9": { "balance": "0", "nonce": 1, - "root": "0x86d6eca3c02c7902d9cb8308a979bb0328be4246d716a06a40304ae5fc4e8e74", + "root": "0x08495c2510c9eb2578041ec50625989b745ca0b18742fb33e6d5ee5f08e4c6f4", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000110": "0110", - "0x0000000000000000000000000000000000000000000000000000000000000111": "0111", - "0x0000000000000000000000000000000000000000000000000000000000000112": "0112" + "0x000000000000000000000000000000000000000000000000000000000000008d": "8d", + "0x000000000000000000000000000000000000000000000000000000000000008e": "8e", + "0x000000000000000000000000000000000000000000000000000000000000008f": "8f" }, - "address": "0xded53dd3e21f2a1f750807afef8c31053485bb28", - "key": "0x323982bb110cddfe49cc86eea33d47fa410394e47cd185814cf8e3d7573b216a" + "address": "0xda3802907f850f9b6672fc38512ae47a5778d8f9", + "key": "0x1d136ad5e4cbb5095ef8259a310816109b06612ac83926e67e27142ce2bc76de" }, - "0xe2FF4E7E4A28D327B030800BB65149d843D82d2D": { + "0xdC60D4434411B2608150f68c4c1b818B6208AcC2": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd4b553aed9df4bb81dfec99c249dbb99fb7beaef39f870cded5fe5719a809f7a", - "code": "0x0dda8da39b09c5d12be3408433542bcb85e79c16e9fa698274be0a5f5c0de0fb9155f2118833bf042b9dc03ff0b395208526fb6aae0ce96bd5b48743c48f179e14f494c65b48b2269e6f5785daed2174329ff45233af29f1ab57a83ec298b66135158e6a4d60ba7fad6584323785917414cc012686456fc0f2439c277bd05cfc9c989adbdafe30987e6fdc03d7338cb0c4591d695fc239ac5a81ff2f8e808e27ae2e9d1466e10fd686cfb1a2f8b60d75f9fd753466b824829dac49112d9496996c44c6278aa5f1fb3b169e5ac7fc49bdcfc3e1806375d1855254212e157be3bf1325408048277dccf4ad3c883277c32a60bc62de3dc708503358ea4b20f98206", - "address": "0xe2ff4e7e4a28d327b030800bb65149d843d82d2d", - "key": "0x911077c76a4a16f33df9c81d27b2ca80256a7141e83339fc2f18948313012e2f" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xdc60d4434411b2608150f68c4c1b818b6208acc2", + "key": "0x8510660ad5e3d35a30d4fb7c2615c040f9f698faae2ac48022e366deaeecbe77" }, - "0xe7B2CEB8674516c4aEb43979808b237656aB3B6B": { + "0xdd579A11208B91980dD1cAAeD24bF04C432Cc863": { + "balance": "0", + "nonce": 1, + "root": "0xa203e4c08093be9ee80f3b95c741037314e0e38cb8fa234683fa40d39ad23e3f", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000020e": "020e", + "0x000000000000000000000000000000000000000000000000000000000000020f": "020f", + "0x0000000000000000000000000000000000000000000000000000000000000210": "0210" + }, + "address": "0xdd579a11208b91980dd1caaed24bf04c432cc863", + "key": "0xe34709ccbef05a4a6e01c3e0201fd1f14abe53c2eeae29cd185c78a25936d805" + }, + "0xe57ef4A8da86f1ccd38ce12e3FAbe819fAa0a95B": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xe7b2ceb8674516c4aeb43979808b237656ab3b6b", - "key": "0x75d231f57a1a9751f58769d5691f4807ab31ac0e802b1a1f6bfc77f5dff0adbf" + "address": "0xe57ef4a8da86f1ccd38ce12e3fabe819faa0a95b", + "key": "0xe69a86b4c8c8a9836fdd2617fbce1d746e4bd63be4f1a1d5cc5ba1f0f409e780" }, - "0xe920AB4e34595482e98B2C0d16Be164c49190546": { + "0xe6dDdBFFDE545e58030d4B8ca9e00cFb68975B5D": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xf91b587fa3d345550ae9b246a788e2f668bf8df9071d8b4e3f07594a52791925", - "code": "0xddf72b2f62b0846ca7da60f0df0f94cdb28e603ef5291f65615841a7468c44c0710244b60ba7c1bd35ceda568c1c62624e99f11696da5612c84c7901031a9ece682e02e2fdab880917c319130d538d88dd4ea8d4b55431d219c9fc1fda9de93cc441712b999ae1b5f312a9513edfd8374c171ed2e13f457312b48a6118e30c586c90643f346afd56f022a6ddf0199dca4d55558c4e0c6b438b89dc77236b62238e8fc62d2064391f7b9dfc498260918dda58b2fadba062c23c105952e10f766b5a9adcc69eddff3413d21062a8f00e1b55efcbb4b88e08038f348ea9bf741c6d8060c339d013a28259483a9bbf8245b3f2c21722b238902c8756e3fa46291ecb", - "address": "0xe920ab4e34595482e98b2c0d16be164c49190546", - "key": "0xd623b1845175b206c127c08046281c013e4a3316402a771f1b3b77a9831143f5" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xe6dddbffde545e58030d4b8ca9e00cfb68975b5d", + "key": "0xa0f5dc2d18608f8e522ffffd86828e3d792b36d924d5505c614383ddff9be2eb" }, "0xedA8645bA6948855E3B3cD596bbB07596d59c603": { - "balance": "1000000000000000000000000200000000000", + "balance": "1000000000000000000000000600000000000", "nonce": 1, "root": "0xdd43fc82ac338ab2ee3c6203da0c8f16e893e6c37720b37ce8676f0e7c68bb05", - "codeHash": "0x3eea9094c21233d71a12df13d1f911a5f47d133c4c828a74089984eaeecf2640", - "code": "0xef0100417fe11f58b6a2d089826b60722fbed1d2db96dd", + "codeHash": "0xa5bafe820ca694bfc931cc4609c353b2311ac0709de1742204fbe051bfe9388a", + "code": "0xef01004dc5e971f8b11ace4f21d40b0ede74a07940f356", "storage": { "0x0000000000000000000000000000000000000000000000000000000000000000": "696e766f6b656400000000000000000000000000000000000000000000000000" }, "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "key": "0xabd8afe9fbf5eaa36c506d7c8a2d48a35d013472f8182816be9c833be35e50da" }, - "0xf068AE4089A66C79Afe47D6E513F718838D8f73F": { + "0xf34dA0E707b69512ca5e87e29021E6E6dC81C5Dc": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xf068ae4089a66c79afe47d6e513f718838d8f73f", - "key": "0x37310559ceaade42e45b3e3f05925aadca9e60aeeb9dd60d824875d9e9e71e26" + "address": "0xf34da0e707b69512ca5e87e29021e6e6dc81c5dc", + "key": "0x6030160e6fde23dc02e472d8865d4601485d1a935bf320bda5f7587d194c6be3" }, - "0xf11Da605c7cE2BB45FDD1117c7A7744F505eFEa4": { + "0xf41f36C9D43AD24Ee6De564215C047b66db1d391": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x5a82aff126ffebff76002b1e4de03c40ba494b81cb3fbc528f23e4be35a9afe6", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xf11da605c7ce2bb45fdd1117c7a7744f505efea4", - "key": "0x4490d5539df3636dbe295411ff92b662bb12ea3656f46fedbf5625af73882277" + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000004b": "4b", + "0x000000000000000000000000000000000000000000000000000000000000004c": "4c", + "0x000000000000000000000000000000000000000000000000000000000000004d": "4d" + }, + "address": "0xf41f36c9d43ad24ee6de564215c047b66db1d391", + "key": "0xfffae3923d4ffa22ca4150e83647a3f7a442233f4f4f6d742028c3f62016da7d" }, - "0xf820E25fAA00515571CFFa390f2fa3E96B0b5c6a": { + "0xf60c9dEeF62A32528b0b4652093b8B260a208827": { "balance": "0", "nonce": 1, - "root": "0xc7839c3366ccfac78f919d8471358021b5b7d493e6532c52efe048ff2da0af0c", + "root": "0xb7ba1d0a5343f51a519e9545efa1a5368a6d3c59a7e4463e3744c30ff35bea20", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001c0": "01c0", - "0x00000000000000000000000000000000000000000000000000000000000001c1": "01c1", - "0x00000000000000000000000000000000000000000000000000000000000001c2": "01c2" + "0x0000000000000000000000000000000000000000000000000000000000000111": "0111", + "0x0000000000000000000000000000000000000000000000000000000000000112": "0112", + "0x0000000000000000000000000000000000000000000000000000000000000113": "0113" }, - "address": "0xf820e25faa00515571cffa390f2fa3e96b0b5c6a", - "key": "0x7e1eec4a63dcc09bf241883e29bb53e7c377c1c0891a1b0189bcd411b20c0738" - }, - "0xfAbE26BC448a25eC56FF9360b19B66d56BaDFf51": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x605a56872757b687e70b0a8c3c3bab8566722172023e2c89b8be7ca0601ddf87", - "code": "0xc189f84ce68d330a8fdf55d40ed2705c7b14e02dd92ac2ee8966971c2fb56ec7ead8f6c0653ac108e89227cbe7425f3b89d61d55b92d8aa75cefaf308a8fbf7e8622f55c65610f385e1d95c8f07ca152f97aa824081a0afcd103f33f6b8ca72a33871796b7313fc5499b1f5322d50f5058acefe7776b255179bf9ae1e55602027173dcd6a2b7fe9242f4c2bd4b2c88cf749fb25984608228bc83697bfa7eb5b471185a1ea5a896559cd0665d0979f85c835265f180e74502f783bd7a192bf63fece6665d217127474d08619b555ba7cf850c9566e44f26045fd57ee3fafe0590e674d6359c3bd263fc88d21d87228700bd819a703993ffdb575906e5517cd01d", - "address": "0xfabe26bc448a25ec56ff9360b19b66d56badff51", - "key": "0x7b5d2a2cc2dee3a5ba257d9324d8772b209ed8ebc559c73dadd32af002df621e" + "address": "0xf60c9deef62a32528b0b4652093b8b260a208827", + "key": "0xd0fb2f31b364fd56c16154fe421ea6f768a5fb87c7f0e20b4d689b6816c4d8d7" }, - "0xfCE0CADC18035c4a6FE8279165277788826591fB": { + "0xf61ac2A10B7981a12822e3E48671EbD969bCe9C2": { "balance": "0", "nonce": 1, - "root": "0x14f9f4b9445c7547d5a4671a38b0b12bbc0e7198c3b2934b82b695c8630d4972", + "root": "0x15590989a348b65eb16aa3f8d2584fb877e412a1385225f36c247b6399764c90", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000126": "0126", - "0x0000000000000000000000000000000000000000000000000000000000000127": "0127", - "0x0000000000000000000000000000000000000000000000000000000000000128": "0128" + "0x00000000000000000000000000000000000000000000000000000000000000da": "da", + "0x00000000000000000000000000000000000000000000000000000000000000db": "db", + "0x00000000000000000000000000000000000000000000000000000000000000dc": "dc" }, - "address": "0xfce0cadc18035c4a6fe8279165277788826591fb", - "key": "0x68bda3bd48de9803b2a21ffd518bc8aa99a56d7eb40cc8db1a6bf803b8693be5" + "address": "0xf61ac2a10b7981a12822e3e48671ebd969bce9c2", + "key": "0xbfe5dee42bddd2860a8ebbcdd09f9c52a588ba38659cf5e74b07d20f396e04d4" }, - "0xfcb2A3a61D3De12F554db60494f13e9477F31a2f": { + "0xf8C11c750ab2B0276A272F875857cf535aBa2Fd7": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x302c2cdce1f556b5053afca77878c358d2492d7745f5cbbf9db5761df20db001", - "code": "0x50ba73278bbf571a271f39357d381d2f5f97b7d5b6a23b684b7751eddba38718b712f55a8405e8766b7610a3b707f0ea903b826c8623fa2624da135a56a422ebb8b9c4837d54a5d26c8f7e03d3b9cd37367cb9ba2a74a2e4e571a0b453433473fcbc0922eb3255790a824facc22abbf7bf018597c0700c13a6df4a019b75b3ae9ffad69f84083f437fc88821853a0555fc46dd72c6c7dcb209f949f252909fdcefff4d220e7779831f23f8b0cb0449a9525f4c42705a5e35acfb5cc1016cf81b8e7bd63088de20dd86bdf2b9ba56bd140f59161a5d05abb70bf55a82cda068e494152e7cadd4eba05f59e9c2118d2ed4e1d9e020bb8d2b37c15f90576f810742", - "address": "0xfcb2a3a61d3de12f554db60494f13e9477f31a2f", - "key": "0x678bb0d1fd0696bae4b7e06994861242bfbfe332bc030c15ab9d33c26eeab13c" + "codeHash": "0x909e99eac3d2f939aa3734152690a23ff48fe70e0bed64695466cd46b583c4e2", + "code": "0x5a2ec50db2ca06446b795168e7be7507522174c31903d424779360a3b6f0ff978162d6cc32dc75b44adf81a1e9dc0ac7f7be79fef38219137739c8af5157a313b64fbcd928f024c431e809fae07258ca41432c098236d3d43c3c8e52253217b6eca4505ea32ae1a4ee824c5255e38a00422c023b789b59b6ce92c6731bc698919de437229a9a5b71b813b2ca574feb648a19bad8f1978fc540dba421c3042f6c68eb1985abb1bca8cc77a9e3c4ceb1ed4b4c857374b7d6d3773b5c340a823c929ed76419063e05b6bd3c4b2b3da7ac5fb72330fe54743c0f00a9c1ac8afb46aed84e31a70eda71f01446d3305fdb4ca4341833b4481c4ad865d2e6179edbb744", + "address": "0xf8c11c750ab2b0276a272f875857cf535aba2fd7", + "key": "0x603aef023d668fbda50a2b26e37969e2ee93b68d0e6f8abbdf7b6f6183a9c09d" }, - "0xfdB19A177ED1B386d141e392B7A27467469fAbB2": { + "0xf935652dc257EF89c33B2488BB18E2d068Bd35f6": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "root": "0x6d9d3f86b1f8f8e94248f307137ef85b10a1d57a5ac60aaf227e8cbfa2224db0", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xfdb19a177ed1b386d141e392b7a27467469fabb2", - "key": "0x7cf2a82cb777b7aa435dcddab99299165f8e46c83c1f9bd50206e428074143be" + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000127": "0127", + "0x0000000000000000000000000000000000000000000000000000000000000128": "0128", + "0x0000000000000000000000000000000000000000000000000000000000000129": "0129" + }, + "address": "0xf935652dc257ef89c33b2488bb18e2d068bd35f6", + "key": "0x20c6bc4ddb42f343ae3b98e9efeb1dbb7290009b8975fbeb29125e771aad2414" } } } \ No newline at end of file diff --git a/cmd/devp2p/internal/ethtest/testdata/newpayload.json b/cmd/devp2p/internal/ethtest/testdata/newpayload.json index 0e18cd85259d..b5327ae81629 100644 --- a/cmd/devp2p/internal/ethtest/testdata/newpayload.json +++ b/cmd/devp2p/internal/ethtest/testdata/newpayload.json @@ -7,17 +7,17 @@ { "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe5d8b049a78427be8c23ebd6811ed436b3a36cc117954b496848b90f0c654844", + "stateRoot": "0xdc43f460541a253c0f64b6943ef83fa3bd601699a255622f088d46f7fde359fc", "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x0", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x0", "timestamp": "0x0", "extraData": "0x68697665636861696e", "baseFeePerGas": "0x3b9aca00", - "blockHash": "0xe5850a454eb99a0b5a4393fc9b4b3e02f8daf8079f828f76c307936006d70b1e", + "blockHash": "0xbd6a252af394d80904c5993b859574bd4669642cea00a116970ec7887db67533", "transactions": [], "withdrawals": [], "blobGasUsed": null, @@ -31,19 +31,19 @@ "method": "engine_newPayloadV2", "params": [ { - "parentHash": "0xe5850a454eb99a0b5a4393fc9b4b3e02f8daf8079f828f76c307936006d70b1e", + "parentHash": "0xbd6a252af394d80904c5993b859574bd4669642cea00a116970ec7887db67533", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x950aea7b35a0d9e8f81dfdc3387fa12aa4d4f8a043f3341de7e9002933ca280f", + "stateRoot": "0xf23e00fd68672e8e166a481663b147dad44c25bd30f8605d2f3c7a070881fddd", "receiptsRoot": "0x97a526b2e32116d208b71a92e95e23a6734f413a15a057d122b5983acf25f8bc", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xf777", "timestamp": "0xa", "extraData": "0x", "baseFeePerGas": "0x342770c0", - "blockHash": "0xbdd7b3e2623f0903d9b0f4c50c161837fc61ee01feac041001f5c5dc75337423", + "blockHash": "0x728bf4239628d65246678bb48fbf2548facfdbe47486e28e87ca1b77a86574e8", "transactions": [ "0xf8938084342770c1830131348080b83c600d380380600d6000396000f360004381526020014681526020014181526020014881526020014481526020013281526020013481526020016000f38718e5bb3abd109fa04bbfb315c19415b5e39df54c30c5a0c8d5e8100fc5e245e67623ff20dd8390279f0a29f1401eec72972b601f590b17c904db69e9ccf3e10384e4da572788269b" ], @@ -59,21 +59,21 @@ "method": "engine_newPayloadV2", "params": [ { - "parentHash": "0xbdd7b3e2623f0903d9b0f4c50c161837fc61ee01feac041001f5c5dc75337423", + "parentHash": "0x728bf4239628d65246678bb48fbf2548facfdbe47486e28e87ca1b77a86574e8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe155278d003025157bb43b08603da00313c14aa9f10710e72b72d69284382afb", + "stateRoot": "0x824f43a809d85b58ea76a4b1e0b378ac704e341024a50281deefee50c7ba6bff", "receiptsRoot": "0xe078709b25bc275a65cecf4c9c5e192aa3c2cbd051b6a35279c391a3ee4d597c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x115c7", "timestamp": "0x14", "extraData": "0x", - "baseFeePerGas": "0x2da81e94", - "blockHash": "0xfacb55d35b1efa3f38d8c066ad6684b329755ad2d34f7029ae5c7c6bbc8a6ae8", + "baseFeePerGas": "0x2da3371a", + "blockHash": "0xd75c28fbfeb77a45bdc1ed85b91cf830153e50fbb1036825f2ab229f28f3ebc3", "transactions": [ - "0xf8b801842da81e9583014f7e8080b860600d380380600d6000396000f3366002146022577177726f6e672d63616c6c6461746173697a656000526012600efd5b60003560f01c61ff01146047576d77726f6e672d63616c6c64617461600052600e6012fd5b61ffee6000526002601ef38718e5bb3abd10a0a045dc6b6d59b0f906744f1d09ea500ceae82dad075a9b0868b7760966ff604870a0464b4a826cb475452d2587b8a67f0e48c98b55adef2558cd5eaf60c181a32afb" + "0xf8b801842da3371b83014f7e8080b860600d380380600d6000396000f3366002146022577177726f6e672d63616c6c6461746173697a656000526012600efd5b60003560f01c61ff01146047576d77726f6e672d63616c6c64617461600052600e6012fd5b61ffee6000526002601ef38718e5bb3abd10a0a0f4897823b552e75cd776e2271125e4b41ede67fac987809d31ed26e67204f7b6a01266df0c10c05ebae5cdc9868300926a503086397ac76a214c2843f63bb08730" ], "withdrawals": [], "blobGasUsed": null, @@ -87,21 +87,21 @@ "method": "engine_newPayloadV2", "params": [ { - "parentHash": "0xfacb55d35b1efa3f38d8c066ad6684b329755ad2d34f7029ae5c7c6bbc8a6ae8", + "parentHash": "0xd75c28fbfeb77a45bdc1ed85b91cf830153e50fbb1036825f2ab229f28f3ebc3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x59e18bf6f9ab05be8ef42c5b91d750b0eda247201beeaa583004724130cba9ac", - "receiptsRoot": "0x75908b9afeb91eecae34b9a2cfbeda7fd4c66398fea481c89a7564e41d5da0cd", + "stateRoot": "0x6081c4f8052b95cb18ad02ea085a642125f9d5a9221cd75eb6056771cf008620", + "receiptsRoot": "0x6b31afc4d4cc15d8a534d4ffd4b09d1833513affcf76811fdfa76719b2a468e5", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3", - "gasLimit": "0x23f3e20", - "gasUsed": "0x143eb", + "gasLimit": "0x11e1a300", + "gasUsed": "0x14823", "timestamp": "0x1e", "extraData": "0x", - "baseFeePerGas": "0x27f89dc5", - "blockHash": "0x30c554999f56478175c7d58b6911819608ec37e738e3b1de824e55094462ceb4", + "baseFeePerGas": "0x27ef8174", + "blockHash": "0x0f51f7687109662f4fc576d9db5e25cec453d9c7e34b766301028adc6d3ddc45", "transactions": [ - "0xf8f3028427f89dc683017d968080b89b600d380380600d6000396000f360003515156036577f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fd5b7f08c379a0000000000000000000000000000000000000000000000000000000006000526020600452600a6024527f75736572206572726f7200000000000000000000000000000000000000000000604452604e6000fd8718e5bb3abd109fa03c13b52b90355f3392f8134624087ca1d80e35900c8f3515e662869feaacea04a05f800daf0a81d4993f977e2b5bb3db8f30888d28ac7e4b3077c79c9028d1ae0e" + "0xf8f8028427ef8175830181ce8080b8a0600d380380600d6000396000f36000356142ff54501515603b577f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fd5b7f08c379a0000000000000000000000000000000000000000000000000000000006000526020600452600a6024527f75736572206572726f7200000000000000000000000000000000000000000000604452604e6000fd8718e5bb3abd10a0a0c5cbfef60cb4e80e7c1e67d3a7efce942c2c9ab8ef4b45d684725b7f6cb06192a01387d0e3b29b6c7eefc31dc3b07ca2ccb27bcbd1e4eb6c8c660573c1fcf9cb4e" ], "withdrawals": [], "blobGasUsed": null, @@ -115,21 +115,21 @@ "method": "engine_newPayloadV2", "params": [ { - "parentHash": "0x30c554999f56478175c7d58b6911819608ec37e738e3b1de824e55094462ceb4", + "parentHash": "0x0f51f7687109662f4fc576d9db5e25cec453d9c7e34b766301028adc6d3ddc45", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x524c3a9d48961688fd669794a18e3dd8c62b75fab78b9c56f008fac18d8b8d7c", + "stateRoot": "0x142ebbf7309e33533bb3fb5e2294f37c78469eb08a1488bb9de24ce5d914db6f", "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x19d36", "timestamp": "0x28", "extraData": "0x", - "baseFeePerGas": "0x22ff2a8b", - "blockHash": "0xd31109a0dbafd1f1cc8c766e26e0d2c604624ff2b66bcc95baf784d3d7e21aef", + "baseFeePerGas": "0x22f2487c", + "blockHash": "0x36f99b2e62608f2ea5567d69ded0f20f485e46a4fee846d8aaf1b5c4f0cdc2f6", "transactions": [ - "0xf885038422ff2a8c8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0bdd3c5894ecd41fe69173487fc04062b827ef70887a998a96854288770eca1f0a03777f418485bf99684eea6842c59e2eeaf6db201f1fcc6d9886cb18fb802c6df" + "0xf885038422f2487d8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0c3620843ed1efb2564e9752094ba5d1e11801e881d4548cee10a44a7b2db7dcfa068bab5711937b0b6cf883318d78729a993c5cf1cba522778c9f45ef00697e1dc" ], "withdrawals": [], "blobGasUsed": null, @@ -143,21 +143,21 @@ "method": "engine_newPayloadV2", "params": [ { - "parentHash": "0xd31109a0dbafd1f1cc8c766e26e0d2c604624ff2b66bcc95baf784d3d7e21aef", + "parentHash": "0x36f99b2e62608f2ea5567d69ded0f20f485e46a4fee846d8aaf1b5c4f0cdc2f6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3616ac845c5539addfdc3c8495c3e5cf92ca55638127a25107dde16fef02139a", + "stateRoot": "0x59e2de990d89e2f2b3eba24141b807554f7dbef4cf0fc1e8bd98072d6d7d235c", "receiptsRoot": "0x399a62e49d637d071f11c70ab4fd9aca6de920b3fddb2b1c9739e107d60d683f", "logsBloom": "0x00000000000000000000000000000000000000000008000000000000040420000000008000000000000000000000000000000000000000000000008200000000000000000000000000000000000000000000080000010000000000000000800000002000000000000000000000000000000000000000000000000004000080000000000000400000000000000000000000000000000000000000000000040000000004020000000800000000000000000000000000010000000000000010000000042000000080000006000000000000000000000000000000000000000000000200000200000000100200000000000000200000020000100000000000000080", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xfc65", "timestamp": "0x32", "extraData": "0x", - "baseFeePerGas": "0x1ea58e20", - "blockHash": "0xfe55c597a9aa81a0233ae2e1aab26b32a2cd890978bbef31b3a3517217d587de", + "baseFeePerGas": "0x1e94c951", + "blockHash": "0x082b9e67d24da6ba292e97c571714a810c6fa187fc70171b761b47c450f14229", "transactions": [ - "0xf87c04841ea58e2183011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa060f7133945281b66a86cbcfe120e0801afbfc9abfdec1597397233c44a758b77a0592c06634ac4f7e82d40f52c2dd92686f47b45382d0256f87f386ae5f3b09d20" + "0xf87c04841e94c95283011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a088cb362c8a80ddfd6e0492ea884a21d1af16ba5ed270c20690f564324586ff68a0706ab5efcd4295bf32eeaca07aeac18b3df84225967ea65e40007837e53cdb0b" ], "withdrawals": [], "blobGasUsed": null, @@ -171,21 +171,21 @@ "method": "engine_newPayloadV3", "params": [ { - "parentHash": "0xfe55c597a9aa81a0233ae2e1aab26b32a2cd890978bbef31b3a3517217d587de", + "parentHash": "0x082b9e67d24da6ba292e97c571714a810c6fa187fc70171b761b47c450f14229", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x89a905393431866fe45f07895e3045eee539820dbdcd9bad7e9a75afa410de6e", + "stateRoot": "0xd1a3e48fd8aeed880df1bc87896b1a7c182e882b54579810e549443c6df2ca89", "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x1d36e", "timestamp": "0x3c", "extraData": "0x", - "baseFeePerGas": "0x1ad438f2", - "blockHash": "0x55e4cf7027d011ce8517b43ce6dbacad82fe7b48b89f1b1053a1d02013be10fd", + "baseFeePerGas": "0x1ac29c11", + "blockHash": "0xf23d9c0afa4431611e843a618a98181b4c5a6dba2a448c43b3e5eb057128d126", "transactions": [ - "0xf86705841ad438f38302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa04618d35cd148b289eba951b1b67fba60ed0c71ec6aa072f01843f0cbb0a6f8e7a01d7d73fba778e165db04d8502f224ea7a2bcb7482c506a036c831cebed70f2ed" + "0xf86705841ac29c128302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0a4f2fec763d302705e1addb2d70408e971d740c06a9ebbd2d448db9cf916fb70a02d1c26bd68d9238dc291250d4544e7b603659bf9c587bf54b9977956df7e1bac" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -201,21 +201,21 @@ "method": "engine_newPayloadV3", "params": [ { - "parentHash": "0x55e4cf7027d011ce8517b43ce6dbacad82fe7b48b89f1b1053a1d02013be10fd", + "parentHash": "0xf23d9c0afa4431611e843a618a98181b4c5a6dba2a448c43b3e5eb057128d126", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0d0e92ffa93004447ae8c651e98a8370ea156e4fffeef500a1be099fa982fad1", + "stateRoot": "0x19b3325ebeb449a0d98d17512c9cb8821ae076bfaa6c678721e98de125b907e6", "receiptsRoot": "0xab3d679c59ae2bd60b09801e3dcaa843b6231d88f744e2d4fb89607f4232b7ab", "logsBloom": "0x00000100000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xbfac", "timestamp": "0x46", "extraData": "0x", - "baseFeePerGas": "0x177f2512", - "blockHash": "0x1b9b663eca7124419b9131f1045a0edbc4154e026f4fc7de8311d459246f2eff", + "baseFeePerGas": "0x176af771", + "blockHash": "0x473e30aad90c807a9b4d16ec01b7f03296b16bbbc62824a9e7034db8d623afda", "transactions": [ - "0x02f8d6870c72dd9d5e883e060184177f2513830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7e2e8b49f93a4f1f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03569f740e521d8bb11c5b72660dc96272ad66bfd811ed918c3a9e02acd4ade8f01a09946d8fc8ffcee7840c0fe223ea25f630d1e734432787ecd0b5107f773253849a03ee58d6d70214319409499d220ec1555ad458e9c312b660c79afe19cb68a89e5" + "0x02f8d6870c72dd9d5e883e060184176af772830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7e2e8b49f93a4f1f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03569f740e521d8bb11c5b72660dc96272ad66bfd811ed918c3a9e02acd4ade8f01a094465f8e0098f0ff2023b5a401f6c83f951866ce96c0f496198dc8562cc5c2f1a0595084d2e72d16377a3200e2b602143939b17d80e637534ec01fba789311ba91" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -231,21 +231,21 @@ "method": "engine_newPayloadV3", "params": [ { - "parentHash": "0x1b9b663eca7124419b9131f1045a0edbc4154e026f4fc7de8311d459246f2eff", + "parentHash": "0x473e30aad90c807a9b4d16ec01b7f03296b16bbbc62824a9e7034db8d623afda", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd47e264283e68d12bba8070826a2f72b06e3bd92527a56d74214a406fa4624b3", + "stateRoot": "0x8b926982786c38e5d363b6c0b8bcd5f190ba4309b447724334e365418e9ac423", "receiptsRoot": "0x59df46f0e6bac1dc285d10ccd74b357af596460248be25ef75fc47c7fac1a39c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000001000000000000000000000000000000000000004000000000000200000000000000000000000200002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x50", "extraData": "0x", - "baseFeePerGas": "0x14913581", - "blockHash": "0x61322084e9721face5911ca9988aa668185e1e2786057fcb069cb29c8190bf61", + "baseFeePerGas": "0x147dd744", + "blockHash": "0xe7925f8091671141f5d8dc167b12d37a1f64242c996f6889babde63839e6963a", "transactions": [ - "0x01f8d5870c72dd9d5e883e078414913582830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c92c0a3cd8b571ac5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a780a0a6d4adfb0a6bbc11fffb1025bdc8e0216316178f3b9bb7275f0d71a6df68067da0454a6e70c9e349890bdd5c9bf42ad3d4809d8bd246fda129dcacabad1d43c228" + "0x01f8d5870c72dd9d5e883e0784147dd745830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c92c0a3cd8b571ac5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a780a0e2d1ea38dc487de618477d0e38d189765addf5fedf5190cf606fa35b0c12033ea05d26448c5b071496b2f991133b9f65928a4b2a685395b5648580a36b9a3a1688" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -261,21 +261,21 @@ "method": "engine_newPayloadV3", "params": [ { - "parentHash": "0x61322084e9721face5911ca9988aa668185e1e2786057fcb069cb29c8190bf61", + "parentHash": "0xe7925f8091671141f5d8dc167b12d37a1f64242c996f6889babde63839e6963a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x498a464dec3c6e5290fa555c92cb8a865b30cdce6682e1ab1871c6a36e0b3e2b", + "stateRoot": "0x654f55922865e39ca98c5998bc2a02d0de19a8facefbb9fa34c4fac2a36e5bd8", "receiptsRoot": "0x7427faac1fbc3e399bb731da9429aa768a3c2c054e1ec11c64625942bb2ba0c3", "logsBloom": "0x00000000000000004000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x5a", "extraData": "0x", - "baseFeePerGas": "0x1200de71", - "blockHash": "0x3af964bbb4a63a63e6110faa9b27c25ae5c1e22d9273a2b60f43c71b6b4bf31d", + "baseFeePerGas": "0x11ee5668", + "blockHash": "0xc849ee85e61206d41e4a84b6f96eccddad3181a8f4d3fcb9c250dfc27f7247d3", "transactions": [ - "0x03f8fc870c72dd9d5e883e0801841200de72830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca66c701845710c6c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a063cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a00fb516e328b806289d882c3ea936d603a2231af896649eb0e49d805152f5f2d4a043e7d256698deeceedcaa310c055ff85b3d7805e7fad3b540ab7de9463011738" + "0x03f8fc870c72dd9d5e883e08018411ee5669830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca66c701845710c6c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a063cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0b42b328c611e0fd94d62f85deb12d2d9a504bd2760581b3cca3ba07e56403c09a05021570d8585e98b5bf49004db7d90ec09595ff87e72fd013d2af5a5b578196e" ], "withdrawals": [], "blobGasUsed": "0x20000", @@ -293,21 +293,21 @@ "method": "engine_newPayloadV3", "params": [ { - "parentHash": "0x3af964bbb4a63a63e6110faa9b27c25ae5c1e22d9273a2b60f43c71b6b4bf31d", + "parentHash": "0xc849ee85e61206d41e4a84b6f96eccddad3181a8f4d3fcb9c250dfc27f7247d3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5561c28bf67d2f12f3b0df3d4865cc661247a904e0f64fa82cd8e8ef80610691", + "stateRoot": "0x8237acbbfa9bd4194321f36611240dd5966509ae0a76e63b66da49385f775e90", "receiptsRoot": "0x4478e3b373311a23ee4d53203c0bd7e990e5e81cd616e690fdc8eb2a784e5020", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000100000000001000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xc268", "timestamp": "0x64", "extraData": "0x", - "baseFeePerGas": "0xfc25878", - "blockHash": "0x7530fb1515a8ec5b024a700bf0220783269b1e2edc3d215207c96bf5c5539632", + "baseFeePerGas": "0xfb0be66", + "blockHash": "0x29219089f7ea2e7ee590b815240304490baf2a2562eb8c71f71dbd2dfecb74e3", "transactions": [ - "0xf87709840fc25879830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c06072144caa6635a656d69748718e5bb3abd10a0a05f933238929883d03102abfa12902de040aa3990210570fedfc48c6820fb9a8aa04edb8bdf127341d132c798f7203e62b37bd27dcf361732fe918792e21066b3aa" + "0xf87709840fb0be67830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c06072144caa6635a656d69748718e5bb3abd109fa07e5a5e5799539e1bdc54fe8322878120970f40ddec8ef4ae11398925a56644e6a02761c08cf79048f11752b09381e24ace2613c771eace32a2e36e75b346c94cd4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -323,21 +323,76 @@ "method": "engine_newPayloadV3", "params": [ { - "parentHash": "0x7530fb1515a8ec5b024a700bf0220783269b1e2edc3d215207c96bf5c5539632", + "parentHash": "0x29219089f7ea2e7ee590b815240304490baf2a2562eb8c71f71dbd2dfecb74e3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5b2457ac13c8edf5deedd62c51bfca391a8a4b99d7901ff251c56658f74bbae9", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd14b9628bb9f5857619fc3f4728d5cc49e9dcc35336a702c45c13bd033e8af62", + "receiptsRoot": "0xf3a28a355739a86089c6d4787342faa0715befb3233623f4174ccdb0db5218e5", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0x56f2a58", "timestamp": "0x6e", "extraData": "0x", - "baseFeePerGas": "0xdcb6245", - "blockHash": "0x7167b82e4207928eb75fbe741b29d18fb5d469fa56c93941223667a07d183c44", - "transactions": [ - "0x02f86d870c72dd9d5e883e0a01840dcb6246825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a084acd22563552cb084358e49c7d881c7fd44d2bb47becbf7d45db91a89d256a0a0693e415095b70f8b616169aba614e663b0dcbad5b55b427407c8e11a70b4dc85" + "baseFeePerGas": "0xdbad13f", + "blockHash": "0xc2edbf6987d529aeb53f0446650f0c76fd4aac53d87319bd3906700461531e28", + "transactions": [ + "0xf86b0a840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0060a6a836a44684639ef8ed0f7204f457fd973b55da0b4d3b66c8f6ccff16707a0480a1af9cecbf3d37245c19a47397b2036f9a2524c5e2e64cd0afc971c2e9fc8", + "0xf86b0b840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0638bfda948e5c187854a8add419315a42b1df21c15987f04772953465e801375a03e928122969c694cfddeee640b1fa0e790046666b23d5146390bbeb1c009a5af", + "0xf86b0c840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a09a2edad519690563258759508a898df82bdb9f408191aa0079ae5e9756e74c40a03f563b9d9e602dd0bb668c56943bffbca60506d44438b888fcc9d5a335e8ceea", + "0xf86b0d840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a06ac6618b278b0e1318863a91fe203261f8ee5df34b195b6d91a27adc63e41409a064b5ae48ca2b67407a7aabf8931b5f921a758cfb3f6f07436bb3153b9fc28d0e", + "0xf86b0e840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a02f40a5218eda11e6f1fad4842b53456a6c278f8c718995281a81d32e8551c264a04dc53af93a9b4bd86741abe1ab17453b2a9f5767d4511722626128b58250a76f", + "0xf86b0f840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0a2e2ba0f486fc14e6d58303362a72b51806098ce9887f6b490670710858b3e9da02d9adcaff934e2b20977de9a179531502bf848c047ea37145f51fcaf7eb9c151", + "0xf86b10840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0cfc44bbbab9da16643ccecd90577f1d21743c424d62858772e342e21529fde34a02647b1fdf866593847ca3951ea05b9c44c243d14d3429ee6b508eb831ab72b19", + "0xf86b11840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a022fc38175f83ac06447f422aed377cefca994fdbddb2f6aa75166f0f6095cc50a0595171bb2aac874629a81374705277b3c250921d3346a5c0fd0b5ee47291c5e8", + "0xf86b12840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0b7a5ca9171575d69f7b1091f9730cf783f13112f8af53897a55bdc226a8a12e9a02170fcff5cac92eac7c2565ba096f9e6893f90a1ac0d89ddcc9c1ec0882a5f76", + "0xf86b13840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0f01f5c7654f62e2eefc87845eeb9e0845cc2b90823257cca63520d15bd33d95fa039ec90117e19629be1fb59a411a20ee67c28aa09ab95a86e021baa2e20b33591", + "0xf86b14840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0420cc50892e5c7eedefe4435da5699d33948fce6b9b9ca2b63c87ab629c540faa0500bc84d8acd87ecef0a195a57ad94b9eddf80aa67829e88f5ad9fbae4708a20", + "0xf86b15840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0495da220099c70ec6b9e83300eb8b3377007849a8272a160b57cbbbef2a2ab63a06ef72c9b22dc5180ffe2f6dea4cdb4afb04c02a2cd0bbd93334dc7c14c0e9b80", + "0xf86b16840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a02397f7b681c73a677f8f2585cf53a90f5e42d0f86610892ff4c93925e5db8e38a02cc58fd6423aebfc544a386e03d04c2e31609e3b820b089b950374fe9095284f", + "0xf86b17840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa06e92957c7d28f52e286210f8435fcaf911fd4acadfc57d3c965bd629b141a748a024e393928a755068e71a4b9b5e2168d1a8e084a3fb0adcdd327bb118cc57689b", + "0xf86b18840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0cfbd36c74d424cda119a40a62d08db755860b7d0eb5ba2658bcd25c005917707a02370319d26b9830067dccc6c105266b753a43a83c72986fe19333b2565b60778", + "0xf86b19840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa074ecc8edea50cafb80ba9c60935f4a666188c6be49575edeb5f3d70dd5671112a077f9fb4f34119f4d7ebd16e7755db476285c9e09c72fcfa714fb04d39eab4358", + "0xf86b1a840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0ea7684569fe50be776abe088bf8543f87d97a6dd1944ce5d717a472f198e1850a058e193c82c62c3d73337ef43805b1937ff9bb0870fd710e957b8c7a8b3f76943", + "0xf86b1b840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0b2a332d784def48e24ba963f6e702636f39cbbbb56b7882eb900296f6615cfe9a00b210739e9cbb2dcc733ddb3ca4e4558fcdfb6c32057e4a6da58edb8b1661886", + "0xf86b1c840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a03624214091f93d21521544b8cb7e93faf8737051202ff9f2800088cf127bacc4a07577042e20768cf2cd929b1de9ff069f660d65aa52178ea641aa97ca87cd5ba2", + "0xf86b1d840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a060f12ef39523644f134b4480ebbc1a7e1123535ccfdbeaf9a7f897708ca32f75a01708d66ab7ba596de1c1c3a5386d47d1cea995326e24478474c427a250d83d92", + "0xf86b1e840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0548594d45851cb1ea7ad4c5171465c938d8eed84de515aeb08744ac93ef7b808a00dd5d2dd5a4505a801a29072791e8386494963ee17010f0b2110615744e2b95f", + "0xf86b1f840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa08db61cf15a694bae68c3329019b07cd2fb8301c9ad954dd000023349d2e14b9ca06b7fc40eccc565de423d69dd3c340b502e7465d8e8bdd7163076a33ea5fe9b9b", + "0xf86b20840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa04dc70ede29948a29fcf42e50f2804cb2445395fd268506e17f0d3e6147689b8aa0750f560de32d82e6ae5ed45ede053a49285b87e6533b499daf24f86874f76a0f", + "0xf86b21840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0c0c55f52a0cbbd8b22b112c9972291b453c7bc434747f07c8dcc4b2b6f63ebb7a001867890b6e29ff99f8f2068cc6ff8bbf45f32072140310390600646b230d6c3", + "0xf86b22840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0f46f282c689c811e33116625fe6119527ca380ed9b931ee8f445b05839798c8fa0631721fe60529ba2da01a5c70313a4bd381be5c16029cac70f92b4ed61e121ff", + "0xf86b23840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0bb19159d6a7c7b5024e4f1fffe57749eafee9635ec546d41a2fccf8caf97dd6aa0215308ae67f9ab88c7280d075194c8153118358bacd62ccf40b09b1bf6497538", + "0xf86b24840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa01225dadac9cf8e2ba0bec73ef248cd363334c0d78b1f8b5e0d98a4feda6620d8a039fa9e778a792853965c54b8add7f3fe9dc8a5a634cab43adb88ca252b132e2e", + "0xf86b25840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a01b9a4ea9a82cdd0f91f76f444f3f3dc42bea7bf1d04771afbffd9b392990416ba06c8bd75045c15c291e2f7ee1e477358d173c7cc0571ba7fc1edbb54ba8f32cad", + "0xf86b26840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0767e765c1ac0bb5a344b4af14486775c2c2d1757f8ed2c686878d4eaca0afde5a00c3daafd17d6f6e4e1ad7e1755a8a9043787195177dbef7629554414c55b5fc2", + "0xf86b27840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0e1aac35219301b58a49eb944553e103497c4ede0be1a9ce4ad84b2cc94497ec6a072ca5fb40f7a9b6a8558c3e4dce03bb5e2f4cd27faad293d410634851601dfed", + "0xf86b28840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a09c452ac6ec4d2e35cc24e0839137d47be044f00d848796fc65557f56d4f67038a060fcc91de163c162afc0fa80efd6a8b63fd1a02b43c00e8394821848e2549426", + "0xf86b29840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa00f3c92f8679ac5f1801714ffa74ef211c9eedf6e14742cd00aaf98d227f85420a062195bb65c91f17f92121640326ab9091b4c434283cd24d1a8daf15c46f3725f", + "0xf86b2a840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0c641996cf5b8015c3981535bd892f14355b4f7277d3ec96e95f5b2e668be2f81a0349f1f66f2ffb544be70cb53447b6b64884b16c28b04bc961fe730516c9a7bc9", + "0xf86b2b840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0da0ce619a88bd01a7f2c6227950446be3e19c58d8b410cf8d625a6f879bf659ba04ea3a11a64f65a80a8d653375acdb6561a07e22641079c570864d48c2c8b4194", + "0xf86b2c840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0a84627a1e6d0f0ac36b6b0b13bb94e4fa5cc9747942e7b9118274af6fcfe8de6a07cb0e5b3338d042671bb55b95a381a9fc73db0cf8bdddb3935e0a17deea5614c", + "0xf86b2d840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa06639660bb59ef8cccad4033082b47af20ed3e099ffcfd8b5c27e169bebb35155a01355e2193aea0d9d861529a6b48f9e526a3a167101e6acb6d2608ab7253c9398", + "0xf86b2e840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa03b452b7cc5bc8ee1395ca8b20fe9abbd7975eda3bd68d3ae983fb2dd16d5f9bca04c27b31e1cc4a91b332f5cbeda438228ddefa0515955f1d7fe5280206b5ab437", + "0xf86b2f840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0829bcb7861ff510c72f125e85f2a84fab10d67334da46a7162fcedb2200c6d91a01f6467f80652001981294388f2c7085896a0e5e706319639df6761c790f50cb5", + "0xf86b30840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a07e6d86cb2511e2b430de99b1f693fd355f5f49a628136c4ca6ed1f013be94983a06d13d6a4a03139fa79bb928cf1d1d0ff24a94895aecd679b367e913afbe69bc2", + "0xf86b31840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0bdd7ef416f1bba4f95e3b0e8589ab843fe13f2dc17b114e0fc7052242fac7423a00f3fc584e0c614a0f9d0324ed8f50a07c4d5c605aa630fab8e3164fe7e57521d", + "0xf86b32840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa01fac2355edf58cca0b855cbb0b22020e091e6cc005cb157d59c88c48796fd41ba048175c688d69cf760cffe51a9f10af6710026ee409fa8fcac1305fdcf16740b9", + "0xf86b33840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0e612287ad2d26780c62b08c05e50b52c99175b4bb82b844c3fb4e53e59043b6fa076c380af8a1d56a436d29ec15c7a56a38ccb6780a82ad434de2926c3f4c450ae", + "0xf86b34840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a084c6a71cb2dc8ec1c043077e9d8a286206fdd7d5208d050184ede16787339e72a0086545d7e5cfefb9b80c70407e6e9cba45d42764196f885c6acc244585d9f7cb", + "0xf86b35840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a01f598656efade45f7162d391407a113f5bf3d37000a932a13c9843aad0555a8fa03500d192cd8eca8ea3d817308ddb6a06cda7656ae2b581d05f4f5682b6811719", + "0xf86b36840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0dcd026db847233875ce87cb3a76cb0642d309d7f0064dd1f9a25110c7e396b56a00a8e0c7d3b8940263eb311432402f76dc64b1a59e5fcb7259013fa8bc114833e", + "0xf86b37840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0be2242fdfe22f5a8d954c9a6f6121d1802def0ce28c0b26f802dd75190c5a209a05159d049dba56843d954cd30c01e22b92c4d5719053cf8a1b20a013295d937c5", + "0xf86b38840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0f6ac311df226aa9c056a50d52ac5a9a7eff0fd5f9e769eb4246a85e7dba851e9a07b3018eafe83b112ae5cab6613c0e232a23be802ba9a794ed5c829218179dc32", + "0xf86b39840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a06b3934dbfa85b7c568d9bd27f6fa0d5ae3706d4d398f7f9d4019d6b44a5878fca04300596f37fe39fdf6bfd46466b2eac00c563aae354842f9fc1d071c593e45a8", + "0xf86b3a840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa08f38036099c59808c4d0d119d1762b368c85263020cba34a7957ab670bdf1d57a055d5bdc38deedc0a5c2c4b1165f040120d5402043d2af2cda1fe1f5ce10fc688", + "0xf86b3b840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0a7f52c6681b6e2187f5977bb350eaa5155d4939453c28ba747fd8da231ebc316a043098bbc0372a4d377942c07f5034f655ad00f98844c03773536282bc0e872a8", + "0xf86b3c840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a02ca79809610eca633936917b5533c33e6794798a6f7db48a97749afb7953facfa026778202f95bb963c18ab61af0f1f098131fa1df41c48ffe1f12b2470a7d9795", + "0xf86b3d840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa07292476592838b3633834075318fa1f0cf49ff6436170f8faf35e3ff75a38492a0107c7eb72a64156b369d3af33aa5ebe02da8bf6fd6584932626126100ec04b08", + "0xf86b3e840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa08810c5b2fc1e46ce53d9b01576060fc0a2f58ed939b306c7a1a5709eac11ae4da051df54b5ef5bbc8eae34558f5080518beee54ddaf3770078404d619bfa2dd986", + "0xf86b3f840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd10a0a0b116d34b2e6d2d4a73d4ded705cca85dcac9e1c3a7e4ee918fe5f7edf0794b37a05ab18a2bc09fde1e6c7e39cad506861e2ea9bad2153d39b7adc2a13840b6abec", + "0xf86b40840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa0ce5601db035883ea12ea00c38e1da64adc35eedc039bdc730fffe6210962ed1fa0629ce0178fc3ce483baf32ccbc709c69eff28ad5d73a827a6b1f68c556953c0c", + "0xf86b41840dbad1408318d7a1948dcd17433742f4c0ca53122ab541d0ba67fc27ff80808718e5bb3abd109fa08d0611d940b6ffe8a94be47e1b38db5a0499175ac14ce4f5e384762de57764aba0157b81dc3d4f2f653869b2e98352e5f6247560d887805ca4cf662c5902ee0b04" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -353,23 +408,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7167b82e4207928eb75fbe741b29d18fb5d469fa56c93941223667a07d183c44", + "parentHash": "0xc2edbf6987d529aeb53f0446650f0c76fd4aac53d87319bd3906700461531e28", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd3dd7c33bb46023c18a65ed23544cd1fa6cb94f44ed609ef6c2f7a8d66ed4f54", + "stateRoot": "0x66fdc6cf3203f8b3e6ae74fda946e0af609adb8054fcb57bcd84a1e2e65aec91", "receiptsRoot": "0xa073f3de39b2256f0a223d83925e01b3ba1924797d00c334d406fa19adc17631", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x21b95", "timestamp": "0x78", "extraData": "0x", - "baseFeePerGas": "0xc1273e2", - "blockHash": "0x23d7c4e274d71eee019119e9403d83ae181d9555d30a81aa0660c2103360f126", + "baseFeePerGas": "0xd0e81f2", + "blockHash": "0x0263c20a17979b8bab4b53b9a8b028faee4ae62a22fd604e17c72a1c5113c5ab", "transactions": [ - "0xf87a0b840c1273e383011c328080a3600d380380600d6000396000f336156009575f355f555b305f525f5460205260405ff38718e5bb3abd109fa0d5560e311f2a2d1711dac8694b2a896df37d88199089c31f35080e3386eccbeaa0731d81520db66c0bd7fe2bb6f5afdf77615352197b3d909147d4fc390d87ef62", - "0x04f8d2870c72dd9d5e883e0c01840c1273e382b3b09400000000000000000000000000000000000000008080c0f863f861870c72dd9d5e883e94417fe11f58b6a2d089826b60722fbed1d2db96dd8080a039590402b13d3414ae54091a9923801c47a76664357c75650a8b84a185a1ba9aa012a807778ca1bc0a9132371ebd97e4b90b58842e8ca19c88ec19dec719b08c7601a042ed44bc123804a06c01dc4363881012c1d6fbf3ab10930af1ff17e7ea05e4c8a01aba6b1d0e03da9aa244f7f5148c7795db17a3864db721bbba1816f28c4accf3", - "0xf8720d840c1273e38301117094eda8645ba6948855e3b3cd596bbb07596d59c6038087696e766f6b65648718e5bb3abd109fa02ee2b3da4dcd45d653a95a338bc9e574509c9d2c5b9367faa2e6bc8c9a8553c4a0191fa50fa1a1b10764d71be4f17bc39286bba27c79ed50eda88a5f197e281886" + "0xf87a42840d0e81f383011c328080a3600d380380600d6000396000f336156009575f355f555b305f525f5460205260405ff38718e5bb3abd10a0a0b45c37f931427032a0c03102b40207dc61a86ffe4b441817b93de10cbe878805a06d80157ebcdd81ed19c7cbf0ab4867b9454c55acbeb73fc274ea03b028f35031", + "0x04f8d2870c72dd9d5e883e4301840d0e81f382b3b09400000000000000000000000000000000000000008080c0f863f861870c72dd9d5e883e944dc5e971f8b11ace4f21d40b0ede74a07940f3568080a0b1374c6ae2e6a067776f1cf11b547c3f0d6658b92e131c31d50d19b0468506fea078843e0f436d58049f084c8057701c490bd8b3e6cd7dc018c5d5ef26c4f8fed380a00781a3a7695968cd136e3c91bd6c368021855323fd121a565d394b3e6b5c6522a04421609cf1f129c97c305cdf6395064d9bece86d609e5fce621e4b69c1f58d88", + "0xf87244840d0e81f38301117094eda8645ba6948855e3b3cd596bbb07596d59c6038087696e766f6b65648718e5bb3abd109fa0eed30d4827a6094bfbd36d418b62422ced674f50d9e6d53c27499ef79af232d6a044c03f449fda39275856086d2fdc5d577f4d3d28ed6a44b864dd0daae42e57f7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -386,21 +441,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x23d7c4e274d71eee019119e9403d83ae181d9555d30a81aa0660c2103360f126", + "parentHash": "0x0263c20a17979b8bab4b53b9a8b028faee4ae62a22fd604e17c72a1c5113c5ab", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x886aac3e90114014faccd1d17dc60c5693a41594a48a31dc2c5049c9790ae96d", + "stateRoot": "0x8899c6e3a9ed9597ff128c704dd93e40c42d1d6c22cc13b8c306576979996064", "receiptsRoot": "0xe4c268cbbfa69cbaf9df3ba67fbc172a06bcbc45b5328a21232249c3fa7cd65d", "logsBloom": "0x00000000008000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x21259", "timestamp": "0x82", "extraData": "0x", - "baseFeePerGas": "0xa92fa1e", - "blockHash": "0xcbe5c6da730320128cc63a3c2454ede30738fa0d59a9e9de2e90f58b1938333a", + "baseFeePerGas": "0xb6d1434", + "blockHash": "0x96767c27f1be95f86f185bdc4f2ad2b9d0cf8fe0179912270b9f09a56dd885db", "transactions": [ - "0x02f8ab870c72dd9d5e883e0e02840a92fa1f830249f09400000961ef480eb55e80d19ad83579a64c007002843b9aca00b838b917cfdc0d25b72d55cf94db328e1629b7f4fde2c30cdacf873b664416f76a0c7f7cc50c9f72a3cb84be88144cde91250000000000000d80c080a0cb1c18b2bec62be2b64921b9d3ba10e7803970317a6b472986f52e5b6b5e6e08a043a8be395aef9cb8873067302ca16e2009f572c46a3594e253107e18dc26f892" + "0x02f8ab870c72dd9d5e883e4502840b6d1435830249f09400000961ef480eb55e80d19ad83579a64c007002843b9aca00b838b917cfdc0d25b72d55cf94db328e1629b7f4fde2c30cdacf873b664416f76a0c7f7cc50c9f72a3cb84be88144cde91250000000000000d80c080a064c7e81464d6887c191d7fb7a79085ecc793aaa58b0412c3e14955e58ddf34d6a01a785503cd7104aae3e8c6a71c5bb38c99a9f6b1098a0a95ff2cb9a60f7d5793" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -419,21 +474,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcbe5c6da730320128cc63a3c2454ede30738fa0d59a9e9de2e90f58b1938333a", + "parentHash": "0x96767c27f1be95f86f185bdc4f2ad2b9d0cf8fe0179912270b9f09a56dd885db", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x273a92dcd7e5b69db9a05c78121c8a932bb3bfd03e53b49fc7cb0bc8133bd63d", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x96887a3713f1535d1e6177897815a84ef67458961637bc5765d4da7c2fdfa7dd", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x8c", "extraData": "0x", - "baseFeePerGas": "0x9430ac8", - "blockHash": "0xec7e5f7aada029114c5b556586e0e3c3ef3a39dde955f379ccea43ef93acabbc", + "baseFeePerGas": "0x9ffc667", + "blockHash": "0x998edaa40eab431c0cb0907adfbbc45bd0559758eda2cc11ac1d0142783db4f7", "transactions": [ - "0x01f86c870c72dd9d5e883e0f8409430ac98252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a01861188078feab73f7703fe6588d303f43c3439f1f9b99e71fd094140e486cafa05eeb3113857b44050ab6cabcb24b8ee60528806a15592a7a97479c380a12d8c0" + "0x02f86d870c72dd9d5e883e46018409ffc6688252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a06c83d9175fbe6a4b8efdcf0d342435b8c47bb34c317cd6ec57ced5c02defdcc6a054ad6cd4d8d639ee951ea7395355c67c9cec481ac9f2b7d1120dc426cd8dc2e4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -450,21 +505,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xec7e5f7aada029114c5b556586e0e3c3ef3a39dde955f379ccea43ef93acabbc", + "parentHash": "0x998edaa40eab431c0cb0907adfbbc45bd0559758eda2cc11ac1d0142783db4f7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7e6fd4b6f397fe383c121c08a5b9b6d3ea854313afcbeec3060ee88b5b2f782d", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x9639d7f2d0b564d1153f42ef9b400f12647c1374af7ecc694f1c0ac8ba6b92a7", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x96", "extraData": "0x", - "baseFeePerGas": "0x81afdf7", - "blockHash": "0x7599aa2261eece5d6075f09401692a0ee37815ad63946cc80ab3ba29838c00f8", + "baseFeePerGas": "0x8bfd912", + "blockHash": "0x32c4b00fa9800092d28ee17d5a2941a100ed6ac3ec1514b774890b9b226ffd43", "transactions": [ - "0xf86a1084081afdf8825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd10a0a057f5046223be25b7a2749c5f8b63468d67191af95b146876ed91d962e1323a97a04041fb4e18f34572224c21f024e7f744d1fc259c3e6335016f484af0231b9fae" + "0x01f86c870c72dd9d5e883e478408bfd913825208940c2c51a0990aee1d73c1228de1586883415575080180c001a07f16edf66b60ecf1cefead739d8a2f6ece3e8dd063c392257221e3105d3733bda01503e22a37408297f890193f4600eb6f3b2dfc77aea493a25791bdbab5cae817" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -481,28 +536,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7599aa2261eece5d6075f09401692a0ee37815ad63946cc80ab3ba29838c00f8", + "parentHash": "0x32c4b00fa9800092d28ee17d5a2941a100ed6ac3ec1514b774890b9b226ffd43", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfc9e1c12454ca1c0629272b15771d8fd75dc9c071784eb7674454da05238fc92", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xc9528c5d71c325b0172dcffdbf9d3f8047967ce3f159447b613584e7fef0736f", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xa0", "extraData": "0x", - "baseFeePerGas": "0x717e832", - "blockHash": "0x60576c148e7ac42f9d36ee36a7df5a89241609f624502b248b5cf710ed269a4c", - "transactions": [], - "withdrawals": [ - { - "index": "0x0", - "validatorIndex": "0x5", - "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", - "amount": "0x64" - } + "baseFeePerGas": "0x7a7e7f9", + "blockHash": "0x827cbc8dc6bd4a545993d61ce2833f7baa3ffafccf0c43da845780b2c60c4f0a", + "transactions": [ + "0xf86a488407a7e7fa825208945f552da00dfb4d3749d9e62dcee3c918855a86a001808718e5bb3abd109fa0bddd0dad61ac2ebf00459eb8ab9b1d2e1a0f0a11cb97e579709fdc60f63279d8a03c7bc06147ac3a2e11f37394ee5203c236a8388db7fb76c92f99f2722af9b558" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -517,23 +567,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x60576c148e7ac42f9d36ee36a7df5a89241609f624502b248b5cf710ed269a4c", + "parentHash": "0x827cbc8dc6bd4a545993d61ce2833f7baa3ffafccf0c43da845780b2c60c4f0a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9d25087eccbadc71b6dcb4f1b429c3e1e1bd74e1adaadc358dbe96706df3dce9", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x8b88e66f13eb3b1b3af037cbaf9200b8a44163830c2e16a921a5864dfaea8c65", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xaa", "extraData": "0x", - "baseFeePerGas": "0x634eb2c", - "blockHash": "0x8cd31f14889acd865b0ad0b2fd746586f29e87941166bf7087dc8bb429f01554", - "transactions": [ - "0xf88511840634eb2d8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a06eec2c18bcf77ec57bab296d887982308ce7ee01c04883b1c667d2b3f99844e0a07f927348927013d0def756a6aaeb1626cbbb82978b0238c1bede7cca96c16f8d" + "baseFeePerGas": "0x6b2f3c2", + "blockHash": "0x8be0f38f24af217357167bb37fa76e4bb07257cbdebbd7060c012dee3685a2b7", + "transactions": [], + "withdrawals": [ + { + "index": "0x0", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -548,21 +603,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8cd31f14889acd865b0ad0b2fd746586f29e87941166bf7087dc8bb429f01554", + "parentHash": "0x8be0f38f24af217357167bb37fa76e4bb07257cbdebbd7060c012dee3685a2b7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2830ff653bec149b7a571e05ee9416397aeb6f859701a4aff1e6ae20c63e3386", - "receiptsRoot": "0x271e2e5c8c30a31dfe415c355346b4698b7b3ab4fc4ecbf5602fbc12e20eae8a", - "logsBloom": "0x00000000000000000000000000000000008000800400000000000082000000200000000000000000000000000000000000000100000000400000100040000000000000000000000000000004000002000000010000000000000000000200000000000000000000000100000100000000000000000000000000000000000000040004000000000000000400000000000000000000001000000008000000000000000000000000000004000000000000000020000000000040000000000000000000000000000020040000000000000000000000000100000000000000000000000000000084000200000800000000000000000000000000004000000000200000", + "stateRoot": "0xffa52234e07c007038859c6ae172dd87b5fd80ac02c3fc9adacbf9c47f7a4028", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xb4", "extraData": "0x", - "baseFeePerGas": "0x56f6b1e", - "blockHash": "0x3e48b276f3b3209dda302780f9c8e4459d2c9378f4508c0fc4f9d26e6a5d173f", + "baseFeePerGas": "0x5dc954a", + "blockHash": "0x33cd3f00a5d4b4786f1028871a2431b2a5cc06abcc1f06d56f520c05c8d709aa", "transactions": [ - "0xf87c1284056f6b1f83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0f902fd4698ffef3b8ddc1c375497f85fe2b56388afcb636bc563116f9e87b16ea07c32cfaac5a1ca683d7f0904ad62b5ebee224cc953d113856124601436367415" + "0xf885498405dc954b8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0c3d40969eb851a36dc39dd77d4c187ba169591eb600ce686f073f53968e9bd40a077c7ccce3b8a8b1326378a2e2e303f04c25da916556897375537a8446fbd6df9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -579,21 +634,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3e48b276f3b3209dda302780f9c8e4459d2c9378f4508c0fc4f9d26e6a5d173f", + "parentHash": "0x33cd3f00a5d4b4786f1028871a2431b2a5cc06abcc1f06d56f520c05c8d709aa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5e0abc8d3e6a776260485305d8dd0c8ef63d7b25394d96c104b5c9ff579bf51e", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6136aa26f9580a8ecacc573d7362769f2a78f6acb779f9b2c84a5970378e2490", + "receiptsRoot": "0xe1449c6203504ff907027c42359f8ddd569284262e60f37920af530362fd4e37", + "logsBloom": "0x00200000000200000000000000200002000000000082000000202000000000800000000000000000000000000000000000000400000008000000000000000000000000000000000000000000000000800000000008000004000000000000000000010000000000000000000000000100008000000000000000000000000000000000000000800000000000000000400000000000000000000000000000100002002000400000000000000002000000080000000000000000080000000000000000000000000000000400400000000000000000000000000001020000000000000000000000000000000000000000000020000000000000000400000010000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xbe", "extraData": "0x", - "baseFeePerGas": "0x4c2165b", - "blockHash": "0x905f74a6377ead9037c78e9008bbb788c74c1fdb7f993b4820e24be5dde9c9af", + "baseFeePerGas": "0x521247e", + "blockHash": "0x6d69508bcfee6a79ab1f9b2654eaa9767beabc4aabd0777b4d16a1c7fe2308d8", "transactions": [ - "0xf867138404c2165c8302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa032f1d63abf50a1b102ee291e13581a0d6ce2eddf511d01a3ebeec5ce97cd839ca02dfb6796f006554686a474dee866c9ddade4b3ee3398f1d5fed3a865c098fa9a" + "0xf87c4a840521247f83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a065b92c9da324aafbf8ee7597b18a6c053420a67e5e01d4c2562a9f6532473939a07f80878b7bc0e69700b617f7b71a365cd22ee8083684c452b4948ea93eae6fa7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -610,21 +665,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x905f74a6377ead9037c78e9008bbb788c74c1fdb7f993b4820e24be5dde9c9af", + "parentHash": "0x6d69508bcfee6a79ab1f9b2654eaa9767beabc4aabd0777b4d16a1c7fe2308d8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc97170cf07d54c88244ab7495de7b219a0c5e53de8a00fedb6a1698d05c072e4", - "receiptsRoot": "0x3e5b0c08f66fb3479a54ec93bdafda95f7988f6c27dc427c3a8c0ef1e491e9f2", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6cf73a178c89645e1ba6560e820ac1f8ec2e48c5098a56aec817886392e5f701", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xc8", "extraData": "0x", - "baseFeePerGas": "0x42acb03", - "blockHash": "0x35398f9b164bfdf8f4b4cde5181a9d96bb37947181332dc7977dc2360bee6300", + "baseFeePerGas": "0x47d1208", + "blockHash": "0xdccd539eebea31af7d83c77ba7b57529a1111630bf3eff5da9eaaf3bdb06cdc7", "transactions": [ - "0x02f8d6870c72dd9d5e883e140184042acb04830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7346f7df2f4852bf656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cb55d89f2ee070d017b426876d6072d91c2a7311ade9a1bed2f8200127ec380e80a08897d5c6dc27a43adfcf912ec9c7ec1bc94763ecf00a0e0f7bb5d48a81c6de74a05708b993e4e74cbfdb940a5bf5a2a09d5a9840e94bfe40662a097bd324614372" + "0xf8674b84047d12098302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa018aaef4670194514f969dbc57def43702154924c076d18bf7ac86627a6511d83a0745918e2423a243a37ca9271170dd1b2781d3ebb10d9c6914a39bee31e2a58f8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -641,21 +696,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x35398f9b164bfdf8f4b4cde5181a9d96bb37947181332dc7977dc2360bee6300", + "parentHash": "0xdccd539eebea31af7d83c77ba7b57529a1111630bf3eff5da9eaaf3bdb06cdc7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5552828e6c3bbf0c5a79f916e732ef9b622a20bd65a36765220a2ef3eace5ee1", - "receiptsRoot": "0x9e8e0dcc70def6a3ae4631d1a635ce268a142352191bd2736faa4ea3e1ddb5b1", + "stateRoot": "0x078874dfd661d73b906ad5e4548d3927246130bb95e8a117c0d3fe9ce36265ec", + "receiptsRoot": "0xd43ad2c6a6199c3bf72c8d94db3521e4ec54a2306e4169e32b25fb1658733a52", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000800000000000000000000000000000000000000000000000004000000000000200000008000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xd2", "extraData": "0x", - "baseFeePerGas": "0x3a5cf93", - "blockHash": "0x4a4aef4730ba6155773a9e5c7e0c5f25a552d187687d59ad81b4a86c9f15a9fb", + "baseFeePerGas": "0x3ed8d1d", + "blockHash": "0xb4125effbc4875925712ea7af12b9b8efd356f9daf371e37982d9d80986500dc", "transactions": [ - "0x01f8d5870c72dd9d5e883e158403a5cf94830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c470b103921f87d93656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e9035562901a04025efe7ff5d26258dc328878721531502592da19dfa528c3fe3e4af4ae32648a02425bd922df542ec69f5e1175f7dd0193e9610d715978a5e8ba70ec06cdd6e28" + "0x02f8d6870c72dd9d5e883e4c018403ed8d1e830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c470b103921f87d93656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e9035562980a061df014fe4d23be90180a1d75fa180aa296f3823dd0dba66af2fbdbb542ddbfba01dcb0288830bc474904670db31bb73ea8e48421f8f8ce650c33ff00da97f8edb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -672,29 +727,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4a4aef4730ba6155773a9e5c7e0c5f25a552d187687d59ad81b4a86c9f15a9fb", + "parentHash": "0xb4125effbc4875925712ea7af12b9b8efd356f9daf371e37982d9d80986500dc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfc375dd0b2d82dba534d316a0ddc2fd9cce0f131e0cb2520059a96ebd4110f57", - "receiptsRoot": "0xa6d78192909ccc0689aa6ab6ad1383a53f32ab9f1941734dd79ec970c9bb581f", + "stateRoot": "0x0e0d167eecdeb9f13a37a28d9a90447fc9f903ce7ac9780a33e4ed1a37ce4742", + "receiptsRoot": "0xbe9ef7c757d2a2b1aaa03c629ce078d0e7901c24d43642a14578828946a4c3a8", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000008000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xdc", "extraData": "0x", - "baseFeePerGas": "0x33167db", - "blockHash": "0xb3c7f4d24254129c2621485e664106ca2c2d08337672a2c8e484524b6e0dd0fb", + "baseFeePerGas": "0x36fe69a", + "blockHash": "0x153171ce62d3a05bfc910c2dc9dbfe08d0b674de9053c4ba50989d55ba75545c", "transactions": [ - "0x03f8fc870c72dd9d5e883e160184033167dc830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c3e08783bf128a680656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0a585e353498ce5174d60739a0b63435439e46487cdbb28b9735d3f2f75ce517da059f052093e5d64f3343fb0b5100e76c3a990fa831d8002117638b02f4072f942" + "0x01f8d5870c72dd9d5e883e4d84036fe69b830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3e08783bf128a680656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b01a031155cd409042d494806233f781edad3fd63af1e0e26441da60518bdbba8515aa04ef6d5eac346649880a8be9e5475b1eed4d9fe25225a10159bd63e0cc9340af7" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x47c896f5986ec29f58ec60eec56ed176910779e9fc9cf45c3c090126aeb21acd", [] ] @@ -705,27 +758,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb3c7f4d24254129c2621485e664106ca2c2d08337672a2c8e484524b6e0dd0fb", + "parentHash": "0x153171ce62d3a05bfc910c2dc9dbfe08d0b674de9053c4ba50989d55ba75545c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xea3988f3c858eef128aa58daea75b61e4bf315f4dcca44bd49b3f7038efe7c9c", - "receiptsRoot": "0x489544b1af9649410f1f0b2edd686f702467f24446ecc3926b905d196f153cff", + "stateRoot": "0x875e51bd6ee9967c39df029032246575c4620111db4fb9997386398c3d193951", + "receiptsRoot": "0x2b9c45f5edbc0a1a16575d9f6914226fb1959bf5300be90abf5994350f6a8510", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xe6", "extraData": "0x", - "baseFeePerGas": "0x2cb82da", - "blockHash": "0x25e8e33978b09de34a49b2595fd3dfe13d0f8c9a8939ca6c88376292459ec533", + "baseFeePerGas": "0x301f384", + "blockHash": "0x631eb6b3e5d105379784bae7414c1a87100222dfaa82de3cbbd449cdbdddfda0", "transactions": [ - "0xf877178402cb82db830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028caaccee2fba6608ff656d69748718e5bb3abd10a0a02f5170b3be2a8b1ea396ce6d7e8328e9fc89e1feeedff915163a421f253066eba04ea5e11797ab87ab71e2affaad4f4d53addaf82345c93a050892af864870dd6f" + "0x03f8fc870c72dd9d5e883e4e01840301f385830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038caaccee2fba6608ff656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a6d01173df2aa437fb0118d181e64a8f8e05713fc01c42fbfd2250516639ae9583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a05ea87f1fc01a228fbf6854e8a91bf346502fd8fe0a0c865914cce118f8acf677a0333dc42ba62418aafcc729befb496de989106e8700d46ca92bf7ae9f17f95535" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x6d19894928a3ab44077bb85dcb47e0865ce1c4c187bba26bad059aa774c03cfe", [] ] @@ -736,21 +791,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x25e8e33978b09de34a49b2595fd3dfe13d0f8c9a8939ca6c88376292459ec533", + "parentHash": "0x631eb6b3e5d105379784bae7414c1a87100222dfaa82de3cbbd449cdbdddfda0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x94a104a2cc89c456366487a7ff541dd38b14800da5d7e74652cab2b633402a0a", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x98f98d5860f1175754c43063cf0aca259fb8a4a5a6b9d8ee4131c2d24bafdcdc", + "receiptsRoot": "0x0c0a430537eaa59021451b67574cba560be2ce825b3d200d5aa616f6030c8f8b", + "logsBloom": "0x00000000000000000000000000000000000000000000000000800000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xf0", "extraData": "0x", - "baseFeePerGas": "0x2724ef3", - "blockHash": "0x4f350577873216755df98391d69caf01ba646006d88459326e2f2bc2acbbf0e0", + "baseFeePerGas": "0x2a1bd99", + "blockHash": "0xdb9610ac987150d64e0c47bf2bf4b4b6c225f7c869a8a3c21a8b4ed42a779da7", "transactions": [ - "0x02f86d870c72dd9d5e883e18018402724ef48252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a08abdb3bb1c920c0a75c8e979079e8bfbd407843ba5aefa8ef97a88bd27329e84a006a953cb7369e2810022fd66d14fdeb5ddedf70d062975d966aa0e28bf690ad0" + "0xf8774f8402a1bd9a830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c0e394e7c8a2b32c9656d69748718e5bb3abd10a0a03ac30f903afc19ddcdfde20f7c30ea3652e1fffd337a4f90a29df20ce3193298a0663531b7fc7c3d4bbb382109f64ebcb76e400c7d2c20ba8ff4bb1dce1bd8cc61" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -767,21 +822,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4f350577873216755df98391d69caf01ba646006d88459326e2f2bc2acbbf0e0", + "parentHash": "0xdb9610ac987150d64e0c47bf2bf4b4b6c225f7c869a8a3c21a8b4ed42a779da7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe6b25116fe80c641f9ae002e38ee0885699983cff8f25515795c4d7187af561a", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xc71e0f04e779cbf8a9423909f9063cc7b1b4611b121724c1d03b7810b50df2cf", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xfa", "extraData": "0x", - "baseFeePerGas": "0x2241b69", - "blockHash": "0xec6593f4d6535e923dce8d47de08d98f8d751ea078f186072fe46b3b745d5274", + "baseFeePerGas": "0x24d8d0e", + "blockHash": "0x484dfda7c0064b4361c5bb164ab29ab46b2f6e4ad1e4d08e054cf87092c301cc", "transactions": [ - "0x01f86c870c72dd9d5e883e198402241b6a825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a0aa91f4ab09c290fb090ca2638cc97bc7af972b422ffa74f075e04865199b1456a06d7240f6be85ef4696869d78189e1d2b5d2441c4caf770b203f2ed4abf7da308" + "0x02f86d870c72dd9d5e883e500184024d8d0f825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a063abd293402ee36462779cb52b1abb2fd46339431db2f1014b32c7f82bdf635ba0314e4f4aa5069de4e5fed2e0dbc5c5e0ad4b6d6b6c19e09c6684002ead3ba833" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -798,21 +853,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xec6593f4d6535e923dce8d47de08d98f8d751ea078f186072fe46b3b745d5274", + "parentHash": "0x484dfda7c0064b4361c5bb164ab29ab46b2f6e4ad1e4d08e054cf87092c301cc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2169a20d6e248e2c5322a5b01f73acd038baf8efc185daba156bb17af84cd8b8", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xa5d4cda71b3c18323bd8e5d87601ae2b3271bde24bf03f44181538deea797097", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x104", "extraData": "0x", - "baseFeePerGas": "0x1dfab87", - "blockHash": "0xc342e54f189bd6e3099871e6ecdb5f5b85a409299decd86a08e5564e42d22aa7", + "baseFeePerGas": "0x203de11", + "blockHash": "0xb83ddbaec179e4a8ca479524a47d3ae87cf9d0d9cbf10f36e4cd27b095f03487", "transactions": [ - "0xf86a1a8401dfab88825208941f5bde34b4afc686f136c7a3cb6ec376f735775901808718e5bb3abd10a0a0bf906d9eaec05fd44a6c7c2d0b7f30d6de811ddef24d96db9e48497ff60a1484a074f6f7bf0aff7038f7769b4e1a5d35b76f72dac84e043b87ca0d90e2271b0783" + "0x01f86c870c72dd9d5e883e51840203de12825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a001d2a0dadb06d7004b8eed1d40effaab9349184c371d9dd071f6c835b14977b4a03012553df7d85cc5b48d8abc14375bd89f8b6bc4177fd9508c02ee498a992e16" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -829,28 +884,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc342e54f189bd6e3099871e6ecdb5f5b85a409299decd86a08e5564e42d22aa7", + "parentHash": "0xb83ddbaec179e4a8ca479524a47d3ae87cf9d0d9cbf10f36e4cd27b095f03487", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf764dd8c400bd0cf0de446a478e786a16d8b6b6c772ec44f55aa63335254ef26", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x29857c3c62622338c183d17a92937e96428f392d79b3f58f5139d34ebad83c54", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x10e", "extraData": "0x", - "baseFeePerGas": "0x1a3c730", - "blockHash": "0x750dd92f162fd79de0f147a4a5a6928ea06463f04ce9ccd6f85d128f726d75c4", - "transactions": [], - "withdrawals": [ - { - "index": "0x1", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } + "baseFeePerGas": "0x1c3649f", + "blockHash": "0xd17fa84bf309999af41acc3a1e006f5f9bc96a7c6bd8343f8dcd851171f89bbd", + "transactions": [ + "0xf86a528401c364a082520894d803681e487e6ac18053afc5a6cd813c86ec3e4d01808718e5bb3abd109fa03aaab096853b8b89c362af7701b60c747ce1dbda9b0d6adea14922c1fa9d83caa07677f467155ee7733eb77d144e1d282a4fab20609b9dd6bb18fbfcdc32adbac8" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -865,23 +915,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x750dd92f162fd79de0f147a4a5a6928ea06463f04ce9ccd6f85d128f726d75c4", + "parentHash": "0xd17fa84bf309999af41acc3a1e006f5f9bc96a7c6bd8343f8dcd851171f89bbd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd3cc1a6a6b477ad90f576880cd467fa97802149e48ba2976e6be835d077a8e6a", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xfabfe1983020fe6ec0e808ffe1ea76625ab329c87f7fda62c8c5815bc5279346", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x118", "extraData": "0x", - "baseFeePerGas": "0x16f4e4a", - "blockHash": "0x851dbf7f27a98cf2fc320a858b96e89bfe8af9551e4aa966cd6ed4d4b5d9dac8", - "transactions": [ - "0xf8851b84016f4e4b8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa01e147627a8b655495ffe95ecc114eeaf910bc89166f4ad45f626774a79c7b195a04c7dac20ac839c4dcaae197402b54589cff504b8dd6e8d084f90651d45193227" + "baseFeePerGas": "0x18afa11", + "blockHash": "0xf95e9ebf1649ad621dce264eb56c4695b2c12bcfdff445f4081d42a1bf35cb93", + "transactions": [], + "withdrawals": [ + { + "index": "0x1", + "validatorIndex": "0x5", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -896,21 +951,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x851dbf7f27a98cf2fc320a858b96e89bfe8af9551e4aa966cd6ed4d4b5d9dac8", + "parentHash": "0xf95e9ebf1649ad621dce264eb56c4695b2c12bcfdff445f4081d42a1bf35cb93", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd2c58f66ca2ceae3eac008458fb5396d2e3c8e80e416d66037472875a4e07997", - "receiptsRoot": "0xd072fe68030b122d6d943712a735f4d9b12048b038b38ce8ca90d3da4f3d4f71", - "logsBloom": "0x00000009000000000020000000000000000000000000000000000000000000000000000000000000000008000000000000100000000000000000000800000200000010000000600000000000000800000000000020000000000002000000000400000000000010000000000000000000000000000000000000000000000200020000000000000000000004000000000000000020000001000000000000000000000000000000008000400080000000000600000100000000000000000000000000000000000000001000000000000000000001000000000000000000000000000000000000008000000020000008000000080000000000000000000040000000", + "stateRoot": "0xb161ffc85f1cbcaf74e168a1473080af3d4ad7dd23d415558189987992e6b34c", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x122", "extraData": "0x", - "baseFeePerGas": "0x141a677", - "blockHash": "0x95d530f6e64e5b60726d6f40f995fbcb099957cfaaf2765dc78684d4fccacb59", + "baseFeePerGas": "0x1599acf", + "blockHash": "0xecb61d653cb6ebe9236bb36c31afd4637f6ebfaf9a84b53c8ab8d5557a177e57", "transactions": [ - "0xf87c1c840141a67883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a09d0cb094f38fc156df1e73cb965c52438c56eb5b3ff00a3128990667b4f8f77aa02a614f5723d63cb69b28b7faa6ab8c55807c9a3a9239d81599e48ce025f6c344" + "0xf885538401599ad08301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a09f1b35dda68089f7818f7d2bb921c4237ebfec4c808906374a28bb7d2112c3e1a01c4235777f7011088a60497dbcfee1cab58bd04119115d37748adb3bcee25427" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -927,21 +982,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x95d530f6e64e5b60726d6f40f995fbcb099957cfaaf2765dc78684d4fccacb59", + "parentHash": "0xecb61d653cb6ebe9236bb36c31afd4637f6ebfaf9a84b53c8ab8d5557a177e57", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x69347f83eaca294d85b8085c403c1e6552b39f9074d8b0907ee4ca2f1052c46b", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x06be7e1abb9f72accc6b70db7f9a573eab98ab7e2f8dff05a6d9c5fb3d196284", + "receiptsRoot": "0x94c061dc8cf44763063b10b8f8bc801f41da75cfdc7f4a26e00c609a3562689e", + "logsBloom": "0x00000000000000000000000001000000000000000000000000000800000000000000000000040000000000000600400100000000000000000010000200000000000010000000100000000004000000000000000004000080000000000000000000000000000000000000000000000000000000000000000000000000000010000000200101000000000001200000400000000000000000000000200000400000000000000000000000000000000000000000000000200000000000000000000000000000000020000000000000080000020000000000000800000000000000000000000000000000000008100800000000000000010020000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x12c", "extraData": "0x", - "baseFeePerGas": "0x11994f1", - "blockHash": "0x1da94a9b2bc22478c3c9e45591d3254ed48b2f15a68dcd86d272273bd362e1db", + "baseFeePerGas": "0x12e6f42", + "blockHash": "0xd454d2e47ddd6508e26a8e6f5f7739c4816e682f72940004b983798e9874db24", "transactions": [ - "0xf8671d84011994f28302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0ea4b870e45a695e7e157f7af87905291f11956ae897a1806c4a3f7b4a3d06c37a0468b5ac7b003d53b820006ee1c1219d7c451aa2780c04d21f7566abb1fc54479" + "0xf87c5484012e6f4383011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0f11fc2cc9d668bc2f1ce8adf2dff1ca7818b5d9e8a0e3eadabdefd42fb7e86a8a07b510479619b99b260a6d295cc0a50ea5ff303e8e350a3c3349726043092022f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -958,21 +1013,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1da94a9b2bc22478c3c9e45591d3254ed48b2f15a68dcd86d272273bd362e1db", + "parentHash": "0xd454d2e47ddd6508e26a8e6f5f7739c4816e682f72940004b983798e9874db24", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x04bfc46ce455b63d4618f74e4d8ecd958040f43843e6ad303245ade19058a95c", - "receiptsRoot": "0xfd4c826f3e7c6c8ac7c8e9205e3b6dbf4c97cf66bd1585ee4db643939a15a009", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000", + "stateRoot": "0x10dfe0fd982218a67c090422ed47c79f949401cedce7e80a8b9b41db0e7a70b0", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x136", "extraData": "0x", - "baseFeePerGas": "0xf69b87", - "blockHash": "0x0776e32e33ee61a75147584501827f9a7cef40e1198d62791acf4d7f5c50a55a", + "baseFeePerGas": "0x108a585", + "blockHash": "0xcb4c113282733de5e500f67e1e2d34dcb1f5ba78d50fd1ee64f589985cbc2e79", "transactions": [ - "0x02f8d5870c72dd9d5e883e1e0183f69b88830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cfc9e175c02d62655656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a073286395f2a86bb5537d9b45ca7c681044645f31475a11d49285d6a0f028b8f001a0348a5f9cc0dfd726dc9c9720e8e8b111b768604032a87de10a6ea140b1abd3dfa04ae302c53544f8f00dda9b71b791c5d6450e26ea5baf697afbcd46eff9355334" + "0xf86755840108a5868302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0bf0586ff59796b985d3268c815acb05e6ddaf36566f259e489a27e036cf440d8a023c7b9cdde40c3b93b2a4711ad2f09ce06afd5817a6ae347a8f93c1fb059239b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -989,21 +1044,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0776e32e33ee61a75147584501827f9a7cef40e1198d62791acf4d7f5c50a55a", + "parentHash": "0xcb4c113282733de5e500f67e1e2d34dcb1f5ba78d50fd1ee64f589985cbc2e79", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbf2c2c34b76a1bc162355b87de7cb815153c0a91a56f92d842c512a5fa61bdb2", - "receiptsRoot": "0x11a9a367c2a5ce735e23968b85f4f00c7f50f20f0b2901cc9c5b4b33b4959682", + "stateRoot": "0x2e378cbae568de2e8ec7902c5673180bac5fef3a48b50936bef95cddd8374c24", + "receiptsRoot": "0x0df732142d4ea95fe58044d306b7759fd0fbb757b3ad00be44e5c6dfb27ab8e3", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000040000000000000000000000000000000000000000000000000000002004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x140", "extraData": "0x", - "baseFeePerGas": "0xd7ddce", - "blockHash": "0x39032e04806c95bf605cab0f493454b349e86b17808b4b019a6fc264c58e570b", + "baseFeePerGas": "0xe79796", + "blockHash": "0x279a30e5b6459ce8cbb11314c86ce121cd09ccfa94e8431da318c389ced90f1d", "transactions": [ - "0x01f8d4870c72dd9d5e883e1f83d7ddcf830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb524830fb1b95fef656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce01a03a3dcce3ef39b2151f4c787cf3ad601d1b71e4659213f948f1661d8f0525c92ea055a309950e20ba06ac5d3e0e89805c14816e63153a7d3ef677407ecdd00e3c5b" + "0x02f8d5870c72dd9d5e883e560183e79797830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb524830fb1b95fef656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce80a02a6350c90c33b23b64b38353c26a0b33b4f030c0cf2246f241d9c77db486391ca040fcf9e872242a744c1daa7361c69eb0919cbc4d20a28e95d42edfb678abb05f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1020,29 +1075,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x39032e04806c95bf605cab0f493454b349e86b17808b4b019a6fc264c58e570b", + "parentHash": "0x279a30e5b6459ce8cbb11314c86ce121cd09ccfa94e8431da318c389ced90f1d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x052055733a53c0f7febb45a9d8a41a2a3dd29ca97278c35849050cf6e4fad0f1", - "receiptsRoot": "0xaba497cc3d5037548e60d91b85c707f2444349ae159036631f95fdd7869f1f8c", + "stateRoot": "0x3ed25f92d59f556698b7bb57cabe553090feb66893446b3aa7f9b319cfa5c058", + "receiptsRoot": "0x1a38ee5591dc15bbeec2de9b55d200df038a259385745527052cc81337289c86", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000800000000000000000008000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x14a", "extraData": "0x", - "baseFeePerGas": "0xbcf517", - "blockHash": "0x7bfd33d91f0f065c4c0963ef3975dfacb13ebcd3b1d9433eeba5f26320bb453b", + "baseFeePerGas": "0xcaa734", + "blockHash": "0xbfa427b49c4b9c8ac6629f2a2d1b62c0e2d3d4e793e603af64d9eb7438b694a1", "transactions": [ - "0x03f8fb870c72dd9d5e883e200183bcf518830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cbf21e84fccd0c2c0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f97083020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0dbce1c078f5374f0da355497abc98d8233dd702e63355fc66d4b77f8aa645c0da02535209ac89839a34994622ac2b9f2fc0b1f45fb08f43a5579093585c9c62caa" + "0x01f8d4870c72dd9d5e883e5783caa735830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbf21e84fccd0c2c0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f97080a0891a7f5d5aaf642d425bcb20d715704a021979d36cb724eb88d87b815a28059aa002df2e16a34ee0c18dbb1ca557831ca519dce2746e8760c2b5568e1eaf868051" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xe9dcf640383969359c944cff24b75f71740627f596110ee8568fa09f9a06db1c", [] ] @@ -1053,27 +1106,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7bfd33d91f0f065c4c0963ef3975dfacb13ebcd3b1d9433eeba5f26320bb453b", + "parentHash": "0xbfa427b49c4b9c8ac6629f2a2d1b62c0e2d3d4e793e603af64d9eb7438b694a1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x56312b12ec96358f46f673850692a02c7769fcc0af7e86e2cc6a31db672bfd34", - "receiptsRoot": "0x13bd42f63e98963d548495d33334a05c830e7aeb166aa5f1116b6601446a4685", + "stateRoot": "0x6662a1b6375759074ea267245e8fa293b084dc885a31e81435da3df797575560", + "receiptsRoot": "0x7947328dc40a62c0cb58142e2b83fd7b60da8388084cf2a6a3010d086de333aa", "logsBloom": "0x00000000000000000000000000000000000000000200000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x154", "extraData": "0x", - "baseFeePerGas": "0xa56718", - "blockHash": "0xcbeea1d0322b931091bee7d7fd49ed48d09f35324c7837f3b51c1f9e017cdcc8", + "baseFeePerGas": "0xb1548c", + "blockHash": "0x8595bd36d4362be24f82626e410c5240689ad948822510812add6669c17e60bf", "transactions": [ - "0xf8762183a56719830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cfd7bf8757ddb24d9656d69748718e5bb3abd10a0a06c07e8d0a7d3ba1f3a8dcb209e990148ed6a7f44e8263d932e6ee30b2ab5310ca05a5eca8431b6406a0910fd5dbfbce72e4b3cc8514cdfbe3b46b10efc533eba64" + "0x03f8fb870c72dd9d5e883e580183b1548d830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cfd7bf8757ddb24d9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e94d0b2545ec05c3ce3431c4d45c3b62fcab156563e8308fae1ebd27a2810c1a83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0e8addc83080c5d2bf2f7da936f4b683a6fa31da3e7399af871bfe8e34dcb27aba032921280f671f62041ed7e56b37344143cef82036baa6b17b47a0b04b85c723e" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x430ef678bb92f1af44dcd77af9c5b59fb87d0fc4a09901a54398ad5b7e19a8f4", [] ] @@ -1084,21 +1139,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcbeea1d0322b931091bee7d7fd49ed48d09f35324c7837f3b51c1f9e017cdcc8", + "parentHash": "0x8595bd36d4362be24f82626e410c5240689ad948822510812add6669c17e60bf", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2ca02337777db57a1ab0266b72eeeb951770529e1e9cdc2e150b2b9f0a1a8365", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x48c5107855960c19360eede30647cb174c36e5026c37bb2fb613d198349de0dc", + "receiptsRoot": "0x6981ee91b3f58a0d3682d3425aac8c6da5488cf1f8e5390716d80bef02faa6e2", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000020000000000000000000000000000000000000000000000000000001000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x15e", "extraData": "0x", - "baseFeePerGas": "0x90c82f", - "blockHash": "0xdaecb35565efc8fe915c286637a2f664473681e90f9ab6e05d0aa02ecdcdc654", + "baseFeePerGas": "0x9b2bf1", + "blockHash": "0xabaae2a5e966b2e2b1de55c4cd3ae9d8eed5a7a96994eb8627465ed0d9d15fa6", "transactions": [ - "0x02f86c870c72dd9d5e883e22018390c8308252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c080a03c1d323db1f685c6ffd338c17c010fd81c6fd4e142a985fbe8ddabc7f4cb8737a02d8d268af499407f139c60e3ef6e5c2b465ef86bd9912313529427ecd20cff02" + "0xf87659839b2bf2830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c95297b6a5c01e24f656d69748718e5bb3abd109fa0324005dca5a2e0d753c04b9ba3b36fc8f09dabf63a4f22f9c1ccb22c48f4fe9fa0733c734fc9a6e1d9f16602abc97ead797bbd1da81092277069ab9791626dd355" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1115,21 +1170,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdaecb35565efc8fe915c286637a2f664473681e90f9ab6e05d0aa02ecdcdc654", + "parentHash": "0xabaae2a5e966b2e2b1de55c4cd3ae9d8eed5a7a96994eb8627465ed0d9d15fa6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xed1385e367caa8d8f469626720d381eeb15cf18bb5b2d28a9fc1fb01d2a2521f", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x175e804afca7dbe19134805ce3ec22251edd4feaa8eed1e95114884d73496791", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x168", "extraData": "0x", - "baseFeePerGas": "0x7eb453", - "blockHash": "0x4accb52ae0491cfaed5866f5296d8d15233a16ffd73c91735040c58cebaf7ff9", + "baseFeePerGas": "0x87c819", + "blockHash": "0xebaf8a77d6fe68c176d3074a8f4b9c702c4b5e96b801a1410291fbe2cc6421e2", "transactions": [ - "0x01f86b870c72dd9d5e883e23837eb454825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c001a04f07315aebd92596d180363d42cb97af8cf0aa76441216f3548929b70dabeca4a03023bffff6c77cf2bebcd9139c9a938504c68bd739bd046002281a4331f1fc90" + "0x02f86c870c72dd9d5e883e5a018387c81a825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0124496e8b49822c38a85f4aa83983d04eea11983e9d12020a1a30a564bf0bd15a038da406edaaf30fc3ed0e8a9c638e84dbe04e35d0f5233a1740bb3c3c3ef50df" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1146,21 +1201,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4accb52ae0491cfaed5866f5296d8d15233a16ffd73c91735040c58cebaf7ff9", + "parentHash": "0xebaf8a77d6fe68c176d3074a8f4b9c702c4b5e96b801a1410291fbe2cc6421e2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1d19c3aacd2f657d1835d032863abbcfda8db6bba9368c64e3def4e716a05599", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xf142e4351d4387ecf5f6a92aa5b26e5c192e0478bea50e4861c158e89e090827", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x25", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x172", "extraData": "0x", - "baseFeePerGas": "0x6ee24e", - "blockHash": "0xa22225105655427813fb4e29887ef8ec1a18877bb441913fadce200903ba0f0f", + "baseFeePerGas": "0x76cfb2", + "blockHash": "0x8a76724de35afb575efb81ef8ab58346825486d654168ef5aeb2f80912e61a78", "transactions": [ - "0xf86924836ee24f82520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd10a0a0ad08245b8162c9482e8c5a0dc7a50bbd4fbcf27bcf60eb2af5f73dc82db728eda048a4a5bbaedea5004b9be5f15e7babac229a7af181cc7146d3a998a7e8e0e481" + "0x01f86b870c72dd9d5e883e5b8376cfb382520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c001a05c5ab0a8c8d2f0517b2afc28a6e1efb3747161f98622edbf553fc50f37713087a0518ace41f0e0f9e26de1bfd4bf464a701bbdb0164943acce193756ab5824f609" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1177,28 +1232,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa22225105655427813fb4e29887ef8ec1a18877bb441913fadce200903ba0f0f", + "parentHash": "0x8a76724de35afb575efb81ef8ab58346825486d654168ef5aeb2f80912e61a78", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaf9f3d14eb60e28d448c5c1177b6d23047481feae580fc5396e5165bfd370d45", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x052e4e1dfa221ec796dff3e3cc3d43f1742b7338dfacbb618b7ff36e26536a58", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x26", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x17c", "extraData": "0x", - "baseFeePerGas": "0x6109f9", - "blockHash": "0x6ad17c25de20d9f09aaff897681a87788d216791d9e33d2d4543b162f3c47423", - "transactions": [], - "withdrawals": [ - { - "index": "0x2", - "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", - "amount": "0x64" - } + "baseFeePerGas": "0x67f645", + "blockHash": "0x9463185605c120f1bbec5549f567ffb50e0a4dd1bb5d202a312640cb3faf5e72", + "transactions": [ + "0xf8695c8367f64682520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc01808718e5bb3abd10a0a0b4d96228bdd1ae700c02bab06e72db922af3b8559da9fb106aba7b35a69be5c9a03008207c3d5df936f349306843588c448eb7fe21c6fc4bf0a9305ed7bef08d2f" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -1213,23 +1263,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6ad17c25de20d9f09aaff897681a87788d216791d9e33d2d4543b162f3c47423", + "parentHash": "0x9463185605c120f1bbec5549f567ffb50e0a4dd1bb5d202a312640cb3faf5e72", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x69e1439c4d3d65155cc6997a6a8d9d64e23af139997f29f366c9fcbb4c94740d", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x009886205d2a87aa86f8dc4aa96bea797885b03905ac63134e283d483699d5f4", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x27", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x186", "extraData": "0x", - "baseFeePerGas": "0x54e8ba", - "blockHash": "0x5b65d43473b3132497d0fc75a2808f73a2808560785c6e7f55d2ac722047d291", - "transactions": [ - "0xf884258354e8bb8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa02a4cf21d43634cc09828755f9c853bd5019954d8139024fdb4edea7a37de03c1a01c6e3fe600e47ecd9c019960d38fc878cdce4937f178cac03d95fb0b257cac7e" + "baseFeePerGas": "0x5af7f4", + "blockHash": "0x817c992ddaad0c33d972ff29048a8ec435e562707950ec4c0d9fb77dbdd84ae1", + "transactions": [], + "withdrawals": [ + { + "index": "0x2", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -1244,21 +1299,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5b65d43473b3132497d0fc75a2808f73a2808560785c6e7f55d2ac722047d291", + "parentHash": "0x817c992ddaad0c33d972ff29048a8ec435e562707950ec4c0d9fb77dbdd84ae1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9ec651a3159991b6da7dfe19c6636291d50bafd2eff0a1673ad0235689da7367", - "receiptsRoot": "0x7e2b4724f582d1d4cb18b0c68b1651b6a1114918e60a553ace9bebd0b0778b72", - "logsBloom": "0x00000000000000000000000000000000000000000000000400000000004000000000000000000000800000000000020000000000021000000000000000000000000080000000010000000000000000002000000000000000000020000000000000000000000000200004000000000000400000000000000000000000000014000000000000000000000000000000000000000000000000000000000000200200000000800400000000000000000000020000000000000000000000000000000000800000000000000000080000000000040000400001080000000040002000000000000000000000000200010000000008000000000000000000000000100080", + "stateRoot": "0xfa2ab79f3edf55b5380b99be5336e14ad787788d54dcaa05c2e0745d1472468d", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x28", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x190", "extraData": "0x", - "baseFeePerGas": "0x4a5ae3", - "blockHash": "0xebf3316f9944a4d7686ca037353ab00ba9aba83839dbf6b81a1f17127bc97131", + "baseFeePerGas": "0x4f98f6", + "blockHash": "0x8d61211d9778e2315598b11c7b715f8a96a3e7b3f7242a280a590aa728a2c2cc", "transactions": [ - "0xf87b26834a5ae483011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0c5d1f9d80dc521f85c9024ee685ec13c3a8cfa793d6bfcbcd47fd4244a0b4d7aa06995f77a29ec57b0005cd8044a79b8060fa046e6264f89617f4e3bdd57ae8f7f" + "0xf8845d834f98f78301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa08dbf399f45ff95b249fcd46c8d53d5c017ce5bcc7d02e79baa2bdc679bad2f99a00ed9eb5d88e831995889ea38ae8acbaddcabac5e4c283ea003bfa1c0ac0f0863" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1275,21 +1330,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xebf3316f9944a4d7686ca037353ab00ba9aba83839dbf6b81a1f17127bc97131", + "parentHash": "0x8d61211d9778e2315598b11c7b715f8a96a3e7b3f7242a280a590aa728a2c2cc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6674d2364f011c039d71388ad814a8cc5b67b9373f0b04ea381257c780084826", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd5a77b5730c4b55882b1964206b1d8113821dbe1ab7aa4e774e8286e68e6b6d6", + "receiptsRoot": "0xf0e4228053d0e4a98c002b31036028bdc76c8866da8ad254ccc4983196cf9ffc", + "logsBloom": "0x00000000000800000000000004400000000000000000000000000002012000000000000000200000000000000000000000002040000000000000000000000000000000028000400000400000000000000000000040000000000040000000000000000000004010000000000001000000000000000000000001000000000000000000000000000000004000000000000000001000000000002000008000001000400000000000000000000004000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000048000000000400000004000000000000000100000000000000000000200000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x29", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x19a", "extraData": "0x", - "baseFeePerGas": "0x4117af", - "blockHash": "0x9a93da70b45233339e8a591567fec5e1fab43884f5b56bece2e795fb964942c3", + "baseFeePerGas": "0x45a7a4", + "blockHash": "0xcb0a318ccf7de5604a9beb6772ba12ddde924fbf0e1074246c5a6864c203c020", "transactions": [ - "0xf86627834117b08302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a05c7eb02efd38c05171b4af43db20a721c7f54087fbadabf662f1be055813d644a075cf5658966cc283f17b61be68dafe570cd75814c67977c33389d645fc37dbe4" + "0xf87b5e8345a7a583011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0ea419b94c0d56d5028977a327e643518b01c91591aeed770a425cccb247cb849a01e24556467589fea695f87fe3a49d860e6c9b6949d1dbb350c5c6f564b968ea9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1306,21 +1361,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9a93da70b45233339e8a591567fec5e1fab43884f5b56bece2e795fb964942c3", + "parentHash": "0xcb0a318ccf7de5604a9beb6772ba12ddde924fbf0e1074246c5a6864c203c020", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x35ab337c3fe3a3d6a7e5253bc5c51f9e6c257f8251fd43344e1a48d58f525a9d", - "receiptsRoot": "0x722bce83ca7ab873dd94d9f22d3df08cca281d5eec34fba8690b529983de0c5c", - "logsBloom": "0x00000000000000000000000000000000000000000000000100000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000", + "stateRoot": "0x794a080cd09e161af78f49b6aaed7a1a5a8d2f98bf3ee5c81729df3fc6517a40", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1a4", "extraData": "0x", - "baseFeePerGas": "0x3901f3", - "blockHash": "0x4087ae9e71cbdae794c137d61684e08835fa8a6c13e9e5a001163eaccf6b842f", + "baseFeePerGas": "0x3cf3a6", + "blockHash": "0x9634b9df44977f0b85afbb35da1ffd571858e7ab44f2ab3e440f920031e57fe4", "transactions": [ - "0x02f8d5870c72dd9d5e883e2801833901f4830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c29db68258899c2fe656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a035f96bc70aa62a539fa99d9153b0f8aaa4594abf70cc8a8d9018e04e39a1798201a016ee4f37bff1c0a3c97047b92910aaaee0e6b82ec659d142ff905846a2c71e93a071ec71aa535ac3a0bb492e70cb4394ad0212af2b7c3000a45e29bd59a281097e" + "0xf8665f833cf3a78302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a00261d826899befcde2c186617fd45a56062345f4a73aa8b33d3c5119986f7c56a031b2eee3d8c2cc7c2eea79968ad847553a8cb036d8069caf70364d8ec17b3490" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1337,21 +1392,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4087ae9e71cbdae794c137d61684e08835fa8a6c13e9e5a001163eaccf6b842f", + "parentHash": "0x9634b9df44977f0b85afbb35da1ffd571858e7ab44f2ab3e440f920031e57fe4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1e43cd66bda4a9c2aa6935b12ecf1051525c9f072c175f247c8d5d94b02cf2c9", - "receiptsRoot": "0x28e6deb0dbc0cb34fb9f35a37cac83443c3a4ff2c1b3266bd55c0a9ebeeff704", + "stateRoot": "0x2f2c9f6e1e8304b2ee9412dabe36312f99007622057f5900e9986d935ccbe93f", + "receiptsRoot": "0x84d61de81263a9ae82c0332b91fec6b9aece65a3b475508f0bafac05b73f0c43", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000200000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000008000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1ae", "extraData": "0x", - "baseFeePerGas": "0x31e6ba", - "blockHash": "0x9eb1dcefdae7fc61fdacb218921236acad55350bda6c209931d89b65dcfd0eeb", + "baseFeePerGas": "0x3556c0", + "blockHash": "0x9f769468769e89b9dc650168649eb0c666f70c82600be471f072caefe08c9d55", "transactions": [ - "0x01f8d4870c72dd9d5e883e298331e6bb830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ceec855297bb026a7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a089c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e5680a07de4f993b57649b9621caacf9230b83e142e5f8dcc05fe53f31d7535a99bc4b8a04db26984ed0c47d7b7077db4468503112cd850621902f1321db6de4951171933" + "0x02f8d5870c72dd9d5e883e6001833556c1830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ceec855297bb026a7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a089c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e5680a00433a43ec306f5266774cfe99da271ec19c1c4578de077d7b04e417e49352112a02cb440a099221deb207d755acf96c594c74c29542a4a2bbe7a8eb9d8f11863bc" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1368,29 +1423,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9eb1dcefdae7fc61fdacb218921236acad55350bda6c209931d89b65dcfd0eeb", + "parentHash": "0x9f769468769e89b9dc650168649eb0c666f70c82600be471f072caefe08c9d55", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x523c5a14c0fc2ea830dfb85907766c4d902eeb56315cc1802aa94c92c906abb1", - "receiptsRoot": "0xc121a079255bfaefd387d136353ea50d122f14486efe1e24d992102de7da41c1", + "stateRoot": "0x2bfa5cdb21678fe08dc24caaf048e65249c12c4f33a9ea751925f324a4b02b9d", + "receiptsRoot": "0x3583fc0e5b1a423557d4c71016a89100e46ef7f652a47871a925385ccaf5e63e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000400000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1b8", "extraData": "0x", - "baseFeePerGas": "0x2bae48", - "blockHash": "0xc0fd1e13ad5b4c7102e278a96573f8cf66809bd6c3445f5c3650189596c0d680", + "baseFeePerGas": "0x2eac80", + "blockHash": "0x4cb55e0dfa4d8e35270542ce0d83991a2b2fddd789475d675f8af1c7c9715594", "transactions": [ - "0x03f8fb870c72dd9d5e883e2a01832bae49830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c2276cc05d723a1e7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a011f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a08dba995d002055ec395867b0cdc2d2986ad057cf63108390ab1d9b4ef1cd6fd0a07f800af40435fc91931b25c9c3c3015fb09c5436c0939d66534ee8dddfc40236" + "0x01f8d4870c72dd9d5e883e61832eac81830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2276cc05d723a1e7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a011f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa01a0bcba956774ce13fc430468f7baa792a3fb1be066f4bff5c91b42bea18ed423c4a07dc200add9d8245e1673dd414410a55274b01e8380f550a4ad57a88c5df161dc" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x2d3fcfd65d0a6881a2e8684d03c2aa27aee6176514d9f6d8ebb3b766f85e1039", [] ] @@ -1401,27 +1454,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc0fd1e13ad5b4c7102e278a96573f8cf66809bd6c3445f5c3650189596c0d680", + "parentHash": "0x4cb55e0dfa4d8e35270542ce0d83991a2b2fddd789475d675f8af1c7c9715594", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdfa9d2b7cda13e260da200f697f2387095f8318b19915c94ad7633cf6f4759fc", - "receiptsRoot": "0xea990763b2324d2121505b0b74be5126cd1a040b1a13d3d0e4d04db99f66df01", + "stateRoot": "0x5067c5e9581e6ad98b545fb754f6e5b19480afbee8039230f11ebda3a3f0f3e2", + "receiptsRoot": "0x0c1073d8c51aba6619e6f1b2ee9c89a99c042612749538ccff05e390ce5e6e0b", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000020000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1c2", "extraData": "0x", - "baseFeePerGas": "0x263c58", - "blockHash": "0x84af2f9798e57abc0431d1f0156b45f6521c7720ff0215459af9fa0553eb47e5", + "baseFeePerGas": "0x28d775", + "blockHash": "0x5cda29c5e65864ba897efa8e61cbefabb0653e2c90aa6317cc66f8b7ea849855", "transactions": [ - "0xf8762b83263c59830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c580abd8a903ed7d3656d69748718e5bb3abd10a0a07c3c3d9aa157f22797519c2adcb77137a16f0a978442ad7213b31129e399269ca053840caea2b9c28f05566f931ec7cda3061b26cb4cea9f805af8353f89cf776b" + "0x03f8fb870c72dd9d5e883e62018328d776830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c580abd8a903ed7d3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06551251b96ca27f3af8a2c500d6dd1ea5b9ab7002b3d923b66db0493f4a7123e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a02f5adb260968bedf29862dd1224abbdc35c6184c3d7938ccf3d588e0df024208a00c4219fd23c6cff6f9fb31ede5fa47953e3a58fe68f9bec110cd6989f348e42f" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x7ce0d5c253a7f910cca7416e949ac04fdaec20a518ab6fcbe4a63d8b439a5cfc", [] ] @@ -1432,21 +1487,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x84af2f9798e57abc0431d1f0156b45f6521c7720ff0215459af9fa0553eb47e5", + "parentHash": "0x5cda29c5e65864ba897efa8e61cbefabb0653e2c90aa6317cc66f8b7ea849855", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xca5cbb3c9dd01d9af5180eae51d6d8f564132488f10c5d85f2aad41f76c62563", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc6a9cb94f56b6bcc3165bb550fd7faa650023515adab2b2975271d31e0308d04", + "receiptsRoot": "0x339d975219ef9a145e813a6df1e3ffbacc69a5b4bac7146356aedca4dca023f4", + "logsBloom": "0x00000040000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000008000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1cc", "extraData": "0x", - "baseFeePerGas": "0x217809", - "blockHash": "0xcb33361cca9889678cb7c5fe9a4fe345d929cc71e8f6e53e5cd310820e01dff3", + "baseFeePerGas": "0x23bcfb", + "blockHash": "0x4fab41210b0a89ad65ef56cccce7146b0c7792e631cb57f9d45f2c390c0930e8", "transactions": [ - "0x02f86c870c72dd9d5e883e2c018321780a8252089483c7e323d189f18725ac510004fdc2941f8c4a780180c001a097d5d861629fb7c4c15662cb0459b76abc9217b963ffa402806e8a13235e6c3ca006f42c3ec85ac47fc5eae74bbfb58c55d113ca213b6d8a31b9b284f4c53606ee" + "0xf876638323bcfc830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1652c4d6db8ff1e1656d69748718e5bb3abd10a0a078526c3e19804e68c0fa3f35a65313654a6abcd8dc081a25936f97ae21e96345a032b8eea38263558ac3c8a13f03bdb1f888fd54018bacf36c47501a9015fcb885" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1463,21 +1518,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcb33361cca9889678cb7c5fe9a4fe345d929cc71e8f6e53e5cd310820e01dff3", + "parentHash": "0x4fab41210b0a89ad65ef56cccce7146b0c7792e631cb57f9d45f2c390c0930e8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x539e0d194f8e6bfb6c425d7f8753df0d75fb12220efdaaa621e7ef7c97327a38", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x4f2ae5c737d65adeed947135195017ffd5be54da2d42d61f17d81637d1f5bbfa", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x2f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1d6", "extraData": "0x", - "baseFeePerGas": "0x1d4a3a", - "blockHash": "0xef24d6293c96bd11abe059e96317856581f1736cf94786dbc0fc0d366df430af", + "baseFeePerGas": "0x1f45bd", + "blockHash": "0x7bab3d8b7342961697225b52e7d8bb83b46cc34903907b0e4661947eb109afdc", "transactions": [ - "0x01f86b870c72dd9d5e883e2d831d4a3b825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a0868fba18eb3230967166a7edbdc2504c2d1efd0d49f778d4a60e8b0db2587028a016086a90bb652179a93788f55823d5d8d8ca3fcf22e7e36dbf6c45eec6bdae67" + "0x02f86c870c72dd9d5e883e6401831f45be825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a01748da08db49d847acad96b1d4af30504d6eee036ab35f8828a4c2e4f21d21a3a03ba294f61faf848a43c69a3dcadf78a45734c3e46b40ae6e9fa4b37606b58b0b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1494,21 +1549,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xef24d6293c96bd11abe059e96317856581f1736cf94786dbc0fc0d366df430af", + "parentHash": "0x7bab3d8b7342961697225b52e7d8bb83b46cc34903907b0e4661947eb109afdc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x48b9e8211c2ddabfb64514a6e5dc2f63fabe2bad8a06e9a8b553c43a60b13718", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xf6394085c8ebd8e530dd4f89b4dae409c07a8035264dc316fc6450fe8ece4132", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x30", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1e0", "extraData": "0x", - "baseFeePerGas": "0x19a1ff", - "blockHash": "0x95d87d14848a52aae340beecba232b70e909de98a3e2648fd44b66b73f7e12f8", + "baseFeePerGas": "0x1b5d2a", + "blockHash": "0xbfeba0d543fa88ab54802a9d5206fd41b5718136dfd21a9c821efb609698750b", "transactions": [ - "0xf8692e8319a2008252089483c7e323d189f18725ac510004fdc2941f8c4a7801808718e5bb3abd10a0a0847f750f8cd8a5d53ccb55b2b59b1c8aed393e7eef8cb47abdefe512f4b21548a04b7305134a0b0043633b2f39f5d80333a8355e51d412735d78de08afa3f4b410" + "0x01f86b870c72dd9d5e883e65831b5d2b8252089483c7e323d189f18725ac510004fdc2941f8c4a780180c001a0029616fc18705b16b8c9b4e8bc43e76f2fd38183a6fa0dae10667282f8d67b88a03b7a41fe2c99b08eccf79a8b77871a09e796e8224360a0960c4b7054aacf718a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1525,28 +1580,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x95d87d14848a52aae340beecba232b70e909de98a3e2648fd44b66b73f7e12f8", + "parentHash": "0xbfeba0d543fa88ab54802a9d5206fd41b5718136dfd21a9c821efb609698750b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf439de1a0caaaebf3494a15de8803730dc41ac7ccd216cff2a4dcb7230581d44", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x4528ce89fc87b464a0cdf50e2ebd92a622451c4bf29236f3d5d94b7dcda48ebb", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x31", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1ea", "extraData": "0x", - "baseFeePerGas": "0x166eaa", - "blockHash": "0xb5e2e62689ca47b11879ba997cd532c410ab09f03719817fd33dc6923d990a03", - "transactions": [], - "withdrawals": [ - { - "index": "0x3", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } + "baseFeePerGas": "0x17f1a5", + "blockHash": "0x0050e8364ebc7a92e7caf312e0b10aa59f685d32073de47561185a14dfb3fce1", + "transactions": [ + "0xf869668317f1a682520894d803681e487e6ac18053afc5a6cd813c86ec3e4d01808718e5bb3abd10a0a0877c2154ffb76b5feb76e93d1c93398c99ec12a16f88fbde76d0fb89dd133556a004909a51d865376fa682042d498affdab8ea4f47a9c3870010e18b7c2c8a54b0" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -1561,23 +1611,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb5e2e62689ca47b11879ba997cd532c410ab09f03719817fd33dc6923d990a03", + "parentHash": "0x0050e8364ebc7a92e7caf312e0b10aa59f685d32073de47561185a14dfb3fce1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x253153c88c427fd59bb0022d9ee7e77c1c82ad3df936e4adcddbac5606b68ddf", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x5254811a5c2755a7ac85595209aaeec699ff0bd3930d86610527317f83d05563", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x32", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1f4", "extraData": "0x", - "baseFeePerGas": "0x13a0d5", - "blockHash": "0x56110ba58fe532a71688f5cb3ff7129f7e9636d4aaf69a4347f70299b6f21a22", - "transactions": [ - "0xf8842f8313a0d68301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a06084bb9d0485fb800f9fe54ad691985f8b129c9a041f731d464e6a69a62ba9c1a01b4e93d85984bd5c0dac90720de54f0482ac2cd9c9177650ebb85a4c29833c53" + "baseFeePerGas": "0x14f38c", + "blockHash": "0xcf0550d9f0e956ea4aea8fd5d4412812acb72922b3c6bd47c8a0086bd0c4abf5", + "transactions": [], + "withdrawals": [ + { + "index": "0x3", + "validatorIndex": "0x5", + "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -1592,21 +1647,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x56110ba58fe532a71688f5cb3ff7129f7e9636d4aaf69a4347f70299b6f21a22", + "parentHash": "0xcf0550d9f0e956ea4aea8fd5d4412812acb72922b3c6bd47c8a0086bd0c4abf5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc8862c70a77a3de6bbc1d10421e0125c3e711c9bd6d4f9357e1ebdcf97757185", - "receiptsRoot": "0x3a82faa3f7e8c825464303587a1e69b4bad3780148937c8746f832aebb601f7f", - "logsBloom": "0x00000000000000000000000000000000000000000000000000020000004000000000000020000000000004400000000000000000080000000000000000000000000000000000800000000000000000000400000002000801000000000000000000001200000000000000000000000000000000000000000000000000000000000000002000000000000000200000000000000000000400000000000000000000000001000000000000000000000200000000040000000800000004000004800000000000000000000000000000008000000000004000000000000000000000000000000000000020000048800000000000002000000000000000000000800820", + "stateRoot": "0xa3ac0f155614dfcf08a5284382b3352011663fd33c8cc2a7422be722f30f542a", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x33", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1fe", "extraData": "0x", - "baseFeePerGas": "0x113041", - "blockHash": "0x2e693ca7593217b296154d482519dd780931e96b006b2deb05490fc2375c8c92", + "baseFeePerGas": "0x12551b", + "blockHash": "0x80994d3ef7108fd26e8124978fbad74e9223d3205785161c272f91311e7481b9", "transactions": [ - "0xf87b308311304283011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0ebf28cffb555f6149bccfa9a4e6e960534d962c25699da92f3467dcadd4f65a1a02e18b53fd5d4b16988e165ab3396984f33958aec50064099cba0056107c6c647" + "0xf884678312551c8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a001e316cedf4998e68c19455626c86444d00ee8de19af86d9343d5197fc602872a0302ee512ee50e575f905ccca9b087afca4532b9114325b703e1d0c5a9749309c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1623,21 +1678,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2e693ca7593217b296154d482519dd780931e96b006b2deb05490fc2375c8c92", + "parentHash": "0x80994d3ef7108fd26e8124978fbad74e9223d3205785161c272f91311e7481b9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x21ce67a7cbd6ace7dc42fb2e8c98a63ca87ddb33a0ad3a31b16ffc2bec255c65", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x4dc84b9445ef8b7f20493698c0acaadf021d02a3c4146d03915edb63d5699391", + "receiptsRoot": "0xe787458a52a5467278d4d6772533ece20b0cd70e458347d122e98995c73f85cf", + "logsBloom": "0x00000020001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000004000080008000000000000400000000000000000000010000000000000000004000000000000800000000000000000000000040000000000000000000080000000000000000000000000000000002008008000004002000000000000000000000000000000000180000000000000080000000000000000000000000010000800000000000000002400000000000200040000000000000000000080000001000000000000101000000000000000000000001000000080000000000000000000000800000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x34", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x208", "extraData": "0x", - "baseFeePerGas": "0xf0c1c", - "blockHash": "0x919d586bdedaf4fb38996e5a32eaa14f753a1babb1da62c6d0aa2035005b5d86", + "baseFeePerGas": "0x100ae2", + "blockHash": "0x164df48af3dddb7478b82f0c716a3e991ce37c2c13a60959409e4e1ffd139f49", "transactions": [ - "0xf86631830f0c1d8302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a03ea49161c9b977393c9d765e2286c1142f8529323b7ef0e6b68dda28f1239603a032b36762398e02c8368d0fe69ec76b5fba945c136a7e06304a58cf2b1b62729a" + "0xf87b6883100ae383011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa06ada20d747ecb015772bafb3195f0fdb8dfe7c11d4aa4ac79bb24002bb932b72a05275dca89d6591422a4e1f80843c15f2c09c3ac8e54141c77df9e12c3c63e697" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1654,21 +1709,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x919d586bdedaf4fb38996e5a32eaa14f753a1babb1da62c6d0aa2035005b5d86", + "parentHash": "0x164df48af3dddb7478b82f0c716a3e991ce37c2c13a60959409e4e1ffd139f49", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xda4cd278427ad08c2147716f414b9daab40231ade9fcb1d42baebb8e4ba56d46", - "receiptsRoot": "0x46c9ff6a21405f72ad433e6b8aa71b50f3fb0a5c7fbeb964cb561cfa5fd3cf7e", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000001000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000020000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xba18c47045f1d22f34df69c0e3450a33254bea64e1191f1fa2754b6b30bcd49c", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x35", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x212", "extraData": "0x", - "baseFeePerGas": "0xd2da8", - "blockHash": "0x978425ebd54536bfd17945cf57726cd02fc25b083bc9332b7b4c8a94c37762bb", + "baseFeePerGas": "0xe09bf", + "blockHash": "0x2c22e6b47f0dc7b95265f02e285984be0c2d2462a9646c69b0c7369b93ab859b", "transactions": [ - "0x02f8d5870c72dd9d5e883e3201830d2da9830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cac2ee5432174b752656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0efcb86facadbec33b8779888975eacca8f44a9073a845521617f1fb30e1ac81801a05fae983b0fa627652888859db16b05d933c27604a4c193629f58fac19ee73d12a05419fe7056d1fdb665bca996c17944711f339966334a962f767133687b832fa7" + "0xf86669830e09c08302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0f51698fb9c38430a1243bc7e0c35434f6fae3ebd8cc290d26b34450bb0706c3aa02206c685b7506d874c925fbdcab9afd49f90df6c8ca816eb1222d11109a39e03" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1685,21 +1740,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x978425ebd54536bfd17945cf57726cd02fc25b083bc9332b7b4c8a94c37762bb", + "parentHash": "0x2c22e6b47f0dc7b95265f02e285984be0c2d2462a9646c69b0c7369b93ab859b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0810e4cc0f16ec17edf78a400c8efee493c863c7ef2ed760356855e7298e4fea", - "receiptsRoot": "0xa7bb91000287f7c0128087719cc6ddcd616ab350484fb520e76b6e581d5ebd25", + "stateRoot": "0x7da858bd9ffeecf4bdc441ba8fdbb63a257bfe8ff7a0b563a5e2884e2002efe0", + "receiptsRoot": "0x6928e95da80558d961c0a6dc15e81d34f230bf4d42d763d26e5bd89d47546b3d", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000002000000000000000000000004000000000000200000000000000000000000000002000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x36", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x21c", "extraData": "0x", - "baseFeePerGas": "0xb891d", - "blockHash": "0x808ecd5038418740fc4b27954cdd2e4952569e8062b846b5cdd234b1eaaf7795", + "baseFeePerGas": "0xc48e3", + "blockHash": "0xc11fc865b8f4414834cdc0b3d92d5ff380c8078f3b61eca63c3f05a33d0ed9b7", "transactions": [ - "0x01f8d4870c72dd9d5e883e33830b891e830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5201fc7d087c0d9b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce501a01810fe081a9df9de52cf2baaed3f136cdd16ed6fb3c860aa71f41ba7096ad1c5a06c9e05751e206ff38b9e192289b24bf8962d77448351b1f35dc5b431ebdc0636" + "0x02f8d5870c72dd9d5e883e6a01830c48e4830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5201fc7d087c0d9b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce501a0e0966f74387580c0164cf8efdeebae697624386c6ed5a2697c88847737accf3ca00fdaa5809b2728a85d7652c435e864bff6af5c092429b2741ff25fae8019368e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1716,29 +1771,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x808ecd5038418740fc4b27954cdd2e4952569e8062b846b5cdd234b1eaaf7795", + "parentHash": "0xc11fc865b8f4414834cdc0b3d92d5ff380c8078f3b61eca63c3f05a33d0ed9b7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe24e18212ede77b435698b2c3edcd891f73d208151d14021bdb894c4f944f6e5", - "receiptsRoot": "0x2798a949b707f2f5df2e046ea3e8bb201e9d6f7b10018f2d35c5ec9fa80c8885", + "stateRoot": "0x995f953236c31742eed6d6ce7d0ce6c0e1381f24aa773f4748b605cb204943a5", + "receiptsRoot": "0x7f635468d01df617f5f6bd5abf3a1015737db6cbd860eefac9fa3f24bd4e6037", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000004000000200000000000000000000000000002000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x37", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x226", "extraData": "0x", - "baseFeePerGas": "0xa18fe", - "blockHash": "0x4313be4af809c236c319dbd5dad18e0d030f610e7e4cacef0ff8b26af563b046", + "baseFeePerGas": "0xabfea", + "blockHash": "0x7f47b785f867aacca1b27d55186dbb6a7a9a6b83754e6d2d0d2b9f1698f32f27", "transactions": [ - "0x03f8fb870c72dd9d5e883e3401830a18ff830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ce62b8536019651e7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a08460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba2283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a099dc58693b7dfd97272436ef8a2bab266caec51f233baa1108f5885449eb4f2ca06c0d1d946a7c787695511505281cce9c65b4e6ab824ea52b608399c8013460c5" + "0x01f8d4870c72dd9d5e883e6b830abfeb830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce62b8536019651e7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a08460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba2201a02559b89237cbb7c1c024467392c1083aa32590e8e8d0d9a28df74485e2c75af6a00f08ec235061bcd8b3f1bb17792dceb30a5284b27c258a619fb14238a0fc5a53" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x217e8514ea30f1431dc3cd006fe730df721f961cebb5d0b52069d1b4e1ae5d13", [] ] @@ -1749,27 +1802,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4313be4af809c236c319dbd5dad18e0d030f610e7e4cacef0ff8b26af563b046", + "parentHash": "0x7f47b785f867aacca1b27d55186dbb6a7a9a6b83754e6d2d0d2b9f1698f32f27", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8e5be0f31660f917fc9ef594f2952008faf8b5b7d86ebde604cc2d12ca6934e7", - "receiptsRoot": "0x8a60bb1e24339f5115c680df6608b457500fc8f3313d738aacab165a72e6e978", + "stateRoot": "0xddce5378bef297b245d35e3795388f10c00044b010a89f4a354bee02175cfc9c", + "receiptsRoot": "0x87a409cc89dd0fd67b46999dc1d3c04d4fe154f7d31ac7f1d5cc32dab0b0d4a7", "logsBloom": "0x00000040000000000000000000000000000000000040000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x38", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x230", "extraData": "0x", - "baseFeePerGas": "0x8d6c2", - "blockHash": "0xcad24a57225330d06226b15cd3b5be7b0f2a42fef155e489994f7026f79924f4", + "baseFeePerGas": "0x9680c", + "blockHash": "0xc0df0d295b403cc825a0825f741923f806f603ff53aafcc04f6b91f39dd35198", "transactions": [ - "0xf876358308d6c3830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c74fb911b03a9f447656d69748718e5bb3abd109fa09b1980b11de8f043e965487b78594b788c64434b74d434201051bbfc4f2472c6a068aa5f4cb9982931e79579100e0fd5ac4c0a6ee46a7a09dee7fe150f900dee95" + "0x03f8fb870c72dd9d5e883e6c018309680d830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c74fb911b03a9f447656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0fa29cff134420b6526f434ab690a9c3a140aa27b8479ae3d8d83b6c799acbc2383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a01b75abfd139972c90f4493f3e7b818e9437ad4db371d961862f09b73b38b4778a020bfca36ce5c2e2c4800663aa36e4a9154486712bdefd8ed5328b63e3c33f942" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x14b775119c252908bb10b13de9f8ae988302e1ea8b2e7a1b6d3c8ae24ba9396b", [] ] @@ -1780,21 +1835,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcad24a57225330d06226b15cd3b5be7b0f2a42fef155e489994f7026f79924f4", + "parentHash": "0xc0df0d295b403cc825a0825f741923f806f603ff53aafcc04f6b91f39dd35198", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xabe5b798fd9af1679cb95f39a37df8944585ad8cebc7b8ea81a2b372d9d55e12", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xa7cea7741eaea66430085cc95526eb540432857dcd8c2301aa432fbbf6b65ffb", + "receiptsRoot": "0x99ed340dbe91050b3fc6ca6aa348f7c1b8bc0a85be44d8e3c6c14c810a8c1ce6", + "logsBloom": "0x00000000000000000000000000000000000000000200000000000002800000000000000000008000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x39", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x23a", "extraData": "0x", - "baseFeePerGas": "0x7bca9", - "blockHash": "0x16e634e48fc62762ce8fc1762c6bfd34e94b3533b98a5fb1bbd504b131a64a65", + "baseFeePerGas": "0x83b26", + "blockHash": "0x9f7f274336bcfaf82e4f7696590eb831dee46dbe71821c14a197810edcb2834a", "transactions": [ - "0x02f86c870c72dd9d5e883e36018307bcaa8252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a0e3cd72920d622e7c8f3317d1f8a8387e25524d15f7e5fa54b2376f750236cf4ca013736138281feef80a6a77396ab234e03d09b82ca141d8b26fa24af15063d135" + "0xf8766d83083b27830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd3e32cccb15d8b65656d69748718e5bb3abd10a0a0ecc2f008ce3a742e1b054d0bf507156b897156a4ed0598daef1e4a9ec2d1a481a007da830d27ff00aad22718653bc3cedcf22082b248f07d2f878a7449abb84b1b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1811,21 +1866,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x16e634e48fc62762ce8fc1762c6bfd34e94b3533b98a5fb1bbd504b131a64a65", + "parentHash": "0x9f7f274336bcfaf82e4f7696590eb831dee46dbe71821c14a197810edcb2834a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2fd54e41658c7a7134d46b16e8152a342d2e2993f81d8ab2dc0f25448e248b9e", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xb247e20af3081900fffb8529138f90154b9e6bf4ee70e3afae3d85245415f3de", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x244", "extraData": "0x", - "baseFeePerGas": "0x6c55b", - "blockHash": "0x39f1c7f651e1970418fd8a5e0786c83e813744d55ea965e7902112bc02f190ec", + "baseFeePerGas": "0x733d8", + "blockHash": "0xabc3fbe0c41b79c30f91b2834dfa28a2a3ca23aff7505b53ef5383f3fef45987", "transactions": [ - "0x01f86b870c72dd9d5e883e378306c55c825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a018d4576c526d8b56ab73d3ec9929d86808d13d3e3c88a45a5ae82c590d492c7ea00cbd53212b5b966bc6af503f738b7f9ec274225664c2d75e15f6a701a24ba9f1" + "0x02f86c870c72dd9d5e883e6e01830733d9825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c001a02db9ba21034d6d62a8b1997c6beb5ce965cbb5f6a011e75c00674cd452858126a0586e8d8ef2601881468ad3b2fc6b663781b528a93727175a8fdb50633208959b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1842,21 +1897,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x39f1c7f651e1970418fd8a5e0786c83e813744d55ea965e7902112bc02f190ec", + "parentHash": "0xabc3fbe0c41b79c30f91b2834dfa28a2a3ca23aff7505b53ef5383f3fef45987", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfbe509b0b3251cebdcd95315fbbcb61f913a524602d35c03b5f270b667108f3a", - "receiptsRoot": "0x642cd2bcdba228efb3996bf53981250d3608289522b80754c4e3c085c93c806f", + "stateRoot": "0xb05cfb0b57d2beb5b6ff5a361057afef5a11ab641b7f90073e856d848e0e1114", + "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x24e", "extraData": "0x", - "baseFeePerGas": "0x5ecee", - "blockHash": "0xceccf9166834bac24869c590390335f72c85c59a1553be2d99db38b039bb4c99", + "baseFeePerGas": "0x64d66", + "blockHash": "0x761bd27a0e51092eee4eaa4a545708b2df734d240ec2e5909e784e478752626f", "transactions": [ - "0xf869388305ecef82520894eda8645ba6948855e3b3cd596bbb07596d59c60301808718e5bb3abd10a0a03ec04936103192dfdb6ba9599584104a1a1af9d46f81c4ccefda71f2637632dba00c983e0ddaec1491cde1f892944cd420020d6a4ffab6a8206404c2f4e562f6bd" + "0x01f86b870c72dd9d5e883e6f83064d6782520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a00de2602b708e8efb0cfd73660ad2dda2e5e1602ab9de18dd725e1c005bf7e50ba00dd41de8f8fb6ed0f5adeb0ef8718da775cad6ce8585602d584c39e455ad2804" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1873,28 +1928,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xceccf9166834bac24869c590390335f72c85c59a1553be2d99db38b039bb4c99", + "parentHash": "0x761bd27a0e51092eee4eaa4a545708b2df734d240ec2e5909e784e478752626f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5b7a9350c65fcf4bc55005baa15c44063e165fb4ac7c1f53f13fbf9363b608da", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x8a768be0bdcd6258f177e1fa0b68d6a2ceae367186afeb3bd14ca23bfe50d4e5", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x258", "extraData": "0x", - "baseFeePerGas": "0x52f87", - "blockHash": "0xb8c495461332ae67504ee899542ccf73e859f73c6682fad15415743f15b7f5e6", - "transactions": [], - "withdrawals": [ - { - "index": "0x4", - "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", - "amount": "0x64" - } + "baseFeePerGas": "0x583c1", + "blockHash": "0xfee26a4ca9c8d56be94795b13f522d026f47a749fb3969c5f5ffa7465acefd36", + "transactions": [ + "0xf86970830583c282520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc01808718e5bb3abd10a0a0adf6eef3b27cd6d5ec8de3fa62efb9e9217693837fe48bb007d00b822458f8a4a05c37acc91f44d9ae418a88e72eb7fba781def6146cb447544ce6763dfa39aaaa" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -1909,23 +1959,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb8c495461332ae67504ee899542ccf73e859f73c6682fad15415743f15b7f5e6", + "parentHash": "0xfee26a4ca9c8d56be94795b13f522d026f47a749fb3969c5f5ffa7465acefd36", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeef64cf4a7bb430d2200064c49eb11996795bdbb68fc4af5398a582c4be86ff1", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x3dba76642c4eb32df53e7f15deb6e14cd5f314893d6d84b98c82cf6875249e66", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x262", "extraData": "0x", - "baseFeePerGas": "0x48997", - "blockHash": "0xfe4445a66aeaa138c2045c340fffae7db7f7a49b7a31df8b8b5f5aa431c58546", - "transactions": [ - "0xf88439830489988301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa038216928b5f6a70e1cf134bb6c9a951de7c2817fc38b3f86949550175a859fb0a043f7d04317166f2d72e9cfd988bcf737ffc95a343c9733f11b288021f523a5ac" + "baseFeePerGas": "0x4d350", + "blockHash": "0xd99ba2e7fce99a98dec8caee0bf6422887042e79facfcb081e4c5d04a3f8fdb6", + "transactions": [], + "withdrawals": [ + { + "index": "0x4", + "validatorIndex": "0x5", + "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -1940,21 +1995,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfe4445a66aeaa138c2045c340fffae7db7f7a49b7a31df8b8b5f5aa431c58546", + "parentHash": "0xd99ba2e7fce99a98dec8caee0bf6422887042e79facfcb081e4c5d04a3f8fdb6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0e3c5c9b3160c6b8d8951ca6b10c478d32c9d7bfd6e62c363054554fd9ddb9a9", - "receiptsRoot": "0x0c764fac3f63a25bae530d64f6553466d7a33565bbfc2aeb58e88cd53d2f1e3f", - "logsBloom": "0x10000000000000000000000000000000000000000000000000000000000000000000020000000040000000000000000000000000000000000000001200004000000000000000000000000000010000000000000000000000040080000000001000000200000000000000000000000000000000000000000001000000000002000000000000000000000000200000000000000000000000000000000000000000040000000000000000000000202000020000000000001000000020000000800000100000000000008001000000000010000000002000010000000000000000000000000000040000010000000000000020000000000000000006000040000000", + "stateRoot": "0x25d950bb56cc65ee4c44f70dcb9894858d2a8433c6a6972307e9065d13f86416", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3e", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x26c", "extraData": "0x", - "baseFeePerGas": "0x3f935", - "blockHash": "0x0f13f717c99151d8b5b509af5cacb5313f1ebf813d7a6b37764cbe1ec0459beb", + "baseFeePerGas": "0x438e6", + "blockHash": "0x1ac60d9a0fbdd7d5779432344ddb1cc080b7d70d8049631e9a5767f94dfc0fb0", "transactions": [ - "0xf87b3a8303f93683011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0b2beb8e7391a9ac3ede139938af3c58f6916107ba6daf327a8964b4f6d273a8fa05561b70ac9189628fd0beaa4547deec02c2fa58766fcde758de4bb2ac93e2d35" + "0xf88471830438e78301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa057079c9077c3232a4f91efd2b4f84dfce1a679facf8c6290c59b2548d2258f97a008023fccd46ee398d35a5f82e4d0663a96bada0efbce6f6dcb4c47ab3ee10c60" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -1971,21 +2026,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0f13f717c99151d8b5b509af5cacb5313f1ebf813d7a6b37764cbe1ec0459beb", + "parentHash": "0x1ac60d9a0fbdd7d5779432344ddb1cc080b7d70d8049631e9a5767f94dfc0fb0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x365f7c27afe4331fd7832a76194f6da1222367f343ab73aabd703d7cb320beae", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb034aadc849aa478d255949d503c0d25679dcfbe117545e5f4094bc426cebe5d", + "receiptsRoot": "0x1efb5076ec1f4f5cb2b603c551c50de2f00dae69dcfa5160a217576a9f6551de", + "logsBloom": "0x00000000100000000102000000001000000000000002000008000000000000000000000000000000800000200000000000000000000040000002400000000000020002000000000000000000040000000000000000000000000000000000000100000000000002000000000400001000000000000000000000000000000000004000200000000000000000040000000000000000000000002002000000000000000008000000008000000000000000000000000040000000000000000000000000000000000000000000000000000000000100000000000000000000000000101000000000000002000000000020080000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x3f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x276", "extraData": "0x", - "baseFeePerGas": "0x37a7e", - "blockHash": "0x2e33aeb9f45e7cb955774b6b43df2c3a438c5aa03a69f90793f137ff5d2eb49e", + "baseFeePerGas": "0x3b1e2", + "blockHash": "0x0592a18e16fdecf8028cfd0172fbd99a44287f9fa77970a947623c4305aff927", "transactions": [ - "0xf8663b83037a7f8302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0330d4dff22fc1215cb9dd37e6c0e4f5f5b8b343901decd1dc090217a1a30780fa0634cd91aecc44473bde30fc756a8d35b9ba50c8f70e199469cd4c48666724b23" + "0xf87b728303b1e383011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa03cdf945881ecaa78ff016a6f8ec7e26cc8ed55984d846133e2f8158839c6f9e4a025d0995c64961fc82c032d3236de123ebb467551301d2d925c53572e5e3df84e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2002,21 +2057,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2e33aeb9f45e7cb955774b6b43df2c3a438c5aa03a69f90793f137ff5d2eb49e", + "parentHash": "0x0592a18e16fdecf8028cfd0172fbd99a44287f9fa77970a947623c4305aff927", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaa1f9542e99b8fc7584926efd625552d9a0b49ac0737ef2ef01f2a328c0b3d07", - "receiptsRoot": "0xc9510b4222f446bd32f7fc5db4f3d25c48644389a56e3f38da4bd0e8e85ea5db", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000009000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x765a22e55593f83268d99b38f8a055963be0b8e886293899167fc7b2c63a7858", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x40", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x280", "extraData": "0x", - "baseFeePerGas": "0x30be4", - "blockHash": "0xf496b8d4d19037d646dcbc3796d2a28bf176488e2e238107feaa0b4b7f5ae6a5", + "baseFeePerGas": "0x33bb3", + "blockHash": "0xe276709cf0da03abbe0672cd6542c8823ba1a79ced1d077331d26a4bfbe4664b", "transactions": [ - "0x02f8d5870c72dd9d5e883e3c0183030be5830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6c744aeee3965d5c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0905cfe802dc4c667312ea08fdbe97798b88cfb11049ade2b18ad9001e8b6dd7c01a08108fba0b09bd2524b990bfdb8859c61415ce9fc89c5a74c6646c006d48cf063a07e42d23500741f1c090ef29678d3ee14ebab252ee22b7b2739b7f247d6f77726" + "0xf8667383033bb48302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a03064d3c81552b2f7c755a56e3679ebcb88a0bf3f13e813f602bb295e0296387da06bdcc96db69bd03db606db527de86f95db09095a11a8e79164de8a4c08da57f5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2033,21 +2088,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf496b8d4d19037d646dcbc3796d2a28bf176488e2e238107feaa0b4b7f5ae6a5", + "parentHash": "0xe276709cf0da03abbe0672cd6542c8823ba1a79ced1d077331d26a4bfbe4664b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6a74cc114b3893db5aae2f6053f8dc07aa202d92809edeaa5c992d6ec64de2d4", - "receiptsRoot": "0x642c1186627a30db8aca0880b5a4e4898347733004fcba0261730af52e7f84e9", + "stateRoot": "0x4f01b084f910cc06f872778327aa44fe90539990dcd5c91b72543a3113ad75a5", + "receiptsRoot": "0x2e9c0e40c154746c3b1ce61786b868384f1c7545b0e7a8b50fb140c45ebce26f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000804000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x41", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x28a", "extraData": "0x", - "baseFeePerGas": "0x2aaad", - "blockHash": "0x49005c56e2c43c7d5d10026c97dce5b3b2e4a38eda72b6db3e544d2e92c12047", + "baseFeePerGas": "0x2d452", + "blockHash": "0xdc32af56e34daa6037e96a2990d6485815b9dbb16ed0fd48e19e794b16d78d52", "transactions": [ - "0x01f8d4870c72dd9d5e883e3d8302aaae830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3f2b9739dd517491656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb380a01e0726157040be97d0fc732cfe43a33f37d3c7023ef5506a6ddc70c382a86568a059b0b6972511633af465bd1361ab7150667deb1069d0d257f6f2f2a7ab02235b" + "0x02f8d5870c72dd9d5e883e74018302d453830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3f2b9739dd517491656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb380a00945194e5e0e0e8f8d4beb2742ced81be8ccf85bcc21421034985cd93cda13cca037b277e7ab9549fac0f305fd40ecf1684db94b9445a306488746b6e023277d6a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2064,29 +2119,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x49005c56e2c43c7d5d10026c97dce5b3b2e4a38eda72b6db3e544d2e92c12047", + "parentHash": "0xdc32af56e34daa6037e96a2990d6485815b9dbb16ed0fd48e19e794b16d78d52", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x14b3123c5e05edc308b317830c11696e3a852faacddfd3c797313e76f3e8d4ac", - "receiptsRoot": "0x336f42e12ba106c40aa9562f2451020ac99cd3f09668f3c93d60e7867939b8bb", + "stateRoot": "0xb5e9446f68d570b553da6d0412e990de655b3fb769d6d42d3e828b0af590bf89", + "receiptsRoot": "0x8a3e160a97c192e4e39bd411702fd7936d10b2726925e81452d8a00a76ff84c4", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000008000400000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x42", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x294", "extraData": "0x", - "baseFeePerGas": "0x25594", - "blockHash": "0xae199d9dff48f9bc1202bd414078c175b977869bce215c79259cbed32e490b16", + "baseFeePerGas": "0x279d0", + "blockHash": "0x2256ff7bd7ede2f79b3392f7898790b3bfcc1dc7bb0143c654a33f2e2f5888ae", "transactions": [ - "0x03f8fb870c72dd9d5e883e3e0183025595830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c4f2fdd3d218cddc4656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0ba7c04326cf6a555be5bd9f31cb2fba1eb9a9f3e33e2946aac1f9fc22b568383a04a0b8e9efdb25fa0cb8a181b58efb746c78f2ddff7e871de4eb252238150a672" + "0x01f8d4870c72dd9d5e883e75830279d1830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4f2fdd3d218cddc4656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f80a08c13050003ddcd771f0fec8d1b89878ce5a27e037db9429f1d109aaef82789f5a018ee9dccf551e5444ce9833475c88d1c0ddb2101104f7164126c7856ad4c1164" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xcc9476183d27810e9738f382c7f2124976735ed89bbafc7dc19c99db8cfa9ad1", [] ] @@ -2097,27 +2150,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xae199d9dff48f9bc1202bd414078c175b977869bce215c79259cbed32e490b16", + "parentHash": "0x2256ff7bd7ede2f79b3392f7898790b3bfcc1dc7bb0143c654a33f2e2f5888ae", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe2923af53ace216a2f3756f07e02eec3fe11417e1444f7f7f3ee962730052b0c", - "receiptsRoot": "0x0c1845ba8a6c851d9de17fa0df7f08367b9b3a8b47d536aaca24ca3551c9e1cb", + "stateRoot": "0x0aef69115f48eb6fbb8edd230c372b670502469d2172a2bebed94e19c97bf267", + "receiptsRoot": "0xe3c4e63900d391a75cfe5ee6bb7369b9098e65dc9696f770dbfbcb859b46a2a2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000009000000000000000000000000000100000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x43", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x29e", "extraData": "0x", - "baseFeePerGas": "0x20b17", - "blockHash": "0x0065ca2f730c7ef4ae37e81f916bfe2a89b86ee315d17796e0b8b5bb76c4127e", + "baseFeePerGas": "0x22a9e", + "blockHash": "0x6163d0b7f02b214352ded0703f0e17a07ffd6b732cf37498e0ea7326863972eb", "transactions": [ - "0xf8763f83020b18830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c830865895079ba54656d69748718e5bb3abd109fa030af21395f8f337afa3ec46a10e083ab868ec41ded089861c9bb7031f6996fc0a01f6cb2daa409d5eabfe1e2f78a94ae403fd8f790b25817a007d999b0bbb9b4d5" + "0x03f8fb870c72dd9d5e883e760183022a9f830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c830865895079ba54656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0412379b7f583981ea6e84408cba75ced69039e07ce9cdaa32a8a9dac997aaafb83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0fef9b70f4e7ee3d672ab232eed3bec3848bc09d3605a903b2441923255454e68a05758f2d31da55b029c5a2c3171f9403fdde911d63722385217e2def96d11b87c" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xf67e5fab2e7cacf5b89acd75ec53b0527d45435adddac6ee7523a345dcbcdceb", [] ] @@ -2128,21 +2183,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0065ca2f730c7ef4ae37e81f916bfe2a89b86ee315d17796e0b8b5bb76c4127e", + "parentHash": "0x6163d0b7f02b214352ded0703f0e17a07ffd6b732cf37498e0ea7326863972eb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x79b6da8621db4d382ab7daf4b067e987df60959df8352369ab182b7e5edb388b", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x80781ed49b23a46e97b31ec8dcd53fe51b069cbe29c9059f8b773c2c93303ace", + "receiptsRoot": "0xf8e5ad4aed3c039edc467864aff788852767d1c4a20c83f3fa61007cde5a8acc", + "logsBloom": "0x00000400000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000008000000000002000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x44", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x2a8", "extraData": "0x", - "baseFeePerGas": "0x1c9e1", - "blockHash": "0xc091a79738ea695804fd7a370a3d24728d5d4523a047835b28fbe5790c914af0", + "baseFeePerGas": "0x1e551", + "blockHash": "0xa5662af7bb63607ebbc0c5ba713be53a59b376199c9f702b141d4b2cf75571b8", "transactions": [ - "0x02f86c870c72dd9d5e883e40018301c9e2825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c001a00929204cf592a006c27998253c5071e583e2c920514e7d5c1e34a49e37453f38a05dbbbc9782cc4d74b300914cb993d12bd127c2122e7fe1b7cca30c65f7c6edcb" + "0xf876778301e552830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca45bff2be728c2a3656d69748718e5bb3abd10a0a0637b96978972ace94aa6b3dc16863c4c205f86005b7ad7876604edd0b5dcffcea005525d14e41366ef8e2d7a7dac83ea9beda14c6271773fe543dc053b22bc939f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2159,21 +2214,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc091a79738ea695804fd7a370a3d24728d5d4523a047835b28fbe5790c914af0", + "parentHash": "0xa5662af7bb63607ebbc0c5ba713be53a59b376199c9f702b141d4b2cf75571b8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa7486d74361a7d787a9e90106c8a08d8a235890e58111e07ec69684b9758ab09", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xd4dc380582a6502e31b2981b10348a41e347cce67dbefd9cd0b256ecae8497ba", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x45", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x2b2", "extraData": "0x", - "baseFeePerGas": "0x190b6", - "blockHash": "0xc0dec6888ce6c75c575ce5ada6f3425cf1511b4d31b4f7ffeb63e93bf00ff243", + "baseFeePerGas": "0x1a8ad", + "blockHash": "0xc2f77b16764d5704a9c3fc3ccdc291c2301b512341ed07de3420e05814f38f44", "transactions": [ - "0x01f86b870c72dd9d5e883e41830190b7825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a040e500b278d2f1bc4f1712d23db7301b0c51eb5fcee5c0e6c2fffe2eeb2c5297a050aa2d6a1dfe6d17354f121168b2a9e2e4e9a486ad2b6ce20c10167c33b1f0ab" + "0x02f86c870c72dd9d5e883e78018301a8ae825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0b180dd7d638a1ee48b760f539880f22ce181f24c4f19cd81a3bd9bc4889771e5a01a78726e8eaf502fac630205fd3a783e99717fc0d01a97b13c2e0e0ce0ebbb79" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2190,21 +2245,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc0dec6888ce6c75c575ce5ada6f3425cf1511b4d31b4f7ffeb63e93bf00ff243", + "parentHash": "0xc2f77b16764d5704a9c3fc3ccdc291c2301b512341ed07de3420e05814f38f44", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0780d1da5793aa323fc66a9089541cb12ae3cb7510f9f3685a3941195276d2ad", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x06ea061dfa57f22d1f8e3ffb69d504b38f4c81e4c79f885a292e06f6f797448f", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x46", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x2bc", "extraData": "0x", - "baseFeePerGas": "0x15eae", - "blockHash": "0xfd1c5aae32a2ab886fbc6b5229bd30528f904fa67063d334e6428dfc94a9909b", + "baseFeePerGas": "0x1739a", + "blockHash": "0x0f684901e87fafdad7d7ffe9f324a534b06cfc52bb98cfd6937ad3373edbe050", "transactions": [ - "0xf8694283015eaf825208942d389075be5be9f2246ad654ce152cf05990b20901808718e5bb3abd109fa0cc54eb0962f6ee85e270409d8e16dcd4a85b55c027c40fede1eb337b6b22b113a06eb534ff3e0ad65677e8d47cbeef950d10ff14edcbbeedae7163c139e20a4289" + "0x01f86b870c72dd9d5e883e798301739b825208942d389075be5be9f2246ad654ce152cf05990b2090180c001a0ef28e0030d89af2f11006a9ba0f24be22336f00c930a4650e0c527e12c697992a07b186a3fa04ad8a6ad04b637060a816f58e68bc71fca5d8fe15f0dc670657f2a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2221,28 +2276,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfd1c5aae32a2ab886fbc6b5229bd30528f904fa67063d334e6428dfc94a9909b", + "parentHash": "0x0f684901e87fafdad7d7ffe9f324a534b06cfc52bb98cfd6937ad3373edbe050", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x67d9e95841df8e76fc7449398d692c9e22aa5a9cc46062f0f9ce86e86c6be65b", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xeeebbcb11f4cae22dc094529622b5447de8cf3711f5f62d61e91c03d58dfbd87", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x47", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x2c6", "extraData": "0x", - "baseFeePerGas": "0x132e5", - "blockHash": "0x537b75471b40aaa24670d4ed625d075165b59e4ab455236c14dedd7e99e65d34", - "transactions": [], - "withdrawals": [ - { - "index": "0x5", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } + "baseFeePerGas": "0x14529", + "blockHash": "0x7ac52282fa3642fe038111e06c27e42bb80e6687faff3a80802b98c0046cff14", + "transactions": [ + "0xf8697a8301452a82520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd109fa0d8f3e3854eebe13f0c2c5a9a086625e9a783dd5f78abaa521f9373df8d72c1d0a063c664d9e97dcc81eca63119405dc35becafccfb5b916b142cd6719001cb3899" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -2257,23 +2307,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x537b75471b40aaa24670d4ed625d075165b59e4ab455236c14dedd7e99e65d34", + "parentHash": "0x7ac52282fa3642fe038111e06c27e42bb80e6687faff3a80802b98c0046cff14", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1e288bfa95da0801a29d41c58b606e07c2741f55b9de3176b9f1304a270bd043", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xc02ebc764f72e04d2c52303b225236c219a3b495bb71bbe714422ba3ebc275df", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x48", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x2d0", "extraData": "0x", - "baseFeePerGas": "0x10c89", - "blockHash": "0x509c406dedf930913cc53d51de88a6b34b0edf15d45c88deee154cdea0b35415", - "transactions": [ - "0xf8844383010c8a8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a00f95d60b8058eb4ed470df1649e1d49a6bdd13b4d4550cf9190ad46deb6e385ca06a35861fbdd443bdaf5b29b45009d23e10095e81e6bc5ae57d56ac18bdad4f8d" + "baseFeePerGas": "0x11c86", + "blockHash": "0x6ac35d9c3afb594c2625d6aa43c248e7f1ebca6cbb3ab4381e8532390005e4d4", + "transactions": [], + "withdrawals": [ + { + "index": "0x5", + "validatorIndex": "0x5", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -2288,21 +2343,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x509c406dedf930913cc53d51de88a6b34b0edf15d45c88deee154cdea0b35415", + "parentHash": "0x6ac35d9c3afb594c2625d6aa43c248e7f1ebca6cbb3ab4381e8532390005e4d4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe629e14f080a5b136f2692b4d69c567f5434c457903057b1b6f5ee7f48f1683e", - "receiptsRoot": "0xbacbf940adc4821ad97f4693540bbfd97f5e03fafb76a803ca8a9d0f48eaad59", - "logsBloom": "0x00000000000000002000200000000004000000000210000000300000000010000000000004000000000040000000000000000004000000000000000000000000000000000000040000000000000000000000000000000000000000000000000800000000000000000020000800000000000000000040000000200000000000000000000000000000000000000000001100000000002000000000000000000000000000000200000000000000000000000000000010000000000000000100000000000000400000010000200000000000800000000000000000000000400000000000080400000000000040000000000800010000000000000000000000000000", + "stateRoot": "0x691f24e77ccb290db740fdc2461d6e88e7399b205bbf1b3f277eed2f504bef78", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x49", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x2da", "extraData": "0x", - "baseFeePerGas": "0xeb29", - "blockHash": "0xcd249ec42453922de5255c9b47ac76191e3cb60144ad0c4bd1b5e02d672c08a0", + "baseFeePerGas": "0xf8f6", + "blockHash": "0x1e3f81c1be76102b47f9d823bb475a6061f72286e53a8d72abc2d363567498ba", "transactions": [ - "0xf87a4482eb2a83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0844a9661b1056386289b482f1ad2b05fae312ad19ce2e3a3d06ab9028ec70a33a022f2d8348abde63af504b925a8ba1d258a2208d2aa056b8b73cbdaad67c55f5d" + "0xf8837b82f8f78301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa01a2c152b4497e19b7e724411e8a6fbd5f83a68170a9df80cc84ae05e8ca999b7a022ed8a35c5c8b0c78c05bdb2f4c8cf37acfdb3e2185b51ab4192549aec484e6d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2319,21 +2374,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcd249ec42453922de5255c9b47ac76191e3cb60144ad0c4bd1b5e02d672c08a0", + "parentHash": "0x1e3f81c1be76102b47f9d823bb475a6061f72286e53a8d72abc2d363567498ba", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x585fadd5c479efb4ac957ebc42b3af0672543a6486bac7218af2a8d20a438172", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1b0d0fe24e13177b0cb5a28d6373d104236ccb98fbf6cb10ed29d1ba67fa9dd3", + "receiptsRoot": "0x3969065861bedbd5387fb8b39289a77281e33297ca1e3ba1ff99ee964a5784f3", + "logsBloom": "0x000800000000000000000000000000000900000000000000002000000000c0080000000000000010000000020000000000000004100000000400008020100000000000000000000000000000001000200000000000000010000010000000000000000000000000000000000000000000040000000000000200000000000000800001000000000000000000000000000000000004000000000000000800000000008000800000000001000000000002000000000000000000000000000000080000000000000000000400000000000000000000000000000000000000000000000000080100000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x2e4", "extraData": "0x", - "baseFeePerGas": "0xcdde", - "blockHash": "0x4b17336fdc9eccebc8c836ffcf41d077a956e9cf786521e9eb4d01db5de5a935", + "baseFeePerGas": "0xd9dd", + "blockHash": "0xb3633d86d73d0b3c8ee7b906a5a0d4bc5ea1bed0490eb0211164833cf5a4b3f4", "transactions": [ - "0xf8654582cddf8302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0903ed0f6e8c13e03dd6873a3dd66d60f595f047b94c3320eb409a6ea4a039b0fa05c8a6d80d1ef19f554c6c5b8dc2093fb9665369c706ff7afb53d7c8b4886743a" + "0xf87a7c82d9de83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0f7d00688d1f40250cdb8c619eda10279419faf6472ee3aa7d1feaa1e0bf7efdda017d632024676f4ef25a13722ed514b057ea2cbd71ee991d87a3af5d8482e0a1d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2350,21 +2405,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4b17336fdc9eccebc8c836ffcf41d077a956e9cf786521e9eb4d01db5de5a935", + "parentHash": "0xb3633d86d73d0b3c8ee7b906a5a0d4bc5ea1bed0490eb0211164833cf5a4b3f4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaad034b9aed035a65c6f0a7bcd8327867b8afc96c350c9c71cab19e4e9c2f309", - "receiptsRoot": "0x5261381ed0a36b358279ebe50c64a85c106a8166fade9b69010f342eb757bea1", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000008000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x8c4a0b2cd0d38b00231f79f70a66a68702d667bd74b7aa1330760bcb768900dd", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4b", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x2ee", "extraData": "0x", - "baseFeePerGas": "0xb44d", - "blockHash": "0x85784669b5e3b7ce03064984463c5c167f4c90bbc7731862bd5d6cdcbbe7dfaf", + "baseFeePerGas": "0xbea5", + "blockHash": "0x502288a02dc23356064d1f98cd38f8e346943b6f6837f0bf98f63534c2027ca9", "transactions": [ - "0x02f8d4870c72dd9d5e883e460182b44e830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c324bbfff4e8882f2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00d968817f6ab6815faa1501ac1eafc810f4bc9b7423abc4f1bd5e65e791b4e0b01a0cf115f14e366d52ac5a9b1faff8e03b73051d51a3deef72e84a21d76a6894971a0764be216a65078c1f43363c76dbe88be7be58367d618682445d8c44a819f6b6a" + "0xf8657d82bea68302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0516d936b4d302f4b4b967654d6241e7994da2c03543a97f4d80bc07fee475f58a012daa6b095ce29321e499ec8d2e7d3e769608987216e241d64f84b6579714ca6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2381,21 +2436,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x85784669b5e3b7ce03064984463c5c167f4c90bbc7731862bd5d6cdcbbe7dfaf", + "parentHash": "0x502288a02dc23356064d1f98cd38f8e346943b6f6837f0bf98f63534c2027ca9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x10f5f1733d662117fa95692a2c2b9867cdb9f1f04b83ae8bc6a75df18429ec4b", - "receiptsRoot": "0x8c6369cb0d38a3b914a4021483e92520156bcf6d81d9d294540fe99ec3c1c0eb", + "stateRoot": "0xb6a97798efa3805c67d7259cf491abfae020063aaf5f2feed35e93dcfea9f172", + "receiptsRoot": "0xbd7ba02f42baaba5afcb42284037349a6efa8e3f3d7ab3708a0699ddd73c601c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000080000000000000000000000000000000000000004000000000000200000000000000000000000400002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x2f8", "extraData": "0x", - "baseFeePerGas": "0x9dd4", - "blockHash": "0x6d3b7ae474719d6929a8374bac361084a530941d9e9c8754bc8765a818704dc4", + "baseFeePerGas": "0xa6d6", + "blockHash": "0xb2145a089c38b7db50fc671aa89fca64e00fa383f540f3c704ed51e7f2179f3a", "transactions": [ - "0x01f8d3870c72dd9d5e883e47829dd5830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3acdabed71e665d0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a041565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c80a0252e9727a43663fd5aa98761487ebeb15b95d7db033235f7d351eb9acb475979a01f3d1b12b2c37a769a0c272fe6e9a7ef01d133dbd50b57cead6d7b7507facc0f" + "0x02f8d4870c72dd9d5e883e7e0182a6d7830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3acdabed71e665d0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a041565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c01a0cffc0f208f83285346026b83f2f5ba195f945ad960f36ce58acb16009de6cfaca068fd55444b5a2fce5d02a87a91ad6dc56928196a22068fa1758bb2457c15da4c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2412,29 +2467,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6d3b7ae474719d6929a8374bac361084a530941d9e9c8754bc8765a818704dc4", + "parentHash": "0xb2145a089c38b7db50fc671aa89fca64e00fa383f540f3c704ed51e7f2179f3a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7206ee5e84555ed8f4ba8d272e1dccfe1925624632761455bcfdc0e67c5e823f", - "receiptsRoot": "0x6982e94426d405c8d3de49f7b6ce870c10701f30c45ecd2af43f133599b6f8bf", + "stateRoot": "0x0c77ef683c268de05888918e6561811589e39b2847f09eca14cd12df1264b96a", + "receiptsRoot": "0xe680fa7144191a3cf69ccec9595d61c7d7d0c32d5ee17d9b5438f3532262508f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000080000000000022000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x302", "extraData": "0x", - "baseFeePerGas": "0x8a28", - "blockHash": "0x60ab9fa061b4a52ae93aac61a70a7049d5ace2d85ad81cd3ba18e5b6f9df5a90", + "baseFeePerGas": "0x91fe", + "blockHash": "0xf0c902bd6d37bdecc5d0b17b012dbabf6856efe771bc52c790be6127b8b8a9ed", "transactions": [ - "0x03f8fa870c72dd9d5e883e4801828a29830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c3bcdbc5784078a41656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a024a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad6907983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0be16a650dcd81359ba2d9f87a008c438a386e541e9a4ba6ed80dfedacea76e12a03d50205907b0ab60580851df05efbb4abc9d8019111bdabb3223a48d33b0048e" + "0x01f8d3870c72dd9d5e883e7f8291ff830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3bcdbc5784078a41656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a024a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad6907901a0ee85123914a3aa5f95b01a79655cc1f7fb805fb946305eb4a4e6c45e63b61146a06f65c10b513b8c62ec6eca0817a310160feef72e30640bd0dcade50073d4f2a6" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x774404c430041ca4a58fdc281e99bf6fcb014973165370556d9e73fdec6d597b", [] ] @@ -2445,27 +2498,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x60ab9fa061b4a52ae93aac61a70a7049d5ace2d85ad81cd3ba18e5b6f9df5a90", + "parentHash": "0xf0c902bd6d37bdecc5d0b17b012dbabf6856efe771bc52c790be6127b8b8a9ed", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdd742a8891473ccbb5ccc2120e977e1408c391722034f2f2484307282b7e767a", - "receiptsRoot": "0x42fd4760a510b52f9c950b84b193545e86594957ee0531c97075c8d30a2cabda", + "stateRoot": "0x1ffd3bf8da28d4c548f4e514d43d10194031b9dc5cf5eaed1ff5a57ab36711cb", + "receiptsRoot": "0x4a34ffe81cd211ed9e5fe067a9cfa19fb29d00dfaeabc3f54cf50382500a0019", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200004000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000020000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4e", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x30c", "extraData": "0x", - "baseFeePerGas": "0x78f0", - "blockHash": "0x8d76a11f766a753283cdebf3c0a4ada62f0a85333eadf13f5c94b5528b9a0bb8", + "baseFeePerGas": "0x7fc0", + "blockHash": "0x0e065a7c1d66be9a7505eaa9846edba1efbc5a2643b0cde0dc11ab9b0e82d2fb", "transactions": [ - "0xf875498278f1830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2d5a0323bb16361f656d69748718e5bb3abd109fa04bebaf0a20678a2de1d3fb9bf40b4ab012b3cd73349d89900b4e5f6d58432fd1a024734d16fda50818adff08a6379f83c3cad54ccf6ef14788cc620042b50439de" + "0x03f8fb870c72dd9d5e883e818001827fc1830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c2d5a0323bb16361f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a087dfa85154edde1626e3a09196eab4b60f71887ec7b50ccbbe7ec76c0be6bdff83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a03a16a62e2d20179fb36e647559caed5f827dd7fdc1777b3e687239c0bc331b40a0750b6366c5221fc164daf878b0d8c10fbf8c1cabaffa2733423a85854ce197c5" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xd616971210c381584bf4846ab5837b53e062cbbb89d112c758b4bd00ce577f09", [] ] @@ -2476,21 +2531,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8d76a11f766a753283cdebf3c0a4ada62f0a85333eadf13f5c94b5528b9a0bb8", + "parentHash": "0x0e065a7c1d66be9a7505eaa9846edba1efbc5a2643b0cde0dc11ab9b0e82d2fb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9c475f68fef47ca76bf7002bb05160c1ed7573f0dfcec725e4a664eabccfc1ce", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb9782d7da020d4884445bb656b079722cb8bb4583a4a2eca1c5974c258554751", + "receiptsRoot": "0x91e123290f40baef855faafc638e4a0fb8e66f75f017102a0d0868297be67cfb", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044000000000000200000000000000000000000000002000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x4f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x316", "extraData": "0x", - "baseFeePerGas": "0x69dd", - "blockHash": "0x70ed6c8dfbfd1a79453b1360fe0c9024d1c9a51b7e9ae491dc9f672c1495ee52", + "baseFeePerGas": "0x6fca", + "blockHash": "0x7a5a9823699ec0f335d977fc08ca50d0786b044c177fadab0f36957d5ee8a6ef", "transactions": [ - "0x02f86b870c72dd9d5e883e4a018269de825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0cec492241954a9cc71f9b7dcacfb8f26b2c3e393964b9ee7fcc1ccaaf04a4969a048fbd9b31f2ac94df51147ab5444d3d866e8c34df7e4a832555861dea6d5c5cd" + "0xf8768181826fcb830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c17df9eb398ae59f4656d69748718e5bb3abd10a0a003340fecb9ea01552af2504c98160019eaa42c855ed117749d37b724ce620601a04d9acc9f0e3232018c44e7b5321d22662a3dbb54c4697ddf4f1145ca67d10965" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2507,21 +2562,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x70ed6c8dfbfd1a79453b1360fe0c9024d1c9a51b7e9ae491dc9f672c1495ee52", + "parentHash": "0x7a5a9823699ec0f335d977fc08ca50d0786b044c177fadab0f36957d5ee8a6ef", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb3b9f2c0207a37013276417dcb6f68feadd4c581a6584b6d7c8ec57027966809", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x182f327169e1cb576c48d7a9572fbb0cf7f0d225e54d20a954c5e578d69fd53d", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x50", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x320", "extraData": "0x", - "baseFeePerGas": "0x5ca6", - "blockHash": "0x829bf1d587f5294d8ee978c07aa33af6df08dc44876e81c4f2d1d9403e6c0478", + "baseFeePerGas": "0x61d2", + "blockHash": "0x0c2f74470c7439c7e783de2e128f65e66d794d01c2bbabe225599eb81927f680", "transactions": [ - "0x01f86a870c72dd9d5e883e4b825ca78252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c080a0173d73de31dce0e30697770fa0adace02cdddce31c863f96b48ebd5644f39dc5a04dcb29a3c6f29163bd885c9954afd430aa16fbdd6c33ded3705b13730c6e9c21" + "0x02f86c870c72dd9d5e883e8182018261d38252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c080a0ebc44bd7b8c39ecdc6cc765d875b385d9fb0cf045e32c1b4ab3d22241e7fb4b7a03d190e6a241ee75b8c85438d705c262ca58659710dfe38b97c761d7d13d446a8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2538,21 +2593,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x829bf1d587f5294d8ee978c07aa33af6df08dc44876e81c4f2d1d9403e6c0478", + "parentHash": "0x0c2f74470c7439c7e783de2e128f65e66d794d01c2bbabe225599eb81927f680", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe2f7eedb26752b56cc96454638b9be27c25f16a24dfc7076701a4bb9cc93d79b", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xd4e910f9fd994562b4360fb5559afc2bc1110371b11abf616c4bb965845d0bcb", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x51", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x32a", "extraData": "0x", - "baseFeePerGas": "0x5115", - "blockHash": "0xb57dc2887b5798442036ac860b372cb07b5858c460977c426b53bf780aee15ba", + "baseFeePerGas": "0x5599", + "blockHash": "0x7489436084d1c2fbd1ef76bd84ee9ff43e054e6ca744fb1ad299f8fb6a5171c6", "transactions": [ - "0xf8684c825116825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c01808718e5bb3abd10a0a0eec30a6c02d46baadfef66f942f70140f3b78f905d3af1147f1501bec20ef862a014e5e443a94dff326c43d830e21df8c9025ea9d8198f59be1e991d06aa1ada9a" + "0x01f86b870c72dd9d5e883e818382559a825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c001a02a7d2a3e2d41438dfe5475471cec7e56bd1c81266f47344535c6318b3a99fd68a00991dca22170ff4884e9f4303163e10c25960dd9348eadc244e05f8e5229c56b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2569,28 +2624,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb57dc2887b5798442036ac860b372cb07b5858c460977c426b53bf780aee15ba", + "parentHash": "0x7489436084d1c2fbd1ef76bd84ee9ff43e054e6ca744fb1ad299f8fb6a5171c6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6d4e3e96904866f611e25ff2555e0edf6c4a78ef22ea78dc0d256ca8205485ca", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xc87c01bb88b69df7936fde7d5eebbe8c8f7f5f2a9e0b2dd73e362cca15a9ebd3", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x52", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x334", "extraData": "0x", - "baseFeePerGas": "0x46f6", - "blockHash": "0x6793c6d579b24b7bfac5cfd619b7335aace2365f75cf5b0d1e1b5c367288b74b", - "transactions": [], - "withdrawals": [ - { - "index": "0x6", - "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", - "amount": "0x64" - } + "baseFeePerGas": "0x4ae7", + "blockHash": "0xb535bb07496aa8764a751097afb4fda7881b9de41e6f3c4c329360a808caff31", + "transactions": [ + "0xf8698184824ae882520894717f8aa2b982bee0e29f573d31df288663e1ce1601808718e5bb3abd109fa086a4fc9f76099c05095cb8e166ac7c4787800a2068ce52721c78e642270fd987a04ee2856ebdcb0ac92d683f3d6e7ca3a149f8fbc77bad4ac767c29a256e42ac6b" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -2605,23 +2655,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6793c6d579b24b7bfac5cfd619b7335aace2365f75cf5b0d1e1b5c367288b74b", + "parentHash": "0xb535bb07496aa8764a751097afb4fda7881b9de41e6f3c4c329360a808caff31", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc79924280afff05363b95785cda5387e9e82ddae8266c1e34e9c8f5a4e2bfe5e", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x7aa894a3689264d49f1055a6842e045acdf00ae2b5e12b211cd40d70c47a4e05", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x53", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x33e", "extraData": "0x", - "baseFeePerGas": "0x3e18", - "blockHash": "0xab38058baae4ce65fe734310ef852d1adb2eb0e5bce297e2dfb1f2aabb8155fe", - "transactions": [ - "0xf8834d823e198301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0ae704e1b38122ca02493c828a10c293237b1088376a32c71c0402cc4ccee0ea9a039f2324696ba0be7a7730d4f922ae10586c25d92b6525e0f1ec332de4fbf3b36" + "baseFeePerGas": "0x418b", + "blockHash": "0x1237af5eec8dabdae0efd403a87ef5588b2dbd724946f41c7e161df50328e468", + "transactions": [], + "withdrawals": [ + { + "index": "0x6", + "validatorIndex": "0x5", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -2636,21 +2691,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xab38058baae4ce65fe734310ef852d1adb2eb0e5bce297e2dfb1f2aabb8155fe", + "parentHash": "0x1237af5eec8dabdae0efd403a87ef5588b2dbd724946f41c7e161df50328e468", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce9a3b040049312688b963ff49410e9dfff53349b9abd1a3f93d4e67b2f2408d", - "receiptsRoot": "0x192362bc21457de45deb735ce9f1cd26e7ee37928db9cdc4d40436d2134140f7", - "logsBloom": "0x00000000008002000000004000000000000000800000800000400800000000040040000000000000000800000000000000000000000040000008002000000000000000000000000000000000000000000000000000000020000000000000000004000000000000000000000008400000000000000000000000010001000000000000000000000000000000800000000000020000000200000000000000020000000000000000000000000000000000000000000020000000000000000000000000000000040000800000000000000200000020008000002000000000002000000000000000000000000000000000000000200008000000000000000000000000", + "stateRoot": "0xe38021b2014f295451d83e2b8f68f31f2faa6a43e27900f628cd836f8f6e422a", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x54", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x348", "extraData": "0x", - "baseFeePerGas": "0x3661", - "blockHash": "0xc129c2d37fdd0defa0d0cdd7b27a95e5f17eb1beb11a8713bc4b398dff6f69a2", + "baseFeePerGas": "0x395a", + "blockHash": "0x7bb88dc7b037cc2aa86a83318f9e2db824f840e0c04526f61fd2921f327eab14", "transactions": [ - "0xf87a4e82366283011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0fe30fa3e184a6907501b49905902316be2f564d4196be62497233bc1610dedd2a016312759531406df473240de2509a119c62c1833808a0a2b246c6d62af9a249c" + "0xf884818582395b8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a04a7a1795e316e2ad3abceb425aa55df15927308048e2a9dea4b486d66658f123a06ca3114fcbc80ca53c48072c795e1ce3d391808e75463a63f1e191838d9609b8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2667,21 +2722,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc129c2d37fdd0defa0d0cdd7b27a95e5f17eb1beb11a8713bc4b398dff6f69a2", + "parentHash": "0x7bb88dc7b037cc2aa86a83318f9e2db824f840e0c04526f61fd2921f327eab14", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb8adf9d72b4060e71a58b8c69a089dc07fccd0f8a6bae96f83f05273a65283ae", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb714b8ca31d57e62146b43e6442498002810cbfb49bbc5b6a08a5b160bfc3970", + "receiptsRoot": "0x0138ed3983b7647acc046786b4b6d86708d0f183403b9a77ea595644e149a5ff", + "logsBloom": "0x14000000000000000000000000000000000000000000000000000000000000004000000000000000000020000000000000200000000000000000000000000000000000000000000000002000020000000000000000000000400000000000000000000000000000000000000000000000000000000001002000001000000000000000800000100000000000004000000000002000000002000000000000000000100000000000000000000002000000000000000800008000000000000000020000120000040000000000000000000000000000008400000000000000000800004000004000000000000080280000000000000000000000000000000000000010", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x55", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x352", "extraData": "0x", - "baseFeePerGas": "0x2f9b", - "blockHash": "0x5e61412b6b77af36026fc83378b2aff64e52121621912d35061bf7db4e315657", + "baseFeePerGas": "0x3231", + "blockHash": "0xe8235717342e9768bf65d0600947b88bebc1d922822b1cc577075dd7ef002462", "transactions": [ - "0xf8654f822f9c8302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0682574928d1ae7cc05750ebf529d96ab94d0b2721e0c40e628dc2d79acd3f5b9a06f0f8ed0215494365e2529f8b460b27d24de18f27bf35d38096f7c1d76b80227" + "0xf87b818682323283011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa014e3aefe0eff66f1d9ad9528bd9da9b03983e8cff43a31b2e778efcbda8930f5a0077f29ae0c9b1d26866c2eafc0527772517fbdbe18df4478308d662358250f77" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2698,21 +2753,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5e61412b6b77af36026fc83378b2aff64e52121621912d35061bf7db4e315657", + "parentHash": "0xe8235717342e9768bf65d0600947b88bebc1d922822b1cc577075dd7ef002462", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa08f4f70e62edae94e6d64a375443d46c1d54439b3e4b8c4f9b40882951c21ba", - "receiptsRoot": "0x2975f936074e89e49d796dc3b56be7f803c99492e85fab5560e6930cb537658f", - "logsBloom": "0x00000000000000000000000040200000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1841c9f0c510c24ab42d67869a29f5adfd06b6d6c5b5ddee06c4cfcbe5c5d0f9", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x56", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x35c", "extraData": "0x", - "baseFeePerGas": "0x29b2", - "blockHash": "0x06a3b3e77a4ecfa284cd0cbc5f563dafcebefcaa7e4610b0433f1da2353d65a5", + "baseFeePerGas": "0x2bec", + "blockHash": "0xf321197dfc592eb856c14ffe0ed175cbb25105b435473559447d58154769bcc0", "transactions": [ - "0x02f8d4870c72dd9d5e883e50018229b3830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf283ffec056e262f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a0634d80c0a702c2b06dfe60ace0d8f788b99406f1d2ac44ad3a26faa3fc146480a021f7ebe5983412cc2643a7a86426e7a1c3acf25fa8ae945515d1c18bcbc04d41a05acfac3d64f7915ab60faddf75f5bd069d60c790c1d53a987d0599c5a7c499d3" + "0xf8668187822bed8302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0aa147aa4c44e555f9e8873cd8b3afb39b241323cfa077523a747495b3ca29e63a05c3d48da118d887c83a4261eb09f7d83c948b9e3f24ddce4708deaa62c5d98e3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2729,21 +2784,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x06a3b3e77a4ecfa284cd0cbc5f563dafcebefcaa7e4610b0433f1da2353d65a5", + "parentHash": "0xf321197dfc592eb856c14ffe0ed175cbb25105b435473559447d58154769bcc0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf28efb86161fd054eaeeb8012454fd6fcabbf1d1a00393e0115d80eab410d30d", - "receiptsRoot": "0x7d22b3980b29df178aadcc46b209a79b386bf81e22e12abda09b5f28bd65ceee", + "stateRoot": "0x41dcdaa9f663b966c234de0aedd89a4a1692c0bf0275081261e82139194bf60a", + "receiptsRoot": "0x336786bdc663d43ebabeb886381cb2e7ca199608ccc0465cc994123bbbbdff0d", "logsBloom": "0x00000000000000000000000000000100000000000000000000000000800008000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x57", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x366", "extraData": "0x", - "baseFeePerGas": "0x2480", - "blockHash": "0x096a5b9ce9899b40e70d721ead24b8da99a16bd9d115412a1e5d4ba2478ba276", + "baseFeePerGas": "0x2670", + "blockHash": "0x2b09c7fb6f54983fcee6cbcd8eef58ac886978c5ccf72edd52795a95ce956c1f", "transactions": [ - "0x01f8d3870c72dd9d5e883e51822481830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8e5b86c510108d5c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a000f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed01a09e097f570d76bf39617cd5dd44154c9e0fcf81f3e7f5b83e92764c27d565bf9aa053c086d715941f75c5c0878067815b8cc96734268162abe11b47f3a06e3adc05" + "0x02f8d5870c72dd9d5e883e818801822671830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8e5b86c510108d5c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a000f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed80a078ec0616bbfe023736d088366d8893c2170c658abc2ec2b8f06ff6fa5fc256cfa07b6597cc5c652edc098335e1f1f16424e77e21e9446cb2d9e7d2be7b54f2aef6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2760,29 +2815,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x096a5b9ce9899b40e70d721ead24b8da99a16bd9d115412a1e5d4ba2478ba276", + "parentHash": "0x2b09c7fb6f54983fcee6cbcd8eef58ac886978c5ccf72edd52795a95ce956c1f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x35b9213f895371cbb4392162da8a7500f5a47cb89e3fa982a508bad473c26271", - "receiptsRoot": "0x945052b14f54239fd074dc767b331c1081ed1b6e0f16b7b26adc4ff42a85542e", + "stateRoot": "0x0a92d83649ae6489939a153a7e3cb81bc0325aacb18b9575afb916d8d270beff", + "receiptsRoot": "0x5f1c9b9dc8dca44c88617679768cc2d1ad31b0ebe7c614d1fafee6d9999c9152", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000010000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x58", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x370", "extraData": "0x", - "baseFeePerGas": "0x1ff4", - "blockHash": "0xa6b1b6fbde7fcc8c1c4b6b035835d839914b9d3ad21dedf946f5d91754d9a6c4", + "baseFeePerGas": "0x21a3", + "blockHash": "0xc39e1323f7b6949a21a1bb6f98d9ebd22d3e776e07676c4cce9fc4174deda0dd", "transactions": [ - "0x03f8fa870c72dd9d5e883e5201821ff5830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cdc2a7ef24edc33ac656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d52583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a017e7abc42245a61de024c71dc03c28e284e819dd4c65cbc300aa4ae44f419d08a07ae5e68345b3710abb71dcb5b4661750bb74db92fbde39954ca440883ba1dc0e" + "0x01f8d4870c72dd9d5e883e81898221a4830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdc2a7ef24edc33ac656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d52580a0831b8f078baa90df02337d5459d784fe392f1ca33a4ca7fb35ae5dc178470c42a035748828f384b1b35b60f8b8590dbfb5911dc0dc3e33bd6fcb487d9d7147af51" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xad13055a49d2b6a4ffc8b781998ff79086adad2fd6470a0563a43b740128c5f2", [] ] @@ -2793,27 +2846,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa6b1b6fbde7fcc8c1c4b6b035835d839914b9d3ad21dedf946f5d91754d9a6c4", + "parentHash": "0xc39e1323f7b6949a21a1bb6f98d9ebd22d3e776e07676c4cce9fc4174deda0dd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1bf7f56cd090ccc023f7e630f15afc802cc285fc6c1b6b58d5c7758dd7cc3da4", - "receiptsRoot": "0x627165c3f8e25a917da5a29d58d0e712ff1762956a221a0560878d7c29865dc9", + "stateRoot": "0x47f0051f4be1a77be57f28680637127ef2d03fec527c038b066f492063465932", + "receiptsRoot": "0x5406859786ff896ef8beba8d78f442b4d12652ab0fafe3938e9169ada2ecbd27", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000008000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x59", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x37a", "extraData": "0x", - "baseFeePerGas": "0x1bf9", - "blockHash": "0x96d9997e171f41cd83e6829c097bd37f9c352553c0a1fb5a739d2766cd7b0772", + "baseFeePerGas": "0x1d6f", + "blockHash": "0x8b79d25d91549e398a5fa94bf6f56b1837b11d042b65811411fe53100ee18c2e", "transactions": [ - "0xf87553821bfa830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd458dc07963e0c5c656d69748718e5bb3abd109fa03486504c2c493dc7c0df1daaa1f22b3253fb838145724f7a687fe81661704de9a00dab1a6db8a4c04cb34fb6a8861624fe5dbe210257e3ef723042bf7fb42d8d12" + "0x03f8fb870c72dd9d5e883e818a01821d70830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cd458dc07963e0c5c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06e2466f20ef20cb42d216dbf4a0d934199213e9b8d75bedc9c2d3e038a58747483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0433af35ed09ed9256baa86d2e0c2c30ea9bd210e6962686f2d3a8b4da1908f15a03f98e493e855d7c3e4c4600bda0508ead72e28a07a24226727208a15c3091c94" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x9e9909e4ed44f5539427ee3bc70ee8b630ccdaea4d0f1ed5337a067e8337119f", [] ] @@ -2824,21 +2879,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x96d9997e171f41cd83e6829c097bd37f9c352553c0a1fb5a739d2766cd7b0772", + "parentHash": "0x8b79d25d91549e398a5fa94bf6f56b1837b11d042b65811411fe53100ee18c2e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa5e05aa6d25b0f8d77edc2c17afd1a35927ebd5f0219255768f83a6bca6c2774", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc66042410497fe5b80bc68d333229ae61dca3b0e109c6daaa3bfff8d8faa7908", + "receiptsRoot": "0x9670d0efa9339a29aa56b91a617ed8f9b2e2f133afefa3835004ad7437127b96", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000400000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x384", "extraData": "0x", - "baseFeePerGas": "0x187d", - "blockHash": "0x70db0ab4ec61502d2a53b8faa0ffe5a45d7db6f562af25e6564d8d2669989d0a", + "baseFeePerGas": "0x19c2", + "blockHash": "0x5d33f0b59d254d470019eac98e38a2a90468e5873067bb5e3cf8e0ccb84ad048", "transactions": [ - "0x02f86b870c72dd9d5e883e540182187e825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c080a071641b0db3191ff7b3372c8d63f3e392f1ec323473550c359736914d5ae435cba0021fe07df29b5ef1cc0ca885184047b173929624a0a7faf0cf3437ab9a5e7320" + "0xf876818b8219c3830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb465b4f1541b4582656d69748718e5bb3abd10a0a0375b35765fb3e1e7e1c2677f15c2c1a583822be8a48c4ed15199ea13a7d5e76da079c3a952c79c81ecfbf37ab16b18ef010572ee9f7ed965ce29d04baf09ade62b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2855,21 +2910,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x70db0ab4ec61502d2a53b8faa0ffe5a45d7db6f562af25e6564d8d2669989d0a", + "parentHash": "0x5d33f0b59d254d470019eac98e38a2a90468e5873067bb5e3cf8e0ccb84ad048", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6b0ad802144e4563427f6909d3dc126246c0b8649117b1a8fffb6a548c2bb6eb", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xe47d0c7ab29cdf81e0e85896ea7ae19d982b9d703113997a48b4df8dd86a76bb", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x38e", "extraData": "0x", - "baseFeePerGas": "0x156f", - "blockHash": "0xa6aa03ee648578c9413c668ab9f6d2dc480a48bcf7b126dec17b85be35b28604", + "baseFeePerGas": "0x168b", + "blockHash": "0xae8ff3f7d1bde73dbd36f2293e845fa059a425576be62bffdc4ba6a2e1be5afa", "transactions": [ - "0x01f86a870c72dd9d5e883e5582157082520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c080a09d31e711219a13ab4928d1b1741ce55a3e4b6ba173deb752a85e2b12661a7c0ba075180a720633d4411a4b1b7bdea101501ec6b4d1c50c411aefd8ee921afded20" + "0x02f86c870c72dd9d5e883e818c0182168c82520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c080a085716712d538ede8849aaca9d7b79c7c91c4cae166df0f6d381e7667f0c2f732a0471c89e0b46db402eebfa4ac5495101b36b275cc3fa88a58dceacadf514047c5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2886,21 +2941,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa6aa03ee648578c9413c668ab9f6d2dc480a48bcf7b126dec17b85be35b28604", + "parentHash": "0xae8ff3f7d1bde73dbd36f2293e845fa059a425576be62bffdc4ba6a2e1be5afa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd53027d41e55fa10d6a7a51bcfd3a6f904c3360fe366d2ff3050afd2a5838e1d", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x4e68ea06813576e3022b778d12baa3a0c6e08f1d56794a95210a87219e860bb6", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x398", "extraData": "0x", - "baseFeePerGas": "0x12c2", - "blockHash": "0xbec4f585aade8992655a98ecf32e5ad71245f864bb2c3987b0216bfcf2acb0c0", + "baseFeePerGas": "0x13ba", + "blockHash": "0x8d1fd7f00d80dd8d4c799dd381b71eb349e695d4190f97e206550ddde559adf4", "transactions": [ - "0xf868568212c38252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c01808718e5bb3abd10a0a0b6faa7b0b72e8d5d945d970a2a587026d18039ca5c2a36cc85a81f4a6463c054a077e7921998baebfe50319cab574a14c1d851440c69a2f0772327629f19811e72" + "0x01f86b870c72dd9d5e883e818d8213bb8252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a0e4568a847a164ca753f4b1ffeb8198bdb0d3118950051738177269c588c50548a073417a8864d9dcf956ed9226081dbcd9bbf7530eff2f7ba55b64793c70ea13dc" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -2917,28 +2972,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbec4f585aade8992655a98ecf32e5ad71245f864bb2c3987b0216bfcf2acb0c0", + "parentHash": "0x8d1fd7f00d80dd8d4c799dd381b71eb349e695d4190f97e206550ddde559adf4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9b12ffe7615b8381a3d361af306212c07f0a006162f1b0bdc7a3305964072a70", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x87962ddb7af98bac117f959ef2a9db93891f07c7eb14ce6462fbdb98ccdd2598", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x3a2", "extraData": "0x", - "baseFeePerGas": "0x106b", - "blockHash": "0xa75924e8dc804bc7d9588a41ae6545effa02c568f519abb7f109d76ae17442c0", - "transactions": [], - "withdrawals": [ - { - "index": "0x7", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "baseFeePerGas": "0x1143", + "blockHash": "0x16b224e441aa3817c03949a4e7930d87e0ff9240d0f2955fdebf23a7f410148a", + "transactions": [ + "0xf869818e821144825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd10a0a092972bf43d78d5819a1bdf53e7efeb459eb8a792ff3e234ada208d7c5e4053d3a067fe419c0dd23c87fcc35b22c456148d64fda89bcb7cc42d09611d6891d988ca" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -2953,23 +3003,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa75924e8dc804bc7d9588a41ae6545effa02c568f519abb7f109d76ae17442c0", + "parentHash": "0x16b224e441aa3817c03949a4e7930d87e0ff9240d0f2955fdebf23a7f410148a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x205f42eb8c6ea2b8f12b340c6a6267c591bd4226f937c79de0611ca85f4dbdfe", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x7e706e5f82ffa370e285ac51e5448ab881d94fb03e4de6309fe23c97190ae7fb", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x3ac", "extraData": "0x", - "baseFeePerGas": "0xe5e", - "blockHash": "0xc80ae577ac0e00ce2a417f069f0db47ca32ba3576ea6092273c623a035980fba", - "transactions": [ - "0xf88357820e5f8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0796daf4b6f92e4c939847cdf656db14c7789b58313aec2713c29efae499e15a6a04fb5264cd95b8a06582bdbf1bb93b25e642a25be12f938005b348f02f186d161" + "baseFeePerGas": "0xf1b", + "blockHash": "0xcf191216637f378d2ee7f2dd47d9a330b3cdd0e20d7a27f8c8bbfb1df421a9eb", + "transactions": [], + "withdrawals": [ + { + "index": "0x7", + "validatorIndex": "0x5", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -2984,21 +3039,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc80ae577ac0e00ce2a417f069f0db47ca32ba3576ea6092273c623a035980fba", + "parentHash": "0xcf191216637f378d2ee7f2dd47d9a330b3cdd0e20d7a27f8c8bbfb1df421a9eb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x48b892bb8b406d4ac3fb597fa6c9ffca4acd27fb4f2704ecf6bd764d79da23eb", - "receiptsRoot": "0x9486adf3b9ae8b48318e66420a28ade75a4e8db57e410418b81478f7996b8f23", - "logsBloom": "0x00000000000000000010000000000000000100000000000000000104000000000000000000000100000000000000000010000000000000000080000000080000000000000000080000000000000000200000000000000000000000000000000000000002000000000800000000000000140000000000048004000001020000020000008000000000000000300000004000000000000000001000000000000000000000000000000000000000000000000000000400000000400000000000000000000100000000000000000000080000008008000000000000000000000000000800000000000000000000000000000000000000000000200000000000000000", + "stateRoot": "0xb042a00ed6a77273755ab545b03fc1144ddf3db74032f1e81d69dd8431a17bee", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x5f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x3b6", "extraData": "0x", - "baseFeePerGas": "0xc95", - "blockHash": "0x3e10fa0f7879c62f9eb6373a80bf6a0a2d4c16fee5ba96566d62488db5477e92", + "baseFeePerGas": "0xd38", + "blockHash": "0x962e7b0b218852cf9c41bbb7fd8908baceece8e7e4c8b2b5d2ab5390f0561b02", "transactions": [ - "0xf87a58820c9683011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0e6fff4260c9471cfb777098433e0fb364640acb16343288999acf14c0b88809ea00b968782ab0888217477cafea77f3b57db4d431452cb8ea7e6978ae773cf2985" + "0xf884818f820d398301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0f373452c20d1ec4a5f1f9255b970391bb33a96fb2428012cdc7d2402f50f9510a014d393105d47c725cb239a6dc7929f41cec85ea2791245ec7328bf909b801825" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3015,21 +3070,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3e10fa0f7879c62f9eb6373a80bf6a0a2d4c16fee5ba96566d62488db5477e92", + "parentHash": "0x962e7b0b218852cf9c41bbb7fd8908baceece8e7e4c8b2b5d2ab5390f0561b02", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdcbc6fa752481c6726f4fb3c12bb4139441dc502d855073c856fe72f2e2b9700", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc3d437dbca917bed12247fd4d677cfda795617d2a0cac9b1eb4d84dbcf3e4e40", + "receiptsRoot": "0xb405ff6fd8cc52640cb348d177599ba52ce5dc59921931c9d718f749ae77516d", + "logsBloom": "0x00000000010000000020000000000000002000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000800000400004000400000002080000000000004000000000000000000000010000000000000000000000000000802000000000800500000000000400000000000040000008000000000010000000000000400000000000000000000000800000000000000400000000000000000090000001000000000000000000000000000000000000040000000000000040000000000000000000000000000008000000000000000010000000000000000000000000000000000000000100000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x60", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x3c0", "extraData": "0x", - "baseFeePerGas": "0xb04", - "blockHash": "0x9ae8e852cab82414dd0762c67565523f30c9049a061c7c3b4a310cfcd4df9d2a", + "baseFeePerGas": "0xb92", + "blockHash": "0x13dc0c8daad8b71fc3f0e62a209b9710cc78934504a6c2e990549a2e473152ed", "transactions": [ - "0xf86559820b058302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0db909926540f1032894a4db02a37d05c8edff1f5541159e8ed3a1cb143c1928ea07ffeb1ba41fd78f66ba04956b0b9cc7f834d6b5961f3afc8a6bae5525739ef5e" + "0xf87b8190820b9383011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0c1298064eb80e75637fcdff710a12e9dc1605aca384b5b592253529c1e8b355da0073cbdd116c442617c0dc6851a8da08694352b93c7a5dc7efcab67166a3be3bf" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3046,21 +3101,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9ae8e852cab82414dd0762c67565523f30c9049a061c7c3b4a310cfcd4df9d2a", + "parentHash": "0x13dc0c8daad8b71fc3f0e62a209b9710cc78934504a6c2e990549a2e473152ed", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc94ba29902b69aa858c2583ca321e2c1e63e6f4dd190a4040362c54969113191", - "receiptsRoot": "0xf596f1ec769d7d49f408b6aa2d8146e77550c7576de2779aeba070e5bc9c370c", - "logsBloom": "0x00000000000000000040000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000109000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x34225405226610fb240063eb3c644c4127c0ea7851574098de3bd90bd276da11", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x61", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x3ca", "extraData": "0x", - "baseFeePerGas": "0x9a6", - "blockHash": "0x6c4fe4ae5fb8b2a347e58868bc6a741a6df75a83593b062869cacb7ce3a715af", + "baseFeePerGas": "0xa20", + "blockHash": "0x333cea669c831ec4b078f39fb05de11664b438741df8d8cd37ea771049dc1f30", "transactions": [ - "0x02f8d4870c72dd9d5e883e5a018209a7830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c50edc262344620eb656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a050495437ee69f7b12c5d6eb55cdcd8f5ce12a2eac21a2a42a7549e9f5289b1fb80a0d1a42fdd58ea301bc622518a5df023b6c47ce337d27c4b6085207d4dbde3dfd7a03a891e16fee217f1f98c0d535690b2ebfce973836172d6aaa77a80ecb8d24049" + "0xf8658191820a218302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a09f934cddc23c26d67cf15b795a2722166f9569fc065a5268ccd163511bd858e3a0305fa6b3562156f48c780d8082402a8c6c9a217f075ade3369217238f169e3bd" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3077,21 +3132,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6c4fe4ae5fb8b2a347e58868bc6a741a6df75a83593b062869cacb7ce3a715af", + "parentHash": "0x333cea669c831ec4b078f39fb05de11664b438741df8d8cd37ea771049dc1f30", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x872601fe4846f89a9affffdd232712819a15245cbb7dc617ae9b16d2a3741c27", - "receiptsRoot": "0xa29fa19bf70f4fc573b33c765b9603c1f39820fb7c365f971cf8425b8a5172da", + "stateRoot": "0xea8d727fd31590d4639fc0cc8c1b2f0e6ac99087f54b79a828771d0142e91bb7", + "receiptsRoot": "0xc2b73eff237f18f6bce6ce993ae0f47ddc37bbbd547c4088022e93ed833e1597", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020009000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x62", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x3d4", "extraData": "0x", - "baseFeePerGas": "0x873", - "blockHash": "0x6722daf402b94682af585921807783bb92e1957789399ed0e0be0e0faa5a8c87", + "baseFeePerGas": "0x8dd", + "blockHash": "0xe377c7a76084c79781cecc442ff79d5a76ab95710878ef19fbaa2ae3b3806d2e", "transactions": [ - "0x01f8d3870c72dd9d5e883e5b820874830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c899b80c8dc11d5c2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd80a0bbb21740cb875793183087033bbe574233d7f0a3ab8b89d4cdc2a2603ccf603ba048c6ff73f3ee02a1d69feb70cf642978368e40861e768cfa7ecd229fddfe54c5" + "0x02f8d5870c72dd9d5e883e8192018208de830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c899b80c8dc11d5c2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd80a09b91b35faf73278875d8b28749c5dd841293b70dfbdc96e04d89cb42cda3b03ea063366cbfc247a591f88a6bddbb9cddc21eadea8110091b1d22c7c57acba40d5b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3108,29 +3163,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6722daf402b94682af585921807783bb92e1957789399ed0e0be0e0faa5a8c87", + "parentHash": "0xe377c7a76084c79781cecc442ff79d5a76ab95710878ef19fbaa2ae3b3806d2e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2239cee6ef71575c8197ff42e2a28e8b2e561b59874f19934636da3c8e3510ad", - "receiptsRoot": "0x006004762186f9eb89941184c170358002854d9fc3990ce1ee068b72f42b6a01", + "stateRoot": "0x9017d746d09d04aca579fe8eb3c9e71c7bce382d5bae554cef86e49f875aa41b", + "receiptsRoot": "0x54b3b8ed5b54b9ec9b5971b24e235b772e34ad7a5bdd4fd296b48ba684baa071", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000004000000000000010000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x63", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x3de", "extraData": "0x", - "baseFeePerGas": "0x766", - "blockHash": "0x651c869c9f62a753fa0c545a984f596d2068aa542234b109032b93a583442ffe", + "baseFeePerGas": "0x7c2", + "blockHash": "0x583000818d360ecba85c0924bee169e64dc799c21d5e468711324c423ae1246c", "transactions": [ - "0x03f8fa870c72dd9d5e883e5c01820767830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c913746d244054c52656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a002bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f41383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a03adcb0eae8331808d9e643d067c542b39ec1496eecc687b299eff56aeea0601fa05fec7e1a65b7d0d89524440cbcc569eef8433d1c3976497daddccffdbc32a21e" + "0x01f8d4870c72dd9d5e883e81938207c3830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c913746d244054c52656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a002bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f41301a0f1cd3b7cc4ea54fad0018a7fb75e8d0f107bf31f5c71442703c9b0c683959285a031e17437c91b89caf38aaecf3844414afa1a3f07821d339049b45706a16ab08d" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x9d580c0ac3a7f00fdc3b135b758ae7c80ab135e907793fcf9621a3a3023ca205", [] ] @@ -3141,27 +3194,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x651c869c9f62a753fa0c545a984f596d2068aa542234b109032b93a583442ffe", + "parentHash": "0x583000818d360ecba85c0924bee169e64dc799c21d5e468711324c423ae1246c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x29db53323cdcc44b58a5f4b48dcd02b2a7c0014d7044387f711b6b2b48b00ac9", - "receiptsRoot": "0x2733fb23cff5be65a62478606a44d8c502792b0c48a42dc70cfa0b80ef758dbc", + "stateRoot": "0x338950c7ec1e65de1294e3016ca6d64e3f0ff6e1fa53151aa5724c9a52ae4f92", + "receiptsRoot": "0x7f9dc480827d9967528a81ce3e2ab6861814297b6d40c45cead1101effd467c4", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x64", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x3e8", "extraData": "0x", - "baseFeePerGas": "0x67a", - "blockHash": "0xe93d89f5d6ab364e7c6597d99b6041f6c1d503a639f1265e8ffb1261f87fa2f3", + "baseFeePerGas": "0x6ca", + "blockHash": "0x89628d10b5c915f51b8def1dd2ea8a9b2e89b30da4435cbe0f5003651bb05e8a", "transactions": [ - "0xf8755d82067b830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c019f76127757f5d2656d69748718e5bb3abd109fa0218afd167510eac77bba6b2fdaa59d3580fd0a70719e57e0e40cda7712a36f8ca041221634bbbf80f4bbd0087fff1a6753631a32e4c2c5684e5191eb8b3d613c2c" + "0x03f8fb870c72dd9d5e883e8194018206cb830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c019f76127757f5d2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d75c9abb1414054ca164bba2f8c09917fb90c24789feaa311ee34a0b3f4a82f083020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0289f457754837be82c7d03b5981b35a569e55d4b30eb3aea79316d672c7b0536a06482af279d5b870ce13e9635e3fcb9186d92418967247ca510cbad40dcd9153b" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xa7fd4dbac4bb62307ac7ad285ffa6a11ec679d950de2bd41839b8a846e239886", [] ] @@ -3172,21 +3227,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe93d89f5d6ab364e7c6597d99b6041f6c1d503a639f1265e8ffb1261f87fa2f3", + "parentHash": "0x89628d10b5c915f51b8def1dd2ea8a9b2e89b30da4435cbe0f5003651bb05e8a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6d1ac14be0fb955ef6d906d373d29690e9609bdbd24b0c4f9d8bbdc2570c4e1d", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xad6b17cc65d1fdd8f28fcb3ee39f548408af6b1af05380c1961828bc9dba46f0", + "receiptsRoot": "0x8981ee59e3934e570ba1fb69f44a1d8986c1446a4f48f2e0756a24fa1f740f3d", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000002000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x65", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x3f2", "extraData": "0x", - "baseFeePerGas": "0x5ac", - "blockHash": "0x0507a6937203ad4297bca7595e8e0d7715d59bb7296968aebd84c135b707c638", + "baseFeePerGas": "0x5f1", + "blockHash": "0x0de163e9e16a0d88854f6e66f30e50d44d2e569f9f581e9a368adaf1f4a5ca6a", "transactions": [ - "0x02f86b870c72dd9d5e883e5e018205ad825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a031b61d05b2b5a5d3618cb2d89d8569ef1f539a16677e2aa8a7396aa684614c77a05e846fbccb38e529992125ba3fb8c49f6abec967dce763660761198fc7813dfa" + "0xf87581958205f2830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c18c281524d7c4ff0656d69748718e5bb3abd109fa0f047c5b762e2efed8e71c169f23fd0c53ab5fcf34d3d472ddc0310b05ff226209f3cd176171de0ef5bcecbd510427783369ffd540c7bde1c61f43a140ff99685" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3203,21 +3258,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0507a6937203ad4297bca7595e8e0d7715d59bb7296968aebd84c135b707c638", + "parentHash": "0x0de163e9e16a0d88854f6e66f30e50d44d2e569f9f581e9a368adaf1f4a5ca6a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7065f9b94923ab593d8472a940eca2f1c4bf224de039f252e5f9e020b5f78b70", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x23a81b5965be134234ba9fab880fea28a11443538394a1a251bbbfa47e925c38", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x66", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x3fc", "extraData": "0x", - "baseFeePerGas": "0x4f7", - "blockHash": "0xf08662ab38a7f4db3179eb425b28a2dd5d918c80b87740d1b88699ebe905a11b", + "baseFeePerGas": "0x533", + "blockHash": "0x0220ce36b8436b0b234a97413f91bd64f6d41cf4b10fd0bd10e53d8b8f7d79ea", "transactions": [ - "0x01f86a870c72dd9d5e883e5f8204f8825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a0d257f99d3499a621786e5a89bf766d9231746493e9b7b3956d9f0b370ac1be56a03a2a2c61d628a2c65befe9279bc9debf8df4697734f7403086fad1f5fa5299ea" + "0x02f86c870c72dd9d5e883e819601820534825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c001a013a8f22d2dd004d6646400fc702d2e61e66b617312e69c8e550ebfb0d84c5d3fa03358b4f85b43c55fb6e153cd64120ff6ee2ec0f4a43dbf8cead59653c4c3271f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3234,21 +3289,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf08662ab38a7f4db3179eb425b28a2dd5d918c80b87740d1b88699ebe905a11b", + "parentHash": "0x0220ce36b8436b0b234a97413f91bd64f6d41cf4b10fd0bd10e53d8b8f7d79ea", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xcfb338887a35752ca4cfc6134cf589ab41cbadecae007a26d188901e182c7e1e", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xba4c766f7fa091672b98e7db67aa7c2573d85102eecb603daa4447ca95903960", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x67", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x406", "extraData": "0x", - "baseFeePerGas": "0x459", - "blockHash": "0x122f9c89a20f0af63d4d5af9ac5e5ca3907ae256efa3d561f22b9288ad122f17", + "baseFeePerGas": "0x48d", + "blockHash": "0x73d6ae295486e56af688dc96243f9841a3a40c4100ea132f2c0d3c7a92d7a724", "transactions": [ - "0xf8686082045a825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df01808718e5bb3abd109fa0a39701c019e6e29a937a0efe26e4a5e34b00a2c12c2812953967794bbb2c14dea0649354ae5e34e4b7b850e1330099b68dfce37805f773db51cae112bf38afeeea" + "0x01f86b870c72dd9d5e883e819782048e825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c001a0a5d1e43dad93fe87054a2f49c363c340be697f12e993168de197bd80f052100da012aacc66ff5d1aa9b6baa6744c91d795609889866c9a8d427cd761a9199df346" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3265,28 +3320,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x122f9c89a20f0af63d4d5af9ac5e5ca3907ae256efa3d561f22b9288ad122f17", + "parentHash": "0x73d6ae295486e56af688dc96243f9841a3a40c4100ea132f2c0d3c7a92d7a724", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf127a71e9abb554f65e7c0aaef0ab838d638b850e63d8270cec55904dc7106dc", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x52eb22576f77ca03957b5f63ade7342c6bf8aacb784592a3909868a7a21f4374", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x68", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x410", "extraData": "0x", - "baseFeePerGas": "0x3cf", - "blockHash": "0x8cd5f4a012d4f51460556c04b7fc6f4a4d94d1203cb092d0297372a43fdf283d", - "transactions": [], - "withdrawals": [ - { - "index": "0x8", - "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", - "amount": "0x64" - } + "baseFeePerGas": "0x3fc", + "blockHash": "0xc57eea72ca6da6fa23e48e0a02d56ccaa84b59f4f663d04d492ba107f6989475", + "transactions": [ + "0xf86981988203fd82520894717f8aa2b982bee0e29f573d31df288663e1ce1601808718e5bb3abd10a0a097a3b18f6239b6aec0a821a378cae98a6623db266debcbd9eed9c1d5bc40f6baa0490640fa301fc984f82ce5c262befaff288336d97bc20d3ceae26eb01689cc04" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -3301,23 +3351,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8cd5f4a012d4f51460556c04b7fc6f4a4d94d1203cb092d0297372a43fdf283d", + "parentHash": "0xc57eea72ca6da6fa23e48e0a02d56ccaa84b59f4f663d04d492ba107f6989475", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa318a4d8ad3b1a05833ee60497927b12a615d115db0812903b6b3b0117aec6d0", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x97dabc3756587832d8b03b3acffca7fb7466a2ead707cc537dba31ab484880f7", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x69", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x41a", "extraData": "0x", - "baseFeePerGas": "0x356", - "blockHash": "0xeba87b6b36d970ede1071402e363515bfc524572febb086525b84c792093175f", - "transactions": [ - "0xf883618203578301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0a10fa7164cced8d2a3bd2f586c3bccaa86bec0337decd61d6196e028e4030c73a04f09a1f0824fc63829428889a95b7030d8dd809b9e56aea441a09a1a95802bef" + "baseFeePerGas": "0x37d", + "blockHash": "0x38aa8a3150af9b19993b8d4cb3e670bb365853c341f1a24d57ba8e1328afb1ad", + "transactions": [], + "withdrawals": [ + { + "index": "0x8", + "validatorIndex": "0x5", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -3332,21 +3387,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xeba87b6b36d970ede1071402e363515bfc524572febb086525b84c792093175f", + "parentHash": "0x38aa8a3150af9b19993b8d4cb3e670bb365853c341f1a24d57ba8e1328afb1ad", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x905e296705351182cef7897c05522e78c9372cdcbd6a731907faee6f63d20b06", - "receiptsRoot": "0x9eeaf7ef73497823223378406a8d225dfe5b60042fce8770c0c2a7c2c5714936", - "logsBloom": "0x100000000000000000000000000000000000000000000000000004200000000000000000000000000000000020080000000400000000000000000000001000000000000800002000000000000000000200000000000000040000000000000004000000000000000000000001800000000000000000080a0000000000000000000800100000000080000000800000000040000000000004000000000000000000000000000000040000000000000000000000000000000000000000000000000000000020000000000000400000000020000000020000000000000800080020001000000000000000000000000000000040000000000000000000000000000000", + "stateRoot": "0xa97f3e742d168891905997ef57a1f86ecaea7d77ef1f7b2377a4460a5e2cd5ab", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x424", "extraData": "0x", - "baseFeePerGas": "0x2ec", - "blockHash": "0x1db257ebc3fdfbb6fe6fa8234fbc771becfee96128648eac4164773196acea99", + "baseFeePerGas": "0x30e", + "blockHash": "0x853b45ca33c271b321625535fbd242f5edd582be0056641890b66a2b1fbe0677", "transactions": [ - "0xf87a628202ed83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0d24465c4877d28eae24a14ca982e561a5163c6bbe358b1c2f73ff936d50eaeb3a02eaa4e9b5434329a62f7bf3d254bb96eb7dd0b155f2cdb75f6ea37a3518c09f7" + "0xf884819982030f8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa041897d6afedb5cb20754c2b134459edf01d22d468c5b28dcd54802a1f69fde17a04a32652d45cd541b994dcddc0ce35cf9b98cf14d19870d967ae5e6c3b5c5d4db" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3363,21 +3418,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1db257ebc3fdfbb6fe6fa8234fbc771becfee96128648eac4164773196acea99", + "parentHash": "0x853b45ca33c271b321625535fbd242f5edd582be0056641890b66a2b1fbe0677", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb5b20b658b75ed622731629e45c6e98dcaaa3c55f1478d74482795b701eb20d0", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x80c9e740cae1ac0f1eb2206c5c2b80d6a306e943f495ce8dab2a0b926ce9214b", + "receiptsRoot": "0xa6212db9ce25b219d93a8a29f40769b126d4bafd6ffccbc0880c77dbc5fa7f36", + "logsBloom": "0x00800100000000000000000000000000000000000000000000000000000000008000000000000000002000000000000000040000000000800400000000000000000000000000000000000810000000000005000000000000208000000000000000000000000000000000000200000000100280000000000100000000008000000010000008000000000000000000000000000000000000000000000000020000008000001000000000002000000000000000000000000000000000000000000000200000000000000004000000000040000000000000000000000000000000000000000000000000400000000000000000004084000000000000000000000080", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x42e", "extraData": "0x", - "baseFeePerGas": "0x28f", - "blockHash": "0x2a5fd10344d681d2e72384382583b1a9fd82fd0125a1fc24b4296bf3e37cf096", + "baseFeePerGas": "0x2ad", + "blockHash": "0x7bd34591adec12322873c046b6d45fc55defd4891f58e6f26970c14e964bce5e", "transactions": [ - "0xf865638202908302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0492cbed3575864725f568fc42711408ac80668d1afe3dcbce06a138f7b62bb35a0141638d9e8d058ac06a1e817e6c1f66d4a226de5d3047e043fb234b6b89d7e16" + "0xf87b819a8202ae83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0a17e60599dac5123759f100bab44aab2cad0a13e91134df6b840f68c47a7f020a04fe10fa48eaed38510105f9e49289da16ce716fc19af3f45434aaa50d7a16cfe" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3394,21 +3449,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2a5fd10344d681d2e72384382583b1a9fd82fd0125a1fc24b4296bf3e37cf096", + "parentHash": "0x7bd34591adec12322873c046b6d45fc55defd4891f58e6f26970c14e964bce5e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbd4789f74fae185b96efda6c2ef419fe9ab9d33f89de1c3389d1c6e64672d663", - "receiptsRoot": "0x95393692a67eeda3b9cba04610c3dbf9c1a2fcef878680e3365e0a5e13995226", - "logsBloom": "0x00000000000000000000000000000000000000000000000000008000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x3e580ee5e9d009a82d2c87540a4263af7596886ce20ac7261a2e27c083fecd7a", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6c", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x438", "extraData": "0x", - "baseFeePerGas": "0x23e", - "blockHash": "0x647266d2cef5a6b13af790b1b0af42fae3962e80f0724115407e6ecf0b2a6556", + "baseFeePerGas": "0x258", + "blockHash": "0x8f288d915f33362322143bec0749279cdfb9f0b72e7a6c379af08c7b4f88b24c", "transactions": [ - "0x02f8d4870c72dd9d5e883e640182023f830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9a87cc3076dc0da4656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a059b1019e8b01471b1dd478e65c30667d2d1780ed0c8bf5fc784b1413789b2f8201a0c50123161c011aa5c434f47412e85e3d23f83f8eb7f5e653b5e1014cd13528eaa0148a25184ec141ed7f9215254f4f4806f78da682c3d3f66aa3e3c1094f4db467" + "0xf866819b8202598302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0b32880b6ede949484b92e883b687bd0ce727c757bd623dae2415f028b62e4e7aa02ce71b46c90e0065768640c5aa3acb7516fe5b4db286a8338b0515d406197bca" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3425,21 +3480,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x647266d2cef5a6b13af790b1b0af42fae3962e80f0724115407e6ecf0b2a6556", + "parentHash": "0x8f288d915f33362322143bec0749279cdfb9f0b72e7a6c379af08c7b4f88b24c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0366e1c148753cbcf3400abb05da7ae31165163d45dad1c2f33f08f6b4ce4821", - "receiptsRoot": "0xd0d0683682a7dfeecf539831e169a2293fa3304248cecf6d40a759e36658877c", + "stateRoot": "0x1ce25437b8a589f13b7085f231b8f7f5c4a93f885c25eb8d944886c431eb59be", + "receiptsRoot": "0x43c5f978670ef0dae590498c6d0518e967b7c7ed52111d5b13185a938af5d41a", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000009000000000001000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca90", "timestamp": "0x442", "extraData": "0x", - "baseFeePerGas": "0x1f7", - "blockHash": "0x52979d072bdf7bfb3fd707c0f83a4a3de1d1c8fb5380c240f858ed964aaa8106", + "baseFeePerGas": "0x20e", + "blockHash": "0x6886974a4794aa2d984957964c2480cce1346776b180888a3777857b4405e26c", "transactions": [ - "0x01f8d3870c72dd9d5e883e658201f8830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9ede968e005a23ff656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da801a0149abcc3167c411f429a2c9caa64e6ac3e56ae1085a23fcf6494e2ed5d384ef5a00e307ed91455775838666610589af7d05d007f7d0213d0dc50da7800f8501c95" + "0x02f8d5870c72dd9d5e883e819c0182020f830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9ede968e005a23ff656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da880a0e6c33e69ea565fe18cbd379c02857aa56dfe3a972204697ac14d6619e48b2305a002b2af300ad5e3dc36b0e265c4d65cf6c13d5556cb4a1a700a8cdd719d251ee9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3456,29 +3511,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x52979d072bdf7bfb3fd707c0f83a4a3de1d1c8fb5380c240f858ed964aaa8106", + "parentHash": "0x6886974a4794aa2d984957964c2480cce1346776b180888a3777857b4405e26c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x34fed49a40f6a9d0ca498e700a05451505ba89367e63f7a46f1706e58117ac10", - "receiptsRoot": "0xf648e46bd37c97cd795ddfab278e6559906de048035d1506cd5d09af3b35e60e", + "stateRoot": "0xca7162623f72164aeaf374fe3c32c58cd21d8066618c32ca2a4c8c90a2025775", + "receiptsRoot": "0xdcacdeb437408789ca3bf5b1b081a9b26cc7bf6c355db7aaf17443ec89cd05ef", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000400000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x44c", "extraData": "0x", - "baseFeePerGas": "0x1b9", - "blockHash": "0x7a86b91b59bbb2f833af91649b2cd1ba2b4e5f78e5775d78c03ab8b71045b3e3", + "baseFeePerGas": "0x1cd", + "blockHash": "0x20e5954a1da37baa1f7446598fd7d4311241c09d4283fdec67782114693bdf99", "transactions": [ - "0x03f8fa870c72dd9d5e883e66018201ba830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cfd87400839d77a68656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0931bd1e023b91d40d304e3f93356dc9a0458e42baff3b7902c8e37905ff2e12da0578219fac1e70b8e8df918fb511dd7d9c8ab126c302cd77d7777764febc9e3aa" + "0x01f8d4870c72dd9d5e883e819d8201ce830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cfd87400839d77a68656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f201a0cff21674476cc07b9f38cc5aab097071353760a95f9aa2e8049f80caf28f4ddca031559d3752bb3432fff6b568726d9731d15ec40fb1a3b1c4714f60468cdde645" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x39c96a6461782ac2efbcb5aaac2e133079b86fb29cb5ea69b0101bdad684ef0d", [] ] @@ -3489,27 +3542,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7a86b91b59bbb2f833af91649b2cd1ba2b4e5f78e5775d78c03ab8b71045b3e3", + "parentHash": "0x20e5954a1da37baa1f7446598fd7d4311241c09d4283fdec67782114693bdf99", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xabb3c52d564e6e1e1c5d9bf01b6f4d60d32aed3d80a781c1467683529ad75882", - "receiptsRoot": "0x5034e9ebd4c3eb2a30e153892377f3cbc49ab2ad49da8eb85600997255c146bf", + "stateRoot": "0xf138a6a42f8a0b01106d265649d6e1e77bb582bcb504ac5b100ed1e7987b6e0e", + "receiptsRoot": "0x207683b9380f85f9daf6ac31b5cc7ece0a2e4078cef1134779d83b7ce7bd5ce3", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000080000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x6f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x456", "extraData": "0x", - "baseFeePerGas": "0x183", - "blockHash": "0x4643bd6c3e1a9ac7a7ad650d12048b9e733e219b843f2b3d830f5da795852454", + "baseFeePerGas": "0x194", + "blockHash": "0x48ccbd91a8643d6e270829515db0595bc97d123453e4a0bc7a1baea82ca1e736", "transactions": [ - "0xf87567820184830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccf12b9aa38445e4b656d69748718e5bb3abd109fa07920da58c7a8bb3d1a93ae181aaba1994d54bfa9936c6847f452085ca4aab987a05f66b99150ed42111c97dc597bedc8b99a15de0e3fd079231d229d6f344da46e" + "0x03f8fb870c72dd9d5e883e819e01820195830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ccf12b9aa38445e4b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0165e0e0cc13ca53c5af4860637550364c5c90a512906490ace14efb53487374183020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0104f471c547d944706288931b5525d9f332410ad3ebc64963d8b8d2474b01b7ca061e0d3293304121836414e3048b13fb6f884694241d6fe7058d50b22c8604893" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x72a2724cdf77138638a109f691465e55d32759d3c044a6cb41ab091c574e3bdb", [] ] @@ -3520,21 +3575,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4643bd6c3e1a9ac7a7ad650d12048b9e733e219b843f2b3d830f5da795852454", + "parentHash": "0x48ccbd91a8643d6e270829515db0595bc97d123453e4a0bc7a1baea82ca1e736", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xcff80202fad319bbd221a272bf547ee59fc92bf289e20f3162b61a9fefd661af", - "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x7753114a456c78900ad8e9673cf870b8c95db614a0cc1428494876fce0f54cf5", + "receiptsRoot": "0xe1b2c181ff50b25faa3594385214d87e5b6ca47a01bf95a0f3c713d755270a2c", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000080000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x70", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x460", "extraData": "0x", - "baseFeePerGas": "0x153", - "blockHash": "0x7c1fb25dc97d20bb97dce8d8343149b20a96180f46f4b771285546da9d3ef7d3", + "baseFeePerGas": "0x162", + "blockHash": "0xef397b238df4b06cf009bacffc969cdeb71e9d300c860286ca42ac367a950d15", "transactions": [ - "0x02f86b870c72dd9d5e883e680182015482520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a0ec462cecc7c71106b7cc36137de204cc166a0c8903553bb54445d254c9fc0e59a07b804ce9fa8f68064c993b5da7db54cd8bed544975610c8a5f64e7bd6ecdabaa" + "0xf876819f820163830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6f384780a449817f656d69748718e5bb3abd10a0a0c8855b327d545d197c8ea42913d6e6f1a023c8795004d55fa73d74b2f7330996a053b7ac83526f7c656dde300e49653c1a267cd492a762fa0e052417a7ed900e84" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3551,21 +3606,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7c1fb25dc97d20bb97dce8d8343149b20a96180f46f4b771285546da9d3ef7d3", + "parentHash": "0xef397b238df4b06cf009bacffc969cdeb71e9d300c860286ca42ac367a950d15", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc6eeb56e5484926bcf28f23f4c7a45270aa94a09b4d15ce8d3def1eacbe41ca4", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xf5f63230b011d62f47d559f3a6d736919d6b75d8f1bd2b521835b01ee35da07b", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x71", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x46a", "extraData": "0x", - "baseFeePerGas": "0x129", - "blockHash": "0xadf0cc4f267c585703d9e7403b046ab5ba320204592557eef982e4c409e3d2ea", + "baseFeePerGas": "0x136", + "blockHash": "0x9a191d0332521ea449a502780c73defd9d7726f61e22c2f527a03184a51364db", "transactions": [ - "0x01f86a870c72dd9d5e883e6982012a82520894717f8aa2b982bee0e29f573d31df288663e1ce160180c080a0ce04f690427d24c279459d884ed669546ce90f5f2df71b823876a7419259a73aa00609df091f125957bd4d9be5cf19f3470fe71e4be5b4db9f96a0daf31e8f5a57" + "0x02f86c870c72dd9d5e883e81a00182013782520894717f8aa2b982bee0e29f573d31df288663e1ce160180c080a0aeb9d2f1b9bb9490246a5104359ec40f1585b4432d5cd05e9ddeb472efa75e29a0465de58a9af484eb91deaf00c76a59c0327c8a2382dd2c080857e2cceb7e4257" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3582,21 +3637,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xadf0cc4f267c585703d9e7403b046ab5ba320204592557eef982e4c409e3d2ea", + "parentHash": "0x9a191d0332521ea449a502780c73defd9d7726f61e22c2f527a03184a51364db", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa8849ca5ed7a18269196963d71e4ce3c8a376e81a85107104f467e1c77a9ddd6", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xe0ac7c4f27b417077446f788d8926c18413426d90adf42b625120334373041b7", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x72", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x474", "extraData": "0x", - "baseFeePerGas": "0x104", - "blockHash": "0x2ee413006dcb6448fb5c37443102aae3575781369fa9cd34175c0f03e3ddb693", + "baseFeePerGas": "0x110", + "blockHash": "0x340fdec47cff7b492def7053fb1e31b0b185e4dbe7cd0f4b0d382a8dafed7ddd", "transactions": [ - "0xf8686a8201058252089484e75c28348fb86acea1a93a39426d7d60f4cc4601808718e5bb3abd10a0a0c3dc13e38f7bff80b68a31cc9e53f620161dd450f4c696236468eef7c7ba2faea01fb1bc7aa82335170e77594acf9aed68211234bde4bd9d174314178ef74dd94b" + "0x01f86b870c72dd9d5e883e81a18201118252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a0b362243ec3185de1c86033c889074dcacc86181c8aba64aea5035ac644fcecdea06cf847a804833ae95a02f0e657fb7c794ae9106def6686d4fce01e532ba07d8b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3613,28 +3668,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2ee413006dcb6448fb5c37443102aae3575781369fa9cd34175c0f03e3ddb693", + "parentHash": "0x340fdec47cff7b492def7053fb1e31b0b185e4dbe7cd0f4b0d382a8dafed7ddd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8a1ec9a0c964fbaf4b7f1767faad0ea0e1cc88801706c08e97c1b76933e8177b", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xcc19587cfcd1fdce2a73ad7b0d01b4b6b0831d39107ffc3ddcef74cbacee6e81", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x73", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x47e", "extraData": "0x", - "baseFeePerGas": "0xe4", - "blockHash": "0x55487f68bbd481313212ae5cca520be32f0a54c44e77705e13518a9c8b1a54bf", - "transactions": [], - "withdrawals": [ - { - "index": "0x9", - "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", - "amount": "0x64" - } + "baseFeePerGas": "0xef", + "blockHash": "0x821c99ea8afea16f7a10bfadfedd23466f35e9bbde9ec413c2c84b7c7dcc3856", + "transactions": [ + "0xf86881a281f082520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc01808718e5bb3abd109fa067f789b6dc7e2c4128bd1873dce830a92792c36a75b8bcb1d4e227b22562a1bba04a675300d70bfc167d4a7685a9f38eb8bc3a6a87f21eaa2efd3a1e92c01e1330" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -3649,23 +3699,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x55487f68bbd481313212ae5cca520be32f0a54c44e77705e13518a9c8b1a54bf", + "parentHash": "0x821c99ea8afea16f7a10bfadfedd23466f35e9bbde9ec413c2c84b7c7dcc3856", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa53943d22ce3fda978418903209e780b9878ead66bed439adf09e733ceffcb0e", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x4c8b5d435e363146a761bc4ac3b630593d83116a4eb0373cf6d131e74bd4eef3", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x74", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x488", "extraData": "0x", - "baseFeePerGas": "0xc8", - "blockHash": "0xd9fa2ad334f336af1b5f9fdb858c0ed6c956b7e0f9454c5e7ee8b64462725ec8", - "transactions": [ - "0xf8826b81c98301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0844fce1ef5552ade29ffc13373e10f0c4b17c330e87863ce986fcd67a6f24e74a06ac11975e7515b69b03f90faf6f3206817931f607dd61040f8644241de4be8f0" + "baseFeePerGas": "0xd2", + "blockHash": "0x5f07aa290e33f4c5f100362b8dfa284c93b910b9895f066fc2a6242698b6ed52", + "transactions": [], + "withdrawals": [ + { + "index": "0x9", + "validatorIndex": "0x5", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -3680,21 +3735,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd9fa2ad334f336af1b5f9fdb858c0ed6c956b7e0f9454c5e7ee8b64462725ec8", + "parentHash": "0x5f07aa290e33f4c5f100362b8dfa284c93b910b9895f066fc2a6242698b6ed52", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7ebb65f88baf475ec0280941de0ec9b32ff0ecf1d4773ee5a2f2a736d14dfbf4", - "receiptsRoot": "0x6ac819d6516dcb344dca13b617ccde929eba52bdfff5b57fbc3449fa71daa72d", - "logsBloom": "0x00000000000000000020000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000100000000000010000000000000000000000000000000000000200000000000000000000000000000000000000000000004000000000002000040000000080200000000000000000000000000020000000040040410000000000000008000044000010000400000000000008000000000000200000000000000000000000000000000000000000000000008000000000000000000000000000000002000020000800084000000000080000000000400000000000000000080000000000000000000000000", + "stateRoot": "0xb33e182a894d3f528a4a33534816e9ef8fc0451b14abe4e6c5e151878671df7a", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x75", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x492", "extraData": "0x", - "baseFeePerGas": "0xb0", - "blockHash": "0xb7f7753236089ad38a8f5fc7d31811b521331e866eece20f7de934579ab95d1e", + "baseFeePerGas": "0xb8", + "blockHash": "0xbbb17f7c60251f96dc948ee25b7afc5ee511eac82fe10ca186cb860349dacde2", "transactions": [ - "0xf8796c81b183011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0c174c4d0bb9963d480b8254de1b9147a6357c2f19e6ac8a71bcd11a7a2ab12dda0732a1860cec66350374c2cbac1a9f0e8b6386317aaf8597aa6c4bbab4991cfd5" + "0xf88381a381b98301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0a5138be66af28cbaf455d5ed952e47b76baf14544c883d15153678fca309b9a6a05e8e0383deb815320cbaac38554ff3c5327d32ba1afcff2743faa5ab5f3fcd59" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3711,21 +3766,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb7f7753236089ad38a8f5fc7d31811b521331e866eece20f7de934579ab95d1e", + "parentHash": "0xbbb17f7c60251f96dc948ee25b7afc5ee511eac82fe10ca186cb860349dacde2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd65821d8f18e362704ebbc137324dcab618207ce58d8c92ef32990f4dff7761d", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x407c941b1a23d6111bad7e16209fb3835fcfcf9bb70cc8c6c8798fe76aaf0d16", + "receiptsRoot": "0xac3ab9bfa285995e77225cba509246d3e4dadb885d2d4143a23a2fc3abe5d702", + "logsBloom": "0x0000000000000000000000000000000000000a00000000000000000000000000000000000000000000010000000000000000000000000000008000000000000048000000000000004000000000000000000008000000000000000000000020000000000000000002201010010000000000000400000000200000000000000000000000000000000000000000200000000000a000000001000080000000000000000000200000000000000000000400040000000000000000000000800000000000000000001000000000000802800000000000000000000080000000000000000000000000000000000000000000000000400000010800000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x76", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x49c", "extraData": "0x", - "baseFeePerGas": "0x9b", - "blockHash": "0xed36126582b6287363b3cbc31b9c39d7afd4d97ee5e83c00b2cd5449c1d6848a", + "baseFeePerGas": "0xa2", + "blockHash": "0x29e7fcb64ad5f6c93603b4ce8d738253b71bc820c4d0ad9d5438ab5eacdd88c9", "transactions": [ - "0xf8646d819c8302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0dfde1f4a31f0020dc87c2572131bf5d96b9e3a756a0c530eaf1af42c329c7576a02514150fb58cb64b06c460e7af51ded20ced9595d9de56ad88ec982cc5c4794d" + "0xf87a81a481a383011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa026855ef1a5b1ca3e15375ade2c88965bf0c7dcb5309d65c78c5010e8e6c350c7a051316a95caca985d7c43fe51b4827a08fdcfc8449bd5ccc47e7a9968b7887b6a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3742,21 +3797,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xed36126582b6287363b3cbc31b9c39d7afd4d97ee5e83c00b2cd5449c1d6848a", + "parentHash": "0x29e7fcb64ad5f6c93603b4ce8d738253b71bc820c4d0ad9d5438ab5eacdd88c9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbfe4a4ed5d8c5dd809c20601719a5c989a00b8496c2dde4f63dff40ec1ee67ee", - "receiptsRoot": "0xbb4b35695bf1d4da91a2959a4e1beeaf0e94f784016e3abab46fcb118b19c33b", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000008000004000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xe341e4d29ee872f05e45b525449bdf9536c2075a04704b307ed7864c65eae6c5", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x77", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x4a6", "extraData": "0x", - "baseFeePerGas": "0x88", - "blockHash": "0x836c48482765990a0b394761a91ee93850aff87b82fac9b1def52375ed7535b3", + "baseFeePerGas": "0x8e", + "blockHash": "0x2021bdc5b47d00e0f11ec24e61aa59485311e5d98f657841de44e0d1750e0f2f", "transactions": [ - "0x02f8d3870c72dd9d5e883e6e018189830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce5868624950d7b3f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a047cd31a1b89686fa610642222d2da6119e54ee8ca761bd01a649e3759e47746c80a0122f8ed1a3241a3f8428a9e8e34cf6da7ffcc6ae4ac12b7935aad14f1831d7faa0658f5be0960c1ceb873dee434e22a2c80cc97879133d1838673fc8579525d6fa" + "0xf86481a5818f8302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0f46012f411a6d50ffe53fc5c22ba931db152b93ddb188f6edeee8f1ca062e9339f6e327706f4e22469b36dac8a19cbf4d65756d6bb4f3fc49e3f60d8c03aab71" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3773,21 +3828,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x836c48482765990a0b394761a91ee93850aff87b82fac9b1def52375ed7535b3", + "parentHash": "0x2021bdc5b47d00e0f11ec24e61aa59485311e5d98f657841de44e0d1750e0f2f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0e82742b466bce6844a7e2805cca31bbe264af1734e9ea8bb532725d43b1237a", - "receiptsRoot": "0x3c2584b43ed6850bacfb2a0d19311ff17baaa0c01436e7a981abc5f0db79f8a6", + "stateRoot": "0x6caa67c7b30c9fdb1af5fedd55f87696738e7d193058c3f8e1c98820c1489e62", + "receiptsRoot": "0x92c8cf691dd844327c90c5bb04bcfb5345f2ef1394ae36a75e8baa4f65f993a9", "logsBloom": "0x00800400000000000000000000000000000000000000000000040000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x78", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x4b0", "extraData": "0x", - "baseFeePerGas": "0x78", - "blockHash": "0xf01e70ef5e688634e591415823fc7c898679659802e4db0de9ec3c3af735f664", + "baseFeePerGas": "0x7d", + "blockHash": "0xd169f3abbf7dd41949f941333a4920bc5246531e22d02fdbe8ed03361303bf13", "transactions": [ - "0x01f8d1870c72dd9d5e883e6f79830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3549372440f3505b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0dbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f501a056996168cd85e8e5d689565d346c2e139aeef2bf6f1c65cc759b48fdd955968da07ff97b195809ea3b42ceeadcff6d101822cdaf6d1be0cb56fe2b0ef00b5b717a" + "0x02f8d3870c72dd9d5e883e81a6017e830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3549372440f3505b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0dbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f580a00b2c0cf799d43e22a728841a1494e20131a1a2b52e09b9ad57dc487af379e682a01b30b5afd63250806e718773744346534319acceb55957d43ce764163a804b84" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3804,29 +3859,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf01e70ef5e688634e591415823fc7c898679659802e4db0de9ec3c3af735f664", + "parentHash": "0xd169f3abbf7dd41949f941333a4920bc5246531e22d02fdbe8ed03361303bf13", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xae1f69500c8994278c41c0e159106e6f4b688be296fb115bfe6af77cf4d9e6fc", - "receiptsRoot": "0xf7b10686a974aa90247a5f4acaae577e16e0fafd0eed9eb02ebf8186c979cb7a", + "stateRoot": "0x3f73d33f5e42371bf65da8ffb177ee93c69428644866531d9b56691404bdf289", + "receiptsRoot": "0xb10d58cf0d745c9dbce5b4ab33542a137979527e4f053cbb44167a466bad1a05", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x79", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x4ba", "extraData": "0x", - "baseFeePerGas": "0x6a", - "blockHash": "0xc04cb16eda5544fcfa77e18ed2092981e834e71cabc2b61bd25153c830b660ff", + "baseFeePerGas": "0x6e", + "blockHash": "0x9d39f6431f7fe252031d29d7ff4f65e9948d5fdc872709df7eee4e856c0a1a66", "transactions": [ - "0x03f8f8870c72dd9d5e883e70016b830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c377bce5421c11bab656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a047e6cb09a7296ded3a00c5eb72eef7de21f83e5b4f1b5ddfe76bab19eec5bce9a02a0222118f9eb3daa5d7ea174cfe5ca3850889b08f71627e157e79c0c94c2f3d" + "0x01f8d2870c72dd9d5e883e81a76f830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c377bce5421c11bab656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f80a06a33ac88f439c584e45d150712b7e7692b0d7024b3dc900539ef3247853055ada0176000dc39fcf5d596d84ea91e26fe1a211a8d62805db37eceaba5ccb59e1d18" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xcc1ea9c015bd3a6470669f85c5c13e42c1161fc79704143df347c4a621dff44f", [] ] @@ -3837,27 +3890,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc04cb16eda5544fcfa77e18ed2092981e834e71cabc2b61bd25153c830b660ff", + "parentHash": "0x9d39f6431f7fe252031d29d7ff4f65e9948d5fdc872709df7eee4e856c0a1a66", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1480fa2896359aa3cdc46abf7f813a7f4586ca63acc3ed60ad6c0e904bf82e47", - "receiptsRoot": "0xad3ae0362ab95a18b4cbd7d4aae22aa7043fc237ac9a9532d25781124f99d82a", + "stateRoot": "0x1d9609b90685770110b2476d46f49aea2f67737c92e6e9b5c420d2f15eb415f0", + "receiptsRoot": "0x296b867543af84c3d651cbfac504068ce97d86179ba5e6cfe14bcc44e34ed95d", "logsBloom": "0x00000000000000000000000000000000000000000000000000000100800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000200000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x4c4", "extraData": "0x", - "baseFeePerGas": "0x5d", - "blockHash": "0x0041d260ba8d4501bbc92352b34daaaec17e3f3fc3652c9b92d87a587beaed96", + "baseFeePerGas": "0x61", + "blockHash": "0x289c7906360262eebacaf52eae6931669dfb87141c14408ee41ccddb738dd7c7", "transactions": [ - "0xf873715e830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1e6612d36269933d656d69748718e5bb3abd10a0a0b4f6ac5bba5f751656d27aa834bd607a421be4b25fb9bd6d44c0d042590a59d5a0430846ae13aceaa6491aa630da433990c9e6f773ec33ec179917b9f18cc6e323" + "0x03f8f9870c72dd9d5e883e81a80162830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c1e6612d36269933d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a016bee816935475cd45501fc5fd01bf913f8ef54330a43d80ef73101a4c728b3483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a07499c73f4295100f94ea0523fce120fded78b558a61dac9d7b2535e82710cad4a0111aae152b56480ba75a3d2ac49febb0bd173ab893b702ef664ff606551fe932" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xb0a22c625dd0c6534e29bccc9ebf94a550736e2c68140b9afe3ddc7216f797de", [] ] @@ -3868,21 +3923,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0041d260ba8d4501bbc92352b34daaaec17e3f3fc3652c9b92d87a587beaed96", + "parentHash": "0x289c7906360262eebacaf52eae6931669dfb87141c14408ee41ccddb738dd7c7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x05ec31cba0fd8b2ab3bccce33dedfdd7182dfb153dd7538793e27e630d026b93", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5cacd008a445e93a324142ab1bfc5794f5bcce2a2b392bf929e8ad0a3aea5f50", + "receiptsRoot": "0xcfb5f26b28261eac800c3507d09de63a767f7959e88b0f4037d366e5d2133d8f", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000010000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x4ce", "extraData": "0x", - "baseFeePerGas": "0x52", - "blockHash": "0xd2331ab665bad7fa9a43bc09da232bb06c72bc79d817a9f1c5bb05f96b9646e6", + "baseFeePerGas": "0x55", + "blockHash": "0x8d2db945bede6e953aaaa66c1b859b0853a8a12cab8f9f88dc1439e1ff3ea600", "transactions": [ - "0x02f869870c72dd9d5e883e720153825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c001a0ca6f290bc58c596ecf60c042d784bf6614046f417274749abb60a6c8dee20e60a028dc9de376bab6b0f4857ed3f07119ff61152305bc467e07e221f0950992a4c4" + "0xf87481a956830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5a3590fbe3ffbfe0656d69748718e5bb3abd10a0a0f84a2873f18ec9922dc629b684cd45ce085ce9850201eeebdee509bfff5212e9a022cce8b8816ac12e4d36cb810d0e86123b0159c6d637a11b5d5e1740728784b6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3899,21 +3954,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd2331ab665bad7fa9a43bc09da232bb06c72bc79d817a9f1c5bb05f96b9646e6", + "parentHash": "0x8d2db945bede6e953aaaa66c1b859b0853a8a12cab8f9f88dc1439e1ff3ea600", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdb068a648f8027eddd24cf90e37cff5d4b734d68270d9736ebcf79408bab0be3", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x7e2a98e8098df21a5e3ec8f45ae22eece90f13abef7f434d63eebe3b815199f7", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x4d8", "extraData": "0x", - "baseFeePerGas": "0x48", - "blockHash": "0x0043e6a0ed19de50761c59208a225a7f9bac091c3eb7dad46807998cf6ee69c7", + "baseFeePerGas": "0x4b", + "blockHash": "0x66457f34ca4352d6bd07e3db8cfb4f37433c0f9e9d926d5fdbd1535974a28ee5", "transactions": [ - "0x01f868870c72dd9d5e883e7349825208940c2c51a0990aee1d73c1228de1586883415575080180c080a032a2fdfc6e8af7f2aa9e598c6030dcf3bd5bfb3b3e6dbc380ade9a4f6e24ea46a05c9e963837afa3b15e63566bfd577f10a2c35d5877c66fc85cee42ec7cca9f5c" + "0x02f86a870c72dd9d5e883e81aa014c825208940c2c51a0990aee1d73c1228de1586883415575080180c080a014420e1fc7b27d46b3c887ccdf67aed952114dd72d04bd29f06f3b4eaa6b7e81a04c54d830c147d1230a380f1183af14d39e76b2b8b1bd77be8eeb6f0b587a5341" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3930,21 +3985,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0043e6a0ed19de50761c59208a225a7f9bac091c3eb7dad46807998cf6ee69c7", + "parentHash": "0x66457f34ca4352d6bd07e3db8cfb4f37433c0f9e9d926d5fdbd1535974a28ee5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa32b1b718a1517a2dbb796c8428a8949d51c845cb5bc68ddc5829aca9cd184b5", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x1eadcb4a0fe52d542e5ea4f94887a525f9b5f717472c583cbdf61931834d7b82", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x4e2", "extraData": "0x", - "baseFeePerGas": "0x40", - "blockHash": "0xf64f01561392db4d006de40b0c35b3b8b56204cbd89b734608d148d2ae629228", + "baseFeePerGas": "0x42", + "blockHash": "0x6afdc529eb5072bef6f94d783505d24465dbb564d90cd22e668c549929d19615", "transactions": [ - "0xf86674418252089414e46043e63d0e3cdcf2530519f4cfaf35058cb201808718e5bb3abd10a0a04492dad8443375d9959f8fc24313113adbe78f4d8675ea6028d50fc459f3c34fa06222bd09536c90124b7a82a43c817c38a34ee8bed6af3fa4b293ae4aa31a189a" + "0x01f869870c72dd9d5e883e81ab438252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c080a006c8f54096b844bea98112ea6365153b95771820e116040c9b5534905c828154a07cf9595cdc1661f4180a064ca64334249c8917ce90e0ecb265678eb5b1e6e92e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -3961,28 +4016,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf64f01561392db4d006de40b0c35b3b8b56204cbd89b734608d148d2ae629228", + "parentHash": "0x6afdc529eb5072bef6f94d783505d24465dbb564d90cd22e668c549929d19615", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc7a87b275cac7243486e8f78dcd2dc1dd561d74319222ca75f00b2c4a1dff6bf", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xa1bbd210e8703502ba17727b89ee0db73a83a227cb5ab0133cc99398352e296b", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x4ec", "extraData": "0x", - "baseFeePerGas": "0x39", - "blockHash": "0x49e6318f4587a021ad50e32ccad223164e0cc1ba28e1be6ee01060d331ecebbf", - "transactions": [], - "withdrawals": [ - { - "index": "0xa", - "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", - "amount": "0x64" - } + "baseFeePerGas": "0x3a", + "blockHash": "0x6d83bef72d2b5bae5824e9489cd9f98336df2e38500e48a8ef3664bcf9358374", + "transactions": [ + "0xf86781ac3b825208944340ee1b812acb40a1eb561c019c327b243b92df01808718e5bb3abd109fa08e5a308f2b14221042af194e912f88dbd52c261536c913cb1190e36a432f6e87a0584c48ffe6c228afac193d806b7ad4d7a73be3ddf49fe1917d758262485f6554" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -3997,23 +4047,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x49e6318f4587a021ad50e32ccad223164e0cc1ba28e1be6ee01060d331ecebbf", + "parentHash": "0x6d83bef72d2b5bae5824e9489cd9f98336df2e38500e48a8ef3664bcf9358374", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x96e7a8269c8e48ac7a7b445f1b438f88c1534d0bb86c21c7dd52885ec1481b8b", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x340c95da0e49447da1de182ca9a5d02ecbc34f48d02bddfd610b07fa6b0943d2", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x7f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x4f6", "extraData": "0x", - "baseFeePerGas": "0x32", - "blockHash": "0x51af93a015c8a1395fdf3030bfa74b3f7104037671ab930defa6eb75e222e1eb", - "transactions": [ - "0xf88175338301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa052d500007cddc18002c2672c0dbc1990811460048d361419dffade1ce101b832a04f6108a2fa5a99ffc810d8593e6c3995ada16e5a1ca772a67d9ac158256758e6" + "baseFeePerGas": "0x33", + "blockHash": "0x16712d8be0e3f51b960bc8d1a39d96d79eb37a4c4ef736357367ea38a9287711", + "transactions": [], + "withdrawals": [ + { + "index": "0xa", + "validatorIndex": "0x5", + "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -4028,21 +4083,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x51af93a015c8a1395fdf3030bfa74b3f7104037671ab930defa6eb75e222e1eb", + "parentHash": "0x16712d8be0e3f51b960bc8d1a39d96d79eb37a4c4ef736357367ea38a9287711", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8310dc68223b2c72b24ce65dd25aaf65b275894ca69f2c7681680a7598571444", - "receiptsRoot": "0xefd8b8e464ca380008383fda4fac3a7a461e5f0474d252d603f316debd45de9c", - "logsBloom": "0x00000002000041000000000200000200400000000000000008000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c00080000000000000000000000000000000000000000000400000000000000008000000000000000000000000800000000000000000000000000000000000000000000000000000000000080000000000008000000000000000000000000000008000002000000000000000100000000000000000200000000000100000000000000000000000000030000800000000000000000000041000000002000000000000000020000400005002000004000000000000000000000", + "stateRoot": "0x8acbf719a58ff74e046433f815412cb38a696863ccb330893593d71a5ac248e0", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x80", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x500", "extraData": "0x", - "baseFeePerGas": "0x2c", - "blockHash": "0x7ca2f8c5a75e26ee5575e7d68fb5035c6a3ad57fb35b1308c19cf0c563e86b55", + "baseFeePerGas": "0x2d", + "blockHash": "0xb97b02fd00e46ec8d5b47eac30dff86679166d19e3485e4b7f979bec91fa7e0f", "transactions": [ - "0xf878762d83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0f681d83827bf4634bd4e1ecd3026953b8b2ebd0014c6db725491f9d6989e1e14a03b3335cf3f7999c19274f41fa482fb6363d4e18626accccadb347e5817b22481" + "0xf88281ad2e8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a094d63da6ecadc8763c6fc569386579a1c8cc77dd39edb2973a273508e39aebb0a04337e8d0a408809a2996b19be20a7b8f155256be70f44caeddfabb1f2a063e01" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4059,21 +4114,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7ca2f8c5a75e26ee5575e7d68fb5035c6a3ad57fb35b1308c19cf0c563e86b55", + "parentHash": "0xb97b02fd00e46ec8d5b47eac30dff86679166d19e3485e4b7f979bec91fa7e0f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbcab9d02dcbf723c5d60536871e651f6ffe620546c5721cd6439f72fc9121935", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb27928f6d85906997f70782f19936567637c9bcb8876412a24a9adca4dd4d040", + "receiptsRoot": "0x78bf002def881b942f59bd9f0bac91ba3a525640038dcdb1e0b25e9b3249b2dd", + "logsBloom": "0x00000000080000000000080000000201000000000000000000000000000010000000000800000000000000000000000000000000000000000000000000000010020000000000000000000008400000100000000000000000000000000000000000002000000000000000080001000000000000000000000000000800000000000000000020000000000000100000000000000000000000000002000100000080000000000004002000000000000000000000002000000000021000000000000000000001000008000080000000200000000000000000000000000009000000000000000000000000000000000000000000000000000000000000001000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x81", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x50a", "extraData": "0x", - "baseFeePerGas": "0x27", - "blockHash": "0x7614b81f123a279df0a712b8e9f0a9999add17fa9020ed9fabd1fd89315362cc", + "baseFeePerGas": "0x28", + "blockHash": "0xc407ae41449bc17863646ffe04e7a8107b4a2145152c875a5f910fdb54cc2701", "transactions": [ - "0xf86377288302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0c146142efd1561230a2d2ef6ecec9cf9be6271a10fd51ecf2e7ce09758037be9a069a11d8bac3df89cda3e144201a06f7fcf7e0cd170306e3d6cf0e51116efea64" + "0xf87981ae2983011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a09e2ba151002a18ce41caceb5a1e545a8fdaa62ce94b7fd48717f223aaf610eeea01edd9fb887a8a37e0b1820ed03d6efc284d387550ae400c562ec0fbd9ecc5d12" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4090,21 +4145,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7614b81f123a279df0a712b8e9f0a9999add17fa9020ed9fabd1fd89315362cc", + "parentHash": "0xc407ae41449bc17863646ffe04e7a8107b4a2145152c875a5f910fdb54cc2701", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9c8f0ef089a58523152c15c140a1c89aeca3a7876045f93097574e1099f4583e", - "receiptsRoot": "0x0e199ed3c170c92dca3cd1aa9248fe6a9f6bcd95c64d18da5e54bdfc3b422717", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004800000000000000000000000000", + "stateRoot": "0x76e565499e484affc5c1708a70f87b11e744772b1464b91c260efbfa2bdccd80", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x82", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x514", "extraData": "0x", - "baseFeePerGas": "0x23", - "blockHash": "0x218dd8608e6cdb93545a3e1203979ab4ca55f0f5bccf76a533fdd191d19f708a", + "baseFeePerGas": "0x24", + "blockHash": "0xf2253cd37aa85a5a3332dd6d777d209db9644eb59806646a39dd5869cdc496cc", "transactions": [ - "0x02f8d2870c72dd9d5e883e780124830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c99ca04a4bf313cdd656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0562f817652b4478bc1e434240cd21e00774a5a1210833cbf0225273e2b98bae280a01f430a7342e607007f513ba0696d28e052c0a2ef944fa28aeaa4037034009210a0309576f12525f004074368b7f8248c46cb033b311c4d898f9c8fcfcb12c03e85" + "0xf86481af258302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a05975ba53224ec111ff1bb23873600db7cc61926c3847316c4e2a492b20fa5732a02c068c3244eb42cfd7b92137b27fb9f25f911e1df7e7be93368f606cb3542ea6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4121,21 +4176,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x218dd8608e6cdb93545a3e1203979ab4ca55f0f5bccf76a533fdd191d19f708a", + "parentHash": "0xf2253cd37aa85a5a3332dd6d777d209db9644eb59806646a39dd5869cdc496cc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd4398f2e95d2b42f66c099f5f54bf784ba5e513926c56ffc18f72e9243c9256c", - "receiptsRoot": "0xd2739a1d0afc6cfbfb2a3cc7da84309cc3b60aef32cf4654c2d836a711bdbab0", + "stateRoot": "0xbb7ee79189b09144739cb6d6b9a15fc93fbbe226bd9c0e804a167441be168c03", + "receiptsRoot": "0xf24c9ed06c403ec3641a338b6bf76d2b8b69c09637089ec672663b52bab7a270", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000001000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x83", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x51e", "extraData": "0x", - "baseFeePerGas": "0x1f", - "blockHash": "0xa5e002a44d498e7a40b8a36eeb8ce8101353c3d379a5955d5809fcaf559a2bfb", + "baseFeePerGas": "0x20", + "blockHash": "0x4185ee3fea8a5aef0c504563c6c4e08f4ebacc343720d6c179ab5cc24c15e1dc", "transactions": [ - "0x01f8d1870c72dd9d5e883e7920830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb3ce3e52ced1e406656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea4500303480a0d3dd236e2e105b7bee61b1b48f944948afdcd12dfecb955bb752af7b8c046adda055eb47d4d846ad6954754a8bd9e8c224a2052202008ebdbbbb4fa7f339273c8d" + "0x02f8d3870c72dd9d5e883e81b00121830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb3ce3e52ced1e406656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea4500303480a028b8f0363d8fb373dcb8fa21b62103f630fed526ecf5a90b579c5a00d331428da04628f11ee1c58986a7609c7c1fb6eae0d7fb84ae83af6cb7e3509dc87172c1d5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4152,29 +4207,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa5e002a44d498e7a40b8a36eeb8ce8101353c3d379a5955d5809fcaf559a2bfb", + "parentHash": "0x4185ee3fea8a5aef0c504563c6c4e08f4ebacc343720d6c179ab5cc24c15e1dc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc2deaea2a4f5283a91fd7da8b0a078c1dee45e03e52373016e7880b32185601f", - "receiptsRoot": "0x24fd8bb66bc1411f5e1df9829f471db8c66dd4e59df98c2c7f016fdf1b95162c", + "stateRoot": "0x4446c578b3a536638c4b16440c3589c747d8a4d95c998bf9407de3cb775ef1b4", + "receiptsRoot": "0xe329fe07d7e78174b7a34c5069074ce4f0306ff5541b45bbfc122b4c9c2dcfed", "logsBloom": "0x00000000000000000000000000000000000000000080000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000002000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x84", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x528", "extraData": "0x", - "baseFeePerGas": "0x1c", - "blockHash": "0x1f7613cc089d031344e77e764174fee74d4eb6f501f467664b12220179d10fac", + "baseFeePerGas": "0x1d", + "blockHash": "0xa8c286786d85b5134461a58e930e24544971798fdb65aa5daf662cb224a9fe40", "transactions": [ - "0x03f8f8870c72dd9d5e883e7a011d830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c9686e77044883203656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a02d932238962a79cf74fc0d1d98eb7eb35a6a95bb961538c9e439d457810940efa0607bd4ac5c4ab3080847eabc8647734c4f211dcbe0c02516bfac55bbb8bd4da6" + "0x01f8d2870c72dd9d5e883e81b11e830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9686e77044883203656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c680a0200604dce713ec4a8a6b0f3825cb26b9ea9b1a0da084404a2bda2d73069952aaa070324b2af9d515556462318e4eadfe3ade90d12af7b669a351679c633bc63ce5" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x5f5204c264b5967682836ed773aee0ea209840fe628fd1c8d61702c416b427ca", [] ] @@ -4185,27 +4238,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1f7613cc089d031344e77e764174fee74d4eb6f501f467664b12220179d10fac", + "parentHash": "0xa8c286786d85b5134461a58e930e24544971798fdb65aa5daf662cb224a9fe40", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6cc6238c45c78f3aa66a619a09daf0d65769b3ef8698df424412d84e789d694c", - "receiptsRoot": "0xb85a4beec31e19cff4e11eedc6048b1458277fd803588a927a0b10645fbf09bb", + "stateRoot": "0xeb421e4444d173b5c42082f64ea03fd658a87dcca0265233b8e0eb20cc52f1b5", + "receiptsRoot": "0x49322e9c1e4cfb4f3c4c1a62084c1a153c335ce9a9715dd56a46fcde04073cf6", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x85", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x532", "extraData": "0x", - "baseFeePerGas": "0x19", - "blockHash": "0xab82fa0386891a0f6590a93f3b0c6852f582a38757c1a32d1d37a8195830c9ef", + "baseFeePerGas": "0x1a", + "blockHash": "0x8ca47a4e017b39fcff33d45a2d8be59d4a66b73516c322c950a5d8ed77d29fc8", "transactions": [ - "0xf8737b1a830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9080873b94ba4d37656d69748718e5bb3abd109fa039e86bd7baaa40d2feb73cc99b71b4ecca448258c13fbca6ade8b9148c464e22a07a9c6db0c1493357ac938689eb50dff7368fc83d774fb8779b6d3774b16dd2e9" + "0x03f8f9870c72dd9d5e883e81b2011b830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c9080873b94ba4d37656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0af1f0d50933e49dd24b61a24c670809a5b875e3b746862636288dead8579dc4e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a049b90ae04588ab88c3c610e04057a6e6f1eb102f83a41bd86c665c87c7ec6010a07c9611e201df0beacd9c8f2340f66e6f0888028b9c938a678f64f93b8970412f" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x5ba9a0326069e000b65b759236f46e54a0e052f379a876d242740c24f6c47aed", [] ] @@ -4216,21 +4271,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xab82fa0386891a0f6590a93f3b0c6852f582a38757c1a32d1d37a8195830c9ef", + "parentHash": "0x8ca47a4e017b39fcff33d45a2d8be59d4a66b73516c322c950a5d8ed77d29fc8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb8f05e7edf45432becb47125a06723edfed825fe60d1c737495a2943f2931b94", - "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcf683f9a8fc2e09a2a7d6630f527f1c9c6b7924f5f995482516ff0c4d79b93d3", + "receiptsRoot": "0x78f959e0b126f88874a77c41bf993ed21543a27d93b487da4ad510bc20e5b96d", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000008004000000000000200000000000000000000100000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x86", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x53c", "extraData": "0x", - "baseFeePerGas": "0x16", - "blockHash": "0xb0d4b43954c092e02e74342616a87ee25e15dabb9ba4d94c0bd474a907dff210", + "baseFeePerGas": "0x17", + "blockHash": "0xc4974092ba20d3c24becf83c675956c9f6602d500d594df532c50a50eb5b2191", "transactions": [ - "0x02f869870c72dd9d5e883e7c011782520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a08c9649b9b7aaf52480798b0a7cae37b11d92860c73e1b027f3fc679e6e4d7ccaa03075417132f7ae630e7e0f6b25b453fa59eec3098a931317d52c0578e02bef5a" + "0xf87481b318830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9a0793cd2f811c2f656d69748718e5bb3abd10a0a00e15dd4043e12cdfd8ee3dec9c459492f8a3e528aa60e3ba6acbcdfd59238549a01841e554d95bb45b914d82ae2d8377aedb51c009fedeb7dc0fbee0ea2cc561f5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4247,21 +4302,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb0d4b43954c092e02e74342616a87ee25e15dabb9ba4d94c0bd474a907dff210", + "parentHash": "0xc4974092ba20d3c24becf83c675956c9f6602d500d594df532c50a50eb5b2191", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3014013b123c35cd5d494cc382ce4fcb877bd594d6f34937fb169db6bd4b595e", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x9cee696519e3c8c9d45c6929bebf1fc35b452d1e7ae59fbe275d3f51a1e53b79", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x87", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x546", "extraData": "0x", - "baseFeePerGas": "0x14", - "blockHash": "0xf14886af3d36d40608acfeebf709b67d679146b86594eb7f3d717ec214cb423c", + "baseFeePerGas": "0x15", + "blockHash": "0xd84d3edc5cce7692db143df3abed01f05fb1aa8a6e7b468cc55e46db10c821bd", "transactions": [ - "0x01f868870c72dd9d5e883e7d1582520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c001a09e397063008ad5f6e64e5523f5976457c60e7aa2b15caad46f81c8bf11bdd971a029ceb9831415f2670bacdba2bf1dfb10060b89df9ae3faf7cafc5186d89bf5c2" + "0x02f86a870c72dd9d5e883e81b4011682520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c001a032e9acab0aaedc9a6d597ffaa190a36db1b49c7e56904de8e4b0de46d101aa6ca057b52014d9124de1a283ff1e1f085e494f576f067f5434ee0c3af4397e8af808" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4278,21 +4333,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf14886af3d36d40608acfeebf709b67d679146b86594eb7f3d717ec214cb423c", + "parentHash": "0xd84d3edc5cce7692db143df3abed01f05fb1aa8a6e7b468cc55e46db10c821bd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce9c1f4e0d2f824c7fd3f8d97a7d46b165f08b7f9e3cbd58bcff478ee5906e8d", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x62094902d5724b10739b9bdcfeee5288699fa25553c41af941c347b457da6e87", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x88", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x550", "extraData": "0x", - "baseFeePerGas": "0x12", - "blockHash": "0xc310edfd4b8d1456b9d2f25ad392a0f409356115a0b6baa06c5055355e690380", + "baseFeePerGas": "0x13", + "blockHash": "0xdccdc1d4567294a4ad0281a7386e643435a612358a8687b79707541a0e572e58", "transactions": [ - "0xf8667e13825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd10a0a0a8e6163a5aaf23cc3407838738c30449547cab7596386147ca02e9187eb0223ca05f8d7500498eb3601b606146a5ca3e1e490aabbd8398f95f7498deddec90f868" + "0x01f869870c72dd9d5e883e81b514825208940c2c51a0990aee1d73c1228de1586883415575080180c080a07eec774e019caadea89c99edcd3c8201c5ed0bfa625773e6d815496f25ef561ba04000ab033e2b451ebd982ca35052e9ee2570503bef1690abfceb1d534fe9cdb8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4309,28 +4364,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc310edfd4b8d1456b9d2f25ad392a0f409356115a0b6baa06c5055355e690380", + "parentHash": "0xdccdc1d4567294a4ad0281a7386e643435a612358a8687b79707541a0e572e58", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x34907069df9fccdce8426d160e557127cb90c64dd2a3c49eaffaec5cfce14889", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xc0b8e44839fff97c5de61362219e96a8251565ada18d7a697ba7c12283401d1b", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x89", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x55a", "extraData": "0x", - "baseFeePerGas": "0x10", - "blockHash": "0xeb26879fc8d9023ee720917ace6b9bfebe36c4b18c476581524c26ff6b1b1770", - "transactions": [], - "withdrawals": [ - { - "index": "0xb", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } + "baseFeePerGas": "0x11", + "blockHash": "0x9c338a73883a108eb3ac237422cc78ba03e073881d79758dccd91587b69164fb", + "transactions": [ + "0xf86781b61282520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd109fa08f549ed1b90821980450d358705366f82e85469df9e52acde2413c95a2b04b7fa051cc4bb372f1883538285a80e001ef96b0359f2a152ff054c18783d5e2ca7741" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -4345,23 +4395,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xeb26879fc8d9023ee720917ace6b9bfebe36c4b18c476581524c26ff6b1b1770", + "parentHash": "0x9c338a73883a108eb3ac237422cc78ba03e073881d79758dccd91587b69164fb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf24a7ac20ba67253c7f7dbcd1f1fb58f3b560da554fdf15787adcc2ea7352f04", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xd5df990c3f0155e1ce3e9314cdacbdc4ef45c93e8ca7a3a5b8ba25aa8041f96b", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x564", "extraData": "0x", - "baseFeePerGas": "0xe", - "blockHash": "0xbc885f1dd76d6044edf950a00f65f8b7e09037b64694a8a5bf040a8f875df73d", - "transactions": [ - "0xf8817f0f8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa00e72485654ffa94bcd36d1670fc89157d9195087a4958e6ea2c10562eced83c1a077968946182406940484c4909601e11ed580e2696f3493c7175fbddd19312c93" + "baseFeePerGas": "0xf", + "blockHash": "0xcdd79ad9085d20d3fd31b042a53227c3760792c62e42f29a10400382b2d8dcc4", + "transactions": [], + "withdrawals": [ + { + "index": "0xb", + "validatorIndex": "0x5", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -4376,21 +4431,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbc885f1dd76d6044edf950a00f65f8b7e09037b64694a8a5bf040a8f875df73d", + "parentHash": "0xcdd79ad9085d20d3fd31b042a53227c3760792c62e42f29a10400382b2d8dcc4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x374c1bfe201a2258607d0523b591bb3ab9321842477f16707d83aac398f7f16b", - "receiptsRoot": "0xbd8b87a861501658112e3db9724e09bd5b25d0893525ffda947d4779df5c8b9b", - "logsBloom": "0x00000000040000000000000000000000000000000000200000080000000000000000000000000000000000000000000000000000040000400000100000000000000000000001000000000004000000000000000008000002200000000000080000800000000000000000000000000000080800000000000000001040100080000000000000000000000000000000000000000000000000004000000101000200000000004000000000010000000800000000000000000000000100000000000010000000080020000000000000000000000000000000000000000000040000000000000000000000000000000000000000800000000000000000000008000000", + "stateRoot": "0x3383a866fe5d985b101657e6de0425f7ef6d214e208f7af5fd2bd61122d4eb29", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8b", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x56e", "extraData": "0x", - "baseFeePerGas": "0xd", - "blockHash": "0x3f8e6751bb589f71b4529f33b341be4bcbb64cc89a86ac00ba2ecd28b96843f4", + "baseFeePerGas": "0xe", + "blockHash": "0x344657a467d897d67b16bf7bb922de11197ff1b4c1ea2749a82749b854f53e94", "transactions": [ - "0xf87981800e83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa02e68a3e01e0491870679191bd5d5a8f24c9ad0695c0e466a5b2083bb17939812a02c6946e6087d40aa0f34fbf65c20f71298b0acab2931d114f9253ca0bd2aeeee" + "0xf88281b70f8301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a057308c5fd37531f5fc3ad1677290cb900caaa60b46b96155bfb98f292b70724ba07cf6c86968468dba0aef0956bf79c2706f1d6fa5a9322523e803fe3db85197b0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4407,21 +4462,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3f8e6751bb589f71b4529f33b341be4bcbb64cc89a86ac00ba2ecd28b96843f4", + "parentHash": "0x344657a467d897d67b16bf7bb922de11197ff1b4c1ea2749a82749b854f53e94", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe12f0c307f5b8dbd21ffb62035a3a29f8214b886fb4ab820d52e777272739527", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcd90a9b18190850ad23264ef71618a3492995a5498eea23c5c5df454b1a6617a", + "receiptsRoot": "0xfe5ceeab9511d0b0c785330e83642dbf57f8d67b87e3d7d54b9b0ddc3d355c0e", + "logsBloom": "0x01000000000000800400000000000000000000000020020000000000000000000000000000011000000000000000000000400000400000008000000100000000800000010000000000000000000800002020004000000000000000000000800000200000000000000000000000000000000020000000000000000000000000000000200000000000000200000000000000000000000000000000000000000000000a00000003000000000000000200000000000000000000000000000000080000000000400000000000000040000000000000000000000000000000000000000000004000000000200000000000000000000000080000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x578", "extraData": "0x", - "baseFeePerGas": "0xc", - "blockHash": "0x53c40989ba0f74285db823aeb706fbdd2f34e53b65edf8edda6054f6fe0154f0", + "baseFeePerGas": "0xd", + "blockHash": "0xc34874c1c02df9d9f0f62ff0c9451be8623e01125af8abcdfb0a3e5fd39753b0", "transactions": [ - "0xf86481810d8302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0790f5ed3e0a86db50c08e8f8be00a4ffba3441d16fb346dc9770eb3ed42d3382a04e5977b201718f87ecefd86cb78c73e445490319a286721ea8eca3e1d9d56326" + "0xf87981b80e83011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0c04438100b1f00f280d0e6df1df756f9e392c0c71ec4b56ac1fedf3c76a234b2a015c9453b9e2d35dce89d5443da2bf9cb24d375cba9e0afd233ae1edfc3fc061a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4438,21 +4493,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x53c40989ba0f74285db823aeb706fbdd2f34e53b65edf8edda6054f6fe0154f0", + "parentHash": "0xc34874c1c02df9d9f0f62ff0c9451be8623e01125af8abcdfb0a3e5fd39753b0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf54e2a19725ec61f6c584507212b46c69f46612692deb8831b23169f30c7d8c3", - "receiptsRoot": "0xa8125b1762025ce748089560e745a695d68cd5f1d6bce93b9c203e3ead57e848", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000008000000000000000000000000004000000000000204000000000000000000000000002000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb2dd76e38b11d311e81f7a740bcd9cb83e168f69b7fc8a2c7f007ddf5af0b055", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x582", "extraData": "0x", - "baseFeePerGas": "0xb", - "blockHash": "0x56aac6e61bbe149532c6f833c15bea8fd7739b35b114c63d0c81d1b6803a9324", + "baseFeePerGas": "0xc", + "blockHash": "0xf26963dd24f2fddb0fcb041ffd520a4a8571622f70168563809051d1f78f5952", "transactions": [ - "0x02f8d3870c72dd9d5e883e8182010c830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccbf493b3fd5e21b0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b9f03edd278ccfc90e45785c1fea3f972618a32899f836dd4fe0e63eaf8c7c4001a0b3b89d84c11187bb50f67a342fdae6a35e024b4a6a4ff546733645767045760ca05e1eeee847ab7f53450eccdf65f9dcc0d41c4e709dd5d9ea938fbeff783e5d68" + "0xf86481b90d8302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa09f8aa7dda49f464aa1f4f8519484cf1b673ec01872e12bd35637666bee7025fda02074a1b2b7d3290179447179f9788c0c146e42784ecacdc844da0c6edb192edb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4469,21 +4524,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x56aac6e61bbe149532c6f833c15bea8fd7739b35b114c63d0c81d1b6803a9324", + "parentHash": "0xf26963dd24f2fddb0fcb041ffd520a4a8571622f70168563809051d1f78f5952", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb964b6c8e95c7efa510287147e3ff724e70b308f6057ab45a7b2145b39747d25", - "receiptsRoot": "0x9d62ba578ebcff7a0054729605a139f9f7292833c6773b0ef0125f3e7723f404", + "stateRoot": "0xa370b7c8886acece71be21d4dea69a48c838ce0d785245f36e8b1fd0dee1dcde", + "receiptsRoot": "0x98d5a8d9463c7cfd16619a1d08b39fddab9070eac03e815b0855dff50a632a83", "logsBloom": "0x04000000000000000000000000000000000000000000000000000000800002000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x58c", "extraData": "0x", - "baseFeePerGas": "0xa", - "blockHash": "0x20a194b00f602fcb1db01bb84014dda4654f7bbf59de521992100e4c90d95eae", + "baseFeePerGas": "0xb", + "blockHash": "0x5b33c4a77a663f8420d206e8c8c677b306dd9dda3c549b73978c22385e064edb", "transactions": [ - "0x01f8d2870c72dd9d5e883e81830b830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cff183a49015bd7b5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f298480a0db78a0e59dce232f5116604b4eedf3edf585172a505530cd0ced9c1574be944ea051d0573c904c5fbddea3424251c85cc629f7d4c8e4ec14a25d6bfa929c375b22" + "0x02f8d3870c72dd9d5e883e81ba010c830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cff183a49015bd7b5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f298401a0c1256a32789b5fe90540903202afdfad4c7f5c187fc88a667184e3dcd6466d86a043d7e25ff9f0d4ce4e5b6b257b1b522c9a3a016f7019c4578b6153395166c4b0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4500,29 +4555,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x20a194b00f602fcb1db01bb84014dda4654f7bbf59de521992100e4c90d95eae", + "parentHash": "0x5b33c4a77a663f8420d206e8c8c677b306dd9dda3c549b73978c22385e064edb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4ec7a8beedb541399d064d98c10425602e479459c9dc4a3e3ea520bff571c303", - "receiptsRoot": "0x7a3e7656e97605f422dad63c732f0d4f9b377abf5f689e6797fb4ac3a371eb97", + "stateRoot": "0x8e1d102032a6109e16aeef5dd9cd242d5cc66eda8a69ade9abdc95c02fd86c76", + "receiptsRoot": "0x88deff45d0fe91c2f6850181d6ad7390fde228c2f6e5abb0d3830d3459672fa0", "logsBloom": "0x00000000000000000000000000000000000000000000200000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000200000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x8f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x596", "extraData": "0x", - "baseFeePerGas": "0x9", - "blockHash": "0x6a7e2a65b2c12ddb337eef91aa0772eae0064f24028cbb5f8d4d7c0c8f1437f9", + "baseFeePerGas": "0xa", + "blockHash": "0xc6e8d87cdf8be0370ba65cf1df31014d0ff6d70d4c63dec3968fd63c7fbaa74a", "transactions": [ - "0x03f8f9870c72dd9d5e883e8184010a830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c3a4d2a2d8e89dcaa656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0faca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda783020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a026afa46d3cb08b993c92000c3d8ee74b6abc12ab63e64adfcb0555404d56b899a0420f20f106de44b6e28510d45b612268c1c0172aaceae7569db3ffd1cd1da249" + "0x01f8d2870c72dd9d5e883e81bb0b830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3a4d2a2d8e89dcaa656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0faca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda780a0b34564ae1216ed23a180648a9398609b48f7f5a4f786cd25fa7e26adf427b84da06a1f0863160a10acc0af91e4aa129b1ff0327966e52c0b14560c482757af9336" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xfc7f9a432e6fd69aaf025f64a326ab7221311147dd99d558633579a4d8a0667b", [] ] @@ -4533,27 +4586,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6a7e2a65b2c12ddb337eef91aa0772eae0064f24028cbb5f8d4d7c0c8f1437f9", + "parentHash": "0xc6e8d87cdf8be0370ba65cf1df31014d0ff6d70d4c63dec3968fd63c7fbaa74a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4eec2647b04de80dc0d87bbea4c6b0ab96e8b2bc11ee339fe44817f348e5e296", - "receiptsRoot": "0x7d644822f58fb3e699e5d3b1d271ffae81684f751f34c5b7fa47ab9dda46fce7", + "stateRoot": "0x7299bbf0e68f51d3a4a053519ca1eaac62ce1b73e2f40c1ded6b0007a5e2369e", + "receiptsRoot": "0x79a3f6b00de36045af809a4ff54f7f35c3a124c4838006f6e62d62b3985e6fea", "logsBloom": "0x00000040000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000200000200000000000000000000000000002000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x90", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x5a0", "extraData": "0x", - "baseFeePerGas": "0x8", - "blockHash": "0x2f3f1707049c34f0ce4b2222d6cbe9f149d79a0e2c1ea6101058cefe33e9b3f6", + "baseFeePerGas": "0x9", + "blockHash": "0x94fd8a5a17afb5aa4438bd72dddf23c73c0ed5059227e6d84a327e217593cb65", "transactions": [ - "0xf874818509830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c80c3c5cf7f5cf0b5656d69748718e5bb3abd10a0a0e0ac4eff9ebab8559197243bef5cd2c60aa79adebc4497312e60029f504dcf14a02434c08e81ef95b7ecf18451d4ed1840da75b11851e68df7a9854c74be700af1" + "0x03f8f9870c72dd9d5e883e81bc010a830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c80c3c5cf7f5cf0b5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a05b300d53be5798f53b472dadb8966674169ff3e8d08eccb3f065bd827abd7b7783020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0f851c2d3a735c7ef307477434eb4b5ba1c30d070febbe9b4865904777447516ea045a97fc6acf7ae508165a18bcf6516660b745f80565ce9c5edf2266f40a161a0" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x949613bd67fb0a68cf58a22e60e7b9b2ccbabb60d1d58c64c15e27a9dec2fb35", [] ] @@ -4564,21 +4619,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2f3f1707049c34f0ce4b2222d6cbe9f149d79a0e2c1ea6101058cefe33e9b3f6", + "parentHash": "0x94fd8a5a17afb5aa4438bd72dddf23c73c0ed5059227e6d84a327e217593cb65", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc45cb8b8a6cc4822bb401e7544b060f50bfaa1a177423c129d9c54ea0e67e3eb", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x709238142976a079d01661a354c91b5e6ab29d290b35d82ead568a07837d3630", + "receiptsRoot": "0x890a7fcaebc200470f3723bd29cac828f0db770ae9b1ef0e5bfec62424386fa1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000080000000002000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x91", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x5aa", "extraData": "0x", "baseFeePerGas": "0x8", - "blockHash": "0xb7332dcef7339e1aaf6fe2b41257738e00b916fbb030c919dafa065f36889886", + "blockHash": "0xdbdf9af38beb3fa29d94941294bca3788732dcd92eb6b4bf2dbb822000cbc0b2", "transactions": [ - "0x02f86a870c72dd9d5e883e81860109825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c080a090531038e16ae92f428682d1c2c7d7f318184674978738bab0b4981d95fd10b3a01e7d766f9c50ecd0b97fbe73e9256debb5113427989e5ea170f9d8dd62952e6b" + "0xf87481bd09830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9a8f0ecf08d4f674656d69748718e5bb3abd109fa0dccff08c49f955c959600fc7f3ab37b55d3e37b831cfd9782d555de3c0cbf7c6a045aff05f24374b0ab99facc7a467ad904e6d7beb38dafafb283a01cef49490a8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4595,21 +4650,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb7332dcef7339e1aaf6fe2b41257738e00b916fbb030c919dafa065f36889886", + "parentHash": "0xdbdf9af38beb3fa29d94941294bca3788732dcd92eb6b4bf2dbb822000cbc0b2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x943ea463107bb78f57c7c9b85983de8d4d60b6d134b20fecd0795eee98b5053a", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x554b96d56fd9ab9918903c71042e054f4f0171965371f12f0a9644b5516ab29d", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x92", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x5b4", "extraData": "0x", "baseFeePerGas": "0x8", - "blockHash": "0x03c384271631c83751232b695f032adf6fb4244c81cbebf3e6fdd030b61e384b", + "blockHash": "0x61355293082e8a9f906e7b52d9d7770877083021e6486ae90f63b2e4bccff11a", "transactions": [ - "0x01f869870c72dd9d5e883e81870982520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c001a0e9b2c7aa279c415491f684a96341e7f0423497e2709f335a338642e0ef35f01ba04438415c1afa592f8319c78f4b7b6c38da34495df036c9291d063b14d33b1997" + "0x02f86a870c72dd9d5e883e81be010982520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c001a0e7a2e65939bf5e7e1f9e4838d5a5b5a881a58609204a82900f113d8f6f416782a0509b43ba07b225240f188764f5b842cbe2f2d16fea536db1c4a81ab726af2f40" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4626,21 +4681,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x03c384271631c83751232b695f032adf6fb4244c81cbebf3e6fdd030b61e384b", + "parentHash": "0x61355293082e8a9f906e7b52d9d7770877083021e6486ae90f63b2e4bccff11a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x327d285af76733061aa1841998502862449c00ef7f48e95ab14bd3d27d96b3d6", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x3b251710415924109488349b79ef84225cab42d2ea65e17a834daa10943222cc", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x93", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x5be", "extraData": "0x", "baseFeePerGas": "0x8", - "blockHash": "0x5d72bae0b85bb59e94d55b7f439c6c0a9a1a8a47fa242f5dc64a82b880260cfe", + "blockHash": "0x0e1c46da0dfdbdd801d7b76c10462b10a1ff579e5f26535bcd3ab1c482043abc", "transactions": [ - "0xf8678188098252089414e46043e63d0e3cdcf2530519f4cfaf35058cb201808718e5bb3abd10a0a060af856a9de223c16e8b15052f3917b808c2e18c2f3053604b378fa1b4722761a07d65c79888d1e83e012b101aed962efcdce3d1f4feb0d63547137c2f822f3122" + "0x01f869870c72dd9d5e883e81bf098252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a0071828366e1b4aaa0a35f6bbed954f6571edf0d48a5ae9a5e02510e5f793e90aa06cd2f3366b7f32f225cd9043eb54bc4645e4889445825321ce0bed640a32984f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4657,28 +4712,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5d72bae0b85bb59e94d55b7f439c6c0a9a1a8a47fa242f5dc64a82b880260cfe", + "parentHash": "0x0e1c46da0dfdbdd801d7b76c10462b10a1ff579e5f26535bcd3ab1c482043abc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbde8a50be5930aa6dac2c84e5826117c2f051180a1f6029b8148245bd25c1f8d", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x36e31ca597eae4ce5f115afba7ef29c573998b57082d5fd539392981d438f2f8", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x94", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", - "timestamp": "0x5c8", - "extraData": "0x", - "baseFeePerGas": "0x8", - "blockHash": "0xb3a80dd6748adaba8d2598da58441cc645b165d96de91b605122e82caff076d8", - "transactions": [], - "withdrawals": [ - { - "index": "0xc", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", + "timestamp": "0x5c8", + "extraData": "0x", + "baseFeePerGas": "0x8", + "blockHash": "0x049cc427707b87414178123334cd9ccc891c192faddb16129b8d87dc945d4710", + "transactions": [ + "0xf86781c00982520894d803681e487e6ac18053afc5a6cd813c86ec3e4d01808718e5bb3abd10a0a00a6e0a8854d689d4bb96c8f7a1dc30e9be33e53c9bb42d9f63c9a849ffea0e9ba0531e3351e970d6eeb3fb92cb018ed6eb5c9b91cb096bd6a19016c8ab70fe1a2d" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -4693,23 +4743,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb3a80dd6748adaba8d2598da58441cc645b165d96de91b605122e82caff076d8", + "parentHash": "0x049cc427707b87414178123334cd9ccc891c192faddb16129b8d87dc945d4710", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdb57798d9239d49ad7beff96ac5d91cca083a8d83e6847a8f645d921b0445d7c", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xabf995ae299a44dbc09d702a5d9d98833a13995b651ae91448d5cc32fe2a0b28", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x95", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x5d2", "extraData": "0x", - "baseFeePerGas": "0x7", - "blockHash": "0x32305ca5493b007b7c591c7ea565ad705010ad747126202b191c78ffb49ea51e", - "transactions": [ - "0xf8828189088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a01c38a62689270d465f4bda87acb5d75a053abb6bbbf49e6fc7cd16208906fba5a06de900ab669c0bda07ae794da2fc54a615003fb80e57615fd5b9b0f586915f5f" + "baseFeePerGas": "0x8", + "blockHash": "0x24e92a19adbe76129e31fa0e7968f3f65f230ea20152fa92bd8553a90040f415", + "transactions": [], + "withdrawals": [ + { + "index": "0xc", + "validatorIndex": "0x5", + "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -4724,21 +4779,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x32305ca5493b007b7c591c7ea565ad705010ad747126202b191c78ffb49ea51e", + "parentHash": "0x24e92a19adbe76129e31fa0e7968f3f65f230ea20152fa92bd8553a90040f415", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x89e41795c7ad30582f1551e838f9801c8ef860a3306fb2d644e46d2cd92402e7", - "receiptsRoot": "0x17f90c244a9a77995c62ce193b5d9794f865c66a53604d9a9d1b78f3742b3634", - "logsBloom": "0x00000000000000000000000000000000008000000000000008000000000000000000000000000000000000008100000000000000000000000000400000000000800000000000000000000000000000000080000000000000000040000002040400440010000000000008000000000000010000000000000040000000000000000000000000000000000000000040000000000020000000000001000000004000000000000000000000000000080000000008000000000000840000000000000040000000008000000000000000000000080000000000000000002000000000040004000000000000000000000000000000000010000000000000100000000000", + "stateRoot": "0x7704b78c42f88db083513a5d15a6e9487c3050e366fe0f0d5639b02ddb781e74", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x96", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x5dc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x11b82f7fbb7a781b00b4eb695a56aacd1a5477a2bc4e8167d4c08b95c4186e4c", + "blockHash": "0x34e0ff9f154ad49785b9a2220d5dcdb476e3cae2c513209d0dc88bc65a3a327b", "transactions": [ - "0xf879818a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0fb6bc8abefcdf980e3381a9e578c4cf34833af1c70660974f233fe998c298865a020bf2bbe3972007569c1ae08084b52510f8814b4f769fa66d962aadbb9537776" + "0xf88281c1088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa037df2e80cd1cd376e703299e9bfbf3486f6187240c517fb4ba1d75c5c8014333a0395ac027c7717521d27ce4c7f0915d4247233858d81e0e5fb5f751a3cb8ad24a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4755,21 +4810,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x11b82f7fbb7a781b00b4eb695a56aacd1a5477a2bc4e8167d4c08b95c4186e4c", + "parentHash": "0x34e0ff9f154ad49785b9a2220d5dcdb476e3cae2c513209d0dc88bc65a3a327b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x49c3d821bbff9c9c40c6f7394732381dcbb37e24e9f3f74691f394705e3d2be6", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x524abb7336dd9295d1ec210102e6cc84a021ac036c8f6bd8f238cb0a52677545", + "receiptsRoot": "0xc388647b000f1383cbebb0ed7e92f352c545b9ebe2c6ac08f992463e6e09104a", + "logsBloom": "0x0010000000000000000000080000000002000000000000000000000000000000000000000000000008000000000000000000000000000000004000400000000000000000000000020000000000000000000000080000000000000000000100000a000000000000008000000000000000000000000000000000044000000000000010000003000000000080000400000000000000100000000000000840100000000000000000000000000000000000000000000000000000000000000000040000000000000000001000000000040020000010000000000000000000800000001000000000000000000000000000000000000000000004000000000002000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x97", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x5e6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7ad16d4c674b10a59ca3364904af33fa3713db2e963cf7c36da3f3172a917aaa", + "blockHash": "0xa038ce1b4343a5466e32f10fc868b23f7ced36538dd115cdfe0deac9f6f21402", "transactions": [ - "0xf864818b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa08e7741ea80652f87e939c0f591416f0f73151b81bcc63ae349f0c9bf56908a95a06ee9f7164b8ddce20836b87a826a5c526ffdfb40990a65a087ac7d87d364fceb" + "0xf87981c20883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0491326428cbf8f3791553c76c78b3a8ee32f6ed7ebc5e1a1885e8092bdbd716ca0103120ddf388ae2ceacdf2dc1134c0fb97a2d1eecaf65ad36fc01b2540962892" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4786,21 +4841,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7ad16d4c674b10a59ca3364904af33fa3713db2e963cf7c36da3f3172a917aaa", + "parentHash": "0xa038ce1b4343a5466e32f10fc868b23f7ced36538dd115cdfe0deac9f6f21402", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x37df5f0770949e923cb083680259e9e615f6bc1a603a2023a2abc463a88ef54c", - "receiptsRoot": "0xac2a853b1066ff5e9270a7a956abece9e2bd883772b78533d9df88a8b4a1f7b8", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xdf239bf5b245cdefcd327048fda5f415637641b66cd3a69c0372737205007160", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x98", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x5f0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe756ee647aad508c521e5463abc774c9ad8d3ac6f25a52c4b6970a04f716331d", + "blockHash": "0x4f6d29ecc1150caa2e43a7837fc7fc577bcda7cceb9de4da0c2e9da8baf8733f", "transactions": [ - "0x02f8d3870c72dd9d5e883e818c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6053ba2fde42abfb656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a072be914df22404e1ed45a8224b52201a77605d52065746a00af5f60980fa4c9980a0522b27fdb7acd48ea02e87e558d437f945b892fc546ca6bd82a043e0153b28b8a06cae65c67e0dd039ec3d58ea6f186c847da741c79ee2173f06659592a285c797" + "0xf86481c3088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0b332a6454e92c8d3936b40c1df2aef29a838c16e7177ce000e35e361066d269da07a7fc53b1aeb7c083a041165d13147c6d1deae8a21a4bf3f6d62768380848615" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4817,21 +4872,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe756ee647aad508c521e5463abc774c9ad8d3ac6f25a52c4b6970a04f716331d", + "parentHash": "0x4f6d29ecc1150caa2e43a7837fc7fc577bcda7cceb9de4da0c2e9da8baf8733f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9017dac7007df13ce16ccdf5385ba94ee95ab77dd4f1351b3caf925f6616166f", - "receiptsRoot": "0x8e9254ee48bb358e97f45c836031761c1a46f624715a4ba1b30c2d86bc19d704", + "stateRoot": "0xa25918ff31e91a4f99c166b9b3fa393f3453ab907d9b81459bb6844a5b12f1fa", + "receiptsRoot": "0x7fd0cf4cbbe369444e96b1f4d7533afabf16b63bb4f3eb844f027f2eebf96c2e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000009000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x99", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x5fa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1a924af515c53c392afb3be5839f952f6495116f677ba7cc630c76d08fa12e24", + "blockHash": "0xd34e3051d7184c6c18e3d51f0a693baf889da9ae98d6a5e777a22d2cb96697dd", "transactions": [ - "0x01f8d2870c72dd9d5e883e818d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca6e511cffb46c94d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b01a0715913aa6cf5380403ee348bd55e7c9a3dfc41f1b9a4e28a7955e310be9aaa9ea02fec01c6a963c199e0797a76be983eb17c1ec48c18fd2a17f9490337497f584b" + "0x02f8d3870c72dd9d5e883e81c40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca6e511cffb46c94d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b80a028339c4317b1a4fb76d48fa0cd6a29abc826a45b563b494c0ca1c5ffef33d3b2a007bb11604c0047ca9043ea07c26349fa14c720cefe216465b33ea084395dda63" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4848,29 +4903,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1a924af515c53c392afb3be5839f952f6495116f677ba7cc630c76d08fa12e24", + "parentHash": "0xd34e3051d7184c6c18e3d51f0a693baf889da9ae98d6a5e777a22d2cb96697dd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe438b4371e3f6c985c10f21afbe1df068e63ae81bed7214ebc6ab201ac562903", - "receiptsRoot": "0x4c32e94ddeb7664373b789e8223b53175959a2abdbd83227de34a34669f3b84a", + "stateRoot": "0xe65290d97963972989777bdfaa1152136a9e81ccc8faa979e0dbd534ee8bb2bf", + "receiptsRoot": "0x893f11f7f5a7b678432ebbac4a86a509d7656206a8810a15f466bf9acf9cfd1c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x604", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0de1dee56d87848e4730dd05feae6c512a356a38bd52304e1e399e8d48be718b", + "blockHash": "0xeb5370ab05f5d8f13e2cc9a45d11eccc1ee7537478e749105b03631c2504d6cf", "transactions": [ - "0x03f8f9870c72dd9d5e883e818e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c9ff25288d1780279656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a080987e3e15e1c0d42cfb26bb7680ac355d8dc6a1984ec21d99001393e2164d36a0787b1b461bd9e5a1924ca1cbdf05320add9bb8021bed65b80f07707b2aa6cf9f" + "0x01f8d2870c72dd9d5e883e81c508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9ff25288d1780279656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c280a03bf33993224c8a368bea3542fd6aa7858acf26e6d6502a566915ba2b9b6d1391a07571c2c9c8374a69dff4a253d7a3d55c3adab0009085d12902f9e89045712cae" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x9cb8a0d41ede6b951c29182422db215e22aedfa1a3549cd27b960a768f6ed522", [] ] @@ -4881,27 +4934,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0de1dee56d87848e4730dd05feae6c512a356a38bd52304e1e399e8d48be718b", + "parentHash": "0xeb5370ab05f5d8f13e2cc9a45d11eccc1ee7537478e749105b03631c2504d6cf", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce08dc560fbc13b5694bdc9f5e22f3708caed3ed03102074fcf4425a6c451018", - "receiptsRoot": "0x687695a315f4cdc3fcdd030f1478f03077e99bba681e7a2b1e9b2f4c616033a2", + "stateRoot": "0x412e0f4f3f6a04bf0be452ada7b442767cbc7c633343fb2d195a1c162a2cd2ff", + "receiptsRoot": "0x043045c702ca4ddfc2b93d7c6b0a72d3cac8b45d8266b9d59e9c4969fed62413", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000100000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000040000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9b", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x60e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xde590f5a6aa2882e34cb6894bf54e16296d5abeb244c7df2c0b12ec627c41432", + "blockHash": "0xe9419065bedd423519028a6f39e599358596a72614880942181ef4d3fbff8807", "transactions": [ - "0xf874818f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c67720111e9886ccf656d69748718e5bb3abd10a0a00c9e5d0c1e1d14bd227c8daf4d9d1a15293c6a488248dcf111ecf973274988f9a008ec61336a0c67d4cc8567abd645aaec105905d1f3638a195a1ad9d0d81eb250" + "0x03f8f9870c72dd9d5e883e81c60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c67720111e9886ccf656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0970a64830f255bfc38886621b37a7f1a7284bad6c4a04b6a2442ad212e19a6a283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a045f140f24c3576ee1c2e376e479443c1a6dbafc1dd95558b01b4763514c0d586a03c895c3bb8f1ff86db606969e2d453d89ef9b333c9711a6f9dc27d8909182fb4" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x2510f8256a020f4735e2be224e3bc3e8c14e56f7588315f069630fe24ce2fa26", [] ] @@ -4912,21 +4967,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xde590f5a6aa2882e34cb6894bf54e16296d5abeb244c7df2c0b12ec627c41432", + "parentHash": "0xe9419065bedd423519028a6f39e599358596a72614880942181ef4d3fbff8807", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x346aaa3da9697932f0716771cd128bc92e7ce3616e4fe38278a93cdc844e993e", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x24b0d883fc8c4f3b70cdb9d56f4ff5952ad845d9420b2bbc361992696b12ccf5", + "receiptsRoot": "0x9df0a67ac640d2a5e9b58437e352ea8fbea4cf8ef96aae000e4f818348399468", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000001000000000000000000000000000000000000000000000000000000000000000000000004000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x618", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcf5949ad3562b8f632d82c9af77116a0b83b9b9806e86d0c2bce517c7be2e842", + "blockHash": "0x076da0f0e01bfd4890f2134fd5df4b54a113439e488680ec9983b81de6178a43", "transactions": [ - "0x02f86a870c72dd9d5e883e81900108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a0732ede76830c2550b47c03a4df6dc6c1690ee0ebab6bc51c2f411a513be950bca0030ab88f2cde156cb8f2646f2f6c85ec20d8639c17fe58d708902c976e692519" + "0xf87481c708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c070947bf5fba1a40656d69748718e5bb3abd10a0a08a515c5e572e72c0c656a798234dd714bd747da87004cd95e61faff98c3800d1a06fc7eed86942feb5c6da3d0736c9cfd8c57115374bc5afdce9dfbe6f534c4853" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4943,21 +4998,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcf5949ad3562b8f632d82c9af77116a0b83b9b9806e86d0c2bce517c7be2e842", + "parentHash": "0x076da0f0e01bfd4890f2134fd5df4b54a113439e488680ec9983b81de6178a43", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x38c9484710c5444a193d3fc1448b8ed06532fa7073760da3393403ca34057c9f", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x43d829eb7c5b95629b2b2e9563c214eae8b0e7f523a43a0f993491911e70b48c", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x622", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb158abf8e49c9fa6cf8103699f81039a82d085721e5cff677edec8c43bee073d", + "blockHash": "0x1b765e0e7ef21700d430daf30c1fb898805cf27237768ae58dd82f68cd1cc26e", "transactions": [ - "0x01f869870c72dd9d5e883e81910882520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc0180c001a0d1bbed0389a5e060eee006d53bae7c7fd7c6890b17a4132712081a6b4cc5865ca021c33c5e1aeb65f26efcd10806ffa37f5703430185c700867bd46d0a782ed315" + "0x02f86a870c72dd9d5e883e81c8010882520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc0180c080a041c33f7a4851dd0ab1cf4b658c074d18a239d191c85bdab129679d9561e92927a0228a4a148ffac4dddd2fa3205b3a637bc23f4045cc87ddd19928e7e22c2b3f5f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -4974,21 +5029,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb158abf8e49c9fa6cf8103699f81039a82d085721e5cff677edec8c43bee073d", + "parentHash": "0x1b765e0e7ef21700d430daf30c1fb898805cf27237768ae58dd82f68cd1cc26e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe25e53409bfccf98112b91a7055943795d2113d83922d66880721a98d54cad66", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x206012e96ed4e84110d9be1ca09ea22c443baeb684467784475ce6be4bcba9f9", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x62c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4c5f50016d24ab6a9b40d925d7b4be07d51679d2f5b12565958dfa80229031fa", + "blockHash": "0x6dcc010b937b7e48545d5476b017e93f0baa2308ef3be862c1c6286911eb63c1", "transactions": [ - "0xf8678192088252089483c7e323d189f18725ac510004fdc2941f8c4a7801808718e5bb3abd10a0a06dac6d4bfed86b0059948afae52133c3e337647d78d1fa5936c9ae819e786645a01cb72ae9ae1feebdc94e332cb21e9180e56e8a604d94c8d100002f260a96cb2a" + "0x01f869870c72dd9d5e883e81c9088252089483c7e323d189f18725ac510004fdc2941f8c4a780180c080a08c1b326c11d9107cf8dcc4e98c2819457f420a6c3941a84ba9627e0686950fb8a03b8de73d7fff309ee86a65ce3066911038404582806e55504b384a106b9c7918" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5005,28 +5060,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4c5f50016d24ab6a9b40d925d7b4be07d51679d2f5b12565958dfa80229031fa", + "parentHash": "0x6dcc010b937b7e48545d5476b017e93f0baa2308ef3be862c1c6286911eb63c1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc65e57367ac6ff6635a710d5bc27bebe7f80d0021157eda2596ccb455f88f048", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xf3f5c238750592e8f53f407252bf506501f82dcfa7e794808a7120c689f65800", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x9f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x636", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdbbf71ab7420933453fd51ae3e6cdb95f05e1c25016e979fbe33deb794ea9ae2", - "transactions": [], - "withdrawals": [ - { - "index": "0xd", - "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", - "amount": "0x64" - } + "blockHash": "0x616a767f1417bf61770bdd4b9947a864fadcbda76a60ac901115b74f55948b81", + "transactions": [ + "0xf86781ca0882520894717f8aa2b982bee0e29f573d31df288663e1ce1601808718e5bb3abd109fa06b9105776265e2eb63e0bf0c4addb6783220e742b41ebe10a92bece1e6837312a05510defc6505b89b296ce8d40bd1195b1edf432bb763f4da034dc7ea1650e000" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -5041,23 +5091,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdbbf71ab7420933453fd51ae3e6cdb95f05e1c25016e979fbe33deb794ea9ae2", + "parentHash": "0x616a767f1417bf61770bdd4b9947a864fadcbda76a60ac901115b74f55948b81", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xea0aba9aaa2ae0cf32fec0e4b08a632e9b8d8887865acf1e68540e4f4a4afe84", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x55c977c17a92e1ae4d3e016af463ce8c5e60a1ad88c4ac6bf42cb2d7645a9f40", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa0", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x640", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe2e850cb3176df3accc03247b8e9cdb15261ac3021c4911839aad275fe2a42ef", - "transactions": [ - "0xf8828193088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a040f8d2fcd495c8f12942431ed7a6d5256b628943b9fa7a303335348cf89c8885a00313b5b242e626a8d8add5c6534c8bfd4a8e89216286c97b4bd5afa5c0029f47" + "blockHash": "0x90f962233f21820cbfb476d1e7b58191e31a745b143fe000a7fdbfb636295ff5", + "transactions": [], + "withdrawals": [ + { + "index": "0xd", + "validatorIndex": "0x5", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -5072,21 +5127,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe2e850cb3176df3accc03247b8e9cdb15261ac3021c4911839aad275fe2a42ef", + "parentHash": "0x90f962233f21820cbfb476d1e7b58191e31a745b143fe000a7fdbfb636295ff5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x134a16436f36855eedcee6544782decc1791b81080f1ed90a44b8b75eeb08605", - "receiptsRoot": "0x4cc54ac939400db6a2166180135b79d2c15a4bd2809d5bcebc29edcb76790555", - "logsBloom": "0x000000000080000000010000200000000000000080000000000000000000000000000000000040000000000400000000000000000000008000000000000002000000000000000000000000000004000800080000000000000000000000100000000200000000000000000000000000000000000008000000000000000000000000000000100000000000000000000000000000000000000400200000000000000000010000000000000001010080000400000100000000000000000000c0001020000000000000000000000000000000000000000001000000200000000000000000000100000000000000000000010000000040200000000000000000000000", + "stateRoot": "0x74a14c1e1011ae12f1fbb485a231299d813b54bc4d999f115a1f2324a01bd690", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa1", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x64a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5fd45fdf3f74bde3842258b46aec022feec7f5148302447a63b6e480d4444330", + "blockHash": "0x9c02e583208597dda2607d80ca5dced296b7245635677699871833053f4561b4", "transactions": [ - "0xf87981940883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa00fa1d4ec54187e3d7d841b1e6593ecaf79255268f6ff6de216214efde80089c7a06575a46743117ed35853698e47b367112b81b09d8cef718f35f4e811114cc260" + "0xf88281cb088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa03edf0d866ad40481335a06c4ed3935cb3bd382c3c3b3cb12fa24c8db6b34a4e8a0681998194756c6bad9dd89d8c29f6464bd0b8a8b6a7cf5465d429534ce853a41" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5103,21 +5158,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5fd45fdf3f74bde3842258b46aec022feec7f5148302447a63b6e480d4444330", + "parentHash": "0x9c02e583208597dda2607d80ca5dced296b7245635677699871833053f4561b4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb0c8f232687dbcac3ee4d9142855aeaa4623b0a201f5fb0dbc6206e76daec3a8", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5357e9126528d1c6f7fe3381bcfb3ab2a116e46c744976476130b98c83d4dd05", + "receiptsRoot": "0xd1b8ea751c030fc813bb08cdcd4dc5e76acac5cdcbfb46521d83603631b88032", + "logsBloom": "0x00000000000000000000000000004000000000000000000000000000000200000000008000000000000000000000000000000010000000000000000000000000000000000008000020000000000000208008000000000000000400000000000000000000000000000000000000801000000000000000000000200000000000000000000001000000000040000000012000000100000000000000000000000000092000000010000000000000000000000040000180000000000000000018000000080000000000000000000000000000000000000000000080000000000000000000000010000001040000040000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa2", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x654", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x639a8f45c9f9219f27cf4db4c33de2d346df8a09dcc770ac6044f60184330864", + "blockHash": "0xb298175a8ca6852255acb5a528906d85a5d33fbf66c70cb786877f4ca844a7b6", "transactions": [ - "0xf8648195088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0cd33c99152a08debe65994ef384af02421d2608bd849e3edf699f2a1e0e60b64a030dcdc834dd98a1f6f8ea6f840146af61439872287267af4e461ab8494c28dc1" + "0xf87981cc0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0c65d8f7eedad5fc65ae8507ca80feadcd774fee1dd73119d7d8ffa163cfcdb75a03ec2b4264045a0fdb87ec0a68c2713c2aa89cc88a53d6a0ba9369ba46c966b10" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5134,21 +5189,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x639a8f45c9f9219f27cf4db4c33de2d346df8a09dcc770ac6044f60184330864", + "parentHash": "0xb298175a8ca6852255acb5a528906d85a5d33fbf66c70cb786877f4ca844a7b6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdd32fc8571657d3464251558c486ff861307737b49054d272262dbe5fcbdd593", - "receiptsRoot": "0x9066b594cce8a9e20431c038c86c396aa3496faedf1d9e1e5ff05387c36ed966", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000002000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x565c09bc1c43c645ac8b18e100a92327c80e55d03f65b91482e37c23f89c95e6", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa3", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x65e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x45941317b4ff496cb5e8832d48f69c5f1d611cf609bf3d2933dba68dae211c49", + "blockHash": "0xcdb49313f08242666708fd58106cd77d39cac694d5109d6292d5205f0eab8cad", "transactions": [ - "0x02f8d3870c72dd9d5e883e81960108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c690ca2dda4d66fb3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ff5c526fc525d03cecce39f4ec167af09f80525e2d44e60ee4df33a357b24ed201a0c7f4fb8e478d0b3739b860f0368dbbca53502c2d71bca014ae9f8eea8262a3cba04efef6442d91a5470a0c8382d0804a6f1e1496722c12794354965577eb687605" + "0xf86481cd088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0954dc4438b20c59dc1409dfe59a25aa4cda9c7de4d0baa465739deabf3a06f7ea03f7e67426575e9d540c0ba89f52f7ced09e3d219d43a1058dea19e7bcdc11b09" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5165,21 +5220,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x45941317b4ff496cb5e8832d48f69c5f1d611cf609bf3d2933dba68dae211c49", + "parentHash": "0xcdb49313f08242666708fd58106cd77d39cac694d5109d6292d5205f0eab8cad", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5553e1692be29a202dee1fd0a0faccc7277830f2c548d8ed47f7b893c563dcb2", - "receiptsRoot": "0x38a18fba7aa21f6f6ceb46a7528f7d9c29d6b4df3481cb302f43b2f2b5084d8b", + "stateRoot": "0x9e7780c154ed61b4eaae15d585766b657905382c8f13309fb018009f36303e20", + "receiptsRoot": "0xecb72b4d3789c1737a69c8aad641dd7e92aab30d4349c2ac74833432580cebe2", "logsBloom": "0x04000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa4", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x668", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x471066471af127a34b62c9f34c3fbfb26ba29d233f81d568f4d120d35d50ceaa", + "blockHash": "0x141eb84f21835812981ca866915b141c199b2a6e574624de1a35b28784d70e31", "transactions": [ - "0x01f8d2870c72dd9d5e883e819708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3ca23be55f2c8073656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a085ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da9780a02c872933387857b9fec1927c3c165793e90839365712494d58200e9de8b2f857a049ec239515f6ed48ce0fa7a523131fded9c6c580edc6df2a3b7f76544b617cc4" + "0x02f8d3870c72dd9d5e883e81ce0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3ca23be55f2c8073656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a085ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da9701a00434ec4941775675dbf9e46da286c975bde49d6eb7b45a4863799a3c0edf827ea06f6548537b6a064b7cabe0a5ecb83f732473423b430202fc98382a22ed98b62d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5196,29 +5251,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x471066471af127a34b62c9f34c3fbfb26ba29d233f81d568f4d120d35d50ceaa", + "parentHash": "0x141eb84f21835812981ca866915b141c199b2a6e574624de1a35b28784d70e31", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc5a4ddf07d3a195d208631b627fa15b7b25e9ab983a75f5b037195df8a509ec9", - "receiptsRoot": "0x5eff3beb82c599d5d1f903ed5c7e366d0d784353dbc0e531e781fa82ca4f8cc5", + "stateRoot": "0x4575650570f9869fbefb9cff07c26aac03b2523aaa6edbe932a0d1b83b96ecae", + "receiptsRoot": "0x9aba37ad1750da383eb0dadcff269b5cca7ae0e6aa7678f6ae229f103200d344", "logsBloom": "0x00000000000000000000000000008000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa5", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x672", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe89e5d3756805d8458b5057f19b7d97faa7fa2351b2a08ddd75405c00af3a8c6", + "blockHash": "0xee6b0ee8c674e6c358ad14a9dc39c9ade98b944a4c3c97992bb882f536e976d5", "transactions": [ - "0x03f8f9870c72dd9d5e883e81980108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cc6f00ba448f8e0bc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf5383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a04848c847e1db33fa57a37324f5ea2bc8c0d73c1b5e8bb55277ed9abd8c1935cba05f7b4fbf6d345db1d94535937a709d81e9965d747b2c70195c6c5c32881dc0ab" + "0x01f8d2870c72dd9d5e883e81cf08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc6f00ba448f8e0bc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf5301a09cecaf27b88dd3958b7a344a56a8d5ab2a838c70ea04c9b1fc5b301c9a5d7c51a002f992c07a70217ec6833ffc04e0464dc87ed889970b554f407f2666dbf6ff01" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x9b72096b8b672ac6ff5362c56f5d06446d1693c5d2daa94a30755aa636320e78", [] ] @@ -5229,27 +5282,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe89e5d3756805d8458b5057f19b7d97faa7fa2351b2a08ddd75405c00af3a8c6", + "parentHash": "0xee6b0ee8c674e6c358ad14a9dc39c9ade98b944a4c3c97992bb882f536e976d5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x82f560474af8d995c875164f8e5ccc4a4c3c775f28cfc1dc00fd4edaea33eb62", - "receiptsRoot": "0xa876268e414ed930180e4e8f99b97830f96c76546b212484b43f4a722a275053", + "stateRoot": "0xecda93701462231bcc24eb6dce6a0f175dc693b4832ba2545813a34543b22b99", + "receiptsRoot": "0x2ba6641c3305aa448eb231382ae874e1eea4d19ebfebff99d00bea6fddf8b779", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000080000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000001000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa6", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x67c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8052bf3205c8803a64bb4cc52c4e86516db9734d9bf0ff47349a337e9bbe10e0", + "blockHash": "0x56a342018c122b38dda95d4590e3be13521d9b293a469b089eec358c040cca09", "transactions": [ - "0xf874819908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2989ce0858ff5f25656d69748718e5bb3abd109fa06ed33391e8205c7a247b82ab2cb6c28ff92e6fab9130115cc6d5538918433677a05fb41e0f3d9636d598ae9e4d4627cf27d782e5b412cdf7718020426523191e05" + "0x03f8f9870c72dd9d5e883e81d00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c2989ce0858ff5f25656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0611f5b5e5ee263412fed40f169d0727f4e6e1a2bc94caf668d2bcf22cddca8c183020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0dcbbe04e77e572bde0be21e68a274bcb735a417b8876907de9c1f0a80e3d0284a01b9d3fa5c553b96642afb915a531249d1999c562dacdb0b5e06c32e687901229" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xf68bff777db51db5f29afc4afe38bd1bf5cdec29caa0dc52535b529e6d99b742", [] ] @@ -5260,21 +5315,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8052bf3205c8803a64bb4cc52c4e86516db9734d9bf0ff47349a337e9bbe10e0", + "parentHash": "0x56a342018c122b38dda95d4590e3be13521d9b293a469b089eec358c040cca09", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x85d3721cd9e6fbf5dd19125a46b3bfdd52c5400508ca9dd504118719ca09f4a4", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x330a3944149ed44fe47b3ca2b2a1618b112f5d346d38bb9d666489ae4908a595", + "receiptsRoot": "0xea12e1bcc7a5684187716a9436c960415cfd557c403bdbdda332da3158d1cfa3", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000004000000000000000000000000000000000004000000000000200000000002000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa7", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x686", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdcf632311be8dfd6de736c05b4ae66e2aea72f7825fb23294bb8ccfeb218f486", + "blockHash": "0xe08d69283e46660cc7d2ec2297498bea4fc2d9e6be5a966fc62d8cc0bf79eb8c", "transactions": [ - "0x02f86a870c72dd9d5e883e819a01088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a03f7964062354cfc08584c3f5788a33d09e1d64681ce283f5582f11f55ceff565a07eeefc310b165a51dc3a0fd06f07f835e9c2ade6781709504a0b2523cca73546" + "0xf87481d108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028caca9e87acc060271656d69748718e5bb3abd109fa05349613da922d5ce5ebe0ed5d3bd6969f0ff6f054bbecf4cf7a5a205bacc01b7a06a1439f870fd4766fd74b6a6af2f70d564578c72b0020f3668e16b1184564089" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5291,21 +5346,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdcf632311be8dfd6de736c05b4ae66e2aea72f7825fb23294bb8ccfeb218f486", + "parentHash": "0xe08d69283e46660cc7d2ec2297498bea4fc2d9e6be5a966fc62d8cc0bf79eb8c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbcbeeb50071dd1d8c9390988cfc6aedd2a137cded25825e554269057bf0a2339", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x7016b5f282139f399516d247a38e39ad6228bae9e255751d76f31be99ac34005", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa8", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x690", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf4d88732713252e8ab1932ca55135b3819ef47a73a05002a338e5aa5617e7d9d", + "blockHash": "0x06cfd65e4ad3f00b853db8c0218f003e65ecdfa83b2cf36be05da03c9abd2b8d", "transactions": [ - "0x01f869870c72dd9d5e883e819b08825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a0f9075df943f26e91ecd0f87e2d5cba53345aaaeea86a9ae71f571f3f9446e8c5a0648499cecaa5f66e84d6fdef0ad70eb732edfbe27e7d8f0aa0ad36dcf1a1f013" + "0x02f86a870c72dd9d5e883e81d20108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c001a0dae685ec946642a5c0e2759c376aed664fe7d5bddf439a8e1403e2d632ac90fba04112033fdc1ba221062dcaeb14c4a63b1cb46b7d8c04003d1872d00ce7d40cf3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5322,21 +5377,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf4d88732713252e8ab1932ca55135b3819ef47a73a05002a338e5aa5617e7d9d", + "parentHash": "0x06cfd65e4ad3f00b853db8c0218f003e65ecdfa83b2cf36be05da03c9abd2b8d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xcd074008f02ff8e77540321cd30af0917f5519990a3fa89750911df721222d97", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x7277b9a176ad81cedd383da3e909ba6044c96e228b04855b660605bf2d589131", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xa9", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x69a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5f5f3976768eaf850e525d41f05497af4731aa637d2b323dbc69154553943c50", + "blockHash": "0x1eaa31322ebe3166d05d4aaecc37da61443ec14bb10abea11a0de6271ceaac31", "transactions": [ - "0xf867819c08825208941f5bde34b4afc686f136c7a3cb6ec376f735775901808718e5bb3abd10a0a0ca6eeaf7f7ddbb82c0374b0eee910d70ca9469397d5bb0b597666c38fca8f7b6a01b4a657dc2c418102526186ddc7c9cbcef74881083391ed51d9dad587db1d4a4" + "0x01f869870c72dd9d5e883e81d308825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a02853d9147f6a2d7fc288c912a1047c24e8761a94b64f11a9bffc8698cfc8cf72a0566df35b5cc2c5a6a90d55970dc391ff6414fa840cf072faaf39abb9920ed36d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5353,28 +5408,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5f5f3976768eaf850e525d41f05497af4731aa637d2b323dbc69154553943c50", + "parentHash": "0x1eaa31322ebe3166d05d4aaecc37da61443ec14bb10abea11a0de6271ceaac31", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2e6fa7f5528da8a715dd74c4b756d34e23732ecd2627b9d4663c2d2592d22fe8", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x273628b39c876725fb027c45fd15fa66ec51778ba185bf9f69a10740e95a4b97", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xaa", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x6a4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc1a9ccd5f651aa46a26433e521d6e7c4fcc6714f8fb9068ee4f1e0a8d043da0d", - "transactions": [], - "withdrawals": [ - { - "index": "0xe", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0x861e741db3d23647d8a9fc61ee8361b044ab5f6472a15e33e1347d26802ae652", + "transactions": [ + "0xf86781d408825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd10a0a0a2c21da04e89413afc7bed90ed49d4f9bdb55e7c5e9d67e96a9ed52883eb36efa023b562940e61aaf3eea56e019e2cd44d02e38f367762d1974d3cf87e9d45bbc2" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -5389,23 +5439,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc1a9ccd5f651aa46a26433e521d6e7c4fcc6714f8fb9068ee4f1e0a8d043da0d", + "parentHash": "0x861e741db3d23647d8a9fc61ee8361b044ab5f6472a15e33e1347d26802ae652", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc8dec30c9a01e3cb25857fea4c9fec2588e9a88c04964ec88446def8b92c1dd1", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xe11eb32a68511b9e3d3ab1af9e0dbbd31a734752d8d01d3178d1288ada023c0a", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xab", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x6ae", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9fb16206a35f8b4b9d8c30570c7010b5bc6a4149b5aa2ce42da9d60c92b5ea1d", - "transactions": [ - "0xf882819d088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0e745f6682c5edbc361349ac85db663d445e657534cab54042b4e7a929c71b3dfa01da4ada16183397c613a392e286749ce543cb828887825535209225ba2cbce1b" + "blockHash": "0x2cf03f61b899f9e1da26b010eec455dd52486700e03c7ac6dd5aef77e1d0ce4a", + "transactions": [], + "withdrawals": [ + { + "index": "0xe", + "validatorIndex": "0x5", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -5420,21 +5475,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9fb16206a35f8b4b9d8c30570c7010b5bc6a4149b5aa2ce42da9d60c92b5ea1d", + "parentHash": "0x2cf03f61b899f9e1da26b010eec455dd52486700e03c7ac6dd5aef77e1d0ce4a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4367db6c6b954c306e2e3d3a3cb846b43cf3a484741c8fd6d0a49099dcb68c32", - "receiptsRoot": "0x1dfa260a60333675b1de018c45c25c44470a3f3159a99821318421f2c1f4e58a", - "logsBloom": "0x00000400000000000002000000000000000000010000000000000000400020002000400000000000000000200000000000204000000000000000000000400000000000000000000000000008400000000000000000000008080000000000002040000000000000000008000040000000000000000000000000000000000000000000001000000000000044000000000000000000000000000000008000000080000000000000000002008000001000000000000000000000000000000000000000000000000000000000840000000000000000004000000000000000000000000000000000000000000040000041000000000000000000000000000000000000", + "stateRoot": "0x2ac9068ae7984536b6cba66a193cf4cb5097df3347dcdf2c4f96aa73add0e7d1", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xac", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x6b8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4d980e42bd8ab35744bf9b5aa58fbc8b71efd85b839b90e2e50584246a3831f8", + "blockHash": "0x63c823f9caa95abdf5aaeaea7d33753359ccd4b76e64155a760bf3355edcc73c", "transactions": [ - "0xf879819e0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a05431136f2ece8ba6297f27c127413c8f219ba3be455c05b1a07e064b1de4e36ca01ca3eb0aa10c2cf4de708b21daf94ea3cc4a14e47b42f50ccef6f288b300dfe2" + "0xf88281d5088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0a4f76822624e38a1098a5068f6f67a121977d29dd56f9e166058381da8d01c53a0742ea9a61fdf179b566429a182e367ec8473848e40660a9e2445744d81b41094" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5451,21 +5506,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4d980e42bd8ab35744bf9b5aa58fbc8b71efd85b839b90e2e50584246a3831f8", + "parentHash": "0x63c823f9caa95abdf5aaeaea7d33753359ccd4b76e64155a760bf3355edcc73c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x001a7058a39d22062714eccf3366ff07d3406f5d5c1cc173a5c9fc2d0b2cfef8", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xabc665a965c4293132e3673c8075a7918772341f9165c93b079a745ebaed0256", + "receiptsRoot": "0xc78cbe275dbb91288da2eba36a5b552aa1833bff451f2bdaeaa349efd865a3d3", + "logsBloom": "0x00000100000000004000000004000000100000000000000000000000000000000000000004000000018004000000000000000000000000000002000000000000000020002000400000002000020000000100000000000000000080010000400000200000000200000000000000000000000000000000010000002000000000000000000000000004000100000000000000000000000000000000000000004000000000000000000000080000004000000000000000000000001000000000000100000800040000000000000000000000000000000000000000000000000000000000000000400000000000004000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xad", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x6c2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc9f402d074ac593ae2f09a8bb846b9e46963c305a8c33690c08ca0c8e0ac719f", + "blockHash": "0x8db5431f9466088e255da8a3ba2c8687e71836d5d1945b13c7f3d9ac7c89632b", "transactions": [ - "0xf864819f088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0705afe706be82a4c7f9a5964e09c9e265b285e4382028136ec8af1e7fb0c7aa2a03f927fc55ed798c4cfb0ef7beb90c044b5325a7b61c45a16504dcc5ddf712d3f" + "0xf87981d60883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0b369556d11c62983b278d0d4fe00f1409f86b5b783428e41a0c01f6d6fcdb40fa008bc2b849bbd2a50c5a6fcd542b20d9f0eeee0456905db1815d5bcd9e3ca47f4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5482,21 +5537,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc9f402d074ac593ae2f09a8bb846b9e46963c305a8c33690c08ca0c8e0ac719f", + "parentHash": "0x8db5431f9466088e255da8a3ba2c8687e71836d5d1945b13c7f3d9ac7c89632b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x564d65ae8bc86bf22cb161dc6c91a654b73d6d2c221f7048b77fc31b6aa08ed5", - "receiptsRoot": "0xb8137d0711f48435401dd4cab75c13b44ad3e5241d683b34e44073ebaf1c1193", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000400000200000000000000000000000000002000000000000000000000000000000800000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6df2168a34cdc84a5a95ca4e9fe06f424de8fc9fe15b265ca63cec1b91367473", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xae", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x6cc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7c6e0e3b4dfc0728d41f7d5729a60d53758cafbab878bca3beed01bdc5ae9c56", + "blockHash": "0x0233de4a61a9a43ed4501eedc83ae61cc6b2f31f7681bb1de10650f724635917", "transactions": [ - "0x02f8d3870c72dd9d5e883e81a00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4a593ce54c67c2ac656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a087fc0239418406958902bcd8e059f9ddc08fb2683a4be0cfd47b1eb97418be1e01a00ed05cf53044f80bc23a49fd3dc69816901a3ff92e1f24bc7fd1fc5cfb87396ca057644e118120719799ba3ebd9b1aa684eb57c6dc92119684adbf26dbd4fdadbc" + "0xf86481d7088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0648e900cc276bee3ab846c737125fbbfca11f5629571b450fb288db3af6bc317a00dd7a954f8127971ee7cbb1e9de7a915bc2572e038713a108be58abc7f476e9e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5513,21 +5568,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7c6e0e3b4dfc0728d41f7d5729a60d53758cafbab878bca3beed01bdc5ae9c56", + "parentHash": "0x0233de4a61a9a43ed4501eedc83ae61cc6b2f31f7681bb1de10650f724635917", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x232b2e0f21a64714fbe5752dae331bf86b0d26ffc92322b62504607a474b224c", - "receiptsRoot": "0xf5d1435054aadeb055c81d3f19a4e56814ce25c8f3a64a413d39681990c927a2", + "stateRoot": "0xf889bbcdd463f48171e33c543817751582a109051c92139e479bc718eeca99c6", + "receiptsRoot": "0x5866cd46efc1eafd675e446d2d1d2978c98c92f320876f60f5cf43c191278df7", "logsBloom": "0x00000000000000000000000000000000000000000000000000000004800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xaf", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x6d6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x36daac85c3d71809d96b04586cf5c50594ae2cafa74b9734491f6fb31b85142c", + "blockHash": "0x899b58ec03cb142e0b55e1fe0ef6c351291a27b9074344bc7e2cafa96373aef6", "transactions": [ - "0x01f8d2870c72dd9d5e883e81a108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c963a3b3b836863cc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a073b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b2801a0ef1453210d03f1651ebad4cfcf238686c7c450a8a2488d0f442db7ea291923caa0798c152e68943ea3a4326bb6c39a8e9956c7d87e5391ecbe6de1f839ae11afad" + "0x02f8d3870c72dd9d5e883e81d80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c963a3b3b836863cc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a073b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b2801a0011cfdd064c9e26b7e3138ab8645a76613b43cfa62982b70ba5e854594927e1ba03c7d9afcfae4fe514ae67a15a57ce6e7bdf32ef4dbc0106bcddf30d3310125ac" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5544,29 +5599,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x36daac85c3d71809d96b04586cf5c50594ae2cafa74b9734491f6fb31b85142c", + "parentHash": "0x899b58ec03cb142e0b55e1fe0ef6c351291a27b9074344bc7e2cafa96373aef6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe868a681d8537e3e322ab2e64f5b6735416f171863eb9343ae96f8f8d51356ef", - "receiptsRoot": "0x04403e16895c094448badf3e31688d759f0993ccf9d9b2cc1fc84d82800f2cec", + "stateRoot": "0x853abd8efed4d27ea5e08885d43378676c813de46a4d761f3bb3ffc0ae60c9ba", + "receiptsRoot": "0xfcff7b43bca1a879ee00b1cde33af7491d6ffbd5f02de3552de7d18866184f76", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000040002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000010000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb0", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x6e0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xedd306e502f0e098d70102017c0f33272d5934bbf766ef1c5ece71713d4f59c2", + "blockHash": "0x13f99454d41f5ac10fd52abd046cde67bb8c0bf7d6010c6b17c465ecbb3ed540", "transactions": [ - "0x03f8f9870c72dd9d5e883e81a20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c2502e1f0dd547127656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0bdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0e41316ae994091bbaf7e2e97d273ce1a16381c60af07c363bee1aea6c89c83f3a04c1879555adec4de34049425b52f6d4e547ac57a1deda752cf0aea86d599b638" + "0x01f8d2870c72dd9d5e883e81d908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2502e1f0dd547127656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0bdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e80a066e575cfc23073b657fc9251aecfeb587f2906d1c5b1381299d908522a6b38c6a054d7c2b1b04312aa07c71c338095b4993a003d277faa621e0003d7cb81e61b1f" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x6f22ae25f70f4b03a2a2b17f370ace1f2b15d17fc7c2457824348a8f2a1eff9f", [] ] @@ -5577,27 +5630,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xedd306e502f0e098d70102017c0f33272d5934bbf766ef1c5ece71713d4f59c2", + "parentHash": "0x13f99454d41f5ac10fd52abd046cde67bb8c0bf7d6010c6b17c465ecbb3ed540", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd58cceebab8ff9038ced6500866b8edffabd41017ff99914350deed71f660bc8", - "receiptsRoot": "0x2af5beed5b567fac7c47bd8e37184bbc6f8ad91cffc3e43116f17c16ea798b81", + "stateRoot": "0xd6e6896cfa33fe72f4f9d47f67f78fbb1957fbc4cd70f2389f0c25f7375e03c6", + "receiptsRoot": "0x5a0501a7d3c464a4d381c2295800026c7729d8b2656bb16c1300af53cce6a87b", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000002000000000000000000000000000000000000040000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb1", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x6ea", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1fdd1686c4e06bf2baf2287347ed95a45855aa4b546244e83e7aea4c6dd56a72", + "blockHash": "0x9a2024c4823f8c503a053ffba21d3d5b8aa44bd69e0e326a3dd861d5ebacbbc5", "transactions": [ - "0xf87481a308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c72faa693d5bb5456656d69748718e5bb3abd10a0a0f23547199e74f2ba75c5dff20d614778a8826e0da6574b86b8e6cec15bdd7786a02461f37d47a7d68db841e7b2d3ec9e999a04fb55ecfda0b3213c451a3418199f" + "0x03f8f9870c72dd9d5e883e81da0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c72faa693d5bb5456656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04632fe8e9579f33e2e42e68811d49a09ad1af1f01a68e7ae742f765e8e797ff883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a079ebe352f2b61d78c3276a2a94cb7198cadb8e627b35ed127031eba7e98c1bb5a02e2d14e03df516fb1127811012d0584bcc1d13db4fb633ed7d09b6732ea92ebd" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xf11fdf2cb985ce7472dc7c6b422c3a8bf2dfbbc6b86b15a1fa62cf9ebae8f6cf", [] ] @@ -5608,21 +5663,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1fdd1686c4e06bf2baf2287347ed95a45855aa4b546244e83e7aea4c6dd56a72", + "parentHash": "0x9a2024c4823f8c503a053ffba21d3d5b8aa44bd69e0e326a3dd861d5ebacbbc5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7159f8b467ffa4666bb640be0fbac17072bba7a084d2591c7123ad506e71d455", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x531e33f5d41f49c6c731302d2fd370ac59953a63cb342c0cc82ac2def7af9635", + "receiptsRoot": "0x8d5ad869d06b7f76a71ff0573f5bc66eee7262abdca743edde6b98b2378236d3", + "logsBloom": "0x00000004000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb2", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x6f4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa69441f08a1bef357d6f34fb74e4eeeaff0feb787f61e10879faf72609aeae24", + "blockHash": "0x97fc752f97b39827ba60179602671d30c1f05bf991650cac51f0346ee24d733d", "transactions": [ - "0x02f86a870c72dd9d5e883e81a40108825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a021303b463c6aafaeebeba14b0276f77308dfb02aee5d8cf8d18c7a6b0f8f5f20a017d70f0dfcc668f51b412ecdb441eabaa92c3a05f649e027922a37a858e6be1e" + "0xf87481db08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3f1234d9a783e10a656d69748718e5bb3abd10a0a0b875a96cc7b43a73edd962e8bbfa4263f6034d1ce25cba2284e2bedd957be720a0639b5e0868048f5d2a42030ecacd89d86a4c271c0db1db9e9a447c03251face0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5639,21 +5694,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa69441f08a1bef357d6f34fb74e4eeeaff0feb787f61e10879faf72609aeae24", + "parentHash": "0x97fc752f97b39827ba60179602671d30c1f05bf991650cac51f0346ee24d733d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xad7daddd8ac491c23cb54f9805b98cfa1ec0455bf333a1c5cbb0f69f7dd69cfe", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x350e249b7dc570b0e2f3186029b5c9951a18da70c4292b58e5cecb224fbea9fa", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb3", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x6fe", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc37e2ca4253945c00e611fd26819875ef83d98dc20bb326a8e4ebbd804613214", + "blockHash": "0x30a494978e0eac0abda5140961431834ace71b6251f4c533c823913efd652aff", "transactions": [ - "0x01f869870c72dd9d5e883e81a508825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a027058d63f06541a9d1096de84b552d3ed9d9c3a1f9fffb5ec09eb534572d4d63a0725d37562a61ee9f0c8f67350f939ff0149289340fb21b0fd6eee4cdfb3675d4" + "0x02f86a870c72dd9d5e883e81dc0108825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a00fedcabee43c250b1ed3963893a0936866044f218dc3b7f06d4dc2d714ff3cefa020acb4fd5af94d1f7b2eff92382a6e6e43c56d02aeef41d22042d892e6078176" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5670,21 +5725,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc37e2ca4253945c00e611fd26819875ef83d98dc20bb326a8e4ebbd804613214", + "parentHash": "0x30a494978e0eac0abda5140961431834ace71b6251f4c533c823913efd652aff", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x055e26ef6ae3fa56e6e9d7a0c149e4d5a4cba9e6cc3dcf761f4b57fb545dc1f8", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x2bcd8e5c3bffa0866dde2054e9aee882c7a625e53f5b58d072cf77ee0ff49d6a", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb4", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x708", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8564835e8d24f3fd01643847625fac3fa7bb13ba829c1a5ad7efd6ceda4f5bed", + "blockHash": "0x6b5d54fd2861b26dd7f2851d7e5370a10006dda6c3030e6d3ec4165516e939a9", "transactions": [ - "0xf86781a608825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df01808718e5bb3abd109fa06bb8cef12c0ac6f6490be490baea684d8ee3fb5a4adda03e890f9fc1f81bf48ca06bbe16d08e1776119189560e89057ba6d8af45c383c2ec23c1b74fdaa7395102" + "0x01f869870c72dd9d5e883e81dd08825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a04f6a301ae2761c56643aaf7514c0caeffe709da0547ecd30cb55463dbf15a417a05fb1e6589cb27f52e2ac658cb70feedc90d1ff9a81032d4b77fe0ab16eb39f25" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5701,28 +5756,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8564835e8d24f3fd01643847625fac3fa7bb13ba829c1a5ad7efd6ceda4f5bed", + "parentHash": "0x6b5d54fd2861b26dd7f2851d7e5370a10006dda6c3030e6d3ec4165516e939a9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd203aca206010f7376fa398f9973cd163e7edb2e666af495953f132f0abd8a35", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xe0ae6430ec981d5e1c3832c665913aa0fc2f101e9dab4e5f354e90e481901e98", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb5", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x712", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc64398436144bb3196587e5ee9267e878400c5616f97cf97fd0921bae181bad4", - "transactions": [], - "withdrawals": [ - { - "index": "0xf", - "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", - "amount": "0x64" - } + "blockHash": "0x4b463a47e277fe903ef73f2504075e63194e03017c299bb340ca82383bc93110", + "transactions": [ + "0xf86781de08825208942d389075be5be9f2246ad654ce152cf05990b20901808718e5bb3abd109fa0de1ebf0a5b83d01e0d1b9b25fea505af5ee5b2fb8f6a563c34a99f813ac3c7c2a0326b01a462426e82549b61283e59a12451b2416be9017fb0c710764106015ae4" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -5737,23 +5787,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc64398436144bb3196587e5ee9267e878400c5616f97cf97fd0921bae181bad4", + "parentHash": "0x4b463a47e277fe903ef73f2504075e63194e03017c299bb340ca82383bc93110", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbe2a810abab83cd951177184055b77b27c030508188678587cbe8132de994797", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x035c2aa50a246db44bb0dd50d4788b886b79708af7368191f55e12b56f707bfb", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb6", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x71c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x12d4a656b5b4d8d9c55515a7698a254fa74a397390a57167f785a2d3602539a6", - "transactions": [ - "0xf88281a7088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0c5bb4c7666740a63b896f57906ea516686a3f0e3501001e8d1aa27ea158717f1a064ae416a38b4a7a973b0d0ed713577647767e09f12968f8b7dd7bcf2f1f014e3" + "blockHash": "0x26fb93f17f20d3912165be93e6c74e30ce01bbd23b1050dc2b0e990810ad8ebe", + "transactions": [], + "withdrawals": [ + { + "index": "0xf", + "validatorIndex": "0x5", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -5768,21 +5823,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x12d4a656b5b4d8d9c55515a7698a254fa74a397390a57167f785a2d3602539a6", + "parentHash": "0x26fb93f17f20d3912165be93e6c74e30ce01bbd23b1050dc2b0e990810ad8ebe", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6329ac409b68501594692643f9c388498a7de1c41ad6789fd1af4b37aceff22a", - "receiptsRoot": "0x98b6f0626985aa0ccf4936d47825312e988b42eaadf98e729290b3bc943f88fe", - "logsBloom": "0x00000080000000000000000000000000000000000000004000000000000010000000000000000000000000000000014000800000000000000000102000000000080000000000020000000000200000000000000000100000000000200000002000000000000000000000002000000000000000000000000000000000000000000000002000000020040000000000000200000000000000000000000000000000000000002000000000000000000040100000000000022000000000000000000000000000000004000000080000000000080000000000000004004000000000040002000040000000000000000000000000000000000000000000000000100000", + "stateRoot": "0x07f2da0c4c14403434a2154536785f6a3b2fb4d3211063ffd119a61459926da3", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb7", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x726", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc858dea4bf702c29161d33ba7c02bfb4977169668843521b0df693d5eebcf5a3", + "blockHash": "0xe08e97c0e494b917d5103858981ef94e7c83ae607274785cfa6e1d58fbeb5ac7", "transactions": [ - "0xf87981a80883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa04a9bf10e11abbcc9a33e6d7d71b5593164b7c112aaac0ae2ae7eeed4c7442c04a065d51bda999af8cfece3c43c6f48d89fac8a82a2d2f576204a9d32991cf16b13" + "0xf88281df088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a07a2594e4484e7401726b6d3d098d01ecbd35e6b17644e589b97bcba3b2c77459a07f08177d12d8069b57c85212658a3492818d0b2062923c1644b83e0ac6b2a379" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5799,21 +5854,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc858dea4bf702c29161d33ba7c02bfb4977169668843521b0df693d5eebcf5a3", + "parentHash": "0xe08e97c0e494b917d5103858981ef94e7c83ae607274785cfa6e1d58fbeb5ac7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4e962e27aad16223647ac79606e777971b1debc744616ab3a2d40872adf77287", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1fc1787348b8a8a51bc390b7240425a40582cdb9f7db29d2526736160f6767b3", + "receiptsRoot": "0x4486addaa38db9aebd1fe1c6c8b70d213fdb181cfc9962b444b3c8b4c8503e74", + "logsBloom": "0x00200000100000001000100000000000000010000000020000000000000000000000000000000000000000000000400000000000000000000400004000000200100000001000000008000000000000000000000000000000000000100000000000000000200000000000020000000000000000000020000000000000000000000000000000000000000000000000000000020000000000000000002000000020000000000000000000000020000000000000000000000020000200000000000000000200000000000200005000000000000020000800000000000400040000000000020000004000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb8", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x730", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x347ad864a477308c79cb4f766e8a6b62f4ece0a981cdfe49987e542acd89b5ac", + "blockHash": "0xde6bf1db842cb83446e36edc46014d23163fd84aebd1c03939eb0bd290767afd", "transactions": [ - "0xf86481a9088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a046152e7f3fede1276e473bb9aafaa72e9cfa60447b0f30bc961ddf840fa45b1da068a9cbc1ffee81b72b52d9c1bb698240d7bf0f1a5673d108c3de46614306afaf" + "0xf87981e00883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a01a23a49d397fc0ab58da7ef83b06ef187ebdd01e8f76022b0e729ca6cbbfda53a052b822f9bbef37785b4a10956aebfb2ffc1104356a85f8cc66f13e79af3e8abf" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5830,21 +5885,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x347ad864a477308c79cb4f766e8a6b62f4ece0a981cdfe49987e542acd89b5ac", + "parentHash": "0xde6bf1db842cb83446e36edc46014d23163fd84aebd1c03939eb0bd290767afd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2790bbb5ba41428ab0b184406e5725bf4d5fbbb603d8a15325eb1b847b4346d9", - "receiptsRoot": "0xeebb7dba7001e7060c6d18cc19e463b790ceab439dd73fc5c2d6907700acb6e9", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000002000000000000000002000000000000001000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xe6840cd73d8ca325ff70656c4ecded82de9a05e7212932b0abedcee5f59da334", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xb9", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x73a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xac0c873a3d9942f92427ae37009ee280b326788fa803baba4dbbcc31736ff2ff", + "blockHash": "0x6bde1987ef5b8bb5fde73ccb7b722f060ce2d5f1f3cf0744498e2eded6ad2fbd", "transactions": [ - "0x02f8d3870c72dd9d5e883e81aa0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cee5a944cf4c7c482656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a085c0042b81b23b846d1e4881b0131b4bbff774dd9bdece2e74fa92ebdb053c3480a0ab91a3e2fdf14c51273af6668fc2fa61f476555b41d52a466d663dcd5d6c776ea07ab7fe8ae84e3e65f3dbe646961c27216943f9d9eb9b2d3c48571cb1fee9f027" + "0xf86481e1088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0a48a7919c6813fd6419de6ac1026eb97cc5ce927050352aff02a6430e0bce5a9a0676e62102cb37a89ee4386c6192ff396f337791d3d12d6162952e5662b61a059" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5861,21 +5916,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xac0c873a3d9942f92427ae37009ee280b326788fa803baba4dbbcc31736ff2ff", + "parentHash": "0x6bde1987ef5b8bb5fde73ccb7b722f060ce2d5f1f3cf0744498e2eded6ad2fbd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x75397ed7dffd9a11c4edcbeeb1e639eb77305bd178dc500dcab6ec8b3faf0408", - "receiptsRoot": "0x22cd406e847641904efd5d8ac1f487eb2623b4fc895fd69ee449f25ad57d6f4f", + "stateRoot": "0x4ae22551484995968643becf5e15bf744ea0c792cb7155b6f9d98f51b7e4dafc", + "receiptsRoot": "0x7fcede4f85e49a01443369f7d463ec02d99314aba310830e45143af821431c90", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000010000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xba", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x744", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5f67af973e604193cdcd68a80dea8ff0622ee1341330c1b8601502020617c2cd", + "blockHash": "0x02795b8afbf3b9cd3539cf5e1c373c07ef6e1be6f4deb1fdbbd6cbe365387dc5", "transactions": [ - "0x01f8d2870c72dd9d5e883e81ab08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6508b81f8764eb37656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a046765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc9792801001a0341b7f2ef62ec29717a389a4940e28475731569675759ae3e8a33f3ca3157861a01538b9cd1c41315974a941a54a6e8f59bf9319214877dbe5b29da3d6500b917c" + "0x02f8d3870c72dd9d5e883e81e20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6508b81f8764eb37656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a046765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc9792801001a086efb5c80be03c51d8454222b0bfd296ff0e19e9d9ef9b3a7862830f74f4925ca0043fac0a6e63dac67dc062fc560a23a2e96a2fbbf462ec99aeee113249f4c154" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5892,29 +5947,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5f67af973e604193cdcd68a80dea8ff0622ee1341330c1b8601502020617c2cd", + "parentHash": "0x02795b8afbf3b9cd3539cf5e1c373c07ef6e1be6f4deb1fdbbd6cbe365387dc5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x48bdda61ea2778c74512475292f1383ad3858049a72ae7db5e30bd3fbf2bd624", - "receiptsRoot": "0x71352a0ec9727dcb65a37d458c233348bdf13252737a63c23cad594194349710", + "stateRoot": "0xf019e36fcbec65df2ce3027134c18b719508f70227ddc57c88435ab3619fde36", + "receiptsRoot": "0x677f708e7c661f962f797d1958ecd12718aff9362efcf2f98d4bac893d1d499a", "logsBloom": "0x00000000000000200000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000040000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xbb", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x74e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x493bf6336f7b638f36a29952c86afbb58526152b62be20eb6433bee0474d62a8", + "blockHash": "0x8e4c83e5e358f39de84987818cbd14c1a963ed5c8de83717bb6f89d11ed0ed65", "transactions": [ - "0x03f8f9870c72dd9d5e883e81ac0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c5f69e43b76f789f0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a023c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0d0263d59ac408ad76fb77656223a8015758a80eab5dff92e7088f0254143ca70a068b79a5e30ce091911f3bca90ade5affc350907f6c8bf8af1dcd860808d126b0" + "0x01f8d2870c72dd9d5e883e81e308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5f69e43b76f789f0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a023c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf680a0c1e6fb9cec6eab080407dd898bcafea263be141bbc087449dd270184d2726910a0416d9a5dbd083739e7846e4b7c01de859b064c9561d8b5b6b1a621e62776ea0c" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xdf979da2784a3bb9e07c368094dc640aafc514502a62a58b464e50e5e50a34bd", [] ] @@ -5925,27 +5978,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x493bf6336f7b638f36a29952c86afbb58526152b62be20eb6433bee0474d62a8", + "parentHash": "0x8e4c83e5e358f39de84987818cbd14c1a963ed5c8de83717bb6f89d11ed0ed65", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x80fd3239645de81ad57f1ebccda32eb45a50668e451b3b26e7218ac0dcadbeef", - "receiptsRoot": "0x247cd528261f6874860ba6679d6568e67b880e47319f8c3b0dd31bc1fb6755d3", + "stateRoot": "0x9f3f6b79b1d42e1d290edb6a602d04f78d4c33e0a60015056d519fded78c4f1e", + "receiptsRoot": "0x46a2752a9a9314e92f22636a4d915502df5b82eb8e09f2aa0b13a3422a472d42", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000002000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xbc", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x758", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2febc2674bc628df6cde532fe9c598bfca92240c5f240d189aa372425c24487a", + "blockHash": "0x2f741c1a54dfde09c36f6f171be91f7cc50a184e29c875af602ef52ed58e6e89", "transactions": [ - "0xf87481ad08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9d643f50f3c3ae83656d69748718e5bb3abd109fa0b3e7127bf0e21a500b9b3b883ec9def5eae78ce9bc8fee10d6cdeffdc0c13f60a00e74798f17ce1b4972603e58546b548c1e24bfba21c3d96bb035c709efeb8490" + "0x03f8f9870c72dd9d5e883e81e40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c9d643f50f3c3ae83656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0205bcc2489f954a3af7a16da4d6042a75fcd6eb69b848c52b3448acb24b2358083020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0bf2b925dfa8018902b89a9625827eaa5500ec20b3f4c4395cfccc31472f32a42a06fbac8676fcb56b7f8b639476c8afe7354fa09cdba4de8a8b015e9dd8b188e2c" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x15855037d4712ce0019f0169dcd58b58493be8373d29decfa80b8df046e3d6ba", [] ] @@ -5956,21 +6011,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2febc2674bc628df6cde532fe9c598bfca92240c5f240d189aa372425c24487a", + "parentHash": "0x2f741c1a54dfde09c36f6f171be91f7cc50a184e29c875af602ef52ed58e6e89", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbf8e94c61c11a129156b7e3fa9ba0de86d54dc00d74a4471e9c98ba815759b38", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x02fe0bb4eb66b26437ec7903fd7eb0eed53170157937bb735b7c00333e361481", + "receiptsRoot": "0xa22af58078ce594861d8ae9f8058938980d716301669166c1f2073b3844c1b15", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000080000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xbd", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x762", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x341223f936840f7f6a33fd74e14e5ebe4300b215cfadf77a8f6e88bfed017dad", + "blockHash": "0x7d60f33d7e776182fce5bd0572f488cd429e742705eb78603179446152aaec20", "transactions": [ - "0x02f86a870c72dd9d5e883e81ae0108825208944340ee1b812acb40a1eb561c019c327b243b92df0180c001a0ed38f6f89589e40421e3b475ea232220aaf132fa8b2f8a429b56aaa847116b9da0097910c31d39272f66c86d4146ca7e354af1e69ef3bfa8c18d40d2b95e4db5f5" + "0xf87481e508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6188771ea4290e13656d69748718e5bb3abd109fa07c93f78010a094d863376ae82eb4a6d37f04442bdc09fcf74dc2a123b8ae6e74a063013dde3a3c73fff4c1d998cd90fce67a104ee5a32be271d42fab78d23d8a1d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -5987,21 +6042,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x341223f936840f7f6a33fd74e14e5ebe4300b215cfadf77a8f6e88bfed017dad", + "parentHash": "0x7d60f33d7e776182fce5bd0572f488cd429e742705eb78603179446152aaec20", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x204529ee2f764b20eaaf6435c4f230829529269cacb29935eb0c3a7120bc1921", - "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", + "stateRoot": "0x665b04889d2e15ede87951b27ea61a4add7124de7f2023dbeb9f1e636e7b71ae", + "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xbe", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x76c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfcacae1b8715635bf3bbb10a375c44c799c2a882cab116306400381ff62e71f2", + "blockHash": "0x822c072433cf13fa896fb579c98e53f0ff3d231f10168b07647d214b5e2a0c24", "transactions": [ - "0x01f869870c72dd9d5e883e81af0882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a056843c6013ef0f7e993d7d4a299d7333722cae8844b9bda606a8f85236a7ae66a06e0498193d10d4767c06dc92c7945d7e8e0fb727437f5f683c4d15d7520aca67" + "0x02f86a870c72dd9d5e883e81e6010882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a0724f2f20750b6e846792035de6314f74d67bc678eb374e7a0378a0d08aca5c58a03dc7cb7a3820fe519393e3919fefb78a91efa6fb06630951b26818f36804ed07" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6018,21 +6073,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfcacae1b8715635bf3bbb10a375c44c799c2a882cab116306400381ff62e71f2", + "parentHash": "0x822c072433cf13fa896fb579c98e53f0ff3d231f10168b07647d214b5e2a0c24", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfd9c7a4406ab2c46dcc6be382fb183735b1d3e070a9d1f1635a7bbb429b1f90b", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xb339bf1097bd9ed7a2baa28b92f5c00263a4df11bf31866ec32b39406c8bec23", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xbf", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x776", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xddb665db1612487f7e1e333fbb5f607b93bcfc618983de7dd61d76dac6f3d948", + "blockHash": "0xc763e36a2d4a71b815dd3cf970327db148b6f24eb23522a4cd962848679f683a", "transactions": [ - "0xf86781b008825208944340ee1b812acb40a1eb561c019c327b243b92df01808718e5bb3abd10a0a015432bdd04ffc5215aa37318a4e5ac3bfbd95cb9f9fdeda20ed2366c03b0ccc2a03f18a7bbed8d5056b9cf1b0f48a57f2a697b4374aee87989304389efd91b8c82" + "0x01f869870c72dd9d5e883e81e708825208944340ee1b812acb40a1eb561c019c327b243b92df0180c080a07fe961f6b99cee70e756dc7fe479180d7855fe002c7572dabe4d7839f708cb3da07ce880477fce751e253fe79741ead343f714c620ae8e9b1d4925d4d8afe43556" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6049,28 +6104,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xddb665db1612487f7e1e333fbb5f607b93bcfc618983de7dd61d76dac6f3d948", + "parentHash": "0xc763e36a2d4a71b815dd3cf970327db148b6f24eb23522a4cd962848679f683a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x62ba3f65349e4c111e0d29f69d2b8e23e737f8b593645d9bd27527b4b6a281c2", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x425443c55bf6cc11f8c742160a3355474bde4551409997d9b56ce6017628c6ce", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc0", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x780", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcdeb0c3a06240f7f742c497bb142ac2477df943a878f8296b911b9f1169c1e46", - "transactions": [], - "withdrawals": [ - { - "index": "0x10", - "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", - "amount": "0x64" - } + "blockHash": "0x2ed48a4ebdefc743bcdbec0ecadc64fa641776a8ad70df8e58c6b29bf6c1a23a", + "transactions": [ + "0xf86781e808825208942d389075be5be9f2246ad654ce152cf05990b20901808718e5bb3abd109fa07ed61509c7ec5fe3ef1deb7c2bf8d01c9f501d9982d2208aecd8d3a7ddfb38afa06c74720e72af536646d725c7d49080686eb94b1d599a8bb99a1279644ca31090" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -6085,23 +6135,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcdeb0c3a06240f7f742c497bb142ac2477df943a878f8296b911b9f1169c1e46", + "parentHash": "0x2ed48a4ebdefc743bcdbec0ecadc64fa641776a8ad70df8e58c6b29bf6c1a23a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeed15dc1d1c3aa58ec844a312c71e28df4da173c397548d8054958fd9935c25b", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x03ed1415ee8648d07940a6d32100ba55e7f6e14bc6ca0b3a8775013753cea0c1", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc1", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x78a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x24b14515d27271ed944fd78cdea5855bbedf6cd84d65f925f8f06a426f7b1e4b", - "transactions": [ - "0xf88281b1088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0e10c5cbc9b32e3884f89ae0b846ec590fac27b518c0b94d4073b29c8bec9f0f6a0211543469b2609d656ed3cf1c81d0c46a1b9d9fe3e40f4db0470629d2dd7a87c" + "blockHash": "0x1e23bc483f7c371d9ebf493ba84b563479656771fe17f2846fd9c863fc9cfafe", + "transactions": [], + "withdrawals": [ + { + "index": "0x10", + "validatorIndex": "0x5", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -6116,21 +6171,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x24b14515d27271ed944fd78cdea5855bbedf6cd84d65f925f8f06a426f7b1e4b", + "parentHash": "0x1e23bc483f7c371d9ebf493ba84b563479656771fe17f2846fd9c863fc9cfafe", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2fe80dd71f69b62d75eed163395dfc900797e0aea020977a6e407545190fbfb7", - "receiptsRoot": "0xfa5f21241960744e16ad565849246d4f375208ad4df418933fb3f903cb4e8ee4", - "logsBloom": "0x00000000000000010000001000000000000800000000000000000000010000000000000000020000000000004200000000000000000000000000000000000080000040040000000000000000004000001000800000000000100000000000000000000001010040000000000000000000000000000000000000000000040000000000000000000020020000000000000000000000000000000000000000000000000000000000004800000080000000000010000000000102000000000000000300000000000800000000000000000000040000000000000000000000000000000000000000000000000000000000000020000000000000004000000000000000", + "stateRoot": "0x096099f2d7c47a0c7af6ab420ad9fa6334c7bf732790f7386ed6618672cc4fdd", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc2", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x794", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd5f960e48e2767108920eba4e8e326c9fc3233c3a2fa349770f04debccc14826", + "blockHash": "0xe61411b998dcbec97ad2ce9bca20014fa673980d1e884325c1075abef61f152d", "transactions": [ - "0xf87981b20883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0ea8ac7e4b44a2483e97723230e913a48bf2a489c115c4ac4ec032391cb653adfa0600e5992a204e2b0537dae104e1ca272eeb87767082c4eb860ef8b3fcb80a242" + "0xf88281e9088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0de5f5b108b09654f7d8ed16787102174e2698a344aa177ab38997e0290331143a004d275d26d1ae07aefc0aaed81a95b90427dccc3d696d0db8d3e63f19825c3c7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6147,21 +6202,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd5f960e48e2767108920eba4e8e326c9fc3233c3a2fa349770f04debccc14826", + "parentHash": "0xe61411b998dcbec97ad2ce9bca20014fa673980d1e884325c1075abef61f152d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa6c3339ba4148d799a285ee82ba2a3d078288592249d5f83e42b99b06f157370", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6be2b9dd7bded88692d1e5ed6e70c8b1d7aa45c5eebfd2f3ff481387b9b14061", + "receiptsRoot": "0x024d9f09c9b45b8c40485e9f29bcee4a0d25aa4160ea228584aa418139c3d88d", + "logsBloom": "0x20000000000000000000000000000000000000008000000000000400000000000000000000000000000000000000000000000000000000000400000000000000000000001000000000800000000000000400000000000000000000000000000000000000000000000000000000000000040010000000800000000000000000000000000001000000000000000020000004000000800000000000000000000000000010040000000000000000000000000000100000000000000000000000000000000008000018000000200810000000000200000002000000101000000000020800000000000000000000000000000000000410000000000100000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc3", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x79e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcbfad2a8bdfe5205c485383414e29d8e0a9c8b10812151d25bb51a74c95549a2", + "blockHash": "0xf24e0907bc9948667699c8f9094931f930f8617e5eafff2271656cfbde5c2956", "transactions": [ - "0xf86481b3088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a07fd2ac2b263f2af12a338119e615fae0d3051dea3796964c46d16c0f941546b5a05414f2148eebe1d2ad114e32ca88ab51e1439fac716bedd3cb87c2110e39d9f3" + "0xf87981ea0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0e42ca826d4b55e9090e794708839ec814729589638826bfb6435f3754ec9ebcfa03b0c3a0bf6311efe28815ab455878767818db4e14f6fd6f406decfabc4117fed" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6178,21 +6233,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcbfad2a8bdfe5205c485383414e29d8e0a9c8b10812151d25bb51a74c95549a2", + "parentHash": "0xf24e0907bc9948667699c8f9094931f930f8617e5eafff2271656cfbde5c2956", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb9543b5c0e7a63e34155d717234d5205c636cc3e6988b66dcf579d56fc91821a", - "receiptsRoot": "0x736e6281d7032bd4ba22922bc0bb6327c4c5b291b7d3cdcb1ed2a8f9ad3a5fa2", - "logsBloom": "0x00000000000000000000000001000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000004000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x528c818971f8e91e1138d4713d88d762e81af2176d7db93264c3b0b8fd47cb0f", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc4", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x7a8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x078aa96db2936406a8d1d69a59f72bd60a908cbde5d2abb12166b41ff714977b", + "blockHash": "0x9587ef58a068fcb27daff28ee3da231caed47c7efa9371fb42b14fc9908767b5", "transactions": [ - "0x02f8d3870c72dd9d5e883e81b40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c67fc28af42e5f642656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a032984cfbb954e0815427570f4ceaef21a3691026950e5ad80401232f687620e701a021bb96eed8ad52a0a4f89d5bd6584a666acd40f58e0ac4abf20005b8bf18d8cba02a3ce328668299ad47d4e7dfa4ed46db5b4bc9b661db9c081654eef1f82f837e" + "0xf86481eb088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa02a1b6ee9e8eb5cd94cd651a3b2930c4543986132e2e215e6f9416dc8be31344ca01f7587b14f4234961447f94cae13c54280f72390b491219b98f1fc2f4a3aab0e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6209,21 +6264,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x078aa96db2936406a8d1d69a59f72bd60a908cbde5d2abb12166b41ff714977b", + "parentHash": "0x9587ef58a068fcb27daff28ee3da231caed47c7efa9371fb42b14fc9908767b5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb00ebb7f6604fb250e1351de6bac6befa9e7e6ce445dafb62ab501fbe85531d5", - "receiptsRoot": "0x44882009e0eee4abe404df368647481c05b2c6c068b0c8c1df0ce88f47bae444", + "stateRoot": "0xfa0dc9ff28e4f903721edb3b35e3b68e8315261318d7b8177e556dadcb11ef6a", + "receiptsRoot": "0xa4e6a14fb19ddad6e78264292f9df58b55152218eae0eff88e1b9348bc3fd654", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000040000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc5", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x7b2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc03fc9d4b6d49d1599717fbf75a9ad47496efb1ec6fafaa5b4bee2afae9bee30", + "blockHash": "0x035aad19a0a2ed13bbbd78630f35c556bfe04d7a89bb2fdbe485ad344e6e81b3", "transactions": [ - "0x01f8d2870c72dd9d5e883e81b508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2b5bb2644ee8dc40656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba80a0f649eb6ccffab94e9a5c90d0e9ca5e0c684ec630d63ab9fa111a9e3c228a1caea05eac0ee3d924d0666bd81261897d914f3018747fa0e061a5e6a55cce4d575dbd" + "0x02f8d2870c72dd9d5e883e81ec0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2b5bb2644ee8dc40656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba019fb39e93ff859f3600c01b7d7097a5a8612b77a52e73ddc099d3888b83b8aa48a00b0213a0a435161fb50eb892a0b62016e30e794657df8203ec443f4181519eaa" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6240,29 +6295,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc03fc9d4b6d49d1599717fbf75a9ad47496efb1ec6fafaa5b4bee2afae9bee30", + "parentHash": "0x035aad19a0a2ed13bbbd78630f35c556bfe04d7a89bb2fdbe485ad344e6e81b3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb0c41dffbade6271470b8f8c5b780ad0b1f02a2119260335d471965ed57569ee", - "receiptsRoot": "0x891fd12b9e201bc60c807e319a161d32840bbe493d9c44a1db9b58083f874dbc", + "stateRoot": "0x17fec881f0a46758a00b8d3f1188246eb7201d6ffbc40723236e1772001c04fc", + "receiptsRoot": "0xcb9c042b698bc6af04b2691e0a065e428419e99e72cf44d9648a8cf4d8f0914a", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000009000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc6", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x7bc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0fa887a20612f7ab9a00abfeb074c01ae4b509b4859c48c2e24abf27b7d7fed3", + "blockHash": "0x5124774422b19463745f7a5aa4c1399d3e8c13abdf68cd0eb70477ba79b3bfd4", "transactions": [ - "0x03f8f9870c72dd9d5e883e81b60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c28b4f9f2367ebabf656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e783020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a04d341d72ad1244a3c31bc3b0015fb98913e5335530a4a62559c93853fb44cdf3a06d3d0dd50c842fe58e16e08248ab122efc34c430b8d750fc332644664c3e5b09" + "0x01f8d2870c72dd9d5e883e81ed08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c28b4f9f2367ebabf656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e701a06640a31d9e8567d5cb1bdbc8c2f8503d8baecddbb42384fbb138148ffb7c53a5a017ba1e6660bdc56e4f8d5713b7f3e336bffdbaea515ff701ee12ae5dac240318" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xa73eb87c45c96b121f9ab081c095bff9a49cfe5a374f316e9a6a66096f532972", [] ] @@ -6273,27 +6326,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0fa887a20612f7ab9a00abfeb074c01ae4b509b4859c48c2e24abf27b7d7fed3", + "parentHash": "0x5124774422b19463745f7a5aa4c1399d3e8c13abdf68cd0eb70477ba79b3bfd4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe72ad6c35d2223bf7e059940350eaabe3e8981c6378596be49864116d0f657a1", - "receiptsRoot": "0xd1e721c5ecad92ff5f7a0d380819f14b87b579ac4df1d2968489b730f9b40d9e", + "stateRoot": "0xef7a3636b93f0d6718bd63542c1360e0eb2b96b5eeeee35a0ef9b99f8547321c", + "receiptsRoot": "0x342eaed63cb38bea909573825289290790acecc440db7592465f2ce257905ce1", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000802000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000009000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc7", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x7c6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbdc33ca00ea1641cf1ca2816913824999b73d47a92e7d5303c4104035ae78725", + "blockHash": "0xa467cc633a88b190c7c454be97d066a22527ccfa3784a6d0eaebb099363da22a", "transactions": [ - "0xf87481b708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbf894c2fffdcdbd0656d69748718e5bb3abd109fa036a4779c859e40e5aedd04afbdc0b99e5c1b2fa06f706e75c8d30952858c566ea05ba2bffb61a84a9947a0c93159d4315826133aa2842fa1931bbc4ff2f60f4eeb" + "0x03f8f9870c72dd9d5e883e81ee0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cbf894c2fffdcdbd0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00a2bc3fd72bd3f8bb7f1de9a7dc9e928a7c6a831237124e65c60c25f8348af1983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a01b1fbce7c0ef87f6f9663a0b60e65cc7677278016d927e12347e76adb5c349fca02c4342ff904879e71f5a9bc230ba38bf9a8fae1d59c8960a706ef33214d2d0d9" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x9040bc28f6e830ca50f459fc3dac39a6cd261ccc8cd1cca5429d59230c10f34c", [] ] @@ -6304,21 +6359,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbdc33ca00ea1641cf1ca2816913824999b73d47a92e7d5303c4104035ae78725", + "parentHash": "0xa467cc633a88b190c7c454be97d066a22527ccfa3784a6d0eaebb099363da22a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xae965001554c570fdf099944449e4a8619bb09413c1b150ad226f240b28c09a6", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x8c8db72fff2333a2033534e709f102e14a1f5d447f4f0bc8dab1593f29b9b755", + "receiptsRoot": "0x89ad6e712ff59972d0e9cb30bb1e153bcf812624c56f0b21b11f5392068d364f", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc8", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x7d0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x44aa9401e0d5848c03c53c87cb883698f3a346340416803b666fce0eb7912595", + "blockHash": "0x4b395a1569a2995fc5ad6e079e367cd135ae61be2315a57336faec96ff6be4f2", "transactions": [ - "0x02f86a870c72dd9d5e883e81b80108825208942d389075be5be9f2246ad654ce152cf05990b2090180c001a0627cc882a43d440583c3751b3cd55df3486c73273d7a96078c16a6ebde51f31ba062b06acb893608526565b6b55122fdbf4312e143f2af2a32154bd057f050c4df" + "0xf87481ef08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3ea8a9234e6d52c8656d69748718e5bb3abd10a0a0f425e20bb20618d370264da280ce98b8cfc5ed905266f4a97b5410a7a13e99cea0169d5c9b136d5c55900d7bc5e9d877219bb0018ed5dec92df79f6fd7657f8095" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6335,21 +6390,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x44aa9401e0d5848c03c53c87cb883698f3a346340416803b666fce0eb7912595", + "parentHash": "0x4b395a1569a2995fc5ad6e079e367cd135ae61be2315a57336faec96ff6be4f2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x217fa2954ee1343cc299de1fd1145da676980d65134ea921cc5b2c1b1041214c", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x7eefbb5fcfd5311819571c7f36f79c4e46685e02b12d0152b08824a5a4a6e37d", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xc9", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x7da", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xabf8b8c18e738be05befb8682083d8212b57c009c599b65535c4a7f47930bfa8", + "blockHash": "0xf3574c46ee7be2f327b4c968186b9cba6ce8bc43cac0917119e3226630ac2e40", "transactions": [ - "0x01f869870c72dd9d5e883e81b9088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a0f18f3e9683cdbef4545211391dc53712720b86cbf3eaa4644fd33713f571a874a009b214615dc2e3423998b3b16d8e8d74d48240a6c2bff07c4cf200d0f6d50419" + "0x02f86a870c72dd9d5e883e81f001088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a01e30abbce6dc782012eea990165f7b02747ba70b0c723f37ed8cd9798ee051b5a069bd38061c66a0605b2bd6dec21e0feff4604ffa7c0562cf735c5a095f2cbacc" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6366,21 +6421,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xabf8b8c18e738be05befb8682083d8212b57c009c599b65535c4a7f47930bfa8", + "parentHash": "0xf3574c46ee7be2f327b4c968186b9cba6ce8bc43cac0917119e3226630ac2e40", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xcaba00e546f770e334b071bdb4d3f4ea77da9722b5bb0c7a0a865d8abd661c97", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x80b41a6c60d2170decdefb74572e5452246657529a32a9ede6c14a73215b993f", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xca", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x7e4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc61c8872972b975d28191544f7200c3f3684a9e152c87f626b6c85aa56af4a22", + "blockHash": "0x4b92c1e975dfdc44423fea09f15c0b0f6cd94b52f75eadaf500817dadfedc05e", "transactions": [ - "0xf86781ba08825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd10a0a063c98b14032fb2c822eb17147b7063eb5c85bb109db346745c9686f12f56884aa0730758544ae9aa1dd644331ddca4a97df3a5cc880fe78c433a80877756440deb" + "0x01f869870c72dd9d5e883e81f108825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c001a069d90c3f5ad35ea13b207c3c320c16387cea3db454e625f0837e315e7064a377a06f6640758b45d8d313870e0244e026757adfac8afe22afc443478390488ef0ac" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6397,28 +6452,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc61c8872972b975d28191544f7200c3f3684a9e152c87f626b6c85aa56af4a22", + "parentHash": "0x4b92c1e975dfdc44423fea09f15c0b0f6cd94b52f75eadaf500817dadfedc05e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8f04f9a48e73c999528f2cf1176cd4b3d3029d20066292517fe649c0cb705624", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x6710a5c1a72b3e069b6ed71011bf5f7345dbce0862c383ff43a5bf797ca65eca", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xcb", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x7ee", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1e7e2004a340707d31625b7ac9ea03d7add6dddfa7c32922e6222147b86aa4b6", - "transactions": [], - "withdrawals": [ - { - "index": "0x11", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0x5f7c14e45a99709c6dd5b99043f115777e3fa2aff9baea04e819c8ea1d49ff4b", + "transactions": [ + "0xf86781f208825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd109fa04dc3febffa0fb3a85d3f7b6b04471b40f9b8ee4752919fd7eb275ab26a7e6ceea0118961b62ac804bda39a47c2fd2bb14cd20ab3f02d5d3c7857482e20c43d0703" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -6433,23 +6483,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1e7e2004a340707d31625b7ac9ea03d7add6dddfa7c32922e6222147b86aa4b6", + "parentHash": "0x5f7c14e45a99709c6dd5b99043f115777e3fa2aff9baea04e819c8ea1d49ff4b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb5e6b4f20465ce1176c50efeeb839321c9c4e8094097f7f7108b6c133dd62dc7", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x9084f2e6fa64e170542a90022d0b1afb798b5e041c64c4d9060fe0d2fae2c4f3", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xcc", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x7f8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x13676db30bae04c5f3b7f190e44e72d1c1b1299567e9e3757603554f30ff45f5", - "transactions": [ - "0xf88281bb088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa019a238a4412caee8f29267c4c04a9570f4d39d62a947012241b6f44e13f75caaa0783f12ca97199c3ca3165a6756de7e8026f49c4aba3753d5b03557938dbf44fb" + "blockHash": "0xa6a548359521b4b239f05fd8001e74c3cdec873dccbc6e9d558942720219436c", + "transactions": [], + "withdrawals": [ + { + "index": "0x11", + "validatorIndex": "0x5", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -6464,21 +6519,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x13676db30bae04c5f3b7f190e44e72d1c1b1299567e9e3757603554f30ff45f5", + "parentHash": "0xa6a548359521b4b239f05fd8001e74c3cdec873dccbc6e9d558942720219436c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x171d9a961fefe91fd1792a751cf4fde90239576fa142b5bd9f588ae9d4d896ce", - "receiptsRoot": "0xa04c112180a3fffdcc1655e8f47a8103a63799fd47aa23ec9b102d827ad96ce3", - "logsBloom": "0x00000000000000000040000000000000080400000000000000000002004000000000000000000000000001000000000000000000000000000000004000000000014000000000000000000006000000000000001000000001000000408000000000000001000000000000000000000000000000000000000000010000000000081000000008000000002000000000000008000000000000000000000000000000002000000000000000000000000000080010000000000000000000040000000000000000000000000010000000000000000000800000000000000002000028000000010000000000000200000000000000000000000000000000000000000000", + "stateRoot": "0x1e670194ebc744dd6b0999f3f8cb20b3043dd3225da24ce3585c6a5bcaa73f21", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xcd", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x802", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x20836fb907f186aefcdcb5764e3d7c48fcd1b16bc98b967edd65b354e68a3e79", + "blockHash": "0x2fda609eaf660679f823fb4376c4bd0cadade83e2fe577f82d1ab3d9f0f42699", "transactions": [ - "0xf87981bc0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa08a8ec366f0bf0013e493ef12013a96ca99ac07150b9b7df31d5d97a634e428c9a030674d41ad2c7628441bd42eee190439577b04f2e19e5193e8290b4f18cad676" + "0xf88281f3088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a02289959547b578eba29dfa0768eae6a5a0f8b7d99462d204107f2686027e90d8a02713d89b93092db05cbc9a9b84afb226fffcdfceacb312dab91431ae251af3f9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6495,21 +6550,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x20836fb907f186aefcdcb5764e3d7c48fcd1b16bc98b967edd65b354e68a3e79", + "parentHash": "0x2fda609eaf660679f823fb4376c4bd0cadade83e2fe577f82d1ab3d9f0f42699", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc6f62b62137ceb0a14ad1b3fde8fa84c7aa3817990780aeb851e34068f9e169b", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc862aa6db897c9f52cc4720788ee061436ea3f10bbc8409d6e65185d94352c93", + "receiptsRoot": "0x3f561108b42b5d639e72338a2c50305f093b051318915b07bbd00898dc95b39f", + "logsBloom": "0x0000000000000000000000000000000800000000080000000000000040000800000000000000000000000000000000000000040004000000000040000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000200000000090000000000040000000000000000000000000000001000800000002000000000000000000000000000000000000000004000800002000000000000000000000000000000000001000000008080000000000200000000000000a020000000000000020008200002000000000002000000000000001800080000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xce", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x80c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5936f662e12c0f1b392611803d3cddbe33bb2d7605769956e334c560b372537a", + "blockHash": "0xa8551de9ee0942059b85b3390a4a8e2b4717e843f5338062877d9a125e1c5d62", "transactions": [ - "0xf86481bd088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa029e6e202c55f9d645b907bc215cd740d2778d6e9d804394013051e786b753969a0037d7a826d61cb0657e04993e66a822a5aba369a49cb548c74c822f50472cde3" + "0xf87981f40883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa00f01325060cdb378a59cdb1f33d728f6a97afa73faac18412da93354251e23b0a0778eb42239b79ccb8aea4921b4d37826c05753e963dfd8a84086fb9b54fe2a55" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6526,21 +6581,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5936f662e12c0f1b392611803d3cddbe33bb2d7605769956e334c560b372537a", + "parentHash": "0xa8551de9ee0942059b85b3390a4a8e2b4717e843f5338062877d9a125e1c5d62", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x16a2bf920aecbb10ddfa63e5b2401f42894e33699c457972c2dff7f8b352bbfa", - "receiptsRoot": "0x78163770546821afe0210ddf4d9b40d3ded121339b8329cac20c43d146e0e972", - "logsBloom": "0x00000000000000000000000000000000004000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000210000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6fdfa0af2b35c52938735071dcc796a47a88984b36f4c4692d33966d070a4c7a", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xcf", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x816", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfa49b5f47466644348d75c491db8ff92813c96fb5b3f4a4deaa02bc92e3e134d", + "blockHash": "0x1cd2293c5df7c51a36bc8527308cfde43dde547b42129799d3f9f94f4b2a5d8a", "transactions": [ - "0x02f8d3870c72dd9d5e883e81be0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c979e5a5fe124c246656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d34d30c2584168001b907965762f784cb4337381aa8090ae36bc66bd515849b580a088110c04c0c6652f487085c6ceda215e70df1c33b1125ac7bcb0af5d489bdd03a054ab88f5af3d8f0dcfaff237bb154395d0c6a59814458a682fed5887ccdd70b1" + "0xf86481f5088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0acaf7d557190a46d89d405d0e8bddab4c67007976f47d7941d359b762419c0d9a0700a188d7fab3f77f68b79258b9fad4ecc01fc029ed4fd5186eb07e35df103e4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6557,21 +6612,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfa49b5f47466644348d75c491db8ff92813c96fb5b3f4a4deaa02bc92e3e134d", + "parentHash": "0x1cd2293c5df7c51a36bc8527308cfde43dde547b42129799d3f9f94f4b2a5d8a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x23c36b132f262810c3858b7e846e553e8c5b4157f0cc759dd4d06cc5b1e2acba", - "receiptsRoot": "0x039055b9ec999e72f11bd659bb792a736d3cc09a343ef525508c39e56c466436", + "stateRoot": "0xa44d0a46223e903d3168caf55f0230899f101c64a42cff41438b3d496bc0fe37", + "receiptsRoot": "0xd42cf506fa4fd2e3355607964d41795f80d5bab48586be0f46bbeb8ab4626634", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800100000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000009000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd0", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x820", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6cedc591e85ed32d70655274734b636e3482105a5e9d416e62ef1dda2ddd4a9d", + "blockHash": "0xbc42869ab3a2245d1c7a2d33a982c8696aab3d3c0f9dfa69d8be2d2cc9cf1d31", "transactions": [ - "0x01f8d2870c72dd9d5e883e81bf08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8676dcf035dc0936656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c401a006d444f4f74e5eea0c3eaaa7254b1749c2620e613021fe3118fb522709af0d49a06893fc0e845a1bf821c0d571ca39aca9143876955a810d4f8c22dcdadbedc7b0" + "0x02f8d3870c72dd9d5e883e81f60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8676dcf035dc0936656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c401a0fb473a535de94722bba71f55061aae1314b7bc78cc1cb160f3bbc481c41ddadda04e09cdf8831c9e3bda3e24a64ef78bdf96a7b332d1d52cf577d74b2829dcd8d8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6588,29 +6643,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6cedc591e85ed32d70655274734b636e3482105a5e9d416e62ef1dda2ddd4a9d", + "parentHash": "0xbc42869ab3a2245d1c7a2d33a982c8696aab3d3c0f9dfa69d8be2d2cc9cf1d31", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x270b9ee22c74c4a262b9a8d5bbc2d91acab5a3d227276856c5db8b57035ab2e5", - "receiptsRoot": "0xb19edeea01beedca72ba67077e0ec43a996a180c8a53de05e2258484987bc1c8", + "stateRoot": "0x4aaffc98ea6a7e916cc783b132dc537a600ba35c901871cfc507f899334351db", + "receiptsRoot": "0x251f5e2c4b0c5e3dd44fc865bd15c121286aa01ae089e879659e6718e90fe9c5", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000800000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd1", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x82a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x53bfe21b477b2780bf2e1aa15b19710aa9bb5100cd7bb69c8cc3a881ae50ab54", + "blockHash": "0x8e8b607660e0016ba139872bc35730d2efe0426136dc7e32ef6091f2c72acf50", "transactions": [ - "0x03f8f9870c72dd9d5e883e81c00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca2da1c555f06d1f8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a05d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0ac9d964fcceb3bb9986d78e3355e6759b0c09aa500b94f8d45a56b387f4e0a9da043a7692fee848877dea8f525b33bfa8ce74fa83d23863b6089b9aacda57aff16" + "0x01f8d2870c72dd9d5e883e81f708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca2da1c555f06d1f8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a05d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f480a0adfa1f7c4c15fe13bce3258149d900ad82ecaa1066f237a6456ec3b529237754a079eedcd2a684aee1a2b771a435b3186a5da0936c6089174e8fafbf122ffa836f" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x6d7b7476cecc036d470a691755f9988409059bd104579c0a2ded58f144236045", [] ] @@ -6621,27 +6674,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x53bfe21b477b2780bf2e1aa15b19710aa9bb5100cd7bb69c8cc3a881ae50ab54", + "parentHash": "0x8e8b607660e0016ba139872bc35730d2efe0426136dc7e32ef6091f2c72acf50", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfdac4f685bce039b15ebcf355bdea6d1bdcb23fd1fa61d5e605d92be7ffb65e5", - "receiptsRoot": "0xc82851acbbbc23f6dcb23ae872dbe441b63e88a28797c7f64d078f287f00aad9", + "stateRoot": "0x480608e954ad9f709e266ca8e840f66eac2f7ff838180c130b3e348bb1c99054", + "receiptsRoot": "0xba5bc7653da51e3500f74cdd416e4eedb5414648e374233de868ac67343e50d1", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000020000000000000000000000004000000000000200000000000000000000000000002100000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd2", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x834", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4c30c648a319319788200f7273f6de74e321f1796b01a2988f98840a11e307f1", + "blockHash": "0x85ad1ea8a6413676241be28adc37e9e9eafc7d7d92838f662f89e954b1946243", "transactions": [ - "0xf87481c108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6cb6df52764cfebc656d69748718e5bb3abd109fa07b559e33b774aecd9aacf0286e66cf455b956de0d23d65e0890b6f8af7824e0ea07d0d6856bf3a5f25b3c38567f1e4c82b67fdbe1fec56883d1a311f858693aef4" + "0x03f8f9870c72dd9d5e883e81f80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c6cb6df52764cfebc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04c3dffb6198347c61671fa1fafd5d80f384ab67a494f5c7bc7428bcb6ca5a44583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a066a0c94f13a1f94614e0f1df0af17cd8652599496fecceb1a7e58bc545490efba0675eb1dc9602c18b7c1eec372e8ae3daa1dd5a3aeca1a89e52c85bc4d72aa854" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x417504d79d00b85a29f58473a7ad643f88e9cdfe5da2ed25a5965411390fda4a", [] ] @@ -6652,21 +6707,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4c30c648a319319788200f7273f6de74e321f1796b01a2988f98840a11e307f1", + "parentHash": "0x85ad1ea8a6413676241be28adc37e9e9eafc7d7d92838f662f89e954b1946243", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5829a4e6c3ba50f94b040eebbd055206d5ff8549d0013b43359d680bf4581b62", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xce71f031bbf67f2695e759640a3940d1278f1bc7c6de271994bf84d3e657c802", + "receiptsRoot": "0x85b5286a8beb7cd62c5f621a2fbb6f9afd256c9ea0f0b7e10d3fcb8a55c80bcf", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000004000000000000000000200000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd3", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x83e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf490758a0266199a571a859efe170beefeb78de97d3a20328ac3d4bf07240fdb", + "blockHash": "0x43cc37e72c9060cd84480dc2b3ad47b73ae9d3153ef17aaee77426eaea98c979", "transactions": [ - "0x02f86a870c72dd9d5e883e81c201088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c080a0aef9e39d76c8457e0a7bb9c8756d1bfa6345f68099e474f8e30f3740a1d6ddfca06fbc5fba7e481cec9942305199b40aec155fec75b61945f4f9f9669e593e6a1b" + "0xf87481f908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cfdcda6573c19394f656d69748718e5bb3abd10a0a0061608e071cc09a95aa321d3751fccb473d16626ab1626ace43d95f685ff49fba01e4c519dcaa3e93ab814cde795a6fa4c5f87f037558981f42438de11a3447302" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6683,21 +6738,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf490758a0266199a571a859efe170beefeb78de97d3a20328ac3d4bf07240fdb", + "parentHash": "0x43cc37e72c9060cd84480dc2b3ad47b73ae9d3153ef17aaee77426eaea98c979", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9fa6c6e9301b88853215e45c7486e03668c41923a9433035600c6774c3f70ac1", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x7dce685a8396403165e98bd384df9ecbf5d01f7e564a347c71cfbdb3deb02c28", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd4", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x848", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0a1e9c1d1ad91f4d574599fe8247974beb2ab68c78b43cdda303870ede057f49", + "blockHash": "0x52cb7c3d0a4baf4b97c814f69a29ce7efd02b30063caeb4dd25182e4945f9443", "transactions": [ - "0x01f869870c72dd9d5e883e81c308825208942d389075be5be9f2246ad654ce152cf05990b2090180c001a09c5619eb9696478f17d50fb6170ee50d8af515c6cbd08e108487c4f3777211aea05db82c382e1cf0861b97e06484e0a3fb71dccfeba88b69d211a8782962b7cd2e" + "0x02f86a870c72dd9d5e883e81fa0108825208942d389075be5be9f2246ad654ce152cf05990b2090180c001a06a4620766ee6615712cff89a149f4a1d4af61e13971ed8217cf05b3c84266b89a007a1673bc56c3298d9ec061ec32cf0b35be7d8a7d18ca2b122e3f8a9915a04e8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6714,21 +6769,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0a1e9c1d1ad91f4d574599fe8247974beb2ab68c78b43cdda303870ede057f49", + "parentHash": "0x52cb7c3d0a4baf4b97c814f69a29ce7efd02b30063caeb4dd25182e4945f9443", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7acb7b8b3870b4776f57a820b541ae9bde134f1d1972ab0294e2e66ac60e6736", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x7c30f7a61d25d256743ddc4f767bfe647c86218e1e04e0e81a378ddbffc2cd83", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd5", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x852", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd89a67d59bfca6ef7942ef28cb121005dfd9c18b404a8dfb95e7c4d1b405a87e", + "blockHash": "0x414140870ecffda2fd30789856025aeeeee6ed2d339c89b09142a80b5d02b2fc", "transactions": [ - "0xf86781c4088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb201808718e5bb3abd109fa08e1059084e07382e7c3f645d2adf302436c9114e70e26b5bdbfa2adff7dbd48ca03c3d1e78c1a4db22758155af5ece83f71158ab8163f9066b651745a186872fc5" + "0x01f869870c72dd9d5e883e81fb088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c080a0ea7f055ff679356b6bbc372e259d1f107d08db148907f27c2e1287bc0e0ab595a01ff11cc25aab1db903fbe7a5a12ca3f0a15551f92df97c0619e875fe72984da2" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6745,28 +6800,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd89a67d59bfca6ef7942ef28cb121005dfd9c18b404a8dfb95e7c4d1b405a87e", + "parentHash": "0x414140870ecffda2fd30789856025aeeeee6ed2d339c89b09142a80b5d02b2fc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x981e76609731467dfeeb081989c54862b48595f14366b0717dad9ce88d967997", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xd0ddf082a0315b3a2fcd6256c25ea67d747fb54b237dcdf8ffc431286c68cade", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd6", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x85c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x44e4a64750e4c9f6511df524c16e9cb23554a89325cf503b74f8f25f16253cec", - "transactions": [], - "withdrawals": [ - { - "index": "0x12", - "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "amount": "0x64" - } + "blockHash": "0x6d091cc14eb2771eda246d6c98884ca88b3e9c1193f9b1094786e7ac38615d0f", + "transactions": [ + "0xf86781fc088252089484e75c28348fb86acea1a93a39426d7d60f4cc4601808718e5bb3abd109fa0d12da3e860c37ac15537560dc07ea48946855a3dcb2045f27bb14034ad34e7a6a05c6a3fdcdc7318b687ae69d8fe93217851dda4df774c487d0fd025495d81eeb3" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -6781,23 +6831,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x44e4a64750e4c9f6511df524c16e9cb23554a89325cf503b74f8f25f16253cec", + "parentHash": "0x6d091cc14eb2771eda246d6c98884ca88b3e9c1193f9b1094786e7ac38615d0f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd00459f2dd9d486fd22a4c2a34cf9793da5a6b76b9020e151db7db7eb402e5f5", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x87180f17e7aa5d9be9e242e7f923bdfb1b095d8774047d3b56ec932625df566d", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd7", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x866", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9a379148fa0512b767d90e2a9a20248c6c19441d7f9284b00f802de8d40c5404", - "transactions": [ - "0xf88281c5088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a029fc410923581507d7291574037a67f6e1eac9f100ffdce835f42d20fa508971a03d3e1a36a3adcc64bc95d036c1335989bd3cd8810a7009fe910d469a0b384b0c" + "blockHash": "0xc2c1970e54d67656e78c75f59b990d4a682800dac92f32e35bbf5c9f4123080e", + "transactions": [], + "withdrawals": [ + { + "index": "0x12", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -6812,21 +6867,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9a379148fa0512b767d90e2a9a20248c6c19441d7f9284b00f802de8d40c5404", + "parentHash": "0xc2c1970e54d67656e78c75f59b990d4a682800dac92f32e35bbf5c9f4123080e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3dedfe9b872cff7e3a73dc6415b388469f09609fc9b9ea8e87d988f3acdb2c40", - "receiptsRoot": "0x44356f2265ddbe65555b4b95e21c7ef48964641e03ab3082353b07d9078f8f51", - "logsBloom": "0x00000000000000000000000000000000000008000000000080000000000000000000000000000000000000000040000000000000000000400009000000000008001000010000000040000000000000000000000000000000000000000018000000000000000000000000000000000000000080000000100000000000000002000000000000000000000000000000000000000000000000000000000000000000004002022002000000044000000040800000000000000000000000000001000000000000000000000000000000000800000000100000000000000000000000000000000000000400000006001000000000000000000080002000000000000000", + "stateRoot": "0x9ead26372087738f0a82c760bf0f9f43dcd72e44b65d094a9b53ef5ce38d0227", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd8", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x870", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x96ce02bc5a0630bbf7d4c1340ff68ba3cbc53a401d8ced01339937d2d764980e", + "blockHash": "0x9869f9d317befc2be06e35c4bb421b2f70ee3a551da726ac450fbe5683e175e9", "transactions": [ - "0xf87981c60883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa030a9d121bc9e2cfecc1898c345a758637c76cd12bff359a9fae9fa5fd4159ca5a079825054df53269360ab9971dbb4fdd41654d53af7ea4b63a9649138e499326f" + "0xf88281fd088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0f07ecb99ca6e3f73e8d15bbb95529e9b6889f7f9a879d2287bb7e15f7dcac49ba0487bc2fddd49b63ac5e1c05e9dd58319163ef2be8e6be6d808aaa82171a95c92" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6843,21 +6898,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x96ce02bc5a0630bbf7d4c1340ff68ba3cbc53a401d8ced01339937d2d764980e", + "parentHash": "0x9869f9d317befc2be06e35c4bb421b2f70ee3a551da726ac450fbe5683e175e9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2befec4b322b55dd859c81bafc76ee06de698ba0a0e1a80100dfc52ecf3a5da9", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x0df6593528615a46f29a840e91658bc09028b232ff4d02b0fc4c889e0f188b1e", + "receiptsRoot": "0xdaeb5682484dc43ef26215a9aaf64a787fc4388eaaca288d11e605f4eca59e1e", + "logsBloom": "0x0000000000000000000000000000000000200000000080000000080100080004000000000000000000004000000000000800000000000000100000000000000000000000040000000000080010004000000000000000000000000000000000000000000000000000200000000000000002000000000000000000000000000000000000000c000001000000000100000000000000000000002000000000000000000000000000000000010008000000002000020000000000000000000000100000000000008000000000000000000000000000000000000000000000000000000000000008000000000000088040000000000000000000000000000400800080", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xd9", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x87a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x41eea349b7529f1465e872f4eeb3958da339bd18193b9055d1f77649b5b5a8b1", + "blockHash": "0x6cd3151a665feb73ef2fd1c09b2ba1dd622e424cf8d437491f67d7acea386a25", "transactions": [ - "0xf86481c7088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0cb1af42d19318f59a0ac8d3cede5c0676a469b9321ba05d79b399c6f797643baa028a8a87701ac2d081f04455ad349560814f8587a534598361d105c7abf886af7" + "0xf87981fe0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0484f9c198cee5bbdb572ac3000910d183ca76e7a0a7728f7e8c387ca592a194ba05963cdec459e60452eba1c8a91a102e59751ed71cbd061efeb41b107e7fb5758" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6874,21 +6929,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x41eea349b7529f1465e872f4eeb3958da339bd18193b9055d1f77649b5b5a8b1", + "parentHash": "0x6cd3151a665feb73ef2fd1c09b2ba1dd622e424cf8d437491f67d7acea386a25", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa59cae76341e126fdd5fdefebd48eaa5a60c0545051f79d5cdbb3fbcfe96ab37", - "receiptsRoot": "0x7336229ff06445fc64883e750bb07c2ac1556b12458cb4981ea24c2fefde5c07", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000", + "stateRoot": "0x33ef2451a664c8d76e1ea636fd70fafc878a7789b182c93dc03ab7b5c99745df", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xda", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x884", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xecdbfed50e09e8bea9b23b0c056b9ef72bd724fd104590fdccfed99e26401a78", + "blockHash": "0xf12671c7915ba944f549618aa1a618c58890d1bb1374ba0d5bfe9a1d219d4e10", "transactions": [ - "0x02f8d3870c72dd9d5e883e81c80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca593b76d11072099656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03982f6a73961b17f67a84959ebc42a5a3ebdd1faa925399f3f276cc2de65f2fb80a0d670ad4d51a872c140a4fe0209330c2e44232837dcb8ab09afff5fc171348c9da04298e929bef7c3d15e8b40dcc6046337ca4e725704f513c2e84286e67f8b7b05" + "0xf86481ff088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0096dbe957c596a1274724cb8a26e91c4d0a5988acc6c4d71663631e2003c975ea06a37dd9cbf388aed02bc4c4798716068e9b5fff60f5f663a38846d109746fba9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6905,21 +6960,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xecdbfed50e09e8bea9b23b0c056b9ef72bd724fd104590fdccfed99e26401a78", + "parentHash": "0xf12671c7915ba944f549618aa1a618c58890d1bb1374ba0d5bfe9a1d219d4e10", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd3d3012407a941194dba4e6a98cf30f376facbea5142628a3ea5606967259d43", - "receiptsRoot": "0x4c08bb651446370eb08574678f4868ba4e705afaf09438505c2ec10b6fd39ace", + "stateRoot": "0x5cea96ea8b8dd8cc17ea87b5d131fee80c3508fd9b4f15fd00b1fa0df6fbaf7c", + "receiptsRoot": "0x79bd13afbabf9625dc7470703ed2e7c638bf975d014e2cadd1a11155a50a7008", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000008", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xdb", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x88e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfa439516704748050ea45b059aad351048e40ae85f495fd0ec4e77c34a02325f", + "blockHash": "0x2cc973d866118aeeb5d5a45bbda5f59f56d1824d01605eff38bde4ba082a2953", "transactions": [ - "0x01f8d2870c72dd9d5e883e81c908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cce282565ecdd5bc9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a081607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa501a0c3c70831d5587c9351e2459dd471faf12422892116d4c8d42b9a63243d9606d9a07300a31913c6ee1498e1f4eb9bf30503ccfe418b0d48dcbd01ab9cd342882f65" + "0x02f8d4870c72dd9d5e883e8201000108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cce282565ecdd5bc9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a081607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa501a043097c04f7681d47ec224343d8a8a5558814dfb7460a998cf76d8391d00b8a2fa067abff87ca6315bce87430aa9c8d8e1996fbe1cd7723f494253354e33f755e88" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -6936,29 +6991,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfa439516704748050ea45b059aad351048e40ae85f495fd0ec4e77c34a02325f", + "parentHash": "0x2cc973d866118aeeb5d5a45bbda5f59f56d1824d01605eff38bde4ba082a2953", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa9888352cf098a936c7ca1bd6dcf29c67a1269911598a3ad2532349bc1878095", - "receiptsRoot": "0xae08072b6df3427088c5c0fe33f7d710b6536f08bcbd142288632314b8757901", + "stateRoot": "0xbca1b202e9a17426e5ae61f7ad2d3b503b2180cde0e6736b34e3d818d1fd6e78", + "receiptsRoot": "0x19a448cfeccf7b829cf2af44a4c5575f12b2872abf24705826ec1f2523284bc4", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000804000000000000200000000000000000000000000002000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xdc", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x898", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8967b48c91a9a3ac039752dc1b0b5c091e38b28635f934949604b9ad0e2017e9", + "blockHash": "0x633313f0428dac31c59a736f610f5da75f22d0c2ea8d112987c918c7405c0440", "transactions": [ - "0x03f8f9870c72dd9d5e883e81ca0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c7c3a8ef48b3cebe9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a051c209d8f78486a77a18312b2a8d08bb75d4a5add1c8499c9683a1a798bd9da7a00faf9bffc5ebaa9f6e1a348321daaabcd83479aa3e844d01d583a4d1a5595030" + "0x01f8d3870c72dd9d5e883e82010108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7c3a8ef48b3cebe9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b01a00174c0a739a6f4744c6590a84c6b65616b2fc9e9d61747c29f63a30fd16a35ffa0403d478c44f9fad1dd7ff6e514a211e095cbfd97d880f6ba65248f8069928fd3" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x36e90abacae8fbe712658e705ac28fa9d00118ef55fe56ea893633680147148a", [] ] @@ -6969,27 +7022,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8967b48c91a9a3ac039752dc1b0b5c091e38b28635f934949604b9ad0e2017e9", + "parentHash": "0x633313f0428dac31c59a736f610f5da75f22d0c2ea8d112987c918c7405c0440", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0103e3b78da1bc9f87e6c73115cca698b429eff7aba71492f1f64d551a56a857", - "receiptsRoot": "0x058846f9ac88fafd60b7a79014917afcf9b3015dc0f98a5aa3ab58700bc35cf1", + "stateRoot": "0xff3498c0882d17bdde653eac3785d898e6799bab863447e537a4baa61425e6d1", + "receiptsRoot": "0xf791bb85f6463471b2e9f6760696edbaa8ce005016d56e8455620c102a85f97d", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000020002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xdd", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x8a2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4a6fe8bfb3d8209f060b20fd83362433e87e45b6059450ecd92207e5bb4bbdad", + "blockHash": "0xab9619afd1e6619dbab5761d6fc5da9a0fbf8b6489fb96eb864e687bbce7952a", "transactions": [ - "0xf87481cb08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf2b2ffddc2dde581656d69748718e5bb3abd10a0a020d836af511621c71c81861e9c0f57225cfd85e18ec6b35ed22a285e3b51f8e2a03d6ee47e8e5d7d5b239153906a7129278cae4941edc1d80ee1116e56c9a4c7e3" + "0x03f8fa870c72dd9d5e883e8201020108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cf2b2ffddc2dde581656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a08a38792846734575025e5114061b62006064b0636caf6733294eb26895bda2ac83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a02abcc99a781c0f7361e7f522a801f831348da0a9fb22421d11c76c9d49a0e431a07acf8b832d0171a0227738295de6d5854861e05a321660d2470ac9a3c50fe41d" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x164177f08412f7e294fae37457d238c4dd76775263e2c7c9f39e8a7ceca9028a", [] ] @@ -7000,21 +7055,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4a6fe8bfb3d8209f060b20fd83362433e87e45b6059450ecd92207e5bb4bbdad", + "parentHash": "0xab9619afd1e6619dbab5761d6fc5da9a0fbf8b6489fb96eb864e687bbce7952a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x01cb1e199169e38b74db5252fd7c4e85a1c3c434cd4ee9175f41923b28317d41", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcd03023d5fd58e2b8d999c16360f778338eac694840dcb6adcc8f90a0c849192", + "receiptsRoot": "0xafd49c477f051880c7aa55ee362f5bbb56c937b1404f08f5c35e3ca9fbf5c734", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000200000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xde", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x8ac", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x58f4f818948eb949af6ebbe9c9922a6742c45eb6c60cc272027488d0d0fb8207", + "blockHash": "0x827cf63f6f1bfebc2c18dc37c641eb9038174492ce580fc881027cbd447dde09", "transactions": [ - "0x02f86a870c72dd9d5e883e81cc0108825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c001a033bfa67c45c7321f9c73581990967d07c95309544419108b403b1872567fc5c5a02f15eb8aeff6e7295cd5a48666b0db706fe17c02d590d4a29ec041af67aef794" + "0xf87582010308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cabe108b68cb3921a656d69748718e5bb3abd109fa0c0a89bb8e4d7ad8bd04b96d0d7be1ffb0fa0b3708e941779034f8b7fc0e8224fa04e995d47759a912b21e632b3efae2104ed0946a2da7e32135db5df622ef33c0b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7031,21 +7086,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x58f4f818948eb949af6ebbe9c9922a6742c45eb6c60cc272027488d0d0fb8207", + "parentHash": "0x827cf63f6f1bfebc2c18dc37c641eb9038174492ce580fc881027cbd447dde09", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6321fb11cded8d0f04d07ae0cd09591a76b1f645051ff9c38c8482c5c5a734ed", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x5e23c4e8ec85e768ad515d8ad0f274fdfc0e2db2a98a4f7726859680a78cb337", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xdf", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x8b6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x75150cd02c717d33df03986668fca9287fa715ae9b3dc786e9a012689cbb4f2b", + "blockHash": "0x17c4a736b0ea52a0a4f64166d211b654d10c8a6b316b7a3d151c84f1afbe2cfc", "transactions": [ - "0x01f869870c72dd9d5e883e81cd0882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c080a0e4c3a90362ec63060f76c892b83612c948dfdd1de2737c2239a052597e8284eda01411079de57054dba22fbf68440b0532614dda48338f16aba134c921308f3c58" + "0x02f86b870c72dd9d5e883e820104010882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c001a02c4661994899245f1f7161c24e6476e42cf57379598cb20cc7a08b75a1673672a0377e496dd0113a554708d7c43244625559fab193cf18ee3b3edae331f9f8deb9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7062,21 +7117,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x75150cd02c717d33df03986668fca9287fa715ae9b3dc786e9a012689cbb4f2b", + "parentHash": "0x17c4a736b0ea52a0a4f64166d211b654d10c8a6b316b7a3d151c84f1afbe2cfc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xed039258f8abcd18b3eb25a20c2ed8798ce6dbcfd9cc3220a5e611a886388d40", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xc4d5ad6932daaf18ca694faec40edc097895ddef0909be79e3231f30ab039e3f", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe0", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x8c0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4b087119094ef790b1981596fe9adfed930802ffbf33a9b5f91cf06b36aac5cf", + "blockHash": "0xc7d92e27e6635446bbbf148991143322dfee51d0c6923abdfe69a9661aa51f3f", "transactions": [ - "0xf86781ce0882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd10a0a0876a442f175fe09eeb195fa0a9bf7d7fd0b81017cf723c52d4e46a2d8d4c55fca07c3d774813ab31a2d4bb6f07267865be0d0dd7cf05512ff5ecc86c10532b696f" + "0x01f86a870c72dd9d5e883e8201050882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c080a0d097876d7e2f660c01f19ad07b26bd4fa4ff1f4e21ffce5ee20a63b39f59263da018f3047c40bc77768b6b81ec939400d56a4afb151403ad33686528bd7fb3dba9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7093,28 +7148,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4b087119094ef790b1981596fe9adfed930802ffbf33a9b5f91cf06b36aac5cf", + "parentHash": "0xc7d92e27e6635446bbbf148991143322dfee51d0c6923abdfe69a9661aa51f3f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfb1c2e225033ea79370ea89f66289c2fe60fcad15cc0cc2f0e44b0f538540c6d", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xf5fe34d46eb9d7c1429d565d8aadcc47fdcd088720899bcfd735ec4c9fb46ddf", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe1", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x8ca", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf7c7c5456af3ba05c94cd1d23c70ac90ea4b79b78e561045c649b08bfdaae321", - "transactions": [], - "withdrawals": [ - { - "index": "0x13", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } + "blockHash": "0x7fd92767aad5a519ab7a1ee8f06e62a0869042dfaf4aba3b9e47037667137147", + "transactions": [ + "0xf86882010608825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd109fa0ec1d50950b085d1abcd0edad527bc1dd6896a4ef8008a5b05bfeddcd4c86a664a01872d9a9283c4a11e2e017b5f22919b71f12a25480aa6a20b862ec014bb7f794" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -7129,23 +7179,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf7c7c5456af3ba05c94cd1d23c70ac90ea4b79b78e561045c649b08bfdaae321", + "parentHash": "0x7fd92767aad5a519ab7a1ee8f06e62a0869042dfaf4aba3b9e47037667137147", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x52e80785d861bf8a6cc6be5dd4bfc993448cbcf27df9a3eeaca02e933e60b0fd", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x1dde1f32d73de2474f924f4693731db2140ff9b6b686a42f873d48147020847d", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe2", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x8d4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x918ae7ac657fc84fc8cb10dcb3794f22ee74635bc3c48a09447f82525c8b4cff", - "transactions": [ - "0xf88281cf088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0d9bd9ba3bc4d8d9712cf4f58d49cd71c1e9d160c4283af86642828cb29a86881a078ed288cdb8c0bb6c587538b05a2960ac5dbbe5372a6d4a30c415455279b6123" + "blockHash": "0x508e549615fc6041f7c0737e69a19b2a78954a3b2e401c1e6cdfcd065f591170", + "transactions": [], + "withdrawals": [ + { + "index": "0x13", + "validatorIndex": "0x5", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -7160,21 +7215,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x918ae7ac657fc84fc8cb10dcb3794f22ee74635bc3c48a09447f82525c8b4cff", + "parentHash": "0x508e549615fc6041f7c0737e69a19b2a78954a3b2e401c1e6cdfcd065f591170", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7f06aab010cf4664949f79c5df9ee9b20994444245a8c62f7c284d9947303dd1", - "receiptsRoot": "0xf6c2782752ebf597acafad6abf0e6202a2eb97b2ec68517799c69bacf47d86d9", - "logsBloom": "0x00000000000000000000000000000000000010000001000000000000000000000000000000000000000000000000000200000000000000000040001000000800800008000000000804440000002000000000080000000004000000000000000000000004000020000000000000000200000000000000000002000800000000000000000000000002000000000000000000000000000000000000000080000000000000000000000001000000000000000000000000024000000000000000000001020000000000000000000000000020000000000000000000000100000000000000000080000000000000000000000000000000000000000080000000000600", + "stateRoot": "0xda7bf74c9af8065830e837aa77b89ef9403692755ea65faab697c9ec7960a65e", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe3", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x8de", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb77cf24f0c1fb354f7bf7c80e1804fdc2328774a1af50eb7959a46a8fe51a590", + "blockHash": "0x380fa604fda76b136b8d0cd29fdd1d4d947c90d328e70679c89d25fd46e30e20", "transactions": [ - "0xf87981d00883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa098f00f0dd1331f7d9de3cf956fe0464b2e0984cc2262b81128a7507572839978a0561657f3d9e0be3d34aaa3b6087cb9055eae540180ea81358be1c7d9cf1a3be8" + "0xf883820107088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a05dd8a8d661cd961e55957d672db81e05101fa822f0ac004ed49853a86071caeca03f56576f78f77226deb6a1e429a9ee442ae7b1d46881779f7cf9845425248784" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7191,21 +7246,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb77cf24f0c1fb354f7bf7c80e1804fdc2328774a1af50eb7959a46a8fe51a590", + "parentHash": "0x380fa604fda76b136b8d0cd29fdd1d4d947c90d328e70679c89d25fd46e30e20", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaaa416970b533c6a6842c7930d502904027f76a8f862dd7bf57e1b7010960dfe", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x0249e268841392bf9fdaf916572f800d9af3df2c6aa664a747e49af6424d19af", + "receiptsRoot": "0xd70a5525f8fbf21175efafcb9acbda1a8d48b1896bd4cf23a8d6c1474c59457d", + "logsBloom": "0x00000001000000000010000000080000000000000000000000000008200000004000002080000001000000000000000000010000000000080000000000000000000000000001800000000000000000000000000000000000000000000000000b00000200000000000000000000200000000000200001400000000400100000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000800000000000000000000000000000000000000000000000020000000010000080000000000000114000000000000000000000040000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe4", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x8e8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb3317abdbcc0bdc256a422a5c333572f99ff8651f095922cdd5b995b44185a49", + "blockHash": "0xa3e71744d3faa5f9827963a5f0d659487a2d102a538122e75395ec771100c68c", "transactions": [ - "0xf86481d1088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a04569e675422075ad4ebd160dd8022e55321509fdbe93f360b3bd35db8104400aa054a06595c32949d3b1baa931e20ca03839c15311c83489df49a9edd73ff409ef" + "0xf87a8201080883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a039291e6b998bc1d7a27a5cceb0045691058a4e921bb821d41618e742e432d66ca05a2a31d95742ffe4689a40e948e01edf3c6e75aa38b4bf8cec5f2445058fdcce" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7222,21 +7277,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb3317abdbcc0bdc256a422a5c333572f99ff8651f095922cdd5b995b44185a49", + "parentHash": "0xa3e71744d3faa5f9827963a5f0d659487a2d102a538122e75395ec771100c68c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8a5e1328b9170468421131678aff4a27c60534242f9ab63212e3b38fa255a58e", - "receiptsRoot": "0xb75a29ffc033968354f87e14e356ca2f90c49c9f3bcbc6224261c048498afe00", - "logsBloom": "0x00000000004000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000", + "stateRoot": "0x2af21bb17b0fef2cfd313f9c6cd140bbea1d7890d5ddcec58ea0463936302c7b", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe5", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x8f2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3958180bd85edf4b17cf80881d40b68216a23a2dbadb92fff52757661070ec35", + "blockHash": "0xcf2f9ba00e585e8346fe60f6bd23d83f81f57b272f3d7ee803aec61e3b66973e", "transactions": [ - "0x02f8d3870c72dd9d5e883e81d20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c15314adb38ad874e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0782a285a3a645a32202a71e713e4a813bbaef9f50ce10e4caa0122c110d86bf680a0524664d3bd0879e248a9ec4a8e1caaba5d51a5d50eb6bb9899be1c2b712a0b69a03df458a145f697af315e747b3dfc8fe53920ba921a5447a7313ee7bfeb3a125d" + "0xf865820109088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa089f115b1426cd5610145d87fc9df3c7dd27f55689e7cecb967bf1a5f88dc7d06a00bccc3cc4a1b7dcfbef0ae543a7ddeb2f131308635a3fb752b37c41506e23f44" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7253,21 +7308,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3958180bd85edf4b17cf80881d40b68216a23a2dbadb92fff52757661070ec35", + "parentHash": "0xcf2f9ba00e585e8346fe60f6bd23d83f81f57b272f3d7ee803aec61e3b66973e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x31ccb550a59d99bfada2947f48481c5fb19963be2aa56fbb37f6b2f9da6115f8", - "receiptsRoot": "0x16b250651438c816ab67a4cf2fd473107a4b1bff0fff288d1f48d8cabd8267d0", + "stateRoot": "0xe1f9b9144e9dc8182d6530aec489863d8509ca6ebc136ae0c15e73acf9a44238", + "receiptsRoot": "0x59e63920eb582c6c1ae19664c57b68675b05075e549bdd56ac27d2fa7cdbe3b7", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000080000000000004000000000000200000000000000000000002000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe6", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x8fc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb1503e5b89008f2ec7cf91492da840a6786f020d11cd33a8ebfd68ee824313ea", + "blockHash": "0x66730b682308530fd5172418ae2100a58c0c78d8e2a4cf3962f74bb5d08a2ad1", "transactions": [ - "0x01f8d2870c72dd9d5e883e81d308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf92aa615f9b4e91c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a680a0d5a6eaf83827edf2c33a97e9909dd47f64e6bac6ab6b343e840f8897df4e5b6aa02999286ada33637076dfc36acb4718a034bcab145843cc4d76eb1895ad8eb5ab" + "0x02f8d4870c72dd9d5e883e82010a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf92aa615f9b4e91c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a601a061ff9c4feac16a7f8ecc5df8c184e1ef1335cd485373081b0943d8e665386fc5a06351a12031ab5030ccd9e74fc17f06a4af327e4cd75dc5b96a3e9171ab461d3f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7284,29 +7339,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb1503e5b89008f2ec7cf91492da840a6786f020d11cd33a8ebfd68ee824313ea", + "parentHash": "0x66730b682308530fd5172418ae2100a58c0c78d8e2a4cf3962f74bb5d08a2ad1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3df027b36c56a135b888b77de630950a40e69281e5be0eaddcec18db6afcbb16", - "receiptsRoot": "0x105f1535835d30dc0d749e0d4cb7d0c3d18e64e74e8f7e158695ce6d057d241f", + "stateRoot": "0xcc8af6749e2ed26a08d6095101170bd336ab1a8a6e62ce01f24b780811d0efc0", + "receiptsRoot": "0xc37260f445c9b53c029d62d3d2158e5afe0f66f526fcd9a27b46710027e6f483", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000080000000000000000001000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe7", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x906", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x74b7c334b7e246ba4cbdb9a91cf69bf72a3491ca4e39c2cda81e39c080bbe720", + "blockHash": "0x4138427f2aaf856de7604cae4193f96636c73e0a8984e967f88eeb9cb9868235", "transactions": [ - "0x03f8f9870c72dd9d5e883e81d40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca7b2474c2b69133f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a018fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b5683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0b4c11de109225403f2ed87e63a7eef36369da1db9fcf5fa469ad526bd948cee2a01ec6b85c41b4cc079ea1804ef0f7343edb57a71780fecdf5897b0285e2889788" + "0x01f8d3870c72dd9d5e883e82010b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca7b2474c2b69133f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a018fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b5680a00de88175878b02e140c2e76f3fa2c6ea350b2115fb956aa96f8918d227fae23da072ce3850569847f9c6bd3b6a1ffc680c759e67b96690fa87308b5ab1a234fb0f" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xb52bb578e25d833410fcca7aa6f35f79844537361a43192dce8dcbc72d15e09b", [] ] @@ -7317,27 +7370,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x74b7c334b7e246ba4cbdb9a91cf69bf72a3491ca4e39c2cda81e39c080bbe720", + "parentHash": "0x4138427f2aaf856de7604cae4193f96636c73e0a8984e967f88eeb9cb9868235", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfa9de399a80e099e176e71ab4c1a0d628e21f1ebe37a100858b3ea6c1996f0fc", - "receiptsRoot": "0x95482d5c3c390e57fab959a9832bc6e46f7cc877207ccea7fbf81eab51318fa5", + "stateRoot": "0x7d4a41062a1ebaf74eb039e9ca60cfa45e8690a27384180f36064472aefec560", + "receiptsRoot": "0xa3f96ff7d0b57b15707ad579b78988215c35c11d442ec707893281de3dcb9b8e", "logsBloom": "0x00000000000002000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe8", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x910", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5e06576f385d64e5475da19a55db8a1b49a905e54cdd00bc833f9a6e0d1821de", + "blockHash": "0xff6c572142173aee3cce05872637e9fa20576e126122f8f096b26c2d7ab562ca", "transactions": [ - "0xf87481d508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca3b82995153488b2656d69748718e5bb3abd10a0a07eae71aefd59e673c777592dc069c9500c2c9cbef7d64fada0a7f34516c5b29aa048780b89098362f47f20ebeb192901c96db681450badc981a2e3fe0266bad08d" + "0x03f8fa870c72dd9d5e883e82010c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca3b82995153488b2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e70ed54757ba10a0b95454f6483d3d2e11613828f13d57d50b8a3a98e2c8df1c83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0c60e26947a2dbf98447511e72332b2ca362b880fea4fb64fc03462b11b4ba092a038d4b9510bfef9146677f146fc8a1b3c5bc614e54ad5d9a4d6b4d2399cfbeb8b" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xff8f6f17c0f6d208d27dd8b9147586037086b70baf4f70c3629e73f8f053d34f", [] ] @@ -7348,21 +7403,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5e06576f385d64e5475da19a55db8a1b49a905e54cdd00bc833f9a6e0d1821de", + "parentHash": "0xff6c572142173aee3cce05872637e9fa20576e126122f8f096b26c2d7ab562ca", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x21f8e87041249c1ba465194c8b715ef58ec364a0b6018f13d524156bd563f74d", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xf80c6c2a65d77db9477b6f676680863460670fa7046e68e566a4ff9a7306f4cf", + "receiptsRoot": "0x647efb03cf0003f7b38e68d1ecc9fb1c211ce88915481adcdf5d3fb6d8c81eda", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000100000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000009000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xe9", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x91a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcdf017d14aa10cc174c1f3f7d597eb085f52da7793e92fd8f84f0032009962df", + "blockHash": "0xfc3daf2feab4448c624c2b6de75cee4ba8555bfedb236a6dabd08625ee75fb8a", "transactions": [ - "0x02f86a870c72dd9d5e883e81d60108825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c001a09f04acf081827c526e799759177320566ce80aeb5f40c64bb24fe9636c8de9c2a007126608b53aa815dd075c43c20ff4f8da9bab03923fe2c03f847260ea95617e" + "0xf87582010d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5bf69af19e2c4d7e656d69748718e5bb3abd109fa0c2503c301bf0681ea966f102db7699fa826963b8df17a946954326bb0cb6dbada037aa73c91078f86f187d56b09ef9d2ea8f48db84166ec5c49e78f78fb5ef6e43" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7379,21 +7434,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcdf017d14aa10cc174c1f3f7d597eb085f52da7793e92fd8f84f0032009962df", + "parentHash": "0xfc3daf2feab4448c624c2b6de75cee4ba8555bfedb236a6dabd08625ee75fb8a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1b33f7de0c2d5985d1b09d684947d984700f244819f685a91cb0cc45ee4724a1", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x3285403b266677669b7500a603d1554194888122e7bc7184693687023540b695", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xea", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x924", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd85b3616680a40d04d64e6ee0d1b0dfbf1967634ca82b0a38be88513a556fce6", + "blockHash": "0x56a716225b0c189b6dfe04eb8dd9012e50bab4fde5c850b3ac032b0bb74c5916", "transactions": [ - "0x01f869870c72dd9d5e883e81d708825208940c2c51a0990aee1d73c1228de1586883415575080180c080a0b74bdf8180bf53defa1de1178eab5ee3390868af0c625f4cd9c5e90703326318a03e4b8d27029ff92f18b8c5c9a11edf7a4656513af34736fc8d518ba7b793716e" + "0x02f86b870c72dd9d5e883e82010e0108825208940c2c51a0990aee1d73c1228de1586883415575080180c080a033a4673c9a8472f5a5ccc2a5de380f0fda913f9862c1586db4ec85045104f242a075d9175ffec2c56075f9656daedf1326c52ee8a96ba5d77be995fa8546bcd89f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7410,21 +7465,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd85b3616680a40d04d64e6ee0d1b0dfbf1967634ca82b0a38be88513a556fce6", + "parentHash": "0x56a716225b0c189b6dfe04eb8dd9012e50bab4fde5c850b3ac032b0bb74c5916", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x35abc62183846924a22493fc22e165f8cc0b1a6d6cc11ec9150956b8b671a995", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x989911af2991818b56381d69809f0899154d0bc06c90160a4b7cc170e484b53c", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xeb", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x92e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xaeb7dd5da8baa32aeb4a33f9d87914815fa0c941f5bc08e595d4e37bfdae7025", + "blockHash": "0x5fb1bbafb479d9b6bb8f0d6a832717b2d585af05d70edc9938597e9c349ccb1e", "transactions": [ - "0xf86781d808825208945f552da00dfb4d3749d9e62dcee3c918855a86a001808718e5bb3abd10a0a077b27af56bab269e10d8c4120c827ea8a6e267e410dcc43f940ccb21aaf725aca055f4af3cb45acc78c5dd2ee9025229ea3c52dd746f032ca0f6e892ee1bb7aa39" + "0x01f86a870c72dd9d5e883e82010f08825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a06453186f6a9c55fb36454e34d41c27d13fc0049f5af658fa7490cc8362744190a0504fbaa0f5e9507b29e006587d014651b19bf2dcb8218e14d965236d548ffb39" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7441,28 +7496,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xaeb7dd5da8baa32aeb4a33f9d87914815fa0c941f5bc08e595d4e37bfdae7025", + "parentHash": "0x5fb1bbafb479d9b6bb8f0d6a832717b2d585af05d70edc9938597e9c349ccb1e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xae24678714258a0678a642f2019faee2b2a60be135f63c7216c65f266ffaa8d8", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xe584cc11999a6c0160d771fcdd009ca6d340893ec577572315234fc2c8f5bce8", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xec", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x938", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd522a23cf0118178de9b0c94528f7161fa5f0e0c954ff141d86f7335fbed4276", - "transactions": [], - "withdrawals": [ - { - "index": "0x14", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } + "blockHash": "0x520f6482328ec8e1a2d2f759d3718f9527046b4eec351d127b4d10920ae7c02c", + "transactions": [ + "0xf8688201100882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d01808718e5bb3abd10a0a03b970b860fc60d5aee40e41743c1eb009255cf8bf7c82dd12f64d675ff24c7f0a06a08d813a4649df981fa4e95c1e425514989b0cc86c10bf5fc46ae9d7530836a" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -7477,23 +7527,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd522a23cf0118178de9b0c94528f7161fa5f0e0c954ff141d86f7335fbed4276", + "parentHash": "0x520f6482328ec8e1a2d2f759d3718f9527046b4eec351d127b4d10920ae7c02c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x98514467ea14630203e7f8752b2861b363ad510a1795389c5257082298d0c6f3", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x90aa516f7634bde1bc39f6e1544693038238b3788c5fd7ec5caf70979bdef707", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xed", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x942", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc24d834bba0307acaf2621819d979f535f972358a557d008cdd4374d6d7279e4", - "transactions": [ - "0xf88281d9088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0675450801a9ff0ba52e0d0c6a9919e99ee02fbcc1f777c783a3a1f458e376ecea0114e5fe0b93d270f3d78915b9fb62e9f640b7024db11cfa38e879ccbff473605" + "blockHash": "0x89d7de3b3cc3f788c75f502ad3c5194de01d53e6d01675bb8e7319084bb044e8", + "transactions": [], + "withdrawals": [ + { + "index": "0x14", + "validatorIndex": "0x5", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -7508,21 +7563,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc24d834bba0307acaf2621819d979f535f972358a557d008cdd4374d6d7279e4", + "parentHash": "0x89d7de3b3cc3f788c75f502ad3c5194de01d53e6d01675bb8e7319084bb044e8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7e34cffa4512765540682e386ccecb352c2939095d4c0705a98e87ce3c50b9da", - "receiptsRoot": "0x0982027ef8748748f3f43f93d29f704d942455b23d272ef229e30020ec561a98", - "logsBloom": "0x00000040000000001000000000008000000000000000200000200000000000000000008000000000000000020000000040000000000000000002000004000000000000000000000000000000000000000000000000000080000000000000001000000000000000000400000000000000000000000000000000000000000000000880000000000400002000000040000000000400000000000000000810000100000000000080000000000000080000000000000001000000000000000000000000000000080000002000000000000010000000000000000010000000000000002000000000800000000400000000000000000000080000000000000000000000", + "stateRoot": "0xe80483c4ed93170ee2a52821d16553f4ec3b7423733606f1f76c8737ff6f1b9b", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xee", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x94c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbc7ccdf6cbccc29bfcb63055c8f06b26648f3b719434b29a74a477466fefaa5e", + "blockHash": "0xea6c0f8842754decf0722e63340f9ce8fbe8d0ad696225c4942eeff7c815cfe3", "transactions": [ - "0xf87981da0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0d59a28faa98ddfa84972f7929fbec44330a628fb5bef71f778cebfd935bcaee3a02cd31b98758b8b921a23dc0e8499be4f6ea77c1ebbe2bf67957b699af942e6c5" + "0xf883820111088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa02c77f1a00ffa8149181fe59b1219dcd106642312194ffdfb0efa3a25b739d368a019af967d474a4d25721ef42b7fa0c41572a848efdb3bf8ef229836d07e0696c3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7539,21 +7594,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbc7ccdf6cbccc29bfcb63055c8f06b26648f3b719434b29a74a477466fefaa5e", + "parentHash": "0xea6c0f8842754decf0722e63340f9ce8fbe8d0ad696225c4942eeff7c815cfe3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbc99bcc1d52e9f4766e23368257dc9c64781b15b59232171c60c4115dce203d4", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x37054ed1d4de8936d6b6d8309d87835e891d4cb7d403664cbff23ccfce00585d", + "receiptsRoot": "0xb3c76769874da188359ca338714937e0ae1586a0b69cea7a88db3f231f9c245e", + "logsBloom": "0x00800000000000001000000000000000000000100000000000000004400000008000000002410000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000800000000000000000000000000002000000000000000000000000000000000000002000000000004400000000000000000100000800000000000000000000040000000000004000000000000000001000200000000000000000000000000000040000000000000000000000800000000000000000000008401040000000080000000000000000000008040000040000000020000000000000000000000000000000200000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xef", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x956", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x84f81fe1c154c744c26786ae33b6ace4bc6e4e9318fd57b03a61e9d18ca64711", + "blockHash": "0xff641c571c4ee7c6ad4776d9e6a619e15a9e9c68173a576adeb39a4d6b7cbcf4", "transactions": [ - "0xf86481db088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0c22c5f39061382a2ef0994d92c08dfcb184e64bbda5c809b7e9105ead307a742a053e1ea72ec9869938790b2d96b105f7b39db6b423cf370074474e16385b45f5c" + "0xf87a8201120883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a082a80eca863ae9c64748a354a84f40290916bcaf8413792b21b3424378e6228ca03d390881b2d45d2465a2b5d4c3544cec5f43ecda93ad6c960cfa291fcaad51eb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7570,21 +7625,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x84f81fe1c154c744c26786ae33b6ace4bc6e4e9318fd57b03a61e9d18ca64711", + "parentHash": "0xff641c571c4ee7c6ad4776d9e6a619e15a9e9c68173a576adeb39a4d6b7cbcf4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7a68d970418201b546fd51691c989867e1c29978eea373e2375bb60b385ce4a9", - "receiptsRoot": "0x627ec21f4de1c579315e005c05b00e19d0186ecbc6377fb85a68878fe8079cd5", - "logsBloom": "0x00000020000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000020200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x8c068ec1861153736ce04d560c6cf63b729d008c9e5c4156b8b8b4351b53577b", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf0", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x960", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xca2b42e197de583b704164d6db489ec43fe7394d38dd8a5752be70f52854ca58", + "blockHash": "0xc0c2d5bded8a29c205781c8126d07498355257ffe0b0a9c63513891158703356", "transactions": [ - "0x02f8d3870c72dd9d5e883e81dc0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd9b3346dfd0e60ce656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a044dc9099d91b074b843002013672df4de9f691cf60546fa74eccafa9044a75a280a08e839541f45f093117f75e17bb6c5d90e060d95d635df5e508df75ae4ea15d02a04a37a82b8fb0d5c28bd196c2dff563b98943f4c294be797f927a9f20c4f93eb6" + "0xf865820113088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a03ea334e2aa8e74511ed0ad87fcda79a9f680ae5812f88a13df8fbf5f7230c27aa054c5cc729b1ef1167f035aed984cd1aeb394e725797757c42b96bcf3285aff08" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7601,21 +7656,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xca2b42e197de583b704164d6db489ec43fe7394d38dd8a5752be70f52854ca58", + "parentHash": "0xc0c2d5bded8a29c205781c8126d07498355257ffe0b0a9c63513891158703356", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9693fa6d1b00303f873a8ad1471a142a790f8b6306e0f1ca9e3f3cdc799f5f33", - "receiptsRoot": "0x776bbccca0cbbdb94db3be7cbb0d3ed277ade8c66c9e4f0cd3b5375ef26cb454", + "stateRoot": "0x7f1e0aba7bde42d7d8cdfc2d10067e723053ab75fba529a996072e3be4e3026a", + "receiptsRoot": "0xdb3d7500cd8c087e3a0392bf0fa606dcdd10b495faddc3e157febe381694bf58", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000080000000000000000400000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf1", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x96a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa09abb195168c21894826ccd65fa0c8549eb923a5b399c62cf9fd1011c465b69", + "blockHash": "0xaee5da2562edc43aae63fdbfcc1ed4a3b9584d31b515a14b6c9e974cbdb8dd29", "transactions": [ - "0x01f8d2870c72dd9d5e883e81dd08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c420286a1fdfc0e5e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a040c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b8193880a095c62361aa8837bc1855c305ba620d2626ab06fa3c0f9e53e15a2514a9107b51a0338b0de9a2eae1aa2a4ab316146123ec3c5c186cfca763aec26070ce1b9fccb5" + "0x02f8d4870c72dd9d5e883e8201140108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c420286a1fdfc0e5e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a040c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b8193880a0963c43efda9e42fb6774a28c7f5e012114afdd0681d067b1b6caf587004146e5a00c0e598f93f2345166df6807de074860ae1776148f8391bf32e32ffd519614ee" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7632,29 +7687,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa09abb195168c21894826ccd65fa0c8549eb923a5b399c62cf9fd1011c465b69", + "parentHash": "0xaee5da2562edc43aae63fdbfcc1ed4a3b9584d31b515a14b6c9e974cbdb8dd29", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8eebf0393ed59ddc4859f5692ade88d664163044283c2fccf142ea9ae3506833", - "receiptsRoot": "0xf3febfa0beb41ed1c3b2dde301a1af4a1900ac13bc37322396ba28a3a0809745", + "stateRoot": "0x0b4814aeab2857f64293c7da4c2d9ad9e1ccbde78f61c37ec905a83812e42357", + "receiptsRoot": "0x57bab588deeaa419da929e4a6d21f5823ffae41492db9abc935466c941655403", "logsBloom": "0x00000000000000000000000000000000000000000000000000002000800000000000000000000000000000000000000000000000000000000000000020000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf2", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x974", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb4020e4b07dcf86bae80b8743a2ea666f6f3d45a5df2284109c25d7f51609ec5", + "blockHash": "0x6d56c50e850214cd81f339f0febfcb4874950f0a6e6c541f448c0dd83bbdec6a", "transactions": [ - "0x03f8f9870c72dd9d5e883e81de0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c7071be300963ff92656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d8346383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a04f7d0bf8f16c7a0e75ce26ac545d0d575ff7f413e2a16e5027afb8a5c4b7f26fa063e8202466a1dfe963f6db436894e47e6eb7e0098800e35cfc1d5254af2077eb" + "0x01f8d3870c72dd9d5e883e82011508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7071be300963ff92656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d8346380a00e7186da492612df60948da5e541d1ce2857a85ad3ea9f07865c9397ade6ffe8a0617e8bb930030a03d25a1b5f1f07b373d9356259d0eea3480deb3c7826d49961" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xd3e7d679c0d232629818cbb94251c24797ce36dd2a45dbe8c77a6a345231c3b3", [] ] @@ -7665,27 +7718,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb4020e4b07dcf86bae80b8743a2ea666f6f3d45a5df2284109c25d7f51609ec5", + "parentHash": "0x6d56c50e850214cd81f339f0febfcb4874950f0a6e6c541f448c0dd83bbdec6a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa268f440925802a0673a23ed9f85bbc06c22f5d2500ce472b384aea395f774d4", - "receiptsRoot": "0xd7f23872614f396dbd94d6ba150b6ef7539f1428c8df485d79def87a8a0785cb", + "stateRoot": "0x2b1e160783e5eff9abed73679a7ceacc0cdd2bd1ff00adec81b0ce03bd7acb2f", + "receiptsRoot": "0xc702b9e5bef54fbd359fb825b44e4b1edd30258116936c988dc9f756d035bd48", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000400000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf3", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x97e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x787fcaaf148ba19e63da9cd7d513303b2e8565baf64c4c28680996276e57c93c", + "blockHash": "0xa0e695a82a49373c16acf2ecbd742c53ea37cadecc6dfd681e6b393bdca6c445", "transactions": [ - "0xf87481df08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3389deedf755957b656d69748718e5bb3abd109fa01e50b3cb9c04e70ceb18374d66620c5441f9e5f23971bbf4e0176d9a973b1137a05b14a56ab599e3f1344627bf3387e3ab72c6d4e34bdfae32c7ad88ee018969ec" + "0x03f8fa870c72dd9d5e883e8201160108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c3389deedf755957b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0427b8ffdff6454ea85c8251407144400ed4e693ffb6a74f319e0238c0e72afad83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a018196be640c0bacce391e26e900787177b20c087bc92aff6671faa5841174ea2a0197c06391e39c60ba885e840bbdcb01006afcffe27d34e85fdf7fd2e853d9f0e" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xd1835b94166e1856dddb6eaa1cfdcc6979193f2ff4541ab274738bd48072899c", [] ] @@ -7696,21 +7751,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x787fcaaf148ba19e63da9cd7d513303b2e8565baf64c4c28680996276e57c93c", + "parentHash": "0xa0e695a82a49373c16acf2ecbd742c53ea37cadecc6dfd681e6b393bdca6c445", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8940dfd9f8d3951b612ad8d6210ccf787fc72c21129453cda59091cec9e42459", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6aae432319fe437eaf4806252103b8df1111b0dd91815b058fa6affdebd3dbbe", + "receiptsRoot": "0x3f253895aade44a9a272ab90feac8bca59f9ef2c9182ecaff4708c0964c4e6ad", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000041000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf4", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x988", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9d81061f02d7bf9a3a57e1b2b291bbe6100fdd34168fcc324a3e4c360168a058", + "blockHash": "0xee14abc18ab909a3c3ff3afbccd5f0b3844727f10754428c44a7c8898f8343ad", "transactions": [ - "0x02f86a870c72dd9d5e883e81e001088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a03cb7b4f18d670562fe957a5f6ce00c3f4f472eb49b06bcdeb554183884eba2cfa017e043c09ffbab9304b2f96729fbeb6ffca00aab56a5bc5b27854eebc9642635" + "0xf87582011708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c328378d492d41023656d69748718e5bb3abd109fa062fa6a4169d9b7adfa4d6fa305c20b40b828bd2b35dc9bc5d8f69f0944618b9aa013f7457305014b59b83fdd28ac7d7d4de3578ad157e054d4295e42f8105fdf38" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7727,21 +7782,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9d81061f02d7bf9a3a57e1b2b291bbe6100fdd34168fcc324a3e4c360168a058", + "parentHash": "0xee14abc18ab909a3c3ff3afbccd5f0b3844727f10754428c44a7c8898f8343ad", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1216a69e570307973e76a594d89cda1e9e79f8d357d46aca9cba98aaaf0f3009", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x6df949a5989f2b5ae123a2cac652c30938649af91697084fc7393701137bbf4b", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf5", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x992", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x111ebb07018c6d7bf8df23b0454405dd991d7f8407d7c14f8bb86a0bd78032ac", + "blockHash": "0x5964eed483298c980e3372a7adab0e90ac671c5bb0fcb80e481a6fd533851ed6", "transactions": [ - "0x01f869870c72dd9d5e883e81e108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a09310fb7d3a437d4c9463094aaf7375a66a58cd9577c736f75bba7330f7fe4113a0145d516d95878524a261a4c34a9c4f0256f7701db03e6f4c5dd900306719fdb2" + "0x02f86b870c72dd9d5e883e8201180108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a02592d6e2ddf8518f5b4d3cb227432b4e799ae5bf0c54236e085790306350398ba013d79dbea43f805f839a8a7bfbb86da979de2f4116c57cec6c97152e3185a16b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7758,21 +7813,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x111ebb07018c6d7bf8df23b0454405dd991d7f8407d7c14f8bb86a0bd78032ac", + "parentHash": "0x5964eed483298c980e3372a7adab0e90ac671c5bb0fcb80e481a6fd533851ed6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xad350a4099570877c1704f074b19c5f3dcea56dca6c9e792016e2a56b379ee52", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x94dda996f1424b5b19de2493fd5feb565bc904e6d179a71ba684ccdc9a8e1c1a", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf6", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x99c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf0fff4c5758d8f5bc9e659c933b0267500c3dcd25916df0c0cd11f51a80057e4", + "blockHash": "0x9093cd0fdc936c5e1a1cde72e4327a8b042d0153d3b268b5441631496ab5b897", "transactions": [ - "0xf86781e208825208944dde844b71bcdf95512fb4dc94e84fb67b512ed801808718e5bb3abd10a0a0c74c4a0d4a72241c9d5837ddc4891eedc641596acc6d6b63ce03d98a10ac501aa0599e554c304a4d88ac4be7aa118b76dcc057fcbf2c4652ba0095f954f61e710a" + "0x01f86a870c72dd9d5e883e82011908825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c080a08f3c930c7a4ed0fc43ffe7cfbcbe0eaa913d2422265d09304e67af8fbd1d1edea07fa116f75eb5f7eb90fbd5ad2185a718c9b29da65dcfaddc62f4f1cf9b7b7b4f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7789,28 +7844,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf0fff4c5758d8f5bc9e659c933b0267500c3dcd25916df0c0cd11f51a80057e4", + "parentHash": "0x9093cd0fdc936c5e1a1cde72e4327a8b042d0153d3b268b5441631496ab5b897", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc27bc2d5cb669f6c51c6a5ff47e1c7636846e82c3a3ef76be73cdbf01577b022", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x50ba0b45c64457f53d8f17fd2973f72a7e154c9ac52412a3078e1c7fdd9cdb97", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf7", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x9a6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4063e7bd93501354cbef2184f7139559650a22eeca85d60bd62f4a468f2bd22c", - "transactions": [], - "withdrawals": [ - { - "index": "0x15", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } + "blockHash": "0x123f2c0202f5d919d2376513b9d5c5c9dceda4b91e6fd70f386d0d88ec067885", + "transactions": [ + "0xf86882011a0882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d01808718e5bb3abd109fa0f4d74436654fa222f1dcfe045bb2f56eeb9ed8d35c962ad79e3695dbf9c13d30a07fa1183cbcb7773b1c4084568a2ff4eba4a6ee2993ab4b293ead0c228e70b866" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -7825,23 +7875,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4063e7bd93501354cbef2184f7139559650a22eeca85d60bd62f4a468f2bd22c", + "parentHash": "0x123f2c0202f5d919d2376513b9d5c5c9dceda4b91e6fd70f386d0d88ec067885", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0991eed72783cbb17cb6cdbc85373e808feeb2134a1663c7b7356514635f4b9e", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x51896bacbfafd9c65c4bf4e5c828fe1dd91e2eeea39da7a1a31bdc2b7593f011", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf8", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x9b0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x161049c951eaacfafd5b046be03ee813c9a9a6d3167fe4591f75673f0ff5097a", - "transactions": [ - "0xf88281e3088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a018eea4cbb63e21a12b7091ab411cbfe92334a0cce67c4cb3d8e33e7c7d442ed9a07dc5c68241d131de386967a2cf4da3e73d483574b0fe5f3989423fb9ba522cb0" + "blockHash": "0x03599481645edb627d61df608525160e3ea5fc6081aa353bdd9828b21f314c63", + "transactions": [], + "withdrawals": [ + { + "index": "0x15", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -7856,21 +7911,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x161049c951eaacfafd5b046be03ee813c9a9a6d3167fe4591f75673f0ff5097a", + "parentHash": "0x03599481645edb627d61df608525160e3ea5fc6081aa353bdd9828b21f314c63", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x14b379a9fd456004e3447097b74c17d5142fa544a85caee69bd3f06e143746ad", - "receiptsRoot": "0xf4c9c04b70aac8e92168f4194367a03efb812d78ea2c1b88ff85f330e155d270", - "logsBloom": "0x04000000000000000000000000000000000000000000000008000000800800000000000000000001000000000000000000000000000000018000000000000000000200000000000200000000000200000000000800000000000080000000000000200000000000000000000000000000000000000000000000000000000000002080040000000110000000000000200000000000200004800000000000000008000000000200000000000000000000000000000020000000800000000000000000000000000000000000000040400000000000000000000000000000020000000000000000000000000000200000000000000000000000000000000000000040", + "stateRoot": "0x430d7fbc65b1a35ad32e5cb29b13911b47d226d8edd6a587086eea71c0c0838d", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xf9", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x9ba", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf10eb78649d3c7dccd8a00576e460bed3eedf5e1e9b94e96cd2cdcf11c4171e7", + "blockHash": "0xb70f87f8243cc700afc179251e201ce53395e86cb99d8f2de002488a632f765b", "transactions": [ - "0xf87981e40883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0401981fa89684c53c54fa7cac07db4b9adaa4fab50210204ce297bbd3893456aa055c506967e336b46424dd6adc093947469947f517a4101251f4dee49584f404a" + "0xf88382011b088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a084c8d41b9787a77274d53507c769d83f917f64b919e7a2424928c9959bbdbfafa06b83df98f1e5cc5e873ae9ac9207af7dbeb000786f40cc76083afd748d337c9e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7887,21 +7942,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf10eb78649d3c7dccd8a00576e460bed3eedf5e1e9b94e96cd2cdcf11c4171e7", + "parentHash": "0xb70f87f8243cc700afc179251e201ce53395e86cb99d8f2de002488a632f765b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x51e359714f3797b19f69d62e42532edc6e1a77905de51d5f71cb791a02fcaba7", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x7f49042388b1464946998060a0f422a3ae704bcb900166b6b531f95af7dde2ed", + "receiptsRoot": "0x0f107923c29a48b7014b6b5bb47237cd248821464a08db5f1d990d39f08c8786", + "logsBloom": "0x00000000000200000000020000000000000000000040400000040000000000000000000000000000000000220000000000000000000482000000000000000080000010402000020200000000000000002000000000000000000000000000000000000000000000000000200000000008000000000004004000000000000000000000000000000000000000000000100020000000000000000000000040000000000100000000000000000000000000000010000000000000000000000000080000000000000000000000000800000000000000000000000100000000000000004000000002000000000000000000000000000000000040000000000000000001", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xfa", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x9c4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9d9c2b94a73067a8ba8736b77b159187bad6ce53b4372d3d0d0aa534aae1d7bd", + "blockHash": "0xc4bf5494f56bc45ce01dad37aee3ce9ffc45d83fdc000e12181f5f8acb8019cd", "transactions": [ - "0xf86481e5088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0bd39af3df2a11f6261e939824dabf6a9e71a3a2c8c1bb063500678af676108e5a009b9c69c3a0de121dcc763befe353b95f0eba94610f3787372819b5ab152f9e1" + "0xf87a82011c0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a001f0bfa70518840b6c846fc573298406585f3ae18d41bd7b09b74a4bcc5ea45aa0497baf1aa5e0080d99e9492897d489f1fd1387d65451da9d5e8e87d5d215c3d7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7918,21 +7973,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9d9c2b94a73067a8ba8736b77b159187bad6ce53b4372d3d0d0aa534aae1d7bd", + "parentHash": "0xc4bf5494f56bc45ce01dad37aee3ce9ffc45d83fdc000e12181f5f8acb8019cd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb73d161455722e25876b549dd5e50384c3d558b9c41a6d212c27ab93f00e073d", - "receiptsRoot": "0x6195d7c85c340ae69791a06465e39d5a202cb53bfb9950da9be615af1fa1c49f", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000804000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000800000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc5b50d5f5bb8459ffc0293d6a89682f22e33c497c5060d2b84db9c24f8800747", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xfb", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x9ce", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa4b169ebb5479f117266df73694d46f704685c3d756d411dcb5fc0b15f500f47", + "blockHash": "0x4a451e3d5c50c59b8f500744456ddbc1305fd7d30a3088e18b63ab514e146a5a", "transactions": [ - "0x02f8d3870c72dd9d5e883e81e60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf88292cc89bf0c81656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a01bf804b21bbd284f3f59e4862747fabb1d91cd202d99df811fbcd650c8916ef101a07a6aa4a316190d2d4190f770ddb893b1460e70fbd3650250387cea8bb5d252cea075c4ad6724b9fd04714eacc8a9fcf101cb4c379177c4903e610d15d80ad1c58f" + "0xf86582011d088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a09802950fbf7bc635e1999203e18e5a7eb8ff2878cdeb9e4dacad002689b01b55a0676f17a2bae780db0606eafe3c28ad8ab6ba4f46a4ca3911469ef1538a566d06" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7949,21 +8004,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa4b169ebb5479f117266df73694d46f704685c3d756d411dcb5fc0b15f500f47", + "parentHash": "0x4a451e3d5c50c59b8f500744456ddbc1305fd7d30a3088e18b63ab514e146a5a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7af673b579848cf739d0977946fbd5e08ece6e8d39f46aaa4092adca0297131b", - "receiptsRoot": "0x90f07e67f04ced23fa47da5ee86634d02744163e2a0c9345a2892e2ac573f8b9", + "stateRoot": "0x5d62e876c9fb75994f975f38a997ced53c6d9e93efa0b68782d2874d51cb796d", + "receiptsRoot": "0x98a9a37889a99b4f9f21fda3496a111b5c72b1f223748956005057dc45b50c9c", "logsBloom": "0x00000000000000000000000000000000000000000000000000100000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xfc", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x9d8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x205a14b20d2c13f174859295063f88da3779c22b3cd8cf8d3718cf014f8c0af9", + "blockHash": "0x7e09bd28fdc45aa33de70b9cc577566820bcc691bb602bb4ea34c060240a3a34", "transactions": [ - "0x01f8d2870c72dd9d5e883e81e708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9a60100c3b84dcd2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b801a0bdda6e7c6e57e00f3a00b472b4a480c2c87440d4b19e5e5482a08fdb666378bea00a82355c7bac100d5dc94f6b76c352b07c531e7cf98d746e089624ee6176d086" + "0x02f8d4870c72dd9d5e883e82011e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9a60100c3b84dcd2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b880a0b289d6cf504d44238e278312e383bd74e5c41396a1b72bfa9b450aaffa7b07b1a03ae51f148de13d9dbcbb1b8b3f4d24b07fe30032979ba0e38aaceb36bd988221" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -7980,29 +8035,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x205a14b20d2c13f174859295063f88da3779c22b3cd8cf8d3718cf014f8c0af9", + "parentHash": "0x7e09bd28fdc45aa33de70b9cc577566820bcc691bb602bb4ea34c060240a3a34", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xda95fcdaffc081ecc6ee8aeb8fc0c34af8d264d206679f8117abcf4ac790aded", - "receiptsRoot": "0xb88d784bbfd12192ec4b0785299fc73c6a5520012b7dc507f6c10f550dc6c11b", + "stateRoot": "0x12f9955199b8b97c6b2f014a63595097abf47b3f6cb5647c81cbf2b813eb5f74", + "receiptsRoot": "0xdd239257b0e6e609ba5892c702f3cdf7bb5df0ea65d15417448bca696977ecea", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000100000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000001000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xfd", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x9e2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x68ee7090901b0083e417d17e1e9eb637b50146077b32d5f3b63568a738220c98", + "blockHash": "0x6b8f79e73655d6e6bf62130982a8130929598f06e537104557fafb585ef859aa", "transactions": [ - "0x03f8f9870c72dd9d5e883e81e80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c77a74f070310737f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea5832883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0357ca9f0031cc59e4be7c4b351da952e631b306646cfa1a0d24a1f9d54392e39a064bad8e978674e591d8b7999ef85fdabb7aea42d32310e005b695f4d98cb5d2e" + "0x01f8d3870c72dd9d5e883e82011f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c77a74f070310737f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea5832801a016d8f464e102d235f5b4a4cfe670e9994b533a50eac8688f258ae0fb2cc84f59a055d952ef33fb3e62215ea5259c32d7b04002b805e8a09c792b04737361d90165" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x7044f700543fd542e87e7cdb94f0126b0f6ad9488d0874a8ac903a72bade34e9", [] ] @@ -8013,27 +8066,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x68ee7090901b0083e417d17e1e9eb637b50146077b32d5f3b63568a738220c98", + "parentHash": "0x6b8f79e73655d6e6bf62130982a8130929598f06e537104557fafb585ef859aa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x086b21523f79b6a1d0bcd4d46a705a225bc8019a10d832acc835ca6d325547de", - "receiptsRoot": "0xf71010c9701f748e035d4cdd1eca78bc13330e2390c1107ae5578dd636d6f6dc", + "stateRoot": "0x1b0f5e16afef64944c550859b5703cb5f7d1fa907857b24bf8095990f031144e", + "receiptsRoot": "0xcece2afc40f80de52e7f38fdf0e3b080356a02624715ed0e51dd82f578e52f88", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000808000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000201000000000000000001000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xfe", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x9ec", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1d4e0daba7e6bdc87c5ecff530bca645bbe36a6a538e27b956c9c106607d982e", + "blockHash": "0x2f59eb73c385708d16bfbdabd173a892b1aedb35aef605b39bf4ecb37e5f4d81", "transactions": [ - "0xf87481e908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c729a65bda31a91e7656d69748718e5bb3abd109fa021ff0b4ad222bba50e9623a46935ff2ccacc88cd21a12ff2bcefe083acb12188a03a105b75e0e54e676cb822a1c85854bdb35b41e517c3b2c8a917325dca037d5c" + "0x03f8fa870c72dd9d5e883e8201200108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c729a65bda31a91e7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02dd51e8325001014c6845bc5ad51b134ab237f95ab18da55cabc4275b029bf3f83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a048b3e953645fd3e4cbea431b95e043ac285045829d6532739853eeb511cea26ba00d538af75559625a07f08c4ed4259602d548b81f08a01c3e2b15fdc75883d1aa" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xf63a7ff76bb9713bea8d47831a1510d2c8971accd22a403d5bbfaaa3dc310616", [] ] @@ -8044,21 +8099,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1d4e0daba7e6bdc87c5ecff530bca645bbe36a6a538e27b956c9c106607d982e", + "parentHash": "0x2f59eb73c385708d16bfbdabd173a892b1aedb35aef605b39bf4ecb37e5f4d81", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb36ba377ca20ab99b4babb2408e48bad77df897f4bcd5e8d04a7903ab87166c7", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb56427b3a211f0a2f62a3a0b2cc41a6183f481796616214d294633846d550537", + "receiptsRoot": "0x08f1a82b6731cc83acd11b29a3f0bc0d9c641f0f090f9a4fed92b49de10c8276", + "logsBloom": "0x00000000000000000000000400000000000000000000000000000000800000000000000000000000000000000000000000000000000100000000000002000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0xff", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x9f6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xadf3ad66db1c5384657a2b75a1753887c646c629bd10a8a50d15097b79c14cbc", + "blockHash": "0xdc795b259c72a03503f2caa5002867f7321785d36a0fc325f23c6a7f0b5bc910", "transactions": [ - "0x02f86a870c72dd9d5e883e81ea0108825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf0180c001a033b27b4f7423b03e6e2fadd430fa2f7e913ef796faf7e7266513fb2d93c8a77fa02420d42939972bab5a6fe4e1198f47cec08194808b4e5cf4d5cf30f9e5972e9a" + "0xf87582012108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c706590b13eb1c33d656d69748718e5bb3abd10a0a08932fe032e5f900ede1c39bb840498c393f529ab619f244cd632db7668b22392a0499938e0564c1ab6ddf20ac4e3bb4eb19dbfadd170e12d62850e9bdfd2d74306" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8075,21 +8130,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xadf3ad66db1c5384657a2b75a1753887c646c629bd10a8a50d15097b79c14cbc", + "parentHash": "0xdc795b259c72a03503f2caa5002867f7321785d36a0fc325f23c6a7f0b5bc910", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x97e68aafb0b19c385ac8546331867122911edc8c22a288849a8cc318082eda74", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xf2e41fdb4e72f7a36c1008b3ebe31da625d6cd0dacd4f72b5f2e81a21110a95d", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x100", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xa00", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9ae54ebf672230a7e3ae4ef423aacf24189f52e240c1356817cb32d767618063", + "blockHash": "0x271a4760953153009f96bed8d964dfa87d6893d05200beca8c28b05661a749a0", "transactions": [ - "0x01f869870c72dd9d5e883e81eb088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a0cc554cf1b152fa1c01e7e409f59f1e2ae8aa77511b726144f7e43136b67bcaa4a0261707e0abe087ed97585f530ffaa0b30f685ef1a20a7f063a34de1672467f17" + "0x02f86b870c72dd9d5e883e82012201088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c080a0cdca45c3cf416d7336cd612875776e83a4852aa0d31a8eb64ed139b5cbda30c0a02abc192501a700bed7a29fa13f9c23d4685ac51f7d98226e739272b1718a28ac" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8106,21 +8161,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9ae54ebf672230a7e3ae4ef423aacf24189f52e240c1356817cb32d767618063", + "parentHash": "0x271a4760953153009f96bed8d964dfa87d6893d05200beca8c28b05661a749a0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6a7e15a097391ede75bbf2a63347ffe9b7cb42135899d0295ff15749e00acb53", - "receiptsRoot": "0x642cd2bcdba228efb3996bf53981250d3608289522b80754c4e3c085c93c806f", + "stateRoot": "0xd4e0fc59a22ec4e6f85ee34181ee0aa62fd0e262627bde52f5a30d3d72b5aefb", + "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x101", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xa0a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xed093194e152b98e10d55a8db6403780d17346e9eff9c511712725e08c422381", + "blockHash": "0xa01a3f6a72dc1967245123b06ac7eae459690d7ef3a4d07700c0e3745a74db71", "transactions": [ - "0xf86781ec0882520894eda8645ba6948855e3b3cd596bbb07596d59c60301808718e5bb3abd109fa0f9040bc146997f43cf4322ae00653a6f48de8da4718552435c5b42ca8c54e359a04f0f757fd150d6d5e9856ee6a925e5191c90aad31452327effed832c764f4349" + "0x01f86a870c72dd9d5e883e8201230882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a0bdc843dcf9fe4bfab0842fa7fe93d5a18ab077b852e42b43e45aaef6e542d18ba061e44f1be5b39592a8ba72b746d8f5387f6fdbe81721782361b958893625157c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8137,28 +8192,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xed093194e152b98e10d55a8db6403780d17346e9eff9c511712725e08c422381", + "parentHash": "0xa01a3f6a72dc1967245123b06ac7eae459690d7ef3a4d07700c0e3745a74db71", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3175246abc21d105322ad9b1b3bba97d2dbae62d42054dd51b59786ae702e3f8", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x0d9cc93a6bc9a1e7acabb383958c985ed8f99e6f5520eb221e749d1dae041285", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x102", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xa14", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcd35112597db3095f6c10b644aee930651c44a03d8c168581d8aff8d26050491", - "transactions": [], - "withdrawals": [ - { - "index": "0x16", - "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "amount": "0x64" - } + "blockHash": "0xe098e6bdfcbf458b4139ee1ebb140d43f6d606f540d989eba5b8b97435bff5ae", + "transactions": [ + "0xf868820124088252089484e75c28348fb86acea1a93a39426d7d60f4cc4601808718e5bb3abd10a0a0d435058270eac8cc8ab931fb3fab35f5c0fd1b61807a8f41dc882b5d56bb390ea045ee97f442161f5e4286ed78131e766593df3cb9607e686443d13a54b1962c76" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -8173,23 +8223,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcd35112597db3095f6c10b644aee930651c44a03d8c168581d8aff8d26050491", + "parentHash": "0xe098e6bdfcbf458b4139ee1ebb140d43f6d606f540d989eba5b8b97435bff5ae", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8f2c077936f439e11f80611dc95c720ad9f4dceb3f0ea11713514b308d279490", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x79104cfc128a45bc8bec55c00d116a4cea3a32716a1d264c9b037976e7284d53", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x103", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xa1e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x46728f520936c769482557b2d4d05386f030a3d9c03cca9d123940d3d3fc97be", - "transactions": [ - "0xf88281ed088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a05ff5043201525e47b2a17bd2efc4aae132dd6f168252e51b2f20fb6fb7ac6043a05476a8576d657d8ff75014e8bcc77e6e9657526efa8b79f085f8f78ca70d3ce7" + "blockHash": "0x8820f152b3cff23de1f3b9447dd120cdc4db4b52be2289b8addfd158c2ad60b2", + "transactions": [], + "withdrawals": [ + { + "index": "0x16", + "validatorIndex": "0x5", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -8204,21 +8259,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x46728f520936c769482557b2d4d05386f030a3d9c03cca9d123940d3d3fc97be", + "parentHash": "0x8820f152b3cff23de1f3b9447dd120cdc4db4b52be2289b8addfd158c2ad60b2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8b08ae94f43b6cde596fead75fc65515098159157826766c042df86e8ee39fbb", - "receiptsRoot": "0xe96c8af980d88dfdb57bb4e77d6139098674406977393b19a5a4a06d409ed1e8", - "logsBloom": "0x80400000000000000000000000000000040000000000000000000000001020000000000000000000000010000000000000000000200000010000000000000000000000000000000000000000001008000000000000000000000800000400000000000000000000000000080000020400000000000000000800000000000000000000000000000000000000000000000200000000010000000000000000000000000020000080000000008000400500000020000000400000400000000000000000000000000000000004000000000000000400000000000000100000000000000000000000000000000000000000000004001000000000000000000000000001", + "stateRoot": "0xc9f270a3715490a6d21769ad119b76059f3bac9a0927df091b843209c6ae901b", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x104", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xa28", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x65989a6ce9bd74150837c8f8feea080d86236e1706b2b1d9bb42ae329a212110", + "blockHash": "0x9055974f536a57910076dff54ffff9856ac72456315542541730ccbd2f24ea9e", "transactions": [ - "0xf87981ee0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0249a03e12c72b484b782d7dd0202a67a7e362781b8037c07502d359ff95d49e5a00966596e0c65871380a7525de7d858c6f29b5262df7672499db7e39ba7779ec2" + "0xf883820125088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0ce757243cc0db6a5bc75785d39bf586d46a5d7fe15d5c7aac61ed7fdbe104a91a062efba996990699558521640d5718e65cf0861a2bd1f56539a434d296b3fc0a9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8235,21 +8290,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x65989a6ce9bd74150837c8f8feea080d86236e1706b2b1d9bb42ae329a212110", + "parentHash": "0x9055974f536a57910076dff54ffff9856ac72456315542541730ccbd2f24ea9e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2a7940a6da7cd8688d8fff2706eb485e00b273a76cb1c620612243f456dd136b", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x7c6c05ef0a73857681154a418f8621ca2f30e4c623228dde96a1e6e82fc53a25", + "receiptsRoot": "0x55dad0db67f2a541e084a97b2740c312e248e965b1c1f7f1e31d0737bfd90305", + "logsBloom": "0x00000000000400000000000000020000000000000000001000000000000000000004000000002000000000040000000020040000000010000000000000000000000000004000020000400080000000000000008000000000000002000000000000000000000000000000000000000400000000000000000000000000000000000000040000000000000000400000000000000000000000001000000080000000100000000080000000000000000002000000000000004000000000080000000400000000000000000000000000000000000000000100000200000000000000000000000000000000000000000000000040280000000000000002000000000010", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x105", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xa32", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1244e39eddc59b8d38c3c9e609867b149bb1222e3087fcde4e60d1785f9ca6fb", + "blockHash": "0x7102af3da7876aa9cff2e92b872cae97f9eaca3f19c6b184a9000d27dbca4e74", "transactions": [ - "0xf86481ef088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0f71990113edc7bbd8fb0652e4f147e4cf8454da209758a3edeae5d85d8ce6348a064c11008d0f851e7b753f6b8557dfa300044fde1503c10d518795b97ca0baaa9" + "0xf8798201260883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa02d7ade69ce5b4edeaf29fbc8d988dd32569ec074296dd98dbd5914a6dd17269c9fafc4d0c1e5aadb398ed630e85c406608324043d76b3f9c8e8b49192bdd4d7d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8266,21 +8321,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1244e39eddc59b8d38c3c9e609867b149bb1222e3087fcde4e60d1785f9ca6fb", + "parentHash": "0x7102af3da7876aa9cff2e92b872cae97f9eaca3f19c6b184a9000d27dbca4e74", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc28b9a58e85ba57dc108f326dec626ef81a0b16946c895ad90961c1cf43c23d6", - "receiptsRoot": "0x2c661ac051aa0ffbf53e7fb3e9fbc5527454a4d1e22c9eece00da386134aaae5", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000040000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x13a8de182e47d58d6c065bc564dff31025097da722d82e7a8d693a14df57ba96", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x106", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xa3c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9b11fa343fc18df51ad37fa94c9d6c17916786bbbab8bc10e3a3d1c0580e0b2f", + "blockHash": "0xd50ce3a9f526cc3f15e8938ea731693ca87130f6ea684d06e3df024c0c2d298b", "transactions": [ - "0x02f8d3870c72dd9d5e883e81f00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc4b2277a673e7dea656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0628887ea9304aeb7f3934543b9d14ab4e7e5cd422ba572d39d6ee10c3304534580a04216844f9698b4c3ac489b56ede5c1330ac2dcf5ab2f0d44882d60f2565d7c34a04f6922b75af7e0fccc73af8aa2253cb6a690121061c83dbbe40890d778514ac6" + "0xf865820127088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0185ee9769a4c97615b18b2e54cd2fff632e9115f7ad53cf2ec3c8ffe2109741da00328e76fb900029f080951acfabd4b5f061481a9dbf613e804ce7bbec0e87038" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8297,21 +8352,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9b11fa343fc18df51ad37fa94c9d6c17916786bbbab8bc10e3a3d1c0580e0b2f", + "parentHash": "0xd50ce3a9f526cc3f15e8938ea731693ca87130f6ea684d06e3df024c0c2d298b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xac12a5a83732b8e0cfb72b17b98da2c647d6c43aafc8781cec9bc934c4667cea", - "receiptsRoot": "0x6a3af165755b8f4ddfb198a02c1ea6fa0e476be8a9e91d41195866f75a6c65bd", + "stateRoot": "0x010a4f44ff3cd9b11606dbaf036f8387acdc2004c52f6d810edc8ca4eebda97b", + "receiptsRoot": "0x316125a325d25224538bdff871ac99cf3bfb3c35d4200250353f77119403dce2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000200000000004000000000000200000000000000000000000000002000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x107", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xa46", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6bd2bb001303e7dfb428c75ea4bd6dd7115d6ff61add2924cb23a0115c920884", + "blockHash": "0xe87cffe7581ce382f9231fd3e5f6c6dd15670fac36f758bcaf841c44459f882f", "transactions": [ - "0x01f8d2870c72dd9d5e883e81f108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1b6adcc983ad4086656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba01a003a3e9854f243d54d673cb575bebb4d014860aa9e0053491cc0fe1cc10aaa8ffa0502f1bf5418002e6a5e19bf6387aec07f366edad070548e4271359c07e1c8dbd" + "0x02f8d4870c72dd9d5e883e8201280108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1b6adcc983ad4086656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba01a048442e64874ab0b16121c95b466712cbdf2e87653a8df012137c53072b2cc743a06f2692920a03883be81526c7daa0b9fa309f8f6f24b4023fda243f7844f7e501" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8328,29 +8383,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6bd2bb001303e7dfb428c75ea4bd6dd7115d6ff61add2924cb23a0115c920884", + "parentHash": "0xe87cffe7581ce382f9231fd3e5f6c6dd15670fac36f758bcaf841c44459f882f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xafb2da9323c0f07fd5d9356a2c9bf67b082d7e36db4871d76339ce059d0caa5f", - "receiptsRoot": "0xc5610bcb5002376ea2eabd88001c2b2fac4b1c3dd0c0046f926c16c3f0c852f3", + "stateRoot": "0x862679188996c77b1c01e201cc58bb22326c513b56a65aa1930c9fca7861c761", + "receiptsRoot": "0xae0675e593af9295b673e2aedba6455869043f45bd1182c52bed6d3517c78ca6", "logsBloom": "0x00000000800000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x108", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xa50", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdb94bbffb05461e4f8a83c827cb5b0cc8e54ce71af9f4b57fd712c7bf245a67e", + "blockHash": "0x4b2ca2c24eb4cfff7f4ea2a8657efae77d1f12850557b1b3cedaf5326498a476", "transactions": [ - "0x03f8f9870c72dd9d5e883e81f20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c6fc8c6364b779b27656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0f4f3451f3c730bab02a9b6000e8fa5cb299d75f3963eb0e1ba4e926a284c93e3a0107d70040f1a155b756b0130439565c52db057287755e9e721e3f24d6655506f" + "0x01f8d3870c72dd9d5e883e82012908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6fc8c6364b779b27656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c901a0caf86e2da1e470d76d0a5e3fe70b58a3a6113abf07985e08eb193cfd96c5918ca02a8b90442569638779433a89bf2760eeef5edc15ad093b998a10c2fb381e99fd" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x99ac5ad7b62dd843abca85e485a6d4331e006ef9d391b0e89fb2eeccef1d29a2", [] ] @@ -8361,27 +8414,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdb94bbffb05461e4f8a83c827cb5b0cc8e54ce71af9f4b57fd712c7bf245a67e", + "parentHash": "0x4b2ca2c24eb4cfff7f4ea2a8657efae77d1f12850557b1b3cedaf5326498a476", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x06aa6955d876a1263894ecbb03fb81460996e83dfd0bd1f67700abf52f69434c", - "receiptsRoot": "0x82a4ca68aa94d5dad5dab5df853ef13aa848d3e427c2264269dafff205d3e4d0", + "stateRoot": "0xf801f0ae5e3d5a5d90ca28b461d3e0a677d9e4cf7255caf1c2eef8eb071711e5", + "receiptsRoot": "0xd593abc3db20ebd5b10a6733655958da6d1c5b35ee05b4814cdc175ee7531b30", "logsBloom": "0x0000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400400000000020000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x109", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xa5a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x669d2fdcd20848e3f746c76753dac2763d798d43492e58e75eec82ef4fb156b3", + "blockHash": "0x6442f9445011c3fabe60fa667b6d3312a035f8b31ba11d66784657a7b1610e67", "transactions": [ - "0xf87481f308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c62087a44acecfb2c656d69748718e5bb3abd109fa0fe8ea091430d3b75ba298e74524e5fb6fe481c4950b522fffccf1e94206ad5c7a013bb8d11137fbf2826ff165447f9f15b8b4acfab5d0e0b092632975f351dbf73" + "0x03f8fa870c72dd9d5e883e82012a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c62087a44acecfb2c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0321c62425869f150c2cb7f489691c3e5cd49f7cd62d07ecbb7477c4148aaaa0b83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0f28cb1c217ed21fd0c1cca1ac6471a4a1e1322513803209debc62d460bbcf5bfa01d36fb08965086554afaf29e564765993a89f231d1fb7c822f9cedbf38142192" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x02a4349c3ee7403fe2f23cad9cf2fb6933b1ae37e34c9d414dc4f64516ea9f97", [] ] @@ -8392,21 +8447,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x669d2fdcd20848e3f746c76753dac2763d798d43492e58e75eec82ef4fb156b3", + "parentHash": "0x6442f9445011c3fabe60fa667b6d3312a035f8b31ba11d66784657a7b1610e67", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa3f1d1f3a5479545b0e1a5e8ede05281f5c19182191663ebceb9d877d674175a", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc24cbb64371207d2535756c6e351e52664feff1f248b0bd5ec9da5b2a6ba1503", + "receiptsRoot": "0xd91270b8ced1e15e9ae15e9082afa3ab675eb35f2ef90504cd34f809be9580d1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000808000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xa64", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8bc68b8a166d2b68a73be23ea20193dccd82a3bfedac661f969bdc32fcd454a4", + "blockHash": "0x957a973ad8b0b3e200ae375441704b26ce89fa5056a66550359b34ee91a2a0d4", "transactions": [ - "0x02f86a870c72dd9d5e883e81f4010882520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c001a0614813ef71b15ae6c0e87a53fdce19608fb50a3f85b90d201fa9fe374e9b28f9a00d51baec84d22441726cfa3d3c87a08e190a791d39736d820726d270edd8c29e" + "0xf87582012b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc71d2dcac9d2c7d8656d69748718e5bb3abd10a0a06b7a5561adc1da4a84af285176c1278e1e457c2e6c88bd1c581986952c6a38c6a024432b3cfeb0da3431d49dcf45dbcf347efc2224f6ad8043c85b3efa66300c43" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8423,21 +8478,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8bc68b8a166d2b68a73be23ea20193dccd82a3bfedac661f969bdc32fcd454a4", + "parentHash": "0x957a973ad8b0b3e200ae375441704b26ce89fa5056a66550359b34ee91a2a0d4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x08dab9f63e2c2aafaa520e12138b01b3e0c23c308893968af25a0d38b15d6c00", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xfd434f0cd7eb391ab7f027196e5f51ac834f735fcac32b8e31d6ad78d18faa3f", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xa6e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf8160bbab91163c4b7120ab3c60606cc47ba1ec0e765daf1d68ca0dcf52d2787", + "blockHash": "0x714651f961e055fb12c089df6e5c83f279400bba685d20810303f77984712cd0", "transactions": [ - "0x01f869870c72dd9d5e883e81f50882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c001a0a6f0f360c5a1a83b44c9596dd1f56ce31b234d0420f6156884a29a66cfbc42bfa0669e36bd373c9265ca998588d043303e88da8c2f8ec8898ca0be6009218d00b6" + "0x02f86b870c72dd9d5e883e82012c010882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c080a07ef0599368e48f92cea08522b2af646397a75b14c5019e5100960f7c6e3621d1a07571eeaa9614c533053d49ebe30d33740bbc681996119333a84bcdc1684fa236" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8454,21 +8509,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf8160bbab91163c4b7120ab3c60606cc47ba1ec0e765daf1d68ca0dcf52d2787", + "parentHash": "0x714651f961e055fb12c089df6e5c83f279400bba685d20810303f77984712cd0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7b0f4215fad37adedc45506bbf63d576e0546ec58e3715743bda1d182a87173c", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x7f6912c6944851e25a3496940081d559f868580a929a9b423d524fccc743495a", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xa78", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3f4cebd4ebd414ba3710ad5eabfefa06fc5f007c62ef0900e07c263e1923889f", + "blockHash": "0x0b3f682d9d441ee52d4a38112d385f970973958bc4586ed97a2ef47a202aa38f", "transactions": [ - "0xf86781f6088252089483c7e323d189f18725ac510004fdc2941f8c4a7801808718e5bb3abd10a0a0b657470f4dd51519c81a036de7f51b2e5554575d49a376a08f4bc155880f2a91a02b9e03016faed61ecece3dddea17a7c27b6e75076cc1351a06966a18ac98636d" + "0x01f86a870c72dd9d5e883e82012d088252089483c7e323d189f18725ac510004fdc2941f8c4a780180c001a078804d323a6d0022973b593c84be513f2f2479a7d370b92f94f4a944b832d913a0396694a61a6e2793d452220f9d6bcdec26754cb218a622fc6c3a1ec73cf406c0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8485,28 +8540,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3f4cebd4ebd414ba3710ad5eabfefa06fc5f007c62ef0900e07c263e1923889f", + "parentHash": "0x0b3f682d9d441ee52d4a38112d385f970973958bc4586ed97a2ef47a202aa38f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2554f77d3552a0ee983978ced700fedd929024bc7690cdf168f1e9ca0c5ada7d", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x642b07f0c012d1a6cc8684db3f438e5b94bff72c3fd16afa1ffd385b5849c102", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xa82", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x51a4821b633b80775e02a85aafd3a58ed2796e158c03aea46004e25ca138eaa1", - "transactions": [], - "withdrawals": [ - { - "index": "0x17", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0xd6a33b58b1e38fe4ac1c3386de7de4d1db23f14871f1b0a6163750738a6844b4", + "transactions": [ + "0xf86882012e08825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd10a0a0779b187a8ebce5b522a53b7c1b541b85e639525c747ac9f29d79361d3cf113cba04013c8dcb8374c518e4cf57dc71e4c48a093002b181cfcbe8d90b312879038f2" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -8521,23 +8571,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x51a4821b633b80775e02a85aafd3a58ed2796e158c03aea46004e25ca138eaa1", + "parentHash": "0xd6a33b58b1e38fe4ac1c3386de7de4d1db23f14871f1b0a6163750738a6844b4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5d2d837f98e90f380271bc4eaaa543f15630b485a755956ab1d023e14d41ef2c", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x7ce4e321ae6a7f99bf8c18556e0337125cde5f4396966ceec6cd7019d2423f62", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xa8c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6904e188fffed4cc41632df32452ec9bd4cafdee6f5d76c36e1b2efd33ad9079", - "transactions": [ - "0xf88281f7088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0bbeeb602a74706ac6e91e64344c1844808b21eda8b2303c2fe5d6a0072be018ba03b5274579f02a9f98c995311ab714ba8f8f83d782cb802aa7eab0d47627f90c8" + "blockHash": "0x7fc400f7b6c69771e1a1dd0fef6a7fcb25f9d4a2160f28c2c20ff5c8c5557396", + "transactions": [], + "withdrawals": [ + { + "index": "0x17", + "validatorIndex": "0x5", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -8552,21 +8607,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6904e188fffed4cc41632df32452ec9bd4cafdee6f5d76c36e1b2efd33ad9079", + "parentHash": "0x7fc400f7b6c69771e1a1dd0fef6a7fcb25f9d4a2160f28c2c20ff5c8c5557396", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2408c8ee1b99f42499120241935b75233442b2ced2ee4df0b662845fd312da2e", - "receiptsRoot": "0x0d4f58d0c68a50f97304f479e8cafe31adfb13cbd601e084066af748100882c7", - "logsBloom": "0x00200000000000000040400000000000000000000002000000000000000000000420000000000000000000000001000000000000080000000000000000000000002000000100000010000000000000000000200004000000000000000100000120000000020000000000000000000000010000800000001000000000000000000000000000000000000200000000000000000000040080000000000000000000000000000000000000000004000400000000000000000000000000000000000000000000000000000000000010000000000008000000201000000000000000000000000001000002002000000000200000000000000000000000000000000000", + "stateRoot": "0x7ff2b46cdb8074ca55d4b3fc13192c9699cb0b7a76d8e9958fd73aada75e88b6", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x10f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xa96", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf6354df3badf86b25e2f88f4630610c9c756a76eab5489bf84dc4b5faa5dfcad", + "blockHash": "0xd40c0450e901d3193859726272a91036198d0bb55438bb30e7e2ee747bf90d07", "transactions": [ - "0xf87981f80883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa074dc1ffa4861a35bcc8448c8e6b1405fbd4b51a3f750a4afcf44ee192c186bcea01755d34cbd340f9c8439880745cad348449f931dc18dc31c69e8b60bccca14b3" + "0xf88382012f088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0d30b64c986d60875c723271137dda91480051141fa40b9b19fda5b35b28498d0a072b15981e23481356183bb684d92a17520fcc49b8e79bd66b01c2a3eb00e5080" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8583,21 +8638,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf6354df3badf86b25e2f88f4630610c9c756a76eab5489bf84dc4b5faa5dfcad", + "parentHash": "0xd40c0450e901d3193859726272a91036198d0bb55438bb30e7e2ee747bf90d07", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x656387ab387b18449d508730369f7633ecc8ad248063a0d2106374a5a72ea043", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xbb6617e19c771c68482094b894c8e7436cbbac7c4f17f55675ef403ea931e18f", + "receiptsRoot": "0x5622fe693f4cec7001b7b5255002970d6a43e8766dd6b65f97dcef68b4b15e73", + "logsBloom": "0x00000000000000000000000000000000000040000000000000000000000001000000000000180000000000500000100000000000000000000000000000000004800000000000000000000000000000000000040008000000000000002000000000000000001000000002000000000002000000000000000000000000000000000080000000000000000000000010000000400000000000001000000000000000000000404000000000000000000000020000800000000004800000000000001800000000020000000000000800000000000108000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x110", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xaa0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa3f857458c4f8e850d17825dd663d51219737a227a157cb9f3eb21a7dabf3c12", + "blockHash": "0xb56358c5f0686a2af5b2569179542237964b481269f589871f1d0a8494b22716", "transactions": [ - "0xf86481f9088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0c169d3545078ccd936ab6cd33f5f22548618c895668c4f84af4f9ebc950eec38a06c86ddbbf36b2aa97dd38d268b4e64b967167f51530c48c63e3a23e24bcae4b3" + "0xf87a8201300883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa067ce64185ff235bc6fb6d1c933db1f65991ea4268907c8029122d1338e903d4ca04dcd6718312a76e391829354b6971c306a8935e0c61eb6ff1f8dd4114a8e22be" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8614,21 +8669,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa3f857458c4f8e850d17825dd663d51219737a227a157cb9f3eb21a7dabf3c12", + "parentHash": "0xb56358c5f0686a2af5b2569179542237964b481269f589871f1d0a8494b22716", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x803db5b17b6a762269881f87517f2941a1a9c42fcd0cddfe7544945544566c49", - "receiptsRoot": "0xecb4f3e60b707949e677bf6d670c9f95cb89f881a643f318b0147d300b110a10", - "logsBloom": "0x00000000000020000000000000000000000100000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xf7a1364bb961162f6574f5b3a8b7b56166ad532a49dc6fd5c80053712008e967", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x111", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xaaa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa9e96ee23c11f8d5762340e128d2280d87ee788885951468baa9a384665b95f7", + "blockHash": "0x6db49261c82dcd68dbd907e9ae99e60e8b60a144e20fa40bc9760e6af5ae95ab", "transactions": [ - "0x02f8d3870c72dd9d5e883e81fa0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1edb46f05849d382656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ee181b97fd68754f6245c655a0a0686e8d12aa4eac5f1d059e7e3b8d6a92407380a0d1c9df9a238c482417fc0bb6a007472f4bc8e77e2c87eb0b31e25370cfdfba11a065fe3cbb739fc600e9a03210f5dbe449df426cb872cfbbc7a9d19c20dec09381" + "0xf865820131088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0963b4b682cee1ac82d2573a185fc77f4dd0bafe984dd0ec3eae6ba6c5b96f336a07bd8df7e9e06faa4484b7a99f81264ec6450f44fd7cfda336c64a771e7879cc0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8645,21 +8700,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa9e96ee23c11f8d5762340e128d2280d87ee788885951468baa9a384665b95f7", + "parentHash": "0x6db49261c82dcd68dbd907e9ae99e60e8b60a144e20fa40bc9760e6af5ae95ab", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x54cffe7d4fef024de316515ce8a1b8d45facfc45060afe9422513b076d3d7d60", - "receiptsRoot": "0x2c4e34289f602c7112bedf7b63c453a4b8ca4d68eb2c6aa24af4ef274deefa2b", + "stateRoot": "0x6337ba2546295dc867f60b1bf81165e062cea1fef20ebc7704386c0e24ed09c4", + "receiptsRoot": "0x04f73f76e4bba7f03157c98cc8882d865b925617737189a14a142449408e9f72", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000040000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x112", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xab4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x443c32584ab5e94cf1393eba7de764dcbf40a903572c0b1737a2198537886269", + "blockHash": "0x295a8e852bcd10264566f53a7c2b7010d082476d400aeee5d1067c6237964b33", "transactions": [ - "0x01f8d2870c72dd9d5e883e81fb08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c84eb17e70e299b7f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c01a0f27f117e815339f2749850a97c719a6c69358b37864d12e9898e689f446a9ceea015788df7af934298d0184f55d371f2ad0c79cf140b9ece4e8518d8a5f0a21efc" + "0x02f8d4870c72dd9d5e883e8201320108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c84eb17e70e299b7f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c01a0f7a778b0a09332e80f8e81093e5e1e7c52bbd27b7ffe32ecc0f7502aa17548e3a01bbb86d42cab74c611445a5952513f45d34bcc5991768a03f1c3094ab8718821" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8676,29 +8731,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x443c32584ab5e94cf1393eba7de764dcbf40a903572c0b1737a2198537886269", + "parentHash": "0x295a8e852bcd10264566f53a7c2b7010d082476d400aeee5d1067c6237964b33", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x26a0e4a442d51c93e770373c6818c0c67ef9ddd7d626707a1f1de5cab25a8086", - "receiptsRoot": "0xc06b7b23d29690d39174ae317e01ab8a941444749c462ce9f86508e504b7b4e2", + "stateRoot": "0xd9103dad491d1411ebde692ed260f608f8a0e516b3667c19745b853d134e05ed", + "receiptsRoot": "0x54b806f301e72c5c97cd72fdb3bfe7f7bf3a33126648b0819df63ffffb9bebd8", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000400000000000000000000000004000000000000200000000000000000000040000002000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x113", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xabe", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1910146905689fbbc61f374a7bde5325be084f307a5617b7bdb319691d7cbe7e", + "blockHash": "0x59c54b1678dca13353be6cbe9090244300dafeeaf924758a74eccaf5d8e83cbe", "transactions": [ - "0x03f8f9870c72dd9d5e883e81fc0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cd67b2566c143f645656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0af1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0e0f28063ea2a24086eab327a71ff3e93f1fe235ae1e1b4481a15c47a53d5bd9ca019cc7b23d66b225280440f0a95b90d9213c83bbf26e5a4d4e6a7a8dc4c72c4a8" + "0x01f8d3870c72dd9d5e883e82013308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd67b2566c143f645656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0af1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa01a068ea7748cd8fb3a62c9c0ca526662190eb90da364aefa43f95a7fd80069f8e0da03fa5b362efa81b138425b1995031b081841e3b74d0e466406092121b431984fa" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xec60e51de32061c531b80d2c515bfa8f81600b9b50fc02beaf4dc01dd6e0c9ca", [] ] @@ -8709,27 +8762,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1910146905689fbbc61f374a7bde5325be084f307a5617b7bdb319691d7cbe7e", + "parentHash": "0x59c54b1678dca13353be6cbe9090244300dafeeaf924758a74eccaf5d8e83cbe", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x365814495fb3a18e4e09db0619a45be4ad5122707ea2dfd6884b63b5e1c2dcd0", - "receiptsRoot": "0xdb1dd143b29f2936ae059b08853ae6e6a89db350809c3185de6ea9c618ea6920", + "stateRoot": "0x3ea9fc59800a6487e43efaa31e2b75edbebac868211334f6424d27229ee9aae9", + "receiptsRoot": "0x75976c90eec5e0755df80f972dc62aa94af9d4dff4dc2348789422a62d262259", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000008002000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x114", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xac8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5d602bc5189b5a955faeb7842825c53c4cd335c0cac7756599e3a7d7a9b1e604", + "blockHash": "0x62434faab09991ba4832b647e7260e305c48a47556068e84a5a0f8d1cd23ca0d", "transactions": [ - "0xf87481fd08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce6d182630e8ffca8656d69748718e5bb3abd10a0a05e0045c49ffc8d2f6c70cd6fc2033bcd0a31c6515b8744720686836a04a2236ba02411fd9607b7640df6c5a2ac2eef30895bd0ed221718ad5b37a5d23d719398a7" + "0x03f8fa870c72dd9d5e883e8201340108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ce6d182630e8ffca8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a01f6ebf3e4d9c96ec86b866137bbec9bbb56d188e7126babfccc6394fdcc6a3d483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a046d328ccc281080c9cbd39806ec008e6e80362fd11dab9fea364f7671e540ea2a01ae74b5fd369a9282a2830a1c67e92416772ebb18da78a90501156733b650e99" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x2fc9f34b3ed6b3cabd7b2b65b4a21381ad4419670eed745007f9efa8dd365ef1", [] ] @@ -8740,21 +8795,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5d602bc5189b5a955faeb7842825c53c4cd335c0cac7756599e3a7d7a9b1e604", + "parentHash": "0x62434faab09991ba4832b647e7260e305c48a47556068e84a5a0f8d1cd23ca0d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xef3660b1a4ef1379d8611613bfdd0fa481d0cb0c447ba91662ed3061407ea867", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd2b92c2a4b2e37692c4fa39277a649ba09add321635433a9f5a85e10323aec38", + "receiptsRoot": "0xa4fb4fa96e26e57cd23777822feb59c66993b86b1c5fe2998054861530bc08a4", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000400000000000000000000000000100000000000000000000000000000000000000004000040000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x115", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xad2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7cdd5d09a0af5e26bad74166fd6a4324185ee337b005e5df5f4f67f00155cce9", + "blockHash": "0x9852b90c33582df6fce102fb4e211a0e0b391b486dd80752560076c200aedf9a", "transactions": [ - "0x02f86a870c72dd9d5e883e81fe010882520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc0180c001a08fc9a8d1ebbdace1c8111cb137b3024b0620a4311574a5bcc3af2c0c5a0b5b7ba0238b44f3d32d593eafedec3d2cca2bbfe3e68dc96e333dc5b7c0b4c0141b4af2" + "0xf87582013508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c175564045165c9ce656d69748718e5bb3abd10a0a0b7490c29a40996e144cc3955a4c2aae7f86a138eef44a24dfd28adf7268314b2a04f5f8a7010b2c8cc4d519bf0712bdcaefc997b02d8085f945349a58b9e39ac64" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8771,21 +8826,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7cdd5d09a0af5e26bad74166fd6a4324185ee337b005e5df5f4f67f00155cce9", + "parentHash": "0x9852b90c33582df6fce102fb4e211a0e0b391b486dd80752560076c200aedf9a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x17d40d4bf412667ea693c2b08587f543806e84f610c1b5a360a9b0be7b25cee6", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x16bc56677af4614198a208557d5464144cff14ed2c033401272883a09b176655", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x116", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xadc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xda06797d4ea9e2d242a7f1d77163e4cd0d18aa7e9ae04a2357c7a359c3a7897b", + "blockHash": "0x65240654f94bde1e2d244ef74fc438f08b54b1e9faecc7ec1ca49a7ba83ce5ce", "transactions": [ - "0x01f869870c72dd9d5e883e81ff088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a08b3ceb8078fd45b2305a1cbe2d116976b180ec20267f1af943ce1548112d7aaaa008999b87bb4d79a8fa0ec280bb0f35435852ec683167f3ccdd63f3987da1209a" + "0x02f86b870c72dd9d5e883e82013601088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a0d9ffd12f7588d14332da52ceb4862c1c9440972503b6bea4ff2f0c814bef0d77a07bfc019e96b947ae8453633bb24a02b9d4ee42d6a61dac59acaba0b3145ab205" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8802,21 +8857,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xda06797d4ea9e2d242a7f1d77163e4cd0d18aa7e9ae04a2357c7a359c3a7897b", + "parentHash": "0x65240654f94bde1e2d244ef74fc438f08b54b1e9faecc7ec1ca49a7ba83ce5ce", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5f02ae67228f20bbde12c883504a1579c4d976759a0e50f2e940e3ffbc481591", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xe6bdb5afa9a849de6b0d4bd5fe3539809083c6c836a54f36b4471339f72bd480", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x117", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xae6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x69c23b6cef19f994ec1120ebe41647daae8fc602ceeccb500bef3599ea8dc4d6", + "blockHash": "0x9f54ff65564ec9e51c194c32c07d73fa64f558ae0df769401105131d1f438d44", "transactions": [ - "0xf86882010008825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd10a0a04ae4a6f0f05c189b4c0a428d6be613758e3a1d6510bebbd6eb33ad3798621ba5a0147389eb4a565503213a8cd391c0896dd64feb7221e25dff795671cf193d970b" + "0x01f86a870c72dd9d5e883e82013708825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c001a086bdb289e75a85bb6f3b4f8b6c2749f65e4b15e58eed8cc66c2ba2d6f5de8ceaa069b4015ac783ad4aadec56b02eca50b0a31b82b72199b09043fb6ba2f4b8e00c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8833,28 +8888,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x69c23b6cef19f994ec1120ebe41647daae8fc602ceeccb500bef3599ea8dc4d6", + "parentHash": "0x9f54ff65564ec9e51c194c32c07d73fa64f558ae0df769401105131d1f438d44", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x96484f33b10331b3839e43593cccf2809ecb6e009c3a8b0de26dae14f2b77454", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xcbf9bef3ad12460cbdc3971187c32f61429c42c3bedd417d57e066788b99b0cc", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x118", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xaf0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1be678ea3efa6308b7fb5b3102651a8493462715c6b09f6cd9697efd05fc7d0e", - "transactions": [], - "withdrawals": [ - { - "index": "0x18", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } + "blockHash": "0x1e86080bc89bddf96fd5508dc58502c9062a2d3e496aa859dd0b10ed033ff085", + "transactions": [ + "0xf8688201380882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd109fa0a662f632deb3fef96f5ab89f3b020b503a4729d9db036e2ec67bba1bb1452df4a044fa3357f58f9bd405168dc003f6e1861a724212d0ba39b33ec537685f365a81" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -8869,23 +8919,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1be678ea3efa6308b7fb5b3102651a8493462715c6b09f6cd9697efd05fc7d0e", + "parentHash": "0x1e86080bc89bddf96fd5508dc58502c9062a2d3e496aa859dd0b10ed033ff085", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf6d58eabd98bd5598e385d578a8ff15f667d36691225d10c633f928d2d689ba6", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x6a7076fae4ff76a77d4f1acafc2da76a7050a4e5ccd3ccd0d3d637a51ca47aa6", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x119", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xafa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf776a4d1d5c352151872b684cb240fb3b7d163b655fd5939337a070a7c896d7a", - "transactions": [ - "0xf883820101088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa01549f55cbe39fb1cba5adf3e7f319c7d79d4fde019b360b322dfa2db5e155727a05961f7e708d6cfa0831a1ba4ad345c01627fc5b952c825aed42912aa8725fb53" + "blockHash": "0x5cb14068ec9e99fcb6e8e78e64cd2aea94f667888a9aa540844dfe0bc8a375dd", + "transactions": [], + "withdrawals": [ + { + "index": "0x18", + "validatorIndex": "0x5", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -8900,21 +8955,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf776a4d1d5c352151872b684cb240fb3b7d163b655fd5939337a070a7c896d7a", + "parentHash": "0x5cb14068ec9e99fcb6e8e78e64cd2aea94f667888a9aa540844dfe0bc8a375dd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x18cd75fc41ff27a21a24a3cfb6bf9ee4635411cabd10c7519fbea1d7faea8a80", - "receiptsRoot": "0xeee70baf6dc22b8457f4fe7e2b8f1e5414f56cd212e6b199d50e0a88c1ad764c", - "logsBloom": "0x00000000000000000000000000000000000000000000040000000020000000000000002000000000200000000000000000800200000002000000000000000100000200000000040001000000004000000000000048400000000004000000080000000000000000000000000000000000400000800000000001000000000000002c00000000000000000000000000000000008000000080000000800000010000000000000000000080000000000000000000000000000000000000000000000000000000000000100000000000200000000000000400000000000000000000000000000000000000000000000001000000000000000002000000000000000000", + "stateRoot": "0xe5e70db521666aeb73a06f9c286b7502fdacb311fdc60efac8a8da590cfeb160", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xb04", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9dc4808f611d1b29c89fe57085c64ec7815675f779d602734d45848babdaa5ce", + "blockHash": "0x44aeef6943cd37a6ffff1de2e0904beb164a461631b591993ab85ccb86abf4f9", "transactions": [ - "0xf87a8201020883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa06595f7a77a4e8c661b3e414b74d407c99eaf12519f8e25800117c63249b616d2a06f667e8299ab690f9e8bca562a0931b49ccaab00bbf3ac4e18a3370d0a7259f0" + "0xf883820139088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a02d4e1f125fb474ed8d60cfc496faf39035ebcd57af5937887ffa2ded09bcde39a03d5597e69b61d3f7abb3383a20338375b913743918ace209bec0c8d0f4f658b1" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8931,21 +8986,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9dc4808f611d1b29c89fe57085c64ec7815675f779d602734d45848babdaa5ce", + "parentHash": "0x44aeef6943cd37a6ffff1de2e0904beb164a461631b591993ab85ccb86abf4f9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x22e2c1b880fa2a250f7d054acb7ef6b8111655409519759fc81d381890285875", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1d45be906d2849f6e3161e17312a2fd977b60a55636ce6cd70eed8549bfee233", + "receiptsRoot": "0x2548b2c4f6ffcaa8cae3f813cc2f88574ccc98c9cdde87e4418a4066a0bcea20", + "logsBloom": "0x00000000000000000000000000000001000000000040000000000800025000000000000000000000000000020000000000000000000080000008004000000000000000000000000000000000000041000000000008000000000000800000000000200000000000000080000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000040000000000000040000000200000000081000400000000800000000010000000000000000000800000000000001000000000000000000000200000000000000000000008000000000000000000000000800000000000000080000004010000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xb0e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe015df4bb2e84589a3bf64fa91b73091581910b42e0ee91f1d6cf25912d60027", + "blockHash": "0x61e5376ab0b484c9dca320837e8bc9dada91f2d60b550767d26adf500f5df996", "transactions": [ - "0xf865820103088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0e0be39b51a060c97c9269d342c0afbbc6dd2435241c31100c744a50ff3bb560ea04165ba1f56b87012d4bb382b551a94e4f01f7a6e59451039b43c7a4b29a18b4c" + "0xf87a82013a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0eff406704f79d3f4db5be64f739a44fe6eceee562491b506795e88167f139e25a00cf97cfb7cdad504262c0d23737384042a1d4c3fd0fa4df3cb7ad6a96d54521e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8962,21 +9017,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe015df4bb2e84589a3bf64fa91b73091581910b42e0ee91f1d6cf25912d60027", + "parentHash": "0x61e5376ab0b484c9dca320837e8bc9dada91f2d60b550767d26adf500f5df996", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8bd72ff011c3ef2840fabbc5a422d1083fd40fe66ef36041c5a26d8555a54224", - "receiptsRoot": "0xa521888fe7f59d6f4ca65e0a1e98a920cf3352adaff79f113375281dcbd20b5b", - "logsBloom": "0x00000020000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000020000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x7cd71e8b07b7bb3fa70ed94616f4887bbfa4a6cce6facaa44e6865f59ae037c6", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11c", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xb18", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9f3faf24dbf97542f5dcac91d35da491af51e24504e58f42c328ba2758b0b268", + "blockHash": "0xeb675d937511476e7fcc82eec7615c2910d74026ae57a3fd9e144ec4afc45a00", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201040108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1787f004c4316268656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f0ca8a88096a033508993a424f4e40ee1d800f62390dfe4ed5dd74a0f6785e2580a0c0ef0c887b5a20d77bce56cc1a830c3e40be563bdfd1869dc8b7b844f8f87974a059b3da2bf65afd778bbe63dbdd64af23a66818ac2babbcf63a0d241a04eeef37" + "0xf86582013b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa05732694bc88f7cc2644b44204bd328078810fb3926618d4ffdfa3e03ea000bb9a01010ef4bcf3eadac81e801f0c25e44a20dc4bd033f17e4ed09e3a0ac5a4b016e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -8993,21 +9048,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9f3faf24dbf97542f5dcac91d35da491af51e24504e58f42c328ba2758b0b268", + "parentHash": "0xeb675d937511476e7fcc82eec7615c2910d74026ae57a3fd9e144ec4afc45a00", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x25ad05d939524d40cddd283c1a7d67244e5dabb0c3e91442fc5b3259f830bdfe", - "receiptsRoot": "0x2e98deb47717de4589517376b85dcf871454659477b5c5c389be57ce31fa4dc8", + "stateRoot": "0x167eaa4051016ad131f5b603d25a900155c045229531514f479eb9b7bbb5aa5e", + "receiptsRoot": "0x5d14337c2d0d5f4da33e745c879800c2634b055d0f71545f3b3618e639eb1b6b", "logsBloom": "0x00000000000000000000000000000000000500000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xb22", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x594c9091455bd0cd08631909cab257feeae3a05401a43544e423c759be125f77", + "blockHash": "0x1cafd78ec641f4af5d4f70f2a69c94688dab74feb7d64115401f7cafec61c7e2", "transactions": [ - "0x01f8d3870c72dd9d5e883e82010508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cadcad3ba169a8a51656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab94201a023c96758cd5fee077920a67e2ff017fa227e63f7486eb5f696507a64d50fad86a006755b6e7016c5e2d1532ef8bf3868845066ae9697920deea92230848988c6ce" + "0x02f8d4870c72dd9d5e883e82013c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cadcad3ba169a8a51656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab94201a01918dbeecc2f61b5e9e696225c1c5f13090a04891d9a4393892109a8163ff3f7a0639e9ec95866c6dca604fb9798e992dd1989b08ffc54299a1a6dc1a2f94498ef" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9024,29 +9079,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x594c9091455bd0cd08631909cab257feeae3a05401a43544e423c759be125f77", + "parentHash": "0x1cafd78ec641f4af5d4f70f2a69c94688dab74feb7d64115401f7cafec61c7e2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7d09b29b87c32bfcf4565856ff0ea4de4f86cfa15376b1f386adf7e193408f83", - "receiptsRoot": "0x84ee5d98c63a630bb6674d0045378f8ddedb2bf68b7f89189eb4477927016868", + "stateRoot": "0x775c80d1a80b1c76fe2f1c0af49b49c4a8e7405bd8090d956d047e998795caac", + "receiptsRoot": "0xd847ae81e705bf592e83e07e114adb8ef9d33af6da479f7c3963828da86d7c41", "logsBloom": "0x00000000000000000000000000000000000000000000040000000000800000000000000010000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xb2c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1f1d279ca073fab2be1f425ff8c09696653b77632516524baee6171427d75532", + "blockHash": "0x437f7e43e11d7d3c69a7449e6cf3bb70f85495c6f84326ec4300833a445c7d8e", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201060108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c8443769f598e5687656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a081260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a00a4d0dfa4ef6445e63d10894fc07f68cc4c8849d23419c3d055690cad04445cba0463eb2a9bf761bfe759d65ce21ac7036ea3624c89321931dac40082f1bc24988" + "0x01f8d3870c72dd9d5e883e82013d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8443769f598e5687656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a081260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f980a07b3fc599b095127e4e675563db4952e2c13c30485fc0e4ac434bb3d175e129e8a03ed2d1e42886b4ec6a6b828f389d4a27849e8487598d5c01c0a1bc5b2c026f5b" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xadfe28a0f8afc89c371dc7b724c78c2e3677904d03580c7141d32ba32f0ed46f", [] ] @@ -9057,27 +9110,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1f1d279ca073fab2be1f425ff8c09696653b77632516524baee6171427d75532", + "parentHash": "0x437f7e43e11d7d3c69a7449e6cf3bb70f85495c6f84326ec4300833a445c7d8e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6d864643a0d723539b741f6ec461b719d9ec8b15954e446782bdd2fb1daf9657", - "receiptsRoot": "0x05a287c710d49390a940418bb5b4e9156adcb109f5fd95e33bf9032646f7bf19", + "stateRoot": "0x8cde4488811e966f0881d87ae02ff4dca1a2aef4f11a854fbe9cd0659f553d67", + "receiptsRoot": "0xc99124f8a46ba081e312e6db1e41f758085537c17dba467ece154417c33b0a81", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000080002000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x11f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xb36", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc48ec13e43df85d25ae98c82d9ef4c2d1d09195aec3de87dd7b36f9cb530e234", + "blockHash": "0x28c467c36d5a76c1f47784655e0360553564b11d092613b84636d27c005a64d9", "transactions": [ - "0xf87582010708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3f20aa6ef3a2d29e656d69748718e5bb3abd109fa05be6a5b4b3ee3ed08965f80adff402ac1d4c42bd388b9c5ad8e65d517ee676e4a01275191545b88aca4a31f12601a4d515bf666a03c61639d0832acd2e9fb6abc4" + "0x03f8fa870c72dd9d5e883e82013e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c3f20aa6ef3a2d29e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09ebbf91a66183d0d37b03faf46daf8fe238c1aa2b24e6663dc14e50557d432c783020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0944a43418c2a82928098195bcd1063a0d4d5553ff905a4772c55031d9b5e188ca0269be874b42c07952b5bfc61303a8ac6ed2aefe16fd234e88f97478436f78795" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xb264d19d2daf7d5fcf8d2214eba0aacf72cabbc7a2617219e535242258d43a31", [] ] @@ -9088,21 +9143,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc48ec13e43df85d25ae98c82d9ef4c2d1d09195aec3de87dd7b36f9cb530e234", + "parentHash": "0x28c467c36d5a76c1f47784655e0360553564b11d092613b84636d27c005a64d9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5db606d71cea1cec324482204654ef78a867c6eb0f07f449640020833b509661", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xf69a897df14993c56451103689053946df7a09c574a10f197c1956e036db6322", + "receiptsRoot": "0xe608d9463d18b52caf248aff389704e7a8d431adce9046d407a3929c168ffbae", + "logsBloom": "0x00000080000000000000000000000000000000002000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x120", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xb40", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x082ba48558d19f6911b12db3e969c8f770871c5836cbd2a02d6686624c744c88", + "blockHash": "0xdcfb02fb51c962c7da9968cb094da0deead9be715cd80fe4edb15316afe5abd3", "transactions": [ - "0x02f86b870c72dd9d5e883e82010801088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c001a02c524f745ada3ce6c926875babfecf9f8756339cd21fb66cc4ada274d84ffbcca07b3c97003cbd3a0321f3d2f927dfc68696d17600b8c5f9cb0f785d188f75d530" + "0xf87582013f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdb7522f95019b619656d69748718e5bb3abd109fa0028fb8a95e9b6be0f40433e37016b9d8aec371876c9efb6d542acfd11a6f5a63a0681fd28936f71c4e26b68dcfb31b01deec00398390ea47791fe6c670133cf93d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9119,21 +9174,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x082ba48558d19f6911b12db3e969c8f770871c5836cbd2a02d6686624c744c88", + "parentHash": "0xdcfb02fb51c962c7da9968cb094da0deead9be715cd80fe4edb15316afe5abd3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe45abb3f86c7ca4f95eba76b969b2b194ec3b8b90e0562567c04502ce0203c9f", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x162e360af683c5a166d055477db0cc06b05117ed9bb7b2558930f81871a5b778", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x121", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xb4a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1e9ef85d67a81bd278cb21a68a068060358717f518aa9a31059b0ea52e9470f5", + "blockHash": "0x54e726c63980affe15f4fcbf0649b8839b2cec81fb03ff9d4885c49c0c13e49b", "transactions": [ - "0x01f86a870c72dd9d5e883e82010908825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a079cd6136faed0aa7f90de446a33df400fc30558589ea33c79ee41dca8ec1904aa060c35b52f54ade9734135680f625dd5790fad894704e08a9e631a53d6aca1de3" + "0x02f86b870c72dd9d5e883e8201400108825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a074086a3abc29275ddd4ca998950ba0189b06bf9fc4fe60336541e33abb96a44ba06021836d2af3aa84c9649616dd1248c020ac4b17b9b04af339f48afb9fecdaba" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9150,21 +9205,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1e9ef85d67a81bd278cb21a68a068060358717f518aa9a31059b0ea52e9470f5", + "parentHash": "0x54e726c63980affe15f4fcbf0649b8839b2cec81fb03ff9d4885c49c0c13e49b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2412974147eafbd2d6c512e7832d37fa6d15590e35d393651b5548ee0f50e940", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x67989baebf9aa997591e0226162add8feffae878efc188ab93d2a22ef07e5683", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x122", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xb54", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x92ccd6105a6a3d6636516fc3de3d1d5b83476e27c6c15f0d1f0a4ac3cdb77f96", + "blockHash": "0x0d07c9bc86d9d0dd335a1d0b4af655218071687d5aa6a1bee5c9dcf69479624b", "transactions": [ - "0xf86882010a08825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c01808718e5bb3abd109fa0e48eab7a2337ecd9a7d93785dfb1a302c4ded058ec53dfb818fc0c5a30eb53eca027a97d55006822944807657fc6326c6f5468c9338f28b9922e7cbce40d184201" + "0x01f86a870c72dd9d5e883e82014108825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0ff1a23dfb62a03a09b014b4bf3e691fbe52a6b78da07ad989de34eaedcfdbabba0331d3bba364e174c4e7b0776864c8abdc389a33620ab9e301cc0fbafca7dbdc9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9181,28 +9236,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x92ccd6105a6a3d6636516fc3de3d1d5b83476e27c6c15f0d1f0a4ac3cdb77f96", + "parentHash": "0x0d07c9bc86d9d0dd335a1d0b4af655218071687d5aa6a1bee5c9dcf69479624b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x190e225db93099517b36effe3f597034d5fe7fd0f772595c7a2d772a3bafdb69", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xd306e642f35fe1a4e613e1090c7c530bd153926e736d8892a27df2f21e712430", + "receiptsRoot": "0x642cd2bcdba228efb3996bf53981250d3608289522b80754c4e3c085c93c806f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x123", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xb5e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x59eb05ad455dd8785b7a82a8ec0b14908b49b9b99b89438e48a64f2c35dbec5f", - "transactions": [], - "withdrawals": [ - { - "index": "0x19", - "validatorIndex": "0x5", - "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", - "amount": "0x64" - } + "blockHash": "0xee4bde5bb8d77b4d171c88650704849bc8308792022a9e0df731a264b6d986a7", + "transactions": [ + "0xf8688201420882520894eda8645ba6948855e3b3cd596bbb07596d59c60301808718e5bb3abd109fa084430de15b72b4529fbbc01601d015a6788bbcd471aa9b921c7b7d816fc71ca0a079bf52bdf4c4bdd192851e1e50b9257e6f6bf9a0d0bcc94eb73002ac5a9275c1" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -9217,23 +9267,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x59eb05ad455dd8785b7a82a8ec0b14908b49b9b99b89438e48a64f2c35dbec5f", + "parentHash": "0xee4bde5bb8d77b4d171c88650704849bc8308792022a9e0df731a264b6d986a7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x602b8a0196a45e1c76fcfb3da25e5ab5577be52d365fbd68a7574f02fd9c5a21", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x0c1c56ccfaa16e9979041c01127f074290f865d4ae7592866ee323ce8f87b82d", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x124", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xb68", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8aff95cd5730ce6970eca865968ba524b1e66c7688319793c6edaa11791b0a33", - "transactions": [ - "0xf88382010b088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0c0d1b53f8fa79401d3b27c1e82ed9e037a75cb9b147879399c9fe3c1084e8357a031aa98f702ea2eb4f7940dac34ac8c9d1ee30292458599593b553534af013f67" + "blockHash": "0xed908adb5661b69ea32366f362a10182a478af8b7ae01a870be3ae36c0a4138e", + "transactions": [], + "withdrawals": [ + { + "index": "0x19", + "validatorIndex": "0x5", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -9248,21 +9303,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8aff95cd5730ce6970eca865968ba524b1e66c7688319793c6edaa11791b0a33", + "parentHash": "0xed908adb5661b69ea32366f362a10182a478af8b7ae01a870be3ae36c0a4138e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfffd80f0432d0b41f5c21f59c2310f41a6d0f518a02fefecfd70a262d28bd1b7", - "receiptsRoot": "0xcac9bc12b1a5ea1f1749945728fc4827d6be026580117754514f28543ea90065", - "logsBloom": "0x00000800000000000000004000010000000000000000000000000000000000000180000000000000800000400000000000001000000000000000100000000000000000000004000008000400008000000000000000000000001000000000000001000000000000000008000000000000000000000000000000000000000000000000000000000000090800000000000000004000000000000100000000002400000000000800000000000000000000000000000000000000000000000400000000200000000000000000000000000000000000000000000000000000000000002000000000000000000200000040000000000008008000000000000000022000", + "stateRoot": "0x4f6a1ce7ef10269593a283f75ef466c9ba84d79f3f845a12b4d1f7162acba87b", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x125", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xb72", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe9652de769d861b7ae1ff71d6086d0049ff01ee57126e7b37f8acb1009efdcb7", + "blockHash": "0x2aaf777b8b9baa765e6c315b77d2ed0bf12654e466a9f5d9a4b3892c34d346ef", "transactions": [ - "0xf87a82010c0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0bd455370a23cf28aba44289a9d2d01f09d02e24617a22c876330c1a634e5cfe2a0533da1d94bf07e6d9f5c1fbf84ba789600fa7db1d43672012af0c66c72ae610c" + "0xf883820143088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa03fd1ed4657ffde9f278a6dbd7498fbd9178afe039cf507c14562ed99832b0650a07ab31ad66326ea0083695f22435947c3f55b501c16febb9fd763573b86ad5390" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9279,21 +9334,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe9652de769d861b7ae1ff71d6086d0049ff01ee57126e7b37f8acb1009efdcb7", + "parentHash": "0x2aaf777b8b9baa765e6c315b77d2ed0bf12654e466a9f5d9a4b3892c34d346ef", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x223b61f461d72039063ef208e4d34ade4ab6182ac9286802e92e34ed451da91f", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5ded562d3f6efa30dbf5691e43a3c2209bde0e1ea1b7e7e613703197991d351d", + "receiptsRoot": "0xd978bab18927277656ed7e13f23ec0784c693d4aa84da97132004c0e3c499947", + "logsBloom": "0x00000004000000000000040000000000000000180000000000000000000020000400000000802020000000010000000000000000080000000000000000000000000000000000000000000000000000000001000004000000000000000000000000000000001000000010000000000000000400000000000800000000000000000000000000000000000084000002000000000000024000000000000400000000000000000000000000001000000000000000000000000000000000000000000002000000000000000000000800000000080000000200000000200008000000000000000000000008000000000400000000000080000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x126", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xb7c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x62defc14b1b4b19b963574f0ddbe0b887a8017d28661a9d889c55729a388a40b", + "blockHash": "0x833f91460ba1a4d3754963b49508167d180860494029996788dfe0a4b7c1898f", "transactions": [ - "0xf86582010d088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a05c79f636d4fff235cf268f4628807ebaf6f678544021908341b8042efc4b4dfaa062ccc5326a5c336e6ec4c42b4c5914b316ccb5a01241a866d21f447b4bc4f828" + "0xf87a8201440883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0a8b9c241eaf3e71ad4fd47ef1b71de7c8907a9532b5cc8a28fcdfa146b511503a06d4416bc1436c0ab12d096e4489e0d213122e05824adb8ff95a01ac9e2d42242" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9310,21 +9365,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x62defc14b1b4b19b963574f0ddbe0b887a8017d28661a9d889c55729a388a40b", + "parentHash": "0x833f91460ba1a4d3754963b49508167d180860494029996788dfe0a4b7c1898f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x24c2880a28d4e01ecf7bfd004e4dde71ac8b2eceae57ca38aef54b5cafaafb68", - "receiptsRoot": "0x9f1aec51311c99ff2556e7ae510cfc0e13b0b9568362b661cfe1caa4d333b386", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000008000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x7e9f3bc83383ca95fe5653f585731fb296de3048f13503b0a6009bb7729cf9fd", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x127", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca90", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xb86", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x98539ac0cea39c8cc5774cb783fa5993c03ab9e2dcc9e2e24ac18d9af67dacb6", + "blockHash": "0x55415e30e330b78eea4143896ca20531aa466962f9e7c270892c0c82b9dc52e8", "transactions": [ - "0x02f8d4870c72dd9d5e883e82010e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5d741e496f004f3e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d2dcfcdea157f70f8422558eb02bdc6a503cf24126f8f2dc2b52a644f5f0227101a03988ba449890e872876769b683ea83684aa9dfab1698dbe8c583052e14772fb4a02965eafe834e54c031b9d56a8ba549ae0e0947f8cdab83a52f5ff3057da40ada" + "0xf865820145088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0fd89b49a61d6883e8494ee4e49b923a929d45b1f213cd7115cc4c71bde233cfca04bfdd7ef8f5a843b7c774ac0b4d6277670d143664a6f0e44ee875b412f62c441" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9341,21 +9396,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x98539ac0cea39c8cc5774cb783fa5993c03ab9e2dcc9e2e24ac18d9af67dacb6", + "parentHash": "0x55415e30e330b78eea4143896ca20531aa466962f9e7c270892c0c82b9dc52e8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb2f3b4b778f8095c0150536a7d267de8df138835ae2815940481daad4a528535", - "receiptsRoot": "0x3eaa13309f383a89aaadf58231da7f07a8b193ca8772a87fb6c32ebf0ed7c164", + "stateRoot": "0x0490c1fa403a13e5798f6c58646769b6dc95070bb79d3a845f136f978508623f", + "receiptsRoot": "0xa7afd0b07e7a2e88b4d7cb98997e0de937a24ea996e160baa8b28357c6cf85e7", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000100000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000002000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x128", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xb90", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x84018a2df44823700329319d9aff27b73093f4284a45402e4a40958dde3ef298", + "blockHash": "0x3fbfd523742f263285774e53c795a95cd422dfcab3af25a98440ef2d9eaded1b", "transactions": [ - "0x01f8d3870c72dd9d5e883e82010f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c526ae023b07bd13d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec080a0d21b4680a8c217acd22a05694031efcabec0311ec4c932df9f776e1a3799ba59a04b555912c1ed496307b90b872a43cfc1b9fafbcc370dd9c65dc691ce6e54e21e" + "0x02f8d4870c72dd9d5e883e8201460108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c526ae023b07bd13d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec080a081642f28c9de3fe1723ef8ccee70c49bed708f8877ce676752d45beff9536f33a078e5303b3fa3cd8038b4acae749adaa355781910f0a3fc023b6fabd75af45827" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9372,29 +9427,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x84018a2df44823700329319d9aff27b73093f4284a45402e4a40958dde3ef298", + "parentHash": "0x3fbfd523742f263285774e53c795a95cd422dfcab3af25a98440ef2d9eaded1b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe750fcd9e9232f9f78e3710665189f967d03b76d8d8ddbd667e961b3c7e53a21", - "receiptsRoot": "0x0d0970d40d588ca540695901d111652461d1246630331bf30cb857868404e0f2", + "stateRoot": "0xf95f4921c08963ef37e942092ca3b4fcf53f0b11bac2d0c5bc0a420e0a3a4ba7", + "receiptsRoot": "0x5b0661634b1e9cb68a186435e4aa5a4bcc97a2b464a4c992a399499830e31c98", "logsBloom": "0x00800000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000200000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x129", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xb9a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe2c8b858ba858e6c7b73dbc23702f10a9a75117fbeaa447084be91921cfbe7f5", + "blockHash": "0x360482b09341ef1eb6bd12fbc2290c17fbcc72f8f1128a1f0eaedd6da6350c60", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201100108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c8a1488f31c40de0e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb183020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a05e89472cf12cb81f835386e94bfe860f236decc11fa90459166e73dbb264c336a0164dc5735512cbd95aaeb58f3e75044bbd10c59ae433dfa87179c1cfe915e6f2" + "0x01f8d3870c72dd9d5e883e82014708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8a1488f31c40de0e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb180a0b74f33715a3d5e6c5acb5487fe7f13ee89ee0d2dcc8e8c8178733081a59ab6f5a0758d36564ed54824326dfe5d02d8a45fef7a563564df9e25ba21693dcfd456ad" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xbc17244b8519292d8fbb455f6253e57ecc16b5803bd58f62b0d94da7f8b2a1d6", [] ] @@ -9405,27 +9458,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe2c8b858ba858e6c7b73dbc23702f10a9a75117fbeaa447084be91921cfbe7f5", + "parentHash": "0x360482b09341ef1eb6bd12fbc2290c17fbcc72f8f1128a1f0eaedd6da6350c60", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x917f884041821b758a575dfb1dc88c0b12796fdc1023c638ef6c9ad881ac82e1", - "receiptsRoot": "0x64750f5470b09938713b1ee31a83a785fc2d232be127c7f839bf78fe5bb0ab04", + "stateRoot": "0x42b2eebbff687a49e5ae924fcc9d17fba5ec8d503c2a07e3ec7623a0b50ccef3", + "receiptsRoot": "0x3eb919d2fcef89e2c1516e126d60ed91a86467b2e89e39d014d587c5388ff17f", "logsBloom": "0x00000000000000000000000000000000000000000000000000020000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000008000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xba4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0a1092b8900b3db78271854ecef3b6b400f1fec980047d9ff07a130255a910f2", + "blockHash": "0xe1a596d7fe5e0df44bd95f04d6e52f6942a3ca81f2c339e69436a1ab39b6cb96", "transactions": [ - "0xf87582011108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf9a5cb54664ef5f8656d69748718e5bb3abd10a0a00f564c0588a89fc970c508b4377f92cdae44a4d9da6d1ce161d62dcf4b7dc534a02343246e2d82d714b18ce75beb3115172b7f680be54ea957410cc4a59d97f75b" + "0x03f8fa870c72dd9d5e883e8201480108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cf9a5cb54664ef5f8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a094605c950838b2b0b1ce76f58acfb91a94c2aba787d02add7187360989745a4e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a03b8ca3a76add252f7bbd8101e13577794778385a8f1bbccb7064828def032416a02b89693ba23e931ff1c55436ea8b56c04db444414933dcf27aa7d5ac19c84d34" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x3ff8b39a3c6de6646124497b27e8d4e657d103c72f2001bdd4c554208a0566e3", [] ] @@ -9436,21 +9491,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0a1092b8900b3db78271854ecef3b6b400f1fec980047d9ff07a130255a910f2", + "parentHash": "0xe1a596d7fe5e0df44bd95f04d6e52f6942a3ca81f2c339e69436a1ab39b6cb96", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5b6235b02e42e778f6d3c97d4e08e717c74b4674a305652e696c84789a899abe", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x3b30cf8f701b20e556ba7642cd359cfe5c11b209ae4fa954fe9bf251e46d289e", + "receiptsRoot": "0x6c51b3f43a82c0424cf86ab4750ada1ab75eb4375120685c9031a4076901be2f", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000024000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xbae", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa1e26afee8565c8352f0dcc623e984f72d24e09e005aba99f916fdb7c3807ab7", + "blockHash": "0xab15736f5f9a88b9ee82577680039c70f6ee7a1a45bcef23aa00ad68f2c4c3c1", "transactions": [ - "0x02f86b870c72dd9d5e883e8201120108825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c080a0ff9e3913d23c05e13e847479ef40474942fb7cb8c8bbd8b6802587b50ccb69d4a02b1eb6dda4520f42c3b23c1c8334a1c0012b41370ae5652ebf3c07f3bbae72f0" + "0xf87582014908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4242e5ba3689784a656d69748718e5bb3abd10a0a006f0d8139bdc84c0e072ec2975098473df9fdcfbdc075b28f89ac9d94fb3ef6da00e30d4713b01d7958df25332fd92eb5d172eace2dd409b10fa28f2903890ab27" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9467,21 +9522,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa1e26afee8565c8352f0dcc623e984f72d24e09e005aba99f916fdb7c3807ab7", + "parentHash": "0xab15736f5f9a88b9ee82577680039c70f6ee7a1a45bcef23aa00ad68f2c4c3c1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x38eb1f6c274b1f9babffc45e581441e4896d82c332ec61d562f5f4e94e11bbf4", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x3223ad04cf675fa197ecf36289db8a47181442ff0a593bd6bf5959f306c8f451", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xbb8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdba21acb5043d419d3e972fad568d8e6179cffb0654e73c7f093a48877f38e9c", + "blockHash": "0xb09555539b48721618134671e9f09ca11c3473b6c972eefc61f7bf6e59901843", "transactions": [ - "0x01f86a870c72dd9d5e883e82011308825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c001a0cd7d371b7e0f8162c06104886a132576bf82ae6a13250bd07db3e91dd3eeb879a038ade257128163d69601b8640d431ebf72fc3b45d47a3276a23eac921a643f57" + "0x02f86b870c72dd9d5e883e82014a0108825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0caed21f372ee5c4593454ade30ef1ee8224ac2ad66bc1aadb1cffa7e8e50c1ffa022bf467d785ea97c1f2b00679c759242c9099fbe548cc079ec5cdb8eef24cb9e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9498,21 +9553,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdba21acb5043d419d3e972fad568d8e6179cffb0654e73c7f093a48877f38e9c", + "parentHash": "0xb09555539b48721618134671e9f09ca11c3473b6c972eefc61f7bf6e59901843", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8a186f5fa70bc32b4def07f2f57dc4f6179ea83d21554890bf9a7286f81638cb", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x4d11bf1d5f97964995316bbb0cb6301bc72e4654e1b4bff5ac56aaab9e534534", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xbc2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4d7b2d7c56da60a9b57c4210cdedba40311978ea1aebf519aac65867e16f6a3e", + "blockHash": "0xfd0af364faeb502cd7a06b059c730040c89c4bb60af5f9e432062745c47a1c76", "transactions": [ - "0xf86882011408825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd10a0a0fe2259e6d738f53a75a9a67fddb88bffd1ccf316b25a1666ae5e90d907128a0ca033c772738145475a5a6aaae112d3b1ee7ee5ef23ad1ec4c39b78632c1afdedbe" + "0x01f86a870c72dd9d5e883e82014b08825208940c2c51a0990aee1d73c1228de1586883415575080180c001a06e7e89f25881bac2942ebb15774d731ff658735063d2fc83af8a3b1e2cbfbebda02f005a584d1e67574a67f45d45c37e214ad520891e291a3a098ec7a675c09ef6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9529,28 +9584,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4d7b2d7c56da60a9b57c4210cdedba40311978ea1aebf519aac65867e16f6a3e", + "parentHash": "0xfd0af364faeb502cd7a06b059c730040c89c4bb60af5f9e432062745c47a1c76", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x74dfc7e86aea9f99ad82259ee8bca79aa19d7b9c129773af3bccb6ef49758f9a", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xb8f4b54f262266ac9a6a7f7251af900e88df5d053dba8951be923734fe45c718", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xbcc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5ee998d96985103ae9e6f31a41ee0d44a4da62003a63b5ff4f29570aa42ddee4", - "transactions": [], - "withdrawals": [ - { - "index": "0x1a", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } + "blockHash": "0xccc479403433e4222f2c1886e3707712822a3ac130f37263b277d7f42fedf93c", + "transactions": [ + "0xf86882014c0882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd109fa0c074d8b1d59a61ddf17c7cd6d9d6d155df7d22c6b02cf6873962860e76e4c946a06bfea57fd386eef123c608f5001b2540921441d7a5518602beaf671b55db011a" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -9565,23 +9615,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5ee998d96985103ae9e6f31a41ee0d44a4da62003a63b5ff4f29570aa42ddee4", + "parentHash": "0xccc479403433e4222f2c1886e3707712822a3ac130f37263b277d7f42fedf93c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x153776d17db6371e53f002afb53b2db67197ef79d802bf1500ea8cf0196cc1ef", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x98eea718b816a398d4eec814aed057da38bcf0d0ab9ec7f87ccc3467d3adcbc1", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x12f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xbd6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x81db24e85960807d0f347bacc0364a9327e64955fecca02ab5fcc55efdc4a37f", - "transactions": [ - "0xf883820115088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a08cddb5ad687d9cfb5635935429f6bc6f73da0d0f14602aedb753d50fb90c11cfa04481220f6b763ec9de7a2ea8a2e64af551a6b90dd3d95d135deab8442aafd85b" + "blockHash": "0xcac6455fec57cb7705d097952412eaa1e3984c8a50f703d4dc84d990e099ce9e", + "transactions": [], + "withdrawals": [ + { + "index": "0x1a", + "validatorIndex": "0x5", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -9596,21 +9651,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x81db24e85960807d0f347bacc0364a9327e64955fecca02ab5fcc55efdc4a37f", + "parentHash": "0xcac6455fec57cb7705d097952412eaa1e3984c8a50f703d4dc84d990e099ce9e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf9fc5c25631e000a316925fb6b7190dd60ad610dc5866db54c1bc91c412f1aa6", - "receiptsRoot": "0x8499e3e63985d28600cbd00c0cffcd173218e8c1df3db90d1ab97a16e7c6e9b7", - "logsBloom": "0x00000000000000002000000000000001000000000004000000000000800000000000000001020000000000000000100040000000000000000000400020000000000000000000008000000000000000000000000000000000000000000000000000000000200000000000000000000050000000000000020040010000000000000000000000020000000000000000000000000000000000000000000000000080000000000000000000010000000010000000100000000000000010000000000000900000004800000020000000001000000000000000000000000000000000000000000400000000000000000000080000000000000000000020000000000008", + "stateRoot": "0xce500d05e918d1eccdf5f44e824e036dae2f5a856441d076b3b0493383161822", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x130", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xbe0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9cbca6aa8b06935a740ab85580674c5cd4b2a840d078c92e005294241a7eac81", + "blockHash": "0xc2497bf1f6196ab87d85a9b1ea008b60687721f7bc75ab3fbf8de50d455baf03", "transactions": [ - "0xf87a8201160883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa039c0aabe6c9bd83ba7ce680430dae1ebfcd48db47589f2e66855d8869c0c9480a0175f7631a70797beed4bd4d075cadc7d86d638def72c6a2644cc767662bc24a0" + "0xf88382014d088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0aed77e1adc4d85735ae91736955ce7d4ccb4a821ca1a354af9c21126fc56d433a0159e0e1a7f5e2eb9ebe116a56a30ce40135336d305851afba8a65a5ea6a89788" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9627,21 +9682,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9cbca6aa8b06935a740ab85580674c5cd4b2a840d078c92e005294241a7eac81", + "parentHash": "0xc2497bf1f6196ab87d85a9b1ea008b60687721f7bc75ab3fbf8de50d455baf03", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfc236631b79f578cf1f730acf4ea9cd3083f4c12d72fa4d909968a88bfa2f1ee", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd5fd98b8df59ff1b25ae93c21f976b037e8046ede37661d1a5e5b27ffb7f8fcf", + "receiptsRoot": "0xd0d766b35165fdf34cddcbe108f063ac07fe182d2b3a2088dc66cbf65536e9a1", + "logsBloom": "0x00000000000000000000000004000200000000000081000000000000000080000000000004000000000000000000000000000000000000010000000000000400000000000010004000100001000000000000000000040000000000000000200400000000000000000000000000000000000000000000000000012000000000000000000000802000000000000000000000020000800000000000000000000000000000000400000000000000000000000000000000400000000000000000000000000000000c00000000002000040000002080200000000000000040000000000000000000000000000000000000000100000000000200000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x131", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xbea", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5121438babb00581bb8862b84bfedfa4d586d59b08f7de67cad8988693061458", + "blockHash": "0x42690f0496662b95458544ff5fa9db8e9839a90c142ba6e211b2ad2fd19a8bfa", "transactions": [ - "0xf865820117088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0e6ec4a35afc15586c4dd750e4610c8b5401687e10ad12f251a4c56f663a8d9dca04c89c681c9d15f4059cc1bfc3e0ccb2228b8d757e810671e8548d5c3ae36a295" + "0xf87a82014e0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0aa853c0c43255b1996de6db7e434268a8c78acf7d547e5f77804b1f9c56c163fa0490f9b0c07434c0d825892fc0d0d96adde2f67b2fe83bc28c5332d62ddced55d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9658,21 +9713,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5121438babb00581bb8862b84bfedfa4d586d59b08f7de67cad8988693061458", + "parentHash": "0x42690f0496662b95458544ff5fa9db8e9839a90c142ba6e211b2ad2fd19a8bfa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xac1f35c169de27ab0497059cb09328b0e2f70022723b371d66a94f99db12baab", - "receiptsRoot": "0xc60042a0f586b4655b929d1f35cf04df2a18799eb4ff8258d47b6b643ab92d14", - "logsBloom": "0x00000000000000000000000000000000004000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000", + "stateRoot": "0xff7e337033c82bba1ba7fda4ef78dcd73c72c96f4e4b280cc4a07d6d75b87e65", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x132", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xbf4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2c00478ccf60b7813adf88eae40d7f36cb2bb19d7d3a5e41904411d59f85b85a", + "blockHash": "0x5dc6a2e4dea9a9151cfb8dc58b8ad3e2e2c590f73ef3659f24bbd1484f5f51ca", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201180108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc45ec4c5c9153907656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04d4855c520c09f3435e2cb46ceb4d2a12df59c127a1f2e871e7e9e8203fd6ce180a065dc63e2ecf0ec0098c02f9d874bb7809d9ea529e99a35efd267944f9f021d6ea057461847abc4de428ee5deca8fa2a6dde61d653ee897a03134d6ab1111edbcfe" + "0xf86582014f088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0f811ab125d628afb503e72fc03ffcf8bf0c94b9278b04a80d4583b5bdca47058a011ed1658949375d5f114abafe92733343e1e9decf853394a04e68b8b7fe1d945" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9689,21 +9744,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2c00478ccf60b7813adf88eae40d7f36cb2bb19d7d3a5e41904411d59f85b85a", + "parentHash": "0x5dc6a2e4dea9a9151cfb8dc58b8ad3e2e2c590f73ef3659f24bbd1484f5f51ca", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x09ae7bf54009cd877f0f4133dd934f1a7ffd44ce1700eca8ddc4fc3dd47a9138", - "receiptsRoot": "0xc6bbe32048f874de5ca9d433a0888e2d71c39fa006e27ba75a563a3f15860984", + "stateRoot": "0xb7f91e8621bd652b26c1cd38102a0da65f88cb5f181daeb52efffcb0b87117a7", + "receiptsRoot": "0x8f4bc522aee40a55d1ea96544b202ffe7c48a27588ca8e0b6280f8e8771d0953", "logsBloom": "0x00000000000000000000004000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x133", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xbfe", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbd2d25d7773172160974f1a8b6b790c629e44a011321c53a0cb08888b9cac459", + "blockHash": "0x170d3dd10df213b71da46b8d94023a22e58c3366eac78c70b095fbceee126712", "transactions": [ - "0x01f8d3870c72dd9d5e883e82011908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce355c4e09ad571c8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a038570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e880a021fc4049285e37a5ffddc71b565a74354b78b3ae23768ddd78f4f89769cca8d2a0506f4888cd6ac4b74e51e1fd2f41c9413ac7dc3e7164594bdd19a9bddb0d13a7" + "0x02f8d4870c72dd9d5e883e8201500108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce355c4e09ad571c8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a038570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e880a0352c735b38d32df5bd6596e8984191065e4da2d6e56547f409c217868a0f56bfa05a618d58a18225ddf45f3243a69200f85a04e21a2778b3434823c21a18925a1e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9720,29 +9775,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbd2d25d7773172160974f1a8b6b790c629e44a011321c53a0cb08888b9cac459", + "parentHash": "0x170d3dd10df213b71da46b8d94023a22e58c3366eac78c70b095fbceee126712", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x447376f436dbcd45154e2d2bcd6ddfe920e413f2ef9a075ba4caae45548871f5", - "receiptsRoot": "0x3ae89f3114f462c13ae1e0805dbcc594921657a098d21c128f119a43a13ef1d7", + "stateRoot": "0x4f8e99267b3f2c937906657a584aeb5e96845da3109e7f0f8cb517e571c70fd4", + "receiptsRoot": "0x1d42b78a784f6ac9a2e208af5dbdce6343dd4a3bc391338f5010f590e5dda60d", "logsBloom": "0x00000000000000000000000000000000000000000800000000000000800000000000000000000000000000000000000000010000000000000000008000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x134", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xc08", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa8a4ee8234dac48e460f619c77d02008ff818db6cf1a0a80de6a81af3e0d7e91", + "blockHash": "0x42e46e023d7d24d978c93644717729a7fdcb0e07c67e390a2c6699c4cb7fc7cd", "transactions": [ - "0x03f8fa870c72dd9d5e883e82011a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c7906a8e7d74f757e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0befb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb54683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a007d97ba541e40dea07923e06265c253c519d279feb2e3e53a79e72946e3b66ada06f694b98cad48d402d39ce4d034fc8ca75f5ebee4b4bb9b1a2eb67c188a49435" + "0x01f8d3870c72dd9d5e883e82015108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7906a8e7d74f757e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0befb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb54601a0d25ae0523675e0fd64ad02bf5d19902816fc5d0f836981b8d57dab847a15338da001df53840599b6eb6e5daa0a0ecda3fd0f24226b06cb0ed473458dcee396527c" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xf6342dd31867c9bef6ffa06b6cf192db23d0891ed8fe610eb8d1aaa79726da01", [] ] @@ -9753,27 +9806,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa8a4ee8234dac48e460f619c77d02008ff818db6cf1a0a80de6a81af3e0d7e91", + "parentHash": "0x42e46e023d7d24d978c93644717729a7fdcb0e07c67e390a2c6699c4cb7fc7cd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf90b6e0f42a055c9b33ca1ca15998bf55c39408aa568028028daa46d9ff67c14", - "receiptsRoot": "0x0afed92b676a3b1e3c4945631c2f35f307b341f6fcc961101935f91fbf6a2475", + "stateRoot": "0x017c09a63851eb3673e1252e64d50010ba08eb374d930344b1190fb2d908c255", + "receiptsRoot": "0x1289b9de706c4e04e62cb0d571c3b3d1ca2855f8d4b220daba7d185a8b6b14c2", "logsBloom": "0x00000000000000000000000000000200000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000008000000000000004000000000000200000000000000000000000000002000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x135", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xc12", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x11ddcb0efb438a2965ba558170ed3ccb27ac43bc3f7028628edcb3406a1d4623", + "blockHash": "0xa7c1b6d6c5d4fc516c4b7a9e6917a1929957edf45107e164fc0768578e4e555f", "transactions": [ - "0xf87582011b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c34cb6faed8212f15656d69748718e5bb3abd109fa09e8eed2041c0b3fb16bc35e8ef8410ba6a311729651c095c3dd63a2de47e79c8a056b251d337e880ef0a3377774c6b911689f29cf74fecf094438e39f5d59c2cee" + "0x03f8fa870c72dd9d5e883e8201520108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c34cb6faed8212f15656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03eb32abcff52bfdf0887e9aebaeeaee4a61b76f2fbc9a183c2afc8552d46c3f683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0fd544670525ed6d6fb445354933e077363014839e878ea0cb8f610c2338af4d3a06dd8877e0b44875d49819c17c4a79181047bad799c836c69ef605c70ba23b859" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xa6589e823979c2c2ac55e034d547b0c63aa02109133575d9f159e8a7677f03cb", [] ] @@ -9784,21 +9839,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x11ddcb0efb438a2965ba558170ed3ccb27ac43bc3f7028628edcb3406a1d4623", + "parentHash": "0xa7c1b6d6c5d4fc516c4b7a9e6917a1929957edf45107e164fc0768578e4e555f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1e2b5442751f07806f0aa28e34525050adbff63fa3f8e6a882c3915d87656f05", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcd8b73cb5b48d69916d97b098deda61b10f5e3f21fec80cfd678ef5b7ffce38e", + "receiptsRoot": "0x86c42eb55a78f125fe8441afa55d1dec4b294bf9314f70ef52ddb716188ec561", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004400000002000200000000000000000000000000002000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x136", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xc1c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xccff97103894795edef27f3a29b05a2109a4f024d3c935233faff6be394b92f7", + "blockHash": "0x0762831f8a197faace5f89136d4e8fd2bdbcd634050bb8c28593c6f62769c2f6", "transactions": [ - "0x02f86b870c72dd9d5e883e82011c0108825208942d389075be5be9f2246ad654ce152cf05990b2090180c080a00a17151e389df51a00e7bf3feadef3191ea0ad38ec1be3fd7476baacdfe7d8eba04cdbe251df1c62cb3f1d59821bc6353909447d7267a172254f184967500e515f" + "0xf87582015308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb731385f04d97db8656d69748718e5bb3abd10a0a09abe467beb55df0823716b56ef94e1034cb4caf9f8f2befb3d03fcadae7f6f02a0548c60031efd2568057a7b428586bc61a539482aa759896d0885be892488ea46" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9815,21 +9870,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xccff97103894795edef27f3a29b05a2109a4f024d3c935233faff6be394b92f7", + "parentHash": "0x0762831f8a197faace5f89136d4e8fd2bdbcd634050bb8c28593c6f62769c2f6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf595ac6b9f66304ef0c2e38e43c9b96ab2360dc87317a74c84eef96614e093c1", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x347540851d85d8e1a3f6aecbe00a90100a88748f66ac59dfc2175dcb2ac705d8", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x137", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xc26", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xaac581c002035b4c80879f87a1418a3129921f493472482a52b09d0fb6233f04", + "blockHash": "0xb534a77d9471e828befa7adf86678b4a7a928e2a2db3e9ccb919eb0d2e2d7131", "transactions": [ - "0x01f86a870c72dd9d5e883e82011d08825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf0180c001a03cb049339eda9bb3c16ca7a3cd92102728378f3d2d232f60d3b45323d821eb8fa004242cea89f245dd65d9a0180c437b23e265a262607b7785eab2683e1779fe1f" + "0x02f86b870c72dd9d5e883e8201540108825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf0180c080a027b3576746e2090eb8c591f5218834c24fc8e546cc326cd47c3d549b0000ef86a0483343082391b0902e7685358a12b24bfe74b84c21b75178790b6127f082858c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9846,21 +9901,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xaac581c002035b4c80879f87a1418a3129921f493472482a52b09d0fb6233f04", + "parentHash": "0xb534a77d9471e828befa7adf86678b4a7a928e2a2db3e9ccb919eb0d2e2d7131", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7965f70a4268dacdca0ed3c4136a4d8c56dea966fdfa0bf518bd9404481270d2", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x86cc1c8ec7b8a9e6864a885a24a5ad32131aa338b242b21b8872784f5ed964a6", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x138", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xc30", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7e3909c2f8ede6f928c0820363dbd9abb712eec9f7be844bfcf8d3d04a538bfe", + "blockHash": "0x797081f69a1e07e62ab7d70958e3840489579027770db2acd79ab7da50c5684e", "transactions": [ - "0xf86882011e08825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd10a0a07eb9ca4cb5e5dc6d8a4a12a87d3176e97df25a11cef96653b54f5764840d31d9a0173cbdb2a5bb18932a30b3826c0fe27605f622eca7dbc36c42fca92e3ff94e0c" + "0x01f86a870c72dd9d5e883e82015508825208940c2c51a0990aee1d73c1228de1586883415575080180c080a0bd50cc3348f9c4df62c2b6819da09ad9f59d6f664ac93d858cd9c4a8a7712fb1a00dd838cd7e8b5f7ea87752357dd50603a9dba395f44148b5d074c04041d45be3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9877,28 +9932,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7e3909c2f8ede6f928c0820363dbd9abb712eec9f7be844bfcf8d3d04a538bfe", + "parentHash": "0x797081f69a1e07e62ab7d70958e3840489579027770db2acd79ab7da50c5684e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x12fe5f9fd18b1d449fd3c25d815c065e9782e2c28cda214d77b45560fc932896", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xf427430575efd44fff9c42db0eef2fbf16eed6170dc1f0c9e27740493e64c2dd", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x139", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xc3a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbd1f3e51c77a927fc30973f8452ada7e030b8452273afd75dff18884af8a204c", - "transactions": [], - "withdrawals": [ - { - "index": "0x1b", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } + "blockHash": "0x0ad3abab22df80481936bb2a0d8b50a807633495c41ede9d1570c25b59fdeaa8", + "transactions": [ + "0xf8688201560882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd109fa08c1fffe0d5b5dcddc5c7eec0cd0e58e596dd46e45cb71629b3a03bc43b0a03f3a0773aeca142fc242046765c6bd72997f60eb5aa72a136b641efd1c790cb6146db" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -9913,23 +9963,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbd1f3e51c77a927fc30973f8452ada7e030b8452273afd75dff18884af8a204c", + "parentHash": "0x0ad3abab22df80481936bb2a0d8b50a807633495c41ede9d1570c25b59fdeaa8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3bbfaf4efde9a24437c51d9ae86ad6bf8287f5ebbd8fe8ebc15c3619a602c6d6", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x0895c6fd3c63f4ac032cf4c14fbd1b4bc865f40ffe4ac85d47238b2eb763fa79", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xc44", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf976366428e1f9e79b69a03a333c3ea2d57804cafad16ea0301def95480afa16", - "transactions": [ - "0xf88382011f088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa02e045ae41ba056fdd3328bd0ac90d86f6f3add947c60dc848d79fdc23e242a84a00bf35d683f8fd6a4e287c87c7c8bccb31d736c126602c55917e4641e902124bc" + "blockHash": "0x5d7d1a0c180dbae5272ccc6e6c01b45960408a2205e36e897320813cc1627af5", + "transactions": [], + "withdrawals": [ + { + "index": "0x1b", + "validatorIndex": "0x5", + "address": "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -9944,21 +9999,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf976366428e1f9e79b69a03a333c3ea2d57804cafad16ea0301def95480afa16", + "parentHash": "0x5d7d1a0c180dbae5272ccc6e6c01b45960408a2205e36e897320813cc1627af5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x11f4b017e2e14ef950b5fb2ca09ea0e8546b9f9bb912ab2c493482b5af85b401", - "receiptsRoot": "0x874bf4080d916fe835dd08d3faffc7a4ebe2a8782654f36aae4b318a177e6e70", - "logsBloom": "0x00020000000020280000200000000000000000000000000000000100000000000000000000000000000000000080000000000000082000000000000004000000000000000000000008000000000040000004000000000000000000000000000000000000000000000000000004000000000000000000000000008080000000000000000000000000000000000000000000200000000000000000000000000000000000000000000010000000080240000200000080000400000000000000000000000000000000000000000000000000000000020000000002080002000010000000000000400000000000000400000000000800000000000000000000000040", + "stateRoot": "0x78b3cb7b18a396757fbc27a3b254334b513e9b11632726110581a1ac9775aae4", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13b", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xc4e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3752f226d6f4f227e0d59f153fcdefff90cc3aa9566c14b02bf86a5ba7e5f740", + "blockHash": "0x457cf3e561354b6040afd9e0d386b3fea81719cc40b3fca29fc4d4f99be875f9", "transactions": [ - "0xf87a8201200883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0b220dbb522cd4c5abed86b07e4d87f62cd190c0bc3b535096a8006efc574b1e7a018a5c6b5be430f923a15c2b1b06de19dd8d1ac808da574f75e7c9254478fae01" + "0xf883820157088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa035f6ba62287308ffbbfb8261894edf57969a9f95630d6b145f44404efce327dea06580af4b699a96a41c5a0f39cf3a7ed3a0c6758ceb2d8d8705f88319643227f3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -9975,21 +10030,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3752f226d6f4f227e0d59f153fcdefff90cc3aa9566c14b02bf86a5ba7e5f740", + "parentHash": "0x457cf3e561354b6040afd9e0d386b3fea81719cc40b3fca29fc4d4f99be875f9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeee8e0dee166ef99e5fa64f9b7c3616cb8fccab712bbe198c9e17ceea46b5d86", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x402bc8c855f2ccb2d737c396d499ead744bb2dee1621fa24bf74fa6a2c91f34e", + "receiptsRoot": "0x7db11edace07336d23f92ccb11a83f53ba5423dd770cebd9373a83640ab9352e", + "logsBloom": "0x00000000000002000000000000000400200000000000000000008000000000000002000000000000000000000000000004000000041000000000080000000000000200000000400010000020000000000002000000002000000000000000000000010000000000000000000000000000008200000004000000000000000000000000000000000000000000000000000000000000000000002000000000000010000000042000000000000000000000000000000200000000080008000000000000000000000000100000000000000000000000000000000400000000420000000000040200000000000000000000000000000000000000000000000000000040", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xc58", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbd34ef105826797a46b3ccc8b4a82c61897bce87047aa90ca88d590887dcef52", + "blockHash": "0x4e8f0489aada99804a9c89679ee1fd98cf0197713766bbb480c77970a95f3f5b", "transactions": [ - "0xf865820121088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a041a8dcd438529e1583b280d53972be37cc7ca049ce3643d8752f19e74c503de9a033fef9a4edbfc399a4652ebd1de044d19cde1cf51ee7c438d535c627d836439b" + "0xf87a8201580883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0ad8dcfb4390f7fa366243f1beb1e059e2f9950088868fec28ee22311f265f35aa05eab4d60f1d1f52965202e06cbe1085e28463db4f1746426c899cbba05acda08" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10006,21 +10061,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbd34ef105826797a46b3ccc8b4a82c61897bce87047aa90ca88d590887dcef52", + "parentHash": "0x4e8f0489aada99804a9c89679ee1fd98cf0197713766bbb480c77970a95f3f5b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc8f81fc12020b9daf991498ee4c67716c5e529cd6ea105b9620ebca5ca0062da", - "receiptsRoot": "0x4910e91c5e2a39c0c7abd39d435d5ee2788849ddfd7b6b0c5fe5d3dbede8f0a1", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000801000000000000000000000080000000000000000000000000000000000000000000000000000000000002000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc02f0ee9f7010e2148b506712066b306ffbbc78d75b209a88daa358d20b6545d", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xc62", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa2689bec112dc66781dfbbfe0877f3b56c055872e331b6d45acd6e8d97e046e6", + "blockHash": "0x8df9fb79d5b59f66814970a325d025e1e059f33616840d45bc73ee25a40f10ee", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201220108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca4875981ed75b054656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a08a76d1e2fd58cc0018aa306e83990d74d16ba9aeab4794595fc72551f046547601a027fec5a40c1948d0ef8fb2c9b078ba930dc8d8592f691f20f104421b34aa7bf4a065e542ab66d86bf61ec21b6efa043928ad96a6e34cde2d1c44f103f1628927e1" + "0xf865820159088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0f40d3332d3996cca69bc91b95b31592abb5dbe52ee89c79da915ab5c9d03c34ea07370380f1a072929757900ea593b048aae64884632dcba2edfb0cd70ab3f6c1f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10037,21 +10092,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa2689bec112dc66781dfbbfe0877f3b56c055872e331b6d45acd6e8d97e046e6", + "parentHash": "0x8df9fb79d5b59f66814970a325d025e1e059f33616840d45bc73ee25a40f10ee", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2635a59927f7b04cd4536a0592c61c64bd6c746df1418ab57d7c318e9b7d057f", - "receiptsRoot": "0xfdf07728708e04bcc7e76047ee1911f309757477f5df93a25114e24b5630af7a", + "stateRoot": "0x8f2edfd625374a5d7beec93191a77b0fd3456319b09968da07909fa875398a36", + "receiptsRoot": "0x89fd8ceeb002cc5ef22dbfceaa45eec15c6f19cc82bc35bf2293380c9be3dd3e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000009000000004000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xc6c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3f028560d99874cc15a76dd76b7da32cdb9548a9e262b5c986bc62ae920e643a", + "blockHash": "0x1da2f81639c8614abf6f4720da2ffca4a5557ae2c62f68948a325f08dce60a71", "transactions": [ - "0x01f8d3870c72dd9d5e883e82012308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5bd1cbdccbb7a3a8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f2042380a03e7e1bb13e2ca57486b2f72bbb4a64a7320520d20c4d8a37499a739a6090713aa038d501ca743320bb18155ced455be09ca9802c7715746d355db1942f04d3d57b" + "0x02f8d4870c72dd9d5e883e82015a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5bd1cbdccbb7a3a8656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f2042380a0f44092a2c4d82ff06c2fed6ee5b831c59867cfcd0fb23d715503bfb6e81f86d1a077a2b1deba8fc487ce7645bb71b1341826193e05b9a9fb5f2839df7171d24682" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10068,29 +10123,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3f028560d99874cc15a76dd76b7da32cdb9548a9e262b5c986bc62ae920e643a", + "parentHash": "0x1da2f81639c8614abf6f4720da2ffca4a5557ae2c62f68948a325f08dce60a71", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x11042b90c5b05bf61a5b314e291ecb32c4feb8964fb002a69c7334e0d74915de", - "receiptsRoot": "0xf2e9f16617598b8bd3b8029a0e67f45874e0fcdec0515e73f20f677a43ba6aa4", + "stateRoot": "0x1c52961562bb9bf1e8ca7d75a53500f81b569d990de2e17441780ba2750f69a8", + "receiptsRoot": "0x7e6e34797a1654b05e5069d916c674f9b74f7a6429a62477147dae8d5cd50684", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000010002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000100000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x13f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xc76", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa0755b0908be2efd8534b105a279c0045087852b3c412f2d3a888988e4fa475c", + "blockHash": "0x378d38c1343aa2703f647894a5fb7330de9fc0e363c86f55beee5d8d66e1d714", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201240108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c15917920cd0da2be656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc139130883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a05a856ee6dffab5fbfd8e1c4ff819353145b18b607699bd9e634af1af2b9081d3a06ab060ac1af8ddfa65300f04c3c68a441c754f390cfa1255626c29391278e71d" + "0x01f8d3870c72dd9d5e883e82015b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c15917920cd0da2be656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc139130880a0861b172f70afee55f8c80a2011df58329d3dcf4977721a0d81cd3b0baec58ef1a027c4d7790f49b29a2c101cc3add1e14793c20a3d799a36ddf17fdb13be5ba69b" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x0ae4ccd2bffa603714cc453bfd92f769dce6c9731c03ac3e2083f35388e6c795", [] ] @@ -10101,27 +10154,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa0755b0908be2efd8534b105a279c0045087852b3c412f2d3a888988e4fa475c", + "parentHash": "0x378d38c1343aa2703f647894a5fb7330de9fc0e363c86f55beee5d8d66e1d714", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6cfcc9ad804ee654482854af83dcdc7f83c693fcbe07c7188bcbbdddddf3927c", - "receiptsRoot": "0xef73cc140dd423c074df587c3d1dc998c1ef798f26acfcd7b4375010adedb9f5", + "stateRoot": "0x6e3f441e95b9277bd883cc95fa0e356cd755c77a78ce43298910126bff8c1a43", + "receiptsRoot": "0xb6746e44eeed87a9ce96f9a793b871ec3850e9b9fcb159b0d6331c6e160eb316", "logsBloom": "0x08000000000000000000000000000000000000000000000040000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x140", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xc80", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdc88273a8339355e4c23b544329f1564ff0f17cda095b1ec2dff43d3dd0e39ed", + "blockHash": "0xa2f88ca8a8ab5ef26e33eb38b5f28edf9349afb29e5f1a8435c070fbc8df25ea", "transactions": [ - "0xf87582012508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca0eb3590d415621b656d69748718e5bb3abd10a0a056263d5515ea59d6ea7821724b2d3600cd4ec52cfd38e5145999c1b46abbf679a003bd6826947fd80264e99af1ab05dc826e5f5545ab7d40be5c77c46a4a5e853c" + "0x03f8fa870c72dd9d5e883e82015c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca0eb3590d415621b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d314fafd686fcd729a24ff511ae5e19248bd6ac6de8c28c79918df72de20e63e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0fbfb4dc589628139ed92ff30a50aa483198db95f62d826b3396c3a8bb1147ad2a04e103d38c928e9c5df35c00103eb3da8be27ef8b735fa9bb9dccbc1692128de4" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xd860c999490d9836cc00326207393c78445b7fb90b12aa1d3607e3662b3d32cd", [] ] @@ -10132,21 +10187,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdc88273a8339355e4c23b544329f1564ff0f17cda095b1ec2dff43d3dd0e39ed", + "parentHash": "0xa2f88ca8a8ab5ef26e33eb38b5f28edf9349afb29e5f1a8435c070fbc8df25ea", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x34c42ce2ae63c16b981127388494b5a674542730742e466dcfd45e6444c536be", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x105d899797d6f5405211a54971d5510e22b55e583e3d2c84dffa0551f42b406b", + "receiptsRoot": "0xbefb0d7f70ff16c79a480b2ed6c8dc4b091d44453ecb28c6678b57bf6a5bc47b", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000001000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x141", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xc8a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xea4108c88374dcffd042b2fd53de46cc82aa3a0c1573c6228198529dd90ad350", + "blockHash": "0x54dc888fd505259107b6574dd8a20a802deb1d07bb9728a54d74795789454270", "transactions": [ - "0x02f86b870c72dd9d5e883e820126010882520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c001a0c0be9c595e579a6396a39470d43578ea9c7797439481f5a538a3e30968f54689a02aba0937f802edac589ec6bebf62ff7f4578c242cb7df2d1873d3ad2fecd8890" + "0xf87582015d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd2f3a8041747db44656d69748718e5bb3abd109fa0498ebae158440b3a5a9f1fee09afb45e54d26070dfb752347789730dbe7f1bbea00607f270ceb41f8bbf3f1dc833a48e2c961c9d7bdedaf926be20b5b0905cbf74" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10163,21 +10218,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xea4108c88374dcffd042b2fd53de46cc82aa3a0c1573c6228198529dd90ad350", + "parentHash": "0x54dc888fd505259107b6574dd8a20a802deb1d07bb9728a54d74795789454270", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9c3444d082b3419f2c1aabbc3d270af0aa1d68c9f7d1d2f225955807b46129cb", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x4da42e9b2ad1e02c7735e0953382c1550a5698713259b895930ed535f40d9565", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x142", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xc94", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x89aa4d141def4c923b06aed9552126683bfb54e96f310d8fbc98bdef21e3b319", + "blockHash": "0xe9b56ec487c3b9eda677017acd8c89f1a995b8edca20949d5492bd47f1278705", "transactions": [ - "0x01f86a870c72dd9d5e883e82012708825208940c2c51a0990aee1d73c1228de1586883415575080180c080a0bc2274e5af7d6af7375fabff23d452d07fccc3ab64e4a8255f456d403182d234a059110fbe12731f4269b029c5b17c1d30f337a2794516d08f30ecb4e953069068" + "0x02f86b870c72dd9d5e883e82015e0108825208940c2c51a0990aee1d73c1228de1586883415575080180c080a05ffa0758fb568bf788d3252bf8b649f3999c5d2009d2685e996b432c69603c5aa06d233e0513203eba2b10f5b6a12e683eacf974f0e27bf938cae9563c3c662a6c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10194,21 +10249,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x89aa4d141def4c923b06aed9552126683bfb54e96f310d8fbc98bdef21e3b319", + "parentHash": "0xe9b56ec487c3b9eda677017acd8c89f1a995b8edca20949d5492bd47f1278705", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc039aa511d618a79634afb4b7038f6674069cce2dd0ec0d1f97d195b836a9ac0", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x87e82e69847cd556c83117835035d0e472cfcbda01e0ca2858f820aa8ebf4315", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x143", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xc9e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5e09d28a6f9e43be4a5f908f764b9c25db1fcb323d9af4d54a9a486721b6b766", + "blockHash": "0x411ec72e0e4ba3c70825d4d76357e30b010815babbbc1837e2c70006d33e809b", "transactions": [ - "0xf86882012808825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c01808718e5bb3abd10a0a02fff8f6f955c6177c3f68cc124a27d9b3865e467cdd2cfe8575dfded052b350ba038ce7fd03ddd6880c63946f71a580a34831c38a4bcbba3de6665448fbcb7ad11" + "0x01f86a870c72dd9d5e883e82015f08825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c001a0c7038d0ff0894d50c4b3988e5e7ea777a7e62678be35d606ebabeeb5ee56fd04a03d5ae90baa01e4a58a59acad839e89d0c48c989a911847cf911fd0ce0bc50cf1" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10225,28 +10280,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5e09d28a6f9e43be4a5f908f764b9c25db1fcb323d9af4d54a9a486721b6b766", + "parentHash": "0x411ec72e0e4ba3c70825d4d76357e30b010815babbbc1837e2c70006d33e809b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x88214fefb638436f3e36c6e8f552adff7a18e75de8ef1ca40c9115f9666e10e2", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x3dd0f9c76155c2f57d35021c21437aba5e1985188c0bab677194408ac703bbb2", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x144", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xca8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa8e614e1553ea89015d1c2d2d90ef31794bacd4f661a9b8ca0e8f57cb8358a99", - "transactions": [], - "withdrawals": [ - { - "index": "0x1c", - "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "amount": "0x64" - } + "blockHash": "0xf92cd7abdc875dece612e2568996c3d03cef02faaf7b0924665b97123207f9a6", + "transactions": [ + "0xf868820160088252089484e75c28348fb86acea1a93a39426d7d60f4cc4601808718e5bb3abd10a0a0df4798399378df307b8a5b41a9e1ffd7e31de6e9569c116ecbfed2404267433ca05727229c50d7a6cb0b77b548ca59c83b08bc7e0955aa1bc73d5f1b308d90457c" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -10261,23 +10311,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa8e614e1553ea89015d1c2d2d90ef31794bacd4f661a9b8ca0e8f57cb8358a99", + "parentHash": "0xf92cd7abdc875dece612e2568996c3d03cef02faaf7b0924665b97123207f9a6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf3cfefcaf0d1829c13c22b2c2a272f81664f58b1264bd3d6ce81587433bad033", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xf561e42206ebda045741ab8254b0d4d2756369c803084af8c151f34eb91fc39d", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x145", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xcb2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x772516ae20b52f5521b3a703dd4fcecd98f348fa2f0523f85aa4b801d46b8a2d", - "transactions": [ - "0xf883820129088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a08b5ea5a1d6a55227e31b8c30960a96dfddbe2cf11c4d54d294e3c13f31e80a4ca017c92582dacae25bc23fd2f006f45f478a8afab54135dfb63899a9ae4ec8f27c" + "blockHash": "0x445c164c66dbe2d97e415132e6519d7765d441454461655d1bc2fef9a5233720", + "transactions": [], + "withdrawals": [ + { + "index": "0x1c", + "validatorIndex": "0x5", + "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -10292,21 +10347,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x772516ae20b52f5521b3a703dd4fcecd98f348fa2f0523f85aa4b801d46b8a2d", + "parentHash": "0x445c164c66dbe2d97e415132e6519d7765d441454461655d1bc2fef9a5233720", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbd91b74f92f8b1f1512c0c16e4d4d6a0cff41ebcd1024b73a590b8190cf870cb", - "receiptsRoot": "0xb08f0d9dedf1fbd11cab90ab1cb4a13c5e5988497da8ed6abbbeb80482029125", - "logsBloom": "0x00000000000000000000000000020000000000000000000000000000000000000000010020000000000000000000000000000000000010000000000002000000040000000000000000000002000000008000000000000000000000000000000000000000000080000000000000000080001000000000000000000040000000000000004000000000000000040004002000000000000000000000040040000080000800000100000040040000000000000000000000000000002000800000000000000001000000000080000000000000000000000000000000000000800002000000000000000000000002400000000001000000002000000000000000000000", + "stateRoot": "0x47fbc9bde812f0e06d109960fe87e00942bafe4ae3c42ee5d32f1b2bf98f3934", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x146", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xcbc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x40137062068c2bef8766bb8df571f0e0c341f3877dc1d7311c84177331165a5a", + "blockHash": "0xfff2ffe2e7354436e669edcbb6301ebde9eb5d415e4dc27166e7a301463ead0a", "transactions": [ - "0xf87a82012a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa03e1a10d66caaef6e2b05ea47a618cdb3d493e18deb0d1014c2cda62f2f63b41fa059eae72098410e95b8ac649e5cb4e89f88f4e8869afd63751232883dbb47ceb7" + "0xf883820161088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa06422792ba59cf88fa36d63374647be8ba347cda8de184377b957e649c1966a53a0617dd0ad96166579c3178602c7b0d1e0994f0248bb6f88c344c3f8dd32570b02" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10323,21 +10378,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x40137062068c2bef8766bb8df571f0e0c341f3877dc1d7311c84177331165a5a", + "parentHash": "0xfff2ffe2e7354436e669edcbb6301ebde9eb5d415e4dc27166e7a301463ead0a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf79638445390b53b07ef4d608b9d08c40cbdef73771ed96e0524353c0870c483", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1b68dca38e932c0134b8936a72f7b7f3a6edaad6ad3ad8d7a2f0acd1dd3ef9d6", + "receiptsRoot": "0x1e7d0a3194a1f0d4e8f6cf96b9cbaf7e6a030ddc9143b6095d3492270736aaca", + "logsBloom": "0x00000000020000000000000000000000000000000000000001000000000000000000000000400000000000000000000000000000000000000800000000800000000000000000100000000000010000000000000000000004000080000000000000000000000002101000000000080002000000001000000000000000000000000000000000000000020000000000000000000000008000000000000000004004000000000001800000000020000000000000008000000000000000000000001000000000000000000200000002000000000000000000000400200000000000000000040000000080000000000001000000000000000080000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x147", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xcc6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc10d42ae21c805f56d5f486087ab29e6c5f16d2743dceea53e68b4c4ec8c41de", + "blockHash": "0x3783621d2f500f95d6dd1f072a06f3cf7776c9b364a4d986b644f9084dc27e5d", "transactions": [ - "0xf86582012b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa09671ecdeaae37b39f175061ce6dfe09d47d0b4234656fcd52771e7604356075ca059c42b5a6ddd0b2cb0438604a0770962df4c4e0b510a48b3daec27b10aab464d" + "0xf87a8201620883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa004c85d63e9b4217809b130798c2bd8029ff6dd85b22cd994201386124c7f238aa0447cb8fa5531097c248069a659914d8b94a66e1fa5b30c545d2844bf6ce64581" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10354,21 +10409,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc10d42ae21c805f56d5f486087ab29e6c5f16d2743dceea53e68b4c4ec8c41de", + "parentHash": "0x3783621d2f500f95d6dd1f072a06f3cf7776c9b364a4d986b644f9084dc27e5d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9c7b6d27985ea981fdacf1a7e5dd136d0d3de60b5bdfbd2c63aea8c1c31b661c", - "receiptsRoot": "0xec2e029e4137b461c04f9b94fdbda71b6f4249479b9adb0095317c11a399f011", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000010000000000000000000000000000000000000000000000000000400000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x8fd0acd1906e7050c77629d7a59ed69f6fdfc6f518284914385eb70e3a8c9fda", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x148", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca90", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xcd0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf37ed9b3c15bebe2c65743e7013c97fa8b75f97e8791a353c033c16171a82fe8", + "blockHash": "0xc292d2df68caf410c52129638905a541d121618c637b4b6e401ae5783369b805", "transactions": [ - "0x02f8d4870c72dd9d5e883e82012c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c712fd7264800465c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07a63090121e41c76eee07564883abe3bd839fb20a0d2513bc9bc524f6c16f88a80a0e2dc2c6fca7b8a278c94417088f7a8b8437187328bfd007920d513824b1bef35a0022bfdea3b75175f59d0447dec7ab34f0584df815d06f1e70ba9c7361f6f7f1e" + "0xf865820163088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0507acf13b05050a3d16ecdf17df7d49fe7d7e25e27ab042450ce3eef1dadee19a06095e719d861aa2688a03fdc622be9bec38e2807c7a5c1850ae1198f86f2f17b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10385,21 +10440,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf37ed9b3c15bebe2c65743e7013c97fa8b75f97e8791a353c033c16171a82fe8", + "parentHash": "0xc292d2df68caf410c52129638905a541d121618c637b4b6e401ae5783369b805", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaa3a2d4acb17ce1ea988794b3335606e349baf071a6418c4d2262737a78e2c21", - "receiptsRoot": "0x50d115fa5f6857f190b2f2e00f1f97beb32711184258c05a2d6334140958c2e6", + "stateRoot": "0x3b1824013446c48faaeaf632a0a5ba3e95ca2777b2b37737dfe60f76c380c9e8", + "receiptsRoot": "0xeb1f423fada524e7f50d34548572c7f716405c09713466256a2f7a0d970b3a15", "logsBloom": "0x08000000000010000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x149", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xcda", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8271d4efd4a54b038c0cc02e2a437d7cc3d96aed9148763fb2825fcc1ca58a1c", + "blockHash": "0x18c79f9a20b1eb4d040190838ad1ecb9401a4d7c6aafdff548163fa0e81a2312", "transactions": [ - "0x01f8d3870c72dd9d5e883e82012d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c44ae3eac6b9e5d37656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac754180a067a4f15c1e36c36e16f90109a5d4ce480d2f1941ee0ec885fe89df52552e1b51a07e0c91908cb4177b81c87ecf6f6e6d7b1e642d29e441f698a8d431ed1ea3cdb1" + "0x02f8d4870c72dd9d5e883e8201640108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c44ae3eac6b9e5d37656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac754180a0aeedac54dc3139a4ba210b5b116daf9a5550de57d98a76e04e5c4b4b56fe209da07a59f711fb189c0bdd003ec929938412ccedad84a93d1435e6106c392035aed6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10416,29 +10471,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8271d4efd4a54b038c0cc02e2a437d7cc3d96aed9148763fb2825fcc1ca58a1c", + "parentHash": "0x18c79f9a20b1eb4d040190838ad1ecb9401a4d7c6aafdff548163fa0e81a2312", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x85f16877081694ae3dc66ee4b6d931e6a3f85d3a6b56055fc61a350430c8dc5a", - "receiptsRoot": "0x54f709424481c40c85d8249a8dd2d11c088ab7eae925a4150441225b960ac786", + "stateRoot": "0xd5d99efcc753c5c5d4c241ffd8805eb62b5943f0ce1fef646456a5ef5eae0663", + "receiptsRoot": "0xb9379afefc656aab5c5c77974265a7cc99c2b7003acad435f5dbf5557087bb55", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000010002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000009000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xce4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa9505142d5e8f2f3585f3d753c6cc615395b9694739c2aaebfdfbd52ea22d378", + "blockHash": "0x079a82efae89bae7dc9f51d23fe219551e0e8dc8d8a1783163ce664741d77c9a", "transactions": [ - "0x03f8fa870c72dd9d5e883e82012e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c9b8c3a423a55b426656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce85783020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0db2322624476ad46dd2320b019f59466ce8ebf0b9a56c2fb14349b334ad6911ca050725915ee3893eaa2709708aefe5d8daae00786aeb6cc44438bad13dd9271ad" + "0x01f8d3870c72dd9d5e883e82016508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9b8c3a423a55b426656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce85780a02461015008be779dd9a8822bb2ff8e7e847bb5bb7d4dd8f3a06dca8551dc419ba05f3626fd4ed8ee8965c1f65d71f7ec69330d0b991625d99a3ea66a6fa51026a5" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x7e0752ddd86339f512ec1b647d3bf4b9b50c45e309ab9e70911da7716454b053", [] ] @@ -10449,27 +10502,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa9505142d5e8f2f3585f3d753c6cc615395b9694739c2aaebfdfbd52ea22d378", + "parentHash": "0x079a82efae89bae7dc9f51d23fe219551e0e8dc8d8a1783163ce664741d77c9a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf64b7bf6dd3782b691a65d074c515dc96dcbbc5b654c41b1bb561b9171febc65", - "receiptsRoot": "0x9f8321c089b9a301b52205bdab9f5c7c5906a7307859eb67580623ae764a40e4", + "stateRoot": "0x06631aceda8dc4801fdca60a168a6c9c9439e10ca0dc70892c7bb6740411164c", + "receiptsRoot": "0x33fdabd28a3754e4172eb8b07983af5ec122a6e17e25af95cd2bd17209791648", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000028000000000000000000000000000000000010000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14b", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xcee", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4d6b8d46d03208985e99ee7ca9d38e3ff54871672663c6a1cb4d8a558fe8b5fc", + "blockHash": "0xbf3d02ee23b46b03fe7a0cf3e5ab2709608d2d6c237357932b73caf7bd0e5962", "transactions": [ - "0xf87582012f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c85b0cf6f2ed6a4c9656d69748718e5bb3abd10a0a0080ede13d861e65459ccfda69653b507eef89c9ae71c31e0514bf89d368bf505a05d18a3565ae14331ad7336b97842425228126f33c6e477b3a5e9f8eb11e6e69a" + "0x03f8fa870c72dd9d5e883e8201660108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c85b0cf6f2ed6a4c9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0951b3b37c2a87b5a67918e750832a50c5565298a35390bad3ffffadb2f7b4afe83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0a3c91082aa5f98cf42c4635a0312f74b7b7dbdc08c66a9b9173d87f93f61260ea00d0aab49ed35714a83897d245d244c71253b6a52271d36a52ec080fcd9cf5b37" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x31d973051189456d5998e05b500da6552138644f8cdbe4ec63f96f21173cb6a1", [] ] @@ -10480,21 +10535,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4d6b8d46d03208985e99ee7ca9d38e3ff54871672663c6a1cb4d8a558fe8b5fc", + "parentHash": "0xbf3d02ee23b46b03fe7a0cf3e5ab2709608d2d6c237357932b73caf7bd0e5962", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf472cd60d56758c2d3646fa51d854ed0b56f9266db923772edef4e5bf0745785", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x84b23c952dfa8f61b6d87ee85bff87b0032b5eb70a26865a552473d5276899b0", + "receiptsRoot": "0x1931b499cde32287e47b63b488b406d2c7ac767ea3e059e789ac043bd64aba21", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000040000000000000000000000000000000000000000100000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xcf8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x317d6cd8a8783099c05585ff4132c92fa56746ac04dc89d01f90a6087d95e3fa", + "blockHash": "0x8f34050bd77c450b1684065a6d47f74e03a13366670639e0ffc82ce56190e7ad", "transactions": [ - "0x02f86b870c72dd9d5e883e820130010882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c080a0f548c826f4e2b8c513899f21fedf09191bb02e657d036f2b312e534f346e1d89a04a1527da2c52c307743f6d31c941ec2d3575b540e89b5fb70bd21c7d3067d7d6" + "0xf87582016708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc35bf5ec655dfd63656d69748718e5bb3abd10a0a0d4ae78d9dffb14b7db544598fc5f80423a487823dc88824385b22fa4a190ad6aa02ce93b7da454a24456708adc38859894e47577d28f46e6b73beba044fcf6c4b7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10511,21 +10566,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x317d6cd8a8783099c05585ff4132c92fa56746ac04dc89d01f90a6087d95e3fa", + "parentHash": "0x8f34050bd77c450b1684065a6d47f74e03a13366670639e0ffc82ce56190e7ad", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x38d13fd335d3ff58df3bceceddd00a98f9a65076c295b474cb913443df6855a5", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x07d91ddc6ee5b8bd4b862a7691ce11a8ea3eba567629b1166557b19281a63287", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14d", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xd02", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1aa7fbd954a82016be127f3624a93bda8d45351191031f3671060abf2fbc7140", + "blockHash": "0x1dc2e1bdcaf6cbc04adf6f2a0bec9df3fb5148469ff491701db0d36a3ccb5561", "transactions": [ - "0x01f86a870c72dd9d5e883e82013108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a08b4402e18a1769ab35ad1c02fa3b3979e6cb5e2499015a08b523d95fbbdc556ca02055eeb30f2f30be3f98032663d662106c441fabd3faf595bb6446464de85d42" + "0x02f86b870c72dd9d5e883e8201680108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a06083e02dd8339c5792974c703870779547de75c6279c216853355220975839c1a025eed1338e4e0ac887f37f02f1ddb4e3b97ad71456af950db3641bb3a46a9418" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10542,21 +10597,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1aa7fbd954a82016be127f3624a93bda8d45351191031f3671060abf2fbc7140", + "parentHash": "0x1dc2e1bdcaf6cbc04adf6f2a0bec9df3fb5148469ff491701db0d36a3ccb5561", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x041f809591aed092d570607d5814744284ede19b1e54f129be243ec696ea8ae1", - "receiptsRoot": "0x642cd2bcdba228efb3996bf53981250d3608289522b80754c4e3c085c93c806f", + "stateRoot": "0x66d19e54834612f718e66638e4da798d11e32dee10599594af5d4ac963c31fe7", + "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xd0c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf0a0f1e9079642d9be82b1a2c786bf1c89f4e0bec03cbd6c1be96b92c47cbeeb", + "blockHash": "0x03399daa6b9a5022b6c6ef393204ddd994dda29cc67998c0dbc1df5f2c7df9bd", "transactions": [ - "0xf8688201320882520894eda8645ba6948855e3b3cd596bbb07596d59c60301808718e5bb3abd10a0a0b8bcc7e609ee631b36339e1e6ccb48055c09c7b0a2ba3303178302dcf4af06b0a07420abb736eb6501693bb726a81507236a738ec8fa0b0e81292ed59f08f1b7f0" + "0x01f86a870c72dd9d5e883e8201690882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a066d0b1cb01e5b1afd0885c075801ec0cdf540c2bd6f83e80d39a7576799e97d0a034239eccc43be4c97c1b5dbff66a2f851dfaa3f24bf9eb204eac8d35795f8f5f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10573,28 +10628,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf0a0f1e9079642d9be82b1a2c786bf1c89f4e0bec03cbd6c1be96b92c47cbeeb", + "parentHash": "0x03399daa6b9a5022b6c6ef393204ddd994dda29cc67998c0dbc1df5f2c7df9bd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x74a65347258f456cb834196ea2439718d86593bad1b6246e957eacfd0b198a56", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xd07861e5c0a3edd3ea5ffc4245c8a65752d0ed2fc1e5fd2b02c670c97972a859", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x14f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xd16", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x286ee500a7ccd24305014fc9ed773b472aa0e9de2005f98b0136bbba193e89f9", - "transactions": [], - "withdrawals": [ - { - "index": "0x1d", - "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", - "amount": "0x64" - } + "blockHash": "0xccc15fd8ddf55d7c8eb75b38f01938eab69a8286a525182fa302c34738c401a8", + "transactions": [ + "0xf86882016a08825208944340ee1b812acb40a1eb561c019c327b243b92df01808718e5bb3abd10a0a0039e6d44ad23b2533467c0d3cd5bb01a4e7ae614a20256b153c139d3d989f99ea00692528563f318af8a9e33e1759fd83c3b093baf1e4bcb4a860c0ff44a83872c" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -10609,23 +10659,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x286ee500a7ccd24305014fc9ed773b472aa0e9de2005f98b0136bbba193e89f9", + "parentHash": "0xccc15fd8ddf55d7c8eb75b38f01938eab69a8286a525182fa302c34738c401a8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5f377cadc6b9379c381701e2fa03a1b8d60018477a76628e6d5c022b7778a32e", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x5ed562333386ccae375d7fb9800a627295ef884723e4a4f545ee59a37c3eb951", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x150", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xd20", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2f60754b89d3acfa2cd8e479e2b94e90c07bc5ca92f5e49b3d0280a30775893c", - "transactions": [ - "0xf883820133088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a00c230c2c6cb704d59fe5ffccb904f6cf5b95915d05b320eb186477831604f30da00138622287e1cd74e8b94f83db1a37b906e7381952de02a27ed354c8cfb237dc" + "blockHash": "0x5f1a9c738684387b66a96f080ed4606ca3b54cc6ef8fbeac69197d9d0ebc18d4", + "transactions": [], + "withdrawals": [ + { + "index": "0x1d", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -10640,21 +10695,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2f60754b89d3acfa2cd8e479e2b94e90c07bc5ca92f5e49b3d0280a30775893c", + "parentHash": "0x5f1a9c738684387b66a96f080ed4606ca3b54cc6ef8fbeac69197d9d0ebc18d4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3360e3947013a74b2bd63f3112f968512361bb63b15562b26486a30c4672aba8", - "receiptsRoot": "0xa234730f8e7ba7c91f2cafe17e1c638dcd8835ad12aa27770f24e3a49a031784", - "logsBloom": "0x04000040800000040000000000000000800000000000400000000000002000004030008000000000000000000000000010000001000000000000000000000002000000000000000000000000000400004000000000000002000000000000000000000000000000200000000000000000000000000000000008000000080000000000000000000080000000000000000000020000800000000000000000000000000000800000000000000000200000000000000000001000000000080000000000000000000000000000000000000000000000000000000000000000000000000000004000000000400001800000000000000000000000080000000000000000", + "stateRoot": "0x222c41acd75836ca90069e3f9de16c669c2e7de990533763e7af046eacba1e99", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x151", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xd2a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1d2172c03aa39bcb2ff80dc3a80b157ee311f01f1972c3ae61df2fbc08581df1", + "blockHash": "0xfdee8c650dfb4cf5fce50480224694b856fde37082e78eb3c82971a2a010f62d", "transactions": [ - "0xf87a8201340883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0e78b28732bf01b7e0f9ac86de0370156a1cec747b602f1720e9bb70319ac0c0da01b0570b525a20760358ab113ec97686d6e849ee0ad08743894366d9c8c6241d7" + "0xf88382016b088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0e14bd8f9c55ca04ed6d545670bf80e4d5cd3753cf8e9d79de138ff52527e8706a04cd3d2765967c35cac423914086efcc5ccfe9877923bab5a397cfa8cfc9e56a5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10671,21 +10726,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1d2172c03aa39bcb2ff80dc3a80b157ee311f01f1972c3ae61df2fbc08581df1", + "parentHash": "0xfdee8c650dfb4cf5fce50480224694b856fde37082e78eb3c82971a2a010f62d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x35cf21dfc0aace304593e0b5f92a4b86080f2d77f42e0a6df1a38316e0699b16", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x3588e1ec84f9149cbe63ebc7fb9088af1dc3d1e489bcb713e0748cb1f2822597", + "receiptsRoot": "0x7de618c7f6479943d81923081acc397007151920bb5e12ac9312cc34b8ed67d2", + "logsBloom": "0x00000000000000000000000000002000000000000000000000000000000080000000000000000000000000000000000000000000008000010000000000000000000000000000000000000000000000000800000040000420000400000000000000000000000000000000000000000000000000000000004000000000000000000200000018000000040000008400000000000000000000000000000001000000001000000010000001000400000000000000000200000000000002000000000000040400000000000000000000000000000000001000000000001000000000000000000000000080000000000004100000101000001000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x152", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xd34", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb5038ea078e022c5f7c97429a3f36c5b15ef525012266a78784315d5f5f8f742", + "blockHash": "0x8b6e1a97ed0b60399797bc48fdc165d7bda6b855f94691276d2e5068d44e0aec", "transactions": [ - "0xf865820135088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa05c10478b2c093f52e6576817dfb0ca2c716eccc77bc3dcc43e3482a14b62aa6fa0183b8f5a623bec5c593fd56f02844a7cb3d358cd61894ff8dcf56bb6b0a50726" + "0xf87a82016c0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a060bbdcc20b9b67af82bc31f9f9d0089a552e568b1a903e22e854ba8d84501f4fa0232988e345d316b37a3c87b07cce6f89b328af0fb7da666eee864ad218631586" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10702,21 +10757,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb5038ea078e022c5f7c97429a3f36c5b15ef525012266a78784315d5f5f8f742", + "parentHash": "0x8b6e1a97ed0b60399797bc48fdc165d7bda6b855f94691276d2e5068d44e0aec", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd1878ecb20758419ab44897b3c479570e4917dc2a18611df054680a838162dca", - "receiptsRoot": "0x33917054a5e8342edac692f717af9212958d9e262cae6256fc670896a6ac7159", - "logsBloom": "0x00000000000000000000000080000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000020000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5f7bae63cf253fb10898a003bece41c3e646441959a5351103acb233264f3c9c", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x153", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xd3e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb63287f903b3d2cd28cec281f1de235c85ed05ba3857e28cc86f9c29f39d57da", + "blockHash": "0x3f9354b48f2c7bcf684bcb6ed3a7635eaca6ba81654a3fc3e4c7273c61b28583", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201360108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c76ed30898ed7a9d0656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c4f8d20ccba0b50d46d9c87f28cebf8c165fced694a2b34412a4b6153b987a1780a0a62a69f48f7b52ee09e21c86e91fb9bdf25246ecc175a9dadd9ad58187b78a32a0534a6c65d782c27d335d7d0ec0817041faed9e63ea864da2169b1dac9cb62e13" + "0xf86582016d088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a07d8f64f397682c2dc4e4f2e9edc5e5105157947a983155dddcce221450289edca01a1edf02e97c2554ba07e9e35a81aa04c7fd1c2509a7c3a6375b2916f5666c1c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10733,21 +10788,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb63287f903b3d2cd28cec281f1de235c85ed05ba3857e28cc86f9c29f39d57da", + "parentHash": "0x3f9354b48f2c7bcf684bcb6ed3a7635eaca6ba81654a3fc3e4c7273c61b28583", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe849e500d56ee2ada110a6081ee1c6617be2adcf083a1caf42e265a067b61aa3", - "receiptsRoot": "0x2dc20a0000586ebc72ed5256aee2947505381983c7d080a69ef8c68d3b802280", + "stateRoot": "0x9a222c73b9c600679419a5af18189da838d947f98c638bd0474e4d68bd8f1b6a", + "receiptsRoot": "0x823e6949edb9c9bd5b0af828fb641d8aea43105774abd1fd3faada72763044b4", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000800000000004000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x154", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xd48", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9c476efe697f7d3482e8a3a620811c6dc88ed3b98cdc752a53bb756d13a6dcb5", + "blockHash": "0x54553da46a588f6dc14580c6ccb5f2ca5c6f6a189dc465c0d4d84ad2c9749a4d", "transactions": [ - "0x01f8d3870c72dd9d5e883e82013708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce481f18bdff3a685656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c01a07939e49d0e5b19e71cd5225a0ce00fce92b05235773d9b97194d5333f9929387a0144d3d0ce7f1c3218e46f3f02b7bbace6c0064be726954bc3d9b399e865501d4" + "0x02f8d4870c72dd9d5e883e82016e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce481f18bdff3a685656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c01a039d63f63b01a369e7db2762519ce08455d58461fe8570ab07cb548909d0dd88ba073c757184c1fd8c3e74471845440ce123e4405b6ac0074caf7bd93c3fcfc465d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10764,29 +10819,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9c476efe697f7d3482e8a3a620811c6dc88ed3b98cdc752a53bb756d13a6dcb5", + "parentHash": "0x54553da46a588f6dc14580c6ccb5f2ca5c6f6a189dc465c0d4d84ad2c9749a4d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeb9a8fabeb5e95490ffb76f24c9af75ba76542e9bf057cef47022880c907a6e8", - "receiptsRoot": "0xbfd591c5699b876e0ffac9c863e7d879eb9e84fd53f09eb7209130d6fddd4a5e", + "stateRoot": "0x17e9d3e4fbc706c36b789842b0eb9cf2523438df5a01e52f507b4fc1e296bb8e", + "receiptsRoot": "0x82d7f72b29e21d7d039c2bc1f2df736f0cee592c5f5e1724fb9ffe58ed8a5629", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000002000000000000000000000000000000000000000200000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x155", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xd52", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xde9ba0e426dbd981f0ea6eb968d6f3a725b664f175d245e6e9e2478ff44afb72", + "blockHash": "0x565a7651bb85599dd4e8bb9deea8c1068fc0525ef77a602875c0ee4c27ecdc3b", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201380108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c225431167194f3d1656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0045a6e1a7be12514ed1b4efb3a494e830a1bb319191b159e22b087b1eb54b9b5a03a9c077a4fb3b3c677d901b35817f68a7fd370d207cf131535c5e099b3bb42e1" + "0x01f8d3870c72dd9d5e883e82016f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c225431167194f3d1656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f201a02332db0453a44066141395c41f2e04de302344b8f118c64ed1fbad3dc317d442a01f412460ccf966d717e8a70cd28f21b6f71dd49262442f79966ac025ad03579c" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xf4df943c52b1d5fb9c1f73294ca743577d83914ec26d6e339b272cdeb62de586", [] ] @@ -10797,27 +10850,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xde9ba0e426dbd981f0ea6eb968d6f3a725b664f175d245e6e9e2478ff44afb72", + "parentHash": "0x565a7651bb85599dd4e8bb9deea8c1068fc0525ef77a602875c0ee4c27ecdc3b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x371ed66c922382b1d523ea4195c56699910652c6012551f348e3c9f3bf436eaa", - "receiptsRoot": "0x488144f2ced26a3a3d1625aec2b9c5da10348700ae76d648175adeb8d1338372", + "stateRoot": "0x0d71e018402a3123814c4e00c01b7bc158e78d8490bb5dea9ad281af7de8ca31", + "receiptsRoot": "0xfa3aaeda4cdf53def7263758bfbecad51a4429b1b8b80029b2fd739732612b8f", "logsBloom": "0x00000000020000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x156", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xd5c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x36e28ee4cdd767038d87e898e8b59f777b31454f9960e87ab3fc258223c5b212", + "blockHash": "0x5a060514a5987fb5defacc69d60df530d84825bb7102f52665c197a5b7cf0d3d", "transactions": [ - "0xf87582013908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c932062c9eeeeb3ed656d69748718e5bb3abd10a0a01212b3d30e6b13040680917257beb75539068dd48a14e7fd8521dec956c0c37aa001697ca60a4210a55ee2ef7fa50227de02aadc61edec2fff5af8e30ba63373fc" + "0x03f8fa870c72dd9d5e883e8201700108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c932062c9eeeeb3ed656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e067f85eba81feba79bf640415c11ab4448d5cc4a41652fc0a200be4d266178683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a005e73074788c05a172afc1a7c5fef991fcbd408ca579a676bd847f27135f90e2a049a59e686b76644576945598bbc9a508f2596c54ee90e5dd8666324632a330bd" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x0bb47661741695863ef89d5c2b56666772f871be1cc1dccf695bd357e4bb26d6", [] ] @@ -10828,21 +10883,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x36e28ee4cdd767038d87e898e8b59f777b31454f9960e87ab3fc258223c5b212", + "parentHash": "0x5a060514a5987fb5defacc69d60df530d84825bb7102f52665c197a5b7cf0d3d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x317db0374b2ad9e322ab95b31c69e1859fc2f2b5975a2c348bd6377779eb672a", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x58bce5cd6dd8d9ee462efa92e639c335c83cacaa9d4ec886beb8f54c47c7fadf", + "receiptsRoot": "0xc841f2781db47e1e32867dc6d784cd6c89a5f827ca9280e5c20568d0261bfd30", + "logsBloom": "0x04000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000080000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x157", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xd66", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2955e6adbcf58ce3f34fc93da829c9c44a6641382ff92336f8cdedd1734669bd", + "blockHash": "0x37a95c1c4d8ae9548f7abf278b6d3c8fd6abce3ad831527a483b585ae5574496", "transactions": [ - "0x02f86b870c72dd9d5e883e82013a01088252089483c7e323d189f18725ac510004fdc2941f8c4a780180c001a060996b291aa6694897f4fd95c881f9c8831551f65d91c2edb0398f8a3ba31c61a00fec3df98ac224517ad5c762dd10caf4bb737e813993340c856a9aa3f63d24ef" + "0xf87582017108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c273de87756911775656d69748718e5bb3abd109fa0281c137f735893068d049ff9c97d9033fa5c9a6f56651ff1b6a442320ddec381a00180b3f8386e2cd45894bd0a2fd42f8e9f61a32d82b93a590f352203bd185a9e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10859,21 +10914,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2955e6adbcf58ce3f34fc93da829c9c44a6641382ff92336f8cdedd1734669bd", + "parentHash": "0x37a95c1c4d8ae9548f7abf278b6d3c8fd6abce3ad831527a483b585ae5574496", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x54016558c8961722006c12d3c14a0e63f83acb89ffe3111a8e23ed00fa021d93", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xf5e39baa18e94b48282c51bc27137bdba258a3a5200b2da4fe2dea6a7a970fdd", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x158", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xd70", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4ef098ab7baa897a6c538545fe29382fbc85c59ac78a01b5428a0db58bb5bfca", + "blockHash": "0x02bf4c87617d99c78ee4061fcad0436ec41d1feb5768436917aad995dc1a5c46", "transactions": [ - "0x01f86a870c72dd9d5e883e82013b0882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c001a061490ee93d7aef29c2ca23db661ecbe276001f15fd2760c5b6e068a844c8e806a02295e4ea97c85188c5accaa5ef1125ce2af9f791ebddb1d37be6a72809c81ed1" + "0x02f86b870c72dd9d5e883e820172010882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c001a0cb87fe5f6cea3745d84f4b61df60a46ec996be8d880e124a72bae1185a32cd66a04c9f4401a5ea80dcd61c2b85eef64a24cfcc272ae5e518cc4e2eb56031510151" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10890,21 +10945,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4ef098ab7baa897a6c538545fe29382fbc85c59ac78a01b5428a0db58bb5bfca", + "parentHash": "0x02bf4c87617d99c78ee4061fcad0436ec41d1feb5768436917aad995dc1a5c46", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8e469b68b653164eb3983c967ddce5c94c6427eb70f9b8e087cb0f369169ee1d", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x2c91336305090ae48c3c695559b175c60fda5fce0b544330272c89d5b0bee540", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x159", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xd7a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xee27e318aea1e83eb7b252d701fc255f8a295bc048819b674977db2140507eaf", + "blockHash": "0x1c88871de6d44ab71e79a3fdbe2e43604daf0194b3a02e1a90337e837201b57c", "transactions": [ - "0xf86882013c08825208944dde844b71bcdf95512fb4dc94e84fb67b512ed801808718e5bb3abd109fa0b230939d00d05d9935edc1612d35a4d651d0e5799ece9623548a3b863fae8dc4a0696d1b595f4c07376bfd0d6c5cdf8bf551cdef599da5b3bc81251eb0d9c49809" + "0x01f86a870c72dd9d5e883e82017308825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c080a0e662016c668666c375d9ff00087154a63129117ac762552065839cafe401f6f8a06aef1d3e9c2b42f3f4f72f00c872591c85e681079deb0a0d3f1b342e6377e376" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -10921,28 +10976,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xee27e318aea1e83eb7b252d701fc255f8a295bc048819b674977db2140507eaf", + "parentHash": "0x1c88871de6d44ab71e79a3fdbe2e43604daf0194b3a02e1a90337e837201b57c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5eb753f46d09f0dac91bca6ca550b735c2402def5c8b90df0a2e54c72a14485f", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x572ee06dceed53734f875c218c0d293026893416aed5d4792e9003218552a52f", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xd84", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x99c16f02cab4384eae354d510b84f49fb3cc77ac1a2deeaa87c7342894ce256b", - "transactions": [], - "withdrawals": [ - { - "index": "0x1e", - "validatorIndex": "0x5", - "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", - "amount": "0x64" - } + "blockHash": "0xe65b0ebcbf8e53e362f198d5286b3be688e04b74109af7e41ba28fc4d7cb5df7", + "transactions": [ + "0xf86882017408825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c01808718e5bb3abd10a0a09fac97de10f5e954dc14927a4e68880f5bfe4a2469c41852c31cfa342a1679f7a033f6b2c3f5812970ba8675bef5eda9ae9f4ee085527566fe729b6040045d8503" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -10957,23 +11007,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x99c16f02cab4384eae354d510b84f49fb3cc77ac1a2deeaa87c7342894ce256b", + "parentHash": "0xe65b0ebcbf8e53e362f198d5286b3be688e04b74109af7e41ba28fc4d7cb5df7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf8fb0d5f0b03dbce3ec0306a54eafcfe052b73623ad18e2893c3aa563c9c2cd5", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xb6c5658fa78aca5831389ede1edf136bc1c396427b317d6f13b9a6726cf8b349", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xd8e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x38c75f8d455709c7dbb8ac586e04a2579d9e7d28a4d33a460588b70612a882e8", - "transactions": [ - "0xf88382013d088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0532bdb455b7324083403ddc1e13da4549613978a1ec591d46995f3eb2c5a0b3ba04ca1c0a37e2de03d4ef5c2ebb955e541ba2085c46d1dc8a85743b8c67afe2e2f" + "blockHash": "0x675cb4223640eb85c8810a74a6fb0820d86a138a1eef666f1a22d27ba1ce730c", + "transactions": [], + "withdrawals": [ + { + "index": "0x1e", + "validatorIndex": "0x5", + "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -10988,21 +11043,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x38c75f8d455709c7dbb8ac586e04a2579d9e7d28a4d33a460588b70612a882e8", + "parentHash": "0x675cb4223640eb85c8810a74a6fb0820d86a138a1eef666f1a22d27ba1ce730c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1f6f555d6e1a61e23db2f07df96d47f070643806deda0e021bac0a3c75461cd0", - "receiptsRoot": "0x24845ea0fc4154b4598890122a5384b3fc9fceccb83c56364d61d4a3a42299bf", - "logsBloom": "0x00000000000000000002000004800000000000000000000000000000000200000000000000000000000000008000000020000000000200000000000000000000000000000000000000000000000000000000000000004000000000000000000000000008010000000000000008000000000020000004000400000000000000080000000000040000000080000000000002000000000000000000000000001000000000200000000000800100000000000000000040000008000000000000000000000040200000000000000000000000000000000000000000000000020000000000200000020000001008000001000000000000000000200000000000000000", + "stateRoot": "0x8b8b0f72c04409635982a7e1f5288061a014232da79f52de36c759e4ce17931b", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15c", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xd98", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x346083b60f44fd307e10d7e0f67b5da3d1230332adf26749cb5c80d00003300b", + "blockHash": "0x05276dd8169c6699371aea9e2758f23c15c2739166b91fd5f8556101b4bb3f21", "transactions": [ - "0xf87a82013e0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0012ead7b881a49a22e7b9eb57c01088ec1e72c9939e582f16ef3558afa51147ea019f4d510d02d8bb75f75f20bd37711605c8c338385f2dfcffdaf6a6a895c6c81" + "0xf883820175088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a010215ed3ba3ccf56eca9507dc5e826c264631d30230d14b85f7b8cf9748a88d8a07b36f2aac7a46cac9e76a2033565f48449f989fcdcae906f12c9967c6f59c746" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11019,21 +11074,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x346083b60f44fd307e10d7e0f67b5da3d1230332adf26749cb5c80d00003300b", + "parentHash": "0x05276dd8169c6699371aea9e2758f23c15c2739166b91fd5f8556101b4bb3f21", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x63b1e01af28bea08292e308f0eb39db17751900ef949289cd5b4da93d6440ef9", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1f1840c6881b5b3235e79dc812bd381db601a181f084f19f9c45b8f22a54aeaa", + "receiptsRoot": "0x97626aeb2db4486d9fe2841c5771953372c090a7db331043abf77a91bb418339", + "logsBloom": "0x20040000400000000000000000000000000000000000008000000000001000010000000000000000000000001000420000000000000000000000000000004000000000000000000000000000000000000000000000000002000000000000000000000000000000400000000000000000000018000000000000000000000000000000000400000000000000000080000400000000000000000000000000000000000000000001000000000000040000000000000000000000000000000200200000800000000800000000000000040000008000000000000000000400000020000000000000000000000020000001000000000000000000000001000000000a00", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xda2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdef08200cf595f64a706819f16a1c39b7409cbbc14fc29a87b50c95a3f9e0464", + "blockHash": "0x2bb6a28a333d633baef19929640188c26f70dfd798c0948bcb81f7b48b7e6f83", "transactions": [ - "0xf86582013f088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa05503af9f6399474958ec75701b360f133e8767010db164cb4e1c0fc415e806bfa0660e8b86200fb2a10af8ee02f9645b8e1d48042c5380542b53797fc255884094" + "0xf87a8201760883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a009972e5c75852272d8e9587a45206370028150edac38eba5d91838075a5b323aa05bb3b9eb946f2f2273c735f60707a6c0bf7d2f137e64fc32e6c6f1e260446a05" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11050,21 +11105,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdef08200cf595f64a706819f16a1c39b7409cbbc14fc29a87b50c95a3f9e0464", + "parentHash": "0x2bb6a28a333d633baef19929640188c26f70dfd798c0948bcb81f7b48b7e6f83", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x82f87064f0098ed17ea770b3040e2a8833923f0e159ea09ee1e0e142cd2193cc", - "receiptsRoot": "0x6e519d18eadaffe71c1fd8e69d0b0ed1012b8fd9f79e97da742a5bd2a119becb", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xf11800afbdc603c481b385010048719fba5062700189315fcff6ca3aba232204", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15e", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xdac", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x701b50b242d6e6062020d66c4134f678c49fc7887ba1f962f97863b7648626f2", + "blockHash": "0x418ac48b8467db2e040a7b57b9f81e3f5295077d62988735ef5db301e4312d85", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201400108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cda2a1c4a6f29dc43656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04b916e15bdb0f5b4bccaa3447694db53cc34095b5bc26299c14a9f573bd6c75801a05b3c47bad5778a6f2b5f618f1746185144a162ed303258d23f52d6d3b3ea4b0ba043b36639da4429ce3a5c7d6e0fc7da8d99b8535ad730aa357e277c1a4a485987" + "0xf865820177088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a02ce52dd89b969da3b9c18ea9cfe004e1bc316f5d57bfd03df25535c708e9a4ada0273e77e52bd6658f4ea91a07d37202381c047b8dd49cb4a1907130d75d44641b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11081,21 +11136,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x701b50b242d6e6062020d66c4134f678c49fc7887ba1f962f97863b7648626f2", + "parentHash": "0x418ac48b8467db2e040a7b57b9f81e3f5295077d62988735ef5db301e4312d85", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6f0f84289a9bde0f88dc60d0ca020fde4b803200f53882b4133da32fa23e11f1", - "receiptsRoot": "0x505408927d83279aff752328f9d0bccad95e9e4eef621b6daddd4b8ca4400627", + "stateRoot": "0xd54e91945baab2131000d844ffc2206205d11be87fd5b0bb692ca44fe04f4d39", + "receiptsRoot": "0x285d25f5101d22f9eaff4bde9abc022b398732069305daba98f23adaaf2ed5be", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000400000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x15f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xdb6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3265fc38a6c5684461c72e9c03fe1ddd99a53cddb2d371d0fc1188a130d76e79", + "blockHash": "0xd97364746b3c009e86e4601ea8a4ec3eed223a070b3b343b33ad8a121708aad7", "transactions": [ - "0x01f8d3870c72dd9d5e883e82014108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9544ff5cb729419c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd80a05e969015af64fe334d2efcb6140612c74081ea1b13cb4b3e6fff55c5c09587c7a040e997ea1855f5eec240cea3d1d78506e6e2029d8cf3e1ba09a8276224c77902" + "0x02f8d4870c72dd9d5e883e8201780108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9544ff5cb729419c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd80a04a6cfece11982a16f1a088d2da3c2ba7f42fe826ebeed0caf4ce8a9174b7cab4a005a8938150b068d77d10a4647a4e8f70940fa26c688282d7b5443c0d1f747cf8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11112,29 +11167,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3265fc38a6c5684461c72e9c03fe1ddd99a53cddb2d371d0fc1188a130d76e79", + "parentHash": "0xd97364746b3c009e86e4601ea8a4ec3eed223a070b3b343b33ad8a121708aad7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x96671fc468fca5490c17be95a600802bf2e9aec1fc65ef02f06e08a7eb750b57", - "receiptsRoot": "0x18cf9fb8fd5c05afa7e14a1e88a774e6901368001f71c84e9e0f69dcab86e19b", + "stateRoot": "0x3db80d9560ba49da9f3db2dc7bb6d41f6e5344a3ff239566c73e8e2a4c26ab9c", + "receiptsRoot": "0x1b2a2ea4be7012743e0819798ac021ff08d03138c84a96f97d99f44b4fc4be25", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000020000000000000000000000000000000000000000000000000000000000000000000000004000000002000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x160", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xdc0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x84bf2031465aeaaa042fc5f12c7cf61ce1cdb3225525bf961b115bffb477ba2d", + "blockHash": "0x915b1161ecce056ce9b09ad20e535ee47578a868802d36a1bfa38ee437beca07", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201420108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c63d51adce824b5da656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a040325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0d091dd0d488f94804707798f84d010809a6af6449224dd237629331078f91c3ba045a80c3a55fe668cabd867d15b92607311061af5ef4d15f2de9fb3732367d1e6" + "0x01f8d3870c72dd9d5e883e82017908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c63d51adce824b5da656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a040325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd01a0cd0a6786dc03f09d4f57b430527c01761a20316ca9800fd74b2bedec8978ab42a02267603eb966f091bf5c62d000b256f1701199c2b55bafdae1df8c5c5db6ce7b" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x7cfa4c7066c690c12b9e8727551bef5fe05b750ac6637a5af632fce4ceb4e2ce", [] ] @@ -11145,27 +11198,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x84bf2031465aeaaa042fc5f12c7cf61ce1cdb3225525bf961b115bffb477ba2d", + "parentHash": "0x915b1161ecce056ce9b09ad20e535ee47578a868802d36a1bfa38ee437beca07", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa328fd0afd4855ac88654b9232abcfb46f0160928ab05db2b041993d60ef50a4", - "receiptsRoot": "0x1a56364363167e0e0d22ef01ae11d49ff6fdfa179e1e93ff9cfe93b66f7a9e69", + "stateRoot": "0x2c5ec480f25be5621da61853aa669c019215deae07d0d43d0356b19e13d2e78b", + "receiptsRoot": "0x17c65ac03b70b69ff8d7bb62b8f0ba8fe30dc0cde6f2694c29eef9fe6ecef98d", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000009000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x161", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xdca", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x95d03fc9c7ab7b1f91a38325076295ba7251541246ff6929d4c3b4d7af875705", + "blockHash": "0x4f58b596ab05605431d3a936043301eeda09adbfa46a3c02e452abcd988f4b34", "transactions": [ - "0xf87582014308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd120caade914624c656d69748718e5bb3abd10a0a0f9ad5ab1339e6df5515b0a06ed1b5fcefdfb497a458a10d1f6c4d7ddff785f34a075ffb836a3c0f32cdc485d56cffd5877eec01e02f952dbed1f3b24dd7e4578e6" + "0x03f8fa870c72dd9d5e883e82017a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cd120caade914624c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d73688caabee79f6ecf3a0b092d26e639b7e486e45c00031db80d3d7abe8c68383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0014f1329eea5010dc0ce5c91bdc12dd6db4f6e6f64335242a2dd68139fc9e0f8a0047128a9852f2ff7470e0ad01a14101bbd076014368a0b00817d47824ca08618" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x943d79e4329b86f8e53e8058961955f2b0a205fc3edeea2aae54ba0c22b40c31", [] ] @@ -11176,21 +11231,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x95d03fc9c7ab7b1f91a38325076295ba7251541246ff6929d4c3b4d7af875705", + "parentHash": "0x4f58b596ab05605431d3a936043301eeda09adbfa46a3c02e452abcd988f4b34", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf4beeeba7e78c83863ab3df26df08f8eef086f7ca90ab6d626873bc57ff24c19", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5066f72db27fc26d1e53522d6c5ab4ec15b43236adb9315ee560eeccd1b3a1ec", + "receiptsRoot": "0xcaf62ebcef1ad7dd1af416141ade74d405d6f79da262e49f0fa7d37af60fcf4c", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000400000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x162", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xdd4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd7e39656fea33b079d0fffa85665bda655e35ac8cd609b24db52fc10dd22030b", + "blockHash": "0x318aec788d4efe4aba9138446d6aa0e292c18554eb34a15b827c22188fbebb46", "transactions": [ - "0x02f86b870c72dd9d5e883e820144010882520894717f8aa2b982bee0e29f573d31df288663e1ce160180c080a06bd165a9d39e2cde94707e00703d551c677d194c8a27bc0958a95f1cf5cc3b66a077dd528aac9a99930887ae334cae6579651a3f537da469d6b58467b7f6eae8d3" + "0xf87582017b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc14eb1947b69c832656d69748718e5bb3abd109fa0601d55820ca29740a96aee46cf81129de59d8cf42cdfd82033eaba021f3c828fa04d69feeeb37c377d530f81aa3526ad392828615e5d8ce9308b54a9c7f16eb427" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11207,21 +11262,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd7e39656fea33b079d0fffa85665bda655e35ac8cd609b24db52fc10dd22030b", + "parentHash": "0x318aec788d4efe4aba9138446d6aa0e292c18554eb34a15b827c22188fbebb46", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3f3333213a8cabf535c44779e3a714381b1fc54f4bcb9c103a56dce09a0e2ac2", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x3fb21f54feb17ff64599c5f4d6219a6d841cbc243e854f16b6b4ba1fead7b9a2", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x163", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xdde", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x56f28aefa9c8a192e22bfd3ba9946ca3b8d1e96897d3599f8f7ce0af473662b6", + "blockHash": "0x4401d3aa9f1ff873ad2aab1d705c874c41cb5bf206ee59eed2e5daee6c6410e0", "transactions": [ - "0x01f86a870c72dd9d5e883e82014508825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a040b7abdaae14c9c548d77583eaf61153bdcf2af46f724abe4efd423d61077e13a02bf59a5961a1fb1d1a00b6c35d78d95b0f0e00d3b7bd6fa0bb4b16eaaf0bccd2" + "0x02f86b870c72dd9d5e883e82017c0108825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a020c3205f300f3a18173e9184024c4bee2604bddb03d4f5444f5192a0556848e8a07f31e8e53caba85a657a76e356f4d00936ff071196496fa38e6cf9561df47872" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11238,21 +11293,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x56f28aefa9c8a192e22bfd3ba9946ca3b8d1e96897d3599f8f7ce0af473662b6", + "parentHash": "0x4401d3aa9f1ff873ad2aab1d705c874c41cb5bf206ee59eed2e5daee6c6410e0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x786ef26f04264a255c620783ab3f8ad48ee353ec00032be699f581aa59459502", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x59df92b306e8627f08bb4f6b15ec055ab32cc5e20f6a39f4d7a9200da45deb3d", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x164", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xde8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa256e8a74e0d5f0db511d6df3d329492b15504f515278ff998d108a49902a8d6", + "blockHash": "0xea7938e34260a926ccd50ce03f9d1f387948af9b961c6f48ceb76ebbecaa2658", "transactions": [ - "0xf868820146088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c01808718e5bb3abd109fa025de91a23f27d8c900dc950bbb17e06495339c1f24a8b6c6e06f11a1c4468450a01737e65efad4010e16860a4b4944c6ef6624d5f2c1fd29bc7626f55e99e80a01" + "0x01f86a870c72dd9d5e883e82017d088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a034bc900da40475695628b9df027c69b53db2a329edf7eff1bd2993e662a0596ba003cc67c5a7b1ddeab871b20722ce8b604c128a3c5b3bdd4aef0c27b893913cf4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11269,28 +11324,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa256e8a74e0d5f0db511d6df3d329492b15504f515278ff998d108a49902a8d6", + "parentHash": "0xea7938e34260a926ccd50ce03f9d1f387948af9b961c6f48ceb76ebbecaa2658", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8367e96cedb6544c9f21058628d72ff78e4be19aeb9e3581eb254cf62a580005", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x0d8cf4596d32bf3d818719617fd18dc80e999ed27bc7075545a4ffc375680d4d", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x165", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xdf2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfda145c2f89e067fcb82e98c5a201fb8f9949d578a1b87241e6f7c103fbda5d4", - "transactions": [], - "withdrawals": [ - { - "index": "0x1f", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } + "blockHash": "0x08f4cc7edd04bd308dc6e7bf4cb07b806e7e2de61545abd1f51f9ad1d59cf75a", + "transactions": [ + "0xf86882017e0882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd10a0a02a40854304a78f963d447a4fc6ed04a83f080d70bc2b9d08830ff778f1691b40a06fc3befc469ccd25b11fe53d93ca3b7f1b17b10753d260374b10b36cb86b6b83" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -11305,23 +11355,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfda145c2f89e067fcb82e98c5a201fb8f9949d578a1b87241e6f7c103fbda5d4", + "parentHash": "0x08f4cc7edd04bd308dc6e7bf4cb07b806e7e2de61545abd1f51f9ad1d59cf75a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa2185fee71394ba245d483bb95d117c04e584a1e3486154dbda7ac23d5e5d6c3", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x2d19f68d8b2ac2dc83f59e006c7ed180a7e1e2f39bcb154b7d047bad5f034f6c", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x166", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xdfc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc60a413c6267e5f34ee8e27efcb89e2bbcdd4b839cb0c961f7dd37805181626f", - "transactions": [ - "0xf883820147088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0f91141179eb75a36e3f88edefa1b6aea266f623647afe0f3a269019f22ff823aa04e9bd3bdeca6818a15445105ae924e61f126ae9355741307b4a5955699b0104e" + "blockHash": "0xa00622d4741d5328d26df1a386bc743d636523cbfb4ae132ef9973770be54646", + "transactions": [], + "withdrawals": [ + { + "index": "0x1f", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -11336,21 +11391,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc60a413c6267e5f34ee8e27efcb89e2bbcdd4b839cb0c961f7dd37805181626f", + "parentHash": "0xa00622d4741d5328d26df1a386bc743d636523cbfb4ae132ef9973770be54646", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5c401a283294494c8cb499c7017ec143afc3880bbf163332bd4f85257fde02b3", - "receiptsRoot": "0xa6efaa2bd5e8b55c9ee7555c2010566ebce0eceb665633bf89fc058554243280", - "logsBloom": "0x00000000040000000000400080000000000040000000000000000000000000800800000001000000000000000000010000000000000002000000000000000000000000000000000020000000004000000000000000000000000000000000000000000000860000001000080010040010000000000000000000000000000000800800001000000004000000000000000000000000000400000000001000000000000000000000000000000000000000000000000000000000000000000000080000000000800000080000000000000000000000000000004000000000000020000000000000000000000001000000000000000000000000100000000000000000", + "stateRoot": "0x9946811b1d721b495e3481d0450a058d0dffca108f1c990a2b3c6fd77e9de916", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x167", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xe06", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9267c3d2e49d9a2fbb84a69db614d9fb33bae938ee4bd0fadcf5cc033562bd8c", + "blockHash": "0x9f5cf2010cc5b11d8e26387a3dc7871353fc465161e0179d7a022e7fc216d894", "transactions": [ - "0xf87a8201480883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0d18d9add1c775ef5e466f61a1519ab1701644a82a77e2fe7f2919eee9be1f271a03bc8219f96194b5cb1414c95ee3839ad3e868bf3e60d4b33e45ced1b73b52401" + "0xf88382017f088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa08ded30f91eadb86aef45f8603080b77479c324a6b0461176bd05b9dc52434366a01f8e64121ef22b0a68dbb5f5fc3ee0e379d24ea28ba18716bc76924962a89efb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11367,21 +11422,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9267c3d2e49d9a2fbb84a69db614d9fb33bae938ee4bd0fadcf5cc033562bd8c", + "parentHash": "0x9f5cf2010cc5b11d8e26387a3dc7871353fc465161e0179d7a022e7fc216d894", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x58b966da2254b60e84562b9b265b24b27f440c3148decb437e8eb759ecedd58b", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc32c77e18357c918a8f28263a0a462d8fbc88cb1cf30ecdbc99541d78ca50cc8", + "receiptsRoot": "0xff1547a0c5d35ecfe6c88ff5afc801fa62ef513b146587249b8f6bb774601a86", + "logsBloom": "0x00000000000000000000000000000004000000000000000400000200000000040000000000000000000000000000000040000000000000000000000000020400000000080000000001000000000000000000000000000000020000000001000000002200000000000000000000000000000000000000000200000000000000002000000200000000000000800000000000400000000000000000000200000000440000000000000010000000000000000000000040000000080300000000000000000000004000000200000020000000000000000000000000080000000000000000000000000000400000000000000000000000010000000000000000004000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x168", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xe10", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf66d68a2b0dd9fbc45a5646cebcb99e8af641c8a372724264058493e141eaa46", + "blockHash": "0x7bae673e78c9468adcbc5af662fa1a64303269928a74faf206c36e8e90d39e9f", "transactions": [ - "0xf865820149088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a066053e37815a04b8665e4108e806ed564fd57af67c7f28cc40b79272e011ec75a0095d99837cab6fc1a53b126936c0d8c2ca339ac55af799229323b7ea128e33cb" + "0xf87a8201800883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa06ee1e2240987a5957c71668bddd78286a8a97c3605f540169dcfed9ba4479311a023858f1a8516678c55295559ae843c02f92211dfb2ebbac5a5cb039c2b7bb1df" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11398,21 +11453,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf66d68a2b0dd9fbc45a5646cebcb99e8af641c8a372724264058493e141eaa46", + "parentHash": "0x7bae673e78c9468adcbc5af662fa1a64303269928a74faf206c36e8e90d39e9f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4453faa136a6236d91bfa955406d6bd7989ad4e6fb06f331d0b8328d4ce02162", - "receiptsRoot": "0xbfbc3f80b299340eaab4e22415e1ed57ebb1d5a83d4431f7189a1851e9ab94f4", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000040000020000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd2fe93f9138446fa18a96211c54de9e99438eb07ee496c0f47348d731e93207d", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x169", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xe1a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcafa23b21dd847e0a6863e2d6a9e81749d2ae6174e340bf3ed6c27e030ed38fe", + "blockHash": "0xf5c8e55d5ccac994718819a5e84706912e3a13ed1138af213068a1dfee7333fc", "transactions": [ - "0x02f8d3870c72dd9d5e883e82014a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc5d1b5234d598db7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07975cc1088361453b019ff19e2177b264cfea56f4c09b1a8a086f6c405dd516c01a0e02857fe8d948db7745f2b17a5cd9713b92a60da8da7daa70d5b1713b12a62ba9f8e03e24b97096b677d1bed7544c3ecc4a18d98989b9dc0bdc5d9a9a7e25fa3" + "0xf865820181088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a01f6404f32c81c38b12d5556286f11a241ff430689390a8152fcf4d5b1e51e260a06f69bf082d07343d45159ea6f2225c15323ff958fa7df453597aacb83a5717f8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11429,21 +11484,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcafa23b21dd847e0a6863e2d6a9e81749d2ae6174e340bf3ed6c27e030ed38fe", + "parentHash": "0xf5c8e55d5ccac994718819a5e84706912e3a13ed1138af213068a1dfee7333fc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x37fb7cae9e1c94703e61e83bc7ef00f5677ec59a3ac867818e3c55010afc2648", - "receiptsRoot": "0xd212385e4afdb5978e6dcb1ce04cf85af1c33c1878da895bc40c97df4abef905", + "stateRoot": "0xd8fe6161789d8b8289fce5f90ea6f929ec4053b65c5a5ee382349c23bf2b6520", + "receiptsRoot": "0xb7877e21a3193c714ca254cdfcbadfa256aa5dc5112a0dff0c627c851f8aa9bd", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000040000000000000000000000000000000004000000000000200000000000100000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca90", "timestamp": "0xe24", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd6aca4fd2acf5ca563efa815897afcfaa175b8955931f699ae4018ac86eeea91", + "blockHash": "0x5ce347e7492dc1fae5a790ee38bbae921fa4c33c12d9728102107ff2242037df", "transactions": [ - "0x01f8d3870c72dd9d5e883e82014b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5b00e11941ab7046656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b2672301a025d780cad1d212faf6744c9e152ba4b6ab144f30edd18a15680fbfdc5bf8e08ba00bebac8aa02d02642c519f1182de690b3d42fa44389d0be8239f41cc97d2de09" + "0x02f8d4870c72dd9d5e883e8201820108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5b00e11941ab7046656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b2672380a0ec7b63e7f42e8247f1617fba414694633262e54c0f369e39902446fd7dbffda3a04b7b40d08a68a5ef1dd52cf072227ad975fd1d542a0ccec8a5eaa894e6c3901b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11460,29 +11515,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd6aca4fd2acf5ca563efa815897afcfaa175b8955931f699ae4018ac86eeea91", + "parentHash": "0x5ce347e7492dc1fae5a790ee38bbae921fa4c33c12d9728102107ff2242037df", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc47ec5827b3096b1f71cfb5615412890ced2d0e4e25c6b809e54647f92007a0d", - "receiptsRoot": "0x51dc4d1b69b22caadb80e85c68166344898ffbc5d4767ee1214c717c46416a88", + "stateRoot": "0xea78b4b29e8d1e06d68d3a7de1e1c383e1876435b30cc398bfee3718d30b92d4", + "receiptsRoot": "0xb45be2085dc2fb2dfd02b696999104f86fdb1648f6e6766eae89996f38066b77", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000009000000000000000000000000800000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xe2e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x16b4cebad9f39a7db380791451d3a9dd9c35dbadc751254c41f94cae8280358e", + "blockHash": "0x704f8986273e3ddd2829747071efe079b0ad626aa5ce53ab8b881fe2dae20407", "transactions": [ - "0x03f8fa870c72dd9d5e883e82014c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c0581a3f309f9b7a9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a09683020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a093f8d363100badb86a1cfaa2bf17b1d051130d2c906dd48c0c44038f4e5f3a5ba0236c43ff36fb2dd731590896717db4c534db3e2e2937fdfead8bf6d2e1d3b4f3" + "0x01f8d3870c72dd9d5e883e82018308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c0581a3f309f9b7a9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a09680a0df8454b1d2ac55fb2b56518b9af603d081fb456dc5a2d1a4f14d32a1930e0b65a05eec84799f4c8113b8e558e727c7cbd95fdac9a60a1a19337b20957589ef9670" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x54a623060b74d56f3c0d6793e40a9269c56f90bcd19898855113e5f9e42abc2d", [] ] @@ -11493,27 +11546,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x16b4cebad9f39a7db380791451d3a9dd9c35dbadc751254c41f94cae8280358e", + "parentHash": "0x704f8986273e3ddd2829747071efe079b0ad626aa5ce53ab8b881fe2dae20407", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x089e671fabff27b7a6a5bec573cf9815686c0597138d9284647a5fe97590d738", - "receiptsRoot": "0x7ac3337326ead8b549b53abed41fcc43cf5d7b8545dc05588173145a617cf712", + "stateRoot": "0x60ca9246696f71c8c5ef48227f3d0706810e226f520d614353c5a27d1a2adc84", + "receiptsRoot": "0x686bb5690e471cbe94f0fbd0bd64178a41189bf1b22860833a753d748989a8c6", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000800000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16c", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xe38", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x505a6bf5ab0f40712af88078826c83c152e5ec99fd74ae718e47c0f1b6c7c0fb", + "blockHash": "0x8b372f1d731e91f9e3e65d489488e2f5256c2db193d27c80adfd7500930bfed8", "transactions": [ - "0xf87582014d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdddf70b2f66dd741656d69748718e5bb3abd109fa0a67de64d6cb2c553afbb804db1871168ceaeaac9e6ad06e8ec141cfc01757178a06d770bae5765c71dd7d77a11ec2e4a15bc84453dbd2016d66a0756c340bcdbc9" + "0x03f8fa870c72dd9d5e883e8201840108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cdddf70b2f66dd741656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0945c01f307d13fcdab0a2a3a4c4bd5ebb69a00c3dd59896a959664e01ce1069583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a002913953086fb38270b582f9264a54a8f7a9fd52f3914c93e1c6bf61ba29c05ca0488e04b63258b9f1b21371dd85f1d48d3eb8ab573f1b7baeed6a7bdad7599698" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x1cfeb8cd5d56e1d202b4ec2851f22e99d6ad89af8a4e001eb014b724d2d64924", [] ] @@ -11524,21 +11579,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x505a6bf5ab0f40712af88078826c83c152e5ec99fd74ae718e47c0f1b6c7c0fb", + "parentHash": "0x8b372f1d731e91f9e3e65d489488e2f5256c2db193d27c80adfd7500930bfed8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe6d3d3f1f1dedd2bf3fddb34a7ad6d5af258eb1080793c91ee8f8844f26ddce9", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xa52cc45cb02dacad022ceafe5fbd047084ced7e1156c04a3939a063823deba23", + "receiptsRoot": "0x3d50045ea7712dabc7bc624626b661a55830490fc4abe245fd79bc3052adf0d7", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc25c", "timestamp": "0xe42", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0f15f04e28de513a6e468d22860d94e5389a07b5b630f8a8e7b84ed7bc0b8558", + "blockHash": "0x8037a2e6778f5a2f86243f0f68e1dc27711a83e23f17dffeadba79650efdc061", "transactions": [ - "0x02f86b870c72dd9d5e883e82014e0108825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c001a005b69e48a3446f70511c54ab36235de711ac546cf056d7e97bc902215e365ec9a02a292f3b4f719296a9a548a42464b52e79d70703a662122c809146ef351c73e5" + "0xf87582018508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c00593792347501e7656d69748718e5bb3abd109fa04aec43f149d696a06905565e4456b92ab3d9291dcf6ce18bbf3e6e0b2e974bfaa05ff76d260a8b25969aaa34161113ed0948153acf0e0f6d56a8fc002712f8b22b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11555,21 +11610,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0f15f04e28de513a6e468d22860d94e5389a07b5b630f8a8e7b84ed7bc0b8558", + "parentHash": "0x8037a2e6778f5a2f86243f0f68e1dc27711a83e23f17dffeadba79650efdc061", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x85571fdc8cc44636348f3c10cdf031ffa5504dc9eedd3598b0710ddad0efe28b", - "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", + "stateRoot": "0xa57db84a5de1a4aa407ead420958d26afc17b75e078728dd02a40e99a5f91790", + "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xe4c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7371118bf9383f5e8b92bbb6cc9aaff94c06477228cde2abfffc48cabafc1bec", + "blockHash": "0x83b55c0c81d1b9e925dd8ded23f5d620d5c90ff0669978808bafe0f9cf4fba4f", "transactions": [ - "0x01f86a870c72dd9d5e883e82014f0882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a072885b5a14a5cae7134e7aa308ef77fdebcd2cb995d9d9c4bdedaa8733fd6cd0a05eb1d201d26f47f1eca74d1f787f91c43f9089ecfb050f67af872352e0431a14" + "0x02f86b870c72dd9d5e883e820186010882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a0c3c4bec7bac5ca693f7fc674a4c3230f1f3ea8dd998de09c920825d26301c011a05ff7bd766555a0e202234d8a43c208bf8c1f9a20a1b30d6c310480dd8dd54fcb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11586,21 +11641,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7371118bf9383f5e8b92bbb6cc9aaff94c06477228cde2abfffc48cabafc1bec", + "parentHash": "0x83b55c0c81d1b9e925dd8ded23f5d620d5c90ff0669978808bafe0f9cf4fba4f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2fcb885f5cd5d4b9bf40eb6d5c0fd445648f559beee2dc7e8c0690c36d31ef8c", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x5705b5b4a3f14d552ac085df2780784da408fa2156d8cccf85527f327a387531", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x16f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xe56", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x77d7c2eb0af7749896c1be40161508d650c019a8fdfdabab4b34b47f0caa5a80", + "blockHash": "0x47d1a1fd87ce37b222c945a0926df5db04b51f7cb7bbab3b5038aa755aecd57d", "transactions": [ - "0xf868820150088252089483c7e323d189f18725ac510004fdc2941f8c4a7801808718e5bb3abd109fa086aab378b3165e20297e9d6ff3d5da704f3e4b3d1f087ad9131a8d5bc5a3c8eda03aa230322dcea454aa1edae6bc9a9af8a0a2c40d5836334b3f2c4fbe1b59c046" + "0x01f86a870c72dd9d5e883e820187088252089483c7e323d189f18725ac510004fdc2941f8c4a780180c001a0371d1a507de4da57f89a4fa71df9f02443ff37580810ea26149bd128c9d6acf5a02818244deb6894ab6b9e2c34e1e6f7c7224d53e27857cf37639cc5d0636587d7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11617,28 +11672,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x77d7c2eb0af7749896c1be40161508d650c019a8fdfdabab4b34b47f0caa5a80", + "parentHash": "0x47d1a1fd87ce37b222c945a0926df5db04b51f7cb7bbab3b5038aa755aecd57d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x727be1133b3b99853b987da08d0e07e8b01358cd426ba12896fe05bb20ec75a6", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x77ee4ebcbde63ea5acdb408b7126f4d9699f740c236b83e9d7d7989d6d0e6369", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x170", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xe60", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc3c6a43b0a9fec6d3e9c232cd9048eb4b655f8c779ff7c510195e75d4c3cb3dc", - "transactions": [], - "withdrawals": [ - { - "index": "0x20", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } + "blockHash": "0x05a64565e90b2488725a1682f087cb8eda679593d4163e606df37d717fa885f3", + "transactions": [ + "0xf8688201880882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd10a0a0339ee08f01a43156d5d3bb10e7ffc8dc8f15a9964de8dca936dd06895d01ae12a06168e11111c7dadee1a31c2454f90e0e833efb767d3b5ff4dfdeff164dc75196" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -11653,23 +11703,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc3c6a43b0a9fec6d3e9c232cd9048eb4b655f8c779ff7c510195e75d4c3cb3dc", + "parentHash": "0x05a64565e90b2488725a1682f087cb8eda679593d4163e606df37d717fa885f3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6aa75134a379dc98080f0313ed78800dfac8e76e701b63edee260fffe7dd0182", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xa58038fc8f490096219df276b21b9d88303ec60cc0ccfc5f7f3bba39e4744c6b", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x171", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xe6a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x024a6e084b404338002e6dd8b70331a3ad6d896cdedecd23db0c7db0cca13ea7", - "transactions": [ - "0xf883820151088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0b7f14a7de3212ac6e25fcc2e7727627619c71692e0a9d8c723f7337738fec4cea0745eab42b319407c929087225440ea9007b7d47751fec14db91ef9bfd055a8b8" + "blockHash": "0x3340b09045d81928d5feb249588b82048aac136feda454dc13bfa778ddaa1405", + "transactions": [], + "withdrawals": [ + { + "index": "0x20", + "validatorIndex": "0x5", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -11684,21 +11739,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x024a6e084b404338002e6dd8b70331a3ad6d896cdedecd23db0c7db0cca13ea7", + "parentHash": "0x3340b09045d81928d5feb249588b82048aac136feda454dc13bfa778ddaa1405", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x94edb1c63ebe96190bba51941774daccf9601236019266f0a758d2d43ce14fa7", - "receiptsRoot": "0x7251de47ca910034b44cc1b34a11098cb7cb41a4251591cbd744030fa6e56070", - "logsBloom": "0x00000000000000000000000000000000000000040000000000000000000020000800000000000000000000000000000000000000000100800000000000000000000000000000000000000000000000200000000000000002000000000000000000000000000000000000000000000000000000000000008000000000000080000040000000000000000000000000000000021000000000201000000000000000000008000000000000000000000800000000000000000000000000004000000100400000000000000080000400000000000000000000000001000000000000000000000000000080004000040004000100000000010010000400000000000805", + "stateRoot": "0xc32294428fa6e335bae612012e6cc9dc08d1bf2dbe9cf366f198214e4466cd40", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x172", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xe74", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4ac493337944aac392f8ec72d0187775a98712347f2d3a8ce5e6dfade5fc88e1", + "blockHash": "0x327de227ff353f33e394e8d4000f33513c924ea807b747f3cc63bfb40d9c950c", "transactions": [ - "0xf87a8201520883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa09ffdca5ddee51f70d71957df581c7af8b647e7ce3cca634b713703fa2056b8eda0633e4ec86b1a5621be40b8b90ee6ab1c6ced4b8f24038739623a7fd720c37cc2" + "0xf883820189088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0c84af0e889fa167b50bfae9fd9df3027267fdf72de8d1f40dbc48af87d5d1024a04f53c349e331c4e6d3193cd6cfec2505da47cd38124a2648371e279be9cbf727" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11715,21 +11770,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4ac493337944aac392f8ec72d0187775a98712347f2d3a8ce5e6dfade5fc88e1", + "parentHash": "0x327de227ff353f33e394e8d4000f33513c924ea807b747f3cc63bfb40d9c950c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9deac8e88d661e3853fcf27372aa74ee3e8a0564581abf2229380cb91bae7285", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x3c040a6da222421e2f4620f2fba8740e6ea68d7f94e330746a3256c7a3d396ef", + "receiptsRoot": "0x2357cddf5a247c3284cb2c7fbf7c87db673014c9c939cb04074dd476481354f6", + "logsBloom": "0x200000000000100000000000000000000000001000000000000000000000000000000000210000000000000000000014000000000000000000000000000000000001000000000000000000000000010010000000000000000000001000000000000200010000100000000000000000808400081000000000000200000400000000000000000000000000000000000000000002000000000200000000000000000000000000000000000000000000000000000000002000000000000000200000000000000000000020000000000000000000000000040000000000000000000000000000000000000000000000000000a8000000000080080000000001000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x173", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xe7e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x53f13c2ada283dad19b4c6e1f5d01844ecdfce9b5e5cc064e025aafaa95c97fc", + "blockHash": "0xfd5902869946c283cf714ba1369a87a419d2efaf809ffee5828138db3998941e", "transactions": [ - "0xf865820153088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa01c4c4dad5cc48dc34f7de3b598ffb02acfa6bd18bbc39ff5f48a7430f1d7e2d6a066a0b6a1d3d70b98a58c1f596a1285cabbe35ebf5365b26e894eed6d8d6c2bf9" + "0xf87a82018a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0bc60b8fd75a4a6d419c09e06f388fd81cfe284c81ef1650db35c8c7fd2d5d857a00b0949182ee719e540197684cce3122e9c425479b3529d5ee69d034e409b75d3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11746,21 +11801,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x53f13c2ada283dad19b4c6e1f5d01844ecdfce9b5e5cc064e025aafaa95c97fc", + "parentHash": "0xfd5902869946c283cf714ba1369a87a419d2efaf809ffee5828138db3998941e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9e53e02a391036fd160aa186d64c5c624a55126dcf665e641e61b04e9ea19536", - "receiptsRoot": "0x14b7dc4ec7b9ec6c7fd91c49ac7aaa6cc4f8f48ff188006e4b72f3b3c862dd0f", - "logsBloom": "0x00000000000000000000000000000000000000000000004000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004002000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1694c00941781d5c70edf603dee32f6773dbbc1d9c86d2e5977868dda81a614e", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x174", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xe88", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5aebb1a84a124ace93a6955bad2c1d3e26769ad5c4c8f7952bca62ffa6ecbb72", + "blockHash": "0xc2ef323c573205f1f1ba96da000d08c88d09b24c95389963a37a5b5f466b8ce8", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201540108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c5ed5f2eba43b9d6e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a05423899586eb1d932cb9da03e478e1dd5d4cbbcb66d24262c7d67e543185c2ef80a035dfd635ab1210be852d9275b75490f908301278d8ecbb2d474367286494ea4fa0488d69db83f65da1b0bd9b15bff90193f94540e8fc85e50bc64fd3e0e04c13ab" + "0xf86582018b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0c268b7a640d08c838a6f6ef04e709f5f45931009e2d0cc43d5e34ce51a8573aba071f8e6078f9e1bdea21152d97cf745e8655622832da6c475dbe76427a29925a1" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11777,21 +11832,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5aebb1a84a124ace93a6955bad2c1d3e26769ad5c4c8f7952bca62ffa6ecbb72", + "parentHash": "0xc2ef323c573205f1f1ba96da000d08c88d09b24c95389963a37a5b5f466b8ce8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x92918085a958a3055fb1d5f08b63e9d93cad3c7dad9663e1298a31effb229074", - "receiptsRoot": "0x42df6f859795da6ef2cbdd440584688a8e875ce5708e87120336cf44292c4ec3", + "stateRoot": "0x7b58d5e0bf2d4951c64784716b25cd2a8432ea5b3d64588c238f964c597b43bf", + "receiptsRoot": "0x2139ad9e9e6fb567eef086dfcdc3b8c592a9d00f0c493d3b8604bba23e6349a1", "logsBloom": "0x20000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000009000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x175", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xe92", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x722cb497906813e0dac64a5e558aebc697f65a0929bdc4c9b763507b37d17442", + "blockHash": "0x29f8ae9fa882fecb82cac317d253adfc23ac083ac8a57f07aa14f450e6cc3a70", "transactions": [ - "0x01f8d3870c72dd9d5e883e82015508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7eccf8bd8f40396c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d880a0b5b75892245daeb02357c3cda72945b5cbc657144f86830ce3d44cd376c7d496a040829b65800769ce56e763b9f4f6b4c75cd3e2a4cffe4f83c62a44543385f6b0" + "0x02f8d4870c72dd9d5e883e82018c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7eccf8bd8f40396c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d801a002f43581fb7145b456d03c03f9a526a2505856e42a7178322e9f43a036141a32a021d13f8f0d56cbb9cc9fbca01d7388a6e82e9e625a459ea7b13b61c967f41ec7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11808,29 +11863,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x722cb497906813e0dac64a5e558aebc697f65a0929bdc4c9b763507b37d17442", + "parentHash": "0x29f8ae9fa882fecb82cac317d253adfc23ac083ac8a57f07aa14f450e6cc3a70", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb313932927133a6c5633b2359129debddf853188e91c7f6c1a1ea15a78310c4b", - "receiptsRoot": "0x0c6b26f41076d265df6003902de96f7e86c075dc5e9a63f8f48a1267d0597426", + "stateRoot": "0x1cafae05ad0b27eeeb762833767e33aef80d349f3b52cc1fdd1ccb751137c448", + "receiptsRoot": "0x8f1aece13eb2799292b9fbff80eaf4196ce333ff2013a1a28a5c610a490d5347", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x176", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xe9c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x86eef2cdfc7f44f813f99a5699adb200ac3e48a490a1e01656f2991f1655f387", + "blockHash": "0xbc73c987e59da4fa66253e4e382bbc25daa551bcebaa40766218c84c249e2022", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201560108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cfe2939afc4f11be2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0ec40ba7acaa9407312daa093659c29c50aa57686f5ed6c0ee253eaa2ec69caa3a07eac3c4bcdd598a852f6b2820f9560ceeb947b77aa25df5d7b8c2d626ac5b0d7" + "0x01f8d3870c72dd9d5e883e82018d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cfe2939afc4f11be2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d01a0d95882f987be1e86360e909070e98c792ae6eaaa4b5e2b13694a417527988975a058e9d712d8da58243e07ae56c75048e6b0af05838b776a2ca2ef62f2c3a0f2c0" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x2b2917b5b755eb6af226e16781382bd22a907c9c7411c34a248af2b5a0439079", [] ] @@ -11841,27 +11894,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x86eef2cdfc7f44f813f99a5699adb200ac3e48a490a1e01656f2991f1655f387", + "parentHash": "0xbc73c987e59da4fa66253e4e382bbc25daa551bcebaa40766218c84c249e2022", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3cbbeca49a1945127768c0baff5802baa1b8e628e4488ed812d556689fe73bef", - "receiptsRoot": "0xdf52941811dbd734ad63629b45095b537ed4ea55e67c677ff846c59d39594956", + "stateRoot": "0xa1bcd8e41df121cc6008d64b049472bde881c2b02c3404e257c61348fc7e98e8", + "receiptsRoot": "0x38b661822706570b109818ad3bf3889b3ba7cf457447413c4a2c5cef0742f17f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000020000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x177", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xea6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf80b907a5268d198f59415e895a2dbd2d2f0ee499394f873bcaad64be35ba295", + "blockHash": "0x8f9e9db44c2a14d5e6f4c109568e1ed5220cbc09face49934d24593d20779eed", "transactions": [ - "0xf87582015708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb5b303999df36021656d69748718e5bb3abd10a0a02616c26eab0952df93c0d803a3e77215f6291c78b8c8c06cd6db33c82f250740a038c446a1a88f1b808599ebe1fef015f19a071b51127078f2267f52fcc7358ac4" + "0x03f8fa870c72dd9d5e883e82018e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cb5b303999df36021656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03f410a22d042d915c50f9269337a2bc7155f86d79bbff1721d83f44153635ac283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a033f479e6f3f19a32cc4ceda762c7ba3d9f72621244228a9617802b01d5d5e204a035baaf72094ac2a994d50552f4a9b2a21dbe633ce9888276f44b3aee2d961e90" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x18d5804f2e9ad3f891ecf05e0bfc2142c2a9f7b4de03aebd1cf18067a1ec6490", [] ] @@ -11872,21 +11927,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf80b907a5268d198f59415e895a2dbd2d2f0ee499394f873bcaad64be35ba295", + "parentHash": "0x8f9e9db44c2a14d5e6f4c109568e1ed5220cbc09face49934d24593d20779eed", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xee441adb4bd9619daedecd5e1159e20ec049eed25fa122b221edfc99bab92964", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x2472f7a374c2fca03cd15eaa484de9f3b526a0877881a36dfbc2af2eba089f44", + "receiptsRoot": "0xac03a0dc44405b2c0e2667e8fa4aa0b25fe0b1008612d6d4052eada04eb50785", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000001000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x178", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xeb0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc4db6912f2653a9382b68bac827e5dd2eb40e3231f203a2f1f8eef0f72e6f02b", + "blockHash": "0x4cbf14ace7c97bbe835d0811871f9eef77d6fe81ece5eaa55e741a4dc1fdd3d0", "transactions": [ - "0x02f86b870c72dd9d5e883e8201580108825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c080a0ec5d5b723b5308b6e3d040a18b25da216cd567053aa39e428de32f696081e037a01f5d2bc541a323b6809774727bd3bcde8f0119aeacf17016ee9a64a15f0623ca" + "0xf87582018f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbd669399699ff5ca656d69748718e5bb3abd10a0a05c3882ff6907deaee22070aa90082cdeffdf3770d929a3d6684f3f5832c30b35a076abd65da2e310d25032bc86d2eea4738c754f26c43887e83bb74058637aa103" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11903,21 +11958,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc4db6912f2653a9382b68bac827e5dd2eb40e3231f203a2f1f8eef0f72e6f02b", + "parentHash": "0x4cbf14ace7c97bbe835d0811871f9eef77d6fe81ece5eaa55e741a4dc1fdd3d0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfe9441c6fb0bea27580b114b71918de7c6a52fd9b4476596ba6f1c61203d9144", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x6a6027ce9189bacce9c0908574485cea0ec74426bee16fd91d4a2c2092344a67", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x179", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xeba", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x499ed1595f081f971a86fa5d465264ec4ebcf362ca75b566c64ed9e143779b92", + "blockHash": "0x6958b982b14e1cffdfc4bd059530efa2eafa98b8b7f5e4d52ea1bae428329660", "transactions": [ - "0x01f86a870c72dd9d5e883e82015908825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf0180c001a0a5ef9f26c5bc750525a80636c71e0e8108fd2ddb4f7f578c8d0a028e9109fdf9a046dce974cdccbe68db42073fe3cc2fe7ed24213042a89baf3c62c9d6884b7d82" + "0x02f86b870c72dd9d5e883e8201900108825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf0180c001a0d3c0a98720b5e62ab0dd2e09c6c6a1d5febbd25768653c7a4dcd0231543b9682a049b33efb78187957b6eb5cfce6ce21711e147451aa4d0baa7f0240a7b52098fe" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11934,21 +11989,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x499ed1595f081f971a86fa5d465264ec4ebcf362ca75b566c64ed9e143779b92", + "parentHash": "0x6958b982b14e1cffdfc4bd059530efa2eafa98b8b7f5e4d52ea1bae428329660", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3f938be2a05406b71df1d2f0e7a39ac8e229ce087850ad6142bffbb884b06101", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x75e7371248e8b4d09aa48c22f93e0ffdd00c3d29d642da5268241d569d495079", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xec4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb079707f805c9e021d3e353694af2c1295ff098e90f96b7e597f604df32d4f7d", + "blockHash": "0xec74048a1581a2c5f60b21cd9e25bf9c356d64346df78fdd4d5ab6da471c09fd", "transactions": [ - "0xf86882015a08825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c01808718e5bb3abd10a0a0e4a8c4ab19bcffc864f8fd1231ed192ce8929410d06e442a6fd0ae7222385d26a0256ace97ccc4af6f32ad0b74fadad90576966cb20e2a09c0c01e866b42b6f99e" + "0x01f86a870c72dd9d5e883e82019108825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0894398d753a80224c3f5956da5fc19f14e47b8030d3a343d2d048db9b7b02e84a07820115a71ebb13d5ab484f151febbfd58299e76bd7dcac10dbc1bfa83c2b5b0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -11965,28 +12020,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb079707f805c9e021d3e353694af2c1295ff098e90f96b7e597f604df32d4f7d", + "parentHash": "0xec74048a1581a2c5f60b21cd9e25bf9c356d64346df78fdd4d5ab6da471c09fd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeb98c7b011307451fd9a31dbb0759dded576923c4b6dfa33c88eee8e553591b6", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xc75c81a1bb1dfebcbcb49def1720e9aefe91ed91083f0516a736738ce6bbf1a7", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xece", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x07a887698ad470a92e0ea4b515f4e0c1eef4d02e005090f039ccad1f98dfa78e", - "transactions": [], - "withdrawals": [ - { - "index": "0x21", - "validatorIndex": "0x5", - "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", - "amount": "0x64" - } + "blockHash": "0x96f61cc569a5cc077dab9be9396177a63a089524e4afbbf0ebeb09e357665e83", + "transactions": [ + "0xf86882019208825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df01808718e5bb3abd10a0a04668f7c9201425d3f6934768909eefda549b8cfdf822cf0c1575aaaa5784f1b3a0033e7f718580e0142fc94ccc16757feae1ed14f59b7a4e7e9a590818c90e536b" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -12001,23 +12051,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x07a887698ad470a92e0ea4b515f4e0c1eef4d02e005090f039ccad1f98dfa78e", + "parentHash": "0x96f61cc569a5cc077dab9be9396177a63a089524e4afbbf0ebeb09e357665e83", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfa5fbe90adb6cd85bed45c22220141e4d4d688ee56d31f9e5ae9395b8c3542d9", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xdbdb7b39c79c0f51a988892b44279d3f6ed5e200e3d28ca9756b5e6bd93de127", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xed8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x37c51aeb36996d1204e1cc23f24fc8ce6a531230eac5fd95a0157afbae993408", - "transactions": [ - "0xf88382015b088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0fc733fa3fb48d3f13ee5eefc2c264d3403b8f29611cb31af2321865502c828bba059f364a077bf6aa468af37acd5c9eed697dbea3e4d35f230c96c6f0961214e44" + "blockHash": "0x0ca41041aeed31cf7dbf302aad1a13f021cff17dc3b30ab3ab8fb5c109bf9965", + "transactions": [], + "withdrawals": [ + { + "index": "0x21", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -12032,21 +12087,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x37c51aeb36996d1204e1cc23f24fc8ce6a531230eac5fd95a0157afbae993408", + "parentHash": "0x0ca41041aeed31cf7dbf302aad1a13f021cff17dc3b30ab3ab8fb5c109bf9965", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5dd19ed57b4f4d3f2fae68e07911c6940af44fb058c9a9454775e87433315e18", - "receiptsRoot": "0xaaf879f16bc945f981764629a68f186ca15a1cc726a6e0994ef7227794ef638a", - "logsBloom": "0x00000000000100000000000000000000100000000000000002000000000000000000000000000012000000000000002000000000010000000000000000004000000000004000008000000000100000000001000000000000000000000000000010000000000000000000000000000000000000000000000000000000080000000000000000000000000000080000000000000000000000000020000000000000000008000100000800000000000000000008080000000000000000000000000000100010000000040000000000000002009008000000000800200000000010000000000000000080000000000000000000000000000000000000000004000000", + "stateRoot": "0x189c87301bd9530fbf7526346c89f2acf21a4a1dd57cc6a4aa4ca21a6cf3261e", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xee2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfb7823c99d6a8cecf4576cccad394131869c27c19903241a4bac149e8a9df5cb", + "blockHash": "0xf2198f4eac45134910f2f5c2f4f4bba2ee608c19e01728288f8f5c583df9b618", "transactions": [ - "0xf87a82015c0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0bca3972d67f3e443b15ef0b1f58d20971b740224462b717cb8a13fcee5381836a004c0d9a49c69b979caa2a1a507fdae8b61d34eb76652ceed6327bf4d4e75f02c" + "0xf883820193088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0fe7d9978bcd2d0147d75b3322de5df21f02a0869bfe5fe96c29dc4670b74fcc1a00110a8737cac1a06b33aa2c4c8d09a5308175223c16758e35b70f380337b6f96" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12063,21 +12118,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfb7823c99d6a8cecf4576cccad394131869c27c19903241a4bac149e8a9df5cb", + "parentHash": "0xf2198f4eac45134910f2f5c2f4f4bba2ee608c19e01728288f8f5c583df9b618", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x434fd480c866cda1d71f0ee80014364d4c42243823bf64409c1776409b4e7062", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x545c993f4299dee364d8f2be4bc7761850c795b03df742693fd8e3ce2147ed82", + "receiptsRoot": "0x53e8b715d86b96a08a43b3f516f075e85d4776c7512a2c0a25b78194be60f9fc", + "logsBloom": "0x00000000000000000000000300000000000000000000000200000000000400000000000000000000810000001000100000000001000102100000000000000000000000000000000000000000020000000000000002000000100000080400000000000000000000000000400040000000000000000000000000000200000040000000000000000000000000010000000000000000080000000000000008000200000000000000000000000000000000000000000000000000000000000000000100000800000220000004000002020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xeec", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb43189b040f33d48780cb23517066fa7ef9be143f72926c776dd2a0deb74cdd8", + "blockHash": "0x9ed60ccc2815f143b3776e728718019b7820044b0e8f1048fada365fefb130d4", "transactions": [ - "0xf86582015d088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0ebb83ef8d58970c8d0b8eef25ef497d0a50401368a20f8f8a7d0ba061cbe2d73a042360047a3fc34863766c17a2c7bbc10355084608fbf1041530d1a14e4c01288" + "0xf87a8201940883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa09064ce9eae2e88497aa4825b33c5780a72d7f7d495ca9a8d18fa2185e2f22edca049b610ab7217c5e910519dcbc21477ed15b9be01b566bbd18aafc049d63c047c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12094,21 +12149,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb43189b040f33d48780cb23517066fa7ef9be143f72926c776dd2a0deb74cdd8", + "parentHash": "0x9ed60ccc2815f143b3776e728718019b7820044b0e8f1048fada365fefb130d4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x463aef358cdff7e34839a185fb9f55a731b3494c97d0862eac151900b40fcf0c", - "receiptsRoot": "0xa34aba31a61b5b0f8a666d471417fe5a2b7b346b8cf7596cb7b91e574cdf33db", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000008200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xbb9320ec53937dd8a33deff1261bcf4c66c5dc794cc8e60bc6d3c1f20918bc19", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x17f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xef6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x36d98a00fa9cb5f2d23adaac16766bf86c534154016d362227b77a09e466ed03", + "blockHash": "0x9062dff550aa9077f3623061b2bfd2bd8d2c86e29909967d614bd4944d9775b4", "transactions": [ - "0x02f8d4870c72dd9d5e883e82015e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c9ccc0eb18b01c799656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0187c8bbc8cd3f478b5688bc03cf5eda82ee75aa605e946b39ed1898f0cc0e00f01a0fe9e522796cce1e5edeee1b4d839489efdf2a88716a677225586730033a452f8a042412e98bc67d6fece4f9e6e0295b8a7db6a654e3d3aa45189d7df51fefa9e8c" + "0xf865820195088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a08de2c7c835ae8f6ccd20e20df057097cb6e8fe56599af11c8489579e84eba2cca002241c5d8c31bb3275de49cc635e8f80655e2cdc5d2ef90467af6c0714ef5957" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12125,21 +12180,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x36d98a00fa9cb5f2d23adaac16766bf86c534154016d362227b77a09e466ed03", + "parentHash": "0x9062dff550aa9077f3623061b2bfd2bd8d2c86e29909967d614bd4944d9775b4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeed54f9703bb531d2c17ad91c352a358544c949059e43a638688ebb06e5af764", - "receiptsRoot": "0x546613d89c675ca166e3b86c77b03920935c041b3652da17dd6f6cc04aff6678", + "stateRoot": "0xe2887614ef7dfd46b2eb60757d520eb36e14df3de8eec61992c4ed45ce64cdd5", + "receiptsRoot": "0x2bb262e1c2de3c524cea3467cc4102a62ffbb6e5dd8e4d3e5e01b5245a226e79", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000001000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000020000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x180", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xf00", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x864f50b8a89fc8049af6830206eeacfa26205d9ac2f1e9ef297c024532a57be4", + "blockHash": "0xd157f96d8cff964d61e492c245aa25b09c561e5c6336ed5452387454dd2936a1", "transactions": [ - "0x01f8d3870c72dd9d5e883e82015f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c036eab5d1496600f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0afc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a80a03228bf3e8e8afcf77dddab3e3c888665915421562e1ba75483734c20b3bccbd3a035e97ae4c4084f99cdc32d4971ccecc9da56b456a4290721283fa44c5d6dc8e9" + "0x02f8d4870c72dd9d5e883e8201960108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c036eab5d1496600f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0afc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a01a0898501fdb06f8326c17c49fbd51da51df4310e5fad6c7c800c2b8726e182ad36a064853e8169e7953b610056f9db4b7f7a095e1277984c1438f143c586fdfc6016" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12156,29 +12211,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x864f50b8a89fc8049af6830206eeacfa26205d9ac2f1e9ef297c024532a57be4", + "parentHash": "0xd157f96d8cff964d61e492c245aa25b09c561e5c6336ed5452387454dd2936a1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc0b2c99de9c2cab2946d5074ed9201e9579af45846fb1d9e1c07487de30a9779", - "receiptsRoot": "0x4aecc944f33d425d167e974a14892ffee063fd9697823a42a2e0037e5a2c1d8d", + "stateRoot": "0xa2c306a43172bcba3f96e70bf46f2c55b2189dfd9f6b2c0f8a747b6367697d73", + "receiptsRoot": "0x16cedaf9e08250d2f20ee5725d06428ee114670fba949a51f5357b4e01fccda1", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000009000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x181", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xf0a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa68dad1f5a2ca3fec7174293fb1eafeed1b3e1209dfc74ba1d4f67272530d1b9", + "blockHash": "0xb8edb732bc8eebb71c6b57b77061ba1acf052b420d919e5da1720abb3c7edb21", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201600108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ccb602560a8ca054b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a014ab990b716fd8be13e9a2439dd38ab3469f2ba1e9e5355031f7d57cc16fe28aa01fcc7a8080064238333c605ad57b373665d3ea857b58dcc4493ab055be5667ff" + "0x01f8d3870c72dd9d5e883e82019708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccb602560a8ca054b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a01a05060bffe7a652e40c953fb35b1e32ee82b3dbd200487895b6095d5c13b643adba077ebf6ec2af6f21adb5a0a42b2cbae112b29bcfbe2fffc372f2aa66fcf35cef8" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x867a7ab4c504e836dd175bd6a00e8489f36edaeda95db9ce4acbf9fb8df28926", [] ] @@ -12189,27 +12242,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa68dad1f5a2ca3fec7174293fb1eafeed1b3e1209dfc74ba1d4f67272530d1b9", + "parentHash": "0xb8edb732bc8eebb71c6b57b77061ba1acf052b420d919e5da1720abb3c7edb21", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbc6c97a060f00ab1be806a461d8e04d012651014ea6100c41753e932b3c43ec5", - "receiptsRoot": "0x4331ea2666467e36433120994481707bce23469d4639f5cb85785f8fc1daebfc", + "stateRoot": "0xb7d507270112bc4faab433198f6bd8ed283d9dfce7c48f022dbe35b2eb1e878b", + "receiptsRoot": "0x4748a7a6d1cc5092adc5b85c9c5b670600b531b5a1f8450d3b47d6cc3a789ae3", "logsBloom": "0x08000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000040000000200400000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x182", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xf14", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb5d6be7351994263965ff5d6bec155497dfae4101d9fa6f7474f4346432cc94f", + "blockHash": "0x15266d7b9ec958793882168c6ecb5b92093f733c0e47fa9f9885dec39977e5e0", "transactions": [ - "0xf87482016108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7ea611ad5cf07d1b656d69748718e5bb3abd10a0a0873a6822a956861366590a1156d256b1bbb07e02e15f6da3b166522ae0d2f50c9ff1915186b50164055d6b6e3a9b46df65ead3ed7889c2696bf87c0b89e2924b" + "0x03f8fa870c72dd9d5e883e8201980108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c7ea611ad5cf07d1b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a04b85d3d5e4e06787a4e7e6d00f4e2f6d7e0358d9e511177ab584553d4ca0603883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0144a8ecfd93531def162b68dfaa7a049752c47ab7057ca9a403e193c15261054a04ad33f9300255a732f62f35103bb245fe6afe7d0fa04495d2cc33c5f8906b239" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x0d01993fd605f101c950c68b4cc2b8096ef7d0009395dec6129f86f195eb2217", [] ] @@ -12220,21 +12275,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb5d6be7351994263965ff5d6bec155497dfae4101d9fa6f7474f4346432cc94f", + "parentHash": "0x15266d7b9ec958793882168c6ecb5b92093f733c0e47fa9f9885dec39977e5e0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8203857ab0f4351d2fc345161fed67871eacce08f4c0590074372d0ffa2ef01b", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x43a00b1aa4db0f080095e7930a6065ce834fcb8c29c2f072f2ccbc4d85cd452a", + "receiptsRoot": "0x2d99a1b319bf0d04c62af6aaf8f18092048165fcee3802270419d4acdc954cac", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x183", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xf1e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x435041bdf7d03562f6cc28be67dd48e2a55cb6c36a8bde74217c78962fe35c04", + "blockHash": "0x96ad738816a0c5035be9c01fbbed53998bc70a21a08bd0fa2427288c9d4b4cfa", "transactions": [ - "0x02f86b870c72dd9d5e883e82016201088252089483c7e323d189f18725ac510004fdc2941f8c4a780180c001a02e258ae70f2eedc9eea027f8bb64f75b3f28c6c08d3c634d9f2bf63472a836bca01bda3a325bafa449bf2e7dc725b096b5fae087bb633c2fb250dd5b77122ca795" + "0xf87582019908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c70bbcbdfb5c84e35656d69748718e5bb3abd10a0a08cb38dfecd5d15969ea5bd2db95c50bcddf8cb5d48a5431037c46511722c4cffa03022edf33caada42b8a0f6d0c07bbd36c13a812c3bca92c6e90262aa7a702152" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12251,21 +12306,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x435041bdf7d03562f6cc28be67dd48e2a55cb6c36a8bde74217c78962fe35c04", + "parentHash": "0x96ad738816a0c5035be9c01fbbed53998bc70a21a08bd0fa2427288c9d4b4cfa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x34e957b7fe8989ad1a1348053a6fcf0f60eb9831d3e0411557da90f20290b592", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xd9d011d38278604ddae7d5e49d640e29f0b5128ba4e3ce8ecdafa9cdb5553cf6", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x184", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xf28", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x74659e9bea0d8d39ee2966f14026731c00cfeac2addae8ab7440f3897752035a", + "blockHash": "0xd78dcce2b8cf4bd8d77c2e3212a31f5e1eb0c62184d07d2c0bd0dcfaf9258e67", "transactions": [ - "0x01f86a870c72dd9d5e883e82016308825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a06c29f5b2e14545a26d4c4fabd5be664ade5046e75bf947df58319e704cd15e83a0411cfb33b24f61406444f3b60bd7269aba228f69fb30073879e54c1d5a61f7a0" + "0x02f86b870c72dd9d5e883e82019a0108825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a058796c88204f4a019fa411ee0fb065d3499c48ecd98ef4b5ff4c8f12d9936140a008d74723a6429931c2bda0c48d75cc1de3e4fe79e15dc74a9f8e81798932edba" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12282,21 +12337,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x74659e9bea0d8d39ee2966f14026731c00cfeac2addae8ab7440f3897752035a", + "parentHash": "0xd78dcce2b8cf4bd8d77c2e3212a31f5e1eb0c62184d07d2c0bd0dcfaf9258e67", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xea3a8543a0d754626f48f9e2bccafddf6b5391ed9da5a8e802d9aeff39ba3500", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x8c1f0cb437c8070e56df88cdbe91555b33d59248b13433075cd22430ad834811", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x185", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xf32", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8166e02057fbd66e2bdfdeb5e1b7348030fb8dcdf336c608186ecdf95a878d73", + "blockHash": "0x53b455b1a2321612d4750d1cb5f2154662340f0596d839583ad50db5d90c42f9", "transactions": [ - "0xf8688201640882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd10a0a0d892ded71ca2da8583433304c4936503f7c77abf5f5192edcc2f71445614fa3ba0578cb9c3c920c69eddae921e7c6d67ff6f7cde3c4b1f45f48724be79fe9a13b9" + "0x01f86a870c72dd9d5e883e82019b0882520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c001a09d5b18b761d63d1a9df732a8936576c71c3ce118a856e5dcc45bbd3ebc334545a0080b412935374e02b9713851a796e0afdc96f6eb0709c83884ed51d0a65691ec" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12313,28 +12368,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8166e02057fbd66e2bdfdeb5e1b7348030fb8dcdf336c608186ecdf95a878d73", + "parentHash": "0x53b455b1a2321612d4750d1cb5f2154662340f0596d839583ad50db5d90c42f9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2f9f3ce5b39159a1a49122bf41140eaee9ec2bb1a396e59fb7fb2520dd512096", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x858cecf2b89032ee42d75787514ce9f12e640d24168d3787531a4844dc3328c2", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x186", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xf3c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x686342d6e14add1de361c209a4f097174472120c2649d4b1e3c0d69478c573a5", - "transactions": [], - "withdrawals": [ - { - "index": "0x22", - "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", - "amount": "0x64" - } + "blockHash": "0xe665360c7c8888bfa138a986f8ff7f890a44b9e8f80b7e736f5f43a7c8bc5349", + "transactions": [ + "0xf86882019c08825208942d389075be5be9f2246ad654ce152cf05990b20901808718e5bb3abd10a0a0e7eed0cb4b06500b37b924d33a203b5defa189b4c3d6d3fb4b8a15d547bb773ca05a505687b0397d49822226429f7d7d751b0e22e5cfbb1ba857fd6cf08fd1fdc8" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -12349,23 +12399,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x686342d6e14add1de361c209a4f097174472120c2649d4b1e3c0d69478c573a5", + "parentHash": "0xe665360c7c8888bfa138a986f8ff7f890a44b9e8f80b7e736f5f43a7c8bc5349", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa913a36ebb2c7286813fd5544542ba932c75ceebd10efa36b772066d1336b019", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xdef174abca6e69793809763b1d37b188934297769a4536a98c35f27da9cc7e0c", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x187", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xf46", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x69ee2c164e201f10e82103b762fa299a98efcd3efb531d7f684cc93fe20877bc", - "transactions": [ - "0xf883820165088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a08f095627d823ccfe8ac3f93f8d6ce42a33865c729ec95941f9b1428590e1b922a01241e87129a475efd61aae53033db7e37576260983c403c1c3663a4e0cfce194" + "blockHash": "0xe5efcbb043c2a94c768287dceb47dd6b9cb7a7cfa2d9af29222678ed900368c8", + "transactions": [], + "withdrawals": [ + { + "index": "0x22", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -12380,21 +12435,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x69ee2c164e201f10e82103b762fa299a98efcd3efb531d7f684cc93fe20877bc", + "parentHash": "0xe5efcbb043c2a94c768287dceb47dd6b9cb7a7cfa2d9af29222678ed900368c8", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x30136876a22c79da7c69981a1022b210879614e2cc999acd90f349bb81ed7876", - "receiptsRoot": "0x9dd67ebc56712a7467d9464a0af506a7e731935e3dfe70c7d0bfefbc10cc316d", - "logsBloom": "0x00000000000000000000000000000001000000000000000000000080000000000400000404000000000080000000000000000000000000000000000004000000000800000020000000000400002000001000000000080000000000000000000200000004000000000000000000050020000000000000010000000000000000000000000000000000000000000000000000200000001000000000000004000000000000000020000000000000000000000001000000000000000000000800000000000000000000000000000100000000000000000020000000040000000000800100000000000002000200000000000000000000000000000000000000004000", + "stateRoot": "0xba682cb45dc6229bdf92ac214a08cf011d628144f6c88f59065c0769a7527b91", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x188", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xf50", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x977c2a14bc576911c691938eb8badf6a77843c4214b0613133fa356a23aa7f92", + "blockHash": "0x21f6741c735a5806078a1f39d17733b135210be8033a80be4fefc59d42c45bc7", "transactions": [ - "0xf87a8201660883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a006e6eb4624ffee7629bad221ef5a8e8cf28e9acd1488f2762f76c254fbd5a5fea03eade6b173f9e255a9280f2e9c948a01fa5f67cbb75fa4107f30bfa818c1ee3b" + "0xf88382019d088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa030067aafa083ba90ed5ac98c474bd13b26f75a5183b1057cf1b3e136b27c6a8aa07cccc9bd109d2b8ed64e6992f93b62781e31b3a4987c08d299562237a932f3ef" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12411,21 +12466,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x977c2a14bc576911c691938eb8badf6a77843c4214b0613133fa356a23aa7f92", + "parentHash": "0x21f6741c735a5806078a1f39d17733b135210be8033a80be4fefc59d42c45bc7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd655197085c144158f70b071963f65898ac8b024e09f768aa23debb200627769", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x29532a6b078691fb21bfd376abeed8257e221095f8b8c605e5c83882d4c7f7b1", + "receiptsRoot": "0x408b424cfe8e4a58b00e7e016fefdee6397c334eb769ab72684a4cda56dc1e80", + "logsBloom": "0x00001000800000000000400040000000000010002000000000004000000000000000000000000000000000000000000000000000000000040000000020000000000000000000000000000000000000800000000200000000000000000000000221000000010000000000000000000000000000000000000000002000000000020000000008000002000000000000000000000000000000000000000000000100000000000000001000000000000020000000000000000000000000000000000000000000000000000020000000000000000001000000000000000200000000000000000000004000000000000000000004000080000000020000001000a00008", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x189", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xf5a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd9a295a0e39c94e3e9c9305b2e410aa89ee5380a8c343b901fc2ce60a19a431c", + "blockHash": "0xd158907e25d23731ef6dce6a9d1614ba8b69f1080f78acecf9c403a853b3e7e1", "transactions": [ - "0xf865820167088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0d3dddbfaf3f7d67794a1af773a81224a033a1c309ed8d1256b0fdf41afa302f4a057c135428d584fec4526536760d0d6801243a495811b0ff25dcc9441fb5320c3" + "0xf87a82019e0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa06f959e2a059ecc0164e6c5c3f07a6ad7a53406b6c9baaae29c3a1edd2fd5664fa039353c67eed349b29feb34980aa3de22607a382bbe3bb1114c347ed65a0087ce" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12442,21 +12497,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd9a295a0e39c94e3e9c9305b2e410aa89ee5380a8c343b901fc2ce60a19a431c", + "parentHash": "0xd158907e25d23731ef6dce6a9d1614ba8b69f1080f78acecf9c403a853b3e7e1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe945c1dd5800f2dc2c10b812401b1d619f1052672ca44029c41780adff44296a", - "receiptsRoot": "0x6c5b098fbf232d565604bd4d7e82242720e0fa2629ef35404a6d74d66237c0db", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000800000000000000000000004000000000000200000000000000000000000000002000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xce1f293e6e98a03a0418ac1c56114779aac94fc03eff0b0ecbbf97610ef698db", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xf64", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf2d8812d4f28578755d4229aef19bd2162c69cd9dbc684dd6a0b0b64c979bd73", + "blockHash": "0x6fab05257a0a012b2d7ae03c844ddece0883c3c319ac1396c86f6f0e136d034b", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201680108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3ce71abfd2a9f6e3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a01bf8eef1506aea16c94dd534ab271dfdae26648de569b3bf6fc8bf4c76bd1a9980a08a54ccd165615a3f6c5c494e2844295ccf525857205a2f86c053030f24d74587a040be30b7aeb05f7cc03b3d2ee39a6cb0c401083a305e93735e93eea1c3ed827b" + "0xf86582019f088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0e3e15349981a88905d5af6ec3b7e5af4805bfb673fb2e4d6fa577d357cd5cf05a05268e935e21321793bbd1a8bbd62b66a633009d365cfe6869eb2d79951367e9c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12473,21 +12528,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf2d8812d4f28578755d4229aef19bd2162c69cd9dbc684dd6a0b0b64c979bd73", + "parentHash": "0x6fab05257a0a012b2d7ae03c844ddece0883c3c319ac1396c86f6f0e136d034b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5fc89e717b8110ffa180abbbf968a6e6a0fa0474f7b1384dbed83d5095b5351a", - "receiptsRoot": "0x125f11b4c9f735f497b05529580226e6e3e005be03a1957777846217f5357f0a", + "stateRoot": "0xf561f28bb33b4623bc346f51cffbbae8ae28693c726809cf8d9fc73c1f318501", + "receiptsRoot": "0x19c705ba74035fab2b2c8330c0d306854a4c35fd804490bd12c26795086413a6", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000800000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000109000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xf6e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc64105453f3f4a50ea7452760ca6066140fc6f2115e16065c397778756460d79", + "blockHash": "0x7c1553d1737048182d4b9d286bce8cfebcf1db592863dcdb04597d033557214e", "transactions": [ - "0x01f8d3870c72dd9d5e883e82016908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c885c8e7048f4f360656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a01f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e4580a02ac6dde1e6dff9ec4155a56114ddd824ef545648c7d523b4b1ece0b781cdcb89a06007350fcd96693d0dedbeea776518761a47dc51a714f55c031b20d443c3cee1" + "0x02f8d4870c72dd9d5e883e8201a00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c885c8e7048f4f360656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a01f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e4501a096bc82b0394d53979f9ae1ebef4aa75f643d05c6228a48d5b1467dd903724a6ba05ed6416fb1a0a40a782fda54a4b1f2bd007238047a9006bab629e3cd8310c068" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12504,29 +12559,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc64105453f3f4a50ea7452760ca6066140fc6f2115e16065c397778756460d79", + "parentHash": "0x7c1553d1737048182d4b9d286bce8cfebcf1db592863dcdb04597d033557214e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6d3bb9ac8c90193e805743b2009e22877fcf38cef9e0fa3ad42b672c596a7785", - "receiptsRoot": "0x56aa14a0b1fc6db4ec5f0332dfefcd53238b912e98e4f8171f6ba5ebb1670f40", + "stateRoot": "0xc1d1402980206ba41ffc92e430b8e35fdc94736a6f5b07e310e7bf2ae2d330db", + "receiptsRoot": "0xf07cb300dfd0f69edcb7adc7b068aa9a82bb4546861e357f19be0583910716ba", "logsBloom": "0x00000000000000000000000000000000000000800000000000000000800000000000000000000000000000000000000000000000000000000000400000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xf78", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xff05bd7ed3a3f4e5abc2e5232c98d4343072bfd25121b241932703d33f875c0f", + "blockHash": "0xb9a2df3ba23cf8289d6075dcaecd47b52b9fb750dee39aa9a93b6477e99b348c", "transactions": [ - "0x03f8fa870c72dd9d5e883e82016a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cb3bbc461cd7b04b9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a092da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a10883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a022c5c0771555973c9e1e3f6bc48bff07002eb74100e495b653e17e4681fce80aa0521757e341c26b96807d5659162b9a96382937584bafa07e43b5d3ac095da704" + "0x01f8d3870c72dd9d5e883e8201a108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cb3bbc461cd7b04b9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a092da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a10801a04e402365b760304dd7885b33e0cad13b6c8de41105f23e8706aaa2e986d81610a02b0842a437c416ef9f7d3184d3ed41a83fbdb1e43de6c7902ce7d7321c4ab71a" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xe2f1e4557ed105cf3bd8bc51ebaa4446f554dcb38c005619bd9f203f4494f5dd", [] ] @@ -12537,27 +12590,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xff05bd7ed3a3f4e5abc2e5232c98d4343072bfd25121b241932703d33f875c0f", + "parentHash": "0xb9a2df3ba23cf8289d6075dcaecd47b52b9fb750dee39aa9a93b6477e99b348c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3fc40ef76d78e19fac56084394db689edd279c048d0f449c09c39c04e5689494", - "receiptsRoot": "0x66b64724e3272f2ec6ef9d0c3f85a510900120dbfe843f1cda530557fd6c93cc", + "stateRoot": "0x8b2014cc1ba5d9b7be83ed0ec428dfe1df8c8b617bab285b61c5cdf11a2fd406", + "receiptsRoot": "0x0be5e2fc34752a3c00710ad282caf7be3018221bc0333964932a60404bca82c5", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000010000000000000000000000000000000000000000000000000000000001000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xf82", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2fa9e1447264c03da65b930986c6c67078d887aa0b6252b49026c3bbc522ca59", + "blockHash": "0x8db428484b88609d95276b97bfc852bbad22b06dd7f40ac765e4e3333720ea83", "transactions": [ - "0xf87582016b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c96c2e214be2bd0a2656d69748718e5bb3abd10a0a0eefa13b194da056212daca7c04fa697d680a2a7cf45a7eda53dfda0aa02692e1a06d27f41d4cb9322c0bde9008870c771aaeadd7a0dd25a0f965e07877d28854d7" + "0x03f8fa870c72dd9d5e883e8201a20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c96c2e214be2bd0a2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00c8e91bcf03d65aedba99f4f76d3ff8cd007668948ce12daf4dded4761c7b19d83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0d0af7bb08c69b25a8eef5629377b5ddcf45799c33c8b1fb564edee75b88dfef8a028f3e326278765d228f6354d7ad10b1ee3fd5926cb3d5b3a8e140b4fef5b5c35" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x48ef06d84d5ad34fe56ce62e095a34ea4a903bf597a8640868706af7b4de7288", [] ] @@ -12568,21 +12623,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2fa9e1447264c03da65b930986c6c67078d887aa0b6252b49026c3bbc522ca59", + "parentHash": "0x8db428484b88609d95276b97bfc852bbad22b06dd7f40ac765e4e3333720ea83", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x90bbc672313c5767ed1c21447ae06c6ebc9a1379a8d3bada37250d468cf4b6fd", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc7d3270843fb0721e863b71bf2e9569178c4c1772df6ffb9830dcccb98ec52a9", + "receiptsRoot": "0xc0fd8226f5464b77c8ed07cc668d831a475c36e763de8a60694e0167d21c1daa", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000202000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xf8c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x10c9eb1115f231e7a50650aa52acc568532a80c7c1e0d695517fe4da1d493a8e", + "blockHash": "0xd52069ed6df2e1d2f640f30f418cfdf95501b1c6085ac06093c891607b0032c3", "transactions": [ - "0x02f86b870c72dd9d5e883e82016c01088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a096c29ad0d1f2947c8efd66353a3f3f2b4921d9bf5c58d0e4670348e29bf1b89da061bbc93071262fa15425909be708bf2c21d06886344e338e9e04dd196d7ba310" + "0xf8758201a308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4f4dd67aabaad6c3656d69748718e5bb3abd10a0a081b8e4c24820f2e8ea5fd2d4fc084667750f08875faa805fcc4e83a4f487341ca0024d08d37c00b11e2e3f6e3d23f2a466c331f91d8bcc8afae4c4b803263e9c97" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12599,21 +12654,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x10c9eb1115f231e7a50650aa52acc568532a80c7c1e0d695517fe4da1d493a8e", + "parentHash": "0xd52069ed6df2e1d2f640f30f418cfdf95501b1c6085ac06093c891607b0032c3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8db3010d08c4adcf5d271beb8e207ce75e9830c859070fdfc4dc4f30d6805c83", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xec34f503baa8a3bf9d5b965aa73eaf7f1c59e6f77f140485375ee0838d1837a8", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x18f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xf96", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5abe00a7721db9dc1fbf458d49714c666ca2424e476099adfb77fd8dd54a0eab", + "blockHash": "0x7a253f0e42ca478ad6c4ae1e4892cbddb34294950e425582a85ae2da34f8a8c2", "transactions": [ - "0x01f86a870c72dd9d5e883e82016d0882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c080a05451364a93364dc251918bf5d8f7cfffdf33b58bd3d48c3f333eab4daec6658ca0156953f7d30f24273a44d6a2f15e1520afcdcbbf7aedbd72f3c395d74cde0e92" + "0x02f86b870c72dd9d5e883e8201a4010882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c001a09728fb333f0202298944f0eba61beb26ec81f57db95bcc9d7b9693432fce75f5a0183787fafb6563e8cd2f9850179759dd5b2d72aa986d21af6543b16e638a7c21" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12630,21 +12685,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5abe00a7721db9dc1fbf458d49714c666ca2424e476099adfb77fd8dd54a0eab", + "parentHash": "0x7a253f0e42ca478ad6c4ae1e4892cbddb34294950e425582a85ae2da34f8a8c2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xcc7f1ba89ea6d4c2a5fbfcc4b42ef1609d9d10fcbad86d34eade03f4d447e7e8", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x7a93c947d5396808acb6505c825ee8766d47620a3fb91bcd2e890a602199901f", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x190", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0xfa0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xade4149b0375ad07777a88bf87a50426806e7e69c98719e63763ebf8585d39be", + "blockHash": "0x4e526a541914f396684974eafbce8e6b898a3330278c3e7626816d435a2ef4d0", "transactions": [ - "0xf86882016e08825208944dde844b71bcdf95512fb4dc94e84fb67b512ed801808718e5bb3abd10a0a030fd8987e8637c05b888e039311b4ce539062b9bb74e95bee4c1230a15316660a03b5edc40f556993df62f7210fa58a970b14bd8d4473a0df7590026589e83ea75" + "0x01f86a870c72dd9d5e883e8201a508825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c001a090a30db198c78f870c93648d4e02917e60d6aa6c9a1ae6af1ad01d8d48391ce6a07313f35931f53dd4edfbb01130a31f51813a1906ad845061ef41baaf5fb42a62" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12661,28 +12716,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xade4149b0375ad07777a88bf87a50426806e7e69c98719e63763ebf8585d39be", + "parentHash": "0x4e526a541914f396684974eafbce8e6b898a3330278c3e7626816d435a2ef4d0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc2a2590076144444ddd91da89477bb827ca9153ac0d75676422ec75ff69577ff", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xbd3526bec68fc236a888c5edb23f1c7885fa46e2deb25fb667f03288fe7cf5f0", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x191", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0xfaa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x90544280b5a1c89044d0a9acf28015355e9f87f99cebb6e423a2429593805c3b", - "transactions": [], - "withdrawals": [ - { - "index": "0x23", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } + "blockHash": "0x03dc453bfc92a17cf81454eafdde515558d116047e9d2deb26e4d653df5960cb", + "transactions": [ + "0xf8688201a608825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd109fa0cef73dc4066b0c8a15b87503df3ac6e7b114ed7a6360bca4c469f3c7a1cdeb46a06912fc6d6eab8e3ab4aad5a6082f82d0cd129071c059db8fba5a911cc4dfe664" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -12697,23 +12747,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x90544280b5a1c89044d0a9acf28015355e9f87f99cebb6e423a2429593805c3b", + "parentHash": "0x03dc453bfc92a17cf81454eafdde515558d116047e9d2deb26e4d653df5960cb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x816daf4319bb2e73679d9c72bc1197acfea24dcced35aacf7b959958b14b5748", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x80d8942ec16df8ea30502c625b3a4f5bf3c7a5c7a35ccf4de6869b534d2fdd30", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x192", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0xfb4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcbaec457a9bb83f627a46b321256873866c0a5c079315e1294328fc71b7d8529", - "transactions": [ - "0xf88382016f088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a05bb36f34fe06f126bd1110d297313d58ae78718e9e0fb3ff6e18afdfa56f3818a075ea98ed3729a3ece6704da4d80d5b13225ad6ebc6acfb834c2a8a669a991836" + "blockHash": "0x7c28f6c5bd3f408616c4374f509a34b30c118bf5d1573a2093630f20e43f2117", + "transactions": [], + "withdrawals": [ + { + "index": "0x23", + "validatorIndex": "0x5", + "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -12728,21 +12783,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcbaec457a9bb83f627a46b321256873866c0a5c079315e1294328fc71b7d8529", + "parentHash": "0x7c28f6c5bd3f408616c4374f509a34b30c118bf5d1573a2093630f20e43f2117", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb95406b5c576820d6fd109e71b527d4f9bb1dbb458ed2a4a6d90f8a6cb25b384", - "receiptsRoot": "0x4cd138fe4eb3a09100a9486093e73b7f05b48c286e7571fac1da38fa9c1e237b", - "logsBloom": "0x08000000000000004010000000000010002000000000000000000000040000000000000000000000001000000000020000000000000000000000000000000400010000000000000000000000000000000000000000000000000000000000000020000000000008100000040000000000000014000000020000000000000001000008000000000000000000000000000100000000001000000000000000000000000000020000000000000000000000000000000000000000020000000000800000000000080000000000000000000000000000000000000080000000000000001020000200800002000000000000000040000000000000000000000400000000", + "stateRoot": "0xe70190f6ed009bd81015684f2421d43c0c0695ccc602351a921a3ea92c1cb3fd", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x193", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0xfbe", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x888127ccf7a04b3ab6dc54a687036e7464c30e3fd813a0f4ddc69094cf250b90", + "blockHash": "0x930fac8adfdbe31343d02ff687fcb52da1c6e61bca71f0f4a0dac8bbdbe9f243", "transactions": [ - "0xf87a8201700883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0c8616a2b954cfb2f2707c4a8fc6b8cc75c9fb1cd061be837d795c2174b773f77a04da08801f22e504206cac7fc792e4c0a65fb0ea8ca981381b419d3db08cc4b32" + "0xf8838201a7088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa03ca2ba685ec1759bc7560c52f9418727274e73d6d59cb61191058cc2dd519565a017c62d2d43eed87d417edf9d377102a2e0b71fe7e552f3427e7e9a16fe1378a6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12759,21 +12814,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x888127ccf7a04b3ab6dc54a687036e7464c30e3fd813a0f4ddc69094cf250b90", + "parentHash": "0x930fac8adfdbe31343d02ff687fcb52da1c6e61bca71f0f4a0dac8bbdbe9f243", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6283fe7582b09ba2f3c59f797b270ac18c7ed091340aee4f4e8b2074b1b5d4d6", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xe06824207c5c1eb5931283fa74777883a8be1eb6e99ef1bc27a3c5088a84d328", + "receiptsRoot": "0x81566a1b74d5ec58900e780cbef9b6e773a0846e3666a2418de8c08a89afd8a0", + "logsBloom": "0x000000000000008000000000002102000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000400000000000000000000000000040000000000000000000200000000000000000000000001000000100000000000000010000000000000000000080000000000000000002000000900400000000000000000000000000000000000000000000000c0000000040020082000000000000000101000000000000048000000000000008010000000004000000000010000100000000000000000020000000000000000000000000000000000000000000400000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x194", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0xfc8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x08d7f2f015c06dee88d707cbc050021fd38afd6a253d3382a783e92ab30f22c8", + "blockHash": "0x899574f6e851f799bb169b1b2ff31f51b11d500716847b660fbb717340b90f14", "transactions": [ - "0xf865820171088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0eeee915b6dcd97f488b2e0862ddf49be8f02b71ce27a970aa3d150a2b73c3d76a0151ede7670a2f2958cd967258efea3bebb7c9da0e7adadc47e07701477782f70" + "0xf87a8201a80883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0f8134902b3f0afcf54b9d803218c26ee97f023a427dfc515f7d872d4ee39c0dca03f44b5313aa79c53ad01f6f331fa50aee26a6386265921b7cfa24f18b876225d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12790,21 +12845,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x08d7f2f015c06dee88d707cbc050021fd38afd6a253d3382a783e92ab30f22c8", + "parentHash": "0x899574f6e851f799bb169b1b2ff31f51b11d500716847b660fbb717340b90f14", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x14d9fb7608ad2f76c0b79ea38c91e2f01743e40d5ce71a906ed89f44ce2d9a12", - "receiptsRoot": "0x83e14211439ab2e9769078e7d4bacb6da4763d09cfcd4fdda6b28526fa7e792d", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000010000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x4f1078dbf2c9687a55b2d2567e284374928604f4ce0032a3c665953f019ea6a9", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x195", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca90", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0xfd2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x729c0e22346bb677499d2b9af1da34dfaf7653ace58567673fc6894cf8d56289", + "blockHash": "0x7310d47dc31a6bc3bcb6dbf90735258a092efc6fc83100937e73835ee2d70531", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201720108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c07dd9b08a900173f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0434e2bcc5f4148668dd618144aac33ef5d463b292b3baad302a60aeb6be03b8601a087509826265d785d522c46423fbe09005b3a67c94c3c16add305eb7f8119ee71a02b871f33bb0bd2bbf2fdd46a0959e221ee03f0670343b9c4e8f6648cf9193d6c" + "0xf8658201a9088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa08207de7d895b35b441bd31c016e50ec023f27817975912b467b01a883e8dee8ca0120b129c7aaaf566631c317698caf548d5a0bf20a6e8332f541795868287c3bc" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12821,21 +12876,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x729c0e22346bb677499d2b9af1da34dfaf7653ace58567673fc6894cf8d56289", + "parentHash": "0x7310d47dc31a6bc3bcb6dbf90735258a092efc6fc83100937e73835ee2d70531", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x203063aa2a6c46cf7d25340d80f0ddb56a22eadc507641d8af3809cbd8cf9937", - "receiptsRoot": "0xda00a4cb704a559e0a67e72cc49701afc18109c598434e05644724ad3f65dbac", + "stateRoot": "0x11f4034edad0b613feef6d1e991d8ba4b3364a611236fd8ee052b20b0cd37ae2", + "receiptsRoot": "0xf444c39e621724e2fceb53f84e89737a22b3af6b612abaedd4ab25b5ee65e683", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000200000000000000000000000000000000000000100000000000000000000000000000004000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x196", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xfdc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd60f9025487642346d1ff6fcb21558a0b719524dda4fb773e50254be6ea5cb70", + "blockHash": "0x9096409d42e5525d369ed6637798f87763c39cded3d9b86b9428c86c93b61b86", "transactions": [ - "0x01f8d3870c72dd9d5e883e82017308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cffdd7bff610bd696656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a019fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c80a04bc739bceb821f509ae877ea8ea9bd82c253a7753543df995f20a5591ac284f7a0792682a6835e34c96fce7d5981820fe7205c6ecd5570acc8d5fcbe48d4487e90" + "0x02f8d4870c72dd9d5e883e8201aa0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cffdd7bff610bd696656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a019fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c01a0ee963bcb4fb67a997b3769f7e321f72876d65a535d74c9466c16f3a73477aa63a03e568a3d2715ba5b2b11274ac55fa7aeb105913dfd4f8c1138ab6c0ae6b982a8" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12852,29 +12907,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd60f9025487642346d1ff6fcb21558a0b719524dda4fb773e50254be6ea5cb70", + "parentHash": "0x9096409d42e5525d369ed6637798f87763c39cded3d9b86b9428c86c93b61b86", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaa9c985aae31d5ca2a42624e5fafc7e2d4808cbf3dcfe033e719e1ac2bca7057", - "receiptsRoot": "0x1964831ba5d3c16a8539d764198bf986575324dd965ea3339e95c107e17177b1", + "stateRoot": "0x6c3de87f414ec08a57a84621b1f5494b34a97eebe4f8395527f60fd871010ab8", + "receiptsRoot": "0x53a86de1d09b83de67cfc4d6118e9cf5314c3eed7608c554909ae2574208b53a", "logsBloom": "0x80000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000800000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x197", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0xfe6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc2f378a6349f5ff2413494603a2bf9bf387182e0d7b2e042e0aa9bdde16b44e6", + "blockHash": "0x12d88d0223ca1c9cf55b618b3c4874591d2ab50eedc5b7acb833cec3efc2c2c2", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201740108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cef0bad2321e818b5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a783020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0c44f471d116d1aca7299d564e3f5e2cd7a0d796310285dff60e4935815089e60a07e10d8cb1bff275ed9bedd1418aefc18e815db7568f529e032c0afc560d61b23" + "0x01f8d3870c72dd9d5e883e8201ab08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cef0bad2321e818b5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a780a053276ccd02cf1655c5832a3fc3f0644ba7c5de29c41fb404fef7b1e42d743c10a032602afc3a48d2f2ce0f3e4087c5cf59888242eb8a6b72b7f67e1efa45940b4d" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x6cef279ba63cbac953676e889e4fe1b040994f044078196a6ec4e6d868b79aa1", [] ] @@ -12885,27 +12938,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc2f378a6349f5ff2413494603a2bf9bf387182e0d7b2e042e0aa9bdde16b44e6", + "parentHash": "0x12d88d0223ca1c9cf55b618b3c4874591d2ab50eedc5b7acb833cec3efc2c2c2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6e77461f7994d7cdf0faa3f3bbcc5f6aba9bf8c65d3a5b52e9eac397b37823c9", - "receiptsRoot": "0x1f55e6dc8eee0103c0154282873007279dc35597279793c98f6fcc2d4de2a915", + "stateRoot": "0xdc9634fc3e1d0aff77dddafeb45a9a91afbace01a4333f0bd86d9d777577da46", + "receiptsRoot": "0xa9d01bd64bd9caeb7b4f166fe7b5e2baadfb930035dccc463e2a094af5ab77e8", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000020000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000020000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x198", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0xff0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2332603e1b89c41adb97428017bd2297310b5deeca32af3d79c88a23090d5aaf", + "blockHash": "0x0f52fa7983ab74a3b8f29492272435381ef85bc78db04283ef614c1fed3aa454", "transactions": [ - "0xf87582017508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c68c46027ef4b7464656d69748718e5bb3abd109fa019abe845ab42c8f4f0b26a3ce199dd4855ae4b18713465d1c48ab06574bc3654a034ad1f9c7406c18cdd07c4178899e6d3ac1e0836d38a915e532ec331cf97b78c" + "0x03f8fa870c72dd9d5e883e8201ac0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c68c46027ef4b7464656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a082a4bb68f7522b711c9f22b00f9c5e050f52cb2bc5f0f50eadcb12a5f1c3083983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a069bfc96d7bc42e126e6348fece3369b2e46c9bd72df269c5aeabe314898bef5da0305fa207d3fc1c4f795de4132b599e0ef15486865359dd3935f9b73c3634e1c4" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x60eb986cb497a0642b684852f009a1da143adb3128764b772daf51f6efaae90a", [] ] @@ -12916,21 +12971,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2332603e1b89c41adb97428017bd2297310b5deeca32af3d79c88a23090d5aaf", + "parentHash": "0x0f52fa7983ab74a3b8f29492272435381ef85bc78db04283ef614c1fed3aa454", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x77cc52aea1dd33ea8055a4f3224367ee609ee0724101acc80c44640e89b57c67", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x8012a731e1bf0836bab09fcfb9c5b286c430cbf5bf3cf5bee5a632cfa52f3fe3", + "receiptsRoot": "0x73d6a4d5387da1c08aba18cbdff3ec5099c19fd396d23cfb5be896c8c744a18f", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000004000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400080000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x199", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0xffa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0b88f4a3ea4fe334e0f85983fc3ed8f0e5031f76642df83e9ffddff65637cf43", + "blockHash": "0x84d0bb93eddee81c91f12a28c949b30782bd4e0edba3512ec7ece7930c060823", "transactions": [ - "0x02f86b870c72dd9d5e883e820176010882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c080a0c35eb8c466b63ba1e03aaa0fe19df9e1e342fadf2146ac08e65d6d1df68343aca05d2d29e1d0c3eaac3128ceb1f97b49287e80dcfd9c4d352c5aa5c6cd306dcac6" + "0xf8758201ad08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6ae46cf81c369e21656d69748718e5bb3abd10a0a0f3af9d4836ccf9a28d01a3c8f31b8a3f65e53ac8ecf85273cf05d0acc5047900a048427de7841f09a85a37409520e5878f6fb353a385d823985d99d33cc417f5ce" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12947,21 +13002,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0b88f4a3ea4fe334e0f85983fc3ed8f0e5031f76642df83e9ffddff65637cf43", + "parentHash": "0x84d0bb93eddee81c91f12a28c949b30782bd4e0edba3512ec7ece7930c060823", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x60ea844559cd2bf012d37b9820a350bfa749ab84e3dbce1773f4d223fcfb9297", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x49b22b8988b9ce9cf215f77389080ce8091c88236757a50c3cc2b530ff93e685", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1004", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd5359ec7c8dbda34bbb1391a68ee130ee2fd94cdd86f2e6683e4ca680ef2ee43", + "blockHash": "0x033fd8cb5296f3226b34e1dc1084b6a25480fa39cec6e680902d838135aa1fb9", "transactions": [ - "0x01f86a870c72dd9d5e883e820177088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c080a0218999699955a193b336dfabf9ae461a76e2a706bdaa4210c77c0621106d4867a078c56e123752282d049c7f07b855516a29f56636dbb6584c645003e6a8d0a351" + "0x02f86b870c72dd9d5e883e8201ae01088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c001a05f06d517a74de8d666613df85a2053dba339563eefcd9a968eb70ff707bf0754a04d8a63e4b8c3db8a67ab6585f08e112608faad9d2b5ce0e00dcfd96f0fa330d7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -12978,21 +13033,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd5359ec7c8dbda34bbb1391a68ee130ee2fd94cdd86f2e6683e4ca680ef2ee43", + "parentHash": "0x033fd8cb5296f3226b34e1dc1084b6a25480fa39cec6e680902d838135aa1fb9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb43131e2c4acc2d2e3c4b6a047e5c29d04db1dd153a9ef7f4512b8e557612ddf", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xd6a79ba7a6ff238b9c9e0187c689ce8c06a1b9f2f147519d3b21913535fee054", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x100e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe068d60356aae28f3154fa8f886f0f0067a7b74b524601c2f623610d258cbebb", + "blockHash": "0x737d7e54435171f7d4f1a31907fd2e6c53cce00b323b09de43222b5c27b78de2", "transactions": [ - "0xf86882017808825208941f5bde34b4afc686f136c7a3cb6ec376f735775901808718e5bb3abd109fa06bb2030f614880eafeb4b5e867ccd0db435b5087d7ac256a1735f6bd31fe87fca02cd3a5b7ce81806d5ca89c9c27cfbe358f2aa39e2945b76f3cc1e4ca77390ec2" + "0x01f86a870c72dd9d5e883e8201af08825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a0d819fc2311e388306378ed79eb2e7a84d2019702015d0442a4962fc404155e2da078b1a0494387cec889d0936cd7c86bfd0cd164c8a59fdb0d92db3f544468e599" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13009,28 +13064,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe068d60356aae28f3154fa8f886f0f0067a7b74b524601c2f623610d258cbebb", + "parentHash": "0x737d7e54435171f7d4f1a31907fd2e6c53cce00b323b09de43222b5c27b78de2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x91b38283503f272f386fd74b54f772dfacccfe91e92aee0ba9a5c4decd81bcf3", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x3bfbb383dc248abfa038405d9007842fc9b4f5fb6d427ce73c2ba66713aa4d8b", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1018", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x650b963d47bb9f9b86c29b9d9e52c219bb70525460c04812bd6da741c0e4f90e", - "transactions": [], - "withdrawals": [ - { - "index": "0x24", - "validatorIndex": "0x5", - "address": "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2", - "amount": "0x64" - } + "blockHash": "0xa18e5315c6a7fc757c84bdcc6b663d717c0549aa53f913f05e2cffaf6d9f2227", + "transactions": [ + "0xf8688201b0088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb201808718e5bb3abd109fa0294c12c24ad5ff685c6e22560ff7c009bd0a45bd75f2794d20f0d6b22a613823a05353ecc7c5bc868be13afebdc9011268eae9dbe38d588b6c392df53fa4426021" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -13045,23 +13095,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x650b963d47bb9f9b86c29b9d9e52c219bb70525460c04812bd6da741c0e4f90e", + "parentHash": "0xa18e5315c6a7fc757c84bdcc6b663d717c0549aa53f913f05e2cffaf6d9f2227", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe793c954b6162268e4323115f6365d84736afbafc70c8564364b56ae961afab4", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x142436557545c30c44363b6484e74b07c37dd3b2b7a9e6784d8a35910e1c2486", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1022", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa36c2bf72d713f99a25528fb03aa69429831432f179f6c7c406918b542f76ea5", - "transactions": [ - "0xf883820179088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a062f9d84758ddae03eefb5a4d51f524d42cd0d5a5cfa84ba6fdbe7f10587d1f15a079cd08882dbba6a8c5a3ed94d390e058c8682dd0b9b479df10928ed9444bfb89" + "blockHash": "0xb29d54443444ecf45ee00696aecb54c788d5bf75b57f20e5130c8a9233ca4c96", + "transactions": [], + "withdrawals": [ + { + "index": "0x24", + "validatorIndex": "0x5", + "address": "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -13076,21 +13131,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa36c2bf72d713f99a25528fb03aa69429831432f179f6c7c406918b542f76ea5", + "parentHash": "0xb29d54443444ecf45ee00696aecb54c788d5bf75b57f20e5130c8a9233ca4c96", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x894f1006a54555b3172661c3a5e6685eafc36ebc667efa983a102af3d75b26a0", - "receiptsRoot": "0xc0d1fae7a44f5a08a6509a062badef2b96f711095c30375cf335ee497308dc96", - "logsBloom": "0x00000400000020000002000000000040000000000000001000000000000000000020000000000000000000000000020000000000010000000000000000000000010000000008018000000000400002000000004008000000000010000000000000010000000000000000000000000000002000000000000010404000000000000800000000000000000000000000000000000000000004080000000000000080002000000000000002000000000000000000000000000000000000000000020000000000000000000000000044000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000001", + "stateRoot": "0x5c8d981fc6b1a0f36d6f67caeacb1a1299c64d747e77b94b6676b08daea00cd1", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19e", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x102c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3987af76d0a00951e4513199ee41aec1071161b52151ce66934cda577c4336c6", + "blockHash": "0x7c3805da218aa7f4e84fd775e7020c28243f7be58b18e624e447ac2905f40b08", "transactions": [ - "0xf87a82017a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa00f896411bf64843d5340737f541e899492806f8936469e4b6a9678e55156c71ba06e77e690e26a2d8b86020c19245ca4c3ee9c937adc0cf8ee86b469cfa2aa6fd2" + "0xf8838201b1088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0045d05afb5984928670226945103658d90226b238769ec6bb94ef4b811014bbea0520d77475cb63aa161a1660f2c8c3edf93bf7144e0b83a9ea4f26eebe3d85789" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13107,21 +13162,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3987af76d0a00951e4513199ee41aec1071161b52151ce66934cda577c4336c6", + "parentHash": "0x7c3805da218aa7f4e84fd775e7020c28243f7be58b18e624e447ac2905f40b08", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf1d3bae1b9a67dcf701164be3c70998e5abbf0eb3506c05e120e100f5a4db0c9", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x37e39fb2cf7e5f3b4a61aa2d916d8685236e04cd39f457168496de231114e560", + "receiptsRoot": "0xfbe1a653c6dd606eb25aafa9b0d2aaadc1159b5cce2e08f3115abcdc570dd839", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000002000000000000000010000000000000000000002000000000000000000000000400000000000000000000000000000000020000000000000000000000000800000002000040000000000800000000000000000400000000000000000000000000100000100101000000000000000000000000000100000000000000001000000000000010000000000c00000000000000011000000000000008000000000000400000000010000000000000000400001000000000000000000000020000000000000002400000000000040000001000080000000000000000000040000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x19f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1036", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7158030722716ed4b3153861925682677908d60a72f68d54c31732380dda9939", + "blockHash": "0xfd605ccf0552f8e7b221992726e492451007e6c6fb9d16e9c9a34200886a04d1", "transactions": [ - "0xf86582017b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa002c0ddfb24254a26c7e83c8a2acb634669318b2d7d8f19d5137aaf6664bc9570a050eef823124703af3f339e533d639fd03f2cde4fd2d3c0edbaa02ecb0d0e8d22" + "0xf87a8201b20883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0b2b55ba8f16cab418721c37d01f5541cca57114991a68007b7af3dcdab25d08fa05467d2dafe6378bf9d876ba0fd4d4f6486a2d33faa2cb833af6cc9b184cae185" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13138,21 +13193,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7158030722716ed4b3153861925682677908d60a72f68d54c31732380dda9939", + "parentHash": "0xfd605ccf0552f8e7b221992726e492451007e6c6fb9d16e9c9a34200886a04d1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xcddab4e72b430f6ecb050f28fff1d86122c7026fd305f08a7e09bfd8361810f2", - "receiptsRoot": "0x0ab2aaedb87b9c5061ad67c8e9690c0a9808d4878de14c2f74723364438e2d8f", - "logsBloom": "0x00000000000000000000000000000400000000000000000000000000800000000000000000000000001000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x4a14d680740cc7ff13ff5795b4760edde2bd0957554767961145c99bfe0c3e85", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a0", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1040", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfe58c2367f07005a8773b7faee91e02dbafcb140bc800a5145ee2e31dcca251e", + "blockHash": "0x105a3b333d909958236b0da2089e6ab33cfd18fdcb2b7778c0c9d71db4298d8b", "transactions": [ - "0x02f8d4870c72dd9d5e883e82017c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028caadfe33857f4d842656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07b95105ef96b105a85277c69993f6f56602d912fe712ddf6156cdfcd8c49060701a07ab3a43124121badbbb9366336cfb92a45c2543a5841f896c5d75db686dc4fcaa0121f0254852b6317571e856a781e2ac05dcb587b4b671c1ee5045fa969bf951d" + "0xf8658201b3088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0b9bf568ddb39b91b0ad1f900ca747b72113d1ede1696c191eb367cc9a5928903a0354e8a4937be2f9bf8d165eb08b939fd37146a70b72e958f05833285ec92d427" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13169,21 +13224,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfe58c2367f07005a8773b7faee91e02dbafcb140bc800a5145ee2e31dcca251e", + "parentHash": "0x105a3b333d909958236b0da2089e6ab33cfd18fdcb2b7778c0c9d71db4298d8b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x85f3cd564a6764dfe793c7fcbc39ce1eb4f27a57c846d7e2140233e1400526bb", - "receiptsRoot": "0x0580aa483cf3198d19d0b7f6e9de2a5331079abd9b266f246f031ecbb63bd95a", + "stateRoot": "0x5f6d88002f6ec9dfd4bcf0d386bb420a3c80bc2de0db349737238cefb0ea1762", + "receiptsRoot": "0x5ae0afe8b3c9a6fe2753d58deee3d7a3935003d1268f603a8e9105ed066df674", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000009000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a1", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x104a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe75e1fff4381bbf11eaa336b11a4a79a82f0a39a8afeda3673bc6b98bf091f92", + "blockHash": "0xa67f1ef534a72c18b935ecdd616dfc74353d87c9a17f605056f99194ca51affa", "transactions": [ - "0x01f8d3870c72dd9d5e883e82017d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c04708e04480c538d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0fb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba01a0173b8145bdb22dcce47f47388371d9f3f5974a982f12614c3ecf1bd97b07c419a0133b6d49e23902ba792b434f38f70ea44c830a2f9a7253c945c2cf470ff986ff" + "0x02f8d4870c72dd9d5e883e8201b40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c04708e04480c538d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0fb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba80a0ddb4aeb62dbc896dba05fe7f78e1a1b56de377120bdc0b624395504f32aae2c0a0471e3f27fcc5933c147e74695e1cf14c9fd287721f8410ae6497b814e418a297" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13200,29 +13255,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe75e1fff4381bbf11eaa336b11a4a79a82f0a39a8afeda3673bc6b98bf091f92", + "parentHash": "0xa67f1ef534a72c18b935ecdd616dfc74353d87c9a17f605056f99194ca51affa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0e4bf4c311366cf2c4203cea923b148f91bca9c1fee87080893ae8396e5b73de", - "receiptsRoot": "0x424e342ad6537fd933701062b2254df294eadb9b0bae746c37bcceb2bbe5784a", + "stateRoot": "0x81f739b4c4a80880f57fcfd8299d8a13ec3e03b5d18e0e9ebbbc22b5bf57a1ba", + "receiptsRoot": "0x1101e907ef640b6732e2561b65877e64564f7ff7f6fb22987f21a5febf783d1c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000020000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000080000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a2", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1054", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7de3c0bd5e846119edcd858e4d51f0c0153974ea077bce8048eb3e7d191c3c65", + "blockHash": "0x9227d788b19ed84597de40bf0d549437fac98898f323c856512eb3e4ece9dded", "transactions": [ - "0x03f8fa870c72dd9d5e883e82017e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c96428e7ddf22a6f5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a073a74ab70a71e0aa0cfcaad84c73af0a2752d5fa3e498aa3a4838fa12578db20a05d16a6b804734303cb0d0f900a32e93c7cd9330a839dd27c9f09d175b333a77d" + "0x01f8d3870c72dd9d5e883e8201b508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c96428e7ddf22a6f5656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a80a0ba52b73bca5eeadfd26b3b0036725c4436f447d1925771334f6e9aadb39aa503a0732ccb0e4d917b530939e459c96b540978db93ed6b94f9c40c40eae3a6cc79a5" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x5e1834c653d853d146db4ab6d17509579497c5f4c2f9004598bcd83172f07a5f", [] ] @@ -13233,27 +13286,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7de3c0bd5e846119edcd858e4d51f0c0153974ea077bce8048eb3e7d191c3c65", + "parentHash": "0x9227d788b19ed84597de40bf0d549437fac98898f323c856512eb3e4ece9dded", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc4d7ddce008ad84dd5f904814ff4db9da61e982622fccc0149f045e3ff6b295b", - "receiptsRoot": "0xca8c2f123e2ca46851eec7bf481705b1ab754040c83e62c04c6be43336e74235", + "stateRoot": "0xe4d2cece4ad701df6f87d2dffa991858df1c3824b479ce126d8f6ac71c91b7dc", + "receiptsRoot": "0x9d7a6982ec8b327f2d6fc89884729da67feeaf03fbc98294792a2eacef14a5a9", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000004000000400000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a3", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x105e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc6053e841c2e4bc75e4e959e1b74a9387b351bb4919ae295314e834c5d94e6ed", + "blockHash": "0x9ac08c74df2efa845713d7c48cb120f3974a7d70270d7e43f2e30651695453a0", "transactions": [ - "0xf87582017f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca4ea5930018eb6de656d69748718e5bb3abd10a0a087d67062c811df509205b9a98f5cd1149db0f711bef8dadd8afcceb3e2deb33fa0565434af06bcc29ccb45767e2f84becf7f31c9194eb9cc0b4073c2a93e252bc4" + "0x03f8fa870c72dd9d5e883e8201b60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca4ea5930018eb6de656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ce87527a0ad3ddb4d0d57d8077e84d48a6f3810f2a5672143d3b6969b0f86d6e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a01e3eac364ebf604b3aede0ceb9ded0664b3cc8c2b95fa6d50fe63f39150369a8a03bdbf726f8daad3eccbe49523ed01cfdc7be73bc56178cfa262b6b621ffea578" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x9f78a30e124d21168645b9196d752a63166a1cf7bbbb9342d0b8fee3363ca8de", [] ] @@ -13264,21 +13319,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc6053e841c2e4bc75e4e959e1b74a9387b351bb4919ae295314e834c5d94e6ed", + "parentHash": "0x9ac08c74df2efa845713d7c48cb120f3974a7d70270d7e43f2e30651695453a0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd48aa6daa5c25bd835c2bc73a9ef497c742f596ac86390c1cdd08e726883ccd8", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x91abe8be79c91da7ef24f512943bddfa049501020d7035a76b0af54c806e93ab", + "receiptsRoot": "0xa600bd75f3d3caf5636d9baf534586af3c2b4150d5a93313c34faabcbf37fc5d", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000800000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000800001000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a4", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1068", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x404b549fee0787cefdf4065cb76e3a0e66aab2ad8c6a318e9adfe0bc4a73b85d", + "blockHash": "0x9c60b65b9e76366621f1355ea1e2e292c0f2f2be7bc0f402ad0095cf9b024598", "transactions": [ - "0x02f86b870c72dd9d5e883e820180010882520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc0180c080a008861b6f3d35926627f023b5813774cddb40cfa87d288c6ccfc964e5bad3212ea02dc34c0f4a392b7a6cd0930c1e2e997e90c65baa6f30809b42b421240986a64f" + "0xf8758201b708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2f18b099ede0c012656d69748718e5bb3abd10a0a0a7c1e5848166c2db947cd8e1ddcac62614bb8e27982f6c0f78478f7caa8891efa03172574a6aed5db3f18943592c15518ae1d5ed6c25485f3c8813f7ffcfa02db9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13295,21 +13350,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x404b549fee0787cefdf4065cb76e3a0e66aab2ad8c6a318e9adfe0bc4a73b85d", + "parentHash": "0x9c60b65b9e76366621f1355ea1e2e292c0f2f2be7bc0f402ad0095cf9b024598", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x733956370b9a63c38e3b43a9476668130057597197e83611dccf93d236f948d6", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x35aa3d8b6cb55e2a0eebd5a754a341e49bc2c605716f28de4c9336bc58e0be1f", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a5", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1072", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1ef7fa7c852474808b71df44ef25db220e3dbbb3fd5e18cbb7445b0546b2dbb7", + "blockHash": "0x2198fa802b4c34aa089ce7b6ce1d7eeb5fc3c2dcc6f6db71ca3d15f8c586a230", "transactions": [ - "0x01f86a870c72dd9d5e883e820181088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c080a0305b41cda8519ea8cbdac25b01e849925a8f150a6a5d529a0acbc7eab39da49ca059338257b32dce95ba36161b8cbbe1a1532a96a00a69d18e51415eeafea7cdd3" + "0x02f86b870c72dd9d5e883e8201b801088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a09520e2ec267207e2385106bd676de25575a03d987a86b3201948ad414fadcc5fa03282a47ea09ef3cc501ff025af54fdb37399806f5880dfa823ad3fbefabd06bb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13326,21 +13381,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1ef7fa7c852474808b71df44ef25db220e3dbbb3fd5e18cbb7445b0546b2dbb7", + "parentHash": "0x2198fa802b4c34aa089ce7b6ce1d7eeb5fc3c2dcc6f6db71ca3d15f8c586a230", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x91a24ce9c7807c4cc2a7e6c226ec8a673b4bfc54b51ee1fdf92fd54c2c40547a", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x7131e4e3048c342fbc04ae495f58613640c05b17a8183890d7ccd516b8b3ae14", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a6", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x107c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc5e3d5218b2e1a652c2f2d9613df0b5e389b8695c73562332f4c3381d59faddc", + "blockHash": "0x4df5952c9c5555bae758de89b1a4bef3107e63fe722a5e95161e02f4132faa78", "transactions": [ - "0xf86882018208825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd109fa051771698d0cbc3cb2bf6d62fe327745ad1f0a74a6c98ab0f7e08b61f9fd3a795a05b8f90ab7b967427dec2d5128cfaf53456a2e41dfe053028b15349615a38c993" + "0x01f86a870c72dd9d5e883e8201b908825208940c2c51a0990aee1d73c1228de1586883415575080180c080a0bc490209934f064f57f6b56c593fbd08bfc42a695ace8b885f17fee9611d7bc8a078addf2935069355d58d1cd4a5f8809031dfcc3ed15a29f3b854e91460f5f1ea" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13357,28 +13412,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc5e3d5218b2e1a652c2f2d9613df0b5e389b8695c73562332f4c3381d59faddc", + "parentHash": "0x4df5952c9c5555bae758de89b1a4bef3107e63fe722a5e95161e02f4132faa78", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x28febba9418b7966c83066c069f21ae146c56bae2c9be677413a522793ec89d4", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xa5a97915021b6a174f1e1e25e3537aeed3b459d431743574291fb3d1bf2b68c9", + "receiptsRoot": "0x642cd2bcdba228efb3996bf53981250d3608289522b80754c4e3c085c93c806f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a7", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1086", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3bddbb879a8d46f692289da30f77e1ba669940bd42a1279d275b94c24dcaf9e0", - "transactions": [], - "withdrawals": [ - { - "index": "0x25", - "validatorIndex": "0x5", - "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", - "amount": "0x64" - } + "blockHash": "0xbf89f44ab29227a246931d0d96a52e7b788dcb2411625bca2d50be6a3797d8aa", + "transactions": [ + "0xf8688201ba0882520894eda8645ba6948855e3b3cd596bbb07596d59c60301808718e5bb3abd109fa05200e72ef6248d64e5b1b66b5b62b009fa164eb803eaf2712fbacb715884dc60a0661aa7732289934bcb684843e240c480b9b9b3df52d08d07e25db6e679efb598" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -13393,23 +13443,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3bddbb879a8d46f692289da30f77e1ba669940bd42a1279d275b94c24dcaf9e0", + "parentHash": "0xbf89f44ab29227a246931d0d96a52e7b788dcb2411625bca2d50be6a3797d8aa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x00a97dd6125d423743fb0de7fa16cabb523a863ccce837e2efc525c197b887f8", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x3a9725954a60141996c988304a4431fedb18567332653f23571c53611f252789", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a8", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1090", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5ddb9e58b0ef297a051097bc988e136b1749d9f3445561b6b14a692fad23b8da", - "transactions": [ - "0xf883820183088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa04b4bf92950c32fe37f7e225b7ac450771573c14da0fc850e5bec45917d4e2112a063619497f80b1174cda00936abf5deb5adb18b6511a34d6bad1c011601de0933" + "blockHash": "0x9d798f5f1806b22c73320500e5b0ecad6ce1e56f0bebd96df975eabd7e9307fc", + "transactions": [], + "withdrawals": [ + { + "index": "0x25", + "validatorIndex": "0x5", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -13424,21 +13479,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5ddb9e58b0ef297a051097bc988e136b1749d9f3445561b6b14a692fad23b8da", + "parentHash": "0x9d798f5f1806b22c73320500e5b0ecad6ce1e56f0bebd96df975eabd7e9307fc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0dba2b3227bca5df06f4358a8f424d800b317f32f319a0a965fc0d31489a7b3c", - "receiptsRoot": "0xa95c0659ea55647106bb0421d6e846937fff8a0204b430d49515f001f39a76c6", - "logsBloom": "0x20000000000000000000000000000200000000000000000000000400000000000010000000000000100000000001000000400000000000400000000000000000000000000100000080000000800000000000000000000000000000000000001000000000000000000000000000000000000000000000000000040000140000000000080040000000000100000000000000480000000000000000000000000000000000000480000000000000000000004000000000000000000000000000000100000000000000004000000000000020080000000000000000000000a00000000000000000000000000000002000000000000000040080010000000000000000", + "stateRoot": "0x1f5a65fcf9ad787107bdd22b6bd03f2311390e8c24b403a2196e134123f05e04", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1a9", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x109a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x36be5e83ae2b1baebbb956bc7c44f540745e5a78a59f3ca2aa088fb994fc62c8", + "blockHash": "0xf0688b0ce2364b1c0e3d43325d3d3c8ccd63e530630a920664d49547169d0601", "transactions": [ - "0xf87a8201840883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa00360adf25dc0ca9566cdbbda097786916c7c04d26534c99cc1f15f2de7207e55a034c2533a5ee702ef318af118fe07a2ad8be3071a75af6c299bcfeb3b3b6dab28" + "0xf8838201bb088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0a8b429d8d8413fd79f290fb0095b068f54f005b66457d4e0fbc317325180993fa051faf81e6e050e7c985468e51a2d0e7ed2a48ba0a3ea33df3a59c6d2acd866d2" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13455,21 +13510,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x36be5e83ae2b1baebbb956bc7c44f540745e5a78a59f3ca2aa088fb994fc62c8", + "parentHash": "0xf0688b0ce2364b1c0e3d43325d3d3c8ccd63e530630a920664d49547169d0601", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x62d6bd10e1c7d9799ce034ad0d67d6b8fd2a1c5ed1bba14fb7b0ad8ba4ba5b09", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xf6d42ab939e8a7ec8c7f5b8d1fea7cc02a696e17692a90710070f92ae60ddc50", + "receiptsRoot": "0xd1b80c442926fe5c120d48dbba8a939553768e94cd9d3d93d689e20358cfbe4b", + "logsBloom": "0x40001000000004000000000000000000000000000000000000000000000000000000080000800000000000000000000000000004000000000000000000000000000000000000000000000000000000008000840000000000000000000000000000000000000000000000002000000000000000000000001000000000000000000400000000000000000000000000000000101000000010000000000020000000000200000000000000000440000000040200000000000000000000000040000100040000080040000001000000000000000000000080000000000050000000000000000000400000000000000000080000000000000400000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1aa", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x10a4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcd0da9da1e9b992dbbc4e98d488adea3b884852750ac79bde2b2ea2265a65d9f", + "blockHash": "0x08d303e510e1cc58b695d015fc2c2210daa94f0f3ff193d83ea43135bbb590b5", "transactions": [ - "0xf865820185088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0bfd2c15f64a419a3af3fdf8b3876d98d34b5b8bde7b0c603b26b2a320b626abca02fe1bee07dac1dff99d8c00afce05afe089d45fb884f0ce0e363ab6b3bd1b0a9" + "0xf87a8201bc0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0f528e7e5606653de34f71128dd2325b8d9ae69900242cc49dc3297ae729656eda06a5dcad3a7bc21867e1507f36889cfff8492c01b5a472dcee9de4c819c500508" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13486,21 +13541,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcd0da9da1e9b992dbbc4e98d488adea3b884852750ac79bde2b2ea2265a65d9f", + "parentHash": "0x08d303e510e1cc58b695d015fc2c2210daa94f0f3ff193d83ea43135bbb590b5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa21d9910200d72f9b7fb5cb2e75dfabe60d7686f27d43a2ebbf792503223b8e5", - "receiptsRoot": "0x961e82599eb3b2fe09e2d99b9454c55550f006bb8b24bedbeb265b4c8b8f0762", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000800800000000000000000000000000000000100000000000000000000000000000001000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x6dcc9c866eadcecfa79df027d479128cfb976f4a4f9a58b25bce25508a36a404", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ab", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x10ae", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa5a646fb42670f9bb6782713ff7b2cdb24cd4bb3323b0586c5e2c03d03221d30", + "blockHash": "0xb266835618e75e3292af2395d56e02a6e3e35264a596cb44f38148b1499ea0d6", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201860108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2bf53f54e8dd4d5c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02ecc9be98f9a8adac6e6acc5f160b0d15439b3856f0dee2a3005db79076252a101a02872d41683ea77b63dcf1907c1442d5785d5f06ce268b336b3a1d2c6a14f989da0140d4174638d1c19ce4e7256670b1dfde9f39cfe6ab4c5d2b9c25a0babf0f70c" + "0xf8658201bd088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0b09a24109a3aa2a21627335bb2db9bf7ea898fc97942727cf6ea7ed4d7fcab38a0191c9a40b0a3d226b36e86ec936f46dba272452b4583baf56e58c114e86875be" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13517,21 +13572,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa5a646fb42670f9bb6782713ff7b2cdb24cd4bb3323b0586c5e2c03d03221d30", + "parentHash": "0xb266835618e75e3292af2395d56e02a6e3e35264a596cb44f38148b1499ea0d6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x5668ab2632de1e192960b43729c4874cdaec8fdf971da4bb9a52d81bc6090c0e", - "receiptsRoot": "0x62f3226a4e64d6a22b562e03d1575571d22526bdc185564fe6066d8bfd4a3e1b", + "stateRoot": "0xbc137cf8f41cf2406c69068da0f2a206eca06cdde21e0248db73b5e8791f0203", + "receiptsRoot": "0x7387492d4f80338aa35cc796106c3c1c13d4f7856f89223f50ec2e3eb254db59", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000009000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ac", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x10b8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xec2df5da5678a7b5ea6e5606f84879096c1b455ff0c9fe35679c9436c77953fd", + "blockHash": "0x301512acf2893751ec72f15dce9fdfb887dccfa96c80d6580a3487dd7857087a", "transactions": [ - "0x01f8d3870c72dd9d5e883e82018708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c94159fe8d22ac484656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c8280a0f2ec4363c51bf39f7d230d7b373ac487aad7feb17090149f86a5874c719dfe9ca02a086f083832d22833880e64ddd6be5e66edaded139778afa4944a0695fd9db5" + "0x02f8d4870c72dd9d5e883e8201be0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c94159fe8d22ac484656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c8201a03a816ba4bc14949ab0ac310f3ffd9f89d92d7ab8f0a4d09c5d45c9401bbde552a032913568eddcee54e3fb9bc629f4c6703e84b9993f8803e82a7a946690b2a4de" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13548,29 +13603,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xec2df5da5678a7b5ea6e5606f84879096c1b455ff0c9fe35679c9436c77953fd", + "parentHash": "0x301512acf2893751ec72f15dce9fdfb887dccfa96c80d6580a3487dd7857087a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd148adac40832b208eeae2792b4f3993d7e0a77984621fd57184eea110e7ebd5", - "receiptsRoot": "0x360fcdd796679c1d4ac0abb9164036e531fc69bc66cbb05cf5289f179a7de02e", + "stateRoot": "0xfe0d52fe58965589a853421ce0cfa0e5bc83c31c146f9818e494579d4233451c", + "receiptsRoot": "0xd952a215b77535449177637a95b2ca41bd0a547138df1aae9b7b876444256554", "logsBloom": "0x00000000000000000000000000000000000000000080000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000002000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ad", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x10c2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3b1fcf135ef30081e41bfa1d41b0fff91843274d326b76a81723c7cbcf81c7a5", + "blockHash": "0x22c0f9622864f960991a2027fa3b70d9941bdb21189e7aa09f68660e27be1dcd", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201880108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c79b38a395911e1de656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb6583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0f28c84cbbd1c15d7b491fdef5672bfb99f5c973911f83a2d9083fba59e896465a00824dd81cd879f51862d7cb3cf53ec6a83849e3665d4a1fba60220dd72ee17b4" + "0x01f8d3870c72dd9d5e883e8201bf08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c79b38a395911e1de656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0cea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb6580a0b38990f5679948bcd4756b2135c382f591d087ee507b4bc71215a67d003f5b48a0434451386aa5c7e22ee1e061fd0a80a8f6641ea94a4ff9474fb2d58ea02fb89d" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x060aba9d44a5513488273214452bed1c1e85dc18695bf28a44d98dd24d20cee5", [] ] @@ -13581,27 +13634,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3b1fcf135ef30081e41bfa1d41b0fff91843274d326b76a81723c7cbcf81c7a5", + "parentHash": "0x22c0f9622864f960991a2027fa3b70d9941bdb21189e7aa09f68660e27be1dcd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x95df3ba204688c6f07e371a7804f555c5c6cadc52161403edfaee76dc75cec47", - "receiptsRoot": "0x9c2e5caec128d23b6bfc7d0b84bb065f516462d455584be36674424be7ba2858", + "stateRoot": "0x6d3cf2ba2fa0035bd25a8262b00c1d42b4e7a16bd05f0da1de12a2947c8df893", + "receiptsRoot": "0xb98bfdbf09ddfd3ce555531f4daebba699bf7e5b2de78ebe546cc491965b6426", "logsBloom": "0x00000000000080000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ae", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x10cc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x76c48fbe8881579636df3e68fe55621e99026e7d9810b74ff9cdb7557873d056", + "blockHash": "0xf6131b88cdb92ad5d8d74aa040be0cef999f2adfc6adc0b8c0f2748ea1aa2e22", "transactions": [ - "0xf87582018908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c59a78d4a871468d2656d69748718e5bb3abd109fa07e98f37b83b11f881db0fca02730e3c1230dc2dfadad408236e1968812196f57a02cb56b32722cfd2e1998f5971bc3b59989468f87910e6a73585589fcb34bfc1f" + "0x03f8fa870c72dd9d5e883e8201c00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c59a78d4a871468d2656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e3cb3b98042d005e52e8bbbf49b25e11be63ec7c63ae5a5043e44c545fce633e83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0017276065030e2f613990c6df7af28405409a9fde15b9d044daa3d5e0fa92627a05d73a9a0f2f89def0f67b51d3e506afa31f4f093c097f39467c782bf2b0bbbb2" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xd5fc23888bb73b0a9c6bf06b969040c7be41d5bfcbaf51388390fe09abbfe03f", [] ] @@ -13612,21 +13667,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x76c48fbe8881579636df3e68fe55621e99026e7d9810b74ff9cdb7557873d056", + "parentHash": "0xf6131b88cdb92ad5d8d74aa040be0cef999f2adfc6adc0b8c0f2748ea1aa2e22", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6aebec23a3a1fa16eaff744a55cd2dda5b85cdc56ae1f26cd263347cf98c202b", - "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd2c77328e8b2d379000523d599659d6061ec088e98829ce5e9982e63329326d8", + "receiptsRoot": "0x983d9f4de1366bdb064be176064c96cfee1482a997696604372a08e4e1cdef98", + "logsBloom": "0x04000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1af", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x10d6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb0915a68a1ecb0bcafe6d483d3fddd6a93249d963db6e9650695570b2d494448", + "blockHash": "0x558e886b4bbd77f53aa9a1a056e8e08481da9dc38b7a3859e498e410dcd973af", "transactions": [ - "0x02f86b870c72dd9d5e883e82018a010882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a0971237415e49f25d91c059c902cbabcac9134a93470a1e50be6623609e9239afa04f15ac058a42f0589ca9667ba90c54f29623badc33777fab188cfcbcde1e2c8a" + "0xf8758201c108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8972e901c8e8d563656d69748718e5bb3abd109fa05a39c1b3c12064690b302e86cc1ab31ee0aabcd928370be7278f9a53e69fd744a01e19f38fe7caaf5c8bafae2337ca163e64000b534ffa83e12eb8c842d9edd772" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13643,21 +13698,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb0915a68a1ecb0bcafe6d483d3fddd6a93249d963db6e9650695570b2d494448", + "parentHash": "0x558e886b4bbd77f53aa9a1a056e8e08481da9dc38b7a3859e498e410dcd973af", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6518db9c6e4925aecb5b221d3f27037a2b223de4a73411217f8df154d8fbc9aa", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x53ba0edc93db891b865e2607a2d19a07e198c5fdb111aef0d16fe386bbd0f532", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b0", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x10e0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfdda715666ca9712626e528f4570ffb24d48cdcc62e14571241d1a2f61576c46", + "blockHash": "0x2588de766ecc1af72b5f7b2a729453d703d85d9bfc027898833f2771039877e7", "transactions": [ - "0x01f869870c72dd9d5e883e82018b08825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a094a1ec3a9b3fb3f62f38dfac1f8d7c36d07dd6547a14f6dcc2d8c370c0c120e39fc62b895dd48527c1be40a87e5f771038e3449fc4f99f7aad6ac843a338463f" + "0x02f86b870c72dd9d5e883e8201c20108825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a04eb20b29b5954872fa9ca7d40c30e2f4eabddace9bded5aa80200472d3a5bb72a0356057b0f4e4d3871924ab3018271b9b721910e1d81d54a1d94c50c15fbb093e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13674,21 +13729,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfdda715666ca9712626e528f4570ffb24d48cdcc62e14571241d1a2f61576c46", + "parentHash": "0x2588de766ecc1af72b5f7b2a729453d703d85d9bfc027898833f2771039877e7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6f9f6aad7db1ac4ca3fd2599e952b004f573a52af118c075241ed55f520b1b53", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xcb734b11977fd3bef39d9d1796a9740f2519b1e67d12837581048e67551f984c", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b1", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x10ea", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x91bab78100c2b6909b533e246d772659957330f8ddfcf194087a8fb67bdfb6f7", + "blockHash": "0xdade7fc48d32dc68d41020ac79b868485abb3558e53bb63a2e8aa47932e39476", "transactions": [ - "0xf86882018c0882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd109fa00560b8397596944a06bec099e80d88b0eba0078a9278b7b48c38ba24dd7cddd9a07e3a0b1cd87163b082111f97a391e0711dd157dcd44ec6da0f2a0d73f5a9e9fd" + "0x01f86a870c72dd9d5e883e8201c30882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c080a031e714710112f21058257225bc17be6d429053ff06e6e00b9539445f2fbeee9aa0673f8e3872dce62f5d036b2671e4371fa956af2eaf368d7ce6071918d6d980f4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13705,28 +13760,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x91bab78100c2b6909b533e246d772659957330f8ddfcf194087a8fb67bdfb6f7", + "parentHash": "0xdade7fc48d32dc68d41020ac79b868485abb3558e53bb63a2e8aa47932e39476", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8c3a01f48611558c766a08174b1c9261f47caa7885ca5ef2656de8ce54c7af07", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x8c6932274324937cf298e1c1d53df3407c6f0a80724a5611e9e81a7188057d3d", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b2", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x10f4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xad585c5a49c5db92630ed7c7b67fc367f3405060a0bff9de9dd64b996505a66d", - "transactions": [], - "withdrawals": [ - { - "index": "0x26", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } + "blockHash": "0x8ceeb2afd3646d249dccab24330b4251a5ce2d7ad671541d746f5daef884bd41", + "transactions": [ + "0xf8688201c408825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd10a0a0b37ca854685d8c8d72156a029b9ff2504261800143b7e6a5a4a3a2f8b3038014a045f3c7dcb4e1f373001d2dba66eb0319cb24c3194ce752b81db843f6d4a68c61" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -13741,23 +13791,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xad585c5a49c5db92630ed7c7b67fc367f3405060a0bff9de9dd64b996505a66d", + "parentHash": "0x8ceeb2afd3646d249dccab24330b4251a5ce2d7ad671541d746f5daef884bd41", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x67e890251a1df44f1fdd8e95b3e3325a51c1e5d8e6b56a098dcfb4bb810bb615", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x240e95ee499f741a4c783b2055041d46a0bd79e898c12110ea4cd21831fbda38", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b3", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x10fe", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb8b4a3064cf8c569375764e5323ef7a03667dab6ea562bedcf67aeca7ad55e44", - "transactions": [ - "0xf88382018d088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0494f4ddedaa75cd53c5d2b2b18873541589fa6ff122d30a8c1fe9d1854e23f1ea0285043a32e0d1aba79a3fdd8fb2b8898584296a6a87f00616834ba6b9f34bf62" + "blockHash": "0x24c5b68530cc49171a66f1dc312ea1a15c3b234db8561a1fb08bf8c3adb972d4", + "transactions": [], + "withdrawals": [ + { + "index": "0x26", + "validatorIndex": "0x5", + "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -13772,21 +13827,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb8b4a3064cf8c569375764e5323ef7a03667dab6ea562bedcf67aeca7ad55e44", + "parentHash": "0x24c5b68530cc49171a66f1dc312ea1a15c3b234db8561a1fb08bf8c3adb972d4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb2950cc3040ff95b8285e0f5023157a9f6f174b23b821ac6b477a9369ea87ddd", - "receiptsRoot": "0xb43680ba5a32c58cb1926993bfe009fce37108c8a7b2e732e7213c54c9e3e0ef", - "logsBloom": "0x40400000000000000000000400000000000000100000000000000000000000000000000000800000000000000100000004000001000000010000000000000000000000002000000000000000000000000000000800000000110400002000000000000000000000820000000000000100000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000004002000000000000000100000001000000000000000000000000000000000000000000000000000024000000000100000000000000000000000001104000100000000000000000000000000000000002000000000000000200000000080000000000", + "stateRoot": "0x2029e8f91c93f23a5dd780e135b953c0fad03065b297a5c5971ae7a64686a8f2", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b4", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1108", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x53611bef1500f1568f35390b80eb6baf31ffaf9d8a4d34aab3932e5adffcecb5", + "blockHash": "0x82f242525cebab571fe6e5fe6fcd838c55ca48eea1eb255ef7bba0fb43dea956", "transactions": [ - "0xf87a82018e0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a073772e2e2652f74c11e6eab648cfc427cac926989470cc8ff4a0a14e83919427a03c84a88b5ee47058d530e52402f6130f7318043baff71a0d7bc021befd85d48c" + "0xf8838201c5088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0298bc191f179c75529f83f3ebb570c552a1e3c7fbe738fc407692c000515004ea05d05a28bc1eeaea191904de98b8486684da78321372603f377939bd4c1b9a229" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13803,21 +13858,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x53611bef1500f1568f35390b80eb6baf31ffaf9d8a4d34aab3932e5adffcecb5", + "parentHash": "0x82f242525cebab571fe6e5fe6fcd838c55ca48eea1eb255ef7bba0fb43dea956", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x31a8c1120baafc802bd64c6831c84074573982654387f88b7b6dbc76f3644a07", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x02d64962553a6ee9c5acb360729cf9ef45830c33ecbc7db6125fd6f4aa0d18ce", + "receiptsRoot": "0xb8b914589b743e34b5a77ea5f20820ee6309792c6238a972c5ae711e24d918d7", + "logsBloom": "0x0000002000000000000000000000000000000204000000420000000000000000000000000804002000000000800000000000000200000000000000000000000004080008000010000000000000200000000000010000100000000000000000000000000000000000000000000000000000000000000002000080c008000000000000000000000000000000000000000000000000000012210001000000000000000000000000000000000000000000000000000000000000400000000000000000000000000040000000000200000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b5", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1112", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdd0f743e193c79a4a3ac080b01ed2ed15d9321300c002d70d74fb4c9b44564fb", + "blockHash": "0x413f11217c8822a00b8b8b614c7e438db97162345ea9d01d1b46bd859f589395", "transactions": [ - "0xf86582018f088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a006c454e8035cd15a2911e3b903fe167f51c630e009e96e5728bbce23bececaa2a01ce57e3a4cb8cae72e443e34abb166ec39e127e063b281a172b2b70d3e9db923" + "0xf87a8201c60883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0144819e3ba3b7b08a6ab16f130ae8ef5ae64b7c3a9a71fb327580735b5f7bca9a00b44f7e6491d37dc3326bd6a92649ffa89df3b3d9ab652bb241fbeb12a240a50" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13834,21 +13889,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdd0f743e193c79a4a3ac080b01ed2ed15d9321300c002d70d74fb4c9b44564fb", + "parentHash": "0x413f11217c8822a00b8b8b614c7e438db97162345ea9d01d1b46bd859f589395", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3ba3d7945f4a4c397d5dbaeeebe57a4f33a15b564598c7282babc9cfb20fd9ce", - "receiptsRoot": "0xdf851086fb2354fe79ca0d3e9e3bf40f1e41c7463ee9581918eb449a0fc555c8", - "logsBloom": "0x00000000000000000000000000001000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd37c5e362086edd1d3a3169ae13c733ffd92063791e3907ab2bee2a8a97f08bf", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b6", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x111c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcfffe2d9251de471b21928c131be8ecb1b332ec4a9ffc226e64f041820caec47", + "blockHash": "0x37a642a12a17850ffc84a65efd942917d6c413e0623d9ed0dfd583f4a6dd280e", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201900108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4370601485444f78656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c452b6d808f45af81c3310dcf94a1704359eafc34709c45b0c7b95adf4cd02af80a06476a024de65684f7abf56ea2992795bc32b9eabca3dfd802f24104738659638a051b6383d626465cf6ff6073eeec5e9fd1759e5a5d5fa203e448eb0dbf03eb614" + "0xf8658201c7088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a06f1927be139e3b48d8120968bde41ffe936decbde7e43aa0d2930bc0c5d0f6daa049c95570c851c4e12be2197005208534a25c2dd4c5a5e03a14c9373e6d0c77eb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13865,21 +13920,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcfffe2d9251de471b21928c131be8ecb1b332ec4a9ffc226e64f041820caec47", + "parentHash": "0x37a642a12a17850ffc84a65efd942917d6c413e0623d9ed0dfd583f4a6dd280e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd2a9076a6c93bae04e4d50c5275761281942cf47668dfc8569587d6361e62970", - "receiptsRoot": "0xa9fb713fa5eca2599ae81d8cd7ab1a44a18ce704ce5949d7778e96bd30d85037", + "stateRoot": "0x5c86a438d336a63de19080d7751184e2d26d8ac59f22caf6b4e4319e187cda6c", + "receiptsRoot": "0xdc0e6d287583eee8532625d0a03d749699dadb32658545f589010cc54cb4da12", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000001000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b7", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1126", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x758647ab7f0d8935064c2c38ef6a2a34457df9c78297c2d42376ce18051a4a56", + "blockHash": "0x2319866ae408c2c16def479454f550894284b65217d988c0f0346c8b788e6f50", "transactions": [ - "0x01f8d3870c72dd9d5e883e82019108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdb38dd98f8319698656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a075eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de080a02bcf01133888df5ef0373d5382917ef6108b1e147cd3c726ccbd72d5156072e6a0671aeea102efacbde075bc75a80fbaab9e15a6e470ecb4717adbe436ef47503a" + "0x02f8d4870c72dd9d5e883e8201c80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdb38dd98f8319698656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a075eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de001a08cd129f5d58113adc5d2175265af0cbe79f04bbce7e8b5f4d6d7772d842355bda05e2bda814e12427c7dbe1ef1dceb7f72fef976ba6ae4f95912a65a011cfc96cb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13896,29 +13951,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x758647ab7f0d8935064c2c38ef6a2a34457df9c78297c2d42376ce18051a4a56", + "parentHash": "0x2319866ae408c2c16def479454f550894284b65217d988c0f0346c8b788e6f50", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9d015c81c2be398fa128de167193c6852c7d31f1f63e6143987bc30b80acbe7b", - "receiptsRoot": "0x03859880c301da93fbc6097c99964de48eae15915c5720e0898b968b0e1e4c43", + "stateRoot": "0xa3edc3d3e1ae71ec0935c87361343b15ad083e06ada9a65299b8f675ad0b4c4a", + "receiptsRoot": "0xb686b4df3c5763dda0313e842ba52aad7478706c4f1540c8d3ff42cf6fabc95a", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000009000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b8", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1130", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1431bfb93a91538f50aebe4b46add424df29fddb8a479eb51c44539f7425d9c2", + "blockHash": "0x21cd372ca079c9c9a302ce46dd6604fe0dab8d1c4963735f200fa7aecf68723e", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201920108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cff9997836ba653fb656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd96383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a067d170ea015f418a85dd9018a66eb5b3f497daeac2e3274aa6e81e12d64dc70ea06ccd0d6a09b13920187d3cc8dd09ed30bd66e8c79d7e7507a10f8fc53333c20e" + "0x01f8d3870c72dd9d5e883e8201c908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cff9997836ba653fb656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd96380a055ccc88d5b46b9a98693893875ce949a2997b6b76f98d97ad4202a89ec4f079aa070330743a9d9be8865bd7b0089a3fb737d57c14fe6254facb2a51ab02be8f0fc" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x6a3a65f6fcf34e82edbc10f8ce17c7aac559454d22b5f8b865b0b26182a791b2", [] ] @@ -13929,27 +13982,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1431bfb93a91538f50aebe4b46add424df29fddb8a479eb51c44539f7425d9c2", + "parentHash": "0x21cd372ca079c9c9a302ce46dd6604fe0dab8d1c4963735f200fa7aecf68723e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1dc00f12b4b67a4ff4469ae92ee5b06f5dec0fc9af1d77d900a374d4ec90e41f", - "receiptsRoot": "0xe4403f226ea34a50550c614e431141bcbc357496382725cf7ab388e550ed1a73", + "stateRoot": "0xdd55b05de585cfd2a8d41191457a953f76626f2a0cedeb1448c3902727a41859", + "receiptsRoot": "0x4e50c1a049436b10baf48b4ae3dfa5b7e19e6afc14f46c08be52adce8c6cb827", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000200000000000000000000000004100000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1b9", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x113a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf2d3d4be2e09a5499d838936b169c6ccf83a1dc510305e54e1e181243480bdcc", + "blockHash": "0x95a47db05dc3a6043cd4a648e1838876d7814cdfc2acc03b6bfd228751a193a9", "transactions": [ - "0xf87582019308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c104809bbbe393c1d656d69748718e5bb3abd109fa02b5dab3335cc19db2050fd831c2ae4fcbe18c229a211ea5ded9fe5f138453a1ca038ed41d85fa8d81885e0b0c20ef134cbf94674f344ef5188fa1f65040cdfe937" + "0x03f8fa870c72dd9d5e883e8201ca0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c104809bbbe393c1d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a01fac03facd67f44699ff86330a7f959ed3745add76d323f4832bc17c35be45c983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0db9f0f490ed8381bf486f22d4b0d5226a6e7ce6965c9769fa156db9ba394a3c9a05ab4c4a13649551a96b56599d84c048023ae831138412ee45562c9636c95cdf7" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x43a4a75cdb8ddebc28bf09b4ae12d71dc0765defafcd384de22c3711726a5d80", [] ] @@ -13960,21 +14015,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf2d3d4be2e09a5499d838936b169c6ccf83a1dc510305e54e1e181243480bdcc", + "parentHash": "0x95a47db05dc3a6043cd4a648e1838876d7814cdfc2acc03b6bfd228751a193a9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7612c719dd4e8378185ea148558b178f0b5eb37dfe856cdcec2057ffef4b6088", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xf2cb5bd72087da6e81d52ae2abcf72b76331431447563452675768b1a70a7bbf", + "receiptsRoot": "0xdefbcd20212e2e430e02a0de3569f95e8eb5d21e41ed5263ee9c2f3299f5052c", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000010000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000009000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ba", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1144", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9b8c6ecde0c9f7d3096db113472984400265c16b8f423527046f7c9cacec1c0d", + "blockHash": "0xe3b09d5570d946f2ab70308a08f0275c443d7ec9d9ef3c32df7c2320f790b4ec", "transactions": [ - "0x02f86b870c72dd9d5e883e8201940108825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c001a0c05fbff6fba6c5f9097b8a5bc7dcd23a1bef40852915fbdc672f2e03fc052a91a0540679ac128e14617a1ecc0e9d18925c965cfd379a01b7304025f3f5bb88fc0e" + "0xf8758201cb08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c703c4a06d7179e4a656d69748718e5bb3abd10a0a0e7f4fd1285f514a91903757942ca5aa4781906b30e993e5fa33d34221e809822a06013f233be081d763faf9d0e8eac1c3d6029b9b67e8f6d498dfe8d3a423f7531" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -13991,21 +14046,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9b8c6ecde0c9f7d3096db113472984400265c16b8f423527046f7c9cacec1c0d", + "parentHash": "0xe3b09d5570d946f2ab70308a08f0275c443d7ec9d9ef3c32df7c2320f790b4ec", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4187854dddfec6279591a4cd9f726102c4663d1c16c87b947effcadd52f9e692", - "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", + "stateRoot": "0xe2cbfdba708a8b5fbc56611cd27b752ddca3923f5dc75ed84a5b43911fdb8ce6", + "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1bb", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x114e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x045aa374dc38d101b3846713180df1f69828e97bd630e2264149777bb19ece35", + "blockHash": "0x590060fc82b55361ca5d13db77f55b5a5cfef362ddb300440f0a48984c9a2e28", "transactions": [ - "0x01f86a870c72dd9d5e883e8201950882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a0a0df669968597ced5aded55893e3dd7d9b40fb05c02657c585877ba9c2aff66ca013e8c0042ac9517ca0e2b59635460a4258283501935b57efa48422b0f3542282" + "0x02f86b870c72dd9d5e883e8201cc010882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a0a20315d3ed21bb88bfd934cf3e23f53ed24dae6e6d83f8b2dab1e7922d267e4da0357155bbeee9cec7c806346a0841bc5d80be7ed07f362f924f64bd2848e93718" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14022,21 +14077,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x045aa374dc38d101b3846713180df1f69828e97bd630e2264149777bb19ece35", + "parentHash": "0x590060fc82b55361ca5d13db77f55b5a5cfef362ddb300440f0a48984c9a2e28", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x970698018f4fecbb86c13ddef6562a78648e7fb584fce6003cd0e01575241f5a", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x14d4a55b70c236c6f56d690d0505a67793c3fc14f88c8fe55fef99a87f8d238b", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1bc", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1158", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe316b409f1472bfb043c4be4e9654a37e2a898850d9bdc815cb9ca1a44b29118", + "blockHash": "0xa9b21f63b40981e09ca454b2739149666dc23a4d33f5a0014463766354cc19f6", "transactions": [ - "0xf868820196088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb201808718e5bb3abd10a0a0de14126ae90f4e6f7172ac889d7788bdd6bbe19ccb3649b216b7a8f507af2e97a05576ccc32b95a6f5e588706f32dc88137bd9baea96e1743a6ead07f44d30a1d7" + "0x01f86a870c72dd9d5e883e8201cd088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a0799dee9c4902eea8b959e169341226e86bda96fd383dcf742a8d8ee607d452d1a016d91de400f3829a5f2957ed11d2d2590cea12e5729e3ec4f47f79652bb4dbef" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14053,28 +14108,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe316b409f1472bfb043c4be4e9654a37e2a898850d9bdc815cb9ca1a44b29118", + "parentHash": "0xa9b21f63b40981e09ca454b2739149666dc23a4d33f5a0014463766354cc19f6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x67c4905dadd5aaad517aa94d209cdc69989c8be8e39ff038f8931792508d1eea", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x22f7dc0d0918b910c836297e58c34a66d703869adbc00a6c1011107e96621834", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1bd", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1162", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5cf2998fd231bdc16bd2c20b02d58af1f81d846a058464ac2e74f75a0485a33b", - "transactions": [], - "withdrawals": [ - { - "index": "0x27", - "validatorIndex": "0x5", - "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", - "amount": "0x64" - } + "blockHash": "0x331d419065a5d0ffa904c435e9022d1e621315eff68f2201ec63a690fec3003e", + "transactions": [ + "0xf8688201ce08825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf01808718e5bb3abd109fa0013753736fec54974ea7e62a21ca2d63995a9c79ef236e9d9debc400b8760c69a02973fdb3be9801e07d7a58c65212d62e8c2963af00cb0c647d8c07de15ba59b4" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -14089,23 +14139,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5cf2998fd231bdc16bd2c20b02d58af1f81d846a058464ac2e74f75a0485a33b", + "parentHash": "0x331d419065a5d0ffa904c435e9022d1e621315eff68f2201ec63a690fec3003e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x04994fb18b014bcd55798ba91dd1f026b23bff9e2273be08e1a90a1d67250247", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xe89ff10d95b4057957a289b060ede7881fc349c059e3d554df9dc08dcbcc03bd", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1be", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x116c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x576518015f61ddc9e28fcf964fa2a13490057c8f8ab669ad82dd2e6bfa19879b", - "transactions": [ - "0xf883820197088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0849cc75ee152d62a3fb486fbab7cd848e2ecc27b9fb566366572e443e33108f9a0603a1d5b2f13c657021472c600cdef596694268c678d88e5de5d3cb209ba5e9d" + "blockHash": "0x44b075e106306c1ca24ca9dc1c5a27e68dbe86367904581bb3981acba06ce979", + "transactions": [], + "withdrawals": [ + { + "index": "0x27", + "validatorIndex": "0x5", + "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -14120,21 +14175,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x576518015f61ddc9e28fcf964fa2a13490057c8f8ab669ad82dd2e6bfa19879b", + "parentHash": "0x44b075e106306c1ca24ca9dc1c5a27e68dbe86367904581bb3981acba06ce979", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfab1e189dfb3cb6578b298363ad541e5355806fa45d0ee637004c23cfce550a3", - "receiptsRoot": "0xd6c1b856f2d2b69cadd746efc3b38a99237e658b25115819c0d394d46830876f", - "logsBloom": "0x00000000000040000800000000000001000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000002000008000000000000000020000000000010000800000000000000000010000000000020800000000000000000000000000000000000000000000000400000400200000000008000100000200000000005004000000000000000000000000000000000000000000000000000000000000000000000000200800008084000000000014800000004000000000401000000000010000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x5cb0060c1b5035f04c6560f07346437d075d089ab444f8d39a603f4ba55c9819", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1bf", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1176", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x21d1d59bcf21cac072a2803938f6fd69d922d1e47a8b7049d8818266bfc27951", + "blockHash": "0x6faa7c1f263480410463c1eaa2ff9a4471dee90cd7b440f9a7fffc7c49c1ab57", "transactions": [ - "0xf87a8201980883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0e0e84d0c2b2c6c49455f0fde3aa355f43de01b49ba6cc21add7a314e42e54b5da03b960f8f3f84bfa9314ed1fa56ecae25166b3245e306aa0520932e0f5256d2fd" + "0xf8838201cf088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0a6e9bd0d3e84219311126f49695d73b24d6e3cc7f93de67a89d4aafd9a93e64ba0025abf1e6f82e07bbf8a351f2d9001232f9fd24c860e07986b7172e696133f92" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14151,21 +14206,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x21d1d59bcf21cac072a2803938f6fd69d922d1e47a8b7049d8818266bfc27951", + "parentHash": "0x6faa7c1f263480410463c1eaa2ff9a4471dee90cd7b440f9a7fffc7c49c1ab57", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x85f8cf721945b935f88454cb7dcc80ed6077316a10ba2604bbd0a52f1d60b4f0", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb9bd751abe7d66c1c1790a05bb8757fec0f057be217d02192c9f6bb5ca328493", + "receiptsRoot": "0x53ffb06514a069fddc141fc8780f7a3250e5185d19f1f03afce5c150535d3671", + "logsBloom": "0x00000000000000000000000004010001000020000000000000040000000000000000000000000000000000000001000000000080001000000000000000000400000000000800000000000000000000000000400004000000000000008000000000000000000000000000000000000000000010000008000000000000000008000000000000000000000000000000000020000004020000000000000000000002000208200000000000080000000200000000000000000000000080000020000000000001200000000000000000000000000000000000000000000000000001000000000000000000000080000000000000000000000010000000100000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c0", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1180", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe4e0607f25a8dcac8a8f7758373f3bbc1bc35176e239966d35a57925684b82fe", + "blockHash": "0x027b707ded941bf200797c580cf2a73d3dba48794d0b2b198965ff9d0aa4b46b", "transactions": [ - "0xf865820199088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a036833029d4bfa43d4b9105e35e8df17007b71e832ea60faa678edf307b7cbef0a079cc8016b3453932fb5d5a5b6f4de361976a12d3859608299b9c76b129f8a0d3" + "0xf87a8201d00883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa080ec0729adbc58c2d0a4e13a4edd9cbdeedf2afce5680be0d9db7e6cce0c888fa020bafea6d0c7a0c7c55be363c3b547722dc768227324c852a55ac7d96c5d2591" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14182,21 +14237,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe4e0607f25a8dcac8a8f7758373f3bbc1bc35176e239966d35a57925684b82fe", + "parentHash": "0x027b707ded941bf200797c580cf2a73d3dba48794d0b2b198965ff9d0aa4b46b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa5458c65c7dbd987ae9d0926cc781bfd453a18b00eea106e8dc9a2c99a5dfa28", - "receiptsRoot": "0xe768f6ae38c5f2054e7ff83ad46a4cc93748c6d829e8f17f6091c07003ccc959", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000040000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000002000000020000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x3cafac9d93b9780d61690341e246e277cfc101f2a9827230e45d2705b38733ab", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c1", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x118a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8b744a371a22b4986eeceb8ee0f512ca44affb56ecd495cea9e6c66a490e1f9b", + "blockHash": "0x35c25ba5f49d95a411ef32426c443c91e887ca1dedf2a6356969292822c0d91e", "transactions": [ - "0x02f8d4870c72dd9d5e883e82019a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c50784d15bdea7b9e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07eae9da1da48fe866f64de7ac5c70c8e43644867b917aa8461f84915396d359801a05fa759f9d89dee838d6c206faaaca0274fc1ce0470137fd92b29414dc7385bc4a06ebb401fcc19aa9889892ff829c1787ad97bf27a553ab1020f96476679279d0f" + "0xf8658201d1088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a067d7bc8bd21e7870cb9a94b7a9c8f95f5dcaed9a2bc12bffb640187fcf640071a06b0f89bdc01f6d022a692dc040694ca3b987500dc5ccf4e4e8127bf666efaddb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14213,21 +14268,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8b744a371a22b4986eeceb8ee0f512ca44affb56ecd495cea9e6c66a490e1f9b", + "parentHash": "0x35c25ba5f49d95a411ef32426c443c91e887ca1dedf2a6356969292822c0d91e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7580d75a460174096af8b7c511f879cf88f9d281b055d58651f1d274b7484a5c", - "receiptsRoot": "0x23c5f32b160f9cdb83afe13090caebc9ebeadcea470982a379a62325aa78b865", + "stateRoot": "0xcd77fdf9f53d458b6a00340027e15704573a60a9b5e6d4f32582ef3d13633657", + "receiptsRoot": "0x1baab2abac477c00e188098d5643447424ec92c721137857f7c00b3d392c07a5", "logsBloom": "0x00000000000000000000000000000000000000000000000000000840800000100000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c2", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1194", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xca1d7f951d628dd35b23cac8c21070a5740d64bba614089170c895a0ec8f57ef", + "blockHash": "0x83e0cab914be2a9ba1c2be60f0ecdff76ee5c946daeef001af4b6a6aa47873dc", "transactions": [ - "0x01f8d3870c72dd9d5e883e82019b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8da9dc6f96ca4d62656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f980a0257adcb05e25646f33deeb98bea0697f601355b5e72da46fcb1c1d0ea1d81fe5a051107d8771eb7448a728cc1a4e5edf15caed6246726977d2480ea42f187d1f0b" + "0x02f8d4870c72dd9d5e883e8201d20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8da9dc6f96ca4d62656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a02aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f901a0ce71194d023e725d872a55051aba64d20e24d16d1a81e6da2256862aae57c673a003c574aab00604a8b86ca7e8b210a741cc8bcdfdac2f839a4822e66e2aedd640" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14244,29 +14299,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xca1d7f951d628dd35b23cac8c21070a5740d64bba614089170c895a0ec8f57ef", + "parentHash": "0x83e0cab914be2a9ba1c2be60f0ecdff76ee5c946daeef001af4b6a6aa47873dc", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x626ca5ae10a12b2efd2b48e7c3bc1e6976cd77ed69722edb4f86b80c2c3a2661", - "receiptsRoot": "0x32ad5c4b7fa7b3c1a393566bab829ec3a4d407c36d8fdb1ddab694bbcd33d1e7", + "stateRoot": "0x4b908a733cb9a3b988ba82a43ddd855a6f42be9d310f9933b2891a4e49b10a5d", + "receiptsRoot": "0x701448c456b1489d79ba377d9019ab44a0401af5fadc84c2756768db23324bc4", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000002200008000000000000000000000002000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c3", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x119e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x410876f7d8880a998a060adf663027422ab139d54e12e973c1bb8342844cb351", + "blockHash": "0xc735802bd46c31c8a7e3e83c2605a218c92e66f7507e88f4cb1c0f351c0a71a3", "transactions": [ - "0x03f8fa870c72dd9d5e883e82019c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cc02a894c6c24e04c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0d5cda3865be365c1ae76bd5e2b0b91f7637da3b11cacdedbfa21cab859942279a0013845f66b55919c176cb4f0647f6894b77cbf0ff4c88a2914124b84977d08a1" + "0x01f8d3870c72dd9d5e883e8201d308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc02a894c6c24e04c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db01a0d6de670436ac3ae5380c60a087ffe3eaf456f354e48a7bac2e1468679b84bab4a014801e5a1c0e20813699837922eb7c7e5d0b25bf83053e6190120f4f149fc64c" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x427e24cb2c8355bd1f18d20aa668805a4e4acfa1411ef2ec980839670499c0a7", [] ] @@ -14277,27 +14330,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x410876f7d8880a998a060adf663027422ab139d54e12e973c1bb8342844cb351", + "parentHash": "0xc735802bd46c31c8a7e3e83c2605a218c92e66f7507e88f4cb1c0f351c0a71a3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa46ba3066c87ce7119b56ce58630ed0cc27373af242719b16976cd670d8ae556", - "receiptsRoot": "0xa4870845d20ff24f436d4c5554b2a5e54400e3e3a9d3a5a2e16a97b91a6dc6cc", + "stateRoot": "0x0b01b0650b43e5149d6fe634fc523568912e7dfc24e3fc12f76f7c9bd3fd57eb", + "receiptsRoot": "0xd2041356b6b4963f58ae843a9218173d592eee55a090752e4f05672fe2f0c690", "logsBloom": "0x00000000000000000080000000000000000000000000000000000000808000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c4", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x11a8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb30c453a9fb88e026819b182903ff90738d44f4237cf66139fe010a93c83ffb4", + "blockHash": "0x781d1e3fdabfafcea2fa6d4486634b6af94498fa3562407f4caa4c4294575417", "transactions": [ - "0xf87582019d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8a743c95d9f14e1c656d69748718e5bb3abd109fa03be3a8d50842a232a28fcf0b3a18425ea2e6f39bbc75d0d5e3e65230e64b3f2ea0289e148b41d97dc01ad89dad1158eeb20f42d906387502cd5beafbb5655670c9" + "0x03f8fa870c72dd9d5e883e8201d40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c8a743c95d9f14e1c656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e4c7ff156c2f31d046217715d0f193c8a6b3a7af6341d6abe0e28c49d121063883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0eb249a5a248d6ed36e9308aad9f867cb6e1543acd0b54ee759efd99e31b27715a07c6a4d27c82be737a7dc621828dc123a5127fc704832bb0bd644ad24a9a4286f" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xb96ddc711361deb1db8cbe6a3bf2bfa883bce23e2f2260c3a0f3c6758f3fcabb", [] ] @@ -14308,21 +14363,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb30c453a9fb88e026819b182903ff90738d44f4237cf66139fe010a93c83ffb4", + "parentHash": "0x781d1e3fdabfafcea2fa6d4486634b6af94498fa3562407f4caa4c4294575417", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd607b37fd2cb910a26e9a84b69095bfc848b823c57d979da9cbf70b8ddfb5849", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcef1e895ff61074bcc7d523b2c6ae314934a2f4457c346cce68c5c8f4c525ff7", + "receiptsRoot": "0x02706fc8554e54ddc25d62368381f347f8635fbbdb1e6e9ddf7be2a8662d4bbf", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c5", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x11b2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5588cd9a04aa1c7e5590c15bf201aa722f59c4aa952bedd1e0de2cd2026c016b", + "blockHash": "0xe516c9e13a00da98680afc3265f13e142ebdd467d12da151e6e5a9677a228c6e", "transactions": [ - "0x02f86b870c72dd9d5e883e82019e0108825208940c2c51a0990aee1d73c1228de1586883415575080180c001a0f5f044b3c2b0e5cac578371ff5332de04f8752ba742606f0899c231dd8960c91a022c3cefad9171af45288b936783781dff0ef8210fc66235a0071d8bf7c72af17" + "0xf8758201d508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c328289220139d4c2656d69748718e5bb3abd109fa037ff19350601c99d783120182d1a079acce8954f3349cecd6680bcdba2a5e6dba02b7141665011e9aa355d5b4ef78c12ea4aa61df652fbf19599b997e3e40591ee" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14339,21 +14394,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5588cd9a04aa1c7e5590c15bf201aa722f59c4aa952bedd1e0de2cd2026c016b", + "parentHash": "0xe516c9e13a00da98680afc3265f13e142ebdd467d12da151e6e5a9677a228c6e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa07aee3a994f4786a9132255d8d82a9ceffe0a586b3b66dfc26b517c7ae9263f", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xa383b9c211851dcd74124fde5b33f90126e42511a894f8f16a37b8c89402474f", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c6", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x11bc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xac273cc7933a2407ec16281e6c7e43bb9b24efd517f53122d265c0fd8e400e6b", + "blockHash": "0x666ac8fcb85fe5025a7b996eb4f4d6411019124c819a009b7e0c7f0e0c4c4c3f", "transactions": [ - "0x01f86a870c72dd9d5e883e82019f08825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a07b02bc124dd50bc80814d08749d075bede4b4c13202a5fad804135b8b493754da002629acd4c30c01ce1c63f74d44d505f544a35cdb087482b803e5e01bf98cc76" + "0x02f86b870c72dd9d5e883e8201d60108825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a0a70906f3b9d0186d8478f9ed31a1bd32a6825ea4ab1afe5d0c2a6cbc9037cde3a07d7777a97031d3a57bbf6ae2d834240e6b47e828b707ed6092d2794c251d19a5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14370,21 +14425,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xac273cc7933a2407ec16281e6c7e43bb9b24efd517f53122d265c0fd8e400e6b", + "parentHash": "0x666ac8fcb85fe5025a7b996eb4f4d6411019124c819a009b7e0c7f0e0c4c4c3f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x80cbabc0bbc66c40593eac7415a5e92ae1c19d77abf691cd6aa369fbd5410449", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x7fe7149a24850748ad6a6e9bb70bd2f99400d08d71005ff580e843f8a6bb2eec", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c7", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x11c6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xde0c3b47b2a8550abaebd952555b5a604916b2aa0c3516ac07f7cf9bf6d289b6", + "blockHash": "0x3c141c08a245a3db335db0f6bb0cff5848f6425057c9961cb3bef827aa0ff53d", "transactions": [ - "0xf8688201a008825208944dde844b71bcdf95512fb4dc94e84fb67b512ed801808718e5bb3abd10a0a0fe551bca46e599932399359e23ba76065cd515b2a6096048cef9a7c127737dd2a052a0df5bbac278462e0f84337ffc1ae8c2667a58205eac272d6596c8e9116ea1" + "0x01f86a870c72dd9d5e883e8201d708825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c001a0d95b3075ed5cd26fd129ff63a5f677c3285ab8a5636df2441de3570eca497511a0047269f7e8a838ffc7d01a99eae702a1bd1972a728a1546bb3b59746172d66ed" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14401,28 +14456,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xde0c3b47b2a8550abaebd952555b5a604916b2aa0c3516ac07f7cf9bf6d289b6", + "parentHash": "0x3c141c08a245a3db335db0f6bb0cff5848f6425057c9961cb3bef827aa0ff53d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x65c9d878df12d376f241b7359e683f079b80cfef32ab553ac6d6f19cd09a66c3", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x42199969c7e33002b1bfc796611c40beaaabd61bf5c7ca2de6c9e941350a4258", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c8", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x11d0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x305bd96c60a6435f5371739f23364940ac2ee253e9a6f8d3bd89a623112533e8", - "transactions": [], - "withdrawals": [ - { - "index": "0x28", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0x63dcab73a746ec6c5ac8f1ff8ddbce7cd483c26548f86554fcc40c2ccc041262", + "transactions": [ + "0xf8688201d808825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd10a0a06f658dca9087556cde4e1708d9f14e16e2b5677a8ba0cd4f330fce97a74e80aea01fc0554df07ab3adb59f1f690d9eac44c2b8a8d6d495e31a6e339af3de9b45d7" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -14437,23 +14487,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x305bd96c60a6435f5371739f23364940ac2ee253e9a6f8d3bd89a623112533e8", + "parentHash": "0x63dcab73a746ec6c5ac8f1ff8ddbce7cd483c26548f86554fcc40c2ccc041262", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe81f2fc60ae550918e122a070d583ce4eadb9dda94f028f04b5c2585627a9c0f", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x9c9072fd7910b1ca7ebecd5c80f83b4ce7c035b862429a49a439e3e1a41d9b4a", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1c9", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x11da", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x322c4d0e57f585f032d5cbfff69c3adb7ac8084c95761a9bbad98b97f101327f", - "transactions": [ - "0xf8838201a1088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa010d014cb65ac522ff899f3b31c72ab16b980f306d0243add48333b3aa655ff66a0103a6f272e55d5c5454f473227432bba2671535641717072db7a9a299ab87074" + "blockHash": "0x3aaec8ddc0224f4b084a8ccc04efefac99cbef0e503b8a7bebc3c7aa4fe46521", + "transactions": [], + "withdrawals": [ + { + "index": "0x28", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -14468,21 +14523,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x322c4d0e57f585f032d5cbfff69c3adb7ac8084c95761a9bbad98b97f101327f", + "parentHash": "0x3aaec8ddc0224f4b084a8ccc04efefac99cbef0e503b8a7bebc3c7aa4fe46521", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1c3e70f87cf00906c14ca168c6b2013992feab17ce72ed6c25ba1941fc5894a9", - "receiptsRoot": "0xef465287d76259c60ad703f515c44ee922414d482c2a6522e489a568d5e7333f", - "logsBloom": "0x10001000000000000000000000000000000000000000000000000100000000000000000000000000000000800000000000000000000000000000000040000000000000000000000000000000000000080000000000000000400000000000000000001400000000010006000000000000000000800200800000000000000000000000000000002000000000000000000080000000000000000200000001000000000000000000000000800000000000000000000000000000000000000000000000080000000008004000000080000000000000000000000000000000000000000200000000020000000020000000400080000008004000000400000000001000", + "stateRoot": "0x6c1e3f0baedbd30d7dffdfee5739c9a99ade5bd4686afdac817a424ef05d3354", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ca", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x11e4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x721f94cdb4c6e847bfbc88d65c74a8eb476178d1fa868af25151fd17256aa5cb", + "blockHash": "0x4dbe3b6b04f679aa9677b3a64d1dcfabc5906a12c178e5ff54b7efbfc2c79b50", "transactions": [ - "0xf87a8201a20883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa081f406b3a913530deb0925331aa8467e902ffec9a5425e75c4f662ca9a2f27a1a013b947b3ff5824ccde3401fef17837608be8f786eeccfeae8e3a9e902fbef5d5" + "0xf8838201d9088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0e2ee2f23a81bd341cd6b4bac5edd7402704ca1bda5f78fb3147c00e409beed43a03505f6ddc3fd70088bab88e500a4a4b9be02f5835d498a6f16a6b0b3751155ec" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14499,21 +14554,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x721f94cdb4c6e847bfbc88d65c74a8eb476178d1fa868af25151fd17256aa5cb", + "parentHash": "0x4dbe3b6b04f679aa9677b3a64d1dcfabc5906a12c178e5ff54b7efbfc2c79b50", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x27bc1b69541d7cc57bbfc82baa65a943bf40ae8402d5a77505a6a5c3995e05d5", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb290df099cf4037d6fbed724859ccf2f96b881e7e4fdf7a75b204cdf53ba5995", + "receiptsRoot": "0xc8e21fa98e1d330dab7a033af29fe0cf36f4daab88993fcc8df33a203fecf36a", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000020000000000000000040000000000000000000000000000000000000000000000000000000000000000000080000000000000800000000000000800000000000000040000000000000000000000000080000000000080000000000000000000000010000000000000000000040000000000001000000020820000002000000200000000000000000400000000040000000000000000000000000000004000041000000000000000000000000000000000000000000000000200000000000200000000000080000000200000000000040810000000000100000000800000000000000402020", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1cb", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x11ee", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe98015589d78db8a32de341208e325d7613c6db8683c7d1376113589e15acf0f", + "blockHash": "0x457c3a83d0815833923bd48642d056782f5fd188041e8cd92f260e2383e0361b", "transactions": [ - "0xf8658201a3088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0fcb36b193135dcc545402c100aa7515eca3114a58ec3ddad2222389dada34c93a04274b8e22b8a65231a168d3e874add304538b0e84fcadcdf667de1c457ec6576" + "0xf87a8201da0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0237cdc137b8c4d7a982822810516a56e8e67196a758016a7e061f5eea951df9fa017c6bdf19ae12a24c00d688f69bd80246314ed28ce8d36411a447cdad435f10f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14530,21 +14585,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe98015589d78db8a32de341208e325d7613c6db8683c7d1376113589e15acf0f", + "parentHash": "0x457c3a83d0815833923bd48642d056782f5fd188041e8cd92f260e2383e0361b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x534a22a7bb7f69a06a59da75fc8e0177fb324c75cf4193eebb37cf0415fe1325", - "receiptsRoot": "0x2e70f6fe320c333766de84b318783349f7bb1037cf5ac5f612703d2439f6aece", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000", + "stateRoot": "0xb1a4a7c84c982bc22f68d702132228c58ca1bc16187b245b8ce361cda2907bb9", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1cc", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x11f8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xca13a2bf7d0eb0db6335849b7706678ec18caf013540bf57873532d5bc5cced4", + "blockHash": "0x02522280a85179021caaa61d6482df93c045087417ba2191809b602832aa710c", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201a40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7025e3856d4257fc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0492ae6c575840126917090c30d003aec0892cd6250f877b99f33b72133b94f2380a0493823516fb5621e5a2fb93f68383f54d9df203babab75c5511e756def8a623ba052e62f5274027ac06f53bcf3fdb0e92f64b12e47ac3034d28e4541c76f2d7b82" + "0xf8658201db088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa01d365c507c37b8a89a02925f59c07239c2a5c2cc08c8e5475522fa289f724e1da06f98b1519f68481ec1fd84cf7d7bc9bd001f9c4309f9160247645c0fa6d20867" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14561,21 +14616,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xca13a2bf7d0eb0db6335849b7706678ec18caf013540bf57873532d5bc5cced4", + "parentHash": "0x02522280a85179021caaa61d6482df93c045087417ba2191809b602832aa710c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4806e71590b11d66562b670bfbb4227af9255f94e8fc0176fdb281bd7675f5c7", - "receiptsRoot": "0x2e8de0056d0fc190139defd3579bc5c7fec36ff1ae323626a9506b593849b1e3", + "stateRoot": "0x4ea59afceb52755cf58d31eba5073167399546703c0efbbd57f8cd254814013e", + "receiptsRoot": "0xa248be07f9d0bb446a3c5e24547e89ec9f0371ca6fed43f2d435bb6f972bcb91", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1cd", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1202", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4d93ae5d91ac6a55b6fe9e452210d4e60472cb09900262104063f91e1c4475fb", + "blockHash": "0x4d587bd01bcfa40e1795ad3ea5f77b546910c6870bc7e6657d40a1f2d8feede3", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201a508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c068ce3b3f4387cea656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a041b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a071880a01412cdbfb14747299cd2225b102548b2d7db5ab760d6ee92d7dfd502dd40ba60a061a8e13fed190951bc37b4d53414fd44b3eafac7c6455f0e83c70c56db6398dd" + "0x02f8d4870c72dd9d5e883e8201dc0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c068ce3b3f4387cea656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a041b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a071801a053ed4223e270f3dd37120d52db640e57e1a0ad5b928374dc62152d647920ebf4a06ef2c07bb9f0f5cb0adafc9e27bee133499dde9e89aed5c119de862f9965f5b7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14592,29 +14647,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4d93ae5d91ac6a55b6fe9e452210d4e60472cb09900262104063f91e1c4475fb", + "parentHash": "0x4d587bd01bcfa40e1795ad3ea5f77b546910c6870bc7e6657d40a1f2d8feede3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd01d51aef5c56620f82b4a65c4de929f29de75529a0f8f39caccf5cb20f5d1df", - "receiptsRoot": "0xe0cb24dd872908c91fbc43cb557530d5965d1875176bb5f5b0c3330cd869b44f", + "stateRoot": "0xb5fe5b21dfee7eef09f05fab7032c8b66f89da53dcf11de600c0cadf1b4478a5", + "receiptsRoot": "0x2cba0c3de079ded028edde282d307cfb5ec9095fa5b3362bc4490e2967c15948", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000010000000000000000000000000000000000000000000000000000000000010000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ce", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x120c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4557b30a7674af7cbacde7748dff90a2d7b4b2a86f9d79d791e89d39f818a4b2", + "blockHash": "0x961d29a7fc57915697ba5b2fae8d3771d8bd91576c32c05afee041ac17d848b0", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201a60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cc3396aa113bce01b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0fd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a083bf65495878dd9268b7b195bc145b7ad21da1c74abd11f3b8c14ce5c5ccf56ca05c3b754eeb0bc0f79c3f06c9cb839a04fc654da6adbcfaef5de25b0f42f1d36f" + "0x01f8d3870c72dd9d5e883e8201dd08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc3396aa113bce01b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0fd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b501a046b49012734c5a0e65cb4b74bf1886be2f71dc7b430445f07b84f26e25b57e9ea076c6c2dde207d08fb4076b5c4fc5f2a83e834d341c72019653f4a5e97bec1eea" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x76daa53b1c8d26a50bd4e4eca2703ba4bcad8248f6ad3227ed0af745d19d8ae4", [] ] @@ -14625,27 +14678,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4557b30a7674af7cbacde7748dff90a2d7b4b2a86f9d79d791e89d39f818a4b2", + "parentHash": "0x961d29a7fc57915697ba5b2fae8d3771d8bd91576c32c05afee041ac17d848b0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6f28e7c311ff4014108eaa947693b7e142229cd3511fd91708744809a3ae3f5a", - "receiptsRoot": "0x803ef636ba01c78ca5c2de004aa09486ba182fbf479f6e4c274f62e0c4c6a8cf", + "stateRoot": "0x4647c30a119488f69aabc14383509b4114c8f059fb3ea7c563e9dc55e2265c90", + "receiptsRoot": "0xdbf406590cf69a43661fd555c05ff6cfbb66a115a4d0cee64ef14ddcc120e62e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000800000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1cf", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1216", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x07a8c620ead87a45afb4e0e815a54ca217e4054077635d1524710f1ce5ecea24", + "blockHash": "0x5c3884749debf301065e34263780232f327a57a85b4fe19376e62de3723aa5e6", "transactions": [ - "0xf8758201a708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1bf41e5570d77f5f656d69748718e5bb3abd109fa0e8b18ebd47bd5fe6b3d0da3e846fecc95bfe019238497660fd044622d333ee68a01c2021e56a61b76b9d4b2cee62f1fd038a60d891897ad0c842b0afd39a709956" + "0x03f8fa870c72dd9d5e883e8201de0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c1bf41e5570d77f5f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09225354562a563158ba2ce0e86cfeed7fde0ed27c77342aaea09551b9c00ea1983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0df6296070eab7c096d63549942185fcb3c14794e2c5e342f5fbb503bcb3b7280a01ea49bc7ee91a3444e64a233809b57b57929fc6c778052d54ff4fab394d5f6ee" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x2143743a63aa6ab5a7a6586dc404e48493f59fcb7021c079cd5e7efbe4a9fc62", [] ] @@ -14656,21 +14711,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x07a8c620ead87a45afb4e0e815a54ca217e4054077635d1524710f1ce5ecea24", + "parentHash": "0x5c3884749debf301065e34263780232f327a57a85b4fe19376e62de3723aa5e6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa3bec6f881c7947a0f7f0862184894e824488ebca6c7c737c3b2d4ce9649adec", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x7e3982e8359b08fc71bb0f57a00785d1df341e1d865459fcb8c7aa277d900421", + "receiptsRoot": "0x4af70ee701dec7aa6d3fa118f2cf11272798fb644c3e37dc9316e6ee45c139ba", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000004000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d0", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1220", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x87bca64e4e6c1a83cf43da1257fa59a376009b2c9f2f37487f85eb8013fb2f0f", + "blockHash": "0x713463804bd20977b4cd34532f3d1168f0a49501d5408fb2877478a477a1f971", "transactions": [ - "0x02f86b870c72dd9d5e883e8201a8010882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c001a04004c9e1e07f1fcb40b17fd0155a6ad6512d31c0be3e7975a470536834fa6a7aa032ce14734e673e544c999078ea52e7b5f99c334dacbc37fe09545f4992974742" + "0xf8758201df08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c389d43df20b49725656d69748718e5bb3abd109fa04fe1b45a88d8e36e60f5c7b0031228371b19d91623eeafc272583c8a1a7d54bfa064c2ce10ca42d5dd64d25b3deae63ff28d5d08eae0df34405559c2f2333dfa52" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14687,21 +14742,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x87bca64e4e6c1a83cf43da1257fa59a376009b2c9f2f37487f85eb8013fb2f0f", + "parentHash": "0x713463804bd20977b4cd34532f3d1168f0a49501d5408fb2877478a477a1f971", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x717549302dad496e69418af6eea2f9b487baed0236ba4b90d13f46b8df45d3be", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x152631f6c3a90c1969cd5f2d066ce16ea6d418631f9e8473847eba018ba28744", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d1", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x122a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5984be6ef98b1e35c943bed4caf24066c34bea65dd09cf99762e7e3b6e41ae03", + "blockHash": "0x461c8fd694ea0c1af8793266c605b6ceeaf7245cec97495903ea2a14ecac4380", "transactions": [ - "0x01f86a870c72dd9d5e883e8201a908825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c001a09abcdf1c2570570e59c823ab3a69bbfddc6d1008562623128e2c1f61e7b6f0dfa03995c9953c9b0931904e8b8d2e6a05128f9f292f0a6763e576ec5176e6cc4a6e" + "0x02f86b870c72dd9d5e883e8201e00108825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a018f98563dca8b7917f8eb1be73f5d88d894d07df709e919e08faeba12208a428a015f6fe6a957f175590b2d354e0fe2068460eaf4091cb1ccf00383d896842b7aa" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14718,21 +14773,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5984be6ef98b1e35c943bed4caf24066c34bea65dd09cf99762e7e3b6e41ae03", + "parentHash": "0x461c8fd694ea0c1af8793266c605b6ceeaf7245cec97495903ea2a14ecac4380", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x47528cdf5370069155e80e30d1f5ca1c7038610dd2a594fd0b40184b32daa753", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x36011c9656d381ccf0ae8eba22328e64e6d94a57911ab9836e31a68e2ddf6814", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d2", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1234", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x223fd06ad6b3a95d0ca0b0fac2819ca9cc7abbcf53686cd3cc9ea9a7099aed2a", + "blockHash": "0x35e31088a1515e1ba6609d0950a16e8f35cde03fa07f46e18e4b86e2cca4edc2", "transactions": [ - "0xf8688201aa0882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd10a0a07a7094e56286d07a0843ec216423dd2e25b45950cd30267a31673a2a03ebbacda079b43cc4f41e5edd1dc8d07ef006668d9b1481e724ac8f5361f431fe2aaf11af" + "0x01f86a870c72dd9d5e883e8201e10882520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c080a07ec461e1d7b71f934e52df449d0378122ace5caa1405c8e154179a99efb44c6aa055bdbb97e7cf0c95bf33add6a5e04eb8d38f1d012f738227d310c74daaa9bf98" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14749,28 +14804,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x223fd06ad6b3a95d0ca0b0fac2819ca9cc7abbcf53686cd3cc9ea9a7099aed2a", + "parentHash": "0x35e31088a1515e1ba6609d0950a16e8f35cde03fa07f46e18e4b86e2cca4edc2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4a805ac2d1c6c3f45e4aa754b3c3f9d92a0c4f02b5b5a6d735ace7041b26081f", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xedbb5222d2e224a4b461c61b0f3f39a4cb6079bd8ee8c281a81423ebe476efd1", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d3", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x123e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbf9df0134a7722c090ee27e9061af8e32ba1f36de3561cf540aa19c1e0301694", - "transactions": [], - "withdrawals": [ - { - "index": "0x29", - "validatorIndex": "0x5", - "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", - "amount": "0x64" - } + "blockHash": "0x61ba03ccc0e0cf9cd98cdcba500e40e8129eb3eb85920d1fef44a05588d49c3c", + "transactions": [ + "0xf8688201e208825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df01808718e5bb3abd10a0a0f088cde85f447d17aa52c469fc2470136b6b700db905c72ad47966bfa4d6e425a002d5e45688e4a4832e334e370d496967e653a59b8fcf820ed78b3416e5932333" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -14785,23 +14835,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbf9df0134a7722c090ee27e9061af8e32ba1f36de3561cf540aa19c1e0301694", + "parentHash": "0x61ba03ccc0e0cf9cd98cdcba500e40e8129eb3eb85920d1fef44a05588d49c3c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xad4453dbba65e66c8793ae1a41e1c1c430f00c1bbe8a6e30663cfa1b13d6ebdf", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x70aed96d46f82f4f5e9f14bc337e9f9f3b1c252dafc675c12683d547273c4b25", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d4", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1248", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3426b1051fd2963cf74c091c9281236fec075e3b1a6207e0ea8bd590d234231f", - "transactions": [ - "0xf8838201ab088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa07f301798a3e8eac769613ffe0c2b89d2a35a386254117a17cadd0ec7ac71d7ffa048e580964d38c0fc0468c0f2a82331e1afe0565d47329be39f2dcb58e7c26583" + "blockHash": "0x851f39c5ce5f4801b082523faa0cc03f2ff3568a0c243f620e5c339ea39da2b2", + "transactions": [], + "withdrawals": [ + { + "index": "0x29", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -14816,21 +14871,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3426b1051fd2963cf74c091c9281236fec075e3b1a6207e0ea8bd590d234231f", + "parentHash": "0x851f39c5ce5f4801b082523faa0cc03f2ff3568a0c243f620e5c339ea39da2b2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd6604a1a483323a25dbb76b0d43c9c7e328e4182688d2b5a588d37665e2b24fb", - "receiptsRoot": "0x13d0652e24c37c769d347b120265923055f96ae713b9d77ff70edac07e2b97ab", - "logsBloom": "0x0000000400000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000020022000000000000100000000100000000800000000000000000100000020200000010000000000080200000000000000001000000000000c000100000000000000040000200000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000004004002000000000000000000000000000000000020000000000000000000000000800000000000040000000004000000080000000000000000000000000000000100000008200000040000", + "stateRoot": "0xa6330e611d1b54d2f4635073f1a7a17356ab1cc0df2b99100bfd1b457df73898", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d5", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1252", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x108535b032c23c831ea3f0e5e60b628b1653a8d4ff2a04f84ea0c28a5f7a334c", + "blockHash": "0x448656736cc3a9a8e8ab0c5e548319b14a51b40e45f5de7eddaf25ca390c3530", "transactions": [ - "0xf87a8201ac0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa089e20aa467ccbe356f76641d9d5cd4fed171b7c95fa49a16980f2fe2a009ea12a047599499ea6eaf56f04c07564a72c486750251dcebc77a37ae34c02b326b886c" + "0xf8838201e3088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a07f59e7ae860ba10d241156b78d6f76682d3067dab13a9d1d3523353b3ed88d5ca04e3b21dc0d748f7a542108f94dffe326dc5c99b2e834e2140dff9e6131cfe88f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14847,21 +14902,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x108535b032c23c831ea3f0e5e60b628b1653a8d4ff2a04f84ea0c28a5f7a334c", + "parentHash": "0x448656736cc3a9a8e8ab0c5e548319b14a51b40e45f5de7eddaf25ca390c3530", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdc68060e9a8798d536f700d4e95e4a7d65072e218d15704879d6ae2697129ae1", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x91e358d29507ec8bfb636eca841fa13420f25f50274bf8de0eb3eebb1aa6d2db", + "receiptsRoot": "0x292095426e80ff11bd31daf84ac551227369f2579436815b4d1d608f57000653", + "logsBloom": "0x0000000000000100000000000c000000000000000000000000000000000000000000000000000000000000080000000000200000000000000000000000000000000000000000000800000000000004000100000000000000008000000000040080000000200000000800000001000000000000000020000000800800000000000000040000200000040100000000000000000000000000000000000080000800000000000000000000000000000000000000000080004000000000000000000000000000000000000000000000000001000000000008010000000000000020000000080000000800000000020000000000000010000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d6", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x125c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc57d09bf4689a42694a8b98bb6ef2cb60c0af0446b6dbd1f55fb9d19743d0b6f", + "blockHash": "0x525d5448d96a5a36b6bd87c4599662f32304d64eeea5f5c07897724a91a4d8a9", "transactions": [ - "0xf8658201ad088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0402b2c34f4929951c4ac6235d801ea3ac81b76f9fcd89a7ff457d5e7623d7940a031a80cf58f13a978fd87ef8f856a4d194ee9ff56144c8c1070b5f75771c04314" + "0xf87a8201e40883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0938be590b7b3723bf5586bd0eaefb2f94d0ff43a17ceb6081c061848426477a1a07b1ad333de362621715df1cf0fb344a008b8199415e58b6f698ef4f6531a5c8c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14878,21 +14933,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc57d09bf4689a42694a8b98bb6ef2cb60c0af0446b6dbd1f55fb9d19743d0b6f", + "parentHash": "0x525d5448d96a5a36b6bd87c4599662f32304d64eeea5f5c07897724a91a4d8a9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7f50235f00afa9a49c4ab915fbae8a3967ce90aa5e1b98ef4c2d3549adf74ebe", - "receiptsRoot": "0x52c0a49dc885b9730273efa05b99464faa0b07a33714b5f0c1f2ecff60c052cc", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000004000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000", + "stateRoot": "0xd403d08c7d8c0f028874fb847965d5ef3a214d68c07efc2b9533fbd5db668020", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d7", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1266", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x62ec7b9a65be76bed69c2d1b89c7338fd99f11c52ce57d223d0978ad2623b666", + "blockHash": "0x3e17e4473b4356e9cf755ce3275618fd3e3d4b82d193bdf6a57a2ecc4ddef386", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201ae0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c575c87bc04e9291a656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c8bbb420578d2d80897ca392a55fce5e4834f1d641472c0fd6a9698b7a8e786601a05fc12f7471072f1ea6a98b7cd2f0c7f07f0e1cbb78f71c04f4be678636daae25a01bf0a3c0b5161dffb0fe80025e912d42c79d7370819f162f598c312790ea27e2" + "0xf8658201e5088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a04485367c62ef9ca1969823b20d6ce8fe64a021da6b1871961bd374297ecf21cea01fc5a7cdb0893792b24dde71ddd73f8111539365bc989162a0e267658817719a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14909,21 +14964,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x62ec7b9a65be76bed69c2d1b89c7338fd99f11c52ce57d223d0978ad2623b666", + "parentHash": "0x3e17e4473b4356e9cf755ce3275618fd3e3d4b82d193bdf6a57a2ecc4ddef386", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfb7c33ebafcb6cbfa3b0aa70a6cfc12de4fac7274242a2c970b9fdad17f74bb6", - "receiptsRoot": "0x99009295049bbc6668b80a4398a19de7347c72fa2aeeaf7e11906e87c57a06e6", + "stateRoot": "0x170c8cc5d0247d0d135009b21a0ae603f0c42e999359739fbccf16937a5bfe75", + "receiptsRoot": "0xc0fb8b64d307424a0d5a9e490ad7d74da1794516d7ec328ba2cdec4291ad9ad6", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000800000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d8", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1270", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x88fc2bd51129c6a76a5fc4d74e5bca399695ea9b272f65febb655c211ffecccf", + "blockHash": "0x7e688056a77a5d6803174648e4a6d2e982a0e02677ae38261c21c6390e90a659", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201af08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbf2de05a5f3c3298656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b9701a0e6226076cfd8bf43fca38277ffd730aa478ace3525224344c3624d3dfb198151a05a4909aa856a16e38a9daca59a24444b99977e4a10aa825abba4890817466af9" + "0x02f8d4870c72dd9d5e883e8201e60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbf2de05a5f3c3298656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b9701a0779b08a58ec2d864e553ad8c02e52783cd8dc92c3f182b0fd1a8c1687c226b5fa019fc8caadbc0e69431cf04307ecc13220fb5e531540a48c4b3be40b523210dee" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -14940,29 +14995,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x88fc2bd51129c6a76a5fc4d74e5bca399695ea9b272f65febb655c211ffecccf", + "parentHash": "0x7e688056a77a5d6803174648e4a6d2e982a0e02677ae38261c21c6390e90a659", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8d7f1216133c42f768e27b8aea317b208bc85bd0dd7df779a73f848f4004aa67", - "receiptsRoot": "0x3790f8072f001910a81933cec43d8df45f92389bbec3f61d73660404da6590cd", + "stateRoot": "0x4cdee9ef273af6c95159af584b45cc77f2a085839708c8f7618e697a645a821c", + "receiptsRoot": "0x564111f73c7c842eb0bd76f41ca63bb0d2442cde7376c4f994becd72b9b29d2c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000400000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1d9", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x127a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4a6fe7d7a0b3433c8c0017a34efcd408751e24ee224d865746e43ee5dbc6b72f", + "blockHash": "0xe2f9a4e56ef10377498499f58bc152015a2db11f8b485232541dfde10f04591f", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201b00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ca9a00d7fed08a726656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a05ca17d0e9f7fcc7e49fa76b0028de5cb6788be576198194960ff4672e6a309a9a04df6d7a4e2a05d0d9917c68215bbe868461ffc8d3c3816930cf2a92da2ce7dc2" + "0x01f8d3870c72dd9d5e883e8201e708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ca9a00d7fed08a726656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda201a01f265a3f554c74f8c8d093a6129bfee22d49da316557402ff5ca22a12b764909a00c8e2a3a41ea947f37a8094c476783fb030af2309a725c35aa7ae852483687af" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xb9b10d869f9b60ca46c5484073a0bb44fe92a031955f3555ed291fe0ffd8328a", [] ] @@ -14973,27 +15026,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4a6fe7d7a0b3433c8c0017a34efcd408751e24ee224d865746e43ee5dbc6b72f", + "parentHash": "0xe2f9a4e56ef10377498499f58bc152015a2db11f8b485232541dfde10f04591f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2f0f3af3ff59064bcba740401a4b8159ee53e9603974f178483083cf618e4d9e", - "receiptsRoot": "0xbb95ad607d48a3ca500b5faef910c56816051b61786acf3e0ba108ec22807fca", + "stateRoot": "0xc074a3a13d58d82b0af6ce7002f6cc820dd9e670c0f3f4d60d7d0175c0927a32", + "receiptsRoot": "0x5787dd7b4a17e226d55eb1a2ec75e4741dea9adf4a6e0a82395532f4ef505b4c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000008000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1da", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1284", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb4d421616ea7a4adc51abdc1eb68ae4517c83a7e65545ad5bd8570fea865bbe4", + "blockHash": "0x33287f7e4ff32b8a0e6c65d03e04ea27978409381ab031fb8b26d5fe4e14fb3c", "transactions": [ - "0xf8758201b108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc69de6f1cebe0728656d69748718e5bb3abd10a0a0a49c19f71e8331b897802ff1ac62f66cb63247f31993d6fc3776696f4b17c729a05bba34c418b3147244fa9d4fccd8890d222c7f44190d9017ca38c7f6bced2095" + "0x03f8fa870c72dd9d5e883e8201e80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cc69de6f1cebe0728656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0231eb803c34ec183e74b466c105b5518b554ce215bbc31bfa52c384138b8479a83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a015131907b52a5121e8eb89d0aa72b94f20a9b9a58d68a9232396d384b13889e6a0489dd64af98876d13d25bfe420e0a64e30e6f199cde9ef8ab78520806b3b37be" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xba29f52ef7aa5b2c71b61919ff7890c9c8d37234ba7fde07a58301b90296e3b2", [] ] @@ -15004,21 +15059,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb4d421616ea7a4adc51abdc1eb68ae4517c83a7e65545ad5bd8570fea865bbe4", + "parentHash": "0x33287f7e4ff32b8a0e6c65d03e04ea27978409381ab031fb8b26d5fe4e14fb3c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb88eb1c1760f6a7a8ba8daffb098eb4560ceafe894dd33354ef3026cdb00a7ae", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc00f3501b3014c75b63bef51a9f76ffebf460119a95937151d6614d9a3549a77", + "receiptsRoot": "0xeb483474067eef838278e418e2b7e436f757856a7684c74ff8666af3aaa2b49e", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000010000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1db", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x128e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x35ca0c82bbc6c2a282e04efd935ad91744a76f738b1a05f543f362089b077549", + "blockHash": "0xf6073bc7c2255ed4e3365fe8668f9529aa2327e566eea8485e105fe80d0afa5b", "transactions": [ - "0x02f86b870c72dd9d5e883e8201b201088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c001a0af05a64f1aca07aedd20d06dd8e6e3c4ceefcde58d487bcfd54bdfaab1c7d274a00302f428e3a63afcfe2be921c12e6ee23e607e08e7ff6ce15d6af2a407f77686" + "0xf8758201e908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4748f0d7de9cec6d656d69748718e5bb3abd10a0a0c7d4ce8366b2f235acc4271275e5389f2043a7492ff26d3cc2f3900cd5d37d20a041cdc65056832a4515d6e9a0db3be2677692f1e6286b5d7bf731d0c8f94a46c0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15035,21 +15090,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x35ca0c82bbc6c2a282e04efd935ad91744a76f738b1a05f543f362089b077549", + "parentHash": "0xf6073bc7c2255ed4e3365fe8668f9529aa2327e566eea8485e105fe80d0afa5b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7665d8970349ea14cbebfdda189a477293e19ca82343a488ff177f4d7440a0d7", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xd91d71d1575ddebaf88f0fee029716eb85e5f9fe35aeeb44bb084dde2ee839c9", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1dc", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1298", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa2e71dde107bc1f02f8f2303e84580a4061adb821347fd065dea806464488543", + "blockHash": "0xf8819d443db1143c7f37606b9cd6003db500b36f8059e0a1b42587b4b7f532fa", "transactions": [ - "0x01f86a870c72dd9d5e883e8201b308825208942d389075be5be9f2246ad654ce152cf05990b2090180c080a017ce16ee9af5b82c7f29ab98a1bac8aa25420afd16954fb36221582db90ab964a0367033c2da81dabfaddc542ffea3d7e7acf0e75567de6ae4a6170985887bfe82" + "0x02f86b870c72dd9d5e883e8201ea0108825208942d389075be5be9f2246ad654ce152cf05990b2090180c001a01da39a69e12e28d7ca88d666e8e7aa7980698823e17b649e3375e7ca781113d6a062b5fe98fa598535f33aad705871cab848540282aef3a455517cf51e259733d0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15066,21 +15121,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa2e71dde107bc1f02f8f2303e84580a4061adb821347fd065dea806464488543", + "parentHash": "0xf8819d443db1143c7f37606b9cd6003db500b36f8059e0a1b42587b4b7f532fa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc79190bbbaa9d1892a4030dfad5eba2b9e0475d43bca555735ed542fda15f2cd", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x3c51b97b8ace9390727db6917acd8adb3ab62007c674dfb0b8bed30cb3f6e8dd", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1dd", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x12a2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8c2efd84e25c29636ce86228e1fa39045936581562d1d80d1273951d3a7e5b5b", + "blockHash": "0xe1dbbc3e7db42e01ee269badbb49ab349b05938d0fe3840f97a9cd6c51384a26", "transactions": [ - "0xf8688201b4088252089483c7e323d189f18725ac510004fdc2941f8c4a7801808718e5bb3abd109fa0d1a8bb93f8b00fd581da6c59f4b2fe8164085b721ceea7768a8ffe0622ebc0d9a04085917721c3989a38169b02489a0a47161f7197e1254c9795a85e505272e6f4" + "0x01f86a870c72dd9d5e883e8201eb088252089483c7e323d189f18725ac510004fdc2941f8c4a780180c080a072485996da69cfd4e9f408f5fdc5f6288d563b6f4d33e7bda3b4ea7a3e01aeb6a07c48e1d88e7888cd8c7c49e0955a8af513c63c72234c36b702a814c31577777c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15097,28 +15152,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8c2efd84e25c29636ce86228e1fa39045936581562d1d80d1273951d3a7e5b5b", + "parentHash": "0xe1dbbc3e7db42e01ee269badbb49ab349b05938d0fe3840f97a9cd6c51384a26", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x67e66504545bc74878b8ab06179caf460f30c6d642352ee54b67ec5d2602eed8", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x1ae307592d0be62d296a59ae574a4c27eb86be7c143fa3dbedf9543543b25f74", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1de", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x12ac", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xae195bb8f9a28f440a0a10bbf872db2c50aae4f08d49089e3b8783187b8b2d5b", - "transactions": [], - "withdrawals": [ - { - "index": "0x2a", - "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", - "amount": "0x64" - } + "blockHash": "0x92e9256953269935a75a21cb3a31b1797564c37a20a104d622c188d6bbbdcf89", + "transactions": [ + "0xf8688201ec08825208944340ee1b812acb40a1eb561c019c327b243b92df01808718e5bb3abd109fa04b03ab3260de9c9db8e6a7d5c33eb45368d0dc3562f761441023416de5fb3b60a03b13926c431a56db5d297eef17e5bade7d889f7328c56e4612c59eec12f277d8" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -15133,23 +15183,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xae195bb8f9a28f440a0a10bbf872db2c50aae4f08d49089e3b8783187b8b2d5b", + "parentHash": "0x92e9256953269935a75a21cb3a31b1797564c37a20a104d622c188d6bbbdcf89", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x66547ac00f48e5f20225bde1cbeb6e6f863f04ab15824f641aa9e9ec9c072573", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xc969cd9048b452774286e82c1c8a38efc9a1053af6e602b95532a11a51b85d0c", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1df", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x12b6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd74fba51d365cdfe355295a9a9cb7470ab1ddb53070cc23dc84706d30a1c9d65", - "transactions": [ - "0xf8838201b5088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0f4bde21ce8013a82ddd78f70733543867415604c7f83e83e0d9983d1c2042f09a02fa838ccec26ff6ed33a6a253318f6b36fde84386ccff6828731b20a873f8947" + "blockHash": "0x0d4b4ba377d471804631f61c131ff1829b09242afb36c667f66eb3a70677bec2", + "transactions": [], + "withdrawals": [ + { + "index": "0x2a", + "validatorIndex": "0x5", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -15164,21 +15219,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd74fba51d365cdfe355295a9a9cb7470ab1ddb53070cc23dc84706d30a1c9d65", + "parentHash": "0x0d4b4ba377d471804631f61c131ff1829b09242afb36c667f66eb3a70677bec2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x51bfce1b3b28f09cfa61606b2238f6b463ed521abd10bc0dec419b0b9dcbb452", - "receiptsRoot": "0xf45df5f4db771d6e3e81e5adb7565f1c865fad3fd735887f7774795b5edac729", - "logsBloom": "0x00000000000000000000008000000400020000000000000000000000000000000000000400000000000000000200400000000000004000000000000000000000000000000000000000000000400000000400000000000000000000000000000001002000000000000000000020000000000002000000000000000000000000010004000000000000000000000000000800000000000000000002000000000000000004000000000000001040000000006000000000000000105000000000004800000000000000008000000000000002000001000000000000000000000200000000000000000000000000000001000000000000000000000000000080000000", + "stateRoot": "0x797dc51f8fa6b9029acb93b97263f84dffc9a7f2482c302172a3e5e55b81c7e5", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e0", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x12c0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x586bfb94de868a094829593278f0059423d4b3a4fa381118368e866ac9ad174d", + "blockHash": "0xa02fc5e98bc45d4a34dc34d16d71c95e6cdcac504157769ba0e41582d1c7c28e", "transactions": [ - "0xf87a8201b60883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0921567dd55a14824f6f5143836996b8922c81586b17d75347e0bc8a2b7a801bca0131f215ee5fc6ebd61c03573fbe0aca770913b85f5dfaee4a24eb6338dcedc97" + "0xf8838201ed088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa01fe54bfd95c8d7bf278cc8bdf65426bd4e6ab72015758f0b5f2478f29552b42ea0084cddd4e5630f43baebcf6407bb7d29c5adc14bd7edd4cda31812d963ad8e17" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15195,21 +15250,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x586bfb94de868a094829593278f0059423d4b3a4fa381118368e866ac9ad174d", + "parentHash": "0xa02fc5e98bc45d4a34dc34d16d71c95e6cdcac504157769ba0e41582d1c7c28e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xde2f8aa7fcd1b76f0f530a100c0a12756c25d5690ab1575e547bbbee2cb8f02f", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x2764c03f2a545c1ec2680ebd911dec206cc3a14d26cf1bcb768af950fa856b75", + "receiptsRoot": "0x03cd6eb6a3385fd00376333c1a05626d66c0921a7eba669300cf12ef2e377f98", + "logsBloom": "0x000008010000008000000800000000000000000000000100000000020000008000c0000000000000000000080000010000000000000000000000000000000000000010200000400000000000020000000000000010000000000000000000029000000000000000000000002000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000102000000000000000000000000000000000010000000000000001000000000201000000000000000000000000004000000000002000000000800000000000000000000000000000000000000000000800000000000000100000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e1", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x12ca", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xed9fa0da61fcefb49df7807a0e827069520dd2e1b7823c23b6c8316f261a1526", + "blockHash": "0x313563af27e7adf66fd7f2842209e0e0c325506fcac7f6dd3abc361d9e03d498", "transactions": [ - "0xf8658201b7088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0aecf3049dc7efad3353bc715162e1b9dde150cdf5e73bedf97d46143b653b1caa059150a8228653539febb5d7fc110bc90267c4daa458447ee2a6cd74d6cf84abf" + "0xf87a8201ee0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0bbb63c32f8a2e23b9b4602f633aa36df1fbec569e655c3901dc8925f2a85cdc3a0281062cc40caf732aa3922eb6b66c423fdca4ba589a8cd2daa4e7e1fd74ec0dd" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15226,21 +15281,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xed9fa0da61fcefb49df7807a0e827069520dd2e1b7823c23b6c8316f261a1526", + "parentHash": "0x313563af27e7adf66fd7f2842209e0e0c325506fcac7f6dd3abc361d9e03d498", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x15c9e6b89f4e66587fd549b5f8a4b383585a915cba6660d8b06fdfbbb52d69db", - "receiptsRoot": "0xce3f0a477c2a7c5cab029ccb48c1898c02bd2489da74880f776886d5cfe1ec85", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000008000000000000000000000000000", + "stateRoot": "0x54b4354c9b9d598973c271a3817acbc49f1f0b124bd12630660fa91b5982e381", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e2", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x12d4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2d4f68ab5cb1b7d5942ed325911da4de560c281bc4165f12e79b40896faf9240", + "blockHash": "0x337fb18e572e14e967fa54af1ce06a81e52ac2a3baf227d55bcd08499dd4117c", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201b80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c03aca25852d251d4656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a03a970a6d07c991261dcb566f26d21a76c578d05d1565c47dbc1fc071934c8c4380a06cc1446084f31de8ff2d02d5bdde83a5e6590f378258dcc4c9c0f8333a6ee1eba0421801793f6f0a0741d1eb34af7fdfbeab593a6b79da2fb321759296c32dab96" + "0xf8658201ef088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a05e2d7258def4f606f3dbd00a8b07954b2904936c48e431ecfff630e2474bf6c5a038c4338ee8b04b290b101d71c63dee17a2cf1df63a77b49c2b2c6e3f09a21ec0" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15257,21 +15312,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2d4f68ab5cb1b7d5942ed325911da4de560c281bc4165f12e79b40896faf9240", + "parentHash": "0x337fb18e572e14e967fa54af1ce06a81e52ac2a3baf227d55bcd08499dd4117c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7418feb7a3b18f559a82312bdf476251e2015a73489fc0a24c054f2198e6e4e2", - "receiptsRoot": "0xb962be4ba02b6d4a9f438029040b74e9fef16c46e3afe1c644f163387ca2d7ae", + "stateRoot": "0x756692ec3ca2529fc666721eade8e28fc3bf2e6f748d915ae79e86fcafb63c4d", + "receiptsRoot": "0x011e1a201070905363e09002f3f9895b8f14774d3fc5202082b525f9e77a7d93", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000100000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000200000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e3", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x12de", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x173ba1064b822d7fd886f79df09291855941c7e187348cb1be74b4f3853ac46a", + "blockHash": "0x497a904516fc0847ae8cadbe627a4c5999451d9c6fb9c407a20478c7f90c3820", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201b908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccd7535d68ec8cda3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb80a034ff1d0664e9a113b7d67aaf8dac7887dc3cd46cda5b46f9be63942bb7ec7617a0762f090dd6f3994d24e026bbbf0309b9d1dad5a365d1ced9f43aa69942a5838c" + "0x02f8d4870c72dd9d5e883e8201f00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccd7535d68ec8cda3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0d1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb80a0f72ec2e95c10423e647163811ca72f731a3a12202ec71bd4d97bcfa6facb17e2a019dd72bbf2c4d19d317ae86a3da3a022a7b0e582924288a5e207f3b660747e46" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15288,29 +15343,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x173ba1064b822d7fd886f79df09291855941c7e187348cb1be74b4f3853ac46a", + "parentHash": "0x497a904516fc0847ae8cadbe627a4c5999451d9c6fb9c407a20478c7f90c3820", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6ecb1e3489f8078a29b87e0eb6d2fd6e945896714d99eddee74d85a4851c1cd9", - "receiptsRoot": "0x58311e701f652cdacdebe59e7b45f8b1b0ebff606fe210236709f712d6f9063d", + "stateRoot": "0xac9ecf7757f857d61ee4ca1211cc414554ce54263aefaf7a069abf879129cf57", + "receiptsRoot": "0x3028c4498f6278049cdf4797d1163e119d4fadda69e43af341e8b4d95c4b8505", "logsBloom": "0x00000000000000000200000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e4", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca90", "timestamp": "0x12e8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5fe23349b74796ea88667c124d31b7f83d1ea6c55888612d0546fcd8781469f0", + "blockHash": "0x1683f93d623b43c0071b287a4f3bba01765e6a5fa591d80e140d2f709960d5a3", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201ba0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c1877e1001127f07b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a027edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a067af6f0192162151e653097d20f7f403d55f09c1017f56c8b99b6b8d54cb57a7a0321c7a4916061de4a010df3a26b3e925d5780f2ae481dc180f845beedab7fe68" + "0x01f8d3870c72dd9d5e883e8201f108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1877e1001127f07b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a027edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe380a047024ee93ab99dcc228fd1e485cca5f3010b5fe2b446aeede6c98bbcd6c9fee2a01fe50ac44ac57779c871c63ec2df5a6dfdad969fbb566eaf6c14ffb1d12d4018" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x79b058ec1c5cbe0920b5952501060f137989ac99cce216800bd06649890c3be1", [] ] @@ -15321,27 +15374,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5fe23349b74796ea88667c124d31b7f83d1ea6c55888612d0546fcd8781469f0", + "parentHash": "0x1683f93d623b43c0071b287a4f3bba01765e6a5fa591d80e140d2f709960d5a3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x27390abd199fe04144543d27d967696f694d14f167df82a55dd83bc3c40878d9", - "receiptsRoot": "0x7739ee9e2c025b802aca02f952dd550a19f4b1f2f88320592f42157b192eb663", + "stateRoot": "0xad689dfd4bbf472268372f49c2ec1049241d6e80073f472b565c064649238da1", + "receiptsRoot": "0x61e976734fc5e2850c9a6bd14e910990a749febb3ffe4d73b78e2a4f5def1a09", "logsBloom": "0x00000100000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000009000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e5", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x12f2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x44b4ee4af4ea93cdc1f6d6a7600b78b1f18918e5adb36a95773fb69f0c95960b", + "blockHash": "0x47bb80c5043a6c8898d1006da95899d8814b8bdc8bc7f5df945418bc33d14616", "transactions": [ - "0xf8758201bb08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cba2beb3c8594f746656d69748718e5bb3abd10a0a0e661c2c68de66c165b67b63e4d3f2f38ea26a81665d63e8f74e6d11e81d3fc85a001ddd2c77206d9343887e41e90004a1cd663a3925c152df47d96a822781c744a" + "0x03f8fa870c72dd9d5e883e8201f20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cba2beb3c8594f746656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a017f29f600f5128013ce183ac10efc609231aff556df37c8f5d6802c1240c22f483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0e5de33d01e5b9d527ee677943307ee5be7b5a38c86979224b3b199211974195ca05ab07fd3d7a6b85d14bf1d13df1608e86738b172e39dd8cc6cd5af5ee77855ac" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xf4c5320c831d84242a9194e38951a279654456e3eb90f3712c14fdac4d326723", [] ] @@ -15352,21 +15407,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x44b4ee4af4ea93cdc1f6d6a7600b78b1f18918e5adb36a95773fb69f0c95960b", + "parentHash": "0x47bb80c5043a6c8898d1006da95899d8814b8bdc8bc7f5df945418bc33d14616", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x50d5213b8e73149d638d379da242d321106af3f234c0c1bf2a77431c669537e0", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x15e32b70e8785a70e77417d4ef9504d4aaca3a6d12f79ae45546756d816b828b", + "receiptsRoot": "0x653ebe6c9fb5db0b5a624be66ec1ec7cd215019fe1795fc4981a469cbb373f32", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000004000000000000000000000000000000000000000000000000000000000000000008000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e6", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x12fc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6e1a5f320d6c603aebe7b47c6f98bab7e6ca3f63648853117f90681ef82be343", + "blockHash": "0x2365c3df9f22079331e7519296bf2f4115bee3a8fa70a357a4fbd4e21476581e", "transactions": [ - "0x02f86b870c72dd9d5e883e8201bc0108825208942d389075be5be9f2246ad654ce152cf05990b2090180c080a04c6e4253cf03fcfd3b8c654c9d4c722cbf7599f527ddb8c29c4cb700928ab211a033779b52f70e001e25329224c6a3faee756bd10e3534b7ab6ad99a5652623c5f" + "0xf8758201f308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c806201b9a3c840b8656d69748718e5bb3abd109fa07be0eb25643b24292dfde8273e2dfb6cd0147a45ada67c9d109d8d8523481f72a045c91bc91c4beec1a018c6c60f60580b03821b21fcc60973c76f927ef94bb132" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15383,21 +15438,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6e1a5f320d6c603aebe7b47c6f98bab7e6ca3f63648853117f90681ef82be343", + "parentHash": "0x2365c3df9f22079331e7519296bf2f4115bee3a8fa70a357a4fbd4e21476581e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x17c5048dbe3b6539839d450f5c43586cf6048ff932a9699d67fb9f23551bc833", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x1990743fabed219ac5547559b6d626d6be7c11914cfabde737f28ed3ebf5baff", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e7", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1306", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0e0736ecbc21d8283a34e648718dfde99dcf213778a19cbb385a528281994d02", + "blockHash": "0x5d5980aceee17c98188ebf3255e3b3e26b8a5d38f9a4ed95a36cdc818661b619", "transactions": [ - "0x01f86a870c72dd9d5e883e8201bd08825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c001a0b32fa00b190ac2b9eb4b3268aa9141cb78a8916b05f6c0a40f206ee664c8a719a012c6432eb6a03755afae2c6de4391acd53acb4d1883a8ace297e86ed36bfdedb" + "0x02f86b870c72dd9d5e883e8201f40108825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c080a0777135addfe6098ee525763dd774f7721e88834d4fbfd8da87da3c62940b2026a040ce07ca2815f08f677b0cf89c53179ee3a7a2c11670f9591b3cdfa9e2a8c6b9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15414,21 +15469,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0e0736ecbc21d8283a34e648718dfde99dcf213778a19cbb385a528281994d02", + "parentHash": "0x5d5980aceee17c98188ebf3255e3b3e26b8a5d38f9a4ed95a36cdc818661b619", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc219431ca24a3d75c7de17bafe6d3d0929836c9e3671768301f2438d78d91ec7", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x49a0ed0a84fbfabaebeaf8a60822500b6822fb2d67efb25d48bee3f59ee24442", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e8", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1310", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8d71815cf7e21c74cf91c9f2ff59fd941cbcf127084f929254498163c494f183", + "blockHash": "0xa848e5ed65c70444a6d1fe529127abea702ad12603be4c42be221994762e0c08", "transactions": [ - "0xf8688201be088252089484e75c28348fb86acea1a93a39426d7d60f4cc4601808718e5bb3abd10a0a0d5da0e78527ea2676cda16dbf0ca9fb8853ef3d655e4ec8b9b6767b495bb25e1a0631003e734b6121487daf284ca1039416efe86e21334eaffb8ff56c86afceeba" + "0x01f86a870c72dd9d5e883e8201f5088252089484e75c28348fb86acea1a93a39426d7d60f4cc460180c001a06995aa9dca71ef9b2d5badfc1bedfbc0f346a4612e6c76c183e097e37a3bfdbaa03b25ad942ef7828e93cedaa4f1a7042b189c901dd2ca868aa06cd4b09b7e77f6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15445,28 +15500,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8d71815cf7e21c74cf91c9f2ff59fd941cbcf127084f929254498163c494f183", + "parentHash": "0xa848e5ed65c70444a6d1fe529127abea702ad12603be4c42be221994762e0c08", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9e33a5b74ae3ae525bea4008b6dcf596742e4a6bfb70da6dac944a5bcd8fad08", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x66c3694db73f10f25c700132c14df95c8368216c69a7252cd50ea1178269ff2c", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1e9", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x131a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbff2f568d9a26daaaedd8e26e46d3eecb122cfb8c091bc194d6326c88d058f1d", - "transactions": [], - "withdrawals": [ - { - "index": "0x2b", - "validatorIndex": "0x5", - "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", - "amount": "0x64" - } + "blockHash": "0xe98fe8994405578378ed95c1d4b9a45d743c652214e50ac48bc8b36a42d2a4d0", + "transactions": [ + "0xf8688201f6088252089483c7e323d189f18725ac510004fdc2941f8c4a7801808718e5bb3abd10a0a044c3a773e583e21230ea57a7e6fbbd6f2dc0df7eb24010fce0a18fc48037eaeda062fa63e7d6f6949fb9c42ff8bf387ee4c184a6b06fbb8791b55ee7edbc126975" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -15481,23 +15531,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbff2f568d9a26daaaedd8e26e46d3eecb122cfb8c091bc194d6326c88d058f1d", + "parentHash": "0xe98fe8994405578378ed95c1d4b9a45d743c652214e50ac48bc8b36a42d2a4d0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x877e7f78c65e7e3685b7683704a0eb62a1c55b982bcc836455d2d3a9c12eeefd", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x63746c1e716d79e76bba04f87d2cc99ede11eee8082b90037841bbebabd1fefe", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ea", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1324", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x509d2a2521abc4c30ba8b397d9e86976e6134a844bea08ebeac4a4b009bfdd32", - "transactions": [ - "0xf8838201bf088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0ab9145a13f1f6ee6429e1b007c4fd516dad28c5c8cde6f1d12abc7c715e4ef6ea0495d16fc67a9781f1de9758ea4bd665a7234f9ea5708dc90916ee927d85c2ee5" + "blockHash": "0x2a67633e64cfd77fe6ce3386742cde79338e1a34f5c7c904ea3eb8f64696d35f", + "transactions": [], + "withdrawals": [ + { + "index": "0x2b", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -15512,21 +15567,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x509d2a2521abc4c30ba8b397d9e86976e6134a844bea08ebeac4a4b009bfdd32", + "parentHash": "0x2a67633e64cfd77fe6ce3386742cde79338e1a34f5c7c904ea3eb8f64696d35f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb3e38a9114049cd2a23f3ea7a946ee0dc2d5436e82e7407809abb4ee54727456", - "receiptsRoot": "0xdd42cfcddceb6322a92d9a307599a410f09f67d7a46c17fbd43a5ba7d862f8f4", - "logsBloom": "0x00000000000000000000000000000000001000000000000400000000000000040800400000000000000000000000010000000100080000004000000100000000000000000000000000000000000024000000000400000000000000000000000200000108000000080000000000000000040000000000000000000000000000000000000000000000000000000000000000000000001000000200200000000000000000000000000020008000000000000000000000000000000000000080000000400000000000000400000000040020000000002000000000000000000000000000000000000000000000006000000000000000000000000000000000020000", + "stateRoot": "0x4b1fd39d3c84f7de5b23c95d26b731554c7d7fbb8a4599476f2f57b48eae13e5", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1eb", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x132e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc73fe82ce95274c1aca827b1e2bcbdc56663f172a9a808e02fb03b594afd5494", + "blockHash": "0x5d1662243b6c9f6dbf53fe2b79a220453b883e9c80bb06e31f2295e68918aecd", "transactions": [ - "0xf87a8201c00883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa06de4d59a4c5a3ad0afbe74ddf01646de5300055e3fb8c58de0c3aa607a407946a0469a4b7411a764a83be3c34664f12faf29c4c1808825f1b440aa502db5f3f402" + "0xf8838201f7088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a06265f4fe6fabae053312352231c46d971e6d55966e9ec1bdea76d56682c30374a06fbb15c78daf63f5a7fa00678e8fd8b9df8b949b773f0091b04ab05d593d8927" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15543,21 +15598,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc73fe82ce95274c1aca827b1e2bcbdc56663f172a9a808e02fb03b594afd5494", + "parentHash": "0x5d1662243b6c9f6dbf53fe2b79a220453b883e9c80bb06e31f2295e68918aecd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd2d759f0c7df5bee393757eb8d19a2f338e5fc379c375645a6c72088364b5d09", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xdde8adf28a35e206ec2c8e0278d521ac46804e44d6b34cea7b264e2c93905117", + "receiptsRoot": "0x42633a48d7c517b6986b13a13ddf51bebfb0c2da6c2b809ed79e88f8b6a57e3f", + "logsBloom": "0x00000000000030000000000080000000000000000000000000000100000000000000000000100000001010000000000000000000000400000000000000000000000000000000000004100000000000000004000000800000000000000000000000000000000000000000000200000000000000008000000000000840000000000000001000000000000000000000000000008000050000000000000000000000000000040000000000100000000000000000000002080100004000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000005000004000100000000000002000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ec", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1338", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8e940db2d4e9688d0eac137008f26832b205e32c67877475cc0348c38be128ab", + "blockHash": "0xeafb3303dba8dc7f4b41bb7b37f3c93e95c8eabd33c392d88dfd0582aa88dc05", "transactions": [ - "0xf8658201c1088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0a815113aa8040972264e983cb3903de2084ffe5b6557ef6a2717111dca7693dea07fb1c0149302c30af0a272c7b2463730984775bad879350692b7f60aab3f24d4" + "0xf87a8201f80883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a00a5beccc3e6ccaed4bfbe069c8b3ec28887eb8779cbd8d24aa80bad7db8d2ac0a07f0837873e5a2df96b5fa4f053a038a382aba9e1f6cf7d4b8fcc6e6e519f47f6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15574,21 +15629,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8e940db2d4e9688d0eac137008f26832b205e32c67877475cc0348c38be128ab", + "parentHash": "0xeafb3303dba8dc7f4b41bb7b37f3c93e95c8eabd33c392d88dfd0582aa88dc05", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaee5de9b102d4af57cb0ab48df984fa280d8189a0808f7f4c595050b40b221af", - "receiptsRoot": "0xa2b618c505ef3395f557921dfeac32a668e58693fa54e4c0b0412235a373fe65", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000008800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002010000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x1b94679eb1ac049ae1685672462af0024f4bea3fe24a7f4ed983c6cbac4ac1c2", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ed", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1342", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc4686ab32da32550e9cc95adc86e731d96b3498f28c3454972b8647922a8c775", + "blockHash": "0x8658952c14dcc2b8f15ed4f1f4e861e033bcdbe4b0b17671dd7984b29d1a8ba3", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201c20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbdbdb63ec06dbc4d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a051524a498a88953303410a83d67c2b8c69ddafeb99b570accaaed774fbc8583e01a02d00dcf0c9f72c9480f3a2f32d53f2d1bd9cc9c7e57c939faabf531d74b5d592a022f86ce2737fe4d613c5c85cec6dc7bf30499d75a43e8af7f8929ab623bad2b2" + "0xf8658201f9088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0aab80d2f2a4c8bc95e431a1cfccf592ca0aa7a04dcfb04e7e4d7a857b6bc05dba046a818232a3d66ef623aa85756752da22b70d25b901d6a51ea00eeb3df940038" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15605,21 +15660,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc4686ab32da32550e9cc95adc86e731d96b3498f28c3454972b8647922a8c775", + "parentHash": "0x8658952c14dcc2b8f15ed4f1f4e861e033bcdbe4b0b17671dd7984b29d1a8ba3", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd02c8177f7c4cf3ab2b848531bcca041fc894e2d86df57796d3323527d5b481d", - "receiptsRoot": "0xb59464b3db3775db16d568e667b0b003728a26c5ef1b495b5a851f8701bb1bbc", + "stateRoot": "0x51568df621da44c017bee6679e8829703398115672f0a1904ecb0525c15c8bb3", + "receiptsRoot": "0xceb21df14a345f6ffaa4003b6a05ad0fc8b9f37fff443b452e11cb95b2cc3c90", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ee", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x134c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2acc9875f08bf7c9185aea7dcce6c1163b303e620de25993fb494a866f831b9a", + "blockHash": "0x9a4b8616c2ab2fd6d1d94a86a6e4a5ebe988708def10c935772e47bdaefe5b0c", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201c308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028caf8e348bf4f0a699656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c80a077b4fbc6b2b04c54b28551086048b86633d30baddcac9cfb815f60f60d5f52c6a0307d634630eecf0ea9ed75b079936760730effb7113d0fe8cead79b67c7ce759" + "0x02f8d4870c72dd9d5e883e8201fa0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028caf8e348bf4f0a699656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c01a04d9e82bcdb1d5195d2c75a9d5ed8c74bea34ce034ea4b867463f76fe897c9acfa03a356eed52c14df6b863950c89b4087d98291e72993290b671b01fff013cd5eb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15636,29 +15691,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2acc9875f08bf7c9185aea7dcce6c1163b303e620de25993fb494a866f831b9a", + "parentHash": "0x9a4b8616c2ab2fd6d1d94a86a6e4a5ebe988708def10c935772e47bdaefe5b0c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa7b6f6132a35d132c8373b83275fdb1899f009f55697d912a487d1e73dac389b", - "receiptsRoot": "0x69272db254a554362866187ba8d083482ba41778b8b26368260a30cd99da7f0f", + "stateRoot": "0x141f77f9eb7139cdc31274634d663688361d71b55e095a8909dc145e25a8a789", + "receiptsRoot": "0x86b3621195987df290f2e0187032ec98536358f92657dc5d97a75981f552999f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000080000000040004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ef", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1356", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe5e2de3cd1a2a8f6551e93be0ab3644c84c9653cae77d63caa4a10f5b805ffd4", + "blockHash": "0x1987f5210117e3866820238e7be09c5b972ff01bc9d3062259ac73abc9fb5d1b", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201c40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cbfc7b909ffb8a701656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0bae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a1983020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a01e19794d92c3e106531229523c5651f09eebad9b1ab8af16b4f574986cddf370a04e514870232ca6580c57baaea9f826b732ccc92bea5f776f60cb6a6667a92f1f" + "0x01f8d3870c72dd9d5e883e8201fb08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbfc7b909ffb8a701656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0bae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a1901a0211fce01407f71e35b8267bdad0ebd5391dbf851bf33683953a9af52d2f94259a018e11c9d49d9344f5b96e664aff381844801869400c3dafe0ad896e645402764" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x9f7e031c508d86e139947f5b167bce022363da48a40dc260d10b7056ac51cf31", [] ] @@ -15669,27 +15722,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe5e2de3cd1a2a8f6551e93be0ab3644c84c9653cae77d63caa4a10f5b805ffd4", + "parentHash": "0x1987f5210117e3866820238e7be09c5b972ff01bc9d3062259ac73abc9fb5d1b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0ce171ab00e064bd363971bdfb9342cd0d45256cd988fa0bd05197d3d027418a", - "receiptsRoot": "0x331c72dc5228abe1d292e038f6ac92d48b45608a0bb99b821a629112eaa757e2", + "stateRoot": "0x5338ae6528c1e13e7970622a637f1d74d94595e136e791364e3a7f75fff9c2d9", + "receiptsRoot": "0xe9d41dd663d82d4e26983666a122a7b7e2a347cd4b5873329f7d7f2d7ed0287d", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800200000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f0", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1360", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6413cdb135c067bf7c9894bc05cbef70350d5d2bcd089f661257b80a28d71a26", + "blockHash": "0xded42d295832ce8251701cc7582d068b37adcf17bf96e9728f49c7ee7dd93c7a", "transactions": [ - "0xf8758201c508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6cbb5e7a4b55690b656d69748718e5bb3abd10a0a0693fb616abfdf9147a81ba213e94679ff3efdcbc80075a645b33eef4673cd6f4a0696a52ef0e40d7dc5540b69f994bd6a38449159100cde3fbdba155fc26ac297c" + "0x03f8fa870c72dd9d5e883e8201fc0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c6cbb5e7a4b55690b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a08405cb4703a08e5160e343c37d42df5f045091f6b22664b0ec3f587df18d2d8283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a04daf1481394f8ce2ba160b6d1cc3d26cc17bac218d8d73c24bffa94c81be5ebea005faf6eba70ae5d5e002c780638b380ac6b084fd1ad76bfa82f83c300b609a05" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xae2de0af5de73a96ed6b567a73e6a11b603d6cd010885f5c0311faafa922f2cf", [] ] @@ -15700,21 +15755,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6413cdb135c067bf7c9894bc05cbef70350d5d2bcd089f661257b80a28d71a26", + "parentHash": "0xded42d295832ce8251701cc7582d068b37adcf17bf96e9728f49c7ee7dd93c7a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7a70c9dfdacb14eddf9099658ab558b18bee5226ac70462bfd133bb44e08244f", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xa3e6560274c15daa2e0a04e384dfe1d6c95cc8b38ac80869cc94b5a604d2cda8", + "receiptsRoot": "0x483ea5eb66c23a317dbd69d496892e22bdc4475156c7797ed76aafd02d8bfcd8", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000400000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000040002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f1", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x136a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe800f779e224dcc43b5c7bb57da2d643e20dbdb53e1cd60e41207b620a040b5c", + "blockHash": "0xb9244e48395116c8a53aabace93900c569c53b973a9e3687002cd218d807f608", "transactions": [ - "0x02f86b870c72dd9d5e883e8201c601088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a0b14191fe5a86ab1c2eefb3e545ed407a50427c4ab05e43b533fa630b54822b00a05269dabe1ed832d6827d152774e95ab4962dac9c030381d89f8dc5419c955fd3" + "0xf8758201fd08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c19deac0d9d02f92f656d69748718e5bb3abd10a0a0253d7d68f600f2d8bf9d53020fe772e78cbaa5717e162acc8df591a2066bd201a0291572bc54c1fef91bd3cb7ad4dd0a09dafe919392d1df28a9a0fcdea6ec5078" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15731,21 +15786,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe800f779e224dcc43b5c7bb57da2d643e20dbdb53e1cd60e41207b620a040b5c", + "parentHash": "0xb9244e48395116c8a53aabace93900c569c53b973a9e3687002cd218d807f608", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd5389d4e7c476363d1aa9bc8c47483bdf71f3993ec983fabb617dd69454ab4d2", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x8cd708e3014abc0f67e0b7de8c77215d14ca6ec2e0bf5569c274ebccefa11cdd", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f2", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1374", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe3bd2dc0e6af6253299c175f22a860b34d75ee109faa0c7dc437c94c8e35643f", + "blockHash": "0xca9205d2f444fffd9a22b3f45c1ae061924fe6b5d885079b4f215fd6da081c89", "transactions": [ - "0x01f86a870c72dd9d5e883e8201c708825208940c2c51a0990aee1d73c1228de1586883415575080180c080a01251136e3ff24d4eddd91f954ca0024980b54ff7f34d9b0254e4af434c121087a047c647dc9ffa9dc78c540c1847bcb598e573d498b6e218ccad749a138bffffa4" + "0x02f86b870c72dd9d5e883e8201fe0108825208940c2c51a0990aee1d73c1228de1586883415575080180c080a04175b4893216d653bd35be0e04a3a9392927c00bd7b2620519ba862b83365272a00bdd994d4fb2691ccdaa459935f42bc09e596067aa1e70b75c6c6d5a0fac6c5b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15762,21 +15817,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe3bd2dc0e6af6253299c175f22a860b34d75ee109faa0c7dc437c94c8e35643f", + "parentHash": "0xca9205d2f444fffd9a22b3f45c1ae061924fe6b5d885079b4f215fd6da081c89", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x96d35284d3c35cc0f1109ee9387ed55f921c875c60d0ebe1086295c55898a214", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xb9a63c728fd4d69a046f9472a178d78e399dde099a9a88220d16516a36a68a30", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f3", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x137e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x44924c88d1ebadca339c20badf7e5e22ce7ec673cfcb7305d46487417a852cde", + "blockHash": "0xd6d29225f2af2f42a875f8e69837b6abac59f79c06b12476351cf46b1f721268", "transactions": [ - "0xf8688201c808825208945f552da00dfb4d3749d9e62dcee3c918855a86a001808718e5bb3abd109fa06a85e590feffd58fc2903caa04a04bcd5c3f5824b42db665d2190652de42a998a060c02bb53efc5d6c73b2f019d8258cd71c1bed7bf3226ca1b3c6f5e4f19f26f2" + "0x01f86a870c72dd9d5e883e8201ff08825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c001a03c2c9118bf1c36271b931bb65ac95e8331a6dd380c0d394a5da03c8b2fc45254a04d95a9c6f65ab0486f6859104819b6d4b8db39a16c4333ea8b42ec1b7d529c86" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15793,28 +15848,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x44924c88d1ebadca339c20badf7e5e22ce7ec673cfcb7305d46487417a852cde", + "parentHash": "0xd6d29225f2af2f42a875f8e69837b6abac59f79c06b12476351cf46b1f721268", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x955e191119551f055a9e6f3e11d07af09851acf643d64a5d0c1f129b894a1609", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x39badf70c7bd52bd12b4380af723bf4fafea00801a564ee0a8f16f21f5af537b", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f4", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1388", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7151d7993c13af657fb9afbcad9340ddb46fac82b873b64baf85f8f5780151df", - "transactions": [], - "withdrawals": [ - { - "index": "0x2c", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0xa006e393879b70cf602f0122a886d8167c8708f8e7feef6de52675f650f07b2e", + "transactions": [ + "0xf86882020008825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd109fa014a28150001e45fd1e5c8aeac21968d48528fd2ad3cbebe0fc3e81856c72bceca056aa4cd1c773b160dd5324012b004c009f03a75f89d965417ec73244172ccbbb" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -15829,23 +15879,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7151d7993c13af657fb9afbcad9340ddb46fac82b873b64baf85f8f5780151df", + "parentHash": "0xa006e393879b70cf602f0122a886d8167c8708f8e7feef6de52675f650f07b2e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x96e8ab6546be093aedbe2325151a1cf208e1bc9e5469883ef677a00cdc310520", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xc1247f5789fadbd0acd8635083ea35818c1ac48f492726ff3c578a0281dc0c07", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f5", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1392", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xeb6625cb0981451d810c0172e25819ca3b6fc2035ea04542f3dee1dce7c516df", - "transactions": [ - "0xf8838201c9088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa09f242f7711b79cdfb5a72c58154bde5cdb442725057daf94dbae85dc50d69feea022df1168ec1f2265cd4caa1a6e79f68efa4ebf524029e655b27d6e9b58428399" + "blockHash": "0x8698a5e929f6712d07c38692354fc0cd108829576fcf507d8249375bb4d34e60", + "transactions": [], + "withdrawals": [ + { + "index": "0x2c", + "validatorIndex": "0x5", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -15860,21 +15915,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xeb6625cb0981451d810c0172e25819ca3b6fc2035ea04542f3dee1dce7c516df", + "parentHash": "0x8698a5e929f6712d07c38692354fc0cd108829576fcf507d8249375bb4d34e60", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf0bc8cdc892895d0382a37436fbae7a42d95b0b86fc6b6e09d53546a0207dfac", - "receiptsRoot": "0x8f1810576b4069894550fda7f0bd820eb92d3b664107d4cafb0fa4f94dc2c5f6", - "logsBloom": "0x00000000000000000000000000200000000800000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000080000002000000000000080000800000000400000080000000000000000102020000000000040000002000000000000000000400000000000000000000000000000000200000800000040000000000000000000000000000000000000000000200100000000000000000010000000000000000000000000000000000000000400000082000000000020000000000000020000000000000000000000024000000000000002000000000000000000000800001000008000000000000080", + "stateRoot": "0xdaf3b9859e5c20e495cc76741c4f5dece17f47b52452c636d8b877c5dcbbfbed", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f6", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x139c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xefab54ac6e96aa6fc5d3270f7a928f03ab557ce9b7d2ed68f08825ca50c6307f", + "blockHash": "0x1e95d4fa85ff39313eed8480ff6f794da6cbdf6c865c33aa2c514fb097c6817d", "transactions": [ - "0xf87a8201ca0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa039c9ec5087989e0ccbd6bcd6d6d98f4088fb0106d55f845c3270d8341d641229a02360f0209d0f71281c3ea6422573e4a818aecaf0d549e29993b48bac4b2df08f" + "0xf883820201088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a09923b9daa48437491a665744b9cd0ce294d3bc24ba845bd801454be70946bcfea0165f575ce7c9a8eeaf1de39f15d8114e9e7a6b84d9442b8ce2b05d24febe40c5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15891,21 +15946,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xefab54ac6e96aa6fc5d3270f7a928f03ab557ce9b7d2ed68f08825ca50c6307f", + "parentHash": "0x1e95d4fa85ff39313eed8480ff6f794da6cbdf6c865c33aa2c514fb097c6817d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x28edc0ed8c0f0ea206e56a325c0d472b6270596e9254797cb248638b7a9fec42", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x47e13343df17d5b67ba4915c2263b79374d5797850dfb49b6076fd1973f57dc5", + "receiptsRoot": "0x2cfadbb06ed7cdff5d419ab398e471d5e12cc56d6a968b771ef85410ab3c4b66", + "logsBloom": "0x00000000000000000000000000000000000020000000020040000000000000000000000000000000000000000000000000000000000000000400000000000000000000000010002000000001000080000800000000000008000000000000002000000000000800000000088000200000080000000000200000000000000000000000080000000000008000000000000000000000004000000000000000080000000000000000000000000000000000080000001000000000000000001004000000000000000000000000000000000000000000000000000080020000042000000000000000200000000000001000000000000000000000400000000000004000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f7", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x13a6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf0591fc75f0711d3d9234011205cb9bd2c40a3477994d943e6d7a12c72e8d613", + "blockHash": "0x52eb082eb7be273f4d5280bbef49733796215c09a7c71ca1b20fcf9ec180affe", "transactions": [ - "0xf8658201cb088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0d1923c8d37e8ccf7655dc86d425eed22c0463724e8fad35e7b08f509ede8e6c8a04f2f8a02f1d8dc629c0cc259e537e28f4522a3116298c1b24c7be64f9131712f" + "0xf87a8202020883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0ce3ad1aeb48a11c8ce83ee5925d5412ad4604ee96fc344ff8d25ad5613bdb0daa03c1cce897babc59372b111e74bd265a7dae4e8287764ee7f461af0721810f961" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15922,21 +15977,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf0591fc75f0711d3d9234011205cb9bd2c40a3477994d943e6d7a12c72e8d613", + "parentHash": "0x52eb082eb7be273f4d5280bbef49733796215c09a7c71ca1b20fcf9ec180affe", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3d7616976d4d75fc2791c04abab12aac2c78ff3b23f040c0d5dfc1d392d9407b", - "receiptsRoot": "0xea5be4c117d6e881a0a1fec4529a98caab71dd5d707a0876a1621aab324b7505", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000008002000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000009000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x223becc9e964d120cd1dac22c4ba32b31456b78b718d255c012365116dd68df4", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f8", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x13b0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdf54b762c56706ef7861a0725b7fd4f01aaadcac614d3d3f39569cb8e621fd1a", + "blockHash": "0xd671e7ebad6a5828dbcc7932d67618bba676951ddc013cd528bf9b41a99f50b7", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201cc0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccd2e3086ddc2ace4656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a096c0d209b0a5b8b06947cc4c7ca723df55c5b972711b6c08ec7b9c393fa6e8ea80a07fe69218a844aee02158afa85fcbff97e407b786542649788f12ca2fee4d1860a020e258ab41db1a20c0c56271edf7f26e16649cc18853668e1c49837a63993a4a" + "0xf865820203088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a077496f47c2c10b741cbb7f4a2a1c3fa843407d1ff64d8a1ca25bd3cfaf9b5ba6a00873c225525b82c71d00833b83812205e694a9e66d4d3027cda8b432aff5d37a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15953,21 +16008,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdf54b762c56706ef7861a0725b7fd4f01aaadcac614d3d3f39569cb8e621fd1a", + "parentHash": "0xd671e7ebad6a5828dbcc7932d67618bba676951ddc013cd528bf9b41a99f50b7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe7f32766b9aacad31862ca17d8c92188805f7979821e77fbb6061ec9b320b613", - "receiptsRoot": "0x1f914c56592f749fd28f2caa300a6799e1c32c2e45a73828c28a84759e9f2a96", + "stateRoot": "0x27784726627f6a6eaa7c04f9eff52dbe92076a4e45e166d44ecb318cb019f92c", + "receiptsRoot": "0x0fa45692791b30d727b254ac4bde2e0c789a86df9789054ad5d617e2a5686439", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000104000000000000200000000000000000000000000002008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1f9", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x13ba", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4effa3cb8383f0ece82c3391e95ce6a88be26f87bddcc62dfd99cd7a5a11dbfe", + "blockHash": "0x1c10e60513c164ab7482d2c33062cbc0f8191dc03f48a211fb9ba5cc9687646e", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201cd08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cba96783a3c242e12656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb080a0062b5a038fc99ab6efd44780c98ae6cd61f31cf04c26fd39c7b3bec8ac03c134a07c9f218dcd1403f4f06eeedacfdc6cd59568e55b48b6f87358b80cd9cd50d4d3" + "0x02f8d4870c72dd9d5e883e8202040108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cba96783a3c242e12656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a00a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb080a0f21908b759628502248071901716b3e84277824718bedb0ba1ab22c611038307a058abe19656820d15ca1350c4d776193017041f731e71ee8885edbc7fc5a6b782" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -15984,29 +16039,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4effa3cb8383f0ece82c3391e95ce6a88be26f87bddcc62dfd99cd7a5a11dbfe", + "parentHash": "0x1c10e60513c164ab7482d2c33062cbc0f8191dc03f48a211fb9ba5cc9687646e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0807efd5f3ab55636012ada7ec38da71e53884084e30f6a897d7b05a5c5fc7c3", - "receiptsRoot": "0x7d42d51cb89c85398dffa2c7bf080ceec75a6b26afdccd37a22d621f438e7bfb", + "stateRoot": "0xd080cbbec39adeafaba8b5b7a3cc932f2aa9448c5e51d2810128bc93afdcd8f1", + "receiptsRoot": "0x56163a3eed26e00e586f2678efc072a984feda04f1afd75bc134da6c9554fb62", "logsBloom": "0x00000000000000000000000000000000000000000001000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000009001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1fa", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x13c4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2d903ece7c308b988d585304235cb0f3bacbafb64ec0b62da27c1f77aeb18d76", + "blockHash": "0x3a66ebe86f285009227283701e0bd5d1ef913636a7a1331799de1c1faa5e4c29", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201ce0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cc1493cb1f9cdc80f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0168d3c7a04bcc073bb45ffa0b8fd35031efcdc8e9cfb08579208573d2acc3142a02af9d8933f7d5abf54870b26a17a465ffaeff4df77230346f9044e11dea6978b" + "0x01f8d3870c72dd9d5e883e82020508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc1493cb1f9cdc80f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b80a04007c1c4f6f6fc1c60b2d8dafa0d6a0d52d5ddf181b0bbfe369a92b133a35773a073a10d1f377d99aeee46b608507f6b2a52933f4c520d32a2c43dd362ff3e4f17" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x38a90f286b0a1fe34e7d3b9ff797c39789970041d2818e5adc11b91e0579537c", [] ] @@ -16017,27 +16070,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2d903ece7c308b988d585304235cb0f3bacbafb64ec0b62da27c1f77aeb18d76", + "parentHash": "0x3a66ebe86f285009227283701e0bd5d1ef913636a7a1331799de1c1faa5e4c29", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf75bf5befb9b72b7c11ca0f64b9cdb20ff4390f70955370f2cff744bedfaafaf", - "receiptsRoot": "0x19dc9bb39d5f6f19a6d2a4521d0630d23599b30a077d025fc8f7bc7bf57c719b", + "stateRoot": "0xfff28addd1b7fa8c13f670f43ee8aecf5fd4e8aea884117a513422e644e5b687", + "receiptsRoot": "0xc6a015ae06bab1f1d18ac5b6e54324d2b92aa4b0c32cb2529c66468a8d154fc9", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1fb", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x13ce", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x005a1cd86c8a2bb05874d5fd341035e7228067175a1c757b91f442dc34922a1b", + "blockHash": "0x062f4d4d65aba3e78d382b9f46e4d5542195003f96b51b865458dcc1f826bef4", "transactions": [ - "0xf8758201cf08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4d992d778a781294656d69748718e5bb3abd10a0a0b6df52cd6d5c870905e39a359ac9ce37ac8d151c60eae85736fe3c0e21d8d489a07655a80dc2c45e6713f4d40840a5cb8b3de31b4bc7592e238a41d75d3a4b9544" + "0x03f8fa870c72dd9d5e883e8202060108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c4d992d778a781294656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e865c3418b47b88e94c28956b326a799298fb44c62a7a6bb55fd991f7c0442ca83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0ed85242a312a75755e1bc8248d6b19e7cc43a61f86453fe3f6e5f54b361a7336a02e7e7870938cc996edaef7553435f345932ead2769411bb771f8dcd0f940ff2a" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xc19bcd1a95bf2edb1eaa8cf59fb23d053422845e57f4a41a2832500d1f415f5a", [] ] @@ -16048,21 +16103,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x005a1cd86c8a2bb05874d5fd341035e7228067175a1c757b91f442dc34922a1b", + "parentHash": "0x062f4d4d65aba3e78d382b9f46e4d5542195003f96b51b865458dcc1f826bef4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7ba3acfe7f78ab817ecc275982440c85e8ceefa241edf02fb5bda27d40715afc", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x28b12ecfc2cc82d9d1f91fc9f8c8eaf83039177a1c6bb969f957fd2aa14a2a51", + "receiptsRoot": "0x62b1a196f913cc42183a51458d294e07675ebadf511c3d4a05da2e591ac137dc", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000200000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000008000000000000000200000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1fc", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x13d8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9e7ffa6ebba334b9810de0937096a05f054a43eb03621ca8874411e5ddaf7543", + "blockHash": "0x41870d7fcfb0ba5dd5425e3a3302b3e93025132d1a2776a249a88c572fb6be05", "transactions": [ - "0x02f86b870c72dd9d5e883e8201d00108825208940c2c51a0990aee1d73c1228de1586883415575080180c080a09b2154776de3ec96562664c4cefd5a0e42c48789d13b04c1ee7fc45c9d695fa7a067389d062cc02c3a9500d08b206f4f8bc0363aa685b8b9a8a5ef4a81eb82d4d9" + "0xf87582020708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf82c55c40f1ff9a2656d69748718e5bb3abd109fa0d38c5217a65679581f1f3dc5b08806638d23232ad739fed58056327a46151846a05ce9944be58bb04737796bbdd217c8649ca8e154b545e08f7fc383a67ef4ac22" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16079,21 +16134,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9e7ffa6ebba334b9810de0937096a05f054a43eb03621ca8874411e5ddaf7543", + "parentHash": "0x41870d7fcfb0ba5dd5425e3a3302b3e93025132d1a2776a249a88c572fb6be05", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x87e1f05da062baba064a0625b957dd18d2afce4914e5a57971dd4c08b789aa98", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xac3b461b766b9c6094c55862cced1cf04309a8059ebdf92ed0460f2c24618b79", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1fd", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x13e2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x68b50078b3394b06d6ee3a3b12462a38eb85286023c07d90e290ba808b5da702", + "blockHash": "0x7c13316eda73749098cf4575409649054e1835f58d626491b4a4b95f2a8a0564", "transactions": [ - "0x01f86a870c72dd9d5e883e8201d108825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c080a0214ea359664d05afcaa80e32b3381041386921a2fc2959dab6b640751fb38ddea07d738ad38513b5651ba8bfc08cb21557223086eba81ccdb9f19cd934f59134a6" + "0x02f86b870c72dd9d5e883e8202080108825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c001a037494e00581b8418c83e72d08293e639690b050b0978070b8479021d3931d298a067014bfc84b271a6596c0aff08cafca2f0ba275c2f67671364b7ab72a43f25a7" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16110,21 +16165,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x68b50078b3394b06d6ee3a3b12462a38eb85286023c07d90e290ba808b5da702", + "parentHash": "0x7c13316eda73749098cf4575409649054e1835f58d626491b4a4b95f2a8a0564", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x633881f7142b2012e0c6bad7bc4c51e40679d0c01c8c19ba3aa1608c96c69eaf", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xaed39ace72d41eb2e4eb2770635e8249e9c6c4dd278a6c31c4681079395ede37", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1fe", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x13ec", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbae08b3b1ac544135b3a06fbaafb931229a99d0e47434318580146086ce0dab3", + "blockHash": "0x5fe375eb49f8ae346cfc274905e352f9d90b8e27a9557c111a4da925da1ec952", "transactions": [ - "0xf8688201d208825208941f5bde34b4afc686f136c7a3cb6ec376f735775901808718e5bb3abd10a0a0e917c71f21dfb1b319d11f2bca6800be74fad51f8e6f728460a9ac8bbe27827ea029942083348d7b4b32fe2c081b415970337e60e99675ba18590101fd3e5de0d9" + "0x01f86a870c72dd9d5e883e82020908825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c080a0fa223e2885966d1ca3ceecec6f277bd350ee2f59e9ae82d53fd88898ec680c49a0538f2f37378b8cd670d70e8b36ae9ad172e94305ba98d641e722c8fbf1712759" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16141,28 +16196,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbae08b3b1ac544135b3a06fbaafb931229a99d0e47434318580146086ce0dab3", + "parentHash": "0x5fe375eb49f8ae346cfc274905e352f9d90b8e27a9557c111a4da925da1ec952", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1b77c1aeefa6f0f0c54074c34f4036d6131bbd246208612b75f6b370a32dd2d9", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x8baf3ffb404de68289de0f11633ae838022c5b3ac5bab2cd3ac3c795e34f7d87", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x1ff", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x13f6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x91711182ab4cdd63dfaac9e02b07f4d49016fe1ac744ff90843bd1f52f893761", - "transactions": [], - "withdrawals": [ - { - "index": "0x2d", - "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", - "amount": "0x64" - } + "blockHash": "0xb2e74edc8a1efbf6260ee1bab5e093a479e2f7e5cd4b857567c0f375363e9620", + "transactions": [ + "0xf86882020a0882520894717f8aa2b982bee0e29f573d31df288663e1ce1601808718e5bb3abd10a0a02cfe24f61eb9ca2f74317c6223b681e61697200e548fc4b8cc1b7f4350542eaba040ba7a29dd832f75d2dd4416b98bda4470f633e72bf8bcccd52c3d767bdbec09" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -16177,23 +16227,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x91711182ab4cdd63dfaac9e02b07f4d49016fe1ac744ff90843bd1f52f893761", + "parentHash": "0xb2e74edc8a1efbf6260ee1bab5e093a479e2f7e5cd4b857567c0f375363e9620", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe7d3338604fdbbe66dc8f1bb3bd9b8d66ef7f1659671827316f61b261799b4a5", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xc8185aa95f2877e6faf46f6677254001b6b49c793a272a024d5a656fb4fef25f", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x200", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1400", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfc6438ea7c3138aca8cf840a05aa7e627ecea40cec8d6166406f98449ba6182f", - "transactions": [ - "0xf8838201d3088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a06c77e9d2b020f89b08ac3b941ced9fa71750062c2023d25ffae22a3b62c7ee96a074e9fc4218a4af7745759a2cc801d188b8c126cb0851c0d521774e4f6eee728f" + "blockHash": "0x66e753584038f784cd85643a76dbb590005f0704537ac697c648abe7cff660cb", + "transactions": [], + "withdrawals": [ + { + "index": "0x2d", + "validatorIndex": "0x5", + "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -16208,21 +16263,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfc6438ea7c3138aca8cf840a05aa7e627ecea40cec8d6166406f98449ba6182f", + "parentHash": "0x66e753584038f784cd85643a76dbb590005f0704537ac697c648abe7cff660cb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce3babe7367acf2a20f05e38f7ef7ab85e308db3405803f7e9d83b2312d9bf70", - "receiptsRoot": "0xe764d433a3fcdf26dd0789611144e14219aec816ff6b5d755df8cef4a4e23783", - "logsBloom": "0x20000000000000000040000000000000001000000000002000000000000000000000000000004040000000000800000000000060000000000000000004000000000000000000000000000000000400000000000000004000000000000000000000000000000200000000000000008000010000000000000000000000000000000008000000000000000000000000000000000002100080200000000000000000000000000040001000000000000000000000000000000000000000000008040000000020000000000000000000000000000000100100000200001008000000000000000000000000000000000000000040000000000000000000080000200000", + "stateRoot": "0xd5e8265bcaff3797a87a90c25aed521b31e6a692f1c97c44fa7f789b515ea1f8", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x201", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x140a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd7d6cfbe9f350fc0643592dbd7a2a98639f92b0183cee49ef6f5d99aba72b47a", + "blockHash": "0xf4d20bce9d8457ff1dd755e1dfbbb89c7bd0ad0a4cbbd507a20a66a75ad9223a", "transactions": [ - "0xf87a8201d40883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0ec40fb21e72abbf085d2b8cb926a287b4e68de48301c538a60be1d31156b50fca07c6315ac48acc96969968e60e283fd046e31c32811865d5d3302389bca84e589" + "0xf88382020b088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa02d1a66d116fb0a777bea6eb147dc41708a0bfd06e8512b1d1d3c78ce9f0f4dc1a03076348c6bb81346bc655312f2e478a19d42ffde18ac9946c59edcc283939a6d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16239,21 +16294,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd7d6cfbe9f350fc0643592dbd7a2a98639f92b0183cee49ef6f5d99aba72b47a", + "parentHash": "0xf4d20bce9d8457ff1dd755e1dfbbb89c7bd0ad0a4cbbd507a20a66a75ad9223a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa176a68ba3c1ecb49e1fd1acc1ed5b300b0cefb6c520e6d88155b92dc2d8d621", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x2a3bd842a1a1d8cd178073262255c1ea79d7f6632ef5968ed70ed1eba1c4dd82", + "receiptsRoot": "0xd48e8e5d94ee6d26c4943db2f03d6a24e765d768a78aeb663b7e269221b08db7", + "logsBloom": "0x00000000000000000000000000000000000140004000000400000000000001000000000000001000009800000000000000000000000000000000001000000000000200000000000000010600000000010008800008000800000000000000001040000040000000000000000000000000000000000000000000000000000000000000001000800000000000010000000000000000000000000000008000000000000000000004000000000000000000100000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000100000000000000000000000020000000000020000000000000000800000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x202", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1414", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe42d2c63e650101bc54d149c19d67b78ec05431cfc15134146790f1da71548b2", + "blockHash": "0x8ccbef8f2661bcf3123cd1d94c22200a4ae5f196f22cc0a75a24a2eb88b18acd", "transactions": [ - "0xf8658201d5088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa07fa54a77142f2ca3c948e34cdf94db1d9ea75232b08ddba064f58d7d1b4081d8a06f6b19500cdfe707a22f0febdc08d281ef27b87b2522194e5a02745c61698839" + "0xf87a82020c0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a007a2f5b051d9a1041a91a371c1cbc41650761498f137e6eb6e36612176de65d4a07611eb038c947ea2b85933da24eb375ac1fa9edeedd695638c206defa8c67d7f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16270,21 +16325,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe42d2c63e650101bc54d149c19d67b78ec05431cfc15134146790f1da71548b2", + "parentHash": "0x8ccbef8f2661bcf3123cd1d94c22200a4ae5f196f22cc0a75a24a2eb88b18acd", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xff3d8349337fdd2205778b8a03c55b0313cf6a59c855ab9d98f7b9716194773c", - "receiptsRoot": "0x246cbacfcb463724b93536f5433ff6394ba997b12924adeb1ee57f771700bacd", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000020000000000000000000000000000000000000000000", + "stateRoot": "0xa9cefeaea24bd9d0c3aa07342a5f53092b8b1144869aa81090e1e6d95e0b1d06", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x203", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x141e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x718c2451b8df916754650ca5d9a3fca98e0f9209d41cdafd30d3ee9343b12216", + "blockHash": "0xbf528a0231aa3fc212ff82fbc410ffd8e8e2191e9af0a3fbc6b5c246cb7ac8aa", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201d60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cd04c9c422abfc528656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a039410f5a8f450e0b7fe63aa93e214a7c5cbe78786c815ebc926f1e8a2a14f4bb80a07951a771241a4c9da56ec3d101b386c01aaaa5993f05cc6d824a1c99bb7bcb8ba07a9576937beaedc82156293b534c1e2624d7dcb41d2c7ac5d587340d0458fca4" + "0xf86582020d088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a070534015db87e0db8903f2cbc9d465d1c6c44e431d2e3490852888903f9b8096a029db6e5b30f48e7e3229cd47b4e8a76191eb8705548fe163cf2fafaeb6220d6e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16301,21 +16356,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x718c2451b8df916754650ca5d9a3fca98e0f9209d41cdafd30d3ee9343b12216", + "parentHash": "0xbf528a0231aa3fc212ff82fbc410ffd8e8e2191e9af0a3fbc6b5c246cb7ac8aa", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x298da922dad8f43ce69c938556232f0eed7f747036e3961ebb5476616577f79a", - "receiptsRoot": "0xbd98f2dc2a79fd7f904ca89c03703911ce6a2f9ae74bbc57857af94b74244656", + "stateRoot": "0x80aecb6dbe2c7a75962e4d89ce833f85f3af8e70f537287cda1168f8e23de9e0", + "receiptsRoot": "0x078019fe2cc83afe1b116e5dbee7fceb7fbdeaada494157bffc7bef8a2e3b5c2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000100000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000010000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x204", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1428", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x64f5dc426951c8d5c389bed1af605f9101235dbfaa4822f2ba83bbe9973be25b", + "blockHash": "0x03938f3ef2d6d88872a92445d63c6617c2ad1c6729900a8263f19ec9d03d5106", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201d708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cff6bcf94f901ef8f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e82380a0fa698bdc90fd08a9f3f1ab954bfe1236b8534f57fe8fb4f5ddd6885e9bca938ca06e75008087626148ebaa8c850497b8511af50ca8a5dd45524cfaec940b29aa5f" + "0x02f8d4870c72dd9d5e883e82020e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cff6bcf94f901ef8f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e82301a0954945afebc39cb2f1f0a6504e5606a4db83e50f4ea6fdaaeae212a30f54919fa0095095c34217ff20ae8d68a0a117249ee30fedf2b8bf4c0fc8a9a87699c93cc9" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16332,29 +16387,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x64f5dc426951c8d5c389bed1af605f9101235dbfaa4822f2ba83bbe9973be25b", + "parentHash": "0x03938f3ef2d6d88872a92445d63c6617c2ad1c6729900a8263f19ec9d03d5106", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xba26112fc1c8049c8f452bfc2c8f32fb9a675a345e25b5ee216d461df7db6203", - "receiptsRoot": "0xc927ac9f5187e2207bffcd8b6530ddee8970370c321c33c3942a120de068d618", + "stateRoot": "0x30356bd77ddf676a5b105b904496f703c42f4be1ee4e1f1dba2707e4d2bb1e87", + "receiptsRoot": "0x6c1ba699b63b83808505871fe095ee486063a79c874aee1b239cbe441298869f", "logsBloom": "0x00000001000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x205", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1432", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1841a4c413f59d37b93421bc6d165288e0546f1261e25357feae9c96a66402e3", + "blockHash": "0x76b268f5c2c12013dabdac36f0d7a87aeabf6d0b9c66afe989de308e9d8cb0ea", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201d80108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cf79d15aecc7ad11f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a0541fee253cfa9457ab460ad9b861e6d894b303ac93e8dbb0d9222e9d2f025859a00eb8085ea838b18113febf57834095a4606646d9694b290e133d9acc7a523491" + "0x01f8d3870c72dd9d5e883e82020f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf79d15aecc7ad11f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a01a0a449b48d32bfb71a61dad3295c6857ad88ccc3e4c3954c52bdc93ae4f4f282b4a061f1cf53321cb02f0ac4067101d21989a51f7213089735ff85668ffd5653e20c" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x5f4be0643a56b90ece82db7ff08963e8d9796840afd11d6a1d0d39b4498fa26e", [] ] @@ -16365,27 +16418,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1841a4c413f59d37b93421bc6d165288e0546f1261e25357feae9c96a66402e3", + "parentHash": "0x76b268f5c2c12013dabdac36f0d7a87aeabf6d0b9c66afe989de308e9d8cb0ea", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7d4ddda2b28be342f1458924b4f860e59a0cc00953b848d7686827dde5f3d514", - "receiptsRoot": "0x5a656d8918863a21cc2ce891040bb31b0ef68b4f6fe333b63dbc9eed8d97ef1a", + "stateRoot": "0xc5d2728bde5d000988fce58ac8a8d6b12bbc29fee6e60fb5c013ee53332bc02b", + "receiptsRoot": "0x0f724fed44b731282bd5b6bd8e2afc72aaf68431ae987ed7f446f6a457d3508d", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000002000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x206", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x143c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x289f40c44da44e6d545900ecfab81d0d86b9756e74d6bfa2fb0095cf28a93cdd", + "blockHash": "0x9025f8fd00f67b94a9b19712e0ff275ddddf0638f35bcd818639f440daf3d392", "transactions": [ - "0xf8758201d908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c777feac9ca0bfcc3656d69748718e5bb3abd109fa01a2065ee360d4a5bc46515858e6464c6529ee55ba3c714fa94b8a90bed4dc6f4a0425c529b6e0b928072abdf1f6b0fbc3f329bc68d80ea1f9a88e89fb672049174" + "0x03f8fa870c72dd9d5e883e8202100108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c777feac9ca0bfcc3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ec200bf1cc6a2c5d58960dc3476cc4794ba1a9fca2ac3d09b63e7811b7299c3d83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a01c781f7fd731cd5eddd7aa29ec280813a90464401110f8dc56d109bd85b01f35a024d6dfa68f4658f54bdd52385ef635e2e8463e56b8cb91065585d14729bc3b22" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x15b308f32252d593d6f48353f3217f10c391d03cff6eb9742f3bccbe6d1d6145", [] ] @@ -16396,21 +16451,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x289f40c44da44e6d545900ecfab81d0d86b9756e74d6bfa2fb0095cf28a93cdd", + "parentHash": "0x9025f8fd00f67b94a9b19712e0ff275ddddf0638f35bcd818639f440daf3d392", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x21cc4bf891fa35781985475468fe6e4973891cee2be5ce2a40512413e21c911c", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcf4b63f32e658014e45a0e3f2016ac8b8ce99828d31100654db894e3b07a1722", + "receiptsRoot": "0xcfe99c24117ebf9a03d23bc0dae58444e2d52cb95e80e4429d02e38881c6b2c3", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000004000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x207", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1446", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb80db8759f920638458bd60e8f97e9a0773970c30941cf2744f4db475b5c53a8", + "blockHash": "0x6d6253031c30b55f6529d6543f837195d883ed16bd214ae6b065668651295a7a", "transactions": [ - "0x02f86b870c72dd9d5e883e8201da010882520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c080a0bd058792f7ad1149ac662402304d2f4aa1b9fc78836dd7332185356a4059b763a062a11cbb48aa986174da2d746dad05ae5b4c0292f9782adf3cdd65324ff7f7e5" + "0xf87582021108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc6f4832da197a358656d69748718e5bb3abd109fa0aabfccd924bf15abd9fdc4aaf99c9ea89b8c0b52c3949ec070eb4b05b5aeaecaa0159ef7ad8519aab9cb77e51f407fd99b95fe9e28b678cd5f62be4cf4844f1674" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16427,21 +16482,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb80db8759f920638458bd60e8f97e9a0773970c30941cf2744f4db475b5c53a8", + "parentHash": "0x6d6253031c30b55f6529d6543f837195d883ed16bd214ae6b065668651295a7a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xdbabffdcf20b39b47375cb2813dc7b5ef1386fd2fedc073f4a39269326eb42b9", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xd70315b88320ba6df67cec0d83140174c0729e61b0e3651f1aa928e050866982", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x208", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1450", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4280ca715e955153245aa296395bd7f179a13606f4e909119b1d58b7b0457e34", + "blockHash": "0x3d381099b916c9111f0a6ef929f91814a584f390a9032879d7e41c6eed3f4870", "transactions": [ - "0x01f86a870c72dd9d5e883e8201db088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a0a3445dea2e057243a7cade92be94c8a047ef1d7e225e0903c7cc1d284d54837da02c5353c9bcd1e1bda954dedda00d7a487916882e4924ebee445a577cdc37073e" + "0x02f86b870c72dd9d5e883e82021201088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a0ba8bd8b5385767687d7077ee8611cd17ab3d8d5c11c833a600060b9e16dc6dc0a0670a8a4b83b407418808abdb824f1659c116cb2b8cb0b88992afd1a494108731" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16458,21 +16513,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4280ca715e955153245aa296395bd7f179a13606f4e909119b1d58b7b0457e34", + "parentHash": "0x3d381099b916c9111f0a6ef929f91814a584f390a9032879d7e41c6eed3f4870", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xaf7ca220478eaaa309220cdf2b29be6989118676c4bb3605ff4e06d3f52cebce", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x2d3763013786aeb5174bbd5da31e61b80c259a65693381e3effefd0546c3099c", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x209", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x145a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x56c95098c7c859b8b786bc2f776f739ba109a1d662beb8545294938b9ce5ef4f", + "blockHash": "0x915d521f633b9e30bbb9abc8024728d9f1c69a3f06fe8f490c82143ea04d2e52", "transactions": [ - "0xf8688201dc0882520894717f8aa2b982bee0e29f573d31df288663e1ce1601808718e5bb3abd10a0a0fa276d4cb8eca10e037988083dc9ccc88d525b2e0103bbe0595a1cf7ae6cdc17a0430d478df942ce08d2cbff40008fa68efee94bbbf2d02a9b8b406b580a215ecb" + "0x01f86a870c72dd9d5e883e8202130882520894717f8aa2b982bee0e29f573d31df288663e1ce160180c080a00d216b3a8f229ef2ce66b38ee57655db833353f59ad7ffed532ac584b9b5f5a9a04f929c3fd6020f1d5fb70bcc02bcf5dd8387b927cb1cf87e83ee3842d113d895" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16489,28 +16544,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x56c95098c7c859b8b786bc2f776f739ba109a1d662beb8545294938b9ce5ef4f", + "parentHash": "0x915d521f633b9e30bbb9abc8024728d9f1c69a3f06fe8f490c82143ea04d2e52", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x27370273d3893ce3bbbbeb8bce070f64c2ad3ddbf21b5b91ae05af0ca5a51a80", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x97e710f46d4a4060e4d9dbaef0a028ee439812a6b45072ada40e7ef8149d4ae9", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20a", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1464", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xed614b855d979afefa3c40027ca4b6fff89a1467173e85302b48a478bfa7abad", - "transactions": [], - "withdrawals": [ - { - "index": "0x2e", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } + "blockHash": "0x863e79fd3c6376662be319b3ef0eb05283fc9f713417b7856a7c8615f977d8c9", + "transactions": [ + "0xf86882021408825208940c2c51a0990aee1d73c1228de15868834155750801808718e5bb3abd109fa0463b8a6f4391ea41bc550df58b0a7269723d27f89ea39503e185b29825ab27e5a00da136a3737caa05c897b1e9394f0b603c050b6759b03a7a3ca98c00a1a8fd93" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -16525,23 +16575,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xed614b855d979afefa3c40027ca4b6fff89a1467173e85302b48a478bfa7abad", + "parentHash": "0x863e79fd3c6376662be319b3ef0eb05283fc9f713417b7856a7c8615f977d8c9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x02aa4ef008879baf8013e7423aec03edce2bb972deaed85a328fb3091b4ed15e", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xa593c2a149e212398ba3eec8f8eeb490ca7a1c1933946666e69cf2107368dc35", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x146e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf379747713313c3ef604ea0d5446066edf0b695213acfb86388ba46e6c926bae", - "transactions": [ - "0xf8838201dd088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a023dc415db791f292cabc61a8b7283f85bce4e465f6874575754d609e1f3ce941a0700ac3dda3383581af5d6955cd810cbb7307ec7137ded66c03b7e22358454d5d" + "blockHash": "0x92017f3c5f46fc656d0b2279ed722c9ee2fefd6aaeef49a9b72a7f3988fda54b", + "transactions": [], + "withdrawals": [ + { + "index": "0x2e", + "validatorIndex": "0x5", + "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -16556,21 +16611,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf379747713313c3ef604ea0d5446066edf0b695213acfb86388ba46e6c926bae", + "parentHash": "0x92017f3c5f46fc656d0b2279ed722c9ee2fefd6aaeef49a9b72a7f3988fda54b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0cd299e9c060969fe6593b7ea08a63355e4280a3f2922270ff3095637dd7948f", - "receiptsRoot": "0x2cb4423ee880ff1ea3b8a2183d7f06169300ebc9b6fe32056fbced32f27b1be7", - "logsBloom": "0x00000000040000000000200000020000000000000000040000000000000000000000000004800000000008000000000000000000080000000000000000000800000000040000000009000000200000000000000000000200000000000000000000000000000000000000000000000000000000002000000000000000000800000000000000001000000000000000000000000000000000000000000000880000001000001000400000000000000000000023000000020100000000000000000000000000000000000040000000000000000000000000000004000000000000000000000000000000000000004000000000008000000000000040000000008000", + "stateRoot": "0x4256a8cdaa5d1adaa4fa6f73a61ecb3c4e0e505e0f8b79a76c6e966bb32f6295", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20c", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1478", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x71345ffec2ba388522c6703f19f24c5af1eb742a44d2ae6749276739d138912e", + "blockHash": "0x5b54670c143ac7faa7dd65ddb7e3b7c85d6932c049e071be3a0f9f51ee3b889d", "transactions": [ - "0xf87a8201de0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a05c1d31b87f32db69d5b9d2e257a848d4c1cb58cd4732960d72e270da0683e93ea01a6781141f8fbb42eadaa7d0a2a57590405d3ffa3890a0f7c648769c3989100f" + "0xf883820215088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa0b15869920d79036b50d162705926df5f6143bca108327d7fdef8c0c15b1aa13fa024bdc8a317f2fd9a864ee29de1674c86bdc4b12de94cfc724f0eaee99aa0b73e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16587,21 +16642,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x71345ffec2ba388522c6703f19f24c5af1eb742a44d2ae6749276739d138912e", + "parentHash": "0x5b54670c143ac7faa7dd65ddb7e3b7c85d6932c049e071be3a0f9f51ee3b889d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4ea5649d17703d51dac0fe529718f0f0cf21f44cc8d509d2543d3d4f90d12719", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x24d01ee8a1ac915a330883c94b58c0d88104e52919c8a6f47150046d2338c7df", + "receiptsRoot": "0x357ce885261f1ec04a6bd7de15cbe2cd9ac6c89e882b560c78050de4f04f90e0", + "logsBloom": "0x00800000000000000000000000000000000000000000000000000008000000000000002000000000200000008020000000000000010000000402000000800000200000000000000000004000000000000000000000000000800000020000000000100000000000000000001000000000000000000000000000200000000000000000000000000000000000000000000000400008000200000000080000000000840000000000004008000100000000000000000000000000000000000000000100000020000000002000000000000000000000000000100000000000000000000000000000020000000000000000200000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1482", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xc73d56854a544ce56956bab6d4ffab7beca0ec861ff5cf5906aa2aec20682c75", + "blockHash": "0xdcc13010415b57cb7729b370840b98797aff553ee150d53acc57944d6880476e", "transactions": [ - "0xf8658201df088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa01720814975890f03e1a3279eb0d5af0541a4b8e217f481890cee5a0dd8ac4023a02843cd3100592f8bf4347b31728aa75f3f75cea374b67f80d3e71527fd65c016" + "0xf87a8202160883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa07eb9ff8d5e16ef4fa6411ab271051945fe0d16680e8c9cea42f481b11c3a98dba0180958212e5b37bf6e3ae590abdb71876d9cfb4cf5734186cdf2ead9ee9237c4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16618,21 +16673,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xc73d56854a544ce56956bab6d4ffab7beca0ec861ff5cf5906aa2aec20682c75", + "parentHash": "0xdcc13010415b57cb7729b370840b98797aff553ee150d53acc57944d6880476e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x190daba25ceaf68c12492a2d923af7d8c96b4afceebc901351efb217d9775367", - "receiptsRoot": "0x10047deb371c2c9cb54cd89eb2eab6b6797c5d35722426601ce4389b6de76f54", - "logsBloom": "0x00000000000000000000000000000000000000000000000000010000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb8ceb7172e8b987932f130ee715a174319067b41534f6519d42c51bf08c83a22", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20e", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x148c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd543d5b576ae572d9996cd3d05295368b201e3c618ae5da30fbec43cf24b52a3", + "blockHash": "0x2d3c7ce06501bbf1916b0a41b645130ba77f69e25b150354934ea8ea0cb3b012", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201e00108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cc37096f89eb8687f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0075a739ccce514f063220aa4bb66f08a7966189b0f24a2c5ad4692133d7aa6cb80a0fb8b4fc683ed078751d7cb16998f23fee9c6c518cb6cb7e53f358166b70be89ea01e42a4c3032a587f5d47a21bb164b61c3dea45c85ce2135315c43ca4cf50b464" + "0xf865820217088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0668c188b5f045222d9eccc2032de6dea0afbea32eb584ff4e55b5e593f691d6ba0420ee8705676a5551e2147d23444f2ac1f699cd379b63dc3d17327874758f77f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16649,21 +16704,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd543d5b576ae572d9996cd3d05295368b201e3c618ae5da30fbec43cf24b52a3", + "parentHash": "0x2d3c7ce06501bbf1916b0a41b645130ba77f69e25b150354934ea8ea0cb3b012", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x69e05db1324cc8ff7d7db4d31bc7d3a3c2402ca7111bf4f5392dfeefc6197a4a", - "receiptsRoot": "0x03a983607249a979042b87909c438e5c752cc71e90cd1d80608242f9c900d81a", + "stateRoot": "0x904a1249204b256c8f6954c075b83c8de19e30575b1e5208ac33d97ce882ebd5", + "receiptsRoot": "0xd95afa4c4613559483642d24acd6e5db40206d887e6964bd5c27ecdbde7a3fa2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000800000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x20f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1496", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdba4322406050555a1a8cfbae1c6fd627bee7757384059a41bfd5b6147543f53", + "blockHash": "0xb8489443b8bb965ee7e0cc42e8ff8c2467d199cd09434fb394df3f34a2a985b7", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201e108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4dd208cc7281960f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f1880a0a1b21815f9c5e92dc5dd6d6de2de28a6cb43d213da883f52b3713b5c82772fa4a0799b9eab259ac6b761d6d5dff843ccd407f5fc75d73cf3048db0ef83514ddebf" + "0x02f8d4870c72dd9d5e883e8202180108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c4dd208cc7281960f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f1801a0aba17b5a65ce9a852c8ecd7c479fd06aa9e1dffa7f9b73007599b84cbb0b6d73a060f6c1e699925c3a40cbb5d13ea0fb9554065d03f4d1158d25769ab386cdba54" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16680,29 +16735,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdba4322406050555a1a8cfbae1c6fd627bee7757384059a41bfd5b6147543f53", + "parentHash": "0xb8489443b8bb965ee7e0cc42e8ff8c2467d199cd09434fb394df3f34a2a985b7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6eb258534e7dc87b92c21e0b551b5ba4b7cbe61220ff88cac3f745c57ced124e", - "receiptsRoot": "0xe78cde3d52f87a1ad382ccdd7c7856f8d373afb165be7c463efcb1996196ceab", + "stateRoot": "0xd60ede81eb19a10fd03c3600b55a9a5cdf0110f27da09dd6891981a5d4e129aa", + "receiptsRoot": "0xacf1ab751527f15fa748a4689f1123006cd24b65daa0e2713f8f364742dbe6fc", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000010000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x210", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x14a0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9eadaf49e03a16c9c7cb8d2ea59c3285d7530750a462d6a9338e9a9e730b1055", + "blockHash": "0xc4194a2d7270901ff947af6ebd80fa701243344f704f832880455f4041285986", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201e20108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c6892c905221f3788656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0ad577f0e6c48f80b38cd100b0209f429072e28e557bcd66fdefe6218dcdafbc9a0382bce4cba9056329b00ca3921f927c3ca90a41f36a3f3e195f3b4d1e2161824" + "0x01f8d3870c72dd9d5e883e82021908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c6892c905221f3788656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df01a080f0928379dc5edff0f44537e1b8a3b6c2225d9551b308815ae44b233bb5e34ea026b23cf8a1ef2f5fd5a5a299be0664512a45761a13130800bdc3cd02d26a0fbd" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xb9808a96196fba3329eb714aa00743098723d9850510689ad18fd6952b655882", [] ] @@ -16713,27 +16766,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9eadaf49e03a16c9c7cb8d2ea59c3285d7530750a462d6a9338e9a9e730b1055", + "parentHash": "0xc4194a2d7270901ff947af6ebd80fa701243344f704f832880455f4041285986", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfd8541477e0d1ae87c8d86a53a130c1a3dca87b079202aa93d60b191a75de382", - "receiptsRoot": "0xbd9775274f3b90081fefb52407bc7b88acf25c5822271cc5b6fcfb34878e391c", + "stateRoot": "0xec9e01a9a015ef87e3b2d41db50f242fcb1fc42f17e112cc7b9672d17cd4f9e7", + "receiptsRoot": "0x00fc1c9c0d4279a6fad522a1397aa4bcdb88cf8075c1ce2a0a0eb462fed5ac88", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000002000000002000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x211", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x14aa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xeefa15b3aa7fbee117a78b61a365f6e38b6d8ae21482bc2eda241e637d43af8a", + "blockHash": "0x1d01c2348f9ac6b46cb793467df238a9f23c29c1d3de9e454bc61644705db054", "transactions": [ - "0xf8758201e308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c315c130cd091bd0d656d69748718e5bb3abd109fa00783dd9ccbdecdb119bd9f6c0fc409abea3f74be77e87fbf7452de4b522b9db0a00a46e1b4c79bbfccd0c4c1b3966b26a26e5dac23650d62371e8685c2914d7db6" + "0x03f8fa870c72dd9d5e883e82021a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c315c130cd091bd0d656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a009b79212fdf6dfcd322d6aabd5ba752b962d7e575cf299112bead28ab955f4c883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0c715416384ee2899ec119959a1682f21aa8907d3eb84f387b6ac74f2a83f30b2a010f076d8bede6a714d02e8b27bbd295401c65e6e15a733e0f6ab7c54aaa92b82" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x3cacbae26791d03a0ba1bec3ba0599219257c88708b022bbddb7e7673ef818e1", [] ] @@ -16744,21 +16799,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xeefa15b3aa7fbee117a78b61a365f6e38b6d8ae21482bc2eda241e637d43af8a", + "parentHash": "0x1d01c2348f9ac6b46cb793467df238a9f23c29c1d3de9e454bc61644705db054", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x465a36ea30cba123d3b7913756c9c00d129550e958bfc4d6b316d39048c408fc", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x09fa5222cabc90d86f87f8dd06feb219be169eaaa0d1985b4266aa36854a7052", + "receiptsRoot": "0x5a71db43e13b3a52004a27880670d67a960357953f6118d42eb1e3d72b26d372", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000010000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x212", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x14b4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3c7d782eb5bbcdd254bbdb120e432c90d9b0510a3c7e64507ed2c82fc01a2a7a", + "blockHash": "0x7cdb5360f32a30019bf96d2ea2034810820d065f655f99482aa59696b371afa4", "transactions": [ - "0x02f86b870c72dd9d5e883e8201e40108825208940c2c51a0990aee1d73c1228de1586883415575080180c001a0f2cf4a1cc75a89cfc63c40d50d28eb5ca1cfc27dc639bb63cf27b8a550a495fca05c00f451e22fffa147a2febb5e19fcc67110fd7dae790449b0fb7d7123b73601" + "0xf87482021b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028caff8e65c5d46d32e656d69748718e5bb3abd109fa0f2a65c97ed86c5b4e2c278d5387dffb88aa8e21278258203337c11698baa8d2f9f50e25c1b3b57fab34b084be2aa9263723320189e1d295b9eb7212feb638ff3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16775,21 +16830,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3c7d782eb5bbcdd254bbdb120e432c90d9b0510a3c7e64507ed2c82fc01a2a7a", + "parentHash": "0x7cdb5360f32a30019bf96d2ea2034810820d065f655f99482aa59696b371afa4", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x262abcbb09739f0c4315c4f1cc05812ed8517ddb9490aad148028dc7fa469e4c", - "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", + "stateRoot": "0xb2f6e94dd715d7dc986869c5eb611f51bd51c4563201719bdbc85ec3e832459a", + "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x213", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x14be", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x56d781324e6bdab32f417adff9cc2b4c645f819184b323f47ec974574121b309", + "blockHash": "0xd17bc796f0ad66329bca1ca889a6c67406db80c0f43200fb0926495f409432b1", "transactions": [ - "0x01f86a870c72dd9d5e883e8201e50882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a0272979494bc567f4068b0a0045c47c7a4d5b61830336ca2f0b5dfb71b360b5b2a06e18389eef16507c32a65a33657d91c0c86ba494fd098e4597c8dfcda5adcdac" + "0x02f86b870c72dd9d5e883e82021c010882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a0663e9d8d81442374c9eb5bfc2c647f256b417216c932c3bf75ba31d2c4866b50a02e371666983865035d0b7c87b8fbfc55fd8c931a32a9b9de4a7dc84d90408092" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16806,21 +16861,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x56d781324e6bdab32f417adff9cc2b4c645f819184b323f47ec974574121b309", + "parentHash": "0xd17bc796f0ad66329bca1ca889a6c67406db80c0f43200fb0926495f409432b1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7a641000a828fc192ecc11aa311654b566eed5e1b3bc965c728d6e5acb96ef1b", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0xdf1f33d9acce87b5dbabfa935a37a51546b99e10166d15213dca15800609adba", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x214", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x14c8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x997c22b77767599b4d1f9f7d21ad9b34b1e13e5ba18986d4dee06d282e89e453", + "blockHash": "0xd8472a9633cefd2b65c8d169fdcc6737e60390ee74069eea5c6209c6e2ad1634", "transactions": [ - "0xf8688201e60882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd10a0a0a0159c130ac25ae9f757ddb7ce145902e9d9c6b2bca2367aee5c0c177138b3e6a06eb8a315be9419b53fffdc809106fe98042b1282ebc54139bed557f95d3cb9d0" + "0x01f86a870c72dd9d5e883e82021d0882520894c7b99a164efd027a93f147376cc7da7c67c6bbe00180c001a007a998646376bad827bdfa2b8be92733e00703f2ecb6cbf2254cf3f80a63245ca00291247571b7de6e4024d131f4fbf186f0f384105376661e0f504e389dc05eb5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16837,28 +16892,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x997c22b77767599b4d1f9f7d21ad9b34b1e13e5ba18986d4dee06d282e89e453", + "parentHash": "0xd8472a9633cefd2b65c8d169fdcc6737e60390ee74069eea5c6209c6e2ad1634", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7d0ac3c7e061d59804dfb4c844c4d6a6c3daf56fb399b9a693a08432128a377b", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xd30e3cd0f7be062c2b863f467970e432059fa882baf20e0f5004b6bc7f270ce6", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x215", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x14d2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x49223c27247cbb012c480dd78497ea761f0de37eab920e169067d710a6c697a6", - "transactions": [], - "withdrawals": [ - { - "index": "0x2f", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } + "blockHash": "0x619efa7e75625a7ebedc7f3f9399965b08abf5834485d1db46a18e52f18c31ee", + "transactions": [ + "0xf86882021e0882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd10a0a02c313c47f073d960dc06bb477f0d12cc143c04ab7f5f822856b697515b8175aaa01cce6e9a1cbf32acc375da6cbb5d6120a0fe6a55b61caec560b77b8f324b3e62" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -16873,23 +16923,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x49223c27247cbb012c480dd78497ea761f0de37eab920e169067d710a6c697a6", + "parentHash": "0x619efa7e75625a7ebedc7f3f9399965b08abf5834485d1db46a18e52f18c31ee", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x97d7c32f96e823071bd92e3ce789ffb7f71a577d045524345567215b20e9c5d4", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xedbfadfdf2d1f7d9ccb6865aec20bcf6488308e772821067fdc942762d129723", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x216", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x14dc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x09f9f3b73c653b5d3440ff550da397d5d6b4dd3e3297a2f2d3c5e67bb128afc9", - "transactions": [ - "0xf8838201e7088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0a65d61b55253835ba754891614405c576b15fab6aaedcf41e661ad09ddc3249aa01c58d6a0533b60d246426b0475bf951081ad130b8a4ecf17ca3fe45817bc54d7" + "blockHash": "0xc2b62f015db1c1d98d0614179d0ce92635a62ab4922a2faa0139119d3d63e071", + "transactions": [], + "withdrawals": [ + { + "index": "0x2f", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -16904,21 +16959,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x09f9f3b73c653b5d3440ff550da397d5d6b4dd3e3297a2f2d3c5e67bb128afc9", + "parentHash": "0xc2b62f015db1c1d98d0614179d0ce92635a62ab4922a2faa0139119d3d63e071", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x06e29a646e53e63f21496c4a3750ab792ae936c9f6aba8ef6c0b394c4162b7ee", - "receiptsRoot": "0x4dc3ce129c50f0f33376b2873180d30ad489254d84227440afda885d13128bc7", - "logsBloom": "0x00000000000800000000000000000000200000000000000000000000000200000000200000000000004000000000008000000000200000400000000000000000100000000000000000005000000000400000000000000000000000000400000000000800000000000100000002000000000000100000000000000000000400000040000000000000000000000040000000000000000000040000020000000000000000000800000000000002000000000009200000000004000000000000001000000000000000000800000000000008000000040000000000000000000000000000000000000000000000000000000004000000000000000000000000000000", + "stateRoot": "0x777b1a54c64e05fede625221c54318074a47d6c025c2ede671e8c860fa84a0b9", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x217", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x14e6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6e277d1000baa83809de9f5f90fc8a3387d1ff660f9a7d7857ec4c3e66f70d57", + "blockHash": "0x58bb373fbaddaa37a1fd35bfbaedfca10e720b9517932daa0041139db7285ac0", "transactions": [ - "0xf87a8201e80883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a02d4072f0fa61da269b2848af2a7c2301b26e411ce33bd229fc1147c4b627b49aa00316bbe2cee82df396f55967d0087d87803bba9f596022542d4e58b23f6fbc6c" + "0xf88382021f088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a011dd7fa5782307088d05ffd1d11037add044a77cb4bbc829bbb4eac634039afaa015df7b7332a0971fd7ddafb31de4113334576d8b7fa2f95fc38453974a0211d5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16935,21 +16990,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6e277d1000baa83809de9f5f90fc8a3387d1ff660f9a7d7857ec4c3e66f70d57", + "parentHash": "0x58bb373fbaddaa37a1fd35bfbaedfca10e720b9517932daa0041139db7285ac0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xf8d9694b5feb43df6c73fb0bd5319235826db3cc7e0cb14bdd5623a50bbd234f", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd5ed54f5fe309c1ac6a3939c3d956a15cd79ad3909229d68a47b8e8b59d3da0c", + "receiptsRoot": "0x2d9ff7a5d365e1d00478fa9158143b2e67b31c3a818e288be00a635c43a08b6a", + "logsBloom": "0x00000000000004000000000000008000000010000000000000002000000000000000000400000000000080000010000000000000000000000004000000000000000000000000004000000000024000000000000000000000040000000000000000000000000000000000040000000000000400000000000100000000000000000800000000000000000000000000000400000000100010000008000000000000000000440000000000000001000000000000031000000000000000000000400000000000000100000020000000000000000000000000000000000000000000000000000000000000000000000000000000800000080000000000000000080000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x218", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x14f0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xeacee55ad16ffef8f34262dd2351947882b5c327565581fdaece63fe35c8044c", + "blockHash": "0xc9e6ff8c4334da9106046cf0aa6ada5653c1c7e4e04e2625132bdf77159440d7", "transactions": [ - "0xf8658201e9088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa022c7b242e1ef059218eb70cf070b49f60caa6fa032bb8b8632f5f09d29f80c35a03c4ce2290d2679e8b9b97050a9ea8831fddff3867a0252c0cbc9ef00e4280e5c" + "0xf87a8202200883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa01f06e1d4129ab42e72bb52b1e9410b535dc6ec558097e4dfe2a33a19120c75a2a0695aca2ee3dd5f3c254de06e6d230556cc653d6363bd81a24fcb2069d3a449cc" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16966,21 +17021,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xeacee55ad16ffef8f34262dd2351947882b5c327565581fdaece63fe35c8044c", + "parentHash": "0xc9e6ff8c4334da9106046cf0aa6ada5653c1c7e4e04e2625132bdf77159440d7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd115c5969ec12b4c5bdc21f5d83d9579a719dcfb222d3ff0283db5e289d98a5d", - "receiptsRoot": "0xce729af5fa5f299bdcd0ff1a99fc476c251d9e0bbf22c3b46addefc7b85f9c29", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000040000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000008000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xbc96c677aad13efe3f2d8d067ad5a84db086d5144d2c9fb1d12e44d3cbfa583e", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x219", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x14fa", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd13cb1082077f93cf162c8868d1e2ddfa3987c12f0b4d17de8f4e456ba9f646b", + "blockHash": "0xd8c58761e29f93f85ed6cba366a7bf37793501e56beb1505083593cef82267c5", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201ea0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c07626586e3a0f1ec656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a09f5941a130f6c2ff98ec21bb2517998dc5c8512230dcb37ede3cb8a4694175ab01a0fb5fb3892fb8cd6a9be0f5b801786a8c79e88b0d9ef5449d56f0c98d185d7d2ea076ecbe90f25a389ad5def021d71350df29f6b730378b85ccf791a8f44c2ac96a" + "0xf865820221088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a074883c6fbc22c51da2652c7b3af7a2ba5c22717e5c9bf833e606ea95fed9f6cca0764930ed2fc298115a761a3b936ee4e72f4bc48a5410a3a63c536078177d9734" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -16997,21 +17052,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd13cb1082077f93cf162c8868d1e2ddfa3987c12f0b4d17de8f4e456ba9f646b", + "parentHash": "0xd8c58761e29f93f85ed6cba366a7bf37793501e56beb1505083593cef82267c5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x81dc32740002a865b0568ecce82a55ff87f3102900c79b2ced81f0436469cecf", - "receiptsRoot": "0xe60b0698c810d1736de5e101f9ef3c378d764079246b845b4b3b2497748b7adc", + "stateRoot": "0xe192da5f688bd047ad26395be54b9afa59d532d45dbd46bbe452eff570f6e4ea", + "receiptsRoot": "0x4fae97195c53d94669ebdff34d0aaccc4bac74fce21c7635fa7c743dce5124f9", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000080000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1504", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x323fc2bb76f6f190369ed67f4eed60233e9ace45b6b77a8a545147f6e2a12826", + "blockHash": "0x1d090490f42aa267658565f6ca68e0d230f7d6e2c2c850276c5428f2e6feac7e", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201eb08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c983c2551657b63bc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed701a08a1e2bea85d17cc28b85ba5aa259d8ecd80f18f356953fd6700bb69a1c4db7b4a046a33e75aa1e0b4dee47a01767b6dc71865ce4520ea58069ffe116cb781bafab" + "0x02f8d4870c72dd9d5e883e8202220108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c983c2551657b63bc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed701a083edf46568e48b42edaeb79d3e8ee7b0b66102c9a0c4c43ffe5f6c9fc128ead0a063242a2130fb3d7bf7bb7ecba5dcd7cbf88189e4769018a0809e66ec7a22a95a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17028,29 +17083,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x323fc2bb76f6f190369ed67f4eed60233e9ace45b6b77a8a545147f6e2a12826", + "parentHash": "0x1d090490f42aa267658565f6ca68e0d230f7d6e2c2c850276c5428f2e6feac7e", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x747e7773e984de4004d7c2fc72ed3d964cff24311f52642022b8d08627233b99", - "receiptsRoot": "0xd84d1f3c040aa4e5e5c4655e4e31423fd5d4c2ca46d25cb7693bc6bde4c923a8", + "stateRoot": "0xa09fe3c9aa57bed39e8aba098b01bae1f9102747baa8d2190f251d86d0997efb", + "receiptsRoot": "0x103e3209b1a4ebafea6a2a117831dc392ef04124614f97228e1c6f309597d062", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000004000000000000000020000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x150e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1a26d12a9846cfa2af53cc33f21eadb49c2f39560b460bbb1d7c253025da7917", + "blockHash": "0xf0867530c5e2d8e1e6f5e8fce7da42ed7d2b62d8f996ad93efabfdb12bd3cfba", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201ec0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038ccb38a78682f396bb656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a18087483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a066648a01bc2252d7e0633c6b759cccd6c6d121ac88f86a69fc118d657e4f6740a01c809c36c3734566dcd0329b3ef0ed31c03a6c7637050bc71f371f875f943bbc" + "0x01f8d3870c72dd9d5e883e82022308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ccb38a78682f396bb656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a06c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a18087480a0bc2651e817375b070b0d9f91130822e5c467312725dff25ffd146eba7a12036fa02b2296294d45cd11376edd4a348493a28de7c89ce9228f2b82e1328e2f3669be" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x72ac7ccbdef2d82e39f5ea95cccfdb59f5d1c4a9a83e7e32a275dd2cf71db91b", [] ] @@ -17061,27 +17114,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1a26d12a9846cfa2af53cc33f21eadb49c2f39560b460bbb1d7c253025da7917", + "parentHash": "0xf0867530c5e2d8e1e6f5e8fce7da42ed7d2b62d8f996ad93efabfdb12bd3cfba", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x69f76adb56454f7d5f754a13c539416c6c7f06afadd175bb91be5a6f39f45414", - "receiptsRoot": "0x02bf599be82af8d5d9e94a53483a4491b53a865e277f526e8de25320e409ca91", + "stateRoot": "0xab4675cbf4cfed5bbcd4654aa3852c9d0cd8b4186ba58b7fe82d8eda579144d6", + "receiptsRoot": "0x51b30d8dea1a3d0bcdaf826a64f1bb286c7194c9918991a2ee3fd1dd787a1c39", "logsBloom": "0x00000000000000000000000000000000000000000008000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21c", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1518", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xa68b828d73467b4edbb8f3a188d1d23b8de8113e1157ebe14ec188e8f266637e", + "blockHash": "0xb2db3d26bc5c38616a7acbaba0e72cbc0d27ddb96f8fe1f4f1437d6ea7c058f9", "transactions": [ - "0xf8758201ed08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c73f53dd5c5a5b8e6656d69748718e5bb3abd109fa07d2f8da526aca447b41d7e8128a8043efa6181ba64f9a80d4e328fe707ac92c8a068a7bf6266e3a6bd7628ecb2df712e9e0fef35fa5e6de05411680d753e797401" + "0x03f8fa870c72dd9d5e883e8202240108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c73f53dd5c5a5b8e6656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ce285eb20810f2d026bc0b62faf3735df2193835ffd85df244ecc2df24f43b0083020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0941d11643e6706c38a19d1fa80a870e7553db9ec5a28fa96765f19a5d594d278a0498241744e65d1a71b91e39257a3abddfc93c33cf8042f7ec3d4cca14f2ebbfc" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x2f72d33db4de041ba2707492686a6f045671d2b63383cc70a770a94f39244793", [] ] @@ -17092,21 +17147,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xa68b828d73467b4edbb8f3a188d1d23b8de8113e1157ebe14ec188e8f266637e", + "parentHash": "0xb2db3d26bc5c38616a7acbaba0e72cbc0d27ddb96f8fe1f4f1437d6ea7c058f9", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x056f995edf8b4f996fd33e30c6822d5826b8a00b41c400c12782b8b3a0e813a7", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xff10357b70eee297cad094f5054140e825d657702345f074536db819f6aa30e7", + "receiptsRoot": "0x1fc5e8be642a0e47830d5f9cb00a1eae91931e0d8cab894c49b586d5b2603a60", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000a00000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1522", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x46d5ce094294750e8d8c4508cea607a110ac887c6876460834bb7f944fb3cba0", + "blockHash": "0x0dbddf3e586a2f5369ac360a4fee1273047238f16f2f4e8b6e16471b2455701a", "transactions": [ - "0x02f86b870c72dd9d5e883e8201ee010882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c001a045477c69fb8e39de6fbb74e2f46fad8a0100af2422237e37b5381c0f68a79966a06c71c781157867e0ee7e162f1a938b634665f3f31a948fce4681c9ba26370cff" + "0xf87582022508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce2934853c0e07a07656d69748718e5bb3abd109fa0806bcb8f517214e708a17372de5245a67396c6a5250aeab9d012af6135f5f20ea045044a58c796c3fbcaaa6841ce92ae2b54c84783d31e07c106ec325bbbb2d7b3" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17123,21 +17178,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x46d5ce094294750e8d8c4508cea607a110ac887c6876460834bb7f944fb3cba0", + "parentHash": "0x0dbddf3e586a2f5369ac360a4fee1273047238f16f2f4e8b6e16471b2455701a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x55f9573aaadb8fc314ca55c112fd5dc4e4d954e062e593d2e11a12cec791d44a", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x92ddc959cb2fb1dd69692ad7bfb8f2bc298dd502b425c332fd2dee520e707e6b", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21e", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x152c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x8d3698f018ddc839a43997a360b3715b80f6f8fbf70836166601ecc42439b1df", + "blockHash": "0xa82749ce59055410613ad90d73c4fdfe715f9b60c665689c4c377125b1dadaef", "transactions": [ - "0x01f86a870c72dd9d5e883e8201ef088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c001a01f2f31fc6b3aed1b75d585c4d97bc8dcc68d59face5224e5ac09d09bd9e5e3c7a0064ff5892a02c786cbd932238664e43b0655e87c2b14939c70f3253121e28d12" + "0x02f86b870c72dd9d5e883e82022601088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c080a05ba7aa03d805cec4b4fcdf0f85965c6640d52210dfc7d7a21f67d1dec2289472a0427f828a0df5cdb75f359b746505e42d73e5698ae804b83e892bc076eb23d39e" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17154,21 +17209,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x8d3698f018ddc839a43997a360b3715b80f6f8fbf70836166601ecc42439b1df", + "parentHash": "0xa82749ce59055410613ad90d73c4fdfe715f9b60c665689c4c377125b1dadaef", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3ff7261f715a6e65f20e6b3891169cad8aadba6e833ee6d9d19bd4be4aebb1ea", - "receiptsRoot": "0x642cd2bcdba228efb3996bf53981250d3608289522b80754c4e3c085c93c806f", + "stateRoot": "0xf5b4db74a22182e3244d6c46bfd8ef415deac2300c7bd7657fc8863215d4dd1c", + "receiptsRoot": "0xbe3866dc0255d0856720d6d82370e49f3695ca287b4f8b480dfc69bbc2dc7168", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x21f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1536", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbdaeadf6d9045a0a986c15262d81d49e1f12a3301035d7d7d03855f315498397", + "blockHash": "0x5be3c764fef371841fdaca04c885c757d884f9ff8971250ae39d77c76e573636", "transactions": [ - "0xf8688201f00882520894eda8645ba6948855e3b3cd596bbb07596d59c60301808718e5bb3abd10a0a06277e04f735948e7b3587c9a498a1cbd1cf26e757597dcaacb670ced21fd851da0419c5056ebae72ab55a9f66fc7a781841fbe5ef02d3eacbde641c11ac45abf97" + "0x01f86a870c72dd9d5e883e8202270882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c080a07cd0b848f57e8939951cf57255fdc454da314830486776b660aa6d2cd9a572eda05a20a6565e5bcb733ec560e01d446c81e38b85f66de4f359920f29ec10850ffb" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17185,28 +17240,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbdaeadf6d9045a0a986c15262d81d49e1f12a3301035d7d7d03855f315498397", + "parentHash": "0x5be3c764fef371841fdaca04c885c757d884f9ff8971250ae39d77c76e573636", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xe359a229439c935d37eb15692119abf3f62f0d44121173742451cbe3c5125978", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x2b1852b2db8a8e35f48485d7f315f8969b95fd277d9b533a61f75a133f52e594", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x220", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1540", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4466a1b8ce15a2b972b93d345e42e24d6c55e49e6e6b390daa111115737c8893", - "transactions": [], - "withdrawals": [ - { - "index": "0x30", - "validatorIndex": "0x5", - "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", - "amount": "0x64" - } + "blockHash": "0xb710b8559fdeaf52af97d3fcf0879011c37044dedb8f94dbbc338a85bfd7c61a", + "transactions": [ + "0xf86882022808825208941f5bde34b4afc686f136c7a3cb6ec376f735775901808718e5bb3abd10a0a05ceec42baa76b27fe39d9ab36d09835722c6d10baeabea922bdbb6b2d796a0b4a01c35d21343f362a283bf74dfbdd4cab090d16de909e304324c69c006be235c79" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -17221,23 +17271,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4466a1b8ce15a2b972b93d345e42e24d6c55e49e6e6b390daa111115737c8893", + "parentHash": "0xb710b8559fdeaf52af97d3fcf0879011c37044dedb8f94dbbc338a85bfd7c61a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x276a6f0667818b0b9e48329b0df3a12c55432a69b7a2e18d804ab0438b9a6981", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xa298d3c4bd50f7285630e98b96c2abdbc4eb9ce9a3bdba0e8c3da99566655de1", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x221", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x154a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xaac5449b0cee4d0ff7e6dc495061712400e5f908b5f5699bd489f8433c7f3ce6", - "transactions": [ - "0xf8838201f1088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0b64f8faa510164cddef08b97617a6d5080fcbab753249ff2069fdebd9bcf18daa03295fb60880b2d53920760615f698f90d44dbf6be4a6b043b842d245e80611a9" + "blockHash": "0x6eb711b67df8460994ec6d375c26a4209acae1a918f7a62392f2a562500980c5", + "transactions": [], + "withdrawals": [ + { + "index": "0x30", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -17252,21 +17307,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xaac5449b0cee4d0ff7e6dc495061712400e5f908b5f5699bd489f8433c7f3ce6", + "parentHash": "0x6eb711b67df8460994ec6d375c26a4209acae1a918f7a62392f2a562500980c5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0d95bdf7c340d3e2da1a434be9aaeed806ec9df50c6981f59f5fcf28e38837cb", - "receiptsRoot": "0x8651d247e3bca392f863186a65208d131bf252e4150ed9ffd7087e51751ba514", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000004040100000000000000000000008000200000000040008000000000000000000000000000000000000000000000000000000000400000000000000000080000000000001000000100000000000100100000000100000000800000000080000000000000000000000040000200000020000000200000000400000000000000000000000000000000000000000000000000000000000000000000000104000800040004000000004200000000000000000000080000000000000000000000000000000000001000000000000000000000000408000400000000000000000", + "stateRoot": "0x5285f20269553112d3fa1b74ef776f3ef4f7cbbe49fbb6285beca90542b1cc18", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x222", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1554", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbfc6905b39a1fd70f2d85dbd0ec084fc9bba34dd6bb89e4feae605de3472a46a", + "blockHash": "0x1da9f51a070e2bf7a49e7631ac54fb0e79bf4034dd2b982f8929cf12c469a593", "transactions": [ - "0xf87a8201f20883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa055096b6dc4a45fbf9170e9c187b9bc41f2438258148bb7d806d75359079ba6b3a044b007eb890bb333264526a6b7e7c92a6d517de42713ac3f96a0b57f2a4ee607" + "0xf883820229088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa01933a4971aa769804ba4ac63507f32bcf9c2b1bf5161dc27e2c465c26caa3c6ba0086c4c204789cfee0de84e151bf06d2c18d9823d6f4abc7035e9e6039f192c50" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17283,21 +17338,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbfc6905b39a1fd70f2d85dbd0ec084fc9bba34dd6bb89e4feae605de3472a46a", + "parentHash": "0x1da9f51a070e2bf7a49e7631ac54fb0e79bf4034dd2b982f8929cf12c469a593", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8c3fac07843541c61d52b4eb13fef58d805669c15dd83653eebce4e9715b1867", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd358f95f0a8aa12bd08232b92749f5e2f189a508447f6a89814509f9581062db", + "receiptsRoot": "0x9519cf62b07b8cbadc460fdc3cefec4aafe9d2bf3b3d4cc3a11d9ad733cb4826", + "logsBloom": "0x00000000008000000000000000100000900000000000000000000000000000000000000000000000000080000008010000000000000000000000400000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004100010004000000000000000000000000000000410400000000010000000000000000000000000000000000050000000100800010000000000000800000000000000000000000000001000004000000000000000000000041040000000000000008000000000000000010000000000004000000000000000000100000000000000000080000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x223", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x155e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x1320207357e4a928664d17895ca63c2e929115bf3078b13a0623a42b1361a27e", + "blockHash": "0x9d719d04326acbac551edf543d8f760e26c65609601f950dc8d7271cbf40a006", "transactions": [ - "0xf8658201f3088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a06ab85e777a6cc0b2dbd52f9c3516390edff3e0e948e7dd2386e7519d8a70e413a05b740cd62710ab8d44076701ed2162a4bd272d2f60800640256f0cd4d6805cdb" + "0xf87a82022a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a060cbd58eda040403b14eca1644f33a5246fe27034ad239413c2b33ed98d7113ca03597763dacc4c210366705368fc9f34c7dd812026df69e046746150922755936" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17314,21 +17369,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x1320207357e4a928664d17895ca63c2e929115bf3078b13a0623a42b1361a27e", + "parentHash": "0x9d719d04326acbac551edf543d8f760e26c65609601f950dc8d7271cbf40a006", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x145414168f2684ac713c1caf12bf80f01f1f9dc4f715f864682ed163654362cc", - "receiptsRoot": "0x91bed430019e3f90cc84ef5e5d56f4276141d26e047324f5e3fb3c631cac4539", - "logsBloom": "0x00000400000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000002080000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x21fc7f56ef62f2a6af0c85e8acd8ad3cb17ae34c757b5251e7c07b17f255b0c6", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x224", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1568", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6988fc4983a5d91cb76203880fcb0be8d513013f9eda28c6db7c27d0e457f417", + "blockHash": "0x488537d78be3c43ce3232056b5e0b1ce2ca9a88d4d7d768f654e0698928743e0", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201f40108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c637837799e0edd06656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a030335bc132be5a5f3bf464e0eed03a3c74f180cb9906552e187e4c04f024b80401a0b8c1fd8af8304dfa9ea0a05efca1dc046c0ee303d2480d33d3571b26ac1cac60a02d88376e9ef62f084881d7cf42a02e196b01d008a3f8162b87b72fc5d0898520" + "0xf86582022b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0aac243f3dc5739a48c97d8c1bf8378d7ddf5d316f6a94d1130065bf9abf2666aa06f86954f6ba0d3366b63224de6f55748f27828f807bd3504bf24a71cd38fe9e6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17345,21 +17400,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6988fc4983a5d91cb76203880fcb0be8d513013f9eda28c6db7c27d0e457f417", + "parentHash": "0x488537d78be3c43ce3232056b5e0b1ce2ca9a88d4d7d768f654e0698928743e0", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd6fcd0749b8b8f49a67d5942c805262f2713201ef2b6ec63b03b6f07de933c62", - "receiptsRoot": "0x844343467c0c25b600bcdee7a3390b3dd9c8ff6bdbe8a74cd849c574c7f096b6", + "stateRoot": "0xd449037270da36f46b81bc1bc11581777b0a23eca0de0502ed5fee65686d472e", + "receiptsRoot": "0xecd16d9340092fa4b69bc2bec07184158e9217ba92b74e0c643205379a3ed4fc", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000010000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x225", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1572", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x293913aa6fd6784e2dabfa7bdbf08dbcceac77ec746f2beaffe37f5c82ebd6e7", + "blockHash": "0x04b7bb9acaf695da6f2e725c22098a6a6d2216ab3478a9e053526bb50e276afe", "transactions": [ - "0x01f8d3870c72dd9d5e883e8201f508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2dbeda6b380ad817656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f01a03dba7195885ae53d62969038775930e5c3836122abd090a07c76596de48a59b3a029534862b9449692777ea4f45389c1ca850bdf164e951c3db834325a39798096" + "0x02f8d4870c72dd9d5e883e82022c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c2dbeda6b380ad817656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f80a03dc0fc4e572b227c6083e6ad856fc992d5fa235f9fbb320f913d2edf4ea64f0fa02341f3497adae073a51ee0db66676e3bf0d9953a65b539a04eaf1f027880c595" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17376,29 +17431,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x293913aa6fd6784e2dabfa7bdbf08dbcceac77ec746f2beaffe37f5c82ebd6e7", + "parentHash": "0x04b7bb9acaf695da6f2e725c22098a6a6d2216ab3478a9e053526bb50e276afe", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x51e463c94ba9dfedc74f013b95d9a29f55f140f4fc8959bf37e5744fef64988b", - "receiptsRoot": "0xcf20b8f39841205271cd4ae3ff22bcebb43f26f931e0bf0ad958927e914bbf67", + "stateRoot": "0xaa8508404b0b8c762b662ef018e226d1f83c73c51b84eef67747fdaaa33e9dfc", + "receiptsRoot": "0x0a490da86114d077ffdc597832c806c9215f936ea0e51ceaa334a1782825e1ff", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029000000000000000000000000000000004000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x226", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x157c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3c64be9f5fc05b3a06c21263201805872058b6dd89f5871f56126074937d7d69", + "blockHash": "0x7181f0084b63db7479c003d7dd4291ca02dae8d4283f82becb53681d47398afb", "transactions": [ - "0x03f8fa870c72dd9d5e883e8201f60108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c909c95399f08d166656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d383020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a013ed2516b753d14620bca1a0422f2396eb472cf0d7eaf692644e3f7c2bbb9e4da0335f33a96e11fad5cc14e20505ec96498459e66485ce9949cc2a25748218ddc3" + "0x01f8d3870c72dd9d5e883e82022d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c909c95399f08d166656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d380a0cf8496be36e7255631748864451cff36c50e2fbe7036a76df16e0a59aefc5dd8a0403adcbafeb9d64323127b28e306cf232099d0f120f3975f442972347ff89850" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xc5ea3d95ee2c22d741f6c48ac6d87e445e826cc8f6d25a1b2c12f3d9a447a353", [] ] @@ -17409,27 +17462,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3c64be9f5fc05b3a06c21263201805872058b6dd89f5871f56126074937d7d69", + "parentHash": "0x7181f0084b63db7479c003d7dd4291ca02dae8d4283f82becb53681d47398afb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1bba34157476fa72f9a3d061f9fb9cf626def503bad27fe5d6b29f4e3d51f021", - "receiptsRoot": "0xf0fdb3e364bbf5d119e2eeed252eef654a0a76118cc40780c49ec0aab44fe863", + "stateRoot": "0x5a29bc7e141a8b5204a67235e6cf2c1bce99f683d255f84745d92148f9a9d90c", + "receiptsRoot": "0x649ed1c0dd1ebcbf96c00305385c490cce0bd53a5131b834fa8fd8db67dbfcc8", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000008000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x227", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1586", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x9c0e5ad32b88aabd00d4e08f111128f36d2b3b9d00ec205b4deea450d7e20f52", + "blockHash": "0x026fb7db67bd230b10afa06b1c7b20edc1219887a13c0accd594f54aba577ca2", "transactions": [ - "0xf8758201f708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c448907ad05bd07de656d69748718e5bb3abd109fa03dae5b6b96f83657923f3df7a39f0c556348cdaafdc2d0164a981238e2f802c4a01aea0f93b7403c476e0475b00a54e552ac60c9035d81f549dc394c00e5d61b46" + "0x03f8fa870c72dd9d5e883e82022e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c448907ad05bd07de656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0f26b2f780c4b92b3f15f1d6e90f7d5a176b58eefea6f0d9cf2f8a0d1f86a139f83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a00ccf3dd0a97645a72eb3926dd694bfa7ff8cde336db1942846b4de7a197753a7a03c34702a7d5ce59948ced0f97c212bffc972d75c29d8b61ca6b943b23a497c8b" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x4085071556a9ec9d229d1d9b802b3e89cdd093f9f9139ea42eb5abe892541ff8", [] ] @@ -17440,21 +17495,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x9c0e5ad32b88aabd00d4e08f111128f36d2b3b9d00ec205b4deea450d7e20f52", + "parentHash": "0x026fb7db67bd230b10afa06b1c7b20edc1219887a13c0accd594f54aba577ca2", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8fdbd867ec5bb8ea8003e3d4e44f084399bbb492e18fe9181cd118bd4fa0d8d7", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x23302eed23ec4d3037ed09a5c8d1cb987b85319c0c6b2ee7cd773b629740e9de", + "receiptsRoot": "0xbe2c34b575afb52dadfa7ff4470d2fdf22388347ae87c871dfec683d85f53fda", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000200800000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x228", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1590", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xee8f988f3c18a72c2abea54699c856a15afdbaeae545924997985cb47210c6d7", + "blockHash": "0x60596113f907eadfb5229325292e44044821a9e22f7e575b24cab3ea58fb5190", "transactions": [ - "0x02f86b870c72dd9d5e883e8201f80108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c080a04956daf7db75c5ee31cc0222de61402254b0ae5673fa3ecb6f10eae2da9c0f0da046ef206b998dfe4a0fd4211738e9feacb9bbc383b4bca9d8f2f86678c9262fd4" + "0xf87582022f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c3bf5f7de7fc40580656d69748718e5bb3abd10a0a0ccb3b524b4240095f21c092cafaf4f649981463e6effd560e4ecc03245e2b29da06cf8a83ca8be11c4e6c8aa095255f57bb7898bdb3183ff669d1170abb34e9e77" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17471,21 +17526,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xee8f988f3c18a72c2abea54699c856a15afdbaeae545924997985cb47210c6d7", + "parentHash": "0x60596113f907eadfb5229325292e44044821a9e22f7e575b24cab3ea58fb5190", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1dda48a48b4ae196dd289c4b65ee93793862b910a1ed7446434c5f11ae9b6beb", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xb331683494cf8e7e2b2a4a68164ae46640adcaa324e827dfa62218e36050a286", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x229", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x159a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x90036a13de8b68ad7fa9658cb90a841951763c528de8a3891db006570d06760b", + "blockHash": "0xd168573695101511d7504d9d987c5a0fa7e64b52dbba520aece42e39e9b889b7", "transactions": [ - "0x01f86a870c72dd9d5e883e8201f908825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a0b550fec75bc8acf21764afaa05eb86ee6e4e69353b0ad78d09557614e93d4786a0727f2c3ee4f3f7bc4c42ce9f5237958dc70f61007f90731764de7aeaa8628274" + "0x02f86b870c72dd9d5e883e8202300108825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c001a0a5daecaa8ba4d8243ee4167aa85b9225f420e7c2c6a131e182dca618d722678ca05e69feb5985a26381b431b80fd5a0bd3ce608c5f44dfc4da0296a1c4534152ac" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17502,21 +17557,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x90036a13de8b68ad7fa9658cb90a841951763c528de8a3891db006570d06760b", + "parentHash": "0xd168573695101511d7504d9d987c5a0fa7e64b52dbba520aece42e39e9b889b7", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd758afcb5f2401ee815721c8170216980c0b8e02fd72d239f50d445efb4925cb", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x04145bd0d53de7b5d09b43bfc479edaaa22403d5bba73db923f5e19f3ee1fe3a", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x15a4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x641e4d31a221b340b02dfbe9aa430eab15367721b41a224ad5aaf44d60bfb649", + "blockHash": "0xcde6e6e9437d8d53d9d119f59621d8af4aab0d36357ae361fc39100037289949", "transactions": [ - "0xf8688201fa0882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e01808718e5bb3abd109fa0c004a45a8d6c03d0407993c24893342e0b3d765f3cd2be95c41222f0d5bcdf2ba078eb1e3e86929285260ec472b40b720db7b1df51009c4f614ab18fdf65a33b93" + "0x01f86a870c72dd9d5e883e8202310882520894654aa64f5fbefb84c270ec74211b81ca8c44a72e0180c001a04e47b90029babb8898afda6f32fb6267d7d6a46fd109e268007c4078ed201721a05d7952ca59f6203255e98664242bb052bfffe1cbc5a45a32de744356e521d056" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17533,28 +17588,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x641e4d31a221b340b02dfbe9aa430eab15367721b41a224ad5aaf44d60bfb649", + "parentHash": "0xcde6e6e9437d8d53d9d119f59621d8af4aab0d36357ae361fc39100037289949", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xc83c6683fac973de49a9b4c8aeda81273118113e44ae6113a15c5c7937283a90", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xa8a3551dbb96af8965635f8a32f91c0b2b215eec518a95f92bdfaa4d88541527", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22b", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x15ae", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdfa68efde1f8c73371b729e119655153388ca5404df5f27cb8aef2d5dc49d472", - "transactions": [], - "withdrawals": [ - { - "index": "0x31", - "validatorIndex": "0x5", - "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", - "amount": "0x64" - } + "blockHash": "0xaf7988749b7c275b2319bbe47c81260f8c3084d77e284db0b00237173851550f", + "transactions": [ + "0xf86882023208825208945f552da00dfb4d3749d9e62dcee3c918855a86a001808718e5bb3abd109fa0882015d7b266b0a114a6d06da722f8b4eb73c1081ea516ef123b498cca88af5ca04c79877c6ae33388b3e79635b23dd69fb0bb4c7f99efdf3d14c700f23efe3185" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -17569,23 +17619,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdfa68efde1f8c73371b729e119655153388ca5404df5f27cb8aef2d5dc49d472", + "parentHash": "0xaf7988749b7c275b2319bbe47c81260f8c3084d77e284db0b00237173851550f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7f9a1949008ffd79638b1722265e65a2ec6e7febf650b5246318eb249aab28fe", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xcffb3fc3c48a966aaccf3265534a087a069b99b14ebff35fadfc5b76d19ad77b", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x15b8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe069e5bf125ec3bd85fc691a6e299363e03130bbbdcbb1d4c0e7ed74c44d19ae", - "transactions": [ - "0xf8838201fb088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a00bb0355e05dff14ae7f093498b4243cb3f5ec8b786d9bc58875d08f7dcb7c0f9a030677e88a404292fe6afbdcb47585f66a8ce2ce7e32f6974314733c8af6fe032" + "blockHash": "0xe80952fe3298776700d0d5527b12772000caeafe16823a1d07d023c092aced4f", + "transactions": [], + "withdrawals": [ + { + "index": "0x31", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -17600,21 +17655,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe069e5bf125ec3bd85fc691a6e299363e03130bbbdcbb1d4c0e7ed74c44d19ae", + "parentHash": "0xe80952fe3298776700d0d5527b12772000caeafe16823a1d07d023c092aced4f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x925dccff4419cd0be1f34db61ebb25b1bedf06c688bc8dd95845ff1a3af5cb89", - "receiptsRoot": "0xe77c45568257ac258a041df8558ba0bfcf5ba6d92493d955fe531307b348c97d", - "logsBloom": "0x08800012000000000001000400000000000000000000208000008000000100002000200000040000000000000000000000000000000200000000000020000000010000000000000000000000000000000080000400000000000400000000000000000000000000008000000000000000000020000000000000000000000000000000000000000000000180000200000000000000000000000000000200000000000000000000000000000000020100000000000000120000000000000000080000000000000000000000000800000000000000000000000000000000000000000000000000080000000000000000400000000000000000000000000000000000", + "stateRoot": "0xc5b4b364d51cb425a8f27ab133549f2e58fb5417e32e874a442f5d1832a8aaa8", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x15c2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7d4c7faff291a34dab9ad08cc22b38e3e0623fbd96e53041f1936aefea2d3d01", + "blockHash": "0x0462b045d5e548d1267a9124eede57927ff6653ee26e515e79484a37fa332fec", "transactions": [ - "0xf87a8201fc0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa022d44bf5f520547c3d62b3af2a668c38a875402603b1761ad0739cbbf6d949fba07d7e176f316d43054bfcbdcbd949c9fa509f66b01d4e43017c3e464b4ad3011e" + "0xf883820233088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa00cba1aff982def9dac39bbfdd8f498296e1c67367236597c77165ad0390378bfa06632af5a65ef5f911e0f8e786b5d695d267351987617cd9479d06ed5fe83147d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17631,21 +17686,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7d4c7faff291a34dab9ad08cc22b38e3e0623fbd96e53041f1936aefea2d3d01", + "parentHash": "0x0462b045d5e548d1267a9124eede57927ff6653ee26e515e79484a37fa332fec", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x36392ba06448a6cf31c42cb250684201926f0ef3a52485c34a6b6465e2316f2a", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x641c1debf3055a466f9aa4ccac95fb2d724f2a2e9f3a89e33c356e3c5ed735b3", + "receiptsRoot": "0x24164ae5affdfeb7ac1b0e45fb9580b20c9ebe72f1308f7ae46c04e9a98a62e2", + "logsBloom": "0x00000000000000000000000000000000400000000000000000000000000000008000000000000000000800000000000008100000000220000000000000000000000000080020000000000000000000000000000000000000000000000001080000000000000050000000008000000200000000001000000000000000000080000000000000400000000000010002000000000000000004000000001000001000000000a10000000000000000004000000000008000100000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000080040000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x15cc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x35fcbe1e362b97d634c17b08b78c253df56c0f4a52fdcc1da23c4c56871485aa", + "blockHash": "0xc2379dccca93cb7af1b9495cb45ff56200395f2d0f799afda2cf7d1a8dc2207c", "transactions": [ - "0xf8658201fd088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a0e96d4d5bf4aefc09603bc653170722a3d3f6fcd29ca3d386c9559d7147078ae5a01529eca727370b97f6b345c20f6e92c687d8e75cbe2cf2ad859e79f74b8c486c" + "0xf87a8202340883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a013c9ae1f02d80119784f5303e3ef1b90c0e572b76521c2917586005a14236deba07acf4937f74477bbc4f9b1a7db1562a7388e6d2a493fbf30f7bdb7bbe6b9d034" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17662,21 +17717,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x35fcbe1e362b97d634c17b08b78c253df56c0f4a52fdcc1da23c4c56871485aa", + "parentHash": "0xc2379dccca93cb7af1b9495cb45ff56200395f2d0f799afda2cf7d1a8dc2207c", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd15854e44e4578650c11096a7c5dca9372abb9e52fff061a36a4865caf71b224", - "receiptsRoot": "0xcafafc113c46cd8f5bb6742a25cd34b0805b1fae9ed6e020f013acac38019f5d", - "logsBloom": "0x00000000020000800000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xd4bef8c5196a6887ddbdd9c798b43317e23992841c8e5fbdae002664620bbbb4", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x22f", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x15d6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x944867748f6677c888eeffa2f0ab037f72791f19d4957c1b015300f87e8f6946", + "blockHash": "0xa7614022dce29db83d3fdfda49d693584249cd3719f6981766ee013a59c53df5", "transactions": [ - "0x02f8d4870c72dd9d5e883e8201fe0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c013b74e9ecf6eb94656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c668aa05d66c2f88a95db12354386f3b6a1722a98aade506e117201f2fd0511f01a0c8ec83bcb1f4c322ab9372efd5360da4dc73819f230fb165b44fc294d1c6d7caa044ea233abe9745a9ea796049df9b6580c6f8ac2cba9a57642fbeb0abea41b4cf" + "0xf865820235088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0f86d215ae7100c55f14c1ec6f53d83c3d1fa777e3e1d9c23839a167beae6e475a01c0b30892286a4ede34138e7df61813bea4df91bf9675cba296e9ca662f3bd9b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17693,21 +17748,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x944867748f6677c888eeffa2f0ab037f72791f19d4957c1b015300f87e8f6946", + "parentHash": "0xa7614022dce29db83d3fdfda49d693584249cd3719f6981766ee013a59c53df5", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xbeee5aed5c512fe2aba90434b11ca3cd83cfe2363f9f1e4542b45fc592163f07", - "receiptsRoot": "0xd620721bcdd8db78ee477a81e7dcc0da3e86b50bba6bc734e1bd7fcb760f6f47", + "stateRoot": "0xd6079afb6c2ce2b1207b0ee498ee03c9130f633fa041b07920d04acacf526b23", + "receiptsRoot": "0x7cdaf89496c1a5a3c531b09245bad68268f8c9825175334217f3fa2b65ca8005", "logsBloom": "0x00000000000000000000000000000000000000000400000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000200000000000000000000000002000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x230", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x15e0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe2a46fb9f878a562bb0392bec6634965964c742d80102bed78abf111455c1530", + "blockHash": "0xa9a699c07f4409eab9ca244799436f35249c79448cfb16f1daac3ea84453ab62", "transactions": [ - "0x01f8d2870c72dd9d5e883e8201ff08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1f9e851ca16e6cb9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc8237019fe363a7a627edb29fd42f641a4694ba154799ce85e5a089f3edb570a69bcfbda0012663e85e981501f5ece5197c12aba3a097cd8de77deedbfef0e9fec5024b94" + "0x02f8d4870c72dd9d5e883e8202360108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1f9e851ca16e6cb9656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc823701a02c04468982075a831b72edc190258ec5b3892f86db9e97cfce65258e812ed1e3a03ed173c6e01067ad6b4be1d2eb27d49a4b226a30df40193c7aae6cb3d69bc424" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17724,29 +17779,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe2a46fb9f878a562bb0392bec6634965964c742d80102bed78abf111455c1530", + "parentHash": "0xa9a699c07f4409eab9ca244799436f35249c79448cfb16f1daac3ea84453ab62", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x789226dabdabfbf7f597dac2cb52db1b2e268ea801b28231c64b7cecfa70adc3", - "receiptsRoot": "0x6c3240fa7b3dad315fd76137e8b64fbc73fdd42666fa325ba022d6515817de0d", + "stateRoot": "0x8d0be3fc6e3043dcb92b33976b33b7136cdf20b5e8d85fcbfa8ee74d9102e158", + "receiptsRoot": "0xf9d700dd528cda36168b7c1b46ab2ad9b3f2d9f8f04ed2464e747e3cdbcdb948", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000080002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x231", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x15ea", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb229d60b67c1708d3994b81cb282f73ef6d2ae75438e401f4c8025562e2340fa", + "blockHash": "0x25b92c413d927baecbcc7836cd6464336f0a89e2d65a9fa0cfbe8729fb3b2eb6", "transactions": [ - "0x03f8fa870c72dd9d5e883e8202000108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c544caaa25bed802a656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a088edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c57083020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a097709dec1bc6016459a45d2525e964c2e6096b513dd70f369034e621f2f40c87a067a4d43475d8fe708b6a474c73678d638d91c70ff39973670da0278a2f522ae3" + "0x01f8d3870c72dd9d5e883e82023708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c544caaa25bed802a656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a088edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c57080a0b586a9f73d5ffc9bb1ce68608c76aaeb65093dcf2b5506ecdfc5a71031ce677fa03c970c8cf4f1668de9c0bcbc91f7efc7227cfab82c441dc23557057ab739fa04" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x80e9466bece8ddfabc70825bcec4e24aa55e1acf4ede6dc91e58bbd507b89106", [] ] @@ -17757,27 +17810,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb229d60b67c1708d3994b81cb282f73ef6d2ae75438e401f4c8025562e2340fa", + "parentHash": "0x25b92c413d927baecbcc7836cd6464336f0a89e2d65a9fa0cfbe8729fb3b2eb6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x84b817485cb14c9eae65f776c34caa5e958edccc2b42a3d7ac864ee5bbc88631", - "receiptsRoot": "0xd66e37e7c990514ad3bbcafb9158eadbce5669b8d56f61675eba2473a8890b66", + "stateRoot": "0xc4be91b8c59b503cab4bc24d11919560692712526990bbf14960dc484e32f1f7", + "receiptsRoot": "0xe7ba570a13b897c5510b99633c11830f998713b3b1f736009bcdf8b43fb2c377", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x232", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x15f4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb3b6afe52f6d14dd44a71f1ff185ed96179409250f324659fa1d1abd1b232739", + "blockHash": "0xa57990630fd6f670bb7e9f46d7c3e913b5392a7b13a83e9e040118b5edce4bf1", "transactions": [ - "0xf87582020108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c714a7ce99187d89b656d69748718e5bb3abd109fa095b150f56f03a017ede55787d2b0258ca65a9760df427ff0234099e5e0196c2ea06815159cf1061de7fcd19095e685a4469d8a6efa28d7cd8ed7d19531970d447e" + "0x03f8fa870c72dd9d5e883e8202380108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c714a7ce99187d89b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ab5140d25dce39c42d511dba633cde87b45465d48aa4ec211b27de998abbadfc83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a02edc679fb6ed3885ebe5d6bb3bf437381ab42e8cd40409eb57d8de68b7a89da0a0548ae149f4ed6a40f7a033ac18c25055586e1ebaf136839c6b88a1372675c4e4" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0xb60ebee302c2151ccc37af32e3613b07defd9503e344434d344ba3f8331954fa", [] ] @@ -17788,21 +17843,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb3b6afe52f6d14dd44a71f1ff185ed96179409250f324659fa1d1abd1b232739", + "parentHash": "0xa57990630fd6f670bb7e9f46d7c3e913b5392a7b13a83e9e040118b5edce4bf1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xa523e6ff0e4803aa8dbe968c322a315db96a3e88d1b7058534df79c7db027dd9", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xce000de5c6f0db7899b3dbce03252e92e3007540ceefb7b66276eee38ac41ac7", + "receiptsRoot": "0xc043e7daa7e45f96db1727335498d81d0b589b81016c3e1d6dbd89fd988b5431", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000009000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x233", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x15fe", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xadafa5a8ecaf727c48b659ef4ab3204554e7cf7b27e69207926a5a62c24fcab6", + "blockHash": "0x1d6f6c4bfa2d734a2b4869d97a28ed74e5ac40595899853e85e98349788a9d58", "transactions": [ - "0x02f86b870c72dd9d5e883e8202020108825208944a0f1452281bcec5bd90c3dce6162a5995bfe9df0180c001a0acab93bf4cb4b97fcd49b3e4df8b1c86c8f11bd672b9fb9745dcd6e544ffafa0a07e7d4a3efd96afa71faaaa62585632f9b490365abd96856dcd992c0c75cdf01e" + "0xf87582023908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c531a2d567445d0b0656d69748718e5bb3abd10a0a09a98ac819a48f4ea3d4c12bb691465eaec672dddf796189317c9c2066bea7fd1a022eed06705e732be508890102bd1c4e1847059dbd4a27f6d93143cd7d602ea1d" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17819,21 +17874,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xadafa5a8ecaf727c48b659ef4ab3204554e7cf7b27e69207926a5a62c24fcab6", + "parentHash": "0x1d6f6c4bfa2d734a2b4869d97a28ed74e5ac40595899853e85e98349788a9d58", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x0add3d869b6d31d27b406a0b296ad46480417ec18534319ee366f06f559a7326", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x3bf8746ca1a5a50afc191189886796323d288227abc154db248a29a72c29eb24", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x234", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1608", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdabd6ae95f5c2d68740f3001b8321ff60efcbd343b4c1d27e425b6e1d6dcbbef", + "blockHash": "0xe8c2b0ff9fe420948d5a90471748469f7cd018d8b62b156404626ee33a4f4edf", "transactions": [ - "0x01f86a870c72dd9d5e883e8202030882520894717f8aa2b982bee0e29f573d31df288663e1ce160180c001a0e24f830339f5be384db5c29002a98cb0a34f2738d1c9872e2aa0a29cc0544dd8a033e12812533b46a55b9559ec498b72f7dc1b75ce991e2006e10b5c276a3cdbc1" + "0x02f86b870c72dd9d5e883e82023a010882520894717f8aa2b982bee0e29f573d31df288663e1ce160180c001a0458b87fd7d6396257685ab25480385171ca3bed9eca7289b40c702be82263b63a04aae7b1501ca7450a82f3c2639369c4c13310358ffaf9bf44ff8d8abe3753348" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17850,21 +17905,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdabd6ae95f5c2d68740f3001b8321ff60efcbd343b4c1d27e425b6e1d6dcbbef", + "parentHash": "0xe8c2b0ff9fe420948d5a90471748469f7cd018d8b62b156404626ee33a4f4edf", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x965ac1ac3accdab7930879f4ee756efac7007fb4576f1da9cd6c05563079ea2e", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x5baf3090db9bba2e50d74a2b0e97d3aaed18413163635d322d717d4844a2f272", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x235", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1612", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbc4039fe1b1fe6767d379b48649f0208eedd6211fd09012c410e96231a70bd32", + "blockHash": "0x96419b60000d8e4e9815500d8e3d69eef3c19d36997bdaedd42cfabf174ae505", "transactions": [ - "0xf8688202040882520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc01808718e5bb3abd10a0a07258d0e5116a06fac217d7dd9e68efdf1dd0a41cfca170707ca91e13b66a47fca07124963ae3315bbf6d55b6f57b6b9d0cc9e99b89359e1f80a25f7ab119ac6888" + "0x01f86a870c72dd9d5e883e82023b0882520894e7d13f7aa2a838d24c59b40186a0aca1e21cffcc0180c001a0ec6af985b7f6670ae589b8b15da1147ccc88af6bb495de6ba682258cd1c0d9faa009958afe72b0ad14f51323cd570488978d8b98b3cb03234f08b4dc0e3fd70bab" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17881,28 +17936,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbc4039fe1b1fe6767d379b48649f0208eedd6211fd09012c410e96231a70bd32", + "parentHash": "0x96419b60000d8e4e9815500d8e3d69eef3c19d36997bdaedd42cfabf174ae505", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce63da29607372e5fb2bd2e3cfc40ad9c32a06a0d75e94b450ece4fbd1782dbc", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x695baba1a16890cf56027a4abec52df8010f389b85c159e4beeca0edefe7d1c6", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x236", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x161c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x83db531e70791b6207c14af0b6321145a00614c977b70fd0668270988de4d5b6", - "transactions": [], - "withdrawals": [ - { - "index": "0x32", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0xffafac142daa1e5dfaa588553a29883ef5d6b9a56408401cc20dd60121467861", + "transactions": [ + "0xf86882023c08825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd109fa088128ea9ba6ec872f8a52ec25fbacca092f5cee67c79cd0cedaf1d9e4097a719a04b62d924ecf4b8c8a432f8ce37a9696014fcb741c6cb197dc0a4d51f80620760" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -17917,23 +17967,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x83db531e70791b6207c14af0b6321145a00614c977b70fd0668270988de4d5b6", + "parentHash": "0xffafac142daa1e5dfaa588553a29883ef5d6b9a56408401cc20dd60121467861", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfba0205e6afe3530dfd7f7ca2f566e5e3fec41a1b72768cef1bd130e0896db9d", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x5398054f6728892e01100f6038e1bc552df25943d10ff4dbcf8fffed8910ed5b", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x237", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1626", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd790766e32a204eba62eb8748875d63e58f290375cb77e1a8e06cee26be50aa0", - "transactions": [ - "0xf883820205088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd109fa08a3293f922745d79e457a90657c7800d24062b70cbd24731cc509cc035a826a5a02418be783d16ad760c9008ff9bc552ff330273c1b77300054a827e1e537078f0" + "blockHash": "0xeb9bc3c34aeff870450eef73debeab5d6a4e853fd5e94794de8de70f3328400b", + "transactions": [], + "withdrawals": [ + { + "index": "0x32", + "validatorIndex": "0x5", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -17948,21 +18003,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd790766e32a204eba62eb8748875d63e58f290375cb77e1a8e06cee26be50aa0", + "parentHash": "0xeb9bc3c34aeff870450eef73debeab5d6a4e853fd5e94794de8de70f3328400b", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x02e8449319a691d4372e57402adf68b09a0c127eacf25dd8c5d24b99ff592f1c", - "receiptsRoot": "0xab5236843c6ec7a9a5c1c857233c1a31227c51fff87b08748241e6e356e656a8", - "logsBloom": "0x0000040000000000000000000000000000004000000804000000000000000000000000000000000200044000040000000000100000000000000000000000001000000000000008000000000000000400000000000000200000000000200000800202000000000000000000000000040000000000008000000000000000000000000000000000000000000000000000000000000000000010000000000000002000000000c000000000000000000000000000000000000000000000000000000000000000400000000000004100000000000000008000000000100000000000020000000000000000000000000000000000000008000000020000000008000000", + "stateRoot": "0xfa0ad05fbd9c5cee03dc844c85e34894cd8e358275a8fb4695d6ed4f7e886ccc", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x238", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x1630", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5f7355f8b08daee6ee6be9e9522ecedee0db5282463952021b5eef1bf8fc6c7e", + "blockHash": "0x168cb5014662382595da9de5a5d07020a00f6871e24ec2f12e4d2c01200a1021", "transactions": [ - "0xf87a8202060883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a0152333c4db61c12a484f33619b7494425c4fb730fa90c830e7440f1a51185003a02373ac712cabf3578803bbff9524b1eca00561fbf30a54e5a6d635eb3a1d42b2" + "0xf88382023d088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0996d3dd760a40ac198ea0625ac932a0049423f2ea1b0badff9790bdd3581de80a0405373b8832cc078d5449bd5d864b000ea7d5d05311a002b11f86354d133f606" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -17979,21 +18034,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5f7355f8b08daee6ee6be9e9522ecedee0db5282463952021b5eef1bf8fc6c7e", + "parentHash": "0x168cb5014662382595da9de5a5d07020a00f6871e24ec2f12e4d2c01200a1021", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9f1f21f14844bbf78578c02bfdab936943f011175e11d57192f110a015e6c69e", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb65bbb0de3f324d1479391e73300b9a96d8ef970393b9c75f4b13a9f55426510", + "receiptsRoot": "0xc2438923e0df877ca3d800892d179f7cdc17b2846caae090c64ded60b4758d92", + "logsBloom": "0x000000020000000000400000000000000080000000000000000000000000000200000000000000000002000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000480000000040200000000000000020000000000000000000000000000a0008000000001000002000000000000000000008400000000001000000000400000000000000000000000002000100100000000000000001000000000000000000000001000000000008000000000000000000000000000000000000010000000000100100000000200000084100000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x239", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x163a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xcd23cbad2ba375c546161adcaee6c4c81319c164b1ad8466811b7490b95e286b", + "blockHash": "0x12d8f16244cd8fd6024d151e6a2070009c315dffa38ee8c5330e1bd3d4c3e550", "transactions": [ - "0xf865820207088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0258584a1147b37a17be31c06af2090dd5eb443f969c020363b2f2cdc459a9596a0282b4f2574e1ec52f6c5289fb36aa4817f07f8fa2b55357f8c918accad542069" + "0xf87a82023e0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa05bcaf8b4aabd360569527d984095742ff50fe933205b334015f9f2d4724a63e5a03e07aa87b6af37e9e8d3fea351ecef37f86685ae75a72d0dd99d79c889f0672a" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18010,21 +18065,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xcd23cbad2ba375c546161adcaee6c4c81319c164b1ad8466811b7490b95e286b", + "parentHash": "0x12d8f16244cd8fd6024d151e6a2070009c315dffa38ee8c5330e1bd3d4c3e550", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd5fb4dd1825b5b107a175ea86e678c666d0e3a7856767e9ea03a8d6fe66852f8", - "receiptsRoot": "0x40e99d7d453a379f204ed089fd42ece7ec4f5231d41153766f315683085eb5fa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000040000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000409000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x2e488aafed1429cc1d6e1833a29b29a042a00665358bebc6cfc6bae35da3a455", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23a", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1644", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xf1357f71ed1cdbcf8c1a31552f1223403b9d85b44dd4ff2c9a3683ee440c95c8", + "blockHash": "0xae534ee68fddcbb56a54e1389963b1b91f2bd81903668bc912fb38e8222616ee", "transactions": [ - "0x02f8d4870c72dd9d5e883e8202080108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c364818558262ea3f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0fc6dfdea8f35e8af49faf38c0164a3deacd65c3927eeece6023868f32fd382a701a02b4279a6f9ec69f63621cb880a47c59e094f6fddf49b9095256bcef44d629798a0674c21917344a22cee20997863b3a49fa450283aa7af2f6b0777b734190d4e05" + "0xf86582023f088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a06c258143226b3e0b083ceb085ed33504648cb3a1131e5fad2688cbfcdd9302f9a03178f9023079da66e69d8b7011168bca212ced59b8e8273b6b5ab0c606d309cd" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18041,21 +18096,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xf1357f71ed1cdbcf8c1a31552f1223403b9d85b44dd4ff2c9a3683ee440c95c8", + "parentHash": "0xae534ee68fddcbb56a54e1389963b1b91f2bd81903668bc912fb38e8222616ee", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x827c4203000de525ba92f76614d6007fbd4696e3a62bc974c3dacba3f6a9817f", - "receiptsRoot": "0x0531e3172fd7f36101c399b4954b96f5e3ca6b52b24b166dc8014ed3ec2a6c5e", + "stateRoot": "0xc87653c55d2584811df8ca04b51e47c130dcdb90a6d10184b8529130af87694a", + "receiptsRoot": "0x7bd993dae053a05a7cf4a17e754878feed89e6549f4797c790a975045fccd4af", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000200000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x164e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb69086a5e21ff6ac0b0177b825eb4ac57307f19211d34d5d27f270d74ca07a17", + "blockHash": "0xd17d8c2fc653829318949d721e152c1578ac66a99c02fea2ed7e9902345888ca", "transactions": [ - "0x01f8d3870c72dd9d5e883e82020908830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7ec75a9a44cbd37a656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f4988301a0612f7a0e06dd7918c6389d3bd4f8bc57e10b32d70da74e884f0dda3b53761209a066d37136bacb647658ec9a497ba10f778bfb78a68f0a1d812d010e56705984d3" + "0x02f8d4870c72dd9d5e883e8202400108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c7ec75a9a44cbd37a656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0b9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f4988380a0d8eb62de0723c4d3071e1e7338cd9dc052714d483705501cf2d7a43ede1ab2efa0691aeb7be0289e154e0db27233a86db840d3df0eb68c3226ae31f2667a85ec61" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18072,29 +18127,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb69086a5e21ff6ac0b0177b825eb4ac57307f19211d34d5d27f270d74ca07a17", + "parentHash": "0xd17d8c2fc653829318949d721e152c1578ac66a99c02fea2ed7e9902345888ca", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfc7105c3a5bf1b58cef7558dc26078ae7adc4a72d55093a1af5a25c1efd40b3f", - "receiptsRoot": "0xe963bcbf726070b5ddc6f9d75c199509949be21a06df053d721b3483a55e0b30", + "stateRoot": "0x34be0e307d6f9095e613d7c1c4ede1d624ff2ccfa921847110a3318499c3aa06", + "receiptsRoot": "0x0e59486f8a1b78699db78104935292fe0707ea9c742817a63491084a27cd878c", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000001000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000800000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23c", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1658", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xd5c1878d16190ffce6abc0972a9250ab129a383fecf447dd5e1e5fe9c560e2b7", + "blockHash": "0x8d7e0a0e7b3ae1c2af06dbe35c75cb89f39ee82eabdcc3dee776c4528e5f44ae", "transactions": [ - "0x03f8fa870c72dd9d5e883e82020a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cdfd0fe3a4aba411e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe8106883020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a011d5b637e77b5987aede42c7762b7fbd44f55cd97820b01c4601b58fc40686c4a059ce5c1474f7dbdc38706a8663fa0a2d2b22f7cf0aabfcb68de52b863d87dc03" + "0x01f8d3870c72dd9d5e883e82024108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdfd0fe3a4aba411e656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a07a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe8106880a0f6d1633a6e9bf948390d5892e601e41435c9d8e194d2420e09d0d2f46498a9e0a052e5d636c533da0e88e37ba8dd2578610f9169b94721f4ff9720a434732fb3ac" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xa662fe4e7f5b359da22861957ebabef233d14df689a0a378333f9caaae8ddcc1", [] ] @@ -18105,27 +18158,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xd5c1878d16190ffce6abc0972a9250ab129a383fecf447dd5e1e5fe9c560e2b7", + "parentHash": "0x8d7e0a0e7b3ae1c2af06dbe35c75cb89f39ee82eabdcc3dee776c4528e5f44ae", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x85ac092ae2e24e0ddaf4dad90aa0c735d6a3986bc5cc14cb2aee394ee03f5974", - "receiptsRoot": "0x6a9f814aa655c257313a8eb715a3a9b779ff613959c7527c5a3e7b839425a1eb", + "stateRoot": "0x147f4144141326f7f9ae8c80266475516cc2ec5b684b0917dad44c659a9893e8", + "receiptsRoot": "0xc640d110a9d3c3320caf892ed640488ade7bb415e95636395222ab8540b62a92", "logsBloom": "0x00000000000800000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000004000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23d", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x1662", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7adf3774b7bd3f89b0948e1ddbbf300835f06dcee2f437e09ee4473df6c8a07c", + "blockHash": "0x1d2cf4804fe3b07289794f1cb5227e51d697cad91934eb7c4705834e36100bb6", "transactions": [ - "0xf87582020b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c48fa07464a4e8d5b656d69748718e5bb3abd10a0a0db116037fd0b9637c96295f7c48bc7ab5362b2fe6b64a7fe14a816fb948be9bfa00e01886ea233240e06d6c3d593c31d257f47ae07ba00f8cc91ab4471a83cecb6" + "0x03f8fa870c72dd9d5e883e8202420108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c48fa07464a4e8d5b656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0c558392238c2d11cdd04a6ae37065f3541a22140500f92c0d8006ff95e8df59583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a029d3c0911a45d36d03af347109f14a7446680818bb9026183118c333c4c07d86a0598c061b1a983b2ac6f74268f8c3dc4bfb87b7ac815ab6103dd7bd7be1d3387d" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x4e99f494a9bb40f134a5ef00de1bcdf3f971b37c873330d5aeb3d49efbcb4c00", [] ] @@ -18136,21 +18191,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7adf3774b7bd3f89b0948e1ddbbf300835f06dcee2f437e09ee4473df6c8a07c", + "parentHash": "0x1d2cf4804fe3b07289794f1cb5227e51d697cad91934eb7c4705834e36100bb6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x168521f6122464c3f1a43faebf1d77414c95c5d95a87201b9bd00437195c19b7", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x3ce5fb93422fcf699bc95fd8778f03bbd2b4a584ffa01bb9f70e88f3fe0a671c", + "receiptsRoot": "0xb1ad8fb2618c7819ec0d8ff2b6931220689bb87ef72ab6dd77f1a41420b1ac0c", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000002200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000009080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23e", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x166c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x2dfc4f087156df89e8f26744590b923f3a81642defd298dd1a1db5bbce0b3d89", + "blockHash": "0xf90b5cc6dac74d3bc26ea436c5009c72a78b680483bba81d842d5500cf2cadcb", "transactions": [ - "0x02f86b870c72dd9d5e883e82020c01088252089416c57edf7fa9d9525378b0b81bf8a3ced0620c1c0180c001a0a42fb001ff2a98cf4adfc09b23851b6fb8da636779221bc8b41c346091630e0fa049a5f535ef66a2f57688fbafaee8d90671f6231df0629f00de594d1bef8728ac" + "0xf87582024308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c0676fa58a1c69ae3656d69748718e5bb3abd10a0a0a98fee5db4ca354081a61973239ef94ae57943d10cb07136e4d8fbb92dfe569da017ec1654d447d17754d34c0eea157cb503aba5e67b6dba2c31dd9b7aef1b00ec" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18167,21 +18222,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x2dfc4f087156df89e8f26744590b923f3a81642defd298dd1a1db5bbce0b3d89", + "parentHash": "0xf90b5cc6dac74d3bc26ea436c5009c72a78b680483bba81d842d5500cf2cadcb", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x4202c11970a82d82c8fee99ca6add1ec9866f1ec626ddd4bf865f4762580bcf6", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x50dc0734b1c45d6c8d624c8773a23461205a777f6846b4817e26cd87647cac5c", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x23f", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1676", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xe58a461ab85b4e2208262ab6de81621a9fe3c96e4eadb9253e7baecdec571434", + "blockHash": "0xda50bf0b60a87259fb867f9ed72c9b70defa034f7579ef5d8b3b1fdc0dcef8fe", "transactions": [ - "0x01f86a870c72dd9d5e883e82020d08825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c001a03f3d6d379ab516c497b0af6290227424b16953bbf968837762326ac2f290bac1a006aab01c6bdfcee9a191a5c9e874e6f34035aa41b07b8785483ffc00b705a8eb" + "0x02f86b870c72dd9d5e883e8202440108825208944dde844b71bcdf95512fb4dc94e84fb67b512ed80180c080a0d1f25aa15ac65ba71d17caeceaeea4a0e095f92175ae2035770d1e4e7d86e714a0158a76f98ee1a2ba361fbb825d373ed56e790b07a09637c7f8d7fba072a025f2" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18198,21 +18253,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xe58a461ab85b4e2208262ab6de81621a9fe3c96e4eadb9253e7baecdec571434", + "parentHash": "0xda50bf0b60a87259fb867f9ed72c9b70defa034f7579ef5d8b3b1fdc0dcef8fe", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xd5f511f8949fd8dc7d1098d4c4ed5ab7f9147c89d4235efe097844de896bed23", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x652ae3ffb65dba74e57debeae4c3f989a8d5873e8a4b62674ba0c19108b04664", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x240", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1680", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x0bdeb401cf2ad8a1f33f3e6a71602b0720182bc5a290cbf92a20ad5a47b421df", + "blockHash": "0x0ed725064a1263c0361d176ecc01bd8f3282fbf917f16c7acc8d74da1a076d5d", "transactions": [ - "0xf86882020e08825208944340ee1b812acb40a1eb561c019c327b243b92df01808718e5bb3abd10a0a05a23960f1d1161a098f5641967203fe3edb3c7e42ee612a474396843253189a7a01e0088b2a97fb0295f0d618ade3f3969d8148fc6577023ae0482060a0f872280" + "0x01f86a870c72dd9d5e883e82024508825208944340ee1b812acb40a1eb561c019c327b243b92df0180c001a0517ec55d421f419f0e343fcfa86577353588322a74e91bddfe81dbace50a8ee1a039516532a256e54763b0026a5527722b1f7aa18a10a023c3860841b67c9196d4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18229,28 +18284,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x0bdeb401cf2ad8a1f33f3e6a71602b0720182bc5a290cbf92a20ad5a47b421df", + "parentHash": "0x0ed725064a1263c0361d176ecc01bd8f3282fbf917f16c7acc8d74da1a076d5d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x101b820600d1c50ee651d71c08332c9c5fffb5be36dfc5e605adfc7d2c135d65", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0xa8d21ab2906d9edc878981252da0147788dd70314a77405e31a613a5b6e6fb30", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x241", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x168a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x29456e95da920f3dbc36b3dc0a926f2dec210b800550386ca672ed6110b169c6", - "transactions": [], - "withdrawals": [ - { - "index": "0x33", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } + "blockHash": "0x6c84eb9a9f855cc6e5d2e3a2e3745e58a19f3dc35dc4d4b87e03fd8be4541313", + "transactions": [ + "0xf86882024608825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f01808718e5bb3abd109fa0a04c4303a6827047f885f5ce098244f44caea3ec02cb19f78fc815761b11ce15a065f4f3fab3c6b51b870a275a7099dac199129d91f96011295d7f3ee43b351811" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -18265,23 +18315,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x29456e95da920f3dbc36b3dc0a926f2dec210b800550386ca672ed6110b169c6", + "parentHash": "0x6c84eb9a9f855cc6e5d2e3a2e3745e58a19f3dc35dc4d4b87e03fd8be4541313", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfc527558007c4f087e899bb1b473615a09e153d997c6cc52fd0a6620f88d6dcc", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0xfef13c4295d27b16ab0e667de806b4cecf97fcf5cb22757d9d53319ae5c05ae1", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x242", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1694", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xae6208b2d4c5f776a63eb1e4dc138b366387fe7ddecf72fd98130637bf65dfeb", - "transactions": [ - "0xf88282020f088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0a57ec1616eb73d62f45ea8a0a64baa948e495d7d227b19fd2a1a8ae15e1583569f1aef5b444ca71d6e75d73f714f9bbc5af70b6c4c0919b43dd7711d010d38f6" + "blockHash": "0xdfe776d8d16b551a7020bdb98ccfbed0c74ce701b7da68a2124088f2661a3592", + "transactions": [], + "withdrawals": [ + { + "index": "0x33", + "validatorIndex": "0x5", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -18296,21 +18351,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xae6208b2d4c5f776a63eb1e4dc138b366387fe7ddecf72fd98130637bf65dfeb", + "parentHash": "0xdfe776d8d16b551a7020bdb98ccfbed0c74ce701b7da68a2124088f2661a3592", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x84f3f8d900f4fffe9bd7cedaf36f2ce7782b849d48687b2b4928e7b2f9c97416", - "receiptsRoot": "0x0db8ebc21dbec5d968112dd938204da0a80726a51093c6550507fd204d7ba3a7", - "logsBloom": "0x02000000040000000000100000100000000000000000000000000010000000000000000000008000000020004000000040080000000000000000000000008000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000020000002000000000000000800000040000008002000800000000000000000000000000000000008008000000000120000000000000000000800000000000000002000000000000000000000000000400000000000000000004000000000000800001000000000000000010000000002000000000000000000000000000000004", + "stateRoot": "0x6d5ed717142863823c1e1a30822027887222f2e890c1e108595382f6168b62c3", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x243", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x169e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbba5107c05a512e72c49b459b20a6ecdc1cfec225f866ef045c9a3693df05905", + "blockHash": "0xff3de971bda54ed67b27bd4b95e38b9045f21d23c4b3b1613def488d9826e293", "transactions": [ - "0xf8798202100883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a02db5572b1b643362370466278086633f4a8b861f4cd3c66fec25129b6f67ad639fa072b90382203dd402b353b789d846eccf6c56c88c49469b852233677fbaa1" + "0xf883820247088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a039df9a0e8de2224bf52aaf601ff7bad23f0934867dd7f1363a51849c6e781c62a06eff52b6c11453d75259640c321523ed37e8263826df260da5bbbdbc2cf3a39b" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18327,21 +18382,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbba5107c05a512e72c49b459b20a6ecdc1cfec225f866ef045c9a3693df05905", + "parentHash": "0xff3de971bda54ed67b27bd4b95e38b9045f21d23c4b3b1613def488d9826e293", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1451a8d4cd68bbb4d5d6f4fe56ad0ab8b35af1200daa855eb3737484c4196b9f", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xdcde1a92d0a85b6a47fc83c03ba46bc2d46cc74e208666bdfe3a5e8e50ed1099", + "receiptsRoot": "0xf69d56acdba1da2116fe7b0ff52cea51d28e294fb1137e9766983df99550c415", + "logsBloom": "0x02000000000000000000000000000000000000008000200400000000000000000000000000000010000000000000000000000004000000000000020000000000000000000000000000000000000000000000000000000000100010000000000000000000000000000000000000000000000000000000000000000000008000000000000000004000000000000000000000004000000000000000001000000040001000000000000400020000000000000008000000000000800000000000000000000000000000000000000180800000000100000000000000000800000000000000000000000000008000000000000000010001020000000000001009000800", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x244", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x16a8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x626d2bcb3645a3cab73403328051faad33be5e5f5f75ff38e195b77dfb0fba01", + "blockHash": "0x689a76ccb80461e78e22e1997c949bb143882516f7db6ec6aeb1062342881540", "transactions": [ - "0xf865820211088302088a808090435b8080556001015a6161a8106001578718e5bb3abd109fa0a96441d65104c23cf9a7088dc28637f66e0622e6b1e5255df248ee585f2e1b31a078dd2974918e32b1927eb9287a7707a78a8811f95522a812266e254c06dbe696" + "0xf87a8202480883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd10a0a030798404d7e574a0b486ccaeb48204b05953314a7fc90a94e161025c06ed2caba01f5c18091e4e21d0a9020534f8c9b1196140a632b752b788cb0721740a2cebd6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18358,21 +18413,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x626d2bcb3645a3cab73403328051faad33be5e5f5f75ff38e195b77dfb0fba01", + "parentHash": "0x689a76ccb80461e78e22e1997c949bb143882516f7db6ec6aeb1062342881540", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x9e6b0afec3d1916e27584af48d680684c7ebd341dbc32150e62191b6e1567cb9", - "receiptsRoot": "0xf0305f035bddf00f19ac42d5ccf9c28b3c82c1aec51c2140e5134160855bda60", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000002000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000001000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x64f2b3af837014cc23fdcf675c5954f171432c9f8e5e55c20c5500a05c0673df", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x245", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x16b2", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xaf6d014836a41c11af83a95a92d5324c0dd0e063a6feda19a05966c97cbeadf0", + "blockHash": "0x179654e16a3900b68bb66927ab2e714430ee0eadadf1930eb6073454bfe66d72", "transactions": [ - "0x02f8d4870c72dd9d5e883e8202120108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cfd2bb460afdb41a7656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a014ec3dfb63100132cf23ef71b80689146033fc6ceb9f8c0f0a65ef93cd18c2c701a0b9ab2ed269132f6bcf5993e88b5a2dc4ef5570c0b458f3298a2fe5b52ffa72f0a06749f3b679e3b44c0719696e00ff6b617236313c0968bd2a57bb8071aa6c9171" + "0xf865820249088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a08c673b248fe7fa166d33b9597135ac842aeaa2cf3af7e62532c629103c211cc0a0047bdd9a697f1e5be98aecf488f95e7a04f443e6f00daf280e82f533d2e703a1" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18389,21 +18444,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xaf6d014836a41c11af83a95a92d5324c0dd0e063a6feda19a05966c97cbeadf0", + "parentHash": "0x179654e16a3900b68bb66927ab2e714430ee0eadadf1930eb6073454bfe66d72", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x1db89cc805b90fb11a5ecbcc4799cd83273d928d594710e61b5b3f9f1c0a236a", - "receiptsRoot": "0xccfd2a7a120d603bcbed46bc9f503dd0b3b4b143fe3968b0d072ff5f576bdd5c", + "stateRoot": "0x65959aa2ff931be2daf44495237c367cee6c6fec1af6b2d6d52cc983fadc9ee5", + "receiptsRoot": "0xb1244d83d83209f04cfa439f7bee0ba45cd1717a5d43b67782ad7026c0d4d510", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000202000000000000000000000000802000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x246", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x16bc", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x6268abdce6bb3bee101c9e848666f3522cf429cab4725f23a27a5eb9575ed2fe", + "blockHash": "0x7a4bcc5016b6d39420221e1206b50128e0efe3fee6a1c5eb573e6bedaab5f215", "transactions": [ - "0x01f8d3870c72dd9d5e883e82021308830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c93e6b57cd7fc7d47656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a7101a01ef6a9871216401c4675b1e0fd92fa9f3e9852afe2b6db70b677a848a9fee53ea04088e3e07660ed373cf7c1cccc9006fc0606725d9f8cf0e806c7648033092b2b" + "0x02f8d4870c72dd9d5e883e82024a0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c93e6b57cd7fc7d47656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0e0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a7101a0587405becdd9f7f7b949ea6524e45b1fbb5f9f0f2a9c65c0115cafc935b665efa05cae49e4f84edcceef753265da15b95cb5642d45e39119883fde73bc755cf6ef" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18420,29 +18475,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x6268abdce6bb3bee101c9e848666f3522cf429cab4725f23a27a5eb9575ed2fe", + "parentHash": "0x7a4bcc5016b6d39420221e1206b50128e0efe3fee6a1c5eb573e6bedaab5f215", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x981e30545692b2c9117c021ba3fd7200ab656a0516acce07ce55671afb03f178", - "receiptsRoot": "0x1f2cb774b67f97bda6ed769189bba6aa75e9b1255e3e2737494c6731cd4dbcbd", + "stateRoot": "0xaeb918d8589201b296ed6a99d6ebe6db00c29dfff95dbafbef8eb673e88790f9", + "receiptsRoot": "0xd26fd26453a9b2409f607a2d805423998851f65f00bd96ec3a7bab0b8314fe72", "logsBloom": "0x00000000000000000000000000000000000000000000000000800000800000000000000000000000000000000000000000000000000000000000000000000000800000000000000000004000000000000200000000000000000000000000002000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x247", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x16c6", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5f5a1ffa3df60840b186c814fe10bee8d745a195f68174d5097067663eb692c8", + "blockHash": "0x54d398355fd128ea6d1db1e790364b184845a3687dfa213ac446f7d298755717", "transactions": [ - "0x03f8fa870c72dd9d5e883e8202140108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c171fa5153d9de7dc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d7583020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a06c389f2f897e70da12b4b3f34239da178f4ad032d13217b485a72c39257d4081a059985e5a30367433b076881ca953326c2c205ac46a46b5a5c5b3de8af8bff067" + "0x01f8d3870c72dd9d5e883e82024b08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c171fa5153d9de7dc656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0a0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d7501a03a036c24dba63089c6a07f0f722f3e19df2d4571d2a15f06566b9feeb0be9d90a059f82d91f48682b9f2330f33dcad8b3a28535173358773e94444c418448a7f51" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0xf48ee127fa2d3b4a69eff4f11cc838cf34b88ea4eb595db690e2f098af6dc64e", [] ] @@ -18453,27 +18506,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5f5a1ffa3df60840b186c814fe10bee8d745a195f68174d5097067663eb692c8", + "parentHash": "0x54d398355fd128ea6d1db1e790364b184845a3687dfa213ac446f7d298755717", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xb0d405e8c5e405de5557c8129aeb800b257c8ce69d6e85aac49969b2412d8c89", - "receiptsRoot": "0xa20442a8b2cea953b63f35f3702d29b408aa490d1cbb05ed89f116110422444f", + "stateRoot": "0x97b30e98baf08c3cb8775680eb83d94aed2a81be867506bf42757d32ed1f465d", + "receiptsRoot": "0xeb1a9ea66d2a50f24352c84749d44eba91e4bea2d92e5ca4df45c4033a66f032", "logsBloom": "0x00000000000000400000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000200000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x248", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x16d0", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xb43bd5c412948cb43408ac47c85d080b9bcdcecc982ec14aa3a09dd531edbda6", + "blockHash": "0xc52e636696619f0055d30d50b17d0f5a62537fa775dcd349d3948956c57a578d", "transactions": [ - "0xf87582021508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c1bea227fe2612720656d69748718e5bb3abd109fa0ab1b2a24caee27f36c27c4b9d6146de80abc99d51fc459b4fa40c6639497beb1a035b0e865c5e6c2246bfb766bde2c9b9af8d1fa737efeda5f0c9c6594fa615739" + "0x03f8fa870c72dd9d5e883e82024c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c1bea227fe2612720656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a069626497767f58c222726a6a3c65050bcfdbb9346f9e5d146ef02bf59275b3d283020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a031f0892dffde4213fe0284ac6420ef191b3aafc4857a03cb45f31f8568f0b28ea0368d809ce4f97e3291908864a932be0c231f197f067c7b1a68bb75fdc8b01109" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x0c047872d9588bf22e89ea7ec207e8be8486d0bfa775d147ea49b25a9847b3c6", [] ] @@ -18484,21 +18539,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xb43bd5c412948cb43408ac47c85d080b9bcdcecc982ec14aa3a09dd531edbda6", + "parentHash": "0xc52e636696619f0055d30d50b17d0f5a62537fa775dcd349d3948956c57a578d", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x7640efa3ea726c17a2a644d3f633e4872f488073eeb9d1d0fa7d6a76da8de37b", - "receiptsRoot": "0x005fb2a0d0c8a6f3490f9594e6458703eea515262f1b69a1103492b61e8d0ee2", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0x12011fc0bb202064b37e2073c3d16bff439bbb9c90c6cd20fef3226dcc887e86", + "receiptsRoot": "0x5a6a0dc6cbea4cdd8a1cdb1ea36a5b7e07330b3c819b58e776b3701ca28aab50", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000009002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x249", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x16da", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xfea440ef23de659e22508daedb4d4dd91a5bb39df9d3f039a24cde8ffa6527e4", + "blockHash": "0x6c72dd1012068c32cf36641b1564e48296fb121ab7a9a9baefd5c28416d8d054", "transactions": [ - "0x02f86b870c72dd9d5e883e820216010882520894eda8645ba6948855e3b3cd596bbb07596d59c6030180c001a0143c22b16b7469abc885b8df50817d05005239f4a88f1e36dec1acd976aee532a0239432b2462737698c72307a848e65f79e2aaec778ee225064553b9cd6c47024" + "0xf87582024d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028ce44dd8ca1b4c2263656d69748718e5bb3abd109fa06ca241263493e263b18d58aa1f5db96bf7bac49aded5de38168e81fe54fc5d42a003b6588ca3402ad0b50cef554a1397d5c3f3a1eeb6d8d1741c478d9cc44ec5ce" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18515,21 +18570,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xfea440ef23de659e22508daedb4d4dd91a5bb39df9d3f039a24cde8ffa6527e4", + "parentHash": "0x6c72dd1012068c32cf36641b1564e48296fb121ab7a9a9baefd5c28416d8d054", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x30298c9c7cdf0f7300b7e99e37cba2246fe79b05ff63d6cddf56f0e120e92a38", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0xb08cd3fc698ac319d37e19de2b37050bc499752841e2b7c7ba5063dedd0f4328", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24a", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x16e4", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5bda26af5e60d0a9bdccc94a59421b97f0d82cc828a117643b021ca4dbaa4372", + "blockHash": "0xa9697418504b9f328eb3b4bb3c4a82ccdad93df60ba4f9666a9ed9d4b61215af", "transactions": [ - "0x01f86a870c72dd9d5e883e82021708825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c080a0066d4c75c7fa794a218f4da41cfe23b5ae88fd68d035e330accc26dfe734d3a3a0057990c5f8dd5982ab7701725beca4af30f550063e131145dc0469dc56e62a2f" + "0x02f86b870c72dd9d5e883e82024e0108825208945f552da00dfb4d3749d9e62dcee3c918855a86a00180c001a0a2f63e0b0cca4620f870d79af0002a98b9cbb9e064c8b81ef0a843131cc49a67a07e9c2a4e7e425a4e875c025d609cbd3aae4f72d219664c7a494fc2226ac98ea4" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18546,21 +18601,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5bda26af5e60d0a9bdccc94a59421b97f0d82cc828a117643b021ca4dbaa4372", + "parentHash": "0xa9697418504b9f328eb3b4bb3c4a82ccdad93df60ba4f9666a9ed9d4b61215af", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x3464c5fa5ece202889ee11c62b4a5ae4ddc886286f322b86fa5297f630750b77", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x66cdb0536095f974bdbdbaff5fe08182728bbfe241e49645d10986c5867b3f8c", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24b", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x16ee", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xbd1d9841873dd0a26419f9a183a78370dedd826f922adeff78afef05811f8f71", + "blockHash": "0xeccc52333b224ed9aa4a274c7c2e6ad7043da8fec8cbd1841c4df037d272a070", "transactions": [ - "0xf868820218088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb201808718e5bb3abd109fa076571d850861e7b1df4aaa542979d07e265dcb85c2f6dff257793323843a1c40a05bd6105d6a281fd6b83642c6c3ccf034586fcc2e7acfd3128112ed3e1e05d7e0" + "0x01f86a870c72dd9d5e883e82024f088252089414e46043e63d0e3cdcf2530519f4cfaf35058cb20180c080a089fb7c079dc6325a8c1e2101776f25d0eaadfd9c5f170e1bc727b75d795a3003a008c2f5bf7e8ec06b9d5db13ddaaebfbf765e117298919e7fdbea7a250796c321" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18577,28 +18632,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xbd1d9841873dd0a26419f9a183a78370dedd826f922adeff78afef05811f8f71", + "parentHash": "0xeccc52333b224ed9aa4a274c7c2e6ad7043da8fec8cbd1841c4df037d272a070", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x44d0fdb391789dad1ba58d79be1c608a15e0b85f0c56a3af181ac8d4b1c8a561", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x545d513c53bddb5d4002b4e88a2f11d15f63ff38ab9ef94b3df8a560a19fa362", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24c", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x16f8", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5f40f6bc01be52c0a6f0f800c4120e73ae430d2a0e2cc6cfd6958ef33aad54e6", - "transactions": [], - "withdrawals": [ - { - "index": "0x34", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } + "blockHash": "0x0e033ec5d1b65a42204e9caf992cf062bf74c8a309c9b2e769b858e366650d94", + "transactions": [ + "0xf8688202500882520894c7b99a164efd027a93f147376cc7da7c67c6bbe001808718e5bb3abd10a0a03e549b7984b29b1df2092f5bcc53a93bb13f9217d18040bd5f3f9ba073b1714fa01824f6d408f8ac57237b06eefffef459ea8db23afd08bc788cf6c4e78f8c9a9f" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -18613,23 +18663,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5f40f6bc01be52c0a6f0f800c4120e73ae430d2a0e2cc6cfd6958ef33aad54e6", + "parentHash": "0x0e033ec5d1b65a42204e9caf992cf062bf74c8a309c9b2e769b858e366650d94", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8ac4b662fee7b371a7a1677ece50909770c14a335438a5d0a2c1b45b7c0c7e35", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x7db9c63aa71032059d5073a74cfe6ea27ab1c24ec5600bc7d2513af677438810", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24d", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1702", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5528f6ef151d9a9f71dae57e39b1cd2c5c6e5c7e0cd3a419afbee06e313d9f47", - "transactions": [ - "0xf883820219088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a019c2fc75ed9320542c35ca28052512936b9954b33a2707282c709bd3103e6567a04f66fe0576ef6b87d76061f4b50262f2b410bd91ed81ed6ef20161440c302b75" + "blockHash": "0x787a2bb58c6e1d4ac5d91e6fb7bbf1713c1e902ca3b86d920504167e9704e574", + "transactions": [], + "withdrawals": [ + { + "index": "0x34", + "validatorIndex": "0x5", + "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -18644,21 +18699,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5528f6ef151d9a9f71dae57e39b1cd2c5c6e5c7e0cd3a419afbee06e313d9f47", + "parentHash": "0x787a2bb58c6e1d4ac5d91e6fb7bbf1713c1e902ca3b86d920504167e9704e574", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x00b336f0e8aaf230ebe5b4cc09829786b2ccb66b49bafbd29cb019b16745cbe5", - "receiptsRoot": "0x2451e6fbb51a782a188493c5fe74bfcbb29e3e0ab32a5c3b0d4f12455ee15966", - "logsBloom": "0x00000000000100000800010000000000000000000000000020008000001000000000000000000000000001004000004000000000000000000000000000000000008000200000000050002000000000000080000000000200000000004000000000100000008000001000000000000000000000000000000000000400000000000000000000000000100000000000000000000000000000000020000000000000000000000000000000000000000000000000000008000000000000400001100000000000020000000000000000000000000001001000041000000000000000000000000000000000000000000200000000000000000000000000000000000000", + "stateRoot": "0xc3c5a6d6f2c1b107494fd143c13eb9609aa63f80edc16015e1e0ed8b7bf7a66b", + "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24e", - "gasLimit": "0x23f3e20", - "gasUsed": "0xfc65", + "gasLimit": "0x11e1a300", + "gasUsed": "0x19d36", "timestamp": "0x170c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xdff8f0703a0840e4d227f77f46348869d6c8b8c30b872137b26a9e2842914410", + "blockHash": "0xaa4611fb72fb0a85c2d1bc1083c160f1f316538c7f58ef556f4340ea20068ce1", "transactions": [ - "0xf87a82021a0883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa081f24574bb6d5fd961496bf2911b1dff1157f69a39cbda71261b5812716324f9a0611602fa072852d98a4b658d42cb9be3ab41a857244cd38449a2ca2843cfb2b6" + "0xf883820251088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0f2a14202ed7395347d395732b271818fa11116b0d3f85e1e6f5ed333fb6343f2a02d0cf49b1eb8efce93816ce11f7832d15a01f0842a80f60577f3fd1e25cf3c74" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18675,21 +18730,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0xdff8f0703a0840e4d227f77f46348869d6c8b8c30b872137b26a9e2842914410", + "parentHash": "0xaa4611fb72fb0a85c2d1bc1083c160f1f316538c7f58ef556f4340ea20068ce1", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x8fd5156899dd8a8847796b80fae5cb28aa68432d14c7982faeb871c452efb7cb", - "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xb132ef8988775a208bdf2b6899c8055ed01edbe8a9d79ca2cf8c42e9c219084f", + "receiptsRoot": "0x63da246261c11b79d6b2257757fe9bc25a2e8854f3ef308b3389316f6b6535db", + "logsBloom": "0x00800000000000000000000000000080000000000000000000000000000020000000000000000008001000000400000000000002000002000000000002000000000000000000000000000000000000000000000000040000000000000000010081000000000000000000000020080000000000000020000000400000000000080000000000000800000000000000000000000000000000000400000008000000000000000000000000000000004000000000000080000000000000000000404110000000000000002008000000000100000000000000000000000000000000000000000040000100000000000000000000000000000000000000000200000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x24f", - "gasLimit": "0x23f3e20", - "gasUsed": "0x1d36e", + "gasLimit": "0x11e1a300", + "gasUsed": "0xfc65", "timestamp": "0x1716", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x4ce9196d2fbc4bda9fcb9ab61e86167c9e1b547e873a7e5226f922b18db59953", + "blockHash": "0x5e35d6b8ace034f15f9ea52f7f1a6a1ec774e7a4234137c6c5bb913dfd733971", "transactions": [ - "0xf86582021b088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a07da1cc208fc8db65c8310f6a595651f7b9a44d36fb7855cfe1f3021236af7b12a0154d8dea9bb629b9574b8f738435b4a4d91b93637a0725247025d9353f4b5435" + "0xf87a8202520883011f588080a54360005260006020525b604060002060208051600101905260206020a15a612710106009578718e5bb3abd109fa0b160861a308a8186409f97802c5e41436e66e14606a74bffc5a64d53c0fc5538a05e314c022138bfe5565de55118d90d5e749fc772592746bc21cbdcaf5d663e2c" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18706,21 +18761,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x4ce9196d2fbc4bda9fcb9ab61e86167c9e1b547e873a7e5226f922b18db59953", + "parentHash": "0x5e35d6b8ace034f15f9ea52f7f1a6a1ec774e7a4234137c6c5bb913dfd733971", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2b1d33774c57b125dc481095f387ec1e12ffc071dbd98027f4aa545c74fe7b20", - "receiptsRoot": "0xb09954e33355e8b7fea3b4fba9111d225dfc44667568a936f3a27675f05b4555", - "logsBloom": "0x00000000000000000000010000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000210000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000", + "stateRoot": "0xbb279d232e60a8f01c32bec723e64223daee4fd285506789e1051cbc25f03aa4", + "receiptsRoot": "0x8e47c51ae3cc2e7f29232aac553163472046f2668ba19aa17733e156999a8234", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x250", - "gasLimit": "0x23f3e20", - "gasUsed": "0xca9c", + "gasLimit": "0x11e1a300", + "gasUsed": "0x1d36e", "timestamp": "0x1720", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x5ba98af8b68bbf0d86879ec911858300293e7bbe347abc02548c5084ab5a0d3e", + "blockHash": "0x0a0ed30330099aaed4d9fc919882376e3624d21bc3b39691003081f575f6b27f", "transactions": [ - "0x02f8d4870c72dd9d5e883e82021c0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbf89b8d49503bdf3656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a05571137d48f7d081e62051a6bbca9d1e25c93ac6f84b7a3bc146f126ac80928d01a021b98f88ca8c35bd6d21a37b6a2519ec36c67c517cef173141ac82c2eeb611a0a021575bbda347f6e57138b220cce4ccd9664eaf6dece4b2f99045267c81da9a5e" + "0xf865820253088302088a808090435b8080556001015a6161a8106001578718e5bb3abd10a0a065082b051f83ae94104b9807a153a05cb7eb2836f39078467253e7f0d534672ba068d1f2159b8c6045fc516e3c55dbf768a35f3134d307096629de881164298ad1" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18737,21 +18792,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x5ba98af8b68bbf0d86879ec911858300293e7bbe347abc02548c5084ab5a0d3e", + "parentHash": "0x0a0ed30330099aaed4d9fc919882376e3624d21bc3b39691003081f575f6b27f", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xfed11f6990ebf4a1e995149d9531df1b9c75eb063347ee56a56b12cdca216ee7", - "receiptsRoot": "0x0656eac35536632b283e78d198105757c78d5ca745dd7c155d6f4e18b6c85f53", + "stateRoot": "0xa6f4f81752da75e187320b73c4cc6ef5333fc0d46c06c4a5f925cf4a8be7411a", + "receiptsRoot": "0x8354d2ef1f62c7c7a783ea323b1289332872be764a4f9fad5bdb89a847fb2718", "logsBloom": "0x00000000000000000000000000800000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x251", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x172a", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3d33f3036b1399cf00cc8966e85b8553b5d7d4127ad121f382df765661a6627a", + "blockHash": "0x3f445c59eb76afc237ab0aff24e4afece553617597903e7c54e2e52535f5f69a", "transactions": [ - "0x01f8d3870c72dd9d5e883e82021d08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf395506d95a7654f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef01a0187066d8724b64ae34dee9c210e49d16ad5ba5b4c2341ebec15c6b5a4362c66ba02d3b474d88899bad59ba824935a87aec4c6b59660a6408728b157db70eb7d087" + "0x02f8d4870c72dd9d5e883e8202540108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cf395506d95a7654f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef01a090eb34a1e3b22bc5f3751af1df6b9b965d574c80aadb09c86472283753a4052da065feaedaa76e0a9b777e3f442714d305d25146b79cb2389f094bea6fe359013f" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18768,29 +18823,27 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3d33f3036b1399cf00cc8966e85b8553b5d7d4127ad121f382df765661a6627a", + "parentHash": "0x3f445c59eb76afc237ab0aff24e4afece553617597903e7c54e2e52535f5f69a", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xeb44311abb1ba7528b75d2454b74e669f9e3f62e7cf84642adafebca15c46a38", - "receiptsRoot": "0xc23ba9703a5d1c83cc099524b48c9c1f1d9cdb06c970a9d26200d8643a6f74ec", + "stateRoot": "0xb2c8af99b02731886eacb5fc4d5e43bb3127b0325129d8d6cd3764c2a3d72f7e", + "receiptsRoot": "0x089a9f710854e80061a0fcd4b802e49f829d4564f2fc88ceec2251af4cc62791", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000002400000000000000000000000000000004000000000000200000000000000000000000000002000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x252", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0xca9c", "timestamp": "0x1734", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x3ed14e1e4d79669a7104b244f12d0dbbda1873230eddacca3ddf00d5e278be9b", + "blockHash": "0x5b913043ae15b19475bdf3bce3000c885837ce744816ee34aa4c4fa13c29e273", "transactions": [ - "0x03f8fa870c72dd9d5e883e82021e0108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038c8bb77ba856e3d12f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a048ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc83020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6880a07968587982d4ec1553c6256dcd929997fae662a778950a5cedc82d409ece8f46a075a549540d89b304904d14d4af525bf0a6989a7c63602e5c5390da5451a0927c" + "0x01f8d3870c72dd9d5e883e82025508830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028c8bb77ba856e3d12f656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a048ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc01a0cb42a8410b26080d7376b8def1c490bcfa0ca62594d82e6b68d18380eb2cd3c7a019def470d2019119f86d96a8d24bb2670661c787a4cb0cc7bdc4a59193f70c19" ], "withdrawals": [], - "blobGasUsed": "0x20000", + "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, - [ - "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" - ], + [], "0x18104f198e6c84cec4875b8b6d2734b6b9b8ce4bbbe158adfa81bfdb239595e2", [] ] @@ -18801,27 +18854,29 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x3ed14e1e4d79669a7104b244f12d0dbbda1873230eddacca3ddf00d5e278be9b", + "parentHash": "0x5b913043ae15b19475bdf3bce3000c885837ce744816ee34aa4c4fa13c29e273", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x415e45d750fdc4726e897237d64fb00fec0992a1323c4bce1af1d3d526ff8043", - "receiptsRoot": "0x7925339d2acc12b05a73a129f8b2737689c6336bd6e01f999c561249cbe6fe01", + "stateRoot": "0xcce9580e6a5a277358bed1921548dc0141515b0e3923ce9ce3286359bfbaadc3", + "receiptsRoot": "0xe8f72ee3af379d8d2d326d7d0bc69d74d371407807cd8ca51129af59bc1d94dd", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000400000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x253", - "gasLimit": "0x23f3e20", - "gasUsed": "0xc268", + "gasLimit": "0x11e1a300", + "gasUsed": "0xca9c", "timestamp": "0x173e", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x93a7231507f57e163e3b2e48a47132fc1eff83375b041b46a35e61a090ded25e", + "blockHash": "0x00cd4351d6d5b3636ccb5424b17c5a8b33e881f83ac158694c1f198b70290d93", "transactions": [ - "0xf87582021f08830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cdbc56807623499cf656d69748718e5bb3abd10a0a0d18bc40c1e3a5823d9f91a0b507e49b77eadf82ed88419fce974ac277690920ba053a0eacf14f315dc03e6bfc73c7d61571ebd6eaa67b5e7889c6ce1194bba7310" + "0x03f8fa870c72dd9d5e883e8202560108830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df038cdbc56807623499cf656d6974f85bf859947dcd17433742f4c0ca53122ab541d0ba67fc27dff842a00000000000000000000000000000000000000000000000000000000000000000a0ee0b894f33a9643c94e4e2237077260f4191c5bf6bb3c17a2212b86af6f67df483020000e1a0015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f6801a0a545f5e30bc665283edb8248dcac5114a99c8464afcf2f69435871fb45ede974a07b1ab9cd75c4e5e222ca96204393a181bfec664116be58b4f1ed72889642df01" ], "withdrawals": [], - "blobGasUsed": "0x0", + "blobGasUsed": "0x20000", "excessBlobGas": "0x0" }, - [], + [ + "0x015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68" + ], "0x64f9ed7df2e19a503f0b6f5b79e4d7b512c66623c28887e7f8968750f081f06a", [] ] @@ -18832,21 +18887,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x93a7231507f57e163e3b2e48a47132fc1eff83375b041b46a35e61a090ded25e", + "parentHash": "0x00cd4351d6d5b3636ccb5424b17c5a8b33e881f83ac158694c1f198b70290d93", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x30a4cff5811cdeb2add55e03102e2cd5cc9e7750540d186bb4a2a165167401e7", - "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xcff585af11146778da3d20655de97626de2e292b6db3e9c3f6feee73dc2ff9fd", + "receiptsRoot": "0xa3560e3cdfbff1482ab2bf3f71bb70a7b7d912f65785d863f6b937f212cdb999", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000200000000000000000000000000002000000000400000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x254", - "gasLimit": "0x23f3e20", - "gasUsed": "0x5208", + "gasLimit": "0x11e1a300", + "gasUsed": "0xc268", "timestamp": "0x1748", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x42f57c5994becd0c778c625c4564b288f2ddd5523bf3505dcba11d4f31e317ea", + "blockHash": "0x84dfa1c19923082db1a37ae307ef33a005c1ae987763f3537078e44a91f72cef", "transactions": [ - "0x02f86b870c72dd9d5e883e820220010882520894d803681e487e6ac18053afc5a6cd813c86ec3e4d0180c080a0061a9064cafcc779bebfc3410463e27e57ef4b69b13b063d79a9a258a363d917a0279a658e80bd6527683f521da84fd287422105c3bddeff127c20420dde99b7f6" + "0xf87582025708830186a0947dcd17433742f4c0ca53122ab541d0ba67fc27df028cbee48aed349a6783656d69748718e5bb3abd10a0a03b7ea625f55336efa74b3e1d5df85cd6a73899201dae3e0d777eae286069b7b5a00d59d0faeebbe85d9e7c86c5d2db39a9f01fc707b6690230811d8c6414686695" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18863,21 +18918,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x42f57c5994becd0c778c625c4564b288f2ddd5523bf3505dcba11d4f31e317ea", + "parentHash": "0x84dfa1c19923082db1a37ae307ef33a005c1ae987763f3537078e44a91f72cef", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x571f92dc76ef8c4ec47f5e496abe8c7182c5c4331537aeae052f95c2521b28c7", - "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", + "stateRoot": "0x4e2712c48c9758696c0619d7cff4034b34f17ae40d1fad8da2697b3dd479af21", + "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x255", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x1752", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x05b8baa80ba3a0782ff6cade5129fb4e3cc8733de5d8da918d2338245ab76b6c", + "blockHash": "0x4f62f1eb606efbd760b849b83f48b5080b0045364da18111e5f81faa74bdf648", "transactions": [ - "0x01f86a870c72dd9d5e883e82022108825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c080a017fe88f6088755cd0167e286cff24eda1e4d2d4cdb035a966036882fc5ce8e92a045ead0434b8343a5db8eefa40b4f88b7191c771313a83550aae586d18be22036" + "0x02f86b870c72dd9d5e883e8202580108825208947435ed30a8b4aeb0877cef0c6e8cffe834eb865f0180c001a00bfb57a904239393551f7406c67cb7bba19973813d6a38d0c6b1441212a8772ca06b94c83d0cadf6dae03d601459712527754ee348037dbd203bf583e3908754c5" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18894,21 +18949,21 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x05b8baa80ba3a0782ff6cade5129fb4e3cc8733de5d8da918d2338245ab76b6c", + "parentHash": "0x4f62f1eb606efbd760b849b83f48b5080b0045364da18111e5f81faa74bdf648", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x6b8f10ea0c744a4333a8ba86f8204a648ba50145d4263af8d1ce8d35bfdcc6e3", - "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", + "stateRoot": "0x87930359636f6c38717ff53ce11fff3d2dfe40300a1c005581fd9ece966db920", + "receiptsRoot": "0xd3a6acf9a244d78b33831df95d472c4128ea85bf079a1d41e32ed0b7d2244c9e", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x256", - "gasLimit": "0x23f3e20", + "gasLimit": "0x11e1a300", "gasUsed": "0x5208", "timestamp": "0x175c", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x7d4219f429001b5f014e933f9a36aa865d09955de79a8292aac8a00e75ba0f03", + "blockHash": "0x6845189fc5fffc30575935e9f8db4c343bcf5001360241b5af6a10c91f5b1003", "transactions": [ - "0xf86882022208825208941f5bde34b4afc686f136c7a3cb6ec376f735775901808718e5bb3abd10a0a0256584d11c94a5ec9fc723cbd9961e7a2569a48a23bc1eae505a74b46065f33ea0120d196163359143ae54697ae076c590ef82df3a89e275147f807fa12a9b34d9" + "0x01f86a870c72dd9d5e883e82025908825208941f5bde34b4afc686f136c7a3cb6ec376f73577590180c001a0e90c53bb3a6b15d32df5ad188aebcc3cfa97a2456a9d16557d3fe649b16debeea01ddee1a867f45c916ba53d89c4dce859812cc7af6a820a44cc6ff58a251464e6" ], "withdrawals": [], "blobGasUsed": "0x0", @@ -18925,28 +18980,23 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x7d4219f429001b5f014e933f9a36aa865d09955de79a8292aac8a00e75ba0f03", + "parentHash": "0x6845189fc5fffc30575935e9f8db4c343bcf5001360241b5af6a10c91f5b1003", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0x2335c84c9cbec7fa7456b92b69afcb95a075433eaacf4aea36c3eb4b9564a333", - "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "stateRoot": "0x62d156f5ddab09f393224bf2f3932e87a93a6c39679aca2f580234fcb4dfb3ca", + "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x257", - "gasLimit": "0x23f3e20", - "gasUsed": "0x0", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x1766", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0x65151b101682b54cd08ba226f640c14c86176865ff9bfc57e0147dadaeac34bb", - "transactions": [], - "withdrawals": [ - { - "index": "0x35", - "validatorIndex": "0x5", - "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", - "amount": "0x64" - } + "blockHash": "0x7e80093a491eba0e5b2c1895837902f64f514100221801318fe391e1e09c96a6", + "transactions": [ + "0xf86882025a08825208941f4924b14f34e24159387c0a4cdbaa32f3ddb0cf01808718e5bb3abd10a0a0343078ff0a2a584258302df6ae1f2571d9ba89d1f7f3fa8fec4c0611aa2d39f1a04a2a53b393aaa218a9ef7a9f7075470a98f4be9d2be19999a4eb3e1ff437880b" ], + "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, @@ -18961,23 +19011,28 @@ "method": "engine_newPayloadV4", "params": [ { - "parentHash": "0x65151b101682b54cd08ba226f640c14c86176865ff9bfc57e0147dadaeac34bb", + "parentHash": "0x7e80093a491eba0e5b2c1895837902f64f514100221801318fe391e1e09c96a6", "feeRecipient": "0x0000000000000000000000000000000000000000", - "stateRoot": "0xce423ebc60fc7764a43f09f1fe3ae61eef25e3eb8d09b1108f7e7eb77dfff5e6", - "receiptsRoot": "0xfe160832b1ca85f38c6674cb0aae3a24693bc49be56e2ecdf3698b71a794de86", + "stateRoot": "0x8fcfb02cfca007773bd55bc1c3e50a3c8612a59c87ce057e5957e8bf17c1728b", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "prevRandao": "0x0000000000000000000000000000000000000000000000000000000000000000", "blockNumber": "0x258", - "gasLimit": "0x23f3e20", - "gasUsed": "0x19d36", + "gasLimit": "0x11e1a300", + "gasUsed": "0x0", "timestamp": "0x1770", "extraData": "0x", "baseFeePerGas": "0x7", - "blockHash": "0xce8d86ba17a2ec303155f0e264c58a4b8f94ce3436274cf1924f91acdb7502d0", - "transactions": [ - "0xf883820223088301bc1c8080ae43600052600060205260405b604060002060208051600101905281526020016101408110600b57506101006040f38718e5bb3abd10a0a0b0889fe12fde37694f828cdb251c94d1e3abed2fd46e321ceb40d28e9747cb85a048aaf8240ecfb1382b4bc47b52ed705786f67b1ae71fbc2a00eb0169f43d0ec5" + "blockHash": "0x44e3809c9a3cda717f00aea3a9da336d149612c8d5657fbc0028176ef8d94d2a", + "transactions": [], + "withdrawals": [ + { + "index": "0x35", + "validatorIndex": "0x5", + "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", + "amount": "0x64" + } ], - "withdrawals": [], "blobGasUsed": "0x0", "excessBlobGas": "0x0" }, diff --git a/cmd/devp2p/internal/ethtest/testdata/txinfo.json b/cmd/devp2p/internal/ethtest/testdata/txinfo.json index 254b59d346c0..4cbecc1bc7c8 100644 --- a/cmd/devp2p/internal/ethtest/testdata/txinfo.json +++ b/cmd/devp2p/internal/ethtest/testdata/txinfo.json @@ -16,12 +16,12 @@ "randomstorage": null, "tx-eip7702": { "account": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", - "proxyAddr": "0x417fe11f58b6a2d089826b60722fbed1d2db96dd", - "authorizeTx": "0x09fd47ebbdfe396288c03b04fd643183097559faff558e5cfbf64cdc1a224d4c" + "proxyAddr": "0x4dc5e971f8b11ace4f21d40b0ede74a07940f356", + "authorizeTx": "0x64c47531984e4099548b480b5af0bce04ab89d29f2fe7ae36e97ba68d688539f" }, "tx-emit-eip1559": [ { - "txhash": "0xaceca283c1a65deea29cfb78389fb2dc90df8ac9426d63d83c9fe67cb0cb7839", + "txhash": "0xf3b025eaf924500c53bc0b9f0f5733d56b59b7dade1df336ba8b39c83d92ac57", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x7", "indexInBlock": 0, @@ -29,433 +29,433 @@ "logtopic1": "0x3569f740e521d8bb11c5b72660dc96272ad66bfd811ed918c3a9e02acd4ade8f" }, { - "txhash": "0xd463f0b9ea6530b1d24d8b8b7021979d48dac8452ed957fb722263a5a1b5ed08", + "txhash": "0x62da81199d8ac0d4231dec90c6085f1153a58eba6bbac04f71da4d5076c9b7c1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14", + "block": "0x15", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xcb55d89f2ee070d017b426876d6072d91c2a7311ade9a1bed2f8200127ec380e" + "logtopic1": "0xf77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e90355629" }, { - "txhash": "0xe131203a45328fe320b0820698177e8ad2f3b3ee8c552787ddb1db725a2c4484", + "txhash": "0x7a8c4456e604a0b6210f29c6e68405d2ca5425fdce16bfcc6dfa3d3904b32740", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f", + "block": "0x20", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x73286395f2a86bb5537d9b45ca7c681044645f31475a11d49285d6a0f028b8f0" + "logtopic1": "0x415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce" }, { - "txhash": "0x4cee3118350175e8ddab6edac9672440c672baea4c9eecd53e4dd411a978a990", + "txhash": "0xd1ec37a2bc2841c4dc61de447dbe772a92284714f03752bc4056eafdac74dc21", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2a", + "block": "0x2b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x35f96bc70aa62a539fa99d9153b0f8aaa4594abf70cc8a8d9018e04e39a17982" + "logtopic1": "0x89c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e56" }, { - "txhash": "0x0cdaf3e63a21eacdaf83b844b5ee98f7ea540667d68f6c527af01a8724bd23b1", + "txhash": "0xa2b3275339e1237e6918726e0f0906f7f6a70a069cfefd3d9b5380e67c2d1305", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x35", + "block": "0x36", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xefcb86facadbec33b8779888975eacca8f44a9073a845521617f1fb30e1ac818" + "logtopic1": "0x9038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce5" }, { - "txhash": "0xd2a4dda75edef4c514a21ca9167f310fe3d296497ab78e66a2861d07dbe38585", + "txhash": "0xc488c5aac30312fe8365ed78fc6cc12b531f9cfc315e6ec5ddb610eac4a48976", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x40", + "block": "0x41", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x905cfe802dc4c667312ea08fdbe97798b88cfb11049ade2b18ad9001e8b6dd7c" + "logtopic1": "0x4b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb3" }, { - "txhash": "0xfeb2fe04b5241685c79ee42b624b2144a8c6e2871e12d2da75d39b03a9b9a950", + "txhash": "0x7b43a1b8ddf97ab6ccb6dcab385184d1a1165e3c221013b34448223af45fc832", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4b", + "block": "0x4c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0d968817f6ab6815faa1501ac1eafc810f4bc9b7423abc4f1bd5e65e791b4e0b" + "logtopic1": "0x41565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c" }, { - "txhash": "0x3d08d1fdf8a7b74fe2af54dcff575b87ff4c0203810df3647ba2a02793710b5e", + "txhash": "0x8954b9d95e7b0d5a726847449419e1cf77a624199e1fa89f311150dcac94b361", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x56", + "block": "0x57", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa0634d80c0a702c2b06dfe60ace0d8f788b99406f1d2ac44ad3a26faa3fc1464" + "logtopic1": "0x00f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed" }, { - "txhash": "0x8be5109fe8dddab4ee47ee4ea8e5c1973eeedcf13749be4e4fca93d9c0550a6e", + "txhash": "0xb2749d3a5d1b062f85a4717ee5c3a7a686a31b03ecb2e29394bce32e15bc3e08", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x61", + "block": "0x62", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x50495437ee69f7b12c5d6eb55cdcd8f5ce12a2eac21a2a42a7549e9f5289b1fb" + "logtopic1": "0x761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd" }, { - "txhash": "0x37d1d547768ea14ceef7274f5f24c8bfeabe795faf8626556a6688a4b72485a3", + "txhash": "0xbf2b014779d3872e5b8ae89c65d8c5912e60c459698f44f7281b9f14e03e6baf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x6c", + "block": "0x6d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x59b1019e8b01471b1dd478e65c30667d2d1780ed0c8bf5fc784b1413789b2f82" + "logtopic1": "0x468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da8" }, { - "txhash": "0xf2fc33ca3b9e09c698e75ddef6db493d606edc4d36803966341cc0937be3dcb1", + "txhash": "0x1d27789de7fbb33eed6c51da18ee5e7cef7b242046842d42141cfb7f4893b624", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x77", + "block": "0x78", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x47cd31a1b89686fa610642222d2da6119e54ee8ca761bd01a649e3759e47746c" + "logtopic1": "0xdbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f5" }, { - "txhash": "0xe6cd7289688ee233a5cc20add1ce439e3faee022bb954c80b84b4ce3c84690d4", + "txhash": "0x48369062975939c17e4695b1368d7a1e0b60d145662ef9ba0b7a61b39c3f2cd4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x82", + "block": "0x83", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x562f817652b4478bc1e434240cd21e00774a5a1210833cbf0225273e2b98bae2" + "logtopic1": "0x7a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea45003034" }, { - "txhash": "0xda6e57b6ed17f0591bb5313cc927800303bae5fcb20507a1eae0d5c24b4da809", + "txhash": "0x7fbb4a27af5e59af9219a6b3a63b8cedf03d7f4601f1cdb83d12ccb85f50d315", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x8d", + "block": "0x8e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb9f03edd278ccfc90e45785c1fea3f972618a32899f836dd4fe0e63eaf8c7c40" + "logtopic1": "0x2df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f2984" }, { - "txhash": "0x3e01b65976317255bd0ebd2ed6e506c7c44671e5786302052367a9d9c5fe1b70", + "txhash": "0xcaf24c0839480fea158a7ab6ef75a23ef77474cfd9ab3c8ac081a945aab21c4e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x98", + "block": "0x99", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x72be914df22404e1ed45a8224b52201a77605d52065746a00af5f60980fa4c99" + "logtopic1": "0xf8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b" }, { - "txhash": "0xfc6bafe4ad86d5d2343cdcaa2d695050931b1d2a49a63e5be4deccd97b84bcaf", + "txhash": "0xdae00232b88d3b90d09205f957ad48386379d37ac2d5540d8af9fe9d553fdbda", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa3", + "block": "0xa4", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xff5c526fc525d03cecce39f4ec167af09f80525e2d44e60ee4df33a357b24ed2" + "logtopic1": "0x85ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da97" }, { - "txhash": "0x687bb7707e54385064c6b22425f9ad06fa0377ee68b8bab7ffe34f592c79b8d5", + "txhash": "0xa10cd97b8629e989007f80e56895aefd1c1e989dbf217ea151b283f86acb2a06", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xae", + "block": "0xaf", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x87fc0239418406958902bcd8e059f9ddc08fb2683a4be0cfd47b1eb97418be1e" + "logtopic1": "0x73b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b28" }, { - "txhash": "0x20add83f7f234cace1af3d3bfc50e28ad885767711f4a143f397b09359999353", + "txhash": "0xaea435d689fd6296e3cce8d5804b780ce50074f43d6fe6181de0342698eab582", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb9", + "block": "0xba", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x85c0042b81b23b846d1e4881b0131b4bbff774dd9bdece2e74fa92ebdb053c34" + "logtopic1": "0x46765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc97928010" }, { - "txhash": "0x5133df1193a2f8e63c0eee29b4cf93edad7b35ec68e5bdd214d959096b330aa2", + "txhash": "0x97ed8f06347509fcd1ad5b8e81c69d3aa2b17f614923eeb028932a7cd68be7a4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc4", + "block": "0xc5", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x32984cfbb954e0815427570f4ceaef21a3691026950e5ad80401232f687620e7" + "logtopic1": "0xd0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba" }, { - "txhash": "0xa2c5369f2abed72c2a9826e79228b372e4b1a387e5832965af5d0d874df68576", + "txhash": "0x85bdef644e1d4dd68f8d748f29ff0047b55ec15731f700b2c9a7aec250a70031", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xcf", + "block": "0xd0", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd34d30c2584168001b907965762f784cb4337381aa8090ae36bc66bd515849b5" + "logtopic1": "0x4323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c4" }, { - "txhash": "0x82abb81ce6873ac4e3dda7b2276c80923283f8a43671eed167b41720f6bdbb27", + "txhash": "0x81eed80ddf014a4ca8e043b52302f20d4f0ccb6a9ff9b595abcb3ee027977be0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xda", + "block": "0xdb", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3982f6a73961b17f67a84959ebc42a5a3ebdd1faa925399f3f276cc2de65f2fb" + "logtopic1": "0x81607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa5" }, { - "txhash": "0x302d4582613dfd96d4c9e18bfecb1017f40a8d8313ef13356e1885575d21622f", + "txhash": "0x7ad3bf852c70e27efab2e2dcb39dead02b88818efbbd12b7aa0633541f7b3f38", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe5", + "block": "0xe6", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x782a285a3a645a32202a71e713e4a813bbaef9f50ce10e4caa0122c110d86bf6" + "logtopic1": "0xb36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a6" }, { - "txhash": "0xaab104ba3538ee8a11349279ac0ba9374cff8b325fbbadab6bac24828f297a49", + "txhash": "0x4aef6e5f54a5115cffe06cf73a588815fa873ef550c94e89713678889585c6e0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf0", + "block": "0xf1", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x44dc9099d91b074b843002013672df4de9f691cf60546fa74eccafa9044a75a2" + "logtopic1": "0x40c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b81938" }, { - "txhash": "0xc6c2d288432ce16555d12b522398b07beb749eb44f6162c4d71c90670b59df79", + "txhash": "0xee20ead2bc204a4049915c4996e332b148ff187fc4653058dbf0df9e73b451c2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xfb", + "block": "0xfc", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1bf804b21bbd284f3f59e4862747fabb1d91cd202d99df811fbcd650c8916ef1" + "logtopic1": "0xa22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b8" }, { - "txhash": "0x205e93a639805b8104b073a1aac798821403d8deeac62a463f934df64907808f", + "txhash": "0xc46b84e641877cab5374c169a802c50ed4bbb63a4be91a2d2e9ea62cc3bed0d7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x106", + "block": "0x107", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x628887ea9304aeb7f3934543b9d14ab4e7e5cd422ba572d39d6ee10c33045345" + "logtopic1": "0xac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba" }, { - "txhash": "0x64e12e4bcceab36795d18fa5758676bd96d4f6ae943c206bba9782dc96c3ef6b", + "txhash": "0x38e848949e94f3d41ba77dd36fda8159401263178046316cf1d2321999101cd9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x111", + "block": "0x112", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xee181b97fd68754f6245c655a0a0686e8d12aa4eac5f1d059e7e3b8d6a924073" + "logtopic1": "0x4edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c" }, { - "txhash": "0xfce43c4ea272fb22e6443782eee4d50c567c17e7e9def4573569778f0ac8558a", + "txhash": "0xe1bbc32cee7b6f6ff8477171315df665b211dac38a64c519aa32402dea5cb675", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x11c", + "block": "0x11d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xf0ca8a88096a033508993a424f4e40ee1d800f62390dfe4ed5dd74a0f6785e25" + "logtopic1": "0x0678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab942" }, { - "txhash": "0x92457c1dd22ebbf0c6b477646b4efa376d5f5c4a55b8cc267e84304b61ca2449", + "txhash": "0x9615de1a110d38ec38ef96054453067bec5e39472ce177d0fbc8523b503edfef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x127", + "block": "0x128", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd2dcfcdea157f70f8422558eb02bdc6a503cf24126f8f2dc2b52a644f5f02271" + "logtopic1": "0xb3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec0" }, { - "txhash": "0x99a7fc49256d1f8092db5990270645ab9a4d96b49fb9224bafe6fddb7f6f86f0", + "txhash": "0x9393ec29fb5a5d71fceec3dc7301afa92a3792d77a2c1be6a29be162cd822e26", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x132", + "block": "0x133", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4d4855c520c09f3435e2cb46ceb4d2a12df59c127a1f2e871e7e9e8203fd6ce1" + "logtopic1": "0x38570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e8" }, { - "txhash": "0xcf272615d5e4bf4555cf867154234f5df2e230442c1c87508c051e407e2811d7", + "txhash": "0x3f51ad5645ecb1d7229406838378a0f949a2703afba50a615d7efe57a90cf669", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x13d", + "block": "0x13e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x8a76d1e2fd58cc0018aa306e83990d74d16ba9aeab4794595fc72551f0465476" + "logtopic1": "0xd5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f20423" }, { - "txhash": "0x26501c0425d7865224b5b38b85ec90d07881f213813c81f85aa863c94109bd64", + "txhash": "0x038b847a33bab554aa0ff0219acb7475ab1c51415337790b78a2a41664194361", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x148", + "block": "0x149", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7a63090121e41c76eee07564883abe3bd839fb20a0d2513bc9bc524f6c16f88a" + "logtopic1": "0xb5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac7541" }, { - "txhash": "0x49249dfc575b61369ae47f58f81cd66315038672a912cb900babfa535e52ed9f", + "txhash": "0xbbff97fbb8a0fd1716b8f33e0f5b56017a9657eac41585f95559845293a34e8f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x153", + "block": "0x154", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc4f8d20ccba0b50d46d9c87f28cebf8c165fced694a2b34412a4b6153b987a17" + "logtopic1": "0xa3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c" }, { - "txhash": "0x0f88d2f5193f44c1595c53019d68fce6fe715e2f9aa8fa4edd751546cbc21475", + "txhash": "0x72c15fd124c1097b19c923848c9b14fd73511db3416327885c156ad62252efdb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x15e", + "block": "0x15f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4b916e15bdb0f5b4bccaa3447694db53cc34095b5bc26299c14a9f573bd6c758" + "logtopic1": "0xcd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd" }, { - "txhash": "0xa164fc90c20e70842b76427eaca6ef266fa3ba71e933c5ce9df68d2e817f6197", + "txhash": "0xc7baf1ea1dd369c9955b15edc0e2644083c227cfdd165f83ef6025ed6b02c344", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x169", + "block": "0x16a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7975cc1088361453b019ff19e2177b264cfea56f4c09b1a8a086f6c405dd516c" + "logtopic1": "0x490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b26723" }, { - "txhash": "0x25b5c50473f34a2940ccccf2080dbd466a264e936c2a38ee6b1410ee4d5798e5", + "txhash": "0x2e221c13d1a9566863bbf42cc0cbefe015613bbd7e9e19b46a2484f4fc81fcac", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x174", + "block": "0x175", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x5423899586eb1d932cb9da03e478e1dd5d4cbbcb66d24262c7d67e543185c2ef" + "logtopic1": "0xcb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d8" }, { - "txhash": "0x14f08427a199620151f7cbe9d4d4a6a6b087e41e294e80ac23d7bb89e9100378", + "txhash": "0xa1af8ade321526f139ceb3e76fa12522a5d5cdac78deb81c0f49cbb5b4a9e93e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x17f", + "block": "0x180", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x187c8bbc8cd3f478b5688bc03cf5eda82ee75aa605e946b39ed1898f0cc0e00f" + "logtopic1": "0xafc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a" }, { - "txhash": "0x5b5626eb904ccbd5e3f96a12ae819a7997238d6950a6eead7e55171e9c8aab3f", + "txhash": "0xab12c172b674032a76a6bfdf79ecc0846d337953d23523fcb709c119cded3f4c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18a", + "block": "0x18b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1bf8eef1506aea16c94dd534ab271dfdae26648de569b3bf6fc8bf4c76bd1a99" + "logtopic1": "0x1f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e45" }, { - "txhash": "0xece63f7c604356e632fdd80e92222629c86f470612feabf2e7059fdb7d09a11d", + "txhash": "0xb5062802b3ebe1a560d0a84ae7405ace74a3bc1b04cbdc0f88a0e894b7cfc90c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x195", + "block": "0x196", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x434e2bcc5f4148668dd618144aac33ef5d463b292b3baad302a60aeb6be03b86" + "logtopic1": "0x19fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c" }, { - "txhash": "0x5b8bef43f888a81d06bb9757ebfbc240f379bcdfef6efbefd76c6974a2b844be", + "txhash": "0x9e3599809a88b599b80114ddf4d2f7c38be757f998b0914954553abc81206fa7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a0", + "block": "0x1a1", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7b95105ef96b105a85277c69993f6f56602d912fe712ddf6156cdfcd8c490607" + "logtopic1": "0xfb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba" }, { - "txhash": "0x1e0ee081c4d5b43e12ed4eb80f14a1519f6e47f1d2ed7d88eea2097b1f2fa0db", + "txhash": "0x4a2eb0bf09b80def14f483a6175281c4067fd2eb220cc47707130d3b14f0fb8c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ab", + "block": "0x1ac", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x2ecc9be98f9a8adac6e6acc5f160b0d15439b3856f0dee2a3005db79076252a1" + "logtopic1": "0xa90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c82" }, { - "txhash": "0x4a2c9d2193f39a13e47237e14bd645267a17d3f096fd7ee6646ec0f4b71ea82e", + "txhash": "0x6cc89bb432f442a20c17b618b075e052f9eebcecc39b21776af49a4cff501bfa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b6", + "block": "0x1b7", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc452b6d808f45af81c3310dcf94a1704359eafc34709c45b0c7b95adf4cd02af" + "logtopic1": "0x75eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de0" }, { - "txhash": "0x5d0a088f57e56aeaaff5958232ae8a0e4846cee85333b465d43c4462714558d0", + "txhash": "0x509133ac59b43f8954559fc0234228110b81c7272b9db1112828ee03d407030a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c1", + "block": "0x1c2", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7eae9da1da48fe866f64de7ac5c70c8e43644867b917aa8461f84915396d3598" + "logtopic1": "0x2aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f9" }, { - "txhash": "0x169f28d6c3062de156f293def5ccad7deff2211443ffd2a44e3e1a711df25478", + "txhash": "0x900a3e1ca48e9a476a45fe3d0f88a8b40134ca59f902719ff75db2b7a361a06b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1cc", + "block": "0x1cd", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x492ae6c575840126917090c30d003aec0892cd6250f877b99f33b72133b94f23" + "logtopic1": "0x41b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a0718" }, { - "txhash": "0xa1deb6e1a31c1eefc0b4348baddcd41b9671fa0189eb32643fde34dfd21a1774", + "txhash": "0x7dfe4a0c877a5193b0f3180e2d8465ee5f042e420f740edd72139dcbdbb46d56", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d7", + "block": "0x1d8", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc8bbb420578d2d80897ca392a55fce5e4834f1d641472c0fd6a9698b7a8e7866" + "logtopic1": "0xca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b97" }, { - "txhash": "0x383b1359ef9168e0c519618b865a0b2bd246f40574f854c56b3dfab642a4c5bd", + "txhash": "0xe67e670bef823b90351ae0811db0c4b167a6549543345128309c0281ef8365d8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e2", + "block": "0x1e3", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3a970a6d07c991261dcb566f26d21a76c578d05d1565c47dbc1fc071934c8c43" + "logtopic1": "0xd1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb" }, { - "txhash": "0x17551b7e94b2b97a41b94ac50c71106bfa09ea50ea92512fb63057557c05a644", + "txhash": "0x8f376b2834fec36a91e856fb0e7b85db94d2d764b6131f064cbb9d796bfb2a19", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ed", + "block": "0x1ee", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x51524a498a88953303410a83d67c2b8c69ddafeb99b570accaaed774fbc8583e" + "logtopic1": "0xa6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c" }, { - "txhash": "0xd2d67b7bee59a1bc320887f03e4c39e9c771af365a2949b53621402857985a7a", + "txhash": "0x66485193e1246cf388f2f6702307d7ddb4dc665b6d98a61b1e603a667b62254f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f8", + "block": "0x1f9", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x96c0d209b0a5b8b06947cc4c7ca723df55c5b972711b6c08ec7b9c393fa6e8ea" + "logtopic1": "0x0a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb0" }, { - "txhash": "0xb826afbbbb480140ac552e49ffb3985f7d3dfe9f37dcb3271ec5c35d71c9c844", + "txhash": "0x487fb2870d14ac9e4df7b20b32afc3b499e69233aacdd983714ca9a879a690ad", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x203", + "block": "0x204", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x39410f5a8f450e0b7fe63aa93e214a7c5cbe78786c815ebc926f1e8a2a14f4bb" + "logtopic1": "0xb50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e823" }, { - "txhash": "0x5be0a9f1701d01528926726a6a63fda07641d87172d1138b3a76c15af80cf396", + "txhash": "0xb4226c093edab69c51ae8c63ae4572b7a5084fb3943e11d192b0587480f61827", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x20e", + "block": "0x20f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x075a739ccce514f063220aa4bb66f08a7966189b0f24a2c5ad4692133d7aa6cb" + "logtopic1": "0xc6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f18" }, { - "txhash": "0xdf443c6601c8656a7bffdfb38d9cc4ec15c324ed50e099546f2a548d1fd6bf6a", + "txhash": "0x4d1eb4c4f40faf9774d150502f66f0c95cea371c61340d48fdbda852d459716b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x219", + "block": "0x21a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9f5941a130f6c2ff98ec21bb2517998dc5c8512230dcb37ede3cb8a4694175ab" + "logtopic1": "0xb296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed7" }, { - "txhash": "0x5c94f25cebcaeaea9dce953b49dafa01f5ebab6bab84ac85257a4df50d216ff5", + "txhash": "0x6adc552ebbb9b37ef662251ae9625857551100f6560033b09f70b7f3be3e673c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x224", + "block": "0x225", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x30335bc132be5a5f3bf464e0eed03a3c74f180cb9906552e187e4c04f024b804" + "logtopic1": "0x142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f" }, { - "txhash": "0xd7ea9612e78bfd71cd959c1bb7b860fb96010f6132326724dd4fe1cd89262928", + "txhash": "0x65adf12f5b8c2e24801a6845adbc615d2b58294f8019572e9ad56921f34507d2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x22f", + "block": "0x230", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc668aa05d66c2f88a95db12354386f3b6a1722a98aade506e117201f2fd0511f" + "logtopic1": "0xa99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc8237" }, { - "txhash": "0x71f54b7f3f4acfdb51b3bc5e822e3a491a6a892b9ef7dee7493d38f135d69df5", + "txhash": "0xf58d4acaa927394b8be4a4a5c2f8594cdd47d6b994f86b40190628fac65891d0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23a", + "block": "0x23b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xfc6dfdea8f35e8af49faf38c0164a3deacd65c3927eeece6023868f32fd382a7" + "logtopic1": "0xb9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f49883" }, { - "txhash": "0x34c7189ae7c5894d908d9df8038d9f15d46bf8fef3b44c179f4bf5c194a49963", + "txhash": "0x61d683cbcc73112161fba6dfd3ec9c70339854e7986be731313162e6a571c9a4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x245", + "block": "0x246", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x14ec3dfb63100132cf23ef71b80689146033fc6ceb9f8c0f0a65ef93cd18c2c7" + "logtopic1": "0xe0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a71" }, { - "txhash": "0x801afe1e8d16b2fa9dca00d4ce5aca48efe8cfb7fedaa9ca4e60e3ec5ba7e9ce", + "txhash": "0x9ccd92d4101101b304db4ed5b25e14444900774ba9a8659f01846da9b8f95660", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x250", + "block": "0x251", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x5571137d48f7d081e62051a6bbca9d1e25c93ac6f84b7a3bc146f126ac80928d" + "logtopic1": "0x701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef" } ], "tx-emit-eip2930": [ { - "txhash": "0xc9303fcbe3f18d9b5f259e62f7b59d8fe7ef6545b301a3022610c8cc32e3d12a", + "txhash": "0x76f2917dfdad8c636c493258e672938661a2044a05338bbad7d14d446fae4d45", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x8", "indexInBlock": 0, @@ -463,433 +463,433 @@ "logtopic1": "0x881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a7" }, { - "txhash": "0xe7ec4729b421badeb6aeae0214ad958c9b51516d617f089dc8fbd514380630de", + "txhash": "0x30fc0bab35d4325db37b953f5cf26e05f2c18593adcc4c14c8fb04b28501c2c5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x15", + "block": "0x16", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xf77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e90355629" + "logtopic1": "0xa41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b" }, { - "txhash": "0x06e43cd84b25d35ea82b3b04c4778d565b7370b2551b36382bb0e971d27961fb", + "txhash": "0x07032ce65db029864ffcc0c3b00ed01bf8fa90da0efc781ecf517920ed762304", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x20", + "block": "0x21", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce" + "logtopic1": "0xb2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f970" }, { - "txhash": "0x414663e2a0b7c8300c9e4f7f6836ff392e626ac8442023e81f479028e0bef79b", + "txhash": "0x61a1ed16c11ef4e4c8036233b87753a761be8c9702514ea87fe3bc82345bbbba", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2b", + "block": "0x2c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x89c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e56" + "logtopic1": "0x11f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa" }, { - "txhash": "0xc6fa80c16effc705553d70ec5776c402eaaceee2ecb41dc444da158ed0166d8a", + "txhash": "0x24a0922096c6a6b34668d0b06c4724db961e3b4c462c6fa645517e19293ec37d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x36", + "block": "0x37", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce5" + "logtopic1": "0x8460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba22" }, { - "txhash": "0x84efb3f3887121d539cadf5e973689d70d91389fc03435e4f51ad361d089ce19", + "txhash": "0xdce27eb7c2b44d61022e4923329a9b18f0dd26093a88dd5efa772fb1e52273eb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x41", + "block": "0x42", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb3" + "logtopic1": "0xe7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f" }, { - "txhash": "0x9fad4904eed2887e05f4f5d2152f2c89a36d9d936c29c50a7ce7601effd8b19c", + "txhash": "0xdb7b8df9ad36fc8838cfedc2f272cb205f7ad2860cd1f5ac5e739ed1a2973784", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4c", + "block": "0x4d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x41565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c" + "logtopic1": "0x24a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad69079" }, { - "txhash": "0xeb53887ad3621080290ea5f1ea0adf1f8085bec14df74c5b81b3c7efe4b7efde", + "txhash": "0xccf0da8511e51af458ef4ea7734531fdb77b8bb48191efd8257cf6ac16daf3f6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x57", + "block": "0x58", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x00f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed" + "logtopic1": "0x7c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d525" }, { - "txhash": "0xbc3f4e9e137c2e0c8973401ad6f64795c04b7d47ac215feb6011aa9a7ed03c7d", + "txhash": "0xe78dac2c962f7fc240909233c4b8bbf47a6ab4b9b3b4376ecb92a4eff4e147e3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x62", + "block": "0x63", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd" + "logtopic1": "0x02bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f413" }, { - "txhash": "0x86c2c4e5a08428efde69db7036025b1349438f22d85c2bbc9714544473f984d0", + "txhash": "0x2e5f23d99b09fd9f81f2fc7013c3a3bd8fea88bd6df07e2b236addad4e9e94e3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x6d", + "block": "0x6e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da8" + "logtopic1": "0x0dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f2" }, { - "txhash": "0x90439c435817e3a77f33a7746c3f79961ecd321fab300519708d661fc7ec65eb", + "txhash": "0x37010507fe716034116f8d945ce2bc35d3718e7c10b78ba34e4ddf780c6063b7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x78", + "block": "0x79", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xdbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f5" + "logtopic1": "0x0f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f" }, { - "txhash": "0x88792d2ea77fce18827a27f02f6aaf54824e5bd6e60215e26e69fe73d00de657", + "txhash": "0xb53c6450c32830cf3be18b73370a0a290a12acbf4d734e8ad8785d4742e8035b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x83", + "block": "0x84", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea45003034" + "logtopic1": "0x2daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c6" }, { - "txhash": "0x1492acea121d6e2e74507e43a99ed8146c57ed80720f2d108cf9c31a22cb5951", + "txhash": "0xb7b48df8d1f44601669025fe789c2a5aa05771ac35ea90bd5bef536ecdc4f92e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x8e", + "block": "0x8f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x2df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f2984" + "logtopic1": "0xfaca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda7" }, { - "txhash": "0x36c80351a5e5b1af63afa0bcf9b3ba0cbda0ec541b3744977b7f049654c54eef", + "txhash": "0x938a5fc80f6fbdf6d5c8838458e4695f0b8fca8db7fc49ead340ed4f0ca2b3d3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x99", + "block": "0x9a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xf8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b" + "logtopic1": "0xe6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c2" }, { - "txhash": "0x15417bc19302807aa8dfa6e7f27d558b7bc3cc63fe1e420ed02cb33d0b7098ab", + "txhash": "0xe3d00022dd63b6705c7eab12a15ad5f279b99eeff670bf4316d4ccda0045f324", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa4", + "block": "0xa5", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x85ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da97" + "logtopic1": "0x6a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf53" }, { - "txhash": "0x02ffd0bf00551df3bdba55994ac9ace84b08169515ca7ad46018caf13cfcfe15", + "txhash": "0xc0f5f7053ddfd90bf909cba8f2d0ba8ec3f5ac2f9efdf7d44f6e632d02d77d51", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xaf", + "block": "0xb0", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x73b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b28" + "logtopic1": "0xbdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e" }, { - "txhash": "0x322d17f7800f157cab844c56b8997f73a4af682c2b9d1896e7febd234f5e3055", + "txhash": "0x06b8f91efd631d83bbc3cabc57e6e4dd311e638f32c0bcd0e2bde98454cde233", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xba", + "block": "0xbb", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x46765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc97928010" + "logtopic1": "0x23c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf6" }, { - "txhash": "0x58e2dd04291740326a8f8fe3475781d8c1dee08176a2ae44eadac4c7518c6bcc", + "txhash": "0x9dbd1ff97745b8fd334b4a2bc75ccaa32ded0c9bfb954baba7f5d9bb7280e6e7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc5", + "block": "0xc6", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba" + "logtopic1": "0x3c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e7" }, { - "txhash": "0x095eb45d2c81cff8a691af38b0b7e3bbf69a77a740a8362f8ad4d7e710de08de", + "txhash": "0xa214e938f072e94479207b9fb4c2c5a247acdd9d6ae0af03d31783495bd82219", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd0", + "block": "0xd1", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c4" + "logtopic1": "0x5d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f4" }, { - "txhash": "0xf69b4d268ccdd64739eb9f74d76e06b6d7ed43e1e86d0d6e7deef093826718f5", + "txhash": "0x24f06cd0fe391480eb99730d94c35fbba76cf55fc51c58a6afb25a1629e86964", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xdb", + "block": "0xdc", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x81607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa5" + "logtopic1": "0xe207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b" }, { - "txhash": "0x8e430bb7a64d7757860a881f31b721c8457b80b69332dd67668be803f48e5d35", + "txhash": "0x5a93049aaace1c9fdcfa440ede274acc58613f8476bfd80d17cc67a289481551", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe6", + "block": "0xe7", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a6" + "logtopic1": "0x18fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b56" }, { - "txhash": "0x61f149d4cfff2ec32410a4684600ef4dff10be09284ae170d4693b9590642e14", + "txhash": "0xbab062324e2bd4efa01fba78c887d8893e40aa9cfb2af72a115877cdbba7efc1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf1", + "block": "0xf2", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x40c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b81938" + "logtopic1": "0xe8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d83463" }, { - "txhash": "0x7ca86b15d7e14a9bbe4a012edf616f8341625a032c2bfb16b0361742165b6033", + "txhash": "0x88411eed62ba108205b74c16cb97c78eb5e670c73a462c81892decf6caf83b48", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xfc", + "block": "0xfd", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b8" + "logtopic1": "0x9138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea58328" }, { - "txhash": "0xd9fca30f3482e9d19271c9f1223ced48fd7e315ca4d0ea28c038afa16ba17d3f", + "txhash": "0x79f84618f37ce72b674e601cb0a4305f2995911efc8cc403de6fee482f34acc3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x107", + "block": "0x108", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba" + "logtopic1": "0x4348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c9" }, { - "txhash": "0xb5bd2b2a1e89dbfc78b28316727a351716033e8968a5832f0fc6f5fad06061a3", + "txhash": "0xe46b05ec347dd18d056a9318a43b3d196e0c493c56cda202b97ee26f9b132af1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x112", + "block": "0x113", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c" + "logtopic1": "0xaf1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa" }, { - "txhash": "0xa620915661e953c73734bc32bb5d340ff2616906dd600a08a777c02f01a752cd", + "txhash": "0xf67bb9d97909efffb323cd48f9547bf08c5051bf1bb9ea58c2e7e9929e9b5a0b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x11d", + "block": "0x11e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab942" + "logtopic1": "0x81260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f9" }, { - "txhash": "0x792c9815f48f974bb737f43e351015f573dde750d3c5bc2ecf78524381addc46", + "txhash": "0x49a00cf1ab0cac049709ad4d7d7a18c5622fa59abc25e0f33f3319c154f27a69", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x128", + "block": "0x129", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec0" + "logtopic1": "0xf9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb1" }, { - "txhash": "0x66f4a947f820d53549e32402217beb1fa688d0a3a9df01393883b43add1af7ba", + "txhash": "0x5490dad7b381c41f8492dac1d97b40465a0291c0a9ad625c4a53d5ef74ba78e7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x133", + "block": "0x134", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x38570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e8" + "logtopic1": "0xbefb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb546" }, { - "txhash": "0xd62159aaeae3823a577e60ec54af48a461c39a2a8d84db012ba6cf9f9716e65a", + "txhash": "0x2f02d65eb6718a9fb37ad3ac3b7811d45a161b9e07681b8b17892929212caa94", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x13e", + "block": "0x13f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f20423" + "logtopic1": "0x9575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc1391308" }, { - "txhash": "0xa5c399b1c83feee457bd10e9cb5443f4184e28f49d44aa75432061e3b379934b", + "txhash": "0x3e1aacd5bbb49d73201c1b91c53abf7a7dc9633d7e4a9eeb1acb248cfd6299bb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x149", + "block": "0x14a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac7541" + "logtopic1": "0xa791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce857" }, { - "txhash": "0xdf6e0917de58a976925e579a3bf7be58bc52009f6307ca89aea3564ea78059dc", + "txhash": "0x9eefff22b8fc296d66b4c0892dd021090efc184974347ba86750265ee81f4967", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x154", + "block": "0x155", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c" + "logtopic1": "0x6df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f2" }, { - "txhash": "0xec034419430d4e6672f6e20c2145c4fadf17f3e06a3e821e9ca6a786c9b45515", + "txhash": "0x1c330cf34399c5116a1f0040282be248753e2b3deadf05ad719684e06ff62a75", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x15f", + "block": "0x160", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xcd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd" + "logtopic1": "0x40325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd" }, { - "txhash": "0xd1b8042da59f6d7a3f740c84f28c46cba7706397e581b7b9c5b2cc80f17586f4", + "txhash": "0x97e229b0d274161ce5acfe05d2770f44e1dc5f5c2390e0b001d227f01e1d56a4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16a", + "block": "0x16b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b26723" + "logtopic1": "0x039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a096" }, { - "txhash": "0x96566916710216635e35febde8ce995b9c109a38e5870706cf77279f609ddb98", + "txhash": "0x68e4f0d419f3f18f2f448f2a2a85eb33cedb8eb9baaae0c41052b3e5c5ab783a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x175", + "block": "0x176", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xcb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d8" + "logtopic1": "0x927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d" }, { - "txhash": "0x3d5e920028d1218989019830525bff1e6f08eb79953470d4f2692476849db51f", + "txhash": "0x4d02d96d7dff2017f1b95c045a61000ad1c2644f342fbdfe39eccc70f3feec7d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x180", + "block": "0x181", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xafc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a" + "logtopic1": "0xe2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a" }, { - "txhash": "0x4c04efa9772f455ce5d77eac6037dcf8f8a904d7849dcc139f1c98b9d90d0471", + "txhash": "0x731cb5ada167fa9cdb4b85e62eef892890f5f4310f548a6928a0aec9cfb361dc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18b", + "block": "0x18c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e45" + "logtopic1": "0x92da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a108" }, { - "txhash": "0x0ee54e10b675053fa6e447175e8a0e64af66d0f3c4938f5a545e392c329e1e73", + "txhash": "0x6acbb0bc12e52870c6fb5240ffb771f703d91f3d933ecb4a228693174787552a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x196", + "block": "0x197", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x19fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c" + "logtopic1": "0x677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a7" }, { - "txhash": "0x6bd480320bb019a63d45deeac7ed513db679147d411f6e8c7a884430d5e9f684", + "txhash": "0xd76726d4614e485b18408bc45046136e9cdd2d897485fe4e4dad69c9e849c3c1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a1", + "block": "0x1a2", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xfb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba" + "logtopic1": "0x250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a" }, { - "txhash": "0x27cdbcc53409169cfaf19ca3c19a424308dd879a53bfb34f0cb622e98341e09c", + "txhash": "0x238bb24148c083d631203d405f31779bf2f8cb674683d7cfaae0a45f33c6be8a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ac", + "block": "0x1ad", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c82" + "logtopic1": "0xcea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb65" }, { - "txhash": "0x691d488d31d23773b488470cbd25e0036b2bfa466ba08e951eea23b856f3f908", + "txhash": "0x29d488a18542c3622726b62f9e223c8b43a885c568d726aee959288cfdf7b3ad", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b7", + "block": "0x1b8", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x75eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de0" + "logtopic1": "0xe5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd963" }, { - "txhash": "0x8878d98141b90199635b3989109699d477c828c5faedf356781f6eb587c4344b", + "txhash": "0x1fe0e80aaeb234d31d5c78f52564efda7ffcd74817e6231c4598eadab68b8dc6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c2", + "block": "0x1c3", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x2aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f9" + "logtopic1": "0x6f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db" }, { - "txhash": "0xf59da47c6804c63a8634cc67a08092994451fdd5fa56b7225c40a67edc23e635", + "txhash": "0x05e939d864b0384a980615b891a60e3c7fd6fdd4f123a03a506c3deb1cd10bef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1cd", + "block": "0x1ce", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x41b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a0718" + "logtopic1": "0xfd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b5" }, { - "txhash": "0xeab623e58b8f2d54649a24878731423ef914b23194a1ffed91b143b877fd69f8", + "txhash": "0xfafb4b8d000ff550dbf4a1e3cc6b1f06ee2973d10dcddfedf7587ea72feefd5f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d8", + "block": "0x1d9", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b97" + "logtopic1": "0x506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda2" }, { - "txhash": "0x0f68375d9c8575badff105441ec3f3fa0227c2fd5015fd3fb288cab15a0dc269", + "txhash": "0xcd68404c240e22562bac6dbd9ac85f0807cd263e8b9b30ae67a0d515cae30cc0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e3", + "block": "0x1e4", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb" + "logtopic1": "0x27edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe3" }, { - "txhash": "0x5e1845a8cd15ad7e127cdede8899eb6a473e59045ad5cac8cbceac140b6ae52b", + "txhash": "0xf12ae2e38e424be45a18c6b0977c009de69f6f3993c34bfbd4ed40f0501def7f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ee", + "block": "0x1ef", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c" + "logtopic1": "0xbae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a19" }, { - "txhash": "0xa56dc267f90bde33765a9acdb6853250ea8405b0819e0884ddb2cd26af1ed262", + "txhash": "0xe8a619cde23c8746d4847eead4dbe79500af69f978bf0d7b8470432eef4a5a31", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f9", + "block": "0x1fa", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb0" + "logtopic1": "0x989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b" }, { - "txhash": "0xc97c6242194520c2185b98119eb572ff29243d6b86afe9e78209c2c0633f8e43", + "txhash": "0x2313cd696ec9c6a7b5ad21e9daa106264d9c382c0e3a067529a56d81a4511c96", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x204", + "block": "0x205", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e823" + "logtopic1": "0xe891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a" }, { - "txhash": "0x102f1c2680bb4bbde8b42b0ed2b27d0f53b0741f6bfafce3326300f0ba02d461", + "txhash": "0x602659a646a466a7044b066ece12a8ff17e34c2e6a4ca667bb794933f874e561", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x20f", + "block": "0x210", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f18" + "logtopic1": "0xab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df" }, { - "txhash": "0xf312429462bdb087f27b05d3485452aad3177090d1c834c4c3b1febae3ebdeb3", + "txhash": "0xfc39bd0e3451001fe930e70883bb945d8373dd99baa6964973d8aa3ac74a3d34", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21a", + "block": "0x21b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed7" + "logtopic1": "0x6c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a180874" }, { - "txhash": "0x6b99996554a4f85b731230f246e924a1d5c455311909d76074a378e2ad0dc344", + "txhash": "0xb1d7b6a1f9fc6af8bc3fd36d72e4d8682167af0c52dad7c1d63e755ace3afc3d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x225", + "block": "0x226", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f" + "logtopic1": "0xa344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d3" }, { - "txhash": "0xe0909f2b9a4d6b4064c61ed92c0914edf5bdc08ea9454cad75409f8edc2b99fc", + "txhash": "0x7f1eea64084e269d16f948a767155c7c0111865f58b9e91c3f7cbe30cec180e6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x230", + "block": "0x231", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc8237" + "logtopic1": "0x88edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c570" }, { - "txhash": "0xec379187efb4e736e8274e899cc4bc4b8c1f94596e67999d57ad1950a9e12e91", + "txhash": "0xde6513995c2989b0a314800a65da7a5aa3d3bb50215909aafcabce6063ebb69b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23b", + "block": "0x23c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f49883" + "logtopic1": "0x7a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe81068" }, { - "txhash": "0xeb7451aba7fe97573c34ea34bdf06b8782335c6de5ba4507aa55c799b1446032", + "txhash": "0x1669770dfc06f40ec72b287e27938ff69b1e3055d68ec6e33633da92108ddda0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x246", + "block": "0x247", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a71" + "logtopic1": "0xa0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d75" }, { - "txhash": "0x73bb7b0c0bfe122b47a7242c5cb85473bfb1b6ab532968acb36e2e95d28abd80", + "txhash": "0x50277d3afe5e049a21cb992cd83e0c069dcc5e5bb97963693fe480cdf48c204e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x251", + "block": "0x252", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef" + "logtopic1": "0x48ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc" } ], "tx-emit-eip4844": [ { - "txhash": "0xf420e289a5ee4f9f9741ede7f240216b93ddb6e9b6e54859db1d33e57edfb174", + "txhash": "0x87630fa02828dad0c04ea8ffa7c5d742bf6aac72b8b0a7e72a28b7d2c0d9fdcb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x9", "indexInBlock": 0, @@ -897,433 +897,433 @@ "logtopic1": "0x63cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f" }, { - "txhash": "0xd5b23faaf6a0054ef645601b6a3882ff63368c518afc2f6555408d35f41adab6", + "txhash": "0x75118b029d56f192f458f1a2a38238237f19c11f88eb97e0483ad26e021ae15c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16", + "block": "0x17", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b" + "logtopic1": "0xa6d01173df2aa437fb0118d181e64a8f8e05713fc01c42fbfd2250516639ae95" }, { - "txhash": "0xddcf88da9d1942ff808a887b92501dcd74b01cfb8031324b684a4ee29fb63c1b", + "txhash": "0x99ba6434209d91a5fc015f2c409877d1d5567287b64c46f984a64d631efa866d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21", + "block": "0x22", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f970" + "logtopic1": "0xe94d0b2545ec05c3ce3431c4d45c3b62fcab156563e8308fae1ebd27a2810c1a" }, { - "txhash": "0x45a0afbc813c5795a8a3f22ff93dfe6810a1557a96e1fb87c90e68d6e834bf6b", + "txhash": "0x17eced62882b234b280f2382a0225cf218e59de7124bd3d7214fa2da8b766188", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2c", + "block": "0x2d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x11f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa" + "logtopic1": "0x6551251b96ca27f3af8a2c500d6dd1ea5b9ab7002b3d923b66db0493f4a7123e" }, { - "txhash": "0x39bec15647bf657b5d91d4571f2e68e7c86705d521d48c09c35c2bd40eed7c0e", + "txhash": "0x7cb0ae261889695ae99b64ea9f6468a493f87b90fccf073761daf15ed4868551", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x37", + "block": "0x38", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x8460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba22" + "logtopic1": "0xfa29cff134420b6526f434ab690a9c3a140aa27b8479ae3d8d83b6c799acbc23" }, { - "txhash": "0x64505ad9b89241532e82029f9eae4c180ac6c32b09a29b1f452c92da1af320a9", + "txhash": "0x0e6a717775a24331736f5062466715bdf7a4330466d235a6ffdd746bffdcaf22", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x42", + "block": "0x43", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f" + "logtopic1": "0x412379b7f583981ea6e84408cba75ced69039e07ce9cdaa32a8a9dac997aaafb" }, { - "txhash": "0x7191d4d64827164b565c87480409d22354811d609572d1c2a314c86560fa4302", + "txhash": "0x153401e45e9053f121b36d88763bec1515553e3762cf5f46f4d125b0700435aa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4d", + "block": "0x4e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x24a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad69079" + "logtopic1": "0x87dfa85154edde1626e3a09196eab4b60f71887ec7b50ccbbe7ec76c0be6bdff" }, { - "txhash": "0xe94af7e94ff9b3cc7ec58666ef5333ffdd8cec10340e270f519ac5a95277eddf", + "txhash": "0x559f888f55e908ab3f4ad9d0d693b4d572ff9ab00058df6465cfe43722b45c6b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x58", + "block": "0x59", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d525" + "logtopic1": "0x6e2466f20ef20cb42d216dbf4a0d934199213e9b8d75bedc9c2d3e038a587474" }, { - "txhash": "0xade7523b78f2e5f6c67cd47e6d7e2f8011534e6ed32552d5bf8d8e5bc3a56d1c", + "txhash": "0x154de45bd8bde35c256318cb983131890d97b99689ec175d686cf88742e82fc9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x63", + "block": "0x64", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x02bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f413" + "logtopic1": "0xd75c9abb1414054ca164bba2f8c09917fb90c24789feaa311ee34a0b3f4a82f0" }, { - "txhash": "0x3292412496ffb7d9778bfb58cb3831b7faad4fd66db3d0eb781fc42acfff63cb", + "txhash": "0x67de1da7ebd65a1f384814112a0ef54c3907e09e18c8a0ddb5630a6883a3c8c5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x6e", + "block": "0x6f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f2" + "logtopic1": "0x165e0e0cc13ca53c5af4860637550364c5c90a512906490ace14efb534873741" }, { - "txhash": "0x647ebc00e9b4f1745b906d55709623d4565c4ee37cc43cce3294e86fbb06af9c", + "txhash": "0x478293db9f43eec14e4a54b90cb07d6e85e72095f3729d3f80c7e8c33f4b0f19", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x79", + "block": "0x7a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f" + "logtopic1": "0x16bee816935475cd45501fc5fd01bf913f8ef54330a43d80ef73101a4c728b34" }, { - "txhash": "0xb19cf34f280a82abe8279d9037a23cff23592f19805be3d08683929a618523ae", + "txhash": "0xd229b870b66a6c5452c88260ef6cc32ffa71363ddbd09340ccda6173af447fc8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x84", + "block": "0x85", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x2daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c6" + "logtopic1": "0xaf1f0d50933e49dd24b61a24c670809a5b875e3b746862636288dead8579dc4e" }, { - "txhash": "0x36f1fabea1bdec555c4febcf4c87ea5bcdf9ae5a1bd9a10726287649704d94c2", + "txhash": "0xf70f764ffe1e6c2e2770eab2bf0137ece8563607cc3578c8b0e76709105553fd", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x8f", + "block": "0x90", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xfaca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda7" + "logtopic1": "0x5b300d53be5798f53b472dadb8966674169ff3e8d08eccb3f065bd827abd7b77" }, { - "txhash": "0x4b518ca4f87136c909ff5c85233c42466d29a1a07991ad4e5a757d81c2b4c9f9", + "txhash": "0xdf9bcc5831652ac45ba42e4128e057379f8c3b6fb6aa602ff2c1e490ede09321", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9a", + "block": "0x9b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c2" + "logtopic1": "0x970a64830f255bfc38886621b37a7f1a7284bad6c4a04b6a2442ad212e19a6a2" }, { - "txhash": "0xfb9370f7667bbfae1f6223e3abff4af8464d2ae0639e915d7f33e0b8fd9db0b5", + "txhash": "0xadfcdf36179a98c790d47379913a53dd22487dbd7cb1110da530a0b93247d6fc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa5", + "block": "0xa6", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x6a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf53" + "logtopic1": "0x611f5b5e5ee263412fed40f169d0727f4e6e1a2bc94caf668d2bcf22cddca8c1" }, { - "txhash": "0x3673b0487371e7e696dafa1a8e4564fb345c950362dac3641d570b2f37018940", + "txhash": "0x89a19e25a99d212f59b3f9aa2767bc896e05ce9d1117fc048ae4fcbcdc83b8d6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb0", + "block": "0xb1", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xbdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e" + "logtopic1": "0x4632fe8e9579f33e2e42e68811d49a09ad1af1f01a68e7ae742f765e8e797ff8" }, { - "txhash": "0x1117f306b532c07bc696dd2b53a66fc8ea8c7be319c8db8149b13a564d9964eb", + "txhash": "0xd20b4075e81e20237b969c5e1859b24ed57dd08e7995dc33ddfaf3d13a5077a3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xbb", + "block": "0xbc", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x23c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf6" + "logtopic1": "0x205bcc2489f954a3af7a16da4d6042a75fcd6eb69b848c52b3448acb24b23580" }, { - "txhash": "0xd589b01ccc4b4c2004a2bd5b3f83fe8749ecce32dc8d96b3a5ee0be0b452374d", + "txhash": "0x5836c415ab49b17a68c21b26c484e9a2a7d6ed3ae02d915be819657b2f0d87b5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc6", + "block": "0xc7", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e7" + "logtopic1": "0x0a2bc3fd72bd3f8bb7f1de9a7dc9e928a7c6a831237124e65c60c25f8348af19" }, { - "txhash": "0x2ae3fdf2e8671f02c712cc2f0ed0a64464e2b3eb69324b4b3291adc850eafb4c", + "txhash": "0x002ad9234cb0fe05d594ff3261c0c0aa9834e884b9554dd2e50796bfb43d2115", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd1", + "block": "0xd2", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x5d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f4" + "logtopic1": "0x4c3dffb6198347c61671fa1fafd5d80f384ab67a494f5c7bc7428bcb6ca5a445" }, { - "txhash": "0x3896b74ebf76ff849f44241bec1e1f649653376971e657ad787801cf89bc002e", + "txhash": "0xf31826ea55e1dfd9a0ef79e69c038c18ce2613ab7521dd40278a57f5abe6597c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xdc", + "block": "0xdd", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b" + "logtopic1": "0x8a38792846734575025e5114061b62006064b0636caf6733294eb26895bda2ac" }, { - "txhash": "0xa0416d5370e59e86c33919e17cbef2ddc5aec738068d627a5158b46513115470", + "txhash": "0x8d92d60cb82c87fa52373745142a7aef3a4e61c4ef8263143b72921ded517926", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe7", + "block": "0xe8", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x18fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b56" + "logtopic1": "0xe70ed54757ba10a0b95454f6483d3d2e11613828f13d57d50b8a3a98e2c8df1c" }, { - "txhash": "0x36e00ad068d4b0aeec3c2d5a7a196da7feb1ae69b19289156477b7b5a025a908", + "txhash": "0x8f92d8ff45acea30275dfe8b0db8275ef2788dc98e2e463f95b611c06e42605c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf2", + "block": "0xf3", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d83463" + "logtopic1": "0x427b8ffdff6454ea85c8251407144400ed4e693ffb6a74f319e0238c0e72afad" }, { - "txhash": "0x8ae68021325ec15d383dac77654f45002c2540c113c8069496b4c7b7ae847f42", + "txhash": "0xca302bad2ca8f5faf8b03738527fc4336d676426582ca7325fc8d056223d0800", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xfd", + "block": "0xfe", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea58328" + "logtopic1": "0x2dd51e8325001014c6845bc5ad51b134ab237f95ab18da55cabc4275b029bf3f" }, { - "txhash": "0xa0521c7d9e65b85ce70e1047a30fc0f40716c958e5d26ed1b892dbb58c631623", + "txhash": "0xa96c411f76d0a78fd803b9e54451f18c325516bf7f2425dc13a186087c7cdd6f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x108", + "block": "0x109", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c9" + "logtopic1": "0x321c62425869f150c2cb7f489691c3e5cd49f7cd62d07ecbb7477c4148aaaa0b" }, { - "txhash": "0xd08c91a1bd8cedb22608d15dcc429cd8fe2785c0e28f8aff323d8a47957b22d2", + "txhash": "0x5453ca1ac0d4597813a0719201d71fbaf656645760f2e9552963e5ee7bac2713", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x113", + "block": "0x114", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xaf1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa" + "logtopic1": "0x1f6ebf3e4d9c96ec86b866137bbec9bbb56d188e7126babfccc6394fdcc6a3d4" }, { - "txhash": "0x50266b81dee4437511591aaa60df86717642524cab47d508be3cfe16248574a9", + "txhash": "0x6865e9e71c92547c91d69f78d48b135cf41025bcb5aed177989683f6b747e660", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x11e", + "block": "0x11f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x81260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f9" + "logtopic1": "0x9ebbf91a66183d0d37b03faf46daf8fe238c1aa2b24e6663dc14e50557d432c7" }, { - "txhash": "0x0dab5929cbcf54b4b6742c4e7ea56774f9f07c5ee046151312accbad330ab7d1", + "txhash": "0xdaf6cde4356d00a862a0c1c651703008413f3ccc4d00f9046fc83c09ecb1ec7c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x129", + "block": "0x12a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xf9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb1" + "logtopic1": "0x94605c950838b2b0b1ce76f58acfb91a94c2aba787d02add7187360989745a4e" }, { - "txhash": "0xd72795a9627079d42e1f65998602783c0e1152b1a6ee62b5f399955aaf1a3808", + "txhash": "0xe72dff0e31241074f1696cfb82a60f4ce97103508edfd854fe2e8e61a694bfa6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x134", + "block": "0x135", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xbefb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb546" + "logtopic1": "0x3eb32abcff52bfdf0887e9aebaeeaee4a61b76f2fbc9a183c2afc8552d46c3f6" }, { - "txhash": "0x1f049fea47d8615029fae54748b820cca1369ac4fb2bd01e570a5bd2478c683e", + "txhash": "0x140b3630a28806c4e07ade0b9ef16d6c46fb643dfefd197f8732ab6fd1a146ed", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x13f", + "block": "0x140", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc1391308" + "logtopic1": "0xd314fafd686fcd729a24ff511ae5e19248bd6ac6de8c28c79918df72de20e63e" }, { - "txhash": "0xa507e1f9dc79761107510d4f931dbcc1d2d846bb2c2007faae7198c926431d61", + "txhash": "0xdb0d10d5fb34e5ccf5b1e3bb0eb7107a0772bbc160430c02c8f9de9f1b58bde2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14a", + "block": "0x14b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce857" + "logtopic1": "0x951b3b37c2a87b5a67918e750832a50c5565298a35390bad3ffffadb2f7b4afe" }, { - "txhash": "0xdc4ebad42a33cedb2c56f2963b7f665b806c7e76a95b3527e03dcee1e8d3aac0", + "txhash": "0xd7268bce9c920c807d1c5a4bdd9ad35e6229feba835b3a0ffdf1226bd47e4f40", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x155", + "block": "0x156", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x6df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f2" + "logtopic1": "0xe067f85eba81feba79bf640415c11ab4448d5cc4a41652fc0a200be4d2661786" }, { - "txhash": "0xc1631f848ee48f93986a0d7f3a3856229d6d7f2ab448da79299ae65ef5c9c72d", + "txhash": "0x94018987b14bf2d6796924a52406f3659776f92832953fdd62d44673dd7e817d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x160", + "block": "0x161", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x40325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd" + "logtopic1": "0xd73688caabee79f6ecf3a0b092d26e639b7e486e45c00031db80d3d7abe8c683" }, { - "txhash": "0xa8b3e0feee69ef4ad9f164709f9d8c93cb0cef54b547d6df3d3bd60d9373ac61", + "txhash": "0xe9d9cd83cb08f1dce82791973d9cda526004b154ab7c41c2115af0db4f9c3494", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16b", + "block": "0x16c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a096" + "logtopic1": "0x945c01f307d13fcdab0a2a3a4c4bd5ebb69a00c3dd59896a959664e01ce10695" }, { - "txhash": "0x59a87b6c242eee2b5bfb727160765d68198245907faeabf342d28663f9695bc0", + "txhash": "0x9412fef1c0313b43d6bcee24f8fedf864ff075a158b254e1f47250347459935f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x176", + "block": "0x177", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d" + "logtopic1": "0x3f410a22d042d915c50f9269337a2bc7155f86d79bbff1721d83f44153635ac2" }, { - "txhash": "0xb6e6ee58c5cdab20b7a2ab2593716985f53644bdab28c89f5cf05c4704b9a43a", + "txhash": "0xe26d038ae4f3490bd88bffc6dd8c673cec148d00d1332958a94e0155146bd688", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x181", + "block": "0x182", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a" + "logtopic1": "0x4b85d3d5e4e06787a4e7e6d00f4e2f6d7e0358d9e511177ab584553d4ca06038" }, { - "txhash": "0xf8b2538634ae7c9012e0298b5658de6faf19edbcc7a6ad8ad9409c3e876ca311", + "txhash": "0x50f46bf3575161f98d3e823b1e8708627ef2c2705e9fba8b43de84032d791306", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18c", + "block": "0x18d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x92da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a108" + "logtopic1": "0x0c8e91bcf03d65aedba99f4f76d3ff8cd007668948ce12daf4dded4761c7b19d" }, { - "txhash": "0x3a93ba0531ec222285241aa65a45f44ab14900e4d9c5389f0713456436881b60", + "txhash": "0xbaee8142b7fd3fa6fa047a67ea1d12b9e366bcde62535d93534f32386fda0222", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x197", + "block": "0x198", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a7" + "logtopic1": "0x82a4bb68f7522b711c9f22b00f9c5e050f52cb2bc5f0f50eadcb12a5f1c30839" }, { - "txhash": "0x1e7d6ae181604098663d2a7b69f2d6a5ef30fe23e953ef480595751a24b63899", + "txhash": "0x168c04757e530b0f6a19b88bb769693adc15ac857c48a2aa3fa67dceab97a484", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a2", + "block": "0x1a3", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a" + "logtopic1": "0xce87527a0ad3ddb4d0d57d8077e84d48a6f3810f2a5672143d3b6969b0f86d6e" }, { - "txhash": "0x80223c925ca21ffa9b819dbdb802b1483b8828f209a1e44a6b66e777aeecfd5f", + "txhash": "0x95e1fd4c38074c94083bed06f882b6b2f88364de3413f7ab8fd47a57cfe239e3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ad", + "block": "0x1ae", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xcea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb65" + "logtopic1": "0xe3cb3b98042d005e52e8bbbf49b25e11be63ec7c63ae5a5043e44c545fce633e" }, { - "txhash": "0x05f3165887c2a6fe74c26b7a5561c22124331bb248a8c83400f9e84254a0a656", + "txhash": "0x59b762afe595324d884387df2e79ac368fe6e8f5a8985c913b7f447459c91b79", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b8", + "block": "0x1b9", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd963" + "logtopic1": "0x1fac03facd67f44699ff86330a7f959ed3745add76d323f4832bc17c35be45c9" }, { - "txhash": "0x9bdf145cf420be4935f61d48d278854fbb146c5dce686a81f586a6b72e2f1697", + "txhash": "0x1a11fc2d6215e58d2d50ccb49c641e0ff870d7eeb54d7315b4151031bf9cde4f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c3", + "block": "0x1c4", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x6f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db" + "logtopic1": "0xe4c7ff156c2f31d046217715d0f193c8a6b3a7af6341d6abe0e28c49d1210638" }, { - "txhash": "0xb1c7a90ffebb5658771131f7286426643259c1d9d3c6581d97a2faccacd3f2b3", + "txhash": "0xdb923b2884944f8adbf8a4e771e4001de4b8da897191c7aa9a9153338e6d0a78", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ce", + "block": "0x1cf", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xfd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b5" + "logtopic1": "0x9225354562a563158ba2ce0e86cfeed7fde0ed27c77342aaea09551b9c00ea19" }, { - "txhash": "0x837101affb0ad970b9101a914f733b437fa042e2550b3d781f6775285fc8cb99", + "txhash": "0xf9d3b87c7fc9b4c13eeec16198e8af4ed75c954de57fc5d9a9faf23a6607642b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d9", + "block": "0x1da", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda2" + "logtopic1": "0x231eb803c34ec183e74b466c105b5518b554ce215bbc31bfa52c384138b8479a" }, { - "txhash": "0x4a5060608b481087ac139068f55d76edcd8a4fa189abca438bf0b18d25450638", + "txhash": "0xbc52633dc609189d4ff57b01d62bdb08f9d72ffc41b56948bf14cf6e6d4155f6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e4", + "block": "0x1e5", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x27edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe3" + "logtopic1": "0x17f29f600f5128013ce183ac10efc609231aff556df37c8f5d6802c1240c22f4" }, { - "txhash": "0x7bf955bd6b528d2435096d3d88b3b39deaee5f7702b206c6e0e9cadf739b2aab", + "txhash": "0x7faacc820e63e7d98aa1bbf4f06e6b834ea0c09f92cf7f0215b9a362e626dee8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ef", + "block": "0x1f0", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xbae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a19" + "logtopic1": "0x8405cb4703a08e5160e343c37d42df5f045091f6b22664b0ec3f587df18d2d82" }, { - "txhash": "0x20ffe88022aa6e1b6a9ff7f2a6465a3db959aad55dd70dc3380d63087e7ee390", + "txhash": "0x44982cdb60b916247d171d4601a276d35fdf2b4609b8f284c9c1a370d8b83f9f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1fa", + "block": "0x1fb", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b" + "logtopic1": "0xe865c3418b47b88e94c28956b326a799298fb44c62a7a6bb55fd991f7c0442ca" }, { - "txhash": "0x4b5bb822f7a362c9e204624b436f342b3abded4c548e19e9a01d36d3493c8a32", + "txhash": "0x98977c7f5978be5e730e77d48d8c6a424d8fc5e2dac8054091fb267d39c7f283", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x205", + "block": "0x206", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a" + "logtopic1": "0xec200bf1cc6a2c5d58960dc3476cc4794ba1a9fca2ac3d09b63e7811b7299c3d" }, { - "txhash": "0x4a8d2ceec1465c2db3990dabd36c0027303110f516a7b591c01a733ef7e7cbed", + "txhash": "0x571efdba0d0d1d75f25fee27437772f66e3b5eae7b7360d46cfd10f543a48714", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x210", + "block": "0x211", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df" + "logtopic1": "0x09b79212fdf6dfcd322d6aabd5ba752b962d7e575cf299112bead28ab955f4c8" }, { - "txhash": "0x56a530e9c72cfcf61a6b0d1fe735f3df56792dd25f942baec63e0ccbb2a41a8a", + "txhash": "0xb762b9e7af89f7a7798ade8f2bc6445262220ac9938dfcc16a6a6594d1e0db89", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21b", + "block": "0x21c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x6c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a180874" + "logtopic1": "0xce285eb20810f2d026bc0b62faf3735df2193835ffd85df244ecc2df24f43b00" }, { - "txhash": "0x4233ea782ca4eb51f939a929af9257a374af873d136c50fac14d2df85564e5d3", + "txhash": "0xd6145f9061be63bed4d88f14de088ca1ad8e4b928cea570fb529d3ea6321b6e6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x226", + "block": "0x227", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d3" + "logtopic1": "0xf26b2f780c4b92b3f15f1d6e90f7d5a176b58eefea6f0d9cf2f8a0d1f86a139f" }, { - "txhash": "0x9f26d7fa9f6598f111b1ff50e143b2579520afa7fd5013544762b1378d2ab4ec", + "txhash": "0xbaf1e1bc18bad6d7788791cbc1ae5bb91e2dd4a09c50c999385a8c1835414e35", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x231", + "block": "0x232", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x88edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c570" + "logtopic1": "0xab5140d25dce39c42d511dba633cde87b45465d48aa4ec211b27de998abbadfc" }, { - "txhash": "0xfb7f1b4cae168e0c7c37155044d0f8907514472726a682ad14dc562cb86ef124", + "txhash": "0xcef14bcb034bec993d8d12107db4dbdcf23f730dcf5d42091ce3a1ea6f7ac13c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23c", + "block": "0x23d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe81068" + "logtopic1": "0xc558392238c2d11cdd04a6ae37065f3541a22140500f92c0d8006ff95e8df595" }, { - "txhash": "0xda8372595a6f7b652d57a878d3de4a14ed4f4ec71a0c465e01ba8bc29c542cd4", + "txhash": "0x3c84318e56935f73527aca010331231b010ad0903bfe8939994ad9680f6d3d25", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x247", + "block": "0x248", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d75" + "logtopic1": "0x69626497767f58c222726a6a3c65050bcfdbb9346f9e5d146ef02bf59275b3d2" }, { - "txhash": "0xdec9676345f2218dcc1eb83512845910541be142c407b8ec119aab5323132dfc", + "txhash": "0xf654d5f9c472097f745521cdecdd9854b4c4f1e23c7c027121724d67be42cc42", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x252", + "block": "0x253", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x48ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc" + "logtopic1": "0xee0b894f33a9643c94e4e2237077260f4191c5bf6bb3c17a2212b86af6f67df4" } ], "tx-emit-legacy": [ { - "txhash": "0x93b1dc3b8982a6c8bd8cecb7d5cf45af27ee28b41daf9c801e51065eb7dc60d4", + "txhash": "0xc9e729de373f2fcab9ddd36402c047cb117522ef48b25435bd415b9bcf794bb9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xa", "indexInBlock": 0, @@ -1331,1724 +1331,1725 @@ "logtopic1": "0xb8d28e7b703baf999848ecbba44026cb6479b3f0466037bcf2221ffc3f8549f9" }, { - "txhash": "0x56d2f9f1862cf585c2419e181e919504b73608b705237dde572bd616f1d650a3", + "txhash": "0xfe4c001ff9cbf3338dd712296b718a6467ab734617ca225ce7ce4e3a9547be41", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x17", + "block": "0x18", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa6d01173df2aa437fb0118d181e64a8f8e05713fc01c42fbfd2250516639ae95" + "logtopic1": "0x95104e47e1982aba633477f377b1511396c3fe83600224bcb0c78949be705b33" }, { - "txhash": "0x86073ac16f561025c7719c0cea52c04a136770717a5d0a9f70e3dcd87efb4e5c", + "txhash": "0xffde4e2fd1cd2f5e51e564b08216b9ef80978c586098221cd19f1ee742db1c03", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x22", + "block": "0x23", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe94d0b2545ec05c3ce3431c4d45c3b62fcab156563e8308fae1ebd27a2810c1a" + "logtopic1": "0x2acfc92a1cc51397c95e434631e449d83a81de91964ed735a8c8b71b35e1a626" }, { - "txhash": "0xb19203054582d226c20a830e5ae3337d13af37db285d2936f7949eee221dd332", + "txhash": "0x965195498584dd1a4ee5ae7d60e5bb4dae1254b2ec61023f7b86678d75643201", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2d", + "block": "0x2e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x6551251b96ca27f3af8a2c500d6dd1ea5b9ab7002b3d923b66db0493f4a7123e" + "logtopic1": "0x5b6618f0def0d634d51118d232eadc26ecbc8d54a7efaa225afc472f0a611c69" }, { - "txhash": "0x794c81d1b630164f8bd2b0abb4ff9606598f03e56e5475526b6736b449feee46", + "txhash": "0x209a012091e6c869a96f21aee8de7ca44490a593d0f619793b961b2ba4a777b2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x38", + "block": "0x39", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xfa29cff134420b6526f434ab690a9c3a140aa27b8479ae3d8d83b6c799acbc23" + "logtopic1": "0x349c26db328204bd2527eb45003b0039d5a636f76c8849bca0b34e8fb134f505" }, { - "txhash": "0x0fcdbb8b331a37eae304599f5e40496965eba8649cdd28319abe9a5184186285", + "txhash": "0xff76c1915b804a9f4abe17f6564b278ece6cbc1ceca0604856e7f440cbd6d9c8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x43", + "block": "0x44", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x412379b7f583981ea6e84408cba75ced69039e07ce9cdaa32a8a9dac997aaafb" + "logtopic1": "0xb66fab7dddd4d16174b227a6f958d7ba2ae8ebc52d763b02c1ff944362755e6e" }, { - "txhash": "0x6bf0e75233c60170a92dcff17d3906533daf2aecc20a427a3cb6260717103396", + "txhash": "0x39c37d8cff047f5047fce694f7703b57b08cf414710cd94fc3daea5902330559", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4e", + "block": "0x4f", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x87dfa85154edde1626e3a09196eab4b60f71887ec7b50ccbbe7ec76c0be6bdff" + "logtopic1": "0x780fa5a814a83baf682b2f170be956308be6ce1bf84ce68ca5f3c59cc41c7c28" }, { - "txhash": "0x95a5b38bf61dedf258cbaec502c5e0c09e1e19e90c504dd48af18f9412ea487c", + "txhash": "0xbac05861c5a87e48448ca240659aca18658a08c7d0b6318690809b0c227470db", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x59", + "block": "0x5a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x6e2466f20ef20cb42d216dbf4a0d934199213e9b8d75bedc9c2d3e038a587474" + "logtopic1": "0x9739ae7192ad23a41778719941582886701a0830589c7ebfc5db094037635d82" }, { - "txhash": "0x4e6eaacb23cdbedac1a0468927c2b1cdeec1448cbf57936620ccfdd0f75ae91a", + "txhash": "0xf24d6d5bd0136dc7a2cf4ce1e2daf6191b415af43dcaf6bf1d43ae69ef2a306c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x64", + "block": "0x65", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd75c9abb1414054ca164bba2f8c09917fb90c24789feaa311ee34a0b3f4a82f0" + "logtopic1": "0xf5acd98a17a3425f113b869e0dd03f82ee696401d2e7f59e8902610150a95a20" }, { - "txhash": "0xb83984637e9c41986b59bfc847b7c922363add3a6412024a73357549f27bf4dc", + "txhash": "0xaf83fcaed15f46e777c9cb54fd6465f00dd6d929c556bd5644ea39fce51be74a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x6f", + "block": "0x70", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x165e0e0cc13ca53c5af4860637550364c5c90a512906490ace14efb534873741" + "logtopic1": "0x5cd04d660080fb51a0cc8df0d716e1bff4eff98c887cf3274aabe7ec53dc3615" }, { - "txhash": "0x4f70c780915a9595d214c9c9fc4d96eb7bda3776cd2301f89f831421c13ea768", + "txhash": "0x7382ad28a6589fcf07195874a36eee8f4c5fa22f3288a1979b374d80e7c6fb88", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x7a", + "block": "0x7b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x16bee816935475cd45501fc5fd01bf913f8ef54330a43d80ef73101a4c728b34" + "logtopic1": "0xf199b2d65bb711d578312320d210574bcc79d63c841d7dcf96ee3604140a7353" }, { - "txhash": "0x37967eef8dec21d44420c96212a7723608eae9c9df5587b70e3f324a09e0c1bd", + "txhash": "0x730f124954d2b20c9ebfdf6715da7192a570450b485ae60c12a102fecd80d21d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x85", + "block": "0x86", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xaf1f0d50933e49dd24b61a24c670809a5b875e3b746862636288dead8579dc4e" + "logtopic1": "0xe9bc0af4e1917255f83262d4d61622be8b86fcb24a5810c7b592dd6da6861d56" }, { - "txhash": "0x15880426a7d1d3df1aa32e7693cb507f8fc69ab9d90e5559eddd9424cdb4f80d", + "txhash": "0x69e193cbcc3231501957748043aa48e52b141d0fa38dc6f5027e06790e3088fe", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x90", + "block": "0x91", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x5b300d53be5798f53b472dadb8966674169ff3e8d08eccb3f065bd827abd7b77" + "logtopic1": "0x74871a06c400033dfb8aee09db8282719447dc850ca097c5e240f67a2fd7fec2" }, { - "txhash": "0xf1aae9cd76d3f95b8796faf9b2d46303421eb3f8bf370b2367a72817d2600eb8", + "txhash": "0x375b37a5a1fc955be827b5782601616fe2c2f420728237644f93f6ba41aa925f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9b", + "block": "0x9c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x970a64830f255bfc38886621b37a7f1a7284bad6c4a04b6a2442ad212e19a6a2" + "logtopic1": "0x32eac35ea119adcf265e25a03e27234688fd743982f4ea87940a85b601b4243f" }, { - "txhash": "0x43c353bb6e0361414d7df069730164f8049957afc9376e24fbce3cf8659b8085", + "txhash": "0xbec707c5af50adffd736ffad61ec142954a1a0c79b64b7bc7d826417ef746b1d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa6", + "block": "0xa7", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x611f5b5e5ee263412fed40f169d0727f4e6e1a2bc94caf668d2bcf22cddca8c1" + "logtopic1": "0x6d8f3f1992b15fdc2a757b2b99a8a3721589fc2e31188ab7620ca2884102ece5" }, { - "txhash": "0xe70aa05480e8ec451e6063031138f83fd569c1b9ec1edd2ce6e5256e7e92965e", + "txhash": "0xdea7d229c8331223fc55f26e6db29436721e1d94181fa4aa35ebea2f52250058", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb1", + "block": "0xb2", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4632fe8e9579f33e2e42e68811d49a09ad1af1f01a68e7ae742f765e8e797ff8" + "logtopic1": "0x10ed5dd66ac107d9c27405dd97b947d333696bb8749b7a6b0890b449d3bf2238" }, { - "txhash": "0x5b7c43d070aea7cb7e9c8daa027e319ebf8662e56701abbedfe2bef07daa9eb1", + "txhash": "0x84ac82e58add797c823abd8d3b4f4a20665dc4068f300be3a9459bf2ef456ef7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xbc", + "block": "0xbd", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x205bcc2489f954a3af7a16da4d6042a75fcd6eb69b848c52b3448acb24b23580" + "logtopic1": "0x8348faa37f759999e3e7d161ca60aeee74b5c55075e626534a26da3aa8962a71" }, { - "txhash": "0x6fafd835f52299368f36bcc17c548df55adfa18f26e56847114893b7ce9de699", + "txhash": "0xe0ca84624d60f1953d23b326950059ef3223e3330bdcea93fac344ec82abc168", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc7", + "block": "0xc8", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0a2bc3fd72bd3f8bb7f1de9a7dc9e928a7c6a831237124e65c60c25f8348af19" + "logtopic1": "0x228c9eabdaf185c57233f73fb31db8870dd1d46eef92c3d4c5a5eba1b8f73f00" }, { - "txhash": "0xa53506fce1b528bd18d18154b72025ebf9c8297ccd17cc52a94c2bcc03a504c1", + "txhash": "0x099cb6b36a37892bbb3d51706996a094a1415a6f33212f243865b875b72e2b8e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd2", + "block": "0xd3", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4c3dffb6198347c61671fa1fafd5d80f384ab67a494f5c7bc7428bcb6ca5a445" + "logtopic1": "0xee9be26249f0e23118ea14c2c58ab3fc7e42e888edb4b1de6de4a03e0b793b00" }, { - "txhash": "0xd21d210873d8178c9ca4b9fd98e3d90e4f6fb00f81d82eb44d6f0c5c2d3b69ac", + "txhash": "0xc2e05a39699ee47ddbce4e95a5340c269f1ee97e5a7548459d31ad6799c0890f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xdd", + "block": "0xde", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x8a38792846734575025e5114061b62006064b0636caf6733294eb26895bda2ac" + "logtopic1": "0x18c688de10e38d70bcc478405df715df76bef7c2783e310b391dc958ab5b0901" }, { - "txhash": "0x00fe86870f7e16b7b184caef8aafe35112faa784d316c71a1932d2e0eca799fb", + "txhash": "0x40f57b0347ea5eeea424e89e020452901299918adbba53ac7638f90ff17ca735", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe8", + "block": "0xe9", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe70ed54757ba10a0b95454f6483d3d2e11613828f13d57d50b8a3a98e2c8df1c" + "logtopic1": "0x656fd2851f3badaee7500720d14437294b0fcb76990f68895b487132860e635a" }, { - "txhash": "0x182de5a2fa9261eb867b7c233750ec22f6456a9902af2677476fef9747af3d65", + "txhash": "0x96a0fe2e43927cf872963c776aa100c66f2113175962fc6086791c32ae2733cb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf3", + "block": "0xf4", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x427b8ffdff6454ea85c8251407144400ed4e693ffb6a74f319e0238c0e72afad" + "logtopic1": "0x70fe2e29e879b5adeef12bf7a782c3fd7815b6fcd3defad6eea94b8fac090e8d" }, { - "txhash": "0x5e8121133745699e0ffdd3cdf62fcce14ad16005c7ec53225df1aac03fc067a7", + "txhash": "0x74a0161cfd87a7d05de5e037daf133ba5ae70b2a16762e851241223c57747d7b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xfe", + "block": "0xff", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x2dd51e8325001014c6845bc5ad51b134ab237f95ab18da55cabc4275b029bf3f" + "logtopic1": "0x95eac6698d094a89aa0fbdbe4dfa56a92b928657bfd2a6374fdd5ffadfd8ebe5" }, { - "txhash": "0x06cf9afd2a64d19c462dff4acb3c32bf9603478d308a5107ae197acf716be505", + "txhash": "0x5ae569d9a62af8934e450e18e1f228f47122ecee5a989786ea8d5026924bb1a5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x109", + "block": "0x10a", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x321c62425869f150c2cb7f489691c3e5cd49f7cd62d07ecbb7477c4148aaaa0b" + "logtopic1": "0x24562ede5125f88e7d44659502457e8632f0cd29dd768d7ce337e567830c6b90" }, { - "txhash": "0x0390a326d5615bea72add73e2398cda64b160a4f7980038997006feeb1721d62", + "txhash": "0x6ec782b355abd516c6fd977888a21cb7aa40bd801f5fa617d24125c2a64b869d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x114", + "block": "0x115", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1f6ebf3e4d9c96ec86b866137bbec9bbb56d188e7126babfccc6394fdcc6a3d4" + "logtopic1": "0xecb9f805cd314a9aef8cf2c51ccee54704c5cdcb0cf745bd3411c0cfd1bb2381" }, { - "txhash": "0xaa9089bc7bf3a9fff0ac8c3d8974ebcbbdf24c494c6be9f6dc330700e0c511ac", + "txhash": "0x7adbe701b69f8e23d502a523be257949189f1c64796dcb2a196b1a38e0bb9fc0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x11f", + "block": "0x120", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9ebbf91a66183d0d37b03faf46daf8fe238c1aa2b24e6663dc14e50557d432c7" + "logtopic1": "0x0e207a83fb16f4e1d86cdb18c78df10f272b8c9dfc773d8c636bf763e5d86ede" }, { - "txhash": "0xc4740d2ec8cc977d641f18f97c1d789b0a761e0a8057105437acaf8f7e5f33cb", + "txhash": "0xb906b20d68d3e9eab03429a2138b01a70b3849e38daeffa372bbb2691a65d4da", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x12a", + "block": "0x12b", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x94605c950838b2b0b1ce76f58acfb91a94c2aba787d02add7187360989745a4e" + "logtopic1": "0x1098fa447b36d691c6d8801147ed65b27ab8c9667e089b59f1a1cdbe54cddecb" }, { - "txhash": "0xaab8e9062dcf651d0bd5fff9cb086ee779f3f91bce1c9a090baba71e0500d696", + "txhash": "0xedb1504025eb7f6b7726435ebd218617ad192c7b1c1d91f5fa391e2282fdd888", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x135", + "block": "0x136", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3eb32abcff52bfdf0887e9aebaeeaee4a61b76f2fbc9a183c2afc8552d46c3f6" + "logtopic1": "0xfef2849e52369d74814504a0592be1651fc3581e54b57283fd34053344624f83" }, { - "txhash": "0xe1fb51da4cd5656875be51625ad129bbaef0a28066ccf1729dc8d4809f636240", + "txhash": "0x18ab4d8f2762ba37f4386d2b2ccb442460fe99bd12bc1e64979008300b1b3524", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x140", + "block": "0x141", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd314fafd686fcd729a24ff511ae5e19248bd6ac6de8c28c79918df72de20e63e" + "logtopic1": "0x304f1607803b1445143f85e860e6837543043e4a7ce83fb6c4b98a2b57a5be44" }, { - "txhash": "0xed9806dd032752f6fdd4234b61a6aa6941af207de555aaaac5610b04f4be967f", + "txhash": "0xeb189808d46e050503dffeb59abb4f6971a926b2ce701d7a6fc2858a62f9d656", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14b", + "block": "0x14c", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x951b3b37c2a87b5a67918e750832a50c5565298a35390bad3ffffadb2f7b4afe" + "logtopic1": "0x6b5eaf5499e02713812d712b5b5d3ee95e185212f6a71cc9a583a971cd861a4f" }, { - "txhash": "0x66cbbe01979712ff30beed89a5088350249b13ea9d1c162b3d770c4ae98387c0", + "txhash": "0x644010d9403c3e434feae06db0943ee0e382a7a16b3534738ec34608134463c3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x156", + "block": "0x157", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe067f85eba81feba79bf640415c11ab4448d5cc4a41652fc0a200be4d2661786" + "logtopic1": "0xf4770d7a56ee02b105688173dbb647939e9168262a4d14b9f6a6efe19b647388" }, { - "txhash": "0xfca2d9cd7cf664cc092bc71e1ff0e6ebefb991bd0a83d1a42d2ebb0fd6b5a50f", + "txhash": "0xf75f7d6ca00fda8215c4f48052b84f6a083b5698d13a627f910e93eeb6dc9bd5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x161", + "block": "0x162", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd73688caabee79f6ecf3a0b092d26e639b7e486e45c00031db80d3d7abe8c683" + "logtopic1": "0xf4c5c0fe94f1f62a752dc2b883078110c5753ac15ab5fe6f425821fb61963118" }, { - "txhash": "0x576ac317e0aa5ce1268c528945bc17fddb69b3391b22df0db5ef6ac7d3d9eced", + "txhash": "0xd989970efb8d750e0d5bd61ff5cfbf84aa5fef070d6bcc6f71258471207bb046", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16c", + "block": "0x16d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x945c01f307d13fcdab0a2a3a4c4bd5ebb69a00c3dd59896a959664e01ce10695" + "logtopic1": "0x8d866e9225b61c55bb3e8d27f9eed41faec221f3eb1ea322661ce1956885d021" }, { - "txhash": "0xed8db5d85b8d9618a7c012715866440ab390b23bacb24885a9638b9d48028faa", + "txhash": "0x16622bce94aaa8e9dfd14e1a3889aee0bf65769454b7c781a2c822bdc2811336", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x177", + "block": "0x178", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3f410a22d042d915c50f9269337a2bc7155f86d79bbff1721d83f44153635ac2" + "logtopic1": "0x7fffa2c61f6cad00c700b65e33937fcbab57dff84b2e792d81126626970905f1" }, { - "txhash": "0x90dd94f9997d05a851a81789518079ba4251ca0c3485083dea817e32df80a2b0", + "txhash": "0xe1c47b77b2b7c5ce5f4d5984ab1279abd3f976603e5d1996b454500bab1e4865", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x182", + "block": "0x183", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4b85d3d5e4e06787a4e7e6d00f4e2f6d7e0358d9e511177ab584553d4ca06038" + "logtopic1": "0x9f569f15edd7832cd57a6cff95e09ab162c23f3dda7e729a74b2f41624294998" }, { - "txhash": "0x019dd8e438d6818397398da44bf836cc9eab53e49fe604be0048bd72d06f7ecf", + "txhash": "0x3a1237cd02dcd1e6e8974ed68da1077dfd2dee6725e8287254e29ad19766d649", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18d", + "block": "0x18e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0c8e91bcf03d65aedba99f4f76d3ff8cd007668948ce12daf4dded4761c7b19d" + "logtopic1": "0x22bc306256606a63c7e6adbfdb53ac8a2579216b16bcdc452de151e042d02124" }, { - "txhash": "0x694c644dd4e60de18a392c912e6c883a9fe177f6995d3ac4b1d0e121ed0b7b2b", + "txhash": "0xb9d6436537e309c4ba46c1c33a099f7f4f0cbf408d39a8815b343972d104822c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x198", + "block": "0x199", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x82a4bb68f7522b711c9f22b00f9c5e050f52cb2bc5f0f50eadcb12a5f1c30839" + "logtopic1": "0xef03c0a4bb7099df0152e975b6c3172e7f47225648d2754efc7e81f2d1ed71c4" }, { - "txhash": "0x48578438fdd693c25ed25e30c141ed5db0743f49c55a4d355c774f5da6ba0a12", + "txhash": "0x54713a1d1c77ea2e204d386c140d54cf409d8a7290be65251399b02bfc1b6718", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a3", + "block": "0x1a4", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xce87527a0ad3ddb4d0d57d8077e84d48a6f3810f2a5672143d3b6969b0f86d6e" + "logtopic1": "0x6542b8fc06728a624d10d21d45cb3fc58b811a380547cab3d5bf9e8af0de6951" }, { - "txhash": "0x6daaa691e14a7a4c586ce5f411c60671c793c2ac01710ceae2e36b2cc2631822", + "txhash": "0x9b50b6ff2a9fdd1fa9b5a016c500bacfcd6472817c916582d1c7f908a792bf42", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ae", + "block": "0x1af", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe3cb3b98042d005e52e8bbbf49b25e11be63ec7c63ae5a5043e44c545fce633e" + "logtopic1": "0x6760889404c1143da18e9f066f1d68de75c9a16a9d10a280d41864fd7580456f" }, { - "txhash": "0x7e1ef2e07a223c6ad828353b5052bba8a87b5c5115ba507f4bd22f9e842a499b", + "txhash": "0x36d9fc6535adfa5bd43b983dbb71f27fe4e224f38ffd753351241951f147cba0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b9", + "block": "0x1ba", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1fac03facd67f44699ff86330a7f959ed3745add76d323f4832bc17c35be45c9" + "logtopic1": "0xef429d45b992d9e888f08c3038963cbf4aa2b1e5b209fff23a8299c595430277" }, { - "txhash": "0xfee141740da30da512d76b3db294ba34e78a108433fc76054c9d93a6222023d8", + "txhash": "0x1f137085055e119cca83f54e757c0db8f19a6781305a2c9348b5fdc2be9668c0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c4", + "block": "0x1c5", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe4c7ff156c2f31d046217715d0f193c8a6b3a7af6341d6abe0e28c49d1210638" + "logtopic1": "0x9a9b2b0f17eb8c44f3d00dc6cd8475e9783cc715b3779af9170ddeed0221bcf2" }, { - "txhash": "0x41f54d93a2f08e78459286b2502954cfa13dc70a18ca7ec73dc1905905544aca", + "txhash": "0xc656c9855aca6fa4ccedde00cd56b2a340391315abee1c18228dcc4e6d482b56", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1cf", + "block": "0x1d0", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9225354562a563158ba2ce0e86cfeed7fde0ed27c77342aaea09551b9c00ea19" + "logtopic1": "0x04050d53dc4e38076a46f473ca2ccad11c6f0357bccc0d1fc7a16e0523892956" }, { - "txhash": "0x63dfd5f89048de40697cf44e045668ed559be531969a8a1e70d0276e5379335d", + "txhash": "0x77a65636b0191f4f3eedd30f15a98a3e6a0132c0496ea87a85932d35971c48bb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1da", + "block": "0x1db", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x231eb803c34ec183e74b466c105b5518b554ce215bbc31bfa52c384138b8479a" + "logtopic1": "0xbb8f646a16b72f34169bcd82f0c023b582d2ae9f395fb59f9e022e6caacd83a0" }, { - "txhash": "0x7244fa2b6a90be34eb69c9c848da7784cff392463f1b4c52307df75bffcf36c8", + "txhash": "0x893aaf0147a55c11d2f3a7316abe881fd6176b170f434d5a8786bae3ccc7b4d1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e5", + "block": "0x1e6", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x17f29f600f5128013ce183ac10efc609231aff556df37c8f5d6802c1240c22f4" + "logtopic1": "0x304daa529f8e4e88c6c20e572fd04f196d6a32a5a47361118b7f42b4602c44d0" }, { - "txhash": "0x8f31383336ceaa850f701b920f47617acca17664ca5f4c971df87ddd0650ebbd", + "txhash": "0x3040182f2f5da3ce5e34f51eadeff0200754f66f65e2993047ec7970300f2369", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f0", + "block": "0x1f1", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x8405cb4703a08e5160e343c37d42df5f045091f6b22664b0ec3f587df18d2d82" + "logtopic1": "0x7e93ec1b055e40d91bd222d7a3d4b0e85d09dfd561b0cd47d09a25fe183a06da" }, { - "txhash": "0xf08771ff65480e0a952226da4d9f994451e971e3acf08185b9442a106ab9c586", + "txhash": "0x98381ec459f4b3df5573e50dbb902bac9822ce2ffb9f5382ee3d46485a6e0700", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1fb", + "block": "0x1fc", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xe865c3418b47b88e94c28956b326a799298fb44c62a7a6bb55fd991f7c0442ca" + "logtopic1": "0xbdfccf10ce95236042860c90f84756794940d0d15da20833f8bdc1b921be3efa" }, { - "txhash": "0xebec9c429aacd0d3b9a9b0650e3136763b70799015d78d0718a37a56bb840130", + "txhash": "0x50f1f26fbf8dad7abcc19a5330645c94410ba61993f68b00d992195a4f9c0d69", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x206", + "block": "0x207", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xec200bf1cc6a2c5d58960dc3476cc4794ba1a9fca2ac3d09b63e7811b7299c3d" + "logtopic1": "0xd407a81a8c9c2573926ab54ecd5ee3eb6f1853de6b11142313df08897b6842e2" }, { - "txhash": "0x52edf7a236dd4d81f928a63f9249a8b3d60e09ae1e44801ace03c2f806cf539c", + "txhash": "0x8e9a160d98ae1ef12734744cfc7d76fe8c7c9913612ea670cfdf33ecad642fb3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x211", + "block": "0x212", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x09b79212fdf6dfcd322d6aabd5ba752b962d7e575cf299112bead28ab955f4c8" + "logtopic1": "0x005c4510db462e3bc91da9b8d22c23873a9f44acfaa4c50c91af1d92652e2e34" }, { - "txhash": "0x08a32aa63fce9746806dc432b63c5059c988cae94575471a64e898dda449209b", + "txhash": "0xbbbc951661c3d4f863d5e05b77682ee5f2640fd3a33d499ab644c02d677581f0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21c", + "block": "0x21d", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xce285eb20810f2d026bc0b62faf3735df2193835ffd85df244ecc2df24f43b00" + "logtopic1": "0x2724a489616bca201e7565382948f9832cbb927d030b1d2439c28ba1910c9bc6" }, { - "txhash": "0x160b312c6247f5629ef3557427776e40b11c6da95495086f92bd3e68796ead01", + "txhash": "0x4b8f8616a8e4c15a532d546db4d61a3cd2f6d850b9f23f87ad6145746c2c660f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x227", + "block": "0x228", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xf26b2f780c4b92b3f15f1d6e90f7d5a176b58eefea6f0d9cf2f8a0d1f86a139f" + "logtopic1": "0x474ee39f920d2819e9ccf6080e9b95c49fc2dfc9841cb795583b81b7497c0425" }, { - "txhash": "0x112b594c142d35c4888d2ea319c3d2128fa6d485fd127abca1c1fca07c10ad23", + "txhash": "0x9c178718bacc5a61736d5659e6130cf16b96a69f0a0d2b1684d70179d4d0eb2d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x232", + "block": "0x233", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xab5140d25dce39c42d511dba633cde87b45465d48aa4ec211b27de998abbadfc" + "logtopic1": "0x67f77810c4968b55b6ae34b927b213ced7c266fba0cf752957a861450bb43a7a" }, { - "txhash": "0xcbb68fb40512406853eae3d8378920825b17ba9ed6849ebfb115f21e07803425", + "txhash": "0xf83ffa5e5321a459515c73c3a553c595ecc4cc1048d22391609427debd3f9079", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23d", + "block": "0x23e", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc558392238c2d11cdd04a6ae37065f3541a22140500f92c0d8006ff95e8df595" + "logtopic1": "0xfc4b6ee72c1b0e13d4d0c218aa48c6233d313507fb55d142e7a2951f0b7c07d5" }, { - "txhash": "0x4aa773330bd4bbf6ff2b0754b34ec922c9cc1466702f07aae225637e0bf812b9", + "txhash": "0xd52afab5788002f90601ef20ee8254a41dadf76832c70da4bb0ee4e6c3cd9e5f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x248", + "block": "0x249", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x69626497767f58c222726a6a3c65050bcfdbb9346f9e5d146ef02bf59275b3d2" + "logtopic1": "0xff442992eff2fa28cd13c50239c9e15f907488f574ade0e75cdba2cfdb26c480" }, { - "txhash": "0xe5af8b4f6d6aa91fe8d453312890cf607a28bd49e3f6aa4fa032dd3d8606498b", + "txhash": "0x96a373f0a6b2f247ba998c24f9f606e8dc65a39e9fbfd5f9034b4caf0e7dbd69", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x253", + "block": "0x254", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xee0b894f33a9643c94e4e2237077260f4191c5bf6bb3c17a2212b86af6f67df4" + "logtopic1": "0xfb0e917bcfc6a3ba3c079d0f19d7f2ede25ac596e725d016e0c31dbc8b390508" } ], + "tx-largereceipt": 11, "tx-request-eip7002": { - "txhash": "0x45d9e01d8dc308a89f2911954f518bc0721d7975d5692f6969217a05bc0e23a0", + "txhash": "0x27d8ca12587f28aa0184966fabcbeb321b438a6495d5e8294dc9c62525f41b8c", "block": "0xd" }, "tx-transfer-eip1559": [ { - "txhash": "0xbc83f75c374dc1b4418ef18bf183ed000b3f7c1fca3da045c0f5253eb0177939", + "txhash": "0x4feb87725c3d45aef205359d7d200f523004b2961282c47736c49e3a453a3ab8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb", + "block": "0xe", "indexInBlock": 0 }, { - "txhash": "0x374ca7fe3bceee86e9b9d9ecb31858eeec3ac7ea7a632e56be943bba4e587fd4", + "txhash": "0xf282b242af9a863a650850cd7390dc3b3b485845e6290ee171edffab96a7c6dc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18", + "block": "0x19", "indexInBlock": 0 }, { - "txhash": "0x9ff78644fb64277ebe7838620b5817a0dbfbaf6b45713b80698628246492cc83", + "txhash": "0xebf2517adcc7342a874af927a17590156aa85059fc903ab1b09f97c34c8b8b4e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23", + "block": "0x24", "indexInBlock": 0 }, { - "txhash": "0x7f7b81c472c91ca8c511f29cab406ac201c770fad32270459a79f54d86c52614", + "txhash": "0x926f6bb97f760b2ac6c523e975d2697276ee3d881dd8348a4e7b7f2c846da188", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2e", + "block": "0x2f", "indexInBlock": 0 }, { - "txhash": "0x2ab6b266e3072e1ecbb21ae3111da1face60d84b41191287fa0f95971944e888", + "txhash": "0xef9dea375d62f1406d8777e70192ba24af24044c356da063eb71712eb7499356", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x39", + "block": "0x3a", "indexInBlock": 0 }, { - "txhash": "0x25b39f052f73a5bac64ba238ce4ffb9770a35dbd835136cb9ac66f4c3ac936de", + "txhash": "0x0816a60a0e6fd2afe45e7db877e33d055c3e4549037eb1e5209a21c4018250bb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x44", + "block": "0x45", "indexInBlock": 0 }, { - "txhash": "0x9de0b20d432dbbe839b178aa91cfa5381bcd84af3603bf48c4494042f716d507", + "txhash": "0x9720170ff561812f8bc717c251fbc942af99eefb8b5be1296c0dc3b331da7b33", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4f", + "block": "0x50", "indexInBlock": 0 }, { - "txhash": "0x610925d303403f4e3aca2495a12e5dc1688839b4f256f80dca33dba22ed45e63", + "txhash": "0xceda26628e2eecad063f6a4341ea4043fcce307a748b5a41c2a3d0e45721bb0f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x5a", + "block": "0x5b", "indexInBlock": 0 }, { - "txhash": "0x4abe64b41866828e0be88788bae36cb03dcbf85d070807670ccf27160e5a9a4d", + "txhash": "0x0d8c55478b560a6305ea886fbbfcb36441767c65270c9618ceb33b22f2ee4eef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x65", + "block": "0x66", "indexInBlock": 0 }, { - "txhash": "0x39f187a146d61009a03fecd06cb2f4c4b38cd26765905c3362fde02c046c0c85", + "txhash": "0x12b7508b1d9a5f9afb9de821961aca87f93d97849b8a1b5065a0e50cfc2e8a5e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x70", + "block": "0x71", "indexInBlock": 0 }, { - "txhash": "0x2f0d711bdc3d0b2f8efecc78a50bef10cad8dbe36a636685df0ce5e77ff2f470", + "txhash": "0xebe88d489dad8695b60b9e8370ce0e389e7cb9e49670980919aac829e2abb83b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x7b", + "block": "0x7c", "indexInBlock": 0 }, { - "txhash": "0x0131d1b2950a637e2709deaffd487fd6b395485df174fd33dda6650bcf6fd42a", + "txhash": "0xdd63b0ac29f1b5b9911a159e704a148fa190ae321158a23e2910b52b69f810ce", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x86", + "block": "0x87", "indexInBlock": 0 }, { - "txhash": "0x7a1a947af6d0713ec475e0e401ac0c30502f9d23a3eec761f40116bd1dc9f0c9", + "txhash": "0x9352e3fdb1640ce153b9580ddf310002221ec5bc20d4ae4f9148cb7e2d7d15bc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x91", + "block": "0x92", "indexInBlock": 0 }, { - "txhash": "0xc991b6e9ea27ca67d7b00afb5c3dcb0d9de6d2890d5ce4e3f032d9e7b2cb44ed", + "txhash": "0xff6132e2fb07b0e93bcc88a2eeb025b8e6a24ee6b2b78acb09e8738b3b902c97", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9c", + "block": "0x9d", "indexInBlock": 0 }, { - "txhash": "0xd190fa45214c261223635b2a8c2659b2a142d8f213a470917075ebf2482e0d28", + "txhash": "0x8e732995f21ca7456d4e2f2c988990ddbfeb2d0ae968024b1940ee9814b06d2e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa7", + "block": "0xa8", "indexInBlock": 0 }, { - "txhash": "0xb4ae0934d6d6775fa216a6f14f638ff0d394bcbfbc97108863a64cf239e0eaab", + "txhash": "0x6bd76373cd2baa3e2f13ff199293fa5cab2b5e3bd7979769b1d79c3612f393bf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb2", + "block": "0xb3", "indexInBlock": 0 }, { - "txhash": "0xe41f1f5bb0c5f4328c608347f2b347ba249793f47395aa57f735d45fbe564463", + "txhash": "0x33895d27bd9d17d08165eebb010d0c01e87503624147a93f05fcc7f6b39cbc00", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xbd", + "block": "0xbe", "indexInBlock": 0 }, { - "txhash": "0xff3473cad2636d1688009c27d790172c3f359a12b2c46fae71932cfdd62982c4", + "txhash": "0xc48a8664d8ad6a7fce451d9414cdbe341466c42f9c9edcd3c7dbcf3b8afe4fdd", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc8", + "block": "0xc9", "indexInBlock": 0 }, { - "txhash": "0xf3892f186643cfa58ecc5a2770c3c06dcdfa06a7701e08e42a8817d7af24093b", + "txhash": "0x8e28590eac2c10ac2a12b28d30f1085ee506c4bed98ec70a9866d99051b38f4b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd3", + "block": "0xd4", "indexInBlock": 0 }, { - "txhash": "0x258d7184e3022ec70cef833ae3a66dce9a36e42a7d2dd0d9e5cc14ed1fb5eedf", + "txhash": "0x22245d80eb9eff7ae730c21743cc4654ca641a3294d1891daafd80aaded914b8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xde", + "block": "0xdf", "indexInBlock": 0 }, { - "txhash": "0x07fa584efe43c50c1ee8bdca6369841ffa7121576750cb7c08bc251356e80a15", + "txhash": "0x8c8365b97fbaac8e4518c70c04dd29512d1b1a036584ebe908ce79d9f18de9cc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe9", + "block": "0xea", "indexInBlock": 0 }, { - "txhash": "0x092365255715c991b48ab31b184ae51f2758c17b2ac1aaf7d1036f105bb333a9", + "txhash": "0x55ffd4fc5e14677b4a26018d48c5a99c8df4e7b797073ada522ada9ca7b30ceb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf4", + "block": "0xf5", "indexInBlock": 0 }, { - "txhash": "0x8034b5908a0204004211f252b06d2f4efd19d276adf6aafbed3de97e5435499f", + "txhash": "0x9bc9ad750a0a4365323da3dbacb65c3723ae8564f7a1654a113a527d810ef8e0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xff", + "block": "0x100", "indexInBlock": 0 }, { - "txhash": "0xcb89f9e7e062c3d72798c6cc38f7c4ec26a5fa6d8cf86b33b9859657264d32f7", + "txhash": "0x1e0effb8659f8e43b7a49a6a926d0b76a352d0a45e86e267b8fbc651ff06a7ac", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x10a", + "block": "0x10b", "indexInBlock": 0 }, { - "txhash": "0xd37c021b3d8923723a80a78eaf9840a72f4d89aaccc63c80af112d52434fe886", + "txhash": "0x42faedb8e5b8d6f1433c5d14438cd28eee2080fd7dd375cd574561234aa6ada1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x115", + "block": "0x116", "indexInBlock": 0 }, { - "txhash": "0x653da2892fc5b19e542ee54ea44cec8b98c7a6a778a6e15cb4007db8b76ed34d", + "txhash": "0xdf64ad606a0975e92909f66625d6a00019e6664a18c67c84ef61ddded0bf0cc3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x120", + "block": "0x121", "indexInBlock": 0 }, { - "txhash": "0xf0721ceefdbd4ad6518652cb402c0611180101bc655545c973018120484c8d7c", + "txhash": "0x92219dc27a8c0fb0337c093c2e548a135bc5022a85fc6ccb0e7b2257e8bd2e86", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x12b", + "block": "0x12c", "indexInBlock": 0 }, { - "txhash": "0xb79eab5bad9b2b9c51873f53ee7820e99446c6530ac407be032d0bda6cd601a5", + "txhash": "0x1242e0eacb6a87f1066df63a9046b9d920b27f2e2d5f808599a4029a36a41e0a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x136", + "block": "0x137", "indexInBlock": 0 }, { - "txhash": "0xb000e7ae9e2b767464fc90d633aff286a663f6aa4c33b27b8649867f403b8848", + "txhash": "0xf27431f9cfd98c4b376684550e44b0b8e7c71dc997630f85680e1bc5c18cf3c3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x141", + "block": "0x142", "indexInBlock": 0 }, { - "txhash": "0xa79af0ce0ef3d6c97f08ad0519ee84eb102a8611ff9bbfdb513b737582c66a71", + "txhash": "0xe32fb93c2365ef4db9f3123a474af1fd4837c7bf0e4e0271c166c260b122aa45", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14c", + "block": "0x14d", "indexInBlock": 0 }, { - "txhash": "0xf3b4d8172c990c289f658b6c3ecf980ce627bfe540ea7a9a11cc4708a38d1e0a", + "txhash": "0xa76927c677654a060e2d90cbe4b326fa5eee76d797f54604786849c23879bdee", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x157", + "block": "0x158", "indexInBlock": 0 }, { - "txhash": "0x385cb2c14d85546645d1cbefa13c01bd6b2eb7f848fc132dd33631b3693d0234", + "txhash": "0x35d8f92489a6e1e20f1942193c470e18f4facd5e92b17db55fa311a397aff249", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x162", + "block": "0x163", "indexInBlock": 0 }, { - "txhash": "0x2cfecb05aa5dff4016e567291331de567995aef33595892dcc8da9e8626c5e29", + "txhash": "0x3698d4bd1112c7eceb64425a6b7b6a4b142d32c77bce800bd6767ecd10ca80bf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16d", + "block": "0x16e", "indexInBlock": 0 }, { - "txhash": "0x3c551a5bcb06c70c5ed8a024b9c3092d145806ec47c79711e728b776581ba933", + "txhash": "0xfc7bad28f0e8df37d6a65b3919d9854d2136e247fa4d2d434ae13f47cee60c81", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x178", + "block": "0x179", "indexInBlock": 0 }, { - "txhash": "0xf212343a00e92eecaa2882a9028a974cdb53427925ca5e8e514686429783b660", + "txhash": "0xde78807bcae67a3590b05f888d9d0a80ddea3c2d30bb2ebcc7a7b84de7943543", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x183", + "block": "0x184", "indexInBlock": 0 }, { - "txhash": "0x1690ab67922c40b4feba88cb3dadb633142ee6f8e394b61d5ce74efe81aaa7a3", + "txhash": "0x369b86a5664091d43b8bc3bbe4976da5a793a47583ffcca617267817e3ae445b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18e", + "block": "0x18f", "indexInBlock": 0 }, { - "txhash": "0x5051062bb54302b19e2f01987ce412c4026a6eccd8b1224adf89638a893d2ce6", + "txhash": "0x8eac800c7781a5ada09bfabee12ffdcecf65d517d164f42d1629a9d1eeb9995f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x199", + "block": "0x19a", "indexInBlock": 0 }, { - "txhash": "0x45b3d0b9de23a95ed6af569805c29bbb67e6a70bfa5f5af994b4d134f68b9fbd", + "txhash": "0x7232f8a35c4fc601bde57e96dbd338e6898ae0733b4feefe74610bb44705577e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a4", + "block": "0x1a5", "indexInBlock": 0 }, { - "txhash": "0xb3446d893246dd626944b802651f051f7e1f52827b8c1b1a1e1b4ab597286726", + "txhash": "0x5b9b04078f27faa47f01cb52179b174c5aaa67b1b3ca6776a2872fbe64be4dac", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1af", + "block": "0x1b0", "indexInBlock": 0 }, { - "txhash": "0x99d235917c941efc6dc2799623a2b36fc4f5eb2a975952e0a402cd368b2c5c3e", + "txhash": "0x25a2cb528f8f5373d2e472d7e28df6b9b18c6d14a5405433aab7333c6d19fe6b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ba", + "block": "0x1bb", "indexInBlock": 0 }, { - "txhash": "0x1841d6e9976ab0bcbc4b00cd67922c026eedd7663122d8f97ad4108f47d70813", + "txhash": "0x64b5195035210f1570783ab55464becc3bc8f3944f854b1432aa9bf4e5f442e2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c5", + "block": "0x1c6", "indexInBlock": 0 }, { - "txhash": "0x22c29f259f4f88ba7758679ceba786815af37b386f899e91fe0196729acee24d", + "txhash": "0xe898405f30c0ceffd19eb618b30e670cd4f75c3ed6cc3fd7700b40e050d6090f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d0", + "block": "0x1d1", "indexInBlock": 0 }, { - "txhash": "0xa157bad573954d4fab243dbb5fc73435233bd00ce8be8dbcd9f7be80b1d17a49", + "txhash": "0x1fe3a558cad7acef03cfe28ad0517af33fe5f1bf5d2497e8b9fc1ddf49f6666a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1db", + "block": "0x1dc", "indexInBlock": 0 }, { - "txhash": "0xe0f9de399946816e8a2db32d0738e41d22cce9f444f60824128e5b76ba0e813b", + "txhash": "0x1b1a72cfc78eb9ac22b033028c35bdec7347c40f3120ed9527fbde2966b78c35", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e6", + "block": "0x1e7", "indexInBlock": 0 }, { - "txhash": "0xf78a2067ea28bab199b8d21a42e09553c1bb8e5df791c76f3ebf77f9162e0da3", + "txhash": "0x0c41e800e62b889789d63028503a2afdc7b48dfa75f8fac0c8b9dccd73726858", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f1", + "block": "0x1f2", "indexInBlock": 0 }, { - "txhash": "0x754486a577ea77ec5e00664bf0451166b2d5dd9fe42e3b55b9824f78aa628d49", + "txhash": "0x7a7ad517c21c75ebca258a25c35b110f414004f87ecfe2aa29283a8b3815f2d8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1fc", + "block": "0x1fd", "indexInBlock": 0 }, { - "txhash": "0x5eee12b1b419ef402143847e1940476be871883c16c3a0a7229b817123c2a408", + "txhash": "0x995502755fff45ae2074c787012c900fdd6dc6264910712bf6b3cb0e25539c66", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x207", + "block": "0x208", "indexInBlock": 0 }, { - "txhash": "0x5970e58e6ed36d823ef504f70b1a28acc9433b76284ddf1a3814b3beba37146d", + "txhash": "0xe19b59781cfb6a730a22b24f96f6b8a9fcd567a0ea4238b2916affe2a1a131f4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x212", + "block": "0x213", "indexInBlock": 0 }, { - "txhash": "0xf5166d4fec3e9457916b4079e7526672cf797bcf7824b69a54867aa78e2f2691", + "txhash": "0xfdb1b2cb3fcf7c849c5376e1d5765e91cbaeeee0aea7877e1d379522436629c3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21d", + "block": "0x21e", "indexInBlock": 0 }, { - "txhash": "0x9a1c5ba87f390597ebd00d8ad572fd3c8b95c68910e62644cb055a0ef06e8eeb", + "txhash": "0x8510955c5bc445ab6272fd2e9cb7ecf10bb529d4edf5cb03eed14a86c34ab7e4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x228", + "block": "0x229", "indexInBlock": 0 }, { - "txhash": "0xef08e643ee3fc351e62c29536758cddb55b8978a71e0fd3ef60fc347d5e6965a", + "txhash": "0xd1c580b4cd75f21af59dc7312726122ca905d363982dd6bdc9b16ab459c4f351", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x233", + "block": "0x234", "indexInBlock": 0 }, { - "txhash": "0x5ffa342f7f5240c5fe829b8e171f0e206b71626337c84e091f08fbc38a64a04f", + "txhash": "0x95826c39ecf731f43925e7be0c36d389cd6dd7cba81911a92e33c60c07a1e54f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23e", + "block": "0x23f", "indexInBlock": 0 }, { - "txhash": "0x93c697d79b649351a04237604f19f399b797ca5756ec56c83657f06ceda7f06f", + "txhash": "0xa25c1a0867649aca89addff35c96b8beb149f68606e08621b9a391ccef9df0db", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x249", + "block": "0x24a", "indexInBlock": 0 }, { - "txhash": "0xd8d2d00485bb8b861ebfe6cf40ff7244593d92fa9d30f8200542527ced99e37d", + "txhash": "0x87fb42acce30f67650d3917485de95788ba5002054907b67996498c23e03137c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x254", + "block": "0x255", "indexInBlock": 0 } ], "tx-transfer-eip2930": [ { - "txhash": "0xe0b7691cf34a37b87a56a79d2887ebb9e1f132d58b0e34c93e51ac80ae361965", + "txhash": "0xf278a97c1c92c517531ae9f24179862518cf6397cd3615deebe37049d5a6c695", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe", + "block": "0xf", "indexInBlock": 0 }, { - "txhash": "0xe404d773d3dd0560096e006eca641ba5345090871591f3fe7e375e7a430c98c7", + "txhash": "0xc33009465ef1eb2ff62d02d50cbaaf73fee9dff8be51f71ac7976367ddfc4541", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x19", + "block": "0x1a", "indexInBlock": 0 }, { - "txhash": "0x0714cd906571480a922fe8d78c1f1061fc40db2cd1ed8cbb4369fda866626a0e", + "txhash": "0xa6598b072ed0598260358ed568e3c907d36e422b14e35ab459e9e24ae98251ef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x24", + "block": "0x25", "indexInBlock": 0 }, { - "txhash": "0xfe336bb145af0acfb0aaccafd4318827ed629b8dd51c3e9acd799bb8831bc5f7", + "txhash": "0x61aa0de65eb4a0db81573b043c35a4de3dcfabf37117a3e67905c7d3038dad23", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2f", + "block": "0x30", "indexInBlock": 0 }, { - "txhash": "0x996f4a409ebc40722579170f38948bc8df1aaceddd57fe43799895e989e9037b", + "txhash": "0xdcf01b9729cddeefec7be5348f0d364ee1295831f999c0f5a49b047c9694e970", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x3a", + "block": "0x3b", "indexInBlock": 0 }, { - "txhash": "0x3723f923685f12cc032c922ea5b3bb33c3801e3501fd5c33efe367036068e209", + "txhash": "0x7867b39e0b2f176fbd61364bce00443bd3f2ca5d743d3ab95104cb13a5cf5208", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x45", + "block": "0x46", "indexInBlock": 0 }, { - "txhash": "0x0920572b6c461143bad4fb1c8fce1172555e1e7def25fa332aa4f925b257372e", + "txhash": "0x2ba84167cbba25e83e98cbca146d39a4a36d29dc2c9d971b41bf5ea1b9c9425a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x50", + "block": "0x51", "indexInBlock": 0 }, { - "txhash": "0x14976ca88889d8e531c3e6e857777514216db60edbc5275e54e07bc1bca12f9d", + "txhash": "0x203b1d7997f674fd45fe2eb6af5f0a88b59eaa8598b86f408ca44763e034bd36", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x5b", + "block": "0x5c", "indexInBlock": 0 }, { - "txhash": "0x27bbf3f736afb8fcaecb7ac3ccc9c213884eeb5fc7eb657954e148231ff3bcb0", + "txhash": "0x8fd08a67b065db1005917aea2934104c6132cad339c2fe07f51e7717bbe4ffe7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x66", + "block": "0x67", "indexInBlock": 0 }, { - "txhash": "0x9acc4d59b8d8c2266714935b4a6f240f58816db5d957883864be194491038cf0", + "txhash": "0xf0a9ae994a7741fcbe854f2d4a684f5fd434d40badc2ae36611f5764aaeb08b3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x71", + "block": "0x72", "indexInBlock": 0 }, { - "txhash": "0xe6aa517bcd4b76ad664af114669499b69d4cd4fa9482e12ac17b519d35d040e1", + "txhash": "0x090fcb3259cccab1bad9dd572493e4ee05df3f53137ca16b4e7ea2f5b5c1d7d3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x7c", + "block": "0x7d", "indexInBlock": 0 }, { - "txhash": "0xc282a609762a7ddd8fbf2202f132e7c6e94c63f05ae94a26833cedeb55f3e7ec", + "txhash": "0xe79b88caea408e8be7e3ac3269889b8f59fd4c1ca612213b9a7999ffe5b72e52", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x87", + "block": "0x88", "indexInBlock": 0 }, { - "txhash": "0xbba59f4b08448ce6e94e457da75e10871594f2fb719b47a94d01354b06db8b4b", + "txhash": "0x1bfa25e0530d084489db9ab1b6afa7d9f1c3b39f863adf5e2832768927644daa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x92", + "block": "0x93", "indexInBlock": 0 }, { - "txhash": "0x26e0ad605b9338c5f9396bd4da0857e4711b6e67303ab777d2f3e304eeb0198b", + "txhash": "0xde483617d2d66c2ad07033b75a73e0c3d9be8e57b614a2aee96eba35f414629d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9d", + "block": "0x9e", "indexInBlock": 0 }, { - "txhash": "0x9c2232aba0d6cea846a96d85fff3444cc9a9c2b4063232d1ebbb3b00a5bacda3", + "txhash": "0x29aeef1bb9f0555427576d10a93920d4cbb848b4df7a11708e1d15877dc1b2e0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa8", + "block": "0xa9", "indexInBlock": 0 }, { - "txhash": "0x1eacd4527bb933ad6054547d9f245ac44e26dbfa11610ed6e835772c6ac8ae48", + "txhash": "0x00986df4dd53f3e79bfb60d0d6532963c32d14082b90a5e0f781a90521c39926", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb3", + "block": "0xb4", "indexInBlock": 0 }, { - "txhash": "0x38647f25a7e7a05902d512884a52a2733603be1e5f20fe9eeda0e2f2dc6fb89e", + "txhash": "0x1041875f7d50a26da74163d4e54a7f9c93d314c299725aa85cbfc7a3ecc35297", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xbe", + "block": "0xbf", "indexInBlock": 0 }, { - "txhash": "0x35ba3e88129db4e62c1806e016e731c72b4d202c2ed1664af0d751558e0b2f5f", + "txhash": "0x79628bf904cf51c4a9746ca13c3f6f55c8cdae638fb2b3166a66d516c4eb5003", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc9", + "block": "0xca", "indexInBlock": 0 }, { - "txhash": "0x714288a3625459cfae682e2e053fb9a6366dd0e37e655da8ac8a603b0c2c879b", + "txhash": "0x40094566e6f9bb849004d5f9593bc361c8572fdda9d56f17dae2cda65c6c1e75", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd4", + "block": "0xd5", "indexInBlock": 0 }, { - "txhash": "0x638d97e8a1034faf96ade4fb9ca6abacf25c66ccdfe5824a999cde11eaa3b8ed", + "txhash": "0x36bcaa05763afdbab9ba004c67cfa38fdd5f0fd87164d8ff388720a54ba4a8a1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xdf", + "block": "0xe0", "indexInBlock": 0 }, { - "txhash": "0xc1382a6685aa78c36e5ed96410da6fdb90549678bd5017ed89412a19ed199f81", + "txhash": "0xb624d30fb3f252245883434de2ed770b795e907a619ac88992d6b7699b48cfa7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xea", + "block": "0xeb", "indexInBlock": 0 }, { - "txhash": "0xb446f8fe040ee764827538219e03981d204c329070db7c0a48cd44adeb24db8f", + "txhash": "0xbd3087ce9745fe988d07ea8ba090b4cb8d1a86e57c50fdcdbb30ecb908dc9e6b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf5", + "block": "0xf6", "indexInBlock": 0 }, { - "txhash": "0xa358a78375426e23e7c6662acd42da119b8f87f2e2888adc163a170cd5e826c7", + "txhash": "0xafa45cc36b48bc966aa8aa30e408db455e4f9c1add0587a89ba40a94866d1e03", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x100", + "block": "0x101", "indexInBlock": 0 }, { - "txhash": "0x7a7611969dfd1bde5325f206a97e22c2bc462ff5d2081e71ff89d28777f31c06", + "txhash": "0xac35c9970d8166e66a131b1b3dc2f863e7ae36292e6a49bbfcb83f3cdd2ff2d2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x10b", + "block": "0x10c", "indexInBlock": 0 }, { - "txhash": "0x457a238e8a1daf3960fc558f8f84033fd33f59fb988b9a9adae36f873ff3c3b4", + "txhash": "0x9b7e08f4c8fa53992950abce073f5eb02f380f451780d0d42de4c69e3a69af23", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x116", + "block": "0x117", "indexInBlock": 0 }, { - "txhash": "0x4c2d91cbcb732caa6abcbd4140976d0645f6c22d108e477617ee2db2d8129e67", + "txhash": "0x3e31801a2a6ea466f490a9b604a116f390794eb63c7ab4721017a5fdf966e166", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x121", + "block": "0x122", "indexInBlock": 0 }, { - "txhash": "0x8c9d1f3bb047963383dadc9ff7cb858b97773169532212e283a5695eea9e033f", + "txhash": "0x51c1f4e597a9f557a71e97975c0ee80b3036775d922acb96fdcab674023790c7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x12c", + "block": "0x12d", "indexInBlock": 0 }, { - "txhash": "0x4c09711bf3edf86842c892fcb260674ec524f014ef5c90f9f3bb23794a8b3956", + "txhash": "0x4e0eec0f6504ef995e5dbf52b0db7c0d4a637b8d4107fd9bb7b9cba124d4e6af", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x137", + "block": "0x138", "indexInBlock": 0 }, { - "txhash": "0x31992687ad2485da5c31dfda4dbeeec248a65f5ed003563af394e704dfacfc88", + "txhash": "0x3dcc58d773206b067dbd8dbc241e12c6cbc22beb64def944ced03490d10c504e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x142", + "block": "0x143", "indexInBlock": 0 }, { - "txhash": "0x661dde8fed4e46c464a33c0f20ee5403250ff3f3c3f99fa55d4307d911b874de", + "txhash": "0xbcd88536b680f217c8ba593327153a9a87850c293c7ab51d28e11161a8c114e6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14d", + "block": "0x14e", "indexInBlock": 0 }, { - "txhash": "0x923cb21db498ee179399dfdb8ebca0e0d9822bca94b1127bcd1f11489845e381", + "txhash": "0xfb4a89e5ad56f40bbd99694669c41784f0dc7b25ec485b07c29d9b8764f6370e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x158", + "block": "0x159", "indexInBlock": 0 }, { - "txhash": "0xb72ca20dc96db26fec00f01efa1b251f29bb12a1ceb311bfe8bf39431769221b", + "txhash": "0x403aa6d501d04dc47e052d9e8e35309047e0e6352bcababbb47d8c3095f2478f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x163", + "block": "0x164", "indexInBlock": 0 }, { - "txhash": "0xd156edd6076ac206519a5851bdb1ec90a88452c2948ae3fba2be79f1e91dbfe3", + "txhash": "0x2d80b71c714bc3f7fd0c5abce861e0499bf11ab1ac915a4ac399d6046b5341de", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16e", + "block": "0x16f", "indexInBlock": 0 }, { - "txhash": "0xf1743d554afb4af9f068901f7ad89b3b432d1bd7a88cbfaeab307a020f14e1de", + "txhash": "0x8e59e25432ee45eb91663edb66f23e30f8988a94d363bd4211ec8106bc7bdc7a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x179", + "block": "0x17a", "indexInBlock": 0 }, { - "txhash": "0x642dd19ff447e4f83c81c529faeaaf07c811215f9fab8967018ec9ff4c9570ef", + "txhash": "0x3b17e71cc75e8af270a71446cb1f55dcd2c3c8c638ba7ca3b156713d5c5bc740", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x184", + "block": "0x185", "indexInBlock": 0 }, { - "txhash": "0x259e0e9918735fd7786872176cec8a4669e0bfcae37a6ce496023d871407d395", + "txhash": "0x62b840b93964bf5ef9f3b308f6cdad7793796a94d6810edd7db64d2d41801b0a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18f", + "block": "0x190", "indexInBlock": 0 }, { - "txhash": "0x34fe95d74f6232b0273cdac075cba7ab6438ae662e89aa71e8b99206bfc57153", + "txhash": "0xf1c711c41fc04a59b26b14994f625576a7c708302044d5dbe3926bde93505459", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x19a", + "block": "0x19b", "indexInBlock": 0 }, { - "txhash": "0xcf826d5d3ccfe1773b5b83a3ec29de8826c92566e310cabf8940733d71ad1cba", + "txhash": "0x7f8d63774d886b4d1e8ad70daf38208d3037fbdf875c1180904240308cb290bd", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a5", + "block": "0x1a6", "indexInBlock": 0 }, { - "txhash": "0x5a88d1e506f286c57a7a3a6f68cab3b18e9f3ef279b574e6910cca83bdaf7daf", + "txhash": "0xc2e3e4e30aa8973c6fa6a8ca0fc9d2c77e4e720d72ed0311132c5a9d33dbad49", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b0", + "block": "0x1b1", "indexInBlock": 0 }, { - "txhash": "0xe383a01e0ad60a5f35cadbe8938a1459a679b7717166a9373512c1a832f24423", + "txhash": "0x0a92968be399bb163ed87a9e950f87301d1bee7faddd5ee58a966629eccd4d99", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1bb", + "block": "0x1bc", "indexInBlock": 0 }, { - "txhash": "0x65efb74528143a9b3fcedcb4e94892d25661480613c1485fccc00691c7488c8d", + "txhash": "0x7f087aea555e2f441682d04c022a63c60dd38129da8196be244618d539b1d899", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c6", + "block": "0x1c7", "indexInBlock": 0 }, { - "txhash": "0x54dcbac0ede42273e9b00e78dbc44bd30122cd3b5b17fbf7b8b761bee5de60f7", + "txhash": "0xfcbee8bc75ade3572115835825b2babe4de4e1e3b776323334e4a6e66c4746ae", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d1", + "block": "0x1d2", "indexInBlock": 0 }, { - "txhash": "0x725e6fdd298ee6d7a0c85da4b86338b179d0e1e2412042302e14e2d1f80fc7c2", + "txhash": "0xf50c7c278b5e2bf2a15b523f4a714ab4c3aa2de23e1b45b20fe7df6dfc0d3d1b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1dc", + "block": "0x1dd", "indexInBlock": 0 }, { - "txhash": "0x9b4e47130328936b6c1c0b1eba493d17c314f973dfe7e75b42a3db206e504a23", + "txhash": "0xca67efa5a92421ffc387fcb06b4f53a14148c1da50f0cc514814587f5f1a63aa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e7", + "block": "0x1e8", "indexInBlock": 0 }, { - "txhash": "0xece1d40c8ee54ccb4e80533dc30cc365e44f97f62b66173819bf3d8629b69381", + "txhash": "0x2d35008bda6dad6c13a68788a1b0b4b671d82ba03ce007d8026124bc2f78ad4e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f2", + "block": "0x1f3", "indexInBlock": 0 }, { - "txhash": "0x76a2d9684d03b8e18b262d1d27a0d6b21753b93efd510b3913ce0ebe1767945c", + "txhash": "0x6e4b127cec980eaebed4039019171993d63ccf3d8f50792b3b651381391d6a3f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1fd", + "block": "0x1fe", "indexInBlock": 0 }, { - "txhash": "0x46351b527c01acf613175fc763cd5a2a70e35c38c7c76ee0b6555f787d86c6e2", + "txhash": "0xab711b291a1efce49e0ff8f0aebe8acdc84eae9405b2d70cb4a886854160a1be", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x208", + "block": "0x209", "indexInBlock": 0 }, { - "txhash": "0xc954c8d329f749ec212c19a85f38482b2a3970da384441ca205ba09a792ea1f7", + "txhash": "0x996878da21de571313c57f2f0dac52d8fc906c4e038bbaa0e5171a46c08dabf9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x213", + "block": "0x214", "indexInBlock": 0 }, { - "txhash": "0x96ee75e8ef38f2fdaef65165ea3b03d125558e45a74568479ef47db03aa6c5fc", + "txhash": "0xd9743a7901761dce46c57ff8df4d3cdf874e108891ff5661ed7d2a4eaf50b54b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21e", + "block": "0x21f", "indexInBlock": 0 }, { - "txhash": "0x2a843d73fc5567275043097afb99799acc38822f63b279d4b1a027fda110968b", + "txhash": "0x388c9d3c3c9ba4afb738e3a0778166e39f685adcfea23175196f0eee64d173bc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x229", + "block": "0x22a", "indexInBlock": 0 }, { - "txhash": "0x32858610393c1bbc5506b9126e2c6be2030c82c93d298fba9c14cc0ada2513d2", + "txhash": "0xf5df907bbe60656be433813c67a612166b23245e7d83078ae8975835f410d492", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x234", + "block": "0x235", "indexInBlock": 0 }, { - "txhash": "0xccc59651e1e4c4b64d645f6110eb5433ce8848b4bcdd5bd7d628eed653a9b32b", + "txhash": "0xe75a50ed07ea70f57dab38daaa3bfa7e763a4fd4503eb13a77518a10648f7caa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23f", + "block": "0x240", "indexInBlock": 0 }, { - "txhash": "0x0f6365dd89c14374995007394ad902ef1b4076160ca7c469a2f40db5143e40fb", + "txhash": "0xb01424eaa3df62924ba4d4e52117b89c7ed24a7556c2d46367f908ad41784db0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x24a", + "block": "0x24b", "indexInBlock": 0 }, { - "txhash": "0x2bdf049c6e42fb2882aa350ae0b1ea17e1cc696505a755f97710a13ab5dd2100", + "txhash": "0x05fe8649c80459cd462cea4676d39d5be523f672f2a1e5fc210b5b6571b59450", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x255", + "block": "0x256", "indexInBlock": 0 } ], "tx-transfer-legacy": [ { - "txhash": "0xf5d6671f1963c4b2803a03776a06fe6fcc7ebae6fcc714f2ba9abaa6b9c4331c", + "txhash": "0x4845dfdee733cb11e204253aa9b2e0a9597c9b7f700642d084fd5aad365dbeff", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf", + "block": "0x10", "indexInBlock": 0 }, { - "txhash": "0x2c4880155cc7084393750b60732e44dfcc36b5da126d7dafd2e3e679d1fe1456", + "txhash": "0xe4ba4ed6784f2f452274186824174874661f76c1961d34fee86371da194a428f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a", + "block": "0x1b", "indexInBlock": 0 }, { - "txhash": "0x836d8aef2c4549477e76f9d2250a7818d2659551d4e46d979b3a9c0695824fd5", + "txhash": "0xe30c98691cc89f2db31aec5c2b3cdfd720015210fce4b48a8ce561d7f179af8b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x25", + "block": "0x26", "indexInBlock": 0 }, { - "txhash": "0x4142c689b6edab80bd472c19730a883236279ffa68be403a4e0062d34b095cde", + "txhash": "0x7538bb702539b67fbb8d44d2e946d1d241ddc4c2943e48ecb3107c8868184775", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x30", + "block": "0x31", "indexInBlock": 0 }, { - "txhash": "0x3d15ef5c40d1abe4006d81bc88a3d7918853099afa1d6ce499747ae49181deb8", + "txhash": "0x88edfa85d3e3bab608081a9421e0eab5fbd09ad10db58c07c178c6ac74617233", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x3b", + "block": "0x3c", "indexInBlock": 0 }, { - "txhash": "0x36b77745eacf696b87e1cefa6eb7308299c022fd04ca579f67bbf9f88a769670", + "txhash": "0x41aec073b267edc44e28b0c33f8c20e7619687ca5d7f09faa30e49621cdd3e70", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x46", + "block": "0x47", "indexInBlock": 0 }, { - "txhash": "0x7bd16c7de942d1dfd8a330d3b4f4388897b88c1e55e29950aaa67ab5d340d63b", + "txhash": "0xe0854da80105ea343c29cb7a8db30413b59f5b62a1f42793ce635be4e7536cc9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x51", + "block": "0x52", "indexInBlock": 0 }, { - "txhash": "0x70aa1c05d32af66dadf90df365318ff39bb29204c01e52e7687c2fa03bcd7792", + "txhash": "0x0cf942350189ee11294379c2a16c9744bc7502f127f4f71ac95cf0a2f681aa3a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x5c", + "block": "0x5d", "indexInBlock": 0 }, { - "txhash": "0x53fb233255b5c3a627afe4bb562c30bcff7c001bbd84118daf5bf7dab3f6b741", + "txhash": "0xd521a3fccc17113eac1a50bd0a34a3ca87ee5234c51fe41ba8eb8c26ad142363", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x67", + "block": "0x68", "indexInBlock": 0 }, { - "txhash": "0xfd5f8f34059ec5a386048f048022aebe3977b326babac83b34d43f1810aea93c", + "txhash": "0x1bcb6ff54f0f244c3b7390b488e76c3d1d95ff7f340adb81f785820930edc010", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x72", + "block": "0x73", "indexInBlock": 0 }, { - "txhash": "0x98e0d4060dbb4451b13a56dfee901f55d212981e156ad9672cb4bc32e95f7744", + "txhash": "0x7571a5b0881a76054142ad7af3924bd225a67a4705479f4f87e6a68388a5f0aa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x7d", + "block": "0x7e", "indexInBlock": 0 }, { - "txhash": "0xdf35c584e51084b3e1ce88e6927f8dfe4b338538026e0119ed44a8a06ee8680f", + "txhash": "0x999f17b911d92aaed0c83e37a545cf44f1effaf1245bddc7c63aae3c092e8200", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x88", + "block": "0x89", "indexInBlock": 0 }, { - "txhash": "0xdd0cdb19583b486fe64aea158301d580605ce93f722e5ed76b6d091ef33cb36b", + "txhash": "0xb72b3670cd73b79b8083e590a96c942c0e387c4f0df39eadee69bf0d23c12f8f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x93", + "block": "0x94", "indexInBlock": 0 }, { - "txhash": "0x5fbf81465a08a6fd6c858ba525a6449759ad4dd9772e88aefa7d70b40f59fe94", + "txhash": "0x71d5d38bd1d2af22f3a2bbc6b657b2d1c081a5f7a8345e1aa0c9f7bacfe884a0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9e", + "block": "0x9f", "indexInBlock": 0 }, { - "txhash": "0x0707d1ec61cbc124e3cc6dd2b3617df6d15c247b4513776fbc64d6749e212564", + "txhash": "0x6acdc778a4e9df4318ee1f01bd3dbdad1539cdb53ff865d28827ce21ac9ab9d6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa9", + "block": "0xaa", "indexInBlock": 0 }, { - "txhash": "0x15ce9de77512ff529b9493f36c4faa3b287e2f48634f444ebf33db2bb26f019a", + "txhash": "0x0303678ee1fa8a6b080ed12b5a752d255008709a9b76e439f48357627d4d8dfe", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb4", + "block": "0xb5", "indexInBlock": 0 }, { - "txhash": "0x81109d5ba61fc6be29b6825aaa3de407d2691364584ec4465853891a1f9a9092", + "txhash": "0x2230bdceb24246aee1c7d17a98eccbfefba3079719c6c1e32e8b7d4fc789761d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xbf", + "block": "0xc0", "indexInBlock": 0 }, { - "txhash": "0x741a9b3cb46fb639934e6705950e754a35be54cde90edaa7dc7a7367b964ec1c", + "txhash": "0xab1ad5a65facf07d9687759b529fb8e8a1cb29ac4a5bc8178b58218a11b8b611", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xca", + "block": "0xcb", "indexInBlock": 0 }, { - "txhash": "0xc74ac6c61b5fa34bd613863335dc814d646c9670319c6b78c5ff78edd303a148", + "txhash": "0xf8d85b2cf1d77a5f513b3158fd49c5fb2b0a11fddad23ddeccfeccfadb3c9e89", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd5", + "block": "0xd6", "indexInBlock": 0 }, { - "txhash": "0x4cb8d6ad80fb3d560e3c99f89a1e6e949706ee34ac60dfee6d3bac5742defeea", + "txhash": "0xc076e024e047c92e61148b6a6312f704fd3d969febd46f9b41e0106f4bdce366", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe0", + "block": "0xe1", "indexInBlock": 0 }, { - "txhash": "0x43e55b80d307da89ba157e2404b4f74486379b82442d2c439b796d05f0b0cc48", + "txhash": "0xfc956eea160fcbbd4a13f4f56f984f245ff189f73512b4807b37e47b0f14096a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xeb", + "block": "0xec", "indexInBlock": 0 }, { - "txhash": "0x2d78dabdfdf32911d516e48b7630ef0c38d1f23e824a0d206126076ab27ea9de", + "txhash": "0x37f2c2e41705384ecf88d1bd58520a91614cbcc3a01ee2a9866482c669154d6c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf6", + "block": "0xf7", "indexInBlock": 0 }, { - "txhash": "0x1b87238c602d7af7240cc63513ffa0ded2851e43587ed3b6a4a9278ebd666f7c", + "txhash": "0xf13d8d224ceb88804b6f61adbf0067c9f67e8247b2748db8339b597cfdeffaef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x101", + "block": "0x102", "indexInBlock": 0 }, { - "txhash": "0x07796620f21dbc0f24cc465703dec79d4d1ede06e4203229a98ce5a1e3838f97", + "txhash": "0x370d01c7b49b48f7eaae30826df1b5f702721dab17da55f509e850665671cf3c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x10c", + "block": "0x10d", "indexInBlock": 0 }, { - "txhash": "0xe42627e627add33a75bac9aa36bbafd70ce5c225805c6c38e1cfe4d172d5115c", + "txhash": "0x3f5065a0ca467127e296ad2d27dc690eaf04d36490c7e7b34231c280fddf1797", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x117", + "block": "0x118", "indexInBlock": 0 }, { - "txhash": "0x63a4e7940479d26fe0540ec179765a76ad718016c46f50b091700bc445e94090", + "txhash": "0xc9edbf3ceeb867c3c6d22a70356139fdf595ef3f98ca4c41415e30a374d2da5a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x122", + "block": "0x123", "indexInBlock": 0 }, { - "txhash": "0x7069110601d62a25c9f53b0d8014a7a350ef57c49e6f4f065db8dcf2d3df424a", + "txhash": "0x3828637a29c6b96eedc2900ea419f059dde3f8d3399db36cadf89870a2784c0c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x12d", + "block": "0x12e", "indexInBlock": 0 }, { - "txhash": "0x908826470714e97daa2f45cca9b77e61fe6187cfd2382cc6855851c3ab6777e6", + "txhash": "0x477443f1609dd34747aff99d568b3752cd8478f75465c2c09717e69f0cbf089b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x138", + "block": "0x139", "indexInBlock": 0 }, { - "txhash": "0xe5e41eee4792cc57e81231553406f05ee5f5d0b1064e93eb113b22a5c67120e1", + "txhash": "0x5d3c2eb824b0e5fa14dc29635d3b0b17f070ddbbf9c8ce07dd62c212f4af61f6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x143", + "block": "0x144", "indexInBlock": 0 }, { - "txhash": "0x502f2197f9a78a84978ad877be0fe29c5c3277895337c7fba7dd2723644763de", + "txhash": "0xdbaed77ef32f3a0149d3a220bd0c2c49b6da1b7ef56637442f1b91c916064b0d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14e", + "block": "0x14f", "indexInBlock": 0 }, { - "txhash": "0xba56db6e61a61cd1a3aaade35a19f85c614ff0e7afbb7156986118a0dee9af6b", + "txhash": "0xd02a9a5522a418abb75b1330b317c98812c033f7ae8c177355c3836a8a28dc95", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x159", + "block": "0x15a", "indexInBlock": 0 }, { - "txhash": "0xc68be8d777be9b31eeffc3daf17761f3a5075875655fe029e82e18cf884b0102", + "txhash": "0x4bca9b38d6eb5008866383961fd1313869a8476fabb260d9b93a5b2dc8986905", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x164", + "block": "0x165", "indexInBlock": 0 }, { - "txhash": "0xcd438fbb83757586be3d83f4d004024f8cbf464f6bf1662671ba4e97177e86b1", + "txhash": "0xeaafeaf48129a32da8973a6190ce0c19b1f3729cc39d3eb55321bd45d3cafacf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16f", + "block": "0x170", "indexInBlock": 0 }, { - "txhash": "0x90a4b393275d8a4e40764b90b1820365ae3b0ebd92c14593789618e08fb44b29", + "txhash": "0x85e50638e9e342829033b7f51913edfe86cc1d7691f98ee4f1b725ba20e2a2d2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x17a", + "block": "0x17b", "indexInBlock": 0 }, { - "txhash": "0xa82459bb400a4fa392738753dc867627d2ee8436d95e143119505120808bb756", + "txhash": "0x7d87678bc9f09d640f401783a67768450e7d19d54ce2deb5fc157fc224be2692", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x185", + "block": "0x186", "indexInBlock": 0 }, { - "txhash": "0xba5383efd6209b60452c61ff20f5faf687ddcbb5426b3d202717a3a0f09cc655", + "txhash": "0x97c821ea0562ce8a74d88a738e7d104f82025952d07e855dca65cd0b46c2d3d5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x190", + "block": "0x191", "indexInBlock": 0 }, { - "txhash": "0xb99807ee84bbedc5e0f04e8bf82400919ffac94c7daa74ce717a9dfcd692dedb", + "txhash": "0xb6eb23273ff663427676741b12392ee848576225b18baefc308543f209500ca9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x19b", + "block": "0x19c", "indexInBlock": 0 }, { - "txhash": "0x1b50a9075eea2053d04b1149a22ceb5982115642e42a46f8773b1e75132ba334", + "txhash": "0x55dbcf25403390d76fab637c2ca501447a93aa371ff36d1316ea2858efbf1aad", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a6", + "block": "0x1a7", "indexInBlock": 0 }, { - "txhash": "0x607ef258fe227a1f5fb6a5bfaa714df94bc22567731591ebf3d2be6435735c85", + "txhash": "0xb163de0bcd66c79501165e608cde61312fcfd73d39c2b1970c4d6db2f8ee9595", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b1", + "block": "0x1b2", "indexInBlock": 0 }, { - "txhash": "0x6337272ab1f627a38c734a263da2debe7958c2154f6607f880d2d9c76cc70c88", + "txhash": "0xf6c6d5abdbb9489d60d66a0a1bf8cbfcd3d06c89cd1bb1aaca5fb0994a5c0e1c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1bc", + "block": "0x1bd", "indexInBlock": 0 }, { - "txhash": "0xd41f6909931b295eea7c3463a11c979d7174df197110ab3aeb77c16075b0e5be", + "txhash": "0xdca0b4a5f20554780d9b2510913cf39498ba3dd98253eddeb292aaab06cb76d1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c7", + "block": "0x1c8", "indexInBlock": 0 }, { - "txhash": "0x5dbc467c60a1655ffc50b47ae6250331a9cdc7818deca6a630e3f00be2fdd419", + "txhash": "0x198387dacde38e90275dc46370055c1180b6fa458930a20c09b900249ac93417", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d2", + "block": "0x1d3", "indexInBlock": 0 }, { - "txhash": "0xad3cdc85f95156f0e6b5cba9228e01db5f4cadea36238ace690321e8150780b7", + "txhash": "0x39d1f89c9b97905bb44a191b1df7364bbba74cd22634e74faac369419b4f409f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1dd", + "block": "0x1de", "indexInBlock": 0 }, { - "txhash": "0x0c35c17ae34707eb557bd7e3d6d56a0e3f39841365b4ef46b586131ffd80d93e", + "txhash": "0xc7aefb93eb98c60bb8badb08df91beb8ba154ef4c076c2b2fb3e68b1668fbb77", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e8", + "block": "0x1e9", "indexInBlock": 0 }, { - "txhash": "0x2660c57fca0ca07684524e301982e6ce557d2eef665d60a92c1bbac586b1daa3", + "txhash": "0xf9b76794a6143a25ee62c9d9e847d7068646dc954357bd4be1872148bd91923b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f3", + "block": "0x1f4", "indexInBlock": 0 }, { - "txhash": "0x57c142cf1c0eb125de13729a590e4e44dc4b65936068286e4fafa1d144c8548c", + "txhash": "0x3590ade203eb06fa0e509948eecdf53ef176c4792d90d50df070b1d1ca4931dc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1fe", + "block": "0x1ff", "indexInBlock": 0 }, { - "txhash": "0x4ec028beafac0f493add6acd0e5389d4767f6e756cfbebed4c907312bd990a7b", + "txhash": "0x267c879d60a9e2d6b86e57c6b50933288e1e50299f3cef26379a536a4703577c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x209", + "block": "0x20a", "indexInBlock": 0 }, { - "txhash": "0x92da32c91120e188fd7a7945c1f9632faa33b85b1c2d63e71da6c5e65d2597ef", + "txhash": "0x6c64b842af6cf82d41bda0f6181369b98d01b096e897299e46a08bddec540f93", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x214", + "block": "0x215", "indexInBlock": 0 }, { - "txhash": "0xb31ea80795c9bba23c7509df3148f04d0b6545e29d463e47ebbb59eb19bfc09d", + "txhash": "0xd64c4fdda714ae62c0ba6139a59dbfdd8d7a9d1bdd9ffd9ed6bb6fcfa618aaf5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21f", + "block": "0x220", "indexInBlock": 0 }, { - "txhash": "0x84ce5e0adc7ecf6da455c89cbb2fb88b19a6530fe3908dc78a3f48e053304bb2", + "txhash": "0x90faef9e382ce09403e51eee1af464cea2c363a5fe3458f03b123b0bf4c69914", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x22a", + "block": "0x22b", "indexInBlock": 0 }, { - "txhash": "0x2660f8cda902bad9c28fe68cc88cd1c8e168ed676b721a1d62ece206520f3ed9", + "txhash": "0x5cdd6add765fbd5afc12c77be220da2d4a81fdbc4f6572977f710d5eadca35ea", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x235", + "block": "0x236", "indexInBlock": 0 }, { - "txhash": "0x9bfb5a154892c511155e70f2897ec9191acc3826d3d94b7f59e14c393f9b82cf", + "txhash": "0x0c961395a8d267e7ce4919a810865266d9286f4272bd3504bc7eabeff7562c7c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x240", + "block": "0x241", "indexInBlock": 0 }, { - "txhash": "0x0fbd5dc542001c414af0d21f05c33a425491f56488994d16505c09782cf67076", + "txhash": "0x2bdbc6ce98d07e93505ceb1f524dbc95f1ced213453e35f1b772e8919729f411", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x24b", + "block": "0x24c", "indexInBlock": 0 }, { - "txhash": "0xbf6d4db691b6c5c6810508476aea4812982794ed5a399fc00c0290dc85901c3f", + "txhash": "0xf0092cb03bbed01544bfef80adfc92f2842a2be9e89a4f0029c50e9511d704e1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x256", + "block": "0x257", "indexInBlock": 0 } ], "withdrawals": { - "104": { + "105": { "withdrawals": [ { "index": "0x8", "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", "amount": "0x64" } ] }, - "115": { + "116": { "withdrawals": [ { "index": "0x9", "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", "amount": "0x64" } ] }, - "126": { + "127": { "withdrawals": [ { "index": "0xa", "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "amount": "0x64" } ] }, - "137": { + "138": { "withdrawals": [ { "index": "0xb", "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", "amount": "0x64" } ] }, - "148": { + "149": { "withdrawals": [ { "index": "0xc", "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", "amount": "0x64" } ] }, - "159": { + "160": { "withdrawals": [ { "index": "0xd", "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", "amount": "0x64" } ] }, - "16": { + "17": { "withdrawals": [ { "index": "0x0", "validatorIndex": "0x5", - "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", "amount": "0x64" } ] }, - "170": { + "171": { "withdrawals": [ { "index": "0xe", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", "amount": "0x64" } ] }, - "181": { + "182": { "withdrawals": [ { "index": "0xf", "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", "amount": "0x64" } ] }, - "192": { + "193": { "withdrawals": [ { "index": "0x10", "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", "amount": "0x64" } ] }, - "203": { + "204": { "withdrawals": [ { "index": "0x11", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", "amount": "0x64" } ] }, - "214": { + "215": { "withdrawals": [ { "index": "0x12", "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", "amount": "0x64" } ] }, - "225": { + "226": { "withdrawals": [ { "index": "0x13", "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", "amount": "0x64" } ] }, - "236": { + "237": { "withdrawals": [ { "index": "0x14", "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", "amount": "0x64" } ] }, - "247": { + "248": { "withdrawals": [ { "index": "0x15", "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "amount": "0x64" } ] }, - "258": { + "259": { "withdrawals": [ { "index": "0x16", "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", "amount": "0x64" } ] }, - "269": { + "270": { "withdrawals": [ { "index": "0x17", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", "amount": "0x64" } ] }, - "27": { + "28": { "withdrawals": [ { "index": "0x1", "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", "amount": "0x64" } ] }, - "280": { + "281": { "withdrawals": [ { "index": "0x18", "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", "amount": "0x64" } ] }, - "291": { + "292": { "withdrawals": [ { "index": "0x19", "validatorIndex": "0x5", - "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", "amount": "0x64" } ] }, - "302": { + "303": { "withdrawals": [ { "index": "0x1a", "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", "amount": "0x64" } ] }, - "313": { + "314": { "withdrawals": [ { "index": "0x1b", "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "address": "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2", "amount": "0x64" } ] }, - "324": { + "325": { "withdrawals": [ { "index": "0x1c", "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", "amount": "0x64" } ] }, - "335": { + "336": { "withdrawals": [ { "index": "0x1d", "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "amount": "0x64" } ] }, - "346": { + "347": { "withdrawals": [ { "index": "0x1e", "validatorIndex": "0x5", - "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", "amount": "0x64" } ] }, - "357": { + "358": { "withdrawals": [ { "index": "0x1f", "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "amount": "0x64" } ] }, - "368": { + "369": { "withdrawals": [ { "index": "0x20", "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", "amount": "0x64" } ] }, - "379": { + "380": { "withdrawals": [ { "index": "0x21", "validatorIndex": "0x5", - "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", "amount": "0x64" } ] }, - "38": { + "39": { "withdrawals": [ { "index": "0x2", "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", "amount": "0x64" } ] }, - "390": { + "391": { "withdrawals": [ { "index": "0x22", "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "amount": "0x64" } ] }, - "401": { + "402": { "withdrawals": [ { "index": "0x23", "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", "amount": "0x64" } ] }, - "412": { + "413": { "withdrawals": [ { "index": "0x24", @@ -3058,167 +3059,167 @@ } ] }, - "423": { + "424": { "withdrawals": [ { "index": "0x25", "validatorIndex": "0x5", - "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", "amount": "0x64" } ] }, - "434": { + "435": { "withdrawals": [ { "index": "0x26", "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "amount": "0x64" } ] }, - "445": { + "446": { "withdrawals": [ { "index": "0x27", "validatorIndex": "0x5", - "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", "amount": "0x64" } ] }, - "456": { + "457": { "withdrawals": [ { "index": "0x28", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", "amount": "0x64" } ] }, - "467": { + "468": { "withdrawals": [ { "index": "0x29", "validatorIndex": "0x5", - "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "amount": "0x64" } ] }, - "478": { + "479": { "withdrawals": [ { "index": "0x2a", "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", "amount": "0x64" } ] }, - "489": { + "490": { "withdrawals": [ { "index": "0x2b", "validatorIndex": "0x5", - "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", "amount": "0x64" } ] }, - "49": { + "50": { "withdrawals": [ { "index": "0x3", "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", "amount": "0x64" } ] }, - "500": { + "501": { "withdrawals": [ { "index": "0x2c", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", "amount": "0x64" } ] }, - "511": { + "512": { "withdrawals": [ { "index": "0x2d", "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", + "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", "amount": "0x64" } ] }, - "522": { + "523": { "withdrawals": [ { "index": "0x2e", "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", "amount": "0x64" } ] }, - "533": { + "534": { "withdrawals": [ { "index": "0x2f", "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", "amount": "0x64" } ] }, - "544": { + "545": { "withdrawals": [ { "index": "0x30", "validatorIndex": "0x5", - "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", "amount": "0x64" } ] }, - "555": { + "556": { "withdrawals": [ { "index": "0x31", "validatorIndex": "0x5", - "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", "amount": "0x64" } ] }, - "566": { + "567": { "withdrawals": [ { "index": "0x32", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", "amount": "0x64" } ] }, - "577": { + "578": { "withdrawals": [ { "index": "0x33", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", "amount": "0x64" } ] }, - "588": { + "589": { "withdrawals": [ { "index": "0x34", @@ -3228,52 +3229,52 @@ } ] }, - "599": { + "600": { "withdrawals": [ { "index": "0x35", "validatorIndex": "0x5", - "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", "amount": "0x64" } ] }, - "60": { + "61": { "withdrawals": [ { "index": "0x4", "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", "amount": "0x64" } ] }, - "71": { + "72": { "withdrawals": [ { "index": "0x5", "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", "amount": "0x64" } ] }, - "82": { + "83": { "withdrawals": [ { "index": "0x6", "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", "amount": "0x64" } ] }, - "93": { + "94": { "withdrawals": [ { "index": "0x7", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", "amount": "0x64" } ] diff --git a/cmd/devp2p/internal/ethtest/transaction.go b/cmd/devp2p/internal/ethtest/transaction.go index cbbbbce8d94b..8ce26f3e1a2d 100644 --- a/cmd/devp2p/internal/ethtest/transaction.go +++ b/cmd/devp2p/internal/ethtest/transaction.go @@ -26,6 +26,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth/protocols/eth" "github.com/ethereum/go-ethereum/internal/utesting" + "github.com/ethereum/go-ethereum/rlp" ) // sendTxs sends the given transactions to the node and @@ -51,7 +52,8 @@ func (s *Suite) sendTxs(t *utesting.T, txs []*types.Transaction) error { return fmt.Errorf("peering failed: %v", err) } - if err = sendConn.Write(ethProto, eth.TransactionsMsg, eth.TransactionsPacket(txs)); err != nil { + encTxs, _ := rlp.EncodeToRawList(txs) + if err = sendConn.Write(ethProto, eth.TransactionsMsg, eth.TransactionsPacket{RawList: encTxs}); err != nil { return fmt.Errorf("failed to write message to connection: %v", err) } @@ -68,7 +70,8 @@ func (s *Suite) sendTxs(t *utesting.T, txs []*types.Transaction) error { } switch msg := msg.(type) { case *eth.TransactionsPacket: - for _, tx := range *msg { + txs, _ := msg.Items() + for _, tx := range txs { got[tx.Hash()] = true } case *eth.NewPooledTransactionHashesPacket: @@ -80,9 +83,10 @@ func (s *Suite) sendTxs(t *utesting.T, txs []*types.Transaction) error { if err != nil { t.Logf("invalid GetBlockHeaders request: %v", err) } + encHeaders, _ := rlp.EncodeToRawList(headers) recvConn.Write(ethProto, eth.BlockHeadersMsg, ð.BlockHeadersPacket{ - RequestId: msg.RequestId, - BlockHeadersRequest: headers, + RequestId: msg.RequestId, + List: encHeaders, }) default: return fmt.Errorf("unexpected eth wire msg: %s", pretty.Sdump(msg)) @@ -167,9 +171,10 @@ func (s *Suite) sendInvalidTxs(t *utesting.T, txs []*types.Transaction) error { if err != nil { t.Logf("invalid GetBlockHeaders request: %v", err) } + encHeaders, _ := rlp.EncodeToRawList(headers) recvConn.Write(ethProto, eth.BlockHeadersMsg, ð.BlockHeadersPacket{ - RequestId: msg.RequestId, - BlockHeadersRequest: headers, + RequestId: msg.RequestId, + List: encHeaders, }) default: return fmt.Errorf("unexpected eth message: %v", pretty.Sdump(msg)) diff --git a/cmd/devp2p/internal/v5test/discv5tests.go b/cmd/devp2p/internal/v5test/discv5tests.go index 2139cd8ca6fa..4dc25076930f 100644 --- a/cmd/devp2p/internal/v5test/discv5tests.go +++ b/cmd/devp2p/internal/v5test/discv5tests.go @@ -52,7 +52,7 @@ func (s *Suite) AllTests() []utesting.Test { {Name: "Ping", Fn: s.TestPing}, {Name: "PingLargeRequestID", Fn: s.TestPingLargeRequestID}, {Name: "PingMultiIP", Fn: s.TestPingMultiIP}, - {Name: "PingHandshakeInterrupted", Fn: s.TestPingHandshakeInterrupted}, + {Name: "HandshakeResend", Fn: s.TestHandshakeResend}, {Name: "TalkRequest", Fn: s.TestTalkRequest}, {Name: "FindnodeZeroDistance", Fn: s.TestFindnodeZeroDistance}, {Name: "FindnodeResults", Fn: s.TestFindnodeResults}, @@ -158,22 +158,20 @@ the attempt from a different IP.`) } } -// TestPingHandshakeInterrupted starts a handshake, but doesn't finish it and sends a second ordinary message -// packet instead of a handshake message packet. The remote node should respond with -// another WHOAREYOU challenge for the second packet. -func (s *Suite) TestPingHandshakeInterrupted(t *utesting.T) { - t.Log(`TestPingHandshakeInterrupted starts a handshake, but doesn't finish it and sends a second ordinary message -packet instead of a handshake message packet. The remote node should respond with -another WHOAREYOU challenge for the second packet.`) - +// TestHandshakeResend starts a handshake, but doesn't finish it and sends a second ordinary message +// packet instead of a handshake message packet. The remote node should repeat the previous WHOAREYOU +// challenge for the first PING. +func (s *Suite) TestHandshakeResend(t *utesting.T) { conn, l1 := s.listen1(t) defer conn.close() // First PING triggers challenge. ping := &v5wire.Ping{ReqID: conn.nextReqID()} conn.write(l1, ping, nil) + var challenge1 *v5wire.Whoareyou switch resp := conn.read(l1).(type) { case *v5wire.Whoareyou: + challenge1 = resp t.Logf("got WHOAREYOU for PING") default: t.Fatal("expected WHOAREYOU, got", resp) @@ -181,9 +179,16 @@ another WHOAREYOU challenge for the second packet.`) // Send second PING. ping2 := &v5wire.Ping{ReqID: conn.nextReqID()} - switch resp := conn.reqresp(l1, ping2).(type) { - case *v5wire.Pong: - checkPong(t, resp, ping2, l1) + conn.write(l1, ping2, nil) + switch resp := conn.read(l1).(type) { + case *v5wire.Whoareyou: + if resp.Nonce != challenge1.Nonce { + t.Fatalf("wrong nonce %x in WHOAREYOU (want %x)", resp.Nonce[:], challenge1.Nonce[:]) + } + if !bytes.Equal(resp.ChallengeData, challenge1.ChallengeData) { + t.Fatalf("wrong ChallengeData in resent WHOAREYOU (want %x)", resp.ChallengeData, challenge1.ChallengeData) + } + resp.Node = conn.remote default: t.Fatal("expected WHOAREYOU, got", resp) } @@ -252,34 +257,50 @@ that they are returned by FINDNODE.`) // Create bystanders. nodes := make([]*bystander, 5) - added := make(chan enode.ID, len(nodes)) + liveCh := make(chan enode.ID, len(nodes)) for i := range nodes { - nodes[i] = newBystander(t, s, added) + nodes[i] = newBystander(t, s, liveCh) defer nodes[i].close() } - // Get them added to the remote table. + // Prefill each bystander with the full bystander set so background FINDNODE + // lookups see useful routing data instead of empty responses. + known := make([]*enode.Node, 0, len(nodes)) + for _, bn := range nodes { + known = append(known, bn.conn.localNode.Node()) + } + for _, bn := range nodes { + bn.known = append([]*enode.Node(nil), known...) + } + + // Wait until enough bystanders have actually become live, i.e. the remote node + // has revalidated them by sending PING and receiving our PONG. + requiredLiveNodes := len(nodes) timeout := 60 * time.Second timeoutCh := time.After(timeout) - for count := 0; count < len(nodes); { + liveSet := make(map[enode.ID]*enode.Node) + for len(liveSet) < requiredLiveNodes { select { - case id := <-added: - t.Logf("bystander node %v added to remote table", id) - count++ + case id := <-liveCh: + for _, bn := range nodes { + if bn.id() == id { + liveSet[id] = bn.conn.localNode.Node() + break + } + } + t.Logf("bystander node %v became live", id) case <-timeoutCh: - t.Errorf("remote added %d bystander nodes in %v, need %d to continue", count, timeout, len(nodes)) - t.Logf("this can happen if the node has a non-empty table from previous runs") + t.Errorf("remote revalidated %d bystander nodes in %v, need %d to continue", len(liveSet), timeout, requiredLiveNodes) return } } - t.Logf("all %d bystander nodes were added", len(nodes)) + t.Logf("continuing after all %d bystander nodes became live", len(liveSet)) - // Collect our nodes by distance. + // Collect live nodes by distance. var dists []uint expect := make(map[enode.ID]*enode.Node) - for _, bn := range nodes { - n := bn.conn.localNode.Node() - expect[n.ID()] = n + for id, n := range liveSet { + expect[id] = n d := uint(enode.LogDist(n.ID(), s.Dest.ID())) if !slices.Contains(dists, d) { dists = append(dists, d) @@ -290,42 +311,63 @@ that they are returned by FINDNODE.`) t.Log("requesting nodes") conn, l1 := s.listen1(t) defer conn.close() - foundNodes, err := conn.findnode(l1, dists) - if err != nil { - t.Fatal(err) - } - t.Logf("remote returned %d nodes for distance list %v", len(foundNodes), dists) - for _, n := range foundNodes { - delete(expect, n.ID()) - } - if len(expect) > 0 { - t.Errorf("missing %d nodes in FINDNODE result", len(expect)) - t.Logf("this can happen if the test is run multiple times in quick succession") - t.Logf("and the remote node hasn't removed dead nodes from previous runs yet") - } else { - t.Logf("all %d expected nodes were returned", len(nodes)) + + const maxAttempts = 5 + const retryInterval = 2 * time.Second + + for attempt := 1; attempt <= maxAttempts; attempt++ { + foundNodes, err := conn.findnode(l1, dists) + if err != nil { + t.Fatal(err) + } + missing := make(map[enode.ID]struct{}) + for id := range expect { + missing[id] = struct{}{} + } + for _, n := range foundNodes { + delete(missing, n.ID()) + } + t.Logf("attempt %d: remote returned %d nodes for distance list %v, missing %d", attempt, len(foundNodes), dists, len(missing)) + if len(missing) == 0 { + t.Logf("all %d expected live nodes were returned", len(expect)) + return + } + if attempt < maxAttempts { + time.Sleep(retryInterval) + } } + t.Errorf("missing nodes in FINDNODE result after %d attempts", maxAttempts) + t.Logf("this can happen if the node has a non-empty table from previous runs") } // A bystander is a node whose only purpose is filling a spot in the remote table. type bystander struct { - dest *enode.Node - conn *conn - l net.PacketConn - - addedCh chan enode.ID - done sync.WaitGroup + dest *enode.Node + conn *conn + l net.PacketConn + known []*enode.Node + + liveCh chan enode.ID + sent map[v5wire.Nonce]v5wire.Packet + done sync.WaitGroup } -func newBystander(t *utesting.T, s *Suite, added chan enode.ID) *bystander { +func newBystander(t *utesting.T, s *Suite, live chan enode.ID) *bystander { conn, l := s.listen1(t) conn.setEndpoint(l) // bystander nodes need IP/port to get pinged bn := &bystander{ - conn: conn, - l: l, - dest: s.Dest, - addedCh: added, + conn: conn, + l: l, + dest: s.Dest, + liveCh: live, + sent: make(map[v5wire.Nonce]v5wire.Packet), } + // Establish an initial session and let the remote learn this node before + // switching to the passive responder loop below. + conn.reqresp(l, &v5wire.Ping{ + ReqID: conn.nextReqID(), + ENRSeq: conn.localNode.Seq(), + }) bn.done.Add(1) go bn.loop() return bn @@ -346,48 +388,57 @@ func (bn *bystander) close() { func (bn *bystander) loop() { defer bn.done.Done() - var ( - lastPing time.Time - wasAdded bool - ) for { - // Ping the remote node. - if !wasAdded && time.Since(lastPing) > 10*time.Second { - bn.conn.reqresp(bn.l, &v5wire.Ping{ - ReqID: bn.conn.nextReqID(), - ENRSeq: bn.dest.Seq(), - }) - lastPing = time.Now() - } - // Answer packets. - switch p := bn.conn.read(bn.l).(type) { + p, from := bn.conn.readFrom(bn.l) + switch p := p.(type) { + case *v5wire.Whoareyou: + p.Node = bn.dest + if resp, ok := bn.sent[p.Nonce]; ok { + nonce := bn.conn.writeTo(bn.l, resp, p, from) + delete(bn.sent, p.Nonce) + bn.sent[nonce] = resp + } else { + bn.conn.writeTo(bn.l, &v5wire.Ping{ + ReqID: bn.conn.nextReqID(), + ENRSeq: bn.conn.localNode.Seq(), + }, p, from) + } case *v5wire.Ping: - bn.conn.write(bn.l, &v5wire.Pong{ - ReqID: p.ReqID, + resp := &v5wire.Pong{ + ReqID: append([]byte(nil), p.ReqID...), ENRSeq: bn.conn.localNode.Seq(), - ToIP: bn.dest.IP(), - ToPort: uint16(bn.dest.UDP()), - }, nil) - wasAdded = true - bn.notifyAdded() + ToIP: from.IP, + ToPort: uint16(from.Port), + } + nonce := bn.conn.writeTo(bn.l, resp, nil, from) + bn.sent[nonce] = resp + bn.notifyLive() case *v5wire.Findnode: - bn.conn.write(bn.l, &v5wire.Nodes{ReqID: p.ReqID, RespCount: 1}, nil) - wasAdded = true - bn.notifyAdded() + resp := &v5wire.Nodes{ReqID: append([]byte(nil), p.ReqID...), RespCount: 1} + for _, n := range bn.known { + if slices.Contains(p.Distances, uint(enode.LogDist(n.ID(), bn.id()))) { + resp.Nodes = append(resp.Nodes, n.Record()) + } + } + nonce := bn.conn.writeTo(bn.l, resp, nil, from) + bn.sent[nonce] = resp case *v5wire.TalkRequest: - bn.conn.write(bn.l, &v5wire.TalkResponse{ReqID: p.ReqID}, nil) + resp := &v5wire.TalkResponse{ReqID: append([]byte(nil), p.ReqID...)} + nonce := bn.conn.writeTo(bn.l, resp, nil, from) + bn.sent[nonce] = resp case *readError: - if !netutil.IsTemporaryError(p.err) { - bn.conn.logf("shutting down: %v", p.err) - return + if netutil.IsTemporaryError(p.err) || v5wire.IsInvalidHeader(p.err) { + continue } + bn.conn.logf("shutting down: %v", p.err) + return } } } -func (bn *bystander) notifyAdded() { - if bn.addedCh != nil { - bn.addedCh <- bn.id() - bn.addedCh = nil +func (bn *bystander) notifyLive() { + if bn.liveCh != nil { + bn.liveCh <- bn.id() + bn.liveCh = nil } } diff --git a/cmd/devp2p/internal/v5test/framework.go b/cmd/devp2p/internal/v5test/framework.go index 92a504815009..0532dafb2c31 100644 --- a/cmd/devp2p/internal/v5test/framework.go +++ b/cmd/devp2p/internal/v5test/framework.go @@ -127,14 +127,16 @@ func (tc *conn) nextReqID() []byte { // The request is retried if a handshake is requested. func (tc *conn) reqresp(c net.PacketConn, req v5wire.Packet) v5wire.Packet { reqnonce := tc.write(c, req, nil) - switch resp := tc.read(c).(type) { + resp, from := tc.readFrom(c) + switch resp := resp.(type) { case *v5wire.Whoareyou: if resp.Nonce != reqnonce { return readErrorf("wrong nonce %x in WHOAREYOU (want %x)", resp.Nonce[:], reqnonce[:]) } resp.Node = tc.remote - tc.write(c, req, resp) - return tc.read(c) + tc.writeTo(c, req, resp, from) + resp2, _ := tc.readFrom(c) + return resp2 default: return resp } @@ -150,21 +152,24 @@ func (tc *conn) findnode(c net.PacketConn, dists []uint) ([]*enode.Node, error) results []*enode.Node ) for n := 1; n > 0; { - switch resp := tc.read(c).(type) { + resp, from := tc.readFrom(c) + switch resp := resp.(type) { case *v5wire.Whoareyou: // Handle handshake. if resp.Nonce == reqnonce { resp.Node = tc.remote - tc.write(c, findnode, resp) + tc.writeTo(c, findnode, resp, from) } else { return nil, fmt.Errorf("unexpected WHOAREYOU (nonce %x), waiting for NODES", resp.Nonce[:]) } case *v5wire.Ping: // Handle ping from remote. - tc.write(c, &v5wire.Pong{ + tc.writeTo(c, &v5wire.Pong{ ReqID: resp.ReqID, ENRSeq: tc.localNode.Seq(), - }, nil) + ToIP: from.IP, + ToPort: uint16(from.Port), + }, nil, from) case *v5wire.Nodes: // Got NODES! Check request ID. if !bytes.Equal(resp.ReqID, findnode.ReqID) { @@ -200,11 +205,16 @@ func (tc *conn) findnode(c net.PacketConn, dists []uint) ([]*enode.Node, error) // write sends a packet on the given connection. func (tc *conn) write(c net.PacketConn, p v5wire.Packet, challenge *v5wire.Whoareyou) v5wire.Nonce { + return tc.writeTo(c, p, challenge, tc.remoteAddr) +} + +// writeTo sends a packet on the given connection to the given UDP address. +func (tc *conn) writeTo(c net.PacketConn, p v5wire.Packet, challenge *v5wire.Whoareyou, to *net.UDPAddr) v5wire.Nonce { packet, nonce, err := tc.codec.Encode(tc.remote.ID(), tc.remoteAddr.String(), p, challenge) if err != nil { panic(fmt.Errorf("can't encode %v packet: %v", p.Name(), err)) } - if _, err := c.WriteTo(packet, tc.remoteAddr); err != nil { + if _, err := c.WriteTo(packet, to); err != nil { tc.logf("Can't send %s: %v", p.Name(), err) } else { tc.logf(">> %s", p.Name()) @@ -214,20 +224,30 @@ func (tc *conn) write(c net.PacketConn, p v5wire.Packet, challenge *v5wire.Whoar // read waits for an incoming packet on the given connection. func (tc *conn) read(c net.PacketConn) v5wire.Packet { + p, _ := tc.readFrom(c) + return p +} + +// readFrom waits for an incoming packet and returns its source address. +func (tc *conn) readFrom(c net.PacketConn) (v5wire.Packet, *net.UDPAddr) { buf := make([]byte, 1280) if err := c.SetReadDeadline(time.Now().Add(waitTime)); err != nil { - return &readError{err} + return &readError{err}, nil } - n, fromAddr, err := c.ReadFrom(buf) + n, from, err := c.ReadFrom(buf) if err != nil { - return &readError{err} + return &readError{err}, nil } - _, _, p, err := tc.codec.Decode(buf[:n], fromAddr.String()) + udpFrom, _ := from.(*net.UDPAddr) + // Use tc.remoteAddr for codec/session lookup because the fixture keys sessions + // by the advertised endpoint, but return the actual UDP source so responses can + // comply with the spec and go back to the request envelope address. + _, _, p, err := tc.codec.Decode(buf[:n], tc.remoteAddr.String()) if err != nil { - return &readError{err} + return &readError{err}, udpFrom } tc.logf("<< %s", p.Name()) - return p + return p, udpFrom } // logf prints to the test log. diff --git a/cmd/devp2p/rlpxcmd.go b/cmd/devp2p/rlpxcmd.go index 1dc8f82460ec..ec73171e76d0 100644 --- a/cmd/devp2p/rlpxcmd.go +++ b/cmd/devp2p/rlpxcmd.go @@ -17,6 +17,7 @@ package main import ( + "bytes" "errors" "fmt" "net" @@ -30,6 +31,31 @@ import ( "github.com/urfave/cli/v2" ) +// decodeRLPxDisconnect parses a disconnect message payload. Per the RLPx spec +// the payload is a list containing a single reason, but some implementations +// (including older geth) sent the reason as a bare byte. Accept both forms. +func decodeRLPxDisconnect(data []byte) (p2p.DiscReason, error) { + s := rlp.NewStream(bytes.NewReader(data), uint64(len(data))) + k, _, err := s.Kind() + if err != nil { + return 0, err + } + var reason p2p.DiscReason + if k == rlp.List { + if _, err := s.List(); err != nil { + return 0, err + } + if err := s.Decode(&reason); err != nil { + return 0, err + } + return reason, nil + } + if err := s.Decode(&reason); err != nil { + return 0, err + } + return reason, nil +} + var ( rlpxCommand = &cli.Command{ Name: "rlpx", @@ -103,11 +129,15 @@ func rlpxPing(ctx *cli.Context) error { } fmt.Printf("%+v\n", h) case 1: - var msg []p2p.DiscReason - if rlp.DecodeBytes(data, &msg); len(msg) == 0 { - return errors.New("invalid disconnect message") + // The disconnect message is specified as a list containing the reason, + // but some implementations (including older geth) send the reason as a + // single byte. Handle both forms, and on failure include the raw payload + // so the operator can see what was actually sent. + reason, decErr := decodeRLPxDisconnect(data) + if decErr != nil { + return fmt.Errorf("invalid disconnect message: %v (raw=0x%x)", decErr, data) } - return fmt.Errorf("received disconnect message: %v", msg[0]) + return fmt.Errorf("received disconnect message: %v", reason) default: return fmt.Errorf("invalid message code %d, expected handshake (code zero) or disconnect (code one)", code) } diff --git a/cmd/devp2p/rlpxcmd_test.go b/cmd/devp2p/rlpxcmd_test.go new file mode 100644 index 000000000000..d7b374c47dc5 --- /dev/null +++ b/cmd/devp2p/rlpxcmd_test.go @@ -0,0 +1,75 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "testing" + + "github.com/ethereum/go-ethereum/p2p" +) + +func TestDecodeRLPxDisconnect(t *testing.T) { + tests := []struct { + name string + payload []byte + want p2p.DiscReason + wantErr bool + }{ + { + name: "list form (spec-compliant)", + payload: []byte{0xc1, 0x04}, // [4] = TooManyPeers + want: p2p.DiscTooManyPeers, + }, + { + name: "list form with reason zero", + payload: []byte{0xc1, 0x80}, // [0] = Requested + want: p2p.DiscRequested, + }, + { + name: "bare byte form (legacy geth)", + payload: []byte{0x04}, // 4 = TooManyPeers + want: p2p.DiscTooManyPeers, + }, + { + name: "bare byte form zero", + payload: []byte{0x80}, // 0 = Requested + want: p2p.DiscRequested, + }, + { + name: "empty payload", + payload: []byte{}, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := decodeRLPxDisconnect(tc.payload) + if tc.wantErr { + if err == nil { + t.Fatalf("expected error, got reason=%v", got) + } + return + } + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got != tc.want { + t.Fatalf("got reason %v, want %v", got, tc.want) + } + }) + } +} diff --git a/cmd/era/main.go b/cmd/era/main.go index 35a889d4dc6b..43279e70014a 100644 --- a/cmd/era/main.go +++ b/cmd/era/main.go @@ -30,6 +30,8 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/execdb" + "github.com/ethereum/go-ethereum/internal/era/onedb" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/flags" "github.com/ethereum/go-ethereum/params" @@ -53,7 +55,7 @@ var ( eraSizeFlag = &cli.IntFlag{ Name: "size", Usage: "number of blocks per era", - Value: era.MaxEra1Size, + Value: era.MaxSize, } txsFlag = &cli.BoolFlag{ Name: "txs", @@ -131,7 +133,7 @@ func block(ctx *cli.Context) error { return nil } -// info prints some high-level information about the era1 file. +// info prints some high-level information about the era file. func info(ctx *cli.Context) error { epoch, err := strconv.ParseUint(ctx.Args().First(), 10, 64) if err != nil { @@ -142,33 +144,34 @@ func info(ctx *cli.Context) error { return err } defer e.Close() - acc, err := e.Accumulator() - if err != nil { - return fmt.Errorf("error reading accumulator: %w", err) + var ( + accHex string + tdStr string + ) + if acc, err := e.Accumulator(); err == nil { + accHex = acc.Hex() } - td, err := e.InitialTD() - if err != nil { - return fmt.Errorf("error reading total difficulty: %w", err) + if td, err := e.InitialTD(); err == nil { + tdStr = td.String() } info := struct { - Accumulator common.Hash `json:"accumulator"` - TotalDifficulty *big.Int `json:"totalDifficulty"` - StartBlock uint64 `json:"startBlock"` - Count uint64 `json:"count"` + Accumulator string `json:"accumulator,omitempty"` + TotalDifficulty string `json:"totalDifficulty,omitempty"` + StartBlock uint64 `json:"startBlock"` + Count uint64 `json:"count"` }{ - acc, td, e.Start(), e.Count(), + accHex, tdStr, e.Start(), e.Count(), } b, _ := json.MarshalIndent(info, "", " ") fmt.Println(string(b)) return nil } -// open opens an era1 file at a certain epoch. -func open(ctx *cli.Context, epoch uint64) (*era.Era, error) { - var ( - dir = ctx.String(dirFlag.Name) - network = ctx.String(networkFlag.Name) - ) +// open opens an era file at a certain epoch. +func open(ctx *cli.Context, epoch uint64) (era.Era, error) { + dir := ctx.String(dirFlag.Name) + network := ctx.String(networkFlag.Name) + entries, err := era.ReadDir(dir, network) if err != nil { return nil, fmt.Errorf("error reading era dir: %w", err) @@ -176,7 +179,28 @@ func open(ctx *cli.Context, epoch uint64) (*era.Era, error) { if epoch >= uint64(len(entries)) { return nil, fmt.Errorf("epoch out-of-bounds: last %d, want %d", len(entries)-1, epoch) } - return era.Open(filepath.Join(dir, entries[epoch])) + path := filepath.Join(dir, entries[epoch]) + return openByPath(path) +} + +// openByPath tries to open a single file as either eraE or era1 based on extension, +// falling back to the other reader if needed. +func openByPath(path string) (era.Era, error) { + switch strings.ToLower(filepath.Ext(path)) { + case ".erae": + if e, err := execdb.Open(path); err != nil { + return nil, err + } else { + return e, nil + } + case ".era1": + if e, err := onedb.Open(path); err != nil { + return nil, err + } else { + return e, nil + } + } + return nil, fmt.Errorf("unsupported or unreadable era file: %s", path) } // verify checks each era1 file in a directory to ensure it is well-formed and @@ -203,18 +227,58 @@ func verify(ctx *cli.Context) error { return fmt.Errorf("error reading %s: %w", dir, err) } - if len(entries) != len(roots) { - return errors.New("number of era1 files should match the number of accumulator hashes") + // Build the verification list respecting the rule: + // era1: must have accumulator, always verify + // erae: verify only if accumulator exists (pre-merge) + + // Build list of files to verify. + verify := make([]string, 0, len(entries)) + + for _, name := range entries { + path := filepath.Join(dir, name) + ext := strings.ToLower(filepath.Ext(name)) + + switch ext { + case ".era1": + e, err := onedb.Open(path) + if err != nil { + return fmt.Errorf("error opening era1 file %s: %w", name, err) + } + _, accErr := e.Accumulator() + e.Close() + if accErr != nil { + return fmt.Errorf("era1 file %s missing accumulator: %w", name, accErr) + } + verify = append(verify, path) + + case ".erae": + e, err := execdb.Open(path) + if err != nil { + return fmt.Errorf("error opening erae file %s: %w", name, err) + } + _, accErr := e.Accumulator() + e.Close() + if accErr == nil { + verify = append(verify, path) // pre-merge only + } + default: + return fmt.Errorf("unsupported era file: %s", name) + } + } + + if len(verify) != len(roots) { + return fmt.Errorf("mismatch between eras to verify (%d) and provided roots (%d)", len(verify), len(roots)) } // Verify each epoch matches the expected root. for i, want := range roots { // Wrap in function so defers don't stack. err := func() error { - name := entries[i] - e, err := era.Open(filepath.Join(dir, name)) + path := verify[i] + name := filepath.Base(path) + e, err := openByPath(path) if err != nil { - return fmt.Errorf("error opening era1 file %s: %w", name, err) + return fmt.Errorf("error opening era file %s: %w", name, err) } defer e.Close() // Read accumulator and check against expected. @@ -243,7 +307,7 @@ func verify(ctx *cli.Context) error { } // checkAccumulator verifies the accumulator matches the data in the Era. -func checkAccumulator(e *era.Era) error { +func checkAccumulator(e era.Era) error { var ( err error want common.Hash @@ -257,7 +321,7 @@ func checkAccumulator(e *era.Era) error { if td, err = e.InitialTD(); err != nil { return fmt.Errorf("error reading total difficulty: %w", err) } - it, err := era.NewIterator(e) + it, err := e.Iterator() if err != nil { return fmt.Errorf("error making era iterator: %w", err) } @@ -273,9 +337,6 @@ func checkAccumulator(e *era.Era) error { // accumulation across the entire set and are verified at the end. for it.Next() { // 1) next() walks the block index, so we're able to implicitly verify it. - if it.Error() != nil { - return fmt.Errorf("error reading block %d: %w", it.Number(), it.Error()) - } block, receipts, err := it.BlockAndReceipts() if err != nil { return fmt.Errorf("error reading block %d: %w", it.Number(), err) @@ -290,9 +351,13 @@ func checkAccumulator(e *era.Era) error { if rr != block.ReceiptHash() { return fmt.Errorf("receipt root in block %d mismatch: want %s, got %s", block.NumberU64(), block.ReceiptHash(), rr) } - hashes = append(hashes, block.Hash()) - td.Add(td, block.Difficulty()) - tds = append(tds, new(big.Int).Set(td)) + // Only include pre-merge blocks in accumulator calculation. + // Post-merge blocks have difficulty == 0. + if block.Difficulty().Sign() > 0 { + hashes = append(hashes, block.Hash()) + td.Add(td, block.Difficulty()) + tds = append(tds, new(big.Int).Set(td)) + } } if it.Error() != nil { return fmt.Errorf("error reading block %d: %w", it.Number(), it.Error()) diff --git a/cmd/evm/internal/t8ntool/block.go b/cmd/evm/internal/t8ntool/block.go index 37a6db9ffcde..6148e9e24888 100644 --- a/cmd/evm/internal/t8ntool/block.go +++ b/cmd/evm/internal/t8ntool/block.go @@ -56,6 +56,7 @@ type header struct { BlobGasUsed *uint64 `json:"blobGasUsed" rlp:"optional"` ExcessBlobGas *uint64 `json:"excessBlobGas" rlp:"optional"` ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` + SlotNumber *uint64 `json:"slotNumber" rlp:"optional"` } type headerMarshaling struct { @@ -68,6 +69,7 @@ type headerMarshaling struct { BaseFee *math.HexOrDecimal256 BlobGasUsed *math.HexOrDecimal64 ExcessBlobGas *math.HexOrDecimal64 + SlotNumber *math.HexOrDecimal64 } type bbInput struct { @@ -136,6 +138,7 @@ func (i *bbInput) ToBlock() *types.Block { BlobGasUsed: i.Header.BlobGasUsed, ExcessBlobGas: i.Header.ExcessBlobGas, ParentBeaconRoot: i.Header.ParentBeaconBlockRoot, + SlotNumber: i.Header.SlotNumber, } // Fill optional values. diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index 44f15c322c4c..a2de58ad4663 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -17,9 +17,12 @@ package t8ntool import ( + "context" + "encoding/json" "fmt" stdmath "math" "math/big" + "os" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -33,6 +36,7 @@ import ( "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -40,13 +44,15 @@ import ( "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/triedb" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) type Prestate struct { Env stEnv `json:"env"` Pre types.GenesisAlloc `json:"pre"` TreeLeaves map[common.Hash]hexutil.Bytes `json:"vkt,omitempty"` + // AllocPath, when non-empty, causes Apply to stream the alloc from disk + // instead of reading Pre, so the full map never materializes in memory. + AllocPath string `json:"-"` } //go:generate go run github.com/fjl/gencodec -type ExecutionResult -field-override executionResultMarshaling -out gen_execresult.go @@ -102,6 +108,7 @@ type stEnv struct { ParentExcessBlobGas *uint64 `json:"parentExcessBlobGas,omitempty"` ParentBlobGasUsed *uint64 `json:"parentBlobGasUsed,omitempty"` ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot"` + SlotNumber *uint64 `json:"slotNumber"` } type stEnvMarshaling struct { @@ -120,6 +127,7 @@ type stEnvMarshaling struct { ExcessBlobGas *math.HexOrDecimal64 ParentExcessBlobGas *math.HexOrDecimal64 ParentBlobGasUsed *math.HexOrDecimal64 + SlotNumber *math.HexOrDecimal64 } type rejectedTx struct { @@ -144,18 +152,27 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, return h } var ( - isEIP4762 = chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) - statedb = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre, isEIP4762) + isEIP4762 = chainConfig.IsUBT(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) + statedb *state.StateDB + ) + if pre.AllocPath != "" { + var err error + statedb, err = MakePreStateStreaming(rawdb.NewMemoryDatabase(), pre.AllocPath, isEIP4762) + if err != nil { + return nil, nil, nil, err + } + } else { + statedb = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre, isEIP4762) + } + var ( signer = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp) - gaspool = new(core.GasPool) + gaspool = core.NewGasPool(pre.Env.GasLimit) blockHash = common.Hash{0x13, 0x37} rejectedTxs []*rejectedTx includedTxs types.Transactions - gasUsed = uint64(0) blobGasUsed = uint64(0) receipts = make(types.Receipts, 0) ) - gaspool.AddGas(pre.Env.GasLimit) vmContext := vm.BlockContext{ CanTransfer: core.CanTransfer, Transfer: core.Transfer, @@ -195,6 +212,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, ExcessBlobGas: pre.Env.ParentExcessBlobGas, BlobGasUsed: pre.Env.ParentBlobGasUsed, BaseFee: pre.Env.ParentBaseFee, + SlotNumber: pre.Env.SlotNumber, } header := &types.Header{ Time: pre.Env.Timestamp, @@ -252,19 +270,22 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, continue } } - statedb.SetTxContext(tx.Hash(), len(receipts)) + statedb.SetTxContext(tx.Hash(), len(receipts), uint32(len(receipts)+1)) var ( snapshot = statedb.Snapshot() - prevGas = gaspool.Gas() + gp = gaspool.Snapshot() ) - receipt, err := core.ApplyTransactionWithEVM(msg, gaspool, statedb, vmContext.BlockNumber, blockHash, pre.Env.Timestamp, tx, &gasUsed, evm) + receipt, err := core.ApplyTransactionWithEVM(msg, gaspool, statedb, vmContext.BlockNumber, blockHash, pre.Env.Timestamp, tx, evm) if err != nil { statedb.RevertToSnapshot(snapshot) log.Info("rejected tx", "index", i, "hash", tx.Hash(), "from", msg.From, "error", err) rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()}) - gaspool.SetGas(prevGas) + gaspool.Set(gp) continue } + if receipt.Logs == nil { + receipt.Logs = []*types.Log{} + } includedTxs = append(includedTxs, tx) if hashError != nil { return nil, nil, nil, NewError(ErrorMissingBlockhash, hashError) @@ -311,27 +332,14 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, } // Gather the execution-layer triggered requests. - var requests [][]byte - if chainConfig.IsPrague(vmContext.BlockNumber, vmContext.Time) { - requests = [][]byte{} - // EIP-6110 - var allLogs []*types.Log - for _, receipt := range receipts { - allLogs = append(allLogs, receipt.Logs...) - } - if err := core.ParseDepositLogs(&requests, allLogs, chainConfig); err != nil { - return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("could not parse requests logs: %v", err)) - } - // EIP-7002 - if err := core.ProcessWithdrawalQueue(&requests, evm); err != nil { - return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("could not process withdrawal requests: %v", err)) - } - // EIP-7251 - if err := core.ProcessConsolidationQueue(&requests, evm); err != nil { - return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("could not process consolidation requests: %v", err)) - } + var allLogs []*types.Log + for _, receipt := range receipts { + allLogs = append(allLogs, receipt.Logs...) + } + requests, err := core.PostExecution(context.Background(), chainConfig, vmContext.BlockNumber, vmContext.Time, allLogs, evm, uint32(len(receipts)+1)) + if err != nil { + return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("failed to process post-execution: %v", err)) } - // Commit block root, err := statedb.Commit(vmContext.BlockNumber.Uint64(), chainConfig.IsEIP158(vmContext.BlockNumber), chainConfig.IsCancun(vmContext.BlockNumber, vmContext.Time)) if err != nil { @@ -346,7 +354,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, Receipts: receipts, Rejected: rejectedTxs, Difficulty: (*math.HexOrDecimal256)(vmContext.Difficulty), - GasUsed: (math.HexOrDecimal64)(gasUsed), + GasUsed: (math.HexOrDecimal64)(gaspool.Used()), BaseFee: (*math.HexOrDecimal256)(vmContext.BaseFee), } if pre.Env.Withdrawals != nil { @@ -361,10 +369,6 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, // Set requestsHash on block. h := types.CalcRequestsHash(requests) execRs.RequestsHash = &h - for i := range requests { - // remove prefix - requests[i] = requests[i][1:] - } execRs.Requests = requests } @@ -378,7 +382,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, } func MakePreState(db ethdb.Database, accounts types.GenesisAlloc, isBintrie bool) *state.StateDB { - tdb := triedb.NewDatabase(db, &triedb.Config{Preimages: true, IsVerkle: isBintrie}) + tdb := triedb.NewDatabase(db, &triedb.Config{Preimages: true, IsUBT: isBintrie}) sdb := state.NewDatabase(tdb, nil) root := types.EmptyRootHash @@ -414,8 +418,78 @@ func MakePreState(db ethdb.Database, accounts types.GenesisAlloc, isBintrie bool return statedb } +// MakePreStateStreaming is like MakePreState, but decodes the alloc from disk +// one account at a time so the full map is never held in memory. +func MakePreStateStreaming(db ethdb.Database, allocPath string, isBintrie bool) (*state.StateDB, error) { + tdb := triedb.NewDatabase(db, &triedb.Config{Preimages: true, IsUBT: isBintrie}) + sdb := state.NewDatabase(tdb, nil) + + root := types.EmptyRootHash + if isBintrie { + root = types.EmptyBinaryHash + } + statedb, err := state.New(root, sdb) + if err != nil { + return nil, NewError(ErrorEVM, fmt.Errorf("failed to create initial statedb: %v", err)) + } + + f, err := os.Open(allocPath) + if err != nil { + return nil, NewError(ErrorIO, fmt.Errorf("failed reading alloc file: %v", err)) + } + defer f.Close() + + dec := json.NewDecoder(f) + tok, err := dec.Token() + if err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed reading alloc opening token: %v", err)) + } + if d, ok := tok.(json.Delim); !ok || d != '{' { + return nil, NewError(ErrorJson, fmt.Errorf("expected alloc object, got %v", tok)) + } + for dec.More() { + keyTok, err := dec.Token() + if err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed reading alloc key: %v", err)) + } + keyStr, ok := keyTok.(string) + if !ok { + return nil, NewError(ErrorJson, fmt.Errorf("alloc key not a string: %v", keyTok)) + } + addr := common.HexToAddress(keyStr) + var acct types.Account + if err := dec.Decode(&acct); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed decoding account %s: %v", keyStr, err)) + } + statedb.SetCode(addr, acct.Code, tracing.CodeChangeUnspecified) + statedb.SetNonce(addr, acct.Nonce, tracing.NonceChangeGenesis) + if acct.Balance != nil { + statedb.SetBalance(addr, uint256.MustFromBig(acct.Balance), tracing.BalanceIncreaseGenesisBalance) + } + for k, v := range acct.Storage { + statedb.SetState(addr, k, v) + } + } + if _, err := dec.Token(); err != nil { + return nil, NewError(ErrorJson, fmt.Errorf("failed reading alloc closing token: %v", err)) + } + + root, err = statedb.Commit(0, false, false) + if err != nil { + return nil, NewError(ErrorEVM, fmt.Errorf("failed to commit initial state: %v", err)) + } + if isBintrie { + return statedb, nil + } + statedb, err = state.New(root, sdb) + if err != nil { + return nil, NewError(ErrorEVM, fmt.Errorf("failed to reopen state after commit: %v", err)) + } + return statedb, nil +} + func rlpHash(x any) (h common.Hash) { - hw := sha3.NewLegacyKeccak256() + hw := keccak.NewLegacyKeccak256() rlp.Encode(hw, x) hw.Sum(h[:0]) return h diff --git a/cmd/evm/internal/t8ntool/file_tracer.go b/cmd/evm/internal/t8ntool/file_tracer.go index 38fc35bd322e..d032252cba90 100644 --- a/cmd/evm/internal/t8ntool/file_tracer.go +++ b/cmd/evm/internal/t8ntool/file_tracer.go @@ -56,27 +56,35 @@ func (l *fileWritingTracer) Write(p []byte) (n int, err error) { return n, nil } -// newFileWriter creates a set of hooks which wraps inner hooks (typically a logger), +// newFileWriter creates a tracer which wraps inner hooks (typically a logger), // and writes the output to a file, one file per transaction. -func newFileWriter(baseDir string, innerFn func(out io.Writer) *tracing.Hooks) *tracing.Hooks { +func newFileWriter(baseDir string, innerFn func(out io.Writer) *tracing.Hooks) *tracers.Tracer { t := &fileWritingTracer{ baseDir: baseDir, suffix: "jsonl", } t.inner = innerFn(t) // instantiate the inner tracer - return t.hooks() + return &tracers.Tracer{ + Hooks: t.hooks(), + GetResult: func() (json.RawMessage, error) { return json.RawMessage("{}"), nil }, + Stop: func(err error) {}, + } } -// newResultWriter creates a set of hooks wraps and invokes an underlying tracer, +// newResultWriter creates a tracer that wraps and invokes an underlying tracer, // and writes the result (getResult-output) to file, one per transaction. -func newResultWriter(baseDir string, tracer *tracers.Tracer) *tracing.Hooks { +func newResultWriter(baseDir string, tracer *tracers.Tracer) *tracers.Tracer { t := &fileWritingTracer{ baseDir: baseDir, getResult: tracer.GetResult, inner: tracer.Hooks, suffix: "json", } - return t.hooks() + return &tracers.Tracer{ + Hooks: t.hooks(), + GetResult: func() (json.RawMessage, error) { return json.RawMessage("{}"), nil }, + Stop: func(err error) {}, + } } // OnTxStart creates a new output-file specific for this transaction, and invokes diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go index a6ec33eacf04..078d3049272f 100644 --- a/cmd/evm/internal/t8ntool/flags.go +++ b/cmd/evm/internal/t8ntool/flags.go @@ -162,6 +162,11 @@ var ( strings.Join(vm.ActivateableEips(), ", ")), Value: "GrayGlacier", } + OpcodeCountFlag = &cli.StringFlag{ + Name: "opcode.count", + Usage: "If set, opcode execution counts will be written to this file (relative to output.basedir).", + Value: "", + } VerbosityFlag = &cli.IntFlag{ Name: "verbosity", Usage: "sets the verbosity level", diff --git a/cmd/evm/internal/t8ntool/gen_header.go b/cmd/evm/internal/t8ntool/gen_header.go index a8c8668978ed..f430feb6d297 100644 --- a/cmd/evm/internal/t8ntool/gen_header.go +++ b/cmd/evm/internal/t8ntool/gen_header.go @@ -38,6 +38,7 @@ func (h header) MarshalJSON() ([]byte, error) { BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed" rlp:"optional"` ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas" rlp:"optional"` ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` + SlotNumber *math.HexOrDecimal64 `json:"slotNumber" rlp:"optional"` } var enc header enc.ParentHash = h.ParentHash @@ -60,6 +61,7 @@ func (h header) MarshalJSON() ([]byte, error) { enc.BlobGasUsed = (*math.HexOrDecimal64)(h.BlobGasUsed) enc.ExcessBlobGas = (*math.HexOrDecimal64)(h.ExcessBlobGas) enc.ParentBeaconBlockRoot = h.ParentBeaconBlockRoot + enc.SlotNumber = (*math.HexOrDecimal64)(h.SlotNumber) return json.Marshal(&enc) } @@ -86,6 +88,7 @@ func (h *header) UnmarshalJSON(input []byte) error { BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed" rlp:"optional"` ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas" rlp:"optional"` ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` + SlotNumber *math.HexOrDecimal64 `json:"slotNumber" rlp:"optional"` } var dec header if err := json.Unmarshal(input, &dec); err != nil { @@ -155,5 +158,8 @@ func (h *header) UnmarshalJSON(input []byte) error { if dec.ParentBeaconBlockRoot != nil { h.ParentBeaconBlockRoot = dec.ParentBeaconBlockRoot } + if dec.SlotNumber != nil { + h.SlotNumber = (*uint64)(dec.SlotNumber) + } return nil } diff --git a/cmd/evm/internal/t8ntool/gen_stenv.go b/cmd/evm/internal/t8ntool/gen_stenv.go index d47db4a8765e..1b8e14abc6d5 100644 --- a/cmd/evm/internal/t8ntool/gen_stenv.go +++ b/cmd/evm/internal/t8ntool/gen_stenv.go @@ -37,6 +37,7 @@ func (s stEnv) MarshalJSON() ([]byte, error) { ParentExcessBlobGas *math.HexOrDecimal64 `json:"parentExcessBlobGas,omitempty"` ParentBlobGasUsed *math.HexOrDecimal64 `json:"parentBlobGasUsed,omitempty"` ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot"` + SlotNumber *math.HexOrDecimal64 `json:"slotNumber"` } var enc stEnv enc.Coinbase = common.UnprefixedAddress(s.Coinbase) @@ -59,6 +60,7 @@ func (s stEnv) MarshalJSON() ([]byte, error) { enc.ParentExcessBlobGas = (*math.HexOrDecimal64)(s.ParentExcessBlobGas) enc.ParentBlobGasUsed = (*math.HexOrDecimal64)(s.ParentBlobGasUsed) enc.ParentBeaconBlockRoot = s.ParentBeaconBlockRoot + enc.SlotNumber = (*math.HexOrDecimal64)(s.SlotNumber) return json.Marshal(&enc) } @@ -85,6 +87,7 @@ func (s *stEnv) UnmarshalJSON(input []byte) error { ParentExcessBlobGas *math.HexOrDecimal64 `json:"parentExcessBlobGas,omitempty"` ParentBlobGasUsed *math.HexOrDecimal64 `json:"parentBlobGasUsed,omitempty"` ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot"` + SlotNumber *math.HexOrDecimal64 `json:"slotNumber"` } var dec stEnv if err := json.Unmarshal(input, &dec); err != nil { @@ -154,5 +157,8 @@ func (s *stEnv) UnmarshalJSON(input []byte) error { if dec.ParentBeaconBlockRoot != nil { s.ParentBeaconBlockRoot = dec.ParentBeaconBlockRoot } + if dec.SlotNumber != nil { + s.SlotNumber = (*uint64)(dec.SlotNumber) + } return nil } diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go index 0f39df0753a9..ca19ae3386da 100644 --- a/cmd/evm/internal/t8ntool/transaction.go +++ b/cmd/evm/internal/t8ntool/transaction.go @@ -27,7 +27,9 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/tests" @@ -115,9 +117,6 @@ func Transaction(ctx *cli.Context) error { } var results []result for it.Next() { - if err := it.Err(); err != nil { - return NewError(ErrorIO, err) - } var tx types.Transaction err := rlp.DecodeBytes(it.Value(), &tx) if err != nil { @@ -134,21 +133,21 @@ func Transaction(ctx *cli.Context) error { } // Check intrinsic gas rules := chainConfig.Rules(common.Big0, true, 0) - gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.SetCodeAuthorizations(), tx.To() == nil, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai) + cost, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.SetCodeAuthorizations(), tx.To() == nil, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai, rules.IsAmsterdam) if err != nil { r.Error = err results = append(results, r) continue } - r.IntrinsicGas = gas - if tx.Gas() < gas { - r.Error = fmt.Errorf("%w: have %d, want %d", core.ErrIntrinsicGas, tx.Gas(), gas) + r.IntrinsicGas = cost.RegularGas + if tx.Gas() < cost.RegularGas { + r.Error = fmt.Errorf("%w: have %d, want %d", core.ErrIntrinsicGas, tx.Gas(), cost.RegularGas) results = append(results, r) continue } // For Prague txs, validate the floor data gas. if rules.IsPrague { - floorDataGas, err := core.FloorDataGas(tx.Data()) + floorDataGas, err := core.FloorDataGas(rules, tx.Data(), tx.AccessList()) if err != nil { r.Error = err results = append(results, r) @@ -180,14 +179,23 @@ func Transaction(ctx *cli.Context) error { r.Error = errors.New("gas * maxFeePerGas exceeds 256 bits") } // Check whether the init code size has been exceeded. - if chainConfig.IsShanghai(new(big.Int), 0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize { - r.Error = errors.New("max initcode size exceeded") + if tx.To() == nil { + if err := vm.CheckMaxInitCodeSize(&rules, uint64(len(tx.Data()))); err != nil { + r.Error = err + } } - if chainConfig.IsOsaka(new(big.Int), 0) && tx.Gas() > params.MaxTxGas { + + isOsaka := chainConfig.IsOsaka(new(big.Int), 0) + isAmsterdam := chainConfig.IsAmsterdam(new(big.Int), 0) + if isOsaka && !isAmsterdam && tx.Gas() > params.MaxTxGas { r.Error = errors.New("gas limit exceeds maximum") } results = append(results, r) } + if err := it.Err(); err != nil { + return NewError(ErrorIO, err) + } + out, err := json.MarshalIndent(results, "", " ") fmt.Println(string(out)) return err diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index af60333cbdbc..89b703d3b805 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -17,6 +17,7 @@ package t8ntool import ( + "bufio" "encoding/json" "errors" "fmt" @@ -37,6 +38,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/tracers" "github.com/ethereum/go-ethereum/eth/tracers/logger" + "github.com/ethereum/go-ethereum/eth/tracers/native" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/tests" @@ -114,11 +116,10 @@ func Transition(ctx *cli.Context) error { } } if allocStr != stdinSelector { - if err := readFile(allocStr, "alloc", &inputData.Alloc); err != nil { - return err - } + prestate.AllocPath = allocStr + } else { + prestate.Pre = inputData.Alloc } - prestate.Pre = inputData.Alloc if btStr != stdinSelector && btStr != "" { if err := readFile(btStr, "BT", &inputData.BT); err != nil { @@ -167,14 +168,15 @@ func Transition(ctx *cli.Context) error { } // Configure tracer + var tracer *tracers.Tracer if ctx.IsSet(TraceTracerFlag.Name) { // Custom tracing config := json.RawMessage(ctx.String(TraceTracerConfigFlag.Name)) - tracer, err := tracers.DefaultDirectory.New(ctx.String(TraceTracerFlag.Name), + innerTracer, err := tracers.DefaultDirectory.New(ctx.String(TraceTracerFlag.Name), nil, config, chainConfig) if err != nil { return NewError(ErrorConfig, fmt.Errorf("failed instantiating tracer: %v", err)) } - vmConfig.Tracer = newResultWriter(baseDir, tracer) + tracer = newResultWriter(baseDir, innerTracer) } else if ctx.Bool(TraceFlag.Name) { // JSON opcode tracing logConfig := &logger.Config{ DisableStack: ctx.Bool(TraceDisableStackFlag.Name), @@ -182,36 +184,96 @@ func Transition(ctx *cli.Context) error { EnableReturnData: ctx.Bool(TraceEnableReturnDataFlag.Name), } if ctx.Bool(TraceEnableCallFramesFlag.Name) { - vmConfig.Tracer = newFileWriter(baseDir, func(out io.Writer) *tracing.Hooks { + tracer = newFileWriter(baseDir, func(out io.Writer) *tracing.Hooks { return logger.NewJSONLoggerWithCallFrames(logConfig, out) }) } else { - vmConfig.Tracer = newFileWriter(baseDir, func(out io.Writer) *tracing.Hooks { + tracer = newFileWriter(baseDir, func(out io.Writer) *tracing.Hooks { return logger.NewJSONLogger(logConfig, out) }) } } + // Configure opcode counter + var opcodeTracer *tracers.Tracer + if ctx.IsSet(OpcodeCountFlag.Name) && ctx.String(OpcodeCountFlag.Name) != "" { + opcodeTracer = native.NewOpcodeCounter() + if tracer != nil { + // If we have an existing tracer, multiplex with the opcode tracer + mux, _ := native.NewMuxTracer([]string{"trace", "opcode"}, []*tracers.Tracer{tracer, opcodeTracer}) + vmConfig.Tracer = mux.Hooks + } else { + vmConfig.Tracer = opcodeTracer.Hooks + } + } else if tracer != nil { + vmConfig.Tracer = tracer.Hooks + } // Run the test and aggregate the result s, result, body, err := prestate.Apply(vmConfig, chainConfig, txIt, ctx.Int64(RewardFlag.Name)) if err != nil { return err } - // Dump the execution result + // Write opcode counts if enabled + if opcodeTracer != nil { + fname := ctx.String(OpcodeCountFlag.Name) + result, err := opcodeTracer.GetResult() + if err != nil { + return NewError(ErrorJson, fmt.Errorf("failed getting opcode counts: %v", err)) + } + if err := saveFile(baseDir, fname, result); err != nil { + return err + } + } + // Dump the execution result. var ( - collector = make(Alloc) + collector Alloc btleaves map[common.Hash]hexutil.Bytes ) - isBinary := chainConfig.IsVerkle(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) - if !isBinary { + isBinary := chainConfig.IsUBT(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) + allocOutput := ctx.String(OutputAllocFlag.Name) + switch { + case !isBinary && allocOutput != "" && allocOutput != "stdout" && allocOutput != "stderr": + // Stream directly to the output file to avoid materializing the + // whole post-state in memory. dispatchOutput is told to skip alloc + // by clearing the output name. + if err := writeStreamedAlloc(filepath.Join(baseDir, allocOutput), s); err != nil { + return err + } + allocOutput = "" + case !isBinary: + collector = make(Alloc) s.DumpToCollector(collector, nil) - } else { + default: btleaves = make(map[common.Hash]hexutil.Bytes) if err := s.DumpBinTrieLeaves(btleaves); err != nil { return err } } + return dispatchOutput(ctx, baseDir, result, collector, allocOutput, body, btleaves) +} - return dispatchOutput(ctx, baseDir, result, collector, body, btleaves) +// writeStreamedAlloc writes the post-state alloc to path one account at a +// time, producing the same JSON shape as saveFile on an Alloc map. +func writeStreamedAlloc(path string, s *state.StateDB) error { + f, err := os.Create(path) + if err != nil { + return NewError(ErrorIO, fmt.Errorf("failed creating alloc output file: %v", err)) + } + bw := bufio.NewWriter(f) + sa := newStreamingAlloc(bw) + s.DumpToCollector(sa, nil) + if err := sa.Close(); err != nil { + f.Close() + return NewError(ErrorIO, fmt.Errorf("failed writing alloc output: %v", err)) + } + if err := bw.Flush(); err != nil { + f.Close() + return NewError(ErrorIO, fmt.Errorf("failed flushing alloc output: %v", err)) + } + if err := f.Close(); err != nil { + return NewError(ErrorIO, fmt.Errorf("failed closing alloc output file: %v", err)) + } + log.Info("Wrote file", "file", path) + return nil } func applyLondonChecks(env *stEnv, chainConfig *params.ChainConfig) error { @@ -300,6 +362,10 @@ func (g Alloc) OnAccount(addr *common.Address, dumpAccount state.DumpAccount) { if addr == nil { return } + g[*addr] = dumpAccountToTypesAccount(dumpAccount) +} + +func dumpAccountToTypesAccount(dumpAccount state.DumpAccount) types.Account { balance, _ := new(big.Int).SetString(dumpAccount.Balance, 0) var storage map[common.Hash]common.Hash if dumpAccount.Storage != nil { @@ -308,13 +374,64 @@ func (g Alloc) OnAccount(addr *common.Address, dumpAccount state.DumpAccount) { storage[k] = common.HexToHash(v) } } - genesisAccount := types.Account{ + return types.Account{ Code: dumpAccount.Code, Storage: storage, Balance: balance, Nonce: dumpAccount.Nonce, } - g[*addr] = genesisAccount +} + +// streamingAlloc is a DumpCollector that writes each account to w as it is +// visited, emitting a single JSON object keyed by address. Close must be +// called to emit the closing brace. +type streamingAlloc struct { + w io.Writer + wroteOne bool + err error +} + +func newStreamingAlloc(w io.Writer) *streamingAlloc { + return &streamingAlloc{w: w} +} + +func (s *streamingAlloc) write(b []byte) { + if s.err != nil { + return + } + _, s.err = s.w.Write(b) +} + +func (s *streamingAlloc) OnRoot(common.Hash) { + s.write([]byte{'{'}) +} + +func (s *streamingAlloc) OnAccount(addr *common.Address, dumpAccount state.DumpAccount) { + if s.err != nil || addr == nil { + return + } + keyJSON, err := json.Marshal(*addr) + if err != nil { + s.err = err + return + } + valueJSON, err := json.Marshal(dumpAccountToTypesAccount(dumpAccount)) + if err != nil { + s.err = err + return + } + if s.wroteOne { + s.write([]byte{','}) + } + s.write(keyJSON) + s.write([]byte{':'}) + s.write(valueJSON) + s.wroteOne = true +} + +func (s *streamingAlloc) Close() error { + s.write([]byte{'}'}) + return s.err } // saveFile marshals the object to the given file @@ -332,8 +449,9 @@ func saveFile(baseDir, filename string, data interface{}) error { } // dispatchOutput writes the output data to either stderr or stdout, or to the specified -// files -func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, alloc Alloc, body hexutil.Bytes, bt map[common.Hash]hexutil.Bytes) error { +// files. An empty allocOutput skips the alloc dispatch, which is used when the +// alloc has already been streamed to disk by the caller. +func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, alloc Alloc, allocOutput string, body hexutil.Bytes, bt map[common.Hash]hexutil.Bytes) error { stdOutObject := make(map[string]interface{}) stdErrObject := make(map[string]interface{}) dispatch := func(baseDir, fName, name string, obj interface{}) error { @@ -351,7 +469,7 @@ func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, a } return nil } - if err := dispatch(baseDir, ctx.String(OutputAllocFlag.Name), "alloc", alloc); err != nil { + if err := dispatch(baseDir, allocOutput, "alloc", alloc); err != nil { return err } if err := dispatch(baseDir, ctx.String(OutputResultFlag.Name), "result", result); err != nil { @@ -425,10 +543,10 @@ func BinKeys(ctx *cli.Context) error { return err } } - db := triedb.NewDatabase(rawdb.NewMemoryDatabase(), triedb.VerkleDefaults) + db := triedb.NewDatabase(rawdb.NewMemoryDatabase(), triedb.UBTDefaults) defer db.Close() - bt, err := genBinTrieFromAlloc(alloc, db) + bt, err := genBinTrieFromAlloc(alloc, db, triedb.UBTDefaults.BinTrieGroupDepth) if err != nil { return fmt.Errorf("error generating bt: %w", err) } @@ -469,10 +587,10 @@ func BinTrieRoot(ctx *cli.Context) error { return err } } - db := triedb.NewDatabase(rawdb.NewMemoryDatabase(), triedb.VerkleDefaults) + db := triedb.NewDatabase(rawdb.NewMemoryDatabase(), triedb.UBTDefaults) defer db.Close() - bt, err := genBinTrieFromAlloc(alloc, db) + bt, err := genBinTrieFromAlloc(alloc, db, triedb.UBTDefaults.BinTrieGroupDepth) if err != nil { return fmt.Errorf("error generating bt: %w", err) } @@ -482,8 +600,8 @@ func BinTrieRoot(ctx *cli.Context) error { } // TODO(@CPerezz): Should this go to `bintrie` module? -func genBinTrieFromAlloc(alloc core.GenesisAlloc, db database.NodeDatabase) (*bintrie.BinaryTrie, error) { - bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, db) +func genBinTrieFromAlloc(alloc core.GenesisAlloc, db database.NodeDatabase, groupDepth int) (*bintrie.BinaryTrie, error) { + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, db, groupDepth) if err != nil { return nil, err } diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 57741b5f9c29..2b7774173850 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -115,7 +115,7 @@ var ( Name: "trace.noreturndata", Aliases: []string{"noreturndata"}, Value: true, - Usage: "enable return data output", + Usage: "disable return data output", Category: traceCategory, } @@ -161,6 +161,7 @@ var ( t8ntool.ForknameFlag, t8ntool.ChainIDFlag, t8ntool.RewardFlag, + t8ntool.OpcodeCountFlag, }, } diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index ebb3e044615d..6d80056d048c 100644 --- a/cmd/evm/runner.go +++ b/cmd/evm/runner.go @@ -166,8 +166,11 @@ func timedExec(bench bool, execFunc func() ([]byte, uint64, error)) ([]byte, exe if haveGasUsed != gasUsed { panic(fmt.Sprintf("gas differs, have %v want %v", haveGasUsed, gasUsed)) } - if haveErr != err { - panic(fmt.Sprintf("err differs, have %v want %v", haveErr, err)) + if (haveErr == nil) != (err == nil) { + panic(fmt.Sprintf("err differs in nil-ness, have %v want %v", haveErr, err)) + } + if haveErr != nil && err != nil && haveErr.Error() != err.Error() { + panic(fmt.Sprintf("err differs, have %q want %q", haveErr.Error(), err.Error())) } } }) @@ -318,7 +321,7 @@ func runCmd(ctx *cli.Context) error { // don't mutate the state! runtimeConfig.State = prestate.Copy() output, _, gasLeft, err := runtime.Create(input, &runtimeConfig) - return output, gasLeft, err + return output, initialGas - gasLeft, err } } else { if len(code) > 0 { diff --git a/cmd/evm/testdata/1/exp.json b/cmd/evm/testdata/1/exp.json index 6537c9517d63..f596cb5e672d 100644 --- a/cmd/evm/testdata/1/exp.json +++ b/cmd/evm/testdata/1/exp.json @@ -24,7 +24,7 @@ "status": "0x1", "cumulativeGasUsed": "0x5208", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x0557bacce3375c98d806609b8d5043072f0b6a8bae45ae5a67a00d3a1a18d673", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x5208", diff --git a/cmd/evm/testdata/13/exp2.json b/cmd/evm/testdata/13/exp2.json index f716289cf7db..260721e22ff5 100644 --- a/cmd/evm/testdata/13/exp2.json +++ b/cmd/evm/testdata/13/exp2.json @@ -12,7 +12,7 @@ "status": "0x0", "cumulativeGasUsed": "0x84d0", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0xa98a24882ea90916c6a86da650fbc6b14238e46f0af04a131ce92be897507476", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x84d0", @@ -27,7 +27,7 @@ "status": "0x0", "cumulativeGasUsed": "0x109a0", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x36bad80acce7040c45fd32764b5c2b2d2e6f778669fb41791f73f546d56e739a", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x84d0", diff --git a/cmd/evm/testdata/23/exp.json b/cmd/evm/testdata/23/exp.json index 2d9cd492db2e..803411de461c 100644 --- a/cmd/evm/testdata/23/exp.json +++ b/cmd/evm/testdata/23/exp.json @@ -11,7 +11,7 @@ "status": "0x1", "cumulativeGasUsed": "0x520b", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x72fadbef39cd251a437eea619cfeda752271a5faaaa2147df012e112159ffb81", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x520b", diff --git a/cmd/evm/testdata/24/exp.json b/cmd/evm/testdata/24/exp.json index 0dd552e1128d..bbde70c631d2 100644 --- a/cmd/evm/testdata/24/exp.json +++ b/cmd/evm/testdata/24/exp.json @@ -27,7 +27,7 @@ "status": "0x1", "cumulativeGasUsed": "0xa861", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x92ea4a28224d033afb20e0cc2b290d4c7c2d61f6a4800a680e4e19ac962ee941", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0xa861", @@ -41,7 +41,7 @@ "status": "0x1", "cumulativeGasUsed": "0x10306", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x16b1d912f1d664f3f60f4e1b5f296f3c82a64a1a253117b4851d18bc03c4f1da", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x5aa5", diff --git a/cmd/evm/testdata/25/exp.json b/cmd/evm/testdata/25/exp.json index 3dac46aa6033..25cac55dc04d 100644 --- a/cmd/evm/testdata/25/exp.json +++ b/cmd/evm/testdata/25/exp.json @@ -23,7 +23,7 @@ "status": "0x1", "cumulativeGasUsed": "0x5208", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x92ea4a28224d033afb20e0cc2b290d4c7c2d61f6a4800a680e4e19ac962ee941", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x5208", diff --git a/cmd/evm/testdata/28/exp.json b/cmd/evm/testdata/28/exp.json index 15b29bc0ac83..f67ff7608715 100644 --- a/cmd/evm/testdata/28/exp.json +++ b/cmd/evm/testdata/28/exp.json @@ -28,7 +28,7 @@ "status": "0x1", "cumulativeGasUsed": "0xa865", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x7508d7139d002a4b3a26a4f12dec0d87cb46075c78bf77a38b569a133b509262", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0xa865", diff --git a/cmd/evm/testdata/29/exp.json b/cmd/evm/testdata/29/exp.json index 69c8661aa8da..cb4b5eaa28cc 100644 --- a/cmd/evm/testdata/29/exp.json +++ b/cmd/evm/testdata/29/exp.json @@ -26,7 +26,7 @@ "status": "0x1", "cumulativeGasUsed": "0x5208", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x84f70aba406a55628a0620f26d260f90aeb6ccc55fed6ec2ac13dd4f727032ed", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x5208", diff --git a/cmd/evm/testdata/3/exp.json b/cmd/evm/testdata/3/exp.json index 807cdccfb4ee..36bf2604afac 100644 --- a/cmd/evm/testdata/3/exp.json +++ b/cmd/evm/testdata/3/exp.json @@ -24,7 +24,7 @@ "status": "0x1", "cumulativeGasUsed": "0x521f", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x72fadbef39cd251a437eea619cfeda752271a5faaaa2147df012e112159ffb81", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x521f", diff --git a/cmd/evm/testdata/30/exp.json b/cmd/evm/testdata/30/exp.json index 9861f5a0717e..7df3b788206e 100644 --- a/cmd/evm/testdata/30/exp.json +++ b/cmd/evm/testdata/30/exp.json @@ -25,7 +25,7 @@ "status": "0x1", "cumulativeGasUsed": "0x5208", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0xa98a24882ea90916c6a86da650fbc6b14238e46f0af04a131ce92be897507476", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x5208", @@ -40,7 +40,7 @@ "status": "0x1", "cumulativeGasUsed": "0xa410", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "logs": null, + "logs": [], "transactionHash": "0x36bad80acce7040c45fd32764b5c2b2d2e6f778669fb41791f73f546d56e739a", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x5208", diff --git a/cmd/evm/testdata/33/exp.json b/cmd/evm/testdata/33/exp.json index b40ca9fee2fe..73aaf80a28b4 100644 --- a/cmd/evm/testdata/33/exp.json +++ b/cmd/evm/testdata/33/exp.json @@ -44,7 +44,7 @@ "root": "0x", "status": "0x1", "cumulativeGasUsed": "0x15fa9", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","logs": null,"transactionHash": "0x0417aab7c1d8a3989190c3167c132876ce9b8afd99262c5a0f9d06802de3d7ef", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","logs": [],"transactionHash": "0x0417aab7c1d8a3989190c3167c132876ce9b8afd99262c5a0f9d06802de3d7ef", "contractAddress": "0x0000000000000000000000000000000000000000", "gasUsed": "0x15fa9", "effectiveGasPrice": null, diff --git a/cmd/fetchpayload/main.go b/cmd/fetchpayload/main.go new file mode 100644 index 000000000000..eafc05fbe871 --- /dev/null +++ b/cmd/fetchpayload/main.go @@ -0,0 +1,177 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +// fetchpayload queries an Ethereum node over RPC, fetches a block and its +// execution witness, and writes the combined Payload (ChainID + Block + +// Witness) to disk in the format consumed by cmd/keeper. +package main + +import ( + "context" + "encoding/json" + "flag" + "fmt" + "math/big" + "os" + "path/filepath" + "strings" + "time" + + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/stateless" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/rpc" +) + +// Payload is duplicated from cmd/keeper/main.go (package main, not importable). +type Payload struct { + ChainID uint64 + Block *types.Block + Witness *stateless.Witness +} + +func main() { + var ( + rpcURL = flag.String("rpc", "http://localhost:8545", "RPC endpoint URL") + blockArg = flag.String("block", "latest", `Block number: decimal, 0x-hex, or "latest"`) + format = flag.String("format", "rlp", "Comma-separated output formats: rlp, hex, json") + outDir = flag.String("out", "", "Output directory (default: current directory)") + ) + flag.Parse() + + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + + // Parse block number (nil means "latest" in ethclient). + blockNum, err := parseBlockNumber(*blockArg) + if err != nil { + fatal("invalid block number %q: %v", *blockArg, err) + } + + // Connect to the node. + client, err := ethclient.DialContext(ctx, *rpcURL) + if err != nil { + fatal("failed to connect to %s: %v", *rpcURL, err) + } + defer client.Close() + + chainID, err := client.ChainID(ctx) + if err != nil { + fatal("failed to get chain ID: %v", err) + } + + // Fetch the block first so we have a concrete number for the witness call, + // avoiding a race where "latest" advances between the two RPCs. + block, err := client.BlockByNumber(ctx, blockNum) + if err != nil { + fatal("failed to fetch block: %v", err) + } + fmt.Printf("Fetched block %d (%#x)\n", block.NumberU64(), block.Hash()) + + // Fetch the execution witness via the debug namespace. + var extWitness stateless.ExtWitness + err = client.Client().CallContext(ctx, &extWitness, "debug_executionWitness", rpc.BlockNumber(block.NumberU64())) + if err != nil { + fatal("failed to fetch execution witness: %v", err) + } + + witness := new(stateless.Witness) + err = witness.FromExtWitness(&extWitness) + if err != nil { + fatal("failed to convert witness: %v", err) + } + + payload := Payload{ + ChainID: chainID.Uint64(), + Block: block, + Witness: witness, + } + + // Encode payload as RLP (shared by "rlp" and "hex" formats). + rlpBytes, err := rlp.EncodeToBytes(payload) + if err != nil { + fatal("failed to RLP-encode payload: %v", err) + } + + // Write one output file per requested format. + blockHex := fmt.Sprintf("%x", block.NumberU64()) + for f := range strings.SplitSeq(*format, ",") { + f = strings.TrimSpace(f) + outPath := filepath.Join(*outDir, fmt.Sprintf("%s_payload.%s", blockHex, f)) + + var data []byte + switch f { + case "rlp": + data = rlpBytes + case "hex": + data = []byte(hexutil.Encode(rlpBytes)) + case "json": + data, err = marshalJSONPayload(chainID, block, &extWitness) + if err != nil { + fatal("failed to JSON-encode payload: %v", err) + } + default: + fatal("unknown format %q (valid: rlp, hex, json)", f) + } + + if err := os.WriteFile(outPath, data, 0644); err != nil { + fatal("failed to write %s: %v", outPath, err) + } + fmt.Printf("Wrote %s (%d bytes)\n", outPath, len(data)) + } +} + +// parseBlockNumber converts a CLI string to *big.Int. +// Returns nil for "latest" (ethclient convention for the head block). +func parseBlockNumber(s string) (*big.Int, error) { + if strings.EqualFold(s, "latest") { + return nil, nil + } + n := new(big.Int) + if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") { + if _, ok := n.SetString(s[2:], 16); !ok { + return nil, fmt.Errorf("invalid hex number") + } + return n, nil + } + if _, ok := n.SetString(s, 10); !ok { + return nil, fmt.Errorf("invalid decimal number") + } + return n, nil +} + +// jsonPayload is a JSON-friendly representation of Payload. It uses ExtWitness +// instead of the internal Witness (which has no JSON marshaling). +type jsonPayload struct { + ChainID uint64 `json:"chainId"` + Block *types.Block `json:"block"` + Witness *stateless.ExtWitness `json:"witness"` +} + +func marshalJSONPayload(chainID *big.Int, block *types.Block, ext *stateless.ExtWitness) ([]byte, error) { + return json.MarshalIndent(jsonPayload{ + ChainID: chainID.Uint64(), + Block: block, + Witness: ext, + }, "", " ") +} + +func fatal(format string, args ...any) { + fmt.Fprintf(os.Stderr, format+"\n", args...) + os.Exit(1) +} diff --git a/cmd/geth/bintrie_convert.go b/cmd/geth/bintrie_convert.go new file mode 100644 index 000000000000..46cb3aa7e428 --- /dev/null +++ b/cmd/geth/bintrie_convert.go @@ -0,0 +1,408 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "errors" + "fmt" + "runtime" + "runtime/debug" + "slices" + "time" + + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" + "github.com/ethereum/go-ethereum/trie/bintrie" + "github.com/ethereum/go-ethereum/trie/trienode" + "github.com/ethereum/go-ethereum/triedb" + "github.com/ethereum/go-ethereum/triedb/pathdb" + "github.com/urfave/cli/v2" +) + +var ( + deleteSourceFlag = &cli.BoolFlag{ + Name: "delete-source", + Usage: "Delete MPT trie nodes after conversion", + } + memoryLimitFlag = &cli.Uint64Flag{ + Name: "memory-limit", + Usage: "Max heap allocation in MB before forcing a commit cycle", + Value: 16384, + } + + bintrieCommand = &cli.Command{ + Name: "bintrie", + Usage: "A set of commands for binary trie operations", + Description: "", + Subcommands: []*cli.Command{ + { + Name: "convert", + Usage: "Convert MPT state to binary trie", + ArgsUsage: "[state-root]", + Action: convertToBinaryTrie, + Flags: slices.Concat([]cli.Flag{ + deleteSourceFlag, + memoryLimitFlag, + }, utils.NetworkFlags, utils.DatabaseFlags), + Description: ` +geth bintrie convert [--delete-source] [--memory-limit MB] [state-root] + +Reads all state from the Merkle Patricia Trie and writes it into a Binary Trie, +operating offline. Memory-safe via periodic commit-and-reload cycles. + +The optional state-root argument specifies which state root to convert. +If omitted, the head block's state root is used. + +Flags: + --delete-source Delete MPT trie nodes after successful conversion + --memory-limit Max heap allocation in MB before forcing a commit (default: 16384) +`, + }, + }, + } +) + +type conversionStats struct { + accounts uint64 + slots uint64 + codes uint64 + commits uint64 + start time.Time + lastReport time.Time + lastMemChk time.Time +} + +func (s *conversionStats) report(force bool) { + if !force && time.Since(s.lastReport) < 8*time.Second { + return + } + elapsed := time.Since(s.start).Seconds() + acctRate := float64(0) + if elapsed > 0 { + acctRate = float64(s.accounts) / elapsed + } + log.Info("Conversion progress", + "accounts", s.accounts, + "slots", s.slots, + "codes", s.codes, + "commits", s.commits, + "accounts/sec", fmt.Sprintf("%.0f", acctRate), + "elapsed", common.PrettyDuration(time.Since(s.start)), + ) + s.lastReport = time.Now() +} + +func convertToBinaryTrie(ctx *cli.Context) error { + if ctx.NArg() > 1 { + return errors.New("too many arguments") + } + stack, _ := makeConfigNode(ctx) + defer stack.Close() + + chaindb := utils.MakeChainDatabase(ctx, stack, false) + defer chaindb.Close() + + headBlock := rawdb.ReadHeadBlock(chaindb) + if headBlock == nil { + return errors.New("no head block found") + } + var ( + root common.Hash + err error + ) + if ctx.NArg() == 1 { + root, err = parseRoot(ctx.Args().First()) + if err != nil { + return fmt.Errorf("invalid state root: %w", err) + } + } else { + root = headBlock.Root() + } + log.Info("Starting MPT to binary trie conversion", "root", root, "block", headBlock.NumberU64()) + + srcTriedb := utils.MakeTrieDatabase(ctx, stack, chaindb, true, true, false) + defer srcTriedb.Close() + + destTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ + IsUBT: true, + PathDB: &pathdb.Config{ + JournalDirectory: stack.ResolvePath("triedb-bintrie"), + }, + }) + defer destTriedb.Close() + + binTrie, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb, ctx.Int(utils.BinTrieGroupDepthFlag.Name)) + if err != nil { + return fmt.Errorf("failed to create binary trie: %w", err) + } + memLimit := ctx.Uint64(memoryLimitFlag.Name) * 1024 * 1024 + + currentRoot, err := runConversionLoop(chaindb, srcTriedb, destTriedb, binTrie, root, memLimit) + if err != nil { + return err + } + log.Info("Conversion complete", "binaryRoot", currentRoot) + + if ctx.Bool(deleteSourceFlag.Name) { + log.Info("Deleting source MPT data") + if err := deleteMPTData(chaindb, srcTriedb, root); err != nil { + return fmt.Errorf("MPT deletion failed: %w", err) + } + log.Info("Source MPT data deleted") + } + return nil +} + +func runConversionLoop(chaindb ethdb.Database, srcTriedb *triedb.Database, destTriedb *triedb.Database, binTrie *bintrie.BinaryTrie, root common.Hash, memLimit uint64) (common.Hash, error) { + currentRoot := types.EmptyBinaryHash + stats := &conversionStats{ + start: time.Now(), + lastReport: time.Now(), + lastMemChk: time.Now(), + } + + srcTrie, err := trie.NewStateTrie(trie.StateTrieID(root), srcTriedb) + if err != nil { + return common.Hash{}, fmt.Errorf("failed to open source trie: %w", err) + } + acctIt, err := srcTrie.NodeIterator(nil) + if err != nil { + return common.Hash{}, fmt.Errorf("failed to create account iterator: %w", err) + } + accIter := trie.NewIterator(acctIt) + + for accIter.Next() { + var acc types.StateAccount + if err := rlp.DecodeBytes(accIter.Value, &acc); err != nil { + return common.Hash{}, fmt.Errorf("invalid account RLP: %w", err) + } + addrBytes := srcTrie.GetKey(accIter.Key) + if addrBytes == nil { + return common.Hash{}, fmt.Errorf("missing preimage for account hash %x (run with --cache.preimages)", accIter.Key) + } + addr := common.BytesToAddress(addrBytes) + + var code []byte + codeHash := common.BytesToHash(acc.CodeHash) + if codeHash != types.EmptyCodeHash { + code = rawdb.ReadCode(chaindb, codeHash) + if code == nil { + return common.Hash{}, fmt.Errorf("missing code for hash %x (account %x)", codeHash, addr) + } + stats.codes++ + } + + if err := binTrie.UpdateAccount(addr, &acc, len(code)); err != nil { + return common.Hash{}, fmt.Errorf("failed to update account %x: %w", addr, err) + } + if len(code) > 0 { + if err := binTrie.UpdateContractCode(addr, codeHash, code); err != nil { + return common.Hash{}, fmt.Errorf("failed to update code for %x: %w", addr, err) + } + } + + if acc.Root != types.EmptyRootHash { + addrHash := common.BytesToHash(accIter.Key) + storageTrie, err := trie.NewStateTrie(trie.StorageTrieID(root, addrHash, acc.Root), srcTriedb) + if err != nil { + return common.Hash{}, fmt.Errorf("failed to open storage trie for %x: %w", addr, err) + } + storageNodeIt, err := storageTrie.NodeIterator(nil) + if err != nil { + return common.Hash{}, fmt.Errorf("failed to create storage iterator for %x: %w", addr, err) + } + storageIter := trie.NewIterator(storageNodeIt) + + slotCount := uint64(0) + for storageIter.Next() { + slotKey := storageTrie.GetKey(storageIter.Key) + if slotKey == nil { + return common.Hash{}, fmt.Errorf("missing preimage for storage key %x (account %x)", storageIter.Key, addr) + } + _, content, _, err := rlp.Split(storageIter.Value) + if err != nil { + return common.Hash{}, fmt.Errorf("invalid storage RLP for key %x (account %x): %w", slotKey, addr, err) + } + if err := binTrie.UpdateStorage(addr, slotKey, content); err != nil { + return common.Hash{}, fmt.Errorf("failed to update storage %x/%x: %w", addr, slotKey, err) + } + stats.slots++ + slotCount++ + + if slotCount%10000 == 0 { + binTrie, currentRoot, err = maybeCommit(binTrie, currentRoot, destTriedb, memLimit, stats) + if err != nil { + return common.Hash{}, err + } + } + } + if storageIter.Err != nil { + return common.Hash{}, fmt.Errorf("storage iteration error for %x: %w", addr, storageIter.Err) + } + } + stats.accounts++ + stats.report(false) + + if stats.accounts%1000 == 0 { + binTrie, currentRoot, err = maybeCommit(binTrie, currentRoot, destTriedb, memLimit, stats) + if err != nil { + return common.Hash{}, err + } + } + } + if accIter.Err != nil { + return common.Hash{}, fmt.Errorf("account iteration error: %w", accIter.Err) + } + + _, currentRoot, err = commitBinaryTrie(binTrie, currentRoot, destTriedb) + if err != nil { + return common.Hash{}, fmt.Errorf("final commit failed: %w", err) + } + stats.commits++ + stats.report(true) + return currentRoot, nil +} + +func maybeCommit(bt *bintrie.BinaryTrie, currentRoot common.Hash, destDB *triedb.Database, memLimit uint64, stats *conversionStats) (*bintrie.BinaryTrie, common.Hash, error) { + if time.Since(stats.lastMemChk) < 5*time.Second { + return bt, currentRoot, nil + } + stats.lastMemChk = time.Now() + + var m runtime.MemStats + runtime.ReadMemStats(&m) + if m.Alloc < memLimit { + return bt, currentRoot, nil + } + log.Info("Memory limit reached, committing", "alloc", common.StorageSize(m.Alloc), "limit", common.StorageSize(memLimit)) + + bt, currentRoot, err := commitBinaryTrie(bt, currentRoot, destDB) + if err != nil { + return nil, common.Hash{}, err + } + stats.commits++ + stats.report(true) + return bt, currentRoot, nil +} + +func commitBinaryTrie(bt *bintrie.BinaryTrie, currentRoot common.Hash, destDB *triedb.Database) (*bintrie.BinaryTrie, common.Hash, error) { + newRoot, nodeSet := bt.Commit(false) + if nodeSet != nil { + merged := trienode.NewWithNodeSet(nodeSet) + if err := destDB.Update(newRoot, currentRoot, 0, merged, triedb.NewStateSet()); err != nil { + return nil, common.Hash{}, fmt.Errorf("triedb update failed: %w", err) + } + if err := destDB.Commit(newRoot, false); err != nil { + return nil, common.Hash{}, fmt.Errorf("triedb commit failed: %w", err) + } + } + runtime.GC() + debug.FreeOSMemory() + + bt, err := bintrie.NewBinaryTrie(newRoot, destDB, bt.GroupDepth()) + if err != nil { + return nil, common.Hash{}, fmt.Errorf("failed to reload binary trie: %w", err) + } + return bt, newRoot, nil +} + +func deleteMPTData(chaindb ethdb.Database, srcTriedb *triedb.Database, root common.Hash) error { + isPathDB := srcTriedb.Scheme() == rawdb.PathScheme + + srcTrie, err := trie.NewStateTrie(trie.StateTrieID(root), srcTriedb) + if err != nil { + return fmt.Errorf("failed to open source trie for deletion: %w", err) + } + acctIt, err := srcTrie.NodeIterator(nil) + if err != nil { + return fmt.Errorf("failed to create account iterator for deletion: %w", err) + } + batch := chaindb.NewBatch() + deleted := 0 + + for acctIt.Next(true) { + if isPathDB { + rawdb.DeleteAccountTrieNode(batch, acctIt.Path()) + } else { + node := acctIt.Hash() + if node != (common.Hash{}) { + rawdb.DeleteLegacyTrieNode(batch, node) + } + } + deleted++ + + if acctIt.Leaf() { + var acc types.StateAccount + if err := rlp.DecodeBytes(acctIt.LeafBlob(), &acc); err != nil { + return fmt.Errorf("invalid account during deletion: %w", err) + } + if acc.Root != types.EmptyRootHash { + addrHash := common.BytesToHash(acctIt.LeafKey()) + storageTrie, err := trie.NewStateTrie(trie.StorageTrieID(root, addrHash, acc.Root), srcTriedb) + if err != nil { + return fmt.Errorf("failed to open storage trie for deletion: %w", err) + } + storageIt, err := storageTrie.NodeIterator(nil) + if err != nil { + return fmt.Errorf("failed to create storage iterator for deletion: %w", err) + } + for storageIt.Next(true) { + if isPathDB { + rawdb.DeleteStorageTrieNode(batch, addrHash, storageIt.Path()) + } else { + node := storageIt.Hash() + if node != (common.Hash{}) { + rawdb.DeleteLegacyTrieNode(batch, node) + } + } + deleted++ + if batch.ValueSize() >= ethdb.IdealBatchSize { + if err := batch.Write(); err != nil { + return fmt.Errorf("batch write failed: %w", err) + } + batch.Reset() + } + } + if storageIt.Error() != nil { + return fmt.Errorf("storage deletion iterator error: %w", storageIt.Error()) + } + } + } + if batch.ValueSize() >= ethdb.IdealBatchSize { + if err := batch.Write(); err != nil { + return fmt.Errorf("batch write failed: %w", err) + } + batch.Reset() + } + } + if acctIt.Error() != nil { + return fmt.Errorf("account deletion iterator error: %w", acctIt.Error()) + } + if batch.ValueSize() > 0 { + if err := batch.Write(); err != nil { + return fmt.Errorf("final batch write failed: %w", err) + } + } + log.Info("MPT deletion complete", "nodesDeleted", deleted) + return nil +} diff --git a/cmd/geth/bintrie_convert_test.go b/cmd/geth/bintrie_convert_test.go new file mode 100644 index 000000000000..32e8c7e55bfd --- /dev/null +++ b/cmd/geth/bintrie_convert_test.go @@ -0,0 +1,229 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "math" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/trie/bintrie" + "github.com/ethereum/go-ethereum/triedb" + "github.com/ethereum/go-ethereum/triedb/pathdb" + "github.com/holiman/uint256" +) + +func TestBintrieConvert(t *testing.T) { + var ( + addr1 = common.HexToAddress("0x1111111111111111111111111111111111111111") + addr2 = common.HexToAddress("0x2222222222222222222222222222222222222222") + slotKey1 = common.HexToHash("0x01") + slotKey2 = common.HexToHash("0x02") + slotVal1 = common.HexToHash("0xdeadbeef") + slotVal2 = common.HexToHash("0xcafebabe") + code = []byte{0x60, 0x42, 0x60, 0x00, 0x52, 0x60, 0x20, 0x60, 0x00, 0xf3} + ) + + chaindb := rawdb.NewMemoryDatabase() + + srcTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ + Preimages: true, + PathDB: pathdb.Defaults, + }) + + gspec := &core.Genesis{ + Config: params.TestChainConfig, + BaseFee: big.NewInt(params.InitialBaseFee), + Alloc: types.GenesisAlloc{ + addr1: { + Balance: big.NewInt(1000000), + Nonce: 5, + }, + addr2: { + Balance: big.NewInt(2000000), + Nonce: 10, + Code: code, + Storage: map[common.Hash]common.Hash{ + slotKey1: slotVal1, + slotKey2: slotVal2, + }, + }, + }, + } + + genesisBlock := gspec.MustCommit(chaindb, srcTriedb) + root := genesisBlock.Root() + t.Logf("Genesis root: %x", root) + srcTriedb.Close() + + srcTriedb2 := triedb.NewDatabase(chaindb, &triedb.Config{ + Preimages: true, + PathDB: &pathdb.Config{ReadOnly: true}, + }) + defer srcTriedb2.Close() + + destTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ + IsUBT: true, + PathDB: pathdb.Defaults, + }) + defer destTriedb.Close() + + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb, 8) + if err != nil { + t.Fatalf("failed to create binary trie: %v", err) + } + + currentRoot, err := runConversionLoop(chaindb, srcTriedb2, destTriedb, bt, root, math.MaxUint64) + if err != nil { + t.Fatalf("conversion failed: %v", err) + } + t.Logf("Binary trie root: %x", currentRoot) + + bt2, err := bintrie.NewBinaryTrie(currentRoot, destTriedb, 8) + if err != nil { + t.Fatalf("failed to reload binary trie: %v", err) + } + + acc1, err := bt2.GetAccount(addr1) + if err != nil { + t.Fatalf("failed to get account1: %v", err) + } + if acc1 == nil { + t.Fatal("account1 not found in binary trie") + } + if acc1.Nonce != 5 { + t.Errorf("account1 nonce: got %d, want 5", acc1.Nonce) + } + wantBal1 := uint256.NewInt(1000000) + if acc1.Balance.Cmp(wantBal1) != 0 { + t.Errorf("account1 balance: got %s, want %s", acc1.Balance, wantBal1) + } + + acc2, err := bt2.GetAccount(addr2) + if err != nil { + t.Fatalf("failed to get account2: %v", err) + } + if acc2 == nil { + t.Fatal("account2 not found in binary trie") + } + if acc2.Nonce != 10 { + t.Errorf("account2 nonce: got %d, want 10", acc2.Nonce) + } + wantBal2 := uint256.NewInt(2000000) + if acc2.Balance.Cmp(wantBal2) != 0 { + t.Errorf("account2 balance: got %s, want %s", acc2.Balance, wantBal2) + } + + treeKey1 := bintrie.GetBinaryTreeKeyStorageSlot(addr2, slotKey1[:]) + val1, err := bt2.GetWithHashedKey(treeKey1) + if err != nil { + t.Fatalf("failed to get storage slot1: %v", err) + } + if len(val1) == 0 { + t.Fatal("storage slot1 not found") + } + got1 := common.BytesToHash(val1) + if got1 != slotVal1 { + t.Errorf("storage slot1: got %x, want %x", got1, slotVal1) + } + + treeKey2 := bintrie.GetBinaryTreeKeyStorageSlot(addr2, slotKey2[:]) + val2, err := bt2.GetWithHashedKey(treeKey2) + if err != nil { + t.Fatalf("failed to get storage slot2: %v", err) + } + if len(val2) == 0 { + t.Fatal("storage slot2 not found") + } + got2 := common.BytesToHash(val2) + if got2 != slotVal2 { + t.Errorf("storage slot2: got %x, want %x", got2, slotVal2) + } +} + +func TestBintrieConvertDeleteSource(t *testing.T) { + addr1 := common.HexToAddress("0x3333333333333333333333333333333333333333") + + chaindb := rawdb.NewMemoryDatabase() + + srcTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ + Preimages: true, + PathDB: pathdb.Defaults, + }) + + gspec := &core.Genesis{ + Config: params.TestChainConfig, + BaseFee: big.NewInt(params.InitialBaseFee), + Alloc: types.GenesisAlloc{ + addr1: { + Balance: big.NewInt(1000000), + }, + }, + } + + genesisBlock := gspec.MustCommit(chaindb, srcTriedb) + root := genesisBlock.Root() + srcTriedb.Close() + + srcTriedb2 := triedb.NewDatabase(chaindb, &triedb.Config{ + Preimages: true, + PathDB: &pathdb.Config{ReadOnly: true}, + }) + + destTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ + IsUBT: true, + PathDB: pathdb.Defaults, + }) + + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb, 8) + if err != nil { + t.Fatalf("failed to create binary trie: %v", err) + } + + newRoot, err := runConversionLoop(chaindb, srcTriedb2, destTriedb, bt, root, math.MaxUint64) + if err != nil { + t.Fatalf("conversion failed: %v", err) + } + + if err := deleteMPTData(chaindb, srcTriedb2, root); err != nil { + t.Fatalf("deletion failed: %v", err) + } + srcTriedb2.Close() + + bt2, err := bintrie.NewBinaryTrie(newRoot, destTriedb, 8) + if err != nil { + t.Fatalf("failed to reload binary trie after deletion: %v", err) + } + + acc, err := bt2.GetAccount(addr1) + if err != nil { + t.Fatalf("failed to get account after deletion: %v", err) + } + if acc == nil { + t.Fatal("account not found after MPT deletion") + } + wantBal := uint256.NewInt(1000000) + if acc.Balance.Cmp(wantBal) != 0 { + t.Errorf("balance after deletion: got %s, want %s", acc.Balance, wantBal) + } + destTriedb.Close() +} diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go index e535d7d89244..0f8b15e77f1a 100644 --- a/cmd/geth/chaincmd.go +++ b/cmd/geth/chaincmd.go @@ -20,6 +20,7 @@ import ( "encoding/json" "errors" "fmt" + "io" "os" "path/filepath" "regexp" @@ -43,6 +44,8 @@ import ( "github.com/ethereum/go-ethereum/internal/debug" "github.com/ethereum/go-ethereum/internal/era" "github.com/ethereum/go-ethereum/internal/era/eradl" + "github.com/ethereum/go-ethereum/internal/era/execdb" + "github.com/ethereum/go-ethereum/internal/era/onedb" "github.com/ethereum/go-ethereum/internal/flags" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" @@ -61,7 +64,7 @@ var ( utils.OverrideOsaka, utils.OverrideBPO1, utils.OverrideBPO2, - utils.OverrideVerkle, + utils.OverrideUBT, }, utils.DatabaseFlags), Description: ` The init command initializes a new genesis block and definition for the network. @@ -108,10 +111,12 @@ if one is set. Otherwise it prints the genesis from the datadir.`, utils.MetricsInfluxDBUsernameFlag, utils.MetricsInfluxDBPasswordFlag, utils.MetricsInfluxDBTagsFlag, + utils.MetricsInfluxDBIntervalFlag, utils.MetricsInfluxDBTokenFlag, utils.MetricsInfluxDBBucketFlag, utils.MetricsInfluxDBOrganizationFlag, utils.StateSizeTrackingFlag, + utils.StateSizeTrackingDepthFlag, utils.TxLookupLimitFlag, utils.VMTraceFlag, utils.VMTraceJsonConfigFlag, @@ -120,6 +125,8 @@ if one is set. Otherwise it prints the genesis from the datadir.`, utils.LogNoHistoryFlag, utils.LogExportCheckpointsFlag, utils.StateHistoryFlag, + utils.TrienodeHistoryFlag, + utils.TrienodeHistoryFullValueCheckpointFlag, }, utils.DatabaseFlags, debug.Flags), Before: func(ctx *cli.Context) error { flags.MigrateGlobalFlags(ctx) @@ -151,7 +158,7 @@ be gzipped.`, Name: "import-history", Usage: "Import an Era archive", ArgsUsage: "", - Flags: slices.Concat([]cli.Flag{utils.TxLookupLimitFlag, utils.TransactionHistoryFlag}, utils.DatabaseFlags, utils.NetworkFlags), + Flags: slices.Concat([]cli.Flag{utils.TxLookupLimitFlag, utils.TransactionHistoryFlag, utils.EraFormatFlag}, utils.DatabaseFlags, utils.NetworkFlags), Description: ` The import-history command will import blocks and their corresponding receipts from Era archives. @@ -162,7 +169,7 @@ from Era archives. Name: "export-history", Usage: "Export blockchain history to Era archives", ArgsUsage: " ", - Flags: utils.DatabaseFlags, + Flags: slices.Concat([]cli.Flag{utils.EraFormatFlag}, utils.DatabaseFlags), Description: ` The export-history command will export blocks and their corresponding receipts into Era archives. Eras are typically packaged in steps of 8192 blocks. @@ -202,13 +209,19 @@ This command dumps out the state for a given block (or latest, if none provided) pruneHistoryCommand = &cli.Command{ Action: pruneHistory, Name: "prune-history", - Usage: "Prune blockchain history (block bodies and receipts) up to the merge block", + Usage: "Prune blockchain history (block bodies and receipts) up to a specified point", ArgsUsage: "", - Flags: utils.DatabaseFlags, + Flags: slices.Concat(utils.DatabaseFlags, []cli.Flag{ + utils.ChainHistoryFlag, + }), Description: ` The prune-history command removes historical block bodies and receipts from the -blockchain database up to the merge block, while preserving block headers. This -helps reduce storage requirements for nodes that don't need full historical data.`, +blockchain database up to a specified point, while preserving block headers. This +helps reduce storage requirements for nodes that don't need full historical data. + +The --history.chain flag is required to specify the pruning target: + - postmerge: Prune up to the merge block. The node will keep the merge block and everything thereafter. + - postprague: Prune up to the Prague (Pectra) upgrade block. The node will keep the prague block and everything thereafter.`, } downloadEraCommand = &cli.Command{ @@ -285,18 +298,18 @@ func initGenesis(ctx *cli.Context) error { v := ctx.Uint64(utils.OverrideBPO2.Name) overrides.OverrideBPO2 = &v } - if ctx.IsSet(utils.OverrideVerkle.Name) { - v := ctx.Uint64(utils.OverrideVerkle.Name) - overrides.OverrideVerkle = &v + if ctx.IsSet(utils.OverrideUBT.Name) { + v := ctx.Uint64(utils.OverrideUBT.Name) + overrides.OverrideUBT = &v } chaindb := utils.MakeChainDatabase(ctx, stack, false) defer chaindb.Close() - triedb := utils.MakeTrieDatabase(ctx, stack, chaindb, ctx.Bool(utils.CachePreimagesFlag.Name), false, genesis.IsVerkle()) + triedb := utils.MakeTrieDatabase(ctx, stack, chaindb, ctx.Bool(utils.CachePreimagesFlag.Name), false, genesis.IsUBT()) defer triedb.Close() - _, hash, compatErr, err := core.SetupGenesisBlockWithOverride(chaindb, triedb, genesis, &overrides) + _, hash, compatErr, err := core.SetupGenesisBlockWithOverride(chaindb, triedb, genesis, &overrides, nil) if err != nil { utils.Fatalf("Failed to write genesis block: %v", err) } @@ -313,7 +326,7 @@ func dumpGenesis(ctx *cli.Context) error { var genesis *core.Genesis if utils.IsNetworkPreset(ctx) { genesis = utils.MakeGenesis(ctx) - } else if ctx.IsSet(utils.DeveloperFlag.Name) && !ctx.IsSet(utils.DataDirFlag.Name) { + } else if ctx.Bool(utils.DeveloperFlag.Name) && !ctx.IsSet(utils.DataDirFlag.Name) { genesis = core.DeveloperGenesisBlock(11_500_000, nil) } @@ -514,15 +527,27 @@ func importHistory(ctx *cli.Context) error { network = networks[0] } - if err := utils.ImportHistory(chain, dir, network); err != nil { + var ( + format = ctx.String(utils.EraFormatFlag.Name) + from func(era.ReadAtSeekCloser) (era.Era, error) + ) + switch format { + case "era1", "era": + from = onedb.From + case "erae": + from = execdb.From + default: + return fmt.Errorf("unknown --era.format %q (expected 'era1' or 'erae')", format) + } + if err := utils.ImportHistory(chain, dir, network, from); err != nil { return err } + fmt.Printf("Import done in %v\n", time.Since(start)) return nil } -// exportHistory exports chain history in Era archives at a specified -// directory. +// exportHistory exports chain history in Era archives at a specified directory. func exportHistory(ctx *cli.Context) error { if ctx.Args().Len() != 3 { utils.Fatalf("usage: %s", ctx.Command.ArgsUsage) @@ -548,10 +573,26 @@ func exportHistory(ctx *cli.Context) error { if head := chain.CurrentSnapBlock(); uint64(last) > head.Number.Uint64() { utils.Fatalf("Export error: block number %d larger than head block %d\n", uint64(last), head.Number.Uint64()) } - err := utils.ExportHistory(chain, dir, uint64(first), uint64(last), uint64(era.MaxEra1Size)) - if err != nil { + + var ( + format = ctx.String(utils.EraFormatFlag.Name) + filename func(network string, epoch int, root common.Hash) string + newBuilder func(w io.Writer) era.Builder + ) + switch format { + case "era1", "era": + newBuilder = func(w io.Writer) era.Builder { return onedb.NewBuilder(w) } + filename = func(network string, epoch int, root common.Hash) string { return onedb.Filename(network, epoch, root) } + case "erae": + newBuilder = func(w io.Writer) era.Builder { return execdb.NewBuilder(w) } + filename = func(network string, epoch int, root common.Hash) string { return execdb.Filename(network, epoch, root) } + default: + return fmt.Errorf("unknown archive format %q (use 'era1' or 'erae')", format) + } + if err := utils.ExportHistory(chain, dir, uint64(first), uint64(last), newBuilder, filename); err != nil { utils.Fatalf("Export error: %v\n", err) } + fmt.Printf("Export done in %v\n", time.Since(start)) return nil } @@ -669,47 +710,77 @@ func hashish(x string) bool { } func pruneHistory(ctx *cli.Context) error { + // Parse and validate the history mode flag. + if !ctx.IsSet(utils.ChainHistoryFlag.Name) { + return errors.New("--history.chain flag is required") + } + var mode history.HistoryMode + if err := mode.UnmarshalText([]byte(ctx.String(utils.ChainHistoryFlag.Name))); err != nil { + return err + } + if mode == history.KeepAll { + return errors.New("--history.chain=all is not valid for pruning. To restore history, use 'geth import-history'") + } + stack, _ := makeConfigNode(ctx) defer stack.Close() - // Open the chain database + // Open the chain database. chain, chaindb := utils.MakeChain(ctx, stack, false) defer chaindb.Close() defer chain.Stop() - // Determine the prune point. This will be the first PoS block. - prunePoint, ok := history.PrunePoints[chain.Genesis().Hash()] - if !ok || prunePoint == nil { - return errors.New("prune point not found") + // Determine the prune point based on the history mode. + genesisHash := chain.Genesis().Hash() + policy, err := history.NewPolicy(mode, genesisHash) + if err != nil { + return err + } + if policy.Target == nil { + return fmt.Errorf("prune point for %q not found for this network", mode.String()) } var ( - mergeBlock = prunePoint.BlockNumber - mergeBlockHash = prunePoint.BlockHash.Hex() + targetBlock = policy.Target.BlockNumber + targetBlockHash = policy.Target.BlockHash ) - // Check we're far enough past merge to ensure all data is in freezer + // Check the current freezer tail to see if pruning is needed/possible. + freezerTail, _ := chaindb.Tail() + if freezerTail > 0 { + if freezerTail == targetBlock { + log.Info("Database already pruned to target block", "tail", freezerTail) + return nil + } + if freezerTail > targetBlock { + // Database is pruned beyond the target - can't unprune. + return fmt.Errorf("database is already pruned to block %d, which is beyond target %d. Cannot unprune. To restore history, use 'geth import-history'", freezerTail, targetBlock) + } + // freezerTail < targetBlock: we can prune further, continue below. + } + + // Check we're far enough past the target to ensure all data is in freezer. currentHeader := chain.CurrentHeader() if currentHeader == nil { return errors.New("current header not found") } - if currentHeader.Number.Uint64() < mergeBlock+params.FullImmutabilityThreshold { - return fmt.Errorf("chain not far enough past merge block, need %d more blocks", - mergeBlock+params.FullImmutabilityThreshold-currentHeader.Number.Uint64()) + if currentHeader.Number.Uint64() < targetBlock+params.FullImmutabilityThreshold { + return fmt.Errorf("chain not far enough past target block %d, need %d more blocks", + targetBlock, targetBlock+params.FullImmutabilityThreshold-currentHeader.Number.Uint64()) } - // Double-check the prune block in db has the expected hash. - hash := rawdb.ReadCanonicalHash(chaindb, mergeBlock) - if hash != common.HexToHash(mergeBlockHash) { - return fmt.Errorf("merge block hash mismatch: got %s, want %s", hash.Hex(), mergeBlockHash) + // Double-check the target block in db has the expected hash. + hash := rawdb.ReadCanonicalHash(chaindb, targetBlock) + if hash != targetBlockHash { + return fmt.Errorf("target block hash mismatch: got %s, want %s", hash.Hex(), targetBlockHash.Hex()) } - log.Info("Starting history pruning", "head", currentHeader.Number, "tail", mergeBlock, "tailHash", mergeBlockHash) + log.Info("Starting history pruning", "head", currentHeader.Number, "target", targetBlock, "targetHash", targetBlockHash.Hex()) start := time.Now() - rawdb.PruneTransactionIndex(chaindb, mergeBlock) - if _, err := chaindb.TruncateTail(mergeBlock); err != nil { + rawdb.PruneTransactionIndex(chaindb, targetBlock) + if _, err := chaindb.TruncateTail(targetBlock); err != nil { return fmt.Errorf("failed to truncate ancient data: %v", err) } - log.Info("History pruning completed", "tail", mergeBlock, "elapsed", common.PrettyDuration(time.Since(start))) + log.Info("History pruning completed", "tail", targetBlock, "elapsed", common.PrettyDuration(time.Since(start))) // TODO(s1na): what if there is a crash between the two prune operations? diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 87627467d2b7..c02e307bdc49 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -38,7 +38,9 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/catalyst" "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/eth/syncer" "github.com/ethereum/go-ethereum/internal/flags" + "github.com/ethereum/go-ethereum/internal/telemetry/tracesetup" "github.com/ethereum/go-ethereum/internal/version" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" @@ -234,14 +236,20 @@ func makeFullNode(ctx *cli.Context) *node.Node { v := ctx.Uint64(utils.OverrideBPO2.Name) cfg.Eth.OverrideBPO2 = &v } - if ctx.IsSet(utils.OverrideVerkle.Name) { - v := ctx.Uint64(utils.OverrideVerkle.Name) - cfg.Eth.OverrideVerkle = &v + if ctx.IsSet(utils.OverrideUBT.Name) { + v := ctx.Uint64(utils.OverrideUBT.Name) + cfg.Eth.OverrideUBT = &v } - // Start metrics export if enabled + // Start metrics export if enabled. utils.SetupMetrics(&cfg.Metrics) + // Setup OpenTelemetry reporting if enabled. + if err := tracesetup.SetupTelemetry(cfg.Node.OpenTelemetry, stack); err != nil { + utils.Fatalf("failed to setup OpenTelemetry: %v", err) + } + + // Add Ethereum service. backend, eth := utils.RegisterEthService(stack, &cfg.Eth) // Create gauge with geth system and build information @@ -262,25 +270,28 @@ func makeFullNode(ctx *cli.Context) *node.Node { filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth) // Configure GraphQL if requested. - if ctx.IsSet(utils.GraphQLEnabledFlag.Name) { + if ctx.Bool(utils.GraphQLEnabledFlag.Name) { utils.RegisterGraphQLService(stack, backend, filterSystem, &cfg.Node) } // Add the Ethereum Stats daemon if requested. if cfg.Ethstats.URL != "" { utils.RegisterEthStatsService(stack, backend, cfg.Ethstats.URL) } + // Configure synchronization override service - var synctarget common.Hash + syncConfig := syncer.Config{ + ExitWhenSynced: ctx.Bool(utils.ExitWhenSyncedFlag.Name), + } if ctx.IsSet(utils.SyncTargetFlag.Name) { target := ctx.String(utils.SyncTargetFlag.Name) if !common.IsHexHash(target) { utils.Fatalf("sync target hash is not a valid hex hash: %s", target) } - synctarget = common.HexToHash(target) + syncConfig.TargetBlock = common.HexToHash(target) } - utils.RegisterSyncOverrideService(stack, eth, synctarget, ctx.Bool(utils.ExitWhenSyncedFlag.Name)) + utils.RegisterSyncOverrideService(stack, eth, syncConfig) - if ctx.IsSet(utils.DeveloperFlag.Name) { + if ctx.Bool(utils.DeveloperFlag.Name) { // Start dev mode. simBeacon, err := catalyst.NewSimulatedBeacon(ctx.Uint64(utils.DeveloperPeriodFlag.Name), cfg.Eth.Miner.PendingFeeRecipient, eth) if err != nil { @@ -370,6 +381,9 @@ func applyMetricConfig(ctx *cli.Context, cfg *gethConfig) { if ctx.IsSet(utils.MetricsInfluxDBTagsFlag.Name) { cfg.Metrics.InfluxDBTags = ctx.String(utils.MetricsInfluxDBTagsFlag.Name) } + if ctx.IsSet(utils.MetricsInfluxDBIntervalFlag.Name) { + cfg.Metrics.InfluxDBInterval = ctx.Duration(utils.MetricsInfluxDBIntervalFlag.Name) + } if ctx.IsSet(utils.MetricsEnableInfluxDBV2Flag.Name) { cfg.Metrics.EnableInfluxDBV2 = ctx.Bool(utils.MetricsEnableInfluxDBV2Flag.Name) } @@ -398,9 +412,9 @@ func applyMetricConfig(ctx *cli.Context, cfg *gethConfig) { ctx.IsSet(utils.MetricsInfluxDBBucketFlag.Name) if enableExport && v2FlagIsSet { - utils.Fatalf("Flags --influxdb.metrics.organization, --influxdb.metrics.token, --influxdb.metrics.bucket are only available for influxdb-v2") + utils.Fatalf("Flags --%s, --%s, --%s are only available for influxdb-v2", utils.MetricsInfluxDBOrganizationFlag.Name, utils.MetricsInfluxDBTokenFlag.Name, utils.MetricsInfluxDBBucketFlag.Name) } else if enableExportV2 && v1FlagIsSet { - utils.Fatalf("Flags --influxdb.metrics.username, --influxdb.metrics.password are only available for influxdb-v1") + utils.Fatalf("Flags --%s, --%s are only available for influxdb-v1", utils.MetricsInfluxDBUsernameFlag.Name, utils.MetricsInfluxDBPasswordFlag.Name) } } } diff --git a/cmd/geth/consolecmd_test.go b/cmd/geth/consolecmd_test.go index 871e8c175fc7..12ee7e7dd1f0 100644 --- a/cmd/geth/consolecmd_test.go +++ b/cmd/geth/consolecmd_test.go @@ -30,7 +30,7 @@ import ( ) const ( - ipcAPIs = "admin:1.0 debug:1.0 engine:1.0 eth:1.0 miner:1.0 net:1.0 rpc:1.0 txpool:1.0 web3:1.0" + ipcAPIs = "admin:1.0 debug:1.0 engine:1.0 eth:1.0 miner:1.0 net:1.0 rpc:1.0 testing:1.0 txpool:1.0 web3:1.0" httpAPIs = "eth:1.0 net:1.0 rpc:1.0 web3:1.0" ) diff --git a/cmd/geth/dbcmd.go b/cmd/geth/dbcmd.go index fb688793e3ec..173fc97def67 100644 --- a/cmd/geth/dbcmd.go +++ b/cmd/geth/dbcmd.go @@ -19,6 +19,7 @@ package main import ( "bytes" "fmt" + "math" "os" "os/signal" "path/filepath" @@ -37,6 +38,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/internal/tablewriter" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" @@ -51,7 +53,24 @@ var ( } removeChainDataFlag = &cli.BoolFlag{ Name: "remove.chain", - Usage: "If set, selects the state data for removal", + Usage: "If set, selects the chain data for removal", + } + inspectTrieTopFlag = &cli.IntFlag{ + Name: "top", + Usage: "Print the top N results per ranking category", + Value: 10, + } + inspectTrieDumpPathFlag = &cli.StringFlag{ + Name: "dump-path", + Usage: "Path for the trie statistics dump file", + } + inspectTrieSummarizeFlag = &cli.StringFlag{ + Name: "summarize", + Usage: "Summarize an existing trie dump file (skip trie traversal)", + } + inspectTrieContractFlag = &cli.StringFlag{ + Name: "contract", + Usage: "Inspect only the storage of the given contract address (skips full account trie walk)", } removedbCommand = &cli.Command{ @@ -74,6 +93,7 @@ Remove blockchain and state databases`, dbCompactCmd, dbGetCmd, dbDeleteCmd, + dbInspectTrieCmd, dbPutCmd, dbGetSlotsCmd, dbDumpFreezerIndex, @@ -92,6 +112,22 @@ Remove blockchain and state databases`, Usage: "Inspect the storage size for each type of data in the database", Description: `This commands iterates the entire database. If the optional 'prefix' and 'start' arguments are provided, then the iteration is limited to the given subset of data.`, } + dbInspectTrieCmd = &cli.Command{ + Action: inspectTrie, + Name: "inspect-trie", + ArgsUsage: "", + Flags: slices.Concat([]cli.Flag{ + utils.ExcludeStorageFlag, + inspectTrieTopFlag, + utils.OutputFileFlag, + inspectTrieDumpPathFlag, + inspectTrieSummarizeFlag, + inspectTrieContractFlag, + }, utils.NetworkFlags, utils.DatabaseFlags), + Usage: "Print detailed trie information about the structure of account trie and storage tries.", + Description: `This commands iterates the entrie trie-backed state. If the 'blocknum' is not specified, +the latest block number will be used by default.`, + } dbCheckStateContentCmd = &cli.Command{ Action: checkStateContent, Name: "check-state-content", @@ -385,6 +421,88 @@ func checkStateContent(ctx *cli.Context) error { return nil } +func inspectTrie(ctx *cli.Context) error { + topN := ctx.Int(inspectTrieTopFlag.Name) + if topN <= 0 { + return fmt.Errorf("invalid --%s value %d (must be > 0)", inspectTrieTopFlag.Name, topN) + } + config := &trie.InspectConfig{ + NoStorage: ctx.Bool(utils.ExcludeStorageFlag.Name), + TopN: topN, + Path: ctx.String(utils.OutputFileFlag.Name), + } + + if summarizePath := ctx.String(inspectTrieSummarizeFlag.Name); summarizePath != "" { + if ctx.NArg() > 0 { + return fmt.Errorf("block number argument is not supported with --%s", inspectTrieSummarizeFlag.Name) + } + config.DumpPath = summarizePath + log.Info("Summarizing trie dump", "path", summarizePath, "top", topN) + return trie.Summarize(summarizePath, config) + } + if ctx.NArg() > 1 { + return fmt.Errorf("excessive number of arguments: %v", ctx.Command.ArgsUsage) + } + + stack, _ := makeConfigNode(ctx) + db := utils.MakeChainDatabase(ctx, stack, false) + defer stack.Close() + defer db.Close() + + var ( + trieRoot common.Hash + hash common.Hash + number uint64 + ) + switch { + case ctx.NArg() == 0 || ctx.Args().Get(0) == "latest": + head := rawdb.ReadHeadHeaderHash(db) + n, ok := rawdb.ReadHeaderNumber(db, head) + if !ok { + return fmt.Errorf("could not load head block hash") + } + number = n + case ctx.Args().Get(0) == "snapshot": + trieRoot = rawdb.ReadSnapshotRoot(db) + number = math.MaxUint64 + default: + var err error + number, err = strconv.ParseUint(ctx.Args().Get(0), 10, 64) + if err != nil { + return fmt.Errorf("failed to parse blocknum, Args[0]: %v, err: %v", ctx.Args().Get(0), err) + } + } + + if number != math.MaxUint64 { + hash = rawdb.ReadCanonicalHash(db, number) + if hash == (common.Hash{}) { + return fmt.Errorf("canonical hash for block %d not found", number) + } + blockHeader := rawdb.ReadHeader(db, hash, number) + trieRoot = blockHeader.Root + } + if trieRoot == (common.Hash{}) { + log.Error("Empty root hash") + } + + config.DumpPath = ctx.String(inspectTrieDumpPathFlag.Name) + if config.DumpPath == "" { + config.DumpPath = stack.ResolvePath("trie-dump.bin") + } + + triedb := utils.MakeTrieDatabase(ctx, stack, db, false, true, false) + defer triedb.Close() + + if contractAddr := ctx.String(inspectTrieContractFlag.Name); contractAddr != "" { + address := common.HexToAddress(contractAddr) + log.Info("Inspecting contract", "address", address, "root", trieRoot, "block", number) + return trie.InspectContract(triedb, db, trieRoot, address) + } + + log.Info("Inspecting trie", "root", trieRoot, "block", number, "dump", config.DumpPath, "top", topN) + return trie.Inspect(triedb, trieRoot, config) +} + func showDBStats(db ethdb.KeyValueStater) { stats, err := db.Stat() if err != nil { @@ -688,6 +806,24 @@ func (iter *snapshotIterator) Release() { iter.storage.Release() } +type codeIterator struct { + iter ethdb.Iterator +} + +func (iter *codeIterator) Next() (byte, []byte, []byte, bool) { + for iter.iter.Next() { + key := iter.iter.Key() + if bytes.HasPrefix(key, rawdb.CodePrefix) && len(key) == (len(rawdb.CodePrefix)+common.HashLength) { + return utils.OpBatchAdd, key, iter.iter.Value(), true + } + } + return 0, nil, nil, false +} + +func (iter *codeIterator) Release() { + iter.iter.Release() +} + // chainExporters defines the export scheme for all exportable chain data. var chainExporters = map[string]func(db ethdb.Database) utils.ChainDataIterator{ "preimage": func(db ethdb.Database) utils.ChainDataIterator { @@ -699,6 +835,10 @@ var chainExporters = map[string]func(db ethdb.Database) utils.ChainDataIterator{ storage := db.NewIterator(rawdb.SnapshotStoragePrefix, nil) return &snapshotIterator{account: account, storage: storage} }, + "code": func(db ethdb.Database) utils.ChainDataIterator { + iter := db.NewIterator(rawdb.CodePrefix, nil) + return &codeIterator{iter: iter} + }, } func exportChaindata(ctx *cli.Context) error { @@ -759,7 +899,7 @@ func showMetaData(ctx *cli.Context) error { data = append(data, []string{"headHeader.Root", fmt.Sprintf("%v", h.Root)}) data = append(data, []string{"headHeader.Number", fmt.Sprintf("%d (%#x)", h.Number, h.Number)}) } - table := rawdb.NewTableWriter(os.Stdout) + table := tablewriter.NewWriter(os.Stdout) table.SetHeader([]string{"Field", "Value"}) table.AppendBulk(data) table.Render() diff --git a/cmd/geth/main.go b/cmd/geth/main.go index b294ee593e2e..4a8a20f3768b 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -22,14 +22,10 @@ import ( "os" "slices" "sort" - "strconv" - "time" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/cmd/utils" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/console/prompt" - "github.com/ethereum/go-ethereum/eth/downloader" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/internal/debug" "github.com/ethereum/go-ethereum/internal/flags" @@ -65,7 +61,7 @@ var ( utils.OverrideOsaka, utils.OverrideBPO1, utils.OverrideBPO2, - utils.OverrideVerkle, + utils.OverrideUBT, utils.OverrideGenesisFlag, utils.EnablePersonal, // deprecated utils.TxPoolLocalsFlag, @@ -94,6 +90,9 @@ var ( utils.LogNoHistoryFlag, utils.LogExportCheckpointsFlag, utils.StateHistoryFlag, + utils.TrienodeHistoryFlag, + utils.TrienodeHistoryFullValueCheckpointFlag, + utils.BinTrieGroupDepthFlag, utils.LightKDFFlag, utils.EthRequiredBlocksFlag, utils.LegacyWhitelistFlag, // deprecated @@ -193,6 +192,14 @@ var ( utils.BatchResponseMaxSize, utils.RPCTxSyncDefaultTimeoutFlag, utils.RPCTxSyncMaxTimeoutFlag, + utils.RPCGlobalRangeLimitFlag, + utils.RPCTelemetryFlag, + utils.RPCTelemetryEndpointFlag, + utils.RPCTelemetryUserFlag, + utils.RPCTelemetryPasswordFlag, + utils.RPCTelemetryInstanceIDFlag, + utils.RPCTelemetryTagsFlag, + utils.RPCTelemetrySampleRatioFlag, } metricsFlags = []cli.Flag{ @@ -206,11 +213,13 @@ var ( utils.MetricsInfluxDBUsernameFlag, utils.MetricsInfluxDBPasswordFlag, utils.MetricsInfluxDBTagsFlag, + utils.MetricsInfluxDBIntervalFlag, utils.MetricsEnableInfluxDBV2Flag, utils.MetricsInfluxDBTokenFlag, utils.MetricsInfluxDBBucketFlag, utils.MetricsInfluxDBOrganizationFlag, utils.StateSizeTrackingFlag, + utils.StateSizeTrackingDepthFlag, } ) @@ -241,7 +250,6 @@ func init() { javascriptCommand, // See misccmd.go: versionCommand, - versionCheckCommand, licenseCommand, // See config.go dumpConfigCommand, @@ -251,8 +259,8 @@ func init() { utils.ShowDeprecated, // See snapshot.go snapshotCommand, - // See verkle.go - verkleCommand, + // See bintrie_convert.go + bintrieCommand, } if logTestCommand != nil { app.Commands = append(app.Commands, logTestCommand) @@ -308,18 +316,6 @@ func prepare(ctx *cli.Context) { case !ctx.IsSet(utils.NetworkIdFlag.Name): log.Info("Starting Geth on Ethereum mainnet...") } - // If we're a full node on mainnet without --cache specified, bump default cache allowance - if !ctx.IsSet(utils.CacheFlag.Name) && !ctx.IsSet(utils.NetworkIdFlag.Name) { - // Make sure we're not on any supported preconfigured testnet either - if !ctx.IsSet(utils.HoleskyFlag.Name) && - !ctx.IsSet(utils.SepoliaFlag.Name) && - !ctx.IsSet(utils.HoodiFlag.Name) && - !ctx.IsSet(utils.DeveloperFlag.Name) { - // Nope, we're really on mainnet. Bump that cache up! - log.Info("Bumping default cache on mainnet", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 4096) - ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096)) - } - } } // geth is the main entry point into the system if no special subcommand is run. @@ -389,28 +385,4 @@ func startNode(ctx *cli.Context, stack *node.Node, isConsole bool) { } } }() - - // Spawn a standalone goroutine for status synchronization monitoring, - // close the node when synchronization is complete if user required. - if ctx.Bool(utils.ExitWhenSyncedFlag.Name) { - go func() { - sub := stack.EventMux().Subscribe(downloader.DoneEvent{}) - defer sub.Unsubscribe() - for { - event := <-sub.Chan() - if event == nil { - continue - } - done, ok := event.Data.(downloader.DoneEvent) - if !ok { - continue - } - if timestamp := time.Unix(int64(done.Latest.Time), 0); time.Since(timestamp) < 10*time.Minute { - log.Info("Synchronisation completed", "latestnum", done.Latest.Number, "latesthash", done.Latest.Hash(), - "age", common.PrettyAge(timestamp)) - stack.Close() - } - } - }() - } } diff --git a/cmd/geth/misccmd.go b/cmd/geth/misccmd.go index 2d31f3abe7b2..f5c0d55ebb5a 100644 --- a/cmd/geth/misccmd.go +++ b/cmd/geth/misccmd.go @@ -27,16 +27,6 @@ import ( ) var ( - VersionCheckUrlFlag = &cli.StringFlag{ - Name: "check.url", - Usage: "URL to use when checking vulnerabilities", - Value: "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities.json", - } - VersionCheckVersionFlag = &cli.StringFlag{ - Name: "check.version", - Usage: "Version to check", - Value: version.ClientName(clientIdentifier), - } versionCommand = &cli.Command{ Action: printVersion, Name: "version", @@ -44,20 +34,6 @@ var ( ArgsUsage: " ", Description: ` The output of this command is supposed to be machine-readable. -`, - } - versionCheckCommand = &cli.Command{ - Action: versionCheck, - Flags: []cli.Flag{ - VersionCheckUrlFlag, - VersionCheckVersionFlag, - }, - Name: "version-check", - Usage: "Checks (online) for known Geth security vulnerabilities", - ArgsUsage: "", - Description: ` -The version-check command fetches vulnerability-information from https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities.json, -and displays information about any security vulnerabilities that affect the currently executing version. `, } licenseCommand = &cli.Command{ diff --git a/cmd/geth/snapshot.go b/cmd/geth/snapshot.go index fc0658a59c8f..d168ee1d7dc0 100644 --- a/cmd/geth/snapshot.go +++ b/cmd/geth/snapshot.go @@ -18,15 +18,18 @@ package main import ( "bytes" + "encoding/hex" "encoding/json" "errors" "fmt" "os" "slices" + "sort" "time" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/state/pruner" @@ -36,6 +39,7 @@ import ( "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" + "github.com/ethereum/go-ethereum/triedb" "github.com/urfave/cli/v2" ) @@ -105,7 +109,9 @@ information about the specified address. Usage: "Traverse the state with given root hash and perform quick verification", ArgsUsage: "", Action: traverseState, - Flags: slices.Concat(utils.NetworkFlags, utils.DatabaseFlags), + Flags: slices.Concat([]cli.Flag{ + utils.AccountFlag, + }, utils.NetworkFlags, utils.DatabaseFlags), Description: ` geth snapshot traverse-state will traverse the whole state from the given state root and will abort if any @@ -113,6 +119,8 @@ referenced trie node or contract code is missing. This command can be used for state integrity verification. The default checking target is the HEAD state. It's also usable without snapshot enabled. + +If --account is specified, only the storage trie of that account is traversed. `, }, { @@ -120,7 +128,9 @@ It's also usable without snapshot enabled. Usage: "Traverse the state with given root hash and perform detailed verification", ArgsUsage: "", Action: traverseRawState, - Flags: slices.Concat(utils.NetworkFlags, utils.DatabaseFlags), + Flags: slices.Concat([]cli.Flag{ + utils.AccountFlag, + }, utils.NetworkFlags, utils.DatabaseFlags), Description: ` geth snapshot traverse-rawstate will traverse the whole state from the given root and will abort if any referenced @@ -129,6 +139,8 @@ verification. The default checking target is the HEAD state. It's basically iden to traverse-state, but the check granularity is smaller. It's also usable without snapshot enabled. + +If --account is specified, only the storage trie of that account is traversed. `, }, { @@ -159,6 +171,22 @@ block is used. Description: ` The export-preimages command exports hash preimages to a flat file, in exactly the expected order for the overlay tree migration. +`, + }, + { + Name: "list-eip-7610-accounts", + Aliases: []string{"eip7610"}, + Usage: "list EIP7610 eligible accounts", + Action: listEIP7610EligibleAccounts, + Flags: slices.Concat(utils.NetworkFlags, utils.DatabaseFlags), + Description: ` +geth snapshot list-eip-7610-accounts +traverses the post–EIP-161 state and returns all accounts that are eligible +under EIP-7610: accounts with zero nonce, empty runtime code, and non-empty +storage. The traversal will be aborted immediately if the state is prior to +EIP-161. + +The exported accounts are identified by their address. `, }, }, @@ -272,6 +300,120 @@ func checkDanglingStorage(ctx *cli.Context) error { return snapshot.CheckDanglingStorage(db) } +// parseAccount parses the account flag value as either an address (20 bytes) +// or an account hash (32 bytes) and returns the hashed account key. +func parseAccount(input string) (common.Hash, error) { + switch len(input) { + case 40, 42: // address + return crypto.Keccak256Hash(common.HexToAddress(input).Bytes()), nil + case 64, 66: // hash + return common.HexToHash(input), nil + default: + return common.Hash{}, errors.New("malformed account address or hash") + } +} + +// lookupAccount resolves the account from the state trie using the given +// account hash. +func lookupAccount(accountHash common.Hash, tr *trie.Trie) (*types.StateAccount, error) { + accData, err := tr.Get(accountHash.Bytes()) + if err != nil { + return nil, fmt.Errorf("failed to get account %s: %w", accountHash, err) + } + if accData == nil { + return nil, fmt.Errorf("account not found: %s", accountHash) + } + var acc types.StateAccount + if err := rlp.DecodeBytes(accData, &acc); err != nil { + return nil, fmt.Errorf("invalid account data %s: %w", accountHash, err) + } + return &acc, nil +} + +func traverseStorage(id *trie.ID, db *triedb.Database, report bool, detail bool) error { + tr, err := trie.NewStateTrie(id, db) + if err != nil { + log.Error("Failed to open storage trie", "account", id.Owner, "root", id.Root, "err", err) + return err + } + var ( + slots int + nodes int + lastReport time.Time + start = time.Now() + ) + it, err := tr.NodeIterator(nil) + if err != nil { + log.Error("Failed to open storage iterator", "account", id.Owner, "root", id.Root, "err", err) + return err + } + logger := log.Debug + if report { + logger = log.Info + } + logger("Start traversing storage trie", "account", id.Owner, "storageRoot", id.Root) + + if !detail { + iter := trie.NewIterator(it) + for iter.Next() { + slots += 1 + if time.Since(lastReport) > time.Second*8 { + logger("Traversing storage", "account", id.Owner, "slots", slots, "elapsed", common.PrettyDuration(time.Since(start))) + lastReport = time.Now() + } + } + if iter.Err != nil { + log.Error("Failed to traverse storage trie", "root", id.Root, "err", iter.Err) + return iter.Err + } + logger("Storage is complete", "account", id.Owner, "slots", slots, "elapsed", common.PrettyDuration(time.Since(start))) + } else { + reader, err := db.NodeReader(id.StateRoot) + if err != nil { + log.Error("Failed to open state reader", "err", err) + return err + } + var ( + buffer = make([]byte, 32) + hasher = crypto.NewKeccakState() + ) + for it.Next(true) { + nodes += 1 + node := it.Hash() + + // Check the presence for non-empty hash node(embedded node doesn't + // have their own hash). + if node != (common.Hash{}) { + blob, _ := reader.Node(id.Owner, it.Path(), node) + if len(blob) == 0 { + log.Error("Missing trie node(storage)", "hash", node) + return errors.New("missing storage") + } + hasher.Reset() + hasher.Write(blob) + hasher.Read(buffer) + if !bytes.Equal(buffer, node.Bytes()) { + log.Error("Invalid trie node(storage)", "hash", node.Hex(), "value", blob) + return errors.New("invalid storage node") + } + } + if it.Leaf() { + slots += 1 + } + if time.Since(lastReport) > time.Second*8 { + logger("Traversing storage", "account", id.Owner, "nodes", nodes, "slots", slots, "elapsed", common.PrettyDuration(time.Since(start))) + lastReport = time.Now() + } + } + if err := it.Error(); err != nil { + log.Error("Failed to traverse storage trie", "root", id.Root, "err", err) + return err + } + logger("Storage is complete", "account", id.Owner, "nodes", nodes, "slots", slots, "elapsed", common.PrettyDuration(time.Since(start))) + } + return nil +} + // traverseState is a helper function used for pruning verification. // Basically it just iterates the trie, ensure all nodes and associated // contract codes are present. @@ -309,6 +451,30 @@ func traverseState(ctx *cli.Context) error { root = headBlock.Root() log.Info("Start traversing the state", "root", root, "number", headBlock.NumberU64()) } + // If --account is specified, only traverse the storage trie of that account. + if accountStr := ctx.String(utils.AccountFlag.Name); accountStr != "" { + accountHash, err := parseAccount(accountStr) + if err != nil { + log.Error("Failed to parse account", "err", err) + return err + } + // Use raw trie since the account key is already hashed. + t, err := trie.New(trie.StateTrieID(root), triedb) + if err != nil { + log.Error("Failed to open state trie", "root", root, "err", err) + return err + } + acc, err := lookupAccount(accountHash, t) + if err != nil { + log.Error("Failed to look up account", "hash", accountHash, "err", err) + return err + } + if acc.Root == types.EmptyRootHash { + log.Info("Account has no storage", "hash", accountHash) + return nil + } + return traverseStorage(trie.StorageTrieID(root, accountHash, acc.Root), triedb, true, false) + } t, err := trie.NewStateTrie(trie.StateTrieID(root), triedb) if err != nil { log.Error("Failed to open trie", "root", root, "err", err) @@ -335,30 +501,10 @@ func traverseState(ctx *cli.Context) error { return err } if acc.Root != types.EmptyRootHash { - id := trie.StorageTrieID(root, common.BytesToHash(accIter.Key), acc.Root) - storageTrie, err := trie.NewStateTrie(id, triedb) + err := traverseStorage(trie.StorageTrieID(root, common.BytesToHash(accIter.Key), acc.Root), triedb, false, false) if err != nil { - log.Error("Failed to open storage trie", "root", acc.Root, "err", err) return err } - storageIt, err := storageTrie.NodeIterator(nil) - if err != nil { - log.Error("Failed to open storage iterator", "root", acc.Root, "err", err) - return err - } - storageIter := trie.NewIterator(storageIt) - for storageIter.Next() { - slots += 1 - - if time.Since(lastReport) > time.Second*8 { - log.Info("Traversing state", "accounts", accounts, "slots", slots, "codes", codes, "elapsed", common.PrettyDuration(time.Since(start))) - lastReport = time.Now() - } - } - if storageIter.Err != nil { - log.Error("Failed to traverse storage trie", "root", acc.Root, "err", storageIter.Err) - return storageIter.Err - } } if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) { if !rawdb.HasCode(chaindb, common.BytesToHash(acc.CodeHash)) { @@ -418,6 +564,30 @@ func traverseRawState(ctx *cli.Context) error { root = headBlock.Root() log.Info("Start traversing the state", "root", root, "number", headBlock.NumberU64()) } + // If --account is specified, only traverse the storage trie of that account. + if accountStr := ctx.String(utils.AccountFlag.Name); accountStr != "" { + accountHash, err := parseAccount(accountStr) + if err != nil { + log.Error("Failed to parse account", "err", err) + return err + } + // Use raw trie since the account key is already hashed. + t, err := trie.New(trie.StateTrieID(root), triedb) + if err != nil { + log.Error("Failed to open state trie", "root", root, "err", err) + return err + } + acc, err := lookupAccount(accountHash, t) + if err != nil { + log.Error("Failed to look up account", "hash", accountHash, "err", err) + return err + } + if acc.Root == types.EmptyRootHash { + log.Info("Account has no storage", "hash", accountHash) + return nil + } + return traverseStorage(trie.StorageTrieID(root, accountHash, acc.Root), triedb, true, true) + } t, err := trie.NewStateTrie(trie.StateTrieID(root), triedb) if err != nil { log.Error("Failed to open trie", "root", root, "err", err) @@ -473,50 +643,10 @@ func traverseRawState(ctx *cli.Context) error { return errors.New("invalid account") } if acc.Root != types.EmptyRootHash { - id := trie.StorageTrieID(root, common.BytesToHash(accIter.LeafKey()), acc.Root) - storageTrie, err := trie.NewStateTrie(id, triedb) + err := traverseStorage(trie.StorageTrieID(root, common.BytesToHash(accIter.LeafKey()), acc.Root), triedb, false, true) if err != nil { - log.Error("Failed to open storage trie", "root", acc.Root, "err", err) - return errors.New("missing storage trie") - } - storageIter, err := storageTrie.NodeIterator(nil) - if err != nil { - log.Error("Failed to open storage iterator", "root", acc.Root, "err", err) return err } - for storageIter.Next(true) { - nodes += 1 - node := storageIter.Hash() - - // Check the presence for non-empty hash node(embedded node doesn't - // have their own hash). - if node != (common.Hash{}) { - blob, _ := reader.Node(common.BytesToHash(accIter.LeafKey()), storageIter.Path(), node) - if len(blob) == 0 { - log.Error("Missing trie node(storage)", "hash", node) - return errors.New("missing storage") - } - hasher.Reset() - hasher.Write(blob) - hasher.Read(got) - if !bytes.Equal(got, node.Bytes()) { - log.Error("Invalid trie node(storage)", "hash", node.Hex(), "value", blob) - return errors.New("invalid storage node") - } - } - // Bump the counter if it's leaf node. - if storageIter.Leaf() { - slots += 1 - } - if time.Since(lastReport) > time.Second*8 { - log.Info("Traversing state", "nodes", nodes, "accounts", accounts, "slots", slots, "codes", codes, "elapsed", common.PrettyDuration(time.Since(start))) - lastReport = time.Now() - } - } - if storageIter.Error() != nil { - log.Error("Failed to traverse storage trie", "root", acc.Root, "err", storageIter.Error()) - return storageIter.Error() - } } if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) { if !rawdb.HasCode(chaindb, common.BytesToHash(acc.CodeHash)) { @@ -690,3 +820,92 @@ func checkAccount(ctx *cli.Context) error { log.Info("Checked the snapshot journalled storage", "time", common.PrettyDuration(time.Since(start))) return nil } + +// listEIP7610EligibleAccounts traverses the post–EIP-161 state and returns all +// accounts that are eligible under EIP-7610: accounts with zero nonce, empty +// runtime code, and non-empty storage. +// +// Such accounts could only have been created before EIP-161, since after that +// all newly created contracts are initialized with a nonce of one. +// +// This helper should be generally applicable to all networks, including the +// Ethereum mainnet. For most networks where EIP-161 was enabled from genesis, +// the resulting set is expected to be empty. Otherwise, network operators are +// responsible for generating the eligible account set themselves. +// +// Notably, the exported accounts are identified by their address. +func listEIP7610EligibleAccounts(ctx *cli.Context) error { + stack, _ := makeConfigNode(ctx) + defer stack.Close() + + chaindb := utils.MakeChainDatabase(ctx, stack, true) + defer chaindb.Close() + + headBlock := rawdb.ReadHeadBlock(chaindb) + if headBlock == nil { + log.Error("Failed to load head block") + return nil + } + config, _, err := core.LoadChainConfig(chaindb, utils.MakeGenesis(ctx)) + if err != nil { + log.Error("Failed to load chain config", "err", err) + return err + } + if !config.IsEIP158(headBlock.Number()) { + log.Info("Local head is prior to EIP-161", "head", headBlock.Number(), "eip-161", *config.EIP158Block) + return nil + } + triedb := utils.MakeTrieDatabase(ctx, stack, chaindb, false, true, false) + defer triedb.Close() + + if triedb.Scheme() != rawdb.PathScheme { + log.Error("Hash scheme is not supported") + return nil + } + iter, err := triedb.AccountIterator(headBlock.Root(), common.Hash{}) + if err != nil { + log.Error("Failed to get account iterator", "err", err) + return err + } + var ( + start = time.Now() + accounts []common.Address + ) + for iter.Next() { + blob := iter.Account() + if blob == nil { + log.Error("Failed to get account blob") + return nil + } + var account types.SlimAccount + if err := rlp.DecodeBytes(blob, &account); err != nil { + log.Error("Failed to decode", "err", err) + return err + } + // EIP-7610 account eligibility: + // - account.nonce == 0 + // - account.runtime_code == empty + // - account.storage != empty + if len(account.CodeHash) == 0 && account.Nonce == 0 && len(account.Root) != 0 { + preimage := rawdb.ReadPreimage(chaindb, iter.Hash()) + if preimage == nil { + log.Error("Failed to read preimage", "hash", iter.Hash().Hex()) + return nil + } + accounts = append(accounts, common.BytesToAddress(preimage)) + } + } + if len(accounts) == 0 { + log.Info("Traversed state", "eligible", len(accounts), "elapsed", common.PrettyDuration(time.Since(start))) + } else { + sort.Slice(accounts, func(i, j int) bool { + return accounts[i].Cmp(accounts[j]) < 0 + }) + buf := make([]byte, len(accounts)*common.AddressLength) + for i, h := range accounts { + copy(buf[i*common.AddressLength:], h[:]) + } + log.Info("Traversed state", "eligible", len(accounts), "elapsed", common.PrettyDuration(time.Since(start)), "output", hex.EncodeToString(buf)) + } + return nil +} diff --git a/cmd/geth/testdata/vcheck/data.json b/cmd/geth/testdata/vcheck/data.json deleted file mode 100644 index e52fd84e670e..000000000000 --- a/cmd/geth/testdata/vcheck/data.json +++ /dev/null @@ -1,202 +0,0 @@ -[ - { - "name": "CorruptedDAG", - "uid": "GETH-2020-01", - "summary": "Mining nodes will generate erroneous PoW on epochs > `385`.", - "description": "A mining flaw could cause miners to erroneously calculate PoW, due to an index overflow, if DAG size is exceeding the maximum 32 bit unsigned value.\n\nThis occurred on the ETC chain on 2020-11-06. This is likely to trigger for ETH mainnet around block `11550000`/epoch `385`, slated to occur early January 2021.\n\nThis issue is relevant only for miners, non-mining nodes are unaffected, since non-mining nodes use a smaller verification cache instead of a full DAG.", - "links": [ - "https://github.com/ethereum/go-ethereum/pull/21793", - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://github.com/ethereum/go-ethereum/commit/567d41d9363706b4b13ce0903804e8acf214af49", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-v592-xf75-856p" - ], - "introduced": "v1.6.0", - "fixed": "v1.9.24", - "published": "2020-11-12", - "severity": "Medium", - "CVE": "CVE-2020-26240", - "check": "Geth\\/v1\\.(6|7|8)\\..*|Geth\\/v1\\.9\\.\\d-.*|Geth\\/v1\\.9\\.1.*|Geth\\/v1\\.9\\.2(0|1|2|3)-.*" - }, - { - "name": "Denial of service due to Go CVE-2020-28362", - "uid": "GETH-2020-02", - "summary": "A denial-of-service issue can be used to crash Geth nodes during block processing, due to an underlying bug in Go (CVE-2020-28362) versions < `1.15.5`, or `<1.14.12`", - "description": "The DoS issue can be used to crash all Geth nodes during block processing, the effects of which would be that a major part of the Ethereum network went offline.\n\nOutside of Go-Ethereum, the issue is most likely relevant for all forks of Geth (such as TurboGeth or ETC’s core-geth) which is built with versions of Go which contains the vulnerability.", - "links": [ - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://groups.google.com/g/golang-announce/c/NpBGTTmKzpM", - "https://github.com/golang/go/issues/42552", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-m6gx-rhvj-fh52" - ], - "introduced": "v0.0.0", - "fixed": "v1.9.24", - "published": "2020-11-12", - "severity": "Critical", - "CVE": "CVE-2020-28362", - "check": "Geth.*\\/go1\\.(11(.*)|12(.*)|13(.*)|14|14\\.(\\d|10|11|)|15|15\\.[0-4])$" - }, - { - "name": "ShallowCopy", - "uid": "GETH-2020-03", - "summary": "A consensus flaw in Geth, related to `datacopy` precompile", - "description": "Geth erroneously performed a 'shallow' copy when the precompiled `datacopy` (at `0x00...04`) was invoked. An attacker could deploy a contract that uses the shallow copy to corrupt the contents of the `RETURNDATA`, thus causing a consensus failure.", - "links": [ - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-69v6-xc2j-r2jf" - ], - "introduced": "v1.9.7", - "fixed": "v1.9.17", - "published": "2020-11-12", - "severity": "Critical", - "CVE": "CVE-2020-26241", - "check": "Geth\\/v1\\.9\\.(7|8|9|10|11|12|13|14|15|16).*$" - }, - { - "name": "Geth DoS via MULMOD", - "uid": "GETH-2020-04", - "summary": "A denial-of-service issue can be used to crash Geth nodes during block processing", - "description": "Affected versions suffer from a vulnerability which can be exploited through the `MULMOD` operation, by specifying a modulo of `0`: `mulmod(a,b,0)`, causing a `panic` in the underlying library. \nThe crash was in the `uint256` library, where a buffer [underflowed](https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L442).\n\n\tif `d == 0`, `dLen` remains `0`\n\nand https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L451 will try to access index `[-1]`.\n\nThe `uint256` library was first merged in this [commit](https://github.com/ethereum/go-ethereum/commit/cf6674539c589f80031f3371a71c6a80addbe454), on 2020-06-08. \nExploiting this vulnerabilty would cause all vulnerable nodes to drop off the network. \n\nThe issue was brought to our attention through a [bug report](https://github.com/ethereum/go-ethereum/issues/21367), showing a `panic` occurring on sync from genesis on the Ropsten network.\n \nIt was estimated that the least obvious way to fix this would be to merge the fix into `uint256`, make a new release of that library and then update the geth-dependency.\n", - "links": [ - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-jm5c-rv3w-w83m", - "https://github.com/holiman/uint256/releases/tag/v1.1.1", - "https://github.com/holiman/uint256/pull/80", - "https://github.com/ethereum/go-ethereum/pull/21368" - ], - "introduced": "v1.9.16", - "fixed": "v1.9.18", - "published": "2020-11-12", - "severity": "Critical", - "CVE": "CVE-2020-26242", - "check": "Geth\\/v1\\.9.(16|17).*$" - }, - { - "name": "LES Server DoS via GetProofsV2", - "uid": "GETH-2020-05", - "summary": "A DoS vulnerability can make a LES server crash.", - "description": "A DoS vulnerability can make a LES server crash via malicious GetProofsV2 request from a connected LES client.\n\nThe vulnerability was patched in #21896.\n\nThis vulnerability only concern users explicitly running geth as a light server", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-r33q-22hv-j29q", - "https://github.com/ethereum/go-ethereum/pull/21896" - ], - "introduced": "v1.8.0", - "fixed": "v1.9.25", - "published": "2020-12-10", - "severity": "Medium", - "CVE": "CVE-2020-26264", - "check": "(Geth\\/v1\\.8\\.*)|(Geth\\/v1\\.9\\.\\d-.*)|(Geth\\/v1\\.9\\.1\\d-.*)|(Geth\\/v1\\.9\\.(20|21|22|23|24)-.*)$" - }, - { - "name": "SELFDESTRUCT-recreate consensus flaw", - "uid": "GETH-2020-06", - "introduced": "v1.9.4", - "fixed": "v1.9.20", - "summary": "A consensus-vulnerability in Geth could cause a chain split, where vulnerable versions refuse to accept the canonical chain.", - "description": "A flaw was repoted at 2020-08-11 by John Youngseok Yang (Software Platform Lab), where a particular sequence of transactions could cause a consensus failure.\n\n- Tx 1:\n - `sender` invokes `caller`.\n - `caller` invokes `0xaa`. `0xaa` has 3 wei, does a self-destruct-to-self\n - `caller` does a `1 wei` -call to `0xaa`, who thereby has 1 wei (the code in `0xaa` still executed, since the tx is still ongoing, but doesn't redo the selfdestruct, it takes a different path if callvalue is non-zero)\n\n-Tx 2:\n - `sender` does a 5-wei call to 0xaa. No exec (since no code). \n\nIn geth, the result would be that `0xaa` had `6 wei`, whereas OE reported (correctly) `5` wei. Furthermore, in geth, if the second tx was not executed, the `0xaa` would be destructed, resulting in `0 wei`. Thus obviously wrong. \n\nIt was determined that the root cause was this [commit](https://github.com/ethereum/go-ethereum/commit/223b950944f494a5b4e0957fd9f92c48b09037ad) from [this PR](https://github.com/ethereum/go-ethereum/pull/19953). The semantics of `createObject` was subtly changd, into returning a non-nil object (with `deleted=true`) where it previously did not if the account had been destructed. This return value caused the new object to inherit the old `balance`.\n", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-xw37-57qp-9mm4" - ], - "published": "2020-12-10", - "severity": "High", - "CVE": "CVE-2020-26265", - "check": "(Geth\\/v1\\.9\\.(4|5|6|7|8|9)-.*)|(Geth\\/v1\\.9\\.1\\d-.*)$" - }, - { - "name": "Not ready for London upgrade", - "uid": "GETH-2021-01", - "summary": "The client is not ready for the 'London' technical upgrade, and will deviate from the canonical chain when the London upgrade occurs (at block '12965000' around August 4, 2021.", - "description": "At (or around) August 4, Ethereum will undergo a technical upgrade called 'London'. Clients not upgraded will fail to progress on the canonical chain.", - "links": [ - "https://github.com/ethereum/eth1.0-specs/blob/master/network-upgrades/mainnet-upgrades/london.md", - "https://notes.ethereum.org/@timbeiko/ropsten-postmortem" - ], - "introduced": "v1.10.1", - "fixed": "v1.10.6", - "published": "2021-07-22", - "severity": "High", - "check": "(Geth\\/v1\\.10\\.(1|2|3|4|5)-.*)$" - }, - { - "name": "RETURNDATA corruption via datacopy", - "uid": "GETH-2021-02", - "summary": "A consensus-flaw in the Geth EVM could cause a node to deviate from the canonical chain.", - "description": "A memory-corruption bug within the EVM can cause a consensus error, where vulnerable nodes obtain a different `stateRoot` when processing a maliciously crafted transaction. This, in turn, would lead to the chain being split: mainnet splitting in two forks.\n\nAll Geth versions supporting the London hard fork are vulnerable (the bug is older than London), so all users should update.\n\nThis bug was exploited on Mainnet at block 13107518.\n\nCredits for the discovery go to @guidovranken (working for Sentnl during an audit of the Telos EVM) and reported via bounty@ethereum.org.", - "links": [ - "https://github.com/ethereum/go-ethereum/blob/master/docs/postmortems/2021-08-22-split-postmortem.md", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-9856-9gg9-qcmq", - "https://github.com/ethereum/go-ethereum/releases/tag/v1.10.8" - ], - "introduced": "v1.10.0", - "fixed": "v1.10.8", - "published": "2021-08-24", - "severity": "High", - "CVE": "CVE-2021-39137", - "check": "(Geth\\/v1\\.10\\.(0|1|2|3|4|5|6|7)-.*)$" - }, - { - "name": "DoS via malicious `snap/1` request", - "uid": "GETH-2021-03", - "summary": "A vulnerable node is susceptible to crash when processing a maliciously crafted message from a peer, via the snap/1 protocol. The crash can be triggered by sending a malicious snap/1 GetTrieNodes package.", - "description": "The `snap/1` protocol handler contains two vulnerabilities related to the `GetTrieNodes` packet, which can be exploited to crash the node. Full details are available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-59hh-656j-3p7v)", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-59hh-656j-3p7v", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities", - "https://github.com/ethereum/go-ethereum/pull/23657" - ], - "introduced": "v1.10.0", - "fixed": "v1.10.9", - "published": "2021-10-24", - "severity": "Medium", - "CVE": "CVE-2021-41173", - "check": "(Geth\\/v1\\.10\\.(0|1|2|3|4|5|6|7|8)-.*)$" - }, - { - "name": "DoS via malicious p2p message", - "uid": "GETH-2022-01", - "summary": "A vulnerable node can crash via p2p messages sent from an attacker node, if running with non-default log options.", - "description": "A vulnerable node, if configured to use high verbosity logging, can be made to crash when handling specially crafted p2p messages sent from an attacker node. Full details are available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-wjxw-gh3m-7pm5)", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-wjxw-gh3m-7pm5", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities", - "https://github.com/ethereum/go-ethereum/pull/24507" - ], - "introduced": "v1.10.0", - "fixed": "v1.10.17", - "published": "2022-05-11", - "severity": "Low", - "CVE": "CVE-2022-29177", - "check": "(Geth\\/v1\\.10\\.(0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16)-.*)$" - }, - { - "name": "DoS via malicious p2p message", - "uid": "GETH-2023-01", - "summary": "A vulnerable node can be made to consume unbounded amounts of memory when handling specially crafted p2p messages sent from an attacker node.", - "description": "The p2p handler spawned a new goroutine to respond to ping requests. By flooding a node with ping requests, an unbounded number of goroutines can be created, leading to resource exhaustion and potentially crash due to OOM.", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-ppjg-v974-84cm", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities" - ], - "introduced": "v1.10.0", - "fixed": "v1.12.1", - "published": "2023-09-06", - "severity": "High", - "CVE": "CVE-2023-40591", - "check": "(Geth\\/v1\\.(10|11)\\..*)|(Geth\\/v1\\.12\\.0-.*)$" - }, - { - "name": "DoS via malicious p2p message", - "uid": "GETH-2024-01", - "summary": "A vulnerable node can be made to consume very large amounts of memory when handling specially crafted p2p messages sent from an attacker node.", - "description": "A vulnerable node can be made to consume very large amounts of memory when handling specially crafted p2p messages sent from an attacker node. Full details will be available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-4xc9-8hmq-j652)", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-4xc9-8hmq-j652", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities" - ], - "introduced": "v1.10.0", - "fixed": "v1.13.15", - "published": "2024-05-06", - "severity": "High", - "CVE": "CVE-2024-32972", - "check": "(Geth\\/v1\\.(10|11|12)\\..*)|(Geth\\/v1\\.13\\.\\d-.*)|(Geth\\/v1\\.13\\.1(0|1|2|3|4)-.*)$" - } -] diff --git a/cmd/geth/testdata/vcheck/minisig-sigs-new/data.json.minisig b/cmd/geth/testdata/vcheck/minisig-sigs-new/data.json.minisig deleted file mode 100644 index 987ffe92bb0a..000000000000 --- a/cmd/geth/testdata/vcheck/minisig-sigs-new/data.json.minisig +++ /dev/null @@ -1,4 +0,0 @@ -untrusted comment: signature from minisign secret key -RUQkliYstQBOKHklFEYCUjepz81dyUuDmIAxjAvXa+icjGuKcjtVfV06G7qfOMSpplS5EcntU12n+AnGNyuOM8zIctaIWcfG2w0= -trusted comment: timestamp:1752094689 file:data.json hashed -u2e4wo4HBTU6viQTSY/NVBHoWoPFJnnTvLZS0FYl3JdvSOYi6+qpbEsDhAIFqq/n8VmlS/fPqqf7vKCNiAgjAA== diff --git a/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.1 b/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.1 deleted file mode 100644 index 6b6aa900e3a8..000000000000 --- a/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.1 +++ /dev/null @@ -1,4 +0,0 @@ -untrusted comment: signature from minisign secret key -RWQkliYstQBOKNoyq2O98hPmeVJQ6ShQLM58+4n0gkY0y0trFMDAsHuN/l4IyHfh8dDQ1ry0+IuZVrf/i8M/P3YFzFfAymDYCQ0= -trusted comment: timestamp:1752094703 file:data.json -cNyq3ZGlqo785HtWODb9ejWqF0HhSeXuLGXzC7z1IhnDrBObWBJngYd3qBG1dQcYlHQ+bgB/On5mSyMFn4UoCQ== diff --git a/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.2 b/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.2 deleted file mode 100644 index 704437de3913..000000000000 --- a/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.2 +++ /dev/null @@ -1,4 +0,0 @@ -untrusted comment: Here's a comment -RWQkliYstQBOKNoyq2O98hPmeVJQ6ShQLM58+4n0gkY0y0trFMDAsHuN/l4IyHfh8dDQ1ry0+IuZVrf/i8M/P3YFzFfAymDYCQ0= -trusted comment: Here's a trusted comment -dL7lO8sqFFCOXJO/u8SgoDk2nlXGWPRDbOTJkChMbmtUp9PB7sG831basXkZ/0CQ/l/vG7AbPyMNEVZyJn5NCg== diff --git a/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.3 b/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.3 deleted file mode 100644 index 806cd0731692..000000000000 --- a/cmd/geth/testdata/vcheck/minisig-sigs/vulnerabilities.json.minisig.3 +++ /dev/null @@ -1,4 +0,0 @@ -untrusted comment: One more (untrusted™) comment -RWQkliYstQBOKNoyq2O98hPmeVJQ6ShQLM58+4n0gkY0y0trFMDAsHuN/l4IyHfh8dDQ1ry0+IuZVrf/i8M/P3YFzFfAymDYCQ0= -trusted comment: Here's a trusted comment -dL7lO8sqFFCOXJO/u8SgoDk2nlXGWPRDbOTJkChMbmtUp9PB7sG831basXkZ/0CQ/l/vG7AbPyMNEVZyJn5NCg== diff --git a/cmd/geth/testdata/vcheck/minisign.pub b/cmd/geth/testdata/vcheck/minisign.pub deleted file mode 100644 index 183dce5f6b5d..000000000000 --- a/cmd/geth/testdata/vcheck/minisign.pub +++ /dev/null @@ -1,2 +0,0 @@ -untrusted comment: minisign public key 284E00B52C269624 -RWQkliYstQBOKOdtClfgC3IypIPX6TAmoEi7beZ4gyR3wsaezvqOMWsp diff --git a/cmd/geth/testdata/vcheck/minisign.sec b/cmd/geth/testdata/vcheck/minisign.sec deleted file mode 100644 index 5c50715b2096..000000000000 --- a/cmd/geth/testdata/vcheck/minisign.sec +++ /dev/null @@ -1,2 +0,0 @@ -untrusted comment: minisign encrypted secret key -RWRTY0Iyz8kmPMKrqk6DCtlO9a33akKiaOQG1aLolqDxs52qvPoAAAACAAAAAAAAAEAAAAAArEiggdvyn6+WzTprirLtgiYQoU+ihz/HyGgjhuF+Pz2ddMduyCO+xjCHeq+vgVVW039fbsI8hW6LRGJZLBKV5/jdxCXAVVQE7qTQ6xpEdO0z8Z731/pV1hlspQXG2PNd16NMtwd9dWw= diff --git a/cmd/geth/testdata/vcheck/signify-sigs/data.json.sig b/cmd/geth/testdata/vcheck/signify-sigs/data.json.sig deleted file mode 100644 index d704af7709a9..000000000000 --- a/cmd/geth/testdata/vcheck/signify-sigs/data.json.sig +++ /dev/null @@ -1,2 +0,0 @@ -untrusted comment: verify with signifykey.pub -RWSKLNhZb0KdARbMcGN40hbHzKQYZDgDOFhEUT1YpzMnqre/mbKJ8td/HVlG03Am1YCszATiI0DbnljjTy4iNHYwqBfzrFUqUg0= diff --git a/cmd/geth/testdata/vcheck/signifykey.pub b/cmd/geth/testdata/vcheck/signifykey.pub deleted file mode 100644 index 328f973ab4dc..000000000000 --- a/cmd/geth/testdata/vcheck/signifykey.pub +++ /dev/null @@ -1,2 +0,0 @@ -untrusted comment: signify public key -RWSKLNhZb0KdATtRT7mZC/bybI3t3+Hv/O2i3ye04Dq9fnT9slpZ1a2/ diff --git a/cmd/geth/testdata/vcheck/signifykey.sec b/cmd/geth/testdata/vcheck/signifykey.sec deleted file mode 100644 index 3279a2e58b55..000000000000 --- a/cmd/geth/testdata/vcheck/signifykey.sec +++ /dev/null @@ -1,2 +0,0 @@ -untrusted comment: signify secret key -RWRCSwAAACpLQDLawSQCtI7eAVIvaiHzjTsTyJsfV5aKLNhZb0KdAWeICXJGa93/bHAcsY6jUh9I8RdEcDWEoGxmaXZC+IdVBPxDpkix9fBRGEUdKWHi3dOfqME0YRzErWI5AVg3cRw= diff --git a/cmd/geth/testdata/vcheck/vulnerabilities.json b/cmd/geth/testdata/vcheck/vulnerabilities.json deleted file mode 100644 index e52fd84e670e..000000000000 --- a/cmd/geth/testdata/vcheck/vulnerabilities.json +++ /dev/null @@ -1,202 +0,0 @@ -[ - { - "name": "CorruptedDAG", - "uid": "GETH-2020-01", - "summary": "Mining nodes will generate erroneous PoW on epochs > `385`.", - "description": "A mining flaw could cause miners to erroneously calculate PoW, due to an index overflow, if DAG size is exceeding the maximum 32 bit unsigned value.\n\nThis occurred on the ETC chain on 2020-11-06. This is likely to trigger for ETH mainnet around block `11550000`/epoch `385`, slated to occur early January 2021.\n\nThis issue is relevant only for miners, non-mining nodes are unaffected, since non-mining nodes use a smaller verification cache instead of a full DAG.", - "links": [ - "https://github.com/ethereum/go-ethereum/pull/21793", - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://github.com/ethereum/go-ethereum/commit/567d41d9363706b4b13ce0903804e8acf214af49", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-v592-xf75-856p" - ], - "introduced": "v1.6.0", - "fixed": "v1.9.24", - "published": "2020-11-12", - "severity": "Medium", - "CVE": "CVE-2020-26240", - "check": "Geth\\/v1\\.(6|7|8)\\..*|Geth\\/v1\\.9\\.\\d-.*|Geth\\/v1\\.9\\.1.*|Geth\\/v1\\.9\\.2(0|1|2|3)-.*" - }, - { - "name": "Denial of service due to Go CVE-2020-28362", - "uid": "GETH-2020-02", - "summary": "A denial-of-service issue can be used to crash Geth nodes during block processing, due to an underlying bug in Go (CVE-2020-28362) versions < `1.15.5`, or `<1.14.12`", - "description": "The DoS issue can be used to crash all Geth nodes during block processing, the effects of which would be that a major part of the Ethereum network went offline.\n\nOutside of Go-Ethereum, the issue is most likely relevant for all forks of Geth (such as TurboGeth or ETC’s core-geth) which is built with versions of Go which contains the vulnerability.", - "links": [ - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://groups.google.com/g/golang-announce/c/NpBGTTmKzpM", - "https://github.com/golang/go/issues/42552", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-m6gx-rhvj-fh52" - ], - "introduced": "v0.0.0", - "fixed": "v1.9.24", - "published": "2020-11-12", - "severity": "Critical", - "CVE": "CVE-2020-28362", - "check": "Geth.*\\/go1\\.(11(.*)|12(.*)|13(.*)|14|14\\.(\\d|10|11|)|15|15\\.[0-4])$" - }, - { - "name": "ShallowCopy", - "uid": "GETH-2020-03", - "summary": "A consensus flaw in Geth, related to `datacopy` precompile", - "description": "Geth erroneously performed a 'shallow' copy when the precompiled `datacopy` (at `0x00...04`) was invoked. An attacker could deploy a contract that uses the shallow copy to corrupt the contents of the `RETURNDATA`, thus causing a consensus failure.", - "links": [ - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-69v6-xc2j-r2jf" - ], - "introduced": "v1.9.7", - "fixed": "v1.9.17", - "published": "2020-11-12", - "severity": "Critical", - "CVE": "CVE-2020-26241", - "check": "Geth\\/v1\\.9\\.(7|8|9|10|11|12|13|14|15|16).*$" - }, - { - "name": "Geth DoS via MULMOD", - "uid": "GETH-2020-04", - "summary": "A denial-of-service issue can be used to crash Geth nodes during block processing", - "description": "Affected versions suffer from a vulnerability which can be exploited through the `MULMOD` operation, by specifying a modulo of `0`: `mulmod(a,b,0)`, causing a `panic` in the underlying library. \nThe crash was in the `uint256` library, where a buffer [underflowed](https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L442).\n\n\tif `d == 0`, `dLen` remains `0`\n\nand https://github.com/holiman/uint256/blob/4ce82e695c10ddad57215bdbeafb68b8c5df2c30/uint256.go#L451 will try to access index `[-1]`.\n\nThe `uint256` library was first merged in this [commit](https://github.com/ethereum/go-ethereum/commit/cf6674539c589f80031f3371a71c6a80addbe454), on 2020-06-08. \nExploiting this vulnerabilty would cause all vulnerable nodes to drop off the network. \n\nThe issue was brought to our attention through a [bug report](https://github.com/ethereum/go-ethereum/issues/21367), showing a `panic` occurring on sync from genesis on the Ropsten network.\n \nIt was estimated that the least obvious way to fix this would be to merge the fix into `uint256`, make a new release of that library and then update the geth-dependency.\n", - "links": [ - "https://blog.ethereum.org/2020/11/12/geth-security-release", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-jm5c-rv3w-w83m", - "https://github.com/holiman/uint256/releases/tag/v1.1.1", - "https://github.com/holiman/uint256/pull/80", - "https://github.com/ethereum/go-ethereum/pull/21368" - ], - "introduced": "v1.9.16", - "fixed": "v1.9.18", - "published": "2020-11-12", - "severity": "Critical", - "CVE": "CVE-2020-26242", - "check": "Geth\\/v1\\.9.(16|17).*$" - }, - { - "name": "LES Server DoS via GetProofsV2", - "uid": "GETH-2020-05", - "summary": "A DoS vulnerability can make a LES server crash.", - "description": "A DoS vulnerability can make a LES server crash via malicious GetProofsV2 request from a connected LES client.\n\nThe vulnerability was patched in #21896.\n\nThis vulnerability only concern users explicitly running geth as a light server", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-r33q-22hv-j29q", - "https://github.com/ethereum/go-ethereum/pull/21896" - ], - "introduced": "v1.8.0", - "fixed": "v1.9.25", - "published": "2020-12-10", - "severity": "Medium", - "CVE": "CVE-2020-26264", - "check": "(Geth\\/v1\\.8\\.*)|(Geth\\/v1\\.9\\.\\d-.*)|(Geth\\/v1\\.9\\.1\\d-.*)|(Geth\\/v1\\.9\\.(20|21|22|23|24)-.*)$" - }, - { - "name": "SELFDESTRUCT-recreate consensus flaw", - "uid": "GETH-2020-06", - "introduced": "v1.9.4", - "fixed": "v1.9.20", - "summary": "A consensus-vulnerability in Geth could cause a chain split, where vulnerable versions refuse to accept the canonical chain.", - "description": "A flaw was repoted at 2020-08-11 by John Youngseok Yang (Software Platform Lab), where a particular sequence of transactions could cause a consensus failure.\n\n- Tx 1:\n - `sender` invokes `caller`.\n - `caller` invokes `0xaa`. `0xaa` has 3 wei, does a self-destruct-to-self\n - `caller` does a `1 wei` -call to `0xaa`, who thereby has 1 wei (the code in `0xaa` still executed, since the tx is still ongoing, but doesn't redo the selfdestruct, it takes a different path if callvalue is non-zero)\n\n-Tx 2:\n - `sender` does a 5-wei call to 0xaa. No exec (since no code). \n\nIn geth, the result would be that `0xaa` had `6 wei`, whereas OE reported (correctly) `5` wei. Furthermore, in geth, if the second tx was not executed, the `0xaa` would be destructed, resulting in `0 wei`. Thus obviously wrong. \n\nIt was determined that the root cause was this [commit](https://github.com/ethereum/go-ethereum/commit/223b950944f494a5b4e0957fd9f92c48b09037ad) from [this PR](https://github.com/ethereum/go-ethereum/pull/19953). The semantics of `createObject` was subtly changd, into returning a non-nil object (with `deleted=true`) where it previously did not if the account had been destructed. This return value caused the new object to inherit the old `balance`.\n", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-xw37-57qp-9mm4" - ], - "published": "2020-12-10", - "severity": "High", - "CVE": "CVE-2020-26265", - "check": "(Geth\\/v1\\.9\\.(4|5|6|7|8|9)-.*)|(Geth\\/v1\\.9\\.1\\d-.*)$" - }, - { - "name": "Not ready for London upgrade", - "uid": "GETH-2021-01", - "summary": "The client is not ready for the 'London' technical upgrade, and will deviate from the canonical chain when the London upgrade occurs (at block '12965000' around August 4, 2021.", - "description": "At (or around) August 4, Ethereum will undergo a technical upgrade called 'London'. Clients not upgraded will fail to progress on the canonical chain.", - "links": [ - "https://github.com/ethereum/eth1.0-specs/blob/master/network-upgrades/mainnet-upgrades/london.md", - "https://notes.ethereum.org/@timbeiko/ropsten-postmortem" - ], - "introduced": "v1.10.1", - "fixed": "v1.10.6", - "published": "2021-07-22", - "severity": "High", - "check": "(Geth\\/v1\\.10\\.(1|2|3|4|5)-.*)$" - }, - { - "name": "RETURNDATA corruption via datacopy", - "uid": "GETH-2021-02", - "summary": "A consensus-flaw in the Geth EVM could cause a node to deviate from the canonical chain.", - "description": "A memory-corruption bug within the EVM can cause a consensus error, where vulnerable nodes obtain a different `stateRoot` when processing a maliciously crafted transaction. This, in turn, would lead to the chain being split: mainnet splitting in two forks.\n\nAll Geth versions supporting the London hard fork are vulnerable (the bug is older than London), so all users should update.\n\nThis bug was exploited on Mainnet at block 13107518.\n\nCredits for the discovery go to @guidovranken (working for Sentnl during an audit of the Telos EVM) and reported via bounty@ethereum.org.", - "links": [ - "https://github.com/ethereum/go-ethereum/blob/master/docs/postmortems/2021-08-22-split-postmortem.md", - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-9856-9gg9-qcmq", - "https://github.com/ethereum/go-ethereum/releases/tag/v1.10.8" - ], - "introduced": "v1.10.0", - "fixed": "v1.10.8", - "published": "2021-08-24", - "severity": "High", - "CVE": "CVE-2021-39137", - "check": "(Geth\\/v1\\.10\\.(0|1|2|3|4|5|6|7)-.*)$" - }, - { - "name": "DoS via malicious `snap/1` request", - "uid": "GETH-2021-03", - "summary": "A vulnerable node is susceptible to crash when processing a maliciously crafted message from a peer, via the snap/1 protocol. The crash can be triggered by sending a malicious snap/1 GetTrieNodes package.", - "description": "The `snap/1` protocol handler contains two vulnerabilities related to the `GetTrieNodes` packet, which can be exploited to crash the node. Full details are available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-59hh-656j-3p7v)", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-59hh-656j-3p7v", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities", - "https://github.com/ethereum/go-ethereum/pull/23657" - ], - "introduced": "v1.10.0", - "fixed": "v1.10.9", - "published": "2021-10-24", - "severity": "Medium", - "CVE": "CVE-2021-41173", - "check": "(Geth\\/v1\\.10\\.(0|1|2|3|4|5|6|7|8)-.*)$" - }, - { - "name": "DoS via malicious p2p message", - "uid": "GETH-2022-01", - "summary": "A vulnerable node can crash via p2p messages sent from an attacker node, if running with non-default log options.", - "description": "A vulnerable node, if configured to use high verbosity logging, can be made to crash when handling specially crafted p2p messages sent from an attacker node. Full details are available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-wjxw-gh3m-7pm5)", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-wjxw-gh3m-7pm5", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities", - "https://github.com/ethereum/go-ethereum/pull/24507" - ], - "introduced": "v1.10.0", - "fixed": "v1.10.17", - "published": "2022-05-11", - "severity": "Low", - "CVE": "CVE-2022-29177", - "check": "(Geth\\/v1\\.10\\.(0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16)-.*)$" - }, - { - "name": "DoS via malicious p2p message", - "uid": "GETH-2023-01", - "summary": "A vulnerable node can be made to consume unbounded amounts of memory when handling specially crafted p2p messages sent from an attacker node.", - "description": "The p2p handler spawned a new goroutine to respond to ping requests. By flooding a node with ping requests, an unbounded number of goroutines can be created, leading to resource exhaustion and potentially crash due to OOM.", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-ppjg-v974-84cm", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities" - ], - "introduced": "v1.10.0", - "fixed": "v1.12.1", - "published": "2023-09-06", - "severity": "High", - "CVE": "CVE-2023-40591", - "check": "(Geth\\/v1\\.(10|11)\\..*)|(Geth\\/v1\\.12\\.0-.*)$" - }, - { - "name": "DoS via malicious p2p message", - "uid": "GETH-2024-01", - "summary": "A vulnerable node can be made to consume very large amounts of memory when handling specially crafted p2p messages sent from an attacker node.", - "description": "A vulnerable node can be made to consume very large amounts of memory when handling specially crafted p2p messages sent from an attacker node. Full details will be available at the Github security [advisory](https://github.com/ethereum/go-ethereum/security/advisories/GHSA-4xc9-8hmq-j652)", - "links": [ - "https://github.com/ethereum/go-ethereum/security/advisories/GHSA-4xc9-8hmq-j652", - "https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities" - ], - "introduced": "v1.10.0", - "fixed": "v1.13.15", - "published": "2024-05-06", - "severity": "High", - "CVE": "CVE-2024-32972", - "check": "(Geth\\/v1\\.(10|11|12)\\..*)|(Geth\\/v1\\.13\\.\\d-.*)|(Geth\\/v1\\.13\\.1(0|1|2|3|4)-.*)$" - } -] diff --git a/cmd/geth/verkle.go b/cmd/geth/verkle.go deleted file mode 100644 index c064d70ababc..000000000000 --- a/cmd/geth/verkle.go +++ /dev/null @@ -1,214 +0,0 @@ -// Copyright 2022 The go-ethereum Authors -// This file is part of go-ethereum. -// -// go-ethereum is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// go-ethereum is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with go-ethereum. If not, see . - -package main - -import ( - "bytes" - "encoding/hex" - "errors" - "fmt" - "os" - "slices" - - "github.com/ethereum/go-ethereum/cmd/utils" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/rawdb" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-verkle" - "github.com/urfave/cli/v2" -) - -var ( - zero [32]byte - - verkleCommand = &cli.Command{ - Name: "verkle", - Usage: "A set of experimental verkle tree management commands", - Description: "", - Subcommands: []*cli.Command{ - { - Name: "verify", - Usage: "verify the conversion of a MPT into a verkle tree", - ArgsUsage: "", - Action: verifyVerkle, - Flags: slices.Concat(utils.NetworkFlags, utils.DatabaseFlags), - Description: ` -geth verkle verify -This command takes a root commitment and attempts to rebuild the tree. - `, - }, - { - Name: "dump", - Usage: "Dump a verkle tree to a DOT file", - ArgsUsage: " [ ...]", - Action: expandVerkle, - Flags: slices.Concat(utils.NetworkFlags, utils.DatabaseFlags), - Description: ` -geth verkle dump [ ...] -This command will produce a dot file representing the tree, rooted at . -in which key1, key2, ... are expanded. - `, - }, - }, - } -) - -// recurse into each child to ensure they can be loaded from the db. The tree isn't rebuilt -// (only its nodes are loaded) so there is no need to flush them, the garbage collector should -// take care of that for us. -func checkChildren(root verkle.VerkleNode, resolver verkle.NodeResolverFn) error { - switch node := root.(type) { - case *verkle.InternalNode: - for i, child := range node.Children() { - childC := child.Commit().Bytes() - - if bytes.Equal(childC[:], zero[:]) { - continue - } - childS, err := resolver(childC[:]) - if err != nil { - return fmt.Errorf("could not find child %x in db: %w", childC, err) - } - // depth is set to 0, the tree isn't rebuilt so it's not a problem - childN, err := verkle.ParseNode(childS, 0) - if err != nil { - return fmt.Errorf("decode error child %x in db: %w", child.Commitment().Bytes(), err) - } - if err := checkChildren(childN, resolver); err != nil { - return fmt.Errorf("%x%w", i, err) // write the path to the erroring node - } - } - case *verkle.LeafNode: - // sanity check: ensure at least one value is non-zero - - for i := 0; i < verkle.NodeWidth; i++ { - if len(node.Value(i)) != 0 { - return nil - } - } - return errors.New("both balance and nonce are 0") - case verkle.Empty: - // nothing to do - default: - return fmt.Errorf("unsupported type encountered %v", root) - } - - return nil -} - -func verifyVerkle(ctx *cli.Context) error { - stack, _ := makeConfigNode(ctx) - defer stack.Close() - - chaindb := utils.MakeChainDatabase(ctx, stack, true) - defer chaindb.Close() - headBlock := rawdb.ReadHeadBlock(chaindb) - if headBlock == nil { - log.Error("Failed to load head block") - return errors.New("no head block") - } - if ctx.NArg() > 1 { - log.Error("Too many arguments given") - return errors.New("too many arguments") - } - var ( - rootC common.Hash - err error - ) - if ctx.NArg() == 1 { - rootC, err = parseRoot(ctx.Args().First()) - if err != nil { - log.Error("Failed to resolve state root", "error", err) - return err - } - log.Info("Rebuilding the tree", "root", rootC) - } else { - rootC = headBlock.Root() - log.Info("Rebuilding the tree", "root", rootC, "number", headBlock.NumberU64()) - } - - serializedRoot, err := chaindb.Get(rootC[:]) - if err != nil { - return err - } - root, err := verkle.ParseNode(serializedRoot, 0) - if err != nil { - return err - } - - if err := checkChildren(root, chaindb.Get); err != nil { - log.Error("Could not rebuild the tree from the database", "err", err) - return err - } - - log.Info("Tree was rebuilt from the database") - return nil -} - -func expandVerkle(ctx *cli.Context) error { - stack, _ := makeConfigNode(ctx) - defer stack.Close() - - chaindb := utils.MakeChainDatabase(ctx, stack, true) - defer chaindb.Close() - var ( - rootC common.Hash - keylist [][]byte - err error - ) - if ctx.NArg() >= 2 { - rootC, err = parseRoot(ctx.Args().First()) - if err != nil { - log.Error("Failed to resolve state root", "error", err) - return err - } - keylist = make([][]byte, 0, ctx.Args().Len()-1) - args := ctx.Args().Slice() - for i := range args[1:] { - key, err := hex.DecodeString(args[i+1]) - log.Info("decoded key", "arg", args[i+1], "key", key) - if err != nil { - return fmt.Errorf("error decoding key #%d: %w", i+1, err) - } - keylist = append(keylist, key) - } - log.Info("Rebuilding the tree", "root", rootC) - } else { - return fmt.Errorf("usage: %s root key1 [key 2...]", ctx.App.Name) - } - - serializedRoot, err := chaindb.Get(rootC[:]) - if err != nil { - return err - } - root, err := verkle.ParseNode(serializedRoot, 0) - if err != nil { - return err - } - - for i, key := range keylist { - log.Info("Reading key", "index", i, "key", key) - root.Get(key, chaindb.Get) - } - - if err := os.WriteFile("dump.dot", []byte(verkle.ToDot(root)), 0600); err != nil { - log.Error("Failed to dump file", "err", err) - } else { - log.Info("Tree was dumped to file", "file", "dump.dot") - } - return nil -} diff --git a/cmd/geth/version_check.go b/cmd/geth/version_check.go deleted file mode 100644 index 237556788eb9..000000000000 --- a/cmd/geth/version_check.go +++ /dev/null @@ -1,170 +0,0 @@ -// Copyright 2020 The go-ethereum Authors -// This file is part of go-ethereum. -// -// go-ethereum is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// go-ethereum is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with go-ethereum. If not, see . - -package main - -import ( - "encoding/json" - "errors" - "fmt" - "io" - "net/http" - "os" - "regexp" - "strings" - - "github.com/ethereum/go-ethereum/log" - "github.com/jedisct1/go-minisign" - "github.com/urfave/cli/v2" -) - -var gethPubKeys []string = []string{ - //@holiman, minisign public key FB1D084D39BAEC24 - "RWQk7Lo5TQgd+wxBNZM+Zoy+7UhhMHaWKzqoes9tvSbFLJYZhNTbrIjx", - //minisign public key 138B1CA303E51687 - "RWSHFuUDoxyLEzjszuWZI1xStS66QTyXFFZG18uDfO26CuCsbckX1e9J", - //minisign public key FD9813B2D2098484 - "RWSEhAnSshOY/b+GmaiDkObbCWefsAoavjoLcPjBo1xn71yuOH5I+Lts", -} - -type vulnJson struct { - Name string - Uid string - Summary string - Description string - Links []string - Introduced string - Fixed string - Published string - Severity string - Check string - CVE string -} - -func versionCheck(ctx *cli.Context) error { - url := ctx.String(VersionCheckUrlFlag.Name) - version := ctx.String(VersionCheckVersionFlag.Name) - log.Info("Checking vulnerabilities", "version", version, "url", url) - return checkCurrent(url, version) -} - -func checkCurrent(url, current string) error { - var ( - data []byte - sig []byte - err error - ) - if data, err = fetch(url); err != nil { - return fmt.Errorf("could not retrieve data: %w", err) - } - if sig, err = fetch(fmt.Sprintf("%v.minisig", url)); err != nil { - return fmt.Errorf("could not retrieve signature: %w", err) - } - if err = verifySignature(gethPubKeys, data, sig); err != nil { - return err - } - var vulns []vulnJson - if err = json.Unmarshal(data, &vulns); err != nil { - return err - } - allOk := true - for _, vuln := range vulns { - r, err := regexp.Compile(vuln.Check) - if err != nil { - return err - } - if r.MatchString(current) { - allOk = false - fmt.Printf("## Vulnerable to %v (%v)\n\n", vuln.Uid, vuln.Name) - fmt.Printf("Severity: %v\n", vuln.Severity) - fmt.Printf("Summary : %v\n", vuln.Summary) - fmt.Printf("Fixed in: %v\n", vuln.Fixed) - if len(vuln.CVE) > 0 { - fmt.Printf("CVE: %v\n", vuln.CVE) - } - if len(vuln.Links) > 0 { - fmt.Printf("References:\n") - for _, ref := range vuln.Links { - fmt.Printf("\t- %v\n", ref) - } - } - fmt.Println() - } - } - if allOk { - fmt.Println("No vulnerabilities found") - } - return nil -} - -// fetch makes an HTTP request to the given url and returns the response body -func fetch(url string) ([]byte, error) { - if filep := strings.TrimPrefix(url, "file://"); filep != url { - return os.ReadFile(filep) - } - res, err := http.Get(url) - if err != nil { - return nil, err - } - defer res.Body.Close() - body, err := io.ReadAll(res.Body) - if err != nil { - return nil, err - } - return body, nil -} - -// verifySignature checks that the sigData is a valid signature of the given -// data, for pubkey GethPubkey -func verifySignature(pubkeys []string, data, sigdata []byte) error { - sig, err := minisign.DecodeSignature(string(sigdata)) - if err != nil { - return err - } - // find the used key - var key *minisign.PublicKey - for _, pubkey := range pubkeys { - pub, err := minisign.NewPublicKey(pubkey) - if err != nil { - // our pubkeys should be parseable - return err - } - if pub.KeyId != sig.KeyId { - continue - } - key = &pub - break - } - if key == nil { - log.Info("Signing key not trusted", "keyid", keyID(sig.KeyId), "error", err) - return errors.New("signature could not be verified") - } - if ok, err := key.Verify(data, sig); !ok || err != nil { - log.Info("Verification failed error", "keyid", keyID(key.KeyId), "error", err) - return errors.New("signature could not be verified") - } - return nil -} - -// keyID turns a binary minisign key ID into a hex string. -// Note: key IDs are printed in reverse byte order. -func keyID(id [8]byte) string { - var rev [8]byte - for i := range id { - rev[len(rev)-1-i] = id[i] - } - return fmt.Sprintf("%X", rev) -} diff --git a/cmd/geth/version_check_test.go b/cmd/geth/version_check_test.go deleted file mode 100644 index fb5d1b2d69c6..000000000000 --- a/cmd/geth/version_check_test.go +++ /dev/null @@ -1,189 +0,0 @@ -// Copyright 2020 The go-ethereum Authors -// This file is part of go-ethereum. -// -// go-ethereum is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// go-ethereum is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with go-ethereum. If not, see . - -package main - -import ( - "encoding/json" - "fmt" - "os" - "path/filepath" - "regexp" - "strconv" - "strings" - "testing" - - "github.com/jedisct1/go-minisign" -) - -func TestVerification(t *testing.T) { - t.Parallel() - // Signatures generated with `minisign`. Legacy format, not pre-hashed file. - t.Run("minisig-legacy", func(t *testing.T) { - t.Parallel() - // For this test, the pubkey is in testdata/vcheck/minisign.pub - // (the privkey is `minisign.sec`, if we want to expand this test. Password 'test' ) - // 1. `minisign -S -l -s ./minisign.sec -m data.json -x ./minisig-sigs/vulnerabilities.json.minisig.1 -c "signature from minisign secret key"` - // 2. `minisign -S -l -s ./minisign.sec -m vulnerabilities.json -x ./minisig-sigs/vulnerabilities.json.minisig.2 -c "Here's a comment" -t "Here's a trusted comment"` - // 3. minisign -S -l -s ./minisign.sec -m vulnerabilities.json -x ./minisig-sigs/vulnerabilities.json.minisig.3 -c "One more (untrusted™) comment" -t "Here's a trusted comment" - pub := "RWQkliYstQBOKOdtClfgC3IypIPX6TAmoEi7beZ4gyR3wsaezvqOMWsp" - testVerification(t, pub, "./testdata/vcheck/minisig-sigs/") - }) - t.Run("minisig-new", func(t *testing.T) { - t.Parallel() - // For this test, the pubkey is in testdata/vcheck/minisign.pub - // (the privkey is `minisign.sec`, if we want to expand this test. Password 'test' ) - // `minisign -S -s ./minisign.sec -m data.json -x ./minisig-sigs-new/data.json.minisig` - pub := "RWQkliYstQBOKOdtClfgC3IypIPX6TAmoEi7beZ4gyR3wsaezvqOMWsp" - testVerification(t, pub, "./testdata/vcheck/minisig-sigs-new/") - }) - // Signatures generated with `signify-openbsd` - t.Run("signify-openbsd", func(t *testing.T) { - t.Parallel() - t.Skip("This currently fails, minisign expects 4 lines of data, signify provides only 2") - // For this test, the pubkey is in testdata/vcheck/signifykey.pub - // (the privkey is `signifykey.sec`, if we want to expand this test. Password 'test' ) - // `signify -S -s signifykey.sec -m data.json -x ./signify-sigs/data.json.sig` - pub := "RWSKLNhZb0KdATtRT7mZC/bybI3t3+Hv/O2i3ye04Dq9fnT9slpZ1a2/" - testVerification(t, pub, "./testdata/vcheck/signify-sigs/") - }) -} - -func testVerification(t *testing.T, pubkey, sigdir string) { - // Data to verify - data, err := os.ReadFile("./testdata/vcheck/data.json") - if err != nil { - t.Fatal(err) - } - // Signatures, with and without comments, both trusted and untrusted - files, err := os.ReadDir(sigdir) - if err != nil { - t.Fatal(err) - } - if len(files) == 0 { - t.Fatal("Missing tests") - } - for _, f := range files { - sig, err := os.ReadFile(filepath.Join(sigdir, f.Name())) - if err != nil { - t.Fatal(err) - } - err = verifySignature([]string{pubkey}, data, sig) - if err != nil { - t.Fatal(err) - } - } -} - -func versionUint(v string) int { - mustInt := func(s string) int { - a, err := strconv.Atoi(s) - if err != nil { - panic(v) - } - return a - } - components := strings.Split(strings.TrimPrefix(v, "v"), ".") - a := mustInt(components[0]) - b := mustInt(components[1]) - c := mustInt(components[2]) - return a*100*100 + b*100 + c -} - -// TestMatching can be used to check that the regexps are correct -func TestMatching(t *testing.T) { - t.Parallel() - data, _ := os.ReadFile("./testdata/vcheck/vulnerabilities.json") - var vulns []vulnJson - if err := json.Unmarshal(data, &vulns); err != nil { - t.Fatal(err) - } - check := func(version string) { - vFull := fmt.Sprintf("Geth/%v-unstable-15339cf1-20201204/linux-amd64/go1.15.4", version) - for _, vuln := range vulns { - r, err := regexp.Compile(vuln.Check) - vulnIntro := versionUint(vuln.Introduced) - vulnFixed := versionUint(vuln.Fixed) - current := versionUint(version) - if err != nil { - t.Fatal(err) - } - if vuln.Name == "Denial of service due to Go CVE-2020-28362" { - // this one is not tied to geth-versions - continue - } - if vulnIntro <= current && vulnFixed > current { - // Should be vulnerable - if !r.MatchString(vFull) { - t.Errorf("Should be vulnerable, version %v, intro: %v, fixed: %v %v %v", - version, vuln.Introduced, vuln.Fixed, vuln.Name, vuln.Check) - } - } else { - if r.MatchString(vFull) { - t.Errorf("Should not be flagged vulnerable, version %v, intro: %v, fixed: %v %v %d %d %d", - version, vuln.Introduced, vuln.Fixed, vuln.Name, vulnIntro, current, vulnFixed) - } - } - } - } - for major := 1; major < 2; major++ { - for minor := 0; minor < 30; minor++ { - for patch := 0; patch < 30; patch++ { - vShort := fmt.Sprintf("v%d.%d.%d", major, minor, patch) - check(vShort) - } - } - } -} - -func TestGethPubKeysParseable(t *testing.T) { - t.Parallel() - for _, pubkey := range gethPubKeys { - _, err := minisign.NewPublicKey(pubkey) - if err != nil { - t.Errorf("Should be parseable") - } - } -} - -func TestKeyID(t *testing.T) { - t.Parallel() - type args struct { - id [8]byte - } - tests := []struct { - name string - args args - want string - }{ - {"@holiman key", args{id: extractKeyId(gethPubKeys[0])}, "FB1D084D39BAEC24"}, - {"second key", args{id: extractKeyId(gethPubKeys[1])}, "138B1CA303E51687"}, - {"third key", args{id: extractKeyId(gethPubKeys[2])}, "FD9813B2D2098484"}, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - t.Parallel() - if got := keyID(tt.args.id); got != tt.want { - t.Errorf("keyID() = %v, want %v", got, tt.want) - } - }) - } -} - -func extractKeyId(pubkey string) [8]byte { - p, _ := minisign.NewPublicKey(pubkey) - return p.KeyId -} diff --git a/cmd/keeper/getpayload_example.go b/cmd/keeper/getpayload_example.go index 683cc7924829..8f40a7bd11ea 100644 --- a/cmd/keeper/getpayload_example.go +++ b/cmd/keeper/getpayload_example.go @@ -15,6 +15,7 @@ // along with the go-ethereum library. If not, see . //go:build example +// +build example package main diff --git a/cmd/keeper/getpayload_wasm.go b/cmd/keeper/getpayload_wasm.go new file mode 100644 index 000000000000..5024ac7d490f --- /dev/null +++ b/cmd/keeper/getpayload_wasm.go @@ -0,0 +1,36 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +//go:build wasm && !womir +// +build wasm,!womir + +package main + +import ( + "unsafe" +) + +//go:wasmimport geth_io len +func hintLen() uint32 + +//go:wasmimport geth_io read +func hintRead(data unsafe.Pointer) + +func getInput() []byte { + data := make([]byte, hintLen()) + hintRead(unsafe.Pointer(&data[0])) + return data +} diff --git a/cmd/keeper/getpayload_womir.go b/cmd/keeper/getpayload_womir.go new file mode 100644 index 000000000000..8645dc7c265c --- /dev/null +++ b/cmd/keeper/getpayload_womir.go @@ -0,0 +1,49 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +//go:build womir + +package main + +import "unsafe" + +// These match the WOMIR guest-io imports (env module). +// Protocol: __hint_input prepares next item, __hint_buffer reads words. +// Each item has format: [byte_len_u32_le, ...data_words_padded_to_4bytes] +// +//go:wasmimport env __hint_input +func hintInput() + +//go:wasmimport env __hint_buffer +func hintBuffer(ptr unsafe.Pointer, numWords uint32) +func readWord() uint32 { + var buf [4]byte + hintBuffer(unsafe.Pointer(&buf[0]), 1) + return uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24 +} +func readBytes() []byte { + hintInput() + byteLen := readWord() + numWords := (byteLen + 3) / 4 + data := make([]byte, numWords*4) + hintBuffer(unsafe.Pointer(&data[0]), numWords) + return data[:byteLen] +} + +// getInput reads the RLP-encoded Payload from the WOMIR hint stream. +func getInput() []byte { + return readBytes() +} diff --git a/cmd/keeper/go.mod b/cmd/keeper/go.mod index 8402382a9b20..2d99cb22322e 100644 --- a/cmd/keeper/go.mod +++ b/cmd/keeper/go.mod @@ -13,15 +13,15 @@ require ( github.com/bits-and-blooms/bitset v1.20.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/consensys/gnark-crypto v0.18.1 // indirect - github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect - github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a // indirect + github.com/crate-crypto/go-eth-kzg v1.5.0 // indirect github.com/deckarep/golang-set/v2 v2.6.0 // indirect github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect github.com/emicklei/dot v1.6.2 // indirect - github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect + github.com/ethereum/c-kzg-4844/v2 v2.1.6 // indirect github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab // indirect - github.com/ethereum/go-verkle v0.2.2 // indirect github.com/ferranbt/fastssz v0.1.4 // indirect + github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/stdr v1.2.2 // indirect github.com/go-ole/go-ole v1.3.0 // indirect github.com/gofrs/flock v0.12.1 // indirect github.com/golang/snappy v1.0.0 // indirect @@ -31,12 +31,16 @@ require ( github.com/minio/sha256-simd v1.0.0 // indirect github.com/mitchellh/mapstructure v1.4.1 // indirect github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect - github.com/supranational/blst v0.3.16-0.20250831170142-f48500c1fdbe // indirect + github.com/supranational/blst v0.3.16 // indirect github.com/tklauser/go-sysconf v0.3.12 // indirect github.com/tklauser/numcpus v0.6.1 // indirect - golang.org/x/crypto v0.36.0 // indirect - golang.org/x/sync v0.12.0 // indirect - golang.org/x/sys v0.36.0 // indirect + go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.opentelemetry.io/otel v1.40.0 // indirect + go.opentelemetry.io/otel/metric v1.40.0 // indirect + go.opentelemetry.io/otel/trace v1.40.0 // indirect + golang.org/x/crypto v0.47.0 // indirect + golang.org/x/sync v0.19.0 // indirect + golang.org/x/sys v0.40.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/cmd/keeper/go.sum b/cmd/keeper/go.sum index 4f4c0dbba087..09c8e55822b5 100644 --- a/cmd/keeper/go.sum +++ b/cmd/keeper/go.sum @@ -28,10 +28,8 @@ github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAK github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= github.com/consensys/gnark-crypto v0.18.1 h1:RyLV6UhPRoYYzaFnPQA4qK3DyuDgkTgskDdoGqFt3fI= github.com/consensys/gnark-crypto v0.18.1/go.mod h1:L3mXGFTe1ZN+RSJ+CLjUt9x7PNdx8ubaYfDROyp2Z8c= -github.com/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg= -github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= -github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg= -github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM= +github.com/crate-crypto/go-eth-kzg v1.5.0 h1:FYRiJMJG2iv+2Dy3fi14SVGjcPteZ5HAAUe4YWlJygc= +github.com/crate-crypto/go-eth-kzg v1.5.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= @@ -42,16 +40,19 @@ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A= github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= -github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s= -github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs= +github.com/ethereum/c-kzg-4844/v2 v2.1.6 h1:xQymkKCT5E2Jiaoqf3v4wsNgjZLY0lRSkZn27fRjSls= +github.com/ethereum/c-kzg-4844/v2 v2.1.6/go.mod h1:8HMkUZ5JRv4hpw/XUrYWSQNAUzhHMg2UDb/U+5m+XNw= github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab h1:rvv6MJhy07IMfEKuARQ9TKojGqLVNxQajaXEp/BoqSk= github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab/go.mod h1:IuLm4IsPipXKF7CW5Lzf68PIbZ5yl7FFd74l/E0o9A8= -github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8= -github.com/ethereum/go-verkle v0.2.2/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= github.com/ferranbt/fastssz v0.1.4 h1:OCDB+dYDEQDvAgtAGnTSidK1Pe2tW3nFV40XyMkTeDY= github.com/ferranbt/fastssz v0.1.4/go.mod h1:Ea3+oeoRGGLGm5shYAeDgu6PGUlcvQhE2fILyD9+tGg= github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= @@ -63,12 +64,16 @@ github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs= github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= -github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4= -github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU= +github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= @@ -100,34 +105,44 @@ github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJf github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= github.com/prysmaticlabs/gohashtree v0.0.4-beta h1:H/EbCuXPeTV3lpKeXGPpEV9gsUpkqOOVnWapUyeWro4= github.com/prysmaticlabs/gohashtree v0.0.4-beta/go.mod h1:BFdtALS+Ffhg3lGQIHv9HDWuHS8cTvHZzrHWxwOtGOs= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/supranational/blst v0.3.16-0.20250831170142-f48500c1fdbe h1:nbdqkIGOGfUAD54q1s2YBcBz/WcsxCO9HUQ4aGV5hUw= -github.com/supranational/blst v0.3.16-0.20250831170142-f48500c1fdbe/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/supranational/blst v0.3.16 h1:bTDadT+3fK497EvLdWRQEjiGnUtzJ7jjIUMF0jqwYhE= +github.com/supranational/blst v0.3.16/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= -golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= -golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/otel v1.40.0 h1:oA5YeOcpRTXq6NN7frwmwFR0Cn3RhTVZvXsP4duvCms= +go.opentelemetry.io/otel v1.40.0/go.mod h1:IMb+uXZUKkMXdPddhwAHm6UfOwJyh4ct1ybIlV14J0g= +go.opentelemetry.io/otel/metric v1.40.0 h1:rcZe317KPftE2rstWIBitCdVp89A2HqjkxR3c11+p9g= +go.opentelemetry.io/otel/metric v1.40.0/go.mod h1:ib/crwQH7N3r5kfiBZQbwrTge743UDc7DTFVZrrXnqc= +go.opentelemetry.io/otel/sdk v1.40.0 h1:KHW/jUzgo6wsPh9At46+h4upjtccTmuZCFAc9OJ71f8= +go.opentelemetry.io/otel/sdk v1.40.0/go.mod h1:Ph7EFdYvxq72Y8Li9q8KebuYUr2KoeyHx0DRMKrYBUE= +go.opentelemetry.io/otel/trace v1.40.0 h1:WA4etStDttCSYuhwvEa8OP8I5EWu24lkOzp+ZYblVjw= +go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTqQ5RgdEJcawiA= +golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8= +golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A= golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df h1:UA2aFVmmsIlefxMk29Dp2juaUSth8Pyn3Tq5Y5mJGME= golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= -golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k= -golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= -golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ= +golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE= +golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8= +google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= +google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/cmd/keeper/main.go b/cmd/keeper/main.go index 9b459f6f36df..df6881acbfa7 100644 --- a/cmd/keeper/main.go +++ b/cmd/keeper/main.go @@ -17,6 +17,7 @@ package main import ( + "context" "fmt" "os" "runtime/debug" @@ -52,7 +53,7 @@ func main() { } vmConfig := vm.Config{} - crossStateRoot, crossReceiptRoot, err := core.ExecuteStateless(chainConfig, vmConfig, payload.Block, payload.Witness) + crossStateRoot, crossReceiptRoot, err := core.ExecuteStateless(context.Background(), chainConfig, vmConfig, payload.Block, payload.Witness) if err != nil { fmt.Fprintf(os.Stderr, "stateless self-validation failed: %v\n", err) os.Exit(10) diff --git a/cmd/keeper/stubs.go b/cmd/keeper/stubs.go index 04a3bc735bde..de7ee64353ed 100644 --- a/cmd/keeper/stubs.go +++ b/cmd/keeper/stubs.go @@ -14,7 +14,8 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -//go:build !example && !ziren +//go:build !example && !ziren && !wasm && !womir +// +build !example,!ziren,!wasm,!womir package main diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 3e337a3d00a3..e490f613b38a 100644 --- a/cmd/utils/cmd.go +++ b/cmd/utils/cmd.go @@ -57,6 +57,8 @@ const ( importBatchSize = 2500 ) +type EraFileFormat int + // ErrImportInterrupted is returned when the user interrupts the import process. var ErrImportInterrupted = errors.New("interrupted") @@ -250,7 +252,7 @@ func readList(filename string) ([]string, error) { // ImportHistory imports Era1 files containing historical block information, // starting from genesis. The assumption is held that the provided chain // segment in Era1 file should all be canonical and verified. -func ImportHistory(chain *core.BlockChain, dir string, network string) error { +func ImportHistory(chain *core.BlockChain, dir string, network string, from func(f era.ReadAtSeekCloser) (era.Era, error)) error { if chain.CurrentSnapBlock().Number.BitLen() != 0 { return errors.New("history import only supported when starting from genesis") } @@ -263,8 +265,10 @@ func ImportHistory(chain *core.BlockChain, dir string, network string) error { return fmt.Errorf("unable to read checksums.txt: %w", err) } if len(checksums) != len(entries) { - return fmt.Errorf("expected equal number of checksums and entries, have: %d checksums, %d entries", len(checksums), len(entries)) + return fmt.Errorf("expected equal number of checksums and entries, have: %d checksums, %d entries", + len(checksums), len(entries)) } + var ( start = time.Now() reported = time.Now() @@ -272,33 +276,64 @@ func ImportHistory(chain *core.BlockChain, dir string, network string) error { h = sha256.New() buf = bytes.NewBuffer(nil) ) - for i, filename := range entries { + + for i, file := range entries { err := func() error { - f, err := os.Open(filepath.Join(dir, filename)) + path := filepath.Join(dir, file) + + // Validate against checksum file in directory. + f, err := os.Open(path) if err != nil { - return fmt.Errorf("unable to open era: %w", err) + return fmt.Errorf("open %s: %w", path, err) } defer f.Close() - // Validate checksum. if _, err := io.Copy(h, f); err != nil { - return fmt.Errorf("unable to recalculate checksum: %w", err) - } - if have, want := common.BytesToHash(h.Sum(buf.Bytes()[:])).Hex(), checksums[i]; have != want { - return fmt.Errorf("checksum mismatch: have %s, want %s", have, want) + return fmt.Errorf("checksum %s: %w", path, err) } + got := common.BytesToHash(h.Sum(buf.Bytes()[:])).Hex() h.Reset() buf.Reset() - + if got != checksums[i] { + return fmt.Errorf("%s checksum mismatch: have %s want %s", file, got, checksums[i]) + } // Import all block data from Era1. - e, err := era.From(f) + e, err := from(f) if err != nil { return fmt.Errorf("error opening era: %w", err) } - it, err := era.NewIterator(e) + defer e.Close() + + it, err := e.Iterator() if err != nil { - return fmt.Errorf("error making era reader: %w", err) + return fmt.Errorf("error creating iterator: %w", err) } + + var ( + blocks = make([]*types.Block, 0, importBatchSize) + receiptsList = make([]types.Receipts, 0, importBatchSize) + flush = func() error { + if len(blocks) == 0 { + return nil + } + enc := types.EncodeBlockReceiptLists(receiptsList) + if _, err := chain.InsertReceiptChain(blocks, enc, math.MaxUint64); err != nil { + return fmt.Errorf("error inserting blocks %d-%d: %w", + blocks[0].NumberU64(), blocks[len(blocks)-1].NumberU64(), err) + } + imported += len(blocks) + if time.Since(reported) >= 8*time.Second { + head := blocks[len(blocks)-1].NumberU64() + log.Info("Importing Era files", "head", head, "imported", imported, + "elapsed", common.PrettyDuration(time.Since(start))) + imported = 0 + reported = time.Now() + } + blocks = blocks[:0] + receiptsList = receiptsList[:0] + return nil + } + ) for it.Next() { block, err := it.Block() if err != nil { @@ -311,26 +346,23 @@ func ImportHistory(chain *core.BlockChain, dir string, network string) error { if err != nil { return fmt.Errorf("error reading receipts %d: %w", it.Number(), err) } - encReceipts := types.EncodeBlockReceiptLists([]types.Receipts{receipts}) - if _, err := chain.InsertReceiptChain([]*types.Block{block}, encReceipts, math.MaxUint64); err != nil { - return fmt.Errorf("error inserting body %d: %w", it.Number(), err) - } - imported += 1 - - // Give the user some feedback that something is happening. - if time.Since(reported) >= 8*time.Second { - log.Info("Importing Era files", "head", it.Number(), "imported", imported, "elapsed", common.PrettyDuration(time.Since(start))) - imported = 0 - reported = time.Now() + blocks = append(blocks, block) + receiptsList = append(receiptsList, receipts) + if len(blocks) == importBatchSize { + if err := flush(); err != nil { + return err + } } } - return nil + if err := it.Error(); err != nil { + return err + } + return flush() }() if err != nil { return err } } - return nil } @@ -389,7 +421,6 @@ func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, las return err } defer fh.Close() - var writer io.Writer = fh if strings.HasSuffix(fn, ".gz") { writer = gzip.NewWriter(writer) @@ -405,7 +436,7 @@ func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, las // ExportHistory exports blockchain history into the specified directory, // following the Era format. -func ExportHistory(bc *core.BlockChain, dir string, first, last, step uint64) error { +func ExportHistory(bc *core.BlockChain, dir string, first, last uint64, newBuilder func(io.Writer) era.Builder, filename func(network string, epoch int, lastBlockHash common.Hash) string) error { log.Info("Exporting blockchain history", "dir", dir) if head := bc.CurrentBlock().Number.Uint64(); head < last { log.Warn("Last block beyond head, setting last = head", "head", head, "last", last) @@ -418,76 +449,100 @@ func ExportHistory(bc *core.BlockChain, dir string, first, last, step uint64) er if err := os.MkdirAll(dir, os.ModePerm); err != nil { return fmt.Errorf("error creating output directory: %w", err) } + var ( start = time.Now() reported = time.Now() h = sha256.New() buf = bytes.NewBuffer(nil) + td = new(big.Int) checksums []string ) - td := new(big.Int) - for i := uint64(0); i < first; i++ { - td.Add(td, bc.GetHeaderByNumber(i).Difficulty) + + // Compute initial TD by accumulating difficulty from genesis to first-1. + // This is necessary because TD is no longer stored in the database. Only + // compute if a segment of the export is pre-merge. + b := bc.GetBlockByNumber(first) + if b == nil { + return fmt.Errorf("block #%d not found", first) + } + if first > 0 && b.Difficulty().Sign() != 0 { + log.Info("Computing initial total difficulty", "from", 0, "to", first-1) + for i := uint64(0); i < first; i++ { + b := bc.GetBlockByNumber(i) + if b == nil { + return fmt.Errorf("block #%d not found while computing initial TD", i) + } + td.Add(td, b.Difficulty()) + } + log.Info("Initial total difficulty computed", "td", td) } - for i := first; i <= last; i += step { - err := func() error { - filename := filepath.Join(dir, era.Filename(network, int(i/step), common.Hash{})) - f, err := os.Create(filename) + + for batch := first; batch <= last; batch += uint64(era.MaxSize) { + idx := int(batch / uint64(era.MaxSize)) + tmpPath := filepath.Join(dir, filename(network, idx, common.Hash{})) + + if err := func() error { + f, err := os.Create(tmpPath) if err != nil { - return fmt.Errorf("could not create era file: %w", err) + return err } defer f.Close() - w := era.NewBuilder(f) - for j := uint64(0); j < step && j <= last-i; j++ { - var ( - n = i + j - block = bc.GetBlockByNumber(n) - ) + builder := newBuilder(f) + + for j := uint64(0); j < uint64(era.MaxSize) && batch+j <= last; j++ { + n := batch + j + block := bc.GetBlockByNumber(n) if block == nil { - return fmt.Errorf("export failed on #%d: not found", n) + return fmt.Errorf("block #%d not found", n) } - receipts := bc.GetReceiptsByHash(block.Hash()) - if receipts == nil { - return fmt.Errorf("export failed on #%d: receipts not found", n) + receipt := bc.GetReceiptsByHash(block.Hash()) + if receipt == nil { + return fmt.Errorf("receipts for #%d missing", n) } - td.Add(td, block.Difficulty()) - if err := w.Add(block, receipts, new(big.Int).Set(td)); err != nil { + + // For pre-merge blocks, pass accumulated TD. + // For post-merge blocks (difficulty == 0), pass nil TD. + var blockTD *big.Int + if block.Difficulty().Sign() != 0 { + td.Add(td, block.Difficulty()) + blockTD = new(big.Int).Set(td) + } + + if err := builder.Add(block, receipt, blockTD); err != nil { return err } } - root, err := w.Finalize() + id, err := builder.Finalize() if err != nil { - return fmt.Errorf("export failed to finalize %d: %w", step/i, err) + return err } - // Set correct filename with root. - os.Rename(filename, filepath.Join(dir, era.Filename(network, int(i/step), root))) - - // Compute checksum of entire Era1. if _, err := f.Seek(0, io.SeekStart); err != nil { return err } + h.Reset() + buf.Reset() if _, err := io.Copy(h, f); err != nil { - return fmt.Errorf("unable to calculate checksum: %w", err) + return err } checksums = append(checksums, common.BytesToHash(h.Sum(buf.Bytes()[:])).Hex()) - h.Reset() - buf.Reset() - return nil - }() - if err != nil { + + // Close before rename. It's required on Windows. + f.Close() + final := filepath.Join(dir, filename(network, idx, id)) + return os.Rename(tmpPath, final) + }(); err != nil { return err } + if time.Since(reported) >= 8*time.Second { - log.Info("Exporting blocks", "exported", i, "elapsed", common.PrettyDuration(time.Since(start))) + log.Info("export progress", "exported", batch, "elapsed", common.PrettyDuration(time.Since(start))) reported = time.Now() } } - os.WriteFile(filepath.Join(dir, "checksums.txt"), []byte(strings.Join(checksums, "\n")), os.ModePerm) - - log.Info("Exported blockchain to", "dir", dir) - + _ = os.WriteFile(filepath.Join(dir, "checksums.txt"), []byte(strings.Join(checksums, "\n")), os.ModePerm) return nil } diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index b73fa80b1743..ef4392271be1 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -218,7 +218,15 @@ var ( Usage: "Max number of elements (0 = no limit)", Value: 0, } - + AccountFlag = &cli.StringFlag{ + Name: "account", + Usage: "Specifies the account address or hash to traverse a single storage trie", + } + OutputFileFlag = &cli.StringFlag{ + Name: "output", + Usage: "Writes the result in json to the output", + Value: "", + } SnapshotFlag = &cli.BoolFlag{ Name: "snapshot", Usage: `Enables snapshot-database mode (default = enable)`, @@ -256,9 +264,9 @@ var ( Usage: "Manually specify the bpo2 fork timestamp, overriding the bundled setting", Category: flags.EthCategory, } - OverrideVerkle = &cli.Uint64Flag{ - Name: "override.verkle", - Usage: "Manually specify the Verkle fork timestamp, overriding the bundled setting", + OverrideUBT = &cli.Uint64Flag{ + Name: "override.ubt", + Usage: "Manually specify the UBT fork timestamp, overriding the bundled setting", Category: flags.EthCategory, } OverrideGenesisFlag = &cli.StringFlag{ @@ -289,12 +297,36 @@ var ( Value: ethconfig.Defaults.EnableStateSizeTracking, Category: flags.StateCategory, } + BinTrieGroupDepthFlag = &cli.IntFlag{ + Name: "bintrie.groupdepth", + Usage: "Number of levels per serialized group in binary trie (1-8, default 5). Lower values create smaller groups with more nodes.", + Value: 5, + Category: flags.StateCategory, + } + StateSizeTrackingDepthFlag = &cli.Uint64Flag{ + Name: "state.size-tracking-depth", + Usage: "Number of recent block state sizes to track (default = 10000, 0 = disabled)", + Value: 10000, + Category: flags.StateCategory, + } StateHistoryFlag = &cli.Uint64Flag{ Name: "history.state", Usage: "Number of recent blocks to retain state history for, only relevant in state.scheme=path (default = 90,000 blocks, 0 = entire chain)", Value: ethconfig.Defaults.StateHistory, Category: flags.StateCategory, } + TrienodeHistoryFlag = &cli.Int64Flag{ + Name: "history.trienode", + Usage: "Number of recent blocks to retain trienode history for, only relevant in state.scheme=path (default/negative = disabled, 0 = entire chain)", + Value: ethconfig.Defaults.TrienodeHistory, + Category: flags.StateCategory, + } + TrienodeHistoryFullValueCheckpointFlag = &cli.UintFlag{ + Name: "history.trienode.full-value-checkpoint", + Usage: "The frequency of full-value encoding. Every n-th node is stored in full-value format; all other nodes are stored as diffs relative to their predecessor", + Value: uint(ethconfig.Defaults.NodeFullValueCheckpoint), + Category: flags.StateCategory, + } TransactionHistoryFlag = &cli.Uint64Flag{ Name: "history.transactions", Usage: "Number of recent blocks to maintain transactions index for (default = about one year, 0 = entire chain)", @@ -303,7 +335,7 @@ var ( } ChainHistoryFlag = &cli.StringFlag{ Name: "history.chain", - Usage: `Blockchain history retention ("all" or "postmerge")`, + Usage: `Blockchain history retention ("all", "postmerge", or "postprague")`, Value: ethconfig.Defaults.HistoryMode.String(), Category: flags.StateCategory, } @@ -468,8 +500,8 @@ var ( // Performance tuning settings CacheFlag = &cli.IntFlag{ Name: "cache", - Usage: "Megabytes of memory allocated to internal caching (default = 4096 mainnet full node, 128 light mode)", - Value: 1024, + Usage: "Megabytes of memory allocated to internal caching", + Value: 4096, Category: flags.PerfCategory, } CacheDatabaseFlag = &cli.IntFlag{ @@ -636,6 +668,12 @@ var ( Value: ethconfig.Defaults.TxSyncMaxTimeout, Category: flags.APICategory, } + RPCGlobalRangeLimitFlag = &cli.Uint64Flag{ + Name: "rpc.rangelimit", + Usage: "Maximum block range (end - begin) allowed for range queries (0 = unlimited)", + Value: ethconfig.Defaults.RangeLimit, + Category: flags.APICategory, + } // Authenticated RPC HTTP settings AuthListenFlag = &cli.StringFlag{ Name: "authrpc.addr", @@ -674,7 +712,7 @@ var ( } LogSlowBlockFlag = &cli.DurationFlag{ Name: "debug.logslowblock", - Usage: "Block execution time threshold beyond which detailed statistics will be logged (0 means disable)", + Usage: "Block execution time threshold beyond which detailed statistics will be logged (0 logs all blocks, negative means disable)", Value: ethconfig.Defaults.SlowBlockThreshold, Category: flags.LoggingCategory, } @@ -998,6 +1036,13 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server. Category: flags.MetricsCategory, } + MetricsInfluxDBIntervalFlag = &cli.DurationFlag{ + Name: "metrics.influxdb.interval", + Usage: "Interval between metrics reports to InfluxDB (with time unit, e.g. 10s)", + Value: metrics.DefaultConfig.InfluxDBInterval, + Category: flags.MetricsCategory, + } + MetricsEnableInfluxDBV2Flag = &cli.BoolFlag{ Name: "metrics.influxdbv2", Usage: "Enable metrics export/push to an external InfluxDB v2 database", @@ -1024,6 +1069,55 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server. Value: metrics.DefaultConfig.InfluxDBOrganization, Category: flags.MetricsCategory, } + + // RPC Telemetry + RPCTelemetryFlag = &cli.BoolFlag{ + Name: "rpc.telemetry", + Usage: "Enable RPC telemetry", + Category: flags.APICategory, + } + + RPCTelemetryEndpointFlag = &cli.StringFlag{ + Name: "rpc.telemetry.endpoint", + Usage: "Defines where RPC telemetry is sent (e.g., http://localhost:4318 or grpc://localhost:4317)", + Category: flags.APICategory, + } + + RPCTelemetryUserFlag = &cli.StringFlag{ + Name: "rpc.telemetry.username", + Usage: "Basic Auth username for OpenTelemetry", + Category: flags.APICategory, + } + + RPCTelemetryPasswordFlag = &cli.StringFlag{ + Name: "rpc.telemetry.password", + Usage: "Basic Auth password for OpenTelemetry", + Category: flags.APICategory, + } + + RPCTelemetryInstanceIDFlag = &cli.StringFlag{ + Name: "rpc.telemetry.instance-id", + Usage: "OpenTelemetry instance ID", + Category: flags.APICategory, + } + + RPCTelemetryTagsFlag = &cli.StringFlag{ + Name: "rpc.telemetry.tags", + Usage: "Comma-separated tags (key/values) added as attributes to the OpenTelemetry resource struct", + Category: flags.APICategory, + } + + RPCTelemetrySampleRatioFlag = &cli.Float64Flag{ + Name: "rpc.telemetry.sample-ratio", + Usage: "Defines the sampling ratio for RPC telemetry (0.0 to 1.0)", + Value: node.DefaultConfig.OpenTelemetry.SampleRatio, + Category: flags.APICategory, + } + // Era flags are a group of flags related to the era archive format. + EraFormatFlag = &cli.StringFlag{ + Name: "era.format", + Usage: "Archive format: 'era1' or 'erae'", + } ) var ( @@ -1414,6 +1508,7 @@ func SetNodeConfig(ctx *cli.Context, cfg *node.Config) { setNodeUserIdent(ctx, cfg) SetDataDir(ctx, cfg) setSmartCard(ctx, cfg) + setOpenTelemetry(ctx, cfg) if ctx.IsSet(JWTSecretFlag.Name) { cfg.JWTSecret = ctx.String(JWTSecretFlag.Name) @@ -1430,7 +1525,7 @@ func SetNodeConfig(ctx *cli.Context, cfg *node.Config) { cfg.KeyStoreDir = ctx.String(KeyStoreDirFlag.Name) } if ctx.IsSet(DeveloperFlag.Name) { - cfg.UseLightweightKDF = true + cfg.UseLightweightKDF = ctx.Bool(DeveloperFlag.Name) } if ctx.IsSet(LightKDFFlag.Name) { cfg.UseLightweightKDF = ctx.Bool(LightKDFFlag.Name) @@ -1481,6 +1576,35 @@ func setSmartCard(ctx *cli.Context, cfg *node.Config) { cfg.SmartCardDaemonPath = path } +func setOpenTelemetry(ctx *cli.Context, cfg *node.Config) { + tcfg := &cfg.OpenTelemetry + if ctx.IsSet(RPCTelemetryFlag.Name) { + tcfg.Enabled = ctx.Bool(RPCTelemetryFlag.Name) + } + if ctx.IsSet(RPCTelemetryEndpointFlag.Name) { + tcfg.Endpoint = ctx.String(RPCTelemetryEndpointFlag.Name) + } + if ctx.IsSet(RPCTelemetryUserFlag.Name) { + tcfg.AuthUser = ctx.String(RPCTelemetryUserFlag.Name) + } + if ctx.IsSet(RPCTelemetryPasswordFlag.Name) { + tcfg.AuthPassword = ctx.String(RPCTelemetryPasswordFlag.Name) + } + if ctx.IsSet(RPCTelemetryInstanceIDFlag.Name) { + tcfg.InstanceID = ctx.String(RPCTelemetryInstanceIDFlag.Name) + } + if ctx.IsSet(RPCTelemetryTagsFlag.Name) { + tcfg.Tags = ctx.String(RPCTelemetryTagsFlag.Name) + } + if ctx.IsSet(RPCTelemetrySampleRatioFlag.Name) { + tcfg.SampleRatio = ctx.Float64(RPCTelemetrySampleRatioFlag.Name) + } + + if tcfg.Endpoint != "" && !tcfg.Enabled { + log.Warn(fmt.Sprintf("OpenTelemetry endpoint configured but telemetry is not enabled, use --%s to enable.", RPCTelemetryFlag.Name)) + } +} + func SetDataDir(ctx *cli.Context, cfg *node.Config) { switch { case ctx.IsSet(DataDirFlag.Name): @@ -1699,6 +1823,15 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) { if ctx.IsSet(StateHistoryFlag.Name) { cfg.StateHistory = ctx.Uint64(StateHistoryFlag.Name) } + if ctx.IsSet(TrienodeHistoryFlag.Name) { + cfg.TrienodeHistory = ctx.Int64(TrienodeHistoryFlag.Name) + } + if ctx.IsSet(TrienodeHistoryFullValueCheckpointFlag.Name) { + cfg.NodeFullValueCheckpoint = uint32(ctx.Uint(TrienodeHistoryFullValueCheckpointFlag.Name)) + } + if ctx.IsSet(BinTrieGroupDepthFlag.Name) { + cfg.BinTrieGroupDepth = ctx.Int(BinTrieGroupDepthFlag.Name) + } if ctx.IsSet(StateSchemeFlag.Name) { cfg.StateScheme = ctx.String(StateSchemeFlag.Name) } @@ -1753,6 +1886,9 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) { if ctx.IsSet(RPCTxSyncMaxTimeoutFlag.Name) { cfg.TxSyncMaxTimeout = ctx.Duration(RPCTxSyncMaxTimeoutFlag.Name) } + if ctx.IsSet(RPCGlobalRangeLimitFlag.Name) { + cfg.RangeLimit = ctx.Uint64(RPCGlobalRangeLimitFlag.Name) + } if !ctx.Bool(SnapshotFlag.Name) || cfg.SnapshotCache == 0 { // If snap-sync is requested, this flag is also required if cfg.SyncMode == ethconfig.SnapSync { @@ -1778,7 +1914,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) { cfg.StatelessSelfValidation = ctx.Bool(VMStatelessSelfValidationFlag.Name) } // Auto-enable StatelessSelfValidation when witness stats are enabled - if ctx.Bool(VMWitnessStatsFlag.Name) { + if cfg.EnableWitnessStats { cfg.StatelessSelfValidation = true } @@ -1809,6 +1945,9 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) { if ctx.Bool(StateSizeTrackingFlag.Name) { cfg.EnableStateSizeTracking = true } + if ctx.IsSet(StateSizeTrackingDepthFlag.Name) { + cfg.StateSizeTrackingDepth = ctx.Uint64(StateSizeTrackingDepthFlag.Name) + } // Override any default configs for hard coded networks. switch { case ctx.Bool(MainnetFlag.Name): @@ -2097,6 +2236,7 @@ func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconf filterSystem := filters.NewFilterSystem(backend, filters.Config{ LogCacheSize: ethcfg.FilterLogCacheSize, LogQueryLimit: ethcfg.LogQueryLimit, + RangeLimit: ethcfg.RangeLimit, }) stack.RegisterAPIs([]rpc.API{{ Namespace: "eth", @@ -2106,13 +2246,13 @@ func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconf } // RegisterSyncOverrideService adds the synchronization override service into node. -func RegisterSyncOverrideService(stack *node.Node, eth *eth.Ethereum, target common.Hash, exitWhenSynced bool) { - if target != (common.Hash{}) { - log.Info("Registered sync override service", "hash", target, "exitWhenSynced", exitWhenSynced) +func RegisterSyncOverrideService(stack *node.Node, eth *eth.Ethereum, config syncer.Config) { + if config.TargetBlock != (common.Hash{}) { + log.Info("Registered sync override service", "hash", config.TargetBlock, "exitWhenSynced", config.ExitWhenSynced) } else { log.Info("Registered sync override service") } - syncer.Register(stack, eth, target, exitWhenSynced) + syncer.Register(stack, eth, config) } // SetupMetrics configures the metrics system. @@ -2141,13 +2281,14 @@ func SetupMetrics(cfg *metrics.Config) { bucket = cfg.InfluxDBBucket organization = cfg.InfluxDBOrganization tagsMap = SplitTagsFlag(cfg.InfluxDBTags) + interval = cfg.InfluxDBInterval ) if enableExport { - log.Info("Enabling metrics export to InfluxDB") - go influxdb.InfluxDBWithTags(metrics.DefaultRegistry, 10*time.Second, endpoint, database, username, password, "geth.", tagsMap) + log.Info("Enabling metrics export to InfluxDB", "interval", interval) + go influxdb.InfluxDBWithTags(metrics.DefaultRegistry, interval, endpoint, database, username, password, "geth.", tagsMap) } else if enableExportV2 { - log.Info("Enabling metrics export to InfluxDB (v2)") - go influxdb.InfluxDBV2WithTags(metrics.DefaultRegistry, 10*time.Second, endpoint, token, bucket, organization, "geth.", tagsMap) + log.Info("Enabling metrics export to InfluxDB (v2)", "interval", interval) + go influxdb.InfluxDBV2WithTags(metrics.DefaultRegistry, interval, endpoint, token, bucket, organization, "geth.", tagsMap) } // Expvar exporter. @@ -2299,15 +2440,18 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh Fatalf("%v", err) } options := &core.BlockChainConfig{ - TrieCleanLimit: ethconfig.Defaults.TrieCleanCache, - NoPrefetch: ctx.Bool(CacheNoPrefetchFlag.Name), - TrieDirtyLimit: ethconfig.Defaults.TrieDirtyCache, - ArchiveMode: ctx.String(GCModeFlag.Name) == "archive", - TrieTimeLimit: ethconfig.Defaults.TrieTimeout, - SnapshotLimit: ethconfig.Defaults.SnapshotCache, - Preimages: ctx.Bool(CachePreimagesFlag.Name), - StateScheme: scheme, - StateHistory: ctx.Uint64(StateHistoryFlag.Name), + TrieCleanLimit: ethconfig.Defaults.TrieCleanCache, + NoPrefetch: ctx.Bool(CacheNoPrefetchFlag.Name), + TrieDirtyLimit: ethconfig.Defaults.TrieDirtyCache, + ArchiveMode: ctx.String(GCModeFlag.Name) == "archive", + TrieTimeLimit: ethconfig.Defaults.TrieTimeout, + SnapshotLimit: ethconfig.Defaults.SnapshotCache, + Preimages: ctx.Bool(CachePreimagesFlag.Name), + StateScheme: scheme, + StateHistory: ctx.Uint64(StateHistoryFlag.Name), + TrienodeHistory: ctx.Int64(TrienodeHistoryFlag.Name), + NodeFullValueCheckpoint: uint32(ctx.Uint(TrienodeHistoryFullValueCheckpointFlag.Name)), + BinTrieGroupDepth: ctx.Int(BinTrieGroupDepthFlag.Name), // Disable transaction indexing/unindexing. TxLookupLimit: -1, @@ -2321,8 +2465,12 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh // Enable state size tracking if enabled StateSizeTracking: ctx.Bool(StateSizeTrackingFlag.Name), - // Configure the slow block statistic logger - SlowBlockThreshold: ctx.Duration(LogSlowBlockFlag.Name), + // Configure the slow block statistic logger (disabled by default) + SlowBlockThreshold: ethconfig.Defaults.SlowBlockThreshold, + } + // Only enable slow block logging if the flag was explicitly set + if ctx.IsSet(LogSlowBlockFlag.Name) { + options.SlowBlockThreshold = ctx.Duration(LogSlowBlockFlag.Name) } if options.ArchiveMode && !options.Preimages { options.Preimages = true @@ -2346,8 +2494,6 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh } vmcfg := vm.Config{ EnablePreimageRecording: ctx.Bool(VMEnableDebugFlag.Name), - EnableWitnessStats: ctx.Bool(VMWitnessStatsFlag.Name), - StatelessSelfValidation: ctx.Bool(VMStatelessSelfValidationFlag.Name) || ctx.Bool(VMWitnessStatsFlag.Name), } if ctx.IsSet(VMTraceFlag.Name) { if name := ctx.String(VMTraceFlag.Name); name != "" { @@ -2361,6 +2507,9 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh } options.VmConfig = vmcfg + options.StatelessSelfValidation = ctx.Bool(VMStatelessSelfValidationFlag.Name) || ctx.Bool(VMWitnessStatsFlag.Name) + options.EnableWitnessStats = ctx.Bool(VMWitnessStatsFlag.Name) + chain, err := core.NewBlockChain(chainDb, gspec, engine, options) if err != nil { Fatalf("Can't create BlockChain: %v", err) @@ -2386,10 +2535,10 @@ func MakeConsolePreloads(ctx *cli.Context) []string { } // MakeTrieDatabase constructs a trie database based on the configured scheme. -func MakeTrieDatabase(ctx *cli.Context, stack *node.Node, disk ethdb.Database, preimage bool, readOnly bool, isVerkle bool) *triedb.Database { +func MakeTrieDatabase(ctx *cli.Context, stack *node.Node, disk ethdb.Database, preimage bool, readOnly bool, isUBT bool) *triedb.Database { config := &triedb.Config{ Preimages: preimage, - IsVerkle: isVerkle, + IsUBT: isUBT, } scheme, err := rawdb.ParseStateScheme(ctx.String(StateSchemeFlag.Name), disk) if err != nil { diff --git a/cmd/utils/history_test.go b/cmd/utils/history_test.go index 994756eda5f9..663194612953 100644 --- a/cmd/utils/history_test.go +++ b/cmd/utils/history_test.go @@ -33,6 +33,8 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/execdb" + "github.com/ethereum/go-ethereum/internal/era/onedb" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/triedb" @@ -44,136 +46,148 @@ var ( ) func TestHistoryImportAndExport(t *testing.T) { - var ( - key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") - address = crypto.PubkeyToAddress(key.PublicKey) - genesis = &core.Genesis{ - Config: params.TestChainConfig, - Alloc: types.GenesisAlloc{address: {Balance: big.NewInt(1000000000000000000)}}, - } - signer = types.LatestSigner(genesis.Config) - ) - - // Generate chain. - db, blocks, _ := core.GenerateChainWithGenesis(genesis, ethash.NewFaker(), int(count), func(i int, g *core.BlockGen) { - if i == 0 { - return - } - tx, err := types.SignNewTx(key, signer, &types.DynamicFeeTx{ - ChainID: genesis.Config.ChainID, - Nonce: uint64(i - 1), - GasTipCap: common.Big0, - GasFeeCap: g.PrevBlock(0).BaseFee(), - Gas: 50000, - To: &common.Address{0xaa}, - Value: big.NewInt(int64(i)), - Data: nil, - AccessList: nil, - }) - if err != nil { - t.Fatalf("error creating tx: %v", err) - } - g.AddTx(tx) - }) + for _, tt := range []struct { + name string + builder func(io.Writer) era.Builder + filename func(network string, epoch int, root common.Hash) string + from func(f era.ReadAtSeekCloser) (era.Era, error) + }{ + {"era1", onedb.NewBuilder, onedb.Filename, onedb.From}, + {"erae", execdb.NewBuilder, execdb.Filename, execdb.From}, + } { + t.Run(tt.name, func(t *testing.T) { + var ( + key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + address = crypto.PubkeyToAddress(key.PublicKey) + genesis = &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{address: {Balance: big.NewInt(1000000000000000000)}}, + } + signer = types.LatestSigner(genesis.Config) + ) - // Initialize BlockChain. - chain, err := core.NewBlockChain(db, genesis, ethash.NewFaker(), nil) - if err != nil { - t.Fatalf("unable to initialize chain: %v", err) - } - if _, err := chain.InsertChain(blocks); err != nil { - t.Fatalf("error inserting chain: %v", err) - } + // Generate chain. + db, blocks, _ := core.GenerateChainWithGenesis(genesis, ethash.NewFaker(), int(count), func(i int, g *core.BlockGen) { + if i == 0 { + return + } + tx, err := types.SignNewTx(key, signer, &types.DynamicFeeTx{ + ChainID: genesis.Config.ChainID, + Nonce: uint64(i - 1), + GasTipCap: common.Big0, + GasFeeCap: g.PrevBlock(0).BaseFee(), + Gas: 50000, + To: &common.Address{0xaa}, + Value: big.NewInt(int64(i)), + Data: nil, + AccessList: nil, + }) + if err != nil { + t.Fatalf("error creating tx: %v", err) + } + g.AddTx(tx) + }) - // Make temp directory for era files. - dir := t.TempDir() + // Initialize BlockChain. + chain, err := core.NewBlockChain(db, genesis, ethash.NewFaker(), nil) + if err != nil { + t.Fatalf("unable to initialize chain: %v", err) + } + if _, err := chain.InsertChain(blocks); err != nil { + t.Fatalf("error inserting chain: %v", err) + } - // Export history to temp directory. - if err := ExportHistory(chain, dir, 0, count, step); err != nil { - t.Fatalf("error exporting history: %v", err) - } + // Make temp directory for era files. + dir := t.TempDir() - // Read checksums. - b, err := os.ReadFile(filepath.Join(dir, "checksums.txt")) - if err != nil { - t.Fatalf("failed to read checksums: %v", err) - } - checksums := strings.Split(string(b), "\n") + // Export history to temp directory. + if err := ExportHistory(chain, dir, 0, count, tt.builder, tt.filename); err != nil { + t.Fatalf("error exporting history: %v", err) + } - // Verify each Era. - entries, _ := era.ReadDir(dir, "mainnet") - for i, filename := range entries { - func() { - f, err := os.Open(filepath.Join(dir, filename)) + // Read checksums. + b, err := os.ReadFile(filepath.Join(dir, "checksums.txt")) if err != nil { - t.Fatalf("error opening era file: %v", err) - } - var ( - h = sha256.New() - buf = bytes.NewBuffer(nil) - ) - if _, err := io.Copy(h, f); err != nil { - t.Fatalf("unable to recalculate checksum: %v", err) + t.Fatalf("failed to read checksums: %v", err) } - if got, want := common.BytesToHash(h.Sum(buf.Bytes()[:])).Hex(), checksums[i]; got != want { - t.Fatalf("checksum %d does not match: got %s, want %s", i, got, want) + checksums := strings.Split(string(b), "\n") + + // Verify each Era. + entries, _ := era.ReadDir(dir, "mainnet") + for i, filename := range entries { + func() { + f, err := os.Open(filepath.Join(dir, filename)) + if err != nil { + t.Fatalf("error opening era file: %v", err) + } + var ( + h = sha256.New() + buf = bytes.NewBuffer(nil) + ) + if _, err := io.Copy(h, f); err != nil { + t.Fatalf("unable to recalculate checksum: %v", err) + } + if got, want := common.BytesToHash(h.Sum(buf.Bytes()[:])).Hex(), checksums[i]; got != want { + t.Fatalf("checksum %d does not match: got %s, want %s", i, got, want) + } + e, err := tt.from(f) + if err != nil { + t.Fatalf("error opening era: %v", err) + } + defer e.Close() + it, err := e.Iterator() + if err != nil { + t.Fatalf("error making era reader: %v", err) + } + for j := 0; it.Next(); j++ { + n := i*int(step) + j + if it.Error() != nil { + t.Fatalf("error reading block entry %d: %v", n, it.Error()) + } + block, receipts, err := it.BlockAndReceipts() + if err != nil { + t.Fatalf("error reading block entry %d: %v", n, err) + } + want := chain.GetBlockByNumber(uint64(n)) + if want, got := uint64(n), block.NumberU64(); want != got { + t.Fatalf("blocks out of order: want %d, got %d", want, got) + } + if want.Hash() != block.Hash() { + t.Fatalf("block hash mismatch %d: want %s, got %s", n, want.Hash().Hex(), block.Hash().Hex()) + } + if got := types.DeriveSha(block.Transactions(), trie.NewStackTrie(nil)); got != want.TxHash() { + t.Fatalf("tx hash %d mismatch: want %s, got %s", n, want.TxHash(), got) + } + if got := types.CalcUncleHash(block.Uncles()); got != want.UncleHash() { + t.Fatalf("uncle hash %d mismatch: want %s, got %s", n, want.UncleHash(), got) + } + if got := types.DeriveSha(receipts, trie.NewStackTrie(nil)); got != want.ReceiptHash() { + t.Fatalf("receipt root %d mismatch: want %s, got %s", n, want.ReceiptHash(), got) + } + } + }() } - e, err := era.From(f) + + // Now import Era. + db2, err := rawdb.Open(rawdb.NewMemoryDatabase(), rawdb.OpenOptions{}) if err != nil { - t.Fatalf("error opening era: %v", err) + panic(err) } - defer e.Close() - it, err := era.NewIterator(e) + t.Cleanup(func() { + db2.Close() + }) + + genesis.MustCommit(db2, triedb.NewDatabase(db2, triedb.HashDefaults)) + imported, err := core.NewBlockChain(db2, genesis, ethash.NewFaker(), nil) if err != nil { - t.Fatalf("error making era reader: %v", err) + t.Fatalf("unable to initialize chain: %v", err) } - for j := 0; it.Next(); j++ { - n := i*int(step) + j - if it.Error() != nil { - t.Fatalf("error reading block entry %d: %v", n, it.Error()) - } - block, receipts, err := it.BlockAndReceipts() - if err != nil { - t.Fatalf("error reading block entry %d: %v", n, err) - } - want := chain.GetBlockByNumber(uint64(n)) - if want, got := uint64(n), block.NumberU64(); want != got { - t.Fatalf("blocks out of order: want %d, got %d", want, got) - } - if want.Hash() != block.Hash() { - t.Fatalf("block hash mismatch %d: want %s, got %s", n, want.Hash().Hex(), block.Hash().Hex()) - } - if got := types.DeriveSha(block.Transactions(), trie.NewStackTrie(nil)); got != want.TxHash() { - t.Fatalf("tx hash %d mismatch: want %s, got %s", n, want.TxHash(), got) - } - if got := types.CalcUncleHash(block.Uncles()); got != want.UncleHash() { - t.Fatalf("uncle hash %d mismatch: want %s, got %s", n, want.UncleHash(), got) - } - if got := types.DeriveSha(receipts, trie.NewStackTrie(nil)); got != want.ReceiptHash() { - t.Fatalf("receipt root %d mismatch: want %s, got %s", n, want.ReceiptHash(), got) - } + if err := ImportHistory(imported, dir, "mainnet", tt.from); err != nil { + t.Fatalf("failed to import chain: %v", err) } - }() - } - - // Now import Era. - db2, err := rawdb.Open(rawdb.NewMemoryDatabase(), rawdb.OpenOptions{}) - if err != nil { - panic(err) - } - t.Cleanup(func() { - db2.Close() - }) - - genesis.MustCommit(db2, triedb.NewDatabase(db2, triedb.HashDefaults)) - imported, err := core.NewBlockChain(db2, genesis, ethash.NewFaker(), nil) - if err != nil { - t.Fatalf("unable to initialize chain: %v", err) - } - if err := ImportHistory(imported, dir, "mainnet"); err != nil { - t.Fatalf("failed to import chain: %v", err) - } - if have, want := imported.CurrentHeader(), chain.CurrentHeader(); have.Hash() != want.Hash() { - t.Fatalf("imported chain does not match expected, have (%d, %s) want (%d, %s)", have.Number, have.Hash(), want.Number, want.Hash()) + if have, want := imported.CurrentHeader(), chain.CurrentHeader(); have.Hash() != want.Hash() { + t.Fatalf("imported chain does not match expected, have (%d, %s) want (%d, %s)", have.Number, have.Hash(), want.Number, want.Hash()) + } + }) } } diff --git a/cmd/workload/README.md b/cmd/workload/README.md index 1b84dd05db94..ee1d6acbc963 100644 --- a/cmd/workload/README.md +++ b/cmd/workload/README.md @@ -34,4 +34,5 @@ the following commands (in this directory) against a synced mainnet node: > go run . filtergen --queries queries/filter_queries_mainnet.json http://host:8545 > go run . historygen --history-tests queries/history_mainnet.json http://host:8545 > go run . tracegen --trace-tests queries/trace_mainnet.json --trace-start 4000000 --trace-end 4000100 http://host:8545 +> go run . proofgen --proof-tests queries/proof_mainnet.json --proof-states 3000 http://host:8545 ``` diff --git a/cmd/workload/main.go b/cmd/workload/main.go index 8ac0e5b6cb12..4ee894e96211 100644 --- a/cmd/workload/main.go +++ b/cmd/workload/main.go @@ -48,6 +48,7 @@ func init() { historyGenerateCommand, filterGenerateCommand, traceGenerateCommand, + proofGenerateCommand, filterPerfCommand, filterFuzzCommand, } diff --git a/cmd/workload/prooftest.go b/cmd/workload/prooftest.go new file mode 100644 index 000000000000..dcc063d30e54 --- /dev/null +++ b/cmd/workload/prooftest.go @@ -0,0 +1,105 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "context" + "encoding/json" + "fmt" + "math/big" + "os" + "strings" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/internal/utesting" + "github.com/urfave/cli/v2" +) + +// proofTest is the content of a state-proof test. +type proofTest struct { + BlockNumbers []uint64 `json:"blockNumbers"` + Addresses [][]common.Address `json:"addresses"` + StorageKeys [][][]string `json:"storageKeys"` + Results [][]common.Hash `json:"results"` +} + +type proofTestSuite struct { + cfg testConfig + tests proofTest + invalidDir string +} + +func newProofTestSuite(cfg testConfig, ctx *cli.Context) *proofTestSuite { + s := &proofTestSuite{ + cfg: cfg, + invalidDir: ctx.String(proofTestInvalidOutputFlag.Name), + } + if err := s.loadTests(); err != nil { + exit(err) + } + return s +} + +func (s *proofTestSuite) loadTests() error { + file, err := s.cfg.fsys.Open(s.cfg.proofTestFile) + if err != nil { + // If not found in embedded FS, try to load it from disk + if !os.IsNotExist(err) { + return err + } + file, err = os.OpenFile(s.cfg.proofTestFile, os.O_RDONLY, 0666) + if err != nil { + return fmt.Errorf("can't open proofTestFile: %v", err) + } + } + defer file.Close() + if err := json.NewDecoder(file).Decode(&s.tests); err != nil { + return fmt.Errorf("invalid JSON in %s: %v", s.cfg.proofTestFile, err) + } + if len(s.tests.BlockNumbers) == 0 { + return fmt.Errorf("proofTestFile %s has no test data", s.cfg.proofTestFile) + } + return nil +} + +func (s *proofTestSuite) allTests() []workloadTest { + return []workloadTest{ + newArchiveWorkloadTest("Proof/GetProof", s.getProof), + } +} + +func (s *proofTestSuite) getProof(t *utesting.T) { + ctx := context.Background() + for i, blockNumber := range s.tests.BlockNumbers { + for j := 0; j < len(s.tests.Addresses[i]); j++ { + res, err := s.cfg.client.Geth.GetProof(ctx, s.tests.Addresses[i][j], s.tests.StorageKeys[i][j], big.NewInt(int64(blockNumber))) + if err != nil { + t.Errorf("State proving fails, blockNumber: %d, address: %x, keys: %v, err: %v\n", blockNumber, s.tests.Addresses[i][j], strings.Join(s.tests.StorageKeys[i][j], " "), err) + continue + } + blob, err := json.Marshal(res) + if err != nil { + t.Fatalf("State proving fails: error %v", err) + continue + } + if crypto.Keccak256Hash(blob) != s.tests.Results[i][j] { + t.Errorf("State proof mismatch, %d, number: %d, address: %x, keys: %v: invalid result", i, blockNumber, s.tests.Addresses[i][j], strings.Join(s.tests.StorageKeys[i][j], " ")) + } + } + } +} diff --git a/cmd/workload/prooftestgen.go b/cmd/workload/prooftestgen.go new file mode 100644 index 000000000000..5d92eea114d7 --- /dev/null +++ b/cmd/workload/prooftestgen.go @@ -0,0 +1,355 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see + +package main + +import ( + "context" + "encoding/json" + "fmt" + "math/big" + "math/rand" + "os" + "path/filepath" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/eth/tracers/native" + "github.com/ethereum/go-ethereum/internal/flags" + "github.com/ethereum/go-ethereum/internal/testrand" + "github.com/ethereum/go-ethereum/log" + "github.com/urfave/cli/v2" +) + +var ( + proofGenerateCommand = &cli.Command{ + Name: "proofgen", + Usage: "Generates tests for state proof verification", + ArgsUsage: "", + Action: generateProofTests, + Flags: []cli.Flag{ + proofTestFileFlag, + proofTestResultOutputFlag, + proofTestStatesFlag, + proofTestStartBlockFlag, + proofTestEndBlockFlag, + }, + } + + proofTestFileFlag = &cli.StringFlag{ + Name: "proof-tests", + Usage: "JSON file containing proof test queries", + Value: "proof_tests.json", + Category: flags.TestingCategory, + } + proofTestResultOutputFlag = &cli.StringFlag{ + Name: "proof-output", + Usage: "Folder containing detailed trace output files", + Value: "", + Category: flags.TestingCategory, + } + proofTestStatesFlag = &cli.Int64Flag{ + Name: "proof-states", + Usage: "Number of states to generate proof against", + Value: 10000, + Category: flags.TestingCategory, + } + proofTestInvalidOutputFlag = &cli.StringFlag{ + Name: "proof-invalid", + Usage: "Folder containing the mismatched state proof output files", + Value: "", + Category: flags.TestingCategory, + } + proofTestStartBlockFlag = &cli.Uint64Flag{ + Name: "proof-start", + Usage: "The number of starting block for proof verification (included)", + Category: flags.TestingCategory, + } + proofTestEndBlockFlag = &cli.Uint64Flag{ + Name: "proof-end", + Usage: "The number of ending block for proof verification (excluded)", + Category: flags.TestingCategory, + } +) + +type proofGenerator func(cli *client, startBlock uint64, endBlock uint64, number int) ([]uint64, [][]common.Address, [][][]string, error) + +func genAccountProof(cli *client, startBlock uint64, endBlock uint64, number int) ([]uint64, [][]common.Address, [][][]string, error) { + var ( + blockNumbers []uint64 + accountAddresses [][]common.Address + storageKeys [][][]string + nAccounts int + ctx = context.Background() + start = time.Now() + ) + chainID, err := cli.Eth.ChainID(ctx) + if err != nil { + return nil, nil, nil, err + } + signer := types.LatestSignerForChainID(chainID) + + for { + if nAccounts >= number { + break + } + blockNumber := uint64(rand.Intn(int(endBlock-startBlock))) + startBlock + + block, err := cli.Eth.BlockByNumber(context.Background(), big.NewInt(int64(blockNumber))) + if err != nil { + continue + } + var ( + addresses []common.Address + keys [][]string + gather = func(address common.Address) { + addresses = append(addresses, address) + keys = append(keys, nil) + nAccounts++ + } + ) + for _, tx := range block.Transactions() { + if nAccounts >= number { + break + } + sender, err := signer.Sender(tx) + if err != nil { + log.Error("Failed to resolve the sender address", "hash", tx.Hash(), "err", err) + continue + } + gather(sender) + + if tx.To() != nil { + gather(*tx.To()) + } + } + blockNumbers = append(blockNumbers, blockNumber) + accountAddresses = append(accountAddresses, addresses) + storageKeys = append(storageKeys, keys) + } + log.Info("Generated tests for account proof", "blocks", len(blockNumbers), "accounts", nAccounts, "elapsed", common.PrettyDuration(time.Since(start))) + return blockNumbers, accountAddresses, storageKeys, nil +} + +func genNonExistentAccountProof(cli *client, startBlock uint64, endBlock uint64, number int) ([]uint64, [][]common.Address, [][][]string, error) { + var ( + blockNumbers []uint64 + accountAddresses [][]common.Address + storageKeys [][][]string + total int + ) + for i := 0; i < number/5; i++ { + var ( + addresses []common.Address + keys [][]string + blockNumber = uint64(rand.Intn(int(endBlock-startBlock))) + startBlock + ) + for j := 0; j < 5; j++ { + addresses = append(addresses, testrand.Address()) + keys = append(keys, nil) + } + total += len(addresses) + blockNumbers = append(blockNumbers, blockNumber) + accountAddresses = append(accountAddresses, addresses) + storageKeys = append(storageKeys, keys) + } + log.Info("Generated tests for non-existing account proof", "blocks", len(blockNumbers), "accounts", total) + return blockNumbers, accountAddresses, storageKeys, nil +} + +func genStorageProof(cli *client, startBlock uint64, endBlock uint64, number int) ([]uint64, [][]common.Address, [][][]string, error) { + var ( + blockNumbers []uint64 + accountAddresses [][]common.Address + storageKeys [][][]string + + nAccounts int + nStorages int + start = time.Now() + ) + for { + if nAccounts+nStorages >= number { + break + } + blockNumber := uint64(rand.Intn(int(endBlock-startBlock))) + startBlock + + block, err := cli.Eth.BlockByNumber(context.Background(), big.NewInt(int64(blockNumber))) + if err != nil { + continue + } + var ( + addresses []common.Address + slots [][]string + tracer = "prestateTracer" + configBlob, _ = json.Marshal(native.PrestateTracerConfig{ + DiffMode: false, + DisableCode: true, + DisableStorage: false, + }) + ) + for _, tx := range block.Transactions() { + if nAccounts+nStorages >= number { + break + } + if tx.To() == nil { + continue + } + ret, err := cli.Geth.TraceTransaction(context.Background(), tx.Hash(), &tracers.TraceConfig{ + Tracer: &tracer, + TracerConfig: configBlob, + }) + if err != nil { + log.Error("Failed to trace the transaction", "blockNumber", blockNumber, "hash", tx.Hash(), "err", err) + continue + } + blob, err := json.Marshal(ret) + if err != nil { + log.Error("Failed to marshal data", "err", err) + continue + } + var accounts map[common.Address]*types.Account + if err := json.Unmarshal(blob, &accounts); err != nil { + log.Error("Failed to decode trace result", "blockNumber", blockNumber, "hash", tx.Hash(), "err", err) + continue + } + for addr, account := range accounts { + if len(account.Storage) == 0 { + continue + } + addresses = append(addresses, addr) + nAccounts += 1 + + var keys []string + for k := range account.Storage { + keys = append(keys, k.Hex()) + } + nStorages += len(keys) + + var emptyKeys []string + for i := 0; i < 3; i++ { + emptyKeys = append(emptyKeys, testrand.Hash().Hex()) + } + nStorages += len(emptyKeys) + + slots = append(slots, append(keys, emptyKeys...)) + } + } + blockNumbers = append(blockNumbers, blockNumber) + accountAddresses = append(accountAddresses, addresses) + storageKeys = append(storageKeys, slots) + } + log.Info("Generated tests for storage proof", "blocks", len(blockNumbers), "accounts", nAccounts, "storages", nStorages, "elapsed", common.PrettyDuration(time.Since(start))) + return blockNumbers, accountAddresses, storageKeys, nil +} + +func genProofRequests(cli *client, startBlock, endBlock uint64, states int) (*proofTest, error) { + var ( + blockNumbers []uint64 + accountAddresses [][]common.Address + storageKeys [][][]string + ) + ratio := []float64{0.2, 0.1, 0.7} + for i, fn := range []proofGenerator{genAccountProof, genNonExistentAccountProof, genStorageProof} { + numbers, addresses, keys, err := fn(cli, startBlock, endBlock, int(float64(states)*ratio[i])) + if err != nil { + return nil, err + } + blockNumbers = append(blockNumbers, numbers...) + accountAddresses = append(accountAddresses, addresses...) + storageKeys = append(storageKeys, keys...) + } + return &proofTest{ + BlockNumbers: blockNumbers, + Addresses: accountAddresses, + StorageKeys: storageKeys, + }, nil +} + +func generateProofTests(clictx *cli.Context) error { + var ( + client = makeClient(clictx) + ctx = context.Background() + states = clictx.Int(proofTestStatesFlag.Name) + outputFile = clictx.String(proofTestFileFlag.Name) + outputDir = clictx.String(proofTestResultOutputFlag.Name) + startBlock = clictx.Uint64(proofTestStartBlockFlag.Name) + endBlock = clictx.Uint64(proofTestEndBlockFlag.Name) + ) + head, err := client.Eth.BlockNumber(ctx) + if err != nil { + exit(err) + } + if startBlock > head || endBlock > head { + return fmt.Errorf("chain is out of proof range, head %d, start: %d, limit: %d", head, startBlock, endBlock) + } + if endBlock == 0 { + endBlock = head + } + log.Info("Generating proof states", "startBlock", startBlock, "endBlock", endBlock, "states", states) + + test, err := genProofRequests(client, startBlock, endBlock, states) + if err != nil { + exit(err) + } + for i, blockNumber := range test.BlockNumbers { + var hashes []common.Hash + for j := 0; j < len(test.Addresses[i]); j++ { + res, err := client.Geth.GetProof(ctx, test.Addresses[i][j], test.StorageKeys[i][j], big.NewInt(int64(blockNumber))) + if err != nil { + log.Error("Failed to prove the state", "number", blockNumber, "address", test.Addresses[i][j], "slots", len(test.StorageKeys[i][j]), "err", err) + continue + } + blob, err := json.Marshal(res) + if err != nil { + return err + } + hashes = append(hashes, crypto.Keccak256Hash(blob)) + + writeStateProof(outputDir, blockNumber, test.Addresses[i][j], res) + } + test.Results = append(test.Results, hashes) + } + writeJSON(outputFile, test) + return nil +} + +func writeStateProof(dir string, blockNumber uint64, address common.Address, result any) { + if dir == "" { + return + } + // Ensure the directory exists + if err := os.MkdirAll(dir, os.ModePerm); err != nil { + exit(fmt.Errorf("failed to create directories: %w", err)) + } + fname := fmt.Sprintf("%d-%x", blockNumber, address) + name := filepath.Join(dir, fname) + file, err := os.Create(name) + if err != nil { + exit(fmt.Errorf("error creating %s: %v", name, err)) + return + } + defer file.Close() + + data, _ := json.MarshalIndent(result, "", " ") + _, err = file.Write(data) + if err != nil { + exit(fmt.Errorf("error writing %s: %v", name, err)) + return + } +} diff --git a/cmd/workload/testsuite.go b/cmd/workload/testsuite.go index 25dc17a49e7f..4e33522f1b65 100644 --- a/cmd/workload/testsuite.go +++ b/cmd/workload/testsuite.go @@ -50,7 +50,9 @@ var ( filterQueryFileFlag, historyTestFileFlag, traceTestFileFlag, + proofTestFileFlag, traceTestInvalidOutputFlag, + proofTestInvalidOutputFlag, }, } testPatternFlag = &cli.StringFlag{ @@ -95,6 +97,7 @@ type testConfig struct { historyTestFile string historyPruneBlock *uint64 traceTestFile string + proofTestFile string } var errPrunedHistory = errors.New("attempt to access pruned history") @@ -145,8 +148,16 @@ func testConfigFromCLI(ctx *cli.Context) (cfg testConfig) { } else { cfg.traceTestFile = "queries/trace_mainnet.json" } + if ctx.IsSet(proofTestFileFlag.Name) { + cfg.proofTestFile = ctx.String(proofTestFileFlag.Name) + } else { + cfg.proofTestFile = "queries/proof_mainnet.json" + } + cfg.historyPruneBlock = new(uint64) - *cfg.historyPruneBlock = history.PrunePoints[params.MainnetGenesisHash].BlockNumber + if p, err := history.NewPolicy(history.KeepPostMerge, params.MainnetGenesisHash); err == nil { + *cfg.historyPruneBlock = p.Target.BlockNumber + } case ctx.Bool(testSepoliaFlag.Name): cfg.fsys = builtinTestFiles if ctx.IsSet(filterQueryFileFlag.Name) { @@ -164,13 +175,22 @@ func testConfigFromCLI(ctx *cli.Context) (cfg testConfig) { } else { cfg.traceTestFile = "queries/trace_sepolia.json" } + if ctx.IsSet(proofTestFileFlag.Name) { + cfg.proofTestFile = ctx.String(proofTestFileFlag.Name) + } else { + cfg.proofTestFile = "queries/proof_sepolia.json" + } + cfg.historyPruneBlock = new(uint64) - *cfg.historyPruneBlock = history.PrunePoints[params.SepoliaGenesisHash].BlockNumber + if p, err := history.NewPolicy(history.KeepPostMerge, params.SepoliaGenesisHash); err == nil { + *cfg.historyPruneBlock = p.Target.BlockNumber + } default: cfg.fsys = os.DirFS(".") cfg.filterQueryFile = ctx.String(filterQueryFileFlag.Name) cfg.historyTestFile = ctx.String(historyTestFileFlag.Name) cfg.traceTestFile = ctx.String(traceTestFileFlag.Name) + cfg.proofTestFile = ctx.String(proofTestFileFlag.Name) } return cfg } @@ -222,11 +242,13 @@ func runTestCmd(ctx *cli.Context) error { filterSuite := newFilterTestSuite(cfg) historySuite := newHistoryTestSuite(cfg) traceSuite := newTraceTestSuite(cfg, ctx) + proofSuite := newProofTestSuite(cfg, ctx) // Filter test cases. tests := filterSuite.allTests() tests = append(tests, historySuite.allTests()...) tests = append(tests, traceSuite.allTests()...) + tests = append(tests, proofSuite.allTests()...) utests := filterTests(tests, ctx.String(testPatternFlag.Name), func(t workloadTest) bool { if t.Slow && !ctx.Bool(testSlowFlag.Name) { diff --git a/common/hexutil/json.go b/common/hexutil/json.go index 6b9f4120783d..c00cd879c8fe 100644 --- a/common/hexutil/json.go +++ b/common/hexutil/json.go @@ -204,6 +204,10 @@ func (b *Big) ToInt() *big.Int { return (*big.Int)(b) } +func (b *Big) ToUint256() (*uint256.Int, bool) { + return uint256.FromBig((*big.Int)(b)) +} + // String returns the hex encoding of b. func (b *Big) String() string { return EncodeBig(b.ToInt()) diff --git a/common/types.go b/common/types.go index a96d6c7c8368..308b8ed879a7 100644 --- a/common/types.go +++ b/common/types.go @@ -30,7 +30,7 @@ import ( "strings" "github.com/ethereum/go-ethereum/common/hexutil" - "golang.org/x/crypto/sha3" + "github.com/ethereum/go-ethereum/crypto/keccak" ) // Lengths of hashes and addresses in bytes. @@ -271,7 +271,7 @@ func (a *Address) checksumHex() []byte { buf := a.hex() // compute checksum - sha := sha3.NewLegacyKeccak256() + sha := keccak.NewLegacyKeccak256() sha.Write(buf[2:]) hash := sha.Sum(nil) for i := 2; i < len(buf); i++ { diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go index dbba73947f32..72ac75c036a3 100644 --- a/consensus/beacon/consensus.go +++ b/consensus/beacon/consensus.go @@ -25,12 +25,10 @@ import ( "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" "github.com/ethereum/go-ethereum/consensus/misc/eip4844" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie" "github.com/holiman/uint256" ) @@ -272,6 +270,24 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa return err } } + + // Verify the existence / non-existence of Amsterdam-specific header fields + amsterdam := chain.Config().IsAmsterdam(header.Number, header.Time) + if amsterdam { + if header.BlockAccessListHash == nil { + return errors.New("header is missing block access list hash") + } + if header.SlotNumber == nil { + return errors.New("header is missing slotNumber") + } + } else { + if header.BlockAccessListHash != nil { + return fmt.Errorf("invalid block access list hash: have %x, expected nil", *header.BlockAccessListHash) + } + if header.SlotNumber != nil { + return fmt.Errorf("invalid slotNumber: have %d, expected nil", *header.SlotNumber) + } + } return nil } @@ -341,72 +357,6 @@ func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types. // No block reward which is issued by consensus layer instead. } -// FinalizeAndAssemble implements consensus.Engine, setting the final state and -// assembling the block. -func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) { - if !beacon.IsPoSHeader(header) { - return beacon.ethone.FinalizeAndAssemble(chain, header, state, body, receipts) - } - shanghai := chain.Config().IsShanghai(header.Number, header.Time) - if shanghai { - // All blocks after Shanghai must include a withdrawals root. - if body.Withdrawals == nil { - body.Withdrawals = make([]*types.Withdrawal, 0) - } - } else { - if len(body.Withdrawals) > 0 { - return nil, errors.New("withdrawals set before Shanghai activation") - } - } - // Finalize and assemble the block. - beacon.Finalize(chain, header, state, body) - - // Assign the final state root to header. - header.Root = state.IntermediateRoot(true) - - // Assemble the final block. - block := types.NewBlock(header, body, receipts, trie.NewStackTrie(nil)) - - // Create the block witness and attach to block. - // This step needs to happen as late as possible to catch all access events. - if chain.Config().IsVerkle(header.Number, header.Time) { - keys := state.AccessEvents().Keys() - - // Open the pre-tree to prove the pre-state against - parent := chain.GetHeaderByNumber(header.Number.Uint64() - 1) - if parent == nil { - return nil, fmt.Errorf("nil parent header for block %d", header.Number) - } - preTrie, err := state.Database().OpenTrie(parent.Root) - if err != nil { - return nil, fmt.Errorf("error opening pre-state tree root: %w", err) - } - postTrie := state.GetTrie() - if postTrie == nil { - return nil, errors.New("post-state tree is not available") - } - vktPreTrie, okpre := preTrie.(*trie.VerkleTrie) - vktPostTrie, okpost := postTrie.(*trie.VerkleTrie) - - // The witness is only attached iff both parent and current block are - // using verkle tree. - if okpre && okpost { - if len(keys) > 0 { - verkleProof, stateDiff, err := vktPreTrie.Proof(vktPostTrie, keys) - if err != nil { - return nil, fmt.Errorf("error generating verkle proof for block %d: %w", header.Number, err) - } - block = block.WithWitness(&types.ExecutionWitness{ - StateDiff: stateDiff, - VerkleProof: verkleProof, - }) - } - } - } - - return block, nil -} - // Seal generates a new sealing request for the given input block and pushes // the result into the given channel. // diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go index a6f02c8c2b1c..ceaec4465661 100644 --- a/consensus/clique/clique.go +++ b/consensus/clique/clique.go @@ -33,16 +33,14 @@ import ( "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-ethereum/trie" - "golang.org/x/crypto/sha3" ) const ( @@ -310,6 +308,8 @@ func (c *Clique) verifyHeader(chain consensus.ChainHeaderReader, header *types.H return fmt.Errorf("invalid blobGasUsed: have %d, expected nil", *header.BlobGasUsed) case header.ParentBeaconRoot != nil: return fmt.Errorf("invalid parentBeaconRoot, have %#x, expected nil", *header.ParentBeaconRoot) + case header.SlotNumber != nil: + return fmt.Errorf("invalid slotNumber, have %#x, expected nil", *header.SlotNumber) } // All basic checks passed, verify cascading fields return c.verifyCascadingFields(chain, header, parents) @@ -577,22 +577,6 @@ func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Heade // No block rewards in PoA, so the state remains as is } -// FinalizeAndAssemble implements consensus.Engine, ensuring no uncles are set, -// nor block rewards given, and returns the final block. -func (c *Clique) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) { - if len(body.Withdrawals) > 0 { - return nil, errors.New("clique does not support withdrawals") - } - // Finalize block - c.Finalize(chain, header, state, body) - - // Assign the final state root to header. - header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) - - // Assemble and return the final block for sealing. - return types.NewBlock(header, &types.Body{Transactions: body.Transactions}, receipts, trie.NewStackTrie(nil)), nil -} - // Authorize injects a private key into the consensus engine to mint new blocks // with. func (c *Clique) Authorize(signer common.Address) { @@ -642,7 +626,7 @@ func (c *Clique) Close() error { // SealHash returns the hash of a block prior to it being sealed. func SealHash(header *types.Header) (hash common.Hash) { - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() encodeSigHeader(hasher, header) hasher.(crypto.KeccakState).Read(hash[:]) return hash @@ -694,6 +678,9 @@ func encodeSigHeader(w io.Writer, header *types.Header) { if header.ParentBeaconRoot != nil { panic("unexpected parent beacon root value in clique") } + if header.SlotNumber != nil { + panic("unexpected slot number value in clique") + } if err := rlp.Encode(w, enc); err != nil { panic("can't encode: " + err.Error()) } diff --git a/consensus/consensus.go b/consensus/consensus.go index a68351f7ffad..4ba389292fc5 100644 --- a/consensus/consensus.go +++ b/consensus/consensus.go @@ -21,7 +21,6 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/params" @@ -87,13 +86,6 @@ type Engine interface { // that happen at finalization (e.g. block rewards). Finalize(chain ChainHeaderReader, header *types.Header, state vm.StateDB, body *types.Body) - // FinalizeAndAssemble runs any post-transaction state modifications (e.g. block - // rewards or process withdrawals) and assembles the final block. - // - // Note: The block header and state database might be updated to reflect any - // consensus rules that happen at finalization (e.g. block rewards). - FinalizeAndAssemble(chain ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) - // Seal generates a new sealing request for the given input block and pushes // the result into the given channel. // diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go index 376cbac8c095..ee9d9d97d63e 100644 --- a/consensus/ethash/consensus.go +++ b/consensus/ethash/consensus.go @@ -27,15 +27,13 @@ import ( "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/consensus/misc/eip1559" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-ethereum/trie" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) // Ethash proof-of-work protocol constants. @@ -283,6 +281,8 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa return fmt.Errorf("invalid blobGasUsed: have %d, expected nil", *header.BlobGasUsed) case header.ParentBeaconRoot != nil: return fmt.Errorf("invalid parentBeaconRoot, have %#x, expected nil", *header.ParentBeaconRoot) + case header.SlotNumber != nil: + return fmt.Errorf("invalid slotNumber, have %#x, expected nil", *header.SlotNumber) } // Add some fake checks for tests if ethash.fakeDelay != nil { @@ -509,25 +509,9 @@ func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types. accumulateRewards(chain.Config(), state, header, body.Uncles) } -// FinalizeAndAssemble implements consensus.Engine, accumulating the block and -// uncle rewards, setting the final state and assembling the block. -func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (*types.Block, error) { - if len(body.Withdrawals) > 0 { - return nil, errors.New("ethash does not support withdrawals") - } - // Finalize block - ethash.Finalize(chain, header, state, body) - - // Assign the final state root to header. - header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) - - // Header seems complete, assemble into a block and return - return types.NewBlock(header, &types.Body{Transactions: body.Transactions, Uncles: body.Uncles}, receipts, trie.NewStackTrie(nil)), nil -} - // SealHash returns the hash of a block prior to it being sealed. func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) { - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() enc := []interface{}{ header.ParentHash, @@ -559,6 +543,9 @@ func (ethash *Ethash) SealHash(header *types.Header) (hash common.Hash) { if header.ParentBeaconRoot != nil { panic("parent beacon root set on ethash") } + if header.SlotNumber != nil { + panic("slot number set on ethash") + } rlp.Encode(hasher, enc) hasher.Sum(hash[:0]) return hash diff --git a/consensus/misc/eip1559/eip1559.go b/consensus/misc/eip1559/eip1559.go index a90bd744b275..9a4cd320a8ee 100644 --- a/consensus/misc/eip1559/eip1559.go +++ b/consensus/misc/eip1559/eip1559.go @@ -43,6 +43,10 @@ func VerifyEIP1559Header(config *params.ChainConfig, parent, header *types.Heade if header.BaseFee == nil { return errors.New("header is missing baseFee") } + // Verify the parent header is not malformed + if config.IsLondon(parent.Number) && parent.BaseFee == nil { + return errors.New("parent header is missing baseFee") + } // Verify the baseFee is correct based on the parent header. expectedBaseFee := CalcBaseFee(config, parent) if header.BaseFee.Cmp(expectedBaseFee) != 0 { diff --git a/consensus/misc/eip4844/eip4844.go b/consensus/misc/eip4844/eip4844.go index 47b54d2e8529..2ebf4f7155d0 100644 --- a/consensus/misc/eip4844/eip4844.go +++ b/consensus/misc/eip4844/eip4844.go @@ -53,9 +53,9 @@ func (bc *BlobConfig) blobPrice(excessBlobGas uint64) *big.Int { return new(big.Int).Mul(f, big.NewInt(params.BlobTxBlobGasPerBlob)) } -func latestBlobConfig(cfg *params.ChainConfig, time uint64) *BlobConfig { +func latestBlobConfig(cfg *params.ChainConfig, time uint64) (BlobConfig, error) { if cfg.BlobScheduleConfig == nil { - return nil + return BlobConfig{}, errors.New("no blob config") } var ( london = cfg.LondonBlock @@ -80,14 +80,14 @@ func latestBlobConfig(cfg *params.ChainConfig, time uint64) *BlobConfig { case cfg.IsCancun(london, time) && s.Cancun != nil: bc = s.Cancun default: - return nil + return BlobConfig{}, errors.New("no blob config") } - return &BlobConfig{ + return BlobConfig{ Target: bc.Target, Max: bc.Max, UpdateFraction: bc.UpdateFraction, - } + }, nil } // VerifyEIP4844Header verifies the presence of the excessBlobGas field and that @@ -98,8 +98,8 @@ func VerifyEIP4844Header(config *params.ChainConfig, parent, header *types.Heade panic("bad header pair") } - bcfg := latestBlobConfig(config, header.Time) - if bcfg == nil { + bcfg, err := latestBlobConfig(config, header.Time) + if err != nil { panic("called before EIP-4844 is active") } @@ -130,11 +130,14 @@ func VerifyEIP4844Header(config *params.ChainConfig, parent, header *types.Heade // blobs on top of the excess blob gas. func CalcExcessBlobGas(config *params.ChainConfig, parent *types.Header, headTimestamp uint64) uint64 { isOsaka := config.IsOsaka(config.LondonBlock, headTimestamp) - bcfg := latestBlobConfig(config, headTimestamp) + bcfg, err := latestBlobConfig(config, headTimestamp) + if err != nil { + panic("calculating excess blob gas on nil blob config") + } return calcExcessBlobGas(isOsaka, bcfg, parent) } -func calcExcessBlobGas(isOsaka bool, bcfg *BlobConfig, parent *types.Header) uint64 { +func calcExcessBlobGas(isOsaka bool, bcfg BlobConfig, parent *types.Header) uint64 { var parentExcessBlobGas, parentBlobGasUsed uint64 if parent.ExcessBlobGas != nil { parentExcessBlobGas = *parent.ExcessBlobGas @@ -169,8 +172,8 @@ func calcExcessBlobGas(isOsaka bool, bcfg *BlobConfig, parent *types.Header) uin // CalcBlobFee calculates the blobfee from the header's excess blob gas field. func CalcBlobFee(config *params.ChainConfig, header *types.Header) *big.Int { - blobConfig := latestBlobConfig(config, header.Time) - if blobConfig == nil { + blobConfig, err := latestBlobConfig(config, header.Time) + if err != nil { panic("calculating blob fee on unsupported fork") } return blobConfig.blobBaseFee(*header.ExcessBlobGas) @@ -178,8 +181,8 @@ func CalcBlobFee(config *params.ChainConfig, header *types.Header) *big.Int { // MaxBlobsPerBlock returns the max blobs per block for a block at the given timestamp. func MaxBlobsPerBlock(cfg *params.ChainConfig, time uint64) int { - blobConfig := latestBlobConfig(cfg, time) - if blobConfig == nil { + blobConfig, err := latestBlobConfig(cfg, time) + if err != nil { return 0 } return blobConfig.Max @@ -193,8 +196,8 @@ func MaxBlobGasPerBlock(cfg *params.ChainConfig, time uint64) uint64 { // LatestMaxBlobsPerBlock returns the latest max blobs per block defined by the // configuration, regardless of the currently active fork. func LatestMaxBlobsPerBlock(cfg *params.ChainConfig) int { - bcfg := latestBlobConfig(cfg, math.MaxUint64) - if bcfg == nil { + bcfg, err := latestBlobConfig(cfg, math.MaxUint64) + if err != nil { return 0 } return bcfg.Max @@ -202,8 +205,8 @@ func LatestMaxBlobsPerBlock(cfg *params.ChainConfig) int { // TargetBlobsPerBlock returns the target blobs per block for a block at the given timestamp. func TargetBlobsPerBlock(cfg *params.ChainConfig, time uint64) int { - blobConfig := latestBlobConfig(cfg, time) - if blobConfig == nil { + blobConfig, err := latestBlobConfig(cfg, time) + if err != nil { return 0 } return blobConfig.Target diff --git a/console/console.go b/console/console.go index b5c77bd78fd4..573d1da57064 100644 --- a/console/console.go +++ b/console/console.go @@ -282,7 +282,7 @@ func (c *Console) AutoCompleteInput(line string, pos int) (string, []string, str for ; start > 0; start-- { // Skip all methods and namespaces (i.e. including the dot) c := line[start] - if c == '.' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '1' && c <= '9') { + if c == '.' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') { continue } // We've hit an unexpected character, autocomplete form here diff --git a/console/prompt/prompter.go b/console/prompt/prompter.go index 2a20b6906abd..5a0a89e76a6f 100644 --- a/console/prompt/prompter.go +++ b/console/prompt/prompter.go @@ -142,7 +142,7 @@ func (p *terminalPrompter) PromptPassword(prompt string) (passwd string, err err // PromptConfirm displays the given prompt to the user and requests a boolean // choice to be made, returning that choice. func (p *terminalPrompter) PromptConfirm(prompt string) (bool, error) { - input, err := p.Prompt(prompt + " [y/n] ") + input, err := p.PromptInput(prompt + " [y/n] ") if len(input) > 0 && strings.EqualFold(input[:1], "y") { return true, nil } diff --git a/core/bench_test.go b/core/bench_test.go index 932188f8e203..65179c54d457 100644 --- a/core/bench_test.go +++ b/core/bench_test.go @@ -89,7 +89,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) { data := make([]byte, nbytes) return func(i int, gen *BlockGen) { toaddr := common.Address{} - gas, _ := IntrinsicGas(data, nil, nil, false, false, false, false) + cost, _ := IntrinsicGas(data, nil, nil, false, false, false, false, false) signer := gen.Signer() gasPrice := big.NewInt(0) if gen.header.BaseFee != nil { @@ -99,7 +99,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) { Nonce: gen.TxNonce(benchRootAddr), To: &toaddr, Value: big.NewInt(1), - Gas: gas, + Gas: cost.RegularGas, Data: data, GasPrice: gasPrice, }) diff --git a/core/bintrie_witness_test.go b/core/bintrie_witness_test.go index 7704ba41fb66..5f6239e4fa28 100644 --- a/core/bintrie_witness_test.go +++ b/core/bintrie_witness_test.go @@ -36,7 +36,7 @@ import ( ) var ( - testVerkleChainConfig = ¶ms.ChainConfig{ + testUBTChainConfig = ¶ms.ChainConfig{ ChainID: big.NewInt(1), HomesteadBlock: big.NewInt(0), EIP150Block: big.NewInt(0), @@ -51,30 +51,30 @@ var ( LondonBlock: big.NewInt(0), Ethash: new(params.EthashConfig), ShanghaiTime: u64(0), - VerkleTime: u64(0), + UBTTime: u64(0), TerminalTotalDifficulty: common.Big0, - EnableVerkleAtGenesis: true, + EnableUBTAtGenesis: true, BlobScheduleConfig: ¶ms.BlobScheduleConfig{ - Verkle: params.DefaultPragueBlobConfig, + UBT: params.DefaultPragueBlobConfig, }, } ) -func TestProcessVerkle(t *testing.T) { +func TestProcessUBT(t *testing.T) { var ( code = common.FromHex(`6060604052600a8060106000396000f360606040526008565b00`) - intrinsicContractCreationGas, _ = IntrinsicGas(code, nil, nil, true, true, true, true) + intrinsicContractCreationGas, _ = IntrinsicGas(code, nil, nil, true, true, true, true, false) // A contract creation that calls EXTCODECOPY in the constructor. Used to ensure that the witness // will not contain that copied data. // Source: https://gist.github.com/gballet/a23db1e1cb4ed105616b5920feb75985 codeWithExtCodeCopy = common.FromHex(`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`) - intrinsicCodeWithExtCodeCopyGas, _ = IntrinsicGas(codeWithExtCodeCopy, nil, nil, true, true, true, true) - signer = types.LatestSigner(testVerkleChainConfig) + intrinsicCodeWithExtCodeCopyGas, _ = IntrinsicGas(codeWithExtCodeCopy, nil, nil, true, true, true, true, false) + signer = types.LatestSigner(testUBTChainConfig) testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") bcdb = rawdb.NewMemoryDatabase() // Database for the blockchain coinbase = common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") gspec = &Genesis{ - Config: testVerkleChainConfig, + Config: testUBTChainConfig, Alloc: GenesisAlloc{ coinbase: { Balance: big.NewInt(1000000000000000000), // 1 ether @@ -87,21 +87,22 @@ func TestProcessVerkle(t *testing.T) { }, } ) - // Verkle trees use the snapshot, which must be enabled before the + // UBTs use the snapshot, which must be enabled before the // data is saved into the tree+database. // genesis := gspec.MustCommit(bcdb, triedb) options := DefaultConfig().WithStateScheme(rawdb.PathScheme) options.SnapshotLimit = 0 + options.BinTrieGroupDepth = triedb.DefaultBinTrieGroupDepth blockchain, _ := NewBlockChain(bcdb, gspec, beacon.New(ethash.NewFaker()), options) defer blockchain.Stop() txCost1 := params.TxGas txCost2 := params.TxGas - contractCreationCost := intrinsicContractCreationGas + + contractCreationCost := intrinsicContractCreationGas.RegularGas + params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation */ params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* creation with value */ 739 /* execution costs */ - codeWithExtCodeCopyGas := intrinsicCodeWithExtCodeCopyGas + + codeWithExtCodeCopyGas := intrinsicCodeWithExtCodeCopyGas.RegularGas + params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation (tx) */ params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation (CREATE at pc=0x20) */ params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* write code hash */ @@ -188,7 +189,7 @@ func TestProcessParentBlockHash(t *testing.T) { // block 1 parent hash is 0x0100.... // block 2 parent hash is 0x0200.... // etc - checkBlockHashes := func(statedb *state.StateDB, isVerkle bool) { + checkBlockHashes := func(statedb *state.StateDB, isUBT bool) { statedb.SetNonce(params.HistoryStorageAddress, 1, tracing.NonceChangeUnspecified) statedb.SetCode(params.HistoryStorageAddress, params.HistoryStorageCode, tracing.CodeChangeUnspecified) // Process n blocks, from 1 .. num @@ -196,8 +197,8 @@ func TestProcessParentBlockHash(t *testing.T) { for i := 1; i <= num; i++ { header := &types.Header{ParentHash: common.Hash{byte(i)}, Number: big.NewInt(int64(i)), Difficulty: new(big.Int)} chainConfig := params.MergedTestChainConfig - if isVerkle { - chainConfig = testVerkleChainConfig + if isUBT { + chainConfig = testUBTChainConfig } vmContext := NewEVMBlockContext(header, nil, new(common.Address)) evm := vm.NewEVM(vmContext, statedb, chainConfig, vm.Config{}) @@ -205,9 +206,9 @@ func TestProcessParentBlockHash(t *testing.T) { } // Read block hashes for block 0 .. num-1 for i := 0; i < num; i++ { - have, want := getContractStoredBlockHash(statedb, uint64(i), isVerkle), common.Hash{byte(i + 1)} + have, want := getContractStoredBlockHash(statedb, uint64(i), isUBT), common.Hash{byte(i + 1)} if have != want { - t.Errorf("block %d, verkle=%v, have parent hash %v, want %v", i, isVerkle, have, want) + t.Errorf("block %d, verkle=%v, have parent hash %v, want %v", i, isUBT, have, want) } } } @@ -215,22 +216,23 @@ func TestProcessParentBlockHash(t *testing.T) { statedb, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) checkBlockHashes(statedb, false) }) - t.Run("Verkle", func(t *testing.T) { + t.Run("UBT", func(t *testing.T) { db := rawdb.NewMemoryDatabase() cacheConfig := DefaultConfig().WithStateScheme(rawdb.PathScheme) + cacheConfig.BinTrieGroupDepth = triedb.DefaultBinTrieGroupDepth cacheConfig.SnapshotLimit = 0 triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(true)) - statedb, _ := state.New(types.EmptyVerkleHash, state.NewDatabase(triedb, nil)) + statedb, _ := state.New(types.EmptyBinaryHash, state.NewDatabase(triedb, nil)) checkBlockHashes(statedb, true) }) } // getContractStoredBlockHash is a utility method which reads the stored parent blockhash for block 'number' -func getContractStoredBlockHash(statedb *state.StateDB, number uint64, isVerkle bool) common.Hash { +func getContractStoredBlockHash(statedb *state.StateDB, number uint64, isUBT bool) common.Hash { ringIndex := number % params.HistoryServeWindow var key common.Hash binary.BigEndian.PutUint64(key[24:], ringIndex) - if isVerkle { + if isUBT { return statedb.GetState(params.HistoryStorageAddress, key) } return statedb.GetState(params.HistoryStorageAddress, key) diff --git a/core/block_validator_test.go b/core/block_validator_test.go index fcc99effd0ef..0280862e3c48 100644 --- a/core/block_validator_test.go +++ b/core/block_validator_test.go @@ -17,6 +17,7 @@ package core import ( + "context" "math/big" "testing" "time" @@ -210,7 +211,7 @@ func testHeaderVerificationForMerging(t *testing.T, isClique bool) { t.Fatalf("post-block %d: unexpected result returned: %v", i, result) case <-time.After(25 * time.Millisecond): } - chain.InsertBlockWithoutSetHead(postBlocks[i], false) + chain.InsertBlockWithoutSetHead(context.Background(), postBlocks[i], false) } // Verify the blocks with pre-merge blocks and post-merge blocks diff --git a/core/blockchain.go b/core/blockchain.go index ae92386dc2e5..43186b75d942 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -18,6 +18,7 @@ package core import ( + "context" "errors" "fmt" "io" @@ -47,6 +48,7 @@ import ( "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/internal/syncx" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/internal/version" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" @@ -75,6 +77,8 @@ var ( storageReadTimer = metrics.NewRegisteredResettingTimer("chain/storage/reads", nil) storageUpdateTimer = metrics.NewRegisteredResettingTimer("chain/storage/updates", nil) storageCommitTimer = metrics.NewRegisteredResettingTimer("chain/storage/commits", nil) + codeReadTimer = metrics.NewRegisteredResettingTimer("chain/code/reads", nil) + codeReadBytesTimer = metrics.NewRegisteredResettingTimer("chain/code/readbytes", nil) accountCacheHitMeter = metrics.NewRegisteredMeter("chain/account/reads/cache/process/hit", nil) accountCacheMissMeter = metrics.NewRegisteredMeter("chain/account/reads/cache/process/miss", nil) @@ -88,9 +92,8 @@ var ( accountReadSingleTimer = metrics.NewRegisteredResettingTimer("chain/account/single/reads", nil) storageReadSingleTimer = metrics.NewRegisteredResettingTimer("chain/storage/single/reads", nil) - - snapshotCommitTimer = metrics.NewRegisteredResettingTimer("chain/snapshot/commits", nil) - triedbCommitTimer = metrics.NewRegisteredResettingTimer("chain/triedb/commits", nil) + codeReadSingleTimer = metrics.NewRegisteredResettingTimer("chain/code/single/reads", nil) + triedbCommitTimer = metrics.NewRegisteredResettingTimer("chain/triedb/commits", nil) blockInsertTimer = metrics.NewRegisteredResettingTimer("chain/inserts", nil) blockValidationTimer = metrics.NewRegisteredResettingTimer("chain/validation", nil) @@ -167,22 +170,33 @@ type BlockChainConfig struct { TrieNoAsyncFlush bool // Whether the asynchronous buffer flushing is disallowed TrieJournalDirectory string // Directory path to the journal used for persisting trie data across node restarts - Preimages bool // Whether to store preimage of trie key to the disk - StateScheme string // Scheme used to store ethereum states and merkle tree nodes on top - ArchiveMode bool // Whether to enable the archive mode + Preimages bool // Whether to store preimage of trie key to the disk + StateScheme string // Scheme used to store ethereum states and merkle tree nodes on top + ArchiveMode bool // Whether to enable the archive mode + BinTrieGroupDepth int // Number of levels per serialized group in binary trie (1-8) // Number of blocks from the chain head for which state histories are retained. // If set to 0, all state histories across the entire chain will be retained; StateHistory uint64 + // Number of blocks from the chain head for which trienode histories are retained. + // If set to 0, all trienode histories across the entire chain will be retained; + // If set to -1, no trienode history will be retained; + TrienodeHistory int64 + + // The frequency of full-value encoding. For example, a value of 16 means + // that, on average, for a given trie node across its 16 consecutive historical + // versions, only one version is stored in full format, while the others + // are stored in diff mode for storage compression. + NodeFullValueCheckpoint uint32 + // State snapshot related options SnapshotLimit int // Memory allowance (MB) to use for caching snapshot entries in memory SnapshotNoBuild bool // Whether the background generation is allowed SnapshotWait bool // Wait for snapshot construction on startup. TODO(karalabe): This is a dirty hack for testing, nuke it - // This defines the cutoff block for history expiry. - // Blocks before this number may be unavailable in the chain database. - ChainHistoryMode history.HistoryMode + // HistoryPolicy defines the chain history pruning intent. + HistoryPolicy history.HistoryPolicy // Misc options NoPrefetch bool // Whether to disable heuristic state prefetching when processing blocks @@ -200,21 +214,29 @@ type BlockChainConfig struct { StateSizeTracking bool // SlowBlockThreshold is the block execution time threshold beyond which - // detailed statistics will be logged. + // detailed statistics will be logged. Negative value means disabled (default), + // zero logs all blocks, positive value filters blocks by execution time. SlowBlockThreshold time.Duration + + // Execution configs + StatelessSelfValidation bool // Generate execution witnesses and self-check against them (testing purpose) + EnableWitnessStats bool // Whether trie access statistics collection is enabled + + // StateSizeTrackingDepth is the number of recent block state sizes to track. + StateSizeTrackingDepth uint64 } // DefaultConfig returns the default config. // Note the returned object is safe to modify! func DefaultConfig() *BlockChainConfig { return &BlockChainConfig{ - TrieCleanLimit: 256, - TrieDirtyLimit: 256, - TrieTimeLimit: 5 * time.Minute, - StateScheme: rawdb.HashScheme, - SnapshotLimit: 256, - SnapshotWait: true, - ChainHistoryMode: history.KeepAll, + TrieCleanLimit: 256, + TrieDirtyLimit: 256, + TrieTimeLimit: 5 * time.Minute, + StateScheme: rawdb.HashScheme, + SnapshotLimit: 256, + SnapshotWait: true, + HistoryPolicy: history.HistoryPolicy{Mode: history.KeepAll}, // Transaction indexing is disabled by default. // This is appropriate for most unit tests. TxLookupLimit: -1, @@ -240,10 +262,11 @@ func (cfg BlockChainConfig) WithNoAsyncFlush(on bool) *BlockChainConfig { } // triedbConfig derives the configures for trie database. -func (cfg *BlockChainConfig) triedbConfig(isVerkle bool) *triedb.Config { +func (cfg *BlockChainConfig) triedbConfig(isUBT bool) *triedb.Config { config := &triedb.Config{ - Preimages: cfg.Preimages, - IsVerkle: isVerkle, + Preimages: cfg.Preimages, + IsUBT: isUBT, + BinTrieGroupDepth: cfg.BinTrieGroupDepth, } if cfg.StateScheme == rawdb.HashScheme { config.HashDB = &hashdb.Config{ @@ -252,17 +275,22 @@ func (cfg *BlockChainConfig) triedbConfig(isVerkle bool) *triedb.Config { } if cfg.StateScheme == rawdb.PathScheme { config.PathDB = &pathdb.Config{ - StateHistory: cfg.StateHistory, - EnableStateIndexing: cfg.ArchiveMode, - TrieCleanSize: cfg.TrieCleanLimit * 1024 * 1024, - StateCleanSize: cfg.SnapshotLimit * 1024 * 1024, - JournalDirectory: cfg.TrieJournalDirectory, - + TrieCleanSize: cfg.TrieCleanLimit * 1024 * 1024, + StateCleanSize: cfg.SnapshotLimit * 1024 * 1024, // TODO(rjl493456442): The write buffer represents the memory limit used // for flushing both trie data and state data to disk. The config name // should be updated to eliminate the confusion. - WriteBufferSize: cfg.TrieDirtyLimit * 1024 * 1024, - NoAsyncFlush: cfg.TrieNoAsyncFlush, + WriteBufferSize: cfg.TrieDirtyLimit * 1024 * 1024, + JournalDirectory: cfg.TrieJournalDirectory, + + // Historical state configurations + StateHistory: cfg.StateHistory, + TrienodeHistory: cfg.TrienodeHistory, + EnableStateIndexing: cfg.ArchiveMode, + FullValueCheckpoint: cfg.NodeFullValueCheckpoint, + + // Testing configurations + NoAsyncFlush: cfg.TrieNoAsyncFlush, } } return config @@ -300,7 +328,7 @@ type BlockChain struct { lastWrite uint64 // Last block when the state was flushed flushInterval atomic.Int64 // Time interval (processing time) after which to flush a state triedb *triedb.Database // The database handler for maintaining trie nodes. - statedb *state.CachingDB // State database to reuse between imports (contains state cache) + codedb *state.CodeDB // The database handler for maintaining contract codes. txIndexer *txIndexer // Transaction indexer, might be nil if not enabled hc *HeaderChain @@ -309,6 +337,7 @@ type BlockChain struct { chainHeadFeed event.Feed logsFeed event.Feed blockProcFeed event.Feed + newPayloadFeed event.Feed // Feed for engine API newPayload events blockProcCounter int32 scope event.SubscriptionScope genesisBlock *types.Block @@ -354,7 +383,7 @@ func NewBlockChain(db ethdb.Database, genesis *Genesis, engine consensus.Engine, } // Open trie database with provided config - enableVerkle, err := EnableVerkleAtGenesis(db, genesis) + enableVerkle, err := EnableUBTAtGenesis(db, genesis) if err != nil { return nil, err } @@ -364,7 +393,7 @@ func NewBlockChain(db ethdb.Database, genesis *Genesis, engine consensus.Engine, // yet. The corresponding chain config will be returned, either from the // provided genesis or from the locally stored configuration if the genesis // has already been initialized. - chainConfig, genesisHash, compatErr, err := SetupGenesisBlockWithOverride(db, triedb, genesis, cfg.Overrides) + chainConfig, genesisHash, compatErr, err := SetupGenesisBlockWithOverride(db, triedb, genesis, cfg.Overrides, cfg.VmConfig.Tracer) if err != nil { return nil, err } @@ -381,6 +410,7 @@ func NewBlockChain(db ethdb.Database, genesis *Genesis, engine consensus.Engine, cfg: cfg, db: db, triedb: triedb, + codedb: state.NewCodeDB(db), triegc: prque.New[int64, common.Hash](nil), chainmu: syncx.NewClosableMutex(), bodyCache: lru.NewCache[common.Hash, *types.Body](bodyCacheLimit), @@ -397,7 +427,6 @@ func NewBlockChain(db ethdb.Database, genesis *Genesis, engine consensus.Engine, return nil, err } bc.flushInterval.Store(int64(cfg.TrieTimeLimit)) - bc.statedb = state.NewDatabase(bc.triedb, nil) bc.validator = NewBlockValidator(chainConfig, bc) bc.prefetcher = newStatePrefetcher(chainConfig, bc.hc) bc.processor = NewStateProcessor(bc.hc) @@ -538,10 +567,10 @@ func NewBlockChain(db ethdb.Database, genesis *Genesis, engine consensus.Engine, // Start state size tracker if bc.cfg.StateSizeTracking { - stateSizer, err := state.NewSizeTracker(bc.db, bc.triedb) + stateSizer, err := state.NewSizeTracker(bc.db, bc.triedb, bc.cfg.StateSizeTrackingDepth) if err == nil { bc.stateSizer = stateSizer - log.Info("Enabled state size metrics") + log.Info("Enabled state size metrics", "depth", bc.cfg.StateSizeTrackingDepth) } else { log.Info("Failed to setup size tracker", "err", err) } @@ -574,9 +603,6 @@ func (bc *BlockChain) setupSnapshot() { AsyncBuild: !bc.cfg.SnapshotWait, } bc.snaps, _ = snapshot.New(snapconfig, bc.db, bc.triedb, head.Root) - - // Re-initialize the state database with snapshot - bc.statedb = state.NewDatabase(bc.triedb, bc.snaps) } } @@ -694,45 +720,43 @@ func (bc *BlockChain) loadLastState() error { // initializeHistoryPruning sets bc.historyPrunePoint. func (bc *BlockChain) initializeHistoryPruning(latest uint64) error { freezerTail, _ := bc.db.Tail() + policy := bc.cfg.HistoryPolicy - switch bc.cfg.ChainHistoryMode { + switch policy.Mode { case history.KeepAll: - if freezerTail == 0 { - return nil - } - // The database was pruned somehow, so we need to figure out if it's a known - // configuration or an error. - predefinedPoint := history.PrunePoints[bc.genesisBlock.Hash()] - if predefinedPoint == nil || freezerTail != predefinedPoint.BlockNumber { - log.Error("Chain history database is pruned with unknown configuration", "tail", freezerTail) - return errors.New("unexpected database tail") + if freezerTail > 0 { + // Database was pruned externally. Record the actual state. + log.Warn("Chain history database is pruned", "tail", freezerTail, "mode", policy.Mode) + bc.historyPrunePoint.Store(&history.PrunePoint{ + BlockNumber: freezerTail, + BlockHash: bc.GetCanonicalHash(freezerTail), + }) } - bc.historyPrunePoint.Store(predefinedPoint) return nil - case history.KeepPostMerge: - if freezerTail == 0 && latest != 0 { - // This is the case where a user is trying to run with --history.chain - // postmerge directly on an existing DB. We could just trigger the pruning - // here, but it'd be a bit dangerous since they may not have intended this - // action to happen. So just tell them how to do it. - log.Error(fmt.Sprintf("Chain history mode is configured as %q, but database is not pruned.", bc.cfg.ChainHistoryMode.String())) - log.Error(fmt.Sprintf("Run 'geth prune-history' to prune pre-merge history.")) - return errors.New("history pruning requested via configuration") - } - predefinedPoint := history.PrunePoints[bc.genesisBlock.Hash()] - if predefinedPoint == nil { - log.Error("Chain history pruning is not supported for this network", "genesis", bc.genesisBlock.Hash()) - return errors.New("history pruning requested for unknown network") - } else if freezerTail > 0 && freezerTail != predefinedPoint.BlockNumber { - log.Error("Chain history database is pruned to unknown block", "tail", freezerTail) - return errors.New("unexpected database tail") - } - bc.historyPrunePoint.Store(predefinedPoint) + case history.KeepPostMerge, history.KeepPostPrague: + target := policy.Target + // Already at the target. + if freezerTail == target.BlockNumber { + bc.historyPrunePoint.Store(target) + return nil + } + // Database is pruned beyond the target. + if freezerTail > target.BlockNumber { + return fmt.Errorf("database pruned beyond requested history (tail=%d, target=%d)", freezerTail, target.BlockNumber) + } + // Database needs pruning (freezerTail < target). + if latest != 0 { + log.Error(fmt.Sprintf("Chain history mode is configured as %q, but database is not pruned to the target block.", policy.Mode.String())) + log.Error(fmt.Sprintf("Run 'geth prune-history --history.chain %s' to prune history.", policy.Mode.String())) + return errors.New("history pruning required") + } + // Fresh database (latest == 0), will sync from target point. + bc.historyPrunePoint.Store(target) return nil default: - return fmt.Errorf("invalid history mode: %d", bc.cfg.ChainHistoryMode) + return fmt.Errorf("invalid history mode: %d", policy.Mode) } } @@ -743,21 +767,7 @@ func (bc *BlockChain) SetHead(head uint64) error { if _, err := bc.setHeadBeyondRoot(head, 0, common.Hash{}, false); err != nil { return err } - // Send chain head event to update the transaction pool - header := bc.CurrentBlock() - if block := bc.GetBlock(header.Hash(), header.Number.Uint64()); block == nil { - // In a pruned node the genesis block will not exist in the freezer. - // It should not happen that we set head to any other pruned block. - if header.Number.Uint64() > 0 { - // This should never happen. In practice, previously currentBlock - // contained the entire block whereas now only a "marker", so there - // is an ever so slight chance for a race we should handle. - log.Error("Current block not found in database", "block", header.Number, "hash", header.Hash()) - return fmt.Errorf("current block missing: #%d [%x..]", header.Number, header.Hash().Bytes()[:4]) - } - } - bc.chainHeadFeed.Send(ChainHeadEvent{Header: header}) - return nil + return bc.sendChainHeadEvent() } // SetHeadWithTimestamp rewinds the local chain to a new head that has at max @@ -768,7 +778,12 @@ func (bc *BlockChain) SetHeadWithTimestamp(timestamp uint64) error { if _, err := bc.setHeadBeyondRoot(0, timestamp, common.Hash{}, false); err != nil { return err } - // Send chain head event to update the transaction pool + return bc.sendChainHeadEvent() +} + +// sendChainHeadEvent notifies all subscribers about the new chain head, +// checking first that the current block is actually available. +func (bc *BlockChain) sendChainHeadEvent() error { header := bc.CurrentBlock() if block := bc.GetBlock(header.Hash(), header.Number.Uint64()); block == nil { // In a pruned node the genesis block will not exist in the freezer. @@ -951,7 +966,8 @@ func (bc *BlockChain) rewindPathHead(head *types.Header, root common.Hash) (*typ // Recover if the target state if it's not available yet. if !bc.HasState(head.Root) { if err := bc.triedb.Recover(head.Root); err != nil { - log.Crit("Failed to rollback state", "err", err) + log.Error("Failed to rollback state, resetting to genesis", "err", err) + return bc.genesisBlock.Header(), rootNumber } } log.Info("Rewound to block with state", "number", head.Number, "hash", head.Hash()) @@ -1102,25 +1118,60 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, time uint64, root common.Ha bc.txLookupCache.Purge() // Clear safe block, finalized block if needed - if safe := bc.CurrentSafeBlock(); safe != nil && head < safe.Number.Uint64() { + headBlock := bc.CurrentBlock() + if safe := bc.CurrentSafeBlock(); safe != nil && headBlock.Number.Uint64() < safe.Number.Uint64() { log.Warn("SetHead invalidated safe block") bc.SetSafe(nil) } - if finalized := bc.CurrentFinalBlock(); finalized != nil && head < finalized.Number.Uint64() { + if finalized := bc.CurrentFinalBlock(); finalized != nil && headBlock.Number.Uint64() < finalized.Number.Uint64() { log.Error("SetHead invalidated finalized block") bc.SetFinalized(nil) } return rootNumber, bc.loadLastState() } -// SnapSyncCommitHead sets the current head block to the one defined by the hash -// irrelevant what the chain contents were prior. -func (bc *BlockChain) SnapSyncCommitHead(hash common.Hash) error { +// SnapSyncStart disables the underlying databases (such as the trie DB and the +// optional state snapshot) to prevent potential concurrent mutations between +// snap sync and other chain operations. +func (bc *BlockChain) SnapSyncStart() error { + if !bc.chainmu.TryLock() { + return errChainStopped + } + defer bc.chainmu.Unlock() + + // Snap sync will directly modify the persistent state, making the entire + // trie database unusable until the state is fully synced. To prevent any + // subsequent state reads, explicitly disable the trie database and state + // syncer is responsible to address and correct any state missing. + if bc.TrieDB().Scheme() == rawdb.PathScheme { + if err := bc.TrieDB().Disable(); err != nil { + return err + } + } + // Snap sync uses the snapshot namespace to store potentially flaky data until + // sync completely heals and finishes. Pause snapshot maintenance in the mean- + // time to prevent access. + if snapshots := bc.Snapshots(); snapshots != nil { // Only nil in tests + snapshots.Disable() + } + return nil +} + +// SnapSyncComplete sets the current head block to the block identified by the +// given hash, regardless of the chain contents prior to snap sync. It is +// invoked once snap sync completes and assumes that SnapSyncStart was called +// previously. +func (bc *BlockChain) SnapSyncComplete(hash common.Hash) error { // Make sure that both the block as well at its state trie exists block := bc.GetBlockByHash(hash) if block == nil { return fmt.Errorf("non existent block [%x..]", hash[:4]) } + if !bc.chainmu.TryLock() { + return errChainStopped + } + defer bc.chainmu.Unlock() + // Reset the trie database with the fresh snap synced state. root := block.Root() if bc.triedb.Scheme() == rawdb.PathScheme { @@ -1131,19 +1182,17 @@ func (bc *BlockChain) SnapSyncCommitHead(hash common.Hash) error { if !bc.HasState(root) { return fmt.Errorf("non existent state [%x..]", root[:4]) } - // If all checks out, manually set the head block. - if !bc.chainmu.TryLock() { - return errChainStopped - } - bc.currentBlock.Store(block.Header()) - headBlockGauge.Update(int64(block.NumberU64())) - bc.chainmu.Unlock() - // Destroy any existing state snapshot and regenerate it in the background, // also resuming the normal maintenance of any previously paused snapshot. if bc.snaps != nil { bc.snaps.Rebuild(root) } + + // If all checks out, manually set the head block. + rawdb.WriteHeadBlockHash(bc.db, hash) + bc.currentBlock.Store(block.Header()) + headBlockGauge.Update(int64(block.NumberU64())) + log.Info("Committed new head block", "number", block.Number(), "hash", hash) return nil } @@ -1232,6 +1281,8 @@ func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error { func (bc *BlockChain) writeHeadBlock(block *types.Block) { // Add the block to the canonical chain number scheme and mark as the head batch := bc.db.NewBatch() + defer batch.Close() + rawdb.WriteHeadHeaderHash(batch, block.Hash()) rawdb.WriteHeadFastBlockHash(batch, block.Hash()) rawdb.WriteCanonicalHash(batch, block.Hash(), block.NumberU64()) @@ -1602,29 +1653,51 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types. // // Note all the components of block(hash->number map, header, body, receipts) // should be written atomically. BlockBatch is used for containing all components. - blockBatch := bc.db.NewBatch() - rawdb.WriteBlock(blockBatch, block) - rawdb.WriteReceipts(blockBatch, block.Hash(), block.NumberU64(), receipts) - rawdb.WritePreimages(blockBatch, statedb.Preimages()) - if err := blockBatch.Write(); err != nil { + var ( + batch = bc.db.NewBatch() + start = time.Now() + ) + defer batch.Close() + + rawdb.WriteBlock(batch, block) + rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), receipts) + rawdb.WritePreimages(batch, statedb.Preimages()) + if err := batch.Write(); err != nil { log.Crit("Failed to write block into disk", "err", err) } + log.Debug("Committed block data", "size", common.StorageSize(batch.ValueSize()), "elapsed", common.PrettyDuration(time.Since(start))) var ( - err error - root common.Hash - isEIP158 = bc.chainConfig.IsEIP158(block.Number()) - isCancun = bc.chainConfig.IsCancun(block.Number(), block.Time()) + err error + root common.Hash + isEIP158 = bc.chainConfig.IsEIP158(block.Number()) + isCancun = bc.chainConfig.IsCancun(block.Number(), block.Time()) + hasStateHook = bc.logger != nil && bc.logger.OnStateUpdate != nil + hasStateSizer = bc.stateSizer != nil ) - if bc.stateSizer == nil { - root, err = statedb.Commit(block.NumberU64(), isEIP158, isCancun) + if hasStateHook || hasStateSizer { + r, update, err := statedb.CommitWithUpdate(block.NumberU64(), isEIP158, isCancun) + if err != nil { + return err + } + update.BlockHash = block.Hash() + if hasStateHook { + trUpdate, err := update.ToTracingUpdate() + if err != nil { + return err + } + bc.logger.OnStateUpdate(trUpdate) + } + if hasStateSizer { + bc.stateSizer.Notify(update) + } + root = r } else { - root, err = statedb.CommitAndTrack(block.NumberU64(), isEIP158, isCancun, bc.stateSizer) - } - if err != nil { - return err + root, err = statedb.Commit(block.NumberU64(), isEIP158, isCancun) + if err != nil { + return err + } } - // If node is running in path mode, skip explicit gc operation // which is unnecessary in this mode. if bc.triedb.Scheme() == rawdb.PathScheme { @@ -1754,7 +1827,7 @@ func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) { } defer bc.chainmu.Unlock() - _, n, err := bc.insertChain(chain, true, false) // No witness collection for mass inserts (would get super large) + _, n, err := bc.insertChain(context.Background(), chain, true, false) // No witness collection for mass inserts (would get super large) return n, err } @@ -1766,7 +1839,7 @@ func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) { // racey behaviour. If a sidechain import is in progress, and the historic state // is imported, but then new canon-head is added before the actual sidechain // completes, then the historic state could be pruned again -func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness bool) (*stateless.Witness, int, error) { +func (bc *BlockChain) insertChain(ctx context.Context, chain types.Blocks, setHead bool, makeWitness bool) (*stateless.Witness, int, error) { // If the chain is terminating, don't even bother starting up. if bc.insertStopped() { return nil, 0, nil @@ -1848,11 +1921,11 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness if setHead { // First block is pruned, insert as sidechain and reorg only if TD grows enough log.Debug("Pruned ancestor, inserting as sidechain", "number", block.Number(), "hash", block.Hash()) - return bc.insertSideChain(block, it, makeWitness) + return bc.insertSideChain(ctx, block, it, makeWitness) } else { // We're post-merge and the parent is pruned, try to recover the parent state log.Debug("Pruned ancestor", "number", block.Number(), "hash", block.Hash()) - _, err := bc.recoverAncestors(block, makeWitness) + _, err := bc.recoverAncestors(ctx, block, makeWitness) return nil, it.index, err } // Some other error(except ErrKnownBlock) occurred, abort. @@ -1924,7 +1997,15 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness } // The traced section of block import. start := time.Now() - res, err := bc.ProcessBlock(parent.Root, block, setHead, makeWitness && len(chain) == 1) + config := ExecuteConfig{ + WriteState: true, + WriteHead: setHead, + EnableTracer: true, + MakeWitness: makeWitness && len(chain) == 1, + StatelessSelfValidation: bc.cfg.StatelessSelfValidation, + EnableWitnessStats: bc.cfg.EnableWitnessStats, + } + res, err := bc.ProcessBlock(ctx, parent.Root, block, config) if err != nil { return nil, it.index, err } @@ -2007,19 +2088,65 @@ func (bpr *blockProcessingResult) Stats() *ExecuteStats { return bpr.stats } +// ExecuteConfig defines optional behaviors during execution. +type ExecuteConfig struct { + // WriteState controls whether the computed state changes are persisted to + // the underlying storage. If false, execution is performed in-memory only. + WriteState bool + + // WriteHead indicates whether the execution result should update the canonical + // chain head. It's only relevant with WriteState == True. + WriteHead bool + + // EnableTracer enables execution tracing. This is typically used for debugging + // or analysis and may significantly impact performance. + EnableTracer bool + + // MakeWitness indicates whether to generate execution witness data during + // execution. Enabling this may introduce additional memory and CPU overhead. + MakeWitness bool + + // StatelessSelfValidation indicates whether the execution witnesses generation + // and self-validation (testing purpose) is enabled. + StatelessSelfValidation bool + + // EnableWitnessStats indicates whether to enable collection of witness trie + // access statistics + EnableWitnessStats bool +} + // ProcessBlock executes and validates the given block. If there was no error // it writes the block and associated state to database. -func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, setHead bool, makeWitness bool) (result *blockProcessingResult, blockEndErr error) { +func (bc *BlockChain) ProcessBlock(ctx context.Context, parentRoot common.Hash, block *types.Block, config ExecuteConfig) (result *blockProcessingResult, blockEndErr error) { var ( err error startTime = time.Now() statedb *state.StateDB interrupt atomic.Bool + sdb state.Database ) defer interrupt.Store(true) // terminate the prefetch at the end - if bc.cfg.NoPrefetch { - statedb, err = state.New(parentRoot, bc.statedb) + if bc.chainConfig.IsUBT(block.Number(), block.Time()) { + sdb = state.NewUBTDatabase(bc.triedb, bc.codedb) + } else { + sdb = state.NewMPTDatabase(bc.triedb, bc.codedb).WithSnapshot(bc.snaps) + } + // If prefetching is enabled, run that against the current state to pre-cache + // transactions and probabilistically some of the account/storage trie nodes. + // + // Note: the main processor and prefetcher share the same reader with a local + // cache for mitigating the overhead of state access. + type prewarmReader interface { + // ReadersWithCacheStats creates a pair of state readers that share the + // same underlying state reader and internal state cache, while maintaining + // separate statistics respectively. + ReadersWithCacheStats(stateRoot common.Hash) (state.Reader, state.Reader, error) + } + warmer, ok := sdb.(prewarmReader) + + if bc.cfg.NoPrefetch || !ok { + statedb, err = state.New(parentRoot, sdb) if err != nil { return nil, err } @@ -2029,38 +2156,29 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s // // Note: the main processor and prefetcher share the same reader with a local // cache for mitigating the overhead of state access. - prefetch, process, err := bc.statedb.ReadersWithCacheStats(parentRoot) + prefetch, process, err := warmer.ReadersWithCacheStats(parentRoot) if err != nil { return nil, err } - throwaway, err := state.NewWithReader(parentRoot, bc.statedb, prefetch) + throwaway, err := state.NewWithReader(parentRoot, sdb, prefetch) if err != nil { return nil, err } - statedb, err = state.NewWithReader(parentRoot, bc.statedb, process) + statedb, err = state.NewWithReader(parentRoot, sdb, process) if err != nil { return nil, err } // Upload the statistics of reader at the end defer func() { - pStat := prefetch.GetStats() - accountCacheHitPrefetchMeter.Mark(pStat.AccountCacheHit) - accountCacheMissPrefetchMeter.Mark(pStat.AccountCacheMiss) - storageCacheHitPrefetchMeter.Mark(pStat.StorageCacheHit) - storageCacheMissPrefetchMeter.Mark(pStat.StorageCacheMiss) - - rStat := process.GetStats() - accountCacheHitMeter.Mark(rStat.AccountCacheHit) - accountCacheMissMeter.Mark(rStat.AccountCacheMiss) - storageCacheHitMeter.Mark(rStat.StorageCacheHit) - storageCacheMissMeter.Mark(rStat.StorageCacheMiss) - if result != nil { - result.stats.StatePrefetchCacheStats = pStat - result.stats.StateReadCacheStats = rStat + if stater, ok := prefetch.(state.ReaderStater); ok { + result.stats.StatePrefetchCacheStats = stater.GetStats() + } + if stater, ok := process.(state.ReaderStater); ok { + result.stats.StateReadCacheStats = stater.GetStats() + } } }() - go func(start time.Time, throwaway *state.StateDB, block *types.Block) { // Disable tracing for prefetcher executions. vmCfg := bc.cfg.VmConfig @@ -2077,43 +2195,42 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s // If we are past Byzantium, enable prefetching to pull in trie node paths // while processing transactions. Before Byzantium the prefetcher is mostly // useless due to the intermediate root hashing after each transaction. - var ( - witness *stateless.Witness - witnessStats *stateless.WitnessStats - ) + var witness *stateless.Witness if bc.chainConfig.IsByzantium(block.Number()) { // Generate witnesses either if we're self-testing, or if it's the // only block being inserted. A bit crude, but witnesses are huge, // so we refuse to make an entire chain of them. - if bc.cfg.VmConfig.StatelessSelfValidation || makeWitness { - witness, err = stateless.NewWitness(block.Header(), bc) + if config.StatelessSelfValidation || config.MakeWitness { + witness, err = stateless.NewWitness(block.Header(), bc, config.EnableWitnessStats) if err != nil { return nil, err } - if bc.cfg.VmConfig.EnableWitnessStats { - witnessStats = stateless.NewWitnessStats() - } } - statedb.StartPrefetcher("chain", witness, witnessStats) + statedb.StartPrefetcher("chain", witness) defer statedb.StopPrefetcher() } - if bc.logger != nil && bc.logger.OnBlockStart != nil { - bc.logger.OnBlockStart(tracing.BlockEvent{ - Block: block, - Finalized: bc.CurrentFinalBlock(), - Safe: bc.CurrentSafeBlock(), - }) - } - if bc.logger != nil && bc.logger.OnBlockEnd != nil { - defer func() { - bc.logger.OnBlockEnd(blockEndErr) - }() + // Instrument the blockchain tracing + if config.EnableTracer { + if bc.logger != nil && bc.logger.OnBlockStart != nil { + bc.logger.OnBlockStart(tracing.BlockEvent{ + Block: block, + Finalized: bc.CurrentFinalBlock(), + Safe: bc.CurrentSafeBlock(), + }) + } + if bc.logger != nil && bc.logger.OnBlockEnd != nil { + defer func() { + bc.logger.OnBlockEnd(blockEndErr) + }() + } } // Process block using the parent state as reference point pstart := time.Now() - res, err := bc.processor.Process(block, statedb, bc.cfg.VmConfig) + pctx, _, spanEnd := telemetry.StartSpan(ctx, "bc.processor.Process") + res, err := bc.processor.Process(pctx, block, statedb, bc.cfg.VmConfig) + spanEnd(&err) if err != nil { bc.reportBadBlock(block, res, err) return nil, err @@ -2121,7 +2238,10 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s ptime := time.Since(pstart) vstart := time.Now() - if err := bc.validator.ValidateState(block, statedb, res, false); err != nil { + _, _, spanEnd = telemetry.StartSpan(ctx, "bc.validator.ValidateState") + err = bc.validator.ValidateState(block, statedb, res, false) + spanEnd(&err) + if err != nil { bc.reportBadBlock(block, res, err) return nil, err } @@ -2133,7 +2253,7 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s // witness builder/runner, which would otherwise be impossible due to the // various invalid chain states/behaviors being contained in those tests. xvstart := time.Now() - if witness := statedb.Witness(); witness != nil && bc.cfg.VmConfig.StatelessSelfValidation { + if witness := statedb.Witness(); witness != nil && config.StatelessSelfValidation { log.Warn("Running stateless self-validation", "block", block.Number(), "hash", block.Hash()) // Remove critical computed fields from the block to force true recalculation @@ -2144,7 +2264,7 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s task := types.NewBlockWithHeader(context).WithBody(*block.Body()) // Run the stateless self-cross-validation - crossStateRoot, crossReceiptRoot, err := ExecuteStateless(bc.chainConfig, bc.cfg.VmConfig, task, witness) + crossStateRoot, crossReceiptRoot, err := ExecuteStateless(ctx, bc.chainConfig, bc.cfg.VmConfig, task, witness) if err != nil { return nil, fmt.Errorf("stateless self-validation failed: %v", err) } @@ -2167,6 +2287,7 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s stats.AccountUpdates = statedb.AccountUpdates // Account updates are complete(in validation) stats.StorageUpdates = statedb.StorageUpdates // Storage updates are complete(in validation) stats.AccountHashes = statedb.AccountHashes // Account hashes are complete(in validation) + stats.CodeReads = statedb.CodeReads stats.AccountLoaded = statedb.AccountLoaded stats.AccountUpdated = statedb.AccountUpdated @@ -2175,36 +2296,38 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s stats.StorageUpdated = int(statedb.StorageUpdated.Load()) stats.StorageDeleted = int(statedb.StorageDeleted.Load()) - stats.Execution = ptime - (statedb.AccountReads + statedb.StorageReads) // The time spent on EVM processing + stats.CodeLoaded = statedb.CodeLoaded + stats.CodeLoadBytes = statedb.CodeLoadBytes + stats.CodeUpdated = statedb.CodeUpdated + stats.CodeUpdateBytes = statedb.CodeUpdateBytes + + stats.Execution = ptime - (statedb.AccountReads + statedb.StorageReads + statedb.CodeReads) // The time spent on EVM processing stats.Validation = vtime - (statedb.AccountHashes + statedb.AccountUpdates + statedb.StorageUpdates) // The time spent on block validation stats.CrossValidation = xvtime // The time spent on stateless cross validation // Write the block to the chain and get the status. - var ( - wstart = time.Now() - status WriteStatus - ) - if !setHead { - // Don't set the head, only insert the block - err = bc.writeBlockWithState(block, res.Receipts, statedb) - } else { - status, err = bc.writeBlockAndSetHead(block, res.Receipts, res.Logs, statedb, false) - } - if err != nil { - return nil, err + var status WriteStatus + if config.WriteState { + wstart := time.Now() + if !config.WriteHead { + // Don't set the head, only insert the block + err = bc.writeBlockWithState(block, res.Receipts, statedb) + } else { + status, err = bc.writeBlockAndSetHead(block, res.Receipts, res.Logs, statedb, false) + } + if err != nil { + return nil, err + } + // Update the metrics touched during block commit + stats.AccountCommits = statedb.AccountCommits // Account commits are complete, we can mark them + stats.StorageCommits = statedb.StorageCommits // Storage commits are complete, we can mark them + stats.DatabaseCommit = statedb.DatabaseCommits // Database commits are complete, we can mark them + stats.BlockWrite = time.Since(wstart) - max(statedb.AccountCommits, statedb.StorageCommits) /* concurrent */ - statedb.DatabaseCommits } // Report the collected witness statistics - if witnessStats != nil { - witnessStats.ReportMetrics(block.NumberU64()) + if witness != nil { + witness.ReportMetrics(block.NumberU64()) } - - // Update the metrics touched during block commit - stats.AccountCommits = statedb.AccountCommits // Account commits are complete, we can mark them - stats.StorageCommits = statedb.StorageCommits // Storage commits are complete, we can mark them - stats.SnapshotCommit = statedb.SnapshotCommits // Snapshot commits are complete, we can mark them - stats.TrieDBCommit = statedb.TrieDBCommits // Trie database commits are complete, we can mark them - stats.BlockWrite = time.Since(wstart) - max(statedb.AccountCommits, statedb.StorageCommits) /* concurrent */ - statedb.SnapshotCommits - statedb.TrieDBCommits - elapsed := time.Since(startTime) + 1 // prevent zero division stats.TotalTime = elapsed stats.MgasPerSecond = float64(res.GasUsed) * 1000 / float64(elapsed) @@ -2225,7 +2348,7 @@ func (bc *BlockChain) ProcessBlock(parentRoot common.Hash, block *types.Block, s // The method writes all (header-and-body-valid) blocks to disk, then tries to // switch over to the new chain if the TD exceeded the current chain. // insertSideChain is only used pre-merge. -func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator, makeWitness bool) (*stateless.Witness, int, error) { +func (bc *BlockChain) insertSideChain(ctx context.Context, block *types.Block, it *insertIterator, makeWitness bool) (*stateless.Witness, int, error) { var current = bc.CurrentBlock() // The first sidechain block error is already verified to be ErrPrunedAncestor. @@ -2306,7 +2429,7 @@ func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator, ma // memory here. if len(blocks) >= 2048 || memory > 64*1024*1024 { log.Info("Importing heavy sidechain segment", "blocks", len(blocks), "start", blocks[0].NumberU64(), "end", block.NumberU64()) - if _, _, err := bc.insertChain(blocks, true, false); err != nil { + if _, _, err := bc.insertChain(ctx, blocks, true, false); err != nil { return nil, 0, err } blocks, memory = blocks[:0], 0 @@ -2320,7 +2443,7 @@ func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator, ma } if len(blocks) > 0 { log.Info("Importing sidechain segment", "start", blocks[0].NumberU64(), "end", blocks[len(blocks)-1].NumberU64()) - return bc.insertChain(blocks, true, makeWitness) + return bc.insertChain(ctx, blocks, true, makeWitness) } return nil, 0, nil } @@ -2329,7 +2452,7 @@ func (bc *BlockChain) insertSideChain(block *types.Block, it *insertIterator, ma // all the ancestor blocks since that. // recoverAncestors is only used post-merge. // We return the hash of the latest block that we could correctly validate. -func (bc *BlockChain) recoverAncestors(block *types.Block, makeWitness bool) (common.Hash, error) { +func (bc *BlockChain) recoverAncestors(ctx context.Context, block *types.Block, makeWitness bool) (common.Hash, error) { // Gather all the sidechain hashes (full blocks may be memory heavy) var ( hashes []common.Hash @@ -2369,7 +2492,7 @@ func (bc *BlockChain) recoverAncestors(block *types.Block, makeWitness bool) (co } else { b = bc.GetBlock(hashes[i], numbers[i]) } - if _, _, err := bc.insertChain(types.Blocks{b}, false, makeWitness && i == 0); err != nil { + if _, _, err := bc.insertChain(ctx, types.Blocks{b}, false, makeWitness && i == 0); err != nil { return b.ParentHash(), err } } @@ -2478,13 +2601,19 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error blockReorgAddMeter.Mark(int64(len(newChain))) } else { // len(newChain) == 0 && len(oldChain) > 0 - // rewind the canonical chain to a lower point. - log.Error("Impossible reorg, please file an issue", "oldnum", oldHead.Number, "oldhash", oldHead.Hash(), "oldblocks", len(oldChain), "newnum", newHead.Number, "newhash", newHead.Hash(), "newblocks", len(newChain)) + // Rewind the canonical chain to a lower point. In EPBs we can reorg to + // a parent of the head within 32 blocks. + if len(oldChain) > 32 { + log.Error("Impossible reorg, please file an issue", "oldnum", oldHead.Number, "oldhash", oldHead.Hash(), "oldblocks", len(oldChain)) + } else { + log.Info("Shorten chain", "del", len(oldChain), "number", oldHead.Number, "hash", oldHead.Hash()) + } } // Acquire the tx-lookup lock before mutation. This step is essential // as the txlookups should be changed atomically, and all subsequent // reads should be blocked until the mutation is complete. bc.txLookupLock.Lock() + defer bc.txLookupLock.Unlock() // Reorg can be executed, start reducing the chain's old blocks and appending // the new blocks @@ -2562,6 +2691,8 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error // Delete useless indexes right now which includes the non-canonical // transaction indexes, canonical chain indexes which above the head. batch := bc.db.NewBatch() + defer batch.Close() + for _, tx := range types.HashDifference(deletedTxs, rebirthTxs) { rawdb.DeleteTxLookupEntry(batch, tx) } @@ -2585,9 +2716,6 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error // Reset the tx lookup cache to clear stale txlookup cache. bc.txLookupCache.Purge() - // Release the tx-lookup lock after mutation. - bc.txLookupLock.Unlock() - return nil } @@ -2596,14 +2724,16 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error // The key difference between the InsertChain is it won't do the canonical chain // updating. It relies on the additional SetCanonical call to finalize the entire // procedure. -func (bc *BlockChain) InsertBlockWithoutSetHead(block *types.Block, makeWitness bool) (*stateless.Witness, error) { +func (bc *BlockChain) InsertBlockWithoutSetHead(ctx context.Context, block *types.Block, makeWitness bool) (witness *stateless.Witness, err error) { + _, _, spanEnd := telemetry.StartSpan(ctx, "core.blockchain.InsertBlockWithoutSetHead") + defer spanEnd(&err) if !bc.chainmu.TryLock() { return nil, errChainStopped } defer bc.chainmu.Unlock() - witness, _, err := bc.insertChain(types.Blocks{block}, false, makeWitness) - return witness, err + witness, _, err = bc.insertChain(ctx, types.Blocks{block}, false, makeWitness) + return } // SetCanonical rewinds the chain to set the new head block as the specified @@ -2617,7 +2747,7 @@ func (bc *BlockChain) SetCanonical(head *types.Block) (common.Hash, error) { // Re-execute the reorged chain in case the head state is missing. if !bc.HasState(head.Root()) { - if latestValidHash, err := bc.recoverAncestors(head, false); err != nil { + if latestValidHash, err := bc.recoverAncestors(context.Background(), head, false); err != nil { return latestValidHash, err } log.Info("Recovered head state", "number", head.Number(), "hash", head.Hash()) diff --git a/core/blockchain_reader.go b/core/blockchain_reader.go index 4894523b0e58..18afa9ce9dd9 100644 --- a/core/blockchain_reader.go +++ b/core/blockchain_reader.go @@ -296,6 +296,14 @@ func (bc *BlockChain) GetReceiptsRLP(hash common.Hash) rlp.RawValue { return rawdb.ReadReceiptsRLP(bc.db, hash, number) } +func (bc *BlockChain) GetAccessListRLP(hash common.Hash) rlp.RawValue { + number, ok := rawdb.ReadHeaderNumber(bc.db, hash) + if !ok { + return nil + } + return rawdb.ReadAccessListRLP(bc.db, hash, number) +} + // GetUnclesInChain retrieves all the uncles from a given block backwards until // a specific distance is reached. func (bc *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.Header { @@ -371,7 +379,7 @@ func (bc *BlockChain) TxIndexDone() bool { // HasState checks if state trie is fully present in the database or not. func (bc *BlockChain) HasState(hash common.Hash) bool { - _, err := bc.statedb.OpenTrie(hash) + _, err := bc.triedb.NodeReader(hash) return err == nil } @@ -403,24 +411,47 @@ func (bc *BlockChain) stateRecoverable(root common.Hash) bool { func (bc *BlockChain) ContractCodeWithPrefix(hash common.Hash) []byte { // TODO(rjl493456442) The associated account address is also required // in Verkle scheme. Fix it once snap-sync is supported for Verkle. - return bc.statedb.ContractCodeWithPrefix(common.Address{}, hash) + return bc.codedb.Reader().CodeWithPrefix(common.Address{}, hash) } // State returns a new mutable state based on the current HEAD block. func (bc *BlockChain) State() (*state.StateDB, error) { - return bc.StateAt(bc.CurrentBlock().Root) + return bc.StateAt(bc.CurrentBlock()) } // StateAt returns a new mutable state based on a particular point in time. -func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) { - return state.New(root, bc.statedb) +func (bc *BlockChain) StateAt(header *types.Header) (*state.StateDB, error) { + if bc.chainConfig.IsUBT(header.Number, header.Time) { + return state.New(header.Root, state.NewUBTDatabase(bc.triedb, bc.codedb)) + } + return state.New(header.Root, state.NewMPTDatabase(bc.triedb, bc.codedb).WithSnapshot(bc.snaps)) +} + +// StateAtForkBoundary returns a new mutable state based on the parent state +// and the given header, handling the transition across the UBT fork. +func (bc *BlockChain) StateAtForkBoundary(parent *types.Header, header *types.Header) (*state.StateDB, error) { + // The parent is already in the UBT fork. + if bc.chainConfig.IsUBT(parent.Number, parent.Time) { + return state.New(parent.Root, state.NewUBTDatabase(bc.triedb, bc.codedb)) + } + // The current block is the first block in the UBT fork + // (i.e., the parent is the last MPT block). + if bc.chainConfig.IsUBT(header.Number, header.Time) { + // TODO(gballet): register chain context if needed + return state.New(parent.Root, state.NewUBTDatabase(bc.triedb, bc.codedb)) + } + // Both the parent and current block are in the MPT fork. + return state.New(parent.Root, state.NewMPTDatabase(bc.triedb, bc.codedb).WithSnapshot(bc.snaps)) } -// HistoricState returns a historic state specified by the given root. +// HistoricState returns a historic state specified by the given header. // Live states are not available and won't be served, please use `State` // or `StateAt` instead. -func (bc *BlockChain) HistoricState(root common.Hash) (*state.StateDB, error) { - return state.New(root, state.NewHistoricDatabase(bc.db, bc.triedb)) +func (bc *BlockChain) HistoricState(header *types.Header) (*state.StateDB, error) { + if bc.chainConfig.IsUBT(header.Number, header.Time) { + return nil, errors.New("historical state over ubt is not yet supported") + } + return state.New(header.Root, state.NewHistoricDatabase(bc.triedb, bc.codedb)) } // Config retrieves the chain's fork configuration. @@ -444,11 +475,6 @@ func (bc *BlockChain) Processor() Processor { return bc.processor } -// StateCache returns the caching database underpinning the blockchain instance. -func (bc *BlockChain) StateCache() state.Database { - return bc.statedb -} - // GasLimit returns the gas limit of the current HEAD block. func (bc *BlockChain) GasLimit() uint64 { return bc.CurrentBlock().GasLimit @@ -473,7 +499,7 @@ func (bc *BlockChain) TxIndexProgress() (TxIndexProgress, error) { } // StateIndexProgress returns the historical state indexing progress. -func (bc *BlockChain) StateIndexProgress() (uint64, error) { +func (bc *BlockChain) StateIndexProgress() (uint64, uint64, error) { return bc.triedb.IndexProgress() } @@ -492,6 +518,11 @@ func (bc *BlockChain) TrieDB() *triedb.Database { return bc.triedb } +// CodeDB retrieves the low level contract code database used for data storage. +func (bc *BlockChain) CodeDB() *state.CodeDB { + return bc.codedb +} + // HeaderChain returns the underlying header chain. func (bc *BlockChain) HeaderChain() *HeaderChain { return bc.hc @@ -522,3 +553,13 @@ func (bc *BlockChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscript func (bc *BlockChain) SubscribeBlockProcessingEvent(ch chan<- bool) event.Subscription { return bc.scope.Track(bc.blockProcFeed.Subscribe(ch)) } + +// SubscribeNewPayloadEvent registers a subscription for NewPayloadEvent. +func (bc *BlockChain) SubscribeNewPayloadEvent(ch chan<- NewPayloadEvent) event.Subscription { + return bc.scope.Track(bc.newPayloadFeed.Subscribe(ch)) +} + +// SendNewPayloadEvent sends a NewPayloadEvent to subscribers. +func (bc *BlockChain) SendNewPayloadEvent(ev NewPayloadEvent) { + bc.newPayloadFeed.Send(ev) +} diff --git a/core/blockchain_sethead_test.go b/core/blockchain_sethead_test.go index 72ca15d7f614..f2fbc003f1cc 100644 --- a/core/blockchain_sethead_test.go +++ b/core/blockchain_sethead_test.go @@ -30,7 +30,6 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core/rawdb" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethdb/pebble" "github.com/ethereum/go-ethereum/params" @@ -2041,7 +2040,6 @@ func testSetHeadWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme dbconfig.HashDB = hashdb.Defaults } chain.triedb = triedb.NewDatabase(chain.db, dbconfig) - chain.statedb = state.NewDatabase(chain.triedb, chain.snaps) // Force run a freeze cycle type freezer interface { diff --git a/core/blockchain_stats.go b/core/blockchain_stats.go index 0cebebc20aa9..d753b0b7000f 100644 --- a/core/blockchain_stats.go +++ b/core/blockchain_stats.go @@ -17,8 +17,7 @@ package core import ( - "fmt" - "strings" + "encoding/json" "time" "github.com/ethereum/go-ethereum/common" @@ -37,19 +36,23 @@ type ExecuteStats struct { AccountCommits time.Duration // Time spent on the account trie commit StorageUpdates time.Duration // Time spent on the storage trie update StorageCommits time.Duration // Time spent on the storage trie commit - - AccountLoaded int // Number of accounts loaded - AccountUpdated int // Number of accounts updated - AccountDeleted int // Number of accounts deleted - StorageLoaded int // Number of storage slots loaded - StorageUpdated int // Number of storage slots updated - StorageDeleted int // Number of storage slots deleted + CodeReads time.Duration // Time spent on the contract code read + + AccountLoaded int // Number of accounts loaded + AccountUpdated int // Number of accounts updated + AccountDeleted int // Number of accounts deleted + StorageLoaded int // Number of storage slots loaded + StorageUpdated int // Number of storage slots updated + StorageDeleted int // Number of storage slots deleted + CodeLoaded int // Number of contract code loaded + CodeLoadBytes int // Number of bytes read from contract code + CodeUpdated int // Number of contract code written (CREATE/CREATE2 + EIP-7702) + CodeUpdateBytes int // Total bytes of code written Execution time.Duration // Time spent on the EVM execution Validation time.Duration // Time spent on the block validation CrossValidation time.Duration // Optional, time spent on the block cross validation - SnapshotCommit time.Duration // Time spent on snapshot commit - TrieDBCommit time.Duration // Time spent on database commit + DatabaseCommit time.Duration // Time spent on database commit BlockWrite time.Duration // Time spent on block write TotalTime time.Duration // The total time spent on block execution MgasPerSecond float64 // The million gas processed per second @@ -61,78 +64,192 @@ type ExecuteStats struct { // reportMetrics uploads execution statistics to the metrics system. func (s *ExecuteStats) reportMetrics() { - accountReadTimer.Update(s.AccountReads) // Account reads are complete(in processing) - storageReadTimer.Update(s.StorageReads) // Storage reads are complete(in processing) if s.AccountLoaded != 0 { + accountReadTimer.Update(s.AccountReads) accountReadSingleTimer.Update(s.AccountReads / time.Duration(s.AccountLoaded)) } if s.StorageLoaded != 0 { + storageReadTimer.Update(s.StorageReads) storageReadSingleTimer.Update(s.StorageReads / time.Duration(s.StorageLoaded)) } - + if s.CodeLoaded != 0 { + codeReadTimer.Update(s.CodeReads) + codeReadSingleTimer.Update(s.CodeReads / time.Duration(s.CodeLoaded)) + codeReadBytesTimer.Update(time.Duration(s.CodeLoadBytes)) + } accountUpdateTimer.Update(s.AccountUpdates) // Account updates are complete(in validation) storageUpdateTimer.Update(s.StorageUpdates) // Storage updates are complete(in validation) accountHashTimer.Update(s.AccountHashes) // Account hashes are complete(in validation) - accountCommitTimer.Update(s.AccountCommits) // Account commits are complete, we can mark them storageCommitTimer.Update(s.StorageCommits) // Storage commits are complete, we can mark them blockExecutionTimer.Update(s.Execution) // The time spent on EVM processing blockValidationTimer.Update(s.Validation) // The time spent on block validation blockCrossValidationTimer.Update(s.CrossValidation) // The time spent on stateless cross validation - snapshotCommitTimer.Update(s.SnapshotCommit) // Snapshot commits are complete, we can mark them - triedbCommitTimer.Update(s.TrieDBCommit) // Trie database commits are complete, we can mark them + triedbCommitTimer.Update(s.DatabaseCommit) // Trie database commits are complete, we can mark them blockWriteTimer.Update(s.BlockWrite) // The time spent on block write blockInsertTimer.Update(s.TotalTime) // The total time spent on block execution chainMgaspsMeter.Update(time.Duration(s.MgasPerSecond)) // TODO(rjl493456442) generalize the ResettingTimer // Cache hit rates - accountCacheHitPrefetchMeter.Mark(s.StatePrefetchCacheStats.AccountCacheHit) - accountCacheMissPrefetchMeter.Mark(s.StatePrefetchCacheStats.AccountCacheMiss) - storageCacheHitPrefetchMeter.Mark(s.StatePrefetchCacheStats.StorageCacheHit) - storageCacheMissPrefetchMeter.Mark(s.StatePrefetchCacheStats.StorageCacheMiss) - - accountCacheHitMeter.Mark(s.StateReadCacheStats.AccountCacheHit) - accountCacheMissMeter.Mark(s.StateReadCacheStats.AccountCacheMiss) - storageCacheHitMeter.Mark(s.StateReadCacheStats.StorageCacheHit) - storageCacheMissMeter.Mark(s.StateReadCacheStats.StorageCacheMiss) + accountCacheHitPrefetchMeter.Mark(s.StatePrefetchCacheStats.StateStats.AccountCacheHit) + accountCacheMissPrefetchMeter.Mark(s.StatePrefetchCacheStats.StateStats.AccountCacheMiss) + storageCacheHitPrefetchMeter.Mark(s.StatePrefetchCacheStats.StateStats.StorageCacheHit) + storageCacheMissPrefetchMeter.Mark(s.StatePrefetchCacheStats.StateStats.StorageCacheMiss) + + accountCacheHitMeter.Mark(s.StateReadCacheStats.StateStats.AccountCacheHit) + accountCacheMissMeter.Mark(s.StateReadCacheStats.StateStats.AccountCacheMiss) + storageCacheHitMeter.Mark(s.StateReadCacheStats.StateStats.StorageCacheHit) + storageCacheMissMeter.Mark(s.StateReadCacheStats.StateStats.StorageCacheMiss) +} + +// slowBlockLog represents the JSON structure for slow block logging. +// This format is designed for cross-client compatibility with other +// Ethereum execution clients (reth, Besu, Nethermind). +type slowBlockLog struct { + Level string `json:"level"` + Msg string `json:"msg"` + Block slowBlockInfo `json:"block"` + Timing slowBlockTime `json:"timing"` + Throughput slowBlockThru `json:"throughput"` + StateReads slowBlockReads `json:"state_reads"` + StateWrites slowBlockWrites `json:"state_writes"` + Cache slowBlockCache `json:"cache"` +} + +type slowBlockInfo struct { + Number uint64 `json:"number"` + Hash common.Hash `json:"hash"` + GasUsed uint64 `json:"gas_used"` + TxCount int `json:"tx_count"` +} + +type slowBlockTime struct { + ExecutionMs float64 `json:"execution_ms"` + StateReadMs float64 `json:"state_read_ms"` + StateHashMs float64 `json:"state_hash_ms"` + CommitMs float64 `json:"commit_ms"` + TotalMs float64 `json:"total_ms"` +} + +type slowBlockThru struct { + MgasPerSec float64 `json:"mgas_per_sec"` +} + +type slowBlockReads struct { + Accounts int `json:"accounts"` + StorageSlots int `json:"storage_slots"` + Code int `json:"code"` + CodeBytes int `json:"code_bytes"` +} + +type slowBlockWrites struct { + Accounts int `json:"accounts"` + AccountsDeleted int `json:"accounts_deleted"` + StorageSlots int `json:"storage_slots"` + StorageSlotsDeleted int `json:"storage_slots_deleted"` + Code int `json:"code"` + CodeBytes int `json:"code_bytes"` +} + +// slowBlockCache represents cache hit/miss statistics for cross-client analysis. +type slowBlockCache struct { + Account slowBlockCacheEntry `json:"account"` + Storage slowBlockCacheEntry `json:"storage"` + Code slowBlockCodeCacheEntry `json:"code"` +} + +// slowBlockCacheEntry represents cache statistics for account/storage caches. +type slowBlockCacheEntry struct { + Hits int64 `json:"hits"` + Misses int64 `json:"misses"` + HitRate float64 `json:"hit_rate"` } -// logSlow prints the detailed execution statistics if the block is regarded as slow. +// slowBlockCodeCacheEntry represents cache statistics for code cache with byte-level granularity. +type slowBlockCodeCacheEntry struct { + Hits int64 `json:"hits"` + Misses int64 `json:"misses"` + HitRate float64 `json:"hit_rate"` + HitBytes int64 `json:"hit_bytes"` + MissBytes int64 `json:"miss_bytes"` +} + +// durationToMs converts a time.Duration to milliseconds as a float64 +// with sub-millisecond precision for accurate cross-client metrics. +func durationToMs(d time.Duration) float64 { + return float64(d.Nanoseconds()) / 1e6 +} + +// logSlow prints the detailed execution statistics in JSON format if the block +// is regarded as slow. The JSON format is designed for cross-client compatibility +// with other Ethereum execution clients. func (s *ExecuteStats) logSlow(block *types.Block, slowBlockThreshold time.Duration) { - if slowBlockThreshold == 0 { + // Negative threshold means disabled (default when flag not set) + if slowBlockThreshold < 0 { return } - if s.TotalTime < slowBlockThreshold { + // Threshold of 0 logs all blocks; positive threshold filters + if slowBlockThreshold > 0 && s.TotalTime < slowBlockThreshold { return } - msg := fmt.Sprintf(` -########## SLOW BLOCK ######### -Block: %v (%#x) txs: %d, mgasps: %.2f, elapsed: %v - -EVM execution: %v -Validation: %v -Account read: %v(%d) -Storage read: %v(%d) -Account hash: %v -Storage hash: %v -DB commit: %v -Block write: %v - -%s -############################## -`, block.Number(), block.Hash(), len(block.Transactions()), s.MgasPerSecond, common.PrettyDuration(s.TotalTime), - common.PrettyDuration(s.Execution), common.PrettyDuration(s.Validation+s.CrossValidation), - common.PrettyDuration(s.AccountReads), s.AccountLoaded, - common.PrettyDuration(s.StorageReads), s.StorageLoaded, - common.PrettyDuration(s.AccountHashes+s.AccountCommits+s.AccountUpdates), - common.PrettyDuration(s.StorageCommits+s.StorageUpdates), - common.PrettyDuration(s.TrieDBCommit+s.SnapshotCommit), common.PrettyDuration(s.BlockWrite), - s.StateReadCacheStats) - for _, line := range strings.Split(msg, "\n") { - if line == "" { - continue - } - log.Info(line) + logEntry := slowBlockLog{ + Level: "warn", + Msg: "Slow block", + Block: slowBlockInfo{ + Number: block.NumberU64(), + Hash: block.Hash(), + GasUsed: block.GasUsed(), + TxCount: len(block.Transactions()), + }, + Timing: slowBlockTime{ + ExecutionMs: durationToMs(s.Execution), + StateReadMs: durationToMs(s.AccountReads + s.StorageReads + s.CodeReads), + StateHashMs: durationToMs(s.AccountHashes + s.AccountUpdates + s.StorageUpdates), + CommitMs: durationToMs(max(s.AccountCommits, s.StorageCommits) + s.DatabaseCommit + s.BlockWrite), + TotalMs: durationToMs(s.TotalTime), + }, + Throughput: slowBlockThru{ + MgasPerSec: s.MgasPerSecond, + }, + StateReads: slowBlockReads{ + Accounts: s.AccountLoaded, + StorageSlots: s.StorageLoaded, + Code: s.CodeLoaded, + CodeBytes: s.CodeLoadBytes, + }, + StateWrites: slowBlockWrites{ + Accounts: s.AccountUpdated, + AccountsDeleted: s.AccountDeleted, + StorageSlots: s.StorageUpdated, + StorageSlotsDeleted: s.StorageDeleted, + Code: s.CodeUpdated, + CodeBytes: s.CodeUpdateBytes, + }, + Cache: slowBlockCache{ + Account: slowBlockCacheEntry{ + Hits: s.StateReadCacheStats.StateStats.AccountCacheHit, + Misses: s.StateReadCacheStats.StateStats.AccountCacheMiss, + HitRate: s.StateReadCacheStats.StateStats.AccountCacheHitRate(), + }, + Storage: slowBlockCacheEntry{ + Hits: s.StateReadCacheStats.StateStats.StorageCacheHit, + Misses: s.StateReadCacheStats.StateStats.StorageCacheMiss, + HitRate: s.StateReadCacheStats.StateStats.StorageCacheHitRate(), + }, + Code: slowBlockCodeCacheEntry{ + Hits: s.StateReadCacheStats.CodeStats.CacheHit, + Misses: s.StateReadCacheStats.CodeStats.CacheMiss, + HitRate: s.StateReadCacheStats.CodeStats.HitRate(), + HitBytes: s.StateReadCacheStats.CodeStats.CacheHitBytes, + MissBytes: s.StateReadCacheStats.CodeStats.CacheMissBytes, + }, + }, + } + jsonBytes, err := json.Marshal(logEntry) + if err != nil { + log.Error("Failed to marshal slow block log", "error", err) + return } + log.Warn(string(jsonBytes)) } diff --git a/core/blockchain_test.go b/core/blockchain_test.go index 3e3053d9bf47..1a2ee452916f 100644 --- a/core/blockchain_test.go +++ b/core/blockchain_test.go @@ -18,6 +18,7 @@ package core import ( "bytes" + "context" "errors" "fmt" gomath "math" @@ -35,7 +36,6 @@ import ( "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/beacon" "github.com/ethereum/go-ethereum/consensus/ethash" - "github.com/ethereum/go-ethereum/core/history" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -156,11 +156,11 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error { } return err } - statedb, err := state.New(blockchain.GetBlockByHash(block.ParentHash()).Root(), blockchain.statedb) + statedb, err := state.New(blockchain.GetBlockByHash(block.ParentHash()).Root(), state.NewDatabase(blockchain.triedb, blockchain.codedb)) if err != nil { return err } - res, err := blockchain.processor.Process(block, statedb, vm.Config{}) + res, err := blockchain.processor.Process(context.Background(), block, statedb, vm.Config{}) if err != nil { blockchain.reportBadBlock(block, res, err) return err @@ -3456,7 +3456,7 @@ func testSetCanonical(t *testing.T, scheme string) { gen.AddTx(tx) }) for _, block := range side { - _, err := chain.InsertBlockWithoutSetHead(block, false) + _, err := chain.InsertBlockWithoutSetHead(context.Background(), block, false) if err != nil { t.Fatalf("Failed to insert into chain: %v", err) } @@ -3890,7 +3890,7 @@ func TestTransientStorageReset(t *testing.T) { t.Fatalf("failed to insert into chain: %v", err) } // Check the storage - state, err := chain.StateAt(chain.CurrentHeader().Root) + state, err := chain.StateAt(chain.CurrentHeader()) if err != nil { t.Fatalf("Failed to load state %v", err) } @@ -4336,26 +4336,13 @@ func TestInsertChainWithCutoff(t *testing.T) { func testInsertChainWithCutoff(t *testing.T, cutoff uint64, ancientLimit uint64, genesis *Genesis, blocks []*types.Block, receipts []types.Receipts) { // log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelDebug, true))) - // Add a known pruning point for the duration of the test. ghash := genesis.ToBlock().Hash() cutoffBlock := blocks[cutoff-1] - history.PrunePoints[ghash] = &history.PrunePoint{ - BlockNumber: cutoffBlock.NumberU64(), - BlockHash: cutoffBlock.Hash(), - } - defer func() { - delete(history.PrunePoints, ghash) - }() - - // Enable pruning in cache config. - config := DefaultConfig().WithStateScheme(rawdb.PathScheme) - config.ChainHistoryMode = history.KeepPostMerge db, _ := rawdb.Open(rawdb.NewMemoryDatabase(), rawdb.OpenOptions{}) defer db.Close() - options := DefaultConfig().WithStateScheme(rawdb.PathScheme) - chain, _ := NewBlockChain(db, genesis, beacon.New(ethash.NewFaker()), options) + chain, _ := NewBlockChain(db, genesis, beacon.New(ethash.NewFaker()), DefaultConfig().WithStateScheme(rawdb.PathScheme)) defer chain.Stop() var ( @@ -4515,3 +4502,45 @@ func TestGetCanonicalReceipt(t *testing.T) { } } } + +// TestSetHeadBeyondRootFinalizedBug tests the issue where the finalized block +// is not cleared when rewinding past it using setHeadBeyondRoot. +func TestSetHeadBeyondRootFinalizedBug(t *testing.T) { + // Create a clean blockchain with 100 blocks using PathScheme (PBSS) + _, _, blockchain, err := newCanonical(ethash.NewFaker(), 100, true, rawdb.PathScheme) + if err != nil { + t.Fatalf("failed to create pristine chain: %v", err) + } + defer blockchain.Stop() + + // Set the "Finalized" marker to the current Head (Block 100) + headBlock := blockchain.CurrentBlock() + if headBlock.Number.Uint64() != 100 { + t.Fatalf("Setup failed: expected head 100, got %d", headBlock.Number.Uint64()) + } + blockchain.SetFinalized(headBlock) + + // Verify setup + if blockchain.CurrentFinalBlock().Number.Uint64() != 100 { + t.Fatalf("Setup failed: Finalized block should be 100") + } + targetBlock := blockchain.GetBlockByNumber(50) + + // Call setHeadBeyondRoot with: + // head = 100 + // repair = true + if _, err := blockchain.setHeadBeyondRoot(100, 0, targetBlock.Root(), true); err != nil { + t.Fatalf("Failed to rewind: %v", err) + } + + currentFinal := blockchain.CurrentFinalBlock() + currentHead := blockchain.CurrentBlock().Number.Uint64() + + // The previous finalized block (100) is now invalid because we rewound to 50. + // The function should have cleared the finalized marker (set to nil). + if currentFinal != nil && currentFinal.Number.Uint64() > currentHead { + t.Errorf("Chain Head: %d , Finalized Block: %d , Finalized block was >= head block.", + currentHead, + currentFinal.Number.Uint64()) + } +} diff --git a/core/chain_makers.go b/core/chain_makers.go index a1e07becba88..cfd63027948c 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -17,6 +17,7 @@ package core import ( + "context" "fmt" "math/big" @@ -63,7 +64,7 @@ func (b *BlockGen) SetCoinbase(addr common.Address) { panic("coinbase can only be set once") } b.header.Coinbase = addr - b.gasPool = new(GasPool).AddGas(b.header.GasLimit) + b.gasPool = NewGasPool(b.header.GasLimit) } // SetExtra sets the extra data field of the generated block. @@ -116,14 +117,16 @@ func (b *BlockGen) addTx(bc *BlockChain, vmConfig vm.Config, tx *types.Transacti blockContext = NewEVMBlockContext(b.header, bc, &b.header.Coinbase) evm = vm.NewEVM(blockContext, b.statedb, b.cm.config, vmConfig) ) - b.statedb.SetTxContext(tx.Hash(), len(b.txs)) - receipt, err := ApplyTransaction(evm, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed) + b.statedb.SetTxContext(tx.Hash(), len(b.txs), uint32(len(b.txs)+1)) + receipt, err := ApplyTransaction(evm, b.gasPool, b.statedb, b.header, tx) if err != nil { panic(err) } + b.header.GasUsed = b.gasPool.Used() + // Merge the tx-local access event into the "block-local" one, in order to collect // all values, so that the witness can be built. - if b.statedb.Database().TrieDB().IsVerkle() { + if b.statedb.Database().Type().Is(state.TypeUBT) { b.statedb.AccessEvents().Merge(evm.AccessEvents) } b.txs = append(b.txs, tx) @@ -312,28 +315,17 @@ func (b *BlockGen) collectRequests(readonly bool) (requests [][]byte) { // off the statedb before executing the system calls. statedb = statedb.Copy() } + var blockLogs []*types.Log + for _, r := range b.receipts { + blockLogs = append(blockLogs, r.Logs...) + } + // TODO use the shared EVM throughout the entire generation cycle + blockContext := NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase) + evm := vm.NewEVM(blockContext, statedb, b.cm.config, vm.Config{}) - if b.cm.config.IsPrague(b.header.Number, b.header.Time) { - requests = [][]byte{} - // EIP-6110 deposits - var blockLogs []*types.Log - for _, r := range b.receipts { - blockLogs = append(blockLogs, r.Logs...) - } - if err := ParseDepositLogs(&requests, blockLogs, b.cm.config); err != nil { - panic(fmt.Sprintf("failed to parse deposit log: %v", err)) - } - // create EVM for system calls - blockContext := NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase) - evm := vm.NewEVM(blockContext, statedb, b.cm.config, vm.Config{}) - // EIP-7002 - if err := ProcessWithdrawalQueue(&requests, evm); err != nil { - panic(fmt.Sprintf("could not process withdrawal requests: %v", err)) - } - // EIP-7251 - if err := ProcessConsolidationQueue(&requests, evm); err != nil { - panic(fmt.Sprintf("could not process consolidation requests: %v", err)) - } + requests, err := PostExecution(context.Background(), b.cm.config, b.header.Number, b.header.Time, blockLogs, evm, uint32(len(b.txs)+1)) + if err != nil { + panic(fmt.Sprintf("failed to run post-execution: %v", err)) } return requests } @@ -389,7 +381,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse misc.ApplyDAOHardFork(statedb) } - if config.IsPrague(b.header.Number, b.header.Time) || config.IsVerkle(b.header.Number, b.header.Time) { + if config.IsPrague(b.header.Number, b.header.Time) || config.IsUBT(b.header.Number, b.header.Time) { // EIP-2935 blockContext := NewEVMBlockContext(b.header, cm, &b.header.Coinbase) blockContext.Random = &common.Hash{} // enable post-merge instruction set @@ -408,11 +400,22 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse b.header.RequestsHash = &reqHash } - body := types.Body{Transactions: b.txs, Uncles: b.uncles, Withdrawals: b.withdrawals} - block, err := b.engine.FinalizeAndAssemble(cm, b.header, statedb, &body, b.receipts) - if err != nil { - panic(err) + body := types.Body{ + Transactions: b.txs, + Uncles: b.uncles, + Withdrawals: b.withdrawals, } + if !config.IsShanghai(b.header.Number, b.header.Time) { + if body.Withdrawals != nil { + panic("unexpected withdrawal before shanghai") + } + } else { + if body.Withdrawals == nil { + body.Withdrawals = make([]*types.Withdrawal, 0) + } + } + // Assemble the block for delivery. + block := AssembleBlock(b.engine, cm, b.header, statedb, &body, b.receipts) // Write state changes to db root, err := statedb.Commit(b.header.Number.Uint64(), config.IsEIP158(b.header.Number), config.IsCancun(b.header.Number, b.header.Time)) @@ -427,8 +430,8 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse // Forcibly use hash-based state scheme for retaining all nodes in disk. var triedbConfig *triedb.Config = triedb.HashDefaults - if config.IsVerkle(config.ChainID, 0) { - triedbConfig = triedb.VerkleDefaults + if config.IsUBT(config.ChainID, 0) { + triedbConfig = triedb.UBTDefaults } triedb := triedb.NewDatabase(db, triedbConfig) defer triedb.Close() @@ -476,16 +479,17 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse func GenerateChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int, gen func(int, *BlockGen)) (ethdb.Database, []*types.Block, []types.Receipts) { db := rawdb.NewMemoryDatabase() var triedbConfig *triedb.Config = triedb.HashDefaults - if genesis.Config != nil && genesis.Config.IsVerkle(genesis.Config.ChainID, 0) { - triedbConfig = triedb.VerkleDefaults + if genesis.Config != nil && genesis.Config.IsUBT(genesis.Config.ChainID, 0) { + triedbConfig = triedb.UBTDefaults } - triedb := triedb.NewDatabase(db, triedbConfig) - defer triedb.Close() - _, err := genesis.Commit(db, triedb) + genesisTriedb := triedb.NewDatabase(db, triedbConfig) + block, err := genesis.Commit(db, genesisTriedb, nil) if err != nil { + genesisTriedb.Close() panic(err) } - blocks, receipts := GenerateChain(genesis.Config, genesis.ToBlock(), engine, db, n, gen) + genesisTriedb.Close() + blocks, receipts := GenerateChain(genesis.Config, block, engine, db, n, gen) return db, blocks, receipts } diff --git a/core/error.go b/core/error.go index 635d802863f8..7dd5b8a43285 100644 --- a/core/error.go +++ b/core/error.go @@ -58,14 +58,14 @@ var ( // by a transaction is higher than what's left in the block. ErrGasLimitReached = errors.New("gas limit reached") + // ErrGasLimitOverflow is returned by the gas pool if the remaining gas + // exceeds the maximum value of uint64. + ErrGasLimitOverflow = errors.New("gas limit overflow") + // ErrInsufficientFundsForTransfer is returned if the transaction sender doesn't // have enough funds for transfer(topmost call only). ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer") - // ErrMaxInitCodeSizeExceeded is returned if creation transaction provides the init code bigger - // than init code size limit. - ErrMaxInitCodeSizeExceeded = errors.New("max initcode size exceeded") - // ErrInsufficientBalanceWitness is returned if the transaction sender has enough // funds to cover the transfer, but not enough to pay for witness access/modification // costs for the transaction diff --git a/core/eth_transfer_logs_test.go b/core/eth_transfer_logs_test.go new file mode 100644 index 000000000000..815b56b588ac --- /dev/null +++ b/core/eth_transfer_logs_test.go @@ -0,0 +1,169 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package core + +import ( + "encoding/binary" + "math/big" + "reflect" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/beacon" + "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/params" +) + +var ethTransferTestCode = common.FromHex("6080604052600436106100345760003560e01c8063574ffc311461003957806366e41cb714610090578063f8a8fd6d1461009a575b600080fd5b34801561004557600080fd5b5061004e6100a4565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6100986100ac565b005b6100a26100f5565b005b63deadbeef81565b7f38e80b5c85ba49b7280ccc8f22548faa62ae30d5a008a1b168fba5f47f5d1ee560405160405180910390a1631234567873ffffffffffffffffffffffffffffffffffffffff16ff5b7f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405160405180910390a163deadbeef73ffffffffffffffffffffffffffffffffffffffff166002348161014657fe5b046040516024016040516020818303038152906040527f66e41cb7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506040518082805190602001908083835b602083106101fd57805182526020820191506020810190506020830392506101da565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d806000811461025f576040519150601f19603f3d011682016040523d82523d6000602084013e610264565b606091505b50505056fea265627a7a723158202cce817a434785d8560c200762f972d453ccd30694481be7545f9035a512826364736f6c63430005100032") + +/* +pragma solidity >=0.4.22 <0.6.0; + +contract TestLogs { + + address public constant target_contract = 0x00000000000000000000000000000000DeaDBeef; + address payable constant selfdestruct_addr = 0x0000000000000000000000000000000012345678; + + event Response(bool success, bytes data); + event TestEvent(); + event TestEvent2(); + + function test() public payable { + emit TestEvent(); + target_contract.call.value(msg.value/2)(abi.encodeWithSignature("test2()")); + } + function test2() public payable { + emit TestEvent2(); + selfdestruct(selfdestruct_addr); + } +} +*/ + +// TestEthTransferLogs tests EIP-7708 ETH transfer log output by simulating a +// scenario including transaction, CALL and SELFDESTRUCT value transfers, and +// also "ordinary" logs emitted. The same scenario is also tested with no value +// transferred. +func TestEthTransferLogs(t *testing.T) { + testEthTransferLogs(t, 1_000_000_000) + testEthTransferLogs(t, 0) +} + +func testEthTransferLogs(t *testing.T, value uint64) { + var ( + key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + addr1 = crypto.PubkeyToAddress(key1.PublicKey) + addr2 = common.HexToAddress("cafebabe") // caller + addr3 = common.HexToAddress("deadbeef") // callee + addr4 = common.HexToAddress("12345678") // selfdestruct target + testEvent = crypto.Keccak256Hash([]byte("TestEvent()")) + testEvent2 = crypto.Keccak256Hash([]byte("TestEvent2()")) + config = *params.MergedTestChainConfig + signer = types.LatestSigner(&config) + engine = beacon.New(ethash.NewFaker()) + ) + + //TODO remove this hacky config initialization when final Amsterdam config is available + config.AmsterdamTime = new(uint64) + blobConfig := *config.BlobScheduleConfig + blobConfig.Amsterdam = blobConfig.Osaka + config.BlobScheduleConfig = &blobConfig + + gspec := &Genesis{ + Config: &config, + Alloc: types.GenesisAlloc{ + addr1: {Balance: newGwei(1000000000)}, + addr2: {Code: ethTransferTestCode}, + addr3: {Code: ethTransferTestCode}, + }, + } + _, blocks, receipts := GenerateChainWithGenesis(gspec, engine, 1, func(i int, b *BlockGen) { + tx := types.MustSignNewTx(key1, signer, &types.DynamicFeeTx{ + ChainID: gspec.Config.ChainID, + Nonce: 0, + To: &addr2, + Gas: 500_000, + GasFeeCap: newGwei(5), + GasTipCap: newGwei(5), + Value: big.NewInt(int64(value)), + Data: common.FromHex("f8a8fd6d"), + }) + b.AddTx(tx) + }) + + blockHash := blocks[0].Hash() + txHash := blocks[0].Transactions()[0].Hash() + addr2hash := func(addr common.Address) (hash common.Hash) { + copy(hash[12:], addr[:]) + return + } + u256 := func(amount uint64) []byte { + data := make([]byte, 32) + binary.BigEndian.PutUint64(data[24:], amount) + return data + } + + var expLogs = []*types.Log{ + { + Address: params.SystemAddress, + Topics: []common.Hash{params.EthTransferLogEvent, addr2hash(addr1), addr2hash(addr2)}, + Data: u256(value), + }, + { + Address: addr2, + Topics: []common.Hash{testEvent}, + Data: nil, + }, + { + Address: params.SystemAddress, + Topics: []common.Hash{params.EthTransferLogEvent, addr2hash(addr2), addr2hash(addr3)}, + Data: u256(value / 2), + }, + { + Address: addr3, + Topics: []common.Hash{testEvent2}, + Data: nil, + }, + { + Address: params.SystemAddress, + Topics: []common.Hash{params.EthTransferLogEvent, addr2hash(addr3), addr2hash(addr4)}, + Data: u256(value / 2), + }, + } + if value == 0 { + // no ETH transfer logs expected with zero value + expLogs = []*types.Log{expLogs[1], expLogs[3]} + } + for i, log := range expLogs { + log.BlockNumber = 1 + log.BlockHash = blockHash + log.BlockTimestamp = 10 + log.TxIndex = 0 + log.TxHash = txHash + log.Index = uint(i) + } + + if len(expLogs) != len(receipts[0][0].Logs) { + t.Fatalf("Incorrect number of logs (expected: %d, got: %d)", len(expLogs), len(receipts[0][0].Logs)) + } + for i, log := range receipts[0][0].Logs { + if !reflect.DeepEqual(expLogs[i], log) { + t.Fatalf("Incorrect log at index %d (expected: %v, got: %v)", i, expLogs[i], log) + } + } +} diff --git a/core/events.go b/core/events.go index ef0de3242621..ed853f1790ac 100644 --- a/core/events.go +++ b/core/events.go @@ -17,6 +17,9 @@ package core import ( + "time" + + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" ) @@ -35,3 +38,10 @@ type ChainEvent struct { type ChainHeadEvent struct { Header *types.Header } + +// NewPayloadEvent is posted when engine_newPayloadVX processes a block. +type NewPayloadEvent struct { + Hash common.Hash + Number uint64 + ProcessingTime time.Duration +} diff --git a/core/evm.go b/core/evm.go index 18d940fdd228..73e4c01a995f 100644 --- a/core/evm.go +++ b/core/evm.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" ) @@ -44,6 +45,7 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common baseFee *big.Int blobBaseFee *big.Int random *common.Hash + slotNum uint64 ) // If we don't have an explicit author (i.e. not mining), extract from the header @@ -61,6 +63,10 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common if header.Difficulty.Sign() == 0 { random = &header.MixDigest } + if header.SlotNumber != nil { + slotNum = *header.SlotNumber + } + return vm.BlockContext{ CanTransfer: CanTransfer, Transfer: Transfer, @@ -73,6 +79,7 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common BlobBaseFee: blobBaseFee, GasLimit: header.GasLimit, Random: random, + SlotNum: slotNum, } } @@ -80,12 +87,9 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common func NewEVMTxContext(msg *Message) vm.TxContext { ctx := vm.TxContext{ Origin: msg.From, - GasPrice: new(big.Int).Set(msg.GasPrice), + GasPrice: msg.GasPrice, BlobHashes: msg.BlobHashes, } - if msg.BlobGasFeeCap != nil { - ctx.BlobFeeCap = new(big.Int).Set(msg.BlobGasFeeCap) - } return ctx } @@ -135,7 +139,10 @@ func CanTransfer(db vm.StateDB, addr common.Address, amount *uint256.Int) bool { } // Transfer subtracts amount from sender and adds amount to recipient using the given Db -func Transfer(db vm.StateDB, sender, recipient common.Address, amount *uint256.Int) { +func Transfer(db vm.StateDB, sender, recipient common.Address, amount *uint256.Int, rules *params.Rules) { db.SubBalance(sender, amount, tracing.BalanceChangeTransfer) db.AddBalance(recipient, amount, tracing.BalanceChangeTransfer) + if rules.IsAmsterdam && !amount.IsZero() && sender != recipient { + db.AddLog(types.EthTransferLog(sender, recipient, amount)) + } } diff --git a/core/filtermaps/math_test.go b/core/filtermaps/math_test.go index a4c16090598e..0cd0046a7d7e 100644 --- a/core/filtermaps/math_test.go +++ b/core/filtermaps/math_test.go @@ -41,9 +41,7 @@ func TestSingleMatch(t *testing.T) { t.Fatalf("Invalid length of matches (got %d, expected 1)", len(matches)) } if matches[0] != lvIndex { - if len(matches) != 1 { - t.Fatalf("Incorrect match returned (got %d, expected %d)", matches[0], lvIndex) - } + t.Fatalf("Incorrect match returned (got %d, expected %d)", matches[0], lvIndex) } } } diff --git a/core/gaspool.go b/core/gaspool.go index 767222674f77..14f5abd93c3b 100644 --- a/core/gaspool.go +++ b/core/gaspool.go @@ -21,39 +21,87 @@ import ( "math" ) -// GasPool tracks the amount of gas available during execution of the transactions -// in a block. The zero value is a pool with zero gas available. -type GasPool uint64 - -// AddGas makes gas available for execution. -func (gp *GasPool) AddGas(amount uint64) *GasPool { - if uint64(*gp) > math.MaxUint64-amount { - panic("gas pool pushed above uint64") +// GasPool tracks the amount of gas available for transaction execution +// within a block, along with the cumulative gas consumed. +type GasPool struct { + remaining uint64 + initial uint64 + cumulativeUsed uint64 +} + +// NewGasPool initializes the gasPool with the given amount. +func NewGasPool(amount uint64) *GasPool { + return &GasPool{ + remaining: amount, + initial: amount, } - *(*uint64)(gp) += amount - return gp } // SubGas deducts the given amount from the pool if enough gas is // available and returns an error otherwise. func (gp *GasPool) SubGas(amount uint64) error { - if uint64(*gp) < amount { + if gp.remaining < amount { return ErrGasLimitReached } - *(*uint64)(gp) -= amount + gp.remaining -= amount + return nil +} + +// ReturnGas adds the refunded gas back to the pool and updates +// the cumulative gas usage accordingly. +func (gp *GasPool) ReturnGas(returned uint64, gasUsed uint64) error { + if gp.remaining > math.MaxUint64-returned { + return fmt.Errorf("%w: remaining: %d, returned: %d", ErrGasLimitOverflow, gp.remaining, returned) + } + // The returned gas calculation differs across forks. + // + // - Pre-Amsterdam: + // returned = purchased - remaining (refund included) + // + // - Post-Amsterdam: + // returned = purchased - gasUsed (refund excluded) + gp.remaining += returned + + // gasUsed = max(txGasUsed - gasRefund, calldataFloorGasCost) + // regardless of Amsterdam is activated or not. + gp.cumulativeUsed += gasUsed return nil } // Gas returns the amount of gas remaining in the pool. func (gp *GasPool) Gas() uint64 { - return uint64(*gp) + return gp.remaining +} + +// CumulativeUsed returns the amount of cumulative consumed gas (refunded included). +func (gp *GasPool) CumulativeUsed() uint64 { + return gp.cumulativeUsed +} + +// Used returns the amount of consumed gas. +func (gp *GasPool) Used() uint64 { + if gp.initial < gp.remaining { + panic("gas used underflow") + } + return gp.initial - gp.remaining +} + +// Snapshot returns the deep-copied object as the snapshot. +func (gp *GasPool) Snapshot() *GasPool { + return &GasPool{ + initial: gp.initial, + remaining: gp.remaining, + cumulativeUsed: gp.cumulativeUsed, + } } -// SetGas sets the amount of gas with the provided number. -func (gp *GasPool) SetGas(gas uint64) { - *(*uint64)(gp) = gas +// Set sets the content of gasPool with the provided one. +func (gp *GasPool) Set(other *GasPool) { + gp.initial = other.initial + gp.remaining = other.remaining + gp.cumulativeUsed = other.cumulativeUsed } func (gp *GasPool) String() string { - return fmt.Sprintf("%d", *gp) + return fmt.Sprintf("initial: %d, remaining: %d, cumulative used: %d", gp.initial, gp.remaining, gp.cumulativeUsed) } diff --git a/core/gen_genesis.go b/core/gen_genesis.go index 2028f98edc06..b94825b18578 100644 --- a/core/gen_genesis.go +++ b/core/gen_genesis.go @@ -34,6 +34,7 @@ func (g Genesis) MarshalJSON() ([]byte, error) { BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"` ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"` BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"` + SlotNumber *uint64 `json:"slotNumber"` } var enc Genesis enc.Config = g.Config @@ -56,6 +57,7 @@ func (g Genesis) MarshalJSON() ([]byte, error) { enc.BaseFee = (*math.HexOrDecimal256)(g.BaseFee) enc.ExcessBlobGas = (*math.HexOrDecimal64)(g.ExcessBlobGas) enc.BlobGasUsed = (*math.HexOrDecimal64)(g.BlobGasUsed) + enc.SlotNumber = g.SlotNumber return json.Marshal(&enc) } @@ -77,6 +79,7 @@ func (g *Genesis) UnmarshalJSON(input []byte) error { BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"` ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"` BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"` + SlotNumber *uint64 `json:"slotNumber"` } var dec Genesis if err := json.Unmarshal(input, &dec); err != nil { @@ -133,5 +136,8 @@ func (g *Genesis) UnmarshalJSON(input []byte) error { if dec.BlobGasUsed != nil { g.BlobGasUsed = (*uint64)(dec.BlobGasUsed) } + if dec.SlotNumber != nil { + g.SlotNumber = dec.SlotNumber + } return nil } diff --git a/core/genesis.go b/core/genesis.go index 7d640c8caec1..6a0affa52e66 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -73,6 +73,7 @@ type Genesis struct { BaseFee *big.Int `json:"baseFeePerGas"` // EIP-1559 ExcessBlobGas *uint64 `json:"excessBlobGas"` // EIP-4844 BlobGasUsed *uint64 `json:"blobGasUsed"` // EIP-4844 + SlotNumber *uint64 `json:"slotNumber"` // EIP-7843 } // copy copies the genesis. @@ -122,27 +123,29 @@ func ReadGenesis(db ethdb.Database) (*Genesis, error) { genesis.BaseFee = genesisHeader.BaseFee genesis.ExcessBlobGas = genesisHeader.ExcessBlobGas genesis.BlobGasUsed = genesisHeader.BlobGasUsed + genesis.SlotNumber = genesisHeader.SlotNumber return &genesis, nil } // hashAlloc computes the state root according to the genesis specification. -func hashAlloc(ga *types.GenesisAlloc, isVerkle bool) (common.Hash, error) { +func hashAlloc(ga *types.GenesisAlloc, isUBT bool) (common.Hash, error) { // If a genesis-time verkle trie is requested, create a trie config // with the verkle trie enabled so that the tree can be initialized // as such. var config *triedb.Config - if isVerkle { + if isUBT { config = &triedb.Config{ - PathDB: pathdb.Defaults, - IsVerkle: true, + PathDB: pathdb.Defaults, + IsUBT: true, + BinTrieGroupDepth: triedb.UBTDefaults.BinTrieGroupDepth, } } // Create an ephemeral in-memory database for computing hash, // all the derived states will be discarded to not pollute disk. emptyRoot := types.EmptyRootHash - if isVerkle { - emptyRoot = types.EmptyVerkleHash + if isUBT { + emptyRoot = types.EmptyBinaryHash } db := rawdb.NewMemoryDatabase() statedb, err := state.New(emptyRoot, state.NewDatabase(triedb.NewDatabase(db, config), nil)) @@ -164,10 +167,10 @@ func hashAlloc(ga *types.GenesisAlloc, isVerkle bool) (common.Hash, error) { // flushAlloc is very similar with hash, but the main difference is all the // generated states will be persisted into the given database. -func flushAlloc(ga *types.GenesisAlloc, triedb *triedb.Database) (common.Hash, error) { +func flushAlloc(ga *types.GenesisAlloc, triedb *triedb.Database, tracer *tracing.Hooks) (common.Hash, error) { emptyRoot := types.EmptyRootHash - if triedb.IsVerkle() { - emptyRoot = types.EmptyVerkleHash + if triedb.IsUBT() { + emptyRoot = types.EmptyBinaryHash } statedb, err := state.New(emptyRoot, state.NewDatabase(triedb, nil)) if err != nil { @@ -185,10 +188,26 @@ func flushAlloc(ga *types.GenesisAlloc, triedb *triedb.Database) (common.Hash, e statedb.SetState(addr, key, value) } } - root, err := statedb.Commit(0, false, false) - if err != nil { - return common.Hash{}, err + + var root common.Hash + if tracer != nil && tracer.OnStateUpdate != nil { + r, update, err := statedb.CommitWithUpdate(0, false, false) + if err != nil { + return common.Hash{}, err + } + trUpdate, err := update.ToTracingUpdate() + if err != nil { + return common.Hash{}, err + } + tracer.OnStateUpdate(trUpdate) + root = r + } else { + root, err = statedb.Commit(0, false, false) + if err != nil { + return common.Hash{}, err + } } + // Commit newly generated states into disk if it's not empty. if root != emptyRoot { if err := triedb.Commit(root, true); err != nil { @@ -258,10 +277,10 @@ func (e *GenesisMismatchError) Error() string { // ChainOverrides contains the changes to chain config. type ChainOverrides struct { - OverrideOsaka *uint64 - OverrideBPO1 *uint64 - OverrideBPO2 *uint64 - OverrideVerkle *uint64 + OverrideOsaka *uint64 + OverrideBPO1 *uint64 + OverrideBPO2 *uint64 + OverrideUBT *uint64 } // apply applies the chain overrides on the supplied chain config. @@ -278,8 +297,8 @@ func (o *ChainOverrides) apply(cfg *params.ChainConfig) error { if o.OverrideBPO2 != nil { cfg.BPO2Time = o.OverrideBPO2 } - if o.OverrideVerkle != nil { - cfg.VerkleTime = o.OverrideVerkle + if o.OverrideUBT != nil { + cfg.UBTTime = o.OverrideUBT } return cfg.CheckConfigForkOrder() } @@ -296,10 +315,10 @@ func (o *ChainOverrides) apply(cfg *params.ChainConfig) error { // specify a fork block below the local head block). In case of a conflict, the // error is a *params.ConfigCompatError and the new, unwritten config is returned. func SetupGenesisBlock(db ethdb.Database, triedb *triedb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { - return SetupGenesisBlockWithOverride(db, triedb, genesis, nil) + return SetupGenesisBlockWithOverride(db, triedb, genesis, nil, nil) } -func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, genesis *Genesis, overrides *ChainOverrides) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { +func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, genesis *Genesis, overrides *ChainOverrides, tracer *tracing.Hooks) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { // Copy the genesis, so we can operate on a copy. genesis = genesis.copy() // Sanitize the supplied genesis, ensuring it has the associated chain @@ -320,7 +339,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, g return nil, common.Hash{}, nil, err } - block, err := genesis.Commit(db, triedb) + block, err := genesis.Commit(db, triedb, tracer) if err != nil { return nil, common.Hash{}, nil, err } @@ -348,7 +367,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, g if hash := genesis.ToBlock().Hash(); hash != ghash { return nil, common.Hash{}, nil, &GenesisMismatchError{ghash, hash} } - block, err := genesis.Commit(db, triedb) + block, err := genesis.Commit(db, triedb, tracer) if err != nil { return nil, common.Hash{}, nil, err } @@ -451,15 +470,15 @@ func (g *Genesis) chainConfigOrDefault(ghash common.Hash, stored *params.ChainCo } } -// IsVerkle indicates whether the state is already stored in a verkle +// IsUBT indicates whether the state is already stored in a verkle // tree at genesis time. -func (g *Genesis) IsVerkle() bool { - return g.Config.IsVerkleGenesis() +func (g *Genesis) IsUBT() bool { + return g.Config.IsUBTGenesis() } // ToBlock returns the genesis block according to genesis specification. func (g *Genesis) ToBlock() *types.Block { - root, err := hashAlloc(&g.Alloc, g.IsVerkle()) + root, err := hashAlloc(&g.Alloc, g.IsUBT()) if err != nil { panic(err) } @@ -531,13 +550,19 @@ func (g *Genesis) toBlockWithRoot(root common.Hash) *types.Block { if conf.IsPrague(num, g.Timestamp) { head.RequestsHash = &types.EmptyRequestsHash } + if conf.IsAmsterdam(num, g.Timestamp) { + head.SlotNumber = g.SlotNumber + if head.SlotNumber == nil { + head.SlotNumber = new(uint64) + } + } } return types.NewBlock(head, &types.Body{Withdrawals: withdrawals}, nil, trie.NewStackTrie(nil)) } // Commit writes the block and state of a genesis specification to the database. // The block is committed as the canonical head block. -func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Block, error) { +func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database, tracer *tracing.Hooks) (*types.Block, error) { if g.Number != 0 { return nil, errors.New("can't commit genesis block with number > 0") } @@ -552,7 +577,7 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Blo return nil, errors.New("can't start clique chain without signers") } // flush the data to disk and compute the state root - root, err := flushAlloc(&g.Alloc, triedb) + root, err := flushAlloc(&g.Alloc, triedb, tracer) if err != nil { return nil, err } @@ -578,31 +603,31 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Blo // MustCommit writes the genesis block and state to db, panicking on error. // The block is committed as the canonical head block. func (g *Genesis) MustCommit(db ethdb.Database, triedb *triedb.Database) *types.Block { - block, err := g.Commit(db, triedb) + block, err := g.Commit(db, triedb, nil) if err != nil { panic(err) } return block } -// EnableVerkleAtGenesis indicates whether the verkle fork should be activated +// EnableUBTAtGenesis indicates whether the verkle fork should be activated // at genesis. This is a temporary solution only for verkle devnet testing, where // verkle fork is activated at genesis, and the configured activation date has // already passed. // // In production networks (mainnet and public testnets), verkle activation always // occurs after the genesis block, making this function irrelevant in those cases. -func EnableVerkleAtGenesis(db ethdb.Database, genesis *Genesis) (bool, error) { +func EnableUBTAtGenesis(db ethdb.Database, genesis *Genesis) (bool, error) { if genesis != nil { if genesis.Config == nil { return false, errGenesisNoConfig } - return genesis.Config.EnableVerkleAtGenesis, nil + return genesis.Config.EnableUBTAtGenesis, nil } if ghash := rawdb.ReadCanonicalHash(db, 0); ghash != (common.Hash{}) { chainCfg := rawdb.ReadChainConfig(db, ghash) if chainCfg != nil { - return chainCfg.EnableVerkleAtGenesis, nil + return chainCfg.EnableUBTAtGenesis, nil } } return false, nil diff --git a/core/genesis_test.go b/core/genesis_test.go index 1ed475695dfc..94f1b3a4fdfd 100644 --- a/core/genesis_test.go +++ b/core/genesis_test.go @@ -88,7 +88,7 @@ func testSetupGenesis(t *testing.T, scheme string) { name: "custom block in DB, genesis == nil", fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { tdb := triedb.NewDatabase(db, newDbConfig(scheme)) - customg.Commit(db, tdb) + customg.Commit(db, tdb, nil) return SetupGenesisBlock(db, tdb, nil) }, wantHash: customghash, @@ -98,7 +98,7 @@ func testSetupGenesis(t *testing.T, scheme string) { name: "custom block in DB, genesis == sepolia", fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { tdb := triedb.NewDatabase(db, newDbConfig(scheme)) - customg.Commit(db, tdb) + customg.Commit(db, tdb, nil) return SetupGenesisBlock(db, tdb, DefaultSepoliaGenesisBlock()) }, wantErr: &GenesisMismatchError{Stored: customghash, New: params.SepoliaGenesisHash}, @@ -107,7 +107,7 @@ func testSetupGenesis(t *testing.T, scheme string) { name: "custom block in DB, genesis == hoodi", fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { tdb := triedb.NewDatabase(db, newDbConfig(scheme)) - customg.Commit(db, tdb) + customg.Commit(db, tdb, nil) return SetupGenesisBlock(db, tdb, DefaultHoodiGenesisBlock()) }, wantErr: &GenesisMismatchError{Stored: customghash, New: params.HoodiGenesisHash}, @@ -116,7 +116,7 @@ func testSetupGenesis(t *testing.T, scheme string) { name: "compatible config in DB", fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) { tdb := triedb.NewDatabase(db, newDbConfig(scheme)) - oldcustomg.Commit(db, tdb) + oldcustomg.Commit(db, tdb, nil) return SetupGenesisBlock(db, tdb, &customg) }, wantHash: customghash, @@ -128,7 +128,7 @@ func testSetupGenesis(t *testing.T, scheme string) { // Commit the 'old' genesis block with Homestead transition at #2. // Advance to block #4, past the homestead transition block of customg. tdb := triedb.NewDatabase(db, newDbConfig(scheme)) - oldcustomg.Commit(db, tdb) + oldcustomg.Commit(db, tdb, nil) bc, _ := NewBlockChain(db, &oldcustomg, ethash.NewFullFaker(), DefaultConfig().WithStateScheme(scheme)) defer bc.Stop() @@ -261,9 +261,9 @@ func newDbConfig(scheme string) *triedb.Config { return &triedb.Config{PathDB: &config} } -func TestVerkleGenesisCommit(t *testing.T) { - var verkleTime uint64 = 0 - verkleConfig := ¶ms.ChainConfig{ +func TestBinaryGenesisCommit(t *testing.T) { + var ubtTime uint64 = 0 + ubtConfig := ¶ms.ChainConfig{ ChainID: big.NewInt(1), HomesteadBlock: big.NewInt(0), DAOForkBlock: nil, @@ -281,34 +281,34 @@ func TestVerkleGenesisCommit(t *testing.T) { ArrowGlacierBlock: big.NewInt(0), GrayGlacierBlock: big.NewInt(0), MergeNetsplitBlock: nil, - ShanghaiTime: &verkleTime, - CancunTime: &verkleTime, - PragueTime: &verkleTime, - OsakaTime: &verkleTime, - VerkleTime: &verkleTime, + ShanghaiTime: &ubtTime, + CancunTime: &ubtTime, + PragueTime: &ubtTime, + OsakaTime: &ubtTime, + UBTTime: &ubtTime, TerminalTotalDifficulty: big.NewInt(0), - EnableVerkleAtGenesis: true, + EnableUBTAtGenesis: true, Ethash: nil, Clique: nil, BlobScheduleConfig: ¶ms.BlobScheduleConfig{ Cancun: params.DefaultCancunBlobConfig, Prague: params.DefaultPragueBlobConfig, Osaka: params.DefaultOsakaBlobConfig, - Verkle: params.DefaultPragueBlobConfig, + UBT: params.DefaultPragueBlobConfig, }, } genesis := &Genesis{ BaseFee: big.NewInt(params.InitialBaseFee), - Config: verkleConfig, - Timestamp: verkleTime, + Config: ubtConfig, + Timestamp: ubtTime, Difficulty: big.NewInt(0), Alloc: types.GenesisAlloc{ {1}: {Balance: big.NewInt(1), Storage: map[common.Hash]common.Hash{{1}: {1}}}, }, } - expected := common.FromHex("19056b480530799a4fdaa9fd9407043b965a3a5c37b4d2a1a9a4f3395a327561") + expected := common.FromHex("0870fd587c41dc778019de8c5cb3193fe4ef1f417976461952d3712ba39163f5") got := genesis.ToBlock().Root().Bytes() if !bytes.Equal(got, expected) { t.Fatalf("invalid genesis state root, expected %x, got %x", expected, got) @@ -320,17 +320,18 @@ func TestVerkleGenesisCommit(t *testing.T) { config.NoAsyncFlush = true triedb := triedb.NewDatabase(db, &triedb.Config{ - IsVerkle: true, - PathDB: &config, + IsUBT: true, + PathDB: &config, + BinTrieGroupDepth: triedb.DefaultBinTrieGroupDepth, }) block := genesis.MustCommit(db, triedb) if !bytes.Equal(block.Root().Bytes(), expected) { t.Fatalf("invalid genesis state root, expected %x, got %x", expected, block.Root()) } - // Test that the trie is verkle - if !triedb.IsVerkle() { - t.Fatalf("expected trie to be verkle") + // Test that the trie is a unified binary trie + if !triedb.IsUBT() { + t.Fatalf("expected trie to be a unified binary trie") } vdb := rawdb.NewTable(db, string(rawdb.VerklePrefix)) if !rawdb.HasAccountTrieNode(vdb, nil) { diff --git a/core/headerchain_test.go b/core/headerchain_test.go index b51fb8f22676..dba04e2cf24d 100644 --- a/core/headerchain_test.go +++ b/core/headerchain_test.go @@ -69,7 +69,7 @@ func TestHeaderInsertion(t *testing.T) { db = rawdb.NewMemoryDatabase() gspec = &Genesis{BaseFee: big.NewInt(params.InitialBaseFee), Config: params.AllEthashProtocolChanges} ) - gspec.Commit(db, triedb.NewDatabase(db, nil)) + gspec.Commit(db, triedb.NewDatabase(db, nil), nil) hc, err := NewHeaderChain(db, gspec.Config, ethash.NewFaker(), func() bool { return false }) if err != nil { t.Fatal(err) diff --git a/core/history/historymode.go b/core/history/historymode.go index e735222d3728..2ba746e7dd7d 100644 --- a/core/history/historymode.go +++ b/core/history/historymode.go @@ -32,10 +32,13 @@ const ( // KeepPostMerge sets the history pruning point to the merge activation block. KeepPostMerge + + // KeepPostPrague sets the history pruning point to the Prague (Pectra) activation block. + KeepPostPrague ) func (m HistoryMode) IsValid() bool { - return m <= KeepPostMerge + return m <= KeepPostPrague } func (m HistoryMode) String() string { @@ -44,6 +47,8 @@ func (m HistoryMode) String() string { return "all" case KeepPostMerge: return "postmerge" + case KeepPostPrague: + return "postprague" default: return fmt.Sprintf("invalid HistoryMode(%d)", m) } @@ -64,33 +69,77 @@ func (m *HistoryMode) UnmarshalText(text []byte) error { *m = KeepAll case "postmerge": *m = KeepPostMerge + case "postprague": + *m = KeepPostPrague default: - return fmt.Errorf(`unknown sync mode %q, want "all" or "postmerge"`, text) + return fmt.Errorf(`unknown history mode %q, want "all", "postmerge", or "postprague"`, text) } return nil } +// PrunePoint identifies a specific block for history pruning. type PrunePoint struct { BlockNumber uint64 BlockHash common.Hash } -// PrunePoints the pre-defined history pruning cutoff blocks for known networks. -// They point to the first post-merge block. Any pruning should truncate *up to* but excluding -// given block. -var PrunePoints = map[common.Hash]*PrunePoint{ - // mainnet - params.MainnetGenesisHash: { - BlockNumber: 15537393, - BlockHash: common.HexToHash("0x55b11b918355b1ef9c5db810302ebad0bf2544255b530cdce90674d5887bb286"), +// staticPrunePoints contains the pre-defined history pruning cutoff blocks for +// known networks, keyed by history mode and genesis hash. They point to the first +// block after the respective fork. Any pruning should truncate *up to* but +// excluding the given block. +var staticPrunePoints = map[HistoryMode]map[common.Hash]*PrunePoint{ + KeepPostMerge: { + params.MainnetGenesisHash: { + BlockNumber: 15537393, + BlockHash: common.HexToHash("0x55b11b918355b1ef9c5db810302ebad0bf2544255b530cdce90674d5887bb286"), + }, + params.SepoliaGenesisHash: { + BlockNumber: 1450409, + BlockHash: common.HexToHash("0x229f6b18ca1552f1d5146deceb5387333f40dc6275aebee3f2c5c4ece07d02db"), + }, }, - // sepolia - params.SepoliaGenesisHash: { - BlockNumber: 1450409, - BlockHash: common.HexToHash("0x229f6b18ca1552f1d5146deceb5387333f40dc6275aebee3f2c5c4ece07d02db"), + KeepPostPrague: { + params.MainnetGenesisHash: { + BlockNumber: 22431084, + BlockHash: common.HexToHash("0x50c8cab760b2948349c590461b166773c45d8f4858cccf5a43025ab2960152e8"), + }, + params.SepoliaGenesisHash: { + BlockNumber: 7836331, + BlockHash: common.HexToHash("0xe6571beb68bf24dbd8a6ba354518996920c55a3f8d8fdca423e391b8ad071f22"), + }, + params.HoodiGenesisHash: { + BlockNumber: 60412, + BlockHash: common.HexToHash("0x1562792812ef418eaafc8f1f093d84d9634971e9dd6b0771302eb5b9fd4d2c46"), + }, }, } +// HistoryPolicy describes the configured history pruning strategy. It captures +// user intent as opposed to the actual DB state. +type HistoryPolicy struct { + Mode HistoryMode + // Static prune point for PostMerge/PostPrague, nil otherwise. + Target *PrunePoint +} + +// NewPolicy constructs a HistoryPolicy from the given mode and genesis hash. +func NewPolicy(mode HistoryMode, genesisHash common.Hash) (HistoryPolicy, error) { + switch mode { + case KeepAll: + return HistoryPolicy{Mode: KeepAll}, nil + + case KeepPostMerge, KeepPostPrague: + point := staticPrunePoints[mode][genesisHash] + if point == nil { + return HistoryPolicy{}, fmt.Errorf("%s history pruning not available for network %s", mode, genesisHash.Hex()) + } + return HistoryPolicy{Mode: mode, Target: point}, nil + + default: + return HistoryPolicy{}, fmt.Errorf("invalid history mode: %d", mode) + } +} + // PrunedHistoryError is returned by APIs when the requested history is pruned. type PrunedHistoryError struct{} diff --git a/core/history/historymode_test.go b/core/history/historymode_test.go new file mode 100644 index 000000000000..87eae188ddb3 --- /dev/null +++ b/core/history/historymode_test.go @@ -0,0 +1,58 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package history + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" +) + +func TestNewPolicy(t *testing.T) { + // KeepAll: no target. + p, err := NewPolicy(KeepAll, params.MainnetGenesisHash) + if err != nil { + t.Fatalf("KeepAll: %v", err) + } + if p.Mode != KeepAll || p.Target != nil { + t.Errorf("KeepAll: unexpected policy %+v", p) + } + + // PostMerge: resolves known mainnet prune point. + p, err = NewPolicy(KeepPostMerge, params.MainnetGenesisHash) + if err != nil { + t.Fatalf("PostMerge: %v", err) + } + if p.Target == nil || p.Target.BlockNumber != 15537393 { + t.Errorf("PostMerge: unexpected target %+v", p.Target) + } + + // PostPrague: resolves known mainnet prune point. + p, err = NewPolicy(KeepPostPrague, params.MainnetGenesisHash) + if err != nil { + t.Fatalf("PostPrague: %v", err) + } + if p.Target == nil || p.Target.BlockNumber != 22431084 { + t.Errorf("PostPrague: unexpected target %+v", p.Target) + } + + // PostMerge on unknown network: error. + if _, err = NewPolicy(KeepPostMerge, common.HexToHash("0xdeadbeef")); err == nil { + t.Fatal("PostMerge unknown network: expected error") + } +} diff --git a/core/overlay/state_transition.go b/core/overlay/state_transition.go index 67ca0f967167..afd2bab017ed 100644 --- a/core/overlay/state_transition.go +++ b/core/overlay/state_transition.go @@ -71,7 +71,7 @@ func (ts *TransitionState) Copy() *TransitionState { // LoadTransitionState retrieves the Verkle transition state associated with // the given state root hash from the database. -func LoadTransitionState(db ethdb.KeyValueReader, root common.Hash, isVerkle bool) *TransitionState { +func LoadTransitionState(db ethdb.KeyValueReader, root common.Hash, isUBT bool) *TransitionState { var ts *TransitionState data, _ := rawdb.ReadVerkleTransitionState(db, root) @@ -97,10 +97,10 @@ func LoadTransitionState(db ethdb.KeyValueReader, root common.Hash, isVerkle boo // Initialize the first transition state, with the "ended" // field set to true if the database was created // as a verkle database. - log.Debug("no transition state found, starting fresh", "is verkle", db) + log.Debug("no transition state found, starting fresh", "verkle", isUBT) // Start with a fresh state - ts = &TransitionState{Ended: isVerkle} + ts = &TransitionState{Ended: isUBT} } return ts } diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go index 6ae64fb2fd11..987b8df39233 100644 --- a/core/rawdb/accessors_chain.go +++ b/core/rawdb/accessors_chain.go @@ -26,6 +26,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus/misc/eip4844" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/types/bal" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" @@ -174,7 +175,9 @@ func WriteFinalizedBlockHash(db ethdb.KeyValueWriter, hash common.Hash) { } // ReadLastPivotNumber retrieves the number of the last pivot block. If the node -// full synced, the last pivot will always be nil. +// has never attempted snap sync, the last pivot will always be nil. The marker +// is written during snap sync and never cleared, so that a rollback past the +// pivot can re-enable snap sync. func ReadLastPivotNumber(db ethdb.KeyValueReader) *uint64 { data, _ := db.Get(lastPivotKey) if len(data) == 0 { @@ -605,6 +608,55 @@ func DeleteReceipts(db ethdb.KeyValueWriter, hash common.Hash, number uint64) { } } +// HasAccessList verifies the existence of a block access list for a block. +func HasAccessList(db ethdb.Reader, hash common.Hash, number uint64) bool { + has, _ := db.Has(accessListKey(number, hash)) + return has +} + +// ReadAccessListRLP retrieves the RLP-encoded block access list for a block from KV. +func ReadAccessListRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue { + data, _ := db.Get(accessListKey(number, hash)) + return data +} + +// ReadAccessList retrieves and decodes the block access list for a block. +func ReadAccessList(db ethdb.Reader, hash common.Hash, number uint64) *bal.BlockAccessList { + data := ReadAccessListRLP(db, hash, number) + if len(data) == 0 { + return nil + } + b := new(bal.BlockAccessList) + if err := rlp.DecodeBytes(data, b); err != nil { + log.Error("Invalid BAL RLP", "hash", hash, "err", err) + return nil + } + return b +} + +// WriteAccessList RLP-encodes and stores a block access list in the active KV store. +func WriteAccessList(db ethdb.KeyValueWriter, hash common.Hash, number uint64, b *bal.BlockAccessList) { + bytes, err := rlp.EncodeToBytes(b) + if err != nil { + log.Crit("Failed to encode BAL", "err", err) + } + WriteAccessListRLP(db, hash, number, bytes) +} + +// WriteAccessListRLP stores a pre-encoded block access list in the active KV store. +func WriteAccessListRLP(db ethdb.KeyValueWriter, hash common.Hash, number uint64, encoded rlp.RawValue) { + if err := db.Put(accessListKey(number, hash), encoded); err != nil { + log.Crit("Failed to store BAL", "err", err) + } +} + +// DeleteAccessList removes a block access list from the active KV store. +func DeleteAccessList(db ethdb.KeyValueWriter, hash common.Hash, number uint64) { + if err := db.Delete(accessListKey(number, hash)); err != nil { + log.Crit("Failed to delete BAL", "err", err) + } +} + // ReceiptLogs is a barebone version of ReceiptForStorage which only keeps // the list of logs. When decoding a stored receipt into this object we // avoid creating the bloom filter. @@ -659,13 +711,25 @@ func ReadBlock(db ethdb.Reader, hash common.Hash, number uint64) *types.Block { if body == nil { return nil } - return types.NewBlockWithHeader(header).WithBody(*body) + block := types.NewBlockWithHeader(header).WithBody(*body) + + // Best-effort assembly of the block access list from the database. + if header.BlockAccessListHash != nil { + al := ReadAccessList(db, hash, number) + block = block.WithAccessListUnsafe(al) + } + return block } // WriteBlock serializes a block into the database, header and body separately. func WriteBlock(db ethdb.KeyValueWriter, block *types.Block) { - WriteBody(db, block.Hash(), block.NumberU64(), block.Body()) + hash, number := block.Hash(), block.NumberU64() + WriteBody(db, hash, number, block.Body()) WriteHeader(db, block.Header()) + + if accessList := block.AccessList(); accessList != nil { + WriteAccessList(db, hash, number, accessList) + } } // WriteAncientBlocks writes entire block data into ancient store and returns the total written size. diff --git a/core/rawdb/accessors_chain_test.go b/core/rawdb/accessors_chain_test.go index 02d51f4dd2a3..c35f56ee07c9 100644 --- a/core/rawdb/accessors_chain_test.go +++ b/core/rawdb/accessors_chain_test.go @@ -27,10 +27,12 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/types/bal" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" - "golang.org/x/crypto/sha3" + "github.com/holiman/uint256" ) // Tests block header storage and retrieval operations. @@ -52,10 +54,7 @@ func TestHeaderStorage(t *testing.T) { if entry := ReadHeaderRLP(db, header.Hash(), header.Number.Uint64()); entry == nil { t.Fatalf("Stored header RLP not found") } else { - hasher := sha3.NewLegacyKeccak256() - hasher.Write(entry) - - if hash := common.BytesToHash(hasher.Sum(nil)); hash != header.Hash() { + if hash := crypto.Keccak256Hash(entry); hash != header.Hash() { t.Fatalf("Retrieved RLP header mismatch: have %v, want %v", entry, header) } } @@ -72,8 +71,7 @@ func TestBodyStorage(t *testing.T) { // Create a test body to move around the database and make sure it's really new body := &types.Body{Uncles: []*types.Header{{Extra: []byte("test header")}}} - - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() rlp.Encode(hasher, body) hash := common.BytesToHash(hasher.Sum(nil)) @@ -90,10 +88,7 @@ func TestBodyStorage(t *testing.T) { if entry := ReadBodyRLP(db, hash, 0); entry == nil { t.Fatalf("Stored body RLP not found") } else { - hasher := sha3.NewLegacyKeccak256() - hasher.Write(entry) - - if calc := common.BytesToHash(hasher.Sum(nil)); calc != hash { + if calc := crypto.Keccak256Hash(entry); calc != hash { t.Fatalf("Retrieved RLP body mismatch: have %v, want %v", entry, body) } } @@ -906,3 +901,78 @@ func TestHeadersRLPStorage(t *testing.T) { checkSequence(1, 1) // Only block 1 checkSequence(1, 2) // Genesis + block 1 } + +func makeTestBAL(t *testing.T) (rlp.RawValue, *bal.BlockAccessList) { + t.Helper() + + cb := bal.NewConstructionBlockAccessList() + addr := common.HexToAddress("0x1111111111111111111111111111111111111111") + cb.AccountRead(addr) + cb.StorageRead(addr, common.BytesToHash([]byte{0x01})) + cb.StorageWrite(0, addr, common.BytesToHash([]byte{0x02}), common.BytesToHash([]byte{0xaa})) + cb.BalanceChange(0, addr, uint256.NewInt(100)) + cb.NonceChange(addr, 0, 1) + + var buf bytes.Buffer + if err := cb.EncodeRLP(&buf); err != nil { + t.Fatalf("failed to encode BAL: %v", err) + } + encoded := buf.Bytes() + + var decoded bal.BlockAccessList + if err := rlp.DecodeBytes(encoded, &decoded); err != nil { + t.Fatalf("failed to decode BAL: %v", err) + } + return encoded, &decoded +} + +// TestBALStorage tests write/read/delete of BALs in the KV store. +func TestBALStorage(t *testing.T) { + db := NewMemoryDatabase() + + hash := common.BytesToHash([]byte{0x03, 0x14}) + number := uint64(42) + + // Check that no BAL exists in a new database. + if HasAccessList(db, hash, number) { + t.Fatal("BAL found in new database") + } + if b := ReadAccessList(db, hash, number); b != nil { + t.Fatalf("non existent BAL returned: %v", b) + } + + // Write a BAL and verify it can be read back. + encoded, testBAL := makeTestBAL(t) + WriteAccessList(db, hash, number, testBAL) + + if !HasAccessList(db, hash, number) { + t.Fatal("HasAccessList returned false after write") + } + if blob := ReadAccessListRLP(db, hash, number); len(blob) == 0 { + t.Fatal("ReadAccessListRLP returned empty after write") + } + if b := ReadAccessList(db, hash, number); b == nil { + t.Fatal("ReadAccessList returned nil after write") + } else if b.Hash() != testBAL.Hash() { + t.Fatalf("BAL hash mismatch: got %x, want %x", b.Hash(), testBAL.Hash()) + } + + // Also test WriteAccessListRLP with pre-encoded data. + hash2 := common.BytesToHash([]byte{0x03, 0x15}) + WriteAccessListRLP(db, hash2, number, encoded) + if b := ReadAccessList(db, hash2, number); b == nil { + t.Fatal("ReadAccessList returned nil after WriteAccessListRLP") + } else if b.Hash() != testBAL.Hash() { + t.Fatalf("BAL hash mismatch after WriteAccessListRLP: got %x, want %x", b.Hash(), testBAL.Hash()) + } + + // Delete the BAL and verify it's gone. + DeleteAccessList(db, hash, number) + + if HasAccessList(db, hash, number) { + t.Fatal("HasAccessList returned true after delete") + } + if b := ReadAccessList(db, hash, number); b != nil { + t.Fatalf("deleted BAL returned: %v", b) + } +} diff --git a/core/rawdb/accessors_indexes.go b/core/rawdb/accessors_indexes.go index 10eb454015b1..8c8c3ec9bb63 100644 --- a/core/rawdb/accessors_indexes.go +++ b/core/rawdb/accessors_indexes.go @@ -147,9 +147,6 @@ func findTxInBlockBody(blockbody rlp.RawValue, target common.Hash) (*types.Trans } txIndex := uint64(0) for iter.Next() { - if iter.Err() != nil { - return nil, 0, iter.Err() - } // The preimage for the hash calculation of legacy transactions // is just their RLP encoding. For typed (EIP-2718) transactions, // which are encoded as byte arrays, the preimage is the content of @@ -171,6 +168,9 @@ func findTxInBlockBody(blockbody rlp.RawValue, target common.Hash) (*types.Trans } txIndex++ } + if iter.Err() != nil { + return nil, 0, iter.Err() + } return nil, 0, errors.New("transaction not found") } diff --git a/core/rawdb/ancient_utils.go b/core/rawdb/ancient_utils.go index 7af3d2e19762..8c6b18df08a4 100644 --- a/core/rawdb/ancient_utils.go +++ b/core/rawdb/ancient_utils.go @@ -149,6 +149,8 @@ func InspectFreezerTable(ancient string, freezerName string, tableName string, s path, tables = resolveChainFreezerDir(ancient), chainFreezerTableConfigs case MerkleStateFreezerName, VerkleStateFreezerName: path, tables = filepath.Join(ancient, freezerName), stateFreezerTableConfigs + case MerkleTrienodeFreezerName, VerkleTrienodeFreezerName: + path, tables = filepath.Join(ancient, freezerName), trienodeFreezerTableConfigs default: return fmt.Errorf("unknown freezer, supported ones: %v", freezers) } @@ -164,6 +166,7 @@ func InspectFreezerTable(ancient string, freezerName string, tableName string, s if err != nil { return err } + defer table.Close() table.dumpIndexStdout(start, end) return nil } diff --git a/core/rawdb/ancienttest/testsuite.go b/core/rawdb/ancienttest/testsuite.go index 7512c1f44b0d..eb66645a3a72 100644 --- a/core/rawdb/ancienttest/testsuite.go +++ b/core/rawdb/ancienttest/testsuite.go @@ -260,6 +260,46 @@ func basicWrite(t *testing.T, newFn func(kinds []string) ethdb.AncientStore) { if err != nil { t.Fatalf("Failed to write ancient data %v", err) } + + // Write should work after truncating from tail but over the head + db.TruncateTail(200) + head, err := db.Ancients() + if err != nil { + t.Fatalf("Failed to retrieve head ancients %v", err) + } + tail, err := db.Tail() + if err != nil { + t.Fatalf("Failed to retrieve tail ancients %v", err) + } + if head != 200 || tail != 200 { + t.Fatalf("Ancient head and tail are not expected") + } + _, err = db.ModifyAncients(func(op ethdb.AncientWriteOp) error { + offset := uint64(200) + for i := 0; i < 100; i++ { + if err := op.AppendRaw("a", offset+uint64(i), dataA[i]); err != nil { + return err + } + if err := op.AppendRaw("b", offset+uint64(i), dataB[i]); err != nil { + return err + } + } + return nil + }) + if err != nil { + t.Fatalf("Failed to write ancient data %v", err) + } + head, err = db.Ancients() + if err != nil { + t.Fatalf("Failed to retrieve head ancients %v", err) + } + tail, err = db.Tail() + if err != nil { + t.Fatalf("Failed to retrieve tail ancients %v", err) + } + if head != 300 || tail != 200 { + t.Fatalf("Ancient head and tail are not expected") + } } func nonMutable(t *testing.T, newFn func(kinds []string) ethdb.AncientStore) { diff --git a/core/rawdb/chain_iterator.go b/core/rawdb/chain_iterator.go index e7c89ca8d911..afa1aa7a4cc3 100644 --- a/core/rawdb/chain_iterator.go +++ b/core/rawdb/chain_iterator.go @@ -87,6 +87,7 @@ func InitDatabaseFromFreezer(db ethdb.Database) { type blockTxHashes struct { number uint64 hashes []common.Hash + err error } // iterateTransactions iterates over all transactions in the (canon) block @@ -144,17 +145,22 @@ func iterateTransactions(db ethdb.Database, from uint64, to uint64, reverse bool }() for data := range rlpCh { var body types.Body + var result *blockTxHashes if err := rlp.DecodeBytes(data.rlp, &body); err != nil { log.Warn("Failed to decode block body", "block", data.number, "error", err) - return - } - var hashes []common.Hash - for _, tx := range body.Transactions { - hashes = append(hashes, tx.Hash()) - } - result := &blockTxHashes{ - hashes: hashes, - number: data.number, + result = &blockTxHashes{ + number: data.number, + err: err, + } + } else { + hashes := make([]common.Hash, len(body.Transactions)) + for i, tx := range body.Transactions { + hashes[i] = tx.Hash() + } + result = &blockTxHashes{ + hashes: hashes, + number: data.number, + } } // Feed the block to the aggregator, or abort on interrupt select { @@ -214,6 +220,10 @@ func indexTransactions(db ethdb.Database, from uint64, to uint64, interrupt chan // Next block available, pop it off and index it delivery := queue.PopItem() lastNum = delivery.number + if delivery.err != nil { + log.Warn("Skipping tx indexing for block with missing/corrupt body", "block", delivery.number, "error", delivery.err) + continue + } WriteTxLookupEntries(batch, delivery.number, delivery.hashes) blocks++ txs += len(delivery.hashes) @@ -307,6 +317,10 @@ func unindexTransactions(db ethdb.Database, from uint64, to uint64, interrupt ch } delivery := queue.PopItem() nextNum = delivery.number + 1 + if delivery.err != nil { + log.Warn("Skipping tx unindexing for block with missing/corrupt body", "block", delivery.number, "error", delivery.err) + continue + } DeleteTxLookupEntries(batch, delivery.hashes) txs += len(delivery.hashes) blocks++ @@ -343,9 +357,9 @@ func unindexTransactions(db ethdb.Database, from uint64, to uint64, interrupt ch } select { case <-interrupt: - logger("Transaction unindexing interrupted", "blocks", blocks, "txs", txs, "tail", to, "elapsed", common.PrettyDuration(time.Since(start))) + logger("Transaction unindexing interrupted", "blocks", blocks, "txs", txs, "tail", nextNum, "elapsed", common.PrettyDuration(time.Since(start))) default: - logger("Unindexed transactions", "blocks", blocks, "txs", txs, "tail", to, "elapsed", common.PrettyDuration(time.Since(start))) + logger("Unindexed transactions", "blocks", blocks, "txs", txs, "tail", nextNum, "elapsed", common.PrettyDuration(time.Since(start))) } } diff --git a/core/rawdb/chain_iterator_test.go b/core/rawdb/chain_iterator_test.go index 75bd5a9a942c..089ebfe828c0 100644 --- a/core/rawdb/chain_iterator_test.go +++ b/core/rawdb/chain_iterator_test.go @@ -218,6 +218,36 @@ func TestIndexTransactions(t *testing.T) { verify(0, 8, false, 8) } +func TestUnindexTransactionsMissingBody(t *testing.T) { + // Construct test chain db + chainDB := NewMemoryDatabase() + blocks, _ := initDatabaseWithTransactions(chainDB) + + // Index the entire chain. + lastBlock := blocks[len(blocks)-1].NumberU64() + IndexTransactions(chainDB, 0, lastBlock+1, nil, false) + + // Prove that block 2 body exists in the database. + if raw := ReadCanonicalBodyRLP(chainDB, 2, nil); len(raw) == 0 { + t.Fatalf("Block 2 body does not exist in the database.") + } + + // Delete body for block 2. This simulates a corrupted database. + key := blockBodyKey(2, blocks[2].Hash()) + if err := chainDB.Delete(key); err != nil { + t.Fatalf("Failed to delete block body %v", err) + } + + // Unindex blocks [0, 3) + UnindexTransactions(chainDB, 0, 3, nil, false) + + // Verify that tx index tail is updated to 3. + tail := ReadTxIndexTail(chainDB) + if tail == nil || *tail != 3 { + t.Fatalf("The tx index tail is wrong: got %v want %d", *tail, 3) + } +} + func TestPruneTransactionIndex(t *testing.T) { chainDB := NewMemoryDatabase() blocks, _ := initDatabaseWithTransactions(chainDB) diff --git a/core/rawdb/database.go b/core/rawdb/database.go index 826039180252..39e1a64e5a23 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -35,6 +35,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb/memorydb" + "github.com/ethereum/go-ethereum/internal/tablewriter" "github.com/ethereum/go-ethereum/log" "golang.org/x/sync/errgroup" ) @@ -412,6 +413,7 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { tds stat numHashPairings stat hashNumPairings stat + blockAccessList stat legacyTries stat stateLookups stat accountTries stat @@ -429,7 +431,8 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { filterMapBlockLV stat // Path-mode archive data - stateIndex stat + stateIndex stat + trienodeIndex stat // Verkle statistics verkleTries stat @@ -476,12 +479,15 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { bodies.add(size) case bytes.HasPrefix(key, blockReceiptsPrefix) && len(key) == (len(blockReceiptsPrefix)+8+common.HashLength): receipts.add(size) - case bytes.HasPrefix(key, headerPrefix) && bytes.HasSuffix(key, headerTDSuffix): + case bytes.HasPrefix(key, headerPrefix) && bytes.HasSuffix(key, headerTDSuffix) && len(key) == (len(headerPrefix)+8+common.HashLength+len(headerTDSuffix)): tds.add(size) - case bytes.HasPrefix(key, headerPrefix) && bytes.HasSuffix(key, headerHashSuffix): + case bytes.HasPrefix(key, headerPrefix) && bytes.HasSuffix(key, headerHashSuffix) && len(key) == (len(headerPrefix)+8+len(headerHashSuffix)): numHashPairings.add(size) case bytes.HasPrefix(key, headerNumberPrefix) && len(key) == (len(headerNumberPrefix)+common.HashLength): hashNumPairings.add(size) + case bytes.HasPrefix(key, accessListPrefix) && len(key) == len(accessListPrefix)+8+common.HashLength: + blockAccessList.add(size) + case IsLegacyTrieNode(key, it.Value()): legacyTries.add(size) case bytes.HasPrefix(key, stateIDPrefix) && len(key) == len(stateIDPrefix)+common.HashLength: @@ -524,8 +530,19 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { bloomBits.add(size) // Path-based historic state indexes - case bytes.HasPrefix(key, StateHistoryIndexPrefix) && len(key) >= len(StateHistoryIndexPrefix)+common.HashLength: + case bytes.HasPrefix(key, StateHistoryAccountMetadataPrefix) && len(key) == len(StateHistoryAccountMetadataPrefix)+common.HashLength: + stateIndex.add(size) + case bytes.HasPrefix(key, StateHistoryStorageMetadataPrefix) && len(key) == len(StateHistoryStorageMetadataPrefix)+2*common.HashLength: + stateIndex.add(size) + case bytes.HasPrefix(key, StateHistoryAccountBlockPrefix) && len(key) == len(StateHistoryAccountBlockPrefix)+common.HashLength+4: stateIndex.add(size) + case bytes.HasPrefix(key, StateHistoryStorageBlockPrefix) && len(key) == len(StateHistoryStorageBlockPrefix)+2*common.HashLength+4: + stateIndex.add(size) + + case bytes.HasPrefix(key, TrienodeHistoryMetadataPrefix) && len(key) >= len(TrienodeHistoryMetadataPrefix)+common.HashLength: + trienodeIndex.add(size) + case bytes.HasPrefix(key, TrienodeHistoryBlockPrefix) && len(key) >= len(TrienodeHistoryBlockPrefix)+common.HashLength+4: + trienodeIndex.add(size) // Verkle trie data is detected, determine the sub-category case bytes.HasPrefix(key, VerklePrefix): @@ -612,6 +629,7 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { {"Key-Value store", "Difficulties (deprecated)", tds.sizeString(), tds.countString()}, {"Key-Value store", "Block number->hash", numHashPairings.sizeString(), numHashPairings.countString()}, {"Key-Value store", "Block hash->number", hashNumPairings.sizeString(), hashNumPairings.countString()}, + {"Key-Value store", "Block accessList", blockAccessList.sizeString(), blockAccessList.countString()}, {"Key-Value store", "Transaction index", txLookups.sizeString(), txLookups.countString()}, {"Key-Value store", "Log index filter-map rows", filterMapRows.sizeString(), filterMapRows.countString()}, {"Key-Value store", "Log index last-block-of-map", filterMapLastBlock.sizeString(), filterMapLastBlock.countString()}, @@ -622,12 +640,13 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { {"Key-Value store", "Path trie state lookups", stateLookups.sizeString(), stateLookups.countString()}, {"Key-Value store", "Path trie account nodes", accountTries.sizeString(), accountTries.countString()}, {"Key-Value store", "Path trie storage nodes", storageTries.sizeString(), storageTries.countString()}, - {"Key-Value store", "Path state history indexes", stateIndex.sizeString(), stateIndex.countString()}, {"Key-Value store", "Verkle trie nodes", verkleTries.sizeString(), verkleTries.countString()}, {"Key-Value store", "Verkle trie state lookups", verkleStateLookups.sizeString(), verkleStateLookups.countString()}, {"Key-Value store", "Trie preimages", preimages.sizeString(), preimages.countString()}, {"Key-Value store", "Account snapshot", accountSnaps.sizeString(), accountSnaps.countString()}, {"Key-Value store", "Storage snapshot", storageSnaps.sizeString(), storageSnaps.countString()}, + {"Key-Value store", "Historical state index", stateIndex.sizeString(), stateIndex.countString()}, + {"Key-Value store", "Historical trie index", trienodeIndex.sizeString(), trienodeIndex.countString()}, {"Key-Value store", "Beacon sync headers", beaconHeaders.sizeString(), beaconHeaders.countString()}, {"Key-Value store", "Clique snapshots", cliqueSnaps.sizeString(), cliqueSnaps.countString()}, {"Key-Value store", "Singleton metadata", metadata.sizeString(), metadata.countString()}, @@ -650,7 +669,7 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { total.Add(uint64(ancient.size())) } - table := NewTableWriter(os.Stdout) + table := tablewriter.NewWriter(os.Stdout) table.SetHeader([]string{"Database", "Category", "Size", "Items"}) table.SetFooter([]string{"", "Total", common.StorageSize(total.Load()).String(), fmt.Sprintf("%d", count.Load())}) table.AppendBulk(stats) @@ -672,7 +691,7 @@ var knownMetadataKeys = [][]byte{ snapshotGeneratorKey, snapshotRecoveryKey, txIndexTailKey, fastTxLookupLimitKey, uncleanShutdownKey, badBlockKey, transitionStatusKey, skeletonSyncStatusKey, persistentStateIDKey, trieJournalKey, snapshotSyncStatusKey, snapSyncStatusFlagKey, - filterMapsRangeKey, headStateHistoryIndexKey, VerkleTransitionStatePrefix, + filterMapsRangeKey, headStateHistoryIndexKey, headTrienodeHistoryIndexKey, VerkleTransitionStatePrefix, } // printChainMetadata prints out chain metadata to stderr. diff --git a/core/rawdb/eradb/eradb.go b/core/rawdb/eradb/eradb.go index a552b94da92c..d715c824ed42 100644 --- a/core/rawdb/eradb/eradb.go +++ b/core/rawdb/eradb/eradb.go @@ -27,6 +27,7 @@ import ( "github.com/ethereum/go-ethereum/common/lru" "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/onedb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" ) @@ -51,7 +52,7 @@ type Store struct { type fileCacheEntry struct { refcount int // reference count. This is protected by Store.mu! opened chan struct{} // signals opening of file has completed - file *era.Era // the file + file *onedb.Era // the file err error // error from opening the file } @@ -102,7 +103,7 @@ func (db *Store) Close() { // GetRawBody returns the raw body for a given block number. func (db *Store) GetRawBody(number uint64) ([]byte, error) { - epoch := number / uint64(era.MaxEra1Size) + epoch := number / uint64(era.MaxSize) entry := db.getEraByEpoch(epoch) if entry.err != nil { if errors.Is(entry.err, fs.ErrNotExist) { @@ -117,7 +118,7 @@ func (db *Store) GetRawBody(number uint64) ([]byte, error) { // GetRawReceipts returns the raw receipts for a given block number. func (db *Store) GetRawReceipts(number uint64) ([]byte, error) { - epoch := number / uint64(era.MaxEra1Size) + epoch := number / uint64(era.MaxSize) entry := db.getEraByEpoch(epoch) if entry.err != nil { if errors.Is(entry.err, fs.ErrNotExist) { @@ -249,7 +250,7 @@ func (db *Store) getCacheEntry(epoch uint64) (stat fileCacheStatus, entry *fileC } // fileOpened is called after an era file has been successfully opened. -func (db *Store) fileOpened(epoch uint64, entry *fileCacheEntry, file *era.Era) { +func (db *Store) fileOpened(epoch uint64, entry *fileCacheEntry, file *onedb.Era) { db.mu.Lock() defer db.mu.Unlock() @@ -282,7 +283,7 @@ func (db *Store) fileFailedToOpen(epoch uint64, entry *fileCacheEntry, err error entry.err = err } -func (db *Store) openEraFile(epoch uint64) (*era.Era, error) { +func (db *Store) openEraFile(epoch uint64) (*onedb.Era, error) { // File name scheme is --. glob := fmt.Sprintf("*-%05d-*.era1", epoch) matches, err := filepath.Glob(filepath.Join(db.datadir, glob)) @@ -297,17 +298,17 @@ func (db *Store) openEraFile(epoch uint64) (*era.Era, error) { } filename := matches[0] - e, err := era.Open(filename) + e, err := onedb.Open(filename) if err != nil { return nil, err } // Sanity-check start block. - if e.Start()%uint64(era.MaxEra1Size) != 0 { + if e.Start()%uint64(era.MaxSize) != 0 { e.Close() - return nil, fmt.Errorf("pre-merge era1 file has invalid boundary. %d %% %d != 0", e.Start(), era.MaxEra1Size) + return nil, fmt.Errorf("pre-merge era1 file has invalid boundary. %d %% %d != 0", e.Start(), era.MaxSize) } log.Debug("Opened era1 file", "epoch", epoch) - return e, nil + return e.(*onedb.Era), nil } // doneWithFile signals that the caller has finished using a file. diff --git a/core/rawdb/freezer.go b/core/rawdb/freezer.go index 42cd2a7999ab..0e2f86d6eddf 100644 --- a/core/rawdb/freezer.go +++ b/core/rawdb/freezer.go @@ -59,7 +59,7 @@ const freezerTableSize = 2 * 1000 * 1000 * 1000 // - The in-order data ensures that disk reads are always optimized. type Freezer struct { datadir string - frozen atomic.Uint64 // Number of items already frozen + head atomic.Uint64 // Number of items stored (including items removed from tail) tail atomic.Uint64 // Number of the first stored item in the freezer // This lock synchronizes writers and the truncate operation, as well as @@ -97,12 +97,12 @@ func NewFreezer(datadir string, namespace string, readonly bool, maxTableSize ui return nil, errSymlinkDatadir } } + // Leveldb/Pebble uses LOCK as the filelock filename. To prevent the + // name collision, we use FLOCK as the lock name. flockFile := filepath.Join(datadir, "FLOCK") if err := os.MkdirAll(filepath.Dir(flockFile), 0755); err != nil { return nil, err } - // Leveldb uses LOCK as the filelock filename. To prevent the - // name collision, we use FLOCK as the lock name. lock := flock.New(flockFile) tryLock := lock.TryLock if readonly { @@ -213,7 +213,7 @@ func (f *Freezer) AncientBytes(kind string, id, offset, length uint64) ([]byte, // Ancients returns the length of the frozen items. func (f *Freezer) Ancients() (uint64, error) { - return f.frozen.Load(), nil + return f.head.Load(), nil } // Tail returns the number of first stored item in the freezer. @@ -252,7 +252,7 @@ func (f *Freezer) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (writeSize defer f.writeLock.Unlock() // Roll back all tables to the starting position in case of error. - prevItem := f.frozen.Load() + prevItem := f.head.Load() defer func() { if err != nil { // The write operation has failed. Go back to the previous item position. @@ -273,7 +273,7 @@ func (f *Freezer) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (writeSize if err != nil { return 0, err } - f.frozen.Store(item) + f.head.Store(item) return writeSize, nil } @@ -286,7 +286,7 @@ func (f *Freezer) TruncateHead(items uint64) (uint64, error) { f.writeLock.Lock() defer f.writeLock.Unlock() - oitems := f.frozen.Load() + oitems := f.head.Load() if oitems <= items { return oitems, nil } @@ -295,7 +295,7 @@ func (f *Freezer) TruncateHead(items uint64) (uint64, error) { return 0, err } } - f.frozen.Store(items) + f.head.Store(items) return oitems, nil } @@ -320,6 +320,11 @@ func (f *Freezer) TruncateTail(tail uint64) (uint64, error) { } } f.tail.Store(tail) + + // Update the head if the requested tail exceeds the current head + if f.head.Load() < tail { + f.head.Store(tail) + } return old, nil } @@ -379,7 +384,7 @@ func (f *Freezer) validate() error { prunedTail = &tmp } - f.frozen.Store(head) + f.head.Store(head) f.tail.Store(*prunedTail) return nil } @@ -414,7 +419,7 @@ func (f *Freezer) repair() error { } } - f.frozen.Store(head) + f.head.Store(head) f.tail.Store(prunedTail) return nil } diff --git a/core/rawdb/freezer_memory.go b/core/rawdb/freezer_memory.go index 8cb4cc20063c..ec6d4b22e2e4 100644 --- a/core/rawdb/freezer_memory.go +++ b/core/rawdb/freezer_memory.go @@ -91,6 +91,13 @@ func (t *memoryTable) truncateHead(items uint64) error { if items < t.offset { return errors.New("truncation below tail") } + for i := int(items - t.offset); i < len(t.data); i++ { + if t.size > uint64(len(t.data[i])) { + t.size -= uint64(len(t.data[i])) + } else { + t.size = 0 + } + } t.data = t.data[:items-t.offset] t.items = items return nil @@ -106,13 +113,30 @@ func (t *memoryTable) truncateTail(items uint64) error { return nil } if t.items < items { - return errors.New("truncation above head") + return t.reset(items) + } + for i := uint64(0); i < items-t.offset; i++ { + if t.size > uint64(len(t.data[i])) { + t.size -= uint64(len(t.data[i])) + } else { + t.size = 0 + } } t.data = t.data[items-t.offset:] t.offset = items return nil } +// reset clears the entire table and sets both the head and tail to the given +// value. It assumes the caller holds the lock and that tail > t.items. +func (t *memoryTable) reset(offset uint64) error { + t.size = 0 + t.data = nil + t.items = offset + t.offset = offset + return nil +} + // commit merges the given item batch into table. It's presumed that the // batch is ordered and continuous with table. func (t *memoryTable) commit(batch [][]byte) error { @@ -373,6 +397,9 @@ func (f *MemoryFreezer) TruncateTail(tail uint64) (uint64, error) { } } f.tail = tail + if f.items < tail { + f.items = tail + } return old, nil } diff --git a/core/rawdb/freezer_resettable.go b/core/rawdb/freezer_resettable.go index f531e668c3d1..5494a648c859 100644 --- a/core/rawdb/freezer_resettable.go +++ b/core/rawdb/freezer_resettable.go @@ -221,13 +221,12 @@ func cleanup(path string) error { if err != nil { return err } + defer dir.Close() + names, err := dir.Readdirnames(0) if err != nil { return err } - if cerr := dir.Close(); cerr != nil { - return cerr - } for _, name := range names { if name == filepath.Base(path)+tmpSuffix { log.Info("Removed leftover freezer directory", "name", name) diff --git a/core/rawdb/freezer_table.go b/core/rawdb/freezer_table.go index aedb2d8eedc4..c770e89989b3 100644 --- a/core/rawdb/freezer_table.go +++ b/core/rawdb/freezer_table.go @@ -157,6 +157,7 @@ func newTable(path string, name string, readMeter, writeMeter *metrics.Meter, si } meta, err = openFreezerFileForReadOnly(filepath.Join(path, fmt.Sprintf("%s.meta", name))) if err != nil { + index.Close() return nil, err } } else { @@ -166,6 +167,7 @@ func newTable(path string, name string, readMeter, writeMeter *metrics.Meter, si } meta, err = openFreezerFileForAppend(filepath.Join(path, fmt.Sprintf("%s.meta", name))) if err != nil { + index.Close() return nil, err } } @@ -173,6 +175,8 @@ func newTable(path string, name string, readMeter, writeMeter *metrics.Meter, si // is detected. metadata, err := newMetadata(meta) if err != nil { + meta.Close() + index.Close() return nil, err } // Create the table and repair any past inconsistency @@ -707,12 +711,13 @@ func (t *freezerTable) truncateTail(items uint64) error { t.lock.Lock() defer t.lock.Unlock() - // Ensure the given truncate target falls in the correct range + // Short-circuit if the requested tail deletion points to a stale position if t.itemHidden.Load() >= items { return nil } + // If the requested tail exceeds the current head, reset the entire table if t.items.Load() < items { - return errors.New("truncation above head") + return t.resetTo(items) } // Load the new tail index by the given new tail position var ( @@ -822,10 +827,9 @@ func (t *freezerTable) truncateTail(items uint64) error { shorten := indexEntrySize * int64(newDeleted-deleted) if t.metadata.flushOffset <= shorten { return fmt.Errorf("invalid index flush offset: %d, shorten: %d", t.metadata.flushOffset, shorten) - } else { - if err := t.metadata.setFlushOffset(t.metadata.flushOffset-shorten, true); err != nil { - return err - } + } + if err := t.metadata.setFlushOffset(t.metadata.flushOffset-shorten, true); err != nil { + return err } // Retrieve the new size and update the total size counter newSize, err := t.sizeNolock() @@ -836,6 +840,59 @@ func (t *freezerTable) truncateTail(items uint64) error { return nil } +// resetTo clears the entire table and sets both the head and tail to the given +// value. It assumes the caller holds the lock and that tail > t.items. +func (t *freezerTable) resetTo(tail uint64) error { + // Sync the entire table before resetting, eliminating the potential + // data corruption. + err := t.doSync() + if err != nil { + return err + } + // Update the index file to reflect the new offset + if err := t.index.Close(); err != nil { + return err + } + entry := &indexEntry{ + filenum: t.headId + 1, + offset: uint32(tail), + } + if err := reset(t.index.Name(), entry.append(nil)); err != nil { + return err + } + if err := t.metadata.setVirtualTail(tail, true); err != nil { + return err + } + if err := t.metadata.setFlushOffset(indexEntrySize, true); err != nil { + return err + } + t.index, err = openFreezerFileForAppend(t.index.Name()) + if err != nil { + return err + } + + // Purge all the existing data file + if err := t.head.Close(); err != nil { + return err + } + t.headId = t.headId + 1 + t.tailId = t.headId + t.headBytes = 0 + + t.head, err = t.openFile(t.headId, openFreezerFileTruncated) + if err != nil { + return err + } + t.releaseFilesBefore(t.headId, true) + + t.items.Store(tail) + t.itemOffset.Store(tail) + t.itemHidden.Store(tail) + t.sizeGauge.Update(0) + + return nil +} + // Close closes all opened files and finalizes the freezer table for use. // This operation must be completed before shutdown to prevent the loss of // recent writes. @@ -1247,25 +1304,20 @@ func (t *freezerTable) doSync() error { if t.index == nil || t.head == nil || t.metadata.file == nil { return errClosed } - var err error - trackError := func(e error) { - if e != nil && err == nil { - err = e - } + if err := t.index.Sync(); err != nil { + return err + } + if err := t.head.Sync(); err != nil { + return err } - trackError(t.index.Sync()) - trackError(t.head.Sync()) - // A crash may occur before the offset is updated, leaving the offset - // points to a old position. If so, the extra items above the offset + // points to an old position. If so, the extra items above the offset // will be truncated during the next run. stat, err := t.index.Stat() if err != nil { return err } - offset := stat.Size() - trackError(t.metadata.setFlushOffset(offset, true)) - return err + return t.metadata.setFlushOffset(stat.Size(), true) } func (t *freezerTable) dumpIndexStdout(start, stop int64) { diff --git a/core/rawdb/freezer_table_test.go b/core/rawdb/freezer_table_test.go index fc21ea6c6350..3393f88e1afc 100644 --- a/core/rawdb/freezer_table_test.go +++ b/core/rawdb/freezer_table_test.go @@ -1139,6 +1139,7 @@ const ( opTruncateHeadAll opTruncateTail opTruncateTailAll + opTruncateTailOverHead opCheckAll opMax // boundary value, not an actual op ) @@ -1226,6 +1227,11 @@ func (randTest) Generate(r *rand.Rand, size int) reflect.Value { step.target = deleted + uint64(len(items)) items = items[:0] deleted = step.target + case opTruncateTailOverHead: + newDeleted := deleted + uint64(len(items)) + 10 + step.target = newDeleted + deleted = newDeleted + items = items[:0] } steps = append(steps, step) } @@ -1268,7 +1274,7 @@ func runRandTest(rt randTest) bool { for i := 0; i < len(step.items); i++ { batch.AppendRaw(step.items[i], step.blobs[i]) } - batch.commit() + rt[i].err = batch.commit() values = append(values, step.blobs...) case opRetrieve: @@ -1290,24 +1296,28 @@ func runRandTest(rt randTest) bool { } case opTruncateHead: - f.truncateHead(step.target) + rt[i].err = f.truncateHead(step.target) length := f.items.Load() - f.itemHidden.Load() values = values[:length] case opTruncateHeadAll: - f.truncateHead(step.target) + rt[i].err = f.truncateHead(step.target) values = nil case opTruncateTail: prev := f.itemHidden.Load() - f.truncateTail(step.target) + rt[i].err = f.truncateTail(step.target) truncated := f.itemHidden.Load() - prev values = values[truncated:] case opTruncateTailAll: - f.truncateTail(step.target) + rt[i].err = f.truncateTail(step.target) + values = nil + + case opTruncateTailOverHead: + rt[i].err = f.truncateTail(step.target) values = nil } // Abort the test on error. @@ -1633,3 +1643,43 @@ func TestFreezerAncientBytes(t *testing.T) { }) } } + +func TestTruncateOverHead(t *testing.T) { + t.Parallel() + + fn := fmt.Sprintf("t-%d", rand.Uint64()) + f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 100, freezerTableConfig{noSnappy: true}, false) + if err != nil { + t.Fatal(err) + } + + // Tail truncation on an empty table + if err := f.truncateTail(10); err != nil { + t.Fatal(err) + } + batch := f.newBatch() + data := getChunk(10, 1) + require.NoError(t, batch.AppendRaw(uint64(10), data)) + require.NoError(t, batch.commit()) + + got, err := f.RetrieveItems(uint64(10), 1, 0) + require.NoError(t, err) + if !bytes.Equal(got[0], data) { + t.Fatalf("Unexpected bytes, want: %v, got: %v", data, got[0]) + } + + // Tail truncation on the non-empty table + if err := f.truncateTail(20); err != nil { + t.Fatal(err) + } + batch = f.newBatch() + data = getChunk(10, 1) + require.NoError(t, batch.AppendRaw(uint64(20), data)) + require.NoError(t, batch.commit()) + + got, err = f.RetrieveItems(uint64(20), 1, 0) + require.NoError(t, err) + if !bytes.Equal(got[0], data) { + t.Fatalf("Unexpected bytes, want: %v, got: %v", data, got[0]) + } +} diff --git a/core/rawdb/freezer_utils.go b/core/rawdb/freezer_utils.go index 752e95ba6aea..cd5239adc01c 100644 --- a/core/rawdb/freezer_utils.go +++ b/core/rawdb/freezer_utils.go @@ -22,6 +22,13 @@ import ( "path/filepath" ) +func atomicRename(src, dest string) error { + if err := os.Rename(src, dest); err != nil { + return err + } + return syncDir(filepath.Dir(src)) +} + // copyFrom copies data from 'srcPath' at offset 'offset' into 'destPath'. // The 'destPath' is created if it doesn't exist, otherwise it is overwritten. // Before the copy is executed, there is a callback can be registered to @@ -69,17 +76,57 @@ func copyFrom(srcPath, destPath string, offset uint64, before func(f *os.File) e // we do the final move. src.Close() + // Permanently persist the content into disk + if err := f.Sync(); err != nil { + return err + } + + if err := f.Close(); err != nil { + return err + } + f = nil + + return atomicRename(fname, destPath) +} + +// reset atomically replaces the file at the given path with the provided content. +func reset(path string, content []byte) error { + // Create a temp file in the same dir where we want it to wind up + f, err := os.CreateTemp(filepath.Dir(path), "*") + if err != nil { + return err + } + fname := f.Name() + + // Clean up the leftover file + defer func() { + if f != nil { + f.Close() + } + os.Remove(fname) + }() + + // Write the content into the temp file + _, err = f.Write(content) + if err != nil { + return err + } + // Permanently persist the content into disk + if err := f.Sync(); err != nil { + return err + } if err := f.Close(); err != nil { return err } f = nil - return os.Rename(fname, destPath) + + return atomicRename(fname, path) } // openFreezerFileForAppend opens a freezer table file and seeks to the end func openFreezerFileForAppend(filename string) (*os.File, error) { // Open the file without the O_APPEND flag - // because it has differing behaviour during Truncate operations + // because it has differing behavior during Truncate operations // on different OS's file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0644) if err != nil { @@ -87,6 +134,7 @@ func openFreezerFileForAppend(filename string) (*os.File, error) { } // Seek to end for append if _, err = file.Seek(0, io.SeekEnd); err != nil { + file.Close() return nil, err } return file, nil diff --git a/core/rawdb/freezer_utils_unix.go b/core/rawdb/freezer_utils_unix.go new file mode 100644 index 000000000000..1d26490cab32 --- /dev/null +++ b/core/rawdb/freezer_utils_unix.go @@ -0,0 +1,49 @@ +// Copyright 2022 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +//go:build !windows +// +build !windows + +package rawdb + +import ( + "errors" + "os" + "syscall" +) + +// syncDir ensures that the directory metadata (e.g. newly renamed files) +// is flushed to durable storage. +func syncDir(name string) error { + f, err := os.Open(name) + if err != nil { + return err + } + defer f.Close() + + // Some file systems do not support fsyncing directories (e.g. some FUSE + // mounts). Ignore EINVAL in those cases. + if err := f.Sync(); err != nil { + if errors.Is(err, os.ErrInvalid) { + return nil + } + if patherr, ok := err.(*os.PathError); ok && patherr.Err == syscall.EINVAL { + return nil + } + return err + } + return nil +} diff --git a/eth/protocols/snap/tracker.go b/core/rawdb/freezer_utils_windows.go similarity index 74% rename from eth/protocols/snap/tracker.go rename to core/rawdb/freezer_utils_windows.go index 2cf59cc23acd..7b652f7ab593 100644 --- a/eth/protocols/snap/tracker.go +++ b/core/rawdb/freezer_utils_windows.go @@ -1,4 +1,4 @@ -// Copyright 2021 The go-ethereum Authors +// Copyright 2022 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify @@ -14,13 +14,13 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package snap +//go:build windows +// +build windows -import ( - "time" +package rawdb - "github.com/ethereum/go-ethereum/p2p/tracker" -) - -// requestTracker is a singleton tracker for request times. -var requestTracker = tracker.New(ProtocolName, time.Minute) +// syncDir is a no-op on Windows. Fsyncing a directory handle is not +// supported and returns "Access is denied". +func syncDir(name string) error { + return nil +} diff --git a/core/rawdb/schema.go b/core/rawdb/schema.go index d9140c5fd658..54c76143b4fe 100644 --- a/core/rawdb/schema.go +++ b/core/rawdb/schema.go @@ -112,6 +112,7 @@ var ( blockBodyPrefix = []byte("b") // blockBodyPrefix + num (uint64 big endian) + hash -> block body blockReceiptsPrefix = []byte("r") // blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts + accessListPrefix = []byte("j") // accessListPrefix + num (uint64 big endian) + hash -> block access list txLookupPrefix = []byte("l") // txLookupPrefix + hash -> transaction/receipt lookup metadata bloomBitsPrefix = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits @@ -214,6 +215,11 @@ func blockReceiptsKey(number uint64, hash common.Hash) []byte { return append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...) } +// accessListKey = accessListPrefix + num (uint64 big endian) + hash +func accessListKey(number uint64, hash common.Hash) []byte { + return append(append(accessListPrefix, encodeBlockNumber(number)...), hash.Bytes()...) +} + // txLookupKey = txLookupPrefix + hash func txLookupKey(hash common.Hash) []byte { return append(txLookupPrefix, hash.Bytes()...) diff --git a/core/rawdb/table.go b/core/rawdb/table.go index d38afdaa3545..407a619c9f58 100644 --- a/core/rawdb/table.go +++ b/core/rawdb/table.go @@ -253,6 +253,11 @@ func (b *tableBatch) Reset() { b.batch.Reset() } +// Close closes the batch and releases all associated resources. +func (b *tableBatch) Close() { + b.batch.Close() +} + // tableReplayer is a wrapper around a batch replayer which truncates // the added prefix. type tableReplayer struct { diff --git a/core/rlp_test.go b/core/rlp_test.go index 69efa8255183..f3655bf533ee 100644 --- a/core/rlp_test.go +++ b/core/rlp_test.go @@ -25,9 +25,9 @@ import ( "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" - "golang.org/x/crypto/sha3" ) func getBlock(transactions int, uncles int, dataSize int) *types.Block { @@ -147,7 +147,7 @@ func BenchmarkHashing(b *testing.B) { blockRlp, _ = rlp.EncodeToBytes(block) } var got common.Hash - var hasher = sha3.NewLegacyKeccak256() + var hasher = keccak.NewLegacyKeccak256() b.Run("iteratorhashing", func(b *testing.B) { for b.Loop() { var hash common.Hash diff --git a/core/state/access_events.go b/core/state/access_events.go index 0575c9898aef..86f44bd62350 100644 --- a/core/state/access_events.go +++ b/core/state/access_events.go @@ -23,7 +23,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie/utils" + "github.com/ethereum/go-ethereum/trie/bintrie" "github.com/holiman/uint256" ) @@ -45,15 +45,12 @@ var zeroTreeIndex uint256.Int type AccessEvents struct { branches map[branchAccessKey]mode chunks map[chunkAccessKey]mode - - pointCache *utils.PointCache } -func NewAccessEvents(pointCache *utils.PointCache) *AccessEvents { +func NewAccessEvents() *AccessEvents { return &AccessEvents{ - branches: make(map[branchAccessKey]mode), - chunks: make(map[chunkAccessKey]mode), - pointCache: pointCache, + branches: make(map[branchAccessKey]mode), + chunks: make(map[chunkAccessKey]mode), } } @@ -75,8 +72,11 @@ func (ae *AccessEvents) Keys() [][]byte { // TODO: consider if parallelizing this is worth it, probably depending on len(ae.chunks). keys := make([][]byte, 0, len(ae.chunks)) for chunk := range ae.chunks { - basePoint := ae.pointCache.Get(chunk.addr[:]) - key := utils.GetTreeKeyWithEvaluatedAddress(basePoint, &chunk.treeIndex, chunk.leafKey) + var offset [32]byte + treeIndexBytes := chunk.treeIndex.Bytes32() + copy(offset[:31], treeIndexBytes[1:]) + offset[31] = chunk.leafKey + key := bintrie.GetBinaryTreeKey(chunk.addr, offset[:]) keys = append(keys, key) } return keys @@ -84,9 +84,8 @@ func (ae *AccessEvents) Keys() [][]byte { func (ae *AccessEvents) Copy() *AccessEvents { cpy := &AccessEvents{ - branches: maps.Clone(ae.branches), - chunks: maps.Clone(ae.chunks), - pointCache: ae.pointCache, + branches: maps.Clone(ae.branches), + chunks: maps.Clone(ae.chunks), } return cpy } @@ -95,12 +94,12 @@ func (ae *AccessEvents) Copy() *AccessEvents { // member fields of an account. func (ae *AccessEvents) AddAccount(addr common.Address, isWrite bool, availableGas uint64) uint64 { var gas uint64 // accumulate the consumed gas - consumed, expected := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.BasicDataLeafKey, isWrite, availableGas) + consumed, expected := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.BasicDataLeafKey, isWrite, availableGas) if consumed < expected { return expected } gas += consumed - consumed, expected = ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeHashLeafKey, isWrite, availableGas-consumed) + consumed, expected = ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.CodeHashLeafKey, isWrite, availableGas-consumed) if consumed < expected { return expected + gas } @@ -112,7 +111,7 @@ func (ae *AccessEvents) AddAccount(addr common.Address, isWrite bool, availableG // cold member fields of an account, that need to be touched when making a message // call to that account. func (ae *AccessEvents) MessageCallGas(destination common.Address, availableGas uint64) uint64 { - _, expected := ae.touchAddressAndChargeGas(destination, zeroTreeIndex, utils.BasicDataLeafKey, false, availableGas) + _, expected := ae.touchAddressAndChargeGas(destination, zeroTreeIndex, bintrie.BasicDataLeafKey, false, availableGas) if expected == 0 { expected = params.WarmStorageReadCostEIP2929 } @@ -122,11 +121,11 @@ func (ae *AccessEvents) MessageCallGas(destination common.Address, availableGas // ValueTransferGas returns the gas to be charged for each of the currently // cold balance member fields of the caller and the callee accounts. func (ae *AccessEvents) ValueTransferGas(callerAddr, targetAddr common.Address, availableGas uint64) uint64 { - _, expected1 := ae.touchAddressAndChargeGas(callerAddr, zeroTreeIndex, utils.BasicDataLeafKey, true, availableGas) + _, expected1 := ae.touchAddressAndChargeGas(callerAddr, zeroTreeIndex, bintrie.BasicDataLeafKey, true, availableGas) if expected1 > availableGas { return expected1 } - _, expected2 := ae.touchAddressAndChargeGas(targetAddr, zeroTreeIndex, utils.BasicDataLeafKey, true, availableGas-expected1) + _, expected2 := ae.touchAddressAndChargeGas(targetAddr, zeroTreeIndex, bintrie.BasicDataLeafKey, true, availableGas-expected1) if expected1+expected2 == 0 { return params.WarmStorageReadCostEIP2929 } @@ -138,8 +137,8 @@ func (ae *AccessEvents) ValueTransferGas(callerAddr, targetAddr common.Address, // address collision is done before the transfer, and so no write // are guaranteed to happen at this point. func (ae *AccessEvents) ContractCreatePreCheckGas(addr common.Address, availableGas uint64) uint64 { - consumed, expected1 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.BasicDataLeafKey, false, availableGas) - _, expected2 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeHashLeafKey, false, availableGas-consumed) + consumed, expected1 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.BasicDataLeafKey, false, availableGas) + _, expected2 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.CodeHashLeafKey, false, availableGas-consumed) return expected1 + expected2 } @@ -147,9 +146,9 @@ func (ae *AccessEvents) ContractCreatePreCheckGas(addr common.Address, available // a contract creation. func (ae *AccessEvents) ContractCreateInitGas(addr common.Address, availableGas uint64) (uint64, uint64) { var gas uint64 - consumed, expected1 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.BasicDataLeafKey, true, availableGas) + consumed, expected1 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.BasicDataLeafKey, true, availableGas) gas += consumed - consumed, expected2 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeHashLeafKey, true, availableGas-consumed) + consumed, expected2 := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.CodeHashLeafKey, true, availableGas-consumed) gas += consumed return gas, expected1 + expected2 } @@ -157,20 +156,20 @@ func (ae *AccessEvents) ContractCreateInitGas(addr common.Address, availableGas // AddTxOrigin adds the member fields of the sender account to the access event list, // so that cold accesses are not charged, since they are covered by the 21000 gas. func (ae *AccessEvents) AddTxOrigin(originAddr common.Address) { - ae.touchAddressAndChargeGas(originAddr, zeroTreeIndex, utils.BasicDataLeafKey, true, gomath.MaxUint64) - ae.touchAddressAndChargeGas(originAddr, zeroTreeIndex, utils.CodeHashLeafKey, false, gomath.MaxUint64) + ae.touchAddressAndChargeGas(originAddr, zeroTreeIndex, bintrie.BasicDataLeafKey, true, gomath.MaxUint64) + ae.touchAddressAndChargeGas(originAddr, zeroTreeIndex, bintrie.CodeHashLeafKey, false, gomath.MaxUint64) } // AddTxDestination adds the member fields of the sender account to the access event list, // so that cold accesses are not charged, since they are covered by the 21000 gas. func (ae *AccessEvents) AddTxDestination(addr common.Address, sendsValue, doesntExist bool) { - ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.BasicDataLeafKey, sendsValue, gomath.MaxUint64) - ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeHashLeafKey, doesntExist, gomath.MaxUint64) + ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.BasicDataLeafKey, sendsValue, gomath.MaxUint64) + ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.CodeHashLeafKey, doesntExist, gomath.MaxUint64) } // SlotGas returns the amount of gas to be charged for a cold storage access. func (ae *AccessEvents) SlotGas(addr common.Address, slot common.Hash, isWrite bool, availableGas uint64, chargeWarmCosts bool) uint64 { - treeIndex, subIndex := utils.StorageIndex(slot.Bytes()) + treeIndex, subIndex := bintrie.StorageIndex(slot.Bytes()) _, expected := ae.touchAddressAndChargeGas(addr, *treeIndex, subIndex, isWrite, availableGas) if expected == 0 && chargeWarmCosts { expected = params.WarmStorageReadCostEIP2929 @@ -313,7 +312,7 @@ func (ae *AccessEvents) CodeChunksRangeGas(contractAddr common.Address, startPC, // Note that an access in write mode implies an access in read mode, whereas an // access in read mode does not imply an access in write mode. func (ae *AccessEvents) BasicDataGas(addr common.Address, isWrite bool, availableGas uint64, chargeWarmCosts bool) uint64 { - _, expected := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.BasicDataLeafKey, isWrite, availableGas) + _, expected := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.BasicDataLeafKey, isWrite, availableGas) if expected == 0 && chargeWarmCosts { if availableGas < params.WarmStorageReadCostEIP2929 { return availableGas @@ -329,7 +328,7 @@ func (ae *AccessEvents) BasicDataGas(addr common.Address, isWrite bool, availabl // Note that an access in write mode implies an access in read mode, whereas an access in // read mode does not imply an access in write mode. func (ae *AccessEvents) CodeHashGas(addr common.Address, isWrite bool, availableGas uint64, chargeWarmCosts bool) uint64 { - _, expected := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeHashLeafKey, isWrite, availableGas) + _, expected := ae.touchAddressAndChargeGas(addr, zeroTreeIndex, bintrie.CodeHashLeafKey, isWrite, availableGas) if expected == 0 && chargeWarmCosts { if availableGas < params.WarmStorageReadCostEIP2929 { return availableGas diff --git a/core/state/access_events_test.go b/core/state/access_events_test.go index e80859a0b428..0b39130e8db8 100644 --- a/core/state/access_events_test.go +++ b/core/state/access_events_test.go @@ -22,7 +22,6 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie/utils" ) var ( @@ -38,7 +37,7 @@ func init() { } func TestAccountHeaderGas(t *testing.T) { - ae := NewAccessEvents(utils.NewPointCache(1024)) + ae := NewAccessEvents() // Check cold read cost gas := ae.BasicDataGas(testAddr, false, math.MaxUint64, false) @@ -93,7 +92,7 @@ func TestAccountHeaderGas(t *testing.T) { // TestContractCreateInitGas checks that the gas cost of contract creation is correctly // calculated. func TestContractCreateInitGas(t *testing.T) { - ae := NewAccessEvents(utils.NewPointCache(1024)) + ae := NewAccessEvents() var testAddr [20]byte for i := byte(0); i < 20; i++ { @@ -116,7 +115,7 @@ func TestContractCreateInitGas(t *testing.T) { // TestMessageCallGas checks that the gas cost of message calls is correctly // calculated. func TestMessageCallGas(t *testing.T) { - ae := NewAccessEvents(utils.NewPointCache(1024)) + ae := NewAccessEvents() // Check cold read cost, without a value gas := ae.MessageCallGas(testAddr, math.MaxUint64) diff --git a/core/state/database.go b/core/state/database.go index ae177d964f9a..3b1e627f286c 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -20,51 +20,57 @@ import ( "fmt" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/lru" - "github.com/ethereum/go-ethereum/core/overlay" "github.com/ethereum/go-ethereum/core/rawdb" - "github.com/ethereum/go-ethereum/core/state/snapshot" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie/bintrie" "github.com/ethereum/go-ethereum/trie/transitiontrie" "github.com/ethereum/go-ethereum/trie/trienode" - "github.com/ethereum/go-ethereum/trie/utils" "github.com/ethereum/go-ethereum/triedb" ) -const ( - // Number of codehash->size associations to keep. - codeSizeCacheSize = 1_000_000 // 4 megabytes in total +// DatabaseType represents the type of trie backing the state database. +type DatabaseType int - // Cache size granted for caching clean code. - codeCacheSize = 256 * 1024 * 1024 +const ( + // TypeMPT indicates a Merkle Patricia Trie (MPT) backed database. + TypeMPT DatabaseType = iota - // Number of address->curve point associations to keep. - pointCacheSize = 4096 + // TypeUBT indicates a Unified Binary Trie (UBT) backed database. + TypeUBT ) +// Is returns the flag indicating the database type equals to the given one. +func (typ DatabaseType) Is(t DatabaseType) bool { + return typ == t +} + // Database wraps access to tries and contract code. type Database interface { + // Type returns the trie type backing this database (MPT or UBT). + Type() DatabaseType + // Reader returns a state reader associated with the specified state root. Reader(root common.Hash) (Reader, error) + // Iteratee returns a state iteratee associated with the specified state root, + // through which the account iterator and storage iterator can be created. + Iteratee(root common.Hash) (Iteratee, error) + // OpenTrie opens the main account trie. OpenTrie(root common.Hash) (Trie, error) // OpenStorageTrie opens the storage trie of an account. OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, trie Trie) (Trie, error) - // PointCache returns the cache holding points used in verkle tree key computation - PointCache() *utils.PointCache - // TrieDB returns the underlying trie database for managing trie nodes. TrieDB() *triedb.Database - // Snapshot returns the underlying state snapshot. - Snapshot() *snapshot.Tree + // Commit flushes all pending writes and finalizes the state transition, + // committing the changes to the underlying storage. It returns an error + // if the commit fails. + Commit(update *StateUpdate) error } // Trie is a Ethereum Merkle Patricia trie. @@ -148,155 +154,25 @@ type Trie interface { // with the node that proves the absence of the key. Prove(key []byte, proofDb ethdb.KeyValueWriter) error - // IsVerkle returns true if the trie is verkle-tree based - IsVerkle() bool -} - -// CachingDB is an implementation of Database interface. It leverages both trie and -// state snapshot to provide functionalities for state access. It's meant to be a -// long-live object and has a few caches inside for sharing between blocks. -type CachingDB struct { - disk ethdb.KeyValueStore - triedb *triedb.Database - snap *snapshot.Tree - codeCache *lru.SizeConstrainedCache[common.Hash, []byte] - codeSizeCache *lru.Cache[common.Hash, int] - pointCache *utils.PointCache - - // Transition-specific fields - TransitionStatePerRoot *lru.Cache[common.Hash, *overlay.TransitionState] + // IsUBT returns true if the trie is unified binary trie based. + IsUBT() bool } // NewDatabase creates a state database with the provided data sources. -func NewDatabase(triedb *triedb.Database, snap *snapshot.Tree) *CachingDB { - return &CachingDB{ - disk: triedb.Disk(), - triedb: triedb, - snap: snap, - codeCache: lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize), - codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize), - pointCache: utils.NewPointCache(pointCacheSize), - TransitionStatePerRoot: lru.NewCache[common.Hash, *overlay.TransitionState](1000), +// +// Deprecated, please use NewMPTDatabase or NewUBTDatabase directly. +func NewDatabase(tdb *triedb.Database, codedb *CodeDB) Database { + if tdb.IsUBT() { + return NewUBTDatabase(tdb, codedb) } + return NewMPTDatabase(tdb, codedb) } // NewDatabaseForTesting is similar to NewDatabase, but it initializes the caching // db by using an ephemeral memory db with default config for testing. -func NewDatabaseForTesting() *CachingDB { - return NewDatabase(triedb.NewDatabase(rawdb.NewMemoryDatabase(), nil), nil) -} - -// Reader returns a state reader associated with the specified state root. -func (db *CachingDB) Reader(stateRoot common.Hash) (Reader, error) { - var readers []StateReader - - // Configure the state reader using the standalone snapshot in hash mode. - // This reader offers improved performance but is optional and only - // partially useful if the snapshot is not fully generated. - if db.TrieDB().Scheme() == rawdb.HashScheme && db.snap != nil { - snap := db.snap.Snapshot(stateRoot) - if snap != nil { - readers = append(readers, newFlatReader(snap)) - } - } - // Configure the state reader using the path database in path mode. - // This reader offers improved performance but is optional and only - // partially useful if the snapshot data in path database is not - // fully generated. - if db.TrieDB().Scheme() == rawdb.PathScheme { - reader, err := db.triedb.StateReader(stateRoot) - if err == nil { - readers = append(readers, newFlatReader(reader)) - } - } - // Configure the trie reader, which is expected to be available as the - // gatekeeper unless the state is corrupted. - tr, err := newTrieReader(stateRoot, db.triedb, db.pointCache) - if err != nil { - return nil, err - } - readers = append(readers, tr) - - combined, err := newMultiStateReader(readers...) - if err != nil { - return nil, err - } - return newReader(newCachingCodeReader(db.disk, db.codeCache, db.codeSizeCache), combined), nil -} - -// ReadersWithCacheStats creates a pair of state readers sharing the same internal cache and -// same backing Reader, but exposing separate statistics. -// and statistics. -func (db *CachingDB) ReadersWithCacheStats(stateRoot common.Hash) (ReaderWithStats, ReaderWithStats, error) { - reader, err := db.Reader(stateRoot) - if err != nil { - return nil, nil, err - } - shared := newReaderWithCache(reader) - return newReaderWithCacheStats(shared), newReaderWithCacheStats(shared), nil -} - -// OpenTrie opens the main account trie at a specific root hash. -func (db *CachingDB) OpenTrie(root common.Hash) (Trie, error) { - if db.triedb.IsVerkle() { - ts := overlay.LoadTransitionState(db.TrieDB().Disk(), root, db.triedb.IsVerkle()) - if ts.InTransition() { - panic("state tree transition isn't supported yet") - } - if ts.Transitioned() { - // Use BinaryTrie instead of VerkleTrie when IsVerkle is set - // (IsVerkle actually means Binary Trie mode in this codebase) - return bintrie.NewBinaryTrie(root, db.triedb) - } - } - tr, err := trie.NewStateTrie(trie.StateTrieID(root), db.triedb) - if err != nil { - return nil, err - } - return tr, nil -} - -// OpenStorageTrie opens the storage trie of an account. -func (db *CachingDB) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, self Trie) (Trie, error) { - if db.triedb.IsVerkle() { - return self, nil - } - tr, err := trie.NewStateTrie(trie.StorageTrieID(stateRoot, crypto.Keccak256Hash(address.Bytes()), root), db.triedb) - if err != nil { - return nil, err - } - return tr, nil -} - -// ContractCodeWithPrefix retrieves a particular contract's code. If the -// code can't be found in the cache, then check the existence with **new** -// db scheme. -func (db *CachingDB) ContractCodeWithPrefix(address common.Address, codeHash common.Hash) []byte { - code, _ := db.codeCache.Get(codeHash) - if len(code) > 0 { - return code - } - code = rawdb.ReadCodeWithPrefix(db.disk, codeHash) - if len(code) > 0 { - db.codeCache.Add(codeHash, code) - db.codeSizeCache.Add(codeHash, len(code)) - } - return code -} - -// TrieDB retrieves any intermediate trie-node caching layer. -func (db *CachingDB) TrieDB() *triedb.Database { - return db.triedb -} - -// PointCache returns the cache of evaluated curve points. -func (db *CachingDB) PointCache() *utils.PointCache { - return db.pointCache -} - -// Snapshot returns the underlying state snapshot. -func (db *CachingDB) Snapshot() *snapshot.Tree { - return db.snap +func NewDatabaseForTesting() Database { + db := rawdb.NewMemoryDatabase() + return NewDatabase(triedb.NewDatabase(db, nil), NewCodeDB(db)) } // mustCopyTrie returns a deep-copied trie. @@ -304,10 +180,10 @@ func mustCopyTrie(t Trie) Trie { switch t := t.(type) { case *trie.StateTrie: return t.Copy() - case *trie.VerkleTrie: - return t.Copy() case *transitiontrie.TransitionTrie: return t.Copy() + case *bintrie.BinaryTrie: + return t.Copy() default: panic(fmt.Errorf("unknown trie type %T", t)) } diff --git a/core/state/database_code.go b/core/state/database_code.go new file mode 100644 index 000000000000..820c9c1168ba --- /dev/null +++ b/core/state/database_code.go @@ -0,0 +1,231 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "sync/atomic" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/lru" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/ethdb" +) + +const ( + // Number of codeHash->size associations to keep. + codeSizeCacheSize = 1_000_000 + + // Cache size granted for caching clean code. + codeCacheSize = 256 * 1024 * 1024 +) + +// CodeCache maintains cached contract code that is shared across blocks, enabling +// fast access for external calls such as RPCs and state transitions. +// +// It is thread-safe and has a bounded size. +type codeCache struct { + codeCache *lru.SizeConstrainedCache[common.Hash, []byte] + codeSizeCache *lru.Cache[common.Hash, int] +} + +// newCodeCache initializes the contract code cache with the predefined capacity. +func newCodeCache() *codeCache { + return &codeCache{ + codeCache: lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize), + codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize), + } +} + +// Get returns the contract code associated with the provided code hash. +func (c *codeCache) Get(hash common.Hash) ([]byte, bool) { + return c.codeCache.Get(hash) +} + +// GetSize returns the contract code size associated with the provided code hash. +func (c *codeCache) GetSize(hash common.Hash) (int, bool) { + return c.codeSizeCache.Get(hash) +} + +// Put adds the provided contract code along with its size information into the cache. +func (c *codeCache) Put(hash common.Hash, code []byte) { + c.codeCache.Add(hash, code) + c.codeSizeCache.Add(hash, len(code)) +} + +// CodeReader implements state.ContractCodeReader, accessing contract code either in +// local key-value store or the shared code cache. +// +// Reader is safe for concurrent access. +type CodeReader struct { + db ethdb.KeyValueReader + cache *codeCache + + // Cache statistics + hit atomic.Int64 // Number of code lookups found in the cache + miss atomic.Int64 // Number of code lookups not found in the cache + hitBytes atomic.Int64 // Total number of bytes read from cache + missBytes atomic.Int64 // Total number of bytes read from database +} + +// newCodeReader constructs the code reader with provided key value store and the cache. +func newCodeReader(db ethdb.KeyValueReader, cache *codeCache) *CodeReader { + return &CodeReader{ + db: db, + cache: cache, + } +} + +// Has returns the flag indicating whether the contract code with +// specified address and hash exists or not. +func (r *CodeReader) Has(addr common.Address, codeHash common.Hash) bool { + return len(r.Code(addr, codeHash)) > 0 +} + +// Code implements state.ContractCodeReader, retrieving a particular contract's code. +// Null is returned if the contract code is not present. +func (r *CodeReader) Code(addr common.Address, codeHash common.Hash) []byte { + code, _ := r.cache.Get(codeHash) + if len(code) > 0 { + r.hit.Add(1) + r.hitBytes.Add(int64(len(code))) + return code + } + r.miss.Add(1) + + code = rawdb.ReadCode(r.db, codeHash) + if len(code) > 0 { + r.cache.Put(codeHash, code) + r.missBytes.Add(int64(len(code))) + } + return code +} + +// CodeSize implements state.ContractCodeReader, retrieving a particular contract +// code's size. Zero is returned if the contract code is not present. +func (r *CodeReader) CodeSize(addr common.Address, codeHash common.Hash) int { + if cached, ok := r.cache.GetSize(codeHash); ok { + r.hit.Add(1) + return cached + } + return len(r.Code(addr, codeHash)) +} + +// CodeWithPrefix retrieves the contract code for the specified account address +// and code hash. It is almost identical to Code, but uses rawdb.ReadCodeWithPrefix +// for database lookups. The intention is to gradually deprecate the old +// contract code scheme. +func (r *CodeReader) CodeWithPrefix(addr common.Address, codeHash common.Hash) []byte { + code, _ := r.cache.Get(codeHash) + if len(code) > 0 { + r.hit.Add(1) + r.hitBytes.Add(int64(len(code))) + return code + } + r.miss.Add(1) + + code = rawdb.ReadCodeWithPrefix(r.db, codeHash) + if len(code) > 0 { + r.cache.Put(codeHash, code) + r.missBytes.Add(int64(len(code))) + } + return code +} + +// GetCodeStats implements ContractCodeReaderStater, returning the statistics +// of the code reader. +func (r *CodeReader) GetCodeStats() ContractCodeReaderStats { + return ContractCodeReaderStats{ + CacheHit: r.hit.Load(), + CacheMiss: r.miss.Load(), + CacheHitBytes: r.hitBytes.Load(), + CacheMissBytes: r.missBytes.Load(), + } +} + +type CodeBatch struct { + db *CodeDB + codes [][]byte + codeHashes []common.Hash +} + +// newCodeBatch constructs the batch for writing contract code. +func newCodeBatch(db *CodeDB) *CodeBatch { + return &CodeBatch{ + db: db, + } +} + +// newCodeBatchWithSize constructs the batch with a pre-allocated capacity. +func newCodeBatchWithSize(db *CodeDB, size int) *CodeBatch { + return &CodeBatch{ + db: db, + codes: make([][]byte, 0, size), + codeHashes: make([]common.Hash, 0, size), + } +} + +// Put inserts the given contract code into the writer, waiting for commit. +func (b *CodeBatch) Put(codeHash common.Hash, code []byte) { + b.codes = append(b.codes, code) + b.codeHashes = append(b.codeHashes, codeHash) +} + +// Commit flushes the accumulated dirty contract code into the database and +// also place them in the cache. +func (b *CodeBatch) Commit() error { + batch := b.db.db.NewBatch() + for i, code := range b.codes { + rawdb.WriteCode(batch, b.codeHashes[i], code) + b.db.cache.Put(b.codeHashes[i], code) + } + if err := batch.Write(); err != nil { + return err + } + b.codes = b.codes[:0] + b.codeHashes = b.codeHashes[:0] + return nil +} + +// CodeDB is responsible for managing the contract code and provides the access +// to it. It can be used as a global object, sharing it between multiple entities. +type CodeDB struct { + db ethdb.KeyValueStore + cache *codeCache +} + +// NewCodeDB constructs the contract code database with the provided key value store. +func NewCodeDB(db ethdb.KeyValueStore) *CodeDB { + return &CodeDB{ + db: db, + cache: newCodeCache(), + } +} + +// Reader returns the contract code reader. +func (d *CodeDB) Reader() *CodeReader { + return newCodeReader(d.db, d.cache) +} + +// NewBatch returns the batch for flushing contract codes. +func (d *CodeDB) NewBatch() *CodeBatch { + return newCodeBatch(d) +} + +// NewBatchWithSize returns the batch with pre-allocated capacity. +func (d *CodeDB) NewBatchWithSize(size int) *CodeBatch { + return newCodeBatchWithSize(d, size) +} diff --git a/core/state/database_history.go b/core/state/database_history.go index 314c56c4708a..fbf4ab5f9c70 100644 --- a/core/state/database_history.go +++ b/core/state/database_history.go @@ -18,40 +18,36 @@ package state import ( "errors" + "fmt" + "sync" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/lru" - "github.com/ethereum/go-ethereum/core/state/snapshot" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-ethereum/trie/utils" + "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/triedb" + "github.com/ethereum/go-ethereum/triedb/database" "github.com/ethereum/go-ethereum/triedb/pathdb" ) -// historicReader wraps a historical state reader defined in path database, -// providing historic state serving over the path scheme. -// -// TODO(rjl493456442): historicReader is not thread-safe and does not fully -// comply with the StateReader interface requirements, needs to be fixed. -// Currently, it is only used in a non-concurrent context, so it is safe for now. -type historicReader struct { +// historicStateReader implements StateReader, wrapping a historical state reader +// defined in path database and provide historic state serving over the path scheme. +type historicStateReader struct { reader *pathdb.HistoricalStateReader + lock sync.Mutex // Lock for protecting concurrent read } -// newHistoricReader constructs a reader for historic state serving. -func newHistoricReader(r *pathdb.HistoricalStateReader) *historicReader { - return &historicReader{reader: r} +// newHistoricStateReader constructs a reader for historical state serving. +func newHistoricStateReader(r *pathdb.HistoricalStateReader) *historicStateReader { + return &historicStateReader{reader: r} } // Account implements StateReader, retrieving the account specified by the address. -// -// An error will be returned if the associated snapshot is already stale or -// the requested account is not yet covered by the snapshot. -// -// The returned account might be nil if it's not existent. -func (r *historicReader) Account(addr common.Address) (*types.StateAccount, error) { +func (r *historicStateReader) Account(addr common.Address) (*types.StateAccount, error) { + r.lock.Lock() + defer r.lock.Unlock() + account, err := r.reader.Account(addr) if err != nil { return nil, err @@ -81,7 +77,10 @@ func (r *historicReader) Account(addr common.Address) (*types.StateAccount, erro // the requested storage slot is not yet covered by the snapshot. // // The returned storage slot might be empty if it's not existent. -func (r *historicReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { +func (r *historicStateReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { + r.lock.Lock() + defer r.lock.Unlock() + blob, err := r.reader.Storage(addr, key) if err != nil { return common.Hash{}, err @@ -98,50 +97,196 @@ func (r *historicReader) Storage(addr common.Address, key common.Hash) (common.H return slot, nil } +// historicTrieOpener is a wrapper of pathdb.HistoricalNodeReader, implementing +// the database.NodeDatabase by adding NodeReader function. +type historicTrieOpener struct { + root common.Hash + reader *pathdb.HistoricalNodeReader +} + +// newHistoricTrieOpener constructs the historical trie opener. +func newHistoricTrieOpener(root common.Hash, reader *pathdb.HistoricalNodeReader) *historicTrieOpener { + return &historicTrieOpener{ + root: root, + reader: reader, + } +} + +// NodeReader implements database.NodeDatabase, returning a node reader of a +// specified state. +func (o *historicTrieOpener) NodeReader(root common.Hash) (database.NodeReader, error) { + if root != o.root { + return nil, fmt.Errorf("state %x is not available", root) + } + return o.reader, nil +} + +// historicalTrieReader wraps a historical node reader defined in path database, +// providing historical node serving over the path scheme. +type historicalTrieReader struct { + root common.Hash + opener *historicTrieOpener + tr Trie + + subRoots map[common.Address]common.Hash // Set of storage roots, cached when the account is resolved + subTries map[common.Address]Trie // Group of storage tries, cached when it's resolved + lock sync.Mutex // Lock for protecting concurrent read +} + +// newHistoricalTrieReader constructs a reader for historical trie node serving. +func newHistoricalTrieReader(root common.Hash, r *pathdb.HistoricalNodeReader) (*historicalTrieReader, error) { + opener := newHistoricTrieOpener(root, r) + tr, err := trie.NewStateTrie(trie.StateTrieID(root), opener) + if err != nil { + return nil, err + } + return &historicalTrieReader{ + root: root, + opener: opener, + tr: tr, + subRoots: make(map[common.Address]common.Hash), + subTries: make(map[common.Address]Trie), + }, nil +} + +// account is the inner version of Account and assumes the r.lock is already held. +func (r *historicalTrieReader) account(addr common.Address) (*types.StateAccount, error) { + account, err := r.tr.GetAccount(addr) + if err != nil { + return nil, err + } + if account == nil { + r.subRoots[addr] = types.EmptyRootHash + } else { + r.subRoots[addr] = account.Root + } + return account, nil +} + +// Account implements StateReader, retrieving the account specified by the address. +// +// An error will be returned if the associated snapshot is already stale or +// the requested account is not yet covered by the snapshot. +// +// The returned account might be nil if it's not existent. +func (r *historicalTrieReader) Account(addr common.Address) (*types.StateAccount, error) { + r.lock.Lock() + defer r.lock.Unlock() + + return r.account(addr) +} + +// Storage implements StateReader, retrieving the storage slot specified by the +// address and slot key. +// +// An error will be returned if the associated snapshot is already stale or +// the requested storage slot is not yet covered by the snapshot. +// +// The returned storage slot might be empty if it's not existent. +func (r *historicalTrieReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { + r.lock.Lock() + defer r.lock.Unlock() + + tr, found := r.subTries[addr] + if !found { + root, ok := r.subRoots[addr] + + // The storage slot is accessed without account caching. It's unexpected + // behavior but try to resolve the account first anyway. + if !ok { + _, err := r.account(addr) + if err != nil { + return common.Hash{}, err + } + root = r.subRoots[addr] + } + var err error + tr, err = trie.NewStateTrie(trie.StorageTrieID(r.root, crypto.Keccak256Hash(addr.Bytes()), root), r.opener) + if err != nil { + return common.Hash{}, err + } + r.subTries[addr] = tr + } + ret, err := tr.GetStorage(addr, key.Bytes()) + if err != nil { + return common.Hash{}, err + } + var value common.Hash + value.SetBytes(ret) + return value, nil +} + // HistoricDB is the implementation of Database interface, with the ability to // access historical state. type HistoricDB struct { - disk ethdb.KeyValueStore - triedb *triedb.Database - codeCache *lru.SizeConstrainedCache[common.Hash, []byte] - codeSizeCache *lru.Cache[common.Hash, int] - pointCache *utils.PointCache + triedb *triedb.Database + codedb *CodeDB +} + +// Type returns the trie type of the underlying database. +func (db *HistoricDB) Type() DatabaseType { + // TODO(rjl493456442) support UBT in the future + return TypeMPT } // NewHistoricDatabase creates a historic state database. -func NewHistoricDatabase(disk ethdb.KeyValueStore, triedb *triedb.Database) *HistoricDB { +func NewHistoricDatabase(triedb *triedb.Database, codedb *CodeDB) *HistoricDB { return &HistoricDB{ - disk: disk, - triedb: triedb, - codeCache: lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize), - codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize), - pointCache: utils.NewPointCache(pointCacheSize), + triedb: triedb, + codedb: codedb, } } // Reader implements Database interface, returning a reader of the specific state. func (db *HistoricDB) Reader(stateRoot common.Hash) (Reader, error) { - hr, err := db.triedb.HistoricReader(stateRoot) + var readers []StateReader + sr, err := db.triedb.HistoricStateReader(stateRoot) + if err == nil { + readers = append(readers, newHistoricStateReader(sr)) + } + nr, err := db.triedb.HistoricNodeReader(stateRoot) + if err == nil { + tr, err := newHistoricalTrieReader(stateRoot, nr) + if err == nil { + readers = append(readers, tr) + } + } + if len(readers) == 0 { + return nil, fmt.Errorf("historical state %x is not available", stateRoot) + } + combined, err := newMultiStateReader(readers...) if err != nil { return nil, err } - return newReader(newCachingCodeReader(db.disk, db.codeCache, db.codeSizeCache), newHistoricReader(hr)), nil + return newReader(db.codedb.Reader(), combined), nil } // OpenTrie opens the main account trie. It's not supported by historic database. func (db *HistoricDB) OpenTrie(root common.Hash) (Trie, error) { - return nil, errors.New("not implemented") + nr, err := db.triedb.HistoricNodeReader(root) + if err != nil { + return nil, err + } + tr, err := trie.NewStateTrie(trie.StateTrieID(root), newHistoricTrieOpener(root, nr)) + if err != nil { + return nil, err + } + return tr, nil } // OpenStorageTrie opens the storage trie of an account. It's not supported by // historic database. -func (db *HistoricDB) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, trie Trie) (Trie, error) { - return nil, errors.New("not implemented") -} - -// PointCache returns the cache holding points used in verkle tree key computation -func (db *HistoricDB) PointCache() *utils.PointCache { - return db.pointCache +func (db *HistoricDB) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, _ Trie) (Trie, error) { + nr, err := db.triedb.HistoricNodeReader(stateRoot) + if err != nil { + return nil, err + } + id := trie.StorageTrieID(stateRoot, crypto.Keccak256Hash(address.Bytes()), root) + tr, err := trie.NewStateTrie(id, newHistoricTrieOpener(stateRoot, nr)) + if err != nil { + return nil, err + } + return tr, nil } // TrieDB returns the underlying trie database for managing trie nodes. @@ -149,7 +294,15 @@ func (db *HistoricDB) TrieDB() *triedb.Database { return db.triedb } -// Snapshot returns the underlying state snapshot. -func (db *HistoricDB) Snapshot() *snapshot.Tree { - return nil +// Commit flushes all pending writes and finalizes the state transition, +// committing the changes to the underlying storage. It returns an error +// if the commit fails. +func (db *HistoricDB) Commit(update *StateUpdate) error { + return errors.New("not implemented") +} + +// Iteratee returns a state iteratee associated with the specified state root, +// through which the account iterator and storage iterator can be created. +func (db *HistoricDB) Iteratee(root common.Hash) (Iteratee, error) { + return nil, errors.New("not implemented") } diff --git a/core/state/database_iterator.go b/core/state/database_iterator.go new file mode 100644 index 000000000000..1ff164b002da --- /dev/null +++ b/core/state/database_iterator.go @@ -0,0 +1,463 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "errors" + "fmt" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state/snapshot" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" + "github.com/ethereum/go-ethereum/triedb" +) + +// Iterator is an iterator to step over all the accounts or the specific +// storage in the specific state. +type Iterator interface { + // Next steps the iterator forward one element. It returns false if the iterator + // is exhausted or if an error occurs. Any error encountered is retained and + // can be retrieved via Error(). + Next() bool + + // Error returns any failure that occurred during iteration, which might have + // caused a premature iteration exit. + Error() error + + // Hash returns the hash of the account or storage slot the iterator is + // currently at. + Hash() common.Hash + + // Release releases associated resources. Release should always succeed and + // can be called multiple times without causing error. + Release() +} + +// AccountIterator is an iterator to step over all the accounts in the +// specific state. +type AccountIterator interface { + Iterator + + // Address returns the raw account address the iterator is currently at. + // An error will be returned if the preimage is not available. + Address() (common.Address, error) + + // Account returns the account the iterator is currently at. + // An error will be retained if the iterator becomes invalid. + Account() *types.StateAccount +} + +// StorageIterator is an iterator to step over the specific storage in the +// specific state. +type StorageIterator interface { + Iterator + + // Key returns the raw storage slot key the iterator is currently at. + // An error will be returned if the preimage is not available. + Key() (common.Hash, error) + + // Slot returns the storage slot the iterator is currently at. An error will + // be retained if the iterator becomes invalid. + Slot() common.Hash +} + +// Iteratee wraps the NewIterator methods for traversing the accounts and +// storages of the specific state. +type Iteratee interface { + // NewAccountIterator creates an account iterator for the state specified by + // the given root. It begins at a specified starting position, corresponding + // to a particular initial key (or the next key if the specified one does + // not exist). + // + // The starting position here refers to the hash of the account address. + NewAccountIterator(start common.Hash) (AccountIterator, error) + + // NewStorageIterator creates a storage iterator for the state specified by + // the address hash. It begins at a specified starting position, corresponding + // to a particular initial key (or the next key if the specified one does + // not exist). + // + // The starting position here refers to the hash of the slot key. + NewStorageIterator(addressHash common.Hash, start common.Hash) (StorageIterator, error) +} + +// PreimageReader wraps the function Preimage for accessing the preimage of +// a given hash. +type PreimageReader interface { + // Preimage returns the preimage of associated hash. + Preimage(hash common.Hash) []byte +} + +// flatAccountIterator is a wrapper around the underlying flat state iterator. +// Before returning data from the iterator, it performs an additional conversion +// to bridge the slim encoding with the full encoding format. +type flatAccountIterator struct { + err error + it snapshot.AccountIterator + preimage PreimageReader +} + +// newFlatAccountIterator constructs the account iterator with the provided +// flat state iterator. +func newFlatAccountIterator(it snapshot.AccountIterator, preimage PreimageReader) *flatAccountIterator { + return &flatAccountIterator{it: it, preimage: preimage} +} + +// Next steps the iterator forward one element. It returns false if the iterator +// is exhausted or if an error occurs. Any error encountered is retained and +// can be retrieved via Error(). +func (ai *flatAccountIterator) Next() bool { + if ai.err != nil { + return false + } + return ai.it.Next() +} + +// Error returns any failure that occurred during iteration, which might have +// caused a premature iteration exit. +func (ai *flatAccountIterator) Error() error { + return errors.Join(ai.err, ai.it.Error()) +} + +// Hash returns the hash of the account or storage slot the iterator is +// currently at. +func (ai *flatAccountIterator) Hash() common.Hash { + return ai.it.Hash() +} + +// Release releases associated resources. Release should always succeed and +// can be called multiple times without causing error. +func (ai *flatAccountIterator) Release() { + ai.it.Release() +} + +// Address returns the raw account address the iterator is currently at. +// An error will be returned if the preimage is not available. +func (ai *flatAccountIterator) Address() (common.Address, error) { + if ai.preimage == nil { + return common.Address{}, errors.New("account address is not available") + } + preimage := ai.preimage.Preimage(ai.Hash()) + if preimage == nil { + return common.Address{}, errors.New("account address is not available") + } + return common.BytesToAddress(preimage), nil +} + +// Account returns the account data the iterator is currently at. The account +// data is encoded as slim format from the underlying iterator, the conversion +// is required. +func (ai *flatAccountIterator) Account() *types.StateAccount { + data, err := types.FullAccount(ai.it.Account()) + if err != nil { + ai.err = err + return nil + } + return data +} + +// flatStorageIterator is a wrapper around the underlying flat state iterator. +type flatStorageIterator struct { + err error + it snapshot.StorageIterator + preimage PreimageReader +} + +// newFlatStorageIterator constructs the storage iterator with the provided +// flat state iterator. +func newFlatStorageIterator(it snapshot.StorageIterator, preimage PreimageReader) *flatStorageIterator { + return &flatStorageIterator{it: it, preimage: preimage} +} + +// Next steps the iterator forward one element. It returns false if the iterator +// is exhausted or if an error occurs. Any error encountered is retained and +// can be retrieved via Error(). +func (si *flatStorageIterator) Next() bool { + if si.err != nil { + return false + } + return si.it.Next() +} + +// Error returns any failure that occurred during iteration, which might have +// caused a premature iteration exit. +func (si *flatStorageIterator) Error() error { + return errors.Join(si.err, si.it.Error()) +} + +// Hash returns the hash of the account or storage slot the iterator is +// currently at. +func (si *flatStorageIterator) Hash() common.Hash { + return si.it.Hash() +} + +// Release releases associated resources. Release should always succeed and +// can be called multiple times without causing error. +func (si *flatStorageIterator) Release() { + si.it.Release() +} + +// Key returns the raw storage slot key the iterator is currently at. +// An error will be returned if the preimage is not available. +func (si *flatStorageIterator) Key() (common.Hash, error) { + if si.preimage == nil { + return common.Hash{}, errors.New("slot key is not available") + } + preimage := si.preimage.Preimage(si.Hash()) + if preimage == nil { + return common.Hash{}, errors.New("slot key is not available") + } + return common.BytesToHash(preimage), nil +} + +// Slot returns the storage slot data the iterator is currently at. +func (si *flatStorageIterator) Slot() common.Hash { + // Perform the rlp-decode as the slot value is RLP-encoded + blob := si.it.Slot() + _, content, _, err := rlp.Split(blob) + if err != nil { + si.err = err + return common.Hash{} + } + var value common.Hash + value.SetBytes(content) + return value +} + +// merkleIterator implements the Iterator interface, providing functions to traverse +// the accounts or storages with the manner of Merkle-Patricia-Trie. +type merkleIterator struct { + tr Trie + err error + it *trie.Iterator + account bool +} + +// newMerkleTrieIterator constructs the iterator with the given trie and starting position. +func newMerkleTrieIterator(tr Trie, start common.Hash, account bool) (*merkleIterator, error) { + it, err := tr.NodeIterator(start.Bytes()) + if err != nil { + return nil, err + } + return &merkleIterator{ + tr: tr, + it: trie.NewIterator(it), + account: account, + }, nil +} + +// Next steps the iterator forward one element. It returns false if the iterator +// is exhausted or if an error occurs. Any error encountered is retained and +// can be retrieved via Error(). +func (ti *merkleIterator) Next() bool { + if ti.err != nil { + return false + } + return ti.it.Next() +} + +// Error returns any failure that occurred during iteration, which might have +// caused a premature iteration exit. +func (ti *merkleIterator) Error() error { + return errors.Join(ti.err, ti.it.Err) +} + +// Hash returns the hash of the account or storage slot the iterator is +// currently at. +func (ti *merkleIterator) Hash() common.Hash { + return common.BytesToHash(ti.it.Key) +} + +// Release releases associated resources. Release should always succeed and +// can be called multiple times without causing error. +func (ti *merkleIterator) Release() {} + +// Address returns the raw account address the iterator is currently at. +// An error will be returned if the preimage is not available. +func (ti *merkleIterator) Address() (common.Address, error) { + if !ti.account { + return common.Address{}, errors.New("account address is not available") + } + preimage := ti.tr.GetKey(ti.it.Key) + if preimage == nil { + return common.Address{}, errors.New("account address is not available") + } + return common.BytesToAddress(preimage), nil +} + +// Account returns the account data the iterator is currently at. +func (ti *merkleIterator) Account() *types.StateAccount { + if !ti.account { + return nil + } + var account types.StateAccount + if err := rlp.DecodeBytes(ti.it.Value, &account); err != nil { + ti.err = err + return nil + } + return &account +} + +// Key returns the raw storage slot key the iterator is currently at. +// An error will be returned if the preimage is not available. +func (ti *merkleIterator) Key() (common.Hash, error) { + if ti.account { + return common.Hash{}, errors.New("slot key is not available") + } + preimage := ti.tr.GetKey(ti.it.Key) + if preimage == nil { + return common.Hash{}, errors.New("slot key is not available") + } + return common.BytesToHash(preimage), nil +} + +// Slot returns the storage slot the iterator is currently at. +func (ti *merkleIterator) Slot() common.Hash { + if ti.account { + return common.Hash{} + } + // Perform the rlp-decode as the slot value is RLP-encoded + _, content, _, err := rlp.Split(ti.it.Value) + if err != nil { + ti.err = err + return common.Hash{} + } + var value common.Hash + value.SetBytes(content) + return value +} + +// stateIteratee implements Iteratee interface, providing the state traversal +// functionalities of a specific state. +type stateIteratee struct { + merkle bool + root common.Hash + triedb *triedb.Database + snap *snapshot.Tree +} + +func newStateIteratee(merkle bool, root common.Hash, triedb *triedb.Database, snap *snapshot.Tree) (*stateIteratee, error) { + return &stateIteratee{ + merkle: merkle, + root: root, + triedb: triedb, + snap: snap, + }, nil +} + +// NewAccountIterator creates an account iterator for the state specified by +// the given root. It begins at a specified starting position, corresponding +// to a particular initial key (or the next key if the specified one does +// not exist). +// +// The starting position here refers to the hash of the account address. +func (si *stateIteratee) NewAccountIterator(start common.Hash) (AccountIterator, error) { + // If the external snapshot is available (hash scheme), try to initialize + // the account iterator from there first. + if si.snap != nil { + it, err := si.snap.AccountIterator(si.root, start) + if err == nil { + return newFlatAccountIterator(it, si.triedb), nil + } + } + // If the external snapshot is not available, try to initialize the + // account iterator from the trie database (path scheme) + it, err := si.triedb.AccountIterator(si.root, start) + if err == nil { + return newFlatAccountIterator(it, si.triedb), nil + } + if !si.merkle { + return nil, fmt.Errorf("state %x is not available for account traversal", si.root) + } + // The snapshot is not usable so far, construct the account iterator from + // the trie as the fallback. It's not as efficient as the flat state iterator. + tr, err := trie.NewStateTrie(trie.StateTrieID(si.root), si.triedb) + if err != nil { + return nil, err + } + return newMerkleTrieIterator(tr, start, true) +} + +// NewStorageIterator creates a storage iterator for the state specified by +// the address hash. It begins at a specified starting position, corresponding +// to a particular initial key (or the next key if the specified one does not exist). +// +// The starting position here refers to the hash of the slot key. +func (si *stateIteratee) NewStorageIterator(addressHash common.Hash, start common.Hash) (StorageIterator, error) { + // If the external snapshot is available (hash scheme), try to initialize + // the storage iterator from there first. + if si.snap != nil { + it, err := si.snap.StorageIterator(si.root, addressHash, start) + if err == nil { + return newFlatStorageIterator(it, si.triedb), nil + } + } + // If the external snapshot is not available, try to initialize the + // storage iterator from the trie database (path scheme) + it, err := si.triedb.StorageIterator(si.root, addressHash, start) + if err == nil { + return newFlatStorageIterator(it, si.triedb), nil + } + if !si.merkle { + return nil, fmt.Errorf("state %x is not available for storage traversal", si.root) + } + // The snapshot is not usable so far, construct the storage iterator from + // the trie as the fallback. It's not as efficient as the flat state iterator. + tr, err := trie.NewStateTrie(trie.StateTrieID(si.root), si.triedb) + if err != nil { + return nil, err + } + acct, err := tr.GetAccountByHash(addressHash) + if err != nil { + return nil, err + } + if acct == nil || acct.Root == types.EmptyRootHash { + return &exhaustedIterator{}, nil + } + storageTr, err := trie.NewStateTrie(trie.StorageTrieID(si.root, addressHash, acct.Root), si.triedb) + if err != nil { + return nil, err + } + return newMerkleTrieIterator(storageTr, start, false) +} + +type exhaustedIterator struct{} + +func (e exhaustedIterator) Next() bool { + return false +} + +func (e exhaustedIterator) Error() error { + return nil +} + +func (e exhaustedIterator) Hash() common.Hash { + return common.Hash{} +} + +func (e exhaustedIterator) Release() { +} + +func (e exhaustedIterator) Key() (common.Hash, error) { + return common.Hash{}, nil +} + +func (e exhaustedIterator) Slot() common.Hash { + return common.Hash{} +} diff --git a/core/state/database_iterator_test.go b/core/state/database_iterator_test.go new file mode 100644 index 000000000000..8313f864038c --- /dev/null +++ b/core/state/database_iterator_test.go @@ -0,0 +1,257 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "bytes" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/trie" +) + +// TestExhaustedIterator verifies the exhaustedIterator sentinel: Next is false, +// Error is nil, Hash/Key are zero, Slot is nil, and double Release is safe. +func TestExhaustedIterator(t *testing.T) { + var it exhaustedIterator + + if it.Next() { + t.Fatal("Next() returned true") + } + if err := it.Error(); err != nil { + t.Fatalf("Error() = %v, want nil", err) + } + if hash := it.Hash(); hash != (common.Hash{}) { + t.Fatalf("Hash() = %x, want zero", hash) + } + if key, err := it.Key(); key != (common.Hash{}) || err != nil { + t.Fatalf("Key() = %x, %v; want zero, nil", key, err) + } + if slot := it.Slot(); slot != (common.Hash{}) { + t.Fatalf("Slot() = %x, want nil", slot) + } + it.Release() + it.Release() +} + +// TestAccountIterator tests the account iterator: correct count, ascending +// hash order, valid full-format RLP, data integrity, address preimage +// resolution, and seek behavior. +func TestAccountIterator(t *testing.T) { + testAccountIterator(t, rawdb.HashScheme) + testAccountIterator(t, rawdb.PathScheme) +} + +func testAccountIterator(t *testing.T, scheme string) { + _, sdb, ndb, root, accounts := makeTestState(scheme) + ndb.Commit(root, false) + + iteratee, err := sdb.Iteratee(root) + if err != nil { + t.Fatalf("(%s) failed to create iteratee: %v", scheme, err) + } + // Build lookups from address hash. + addrByHash := make(map[common.Hash]*testAccount) + for _, acc := range accounts { + addrByHash[crypto.Keccak256Hash(acc.address.Bytes())] = acc + } + + // --- Full iteration: count, ordering, RLP validity, data integrity, address resolution --- + acctIt, err := iteratee.NewAccountIterator(common.Hash{}) + if err != nil { + t.Fatalf("(%s) failed to create account iterator: %v", scheme, err) + } + var ( + hashes []common.Hash + prevHash common.Hash + ) + for acctIt.Next() { + hash := acctIt.Hash() + if hash == (common.Hash{}) { + t.Fatalf("(%s) zero hash at position %d", scheme, len(hashes)) + } + if len(hashes) > 0 && bytes.Compare(prevHash.Bytes(), hash.Bytes()) >= 0 { + t.Fatalf("(%s) hashes not ascending: %x >= %x", scheme, prevHash, hash) + } + prevHash = hash + hashes = append(hashes, hash) + + // Decode and verify account data. + got := acctIt.Account() + if got == nil { + t.Fatalf("(%s) nil account at %x", scheme, hash) + } + acc := addrByHash[hash] + if got.Nonce != acc.nonce { + t.Fatalf("(%s) nonce %x: got %d, want %d", scheme, hash, got.Nonce, acc.nonce) + } + if got.Balance.Cmp(acc.balance) != 0 { + t.Fatalf("(%s) balance %x: got %v, want %v", scheme, hash, got.Balance, acc.balance) + } + // Verify address preimage resolution. + addr, err := acctIt.Address() + if err != nil { + t.Fatalf("(%s) failed to address: %v", scheme, err) + } + if addr != acc.address { + t.Fatalf("(%s) Address() = %x, want %x", scheme, addr, acc.address) + } + } + acctIt.Release() + + if err := acctIt.Error(); err != nil { + t.Fatalf("(%s) iteration error: %v", scheme, err) + } + if len(hashes) != len(accounts) { + t.Fatalf("(%s) iterated %d accounts, want %d", scheme, len(hashes), len(accounts)) + } + + // --- Seek: starting from midpoint should skip earlier entries --- + mid := hashes[len(hashes)/2] + seekIt, err := iteratee.NewAccountIterator(mid) + if err != nil { + t.Fatalf("(%s) failed to create seeked iterator: %v", scheme, err) + } + seekCount := 0 + for seekIt.Next() { + if bytes.Compare(seekIt.Hash().Bytes(), mid.Bytes()) < 0 { + t.Fatalf("(%s) seeked iterator returned hash before start", scheme) + } + seekCount++ + } + seekIt.Release() + + if seekCount != len(hashes)/2 { + t.Fatalf("(%s) unexpected seeked count, %d != %d", scheme, seekCount, len(hashes)/2) + } +} + +// TestStorageIterator tests the storage iterator: correct slot counts against +// the trie, ascending hash order, non-nil slot data, key preimage resolution, +// seek behavior, and empty-storage accounts. +func TestStorageIterator(t *testing.T) { + testStorageIterator(t, rawdb.HashScheme) + testStorageIterator(t, rawdb.PathScheme) +} + +func testStorageIterator(t *testing.T, scheme string) { + _, sdb, ndb, root, accounts := makeTestState(scheme) + ndb.Commit(root, false) + + iteratee, err := sdb.Iteratee(root) + if err != nil { + t.Fatalf("(%s) failed to create iteratee: %v", scheme, err) + } + + // --- Slot count and ordering for every account --- + var withStorage common.Hash // remember an account that has storage for seek test + for _, acc := range accounts { + addrHash := crypto.Keccak256Hash(acc.address.Bytes()) + expected := countStorageSlots(t, scheme, sdb, root, addrHash) + + storageIt, err := iteratee.NewStorageIterator(addrHash, common.Hash{}) + if err != nil { + t.Fatalf("(%s) failed to create storage iterator for %x: %v", scheme, acc.address, err) + } + count := 0 + var prevHash common.Hash + for storageIt.Next() { + hash := storageIt.Hash() + if count > 0 && bytes.Compare(prevHash.Bytes(), hash.Bytes()) >= 0 { + t.Fatalf("(%s) storage hashes not ascending for %x", scheme, acc.address) + } + prevHash = hash + if storageIt.Slot() == (common.Hash{}) { + t.Fatalf("(%s) nil slot at %x", scheme, hash) + } + // Check key preimage resolution on first slot. + if _, err := storageIt.Key(); err != nil { + t.Fatalf("(%s) Key() failed to resolve", scheme) + } + count++ + } + if err := storageIt.Error(); err != nil { + t.Fatalf("(%s) storage iteration error for %x: %v", scheme, acc.address, err) + } + storageIt.Release() + + if count != expected { + t.Fatalf("(%s) account %x: %d slots, want %d", scheme, acc.address, count, expected) + } + if count > 0 { + withStorage = addrHash + } + } + + // --- Seek: starting from second slot should skip the first --- + if withStorage == (common.Hash{}) { + t.Fatalf("(%s) no account with storage found", scheme) + } + fullIt, err := iteratee.NewStorageIterator(withStorage, common.Hash{}) + if err != nil { + t.Fatalf("(%s) failed to create full storage iterator: %v", scheme, err) + } + var slotHashes []common.Hash + for fullIt.Next() { + slotHashes = append(slotHashes, fullIt.Hash()) + } + fullIt.Release() + + seekIt, err := iteratee.NewStorageIterator(withStorage, slotHashes[1]) + if err != nil { + t.Fatalf("(%s) failed to create seeked storage iterator: %v", scheme, err) + } + seekCount := 0 + for seekIt.Next() { + if bytes.Compare(seekIt.Hash().Bytes(), slotHashes[1].Bytes()) < 0 { + t.Fatalf("(%s) seeked storage iterator returned hash before start", scheme) + } + seekCount++ + } + seekIt.Release() + + if seekCount != len(slotHashes)-1 { + t.Fatalf("(%s) unexpected seeked storage count %d != %d", scheme, seekCount, len(slotHashes)-1) + } +} + +// countStorageSlots counts storage slots for an account by opening the +// storage trie directly. +func countStorageSlots(t *testing.T, scheme string, sdb Database, root common.Hash, addrHash common.Hash) int { + t.Helper() + accTrie, err := trie.NewStateTrie(trie.StateTrieID(root), sdb.TrieDB()) + if err != nil { + t.Fatalf("(%s) failed to open account trie: %v", scheme, err) + } + acct, err := accTrie.GetAccountByHash(addrHash) + if err != nil || acct == nil || acct.Root == types.EmptyRootHash { + return 0 + } + storageTrie, err := trie.NewStateTrie(trie.StorageTrieID(root, addrHash, acct.Root), sdb.TrieDB()) + if err != nil { + t.Fatalf("(%s) failed to open storage trie for %x: %v", scheme, addrHash, err) + } + it := trie.NewIterator(storageTrie.MustNodeIterator(nil)) + count := 0 + for it.Next() { + count++ + } + return count +} diff --git a/core/state/database_mpt.go b/core/state/database_mpt.go new file mode 100644 index 000000000000..42c5f2e5efe0 --- /dev/null +++ b/core/state/database_mpt.go @@ -0,0 +1,187 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/state/snapshot" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/trie" + "github.com/ethereum/go-ethereum/triedb" +) + +// MPTDatabase is an implementation of Database interface for Merkle Patricia Tries. +// It leverages both trie and state snapshot to provide functionalities for state +// access. +type MPTDatabase struct { + triedb *triedb.Database + codedb *CodeDB + snap *snapshot.Tree +} + +// Type returns Merkle, indicating this database is backed by a Merkle Patricia Trie. +func (db *MPTDatabase) Type() DatabaseType { return TypeMPT } + +// NewMPTDatabase creates a state database with the Merkle Patricia Trie manner. +func NewMPTDatabase(tdb *triedb.Database, codedb *CodeDB) *MPTDatabase { + if codedb == nil { + codedb = NewCodeDB(tdb.Disk()) + } + return &MPTDatabase{ + triedb: tdb, + codedb: codedb, + } +} + +// WithSnapshot configures the provided state snapshot. Note that this +// registration must be performed before the MPTDatabase is used. +func (db *MPTDatabase) WithSnapshot(snapshot *snapshot.Tree) Database { + db.snap = snapshot + return db +} + +// StateReader returns a state reader associated with the specified state root. +func (db *MPTDatabase) StateReader(stateRoot common.Hash) (StateReader, error) { + var readers []StateReader + + // Configure the state reader using the standalone snapshot in hash mode. + // This reader offers improved performance but is optional and only + // partially useful if the snapshot is not fully generated. + if db.TrieDB().Scheme() == rawdb.HashScheme && db.snap != nil { + snap := db.snap.Snapshot(stateRoot) + if snap != nil { + readers = append(readers, newFlatReader(snap)) + } + } + // Configure the state reader using the path database in path mode. + // This reader offers improved performance but is optional and only + // partially useful if the snapshot data in path database is not + // fully generated. + if db.TrieDB().Scheme() == rawdb.PathScheme { + reader, err := db.triedb.StateReader(stateRoot) + if err == nil { + readers = append(readers, newFlatReader(reader)) + } + } + // Configure the trie reader, which is expected to be available as the + // gatekeeper unless the state is corrupted. + tr, err := newMPTTrieReader(stateRoot, db.triedb) + if err != nil { + return nil, err + } + readers = append(readers, tr) + + return newMultiStateReader(readers...) +} + +// Reader implements Database, returning a reader associated with the specified +// state root. +func (db *MPTDatabase) Reader(stateRoot common.Hash) (Reader, error) { + sr, err := db.StateReader(stateRoot) + if err != nil { + return nil, err + } + return newReader(db.codedb.Reader(), sr), nil +} + +// ReadersWithCacheStats creates a pair of state readers that share the same +// underlying state reader and internal state cache, while maintaining separate +// statistics respectively. +func (db *MPTDatabase) ReadersWithCacheStats(stateRoot common.Hash) (Reader, Reader, error) { + r, err := db.StateReader(stateRoot) + if err != nil { + return nil, nil, err + } + sr := newStateReaderWithCache(r) + ra := newReader(db.codedb.Reader(), newStateReaderWithStats(sr)) + rb := newReader(db.codedb.Reader(), newStateReaderWithStats(sr)) + return ra, rb, nil +} + +// OpenTrie opens the main account trie at a specific root hash. +func (db *MPTDatabase) OpenTrie(root common.Hash) (Trie, error) { + tr, err := trie.NewStateTrie(trie.StateTrieID(root), db.triedb) + if err != nil { + return nil, err + } + return tr, nil +} + +// OpenStorageTrie opens the storage trie of an account. +func (db *MPTDatabase) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, self Trie) (Trie, error) { + tr, err := trie.NewStateTrie(trie.StorageTrieID(stateRoot, crypto.Keccak256Hash(address.Bytes()), root), db.triedb) + if err != nil { + return nil, err + } + return tr, nil +} + +// TrieDB retrieves any intermediate trie-node caching layer. +func (db *MPTDatabase) TrieDB() *triedb.Database { + return db.triedb +} + +// Commit flushes all pending writes and finalizes the state transition, +// committing the changes to the underlying storage. It returns an error +// if the commit fails. +func (db *MPTDatabase) Commit(update *StateUpdate) error { + // Short circuit if nothing to commit + if update.Empty() { + return nil + } + // Commit dirty contract code if any exists + if len(update.Codes) > 0 { + batch := db.codedb.NewBatchWithSize(len(update.Codes)) + for _, code := range update.Codes { + batch.Put(code.Hash, code.Blob) + } + if err := batch.Commit(); err != nil { + return err + } + } + // Encode the state mutations in the MPT format + accounts, accountOrigin, storages, storageOrigin := update.EncodeMPTState() + + // If snapshotting is enabled, update the snapshot tree with this new version + if db.snap != nil && db.snap.Snapshot(update.OriginRoot) != nil { + if err := db.snap.Update(update.Root, update.OriginRoot, accounts, storages); err != nil { + log.Warn("Failed to update snapshot tree", "from", update.OriginRoot, "to", update.Root, "err", err) + } + // Keep 128 diff layers in the memory, persistent layer is 129th. + // - head layer is paired with HEAD state + // - head-1 layer is paired with HEAD-1 state + // - head-127 layer(bottom-most diff layer) is paired with HEAD-127 state + if err := db.snap.Cap(update.Root, TriesInMemory); err != nil { + log.Warn("Failed to cap snapshot tree", "root", update.Root, "layers", TriesInMemory, "err", err) + } + } + return db.triedb.Update(update.Root, update.OriginRoot, update.BlockNumber, update.Nodes, &triedb.StateSet{ + Accounts: accounts, + AccountsOrigin: accountOrigin, + Storages: storages, + StoragesOrigin: storageOrigin, + RawStorageKey: update.StorageKeyType == StorageKeyPlain, + }) +} + +// Iteratee returns a state iteratee associated with the specified state root, +// through which the account iterator and storage iterator can be created. +func (db *MPTDatabase) Iteratee(root common.Hash) (Iteratee, error) { + return newStateIteratee(true, root, db.triedb, db.snap) +} diff --git a/core/state/database_ubt.go b/core/state/database_ubt.go new file mode 100644 index 000000000000..16579f6d6a0f --- /dev/null +++ b/core/state/database_ubt.go @@ -0,0 +1,147 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/trie/bintrie" + "github.com/ethereum/go-ethereum/triedb" +) + +// UBTDatabase is an implementation of Database interface for Unified Binary Trie. +// It provides the same functionality as MPTDatabase but uses unified binary +// trie for state hashing instead of Merkle Patricia Tries. +type UBTDatabase struct { + triedb *triedb.Database + codedb *CodeDB +} + +// Type returns Binary, indicating this database is backed by a Universal Binary Trie. +func (db *UBTDatabase) Type() DatabaseType { return TypeUBT } + +// NewUBTDatabase creates a state database with the Unified binary trie manner. +func NewUBTDatabase(triedb *triedb.Database, codedb *CodeDB) *UBTDatabase { + if codedb == nil { + codedb = NewCodeDB(triedb.Disk()) + } + return &UBTDatabase{ + triedb: triedb, + codedb: codedb, + } +} + +// StateReader returns a state reader associated with the specified state root. +func (db *UBTDatabase) StateReader(stateRoot common.Hash) (StateReader, error) { + var readers []StateReader + + // Configure the state reader using the path database in path mode. + // This reader offers improved performance but is optional and only + // partially useful if the snapshot data in path database is not + // fully generated. + if db.TrieDB().Scheme() == rawdb.PathScheme { + reader, err := db.triedb.StateReader(stateRoot) + if err == nil { + readers = append(readers, newFlatReader(reader)) + } + } + // Configure the trie reader, which is expected to be available as the + // gatekeeper unless the state is corrupted. + tr, err := newUBTTrieReader(stateRoot, db.triedb) + if err != nil { + return nil, err + } + readers = append(readers, tr) + + return newMultiStateReader(readers...) +} + +// Reader implements Database, returning a reader associated with the specified +// state root. +func (db *UBTDatabase) Reader(stateRoot common.Hash) (Reader, error) { + sr, err := db.StateReader(stateRoot) + if err != nil { + return nil, err + } + return newReader(db.codedb.Reader(), sr), nil +} + +// ReadersWithCacheStats creates a pair of state readers that share the same +// underlying state reader and internal state cache, while maintaining separate +// statistics respectively. +func (db *UBTDatabase) ReadersWithCacheStats(stateRoot common.Hash) (Reader, Reader, error) { + r, err := db.StateReader(stateRoot) + if err != nil { + return nil, nil, err + } + sr := newStateReaderWithCache(r) + ra := newReader(db.codedb.Reader(), newStateReaderWithStats(sr)) + rb := newReader(db.codedb.Reader(), newStateReaderWithStats(sr)) + return ra, rb, nil +} + +// OpenTrie opens the main account trie at a specific root hash. +func (db *UBTDatabase) OpenTrie(root common.Hash) (Trie, error) { + return bintrie.NewBinaryTrie(root, db.triedb, db.triedb.BinTrieGroupDepth()) +} + +// OpenStorageTrie opens the storage trie of an account. In binary trie mode, +// all state objects share one unified trie, so the main trie is returned. +func (db *UBTDatabase) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash, self Trie) (Trie, error) { + return self, nil +} + +// TrieDB retrieves any intermediate trie-node caching layer. +func (db *UBTDatabase) TrieDB() *triedb.Database { + return db.triedb +} + +// Commit flushes all pending writes and finalizes the state transition, +// committing the changes to the underlying storage. It returns an error +// if the commit fails. +func (db *UBTDatabase) Commit(update *StateUpdate) error { + // Short circuit if nothing to commit + if update.Empty() { + return nil + } + // Commit dirty contract code if any exists + if len(update.Codes) > 0 { + batch := db.codedb.NewBatchWithSize(len(update.Codes)) + for _, code := range update.Codes { + batch.Put(code.Hash, code.Blob) + } + if err := batch.Commit(); err != nil { + return err + } + } + // Encode the state mutations in the UBT format + accounts, accountOrigin, storages, storageOrigin := update.EncodeUBTState() + + return db.triedb.Update(update.Root, update.OriginRoot, update.BlockNumber, update.Nodes, &triedb.StateSet{ + Accounts: accounts, + AccountsOrigin: accountOrigin, + Storages: storages, + StoragesOrigin: storageOrigin, + RawStorageKey: update.StorageKeyType == StorageKeyPlain, + }) +} + +// Iteratee returns a state iteratee associated with the specified state root, +// through which the account iterator and storage iterator can be created. +func (db *UBTDatabase) Iteratee(root common.Hash) (Iteratee, error) { + return newStateIteratee(false, root, db.triedb, nil) +} diff --git a/core/state/dump.go b/core/state/dump.go index 829d106ed3ac..cbf53de05333 100644 --- a/core/state/dump.go +++ b/core/state/dump.go @@ -24,10 +24,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" - "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie/bintrie" ) @@ -45,6 +42,7 @@ type DumpConfig struct { type DumpCollector interface { // OnRoot is called with the state root OnRoot(common.Hash) + // OnAccount is called once for each account in the trie OnAccount(*common.Address, DumpAccount) } @@ -65,9 +63,10 @@ type DumpAccount struct { type Dump struct { Root string `json:"root"` Accounts map[string]DumpAccount `json:"accounts"` + // Next can be set to represent that this dump is only partial, and Next // is where an iterator should be positioned in order to continue the dump. - Next []byte `json:"next,omitempty"` // nil if no more accounts + Next hexutil.Bytes `json:"next,omitempty"` // nil if no more accounts } // OnRoot implements DumpCollector interface @@ -114,10 +113,7 @@ func (d iterativeDump) OnRoot(root common.Hash) { // DumpToCollector iterates the state according to the given options and inserts // the items into a collector for aggregation or serialization. -// -// The state iterator is still trie-based and can be converted to snapshot-based -// once the state snapshot is fully integrated into database. TODO(rjl493456442). -func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []byte) { +func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []byte, err error) { // Sanitize the input to allow nil configs if conf == nil { conf = new(DumpConfig) @@ -131,21 +127,27 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] log.Info("Trie dumping started", "root", s.originalRoot) c.OnRoot(s.originalRoot) - tr, err := s.db.OpenTrie(s.originalRoot) + iteratee, err := s.db.Iteratee(s.originalRoot) if err != nil { - return nil + return nil, err } - trieIt, err := tr.NodeIterator(conf.Start) + var startHash common.Hash + if conf.Start != nil { + startHash = common.BytesToHash(conf.Start) + } + acctIt, err := iteratee.NewAccountIterator(startHash) if err != nil { - log.Error("Trie dumping error", "err", err) - return nil + return nil, err } - it := trie.NewIterator(trieIt) + defer acctIt.Release() - for it.Next() { - var data types.StateAccount - if err := rlp.DecodeBytes(it.Value, &data); err != nil { - panic(err) + for acctIt.Next() { + data := acctIt.Account() + if err := acctIt.Error(); err != nil { + return nil, err + } + if data == nil { + return nil, fmt.Errorf("unexpected nil account value") } var ( account = DumpAccount{ @@ -153,63 +155,54 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] Nonce: data.Nonce, Root: data.Root[:], CodeHash: data.CodeHash, - AddressHash: it.Key, + AddressHash: acctIt.Hash().Bytes(), } - address *common.Address - addr common.Address - addrBytes = tr.GetKey(it.Key) + address *common.Address ) - if addrBytes == nil { + addrBytes, err := acctIt.Address() + if err != nil { missingPreimages++ if conf.OnlyWithAddresses { continue } } else { - addr = common.BytesToAddress(addrBytes) - address = &addr + address = &addrBytes account.Address = address } - obj := newObject(s, addr, &data) + obj := newObject(s, addrBytes, data) if !conf.SkipCode { account.Code = obj.Code() } if !conf.SkipStorage { account.Storage = make(map[common.Hash]string) - storageTr, err := s.db.OpenStorageTrie(s.originalRoot, addr, obj.Root(), tr) - if err != nil { - log.Error("Failed to load storage trie", "err", err) - continue - } - trieIt, err := storageTr.NodeIterator(nil) + storageIt, err := iteratee.NewStorageIterator(acctIt.Hash(), common.Hash{}) if err != nil { - log.Error("Failed to create trie iterator", "err", err) - continue + return nil, err } - storageIt := trie.NewIterator(trieIt) for storageIt.Next() { - _, content, _, err := rlp.Split(storageIt.Value) - if err != nil { - log.Error("Failed to decode the value returned by iterator", "error", err) - continue + val := storageIt.Slot() + if err := storageIt.Error(); err != nil { + storageIt.Release() + return nil, err } - key := storageTr.GetKey(storageIt.Key) - if key == nil { + key, err := storageIt.Key() + if err != nil { continue } - account.Storage[common.BytesToHash(key)] = common.Bytes2Hex(content) + account.Storage[key] = common.Bytes2Hex(common.TrimLeftZeroes(val[:])) } + storageIt.Release() } c.OnAccount(address, account) accounts++ if time.Since(logged) > 8*time.Second { - log.Info("Trie dumping in progress", "at", common.Bytes2Hex(it.Key), "accounts", accounts, - "elapsed", common.PrettyDuration(time.Since(start))) + log.Info("Trie dumping in progress", "at", acctIt.Hash().Hex(), "accounts", accounts, "elapsed", common.PrettyDuration(time.Since(start))) logged = time.Now() } if conf.Max > 0 && accounts >= conf.Max { - if it.Next() { - nextKey = it.Key + if acctIt.Next() { + nextKey = acctIt.Hash().Bytes() } break } @@ -217,10 +210,8 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] if missingPreimages > 0 { log.Warn("Dump incomplete due to missing preimages", "missing", missingPreimages) } - log.Info("Trie dumping complete", "accounts", accounts, - "elapsed", common.PrettyDuration(time.Since(start))) - - return nextKey + log.Info("Trie dumping complete", "accounts", accounts, "elapsed", common.PrettyDuration(time.Since(start))) + return nextKey, nil } // DumpBinTrieLeaves collects all binary trie leaf nodes into the provided map. @@ -251,7 +242,8 @@ func (s *StateDB) RawDump(opts *DumpConfig) Dump { dump := &Dump{ Accounts: make(map[string]DumpAccount), } - dump.Next = s.DumpToCollector(dump, opts) + next, _ := s.DumpToCollector(dump, opts) + dump.Next = next return *dump } diff --git a/core/state/iterator.go b/core/state/iterator.go index 0abae091d954..0050a840d802 100644 --- a/core/state/iterator.go +++ b/core/state/iterator.go @@ -144,10 +144,7 @@ func (it *nodeIterator) step() error { } if !bytes.Equal(account.CodeHash, types.EmptyCodeHash.Bytes()) { it.codeHash = common.BytesToHash(account.CodeHash) - it.code, err = it.state.reader.Code(address, common.BytesToHash(account.CodeHash)) - if err != nil { - return fmt.Errorf("code %x: %v", account.CodeHash, err) - } + it.code = it.state.reader.Code(address, common.BytesToHash(account.CodeHash)) if len(it.code) == 0 { return fmt.Errorf("code is not found: %x", account.CodeHash) } diff --git a/core/state/journal.go b/core/state/journal.go index f3f976f24fed..353144a1c7ca 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -18,7 +18,6 @@ package state import ( "fmt" - "maps" "slices" "sort" @@ -32,25 +31,163 @@ type revision struct { journalIndex int } +// journalMutationKind indicates the type of account mutation. +type journalMutationKind uint8 + +const ( + // journalMutationKindNone is the zero value returned by mutation() for + // entries that don't carry a tracked account mutation. The accompanying + // bool is false in that case; callers must gate on it before using the + // kind. + journalMutationKindNone journalMutationKind = iota + journalMutationKindTouch + journalMutationKindCreate + journalMutationKindSelfDestruct + journalMutationKindBalance + journalMutationKindNonce + journalMutationKindCode + journalMutationKindStorage + journalMutationKindCount // sentinel, must stay last +) + +type journalMutationCounts [journalMutationKindCount]int + +// journalMutationState tracks, per account, both the per-kind count of mutation +// entries currently present in the journal and the pre-tx value of each +// metadata field captured on its first touch (balance/nonce/code). +// The *Set flags indicate whether the corresponding field has been mutated +// at least once in the current tx window; they are cleared when all entries +// of that kind are reverted. Storage slots are tracked elsewhere. +type journalMutationState struct { + counts journalMutationCounts + + balance *uint256.Int + balanceSet bool + nonce uint64 + nonceSet bool + code []byte + codeSet bool +} + +func (s *journalMutationState) add(kind journalMutationKind) { + s.counts.add(kind) +} + +// remove drops one occurrence of the given mutation kind. It returns a flag +// indicating whether no entries of any kind remain. +func (s *journalMutationState) remove(kind journalMutationKind) bool { + if s.counts.remove(kind) { + // No entries of this kind remain for this account; drop the + // corresponding stashed original so the state mirrors the + // live mutation set. + s.clearKind(kind) + } + return s.counts == (journalMutationCounts{}) +} + +// clearKind drops the stashed original for the given mutation kind. It is +// invoked during revert once no journal entries of that kind remain for the +// account. Kinds that don't correspond to a tracked metadata field are no-ops. +func (s *journalMutationState) clearKind(kind journalMutationKind) { + switch kind { + case journalMutationKindBalance: + s.balance = nil + s.balanceSet = false + case journalMutationKindNonce: + s.nonce = 0 + s.nonceSet = false + case journalMutationKindCode: + s.code = nil + s.codeSet = false + } +} + +func (s *journalMutationState) copy() *journalMutationState { + cpy := *s + if s.balance != nil { + cpy.balance = new(uint256.Int).Set(s.balance) + } + if s.code != nil { + cpy.code = slices.Clone(s.code) + } + return &cpy +} + +func (c *journalMutationCounts) add(kind journalMutationKind) { + c[kind]++ +} + +func (c *journalMutationCounts) remove(kind journalMutationKind) bool { + c[kind]-- + return c[kind] == 0 +} + // journalEntry is a modification entry in the state change journal that can be // reverted on demand. type journalEntry interface { // revert undoes the changes introduced by this journal entry. revert(*StateDB) - // dirtied returns the Ethereum address modified by this journal entry. - dirtied() *common.Address + // mutation returns the account mutation introduced by this entry. + // It indicates false if no tracked account mutation was made. + mutation() (common.Address, journalMutationKind, bool) // copy returns a deep-copied journal entry. copy() journalEntry } +// stashBalance records prev as the pre-tx balance of addr, iff this is the +// first balance touch seen in the current tx. Subsequent balance writes are +// ignored so the stored value remains the true pre-tx original. +func (j *journal) stashBalance(addr common.Address, prev *uint256.Int) { + s := j.mutationStateFor(addr) + if s.balanceSet { + return + } + // The balance is already deep-copied and safe to hold the object here. + s.balance = prev + s.balanceSet = true +} + +// stashNonce records prev as the pre-tx nonce of addr on first touch. +func (j *journal) stashNonce(addr common.Address, prev uint64) { + s := j.mutationStateFor(addr) + if s.nonceSet { + return + } + s.nonce = prev + s.nonceSet = true +} + +// stashCode records prev as the pre-tx code of addr on first touch. +func (j *journal) stashCode(addr common.Address, prev []byte) { + s := j.mutationStateFor(addr) + if s.codeSet { + return + } + // The code is already deep-copied in the StateDB, safe to + // hold the reference here. + s.code = prev + s.codeSet = true +} + +// mutationStateFor returns the mutation state for addr, creating an empty one +// if absent. +func (j *journal) mutationStateFor(addr common.Address) *journalMutationState { + s := j.mutations[addr] + if s == nil { + s = new(journalMutationState) + j.mutations[addr] = s + } + return s +} + // journal contains the list of state modifications applied since the last state // commit. These are tracked to be able to be reverted in the case of an execution // exception or request for reversal. type journal struct { - entries []journalEntry // Current changes tracked by the journal - dirties map[common.Address]int // Dirty accounts and the number of changes + entries []journalEntry // Current changes tracked by the journal + mutations map[common.Address]*journalMutationState // Per-account mutation kinds and pre-tx originals validRevisions []revision nextRevisionId int @@ -59,7 +196,7 @@ type journal struct { // newJournal creates a new initialized journal. func newJournal() *journal { return &journal{ - dirties: make(map[common.Address]int), + mutations: make(map[common.Address]*journalMutationState), } } @@ -69,7 +206,7 @@ func newJournal() *journal { func (j *journal) reset() { j.entries = j.entries[:0] j.validRevisions = j.validRevisions[:0] - clear(j.dirties) + clear(j.mutations) j.nextRevisionId = 0 } @@ -100,33 +237,52 @@ func (j *journal) revertToSnapshot(revid int, s *StateDB) { // append inserts a new modification entry to the end of the change journal. func (j *journal) append(entry journalEntry) { j.entries = append(j.entries, entry) - if addr := entry.dirtied(); addr != nil { - j.dirties[*addr]++ + if addr, kind, dirty := entry.mutation(); dirty { + state := j.mutations[addr] + if state == nil { + state = new(journalMutationState) + j.mutations[addr] = state + } + state.add(kind) } } // revert undoes a batch of journalled modifications along with any reverted -// dirty handling too. +// mutation tracking too. func (j *journal) revert(statedb *StateDB, snapshot int) { for i := len(j.entries) - 1; i >= snapshot; i-- { // Undo the changes made by the operation j.entries[i].revert(statedb) - // Drop any dirty tracking induced by the change - if addr := j.entries[i].dirtied(); addr != nil { - if j.dirties[*addr]--; j.dirties[*addr] == 0 { - delete(j.dirties, *addr) + // Drop any mutation tracking induced by the change. + if addr, kind, dirty := j.entries[i].mutation(); dirty { + state := j.mutations[addr] + if state == nil { + panic(fmt.Errorf("journal mutation tracking missing for %x", addr[:])) + } + if state.remove(kind) { + delete(j.mutations, addr) } } } j.entries = j.entries[:snapshot] } -// dirty explicitly sets an address to dirty, even if the change entries would -// otherwise suggest it as clean. This method is an ugly hack to handle the RIPEMD -// precompile consensus exception. -func (j *journal) dirty(addr common.Address) { - j.dirties[addr]++ +// ripemdMagic explicitly keeps RIPEMD160 in the mutation set with a touch change. +// +// Ethereum Mainnet contains an old empty-account touch/revert quirk for address +// 0x03. If we only relied on the journal entry above, the revert path would +// remove the account from the mutation set together with the touch. +// +// Keep an explicit touch marker so tx finalisation still sees RIPEMD160 +// on the mutation pass when replaying that historical case. +func (j *journal) ripemdMagic() { + state := j.mutations[ripemd] + if state == nil { + state = new(journalMutationState) + j.mutations[ripemd] = state + } + state.add(journalMutationKindTouch) } // length returns the current number of entries in the journal. @@ -140,9 +296,13 @@ func (j *journal) copy() *journal { for i := 0; i < j.length(); i++ { entries = append(entries, j.entries[i].copy()) } + mutations := make(map[common.Address]*journalMutationState, len(j.mutations)) + for addr, state := range j.mutations { + mutations[addr] = state.copy() + } return &journal{ entries: entries, - dirties: maps.Clone(j.dirties), + mutations: mutations, validRevisions: slices.Clone(j.validRevisions), nextRevisionId: j.nextRevisionId, } @@ -186,13 +346,16 @@ func (j *journal) refundChange(previous uint64) { } func (j *journal) balanceChange(addr common.Address, previous *uint256.Int) { + prev := previous.Clone() + j.stashBalance(addr, prev) j.append(balanceChange{ account: addr, - prev: previous.Clone(), + prev: prev, }) } func (j *journal) setCode(address common.Address, prevCode []byte) { + j.stashCode(address, prevCode) j.append(codeChange{ account: address, prevCode: prevCode, @@ -200,6 +363,7 @@ func (j *journal) setCode(address common.Address, prevCode []byte) { } func (j *journal) nonceChange(address common.Address, prev uint64) { + j.stashNonce(address, prev) j.append(nonceChange{ account: address, prev: prev, @@ -211,9 +375,18 @@ func (j *journal) touchChange(address common.Address) { account: address, }) if address == ripemd { - // Explicitly put it in the dirty-cache, which is otherwise generated from - // flattened journals. - j.dirty(address) + // Preserve the historical RIPEMD160 precompile consensus exception. + // + // Mainnet contains an old empty-account touch/revert quirk for address + // 0x03. If we only relied on the journal entry above, the revert path + // would remove the account from the dirty set together with the touch. + // Keep an explicit dirty marker so tx finalisation still sees the + // account on the dirty pass when replaying that historical case. + // + // This does not force deletion by itself: Finalise will still delete the + // account only if the state object is present at tx end and qualifies for + // deletion there. + j.ripemdMagic() } } @@ -294,8 +467,8 @@ func (ch createObjectChange) revert(s *StateDB) { delete(s.stateObjects, ch.account) } -func (ch createObjectChange) dirtied() *common.Address { - return &ch.account +func (ch createObjectChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindCreate, true } func (ch createObjectChange) copy() journalEntry { @@ -308,8 +481,8 @@ func (ch createContractChange) revert(s *StateDB) { s.getStateObject(ch.account).newContract = false } -func (ch createContractChange) dirtied() *common.Address { - return nil +func (ch createContractChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch createContractChange) copy() journalEntry { @@ -325,8 +498,8 @@ func (ch selfDestructChange) revert(s *StateDB) { } } -func (ch selfDestructChange) dirtied() *common.Address { - return &ch.account +func (ch selfDestructChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindSelfDestruct, true } func (ch selfDestructChange) copy() journalEntry { @@ -340,8 +513,8 @@ var ripemd = common.HexToAddress("0000000000000000000000000000000000000003") func (ch touchChange) revert(s *StateDB) { } -func (ch touchChange) dirtied() *common.Address { - return &ch.account +func (ch touchChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindTouch, true } func (ch touchChange) copy() journalEntry { @@ -354,8 +527,8 @@ func (ch balanceChange) revert(s *StateDB) { s.getStateObject(ch.account).setBalance(ch.prev) } -func (ch balanceChange) dirtied() *common.Address { - return &ch.account +func (ch balanceChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindBalance, true } func (ch balanceChange) copy() journalEntry { @@ -369,8 +542,8 @@ func (ch nonceChange) revert(s *StateDB) { s.getStateObject(ch.account).setNonce(ch.prev) } -func (ch nonceChange) dirtied() *common.Address { - return &ch.account +func (ch nonceChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindNonce, true } func (ch nonceChange) copy() journalEntry { @@ -384,8 +557,8 @@ func (ch codeChange) revert(s *StateDB) { s.getStateObject(ch.account).setCode(crypto.Keccak256Hash(ch.prevCode), ch.prevCode) } -func (ch codeChange) dirtied() *common.Address { - return &ch.account +func (ch codeChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindCode, true } func (ch codeChange) copy() journalEntry { @@ -399,8 +572,8 @@ func (ch storageChange) revert(s *StateDB) { s.getStateObject(ch.account).setState(ch.key, ch.prevvalue, ch.origvalue) } -func (ch storageChange) dirtied() *common.Address { - return &ch.account +func (ch storageChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindStorage, true } func (ch storageChange) copy() journalEntry { @@ -416,8 +589,8 @@ func (ch transientStorageChange) revert(s *StateDB) { s.setTransientState(ch.account, ch.key, ch.prevalue) } -func (ch transientStorageChange) dirtied() *common.Address { - return nil +func (ch transientStorageChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch transientStorageChange) copy() journalEntry { @@ -432,8 +605,8 @@ func (ch refundChange) revert(s *StateDB) { s.refund = ch.prev } -func (ch refundChange) dirtied() *common.Address { - return nil +func (ch refundChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch refundChange) copy() journalEntry { @@ -452,8 +625,8 @@ func (ch addLogChange) revert(s *StateDB) { s.logSize-- } -func (ch addLogChange) dirtied() *common.Address { - return nil +func (ch addLogChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch addLogChange) copy() journalEntry { @@ -475,8 +648,8 @@ func (ch accessListAddAccountChange) revert(s *StateDB) { s.accessList.DeleteAddress(ch.address) } -func (ch accessListAddAccountChange) dirtied() *common.Address { - return nil +func (ch accessListAddAccountChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch accessListAddAccountChange) copy() journalEntry { @@ -489,8 +662,8 @@ func (ch accessListAddSlotChange) revert(s *StateDB) { s.accessList.DeleteSlot(ch.address, ch.slot) } -func (ch accessListAddSlotChange) dirtied() *common.Address { - return nil +func (ch accessListAddSlotChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch accessListAddSlotChange) copy() journalEntry { diff --git a/core/state/journal_test.go b/core/state/journal_test.go new file mode 100644 index 000000000000..262cee77fe95 --- /dev/null +++ b/core/state/journal_test.go @@ -0,0 +1,219 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/types" + "github.com/holiman/uint256" +) + +// fuzzJournalAddrs is a small fixed pool used by the fuzz harness to force +// repeated collisions on the same account, which exercises the multi-entry +// path in the journal's mutation tracking and originals cleanup on revert. +// It deliberately excludes the RIPEMD-160 precompile (0x03), which has a +// consensus-level touch/revert exception that would complicate invariants. +var fuzzJournalAddrs = []common.Address{ + common.BytesToAddress([]byte{0x11}), + common.BytesToAddress([]byte{0x22}), + common.BytesToAddress([]byte{0x44}), +} + +// checkJournalInvariants validates that: +// - journal.mutations exactly reflects the dirty entries currently in +// journal.entries (per-kind counts and mask match what you'd get by +// walking the entries from scratch). +// - journal.originals mirrors that set for the three tracked metadata kinds +// (balance/nonce/code): a *Set flag is true iff the account currently has +// at least one corresponding entry in the journal. +// - An address is present in originals only if it also has at least one +// tracked-kind mutation in the journal. +func checkJournalInvariants(t *testing.T, j *journal) { + t.Helper() + + // Reconstruct the expected per-address counts from the live entries. + expected := make(map[common.Address]*journalMutationCounts) + for _, e := range j.entries { + addr, kind, dirty := e.mutation() + if !dirty { + continue + } + c := expected[addr] + if c == nil { + c = &journalMutationCounts{} + expected[addr] = c + } + c.add(kind) + } + + if len(j.mutations) != len(expected) { + t.Fatalf("mutations size %d, want %d", len(j.mutations), len(expected)) + } + for addr, state := range j.mutations { + want, ok := expected[addr] + if !ok { + t.Fatalf("mutations has extra address %x", addr) + } + if state.counts != *want { + t.Fatalf("addr %x: counts=%+v want=%+v", addr, state.counts, *want) + } + // First-touch *Set flags must mirror the live per-kind counts. + if state.balanceSet != (want[journalMutationKindBalance] > 0) { + t.Fatalf("addr %x: balanceSet=%v want=%v (balance count=%d)", + addr, state.balanceSet, want[journalMutationKindBalance] > 0, want[journalMutationKindBalance]) + } + if state.nonceSet != (want[journalMutationKindNonce] > 0) { + t.Fatalf("addr %x: nonceSet=%v want=%v (nonce count=%d)", + addr, state.nonceSet, want[journalMutationKindNonce] > 0, want[journalMutationKindNonce]) + } + if state.codeSet != (want[journalMutationKindCode] > 0) { + t.Fatalf("addr %x: codeSet=%v want=%v (code count=%d)", + addr, state.codeSet, want[journalMutationKindCode] > 0, want[journalMutationKindCode]) + } + } +} + +// FuzzJournal drives a randomised sequence of state mutations, snapshots and +// reverts against a fresh StateDB and validates the journal's internal +// bookkeeping invariants after every step. It also asserts that reverting +// back to the root snapshot empties mutations, originals and entries +// completely. The seed corpus ensures the test also runs as a regular unit +// test via `go test -run FuzzJournal`. +func FuzzJournal(f *testing.F) { + seeds := [][]byte{ + // balance then full revert (simplest a→b→a case). + {0x00, 0x00, 0x05, 0x05, 0x00}, + // balance+nonce+code mixed, then revert to root. + {0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x00, 0x03, 0x05, 0x00}, + // snapshot, mutate, revert, mutate again. + {0x04, 0x00, 0x00, 0x07, 0x05, 0x00, 0x00, 0x01, 0x05}, + // storage interleaved with metadata. + {0x03, 0x00, 0x01, 0x00, 0x01, 0x05, 0x03, 0x02, 0x02, 0x04, 0x03, 0x01, 0x07}, + // many ops, no explicit revert — exercises steady-state invariants. + {0x00, 0x01, 0x02, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x00, 0x01, 0x02, 0x00, 0x06, 0x08, 0x0a, 0x0c}, + } + for _, s := range seeds { + f.Add(s) + } + + f.Fuzz(func(t *testing.T, data []byte) { + sdb, err := New(types.EmptyRootHash, NewDatabaseForTesting()) + if err != nil { + t.Fatal(err) + } + root := sdb.Snapshot() + + // Stack of snapshot IDs taken during the fuzz loop. + var pending []int + + // readByte returns the next byte and advances the cursor. Returns + // (0, false) if exhausted. + i := 0 + readByte := func() (byte, bool) { + if i >= len(data) { + return 0, false + } + b := data[i] + i++ + return b, true + } + + for { + op, ok := readByte() + if !ok { + break + } + switch op % 6 { + case 0: // SetBalance + a, ok1 := readByte() + v, ok2 := readByte() + if !ok1 || !ok2 { + break + } + addr := fuzzJournalAddrs[int(a)%len(fuzzJournalAddrs)] + sdb.SetBalance(addr, uint256.NewInt(uint64(v)), tracing.BalanceChangeUnspecified) + case 1: // SetNonce + a, ok1 := readByte() + n, ok2 := readByte() + if !ok1 || !ok2 { + break + } + addr := fuzzJournalAddrs[int(a)%len(fuzzJournalAddrs)] + sdb.SetNonce(addr, uint64(n), tracing.NonceChangeUnspecified) + case 2: // SetCode + a, ok1 := readByte() + l, ok2 := readByte() + if !ok1 || !ok2 { + break + } + addr := fuzzJournalAddrs[int(a)%len(fuzzJournalAddrs)] + code := make([]byte, int(l)%8) + for k := range code { + b, ok := readByte() + if !ok { + break + } + code[k] = b + } + sdb.SetCode(addr, code, tracing.CodeChangeUnspecified) + case 3: // SetState (storage; tracked as mutation kind, no original) + a, ok1 := readByte() + k, ok2 := readByte() + v, ok3 := readByte() + if !ok1 || !ok2 || !ok3 { + break + } + addr := fuzzJournalAddrs[int(a)%len(fuzzJournalAddrs)] + sdb.SetState(addr, + common.BytesToHash([]byte{k}), + common.BytesToHash([]byte{v})) + case 4: // Snapshot + pending = append(pending, sdb.Snapshot()) + case 5: // RevertToSnapshot + if len(pending) == 0 { + break + } + sel, ok := readByte() + if !ok { + break + } + idx := int(sel) % len(pending) + sdb.RevertToSnapshot(pending[idx]) + pending = pending[:idx] + } + checkJournalInvariants(t, sdb.journal) + } + + // After reverting to the root snapshot, the journal must be fully + // drained: no entries, no mutations, no originals. This is the core + // guarantee the user cares about — "all mutations against a single + // account reverted" taken to its limit across every account. + sdb.RevertToSnapshot(root) + checkJournalInvariants(t, sdb.journal) + + if n := len(sdb.journal.entries); n != 0 { + t.Fatalf("entries not drained after revert-to-root: %d remain", n) + } + if n := len(sdb.journal.mutations); n != 0 { + t.Fatalf("mutations not drained after revert-to-root: %d remain", n) + } + }) +} diff --git a/core/state/reader.go b/core/state/reader.go index c912ca28da8b..be07cec0f97f 100644 --- a/core/state/reader.go +++ b/core/state/reader.go @@ -18,52 +18,42 @@ package state import ( "errors" - "fmt" "sync" "sync/atomic" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/lru" "github.com/ethereum/go-ethereum/core/overlay" - "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie/bintrie" "github.com/ethereum/go-ethereum/trie/transitiontrie" - "github.com/ethereum/go-ethereum/trie/utils" "github.com/ethereum/go-ethereum/triedb" "github.com/ethereum/go-ethereum/triedb/database" ) // ContractCodeReader defines the interface for accessing contract code. +// +// ContractCodeReader is supposed to be thread-safe. type ContractCodeReader interface { // Has returns the flag indicating whether the contract code with // specified address and hash exists or not. Has(addr common.Address, codeHash common.Hash) bool - // Code retrieves a particular contract's code. - // - // - Returns nil code along with nil error if the requested contract code - // doesn't exist - // - Returns an error only if an unexpected issue occurs - Code(addr common.Address, codeHash common.Hash) ([]byte, error) + // Code retrieves a particular contract's code. Returns nil code if the + // requested contract code doesn't exist. + Code(addr common.Address, codeHash common.Hash) []byte - // CodeSize retrieves a particular contracts code's size. - // - // - Returns zero code size along with nil error if the requested contract code - // doesn't exist - // - Returns an error only if an unexpected issue occurs - CodeSize(addr common.Address, codeHash common.Hash) (int, error) + // CodeSize retrieves a particular contracts code's size. Returns zero code + // size if the requested contract code doesn't exist. + CodeSize(addr common.Address, codeHash common.Hash) int } // StateReader defines the interface for accessing accounts and storage slots // associated with a specific state. // -// StateReader is assumed to be thread-safe and implementation must take care -// of the concurrency issue by themselves. +// StateReader is supposed to be thread-safe. type StateReader interface { // Account retrieves the account associated with a particular address. // @@ -91,96 +81,6 @@ type Reader interface { StateReader } -// ReaderStats wraps the statistics of reader. -type ReaderStats struct { - // Cache stats - AccountCacheHit int64 - AccountCacheMiss int64 - StorageCacheHit int64 - StorageCacheMiss int64 -} - -// String implements fmt.Stringer, returning string format statistics. -func (s ReaderStats) String() string { - var ( - accountCacheHitRate float64 - storageCacheHitRate float64 - ) - if s.AccountCacheHit > 0 { - accountCacheHitRate = float64(s.AccountCacheHit) / float64(s.AccountCacheHit+s.AccountCacheMiss) * 100 - } - if s.StorageCacheHit > 0 { - storageCacheHitRate = float64(s.StorageCacheHit) / float64(s.StorageCacheHit+s.StorageCacheMiss) * 100 - } - msg := fmt.Sprintf("Reader statistics\n") - msg += fmt.Sprintf("account: hit: %d, miss: %d, rate: %.2f\n", s.AccountCacheHit, s.AccountCacheMiss, accountCacheHitRate) - msg += fmt.Sprintf("storage: hit: %d, miss: %d, rate: %.2f\n", s.StorageCacheHit, s.StorageCacheMiss, storageCacheHitRate) - return msg -} - -// ReaderWithStats wraps the additional method to retrieve the reader statistics from. -type ReaderWithStats interface { - Reader - GetStats() ReaderStats -} - -// cachingCodeReader implements ContractCodeReader, accessing contract code either in -// local key-value store or the shared code cache. -// -// cachingCodeReader is safe for concurrent access. -type cachingCodeReader struct { - db ethdb.KeyValueReader - - // These caches could be shared by multiple code reader instances, - // they are natively thread-safe. - codeCache *lru.SizeConstrainedCache[common.Hash, []byte] - codeSizeCache *lru.Cache[common.Hash, int] -} - -// newCachingCodeReader constructs the code reader. -func newCachingCodeReader(db ethdb.KeyValueReader, codeCache *lru.SizeConstrainedCache[common.Hash, []byte], codeSizeCache *lru.Cache[common.Hash, int]) *cachingCodeReader { - return &cachingCodeReader{ - db: db, - codeCache: codeCache, - codeSizeCache: codeSizeCache, - } -} - -// Code implements ContractCodeReader, retrieving a particular contract's code. -// If the contract code doesn't exist, no error will be returned. -func (r *cachingCodeReader) Code(addr common.Address, codeHash common.Hash) ([]byte, error) { - code, _ := r.codeCache.Get(codeHash) - if len(code) > 0 { - return code, nil - } - code = rawdb.ReadCode(r.db, codeHash) - if len(code) > 0 { - r.codeCache.Add(codeHash, code) - r.codeSizeCache.Add(codeHash, len(code)) - } - return code, nil -} - -// CodeSize implements ContractCodeReader, retrieving a particular contracts code's size. -// If the contract code doesn't exist, no error will be returned. -func (r *cachingCodeReader) CodeSize(addr common.Address, codeHash common.Hash) (int, error) { - if cached, ok := r.codeSizeCache.Get(codeHash); ok { - return cached, nil - } - code, err := r.Code(addr, codeHash) - if err != nil { - return 0, err - } - return len(code), nil -} - -// Has returns the flag indicating whether the contract code with -// specified address and hash exists or not. -func (r *cachingCodeReader) Has(addr common.Address, codeHash common.Hash) bool { - code, _ := r.Code(addr, codeHash) - return len(code) > 0 -} - // flatReader wraps a database state reader and is safe for concurrent access. type flatReader struct { reader database.StateReader @@ -198,7 +98,7 @@ func newFlatReader(reader database.StateReader) *flatReader { // // The returned account might be nil if it's not existent. func (r *flatReader) Account(addr common.Address) (*types.StateAccount, error) { - account, err := r.reader.Account(crypto.Keccak256Hash(addr.Bytes())) + account, err := r.reader.Account(crypto.Keccak256Hash(addr[:])) if err != nil { return nil, err } @@ -228,8 +128,8 @@ func (r *flatReader) Account(addr common.Address) (*types.StateAccount, error) { // // The returned storage slot might be empty if it's not existent. func (r *flatReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { - addrHash := crypto.Keccak256Hash(addr.Bytes()) - slotHash := crypto.Keccak256Hash(key.Bytes()) + addrHash := crypto.Keccak256Hash(addr[:]) + slotHash := crypto.Keccak256Hash(key[:]) ret, err := r.reader.Storage(addrHash, slotHash) if err != nil { return common.Hash{}, err @@ -248,70 +148,28 @@ func (r *flatReader) Storage(addr common.Address, key common.Hash) (common.Hash, return value, nil } -// trieReader implements the StateReader interface, providing functions to access -// state from the referenced trie. +// mptTrieReader implements the StateReader interface, providing functions to +// access state from the referenced Merkle-Patricia-tree. // -// trieReader is safe for concurrent read. -type trieReader struct { - root common.Hash // State root which uniquely represent a state +// mptTrieReader is safe for concurrent read. +type mptTrieReader struct { + root common.Hash // State root which uniquely represents a state db *triedb.Database // Database for loading trie - // Main trie, resolved in constructor. Note either the Merkle-Patricia-tree - // or Verkle-tree is not safe for concurrent read. - mainTrie Trie - + mainTrie Trie // Main trie, resolved in constructor, not thread-safe subRoots map[common.Address]common.Hash // Set of storage roots, cached when the account is resolved subTries map[common.Address]Trie // Group of storage tries, cached when it's resolved lock sync.Mutex // Lock for protecting concurrent read } -// newTrieReader constructs a trie reader of the specific state. An error will be -// returned if the associated trie specified by root is not existent. -func newTrieReader(root common.Hash, db *triedb.Database, cache *utils.PointCache) (*trieReader, error) { - var ( - tr Trie - err error - ) - if !db.IsVerkle() { - tr, err = trie.NewStateTrie(trie.StateTrieID(root), db) - } else { - // When IsVerkle() is true, create a BinaryTrie wrapped in TransitionTrie - binTrie, binErr := bintrie.NewBinaryTrie(root, db) - if binErr != nil { - return nil, binErr - } - - // Based on the transition status, determine if the overlay - // tree needs to be created, or if a single, target tree is - // to be picked. - ts := overlay.LoadTransitionState(db.Disk(), root, true) - if ts.InTransition() { - mpt, err := trie.NewStateTrie(trie.StateTrieID(ts.BaseRoot), db) - if err != nil { - return nil, err - } - tr = transitiontrie.NewTransitionTrie(mpt, binTrie, false) - } else { - // HACK: Use TransitionTrie with nil base as a wrapper to make BinaryTrie - // satisfy the Trie interface. This works around the import cycle between - // trie and trie/bintrie packages. - // - // TODO: In future PRs, refactor the package structure to avoid this hack: - // - Option 1: Move common interfaces (Trie, NodeIterator) to a separate - // package that both trie and trie/bintrie can import - // - Option 2: Create a factory function in the trie package that returns - // BinaryTrie as a Trie interface without direct import - // - Option 3: Move BinaryTrie to the main trie package - // - // The current approach works but adds unnecessary overhead and complexity - // by using TransitionTrie when there's no actual transition happening. - tr = transitiontrie.NewTransitionTrie(nil, binTrie, false) - } - } +// newMPTTrieReader constructs a Merkle-Patricia-tree reader of the specific state. +// An error will be returned if the associated trie specified by root is not existent. +func newMPTTrieReader(root common.Hash, db *triedb.Database) (*mptTrieReader, error) { + tr, err := trie.NewStateTrie(trie.StateTrieID(root), db) if err != nil { return nil, err } - return &trieReader{ + return &mptTrieReader{ root: root, db: db, mainTrie: tr, @@ -321,7 +179,7 @@ func newTrieReader(root common.Hash, db *triedb.Database, cache *utils.PointCach } // account is the inner version of Account and assumes the r.lock is already held. -func (r *trieReader) account(addr common.Address) (*types.StateAccount, error) { +func (r *mptTrieReader) account(addr common.Address) (*types.StateAccount, error) { account, err := r.mainTrie.GetAccount(addr) if err != nil { return nil, err @@ -336,9 +194,9 @@ func (r *trieReader) account(addr common.Address) (*types.StateAccount, error) { // Account implements StateReader, retrieving the account specified by the address. // -// An error will be returned if the trie state is corrupted. An nil account +// An error will be returned if the trie state is corrupted. A nil account // will be returned if it's not existent in the trie. -func (r *trieReader) Account(addr common.Address) (*types.StateAccount, error) { +func (r *mptTrieReader) Account(addr common.Address) (*types.StateAccount, error) { r.lock.Lock() defer r.lock.Unlock() @@ -350,43 +208,118 @@ func (r *trieReader) Account(addr common.Address) (*types.StateAccount, error) { // // An error will be returned if the trie state is corrupted. An empty storage // slot will be returned if it's not existent in the trie. -func (r *trieReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { +func (r *mptTrieReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { r.lock.Lock() defer r.lock.Unlock() - var ( - tr Trie - found bool - value common.Hash - ) - if r.db.IsVerkle() { - tr = r.mainTrie - } else { - tr, found = r.subTries[addr] - if !found { - root, ok := r.subRoots[addr] - - // The storage slot is accessed without account caching. It's unexpected - // behavior but try to resolve the account first anyway. - if !ok { - _, err := r.account(addr) - if err != nil { - return common.Hash{}, err - } - root = r.subRoots[addr] - } - var err error - tr, err = trie.NewStateTrie(trie.StorageTrieID(r.root, crypto.Keccak256Hash(addr.Bytes()), root), r.db) + tr, found := r.subTries[addr] + if !found { + root, ok := r.subRoots[addr] + + // The storage slot is accessed without account caching. It's unexpected + // behavior but try to resolve the account first anyway. + if !ok { + _, err := r.account(addr) if err != nil { return common.Hash{}, err } - r.subTries[addr] = tr + root = r.subRoots[addr] } + var err error + tr, err = trie.NewStateTrie(trie.StorageTrieID(r.root, crypto.Keccak256Hash(addr.Bytes()), root), r.db) + if err != nil { + return common.Hash{}, err + } + r.subTries[addr] = tr } ret, err := tr.GetStorage(addr, key.Bytes()) if err != nil { return common.Hash{}, err } + var value common.Hash + value.SetBytes(ret) + return value, nil +} + +// ubtTrieReader implements the StateReader interface, providing functions to access +// state from the referenced Unified-binary-trie. +// +// ubtTrieReader is safe for concurrent read. +type ubtTrieReader struct { + root common.Hash // State root which uniquely represents a state + db *triedb.Database // Database for loading trie + tr Trie // Referenced unified binary trie + lock sync.Mutex // Lock for protecting concurrent read +} + +// newUBTTrieReader constructs a Unified-binary-trie reader of the specific state. +// An error will be returned if the associated trie specified by root is not existent. +func newUBTTrieReader(root common.Hash, db *triedb.Database) (*ubtTrieReader, error) { + binTrie, binErr := bintrie.NewBinaryTrie(root, db, db.BinTrieGroupDepth()) + if binErr != nil { + return nil, binErr + } + // Based on the transition status, determine if the overlay + // tree needs to be created, or if a single, target tree is + // to be picked. + var ( + tr Trie + ts = overlay.LoadTransitionState(db.Disk(), root, true) + ) + if ts.InTransition() { + mpt, err := trie.NewStateTrie(trie.StateTrieID(ts.BaseRoot), db) + if err != nil { + return nil, err + } + tr = transitiontrie.NewTransitionTrie(mpt, binTrie, false) + } else { + // HACK: Use TransitionTrie with nil base as a wrapper to make BinaryTrie + // satisfy the Trie interface. This works around the import cycle between + // trie and trie/bintrie packages. + // + // TODO: In future PRs, refactor the package structure to avoid this hack: + // - Option 1: Move common interfaces (Trie, NodeIterator) to a separate + // package that both trie and trie/bintrie can import + // - Option 2: Create a factory function in the trie package that returns + // BinaryTrie as a Trie interface without direct import + // - Option 3: Move BinaryTrie to the main trie package + // + // The current approach works but adds unnecessary overhead and complexity + // by using TransitionTrie when there's no actual transition happening. + tr = transitiontrie.NewTransitionTrie(nil, binTrie, false) + } + return &ubtTrieReader{ + root: root, + db: db, + tr: tr, + }, nil +} + +// Account implements StateReader, retrieving the account specified by the address. +// +// An error will be returned if the trie state is corrupted. A nil account +// will be returned if it's not existent in the trie. +func (r *ubtTrieReader) Account(addr common.Address) (*types.StateAccount, error) { + r.lock.Lock() + defer r.lock.Unlock() + + return r.tr.GetAccount(addr) +} + +// Storage implements StateReader, retrieving the storage slot specified by the +// address and slot key. +// +// An error will be returned if the trie state is corrupted. An empty storage +// slot will be returned if it's not existent in the trie. +func (r *ubtTrieReader) Storage(addr common.Address, key common.Hash) (common.Hash, error) { + r.lock.Lock() + defer r.lock.Unlock() + + ret, err := r.tr.GetStorage(addr, key.Bytes()) + if err != nil { + return common.Hash{}, err + } + var value common.Hash value.SetBytes(ret) return value, nil } @@ -449,24 +382,10 @@ func (r *multiStateReader) Storage(addr common.Address, slot common.Hash) (commo return common.Hash{}, errors.Join(errs...) } -// reader is the wrapper of ContractCodeReader and StateReader interface. -type reader struct { - ContractCodeReader +// stateReaderWithCache is a wrapper around StateReader that maintains additional +// state caches to support concurrent state access. +type stateReaderWithCache struct { StateReader -} - -// newReader constructs a reader with the supplied code reader and state reader. -func newReader(codeReader ContractCodeReader, stateReader StateReader) *reader { - return &reader{ - ContractCodeReader: codeReader, - StateReader: stateReader, - } -} - -// readerWithCache is a wrapper around Reader that maintains additional state caches -// to support concurrent state access. -type readerWithCache struct { - Reader // safe for concurrent read // Previously resolved state entries. accounts map[common.Address]*types.StateAccount @@ -482,11 +401,11 @@ type readerWithCache struct { } } -// newReaderWithCache constructs the reader with local cache. -func newReaderWithCache(reader Reader) *readerWithCache { - r := &readerWithCache{ - Reader: reader, - accounts: make(map[common.Address]*types.StateAccount), +// newStateReaderWithCache constructs the state reader with local cache. +func newStateReaderWithCache(sr StateReader) *stateReaderWithCache { + r := &stateReaderWithCache{ + StateReader: sr, + accounts: make(map[common.Address]*types.StateAccount), } for i := range r.storageBuckets { r.storageBuckets[i].storages = make(map[common.Address]map[common.Hash]common.Hash) @@ -499,7 +418,7 @@ func newReaderWithCache(reader Reader) *readerWithCache { // might be nil if it's not existent. // // An error will be returned if the state is corrupted in the underlying reader. -func (r *readerWithCache) account(addr common.Address) (*types.StateAccount, bool, error) { +func (r *stateReaderWithCache) account(addr common.Address) (*types.StateAccount, bool, error) { // Try to resolve the requested account in the local cache r.accountLock.RLock() acct, ok := r.accounts[addr] @@ -508,7 +427,7 @@ func (r *readerWithCache) account(addr common.Address) (*types.StateAccount, boo return acct, true, nil } // Try to resolve the requested account from the underlying reader - acct, err := r.Reader.Account(addr) + acct, err := r.StateReader.Account(addr) if err != nil { return nil, false, err } @@ -522,7 +441,7 @@ func (r *readerWithCache) account(addr common.Address) (*types.StateAccount, boo // The returned account might be nil if it's not existent. // // An error will be returned if the state is corrupted in the underlying reader. -func (r *readerWithCache) Account(addr common.Address) (*types.StateAccount, error) { +func (r *stateReaderWithCache) Account(addr common.Address) (*types.StateAccount, error) { account, _, err := r.account(addr) return account, err } @@ -530,7 +449,7 @@ func (r *readerWithCache) Account(addr common.Address) (*types.StateAccount, err // storage retrieves the storage slot specified by the address and slot key, along // with a flag indicating whether it's found in the cache or not. The returned // storage slot might be empty if it's not existent. -func (r *readerWithCache) storage(addr common.Address, slot common.Hash) (common.Hash, bool, error) { +func (r *stateReaderWithCache) storage(addr common.Address, slot common.Hash) (common.Hash, bool, error) { var ( value common.Hash ok bool @@ -547,7 +466,7 @@ func (r *readerWithCache) storage(addr common.Address, slot common.Hash) (common return value, true, nil } // Try to resolve the requested storage slot from the underlying reader - value, err := r.Reader.Storage(addr, slot) + value, err := r.StateReader.Storage(addr, slot) if err != nil { return common.Hash{}, false, err } @@ -568,13 +487,15 @@ func (r *readerWithCache) storage(addr common.Address, slot common.Hash) (common // existent. // // An error will be returned if the state is corrupted in the underlying reader. -func (r *readerWithCache) Storage(addr common.Address, slot common.Hash) (common.Hash, error) { +func (r *stateReaderWithCache) Storage(addr common.Address, slot common.Hash) (common.Hash, error) { value, _, err := r.storage(addr, slot) return value, err } -type readerWithCacheStats struct { - *readerWithCache +// stateReaderWithStats is a wrapper over the stateReaderWithCache, tracking +// the cache hit statistics of the reader. +type stateReaderWithStats struct { + *stateReaderWithCache accountCacheHit atomic.Int64 accountCacheMiss atomic.Int64 @@ -582,10 +503,10 @@ type readerWithCacheStats struct { storageCacheMiss atomic.Int64 } -// newReaderWithCacheStats constructs the reader with additional statistics tracked. -func newReaderWithCacheStats(reader *readerWithCache) *readerWithCacheStats { - return &readerWithCacheStats{ - readerWithCache: reader, +// newReaderWithStats constructs the state reader with additional statistics tracked. +func newStateReaderWithStats(sr *stateReaderWithCache) *stateReaderWithStats { + return &stateReaderWithStats{ + stateReaderWithCache: sr, } } @@ -593,8 +514,8 @@ func newReaderWithCacheStats(reader *readerWithCache) *readerWithCacheStats { // The returned account might be nil if it's not existent. // // An error will be returned if the state is corrupted in the underlying reader. -func (r *readerWithCacheStats) Account(addr common.Address) (*types.StateAccount, error) { - account, incache, err := r.readerWithCache.account(addr) +func (r *stateReaderWithStats) Account(addr common.Address) (*types.StateAccount, error) { + account, incache, err := r.stateReaderWithCache.account(addr) if err != nil { return nil, err } @@ -611,8 +532,8 @@ func (r *readerWithCacheStats) Account(addr common.Address) (*types.StateAccount // existent. // // An error will be returned if the state is corrupted in the underlying reader. -func (r *readerWithCacheStats) Storage(addr common.Address, slot common.Hash) (common.Hash, error) { - value, incache, err := r.readerWithCache.storage(addr, slot) +func (r *stateReaderWithStats) Storage(addr common.Address, slot common.Hash) (common.Hash, error) { + value, incache, err := r.stateReaderWithCache.storage(addr, slot) if err != nil { return common.Hash{}, err } @@ -624,12 +545,51 @@ func (r *readerWithCacheStats) Storage(addr common.Address, slot common.Hash) (c return value, nil } -// GetStats implements ReaderWithStats, returning the statistics of state reader. -func (r *readerWithCacheStats) GetStats() ReaderStats { - return ReaderStats{ +// GetStateStats implements StateReaderStater, returning the statistics of the +// state reader. +func (r *stateReaderWithStats) GetStateStats() StateReaderStats { + return StateReaderStats{ AccountCacheHit: r.accountCacheHit.Load(), AccountCacheMiss: r.accountCacheMiss.Load(), StorageCacheHit: r.storageCacheHit.Load(), StorageCacheMiss: r.storageCacheMiss.Load(), } } + +// reader aggregates a code reader and a state reader into a single object. +type reader struct { + ContractCodeReader + StateReader +} + +// newReader constructs a reader with the supplied code reader and state reader. +func newReader(codeReader ContractCodeReader, stateReader StateReader) *reader { + return &reader{ + ContractCodeReader: codeReader, + StateReader: stateReader, + } +} + +// GetCodeStats returns the statistics of code access. +func (r *reader) GetCodeStats() ContractCodeReaderStats { + if stater, ok := r.ContractCodeReader.(ContractCodeReaderStater); ok { + return stater.GetCodeStats() + } + return ContractCodeReaderStats{} +} + +// GetStateStats returns the statistics of state access. +func (r *reader) GetStateStats() StateReaderStats { + if stater, ok := r.StateReader.(StateReaderStater); ok { + return stater.GetStateStats() + } + return StateReaderStats{} +} + +// GetStats returns the aggregated statistics for both state and code access. +func (r *reader) GetStats() ReaderStats { + return ReaderStats{ + CodeStats: r.GetCodeStats(), + StateStats: r.GetStateStats(), + } +} diff --git a/core/state/reader_eip_7928.go b/core/state/reader_eip_7928.go new file mode 100644 index 000000000000..ff315ac5eb6e --- /dev/null +++ b/core/state/reader_eip_7928.go @@ -0,0 +1,247 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "sync" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/types/bal" +) + +// The EIP27928 reader utilizes a hierarchical architecture to optimize state +// access during block execution: +// +// - Base layer: The reader is initialized with the pre-transition state root, +// providing the access of the state. +// +// - Prefetching Layer: This base reader is wrapped by newPrefetchStateReader. +// Using an Access List hint, it asynchronously fetches required state data +// in the background, minimizing I/O blocking during transaction processing. +// +// - Execution Layer: To support parallel transaction execution within the EIP +// 7928 context, readers are wrapped in ReaderWithBlockLevelAccessList. +// This layer provides a "unified view" by merging the pre-transition state +// with mutated states from preceding transactions in the block. +// +// - Tracking Layer: Finally, the readerTracker wraps the execution reader to +// capture all state reads made during a specific transaction. These individual +// reads are subsequently merged to construct a comprehensive access list +// for the entire block. +// +// The architecture can be illustrated by the diagram below: +// +// ┌──────────────┴──────────────┐ ┌──────────────┴──────────────┐ +// │ ReaderWithBlockLevelAL │ │ ReaderWithBlockLevelAL │ +// │ (Pre-state + Mutations) │ │ (Pre-state + Mutations) │ +// └──────────────┬──────────────┘ └──────────────┬──────────────┘ +// │ │ +// └────────────────┬─────────────────┘ +// │ +// ┌──────────────┴──────────────┐ +// │ newPrefetchStateReader │ (Async I/O) +// │ (Access List Hint driven) │ +// └──────────────┬──────────────┘ +// │ +// ┌──────────────┴──────────────┐ +// │ Base Reader │ (State Root) +// │ (State & Contract Code) │ +// └─────────────────────────────┘ + +// Note: The block producer, which is responsible for generating the block +// along with the block-level access list, does not maintain the internal +// hierarchy (e.g., PrefetchStateReader or ReaderWithBlockLevelAL). +// Instead, it directly utilizes the readerTracker, wrapped around the +// base reader, to construct the access list. + +type fetchTask struct { + addr common.Address + slots []common.Hash +} + +func (t *fetchTask) weight() int { return 1 + len(t.slots) } + +type prefetchStateReader struct { + StateReader + + tasks []*fetchTask + nThreads int + done chan struct{} + term chan struct{} + closeOnce sync.Once +} + +// nolint:unused +func newPrefetchStateReader(reader StateReader, accessList map[common.Address][]common.Hash, nThreads int) *prefetchStateReader { + tasks := make([]*fetchTask, 0, len(accessList)) + for addr, slots := range accessList { + tasks = append(tasks, &fetchTask{ + addr: addr, + slots: slots, + }) + } + return newPrefetchStateReaderInternal(reader, tasks, nThreads) +} + +func newPrefetchStateReaderInternal(reader StateReader, tasks []*fetchTask, nThreads int) *prefetchStateReader { + r := &prefetchStateReader{ + StateReader: reader, + tasks: tasks, + nThreads: nThreads, + done: make(chan struct{}), + term: make(chan struct{}), + } + go r.prefetch() + return r +} + +func (r *prefetchStateReader) Close() { + r.closeOnce.Do(func() { + close(r.term) + <-r.done + }) +} + +func (r *prefetchStateReader) Wait() error { + select { + case <-r.term: + return nil + case <-r.done: + return nil + } +} + +func (r *prefetchStateReader) prefetch() { + defer close(r.done) + + if len(r.tasks) == 0 { + return + } + var total int + for _, t := range r.tasks { + total += t.weight() + } + var ( + wg sync.WaitGroup + unit = (total + r.nThreads - 1) / r.nThreads // round-up the per worker unit + ) + for i := 0; i < r.nThreads; i++ { + start := i * unit + if start >= total { + break + } + limit := (i + 1) * unit + if i == r.nThreads-1 { + limit = total + } + // Schedule the worker for prefetching, the items on the range [start, limit) + // is exclusively assigned for this worker. + wg.Add(1) + go func(workerID, startW, endW int) { + r.process(startW, endW) + wg.Done() + }(i, start, limit) + } + wg.Wait() +} + +func (r *prefetchStateReader) process(start, limit int) { + var total = 0 + for _, t := range r.tasks { + tw := t.weight() + if total+tw > start { + s := 0 + if start > total { + s = start - total + } + l := tw + if limit < total+tw { + l = limit - total + } + for j := s; j < l; j++ { + select { + case <-r.term: + return + default: + if j == 0 { + r.StateReader.Account(t.addr) + } else { + r.StateReader.Storage(t.addr, t.slots[j-1]) + } + } + } + } + total += tw + if total >= limit { + return + } + } +} + +// ReaderWithBlockLevelAccessList provides state access that reflects the +// pre-transition state combined with the mutations made by transactions +// prior to TxIndex. +type ReaderWithBlockLevelAccessList struct { + Reader + AccessList *bal.ConstructionBlockAccessList + TxIndex int +} + +// NewReaderWithBlockLevelAccessList constructs a reader for accessing states +// with the mutations made by transactions prior to txIndex. +// +// The txIndex refers to the call frame as such: +// - 0 for pre‑execution system contract calls. +// - 1 … n for transactions (in block order). +// - n + 1 for post‑execution system contract calls. +func NewReaderWithBlockLevelAccessList(base Reader, accessList *bal.ConstructionBlockAccessList, txIndex int) *ReaderWithBlockLevelAccessList { + return &ReaderWithBlockLevelAccessList{ + Reader: base, + AccessList: accessList, + TxIndex: txIndex, + } +} + +// Account implements Reader, returning the account with the specific address. +func (r *ReaderWithBlockLevelAccessList) Account(addr common.Address) (*types.StateAccount, error) { + panic("implement me") +} + +// Storage implements Reader, returning the storage slot with the specific +// address and slot key. +func (r *ReaderWithBlockLevelAccessList) Storage(addr common.Address, slot common.Hash) (common.Hash, error) { + panic("implement me") +} + +// Has implements Reader, returning the flag indicating whether the contract +// code with specified address and hash exists or not. +func (r *ReaderWithBlockLevelAccessList) Has(addr common.Address, codeHash common.Hash) bool { + panic("implement me") +} + +// Code implements Reader, returning the contract code with specified address +// and hash. +func (r *ReaderWithBlockLevelAccessList) Code(addr common.Address, codeHash common.Hash) ([]byte, error) { + panic("implement me") +} + +// CodeSize implements Reader, returning the contract code size with specified +// address and hash. +func (r *ReaderWithBlockLevelAccessList) CodeSize(addr common.Address, codeHash common.Hash) (int, error) { + panic("implement me") +} diff --git a/core/state/reader_eip_7928_test.go b/core/state/reader_eip_7928_test.go new file mode 100644 index 000000000000..b2d432258c39 --- /dev/null +++ b/core/state/reader_eip_7928_test.go @@ -0,0 +1,145 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +import ( + "fmt" + "math/rand" + "sync" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/testrand" +) + +type countingStateReader struct { + accounts map[common.Address]int + storages map[common.Address]map[common.Hash]int + lock sync.Mutex +} + +func newRefStateReader() *countingStateReader { + return &countingStateReader{ + accounts: make(map[common.Address]int), + storages: make(map[common.Address]map[common.Hash]int), + } +} + +func (r *countingStateReader) validate(total int) error { + var sum int + for addr, n := range r.accounts { + if n != 1 { + return fmt.Errorf("duplicated account access: %x-%d", addr, n) + } + sum += 1 + + slots, exists := r.storages[addr] + if !exists { + continue + } + for key, n := range slots { + if n != 1 { + return fmt.Errorf("duplicated storage access: %x-%x-%d", addr, key, n) + } + sum += 1 + } + } + for addr := range r.storages { + _, exists := r.accounts[addr] + if !exists { + return fmt.Errorf("dangling storage access: %x", addr) + } + } + if sum != total { + return fmt.Errorf("unexpected number of access, want: %d, got: %d", total, sum) + } + return nil +} + +func (r *countingStateReader) Account(addr common.Address) (*types.StateAccount, error) { + r.lock.Lock() + defer r.lock.Unlock() + + r.accounts[addr] += 1 + return nil, nil +} +func (r *countingStateReader) Storage(addr common.Address, slot common.Hash) (common.Hash, error) { + r.lock.Lock() + defer r.lock.Unlock() + + slots, exists := r.storages[addr] + if !exists { + slots = make(map[common.Hash]int) + r.storages[addr] = slots + } + slots[slot] += 1 + return common.Hash{}, nil +} + +func makeFetchTasks(n int) ([]*fetchTask, int) { + var ( + total int + tasks []*fetchTask + ) + for i := 0; i < n; i++ { + var slots []common.Hash + if rand.Intn(3) != 0 { + for j := 0; j < rand.Intn(100); j++ { + slots = append(slots, testrand.Hash()) + } + } + tasks = append(tasks, &fetchTask{ + addr: testrand.Address(), + slots: slots, + }) + total += len(slots) + 1 + } + return tasks, total +} + +func TestPrefetchReader(t *testing.T) { + type suite struct { + tasks []*fetchTask + threads int + total int + } + var suites []suite + for i := 0; i < 100; i++ { + tasks, total := makeFetchTasks(100) + suites = append(suites, suite{ + tasks: tasks, + threads: rand.Intn(30) + 1, + total: total, + }) + } + // num(tasks) < num(threads) + tasks, total := makeFetchTasks(1) + suites = append(suites, suite{ + tasks: tasks, + threads: 100, + total: total, + }) + for _, s := range suites { + r := newRefStateReader() + pr := newPrefetchStateReaderInternal(r, s.tasks, s.threads) + pr.Wait() + if err := r.validate(s.total); err != nil { + t.Fatal(err) + } + } +} diff --git a/core/state/reader_stater.go b/core/state/reader_stater.go new file mode 100644 index 000000000000..529427595389 --- /dev/null +++ b/core/state/reader_stater.go @@ -0,0 +1,82 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package state + +// ContractCodeReaderStats aggregates statistics for the contract code reader. +type ContractCodeReaderStats struct { + CacheHit int64 // Number of cache hits + CacheMiss int64 // Number of cache misses + CacheHitBytes int64 // Total bytes served from cache + CacheMissBytes int64 // Total bytes read on cache misses +} + +// HitRate returns the cache hit rate in percentage. +func (s ContractCodeReaderStats) HitRate() float64 { + total := s.CacheHit + s.CacheMiss + if total == 0 { + return 0 + } + return float64(s.CacheHit) / float64(total) * 100 +} + +// ContractCodeReaderStater wraps the method to retrieve the statistics of +// contract code reader. +type ContractCodeReaderStater interface { + GetCodeStats() ContractCodeReaderStats +} + +// StateReaderStats aggregates statistics for the state reader. +type StateReaderStats struct { + AccountCacheHit int64 // Number of account cache hits + AccountCacheMiss int64 // Number of account cache misses + StorageCacheHit int64 // Number of storage cache hits + StorageCacheMiss int64 // Number of storage cache misses +} + +// AccountCacheHitRate returns the cache hit rate of account requests in percentage. +func (s StateReaderStats) AccountCacheHitRate() float64 { + total := s.AccountCacheHit + s.AccountCacheMiss + if total == 0 { + return 0 + } + return float64(s.AccountCacheHit) / float64(total) * 100 +} + +// StorageCacheHitRate returns the cache hit rate of storage requests in percentage. +func (s StateReaderStats) StorageCacheHitRate() float64 { + total := s.StorageCacheHit + s.StorageCacheMiss + if total == 0 { + return 0 + } + return float64(s.StorageCacheHit) / float64(total) * 100 +} + +// StateReaderStater wraps the method to retrieve the statistics of state reader. +type StateReaderStater interface { + GetStateStats() StateReaderStats +} + +// ReaderStats wraps the statistics of reader. +type ReaderStats struct { + CodeStats ContractCodeReaderStats + StateStats StateReaderStats +} + +// ReaderStater defines the capability to retrieve aggregated statistics. +type ReaderStater interface { + GetStats() ReaderStats +} diff --git a/core/state/snapshot/difflayer.go b/core/state/snapshot/difflayer.go index 28957051d446..1286ded7e1a5 100644 --- a/core/state/snapshot/difflayer.go +++ b/core/state/snapshot/difflayer.go @@ -465,6 +465,6 @@ func (dl *diffLayer) StorageList(accountHash common.Hash) []common.Hash { storageList := slices.SortedFunc(maps.Keys(dl.storageData[accountHash]), common.Hash.Cmp) dl.storageList[accountHash] = storageList - dl.memory += uint64(len(dl.storageList)*common.HashLength + common.HashLength) + dl.memory += uint64(len(storageList)*common.HashLength + common.HashLength) return storageList } diff --git a/core/state/snapshot/difflayer_test.go b/core/state/snapshot/difflayer_test.go index 2c868b30106a..90a265645d9b 100644 --- a/core/state/snapshot/difflayer_test.go +++ b/core/state/snapshot/difflayer_test.go @@ -198,6 +198,39 @@ func TestInsertAndMerge(t *testing.T) { } } +// TestStorageListMemoryAccounting ensures that StorageList increases dl.memory +// proportionally to the number of storage slots in the requested account and +// does not change memory usage on repeated calls for the same account. +func TestStorageListMemoryAccounting(t *testing.T) { + parent := newDiffLayer(emptyLayer(), common.Hash{}, nil, nil) + account := common.HexToHash("0x01") + + slots := make(map[common.Hash][]byte) + for i := 0; i < 3; i++ { + slots[randomHash()] = []byte{0x01} + } + storage := map[common.Hash]map[common.Hash][]byte{ + account: slots, + } + dl := newDiffLayer(parent, common.Hash{}, nil, storage) + + before := dl.memory + list := dl.StorageList(account) + if have, want := len(list), len(slots); have != want { + t.Fatalf("StorageList length mismatch: have %d, want %d", have, want) + } + expectedDelta := uint64(len(list)*common.HashLength + common.HashLength) + if have, want := dl.memory-before, expectedDelta; have != want { + t.Fatalf("StorageList memory delta mismatch: have %d, want %d", have, want) + } + + before = dl.memory + _ = dl.StorageList(account) + if dl.memory != before { + t.Fatalf("StorageList changed memory on cached call: have %d, want %d", dl.memory, before) + } +} + func emptyLayer() *diskLayer { return &diskLayer{ diskdb: memorydb.New(), diff --git a/core/state/snapshot/generate_test.go b/core/state/snapshot/generate_test.go index 44886300958e..7fb4c152dca9 100644 --- a/core/state/snapshot/generate_test.go +++ b/core/state/snapshot/generate_test.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" @@ -34,16 +35,10 @@ import ( "github.com/ethereum/go-ethereum/triedb/hashdb" "github.com/ethereum/go-ethereum/triedb/pathdb" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) func hashData(input []byte) common.Hash { - var hasher = sha3.NewLegacyKeccak256() - var hash common.Hash - hasher.Reset() - hasher.Write(input) - hasher.Sum(hash[:0]) - return hash + return crypto.Keccak256Hash(input) } // Tests that snapshot generation from an empty database. diff --git a/core/state/snapshot/iterator_test.go b/core/state/snapshot/iterator_test.go index dd6c4cf9688d..8e473aa312a8 100644 --- a/core/state/snapshot/iterator_test.go +++ b/core/state/snapshot/iterator_test.go @@ -342,7 +342,7 @@ func TestAccountIteratorTraversalValues(t *testing.T) { if i%8 == 0 { e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i) } - if i > 50 || i < 85 { + if i > 50 && i < 85 { f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i) } if i%64 == 0 { @@ -441,7 +441,7 @@ func TestStorageIteratorTraversalValues(t *testing.T) { if i%8 == 0 { e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i) } - if i > 50 || i < 85 { + if i > 50 && i < 85 { f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i) } if i%64 == 0 { diff --git a/core/state/state_object.go b/core/state/state_object.go index 8f2f323327dd..ce456e7668f6 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -27,8 +27,8 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" + "github.com/ethereum/go-ethereum/trie/bintrie" "github.com/ethereum/go-ethereum/trie/transitiontrie" "github.com/ethereum/go-ethereum/trie/trienode" "github.com/holiman/uint256" @@ -47,11 +47,11 @@ func (s Storage) Copy() Storage { // - Account values as well as storages can be accessed and modified through the object. // - Finally, call commit to return the changes of storage trie and update account data. type stateObject struct { - db *StateDB - address common.Address // address of ethereum account - addrHash common.Hash // hash of ethereum address of the account - origin *types.StateAccount // Account original data without any change applied, nil means it was not existent - data types.StateAccount // Account data with all mutations applied in the scope of block + db *StateDB + address common.Address // address of ethereum account + addressHash *common.Hash // hash of ethereum address of the account + origin *types.StateAccount // Account original data without any change applied, nil means it was not existent + data types.StateAccount // Account data with all mutations applied in the scope of block // Write caches. trie Trie // storage trie, which becomes non-nil on first access @@ -101,7 +101,6 @@ func newObject(db *StateDB, address common.Address, acct *types.StateAccount) *s return &stateObject{ db: db, address: address, - addrHash: crypto.Keccak256Hash(address[:]), origin: origin, data: *acct, originStorage: make(Storage), @@ -111,6 +110,14 @@ func newObject(db *StateDB, address common.Address, acct *types.StateAccount) *s } } +func (s *stateObject) addrHash() common.Hash { + if s.addressHash == nil { + h := crypto.Keccak256Hash(s.address[:]) + s.addressHash = &h + } + return *s.addressHash +} + func (s *stateObject) markSelfdestructed() { s.selfDestructed = true } @@ -146,17 +153,20 @@ func (s *stateObject) getTrie() (Trie, error) { func (s *stateObject) getPrefetchedTrie() Trie { // If there's nothing to meaningfully return, let the user figure it out by // pulling the trie from disk. - if (s.data.Root == types.EmptyRootHash && !s.db.db.TrieDB().IsVerkle()) || s.db.prefetcher == nil { + if (s.data.Root == types.EmptyRootHash && s.db.db.Type().Is(TypeMPT)) || s.db.prefetcher == nil { return nil } // Attempt to retrieve the trie from the prefetcher - return s.db.prefetcher.trie(s.addrHash, s.data.Root) + return s.db.prefetcher.trie(s.addrHash(), s.data.Root) } // GetState retrieves a value associated with the given storage key. func (s *stateObject) GetState(key common.Hash) common.Hash { - value, _ := s.getState(key) - return value + value, dirty := s.dirtyStorage[key] + if dirty { + return value + } + return s.GetCommittedState(key) } // getState retrieves a value associated with the given storage key, along with @@ -173,6 +183,10 @@ func (s *stateObject) getState(key common.Hash) (common.Hash, common.Hash) { // GetCommittedState retrieves the value associated with the specific key // without any mutations caused in the current execution. func (s *stateObject) GetCommittedState(key common.Hash) common.Hash { + // Record slot access regardless of whether the storage slot exists. + if s.db.stateAccessList != nil { + s.db.stateAccessList.StorageRead(s.address, key) + } // If we have a pending write or clean cached, return that if value, pending := s.pendingStorage[key]; pending { return value @@ -202,7 +216,7 @@ func (s *stateObject) GetCommittedState(key common.Hash) common.Hash { // Schedule the resolved storage slots for prefetching if it's enabled. if s.db.prefetcher != nil && s.data.Root != types.EmptyRootHash { - if err = s.db.prefetcher.prefetch(s.addrHash, s.origin.Root, s.address, nil, []common.Hash{key}, true); err != nil { + if err = s.db.prefetcher.prefetch(s.addrHash(), s.origin.Root, s.address, nil, []common.Hash{key}, true); err != nil { log.Error("Failed to prefetch storage slot", "addr", s.address, "key", key, "err", err) } } @@ -261,9 +275,16 @@ func (s *stateObject) finalise() { // map as the dirty slot might have been committed already (before the // byzantium fork) and entry is necessary to modify the value back. s.pendingStorage[key] = value + + // Aggregate storage writes into the block-level access list. + // All slots in the dirtyStorage set must have post-transaction + // values that differ from their pre-transaction values. + if s.db.stateAccessList != nil { + s.db.stateAccessList.StorageWrite(s.db.blockAccessIndex, s.address, key, value) + } } if s.db.prefetcher != nil && len(slotsToPrefetch) > 0 && s.data.Root != types.EmptyRootHash { - if err := s.db.prefetcher.prefetch(s.addrHash, s.data.Root, s.address, nil, slotsToPrefetch, false); err != nil { + if err := s.db.prefetcher.prefetch(s.addrHash(), s.data.Root, s.address, nil, slotsToPrefetch, false); err != nil { log.Error("Failed to prefetch slots", "addr", s.address, "slots", len(slotsToPrefetch), "err", err) } } @@ -358,7 +379,7 @@ func (s *stateObject) updateTrie() (Trie, error) { s.db.StorageDeleted.Add(1) } if s.db.prefetcher != nil { - s.db.prefetcher.used(s.addrHash, s.data.Root, nil, used) + s.db.prefetcher.used(s.addrHash(), s.data.Root, nil, used) } s.uncommittedStorage = make(Storage) // empties the commit markers return tr, nil @@ -377,17 +398,8 @@ func (s *stateObject) updateRoot() { } // commitStorage overwrites the clean storage with the storage changes and -// fulfills the storage diffs into the given accountUpdate struct. -func (s *stateObject) commitStorage(op *accountUpdate) { - var ( - encode = func(val common.Hash) []byte { - if val == (common.Hash{}) { - return nil - } - blob, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(val[:])) - return blob - } - ) +// fulfills the storage diffs into the given AccountUpdate struct. +func (s *stateObject) commitStorage(op *AccountUpdate) { for key, val := range s.pendingStorage { // Skip the noop storage changes, it might be possible the value // of tracked slot is same in originStorage and pendingStorage @@ -397,20 +409,20 @@ func (s *stateObject) commitStorage(op *accountUpdate) { continue } hash := crypto.Keccak256Hash(key[:]) - if op.storages == nil { - op.storages = make(map[common.Hash][]byte) + if op.Storages == nil { + op.Storages = make(map[common.Hash]common.Hash) } - op.storages[hash] = encode(val) + op.Storages[hash] = val - if op.storagesOriginByKey == nil { - op.storagesOriginByKey = make(map[common.Hash][]byte) + if op.StoragesOriginByKey == nil { + op.StoragesOriginByKey = make(map[common.Hash]common.Hash) } - if op.storagesOriginByHash == nil { - op.storagesOriginByHash = make(map[common.Hash][]byte) + if op.StoragesOriginByHash == nil { + op.StoragesOriginByHash = make(map[common.Hash]common.Hash) } - origin := encode(s.originStorage[key]) - op.storagesOriginByKey[key] = origin - op.storagesOriginByHash[hash] = origin + origin := s.originStorage[key] + op.StoragesOriginByKey[key] = origin + op.StoragesOriginByHash[hash] = origin // Overwrite the clean value of storage slots s.originStorage[key] = val @@ -423,32 +435,47 @@ func (s *stateObject) commitStorage(op *accountUpdate) { // // Note, commit may run concurrently across all the state objects. Do not assume // thread-safe access to the statedb. -func (s *stateObject) commit() (*accountUpdate, *trienode.NodeSet, error) { - // commit the account metadata changes - op := &accountUpdate{ - address: s.address, - data: types.SlimAccountRLP(s.data), - } - if s.origin != nil { - op.origin = types.SlimAccountRLP(*s.origin) +func (s *stateObject) commit() (*AccountUpdate, *trienode.NodeSet, error) { + // commit the account metadata changes, the data must be deep-copied + // to prevent accidental mutations later on (in practice the stateDB + // won't be modified after commit). The origin is safe to use directly. + op := &AccountUpdate{ + Address: s.address, + Data: s.data.Copy(), + Origin: s.origin, } // commit the contract code if it's modified if s.dirtyCode { - op.code = &contractCode{ - hash: common.BytesToHash(s.CodeHash()), - blob: s.code, + op.Code = &ContractCode{ + Hash: common.BytesToHash(s.CodeHash()), + Blob: s.code, } s.dirtyCode = false // reset the dirty flag + + if s.origin == nil { + op.Code.OriginHash = types.EmptyCodeHash + } else { + op.Code.OriginHash = common.BytesToHash(s.origin.CodeHash) + } } // Commit storage changes and the associated storage trie s.commitStorage(op) - if len(op.storages) == 0 { + if len(op.Storages) == 0 { // nothing changed, don't bother to commit the trie s.origin = s.data.Copy() return op, nil, nil } - root, nodes := s.trie.Commit(false) - s.data.Root = root + // In Verkle/binary trie mode, all state objects share one unified trie. + // The main account trie commit in stateDB.commit() already calls + // CollectNodes on this trie, so calling Commit here again would + // redundantly traverse and serialize the entire tree per dirty account. + if s.db.GetTrie().IsUBT() { + s.origin = s.data.Copy() + return op, nil, nil + } + // The storage trie root is omitted, as it has already been updated in the + // previous updateRoot step. + _, nodes := s.trie.Commit(false) s.origin = s.data.Copy() return op, nodes, nil } @@ -484,7 +511,7 @@ func (s *stateObject) deepCopy(db *StateDB) *stateObject { obj := &stateObject{ db: db, address: s.address, - addrHash: s.addrHash, + addressHash: nil, origin: s.origin, data: s.data, code: s.code, @@ -498,8 +525,8 @@ func (s *stateObject) deepCopy(db *StateDB) *stateObject { } switch s.trie.(type) { - case *trie.VerkleTrie: - // Verkle uses only one tree, and the copy has already been + case *bintrie.BinaryTrie: + // UBT uses only one tree, and the copy has already been // made in mustCopyTrie. obj.trie = db.trie case *transitiontrie.TransitionTrie: @@ -531,10 +558,13 @@ func (s *stateObject) Code() []byte { if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) { return nil } - code, err := s.db.reader.Code(s.address, common.BytesToHash(s.CodeHash())) - if err != nil { - s.db.setError(fmt.Errorf("can't load code hash %x: %v", s.CodeHash(), err)) - } + defer func(start time.Time) { + s.db.CodeLoaded += 1 + s.db.CodeReads += time.Since(start) + s.db.CodeLoadBytes += len(s.code) + }(time.Now()) + + code := s.db.reader.Code(s.address, common.BytesToHash(s.CodeHash())) if len(code) == 0 { s.db.setError(fmt.Errorf("code is not found %x", s.CodeHash())) } @@ -552,10 +582,12 @@ func (s *stateObject) CodeSize() int { if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) { return 0 } - size, err := s.db.reader.CodeSize(s.address, common.BytesToHash(s.CodeHash())) - if err != nil { - s.db.setError(fmt.Errorf("can't load code size %x: %v", s.CodeHash(), err)) - } + defer func(start time.Time) { + s.db.CodeLoaded += 1 + s.db.CodeReads += time.Since(start) + }(time.Now()) + + size := s.db.reader.CodeSize(s.address, common.BytesToHash(s.CodeHash())) if size == 0 { s.db.setError(fmt.Errorf("code is not found %x", s.CodeHash())) } diff --git a/core/state/state_sizer.go b/core/state/state_sizer.go index 3faa75090667..72c93ff21413 100644 --- a/core/state/state_sizer.go +++ b/core/state/state_sizer.go @@ -37,7 +37,7 @@ import ( ) const ( - statEvictThreshold = 128 // the depth of statistic to be preserved + statEvictThresholdDefault = 10000 // the default depth of statistic to be preserved ) // Database key scheme for states. @@ -69,6 +69,7 @@ var ( type SizeStats struct { StateRoot common.Hash // State root hash at the time of measurement BlockNumber uint64 // Associated block number at the time of measurement + BlockHash common.Hash // Associated block hash at the time of measurement Accounts int64 // Total number of accounts in the state AccountBytes int64 // Total storage size used by all account data (in bytes) @@ -110,6 +111,7 @@ func (s SizeStats) publish() { func (s SizeStats) add(diff SizeStats) SizeStats { s.StateRoot = diff.StateRoot s.BlockNumber = diff.BlockNumber + s.BlockHash = diff.BlockHash s.Accounts += diff.Accounts s.AccountBytes += diff.AccountBytes @@ -125,16 +127,18 @@ func (s SizeStats) add(diff SizeStats) SizeStats { } // calSizeStats measures the state size changes of the provided state update. -func calSizeStats(update *stateUpdate) (SizeStats, error) { +func calSizeStats(update *StateUpdate) (SizeStats, error) { stats := SizeStats{ - BlockNumber: update.blockNumber, - StateRoot: update.root, + BlockNumber: update.BlockNumber, + BlockHash: update.BlockHash, + StateRoot: update.Root, } + accounts, accountOrigin, storages, storageOrigin := update.EncodeMPTState() // Measure the account changes - for addr, oldValue := range update.accountsOrigin { + for addr, oldValue := range accountOrigin { addrHash := crypto.Keccak256Hash(addr.Bytes()) - newValue, exists := update.accounts[addrHash] + newValue, exists := accounts[addrHash] if !exists { return SizeStats{}, fmt.Errorf("account %x not found", addr) } @@ -156,9 +160,9 @@ func calSizeStats(update *stateUpdate) (SizeStats, error) { } // Measure storage changes - for addr, slots := range update.storagesOrigin { + for addr, slots := range storageOrigin { addrHash := crypto.Keccak256Hash(addr.Bytes()) - subset, exists := update.storages[addrHash] + subset, exists := storages[addrHash] if !exists { return SizeStats{}, fmt.Errorf("storage %x not found", addr) } @@ -167,7 +171,7 @@ func calSizeStats(update *stateUpdate) (SizeStats, error) { exists bool newValue []byte ) - if update.rawStorageKey { + if update.StorageKeyType == StorageKeyPlain { newValue, exists = subset[crypto.Keccak256Hash(key.Bytes())] } else { newValue, exists = subset[key] @@ -194,7 +198,7 @@ func calSizeStats(update *stateUpdate) (SizeStats, error) { } // Measure trienode changes - for owner, subset := range update.nodes.Sets { + for owner, subset := range update.Nodes.Sets { var ( keyPrefix int64 isAccount = owner == (common.Hash{}) @@ -244,13 +248,13 @@ func calSizeStats(update *stateUpdate) (SizeStats, error) { } codeExists := make(map[common.Hash]struct{}) - for _, code := range update.codes { - if _, ok := codeExists[code.hash]; ok || code.exists { + for _, code := range update.Codes { + if _, ok := codeExists[code.Hash]; ok || code.Duplicate { continue } stats.ContractCodes += 1 - stats.ContractCodeBytes += codeKeySize + int64(len(code.blob)) - codeExists[code.hash] = struct{}{} + stats.ContractCodeBytes += codeKeySize + int64(len(code.Blob)) + codeExists[code.Hash] = struct{}{} } return stats, nil } @@ -267,22 +271,27 @@ type SizeTracker struct { triedb *triedb.Database abort chan struct{} aborted chan struct{} - updateCh chan *stateUpdate + updateCh chan *StateUpdate queryCh chan *stateSizeQuery + depth uint64 // the depth of statistics to be preserved } // NewSizeTracker creates a new state size tracker and starts it automatically -func NewSizeTracker(db ethdb.KeyValueStore, triedb *triedb.Database) (*SizeTracker, error) { +func NewSizeTracker(db ethdb.KeyValueStore, triedb *triedb.Database, depth uint64) (*SizeTracker, error) { if triedb.Scheme() != rawdb.PathScheme { return nil, errors.New("state size tracker is not compatible with hash mode") } + if depth == 0 { + depth = statEvictThresholdDefault + } t := &SizeTracker{ db: db, triedb: triedb, abort: make(chan struct{}), aborted: make(chan struct{}), - updateCh: make(chan *stateUpdate), + updateCh: make(chan *StateUpdate), queryCh: make(chan *stateSizeQuery), + depth: depth, } go t.run() return t, nil @@ -328,9 +337,9 @@ func (t *SizeTracker) run() { for { select { case u := <-t.updateCh: - base, found := stats[u.originRoot] + base, found := stats[u.OriginRoot] if !found { - log.Debug("Ignored the state size without parent", "parent", u.originRoot, "root", u.root, "number", u.blockNumber) + log.Debug("Ignored the state size without parent", "parent", u.OriginRoot, "root", u.Root, "number", u.BlockNumber) continue } diff, err := calSizeStats(u) @@ -338,15 +347,32 @@ func (t *SizeTracker) run() { continue } stat := base.add(diff) - stats[u.root] = stat - last = u.root + stats[u.Root] = stat + last = u.Root // Publish statistics to metric system stat.publish() + // Log state size metrics for external monitoring (e.g., xatu-sentry fallback) + log.Info("State size updated", + "blockNumber", stat.BlockNumber, + "blockHash", stat.BlockHash, + "stateRoot", stat.StateRoot, + "accounts", stat.Accounts, + "accountBytes", stat.AccountBytes, + "storages", stat.Storages, + "storageBytes", stat.StorageBytes, + "accountTrienodes", stat.AccountTrienodes, + "accountTrienodeBytes", stat.AccountTrienodeBytes, + "storageTrienodes", stat.StorageTrienodes, + "storageTrienodeBytes", stat.StorageTrienodeBytes, + "contractCodes", stat.ContractCodes, + "contractCodeBytes", stat.ContractCodeBytes, + ) + // Evict the stale statistics - heap.Push(&h, stats[u.root]) - for u.blockNumber-h[0].BlockNumber > statEvictThreshold { + heap.Push(&h, stats[u.Root]) + for len(h) > 0 && u.BlockNumber-h[0].BlockNumber > t.depth { delete(stats, h[0].StateRoot) heap.Pop(&h) } @@ -402,7 +428,7 @@ wait: } var ( - updates = make(map[common.Hash]*stateUpdate) + updates = make(map[common.Hash]*StateUpdate) children = make(map[common.Hash][]common.Hash) done chan buildResult ) @@ -410,9 +436,9 @@ wait: for { select { case u := <-t.updateCh: - updates[u.root] = u - children[u.originRoot] = append(children[u.originRoot], u.root) - log.Debug("Received state update", "root", u.root, "blockNumber", u.blockNumber) + updates[u.Root] = u + children[u.OriginRoot] = append(children[u.OriginRoot], u.Root) + log.Debug("Received state update", "root", u.Root, "blockNumber", u.BlockNumber) case r := <-t.queryCh: r.err = errors.New("state size is not initialized yet") @@ -432,8 +458,8 @@ wait: continue } done = make(chan buildResult) - go t.build(entry.root, entry.blockNumber, done) - log.Info("Measuring persistent state size", "root", root.Hex(), "number", entry.blockNumber) + go t.build(entry.Root, entry.BlockNumber, done) + log.Info("Measuring persistent state size", "root", root.Hex(), "number", entry.BlockNumber) case result := <-done: if result.err != nil { @@ -646,8 +672,8 @@ func (t *SizeTracker) iterateTableParallel(closed chan struct{}, prefix []byte, // Notify is an async method used to send the state update to the size tracker. // It ignores empty updates (where no state changes occurred). // If the channel is full, it drops the update to avoid blocking. -func (t *SizeTracker) Notify(update *stateUpdate) { - if update == nil || update.empty() { +func (t *SizeTracker) Notify(update *StateUpdate) { + if update == nil || update.Empty() { return } select { diff --git a/core/state/state_sizer_test.go b/core/state/state_sizer_test.go index b3203afd7449..8f2667d23316 100644 --- a/core/state/state_sizer_test.go +++ b/core/state/state_sizer_test.go @@ -128,7 +128,7 @@ func TestSizeTracker(t *testing.T) { baseline := baselineResult.stat // Now start the tracker and notify it of updates that happen AFTER the baseline - tracker, err := NewSizeTracker(db, tdb) + tracker, err := NewSizeTracker(db, tdb, 128) if err != nil { t.Fatalf("Failed to create size tracker: %v", err) } @@ -160,7 +160,7 @@ func TestSizeTracker(t *testing.T) { } tracker.Notify(ret) - if err := tdb.Commit(ret.root, false); err != nil { + if err := tdb.Commit(ret.Root, false); err != nil { t.Fatalf("Failed to commit trie at block %d: %v", blockNum, err) } @@ -169,7 +169,7 @@ func TestSizeTracker(t *testing.T) { t.Fatalf("Failed to calculate size stats for block %d: %v", blockNum, err) } trackedUpdates = append(trackedUpdates, diff) - currentRoot = ret.root + currentRoot = ret.Root } finalRoot := rawdb.ReadSnapshotRoot(db) diff --git a/core/state/statedb.go b/core/state/statedb.go index 8d8ab00e483e..1c49d460206d 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -18,6 +18,7 @@ package state import ( + "bytes" "errors" "fmt" "maps" @@ -28,17 +29,15 @@ import ( "time" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/rawdb" - "github.com/ethereum/go-ethereum/core/state/snapshot" "github.com/ethereum/go-ethereum/core/stateless" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/types/bal" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie/trienode" - "github.com/ethereum/go-ethereum/trie/utils" "github.com/holiman/uint256" "golang.org/x/sync/errgroup" ) @@ -129,6 +128,12 @@ type StateDB struct { accessList *accessList accessEvents *AccessEvents + // Per-transaction state access footprint for EIP-7928 + stateAccessList *bal.ConstructionBlockAccessList + + // Block access index (0 for pre-execution, 1..n for transactions, n+1 for post-execution) + blockAccessIndex uint32 + // Transient storage transientStorage transientStorage @@ -137,8 +142,7 @@ type StateDB struct { journal *journal // State witness if cross validation is needed - witness *stateless.Witness - witnessStats *stateless.WitnessStats + witness *stateless.Witness // Measurements gathered during execution for debugging purposes AccountReads time.Duration @@ -149,8 +153,8 @@ type StateDB struct { StorageReads time.Duration StorageUpdates time.Duration StorageCommits time.Duration - SnapshotCommits time.Duration - TrieDBCommits time.Duration + DatabaseCommits time.Duration + CodeReads time.Duration AccountLoaded int // Number of accounts retrieved from the database during the state transition AccountUpdated int // Number of accounts updated during the state transition @@ -158,6 +162,15 @@ type StateDB struct { StorageLoaded int // Number of storage slots retrieved from the database during the state transition StorageUpdated atomic.Int64 // Number of storage slots updated during the state transition StorageDeleted atomic.Int64 // Number of storage slots deleted during the state transition + + // CodeLoadBytes is the total number of bytes read from contract code. + // This value may be smaller than the actual number of bytes read, since + // some APIs (e.g. CodeSize) may load the entire code from either the + // cache or the database when the size is not available in the cache. + CodeLoaded int // Number of contract code loaded during the state transition + CodeLoadBytes int // Total bytes of resolved code + CodeUpdated int // Number of contracts with code changes that persisted + CodeUpdateBytes int // Total bytes of persisted code written } // New creates a new state from a given trie. @@ -185,8 +198,8 @@ func NewWithReader(root common.Hash, db Database, reader Reader) (*StateDB, erro accessList: newAccessList(), transientStorage: newTransientStorage(), } - if db.TrieDB().IsVerkle() { - sdb.accessEvents = NewAccessEvents(db.PointCache()) + if db.Type().Is(TypeUBT) { + sdb.accessEvents = NewAccessEvents() } return sdb, nil } @@ -194,13 +207,12 @@ func NewWithReader(root common.Hash, db Database, reader Reader) (*StateDB, erro // StartPrefetcher initializes a new trie prefetcher to pull in nodes from the // state trie concurrently while the state is mutated so that when we reach the // commit phase, most of the needed data is already hot. -func (s *StateDB) StartPrefetcher(namespace string, witness *stateless.Witness, witnessStats *stateless.WitnessStats) { +func (s *StateDB) StartPrefetcher(namespace string, witness *stateless.Witness) { // Terminate any previously running prefetcher s.StopPrefetcher() // Enable witness collection if requested s.witness = witness - s.witnessStats = witnessStats // With the switch to the Proof-of-Stake consensus algorithm, block production // rewards are now handled at the consensus layer. Consequently, a block may @@ -313,6 +325,11 @@ func (s *StateDB) Empty(addr common.Address) bool { return so == nil || so.empty() } +// Touch accesses the specific account without returning anything. +func (s *StateDB) Touch(addr common.Address) { + s.getStateObject(addr) +} + // GetBalance retrieves the balance from the given address or 0 if object not found func (s *StateDB) GetBalance(addr common.Address) *uint256.Int { stateObject := s.getStateObject(addr) @@ -334,6 +351,9 @@ func (s *StateDB) GetNonce(addr common.Address) uint64 { // GetStorageRoot retrieves the storage root from the given address or empty // if object not found. +// +// Note: the storage root returned corresponds to the trie since last Intermediate +// operation, some recent in-memory changes are excluded. func (s *StateDB) GetStorageRoot(addr common.Address) common.Hash { stateObject := s.getStateObject(addr) if stateObject != nil { @@ -508,21 +528,13 @@ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common } // SelfDestruct marks the given account as selfdestructed. -// This clears the account balance. // // The account's state object is still available until the state is committed, // getStateObject will return a non-nil account after SelfDestruct. -func (s *StateDB) SelfDestruct(addr common.Address) uint256.Int { +func (s *StateDB) SelfDestruct(addr common.Address) { stateObject := s.getStateObject(addr) - var prevBalance uint256.Int if stateObject == nil { - return prevBalance - } - prevBalance = *(stateObject.Balance()) - // Regardless of whether it is already destructed or not, we do have to - // journal the balance-change, if we set it to zero here. - if !stateObject.Balance().IsZero() { - stateObject.SetBalance(new(uint256.Int)) + return } // If it is already marked as self-destructed, we do not need to add it // for journalling a second time. @@ -530,18 +542,6 @@ func (s *StateDB) SelfDestruct(addr common.Address) uint256.Int { s.journal.destruct(addr) stateObject.markSelfdestructed() } - return prevBalance -} - -func (s *StateDB) SelfDestruct6780(addr common.Address) (uint256.Int, bool) { - stateObject := s.getStateObject(addr) - if stateObject == nil { - return uint256.Int{}, false - } - if stateObject.newContract { - return s.SelfDestruct(addr), true - } - return *(stateObject.Balance()), false } // SetTransientState sets transient storage for a given account. It @@ -592,6 +592,10 @@ func (s *StateDB) deleteStateObject(addr common.Address) { // getStateObject retrieves a state object given by the address, returning nil if // the object is not found or was deleted in this execution context. func (s *StateDB) getStateObject(addr common.Address) *stateObject { + // Record state access regardless of whether the account exists. + if s.stateAccessList != nil { + s.stateAccessList.AccountRead(addr) + } // Prefer live objects if any is available if obj := s.stateObjects[addr]; obj != nil { return obj @@ -669,6 +673,16 @@ func (s *StateDB) CreateContract(addr common.Address) { } } +// IsNewContract reports whether the contract at the given address was deployed +// during the current transaction. +func (s *StateDB) IsNewContract(addr common.Address) bool { + obj := s.getStateObject(addr) + if obj == nil { + return false + } + return obj.newContract +} + // Copy creates a deep, independent copy of the state. // Snapshots of the copied state cannot be applied to the copy. func (s *StateDB) Copy() *StateDB { @@ -684,6 +698,7 @@ func (s *StateDB) Copy() *StateDB { refund: s.refund, thash: s.thash, txIndex: s.txIndex, + blockAccessIndex: s.blockAccessIndex, logs: make(map[common.Hash][]*types.Log, len(s.logs)), logSize: s.logSize, preimages: maps.Clone(s.preimages), @@ -728,6 +743,9 @@ func (s *StateDB) Copy() *StateDB { } state.logs[hash] = cpy } + if s.stateAccessList != nil { + state.stateAccessList = s.stateAccessList.Copy() + } return state } @@ -746,32 +764,110 @@ func (s *StateDB) GetRefund() uint64 { return s.refund } +type removedAccountWithBalance struct { + address common.Address + balance *uint256.Int +} + +// LogsForBurnAccounts returns the eth burn logs for accounts scheduled for +// removal which still have positive balance. The purpose of this function is +// to handle a corner case of EIP-7708 where a self-destructed account might +// still receive funds between sending/burning its previous balance and actual +// removal. In this case the burning of these remaining balances still need to +// be logged. +// Specification EIP-7708: https://eips.ethereum.org/EIPS/eip-7708 +// +// This function should only be invoked at the transaction boundary, specifically +// before the Finalise. +func (s *StateDB) LogsForBurnAccounts() []*types.Log { + var list []removedAccountWithBalance + for addr := range s.journal.mutations { + if obj, exist := s.stateObjects[addr]; exist && obj.selfDestructed && !obj.Balance().IsZero() { + list = append(list, removedAccountWithBalance{ + address: obj.address, + balance: obj.Balance(), + }) + } + } + if list == nil { + return nil + } + sort.Slice(list, func(i, j int) bool { + return list[i].address.Cmp(list[j].address) < 0 + }) + logs := make([]*types.Log, len(list)) + for i, acct := range list { + logs[i] = types.EthBurnLog(acct.address, acct.balance) + } + return logs +} + // Finalise finalises the state by removing the destructed objects and clears // the journal as well as the refunds. Finalise, however, will not push any updates // into the tries just yet. Only IntermediateRoot or Commit will do that. -func (s *StateDB) Finalise(deleteEmptyObjects bool) { - addressesToPrefetch := make([]common.Address, 0, len(s.journal.dirties)) - for addr := range s.journal.dirties { +func (s *StateDB) Finalise(deleteEmptyObjects bool) *bal.ConstructionBlockAccessList { + addressesToPrefetch := make([]common.Address, 0, len(s.journal.mutations)) + for addr, state := range s.journal.mutations { obj, exist := s.stateObjects[addr] if !exist { - // ripeMD is 'touched' at block 1714175, in tx 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2 - // That tx goes out of gas, and although the notion of 'touched' does not exist there, the - // touch-event will still be recorded in the journal. Since ripeMD is a special snowflake, - // it will persist in the journal even though the journal is reverted. In this special circumstance, - // it may exist in `s.journal.dirties` but not in `s.stateObjects`. - // Thus, we can safely ignore it here + // RIPEMD160 (0x03) gets an extra dirty marker for a historical + // mainnet consensus exception (at block 1714175, in tx + // 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2) + // around empty-account touch/revert handling. + // + // That marker survives journal revert, so the account may remain in + // s.journal.mutations even though its state object was rolled + // back and no longer exists. In that case there is nothing to + // finalise or delete, so ignore it here. continue } if obj.selfDestructed || (deleteEmptyObjects && obj.empty()) { delete(s.stateObjects, obj.address) s.markDelete(addr) + // We need to maintain account deletions explicitly (will remain // set indefinitely). Note only the first occurred self-destruct // event is tracked. if _, ok := s.stateObjectsDestruct[obj.address]; !ok { s.stateObjectsDestruct[obj.address] = obj } + // Aggregate the account mutation into the block-level accessList + // if Amsterdam has been activated. + if s.stateAccessList != nil { + // Notably, if the account is deleted during the transaction, + // its pre-transaction nonce, code, and storage must be empty. + // + // EIP-6780 restricts self-destruct to contracts deployed within + // the same transaction, while EIP-7610 rejects deployments to + // destinations with non-empty storage, non-zero nonce and non-empty + // code. + // + // Therefore, when an account is deleted, its pre-transaction nonce + // code and storage is guaranteed to be empty, leaving nothing to + // clean up here. + balance := uint256.NewInt(0) + if state.balanceSet && balance.Cmp(state.balance) != 0 { + s.stateAccessList.BalanceChange(s.blockAccessIndex, addr, balance) + } + } } else { + // Aggregate the account mutation into the block-level accessList + // if Amsterdam has been activated. + if s.stateAccessList != nil { + balance := obj.Balance() + if state.balanceSet && balance.Cmp(state.balance) != 0 { + s.stateAccessList.BalanceChange(s.blockAccessIndex, addr, balance) + } + nonce := obj.Nonce() + if state.nonceSet && nonce != state.nonce { + s.stateAccessList.NonceChange(addr, s.blockAccessIndex, nonce) + } + if state.codeSet { + if code := obj.Code(); !bytes.Equal(code, state.code) { + s.stateAccessList.CodeChange(addr, s.blockAccessIndex, code) + } + } + } obj.finalise() s.markUpdate(addr) } @@ -787,6 +883,8 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) { } // Invalidate journal because reverting across transactions is not allowed. s.clearJournalAndRefund() + + return s.stateAccessList } // IntermediateRoot computes the current root hash of the state trie. @@ -826,38 +924,73 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { start = time.Now() workers errgroup.Group ) - if s.db.TrieDB().IsVerkle() { - // Whilst MPT storage tries are independent, Verkle has one single trie - // for all the accounts and all the storage slots merged together. The - // former can thus be simply parallelized, but updating the latter will - // need concurrency support within the trie itself. That's a TODO for a - // later time. - workers.SetLimit(1) - } - for addr, op := range s.mutations { - if op.applied || op.isDelete() { - continue + if s.db.Type().Is(TypeUBT) { + // Bypass per-account updateTrie() for binary trie. In binary trie mode + // there is only one unified trie (OpenStorageTrie returns self), so the + // per-account trie setup in updateTrie() (getPrefetchedTrie, getTrie, + // prefetcher.used) is redundant overhead. Apply all storage updates + // directly in a single pass. + for addr, op := range s.mutations { + if op.applied || op.isDelete() { + continue + } + obj := s.stateObjects[addr] + if len(obj.uncommittedStorage) == 0 { + continue + } + for key, origin := range obj.uncommittedStorage { + value, exist := obj.pendingStorage[key] + if value == origin || !exist { + continue + } + if (value != common.Hash{}) { + if err := s.trie.UpdateStorage(addr, key[:], common.TrimLeftZeroes(value[:])); err != nil { + s.setError(err) + } + s.StorageUpdated.Add(1) + } else { + if err := s.trie.DeleteStorage(addr, key[:]); err != nil { + s.setError(err) + } + s.StorageDeleted.Add(1) + } + } } - obj := s.stateObjects[addr] // closure for the task runner below - workers.Go(func() error { - if s.db.TrieDB().IsVerkle() { - obj.updateTrie() - } else { + // Clear uncommittedStorage and assign trie on each touched object. + // obj.trie must be set because this path bypasses updateTrie(), which + // is where obj.trie normally gets lazily loaded via getTrie(). + for addr, op := range s.mutations { + if op.applied || op.isDelete() { + continue + } + obj := s.stateObjects[addr] + if len(obj.uncommittedStorage) > 0 { + obj.uncommittedStorage = make(Storage) + } + obj.trie = s.trie + } + } else { + for addr, op := range s.mutations { + if op.applied || op.isDelete() { + continue + } + obj := s.stateObjects[addr] // closure for the task runner below + workers.Go(func() error { obj.updateRoot() // If witness building is enabled and the state object has a trie, // gather the witnesses for its specific storage trie if s.witness != nil && obj.trie != nil { - s.witness.AddState(obj.trie.Witness()) + s.witness.AddState(obj.trie.Witness(), obj.addrHash()) } - } - return nil - }) + return nil + }) + } } // If witness building is enabled, gather all the read-only accesses. - // Skip witness collection in Verkle mode, they will be gathered - // together at the end. - if s.witness != nil && !s.db.TrieDB().IsVerkle() { + // Skip witness collection in Unified-binary-trie mode, they will be + // gathered together at the end. + if s.witness != nil && s.db.Type().Is(TypeMPT) { // Pull in anything that has been accessed before destruction for _, obj := range s.stateObjectsDestruct { // Skip any objects that haven't touched their storage @@ -865,17 +998,9 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { continue } if trie := obj.getPrefetchedTrie(); trie != nil { - witness := trie.Witness() - s.witness.AddState(witness) - if s.witnessStats != nil { - s.witnessStats.Add(witness, obj.addrHash) - } + s.witness.AddState(trie.Witness(), obj.addrHash()) } else if obj.trie != nil { - witness := obj.trie.Witness() - s.witness.AddState(witness) - if s.witnessStats != nil { - s.witnessStats.Add(witness, obj.addrHash) - } + s.witness.AddState(obj.trie.Witness(), obj.addrHash()) } } // Pull in only-read and non-destructed trie witnesses @@ -889,17 +1014,9 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { continue } if trie := obj.getPrefetchedTrie(); trie != nil { - witness := trie.Witness() - s.witness.AddState(witness) - if s.witnessStats != nil { - s.witnessStats.Add(witness, obj.addrHash) - } + s.witness.AddState(trie.Witness(), obj.addrHash()) } else if obj.trie != nil { - witness := obj.trie.Witness() - s.witness.AddState(witness) - if s.witnessStats != nil { - s.witnessStats.Add(witness, obj.addrHash) - } + s.witness.AddState(obj.trie.Witness(), obj.addrHash()) } } } @@ -914,7 +1031,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { // only a single trie is used for state hashing. Replacing a non-nil verkle tree // here could result in losing uncommitted changes from storage. start = time.Now() - if s.prefetcher != nil { + if s.prefetcher != nil && s.db.Type().Is(TypeMPT) { if trie := s.prefetcher.trie(common.Hash{}, s.originalRoot); trie == nil { log.Error("Failed to retrieve account pre-fetcher trie") } else { @@ -944,8 +1061,15 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { if op.isDelete() { deletedAddrs = append(deletedAddrs, addr) } else { - s.updateStateObject(s.stateObjects[addr]) + obj := s.stateObjects[addr] + s.updateStateObject(obj) s.AccountUpdated += 1 + + // Count code writes post-Finalise so reverted CREATEs are excluded. + if obj.dirtyCode { + s.CodeUpdated += 1 + s.CodeUpdateBytes += len(obj.code) + } } usedAddrs = append(usedAddrs, addr) // Copy needed for closure } @@ -965,11 +1089,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { // If witness building is enabled, gather the account trie witness if s.witness != nil { - witness := s.trie.Witness() - s.witness.AddState(witness) - if s.witnessStats != nil { - s.witnessStats.Add(witness, common.Hash{}) - } + s.witness.AddState(s.trie.Witness(), common.Hash{}) } return hash } @@ -977,9 +1097,10 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { // SetTxContext sets the current transaction hash and index which are // used when the EVM emits new state logs. It should be invoked before // transaction execution. -func (s *StateDB) SetTxContext(thash common.Hash, ti int) { +func (s *StateDB) SetTxContext(thash common.Hash, ti int, blockAccessIndex uint32) { s.thash = thash s.txIndex = ti + s.blockAccessIndex = blockAccessIndex } func (s *StateDB) clearJournalAndRefund() { @@ -987,39 +1108,45 @@ func (s *StateDB) clearJournalAndRefund() { s.refund = 0 } -// fastDeleteStorage is the function that efficiently deletes the storage trie -// of a specific account. It leverages the associated state snapshot for fast -// storage iteration and constructs trie node deletion markers by creating -// stack trie with iterated slots. -func (s *StateDB) fastDeleteStorage(snaps *snapshot.Tree, addrHash common.Hash, root common.Hash) (map[common.Hash][]byte, map[common.Hash][]byte, *trienode.NodeSet, error) { - iter, err := snaps.StorageIterator(s.originalRoot, addrHash, common.Hash{}) +// deleteStorage is designed to delete the storage trie of a designated account. +func (s *StateDB) deleteStorage(addrHash common.Hash, root common.Hash) (map[common.Hash]common.Hash, map[common.Hash]common.Hash, *trienode.NodeSet, error) { + var ( + nodes = trienode.NewNodeSet(addrHash) // the set for trie node mutations (value is nil) + storages = make(map[common.Hash]common.Hash) // the set for storage mutations (value is nil) + storageOrigins = make(map[common.Hash]common.Hash) // the set for tracking the original value of slot + ) + iteratee, err := s.db.Iteratee(s.originalRoot) + if err != nil { + return nil, nil, nil, err + } + it, err := iteratee.NewStorageIterator(addrHash, common.Hash{}) if err != nil { return nil, nil, nil, err } - defer iter.Release() + defer it.Release() - var ( - nodes = trienode.NewNodeSet(addrHash) // the set for trie node mutations (value is nil) - storages = make(map[common.Hash][]byte) // the set for storage mutations (value is nil) - storageOrigins = make(map[common.Hash][]byte) // the set for tracking the original value of slot - ) stack := trie.NewStackTrie(func(path []byte, hash common.Hash, blob []byte) { nodes.AddNode(path, trienode.NewDeletedWithPrev(blob)) }) - for iter.Next() { - slot := common.CopyBytes(iter.Slot()) - if err := iter.Error(); err != nil { // error might occur after Slot function + for it.Next() { + slot := it.Slot() + // Error might occur after Slot function + if err := it.Error(); err != nil { return nil, nil, nil, err } - key := iter.Hash() - storages[key] = nil + if slot == (common.Hash{}) { + return nil, nil, nil, fmt.Errorf("unexpected empty storage slot, addr: %x, slot: %x", addrHash, it.Hash()) + } + key := it.Hash() + storages[key] = common.Hash{} storageOrigins[key] = slot - if err := stack.Update(key.Bytes(), slot); err != nil { + if err := stack.Update(key.Bytes(), encodeSlot(slot)); err != nil { return nil, nil, nil, err } } - if err := iter.Error(); err != nil { // error might occur during iteration + // Error might occur during iteration + if err := it.Error(); err != nil { return nil, nil, nil, err } if stack.Hash() != root { @@ -1028,68 +1155,6 @@ func (s *StateDB) fastDeleteStorage(snaps *snapshot.Tree, addrHash common.Hash, return storages, storageOrigins, nodes, nil } -// slowDeleteStorage serves as a less-efficient alternative to "fastDeleteStorage," -// employed when the associated state snapshot is not available. It iterates the -// storage slots along with all internal trie nodes via trie directly. -func (s *StateDB) slowDeleteStorage(addr common.Address, addrHash common.Hash, root common.Hash) (map[common.Hash][]byte, map[common.Hash][]byte, *trienode.NodeSet, error) { - tr, err := s.db.OpenStorageTrie(s.originalRoot, addr, root, s.trie) - if err != nil { - return nil, nil, nil, fmt.Errorf("failed to open storage trie, err: %w", err) - } - it, err := tr.NodeIterator(nil) - if err != nil { - return nil, nil, nil, fmt.Errorf("failed to open storage iterator, err: %w", err) - } - var ( - nodes = trienode.NewNodeSet(addrHash) // the set for trie node mutations (value is nil) - storages = make(map[common.Hash][]byte) // the set for storage mutations (value is nil) - storageOrigins = make(map[common.Hash][]byte) // the set for tracking the original value of slot - ) - for it.Next(true) { - if it.Leaf() { - key := common.BytesToHash(it.LeafKey()) - storages[key] = nil - storageOrigins[key] = common.CopyBytes(it.LeafBlob()) - continue - } - if it.Hash() == (common.Hash{}) { - continue - } - nodes.AddNode(it.Path(), trienode.NewDeletedWithPrev(it.NodeBlob())) - } - if err := it.Error(); err != nil { - return nil, nil, nil, err - } - return storages, storageOrigins, nodes, nil -} - -// deleteStorage is designed to delete the storage trie of a designated account. -// The function will make an attempt to utilize an efficient strategy if the -// associated state snapshot is reachable; otherwise, it will resort to a less -// efficient approach. -func (s *StateDB) deleteStorage(addr common.Address, addrHash common.Hash, root common.Hash) (map[common.Hash][]byte, map[common.Hash][]byte, *trienode.NodeSet, error) { - var ( - err error - nodes *trienode.NodeSet // the set for trie node mutations (value is nil) - storages map[common.Hash][]byte // the set for storage mutations (value is nil) - storageOrigins map[common.Hash][]byte // the set for tracking the original value of slot - ) - // The fast approach can be failed if the snapshot is not fully - // generated, or it's internally corrupted. Fallback to the slow - // one just in case. - snaps := s.db.Snapshot() - if snaps != nil { - storages, storageOrigins, nodes, err = s.fastDeleteStorage(snaps, addrHash, root) - } - if snaps == nil || err != nil { - storages, storageOrigins, nodes, err = s.slowDeleteStorage(addr, addrHash, root) - } - if err != nil { - return nil, nil, nil, err - } - return storages, storageOrigins, nodes, nil -} - // handleDestruction processes all destruction markers and deletes the account // and associated storage slots if necessary. There are four potential scenarios // as following: @@ -1108,10 +1173,10 @@ func (s *StateDB) deleteStorage(addr common.Address, addrHash common.Hash, root // with their values be tracked as original value. // In case (d), **original** account along with its storages should be deleted, // with their values be tracked as original value. -func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*accountDelete, []*trienode.NodeSet, error) { +func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*AccountDelete, []*trienode.NodeSet, error) { var ( nodes []*trienode.NodeSet - deletes = make(map[common.Hash]*accountDelete) + deletes = make(map[common.Hash]*AccountDelete) ) for addr, prevObj := range s.stateObjectsDestruct { prev := prevObj.origin @@ -1125,27 +1190,27 @@ func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*acco continue } // The account was existent, it can be either case (c) or (d). - addrHash := crypto.Keccak256Hash(addr.Bytes()) - op := &accountDelete{ - address: addr, - origin: types.SlimAccountRLP(*prev), + addrHash := prevObj.addrHash() + op := &AccountDelete{ + Address: addr, + Origin: prev, } deletes[addrHash] = op // Short circuit if the origin storage was empty. - if prev.Root == types.EmptyRootHash || s.db.TrieDB().IsVerkle() { + if prev.Root == types.EmptyRootHash || s.db.Type().Is(TypeUBT) { continue } if noStorageWiping { return nil, nil, fmt.Errorf("unexpected storage wiping, %x", addr) } // Remove storage slots belonging to the account. - storages, storagesOrigin, set, err := s.deleteStorage(addr, addrHash, prev.Root) + storages, storagesOrigin, set, err := s.deleteStorage(addrHash, prev.Root) if err != nil { return nil, nil, fmt.Errorf("failed to delete storage, err: %w", err) } - op.storages = storages - op.storagesOrigin = storagesOrigin + op.Storages = storages + op.StoragesOrigin = storagesOrigin // Aggregate the associated trie node changes. nodes = append(nodes, set) @@ -1160,13 +1225,13 @@ func (s *StateDB) GetTrie() Trie { // commit gathers the state mutations accumulated along with the associated // trie changes, resetting all internal flags with the new state as the base. -func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNumber uint64) (*stateUpdate, error) { +func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNumber uint64) (*StateUpdate, error) { // Short circuit in case any database failure occurred earlier. if s.dbErr != nil { return nil, fmt.Errorf("commit aborted due to earlier error: %v", s.dbErr) } // Finalize any pending changes and merge everything into the tries - s.IntermediateRoot(deleteEmptyObjects) + root := s.IntermediateRoot(deleteEmptyObjects) // Short circuit if any error occurs within the IntermediateRoot. if s.dbErr != nil { @@ -1181,7 +1246,7 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNum lock sync.Mutex // protect two maps below nodes = trienode.NewMergedNodeSet() // aggregated trie nodes - updates = make(map[common.Hash]*accountUpdate, len(s.mutations)) // aggregated account updates + updates = make(map[common.Hash]*AccountUpdate, len(s.mutations)) // aggregated account updates // merge aggregates the dirty trie nodes into the global set. // @@ -1228,7 +1293,6 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNum // writes to run in parallel with the computations. var ( start = time.Now() - root common.Hash workers errgroup.Group ) // Schedule the account trie first since that will be the biggest, so give @@ -1242,9 +1306,7 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNum // code didn't anticipate for. workers.Go(func() error { // Write the account trie changes, measuring the amount of wasted time - newroot, set := s.trie.Commit(true) - root = newroot - + _, set := s.trie.Commit(true) if err := merge(set); err != nil { return err } @@ -1278,7 +1340,7 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNum return err } lock.Lock() - updates[obj.addrHash] = update + updates[obj.addrHash()] = update s.StorageCommits = time.Since(start) // overwrite with the longest storage commit runtime lock.Unlock() return nil @@ -1312,57 +1374,34 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNum origin := s.originalRoot s.originalRoot = root - return newStateUpdate(noStorageWiping, origin, root, blockNumber, deletes, updates, nodes), nil + typ := StorageKeyHashed + if noStorageWiping { + typ = StorageKeyPlain + } + return NewStateUpdate(typ, origin, root, blockNumber, deletes, updates, nodes), nil } // commitAndFlush is a wrapper of commit which also commits the state mutations // to the configured data stores. -func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorageWiping bool, dedupCode bool) (*stateUpdate, error) { +func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorageWiping bool, deriveCodeFields bool) (*StateUpdate, error) { ret, err := s.commit(deleteEmptyObjects, noStorageWiping, block) if err != nil { return nil, err } - - if dedupCode { - ret.markCodeExistence(s.reader) - } - - // Commit dirty contract code if any exists - if db := s.db.TrieDB().Disk(); db != nil && len(ret.codes) > 0 { - batch := db.NewBatch() - for _, code := range ret.codes { - rawdb.WriteCode(batch, code.hash, code.blob) - } - if err := batch.Write(); err != nil { + if deriveCodeFields { + if err := ret.deriveCodeFields(s.reader); err != nil { return nil, err } } - if !ret.empty() { - // If snapshotting is enabled, update the snapshot tree with this new version - if snap := s.db.Snapshot(); snap != nil && snap.Snapshot(ret.originRoot) != nil { - start := time.Now() - if err := snap.Update(ret.root, ret.originRoot, ret.accounts, ret.storages); err != nil { - log.Warn("Failed to update snapshot tree", "from", ret.originRoot, "to", ret.root, "err", err) - } - // Keep 128 diff layers in the memory, persistent layer is 129th. - // - head layer is paired with HEAD state - // - head-1 layer is paired with HEAD-1 state - // - head-127 layer(bottom-most diff layer) is paired with HEAD-127 state - if err := snap.Cap(ret.root, TriesInMemory); err != nil { - log.Warn("Failed to cap snapshot tree", "root", ret.root, "layers", TriesInMemory, "err", err) - } - s.SnapshotCommits += time.Since(start) - } - // If trie database is enabled, commit the state update as a new layer - if db := s.db.TrieDB(); db != nil { - start := time.Now() - if err := db.Update(ret.root, ret.originRoot, block, ret.nodes, ret.stateSet()); err != nil { - return nil, err - } - s.TrieDBCommits += time.Since(start) - } + start := time.Now() + if err := s.db.Commit(ret); err != nil { + return nil, err } - s.reader, _ = s.db.Reader(s.originalRoot) + s.DatabaseCommits = time.Since(start) + + // The reader update must be performed as the final step, otherwise, + // the new state would not be visible before db.commit. + s.reader, err = s.db.Reader(s.originalRoot) return ret, err } @@ -1385,17 +1424,17 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool, noStorageWiping if err != nil { return common.Hash{}, err } - return ret.root, nil + return ret.Root, nil } -// CommitAndTrack writes the state mutations and notifies the size tracker of the state changes. -func (s *StateDB) CommitAndTrack(block uint64, deleteEmptyObjects bool, noStorageWiping bool, sizer *SizeTracker) (common.Hash, error) { +// CommitWithUpdate writes the state mutations and returns the state update for +// external processing (e.g., live tracing hooks or size tracker). +func (s *StateDB) CommitWithUpdate(block uint64, deleteEmptyObjects bool, noStorageWiping bool) (common.Hash, *StateUpdate, error) { ret, err := s.commitAndFlush(block, deleteEmptyObjects, noStorageWiping, true) if err != nil { - return common.Hash{}, err + return common.Hash{}, nil, err } - sizer.Notify(ret) - return ret.root, nil + return ret.Root, ret, nil } // Prepare handles the preparatory steps for executing a state transition with. @@ -1440,6 +1479,10 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d } // Reset transient storage at the beginning of transaction execution s.transientStorage = newTransientStorage() + + if rules.IsAmsterdam { + s.stateAccessList = bal.NewConstructionBlockAccessList() + } } // AddAddressToAccessList adds the given address to the access list @@ -1493,11 +1536,6 @@ func (s *StateDB) markUpdate(addr common.Address) { s.mutations[addr].typ = update } -// PointCache returns the point cache used by verkle tree. -func (s *StateDB) PointCache() *utils.PointCache { - return s.db.PointCache() -} - // Witness retrieves the current state witness being collected. func (s *StateDB) Witness() *stateless.Witness { return s.witness diff --git a/core/state/statedb_fuzz_test.go b/core/state/statedb_fuzz_test.go index 8b6ac0ba649b..c796b416a32b 100644 --- a/core/state/statedb_fuzz_test.go +++ b/core/state/statedb_fuzz_test.go @@ -182,11 +182,12 @@ func (test *stateTest) run() bool { accountOrigin []map[common.Address][]byte storages []map[common.Hash]map[common.Hash][]byte storageOrigin []map[common.Address]map[common.Hash][]byte - copyUpdate = func(update *stateUpdate) { - accounts = append(accounts, maps.Clone(update.accounts)) - accountOrigin = append(accountOrigin, maps.Clone(update.accountsOrigin)) - storages = append(storages, maps.Clone(update.storages)) - storageOrigin = append(storageOrigin, maps.Clone(update.storagesOrigin)) + copyUpdate = func(update *StateUpdate) { + accts, acctOrigin, slots, slotOrigin := update.EncodeMPTState() + accounts = append(accounts, maps.Clone(accts)) + accountOrigin = append(accountOrigin, maps.Clone(acctOrigin)) + storages = append(storages, maps.Clone(slots)) + storageOrigin = append(storageOrigin, maps.Clone(slotOrigin)) } disk = rawdb.NewMemoryDatabase() tdb = triedb.NewDatabase(disk, &triedb.Config{PathDB: pathdb.Defaults}) @@ -209,7 +210,7 @@ func (test *stateTest) run() bool { if i != 0 { root = roots[len(roots)-1] } - state, err := New(root, NewDatabase(tdb, snaps)) + state, err := New(root, NewMPTDatabase(tdb, nil).WithSnapshot(snaps)) if err != nil { panic(err) } @@ -232,11 +233,11 @@ func (test *stateTest) run() bool { if err != nil { panic(err) } - if ret.empty() { + if ret.Empty() { return true } copyUpdate(ret) - roots = append(roots, ret.root) + roots = append(roots, ret.Root) } for i := 0; i < len(test.actions); i++ { root := types.EmptyRootHash diff --git a/core/state/statedb_hooked.go b/core/state/statedb_hooked.go index 50acc03aa8be..98d01343a45e 100644 --- a/core/state/statedb_hooked.go +++ b/core/state/statedb_hooked.go @@ -17,15 +17,17 @@ package state import ( + "bytes" "math/big" + "sort" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/stateless" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/types/bal" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie/utils" "github.com/holiman/uint256" ) @@ -53,6 +55,10 @@ func (s *hookedStateDB) CreateContract(addr common.Address) { s.inner.CreateContract(addr) } +func (s *hookedStateDB) IsNewContract(addr common.Address) bool { + return s.inner.IsNewContract(addr) +} + func (s *hookedStateDB) GetBalance(addr common.Address) *uint256.Int { return s.inner.GetBalance(addr) } @@ -93,10 +99,6 @@ func (s *hookedStateDB) GetState(addr common.Address, hash common.Hash) common.H return s.inner.GetState(addr, hash) } -func (s *hookedStateDB) GetStorageRoot(addr common.Address) common.Hash { - return s.inner.GetStorageRoot(addr) -} - func (s *hookedStateDB) GetTransientState(addr common.Address, key common.Hash) common.Hash { return s.inner.GetTransientState(addr, key) } @@ -113,6 +115,10 @@ func (s *hookedStateDB) Exist(addr common.Address) bool { return s.inner.Exist(addr) } +func (s *hookedStateDB) Touch(addr common.Address) { + s.inner.Touch(addr) +} + func (s *hookedStateDB) Empty(addr common.Address) bool { return s.inner.Empty(addr) } @@ -133,10 +139,6 @@ func (s *hookedStateDB) AddSlotToAccessList(addr common.Address, slot common.Has s.inner.AddSlotToAccessList(addr, slot) } -func (s *hookedStateDB) PointCache() *utils.PointCache { - return s.inner.PointCache() -} - func (s *hookedStateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) { s.inner.Prepare(rules, sender, coinbase, dest, precompiles, txAccesses) } @@ -216,78 +218,77 @@ func (s *hookedStateDB) SetState(address common.Address, key common.Hash, value return prev } -func (s *hookedStateDB) SelfDestruct(address common.Address) uint256.Int { - var prevCode []byte - var prevCodeHash common.Hash +func (s *hookedStateDB) SelfDestruct(address common.Address) { + s.inner.SelfDestruct(address) +} - if s.hooks.OnCodeChange != nil || s.hooks.OnCodeChangeV2 != nil { - prevCode = s.inner.GetCode(address) - prevCodeHash = s.inner.GetCodeHash(address) +func (s *hookedStateDB) AddLog(log *types.Log) { + // The inner will modify the log (add fields), so invoke that first + s.inner.AddLog(log) + if s.hooks.OnLog != nil { + s.hooks.OnLog(log) } +} - prev := s.inner.SelfDestruct(address) +func (s *hookedStateDB) LogsForBurnAccounts() []*types.Log { + return s.inner.LogsForBurnAccounts() +} - if s.hooks.OnBalanceChange != nil && !prev.IsZero() { - s.hooks.OnBalanceChange(address, prev.ToBig(), new(big.Int), tracing.BalanceDecreaseSelfdestruct) +func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) *bal.ConstructionBlockAccessList { + if s.hooks.OnBalanceChange == nil && s.hooks.OnNonceChangeV2 == nil && s.hooks.OnNonceChange == nil && s.hooks.OnCodeChangeV2 == nil && s.hooks.OnCodeChange == nil { + // Short circuit if no relevant hooks are set. + return s.inner.Finalise(deleteEmptyObjects) } - if len(prevCode) > 0 { - if s.hooks.OnCodeChangeV2 != nil { - s.hooks.OnCodeChangeV2(address, prevCodeHash, prevCode, types.EmptyCodeHash, nil, tracing.CodeChangeSelfDestruct) - } else if s.hooks.OnCodeChange != nil { - s.hooks.OnCodeChange(address, prevCodeHash, prevCode, types.EmptyCodeHash, nil) + // Collect all self-destructed addresses first, then sort them to ensure + // that state change hooks will be invoked in deterministic + // order when the accounts are deleted below + var selfDestructedAddrs []common.Address + for addr := range s.inner.journal.mutations { + obj := s.inner.stateObjects[addr] + if obj == nil || !obj.selfDestructed { + // Not self-destructed, keep searching. + continue } + selfDestructedAddrs = append(selfDestructedAddrs, addr) } + sort.Slice(selfDestructedAddrs, func(i, j int) bool { + return bytes.Compare(selfDestructedAddrs[i][:], selfDestructedAddrs[j][:]) < 0 + }) - return prev -} - -func (s *hookedStateDB) SelfDestruct6780(address common.Address) (uint256.Int, bool) { - var prevCode []byte - var prevCodeHash common.Hash - - if s.hooks.OnCodeChange != nil || s.hooks.OnCodeChangeV2 != nil { - prevCodeHash = s.inner.GetCodeHash(address) - prevCode = s.inner.GetCode(address) - } + for _, addr := range selfDestructedAddrs { + obj := s.inner.stateObjects[addr] + // Bingo: state object was self-destructed, call relevant hooks. - prev, changed := s.inner.SelfDestruct6780(address) + // If ether was sent to account post-selfdestruct, record as burnt. + if s.hooks.OnBalanceChange != nil { + if bal := obj.Balance(); bal.Sign() != 0 { + s.hooks.OnBalanceChange(addr, bal.ToBig(), new(big.Int), tracing.BalanceDecreaseSelfdestructBurn) + } + } - if s.hooks.OnBalanceChange != nil && !prev.IsZero() { - s.hooks.OnBalanceChange(address, prev.ToBig(), new(big.Int), tracing.BalanceDecreaseSelfdestruct) - } + // Nonce is set to reset on self-destruct. + if s.hooks.OnNonceChangeV2 != nil { + s.hooks.OnNonceChangeV2(addr, obj.Nonce(), 0, tracing.NonceChangeSelfdestruct) + } else if s.hooks.OnNonceChange != nil { + s.hooks.OnNonceChange(addr, obj.Nonce(), 0) + } - if changed && len(prevCode) > 0 { + // If an initcode invokes selfdestruct, do not emit a code change. + prevCodeHash := s.inner.GetCodeHash(addr) + if prevCodeHash == types.EmptyCodeHash { + continue + } + // Otherwise, trace the change. if s.hooks.OnCodeChangeV2 != nil { - s.hooks.OnCodeChangeV2(address, prevCodeHash, prevCode, types.EmptyCodeHash, nil, tracing.CodeChangeSelfDestruct) + s.hooks.OnCodeChangeV2(addr, prevCodeHash, s.inner.GetCode(addr), types.EmptyCodeHash, nil, tracing.CodeChangeSelfDestruct) } else if s.hooks.OnCodeChange != nil { - s.hooks.OnCodeChange(address, prevCodeHash, prevCode, types.EmptyCodeHash, nil) + s.hooks.OnCodeChange(addr, prevCodeHash, s.inner.GetCode(addr), types.EmptyCodeHash, nil) } } - - return prev, changed -} - -func (s *hookedStateDB) AddLog(log *types.Log) { - // The inner will modify the log (add fields), so invoke that first - s.inner.AddLog(log) - if s.hooks.OnLog != nil { - s.hooks.OnLog(log) - } + return s.inner.Finalise(deleteEmptyObjects) } -func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) { - defer s.inner.Finalise(deleteEmptyObjects) - if s.hooks.OnBalanceChange == nil { - return - } - for addr := range s.inner.journal.dirties { - obj := s.inner.stateObjects[addr] - if obj != nil && obj.selfDestructed { - // If ether was sent to account post-selfdestruct it is burnt. - if bal := obj.Balance(); bal.Sign() != 0 { - s.hooks.OnBalanceChange(addr, bal.ToBig(), new(big.Int), tracing.BalanceDecreaseSelfdestructBurn) - } - } - } +func (s *hookedStateDB) SetTxContext(thash common.Hash, ti int, blockAccessIndex uint32) { + s.inner.SetTxContext(thash, ti, blockAccessIndex) } diff --git a/core/state/statedb_hooked_test.go b/core/state/statedb_hooked_test.go index 4ff1023eb2c9..fad234f848a9 100644 --- a/core/state/statedb_hooked_test.go +++ b/core/state/statedb_hooked_test.go @@ -49,6 +49,8 @@ func TestBurn(t *testing.T) { createAndDestroy := func(addr common.Address) { hooked.AddBalance(addr, uint256.NewInt(100), tracing.BalanceChangeUnspecified) hooked.CreateContract(addr) + // Simulate what the opcode handler does: clear balance before selfdestruct + hooked.SubBalance(addr, hooked.GetBalance(addr), tracing.BalanceDecreaseSelfdestruct) hooked.SelfDestruct(addr) // sanity-check that balance is now 0 if have, want := hooked.GetBalance(addr), new(uint256.Int); !have.Eq(want) { @@ -80,7 +82,7 @@ func TestBurn(t *testing.T) { // TestHooks is a basic sanity-check of all hooks func TestHooks(t *testing.T) { inner, _ := New(types.EmptyRootHash, NewDatabaseForTesting()) - inner.SetTxContext(common.Hash{0x11}, 100) // For the log + inner.SetTxContext(common.Hash{0x11}, 100, 101) // For the log var result []string var wants = []string{ "0xaa00000000000000000000000000000000000000.balance: 0->100 (Unspecified)", @@ -129,7 +131,7 @@ func TestHooks(t *testing.T) { for i, want := range wants { if have := result[i]; have != want { - t.Fatalf("error event %d, have\n%v\nwant%v\n", i, have, want) + t.Fatalf("error event %d\nhave: %v\nwant: %v", i, have, want) } } } @@ -140,8 +142,8 @@ func TestHooks_OnCodeChangeV2(t *testing.T) { var result []string var wants = []string{ "0xaa00000000000000000000000000000000000000.code: (0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470) ->0x1325 (0xa12ae05590de0c93a00bc7ac773c2fdb621e44f814985e72194f921c0050f728) ContractCreation", - "0xaa00000000000000000000000000000000000000.code: 0x1325 (0xa12ae05590de0c93a00bc7ac773c2fdb621e44f814985e72194f921c0050f728) -> (0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470) SelfDestruct", "0xbb00000000000000000000000000000000000000.code: (0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470) ->0x1326 (0x3c54516221d604e623f358bc95996ca3242aaa109bddabcebda13db9b3f90dcb) ContractCreation", + "0xaa00000000000000000000000000000000000000.code: 0x1325 (0xa12ae05590de0c93a00bc7ac773c2fdb621e44f814985e72194f921c0050f728) -> (0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470) SelfDestruct", "0xbb00000000000000000000000000000000000000.code: 0x1326 (0x3c54516221d604e623f358bc95996ca3242aaa109bddabcebda13db9b3f90dcb) -> (0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470) SelfDestruct", } emitF := func(format string, a ...any) { @@ -157,7 +159,8 @@ func TestHooks_OnCodeChangeV2(t *testing.T) { sdb.SetCode(common.Address{0xbb}, []byte{0x13, 38}, tracing.CodeChangeContractCreation) sdb.CreateContract(common.Address{0xbb}) - sdb.SelfDestruct6780(common.Address{0xbb}) + sdb.SelfDestruct(common.Address{0xbb}) + sdb.Finalise(true) if len(result) != len(wants) { t.Fatalf("number of tracing events wrong, have %d want %d", len(result), len(wants)) @@ -165,7 +168,7 @@ func TestHooks_OnCodeChangeV2(t *testing.T) { for i, want := range wants { if have := result[i]; have != want { - t.Fatalf("error event %d, have\n%v\nwant%v\n", i, have, want) + t.Fatalf("error event %d\nhave: %v\nwant: %v", i, have, want) } } } diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index 661d17bb7beb..0bf9b50e7b53 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -247,16 +247,16 @@ func TestCopyWithDirtyJournal(t *testing.T) { orig.Finalise(true) for i := byte(0); i < 255; i++ { - root := orig.GetStorageRoot(common.BytesToAddress([]byte{i})) - if root != (common.Hash{}) { - t.Errorf("Unexpected storage root %x", root) + balance := orig.GetBalance(common.BytesToAddress([]byte{i})) + if !balance.IsZero() { + t.Errorf("Unexpected balance %x", root) } } cpy.Finalise(true) for i := byte(0); i < 255; i++ { - root := cpy.GetStorageRoot(common.BytesToAddress([]byte{i})) - if root != (common.Hash{}) { - t.Errorf("Unexpected storage root %x", root) + balance := cpy.GetBalance(common.BytesToAddress([]byte{i})) + if !balance.IsZero() { + t.Errorf("Unexpected balance %x", root) } } if cpy.IntermediateRoot(true) != orig.IntermediateRoot(true) { @@ -394,9 +394,7 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction { } contractHash := s.GetCodeHash(addr) emptyCode := contractHash == (common.Hash{}) || contractHash == types.EmptyCodeHash - storageRoot := s.GetStorageRoot(addr) - emptyStorage := storageRoot == (common.Hash{}) || storageRoot == types.EmptyRootHash - if s.GetNonce(addr) == 0 && emptyCode && emptyStorage { + if s.GetNonce(addr) == 0 && emptyCode { s.CreateContract(addr) // We also set some code here, to prevent the // CreateContract action from being performed twice in a row, @@ -641,7 +639,7 @@ func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error { { have := state.transientStorage want := checkstate.transientStorage - if !maps.EqualFunc(have, want, maps.Equal) { + if !maps.Equal(have, want) { return fmt.Errorf("transient storage differs ,have\n%v\nwant\n%v", have.PrettyPrint(), want.PrettyPrint()) @@ -664,26 +662,30 @@ func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error { return fmt.Errorf("got GetLogs(common.Hash{}) == %v, want GetLogs(common.Hash{}) == %v", state.GetLogs(common.Hash{}, 0, common.Hash{}, 0), checkstate.GetLogs(common.Hash{}, 0, common.Hash{}, 0)) } - if !maps.Equal(state.journal.dirties, checkstate.journal.dirties) { - getKeys := func(dirty map[common.Address]int) string { - var keys []common.Address - out := new(strings.Builder) - for key := range dirty { - keys = append(keys, key) - } - slices.SortFunc(keys, common.Address.Cmp) - for i, key := range keys { - fmt.Fprintf(out, " %d. %v\n", i, key) - } - return out.String() - } - have := getKeys(state.journal.dirties) - want := getKeys(checkstate.journal.dirties) - return fmt.Errorf("dirty-journal set mismatch.\nhave:\n%v\nwant:\n%v\n", have, want) + if !equalMutationSets(state.journal.mutations, checkstate.journal.mutations) { + return fmt.Errorf("journal mutation set mismatch.\nhave:\n%v\nwant:\n%v\n", state.journal.mutations, checkstate.journal.mutations) } return nil } +// equalMutationSets checks that two journal mutation maps have the same set of +// addresses and, for each address, the same per-kind counts. The stashed +// original values are ignored because comparing them across two independent +// state databases (with distinct pointer identities) isn't the point of this +// check — we only care that the two journals agree on what was touched. +func equalMutationSets(a, b map[common.Address]*journalMutationState) bool { + if len(a) != len(b) { + return false + } + for addr, sa := range a { + sb, ok := b[addr] + if !ok || sa.counts != sb.counts { + return false + } + } + return true +} + func TestTouchDelete(t *testing.T) { s := newStateEnv() s.state.getOrNewStateObject(common.Address{}) @@ -693,12 +695,54 @@ func TestTouchDelete(t *testing.T) { snapshot := s.state.Snapshot() s.state.AddBalance(common.Address{}, new(uint256.Int), tracing.BalanceChangeUnspecified) - if len(s.state.journal.dirties) != 1 { - t.Fatal("expected one dirty state object") + if len(s.state.journal.mutations) != 1 { + t.Fatal("expected one mutated state object") } s.state.RevertToSnapshot(snapshot) - if len(s.state.journal.dirties) != 0 { - t.Fatal("expected no dirty state object") + if len(s.state.journal.mutations) != 0 { + t.Fatal("expected no journal mutations") + } +} + +func TestJournalMutationTracking(t *testing.T) { + state, _ := New(types.EmptyRootHash, NewDatabaseForTesting()) + addr := common.HexToAddress("0x01") + key := common.HexToHash("0x02") + + if _, ok := state.journal.mutations[addr]; ok { + t.Fatal("unexpected initial mutation entry") + } + snapshot := state.Snapshot() + + state.SetBalance(addr, uint256.NewInt(1), tracing.BalanceChangeUnspecified) + state.SetNonce(addr, 2, tracing.NonceChangeUnspecified) + state.SetCode(addr, []byte{0x1}, tracing.CodeChangeUnspecified) + state.SetState(addr, key, common.Hash{0x3}) + + want := journalMutationCounts{ + journalMutationKindCreate: 1, + journalMutationKindBalance: 1, + journalMutationKindNonce: 1, + journalMutationKindCode: 1, + journalMutationKindStorage: 1, + } + checkCounts := func(got *journalMutationState, label string) { + t.Helper() + if got == nil { + t.Fatalf("%s: missing mutation entry for %x", label, addr) + } + if got.counts != want { + t.Fatalf("%s: counts=%+v, want=%+v", label, got.counts, want) + } + } + checkCounts(state.journal.mutations[addr], "state") + + copy := state.Copy() + checkCounts(copy.journal.mutations[addr], "copy") + + state.RevertToSnapshot(snapshot) + if _, ok := state.journal.mutations[addr]; ok { + t.Fatalf("unexpected mutation entry after revert") } } @@ -1276,7 +1320,7 @@ func TestDeleteStorage(t *testing.T) { disk = rawdb.NewMemoryDatabase() tdb = triedb.NewDatabase(disk, nil) snaps, _ = snapshot.New(snapshot.Config{CacheSize: 10}, disk, tdb, types.EmptyRootHash) - db = NewDatabase(tdb, snaps) + db = NewMPTDatabase(tdb, nil).WithSnapshot(snaps) state, _ = New(types.EmptyRootHash, db) addr = common.HexToAddress("0x1") ) @@ -1290,18 +1334,18 @@ func TestDeleteStorage(t *testing.T) { } root, _ := state.Commit(0, true, false) // Init phase done, create two states, one with snap and one without - fastState, _ := New(root, NewDatabase(tdb, snaps)) - slowState, _ := New(root, NewDatabase(tdb, nil)) + fastState, _ := New(root, NewMPTDatabase(tdb, nil).WithSnapshot(snaps)) + slowState, _ := New(root, NewMPTDatabase(tdb, nil)) obj := fastState.getOrNewStateObject(addr) storageRoot := obj.data.Root - _, _, fastNodes, err := fastState.deleteStorage(addr, crypto.Keccak256Hash(addr[:]), storageRoot) + _, _, fastNodes, err := fastState.deleteStorage(crypto.Keccak256Hash(addr[:]), storageRoot) if err != nil { t.Fatal(err) } - _, _, slowNodes, err := slowState.deleteStorage(addr, crypto.Keccak256Hash(addr[:]), storageRoot) + _, _, slowNodes, err := slowState.deleteStorage(crypto.Keccak256Hash(addr[:]), storageRoot) if err != nil { t.Fatal(err) } @@ -1368,3 +1412,38 @@ func TestStorageDirtiness(t *testing.T) { state.RevertToSnapshot(snap) checkDirty(common.Hash{0x1}, common.Hash{0x1}, true) } + +// TestStateDBCopyUBT exercises StateDB.Copy on a UBT-backed state database. +// Before the mustCopyTrie fix, this panicked with "unknown trie type +// *bintrie.BinaryTrie" because the type switch in mustCopyTrie only covered +// *trie.StateTrie and *transitiontrie.TransitionTrie. +func TestStateDBCopyUBT(t *testing.T) { + disk := rawdb.NewMemoryDatabase() + tdb := triedb.NewDatabase(disk, triedb.UBTDefaults) + sdb := NewDatabase(tdb, nil) + + orig, err := New(types.EmptyRootHash, sdb) + if err != nil { + t.Fatalf("New: %v", err) + } + + // Touch the trie so StateDB.Copy actually has to copy it. + addr := common.HexToAddress("0x1111111111111111111111111111111111111111") + orig.SetBalance(addr, uint256.NewInt(1_000), tracing.BalanceChangeUnspecified) + + // Must not panic. + cpy := orig.Copy() + if cpy == nil { + t.Fatal("Copy returned nil") + } + + // The copy must be independent: mutating the copy does not affect the + // original. Use balance as an observable. + cpy.SetBalance(addr, uint256.NewInt(2_000), tracing.BalanceChangeUnspecified) + if got, want := orig.GetBalance(addr), uint256.NewInt(1_000); got.Cmp(want) != 0 { + t.Fatalf("original balance mutated through copy: got %s, want %s", got, want) + } + if got, want := cpy.GetBalance(addr), uint256.NewInt(2_000); got.Cmp(want) != 0 { + t.Fatalf("copy balance did not update: got %s, want %s", got, want) + } +} diff --git a/core/state/stateupdate.go b/core/state/stateupdate.go index 853ed09dad4e..adf959e761e4 100644 --- a/core/state/stateupdate.go +++ b/core/state/stateupdate.go @@ -17,139 +17,153 @@ package state import ( + "fmt" "maps" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie/trienode" - "github.com/ethereum/go-ethereum/triedb" ) -// contractCode represents a contract code with associated metadata. -type contractCode struct { - hash common.Hash // hash is the cryptographic hash of the contract code. - blob []byte // blob is the binary representation of the contract code. - exists bool // flag whether the code has been existent +// ContractCode represents contract bytecode mutation along with its +// associated metadata. +type ContractCode struct { + Hash common.Hash // Hash is the cryptographic hash of the current contract code. + Blob []byte // Blob is the binary representation of the current contract code. + OriginHash common.Hash // OriginHash is the cryptographic hash of the code before mutation. + + // Derived fields, populated only when state tracking is enabled. + Duplicate bool // Duplicate indicates whether the updated code already exists. + OriginBlob []byte // OriginBlob is the original binary representation of the contract code. } -// accountDelete represents an operation for deleting an Ethereum account. -type accountDelete struct { - address common.Address // address is the unique account identifier - origin []byte // origin is the original value of account data in slim-RLP encoding. +// AccountDelete represents a deletion operation for an Ethereum account. +type AccountDelete struct { + Address common.Address // Address uniquely identifies the account. + Origin *types.StateAccount // Origin is the account state prior to deletion (never be null). + Storages map[common.Hash]common.Hash // Storages contains mutated storage slots. + StoragesOrigin map[common.Hash]common.Hash // StoragesOrigin holds original values of mutated slots; keys are hashes of raw storage slot keys. +} - // storages stores mutated slots, the value should be nil. - storages map[common.Hash][]byte +// AccountUpdate represents an update operation for an Ethereum account. +type AccountUpdate struct { + Address common.Address // Address uniquely identifies the account. + Data *types.StateAccount // Data is the updated account state; nil indicates deletion. + Origin *types.StateAccount // Origin is the previous account state; nil indicates non-existence. + Code *ContractCode // Code contains updated contract code; nil if unchanged. + Storages map[common.Hash]common.Hash // Storages contains updated storage slots. - // storagesOrigin stores the original values of mutated slots in - // prefix-zero-trimmed RLP format. The map key refers to the **HASH** - // of the raw storage slot key. - storagesOrigin map[common.Hash][]byte + // StoragesOriginByKey and StoragesOriginByHash both record original values + // of mutated storage slots: + // - StoragesOriginByKey uses raw storage slot keys. + // - StoragesOriginByHash uses hashed storage slot keys. + StoragesOriginByKey map[common.Hash]common.Hash + StoragesOriginByHash map[common.Hash]common.Hash } -// accountUpdate represents an operation for updating an Ethereum account. -type accountUpdate struct { - address common.Address // address is the unique account identifier - data []byte // data is the slim-RLP encoded account data. - origin []byte // origin is the original value of account data in slim-RLP encoding. - code *contractCode // code represents mutated contract code; nil means it's not modified. - storages map[common.Hash][]byte // storages stores mutated slots in prefix-zero-trimmed RLP format. - - // storagesOriginByKey and storagesOriginByHash both store the original values - // of mutated slots in prefix-zero-trimmed RLP format. The difference is that - // storagesOriginByKey uses the **raw** storage slot key as the map ID, while - // storagesOriginByHash uses the **hash** of the storage slot key instead. - storagesOriginByKey map[common.Hash][]byte - storagesOriginByHash map[common.Hash][]byte -} +// StorageKeyEncoding specifies the encoding scheme of a storage key. +type StorageKeyEncoding int -// stateUpdate represents the difference between two states resulting from state +const ( + // StorageKeyHashed represents a hashed key (e.g. Keccak256). + StorageKeyHashed StorageKeyEncoding = iota + + // StorageKeyPlain represents a raw (unhashed) key. + StorageKeyPlain +) + +// StateUpdate represents the difference between two states resulting from state // execution. It contains information about mutated contract codes, accounts, // and storage slots, along with their original values. -type stateUpdate struct { - originRoot common.Hash // hash of the state before applying mutation - root common.Hash // hash of the state after applying mutation - blockNumber uint64 // Associated block number - - accounts map[common.Hash][]byte // accounts stores mutated accounts in 'slim RLP' encoding - accountsOrigin map[common.Address][]byte // accountsOrigin stores the original values of mutated accounts in 'slim RLP' encoding - - // storages stores mutated slots in 'prefix-zero-trimmed' RLP format. - // The value is keyed by account hash and **storage slot key hash**. - storages map[common.Hash]map[common.Hash][]byte - - // storagesOrigin stores the original values of mutated slots in - // 'prefix-zero-trimmed' RLP format. - // (a) the value is keyed by account hash and **storage slot key** if rawStorageKey is true; - // (b) the value is keyed by account hash and **storage slot key hash** if rawStorageKey is false; - storagesOrigin map[common.Address]map[common.Hash][]byte - rawStorageKey bool - - codes map[common.Address]contractCode // codes contains the set of dirty codes - nodes *trienode.MergedNodeSet // Aggregated dirty nodes caused by state changes +type StateUpdate struct { + OriginRoot common.Hash // Hash of the state before applying mutation + Root common.Hash // Hash of the state after applying mutation + BlockNumber uint64 // Associated block number + BlockHash common.Hash // Associated block hash (set externally for logging) + + // Accounts contains mutated accounts, keyed by address hash. + Accounts map[common.Hash]*types.StateAccount + + // Storages contains mutated storage slots, keyed by address + // hash and storage slot key hash. + Storages map[common.Hash]map[common.Hash]common.Hash + + // AccountsOrigin holds the original values of mutated accounts, keyed by address. + AccountsOrigin map[common.Address]*types.StateAccount + + // StoragesOrigin holds the original values of mutated storage slots. + // The key format depends on StorageKeyType: + // - if StorageKeyType is plain: keyed by account address and plain storage slot key. + // - if StorageKeyType is hashed: keyed by account address and storage slot key hash. + StoragesOrigin map[common.Address]map[common.Hash]common.Hash + StorageKeyType StorageKeyEncoding + + Codes map[common.Address]*ContractCode // Codes contains the set of dirty codes + Nodes *trienode.MergedNodeSet // Aggregated dirty nodes caused by state changes } -// empty returns a flag indicating the state transition is empty or not. -func (sc *stateUpdate) empty() bool { - return sc.originRoot == sc.root +// Empty returns a flag indicating the state transition is empty or not. +func (sc *StateUpdate) Empty() bool { + return sc.OriginRoot == sc.Root } -// newStateUpdate constructs a state update object by identifying the differences +// NewStateUpdate constructs a state update object by identifying the differences // between two states through state execution. It combines the specified account // deletions and account updates to create a complete state update. -// -// rawStorageKey is a flag indicating whether to use the raw storage slot key or -// the hash of the slot key for constructing state update object. -func newStateUpdate(rawStorageKey bool, originRoot common.Hash, root common.Hash, blockNumber uint64, deletes map[common.Hash]*accountDelete, updates map[common.Hash]*accountUpdate, nodes *trienode.MergedNodeSet) *stateUpdate { +func NewStateUpdate(typ StorageKeyEncoding, originRoot common.Hash, root common.Hash, blockNumber uint64, deletes map[common.Hash]*AccountDelete, updates map[common.Hash]*AccountUpdate, nodes *trienode.MergedNodeSet) *StateUpdate { var ( - accounts = make(map[common.Hash][]byte) - accountsOrigin = make(map[common.Address][]byte) - storages = make(map[common.Hash]map[common.Hash][]byte) - storagesOrigin = make(map[common.Address]map[common.Hash][]byte) - codes = make(map[common.Address]contractCode) + accounts = make(map[common.Hash]*types.StateAccount) + accountsOrigin = make(map[common.Address]*types.StateAccount) + storages = make(map[common.Hash]map[common.Hash]common.Hash) + storagesOrigin = make(map[common.Address]map[common.Hash]common.Hash) + codes = make(map[common.Address]*ContractCode) ) - // Since some accounts might be destroyed and recreated within the same + // Since some accounts might be deleted and recreated within the same // block, deletions must be aggregated first. for addrHash, op := range deletes { - addr := op.address + addr := op.Address accounts[addrHash] = nil - accountsOrigin[addr] = op.origin + accountsOrigin[addr] = op.Origin - // If storage wiping exists, the hash of the storage slot key must be used - if len(op.storages) > 0 { - storages[addrHash] = op.storages + if len(op.Storages) > 0 { + storages[addrHash] = op.Storages } - if len(op.storagesOrigin) > 0 { - storagesOrigin[addr] = op.storagesOrigin + if len(op.StoragesOrigin) > 0 { + storagesOrigin[addr] = op.StoragesOrigin } } // Aggregate account updates then. for addrHash, op := range updates { // Aggregate dirty contract codes if they are available. - addr := op.address - if op.code != nil { - codes[addr] = *op.code + addr := op.Address + if op.Code != nil { + codes[addr] = op.Code } - accounts[addrHash] = op.data + accounts[addrHash] = op.Data // Aggregate the account original value. If the account is already - // present in the aggregated accountsOrigin set, skip it. + // present in the aggregated AccountsOrigin set, skip it. if _, found := accountsOrigin[addr]; !found { - accountsOrigin[addr] = op.origin + accountsOrigin[addr] = op.Origin } // Aggregate the storage mutation list. If a slot in op.storages is // already present in aggregated storages set, the value will be // overwritten. - if len(op.storages) > 0 { + if len(op.Storages) > 0 { if _, exist := storages[addrHash]; !exist { - storages[addrHash] = op.storages + storages[addrHash] = op.Storages } else { - maps.Copy(storages[addrHash], op.storages) + maps.Copy(storages[addrHash], op.Storages) } } // Aggregate the storage original values. If the slot is already present - // in aggregated storagesOrigin set, skip it. - storageOriginSet := op.storagesOriginByHash - if rawStorageKey { - storageOriginSet = op.storagesOriginByKey + // in aggregated StoragesOrigin set, skip it. + storageOriginSet := op.StoragesOriginByHash + if typ == StorageKeyPlain { + storageOriginSet = op.StoragesOriginByKey } if len(storageOriginSet) > 0 { origin, exist := storagesOrigin[addr] @@ -164,49 +178,240 @@ func newStateUpdate(rawStorageKey bool, originRoot common.Hash, root common.Hash } } } - return &stateUpdate{ - originRoot: originRoot, - root: root, - blockNumber: blockNumber, - accounts: accounts, - accountsOrigin: accountsOrigin, - storages: storages, - storagesOrigin: storagesOrigin, - rawStorageKey: rawStorageKey, - codes: codes, - nodes: nodes, + return &StateUpdate{ + OriginRoot: originRoot, + Root: root, + BlockNumber: blockNumber, + Accounts: accounts, + AccountsOrigin: accountsOrigin, + Storages: storages, + StoragesOrigin: storagesOrigin, + StorageKeyType: typ, + Codes: codes, + Nodes: nodes, + } +} + +// encodeSlot encodes the storage slot value by trimming all leading zeros +// and then RLP-encoding the result. +func encodeSlot(value common.Hash) []byte { + if value == (common.Hash{}) { + return nil } + blob, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(value[:])) + return blob } -// stateSet converts the current stateUpdate object into a triedb.StateSet -// object. This function extracts the necessary data from the stateUpdate -// struct and formats it into the StateSet structure consumed by the triedb -// package. -func (sc *stateUpdate) stateSet() *triedb.StateSet { - return &triedb.StateSet{ - Accounts: sc.accounts, - AccountsOrigin: sc.accountsOrigin, - Storages: sc.storages, - StoragesOrigin: sc.storagesOrigin, - RawStorageKey: sc.rawStorageKey, +// EncodeMPTState encodes all state mutations alongside their original value +// into the Merkle-Patricia-Trie representation. +// +// It transforms account and storage updates into their corresponding MPT-encoded +// key-value mappings, using the same encoding rules as the Ethereum state trie. +func (sc *StateUpdate) EncodeMPTState() (map[common.Hash][]byte, map[common.Address][]byte, map[common.Hash]map[common.Hash][]byte, map[common.Address]map[common.Hash][]byte) { + var ( + accounts = make(map[common.Hash][]byte, len(sc.Accounts)) + storages = make(map[common.Hash]map[common.Hash][]byte, len(sc.Storages)) + accountOrigin = make(map[common.Address][]byte, len(sc.AccountsOrigin)) + storageOrigin = make(map[common.Address]map[common.Hash][]byte, len(sc.StoragesOrigin)) + ) + for addr, prev := range sc.AccountsOrigin { + if prev == nil { + accountOrigin[addr] = nil + } else { + accountOrigin[addr] = types.SlimAccountRLP(*prev) + } + } + for addrHash, data := range sc.Accounts { + if data == nil { + accounts[addrHash] = nil + } else { + accounts[addrHash] = types.SlimAccountRLP(*data) + } + } + for addr, slots := range sc.StoragesOrigin { + subset := make(map[common.Hash][]byte) + for key, val := range slots { + subset[key] = encodeSlot(val) + } + storageOrigin[addr] = subset + } + for addrHash, slots := range sc.Storages { + subset := make(map[common.Hash][]byte) + for key, val := range slots { + subset[key] = encodeSlot(val) + } + storages[addrHash] = subset + } + return accounts, accountOrigin, storages, storageOrigin +} + +// EncodeUBTState encodes all state mutations alongside their original value +// into the Unified-Binary-Trie representation. +// +// It transforms account and storage updates into their corresponding UBT-encoded +// key-value mappings, using the same encoding rules as the Ethereum state trie. +func (sc *StateUpdate) EncodeUBTState() (map[common.Hash][]byte, map[common.Address][]byte, map[common.Hash]map[common.Hash][]byte, map[common.Address]map[common.Hash][]byte) { + var ( + accounts = make(map[common.Hash][]byte, len(sc.Accounts)) + storages = make(map[common.Hash]map[common.Hash][]byte, len(sc.Storages)) + accountOrigin = make(map[common.Address][]byte, len(sc.AccountsOrigin)) + storageOrigin = make(map[common.Address]map[common.Hash][]byte, len(sc.StoragesOrigin)) + ) + for addr, prev := range sc.AccountsOrigin { + if prev == nil { + accountOrigin[addr] = nil + } else { + accountOrigin[addr] = types.SlimAccountRLP(*prev) + } + } + for addrHash, data := range sc.Accounts { + if data == nil { + accounts[addrHash] = nil + } else { + accounts[addrHash] = types.SlimAccountRLP(*data) + } + } + for addr, slots := range sc.StoragesOrigin { + subset := make(map[common.Hash][]byte) + for key, val := range slots { + subset[key] = encodeSlot(val) + } + storageOrigin[addr] = subset + } + for addrHash, slots := range sc.Storages { + subset := make(map[common.Hash][]byte) + for key, val := range slots { + subset[key] = encodeSlot(val) + } + storages[addrHash] = subset } + return accounts, accountOrigin, storages, storageOrigin } -// markCodeExistence determines whether each piece of contract code referenced -// in this state update actually exists. +// deriveCodeFields derives the missing fields of contract code changes +// such as original code value. // -// Note: This operation is expensive and not needed during normal state transitions. -// It is only required when SizeTracker is enabled to produce accurate state -// statistics. -func (sc *stateUpdate) markCodeExistence(reader ContractCodeReader) { +// Note: This operation is expensive and not needed during normal state +// transitions. It is only required when SizeTracker or StateUpdate hook +// is enabled to produce accurate state statistics. +func (sc *StateUpdate) deriveCodeFields(reader ContractCodeReader) error { cache := make(map[common.Hash]bool) - for addr, code := range sc.codes { - if exists, ok := cache[code.hash]; ok { - code.exists = exists + for addr, code := range sc.Codes { + if code.OriginHash != types.EmptyCodeHash { + blob := reader.Code(addr, code.OriginHash) + if len(blob) == 0 { + return fmt.Errorf("original code of %x is empty", addr) + } + code.OriginBlob = blob + } + if exists, ok := cache[code.Hash]; ok { + code.Duplicate = exists continue } - res := reader.Has(addr, code.hash) - cache[code.hash] = res - code.exists = res + res := reader.Has(addr, code.Hash) + cache[code.Hash] = res + code.Duplicate = res + } + return nil +} + +// ToTracingUpdate converts the internal StateUpdate to an exported tracing.StateUpdate. +func (sc *StateUpdate) ToTracingUpdate() (*tracing.StateUpdate, error) { + update := &tracing.StateUpdate{ + OriginRoot: sc.OriginRoot, + Root: sc.Root, + BlockNumber: sc.BlockNumber, + AccountChanges: make(map[common.Address]*tracing.AccountChange, len(sc.AccountsOrigin)), + StorageChanges: make(map[common.Address]map[common.Hash]*tracing.StorageChange), + CodeChanges: make(map[common.Address]*tracing.CodeChange, len(sc.Codes)), + TrieChanges: make(map[common.Hash]map[string]*tracing.TrieNodeChange), + } + // Gather all account changes + for addr, oldData := range sc.AccountsOrigin { + addrHash := crypto.Keccak256Hash(addr.Bytes()) + newData, exists := sc.Accounts[addrHash] + if !exists { + return nil, fmt.Errorf("account %x not found", addr) + } + change := &tracing.AccountChange{ + Prev: oldData, + New: newData, + } + update.AccountChanges[addr] = change + } + + // Gather all storage slot changes + for addr, slots := range sc.StoragesOrigin { + addrHash := crypto.Keccak256Hash(addr.Bytes()) + subset, exists := sc.Storages[addrHash] + if !exists { + return nil, fmt.Errorf("storage %x not found", addr) + } + storageChanges := make(map[common.Hash]*tracing.StorageChange, len(slots)) + + for key, oldData := range slots { + // Get new value - handle both raw and hashed key formats + var ( + exists bool + newData common.Hash + ) + if sc.StorageKeyType == StorageKeyPlain { + newData, exists = subset[crypto.Keccak256Hash(key.Bytes())] + } else { + newData, exists = subset[key] + } + if !exists { + return nil, fmt.Errorf("storage slot %x-%x not found", addr, key) + } + storageChanges[key] = &tracing.StorageChange{ + Prev: oldData, + New: newData, + } + } + update.StorageChanges[addr] = storageChanges + } + + // Gather all contract code changes + for addr, code := range sc.Codes { + change := &tracing.CodeChange{ + New: &tracing.ContractCode{ + Hash: code.Hash, + Code: code.Blob, + Exists: code.Duplicate, + }, + } + if code.OriginHash != types.EmptyCodeHash { + change.Prev = &tracing.ContractCode{ + Hash: code.OriginHash, + Code: code.OriginBlob, + Exists: true, + } + } + update.CodeChanges[addr] = change + } + + // Gather all trie node changes + if sc.Nodes != nil { + for owner, subset := range sc.Nodes.Sets { + nodeChanges := make(map[string]*tracing.TrieNodeChange, len(subset.Origins)) + for path, oldNode := range subset.Origins { + newNode, exists := subset.Nodes[path] + if !exists { + return nil, fmt.Errorf("node %x-%v not found", owner, path) + } + nodeChanges[path] = &tracing.TrieNodeChange{ + Prev: &trienode.Node{ + Hash: crypto.Keccak256Hash(oldNode), + Blob: oldNode, + }, + New: &trienode.Node{ + Hash: newNode.Hash, + Blob: newNode.Blob, + }, + } + } + update.TrieChanges[owner] = nodeChanges + } } + return update, nil } diff --git a/core/state/sync_test.go b/core/state/sync_test.go index cae0e0a936bc..e5e22deae5fb 100644 --- a/core/state/sync_test.go +++ b/core/state/sync_test.go @@ -222,8 +222,8 @@ func testIterativeStateSync(t *testing.T, count int, commit bool, bypath bool, s codeResults = make([]trie.CodeSyncResult, len(codeElements)) ) for i, element := range codeElements { - data, err := cReader.Code(common.Address{}, element.code) - if err != nil || len(data) == 0 { + data := cReader.Code(common.Address{}, element.code) + if len(data) == 0 { t.Fatalf("failed to retrieve contract bytecode for hash %x", element.code) } codeResults[i] = trie.CodeSyncResult{Hash: element.code, Data: data} @@ -346,8 +346,8 @@ func testIterativeDelayedStateSync(t *testing.T, scheme string) { if len(codeElements) > 0 { codeResults := make([]trie.CodeSyncResult, len(codeElements)/2+1) for i, element := range codeElements[:len(codeResults)] { - data, err := cReader.Code(common.Address{}, element.code) - if err != nil || len(data) == 0 { + data := cReader.Code(common.Address{}, element.code) + if len(data) == 0 { t.Fatalf("failed to retrieve contract bytecode for %x", element.code) } codeResults[i] = trie.CodeSyncResult{Hash: element.code, Data: data} @@ -452,8 +452,8 @@ func testIterativeRandomStateSync(t *testing.T, count int, scheme string) { if len(codeQueue) > 0 { results := make([]trie.CodeSyncResult, 0, len(codeQueue)) for hash := range codeQueue { - data, err := cReader.Code(common.Address{}, hash) - if err != nil || len(data) == 0 { + data := cReader.Code(common.Address{}, hash) + if len(data) == 0 { t.Fatalf("failed to retrieve node data for %x", hash) } results = append(results, trie.CodeSyncResult{Hash: hash, Data: data}) @@ -551,8 +551,8 @@ func testIterativeRandomDelayedStateSync(t *testing.T, scheme string) { for hash := range codeQueue { delete(codeQueue, hash) - data, err := cReader.Code(common.Address{}, hash) - if err != nil || len(data) == 0 { + data := cReader.Code(common.Address{}, hash) + if len(data) == 0 { t.Fatalf("failed to retrieve node data for %x", hash) } results = append(results, trie.CodeSyncResult{Hash: hash, Data: data}) @@ -671,8 +671,8 @@ func testIncompleteStateSync(t *testing.T, scheme string) { if len(codeQueue) > 0 { results := make([]trie.CodeSyncResult, 0, len(codeQueue)) for hash := range codeQueue { - data, err := cReader.Code(common.Address{}, hash) - if err != nil || len(data) == 0 { + data := cReader.Code(common.Address{}, hash) + if len(data) == 0 { t.Fatalf("failed to retrieve node data for %x", hash) } results = append(results, trie.CodeSyncResult{Hash: hash, Data: data}) diff --git a/core/state/transient_storage.go b/core/state/transient_storage.go index 3bb495542553..a3cfaceb3eba 100644 --- a/core/state/transient_storage.go +++ b/core/state/transient_storage.go @@ -25,8 +25,13 @@ import ( "github.com/ethereum/go-ethereum/common" ) +type transientStorageKey struct { + addr common.Address + key common.Hash +} + // transientStorage is a representation of EIP-1153 "Transient Storage". -type transientStorage map[common.Address]Storage +type transientStorage map[transientStorageKey]common.Hash // newTransientStorage creates a new instance of a transientStorage. func newTransientStorage() transientStorage { @@ -35,52 +40,43 @@ func newTransientStorage() transientStorage { // Set sets the transient-storage `value` for `key` at the given `addr`. func (t transientStorage) Set(addr common.Address, key, value common.Hash) { + tsKey := transientStorageKey{addr: addr, key: key} if value == (common.Hash{}) { // this is a 'delete' - if _, ok := t[addr]; ok { - delete(t[addr], key) - if len(t[addr]) == 0 { - delete(t, addr) - } - } + delete(t, tsKey) } else { - if _, ok := t[addr]; !ok { - t[addr] = make(Storage) - } - t[addr][key] = value + t[tsKey] = value } } // Get gets the transient storage for `key` at the given `addr`. func (t transientStorage) Get(addr common.Address, key common.Hash) common.Hash { - val, ok := t[addr] - if !ok { - return common.Hash{} - } - return val[key] + tsKey := transientStorageKey{addr: addr, key: key} + return t[tsKey] } // Copy does a deep copy of the transientStorage func (t transientStorage) Copy() transientStorage { - storage := make(transientStorage) - for key, value := range t { - storage[key] = value.Copy() - } - return storage + return maps.Clone(t) } // PrettyPrint prints the contents of the access list in a human-readable form func (t transientStorage) PrettyPrint() string { out := new(strings.Builder) - sortedAddrs := slices.Collect(maps.Keys(t)) - slices.SortFunc(sortedAddrs, common.Address.Cmp) + sortedTSKeys := slices.Collect(maps.Keys(t)) + slices.SortFunc(sortedTSKeys, func(a, b transientStorageKey) int { + r := a.addr.Cmp(b.addr) + if r != 0 { + return r + } + return a.key.Cmp(b.key) + }) - for _, addr := range sortedAddrs { - fmt.Fprintf(out, "%#x:", addr) - storage := t[addr] - sortedKeys := slices.Collect(maps.Keys(storage)) - slices.SortFunc(sortedKeys, common.Hash.Cmp) - for _, key := range sortedKeys { - fmt.Fprintf(out, " %X : %X\n", key, storage[key]) + for i := 0; i < len(sortedTSKeys); { + tsKey := sortedTSKeys[i] + fmt.Fprintf(out, "%#x:", tsKey.addr) + for ; i < len(sortedTSKeys) && sortedTSKeys[i].addr == tsKey.addr; i++ { + tsKey2 := sortedTSKeys[i] + fmt.Fprintf(out, " %X : %X\n", tsKey2.key, t[tsKey2]) } } return out.String() diff --git a/core/state/trie_prefetcher.go b/core/state/trie_prefetcher.go index a9faddcdff6c..a0310eb3b39d 100644 --- a/core/state/trie_prefetcher.go +++ b/core/state/trie_prefetcher.go @@ -40,7 +40,7 @@ var ( // // Note, the prefetcher's API is not thread safe. type triePrefetcher struct { - verkle bool // Flag whether the prefetcher is in verkle mode + isUBT bool // Flag whether the prefetcher is in UBT mode db Database // Database to fetch trie nodes through root common.Hash // Root hash of the account trie for metrics fetchers map[string]*subfetcher // Subfetchers for each trie @@ -67,7 +67,7 @@ type triePrefetcher struct { func newTriePrefetcher(db Database, root common.Hash, namespace string, noreads bool) *triePrefetcher { prefix := triePrefetchMetricsPrefix + namespace return &triePrefetcher{ - verkle: db.TrieDB().IsVerkle(), + isUBT: db.Type().Is(TypeUBT), db: db, root: root, fetchers: make(map[string]*subfetcher), // Active prefetchers use the fetchers map @@ -206,8 +206,8 @@ func (p *triePrefetcher) used(owner common.Hash, root common.Hash, usedAddr []co // trieID returns an unique trie identifier consists the trie owner and root hash. func (p *triePrefetcher) trieID(owner common.Hash, root common.Hash) string { - // The trie in verkle is only identified by state root - if p.verkle { + // The trie in ubt is only identified by state root + if p.isUBT { return p.root.Hex() } // The trie in merkle is either identified by state root (account trie), @@ -340,12 +340,12 @@ func (sf *subfetcher) terminate(async bool) { // openTrie resolves the target trie from database for prefetching. func (sf *subfetcher) openTrie() error { - // Open the verkle tree if the sub-fetcher is in verkle mode. Note, there is - // only a single fetcher for verkle. - if sf.db.TrieDB().IsVerkle() { + // Open the ubt tree if the sub-fetcher is in ubt mode. Note, there is + // only a single fetcher for ubt. + if sf.db.Type().Is(TypeUBT) { tr, err := sf.db.OpenTrie(sf.state) if err != nil { - log.Warn("Trie prefetcher failed opening verkle trie", "root", sf.root, "err", err) + log.Warn("Trie prefetcher failed opening UBT trie", "root", sf.root, "err", err) return err } sf.trie = tr diff --git a/core/state/trie_prefetcher_test.go b/core/state/trie_prefetcher_test.go index 41349c0c0e70..8a03d93a0877 100644 --- a/core/state/trie_prefetcher_test.go +++ b/core/state/trie_prefetcher_test.go @@ -68,7 +68,7 @@ func TestUseAfterTerminate(t *testing.T) { func TestVerklePrefetcher(t *testing.T) { disk := rawdb.NewMemoryDatabase() - db := triedb.NewDatabase(disk, triedb.VerkleDefaults) + db := triedb.NewDatabase(disk, triedb.UBTDefaults) sdb := NewDatabase(db, nil) state, err := New(types.EmptyRootHash, sdb) @@ -86,18 +86,17 @@ func TestVerklePrefetcher(t *testing.T) { root, _ := state.Commit(0, true, false) state, _ = New(root, sdb) - sRoot := state.GetStorageRoot(addr) fetcher := newTriePrefetcher(sdb, root, "", false) // Read account fetcher.prefetch(common.Hash{}, root, common.Address{}, []common.Address{addr}, nil, false) // Read storage slot - fetcher.prefetch(crypto.Keccak256Hash(addr.Bytes()), sRoot, addr, nil, []common.Hash{skey}, false) + fetcher.prefetch(crypto.Keccak256Hash(addr.Bytes()), common.Hash{}, addr, nil, []common.Hash{skey}, false) fetcher.terminate(false) accountTrie := fetcher.trie(common.Hash{}, root) - storageTrie := fetcher.trie(crypto.Keccak256Hash(addr.Bytes()), sRoot) + storageTrie := fetcher.trie(crypto.Keccak256Hash(addr.Bytes()), common.Hash{}) rootA := accountTrie.Hash() rootB := storageTrie.Hash() diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index 1c738c1e38e2..d99611ff2c66 100644 --- a/core/state_prefetcher.go +++ b/core/state_prefetcher.go @@ -93,6 +93,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c } // Execute the message to preload the implicit touched states evm := vm.NewEVM(NewEVMBlockContext(header, p.chain, nil), stateCpy, p.config, cfg) + defer evm.Release() // Convert the transaction into an executable message and pre-cache its sender msg, err := TransactionToMessage(tx, signer, header.BaseFee) @@ -103,11 +104,11 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c // Disable the nonce check msg.SkipNonceChecks = true - stateCpy.SetTxContext(tx.Hash(), i) + stateCpy.SetTxContext(tx.Hash(), i, uint32(i+1)) // We attempt to apply a transaction. The goal is not to execute // the transaction successfully, rather to warm up touched data slots. - if _, err := ApplyMessage(evm, msg, new(GasPool).AddGas(block.GasLimit())); err != nil { + if _, err := ApplyMessage(evm, msg, nil); err != nil { fails.Add(1) return nil // Ugh, something went horribly wrong, bail out } diff --git a/core/state_processor.go b/core/state_processor.go index b4b22e4318b4..13466b7815a5 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -17,17 +17,22 @@ package core import ( + "context" "fmt" "math/big" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/trie" + "github.com/holiman/uint256" ) // StateProcessor is a basic Processor, which takes care of transitioning @@ -57,91 +62,113 @@ func (p *StateProcessor) chainConfig() *params.ChainConfig { // Process returns the receipts and logs accumulated during the process and // returns the amount of gas that was used in the process. If any of the // transactions failed to execute due to insufficient gas it will return an error. -func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (*ProcessResult, error) { +func (p *StateProcessor) Process(ctx context.Context, block *types.Block, statedb *state.StateDB, cfg vm.Config) (*ProcessResult, error) { var ( config = p.chainConfig() - receipts types.Receipts - usedGas = new(uint64) + receipts = make(types.Receipts, 0, len(block.Transactions())) header = block.Header() blockHash = block.Hash() blockNumber = block.Number() allLogs []*types.Log - gp = new(GasPool).AddGas(block.GasLimit()) + gp = NewGasPool(block.GasLimit()) ) - var tracingStateDB = vm.StateDB(statedb) if hooks := cfg.Tracer; hooks != nil { tracingStateDB = state.NewHookedState(statedb, hooks) } - // Mutate the block and state according to any hard-fork specs if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(block.Number()) == 0 { misc.ApplyDAOHardFork(tracingStateDB) } var ( - context vm.BlockContext + context = NewEVMBlockContext(header, p.chain, nil) signer = types.MakeSigner(config, header.Number, header.Time) + evm = vm.NewEVM(context, tracingStateDB, config, cfg) ) - - // Apply pre-execution system calls. - context = NewEVMBlockContext(header, p.chain, nil) - evm := vm.NewEVM(context, tracingStateDB, config, cfg) - - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if config.IsPrague(block.Number(), block.Time()) || config.IsVerkle(block.Number(), block.Time()) { - ProcessParentBlockHash(block.ParentHash(), evm) - } - + defer evm.Release() + // Run the pre-execution system calls + PreExecution(ctx, block.BeaconRoot(), block.ParentHash(), config, evm, block.Number(), block.Time()) // Iterate over and process the individual transactions for i, tx := range block.Transactions() { msg, err := TransactionToMessage(tx, signer, header.BaseFee) if err != nil { return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } - statedb.SetTxContext(tx.Hash(), i) + statedb.SetTxContext(tx.Hash(), i, uint32(i+1)) + _, _, spanEnd := telemetry.StartSpan(ctx, "core.ApplyTransactionWithEVM", + telemetry.StringAttribute("tx.hash", tx.Hash().Hex()), + telemetry.Int64Attribute("tx.index", int64(i)), + ) - receipt, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, context.Time, tx, usedGas, evm) + receipt, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, context.Time, tx, evm) if err != nil { + spanEnd(&err) return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } receipts = append(receipts, receipt) allLogs = append(allLogs, receipt.Logs...) + spanEnd(nil) + } + requests, err := PostExecution(ctx, config, block.Number(), block.Time(), allLogs, evm, uint32(len(block.Transactions())+1)) + if err != nil { + return nil, err + } + // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) + p.chain.Engine().Finalize(p.chain, header, tracingStateDB, block.Body()) + + return &ProcessResult{ + Receipts: receipts, + Requests: requests, + Logs: allLogs, + GasUsed: gp.Used(), + }, nil +} + +// PreExecution processes pre-execution system calls. +func PreExecution(ctx context.Context, beaconRoot *common.Hash, parent common.Hash, config *params.ChainConfig, evm *vm.EVM, number *big.Int, time uint64) { + _, _, spanEnd := telemetry.StartSpan(ctx, "core.preExecution") + defer spanEnd(nil) + + // EIP-4788 + if beaconRoot != nil { + ProcessBeaconBlockRoot(*beaconRoot, evm) } + // EIP-2935 + if config.IsPrague(number, time) || config.IsUBT(number, time) { + ProcessParentBlockHash(parent, evm) + } +} + +// PostExecution processes post-execution system calls when Prague is enabled. +// If Prague is not activated, it returns null requests to differentiate from +// empty requests. +func PostExecution(ctx context.Context, config *params.ChainConfig, number *big.Int, time uint64, allLogs []*types.Log, evm *vm.EVM, blockAccessIndex uint32) (requests [][]byte, err error) { + _, _, spanEnd := telemetry.StartSpan(ctx, "core.postExecution") + defer spanEnd(&err) + // Read requests if Prague is enabled. - var requests [][]byte - if config.IsPrague(block.Number(), block.Time()) { + if config.IsPrague(number, time) { requests = [][]byte{} // EIP-6110 if err := ParseDepositLogs(&requests, allLogs, config); err != nil { return nil, fmt.Errorf("failed to parse deposit logs: %w", err) } // EIP-7002 - if err := ProcessWithdrawalQueue(&requests, evm); err != nil { + if err := ProcessWithdrawalQueue(&requests, evm, blockAccessIndex); err != nil { return nil, fmt.Errorf("failed to process withdrawal queue: %w", err) } // EIP-7251 - if err := ProcessConsolidationQueue(&requests, evm); err != nil { + if err := ProcessConsolidationQueue(&requests, evm, blockAccessIndex); err != nil { return nil, fmt.Errorf("failed to process consolidation queue: %w", err) } } - - // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) - p.chain.Engine().Finalize(p.chain, header, tracingStateDB, block.Body()) - - return &ProcessResult{ - Receipts: receipts, - Requests: requests, - Logs: allLogs, - GasUsed: *usedGas, - }, nil + return requests, nil } // ApplyTransactionWithEVM attempts to apply a transaction to the given state database // and uses the input parameters for its environment similar to ApplyTransaction. However, // this method takes an already created EVM instance as input. -func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, blockTime uint64, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (receipt *types.Receipt, err error) { +func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, blockTime uint64, tx *types.Transaction, evm *vm.EVM) (receipt *types.Receipt, err error) { if hooks := evm.Config.Tracer; hooks != nil { if hooks.OnTxStart != nil { hooks.OnTxStart(evm.GetVMContext(), tx, msg.From) @@ -162,27 +189,31 @@ func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, } else { root = statedb.IntermediateRoot(evm.ChainConfig().IsEIP158(blockNumber)).Bytes() } - *usedGas += result.UsedGas - // Merge the tx-local access event into the "block-local" one, in order to collect // all values, so that the witness can be built. - if statedb.Database().TrieDB().IsVerkle() { + if statedb.Database().Type().Is(state.TypeUBT) { statedb.AccessEvents().Merge(evm.AccessEvents) } - return MakeReceipt(evm, result, statedb, blockNumber, blockHash, blockTime, tx, *usedGas, root), nil + return MakeReceipt(evm, result, statedb, blockNumber, blockHash, blockTime, tx, gp.CumulativeUsed(), root), nil } // MakeReceipt generates the receipt object for a transaction given its execution result. -func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, blockTime uint64, tx *types.Transaction, usedGas uint64, root []byte) *types.Receipt { - // Create a new receipt for the transaction, storing the intermediate root and gas used - // by the tx. - receipt := &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: usedGas} +func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, blockTime uint64, tx *types.Transaction, cumulativeGas uint64, root []byte) *types.Receipt { + // Create a new receipt for the transaction, storing the intermediate root + // and gas used by the tx. + // + // The cumulative gas used equals the sum of gasUsed across all preceding + // txs with refunded gas deducted. + receipt := &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: cumulativeGas} if result.Failed() { receipt.Status = types.ReceiptStatusFailed } else { receipt.Status = types.ReceiptStatusSuccessful } receipt.TxHash = tx.Hash() + + // GasUsed = max(tx_gas_used - gas_refund, calldata_floor_gas_cost), unchanged + // in the Amsterdam fork. receipt.GasUsed = result.UsedGas if tx.Type() == types.BlobTxType { @@ -206,15 +237,15 @@ func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, b // ApplyTransaction attempts to apply a transaction to the given state database // and uses the input parameters for its environment. It returns the receipt -// for the transaction, gas used and an error if the transaction failed, +// for the transaction and an error if the transaction failed, // indicating the block was invalid. -func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64) (*types.Receipt, error) { +func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction) (*types.Receipt, error) { msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time), header.BaseFee) if err != nil { return nil, err } // Create a new context to be used in the EVM environment - return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), header.Time, tx, usedGas, evm) + return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), header.Time, tx, evm) } // ProcessBeaconBlockRoot applies the EIP-4788 system call to the beacon block root @@ -229,15 +260,19 @@ func ProcessBeaconBlockRoot(beaconRoot common.Hash, evm *vm.EVM) { msg := &Message{ From: params.SystemAddress, GasLimit: 30_000_000, - GasPrice: common.Big0, - GasFeeCap: common.Big0, - GasTipCap: common.Big0, + GasPrice: uint256.NewInt(0), + GasFeeCap: uint256.NewInt(0), + GasTipCap: uint256.NewInt(0), To: ¶ms.BeaconRootsAddress, Data: beaconRoot[:], } evm.SetTxContext(NewEVMTxContext(msg)) + evm.StateDB.SetTxContext(common.Hash{}, 0, 0) evm.StateDB.AddAddressToAccessList(params.BeaconRootsAddress) - _, _, _ = evm.Call(msg.From, *msg.To, msg.Data, 30_000_000, common.U2560) + _, _, _ = evm.Call(msg.From, *msg.To, msg.Data, vm.NewGasBudget(30_000_000), common.U2560) + if evm.StateDB.AccessEvents() != nil { + evm.StateDB.AccessEvents().Merge(evm.AccessEvents) + } evm.StateDB.Finalise(true) } @@ -253,15 +288,16 @@ func ProcessParentBlockHash(prevHash common.Hash, evm *vm.EVM) { msg := &Message{ From: params.SystemAddress, GasLimit: 30_000_000, - GasPrice: common.Big0, - GasFeeCap: common.Big0, - GasTipCap: common.Big0, + GasPrice: uint256.NewInt(0), + GasFeeCap: uint256.NewInt(0), + GasTipCap: uint256.NewInt(0), To: ¶ms.HistoryStorageAddress, Data: prevHash.Bytes(), } evm.SetTxContext(NewEVMTxContext(msg)) + evm.StateDB.SetTxContext(common.Hash{}, 0, 0) evm.StateDB.AddAddressToAccessList(params.HistoryStorageAddress) - _, _, err := evm.Call(msg.From, *msg.To, msg.Data, 30_000_000, common.U2560) + _, _, err := evm.Call(msg.From, *msg.To, msg.Data, vm.NewGasBudget(30_000_000), common.U2560) if err != nil { panic(err) } @@ -273,17 +309,17 @@ func ProcessParentBlockHash(prevHash common.Hash, evm *vm.EVM) { // ProcessWithdrawalQueue calls the EIP-7002 withdrawal queue contract. // It returns the opaque request data returned by the contract. -func ProcessWithdrawalQueue(requests *[][]byte, evm *vm.EVM) error { - return processRequestsSystemCall(requests, evm, 0x01, params.WithdrawalQueueAddress) +func ProcessWithdrawalQueue(requests *[][]byte, evm *vm.EVM, blockAccessIndex uint32) error { + return processRequestsSystemCall(requests, evm, 0x01, params.WithdrawalQueueAddress, blockAccessIndex) } // ProcessConsolidationQueue calls the EIP-7251 consolidation queue contract. // It returns the opaque request data returned by the contract. -func ProcessConsolidationQueue(requests *[][]byte, evm *vm.EVM) error { - return processRequestsSystemCall(requests, evm, 0x02, params.ConsolidationQueueAddress) +func ProcessConsolidationQueue(requests *[][]byte, evm *vm.EVM, blockAccessIndex uint32) error { + return processRequestsSystemCall(requests, evm, 0x02, params.ConsolidationQueueAddress, blockAccessIndex) } -func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte, addr common.Address) error { +func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte, addr common.Address, blockAccessIndex uint32) error { if tracer := evm.Config.Tracer; tracer != nil { onSystemCallStart(tracer, evm.GetVMContext()) if tracer.OnSystemCallEnd != nil { @@ -293,14 +329,18 @@ func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte msg := &Message{ From: params.SystemAddress, GasLimit: 30_000_000, - GasPrice: common.Big0, - GasFeeCap: common.Big0, - GasTipCap: common.Big0, + GasPrice: uint256.NewInt(0), + GasFeeCap: uint256.NewInt(0), + GasTipCap: uint256.NewInt(0), To: &addr, } evm.SetTxContext(NewEVMTxContext(msg)) + evm.StateDB.SetTxContext(common.Hash{}, 0, blockAccessIndex) evm.StateDB.AddAddressToAccessList(addr) - ret, _, err := evm.Call(msg.From, *msg.To, msg.Data, 30_000_000, common.U2560) + ret, _, err := evm.Call(msg.From, *msg.To, msg.Data, vm.NewGasBudget(30_000_000), common.U2560) + if evm.StateDB.AccessEvents() != nil { + evm.StateDB.AccessEvents().Merge(evm.AccessEvents) + } evm.StateDB.Finalise(true) if err != nil { return fmt.Errorf("system call failed to execute: %v", err) @@ -344,3 +384,11 @@ func onSystemCallStart(tracer *tracing.Hooks, ctx *tracing.VMContext) { tracer.OnSystemCallStart() } } + +// AssembleBlock finalizes the state and assembles the block with provided +// body and receipts. +func AssembleBlock(engine consensus.Engine, chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) *types.Block { + engine.Finalize(chain, header, state, body) + header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) + return types.NewBlock(header, body, receipts, trie.NewStackTrie(nil)) +} diff --git a/core/state_processor_test.go b/core/state_processor_test.go index 9d6cbdbc8b52..2700aed50515 100644 --- a/core/state_processor_test.go +++ b/core/state_processor_test.go @@ -31,10 +31,10 @@ import ( "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/trie" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) func u64(val uint64) *uint64 { return &val } @@ -398,7 +398,7 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr var receipts []*types.Receipt // The post-state result doesn't need to be correct (this is a bad block), but we do need something there // Preferably something unique. So let's use a combo of blocknum + txhash - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() hasher.Write(header.Number.Bytes()) var cumulativeGas uint64 var nBlobs int @@ -422,6 +422,9 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr beaconRoot := common.HexToHash("0xbeac00") header.ParentBeaconRoot = &beaconRoot } + if config.IsAmsterdam(header.Number, header.Time) { + header.SlotNumber = new(uint64) + } // Assemble and return the final block for sealing body := &types.Body{Transactions: txs} if config.IsShanghai(header.Number, header.Time) { diff --git a/core/state_transition.go b/core/state_transition.go index bf5ac07636d5..0a6994505d3a 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -34,7 +34,7 @@ import ( // ExecutionResult includes all output after executing given evm // message no matter the execution itself is successful or not. type ExecutionResult struct { - UsedGas uint64 // Total used gas, not including the refunded gas + UsedGas uint64 // Total used gas, refunded gas is deducted MaxUsedGas uint64 // Maximum gas consumed during execution, excluding gas refunds. Err error // Any error encountered during the execution(listed in core/vm/errors.go) ReturnData []byte // Returned data from evm(function result or data supplied with revert opcode) @@ -68,7 +68,7 @@ func (result *ExecutionResult) Revert() []byte { } // IntrinsicGas computes the 'intrinsic gas' for a message with the given data. -func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.SetCodeAuthorization, isContractCreation, isHomestead, isEIP2028, isEIP3860 bool) (uint64, error) { +func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.SetCodeAuthorization, isContractCreation, isHomestead, isEIP2028, isEIP3860, isAmsterdam bool) (vm.GasCosts, error) { // Set the starting gas for the raw transaction var gas uint64 if isContractCreation && isHomestead { @@ -89,46 +89,110 @@ func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.Set nonZeroGas = params.TxDataNonZeroGasEIP2028 } if (math.MaxUint64-gas)/nonZeroGas < nz { - return 0, ErrGasUintOverflow + return vm.GasCosts{}, ErrGasUintOverflow } gas += nz * nonZeroGas if (math.MaxUint64-gas)/params.TxDataZeroGas < z { - return 0, ErrGasUintOverflow + return vm.GasCosts{}, ErrGasUintOverflow } gas += z * params.TxDataZeroGas if isContractCreation && isEIP3860 { lenWords := toWordSize(dataLen) if (math.MaxUint64-gas)/params.InitCodeWordGas < lenWords { - return 0, ErrGasUintOverflow + return vm.GasCosts{}, ErrGasUintOverflow } gas += lenWords * params.InitCodeWordGas } } if accessList != nil { - gas += uint64(len(accessList)) * params.TxAccessListAddressGas - gas += uint64(accessList.StorageKeys()) * params.TxAccessListStorageKeyGas + addresses := uint64(len(accessList)) + storageKeys := uint64(accessList.StorageKeys()) + if (math.MaxUint64-gas)/params.TxAccessListAddressGas < addresses { + return vm.GasCosts{}, ErrGasUintOverflow + } + gas += addresses * params.TxAccessListAddressGas + if (math.MaxUint64-gas)/params.TxAccessListStorageKeyGas < storageKeys { + return vm.GasCosts{}, ErrGasUintOverflow + } + gas += storageKeys * params.TxAccessListStorageKeyGas + + // EIP-7981: access list data is charged in addition to the base charge. + if isAmsterdam { + const ( + addressCost = common.AddressLength * params.TxCostFloorPerToken7976 * params.TxTokenPerNonZeroByte + storageKeyCost = common.HashLength * params.TxCostFloorPerToken7976 * params.TxTokenPerNonZeroByte + ) + if (math.MaxUint64-gas)/addressCost < addresses { + return vm.GasCosts{}, ErrGasUintOverflow + } + gas += addresses * addressCost + if (math.MaxUint64-gas)/storageKeyCost < storageKeys { + return vm.GasCosts{}, ErrGasUintOverflow + } + gas += storageKeys * storageKeyCost + } } if authList != nil { gas += uint64(len(authList)) * params.CallNewAccountGas } - return gas, nil + return vm.GasCosts{RegularGas: gas}, nil } // FloorDataGas computes the minimum gas required for a transaction based on its data tokens (EIP-7623). -func FloorDataGas(data []byte) (uint64, error) { +func FloorDataGas(rules params.Rules, data []byte, accessList types.AccessList) (uint64, error) { var ( - z = uint64(bytes.Count(data, []byte{0})) - nz = uint64(len(data)) - z - tokens = nz*params.TxTokenPerNonZeroByte + z + tokens uint64 + tokenCost uint64 ) + if rules.IsAmsterdam { + // EIP-7976 changes how calldata is priced. + // From 10/40 to 64/64 for zero/non-zero bytes. + tokenCost = params.TxCostFloorPerToken7976 + dataLen := uint64(len(data)) + if math.MaxUint64/params.TxTokenPerNonZeroByte < dataLen { + return 0, ErrGasUintOverflow + } + tokens = dataLen * params.TxTokenPerNonZeroByte + + // EIP-7981 adds additional tokens for every entry in the accesslist + const addressTokenCost = uint64(common.AddressLength) * params.TxTokenPerNonZeroByte + addresses := uint64(len(accessList)) + if (math.MaxUint64-tokens)/addressTokenCost < addresses { + return 0, ErrGasUintOverflow + } + tokens += addresses * addressTokenCost + + const storageKeyTokenCost = uint64(common.HashLength) * params.TxTokenPerNonZeroByte + storageKeys := uint64(accessList.StorageKeys()) + if (math.MaxUint64-tokens)/storageKeyTokenCost < storageKeys { + return 0, ErrGasUintOverflow + } + tokens += storageKeys * storageKeyTokenCost + } else { + var ( + z = uint64(bytes.Count(data, []byte{0})) + nz = uint64(len(data)) - z + ) + // Pre-Amsterdam + if math.MaxUint64/params.TxTokenPerNonZeroByte < nz { + return 0, ErrGasUintOverflow + } + tokens = nz * params.TxTokenPerNonZeroByte + if math.MaxUint64-tokens < z { + return 0, ErrGasUintOverflow + } + tokens += z + tokenCost = params.TxCostFloorPerToken + } + // Check for overflow - if (math.MaxUint64-params.TxGas)/params.TxCostFloorPerToken < tokens { + if (math.MaxUint64-params.TxGas)/tokenCost < tokens { return 0, ErrGasUintOverflow } // Minimum gas required for a transaction based on its data tokens (EIP-7623). - return params.TxGas + tokens*params.TxCostFloorPerToken, nil + return params.TxGas + tokens*tokenCost, nil } // toWordSize returns the ceiled word size required for init code payment calculation. @@ -146,14 +210,14 @@ type Message struct { To *common.Address From common.Address Nonce uint64 - Value *big.Int + Value *uint256.Int GasLimit uint64 - GasPrice *big.Int - GasFeeCap *big.Int - GasTipCap *big.Int + GasPrice *uint256.Int + GasFeeCap *uint256.Int + GasTipCap *uint256.Int Data []byte AccessList types.AccessList - BlobGasFeeCap *big.Int + BlobGasFeeCap *uint256.Int BlobHashes []common.Hash SetCodeAuthorizations []types.SetCodeAuthorization @@ -174,32 +238,64 @@ type Message struct { // TransactionToMessage converts a transaction into a Message. func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) { + from, err := types.Sender(s, tx) + if err != nil { + return nil, err + } + gasPrice, overflow := uint256.FromBig(tx.GasPrice()) + if overflow { + return nil, fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh, + from.Hex(), tx.GasPrice().BitLen()) + } + txGasFeeCap := tx.GasFeeCap() + gasFeeCap, overflow := uint256.FromBig(txGasFeeCap) + if overflow { + return nil, fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh, + from.Hex(), tx.GasFeeCap().BitLen()) + } + txGasTipCap := tx.GasTipCap() + gasTipCap, overflow := uint256.FromBig(txGasTipCap) + if overflow { + return nil, fmt.Errorf("%w: address %v, maxPriorityFeePerGas bit length: %d", ErrTipVeryHigh, + from.Hex(), tx.GasTipCap().BitLen()) + } + value, overflow := uint256.FromBig(tx.Value()) + if overflow { + return nil, fmt.Errorf("value exceeds 256 bits: address %v", from.Hex()) + } + blobGasFeeCap, overflow := uint256.FromBig(tx.BlobGasFeeCap()) + if overflow { + return nil, fmt.Errorf("blobGasFeeCap exceeds 256 bits: address %v", from.Hex()) + } + msg := &Message{ + From: from, Nonce: tx.Nonce(), GasLimit: tx.Gas(), - GasPrice: new(big.Int).Set(tx.GasPrice()), - GasFeeCap: new(big.Int).Set(tx.GasFeeCap()), - GasTipCap: new(big.Int).Set(tx.GasTipCap()), + GasPrice: gasPrice, + GasFeeCap: gasFeeCap, + GasTipCap: gasTipCap, To: tx.To(), - Value: tx.Value(), + Value: value, Data: tx.Data(), AccessList: tx.AccessList(), SetCodeAuthorizations: tx.SetCodeAuthorizations(), SkipNonceChecks: false, SkipTransactionChecks: false, BlobHashes: tx.BlobHashes(), - BlobGasFeeCap: tx.BlobGasFeeCap(), + BlobGasFeeCap: blobGasFeeCap, } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil { - msg.GasPrice = msg.GasPrice.Add(msg.GasTipCap, baseFee) - if msg.GasPrice.Cmp(msg.GasFeeCap) > 0 { - msg.GasPrice = msg.GasFeeCap + effectiveGasPrice := new(big.Int).Add(baseFee, txGasTipCap) + if effectiveGasPrice.Cmp(txGasFeeCap) > 0 { + effectiveGasPrice = txGasFeeCap } + // EffectiveGasPrice is already capped by txGasFeeCap, therefore + // the overflow check is not required. + msg.GasPrice = uint256.MustFromBig(effectiveGasPrice) } - var err error - msg.From, err = types.Sender(s, tx) - return msg, err + return msg, nil } // ApplyMessage computes the new state by applying the given message @@ -210,6 +306,11 @@ func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.In // indicates a core error meaning that the message would always fail for that particular // state and would never be accepted within a block. func ApplyMessage(evm *vm.EVM, msg *Message, gp *GasPool) (*ExecutionResult, error) { + // Do not panic if the gas pool is nil. This is allowed when executing + // a single message via RPC invocation. + if gp == nil { + gp = NewGasPool(msg.GasLimit) + } evm.SetTxContext(NewEVMTxContext(msg)) return newStateTransition(evm, msg, gp).execute() } @@ -237,12 +338,12 @@ func ApplyMessage(evm *vm.EVM, msg *Message, gp *GasPool) (*ExecutionResult, err // 5. Run Script section // 6. Derive new state root type stateTransition struct { - gp *GasPool - msg *Message - gasRemaining uint64 - initialGas uint64 - state vm.StateDB - evm *vm.EVM + gp *GasPool + msg *Message + initialBudget vm.GasBudget + gasRemaining vm.GasBudget + state vm.StateDB + evm *vm.EVM } // newStateTransition initialises and returns a new state transition object. @@ -264,46 +365,70 @@ func (st *stateTransition) to() common.Address { } func (st *stateTransition) buyGas() error { - mgval := new(big.Int).SetUint64(st.msg.GasLimit) - mgval.Mul(mgval, st.msg.GasPrice) - balanceCheck := new(big.Int).Set(mgval) + mgval := new(uint256.Int).SetUint64(st.msg.GasLimit) + _, overflow := mgval.MulOverflow(mgval, st.msg.GasPrice) + if overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } + balanceCheck := new(uint256.Int).Set(mgval) if st.msg.GasFeeCap != nil { balanceCheck.SetUint64(st.msg.GasLimit) - balanceCheck = balanceCheck.Mul(balanceCheck, st.msg.GasFeeCap) + if _, overflow := balanceCheck.MulOverflow(balanceCheck, st.msg.GasFeeCap); overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } + } + if st.msg.Value != nil { + if _, overflow := balanceCheck.AddOverflow(balanceCheck, st.msg.Value); overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } } - balanceCheck.Add(balanceCheck, st.msg.Value) if st.evm.ChainConfig().IsCancun(st.evm.Context.BlockNumber, st.evm.Context.Time) { if blobGas := st.blobGasUsed(); blobGas > 0 { // Check that the user has enough funds to cover blobGasUsed * tx.BlobGasFeeCap - blobBalanceCheck := new(big.Int).SetUint64(blobGas) - blobBalanceCheck.Mul(blobBalanceCheck, st.msg.BlobGasFeeCap) - balanceCheck.Add(balanceCheck, blobBalanceCheck) + blobBalanceCheck := new(uint256.Int).SetUint64(blobGas) + if _, overflow := blobBalanceCheck.MulOverflow(blobBalanceCheck, st.msg.BlobGasFeeCap); overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } + if _, overflow := balanceCheck.AddOverflow(balanceCheck, blobBalanceCheck); overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } // Pay for blobGasUsed * actual blob fee - blobFee := new(big.Int).SetUint64(blobGas) - blobFee.Mul(blobFee, st.evm.Context.BlobBaseFee) - mgval.Add(mgval, blobFee) + blobBaseFee, overflow := uint256.FromBig(st.evm.Context.BlobBaseFee) + if overflow { + return fmt.Errorf("invalid blobBaseFee: %v", st.evm.Context.BlobBaseFee) + } + blobFee := new(uint256.Int).SetUint64(blobGas) + + // In practice, overflow checking is unnecessary, as blobBaseFee cannot exceed + // BlobGasFeeCap. However, in eth_call it is still possible for users to specify + // an excessively large blob base fee and bypass the blob base fee validation. + _, overflow = blobFee.MulOverflow(blobFee, blobBaseFee) + if overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } + _, overflow = mgval.AddOverflow(mgval, blobFee) + if overflow { + return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) + } } } - balanceCheckU256, overflow := uint256.FromBig(balanceCheck) - if overflow { - return fmt.Errorf("%w: address %v required balance exceeds 256 bits", ErrInsufficientFunds, st.msg.From.Hex()) - } - if have, want := st.state.GetBalance(st.msg.From), balanceCheckU256; have.Cmp(want) < 0 { + if have, want := st.state.GetBalance(st.msg.From), balanceCheck; have.Cmp(want) < 0 { return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From.Hex(), have, want) } if err := st.gp.SubGas(st.msg.GasLimit); err != nil { return err } - if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil { - st.evm.Config.Tracer.OnGasChange(0, st.msg.GasLimit, tracing.GasChangeTxInitialBalance) + if st.evm.Config.Tracer.HasGasHook() { + empty := vm.GasBudget{} + initial := vm.NewGasBudget(st.msg.GasLimit) + st.evm.Config.Tracer.EmitGasChange(empty.AsTracing(), initial.AsTracing(), tracing.GasChangeTxInitialBalance) } - st.gasRemaining = st.msg.GasLimit + st.gasRemaining = vm.NewGasBudget(st.msg.GasLimit) + st.initialBudget = st.gasRemaining.Copy() - st.initialGas = st.msg.GasLimit - mgvalU256, _ := uint256.FromBig(mgval) - st.state.SubBalance(st.msg.From, mgvalU256, tracing.BalanceDecreaseGasBuy) + st.state.SubBalance(st.msg.From, mgval, tracing.BalanceDecreaseGasBuy) return nil } @@ -325,9 +450,10 @@ func (st *stateTransition) preCheck() error { } } isOsaka := st.evm.ChainConfig().IsOsaka(st.evm.Context.BlockNumber, st.evm.Context.Time) + isAmsterdam := st.evm.ChainConfig().IsAmsterdam(st.evm.Context.BlockNumber, st.evm.Context.Time) if !msg.SkipTransactionChecks { // Verify tx gas limit does not exceed EIP-7825 cap. - if isOsaka && msg.GasLimit > params.MaxTxGas { + if isOsaka && !isAmsterdam && msg.GasLimit > params.MaxTxGas { return fmt.Errorf("%w (cap: %d, tx: %d)", ErrGasLimitTooHigh, params.MaxTxGas, msg.GasLimit) } // Make sure the sender is an EOA @@ -342,21 +468,13 @@ func (st *stateTransition) preCheck() error { // Skip the checks if gas fields are zero and baseFee was explicitly disabled (eth_call) skipCheck := st.evm.Config.NoBaseFee && msg.GasFeeCap.BitLen() == 0 && msg.GasTipCap.BitLen() == 0 if !skipCheck { - if l := msg.GasFeeCap.BitLen(); l > 256 { - return fmt.Errorf("%w: address %v, maxFeePerGas bit length: %d", ErrFeeCapVeryHigh, - msg.From.Hex(), l) - } - if l := msg.GasTipCap.BitLen(); l > 256 { - return fmt.Errorf("%w: address %v, maxPriorityFeePerGas bit length: %d", ErrTipVeryHigh, - msg.From.Hex(), l) - } if msg.GasFeeCap.Cmp(msg.GasTipCap) < 0 { return fmt.Errorf("%w: address %v, maxPriorityFeePerGas: %s, maxFeePerGas: %s", ErrTipAboveFeeCap, msg.From.Hex(), msg.GasTipCap, msg.GasFeeCap) } // This will panic if baseFee is nil, but basefee presence is verified // as part of header validation. - if msg.GasFeeCap.Cmp(st.evm.Context.BaseFee) < 0 { + if msg.GasFeeCap.CmpBig(st.evm.Context.BaseFee) < 0 { return fmt.Errorf("%w: address %v, maxFeePerGas: %s, baseFee: %s", ErrFeeCapTooLow, msg.From.Hex(), msg.GasFeeCap, st.evm.Context.BaseFee) } @@ -390,7 +508,7 @@ func (st *stateTransition) preCheck() error { if !skipCheck { // This will panic if blobBaseFee is nil, but blobBaseFee presence // is verified as part of header validation. - if msg.BlobGasFeeCap.Cmp(st.evm.Context.BlobBaseFee) < 0 { + if msg.BlobGasFeeCap.CmpBig(st.evm.Context.BlobBaseFee) < 0 { return fmt.Errorf("%w: address %v blobGasFeeCap: %v, blobBaseFee: %v", ErrBlobFeeCapTooLow, msg.From.Hex(), msg.BlobGasFeeCap, st.evm.Context.BlobBaseFee) } @@ -441,18 +559,21 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { contractCreation = msg.To == nil floorDataGas uint64 ) - // Check clauses 4-5, subtract intrinsic gas if everything is correct - gas, err := IntrinsicGas(msg.Data, msg.AccessList, msg.SetCodeAuthorizations, contractCreation, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai) + cost, err := IntrinsicGas(msg.Data, msg.AccessList, msg.SetCodeAuthorizations, contractCreation, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai, rules.IsAmsterdam) if err != nil { return nil, err } - if st.gasRemaining < gas { - return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gasRemaining, gas) + prior, sufficient := st.gasRemaining.Charge(cost) + if !sufficient { + return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gasRemaining.RegularGas, cost.RegularGas) + } + if st.evm.Config.Tracer.HasGasHook() { + st.evm.Config.Tracer.EmitGasChange(prior.AsTracing(), st.gasRemaining.AsTracing(), tracing.GasChangeTxIntrinsicGas) } // Gas limit suffices for the floor data cost (EIP-7623) if rules.IsPrague { - floorDataGas, err = FloorDataGas(msg.Data) + floorDataGas, err = FloorDataGas(rules, msg.Data, msg.AccessList) if err != nil { return nil, err } @@ -460,10 +581,6 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { return nil, fmt.Errorf("%w: have %d, want %d", ErrFloorDataGas, msg.GasLimit, floorDataGas) } } - if t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil { - t.OnGasChange(st.gasRemaining, st.gasRemaining-gas, tracing.GasChangeTxIntrinsicGas) - } - st.gasRemaining -= gas if rules.IsEIP4762 { st.evm.AccessEvents.AddTxOrigin(msg.From) @@ -474,17 +591,19 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { } // Check clause 6 - value, overflow := uint256.FromBig(msg.Value) - if overflow { - return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From.Hex()) + value := msg.Value + if value == nil { + value = new(uint256.Int) } if !value.IsZero() && !st.evm.Context.CanTransfer(st.state, msg.From, value) { return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From.Hex()) } // Check whether the init code size has been exceeded. - if rules.IsShanghai && contractCreation && len(msg.Data) > params.MaxInitCodeSize { - return nil, fmt.Errorf("%w: code size %v limit %v", ErrMaxInitCodeSizeExceeded, len(msg.Data), params.MaxInitCodeSize) + if contractCreation { + if err := vm.CheckMaxInitCodeSize(&rules, uint64(len(msg.Data))); err != nil { + return nil, err + } } // Execute the preparatory steps for state transition which includes: @@ -528,27 +647,42 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { peakGasUsed := st.gasUsed() // Compute refund counter, capped to a refund quotient. - st.gasRemaining += st.calcRefund() + st.gasRemaining.Refund(st.calcRefund()) + if rules.IsPrague { // After EIP-7623: Data-heavy transactions pay the floor gas. - if st.gasUsed() < floorDataGas { - prev := st.gasRemaining - st.gasRemaining = st.initialGas - floorDataGas - if t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil { - t.OnGasChange(prev, st.gasRemaining, tracing.GasChangeTxDataFloor) + if used := st.gasUsed(); used < floorDataGas { + prior, _ := st.gasRemaining.Charge(vm.GasCosts{RegularGas: floorDataGas - used}) + if st.evm.Config.Tracer.HasGasHook() { + st.evm.Config.Tracer.EmitGasChange(prior.AsTracing(), st.gasRemaining.AsTracing(), tracing.GasChangeTxDataFloor) } } if peakGasUsed < floorDataGas { peakGasUsed = floorDataGas } } + // Return gas to the user st.returnGas() + // Return gas to the gas pool + if rules.IsAmsterdam { + // Refund is excluded for returning + err = st.gp.ReturnGas(st.initialBudget.RegularGas-peakGasUsed, st.gasUsed()) + } else { + // Refund is included for returning + err = st.gp.ReturnGas(st.gasRemaining.RegularGas, st.gasUsed()) + } + if err != nil { + return nil, err + } effectiveTip := msg.GasPrice if rules.IsLondon { - effectiveTip = new(big.Int).Sub(msg.GasPrice, st.evm.Context.BaseFee) + baseFee, overflow := uint256.FromBig(st.evm.Context.BaseFee) + if overflow { + return nil, fmt.Errorf("invalid baseFee: %v", st.evm.Context.BaseFee) + } + effectiveTip = new(uint256.Int).Sub(msg.GasPrice, baseFee) } - effectiveTipU256, _ := uint256.FromBig(effectiveTip) if st.evm.Config.NoBaseFee && msg.GasFeeCap.Sign() == 0 && msg.GasTipCap.Sign() == 0 { // Skip fee payment when NoBaseFee is set and the fee fields @@ -556,7 +690,7 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { // the coinbase when simulating calls. } else { fee := new(uint256.Int).SetUint64(st.gasUsed()) - fee.Mul(fee, effectiveTipU256) + fee.Mul(fee, effectiveTip) st.state.AddBalance(st.evm.Context.Coinbase, fee, tracing.BalanceIncreaseRewardTransactionFee) // add the coinbase to the witness iff the fee is greater than 0 @@ -564,7 +698,11 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { st.evm.AccessEvents.AddAccount(st.evm.Context.Coinbase, true, math.MaxUint64) } } - + if rules.IsAmsterdam { + for _, log := range st.evm.StateDB.LogsForBurnAccounts() { + st.evm.StateDB.AddLog(log) + } + } return &ExecutionResult{ UsedGas: st.gasUsed(), MaxUsedGas: peakGasUsed, @@ -632,7 +770,7 @@ func (st *stateTransition) applyAuthorization(auth *types.SetCodeAuthorization) } // calcRefund computes refund counter, capped to a refund quotient. -func (st *stateTransition) calcRefund() uint64 { +func (st *stateTransition) calcRefund() vm.GasBudget { var refund uint64 if !st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) { // Before EIP-3529: refunds were capped to gasUsed / 2 @@ -644,31 +782,32 @@ func (st *stateTransition) calcRefund() uint64 { if refund > st.state.GetRefund() { refund = st.state.GetRefund() } - if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && refund > 0 { - st.evm.Config.Tracer.OnGasChange(st.gasRemaining, st.gasRemaining+refund, tracing.GasChangeTxRefunds) + if refund > 0 && st.evm.Config.Tracer.HasGasHook() { + after := st.gasRemaining + after.RegularGas += refund + + st.evm.Config.Tracer.EmitGasChange(st.gasRemaining.AsTracing(), after.AsTracing(), tracing.GasChangeTxRefunds) } - return refund + return vm.NewGasBudget(refund) } // returnGas returns ETH for remaining gas, // exchanged at the original rate. func (st *stateTransition) returnGas() { - remaining := uint256.NewInt(st.gasRemaining) - remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) + remaining := uint256.NewInt(st.gasRemaining.RegularGas) + remaining.Mul(remaining, st.msg.GasPrice) st.state.AddBalance(st.msg.From, remaining, tracing.BalanceIncreaseGasReturn) - if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && st.gasRemaining > 0 { - st.evm.Config.Tracer.OnGasChange(st.gasRemaining, 0, tracing.GasChangeTxLeftOverReturned) + if st.gasRemaining.RegularGas > 0 && st.evm.Config.Tracer.HasGasHook() { + after := st.gasRemaining + after.RegularGas = 0 + st.evm.Config.Tracer.EmitGasChange(st.gasRemaining.AsTracing(), after.AsTracing(), tracing.GasChangeTxLeftOverReturned) } - - // Also return remaining gas to the block gas counter so it is - // available for the next transaction. - st.gp.AddGas(st.gasRemaining) } // gasUsed returns the amount of gas used up by the state transition. func (st *stateTransition) gasUsed() uint64 { - return st.initialGas - st.gasRemaining + return st.gasRemaining.Used(st.initialBudget) } // blobGasUsed returns the amount of blob gas used by the message. diff --git a/core/state_transition_test.go b/core/state_transition_test.go new file mode 100644 index 000000000000..8aab016123e6 --- /dev/null +++ b/core/state_transition_test.go @@ -0,0 +1,287 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package core + +import ( + "bytes" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/params" +) + +func TestFloorDataGas(t *testing.T) { + addr1 := common.HexToAddress("0x1111111111111111111111111111111111111111") + addr2 := common.HexToAddress("0x2222222222222222222222222222222222222222") + key1 := common.HexToHash("0xaa") + key2 := common.HexToHash("0xbb") + + tests := []struct { + name string + amsterdam bool + data []byte + accessList types.AccessList + want uint64 + }{ + { + name: "pre-amsterdam/empty", + want: params.TxGas, + }, + { + name: "pre-amsterdam/zero-bytes-only", + data: bytes.Repeat([]byte{0x00}, 100), + // 100 zero tokens * 10 cost = 1000 + want: params.TxGas + 100*params.TxCostFloorPerToken, + }, + { + name: "pre-amsterdam/non-zero-bytes-only", + data: bytes.Repeat([]byte{0xff}, 100), + // 100 nz * 4 tokens * 10 cost = 4000 + want: params.TxGas + 100*params.TxTokenPerNonZeroByte*params.TxCostFloorPerToken, + }, + { + name: "pre-amsterdam/mixed", + data: append(bytes.Repeat([]byte{0x00}, 50), bytes.Repeat([]byte{0xff}, 50)...), + // 50 zero + 50*4 nz = 250 tokens * 10 = 2500 + want: params.TxGas + (50+50*params.TxTokenPerNonZeroByte)*params.TxCostFloorPerToken, + }, + { + name: "pre-amsterdam/access-list-ignored", + data: bytes.Repeat([]byte{0xff}, 10), + accessList: types.AccessList{ + {Address: addr1, StorageKeys: []common.Hash{key1, key2}}, + }, + // pre-amsterdam: floor calculation does not include access list + want: params.TxGas + 10*params.TxTokenPerNonZeroByte*params.TxCostFloorPerToken, + }, + { + name: "amsterdam/empty", + amsterdam: true, + want: params.TxGas, + }, + { + name: "amsterdam/data-only", + amsterdam: true, + data: bytes.Repeat([]byte{0x00}, 1024), + // post-amsterdam: every byte = 4 tokens regardless of value + want: params.TxGas + 1024*params.TxTokenPerNonZeroByte*params.TxCostFloorPerToken7976, + }, + { + name: "amsterdam/data-non-zero", + amsterdam: true, + data: bytes.Repeat([]byte{0xff}, 1024), + // same as zero data post-amsterdam + want: params.TxGas + 1024*params.TxTokenPerNonZeroByte*params.TxCostFloorPerToken7976, + }, + { + name: "amsterdam/access-list-addresses-only", + amsterdam: true, + accessList: types.AccessList{ + {Address: addr1}, + {Address: addr2}, + }, + // 2 * 20 bytes * 4 tokens/byte * 16 cost/token + want: params.TxGas + 2*common.AddressLength*params.TxTokenPerNonZeroByte*params.TxCostFloorPerToken7976, + }, + { + name: "amsterdam/access-list-with-storage-keys", + amsterdam: true, + accessList: types.AccessList{ + {Address: addr1, StorageKeys: []common.Hash{key1, key2}}, + }, + // 1 addr * 20 * 4 + 2 keys * 32 * 4 = 80 + 256 = 336 tokens * 16 + want: params.TxGas + (1*common.AddressLength+2*common.HashLength)*params.TxTokenPerNonZeroByte*params.TxCostFloorPerToken7976, + }, + { + name: "amsterdam/mixed", + amsterdam: true, + data: bytes.Repeat([]byte{0xff}, 100), + accessList: types.AccessList{ + {Address: addr1, StorageKeys: []common.Hash{key1}}, + {Address: addr2, StorageKeys: []common.Hash{key1, key2}}, + }, + // data: 100*4 = 400; addrs: 2*20*4 = 160; keys: 3*32*4 = 384; total = 944 * 16 + want: params.TxGas + (100*params.TxTokenPerNonZeroByte+2*common.AddressLength*params.TxTokenPerNonZeroByte+3*common.HashLength*params.TxTokenPerNonZeroByte)*params.TxCostFloorPerToken7976, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + rules := params.Rules{IsAmsterdam: tt.amsterdam} + got, err := FloorDataGas(rules, tt.data, tt.accessList) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got != tt.want { + t.Fatalf("gas mismatch: got %d, want %d", got, tt.want) + } + }) + } +} + +func TestIntrinsicGas(t *testing.T) { + addr1 := common.HexToAddress("0x1111111111111111111111111111111111111111") + addr2 := common.HexToAddress("0x2222222222222222222222222222222222222222") + key1 := common.HexToHash("0xaa") + key2 := common.HexToHash("0xbb") + + const ( + amsterdamAddressCost = uint64(common.AddressLength) * params.TxCostFloorPerToken7976 * params.TxTokenPerNonZeroByte // 1280 + amsterdamStorageKeyCost = uint64(common.HashLength) * params.TxCostFloorPerToken7976 * params.TxTokenPerNonZeroByte // 2048 + ) + + tests := []struct { + name string + data []byte + accessList types.AccessList + authList []types.SetCodeAuthorization + creation bool + isHomestead bool + isEIP2028 bool + isEIP3860 bool + isAmsterdam bool + want uint64 + }{ + { + name: "frontier/empty-call", + want: params.TxGas, + }, + { + name: "frontier/contract-creation-pre-homestead", + creation: true, + isHomestead: false, + // pre-homestead, contract creation still uses TxGas + want: params.TxGas, + }, + { + name: "homestead/contract-creation", + creation: true, + isHomestead: true, + want: params.TxGasContractCreation, + }, + { + name: "frontier/non-zero-data", + data: bytes.Repeat([]byte{0xff}, 100), + // 100 nz bytes * 68 (frontier) + want: params.TxGas + 100*params.TxDataNonZeroGasFrontier, + }, + { + name: "istanbul/non-zero-data", + data: bytes.Repeat([]byte{0xff}, 100), + isEIP2028: true, + // 100 nz bytes * 16 (post-EIP2028) + want: params.TxGas + 100*params.TxDataNonZeroGasEIP2028, + }, + { + name: "istanbul/zero-data", + data: bytes.Repeat([]byte{0x00}, 100), + isEIP2028: true, + // 100 zero bytes * 4 + want: params.TxGas + 100*params.TxDataZeroGas, + }, + { + name: "istanbul/mixed-data", + data: append(bytes.Repeat([]byte{0x00}, 50), bytes.Repeat([]byte{0xff}, 50)...), + isEIP2028: true, + want: params.TxGas + 50*params.TxDataZeroGas + 50*params.TxDataNonZeroGasEIP2028, + }, + { + name: "shanghai/init-code-word-gas", + data: bytes.Repeat([]byte{0x00}, 64), // 2 words + creation: true, + isHomestead: true, + isEIP2028: true, + isEIP3860: true, + // TxGasContractCreation + 64 zero bytes * 4 + 2 words * 2 + want: params.TxGasContractCreation + 64*params.TxDataZeroGas + 2*params.InitCodeWordGas, + }, + { + name: "shanghai/init-code-non-multiple-of-32", + data: bytes.Repeat([]byte{0x00}, 33), // 2 words (rounded up) + creation: true, + isHomestead: true, + isEIP2028: true, + isEIP3860: true, + want: params.TxGasContractCreation + 33*params.TxDataZeroGas + 2*params.InitCodeWordGas, + }, + { + name: "berlin/access-list", + accessList: types.AccessList{ + {Address: addr1, StorageKeys: []common.Hash{key1, key2}}, + {Address: addr2, StorageKeys: []common.Hash{key1}}, + }, + isEIP2028: true, + // 2 addrs * 2400 + 3 keys * 1900 + want: params.TxGas + 2*params.TxAccessListAddressGas + 3*params.TxAccessListStorageKeyGas, + }, + { + name: "amsterdam/access-list-extra-cost", + accessList: types.AccessList{ + {Address: addr1, StorageKeys: []common.Hash{key1, key2}}, + {Address: addr2, StorageKeys: []common.Hash{key1}}, + }, + isEIP2028: true, + isAmsterdam: true, + // base access-list charge + EIP-7981 extra + want: params.TxGas + + 2*params.TxAccessListAddressGas + 3*params.TxAccessListStorageKeyGas + + 2*amsterdamAddressCost + 3*amsterdamStorageKeyCost, + }, + { + name: "prague/auth-list", + authList: []types.SetCodeAuthorization{ + {Address: addr1}, + {Address: addr2}, + {Address: addr1}, + }, + isEIP2028: true, + // 3 auths * 25000 + want: params.TxGas + 3*params.CallNewAccountGas, + }, + { + name: "amsterdam/combined", + data: bytes.Repeat([]byte{0xff}, 100), + accessList: types.AccessList{ + {Address: addr1, StorageKeys: []common.Hash{key1}}, + }, + authList: []types.SetCodeAuthorization{ + {Address: addr2}, + }, + isEIP2028: true, + isAmsterdam: true, + want: params.TxGas + + 100*params.TxDataNonZeroGasEIP2028 + + 1*params.TxAccessListAddressGas + 1*params.TxAccessListStorageKeyGas + + 1*amsterdamAddressCost + 1*amsterdamStorageKeyCost + + 1*params.CallNewAccountGas, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := IntrinsicGas(tt.data, tt.accessList, tt.authList, + tt.creation, tt.isHomestead, tt.isEIP2028, tt.isEIP3860, tt.isAmsterdam) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + want := vm.GasCosts{RegularGas: tt.want} + if got != want { + t.Fatalf("gas mismatch: got %+v, want %+v", got, want) + } + }) + } +} diff --git a/core/stateless.go b/core/stateless.go index b20c909da670..86d4dc304b6e 100644 --- a/core/stateless.go +++ b/core/stateless.go @@ -17,6 +17,8 @@ package core import ( + "context" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/lru" "github.com/ethereum/go-ethereum/consensus/beacon" @@ -40,7 +42,7 @@ import ( // - It cannot be placed outside of core, because it needs to construct a dud headerchain // // TODO(karalabe): Would be nice to resolve both issues above somehow and move it. -func ExecuteStateless(config *params.ChainConfig, vmconfig vm.Config, block *types.Block, witness *stateless.Witness) (common.Hash, common.Hash, error) { +func ExecuteStateless(ctx context.Context, config *params.ChainConfig, vmconfig vm.Config, block *types.Block, witness *stateless.Witness) (common.Hash, common.Hash, error) { // Sanity check if the supplied block accidentally contains a set root or // receipt hash. If so, be very loud, but still continue. if block.Root() != (common.Hash{}) { @@ -51,7 +53,7 @@ func ExecuteStateless(config *params.ChainConfig, vmconfig vm.Config, block *typ } // Create and populate the state database to serve as the stateless backend memdb := witness.MakeHashDB() - db, err := state.New(witness.Root(), state.NewDatabase(triedb.NewDatabase(memdb, triedb.HashDefaults), nil)) + db, err := state.New(witness.Root(), state.NewDatabase(triedb.NewDatabase(memdb, triedb.HashDefaults), state.NewCodeDB(memdb))) if err != nil { return common.Hash{}, common.Hash{}, err } @@ -66,7 +68,7 @@ func ExecuteStateless(config *params.ChainConfig, vmconfig vm.Config, block *typ validator := NewBlockValidator(config, nil) // No chain, we only validate the state, not the block // Run the stateless blocks processing and self-validate certain fields - res, err := processor.Process(block, db, vmconfig) + res, err := processor.Process(ctx, block, db, vmconfig) if err != nil { return common.Hash{}, common.Hash{}, err } diff --git a/core/stateless/encoding.go b/core/stateless/encoding.go index 5c43159e66b8..1b20c4cb2ac3 100644 --- a/core/stateless/encoding.go +++ b/core/stateless/encoding.go @@ -17,6 +17,7 @@ package stateless import ( + "errors" "io" "github.com/ethereum/go-ethereum/common/hexutil" @@ -40,8 +41,11 @@ func (w *Witness) ToExtWitness() *ExtWitness { return ext } -// fromExtWitness converts the consensus witness format into our internal one. -func (w *Witness) fromExtWitness(ext *ExtWitness) error { +// FromExtWitness converts the consensus witness format into our internal one. +func (w *Witness) FromExtWitness(ext *ExtWitness) error { + if len(ext.Headers) == 0 { + return errors.New("witness must contain at least one header") + } w.Headers = ext.Headers w.Codes = make(map[string]struct{}, len(ext.Codes)) @@ -66,7 +70,7 @@ func (w *Witness) DecodeRLP(s *rlp.Stream) error { if err := s.Decode(&ext); err != nil { return err } - return w.fromExtWitness(&ext) + return w.FromExtWitness(&ext) } // ExtWitness is a witness RLP encoding for transferring across clients. diff --git a/core/stateless/stats.go b/core/stateless/stats.go index 94f5587f9997..8c05b23d3756 100644 --- a/core/stateless/stats.go +++ b/core/stateless/stats.go @@ -27,6 +27,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" + "github.com/ethereum/go-ethereum/trie" ) var accountTrieLeavesAtDepth [16]*metrics.Counter @@ -41,52 +42,75 @@ func init() { // WitnessStats aggregates statistics for account and storage trie accesses. type WitnessStats struct { - accountTrieLeaves [16]int64 - storageTrieLeaves [16]int64 + accountTrie *trie.LevelStats + storageTrie *trie.LevelStats } // NewWitnessStats creates a new WitnessStats collector. func NewWitnessStats() *WitnessStats { - return &WitnessStats{} + return &WitnessStats{ + accountTrie: trie.NewLevelStats(), + storageTrie: trie.NewLevelStats(), + } +} + +func (s *WitnessStats) copy() *WitnessStats { + return &WitnessStats{ + accountTrie: s.accountTrie.Copy(), + storageTrie: s.storageTrie.Copy(), + } +} + +func (s *WitnessStats) init() { + if s.accountTrie == nil { + s.accountTrie = trie.NewLevelStats() + } + if s.storageTrie == nil { + s.storageTrie = trie.NewLevelStats() + } } // Add records trie access depths from the given node paths. // If `owner` is the zero hash, accesses are attributed to the account trie; // otherwise, they are attributed to the storage trie of that account. func (s *WitnessStats) Add(nodes map[string][]byte, owner common.Hash) { - // Extract paths from the nodes map + s.init() + + // Extract paths from the nodes map. paths := slices.Collect(maps.Keys(nodes)) sort.Strings(paths) + ownerStat := s.accountTrie + if owner != (common.Hash{}) { + ownerStat = s.storageTrie + } + for i, path := range paths { // If current path is a prefix of the next path, it's not a leaf. // The last path is always a leaf. if i == len(paths)-1 || !strings.HasPrefix(paths[i+1], paths[i]) { - if owner == (common.Hash{}) { - s.accountTrieLeaves[len(path)] += 1 - } else { - s.storageTrieLeaves[len(path)] += 1 - } + ownerStat.AddLeaf(len(path)) } } } // ReportMetrics reports the collected statistics to the global metrics registry. func (s *WitnessStats) ReportMetrics(blockNumber uint64) { - // Encode the metrics as JSON for easier consumption - accountLeavesJson, _ := json.Marshal(s.accountTrieLeaves) - storageLeavesJson, _ := json.Marshal(s.storageTrieLeaves) - - // Log account trie depth statistics - log.Info("Account trie depth stats", - "block", blockNumber, - "leavesAtDepth", string(accountLeavesJson)) - log.Info("Storage trie depth stats", - "block", blockNumber, - "leavesAtDepth", string(storageLeavesJson)) + s.init() - for i := 0; i < 16; i++ { - accountTrieLeavesAtDepth[i].Inc(s.accountTrieLeaves[i]) - storageTrieLeavesAtDepth[i].Inc(s.storageTrieLeaves[i]) + accountTrieLeaves := s.accountTrie.LeafDepths() + storageTrieLeaves := s.storageTrie.LeafDepths() + + // Encode the metrics as JSON for easier consumption. + accountLeavesJSON, _ := json.Marshal(accountTrieLeaves) + storageLeavesJSON, _ := json.Marshal(storageTrieLeaves) + + // Log account trie depth statistics. + log.Info("Account trie depth stats", "block", blockNumber, "leavesAtDepth", string(accountLeavesJSON)) + log.Info("Storage trie depth stats", "block", blockNumber, "leavesAtDepth", string(storageLeavesJSON)) + + for i := 0; i < len(accountTrieLeavesAtDepth); i++ { + accountTrieLeavesAtDepth[i].Inc(accountTrieLeaves[i]) + storageTrieLeavesAtDepth[i].Inc(storageTrieLeaves[i]) } } diff --git a/core/stateless/stats_test.go b/core/stateless/stats_test.go index e77084df5dcb..6dc1fa0844b5 100644 --- a/core/stateless/stats_test.go +++ b/core/stateless/stats_test.go @@ -17,18 +17,27 @@ package stateless import ( + "strings" "testing" "github.com/ethereum/go-ethereum/common" ) +func expectedLeaves(counts map[int]int64) [16]int64 { + var leaves [16]int64 + for depth, count := range counts { + leaves[depth] = count + } + return leaves +} + func TestWitnessStatsAdd(t *testing.T) { tests := []struct { name string nodes map[string][]byte owner common.Hash - expectedAccountLeaves map[int64]int64 - expectedStorageLeaves map[int64]int64 + expectedAccountLeaves map[int]int64 + expectedStorageLeaves map[int]int64 }{ { name: "empty nodes", @@ -41,7 +50,7 @@ func TestWitnessStatsAdd(t *testing.T) { "": []byte("data"), }, owner: common.Hash{}, - expectedAccountLeaves: map[int64]int64{0: 1}, + expectedAccountLeaves: map[int]int64{0: 1}, }, { name: "single account trie leaf", @@ -49,7 +58,7 @@ func TestWitnessStatsAdd(t *testing.T) { "abc": []byte("data"), }, owner: common.Hash{}, - expectedAccountLeaves: map[int64]int64{3: 1}, + expectedAccountLeaves: map[int]int64{3: 1}, }, { name: "account trie with internal nodes", @@ -59,7 +68,7 @@ func TestWitnessStatsAdd(t *testing.T) { "abc": []byte("data3"), }, owner: common.Hash{}, - expectedAccountLeaves: map[int64]int64{3: 1}, // Only "abc" is a leaf + expectedAccountLeaves: map[int]int64{3: 1}, // Only "abc" is a leaf }, { name: "multiple account trie branches", @@ -72,7 +81,7 @@ func TestWitnessStatsAdd(t *testing.T) { "bcd": []byte("data6"), }, owner: common.Hash{}, - expectedAccountLeaves: map[int64]int64{3: 2}, // "abc" (3) + "bcd" (3) + expectedAccountLeaves: map[int]int64{3: 2}, // "abc" (3) + "bcd" (3) }, { name: "siblings are all leaves", @@ -82,7 +91,7 @@ func TestWitnessStatsAdd(t *testing.T) { "ac": []byte("data3"), }, owner: common.Hash{}, - expectedAccountLeaves: map[int64]int64{2: 3}, + expectedAccountLeaves: map[int]int64{2: 3}, }, { name: "storage trie leaves", @@ -93,7 +102,7 @@ func TestWitnessStatsAdd(t *testing.T) { "124": []byte("data4"), }, owner: common.HexToHash("0x1234"), - expectedStorageLeaves: map[int64]int64{3: 2}, // "123" (3) + "124" (3) + expectedStorageLeaves: map[int]int64{3: 2}, // "123" (3) + "124" (3) }, { name: "complex trie structure", @@ -109,7 +118,7 @@ func TestWitnessStatsAdd(t *testing.T) { "3": []byte("data9"), }, owner: common.Hash{}, - expectedAccountLeaves: map[int64]int64{1: 1, 3: 4}, // "123"(3) + "124"(3) + "234"(3) + "235"(3) + "3"(1) + expectedAccountLeaves: map[int]int64{1: 1, 3: 4}, // "123"(3) + "124"(3) + "234"(3) + "235"(3) + "3"(1) }, } @@ -118,32 +127,59 @@ func TestWitnessStatsAdd(t *testing.T) { stats := NewWitnessStats() stats.Add(tt.nodes, tt.owner) - var expectedAccountTrieLeaves [16]int64 - for depth, count := range tt.expectedAccountLeaves { - expectedAccountTrieLeaves[depth] = count + if got, want := stats.accountTrie.LeafDepths(), expectedLeaves(tt.expectedAccountLeaves); got != want { + t.Errorf("account trie leaves = %v, want %v", got, want) } - var expectedStorageTrieLeaves [16]int64 - for depth, count := range tt.expectedStorageLeaves { - expectedStorageTrieLeaves[depth] = count + if got, want := stats.storageTrie.LeafDepths(), expectedLeaves(tt.expectedStorageLeaves); got != want { + t.Errorf("storage trie leaves = %v, want %v", got, want) } + }) + } +} - // Check account trie depth - if stats.accountTrieLeaves != expectedAccountTrieLeaves { - t.Errorf("Account trie total depth = %v, want %v", stats.accountTrieLeaves, expectedAccountTrieLeaves) - } +func TestWitnessStatsStorageTrieAggregation(t *testing.T) { + stats := NewWitnessStats() + ownerA := common.HexToHash("0xa") + ownerB := common.HexToHash("0xb") - // Check storage trie depth - if stats.storageTrieLeaves != expectedStorageTrieLeaves { - t.Errorf("Storage trie total depth = %v, want %v", stats.storageTrieLeaves, expectedStorageTrieLeaves) - } - }) + stats.Add(map[string][]byte{ + "a": []byte("data1"), + "ab": []byte("data2"), + "abc": []byte("data3"), + }, ownerA) + stats.Add(map[string][]byte{ + "xy": []byte("data4"), + }, ownerA) + stats.Add(map[string][]byte{ + "1": []byte("data5"), + "12": []byte("data6"), + "123": []byte("data7"), + "124": []byte("data8"), + }, ownerB) + + if got, want := stats.storageTrie.LeafDepths(), expectedLeaves(map[int]int64{2: 1, 3: 3}); got != want { + t.Errorf("storage leaves = %v, want %v", got, want) } + if got, want := stats.accountTrie.LeafDepths(), expectedLeaves(nil); got != want { + t.Errorf("account leaves = %v, want %v", got, want) + } +} + +func TestWitnessStatsPanicsOnDeepLeaf(t *testing.T) { + stats := NewWitnessStats() + + defer func() { + if r := recover(); r == nil { + t.Fatal("expected panic for depth >= 16") + } + }() + stats.Add(map[string][]byte{strings.Repeat("a", 16): []byte("data")}, common.Hash{}) } func TestWitnessStatsMinMax(t *testing.T) { stats := NewWitnessStats() - // Add some account trie nodes with varying depths + // Add some account trie nodes with varying depths. stats.Add(map[string][]byte{ "a": []byte("data1"), "ab": []byte("data2"), @@ -152,21 +188,21 @@ func TestWitnessStatsMinMax(t *testing.T) { "abcde": []byte("data5"), }, common.Hash{}) - // Only "abcde" is a leaf (depth 5) - for i, v := range stats.accountTrieLeaves { + // Only "abcde" is a leaf (depth 5). + for i, v := range stats.accountTrie.LeafDepths() { if v != 0 && i != 5 { t.Errorf("leaf found at invalid depth %d", i) } } - // Add more leaves with different depths + // Add more leaves with different depths. stats.Add(map[string][]byte{ "x": []byte("data6"), "yz": []byte("data7"), }, common.Hash{}) - // Now we have leaves at depths 1, 2, and 5 - for i, v := range stats.accountTrieLeaves { + // Now we have leaves at depths 1, 2, and 5. + for i, v := range stats.accountTrie.LeafDepths() { if v != 0 && (i != 5 && i != 2 && i != 1) { t.Errorf("leaf found at invalid depth %d", i) } @@ -176,7 +212,7 @@ func TestWitnessStatsMinMax(t *testing.T) { func TestWitnessStatsAverage(t *testing.T) { stats := NewWitnessStats() - // Add nodes that will create leaves at depths 2, 3, and 4 + // Add nodes that will create leaves at depths 2, 3, and 4. stats.Add(map[string][]byte{ "aa": []byte("data1"), "bb": []byte("data2"), @@ -184,22 +220,22 @@ func TestWitnessStatsAverage(t *testing.T) { "dddd": []byte("data4"), }, common.Hash{}) - // All are leaves: 2 + 2 + 3 + 4 = 11 total, 4 samples + // All are leaves: 2 + 2 + 3 + 4 = 11 total, 4 samples. expectedAvg := int64(11) / int64(4) var actualAvg, totalSamples int64 - for i, c := range stats.accountTrieLeaves { + for i, c := range stats.accountTrie.LeafDepths() { actualAvg += c * int64(i) totalSamples += c } actualAvg = actualAvg / totalSamples if actualAvg != expectedAvg { - t.Errorf("Account trie average depth = %d, want %d", actualAvg, expectedAvg) + t.Errorf("account trie average depth = %d, want %d", actualAvg, expectedAvg) } } func BenchmarkWitnessStatsAdd(b *testing.B) { - // Create a realistic trie node structure + // Create a realistic trie node structure. nodes := make(map[string][]byte) for i := 0; i < 100; i++ { base := string(rune('a' + i%26)) diff --git a/core/stateless/witness.go b/core/stateless/witness.go index 588c895a2fd8..f1321699c121 100644 --- a/core/stateless/witness.go +++ b/core/stateless/witness.go @@ -42,12 +42,13 @@ type Witness struct { Codes map[string]struct{} // Set of bytecodes ran or accessed State map[string]struct{} // Set of MPT state trie nodes (account and storage together) - chain HeaderReader // Chain reader to convert block hash ops to header proofs - lock sync.Mutex // Lock to allow concurrent state insertions + chain HeaderReader // Chain reader to convert block hash ops to header proofs + stats *WitnessStats // Optional statistics collector + lock sync.Mutex // Lock to allow concurrent state insertions } // NewWitness creates an empty witness ready for population. -func NewWitness(context *types.Header, chain HeaderReader) (*Witness, error) { +func NewWitness(context *types.Header, chain HeaderReader, enableStats bool) (*Witness, error) { // When building witnesses, retrieve the parent header, which will *always* // be included to act as a trustless pre-root hash container var headers []*types.Header @@ -59,13 +60,17 @@ func NewWitness(context *types.Header, chain HeaderReader) (*Witness, error) { headers = append(headers, parent) } // Create the witness with a reconstructed gutted out block - return &Witness{ + w := &Witness{ context: context, Headers: headers, Codes: make(map[string]struct{}), State: make(map[string]struct{}), chain: chain, - }, nil + } + if enableStats { + w.stats = NewWitnessStats() + } + return w, nil } // AddBlockHash adds a "blockhash" to the witness with the designated offset from @@ -87,8 +92,11 @@ func (w *Witness) AddCode(code []byte) { w.Codes[string(code)] = struct{}{} } -// AddState inserts a batch of MPT trie nodes into the witness. -func (w *Witness) AddState(nodes map[string][]byte) { +// AddState inserts a batch of MPT trie nodes into the witness. The owner +// identifies which trie the nodes belong to: the zero hash for the account +// trie, or the hashed address for a storage trie. This is used for optional +// statistics collection. +func (w *Witness) AddState(nodes map[string][]byte, owner common.Hash) { if len(nodes) == 0 { return } @@ -98,6 +106,17 @@ func (w *Witness) AddState(nodes map[string][]byte) { for _, value := range nodes { w.State[string(value)] = struct{}{} } + if w.stats != nil { + w.stats.Add(nodes, owner) + } +} + +// ReportMetrics reports the collected statistics to the global metrics registry. +func (w *Witness) ReportMetrics(blockNumber uint64) { + if w.stats == nil { + return + } + w.stats.ReportMetrics(blockNumber) } func (w *Witness) AddKey() { @@ -113,6 +132,9 @@ func (w *Witness) Copy() *Witness { State: maps.Clone(w.State), chain: w.chain, } + if w.stats != nil { + cpy.stats = w.stats.copy() + } if w.context != nil { cpy.context = types.CopyHeader(w.context) } diff --git a/core/tracing/gen_balance_change_reason_stringer.go b/core/tracing/gen_balance_change_reason_stringer.go index 250b5211939d..f0edfad87266 100644 --- a/core/tracing/gen_balance_change_reason_stringer.go +++ b/core/tracing/gen_balance_change_reason_stringer.go @@ -31,8 +31,9 @@ const _BalanceChangeReason_name = "UnspecifiedBalanceIncreaseRewardMineUncleBala var _BalanceChangeReason_index = [...]uint16{0, 11, 41, 71, 96, 125, 160, 181, 205, 231, 256, 264, 276, 303, 330, 361, 367} func (i BalanceChangeReason) String() string { - if i >= BalanceChangeReason(len(_BalanceChangeReason_index)-1) { + idx := int(i) - 0 + if i < 0 || idx >= len(_BalanceChangeReason_index)-1 { return "BalanceChangeReason(" + strconv.FormatInt(int64(i), 10) + ")" } - return _BalanceChangeReason_name[_BalanceChangeReason_index[i]:_BalanceChangeReason_index[i+1]] + return _BalanceChangeReason_name[_BalanceChangeReason_index[idx]:_BalanceChangeReason_index[idx+1]] } diff --git a/core/tracing/gen_code_change_reason_stringer.go b/core/tracing/gen_code_change_reason_stringer.go index 937295406318..2531b10471cd 100644 --- a/core/tracing/gen_code_change_reason_stringer.go +++ b/core/tracing/gen_code_change_reason_stringer.go @@ -22,8 +22,9 @@ const _CodeChangeReason_name = "UnspecifiedContractCreationGenesisAuthorizationA var _CodeChangeReason_index = [...]uint8{0, 11, 27, 34, 47, 65, 77, 83} func (i CodeChangeReason) String() string { - if i >= CodeChangeReason(len(_CodeChangeReason_index)-1) { + idx := int(i) - 0 + if i < 0 || idx >= len(_CodeChangeReason_index)-1 { return "CodeChangeReason(" + strconv.FormatInt(int64(i), 10) + ")" } - return _CodeChangeReason_name[_CodeChangeReason_index[i]:_CodeChangeReason_index[i+1]] + return _CodeChangeReason_name[_CodeChangeReason_index[idx]:_CodeChangeReason_index[idx+1]] } diff --git a/core/tracing/gen_nonce_change_reason_stringer.go b/core/tracing/gen_nonce_change_reason_stringer.go index f775c1f3a6de..8c9099b7ce18 100644 --- a/core/tracing/gen_nonce_change_reason_stringer.go +++ b/core/tracing/gen_nonce_change_reason_stringer.go @@ -15,15 +15,17 @@ func _() { _ = x[NonceChangeNewContract-4] _ = x[NonceChangeAuthorization-5] _ = x[NonceChangeRevert-6] + _ = x[NonceChangeSelfdestruct-7] } -const _NonceChangeReason_name = "UnspecifiedGenesisEoACallContractCreatorNewContractAuthorizationRevert" +const _NonceChangeReason_name = "UnspecifiedGenesisEoACallContractCreatorNewContractAuthorizationRevertSelfdestruct" -var _NonceChangeReason_index = [...]uint8{0, 11, 18, 25, 40, 51, 64, 70} +var _NonceChangeReason_index = [...]uint8{0, 11, 18, 25, 40, 51, 64, 70, 82} func (i NonceChangeReason) String() string { - if i >= NonceChangeReason(len(_NonceChangeReason_index)-1) { + idx := int(i) - 0 + if i < 0 || idx >= len(_NonceChangeReason_index)-1 { return "NonceChangeReason(" + strconv.FormatInt(int64(i), 10) + ")" } - return _NonceChangeReason_name[_NonceChangeReason_index[i]:_NonceChangeReason_index[i+1]] + return _NonceChangeReason_name[_NonceChangeReason_index[idx]:_NonceChangeReason_index[idx+1]] } diff --git a/core/tracing/hooks.go b/core/tracing/hooks.go index 8e50dc3d8f3e..6ea3f7ebbfa9 100644 --- a/core/tracing/hooks.go +++ b/core/tracing/hooks.go @@ -30,6 +30,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/trie/trienode" "github.com/holiman/uint256" ) @@ -75,6 +76,56 @@ type BlockEvent struct { Safe *types.Header } +// StateUpdate represents the state mutations resulting from block execution. +// It provides access to account changes, storage changes, and contract code +// deployments with both previous and new values. +type StateUpdate struct { + OriginRoot common.Hash // State root before the update + Root common.Hash // State root after the update + BlockNumber uint64 + + // AccountChanges contains all account state changes keyed by address. + AccountChanges map[common.Address]*AccountChange + + // StorageChanges contains all storage slot changes keyed by address and storage slot key. + StorageChanges map[common.Address]map[common.Hash]*StorageChange + + // CodeChanges contains all contract code changes keyed by address. + CodeChanges map[common.Address]*CodeChange + + // TrieChanges contains trie node mutations keyed by address hash and trie node path. + TrieChanges map[common.Hash]map[string]*TrieNodeChange +} + +// AccountChange represents a change to an account's state. +type AccountChange struct { + Prev *types.StateAccount // nil if account was created + New *types.StateAccount // nil if account was deleted +} + +// StorageChange represents a change to a storage slot. +type StorageChange struct { + Prev common.Hash // previous value (zero if slot was created) + New common.Hash // new value (zero if slot was deleted) +} + +type ContractCode struct { + Hash common.Hash + Code []byte + Exists bool // true if the code was existent +} + +// CodeChange represents a change in contract code of an account. +type CodeChange struct { + Prev *ContractCode // nil if no code existed before + New *ContractCode +} + +type TrieNodeChange struct { + Prev *trienode.Node + New *trienode.Node +} + type ( /* - VM events - @@ -113,9 +164,37 @@ type ( // FaultHook is invoked when an error occurs during the execution of an opcode. FaultHook = func(pc uint64, op byte, gas, cost uint64, scope OpContext, depth int, err error) - // GasChangeHook is invoked when the gas changes. + // GasChangeHook reports changes to the regular execution gas. Tracers + // that don't need visibility into the state-access gas dimension + // introduced by EIP-8037 (Amsterdam) can implement only this hook; it + // will continue to fire across the Amsterdam fork unchanged. + // + // If both this hook and GasChangeHookV2 are implemented on the same + // tracer, only V2 will be invoked. Implement exactly one to avoid + // double-counting. GasChangeHook = func(old, new uint64, reason GasChangeReason) + // GasChangeHookV2 is invoked when any gas dimension changes. It is the + // multi-dimensional successor to GasChangeHook, exposing the state-access + // gas dimension introduced by EIP-8037 (Amsterdam) alongside the regular + // dimension. + // + // Compatibility: + // - Post-Amsterdam: fires for changes to either the regular or the + // state-access dimension. The non-changing dimension is passed through + // unchanged in both `old` and `new` so consumers always observe the + // complete gas vector. + // - Pre-Amsterdam: no state-access gas events occur, so the State field + // of both `old` and `new` is always zero. Tracers that register only + // V2 still receive every regular-gas change as Gas{State: 0} and + // behave identically to a V1 tracer; there is no pre-Amsterdam event + // a V2-only tracer misses. + // + // V1 and V2 coexist: when both are registered on a tracer, only V2 is + // invoked. Tracers SHOULD register at most one of the two to avoid + // double-counting. + GasChangeHookV2 = func(old, new Gas, reason GasChangeReason) + /* - Chain events - */ @@ -161,6 +240,11 @@ type ( // beacon block root. OnSystemCallEndHook = func() + // StateUpdateHook is called after state is committed for a block. + // It provides access to the complete state mutations including account changes, + // storage changes, trie node mutations, and contract code deployments. + StateUpdateHook = func(update *StateUpdate) + /* - State events - */ @@ -192,13 +276,14 @@ type ( type Hooks struct { // VM events - OnTxStart TxStartHook - OnTxEnd TxEndHook - OnEnter EnterHook - OnExit ExitHook - OnOpcode OpcodeHook - OnFault FaultHook - OnGasChange GasChangeHook + OnTxStart TxStartHook + OnTxEnd TxEndHook + OnEnter EnterHook + OnExit ExitHook + OnOpcode OpcodeHook + OnFault FaultHook + OnGasChange GasChangeHook + OnGasChangeV2 GasChangeHookV2 // Chain events OnBlockchainInit BlockchainInitHook OnClose CloseHook @@ -209,6 +294,7 @@ type Hooks struct { OnSystemCallStart OnSystemCallStartHook OnSystemCallStartV2 OnSystemCallStartHookV2 OnSystemCallEnd OnSystemCallEndHook + OnStateUpdate StateUpdateHook // State events OnBalanceChange BalanceChangeHook OnNonceChange NonceChangeHook @@ -221,6 +307,35 @@ type Hooks struct { OnBlockHashRead BlockHashReadHook } +// HasGasHook reports whether any gas-change hook is registered. Call sites +// should use this to short-circuit before constructing the Gas / GasBudget +// arguments to EmitGasChange when tracing is off — the dispatch is otherwise +// always paid the cost of evaluating those args. +func (h *Hooks) HasGasHook() bool { + return h != nil && (h.OnGasChangeV2 != nil || h.OnGasChange != nil) +} + +// EmitGasChange dispatches a gas change event to the registered hooks. If the +// multi-dimensional OnGasChangeV2 hook is set it is invoked with the full Gas +// vectors; otherwise the single-dimensional OnGasChange hook is invoked with +// the regular-gas dimension only. The call is a no-op when the receiver is +// nil, when neither hook is registered, or when the reason is GasChangeIgnored. +// +// Call sites SHOULD use this helper instead of invoking the hooks directly so +// that both variants stay consistent across the Amsterdam fork boundary. +func (h *Hooks) EmitGasChange(old, new Gas, reason GasChangeReason) { + if h == nil || reason == GasChangeIgnored { + return + } + if h.OnGasChangeV2 != nil { + h.OnGasChangeV2(old, new, reason) + return + } + if h.OnGasChange != nil { + h.OnGasChange(old.Regular, new.Regular, reason) + } +} + // BalanceChangeReason is used to indicate the reason for a balance change, useful // for tracing and reporting. type BalanceChangeReason byte @@ -276,6 +391,19 @@ const ( BalanceChangeRevert BalanceChangeReason = 15 ) +// Gas represents a multi-dimensional gas budget introduced by EIP-8037. +// It carries the regular execution gas and the state-access gas, which are +// metered independently from the Amsterdam fork onwards. +// +// Before Amsterdam, gas metering is single-dimensional and only the Regular +// field is meaningful; State is always zero. The struct is shaped so that +// pre-Amsterdam call sites can populate it as Gas{Regular: g} without loss +// of fidelity relative to the legacy single-uint64 hook. +type Gas struct { + Regular uint64 // Regular is the budget for ordinary execution gas. + State uint64 // State is the budget dedicated to state-access gas (zero pre-Amsterdam). +} + // GasChangeReason is used to indicate the reason for a gas change, useful // for tracing and reporting. // @@ -301,7 +429,7 @@ const ( // this generates an increase in gas. There is at most one of such gas change per transaction. GasChangeTxRefunds GasChangeReason = 3 // GasChangeTxLeftOverReturned is the amount of gas left over at the end of transaction's execution that will be returned - // to the chain. This change will always be a negative change as we "drain" left over gas towards 0. If there was no gas + // to the account. This change will always be a negative change as we "drain" left over gas towards 0. If there was no gas // left at the end of execution, no such even will be emitted. The returned gas's value in Wei is returned to caller. // There is at most one of such gas change per transaction. GasChangeTxLeftOverReturned GasChangeReason = 4 @@ -369,12 +497,15 @@ const ( // NonceChangeNewContract is the nonce change of a newly created contract. NonceChangeNewContract NonceChangeReason = 4 - // NonceChangeTransaction is the nonce change due to a EIP-7702 authorization. + // NonceChangeAuthorization is the nonce change due to a EIP-7702 authorization. NonceChangeAuthorization NonceChangeReason = 5 // NonceChangeRevert is emitted when the nonce is reverted back to a previous value due to call failure. // It is only emitted when the tracer has opted in to use the journaling wrapper (WrapWithJournal). NonceChangeRevert NonceChangeReason = 6 + + // NonceChangeSelfdestruct is emitted when the nonce is reset to zero due to a self-destruct + NonceChangeSelfdestruct NonceChangeReason = 7 ) // CodeChangeReason is used to indicate the reason for a code change. diff --git a/core/tracing/journal.go b/core/tracing/journal.go index 62a70d6c2728..560c93711522 100644 --- a/core/tracing/journal.go +++ b/core/tracing/journal.go @@ -155,10 +155,18 @@ func (j *journal) OnBalanceChange(addr common.Address, prev, new *big.Int, reaso } func (j *journal) OnNonceChangeV2(addr common.Address, prev, new uint64, reason NonceChangeReason) { - // When a contract is created, the nonce of the creator is incremented. - // This change is not reverted when the creation fails. - if reason != NonceChangeContractCreator { - j.entries = append(j.entries, nonceChange{addr: addr, prev: prev, new: new}) + j.entries = append(j.entries, nonceChange{addr: addr, prev: prev, new: new}) + if reason == NonceChangeContractCreator { + // When a contract is created via CREATE/CREATE2, the creator's nonce is + // incremented. The EVM does not revert this when the CREATE frame itself + // fails (the nonce change happens before the EVM snapshot). However, if + // a parent frame reverts, the nonce must be reverted along with everything + // else. + // + // To achieve this, advance the current frame's revision point past this + // entry. The CREATE frame's revert won't touch it (it's below the revision), + // but a parent frame's revert will (it's above the parent's revision). + j.revisions[len(j.revisions)-1] = len(j.entries) } if j.hooks.OnNonceChangeV2 != nil { j.hooks.OnNonceChangeV2(addr, prev, new, reason) diff --git a/core/tracing/journal_test.go b/core/tracing/journal_test.go index e00447f5f3ee..488d192502eb 100644 --- a/core/tracing/journal_test.go +++ b/core/tracing/journal_test.go @@ -219,6 +219,42 @@ func TestNonceIncOnCreate(t *testing.T) { } } +// TestNonceIncOnCreateParentReverts checks that the creator's nonce increment +// from CREATE survives the CREATE frame's own revert but is properly reverted +// when the parent call frame reverts. +func TestNonceIncOnCreateParentReverts(t *testing.T) { + const opCREATE = 0xf0 + + tr := &testTracer{t: t} + wr, err := WrapWithJournal(&Hooks{OnNonceChange: tr.OnNonceChange}) + if err != nil { + t.Fatalf("failed to wrap test tracer: %v", err) + } + + addr := common.HexToAddress("0x1234") + { + // Parent call frame + wr.OnEnter(0, 0, addr, addr, nil, 1000, big.NewInt(0)) + { + // CREATE frame — creator nonce incremented, then CREATE reverts + wr.OnEnter(1, opCREATE, addr, addr, nil, 1000, big.NewInt(0)) + wr.OnNonceChangeV2(addr, 0, 1, NonceChangeContractCreator) + wr.OnExit(1, nil, 100, errors.New("revert"), true) + } + // After CREATE reverts, nonce should still be 1 + if tr.nonce != 1 { + t.Fatalf("nonce after CREATE revert: got %v, want 1", tr.nonce) + } + // Parent frame also reverts + wr.OnExit(0, nil, 150, errors.New("revert"), true) + } + + // After parent reverts, nonce should be back to 0 + if tr.nonce != 0 { + t.Fatalf("nonce after parent revert: got %v, want 0", tr.nonce) + } +} + func TestOnNonceChangeV2(t *testing.T) { tr := &testTracer{t: t} wr, err := WrapWithJournal(&Hooks{OnNonceChangeV2: tr.OnNonceChangeV2}) diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index bfaf4d5b8e3c..f8021e00c484 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -21,12 +21,10 @@ import ( "container/heap" "errors" "fmt" - "maps" "math" "math/big" "os" "path/filepath" - "slices" "sort" "sync" "sync/atomic" @@ -97,12 +95,29 @@ const ( // store. storeVersion = 1 - // conversionTimeWindow defines the period after the Osaka fork during which - // the pool will still accept and convert legacy blob transactions. After this - // window, all legacy blob transactions will be rejected. - conversionTimeWindow = time.Hour * 2 + // gappedLifetime is the approximate duration for which nonce-gapped transactions + // are kept before being dropped. Since gapped is only a reorder buffer and it + // is expected that the original transactions were inserted in the mempool in + // nonce order, the duration is kept short to avoid DoS vectors. + gappedLifetime = 1 * time.Minute + + // maxGappedTxs is the maximum number of gapped transactions kept overall. + // This is a safety limit to avoid DoS vectors. + maxGapped = 128 + + // notifyThreshold is the eviction priority threshold above which a transaction + // is considered close enough to being includable to be announced to peers. + // Setting this to zero will disable announcements for anyting not immediately + // includable. Setting it to -1 allows transactions that are close to being + // includable, maybe already in the next block if fees go down, to be announced. + + // Note, this threshold is in the abstract eviction priority space, so its + // meaning depends on the current basefee/blobfee and the transaction's fees. + announceThreshold = -1 ) +var errLegacyTx = errors.New("legacy transaction format") + // blobTxMeta is the minimal subset of types.BlobTx necessary to validate and // schedule the blob transactions into the following blocks. Only ever add the // bare minimum needed fields to keep the size down (and thus number of entries @@ -112,6 +127,8 @@ type blobTxMeta struct { vhashes []common.Hash // Blob versioned hashes to maintain the lookup table version byte // Blob transaction version to determine proof type + announced bool // Whether the tx has been announced to listeners + id uint64 // Storage ID in the pool's persistent store storageSize uint32 // Byte size in the pool's persistent store size uint64 // RLP-encoded size of transaction including the attached blob @@ -132,31 +149,140 @@ type blobTxMeta struct { evictionBlobFeeJumps float64 // Worse blob fee (converted to fee jumps) across all previous nonces } -// newBlobTxMeta retrieves the indexed metadata fields from a blob transaction -// and assembles a helper struct to track in memory. -// Requires the transaction to have a sidecar (or that we introduce a special version tag for no-sidecar). -func newBlobTxMeta(id uint64, size uint64, storageSize uint32, tx *types.Transaction) *blobTxMeta { - if tx.BlobTxSidecar() == nil { - // This should never happen, as the pool only admits blob transactions with a sidecar +// blobTxForPool is the storage representation of a blob transaction in the +// blobpool. +type blobTxForPool struct { + Tx *types.Transaction // tx without sidecar + Version byte + Commitments []kzg4844.Commitment + Proofs []kzg4844.Proof + Blobs []kzg4844.Blob +} + +// Sidecar returns BlobTxSidecar of ptx. +func (ptx *blobTxForPool) Sidecar() *types.BlobTxSidecar { + return types.NewBlobTxSidecar(ptx.Version, ptx.Blobs, ptx.Commitments, ptx.Proofs) +} + +// ApplySidecar copies the sidecar's fields into the flat fields. +func (ptx *blobTxForPool) ApplySidecar(sc *types.BlobTxSidecar) { + ptx.Version = sc.Version + ptx.Commitments = sc.Commitments + ptx.Proofs = sc.Proofs + ptx.Blobs = sc.Blobs +} + +// TxSize returns the transaction size on the network without +// reconstructing the transaction. +func (ptx *blobTxForPool) TxSize() uint64 { + var blobs, commitments, proofs uint64 + for i := range ptx.Blobs { + blobs += rlp.BytesSize(ptx.Blobs[i][:]) + } + for i := range ptx.Commitments { + commitments += rlp.BytesSize(ptx.Commitments[i][:]) + } + for i := range ptx.Proofs { + proofs += rlp.BytesSize(ptx.Proofs[i][:]) + } + return ptx.Tx.Size() + rlp.ListSize(rlp.ListSize(blobs)+rlp.ListSize(commitments)+rlp.ListSize(proofs)) +} + +// ToTx reconstructs a full Transaction with the sidecar attached. +func (ptx *blobTxForPool) ToTx() *types.Transaction { + return ptx.Tx.WithBlobTxSidecar(ptx.Sidecar()) +} + +// newBlobTxForPool decomposes a blob transaction into blobTxForPool type. +func newBlobTxForPool(tx *types.Transaction) *blobTxForPool { + sc := tx.BlobTxSidecar() + if sc == nil { panic("missing blob tx sidecar") } + return &blobTxForPool{ + Tx: tx.WithoutBlobTxSidecar(), + Version: sc.Version, + Commitments: sc.Commitments, + Proofs: sc.Proofs, + Blobs: sc.Blobs, + } +} + +// encodeForNetwork transforms stored blobTxForPool RLP into the standard +// network transaction encoding. This is used for getRLP. +// +// Stored RLP: [type_byte || tx_fields, version, [comms], [proofs], [blobs]] +// V0: type_byte || rlp([tx_fields, [blobs], [comms], [proofs]]) +// V1: type_byte || rlp([tx_fields, version, [blobs], [comms], [proofs]]) +func encodeForNetwork(storedRLP []byte) ([]byte, error) { + elems, err := rlp.SplitListValues(storedRLP) + if err != nil { + return nil, fmt.Errorf("invalid blobTxForPool RLP: %w", err) + } + if len(elems) < 5 { + return nil, fmt.Errorf("blobTxForPool has %d elements, need at least 5", len(elems)) + } + + // 1. Extract tx byte and other tx fields + txBytes, _, err := rlp.SplitString(elems[0]) + if err != nil { + return nil, fmt.Errorf("invalid tx bytes: %w", err) + } + if len(txBytes) < 2 { + return nil, errors.New("tx bytes too short") + } + typeByte := txBytes[0] + txRLP := txBytes[1:] + + // 2. Find the version of sidecar. + version, _, err := rlp.SplitUint64(elems[1]) + if err != nil || version > 255 { + return nil, fmt.Errorf("invalid version: %w", err) + } + versionByte := byte(version) + // 3. Extract sidecar elements. + commitmentsRLP := elems[2] + proofsRLP := elems[3] + blobsRLP := elems[4] + + // 4. Reconstruct into the network format. + var outer [][]byte + if versionByte == types.BlobSidecarVersion0 { + outer = [][]byte{txRLP, blobsRLP, commitmentsRLP, proofsRLP} + } else { + outer = [][]byte{txRLP, elems[1], blobsRLP, commitmentsRLP, proofsRLP} + } + body, err := rlp.MergeListValues(outer) + if err != nil { + return nil, err + } + // Prepend type byte and wrap as an RLP string. + inner := make([]byte, 1+len(body)) + inner[0] = typeByte + copy(inner[1:], body) + return rlp.EncodeToBytes(inner) +} + +// newBlobTxMeta retrieves the indexed metadata fields from a pooled blob +// transaction and assembles a helper struct to track in memory. +func newBlobTxMeta(id uint64, size uint64, storageSize uint32, ptx *blobTxForPool) *blobTxMeta { meta := &blobTxMeta{ - hash: tx.Hash(), - vhashes: tx.BlobHashes(), - version: tx.BlobTxSidecar().Version, + hash: ptx.Tx.Hash(), + vhashes: ptx.Tx.BlobHashes(), + version: ptx.Version, id: id, storageSize: storageSize, size: size, - nonce: tx.Nonce(), - costCap: uint256.MustFromBig(tx.Cost()), - execTipCap: uint256.MustFromBig(tx.GasTipCap()), - execFeeCap: uint256.MustFromBig(tx.GasFeeCap()), - blobFeeCap: uint256.MustFromBig(tx.BlobGasFeeCap()), - execGas: tx.Gas(), - blobGas: tx.BlobGas(), + nonce: ptx.Tx.Nonce(), + costCap: uint256.MustFromBig(ptx.Tx.Cost()), + execTipCap: uint256.MustFromBig(ptx.Tx.GasTipCap()), + execFeeCap: uint256.MustFromBig(ptx.Tx.GasFeeCap()), + blobFeeCap: uint256.MustFromBig(ptx.Tx.BlobGasFeeCap()), + execGas: ptx.Tx.Gas(), + blobGas: ptx.Tx.BlobGas(), } meta.basefeeJumps = dynamicFeeJumps(meta.execFeeCap) - meta.blobfeeJumps = dynamicFeeJumps(meta.blobFeeCap) + meta.blobfeeJumps = dynamicBlobFeeJumps(meta.blobFeeCap) return meta } @@ -207,6 +333,14 @@ func newBlobTxMeta(id uint64, size uint64, storageSize uint32, tx *types.Transac // via a normal transaction. It should nonetheless be high enough to support // resurrecting reorged transactions. Perhaps 4-16. // +// - It is not the role of the blobpool to serve as a storage for limit orders +// below market: blob transactions with fee caps way below base fee or blob fee. +// Therefore, the propagation of blob transactions that are far from being +// includable is suppressed. The pool will only announce blob transactions that +// are close to being includable (based on the current fees and the transaction's +// fee caps), and will delay the announcement of blob transactions that are far +// from being includable until base fee and/or blob fee is reduced. +// // - Local txs are meaningless. Mining pools historically used local transactions // for payouts or for backdoor deals. With 1559 in place, the basefee usually // dominates the final price, so 0 or non-0 tip doesn't change much. Blob txs @@ -278,47 +412,54 @@ func newBlobTxMeta(id uint64, size uint64, storageSize uint32, tx *types.Transac // solve after every block. // // - The first observation is that comparing 1559 base fees or 4844 blob fees -// needs to happen in the context of their dynamism. Since these fees jump -// up or down in ~1.125 multipliers (at max) across blocks, comparing fees -// in two transactions should be based on log1.125(fee) to eliminate noise. +// needs to happen in the context of their dynamism. Since base fees are +// adjusted continuously and fluctuate, and we want to optimize for effective +// miner fees, it is better to disregard small base fee cap differences. +// Instead of considering the exact fee cap values, we should group +// transactions into buckets based on fee cap values, allowing us to use +// the miner tip meaningfully as a splitter inside a bucket. // -// - The second observation is that the basefee and blobfee move independently, -// so there's no way to split mixed txs on their own (A has higher base fee, -// B has higher blob fee). Rather than look at the absolute fees, the useful -// metric is the max time it can take to exceed the transaction's fee caps. +// To create these buckets, rather than looking at the absolute fee +// differences, the useful metric is the max time it can take to exceed the +// transaction's fee caps. Base fee changes are multiplicative, so we use a +// logarithmic scale. Fees jumps up or down in ~1.125 multipliers at max +// across blocks, so we use log1.125(fee) and rounding to eliminate noise. // Specifically, we're interested in the number of jumps needed to go from // the current fee to the transaction's cap: // -// jumps = log1.125(txfee) - log1.125(basefee) +// jumps = floor(log1.125(txfee) - log1.125(basefee)) +// +// For blob fees, EIP-7892 changed the ratio of target to max blobs, and +// with that also the maximum blob fee decrease in a slot from 1.125 to +// approx 1.17. therefore, we use: // -// - The third observation is that the base fee tends to hover around rather -// than swing wildly. The number of jumps needed from the current fee starts -// to get less relevant the higher it is. To remove the noise here too, the -// pool will use log(jumps) as the delta for comparing transactions. +// blobfeeJumps = floor(log1.17(txBlobfee) - log1.17(blobfee)) // -// delta = sign(jumps) * log(abs(jumps)) +// - The second observation is that when ranking executable blob txs, it +// does not make sense to grant a later eviction priority to txs with high +// fee caps since it could enable pool wars. As such, any positive priority +// will be grouped together. +// +// priority = min(jumps, 0) +// +// - The third observation is that the basefee and blobfee move independently, +// so there's no way to split mixed txs on their own (A has higher base fee, +// B has higher blob fee). // -// - To establish a total order, we need to reduce the dimensionality of the +// To establish a total order, we need to reduce the dimensionality of the // two base fees (log jumps) to a single value. The interesting aspect from // the pool's perspective is how fast will a tx get executable (fees going // down, crossing the smaller negative jump counter) or non-executable (fees // going up, crossing the smaller positive jump counter). As such, the pool // cares only about the min of the two delta values for eviction priority. // -// priority = min(deltaBasefee, deltaBlobfee) +// priority = min(deltaBasefee, deltaBlobfee, 0) // // - The above very aggressive dimensionality and noise reduction should result // in transaction being grouped into a small number of buckets, the further // the fees the larger the buckets. This is good because it allows us to use // the miner tip meaningfully as a splitter. // -// - For the scenario where the pool does not contain non-executable blob txs -// anymore, it does not make sense to grant a later eviction priority to txs -// with high fee caps since it could enable pool wars. As such, any positive -// priority will be grouped together. -// -// priority = min(deltaBasefee, deltaBlobfee, 0) -// // Optimisation tradeoffs: // // - Eviction relies on 3 fee minimums per account (exec tip, exec cap and blob @@ -337,9 +478,11 @@ type BlobPool struct { stored uint64 // Useful data size of all transactions on disk limbo *limbo // Persistent data store for the non-finalized blobs - signer types.Signer // Transaction signer to use for sender recovery - chain BlockChain // Chain object to access the state through - cQueue *conversionQueue // The queue for performing legacy sidecar conversion (TODO: remove after Osaka) + gapped map[common.Address][]*types.Transaction // Transactions that are currently gapped (nonce too high) + gappedSource map[common.Hash]common.Address // Source of gapped transactions to allow rechecking on inclusion + + signer types.Signer // Transaction signer to use for sender recovery + chain BlockChain // Chain object to access the state through head atomic.Pointer[types.Header] // Current head of the chain state *state.StateDB // Current state at the head of the chain @@ -368,16 +511,22 @@ func New(config Config, chain BlockChain, hasPendingAuth func(common.Address) bo hasPendingAuth: hasPendingAuth, signer: types.LatestSigner(chain.Config()), chain: chain, - cQueue: newConversionQueue(), // Deprecate it after the osaka fork lookup: newLookup(), index: make(map[common.Address][]*blobTxMeta), spent: make(map[common.Address]*uint256.Int), + gapped: make(map[common.Address][]*types.Transaction), + gappedSource: make(map[common.Hash]common.Address), } } // Filter returns whether the given transaction can be consumed by the blob pool. func (p *BlobPool) Filter(tx *types.Transaction) bool { - return tx.Type() == types.BlobTxType + return p.FilterType(tx.Type()) +} + +// FilterType returns whether the blob pool supports the given transaction type. +func (p *BlobPool) FilterType(kind byte) bool { + return kind == types.BlobTxType } // Init sets the gas price needed to keep a transaction in the pool and the chain @@ -403,9 +552,9 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserver txpool.Reser // Initialize the state with head block, or fallback to empty one in // case the head state is not available (might occur when node is not // fully synced). - state, err := p.chain.StateAt(head.Root) + state, err := p.chain.StateAt(head) if err != nil { - state, err = p.chain.StateAt(types.EmptyRootHash) + state, err = p.chain.StateAt(p.chain.Genesis().Header()) } if err != nil { return err @@ -414,7 +563,7 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserver txpool.Reser p.state = state // Create new slotter for pre-Osaka blob configuration. - slotter := newSlotter(eip4844.LatestMaxBlobsPerBlock(p.chain.Config())) + slotter := newSlotter(params.BlobTxMaxBlobs) // See if we need to migrate the queue blob store after fusaka slotter, err = tryMigrate(p.chain.Config(), slotter, queuedir) @@ -422,10 +571,17 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserver txpool.Reser return err } // Index all transactions on disk and delete anything unprocessable - var fails []uint64 + var ( + toDelete []uint64 + convertTxs []uint64 + ) index := func(id uint64, size uint32, blob []byte) { - if p.parseTransaction(id, size, blob) != nil { - fails = append(fails, id) + err := p.parseTransaction(id, size, blob) + if err != nil { + toDelete = append(toDelete, id) + } + if errors.Is(err, errLegacyTx) { + convertTxs = append(convertTxs, id) } } store, err := billy.Open(billy.Options{Path: queuedir, Repair: true}, slotter, index) @@ -434,17 +590,58 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserver txpool.Reser } p.store = store - if len(fails) > 0 { - log.Warn("Dropping invalidated blob transactions", "ids", fails) - dropInvalidMeter.Mark(int64(len(fails))) + // Migrate legacy transactions (types.Transaction) to pooledBlobTx format. + if len(convertTxs) > 0 { + for _, id := range convertTxs { + var tx types.Transaction + data, err := p.store.Get(id) + if err != nil { + continue + } + err = rlp.DecodeBytes(data, &tx) + if err != nil { + continue + } + if tx.BlobTxSidecar() == nil { + continue + } + ptx := newBlobTxForPool(&tx) + blob, err := rlp.EncodeToBytes(ptx) + if err != nil { + continue + } + id, err := p.store.Put(blob) + if err != nil { + continue + } + meta := newBlobTxMeta(id, ptx.TxSize(), p.store.Size(id), ptx) + + // If the newly inserted transaction fails to be tracked, + // it should also be removed with those in `toDelete` + sender, err := types.Sender(p.signer, ptx.Tx) + if err != nil { + toDelete = append(toDelete, id) + continue + } + if err := p.trackTransaction(meta, sender); err != nil { + toDelete = append(toDelete, id) + continue + } + } + } + + if len(toDelete) > 0 { + log.Warn("Dropping invalidated blob transactions", "ids", toDelete) + dropInvalidMeter.Mark(int64(len(toDelete))) - for _, id := range fails { + for _, id := range toDelete { if err := p.store.Delete(id); err != nil { p.Close() return err } } } + // Sort the indexed transactions by nonce and delete anything gapped, create // the eviction heap of anyone still standing for addr := range p.index { @@ -459,6 +656,20 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserver txpool.Reser } p.evict = newPriceHeap(basefee, blobfee, p.index) + // Guess what was announced. This is needed because we don't want to + // participate in the diffusion of transactions where inclusion is blocked by + // a low base fee transaction. Since we don't persist that info, the best + // we can do is to assume that anything that could have been announced + // at current prices, actually was. + for addr := range p.index { + for _, tx := range p.index[addr] { + tx.announced = p.isAnnouncable(tx) + if !tx.announced { + break + } + } + } + // Pool initialized, attach the blob limbo to it to track blobs included // recently but not yet finalized p.limbo, err = newLimbo(p.chain.Config(), limbodir) @@ -485,9 +696,6 @@ func (p *BlobPool) Init(gasTip uint64, head *types.Header, reserver txpool.Reser // Close closes down the underlying persistent store. func (p *BlobPool) Close() error { - // Terminate the conversion queue - p.cQueue.close() - var errs []error if p.limbo != nil { // Close might be invoked due to error in constructor, before p,limbo is set if err := p.limbo.Close(); err != nil { @@ -509,35 +717,33 @@ func (p *BlobPool) Close() error { // parseTransaction is a callback method on pool creation that gets called for // each transaction on disk to create the in-memory metadata index. +// Return value `bool` is set to true when the entry has old Transaction type. func (p *BlobPool) parseTransaction(id uint64, size uint32, blob []byte) error { - tx := new(types.Transaction) - if err := rlp.DecodeBytes(blob, tx); err != nil { - // This path is impossible unless the disk data representation changes - // across restarts. For that ever improbable case, recover gracefully - // by ignoring this data entry. - log.Error("Failed to decode blob pool entry", "id", id, "err", err) + var ptx blobTxForPool + if err := rlp.DecodeBytes(blob, &ptx); err != nil { + kind, content, _, splitErr := rlp.Split(blob) + // check whether it is legacy tx type + if splitErr == nil && kind == rlp.String && len(content) > 1 && content[0] == 3 { + return errLegacyTx + } return err } - if tx.BlobTxSidecar() == nil { - log.Error("Missing sidecar in blob pool entry", "id", id, "hash", tx.Hash()) - return errors.New("missing blob sidecar") + meta := newBlobTxMeta(id, ptx.TxSize(), size, &ptx) + sender, err := types.Sender(p.signer, ptx.Tx) + if err != nil { + return err } + return p.trackTransaction(meta, sender) +} - meta := newBlobTxMeta(id, tx.Size(), size, tx) +// trackTransaction registers a transaction's metadata in the pool's indices. +func (p *BlobPool) trackTransaction(meta *blobTxMeta, sender common.Address) error { if p.lookup.exists(meta.hash) { // This path is only possible after a crash, where deleted items are not // removed via the normal shutdown-startup procedure and thus may get // partially resurrected. - log.Error("Rejecting duplicate blob pool entry", "id", id, "hash", tx.Hash()) - return errors.New("duplicate blob entry") - } - sender, err := types.Sender(p.signer, tx) - if err != nil { - // This path is impossible unless the signature validity changes across - // restarts. For that ever improbable case, recover gracefully by ignoring - // this data entry. - log.Error("Failed to recover blob tx sender", "id", id, "hash", tx.Hash(), "err", err) - return err + log.Error("Rejecting duplicate blob pool entry", "id", meta.id, "hash", meta.hash) + return fmt.Errorf("duplicate blob entry %d, %s", meta.id, meta.hash) } if _, ok := p.index[sender]; !ok { if err := p.reserver.Hold(sender); err != nil { @@ -813,17 +1019,17 @@ func (p *BlobPool) offload(addr common.Address, nonce uint64, id uint64, inclusi log.Error("Blobs missing for included transaction", "from", addr, "nonce", nonce, "id", id, "err", err) return } - var tx types.Transaction - if err = rlp.DecodeBytes(data, &tx); err != nil { + var ptx blobTxForPool + if err := rlp.DecodeBytes(data, &ptx); err != nil { log.Error("Blobs corrupted for included transaction", "from", addr, "nonce", nonce, "id", id, "err", err) return } - block, ok := inclusions[tx.Hash()] + block, ok := inclusions[ptx.Tx.Hash()] if !ok { log.Warn("Blob transaction swapped out by signer", "from", addr, "nonce", nonce, "id", id) return } - if err := p.limbo.push(&tx, block); err != nil { + if err := p.limbo.push(&ptx, block); err != nil { log.Warn("Failed to offload blob tx into limbo", "err", err) return } @@ -841,7 +1047,10 @@ func (p *BlobPool) Reset(oldHead, newHead *types.Header) { resettimeHist.Update(time.Since(start).Nanoseconds()) }(time.Now()) - statedb, err := p.chain.StateAt(newHead.Root) + // Handle reorg buffer timeouts evicting old gapped transactions + p.evictGapped() + + statedb, err := p.chain.StateAt(newHead) if err != nil { log.Error("Failed to reset blobpool state", "err", err) return @@ -882,175 +1091,40 @@ func (p *BlobPool) Reset(oldHead, newHead *types.Header) { } p.evict.reinit(basefee, blobfee, false) - basefeeGauge.Update(int64(basefee.Uint64())) - blobfeeGauge.Update(int64(blobfee.Uint64())) - p.updateStorageMetrics() - - // Perform the conversion logic at the fork boundary - if !p.chain.Config().IsOsaka(oldHead.Number, oldHead.Time) && p.chain.Config().IsOsaka(newHead.Number, newHead.Time) { - // Deep copy all indexed transaction metadata. - var ( - ids = make(map[common.Address]map[uint64]uint64) - txs = make(map[common.Address]map[uint64]common.Hash) - ) - for sender, list := range p.index { - ids[sender] = make(map[uint64]uint64) - txs[sender] = make(map[uint64]common.Hash) - for _, m := range list { - ids[sender][m.nonce] = m.id - txs[sender][m.nonce] = m.hash + // Announce transactions that became announcable due to fee changes + var announcable []*types.Transaction + for addr, txs := range p.index { + for i, meta := range txs { + if !meta.announced && (i == 0 || txs[i-1].announced) && p.isAnnouncable(meta) { + // Load the full transaction and strip the sidecar before announcing + // TODO: this is a bit ugly, as we have everything needed in meta already + data, err := p.store.Get(meta.id) + // Technically, we are supposed to set announced only if Get is successful. + // However, Get failing here indicates a more serious issue (data loss), + // so we set announced anyway to avoid repeated attempts. + meta.announced = true + if err != nil { + log.Error("Blobs missing for announcable transaction", "from", addr, "nonce", meta.nonce, "id", meta.id, "err", err) + continue + } + var tx types.Transaction + if err = rlp.DecodeBytes(data, &tx); err != nil { + log.Error("Blobs corrupted for announcable transaction", "from", addr, "nonce", meta.nonce, "id", meta.id, "err", err) + continue + } + announcable = append(announcable, tx.WithoutBlobTxSidecar()) + log.Trace("Blob transaction now announcable", "from", addr, "nonce", meta.nonce, "id", meta.id, "hash", tx.Hash()) } } - // Initiate the background conversion thread. - p.cQueue.launchBillyConversion(func() { - p.convertLegacySidecars(ids, txs) - }) } -} - -// compareAndSwap checks if the specified transaction is still tracked in the pool -// and replace the metadata accordingly. It should only be used in the fork boundary -// bulk conversion. If it fails for some reason, the subsequent txs won't be dropped -// for simplicity which we assume it's very likely to happen. -// -// The returned flag indicates whether the replacement succeeded. -func (p *BlobPool) compareAndSwap(address common.Address, hash common.Hash, blob []byte, oldID uint64, oldStorageSize uint32) bool { - p.lock.Lock() - defer p.lock.Unlock() - - newId, err := p.store.Put(blob) - if err != nil { - log.Error("Failed to store transaction", "hash", hash, "err", err) - return false + if len(announcable) > 0 { + p.discoverFeed.Send(core.NewTxsEvent{Txs: announcable}) } - newSize := uint64(len(blob)) - newStorageSize := p.store.Size(newId) - // Terminate the procedure if the transaction was already evicted. The - // newly added blob should be removed before return. - if !p.lookup.update(hash, newId, newSize) { - if derr := p.store.Delete(newId); derr != nil { - log.Error("Failed to delete the dangling blob tx", "err", derr) - } else { - log.Warn("Deleted the dangling blob tx", "id", newId) - } - return false - } - // Update the metadata of blob transaction - for _, meta := range p.index[address] { - if meta.hash == hash { - meta.id = newId - meta.version = types.BlobSidecarVersion1 - meta.storageSize = newStorageSize - meta.size = newSize - - p.stored += uint64(newStorageSize) - p.stored -= uint64(oldStorageSize) - break - } - } - if err := p.store.Delete(oldID); err != nil { - log.Error("Failed to delete the legacy transaction", "hash", hash, "id", oldID, "err", err) - } - return true -} - -// convertLegacySidecar fetches transaction data from the store, performs an -// on-the-fly conversion. This function is intended for use only during the -// Osaka fork transition period. -// -// The returned flag indicates whether the replacement succeeds or not. -func (p *BlobPool) convertLegacySidecar(sender common.Address, hash common.Hash, id uint64) bool { - start := time.Now() - - // Retrieves the legacy blob transaction from the underlying store with - // read lock held, preventing any potential data race around the slot - // specified by the id. - p.lock.RLock() - data, err := p.store.Get(id) - if err != nil { - p.lock.RUnlock() - // The transaction may have been evicted simultaneously, safe to skip conversion. - log.Debug("Blob transaction is missing", "hash", hash, "id", id, "err", err) - return false - } - oldStorageSize := p.store.Size(id) - p.lock.RUnlock() - - // Decode the transaction, the failure is not expected and report the error - // loudly if possible. If the blob transaction in this slot is corrupted, - // leave it in the store, it will be dropped during the next pool - // initialization. - var tx types.Transaction - if err = rlp.DecodeBytes(data, &tx); err != nil { - log.Error("Blob transaction is corrupted", "hash", hash, "id", id, "err", err) - return false - } - - // Skip conversion if the transaction does not match the expected hash, or if it was - // already converted. This can occur if the original transaction was evicted from the - // pool and the slot was reused by a new one. - if tx.Hash() != hash { - log.Warn("Blob transaction was replaced", "hash", hash, "id", id, "stored", tx.Hash()) - return false - } - sc := tx.BlobTxSidecar() - if sc.Version >= types.BlobSidecarVersion1 { - log.Debug("Skipping conversion of blob tx", "hash", hash, "id", id) - return false - } - - // Perform the sidecar conversion, the failure is not expected and report the error - // loudly if possible. - if err := tx.BlobTxSidecar().ToV1(); err != nil { - log.Error("Failed to convert blob transaction", "hash", hash, "err", err) - return false - } - - // Encode the converted transaction, the failure is not expected and report - // the error loudly if possible. - blob, err := rlp.EncodeToBytes(&tx) - if err != nil { - log.Error("Failed to encode blob transaction", "hash", tx.Hash(), "err", err) - return false - } - - // Replace the legacy blob transaction with the converted format. - if !p.compareAndSwap(sender, hash, blob, id, oldStorageSize) { - log.Error("Failed to replace the legacy transaction", "hash", hash) - return false - } - log.Debug("Converted legacy blob transaction", "hash", hash, "elapsed", common.PrettyDuration(time.Since(start))) - return true -} - -// convertLegacySidecars converts all given transactions to sidecar version 1. -// -// If any of them fails to be converted, the subsequent transactions will still -// be processed, as we assume the failure is very unlikely to happen. If happens, -// these transactions will be stuck in the pool until eviction. -func (p *BlobPool) convertLegacySidecars(ids map[common.Address]map[uint64]uint64, txs map[common.Address]map[uint64]common.Hash) { - var ( - start = time.Now() - success int - failure int - ) - for addr, list := range txs { - // Transactions evicted from the pool must be contiguous, if in any case, - // the transactions are gapped with each other, they will be discarded. - nonces := slices.Collect(maps.Keys(list)) - slices.Sort(nonces) - - // Convert the txs with nonce order - for _, nonce := range nonces { - if p.convertLegacySidecar(addr, list[nonce], ids[addr][nonce]) { - success++ - } else { - failure++ - } - } - } - log.Info("Completed blob transaction conversion", "discarded", failure, "injected", success, "elapsed", common.PrettyDuration(time.Since(start))) + // Update the basefee and blobfee metrics + basefeeGauge.Update(int64(basefee.Uint64())) + blobfeeGauge.Update(int64(blobfee.Uint64())) + p.updateStorageMetrics() } // reorg assembles all the transactors and missing transactions between an old @@ -1190,7 +1264,7 @@ func (p *BlobPool) reorg(oldHead, newHead *types.Header) (map[common.Address][]* func (p *BlobPool) reinject(addr common.Address, txhash common.Hash) error { // Retrieve the associated blob from the limbo. Without the blobs, we cannot // add the transaction back into the pool as it is not mineable. - tx, err := p.limbo.pull(txhash) + ptx, err := p.limbo.pull(txhash) if err != nil { log.Error("Blobs unavailable, dropping reorged tx", "err", err) return err @@ -1206,30 +1280,29 @@ func (p *BlobPool) reinject(addr common.Address, txhash common.Hash) error { // could theoretically halt a Geth node for ~1.2s by reorging per block. However, // this attack is financially inefficient to execute. head := p.head.Load() - if p.chain.Config().IsOsaka(head.Number, head.Time) && tx.BlobTxSidecar().Version == types.BlobSidecarVersion0 { - if err := tx.BlobTxSidecar().ToV1(); err != nil { + if p.chain.Config().IsOsaka(head.Number, head.Time) && ptx.Version == types.BlobSidecarVersion0 { + sc := ptx.Sidecar() + if err := sc.ToV1(); err != nil { log.Error("Failed to convert the legacy sidecar", "err", err) return err } - log.Info("Legacy blob transaction is reorged", "hash", tx.Hash()) + ptx.ApplySidecar(sc) + log.Info("Legacy blob transaction is reorged", "hash", ptx.Tx.Hash()) } - // Serialize the transaction back into the primary datastore. - blob, err := rlp.EncodeToBytes(tx) + blob, err := rlp.EncodeToBytes(ptx) if err != nil { - log.Error("Failed to encode transaction for storage", "hash", tx.Hash(), "err", err) + log.Error("Failed to encode transaction for storage", "hash", ptx.Tx.Hash(), "err", err) return err } id, err := p.store.Put(blob) if err != nil { - log.Error("Failed to write transaction into storage", "hash", tx.Hash(), "err", err) + log.Error("Failed to write transaction into storage", "hash", ptx.Tx.Hash(), "err", err) return err } - - // Update the indices and metrics - meta := newBlobTxMeta(id, tx.Size(), p.store.Size(id), tx) + meta := newBlobTxMeta(id, ptx.TxSize(), p.store.Size(id), ptx) if _, ok := p.index[addr]; !ok { if err := p.reserver.Hold(addr); err != nil { - log.Warn("Failed to reserve account for blob pool", "tx", tx.Hash(), "from", addr, "err", err) + log.Warn("Failed to reserve account for blob pool", "tx", ptx.Tx.Hash(), "from", addr, "err", err) return err } p.index[addr] = []*blobTxMeta{meta} @@ -1369,7 +1442,9 @@ func (p *BlobPool) validateTx(tx *types.Transaction) error { State: p.state, FirstNonceGap: func(addr common.Address) uint64 { - // Nonce gaps are not permitted in the blob pool, the first gap will + // Nonce gaps are permitted in the blob pool, but only as part of the + // in-memory 'gapped' buffer. We expose the gap here to validateTx, + // then handle the error by adding to the buffer. The first gap will // be the next nonce shifted by however many transactions we already // have pooled. return p.state.GetNonce(addr) + uint64(len(p.index[addr])) @@ -1448,7 +1523,9 @@ func (p *BlobPool) Has(hash common.Hash) bool { p.lock.RLock() defer p.lock.RUnlock() - return p.lookup.exists(hash) + poolHas := p.lookup.exists(hash) + _, gapped := p.gappedSource[hash] + return poolHas || gapped } func (p *BlobPool) getRLP(hash common.Hash) []byte { @@ -1482,20 +1559,29 @@ func (p *BlobPool) Get(hash common.Hash) *types.Transaction { if len(data) == 0 { return nil } - item := new(types.Transaction) - if err := rlp.DecodeBytes(data, item); err != nil { + var ptx blobTxForPool + if err := rlp.DecodeBytes(data, &ptx); err != nil { id, _ := p.lookup.storeidOfTx(hash) log.Error("Blobs corrupted for traced transaction", "hash", hash, "id", id, "err", err) return nil } - return item + return ptx.ToTx() } -// GetRLP returns a RLP-encoded transaction if it is contained in the pool. +// GetRLP returns a RLP-encoded transaction for network if it is contained in the pool. +// It converts the pool's internal type to the RLP format used by the eth protocol: +// e.g. type_byte || [..., version, [blobs], [comms], [proofs]] func (p *BlobPool) GetRLP(hash common.Hash) []byte { - return p.getRLP(hash) + data := p.getRLP(hash) + rlp, err := encodeForNetwork(data) + if err != nil { + log.Error("Failed to encode pooled tx into the network type", "hash", hash, "err", err) + return nil + } + + return rlp } // GetMetadata returns the transaction type and transaction size with the @@ -1530,8 +1616,8 @@ func (p *BlobPool) GetMetadata(hash common.Hash) *txpool.TxMetadata { // // The version argument specifies the type of proofs to return, either the // blob proofs (version 0) or the cell proofs (version 1). Proofs conversion is -// CPU intensive, so only done if explicitly requested with the convert flag. -func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte, convert bool) ([]*kzg4844.Blob, []kzg4844.Commitment, [][]kzg4844.Proof, error) { +// CPU intensive and prohibited in the blobpool explicitly. +func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte) ([]*kzg4844.Blob, []kzg4844.Commitment, [][]kzg4844.Proof, error) { var ( blobs = make([]*kzg4844.Blob, len(vhashes)) commitments = make([]kzg4844.Commitment, len(vhashes)) @@ -1564,25 +1650,21 @@ func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte, convert bool) ( } // Decode the blob transaction - tx := new(types.Transaction) - if err := rlp.DecodeBytes(data, tx); err != nil { + var ptx blobTxForPool + if err := rlp.DecodeBytes(data, &ptx); err != nil { log.Error("Blobs corrupted for traced transaction", "id", txID, "err", err) continue } - sidecar := tx.BlobTxSidecar() - if sidecar == nil { - log.Error("Blob tx without sidecar", "hash", tx.Hash(), "id", txID) - continue - } + sidecar := ptx.Sidecar() // Traverse the blobs in the transaction - for i, hash := range tx.BlobHashes() { + for i, hash := range ptx.Tx.BlobHashes() { list, ok := indices[hash] if !ok { continue // non-interesting blob } // Mark hash as seen. filled[hash] = struct{}{} - if sidecar.Version != version && !convert { + if sidecar.Version != version { // Skip blobs with incompatible version. Note we still track the blob hash // in `filled` here, ensuring that we do not resolve this tx another time. continue @@ -1591,29 +1673,14 @@ func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte, convert bool) ( var pf []kzg4844.Proof switch version { case types.BlobSidecarVersion0: - if sidecar.Version == types.BlobSidecarVersion0 { - pf = []kzg4844.Proof{sidecar.Proofs[i]} - } else { - proof, err := kzg4844.ComputeBlobProof(&sidecar.Blobs[i], sidecar.Commitments[i]) - if err != nil { - return nil, nil, nil, err - } - pf = []kzg4844.Proof{proof} - } + pf = []kzg4844.Proof{sidecar.Proofs[i]} case types.BlobSidecarVersion1: - if sidecar.Version == types.BlobSidecarVersion0 { - cellProofs, err := kzg4844.ComputeCellProofs(&sidecar.Blobs[i]) - if err != nil { - return nil, nil, nil, err - } - pf = cellProofs - } else { - cellProofs, err := sidecar.CellProofsAt(i) - if err != nil { - return nil, nil, nil, err - } - pf = cellProofs + cellProofs, err := sidecar.CellProofsAt(i) + if err != nil { + log.Error("Failed to get cell proofs", "id", txID, "err", err) + continue } + pf = cellProofs } for _, index := range list { blobs[index] = &sidecar.Blobs[i] @@ -1640,65 +1707,15 @@ func (p *BlobPool) AvailableBlobs(vhashes []common.Hash) int { return available } -// preCheck performs the static validation upon the provided tx and converts -// the legacy sidecars if Osaka fork has been activated with a short time window. -// -// This function is pure static and lock free. -func (p *BlobPool) preCheck(tx *types.Transaction) error { - var ( - head = p.head.Load() - isOsaka = p.chain.Config().IsOsaka(head.Number, head.Time) - deadline time.Time - ) - if isOsaka { - deadline = time.Unix(int64(*p.chain.Config().OsakaTime), 0).Add(conversionTimeWindow) - } - // Validate the transaction statically at first to avoid unnecessary - // conversion. This step doesn't require lock protection. - if err := p.ValidateTxBasics(tx); err != nil { - return err - } - // Before the Osaka fork, reject the blob txs with cell proofs - if !isOsaka { - if tx.BlobTxSidecar().Version == types.BlobSidecarVersion0 { - return nil - } else { - return errors.New("cell proof is not supported yet") - } - } - // After the Osaka fork, reject the legacy blob txs if the conversion - // time window is passed. - if tx.BlobTxSidecar().Version == types.BlobSidecarVersion1 { - return nil - } - if head.Time > uint64(deadline.Unix()) { - return errors.New("legacy blob tx is not supported") - } - // Convert the legacy sidecar after Osaka fork. This could be a long - // procedure which takes a few seconds, even minutes if there is a long - // queue. Fortunately it will only block the routine of the source peer - // announcing the tx, without affecting other parts. - return p.cQueue.convert(tx) -} - // Add inserts a set of blob transactions into the pool if they pass validation (both // consensus validity and pool restrictions). func (p *BlobPool) Add(txs []*types.Transaction, sync bool) []error { - var ( - errs []error = make([]error, len(txs)) - adds = make([]*types.Transaction, 0, len(txs)) - ) + errs := make([]error, len(txs)) for i, tx := range txs { - if errs[i] = p.preCheck(tx); errs[i] != nil { + if errs[i] = p.ValidateTxBasics(tx); errs[i] != nil { continue } - if errs[i] = p.add(tx); errs[i] == nil { - adds = append(adds, tx.WithoutBlobTxSidecar()) - } - } - if len(adds) > 0 { - p.discoverFeed.Send(core.NewTxsEvent{Txs: adds}) - p.insertFeed.Send(core.NewTxsEvent{Txs: adds}) + errs[i] = p.add(tx) } return errs } @@ -1718,6 +1735,13 @@ func (p *BlobPool) add(tx *types.Transaction) (err error) { addtimeHist.Update(time.Since(start).Nanoseconds()) }(time.Now()) + return p.addLocked(tx, true) +} + +// addLocked inserts a new blob transaction into the pool if it passes validation (both +// consensus validity and pool restrictions). It must be called with the pool lock held. +// Only for internal use. +func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (err error) { // Ensure the transaction is valid from all perspectives if err := p.validateTx(tx); err != nil { log.Trace("Transaction validation failed", "hash", tx.Hash(), "err", err) @@ -1730,6 +1754,23 @@ func (p *BlobPool) add(tx *types.Transaction) (err error) { addStaleMeter.Mark(1) case errors.Is(err, core.ErrNonceTooHigh): addGappedMeter.Mark(1) + // Store the tx in memory, and revalidate later + from, _ := types.Sender(p.signer, tx) + allowance := p.gappedAllowance(from) + if allowance >= 1 && len(p.gappedSource) < maxGapped { + p.gapped[from] = append(p.gapped[from], tx) + p.gappedSource[tx.Hash()] = from + gappedGauge.Update(int64(len(p.gappedSource))) + log.Trace("added tx to gapped blob queue", "allowance", allowance, "hash", tx.Hash(), "from", from, "nonce", tx.Nonce(), "qlen", len(p.gapped[from])) + return nil + } else { + // if maxGapped is reached, it is better to give time to gapped + // transactions by keeping the old and dropping this one. + // Thus replacing a gapped transaction with another gapped transaction + // is discouraged. + addGappedFullMeter.Mark(1) + log.Trace("no gapped blob queue allowance", "allowance", allowance, "hash", tx.Hash(), "from", from, "nonce", tx.Nonce(), "qlen", len(p.gapped[from])) + } case errors.Is(err, core.ErrInsufficientFunds): addOverdraftedMeter.Mark(1) case errors.Is(err, txpool.ErrAccountLimitExceeded): @@ -1763,7 +1804,8 @@ func (p *BlobPool) add(tx *types.Transaction) (err error) { } // Transaction permitted into the pool from a nonce and cost perspective, // insert it into the database and update the indices - blob, err := rlp.EncodeToBytes(tx) + ptx := newBlobTxForPool(tx) + blob, err := rlp.EncodeToBytes(ptx) if err != nil { log.Error("Failed to encode transaction for storage", "hash", tx.Hash(), "err", err) return err @@ -1772,7 +1814,7 @@ func (p *BlobPool) add(tx *types.Transaction) (err error) { if err != nil { return err } - meta := newBlobTxMeta(id, tx.Size(), p.store.Size(id), tx) + meta := newBlobTxMeta(id, tx.Size(), p.store.Size(id), ptx) var ( next = p.state.GetNonce(from) @@ -1867,6 +1909,66 @@ func (p *BlobPool) add(tx *types.Transaction) (err error) { p.updateStorageMetrics() addValidMeter.Mark(1) + + // Transaction was addded successfully, but we only announce if it is (close to being) + // includable and the previous one was already announced. + if p.isAnnouncable(meta) && (meta.nonce == next || (len(txs) > 1 && txs[offset-1].announced)) { + meta.announced = true + p.discoverFeed.Send(core.NewTxsEvent{Txs: []*types.Transaction{tx.WithoutBlobTxSidecar()}}) + p.insertFeed.Send(core.NewTxsEvent{Txs: []*types.Transaction{tx.WithoutBlobTxSidecar()}}) + } else { + log.Trace("Blob transaction not announcable yet", "hash", tx.Hash(), "nonce", tx.Nonce()) + } + + //check the gapped queue for this account and try to promote + if gtxs, ok := p.gapped[from]; checkGapped && ok && len(gtxs) > 0 { + // We have to add in nonce order, but we want to stable sort to cater for situations + // where transactions are replaced, keeping the original receive order for same nonce + sort.SliceStable(gtxs, func(i, j int) bool { + return gtxs[i].Nonce() < gtxs[j].Nonce() + }) + for len(gtxs) > 0 { + stateNonce := p.state.GetNonce(from) + firstgap := stateNonce + uint64(len(p.index[from])) + + if gtxs[0].Nonce() > firstgap { + // Anything beyond the first gap is not addable yet + break + } + + // Drop any buffered transactions that became stale in the meantime (included in chain or replaced) + // If we arrive to the transaction in the pending range (between the state Nonce and first gap, we + // try to add them now while removing from here. + tx := gtxs[0] + gtxs[0] = nil + gtxs = gtxs[1:] + delete(p.gappedSource, tx.Hash()) + + if tx.Nonce() < stateNonce { + // Stale, drop it. Eventually we could add to limbo here if hash matches. + log.Trace("Gapped blob transaction became stale", "hash", tx.Hash(), "from", from, "nonce", tx.Nonce(), "state", stateNonce, "qlen", len(p.gapped[from])) + continue + } + + if tx.Nonce() <= firstgap { + // If we hit the pending range, including the first gap, add it and continue to try to add more. + // We do not recurse here, but continue to loop instead. + // We are under lock, so we can add the transaction directly. + if err := p.addLocked(tx, false); err == nil { + gappedPromotedMeter.Mark(1) + log.Trace("Gapped blob transaction added to pool", "hash", tx.Hash(), "from", from, "nonce", tx.Nonce(), "qlen", len(p.gapped[from])) + } else { + log.Trace("Gapped blob transaction not accepted", "hash", tx.Hash(), "from", from, "nonce", tx.Nonce(), "err", err) + } + } + } + if len(gtxs) == 0 { + delete(p.gapped, from) + } else { + p.gapped[from] = gtxs + } + gappedGauge.Update(int64(len(p.gappedSource))) + } return nil } @@ -1929,11 +2031,11 @@ func (p *BlobPool) drop() { // // The transactions can also be pre-filtered by the dynamic fee components to // reduce allocations and load on downstream subsystems. -func (p *BlobPool) Pending(filter txpool.PendingFilter) map[common.Address][]*txpool.LazyTransaction { +func (p *BlobPool) Pending(filter txpool.PendingFilter) (map[common.Address][]*txpool.LazyTransaction, int) { // If only plain transactions are requested, this pool is unsuitable as it // contains none, don't even bother. if !filter.BlobTxs { - return nil + return nil, 0 } // Track the amount of time waiting to retrieve the list of pending blob txs // from the pool and the amount of time actually spent on assembling the data. @@ -1949,6 +2051,7 @@ func (p *BlobPool) Pending(filter txpool.PendingFilter) map[common.Address][]*tx pendtimeHist.Update(time.Since(execStart).Nanoseconds()) }() + var count int pending := make(map[common.Address][]*txpool.LazyTransaction, len(p.index)) for addr, txs := range p.index { lazies := make([]*txpool.LazyTransaction, 0, len(txs)) @@ -1994,9 +2097,10 @@ func (p *BlobPool) Pending(filter txpool.PendingFilter) map[common.Address][]*tx } if len(lazies) > 0 { pending[addr] = lazies + count += len(lazies) } } - return pending + return pending, count } // updateStorageMetrics retrieves a bunch of stats from the data store and pushes @@ -2098,6 +2202,58 @@ func (p *BlobPool) Nonce(addr common.Address) uint64 { return p.state.GetNonce(addr) } +// gappedAllowance returns the number of gapped transactions still +// allowed for the given account. Allowance is based on a slow-start +// logic, allowing more gaps (resource usage) to accounts with a +// higher nonce. Can also return negative values. +func (p *BlobPool) gappedAllowance(addr common.Address) int { + // Gaps happen, but we don't want to allow too many. + // Use log10(nonce+1) as the allowance, with a minimum of 0. + nonce := p.state.GetNonce(addr) + allowance := int(math.Log10(float64(nonce + 1))) + // Cap the allowance to the remaining pool space + return min(allowance, maxTxsPerAccount-len(p.index[addr])) - len(p.gapped[addr]) +} + +// evictGapped removes the old transactions from the gapped reorder buffer. +// Concurrency: The caller must hold the pool lock before calling this function. +func (p *BlobPool) evictGapped() { + cutoff := time.Now().Add(-gappedLifetime) + for from, txs := range p.gapped { + nonce := p.state.GetNonce(from) + // Reuse the original slice to avoid extra allocations. + // This is safe because we only keep references to the original gappedTx objects, + // and we overwrite the slice for this account after filtering. + keep := txs[:0] + for i, gtx := range txs { + if gtx.Time().Before(cutoff) || gtx.Nonce() < nonce { + // Evict old or stale transactions + // Should we add stale to limbo here if it would belong? + delete(p.gappedSource, gtx.Hash()) + txs[i] = nil // Explicitly nil out evicted element + } else { + keep = append(keep, gtx) + } + } + if evicted := len(txs) - len(keep); evicted > 0 { + gappedEvictedMeter.Mark(int64(evicted)) + log.Trace("Evicting old gapped blob transactions", "count", evicted, "from", from) + } + if len(keep) == 0 { + delete(p.gapped, from) + } else { + p.gapped[from] = keep + } + } + gappedGauge.Update(int64(len(p.gappedSource))) +} + +// isAnnouncable checks whether a transaction is announcable based on its +// fee parameters and announceThreshold. +func (p *BlobPool) isAnnouncable(meta *blobTxMeta) bool { + return evictionPriority(p.evict.basefeeJumps, meta.basefeeJumps, p.evict.blobfeeJumps, meta.blobfeeJumps) >= announceThreshold +} + // Stats retrieves the current pool stats, namely the number of pending and the // number of queued (non-executable) transactions. func (p *BlobPool) Stats() (int, int) { @@ -2132,9 +2288,15 @@ func (p *BlobPool) ContentFrom(addr common.Address) ([]*types.Transaction, []*ty // Status returns the known status (unknown/pending/queued) of a transaction // identified by their hashes. func (p *BlobPool) Status(hash common.Hash) txpool.TxStatus { - if p.Has(hash) { + p.lock.RLock() + defer p.lock.RUnlock() + + if p.lookup.exists(hash) { return txpool.TxStatusPending } + if _, gapped := p.gappedSource[hash]; gapped { + return txpool.TxStatusQueued + } return txpool.TxStatusUnknown } @@ -2184,6 +2346,11 @@ func (p *BlobPool) Clear() { p.index = make(map[common.Address][]*blobTxMeta) p.spent = make(map[common.Address]*uint256.Int) + // Reset counters and the gapped buffer + p.stored = 0 + p.gapped = make(map[common.Address][]*types.Transaction) + p.gappedSource = make(map[common.Hash]common.Address) + var ( basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head.Load())) blobfee = uint256.NewInt(params.BlobTxMinBlobGasprice) diff --git a/core/txpool/blobpool/blobpool_test.go b/core/txpool/blobpool/blobpool_test.go index 2fa1927cae2c..8032e21e8a47 100644 --- a/core/txpool/blobpool/blobpool_test.go +++ b/core/txpool/blobpool/blobpool_test.go @@ -45,6 +45,7 @@ import ( "github.com/ethereum/go-ethereum/internal/testrand" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" "github.com/holiman/billy" "github.com/holiman/uint256" ) @@ -92,10 +93,6 @@ type testBlockChain struct { blockTime *uint64 } -func (bc *testBlockChain) setHeadTime(time uint64) { - bc.blockTime = &time -} - func (bc *testBlockChain) Config() *params.ChainConfig { return bc.config } @@ -184,10 +181,14 @@ func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block return bc.blocks[number] } -func (bc *testBlockChain) StateAt(common.Hash) (*state.StateDB, error) { +func (bc *testBlockChain) StateAt(header *types.Header) (*state.StateDB, error) { return bc.statedb, nil } +func (bc *testBlockChain) Genesis() *types.Block { + return types.NewBlock(bc.CurrentBlock(), nil, nil, trie.NewStackTrie(nil)) +} + // reserver is a utility struct to sanity check that accounts are // properly reserved by the blobpool (no duplicate reserves or unreserves). type reserver struct { @@ -234,6 +235,12 @@ func makeTx(nonce uint64, gasTipCap uint64, gasFeeCap uint64, blobFeeCap uint64, return types.MustSignNewTx(key, types.LatestSigner(params.MainnetChainConfig), blobtx) } +// encodeForPool encodes a blob transaction in the blobTxForPool storage format. +func encodeForPool(tx *types.Transaction) []byte { + blob, _ := rlp.EncodeToBytes(newBlobTxForPool(tx)) + return blob +} + // makeMultiBlobTx is a utility method to construct a ramdom blob tx with // certain number of blobs in its sidecar. func makeMultiBlobTx(nonce uint64, gasTipCap uint64, gasFeeCap uint64, blobFeeCap uint64, blobCount int, blobOffset int, key *ecdsa.PrivateKey, version byte) *types.Transaction { @@ -433,11 +440,11 @@ func verifyBlobRetrievals(t *testing.T, pool *BlobPool) { hashes = append(hashes, tx.vhashes...) } } - blobs1, _, proofs1, err := pool.GetBlobs(hashes, types.BlobSidecarVersion0, false) + blobs1, _, proofs1, err := pool.GetBlobs(hashes, types.BlobSidecarVersion0) if err != nil { t.Fatal(err) } - blobs2, _, proofs2, err := pool.GetBlobs(hashes, types.BlobSidecarVersion1, false) + blobs2, _, proofs2, err := pool.GetBlobs(hashes, types.BlobSidecarVersion1) if err != nil { t.Fatal(err) } @@ -529,7 +536,7 @@ func TestOpenDrops(t *testing.T) { ) for _, nonce := range []uint64{0, 1, 3, 4, 6, 7} { // first gap at #2, another at #5 tx := makeTx(nonce, 1, 1, 1, gapper) - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) if nonce < 2 { @@ -546,7 +553,7 @@ func TestOpenDrops(t *testing.T) { ) for _, nonce := range []uint64{1, 2, 3} { // first gap at #0, all set dangling tx := makeTx(nonce, 1, 1, 1, dangler) - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) dangling[id] = struct{}{} @@ -559,7 +566,7 @@ func TestOpenDrops(t *testing.T) { ) for _, nonce := range []uint64{0, 1, 2} { // account nonce at 3, all set filled tx := makeTx(nonce, 1, 1, 1, filler) - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) filled[id] = struct{}{} @@ -572,7 +579,7 @@ func TestOpenDrops(t *testing.T) { ) for _, nonce := range []uint64{0, 1, 2, 3} { // account nonce at 2, half filled tx := makeTx(nonce, 1, 1, 1, overlapper) - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) if nonce >= 2 { @@ -594,7 +601,7 @@ func TestOpenDrops(t *testing.T) { } else { tx = makeTx(uint64(i), 1, 1, 1, underpayer) } - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) underpaid[id] = struct{}{} @@ -613,7 +620,7 @@ func TestOpenDrops(t *testing.T) { } else { tx = makeTx(uint64(i), 1, 1, 1, outpricer) } - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) if i < 2 { @@ -635,7 +642,7 @@ func TestOpenDrops(t *testing.T) { } else { tx = makeTx(nonce, 1, 1, 1, exceeder) } - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) exceeded[id] = struct{}{} @@ -653,7 +660,7 @@ func TestOpenDrops(t *testing.T) { } else { tx = makeTx(nonce, 1, 1, 1, overdrafter) } - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) id, _ := store.Put(blob) if nonce < 1 { @@ -669,7 +676,7 @@ func TestOpenDrops(t *testing.T) { overcapped = make(map[uint64]struct{}) ) for nonce := uint64(0); nonce < maxTxsPerAccount+3; nonce++ { - blob, _ := rlp.EncodeToBytes(makeTx(nonce, 1, 1, 1, overcapper)) + blob := encodeForPool(makeTx(nonce, 1, 1, 1, overcapper)) id, _ := store.Put(blob) if nonce < maxTxsPerAccount { @@ -685,7 +692,7 @@ func TestOpenDrops(t *testing.T) { duplicated = make(map[uint64]struct{}) ) for _, nonce := range []uint64{0, 1, 2} { - blob, _ := rlp.EncodeToBytes(makeTx(nonce, 1, 1, 1, duplicater)) + blob := encodeForPool(makeTx(nonce, 1, 1, 1, duplicater)) for i := 0; i < int(nonce)+1; i++ { id, _ := store.Put(blob) @@ -704,7 +711,7 @@ func TestOpenDrops(t *testing.T) { ) for _, nonce := range []uint64{0, 1, 2} { for i := 0; i < int(nonce)+1; i++ { - blob, _ := rlp.EncodeToBytes(makeTx(nonce, 1, uint64(i)+1 /* unique hashes */, 1, repeater)) + blob := encodeForPool(makeTx(nonce, 1, uint64(i)+1 /* unique hashes */, 1, repeater)) id, _ := store.Put(blob) if i == 0 { @@ -834,14 +841,14 @@ func TestOpenIndex(t *testing.T) { //blobfeeJumps = []float64{34.023, 35.570, 36.879, 29.686, 26.243, 20.358} // log 1.125 (blob fee cap) evictExecTipCaps = []uint64{10, 10, 5, 5, 1, 1} - evictExecFeeJumps = []float64{39.098, 38.204, 38.204, 19.549, 19.549, 19.549} // min(log 1.125 (exec fee cap)) - evictBlobFeeJumps = []float64{34.023, 34.023, 34.023, 29.686, 26.243, 20.358} // min(log 1.125 (blob fee cap)) + evictExecFeeJumps = []float64{39.098, 38.204, 38.204, 19.549, 19.549, 19.549} // min(log 1.125 (exec fee cap)) + evictBlobFeeJumps = []float64{25.517256, 25.517256, 25.517256, 22.264502, 19.682646, 15.268934} // min(log 1.17 (blob fee cap)) totalSpent = uint256.NewInt(21000*(100+90+200+10+80+300) + blobSize*(55+66+77+33+22+11) + 100*6) // 21000 gas x price + 128KB x blobprice + value ) for _, i := range []int{5, 3, 4, 2, 0, 1} { // Randomize the tx insertion order to force sorting on load tx := makeTx(uint64(i), txExecTipCaps[i], txExecFeeCaps[i], txBlobFeeCaps[i], key) - blob, _ := rlp.EncodeToBytes(tx) + blob := encodeForPool(tx) store.Put(blob) } store.Close() @@ -933,9 +940,9 @@ func TestOpenHeap(t *testing.T) { tx2 = makeTx(0, 1, 800, 70, key2) tx3 = makeTx(0, 1, 1500, 110, key3) - blob1, _ = rlp.EncodeToBytes(tx1) - blob2, _ = rlp.EncodeToBytes(tx2) - blob3, _ = rlp.EncodeToBytes(tx3) + blob1 = encodeForPool(tx1) + blob2 = encodeForPool(tx2) + blob3 = encodeForPool(tx3) heapOrder = []common.Address{addr2, addr1, addr3} heapIndex = map[common.Address]int{addr2: 0, addr1: 1, addr3: 2} @@ -1008,9 +1015,9 @@ func TestOpenCap(t *testing.T) { tx2 = makeTx(0, 1, 800, 70, key2) tx3 = makeTx(0, 1, 1500, 110, key3) - blob1, _ = rlp.EncodeToBytes(tx1) - blob2, _ = rlp.EncodeToBytes(tx2) - blob3, _ = rlp.EncodeToBytes(tx3) + blob1 = encodeForPool(tx1) + blob2 = encodeForPool(tx2) + blob3 = encodeForPool(tx3) keep = []common.Address{addr1, addr3} drop = []common.Address{addr2} @@ -1097,8 +1104,8 @@ func TestChangingSlotterSize(t *testing.T) { tx2 = makeMultiBlobTx(0, 1, 800, 70, 6, 0, key2, types.BlobSidecarVersion0) tx3 = makeMultiBlobTx(0, 1, 800, 110, 24, 0, key3, types.BlobSidecarVersion0) - blob1, _ = rlp.EncodeToBytes(tx1) - blob2, _ = rlp.EncodeToBytes(tx2) + blob1 = encodeForPool(tx1) + blob2 = encodeForPool(tx2) ) // Write the two safely sized txs to store. note: although the store is @@ -1200,8 +1207,8 @@ func TestBillyMigration(t *testing.T) { tx2 = makeMultiBlobTx(0, 1, 800, 70, 6, 0, key2, types.BlobSidecarVersion0) tx3 = makeMultiBlobTx(0, 1, 800, 110, 24, 0, key3, types.BlobSidecarVersion0) - blob1, _ = rlp.EncodeToBytes(tx1) - blob2, _ = rlp.EncodeToBytes(tx2) + blob1 = encodeForPool(tx1) + blob2 = encodeForPool(tx2) ) // Write the two safely sized txs to store. note: although the store is @@ -1280,6 +1287,85 @@ func TestBillyMigration(t *testing.T) { } } +// TestLegacyTxConversion verifies that on Init, transactions stored in the +// legacy *types.Transaction RLP format are detected and migrated into the new +// blobTxForPool storage format, and that they remain retrievable via the pool +// API after the conversion. +func TestLegacyTxConversion(t *testing.T) { + storage := t.TempDir() + os.MkdirAll(filepath.Join(storage, pendingTransactionStore), 0700) + os.MkdirAll(filepath.Join(storage, limboedTransactionStore), 0700) + + // Initialize the pending store with two blob transactions encoded in the + // legacy format. + queuedir := filepath.Join(storage, pendingTransactionStore) + store, err := billy.Open(billy.Options{Path: queuedir}, newSlotter(testMaxBlobsPerBlock), nil) + if err != nil { + t.Fatalf("failed to open billy: %v", err) + } + + key1, _ := crypto.GenerateKey() + key2, _ := crypto.GenerateKey() + addr1 := crypto.PubkeyToAddress(key1.PublicKey) + addr2 := crypto.PubkeyToAddress(key2.PublicKey) + + tx1 := makeMultiBlobTx(0, 1, 1000, 100, 2, 0, key1, types.BlobSidecarVersion0) + tx2 := makeMultiBlobTx(0, 1, 1000, 100, 2, 2, key2, types.BlobSidecarVersion0) + + for _, tx := range []*types.Transaction{tx1, tx2} { + legacy, err := rlp.EncodeToBytes(tx) + if err != nil { + t.Fatalf("failed to legacy-encode tx: %v", err) + } + if _, err := store.Put(legacy); err != nil { + t.Fatalf("failed to put legacy blob: %v", err) + } + } + store.Close() + + // Init should migrate the legacy entries into the new storage format. + statedb, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) + statedb.AddBalance(addr1, uint256.NewInt(1_000_000_000), tracing.BalanceChangeUnspecified) + statedb.AddBalance(addr2, uint256.NewInt(1_000_000_000), tracing.BalanceChangeUnspecified) + statedb.Commit(0, true, false) + + chain := &testBlockChain{ + config: params.MainnetChainConfig, + basefee: uint256.NewInt(params.InitialBaseFee), + blobfee: uint256.NewInt(params.BlobTxMinBlobGasprice), + statedb: statedb, + } + pool := New(Config{Datadir: storage}, chain, nil) + if err := pool.Init(1, chain.CurrentBlock(), newReserver()); err != nil { + t.Fatalf("failed to create blob pool: %v", err) + } + defer pool.Close() + + // Both transactions should be retrievable. + for _, want := range []*types.Transaction{tx1, tx2} { + got := pool.Get(want.Hash()) + if got == nil { + t.Fatalf("migrated tx %s not found in pool", want.Hash()) + } + if got.BlobTxSidecar() == nil { + t.Fatalf("migrated tx %s lost its sidecar", want.Hash()) + } + if got.Hash() != want.Hash() { + t.Fatalf("migrated tx hash mismatch: have %s, want %s", got.Hash(), want.Hash()) + } + } + + // Legacy formats should not exist on pool.store + pool.store.Iterate(func(id uint64, size uint32, blob []byte) { + var ptx blobTxForPool + if err := rlp.DecodeBytes(blob, &ptx); err != nil { + t.Errorf("entry %d not in new blobTxForPool format: %v", id, err) + } + }) + + verifyPoolInternals(t, pool) +} + // TestBlobCountLimit tests the blobpool enforced limits on the max blob count. func TestBlobCountLimit(t *testing.T) { var ( @@ -1329,7 +1415,7 @@ func TestBlobCountLimit(t *testing.T) { // Check that first succeeds second fails. if errs[0] != nil { - t.Fatalf("expected tx with 7 blobs to succeed") + t.Fatalf("expected tx with 7 blobs to succeed, got %v", errs[0]) } if !errors.Is(errs[1], txpool.ErrTxBlobLimitExceeded) { t.Fatalf("expected tx with 8 blobs to fail, got: %v", errs[1]) @@ -1356,9 +1442,10 @@ func TestAdd(t *testing.T) { } // addtx is a helper sender/tx tuple to represent a new tx addition type addtx struct { - from string - tx *types.BlobTx - err error + from string + tx *types.BlobTx + err error + check func(*BlobPool, *types.Transaction) bool } tests := []struct { @@ -1375,6 +1462,7 @@ func TestAdd(t *testing.T) { "bob": {balance: 21100 + blobSize, nonce: 1}, "claire": {balance: 21100 + blobSize}, "dave": {balance: 21100 + blobSize, nonce: 1}, + "eve": {balance: 21100 + blobSize, nonce: 10}, // High nonce to test gapped acceptance }, adds: []addtx{ { // New account, no previous txs: accept nonce 0 @@ -1402,6 +1490,14 @@ func TestAdd(t *testing.T) { tx: makeUnsignedTx(2, 1, 1, 1), err: core.ErrNonceTooHigh, }, + { // Old account, 10 txs in chain: 0 pending: accept nonce 11 as gapped + from: "eve", + tx: makeUnsignedTx(11, 1, 1, 1), + err: nil, + check: func(pool *BlobPool, tx *types.Transaction) bool { + return pool.Status(tx.Hash()) == txpool.TxStatusQueued + }, + }, }, }, // Transactions from already pooled accounts should only be accepted if @@ -1735,7 +1831,7 @@ func TestAdd(t *testing.T) { // Sign the seed transactions and store them in the data store for _, tx := range seed.txs { signed := types.MustSignNewTx(keys[acc], types.LatestSigner(params.MainnetChainConfig), tx) - blob, _ := rlp.EncodeToBytes(signed) + blob := encodeForPool(signed) store.Put(blob) } } @@ -1745,8 +1841,8 @@ func TestAdd(t *testing.T) { // Create a blob pool out of the pre-seeded dats chain := &testBlockChain{ config: params.MainnetChainConfig, - basefee: uint256.NewInt(1050), - blobfee: uint256.NewInt(105), + basefee: uint256.NewInt(1), + blobfee: uint256.NewInt(1), statedb: statedb, } pool := New(Config{Datadir: storage}, chain, nil) @@ -1762,15 +1858,28 @@ func TestAdd(t *testing.T) { t.Errorf("test %d, tx %d: adding transaction error mismatch: have %v, want %v", i, j, errs[0], add.err) } if add.err == nil { - size, exist := pool.lookup.sizeOfTx(signed.Hash()) - if !exist { - t.Errorf("test %d, tx %d: failed to lookup transaction's size", i, j) + // first check if tx is in the pool (reorder queue or pending) + if !pool.Has(signed.Hash()) { + t.Errorf("test %d, tx %d: added transaction not found in pool", i, j) } - if size != signed.Size() { - t.Errorf("test %d, tx %d: transaction's size mismatches: have %v, want %v", - i, j, size, signed.Size()) + // if it is pending, check if size matches + if pool.Status(signed.Hash()) == txpool.TxStatusPending { + size, exist := pool.lookup.sizeOfTx(signed.Hash()) + if !exist { + t.Errorf("test %d, tx %d: failed to lookup transaction's size", i, j) + } + if size != signed.Size() { + t.Errorf("test %d, tx %d: transaction's size mismatches: have %v, want %v", + i, j, size, signed.Size()) + } } } + if add.check != nil { + if !add.check(pool, signed) { + t.Errorf("test %d, tx %d: custom check failed", i, j) + } + } + // Verify the pool internals after each addition verifyPoolInternals(t, pool) } verifyPoolInternals(t, pool) @@ -1806,66 +1915,6 @@ func TestAdd(t *testing.T) { } } -// Tests that transactions with legacy sidecars are accepted within the -// conversion window but rejected after it has passed. -func TestAddLegacyBlobTx(t *testing.T) { - testAddLegacyBlobTx(t, true) // conversion window has not yet passed - testAddLegacyBlobTx(t, false) // conversion window passed -} - -func testAddLegacyBlobTx(t *testing.T, accept bool) { - var ( - key1, _ = crypto.GenerateKey() - key2, _ = crypto.GenerateKey() - - addr1 = crypto.PubkeyToAddress(key1.PublicKey) - addr2 = crypto.PubkeyToAddress(key2.PublicKey) - ) - - statedb, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) - statedb.AddBalance(addr1, uint256.NewInt(1_000_000_000), tracing.BalanceChangeUnspecified) - statedb.AddBalance(addr2, uint256.NewInt(1_000_000_000), tracing.BalanceChangeUnspecified) - statedb.Commit(0, true, false) - - chain := &testBlockChain{ - config: params.MergedTestChainConfig, - basefee: uint256.NewInt(1050), - blobfee: uint256.NewInt(105), - statedb: statedb, - } - var timeDiff uint64 - if accept { - timeDiff = uint64(conversionTimeWindow.Seconds()) - 1 - } else { - timeDiff = uint64(conversionTimeWindow.Seconds()) + 1 - } - time := *params.MergedTestChainConfig.OsakaTime + timeDiff - chain.setHeadTime(time) - - pool := New(Config{Datadir: t.TempDir()}, chain, nil) - if err := pool.Init(1, chain.CurrentBlock(), newReserver()); err != nil { - t.Fatalf("failed to create blob pool: %v", err) - } - - // Attempt to add legacy blob transactions. - var ( - tx1 = makeMultiBlobTx(0, 1, 1000, 100, 6, 0, key1, types.BlobSidecarVersion0) - tx2 = makeMultiBlobTx(0, 1, 800, 70, 6, 6, key2, types.BlobSidecarVersion0) - txs = []*types.Transaction{tx1, tx2} - ) - errs := pool.Add(txs, true) - for _, err := range errs { - if accept && err != nil { - t.Fatalf("expected tx add to succeed, %v", err) - } - if !accept && err == nil { - t.Fatal("expected tx add to fail") - } - } - verifyPoolInternals(t, pool) - pool.Close() -} - func TestGetBlobs(t *testing.T) { //log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelTrace, true))) @@ -1889,9 +1938,9 @@ func TestGetBlobs(t *testing.T) { tx2 = makeMultiBlobTx(0, 1, 800, 70, 6, 6, key2, types.BlobSidecarVersion1) // [6, 12) tx3 = makeMultiBlobTx(0, 1, 800, 110, 6, 12, key3, types.BlobSidecarVersion0) // [12, 18) - blob1, _ = rlp.EncodeToBytes(tx1) - blob2, _ = rlp.EncodeToBytes(tx2) - blob3, _ = rlp.EncodeToBytes(tx3) + blob1 = encodeForPool(tx1) + blob2 = encodeForPool(tx2) + blob3 = encodeForPool(tx3) ) // Write the two safely sized txs to store. note: although the store is @@ -1952,7 +2001,6 @@ func TestGetBlobs(t *testing.T) { limit int fillRandom bool // Whether to randomly fill some of the requested blobs with unknowns version byte // Blob sidecar version to request - convert bool // Whether to convert version on retrieval }{ { start: 0, limit: 6, @@ -2018,11 +2066,6 @@ func TestGetBlobs(t *testing.T) { start: 0, limit: 18, fillRandom: true, version: types.BlobSidecarVersion1, }, - { - start: 0, limit: 18, fillRandom: true, - version: types.BlobSidecarVersion1, - convert: true, // Convert some version 0 blobs to version 1 while retrieving - }, } for i, c := range cases { var ( @@ -2044,7 +2087,7 @@ func TestGetBlobs(t *testing.T) { filled[len(vhashes)] = struct{}{} vhashes = append(vhashes, testrand.Hash()) } - blobs, _, proofs, err := pool.GetBlobs(vhashes, c.version, c.convert) + blobs, _, proofs, err := pool.GetBlobs(vhashes, c.version) if err != nil { t.Errorf("Unexpected error for case %d, %v", i, err) } @@ -2070,8 +2113,7 @@ func TestGetBlobs(t *testing.T) { // If an item is missing, but shouldn't, error if blobs[j] == nil || proofs[j] == nil { // This is only an error if there was no version mismatch - if c.convert || - (c.version == types.BlobSidecarVersion1 && 6 <= testBlobIndex && testBlobIndex < 12) || + if (c.version == types.BlobSidecarVersion1 && 6 <= testBlobIndex && testBlobIndex < 12) || (c.version == types.BlobSidecarVersion0 && (testBlobIndex < 6 || 12 <= testBlobIndex)) { t.Errorf("tracked blob retrieval failed: item %d, hash %x", j, vhashes[j]) } @@ -2098,183 +2140,30 @@ func TestGetBlobs(t *testing.T) { pool.Close() } -// TestSidecarConversion will verify that after the Osaka fork, all legacy -// sidecars in the pool are successfully convert to v1 sidecars. -func TestSidecarConversion(t *testing.T) { - // log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelTrace, true))) - - // Create a temporary folder for the persistent backend - storage := t.TempDir() - os.MkdirAll(filepath.Join(storage, pendingTransactionStore), 0700) - - var ( - preOsakaTxs = make(types.Transactions, 10) - postOsakaTxs = make(types.Transactions, 3) - keys = make([]*ecdsa.PrivateKey, len(preOsakaTxs)+len(postOsakaTxs)) - addrs = make([]common.Address, len(preOsakaTxs)+len(postOsakaTxs)) - statedb, _ = state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) - ) - for i := range keys { - keys[i], _ = crypto.GenerateKey() - addrs[i] = crypto.PubkeyToAddress(keys[i].PublicKey) - statedb.AddBalance(addrs[i], uint256.NewInt(1_000_000_000), tracing.BalanceChangeUnspecified) - } - for i := range preOsakaTxs { - preOsakaTxs[i] = makeMultiBlobTx(0, 1, 1000, 100, 2, 0, keys[i], types.BlobSidecarVersion0) - } - for i := range postOsakaTxs { - if i == 0 { - // First has a v0 sidecar. - postOsakaTxs[i] = makeMultiBlobTx(0, 1, 1000, 100, 1, 0, keys[len(preOsakaTxs)+i], types.BlobSidecarVersion0) - } - postOsakaTxs[i] = makeMultiBlobTx(0, 1, 1000, 100, 1, 0, keys[len(preOsakaTxs)+i], types.BlobSidecarVersion1) - } - statedb.Commit(0, true, false) - - // Test plan: - // 1) Create a bunch v0 sidecar txs and add to pool before Osaka. - // 2) Pass in new Osaka header to activate the conversion thread. - // 3) Continue adding both v0 and v1 transactions to the pool. - // 4) Verify that as additional blocks come in, transactions involved in the - // migration are correctly discarded. - - config := ¶ms.ChainConfig{ - ChainID: big.NewInt(1), - LondonBlock: big.NewInt(0), - BerlinBlock: big.NewInt(0), - CancunTime: newUint64(0), - PragueTime: newUint64(0), - OsakaTime: newUint64(1), - BlobScheduleConfig: params.DefaultBlobSchedule, - } - chain := &testBlockChain{ - config: config, - basefee: uint256.NewInt(1050), - blobfee: uint256.NewInt(105), - statedb: statedb, - blocks: make(map[uint64]*types.Block), - } - - // Create 3 blocks: - // - the current block, before Osaka - // - the first block after Osaka - // - another post-Osaka block with several transactions in it - header0 := chain.CurrentBlock() - header0.Time = 0 - chain.blocks[0] = types.NewBlockWithHeader(header0) - - header1 := chain.CurrentBlock() - header1.Number = big.NewInt(1) - header1.Time = 1 - chain.blocks[1] = types.NewBlockWithHeader(header1) - - header2 := chain.CurrentBlock() - header2.Time = 2 - header2.Number = big.NewInt(2) - - // Make a copy of one of the pre-Osaka transactions and convert it to v1 here - // so that we can add it to the pool later and ensure a duplicate is not added - // by the conversion queue. - tx := preOsakaTxs[len(preOsakaTxs)-1] - sc := *tx.BlobTxSidecar() // copy sidecar - sc.ToV1() - tx.WithBlobTxSidecar(&sc) - - block2 := types.NewBlockWithHeader(header2).WithBody(types.Body{Transactions: append(postOsakaTxs, tx)}) - chain.blocks[2] = block2 - - pool := New(Config{Datadir: storage}, chain, nil) - if err := pool.Init(1, header0, newReserver()); err != nil { - t.Fatalf("failed to create blob pool: %v", err) - } - - errs := pool.Add(preOsakaTxs, true) - for i, err := range errs { - if err != nil { - t.Errorf("failed to insert blob tx from %s: %s", addrs[i], errs[i]) - } - } - - // Kick off migration. - pool.Reset(header0, header1) - - // Add the v0 sidecar tx, but don't block so we can keep doing other stuff - // while it converts the sidecar. - addDone := make(chan struct{}) - go func() { - pool.Add(types.Transactions{postOsakaTxs[0]}, false) - close(addDone) - }() - - // Add the post-Osaka v1 sidecar txs. - errs = pool.Add(postOsakaTxs[1:], false) - for _, err := range errs { - if err != nil { - t.Fatalf("expected tx add to succeed: %v", err) - } - } +// TestEncodeForNetwork verifies that encodeForNetwork produces output identical +// to rlp.EncodeToBytes on the original transaction, for both V0 and V1 sidecars. +func TestEncodeForNetwork(t *testing.T) { + t.Run("v0", func(t *testing.T) { testEncodeForNetwork(t, types.BlobSidecarVersion0) }) + t.Run("v1", func(t *testing.T) { testEncodeForNetwork(t, types.BlobSidecarVersion1) }) +} - // Wait for the first tx's conversion to complete, then check that all - // transactions added after Osaka can be accounted for in the pool. - <-addDone - pending := pool.Pending(txpool.PendingFilter{BlobTxs: true, BlobVersion: types.BlobSidecarVersion1}) - for _, tx := range postOsakaTxs { - from, _ := pool.signer.Sender(tx) - if len(pending[from]) != 1 || pending[from][0].Hash != tx.Hash() { - t.Fatalf("expected post-Osaka txs to be pending") - } - } +func testEncodeForNetwork(t *testing.T, version byte) { + key, _ := crypto.GenerateKey() + tx := makeMultiBlobTx(0, 1, 1, 1, 1, 0, key, version) - // Now update the pool with the next block. This should cause the pool to - // clear out the post-Osaka txs since they were included in block 2. Since the - // test blockchain doesn't manage nonces, we'll just do that manually before - // the reset is called. Don't forget about the pre-Osaka transaction we also - // added to block 2! - for i := range postOsakaTxs { - statedb.SetNonce(addrs[len(preOsakaTxs)+i], 1, tracing.NonceChangeEoACall) + wantRLP, err := rlp.EncodeToBytes(tx) + if err != nil { + t.Fatalf("failed to encode tx: %v", err) } - statedb.SetNonce(addrs[len(preOsakaTxs)-1], 1, tracing.NonceChangeEoACall) - pool.Reset(header1, block2.Header()) + storedRLP := encodeForPool(tx) - // Now verify no post-Osaka transactions are tracked by the pool. - for i, tx := range postOsakaTxs { - if pool.Get(tx.Hash()) != nil { - t.Fatalf("expected txs added post-osaka to have been placed in limbo due to inclusion in a block: index %d, hash %s", i, tx.Hash()) - } + gotRLP, err := encodeForNetwork(storedRLP) + if err != nil { + t.Fatalf("encodeForNetwork failed: %v", err) } - - // Wait for the pool migration to complete. - <-pool.cQueue.anyBillyConversionDone - - // Verify all transactions in the pool were converted and verify the - // subsequent cell proofs. - count, _ := pool.Stats() - if count != len(preOsakaTxs)-1 { - t.Errorf("expected pending count to match initial tx count: pending=%d, expected=%d", count, len(preOsakaTxs)-1) + if !bytes.Equal(gotRLP, wantRLP) { + t.Fatalf("network encoding mismatch (version %d): got %d bytes, want %d bytes", version, len(gotRLP), len(wantRLP)) } - for addr, acc := range pool.index { - for _, m := range acc { - if m.version != types.BlobSidecarVersion1 { - t.Errorf("expected sidecar to have been converted: from %s, hash %s", addr, m.hash) - } - tx := pool.Get(m.hash) - if tx == nil { - t.Errorf("failed to get tx by hash: %s", m.hash) - } - sc := tx.BlobTxSidecar() - if err := kzg4844.VerifyCellProofs(sc.Blobs, sc.Commitments, sc.Proofs); err != nil { - t.Errorf("failed to verify cell proofs for tx %s after conversion: %s", m.hash, err) - } - } - } - - verifyPoolInternals(t, pool) - - // Launch conversion a second time. - // This is just a sanity check to ensure we can handle it. - pool.Reset(header0, header1) - - pool.Close() } // fakeBilly is a billy.Database implementation which just drops data on the floor. @@ -2349,7 +2238,7 @@ func benchmarkPoolPending(b *testing.B, datacap uint64) { b.ReportAllocs() for i := 0; i < b.N; i++ { - p := pool.Pending(txpool.PendingFilter{ + p, _ := pool.Pending(txpool.PendingFilter{ MinTip: uint256.NewInt(1), BaseFee: chain.basefee, BlobFee: chain.blobfee, @@ -2360,5 +2249,3 @@ func benchmarkPoolPending(b *testing.B, datacap uint64) { } } } - -func newUint64(val uint64) *uint64 { return &val } diff --git a/core/txpool/blobpool/conversion.go b/core/txpool/blobpool/conversion.go deleted file mode 100644 index afdc10554f66..000000000000 --- a/core/txpool/blobpool/conversion.go +++ /dev/null @@ -1,218 +0,0 @@ -// Copyright 2025 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package blobpool - -import ( - "errors" - "slices" - "sync/atomic" - "time" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/log" -) - -// maxPendingConversionTasks caps the number of pending conversion tasks. This -// prevents excessive memory usage; the worst-case scenario (2k transactions -// with 6 blobs each) would consume approximately 1.5GB of memory. -const maxPendingConversionTasks = 2048 - -// txConvert represents a conversion task with an attached legacy blob transaction. -type txConvert struct { - tx *types.Transaction // Legacy blob transaction - done chan error // Channel for signaling back if the conversion succeeds -} - -// conversionQueue is a dedicated queue for converting legacy blob transactions -// received from the network after the Osaka fork. Since conversion is expensive, -// it is performed in the background by a single thread, ensuring the main Geth -// process is not overloaded. -type conversionQueue struct { - tasks chan *txConvert - startBilly chan func() - quit chan struct{} - closed chan struct{} - - billyQueue []func() - billyTaskDone chan struct{} - - // This channel will be closed when the first billy conversion finishes. - // It's added for unit tests to synchronize with the conversion progress. - anyBillyConversionDone chan struct{} -} - -// newConversionQueue constructs the conversion queue. -func newConversionQueue() *conversionQueue { - q := &conversionQueue{ - tasks: make(chan *txConvert), - startBilly: make(chan func()), - quit: make(chan struct{}), - closed: make(chan struct{}), - anyBillyConversionDone: make(chan struct{}), - } - go q.loop() - return q -} - -// convert accepts a legacy blob transaction with version-0 blobs and queues it -// for conversion. -// -// This function may block for a long time until the transaction is processed. -func (q *conversionQueue) convert(tx *types.Transaction) error { - done := make(chan error, 1) - select { - case q.tasks <- &txConvert{tx: tx, done: done}: - return <-done - case <-q.closed: - return errors.New("conversion queue closed") - } -} - -// launchBillyConversion starts a conversion task in the background. -func (q *conversionQueue) launchBillyConversion(fn func()) error { - select { - case q.startBilly <- fn: - return nil - case <-q.closed: - return errors.New("conversion queue closed") - } -} - -// close terminates the conversion queue. -func (q *conversionQueue) close() { - select { - case <-q.closed: - return - default: - close(q.quit) - <-q.closed - } -} - -// run converts a batch of legacy blob txs to the new cell proof format. -func (q *conversionQueue) run(tasks []*txConvert, done chan struct{}, interrupt *atomic.Int32) { - defer close(done) - - for _, t := range tasks { - if interrupt != nil && interrupt.Load() != 0 { - t.done <- errors.New("conversion is interrupted") - continue - } - sidecar := t.tx.BlobTxSidecar() - if sidecar == nil { - t.done <- errors.New("tx without sidecar") - continue - } - // Run the conversion, the original sidecar will be mutated in place - start := time.Now() - err := sidecar.ToV1() - t.done <- err - log.Trace("Converted legacy blob tx", "hash", t.tx.Hash(), "err", err, "elapsed", common.PrettyDuration(time.Since(start))) - } -} - -func (q *conversionQueue) loop() { - defer close(q.closed) - - var ( - done chan struct{} // Non-nil if background routine is active - interrupt *atomic.Int32 // Flag to signal conversion interruption - - // The pending tasks for sidecar conversion. We assume the number of legacy - // blob transactions requiring conversion will not be excessive. However, - // a hard cap is applied as a protective measure. - txTasks []*txConvert - - firstBilly = true - ) - - for { - select { - case t := <-q.tasks: - if len(txTasks) >= maxPendingConversionTasks { - t.done <- errors.New("conversion queue is overloaded") - continue - } - txTasks = append(txTasks, t) - - // Launch the background conversion thread if it's idle - if done == nil { - done, interrupt = make(chan struct{}), new(atomic.Int32) - - tasks := slices.Clone(txTasks) - txTasks = txTasks[:0] - go q.run(tasks, done, interrupt) - } - - case <-done: - done, interrupt = nil, nil - if len(txTasks) > 0 { - done, interrupt = make(chan struct{}), new(atomic.Int32) - tasks := slices.Clone(txTasks) - txTasks = txTasks[:0] - go q.run(tasks, done, interrupt) - } - - case fn := <-q.startBilly: - q.billyQueue = append(q.billyQueue, fn) - q.runNextBillyTask() - - case <-q.billyTaskDone: - if firstBilly { - close(q.anyBillyConversionDone) - firstBilly = false - } - q.runNextBillyTask() - - case <-q.quit: - if done != nil { - log.Debug("Waiting for blob proof conversion to exit") - interrupt.Store(1) - <-done - } - if q.billyTaskDone != nil { - log.Debug("Waiting for blobpool billy conversion to exit") - <-q.billyTaskDone - } - // Signal any tasks that were queued for the next batch but never started - // so callers blocked in convert() receive an error instead of hanging. - for _, t := range txTasks { - // Best-effort notify; t.done is a buffered channel of size 1 - // created by convert(), and we send exactly once per task. - t.done <- errors.New("conversion queue closed") - } - // Drop references to allow GC of the backing array. - txTasks = txTasks[:0] - return - } - } -} - -func (q *conversionQueue) runNextBillyTask() { - if len(q.billyQueue) == 0 { - q.billyTaskDone = nil - return - } - - fn := q.billyQueue[0] - q.billyQueue = append(q.billyQueue[:0], q.billyQueue[1:]...) - - done := make(chan struct{}) - go func() { defer close(done); fn() }() - q.billyTaskDone = done -} diff --git a/core/txpool/blobpool/conversion_test.go b/core/txpool/blobpool/conversion_test.go deleted file mode 100644 index 7ffffb2e4d36..000000000000 --- a/core/txpool/blobpool/conversion_test.go +++ /dev/null @@ -1,171 +0,0 @@ -// Copyright 2025 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package blobpool - -import ( - "crypto/ecdsa" - "crypto/sha256" - "sync" - "testing" - "time" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/crypto/kzg4844" - "github.com/ethereum/go-ethereum/params" - "github.com/holiman/uint256" -) - -// createV1BlobTx creates a blob transaction with version 1 sidecar for testing. -func createV1BlobTx(nonce uint64, key *ecdsa.PrivateKey) *types.Transaction { - blob := &kzg4844.Blob{byte(nonce)} - commitment, _ := kzg4844.BlobToCommitment(blob) - cellProofs, _ := kzg4844.ComputeCellProofs(blob) - - blobtx := &types.BlobTx{ - ChainID: uint256.MustFromBig(params.MainnetChainConfig.ChainID), - Nonce: nonce, - GasTipCap: uint256.NewInt(1), - GasFeeCap: uint256.NewInt(1000), - Gas: 21000, - BlobFeeCap: uint256.NewInt(100), - BlobHashes: []common.Hash{kzg4844.CalcBlobHashV1(sha256.New(), &commitment)}, - Value: uint256.NewInt(100), - Sidecar: types.NewBlobTxSidecar(types.BlobSidecarVersion1, []kzg4844.Blob{*blob}, []kzg4844.Commitment{commitment}, cellProofs), - } - return types.MustSignNewTx(key, types.LatestSigner(params.MainnetChainConfig), blobtx) -} - -func TestConversionQueueBasic(t *testing.T) { - queue := newConversionQueue() - defer queue.close() - - key, _ := crypto.GenerateKey() - tx := makeTx(0, 1, 1, 1, key) - if err := queue.convert(tx); err != nil { - t.Fatalf("Expected successful conversion, got error: %v", err) - } - if tx.BlobTxSidecar().Version != types.BlobSidecarVersion1 { - t.Errorf("Expected sidecar version to be %d, got %d", types.BlobSidecarVersion1, tx.BlobTxSidecar().Version) - } -} - -func TestConversionQueueV1BlobTx(t *testing.T) { - queue := newConversionQueue() - defer queue.close() - - key, _ := crypto.GenerateKey() - tx := createV1BlobTx(0, key) - version := tx.BlobTxSidecar().Version - - err := queue.convert(tx) - if err != nil { - t.Fatalf("Expected successful conversion, got error: %v", err) - } - if tx.BlobTxSidecar().Version != version { - t.Errorf("Expected sidecar version to remain %d, got %d", version, tx.BlobTxSidecar().Version) - } -} - -func TestConversionQueueClosed(t *testing.T) { - queue := newConversionQueue() - - // Close the queue first - queue.close() - key, _ := crypto.GenerateKey() - tx := makeTx(0, 1, 1, 1, key) - - err := queue.convert(tx) - if err == nil { - t.Fatal("Expected error when converting on closed queue, got nil") - } -} - -func TestConversionQueueDoubleClose(t *testing.T) { - queue := newConversionQueue() - queue.close() - queue.close() // Should not panic -} - -func TestConversionQueueAutoRestartBatch(t *testing.T) { - queue := newConversionQueue() - defer queue.close() - - key, _ := crypto.GenerateKey() - - // Create a heavy transaction to ensure the first batch runs long enough - // for subsequent tasks to be queued while it is active. - heavy := makeMultiBlobTx(0, 1, 1, 1, int(params.BlobTxMaxBlobs), 0, key, types.BlobSidecarVersion0) - - var wg sync.WaitGroup - wg.Add(1) - heavyDone := make(chan error, 1) - go func() { - defer wg.Done() - heavyDone <- queue.convert(heavy) - }() - - // Give the conversion worker a head start so that the following tasks are - // enqueued while the first batch is running. - time.Sleep(200 * time.Millisecond) - - tx1 := makeTx(1, 1, 1, 1, key) - tx2 := makeTx(2, 1, 1, 1, key) - - wg.Add(2) - done1 := make(chan error, 1) - done2 := make(chan error, 1) - go func() { defer wg.Done(); done1 <- queue.convert(tx1) }() - go func() { defer wg.Done(); done2 <- queue.convert(tx2) }() - - select { - case err := <-done1: - if err != nil { - t.Fatalf("tx1 conversion error: %v", err) - } - case <-time.After(30 * time.Second): - t.Fatal("timeout waiting for tx1 conversion") - } - - select { - case err := <-done2: - if err != nil { - t.Fatalf("tx2 conversion error: %v", err) - } - case <-time.After(30 * time.Second): - t.Fatal("timeout waiting for tx2 conversion") - } - - select { - case err := <-heavyDone: - if err != nil { - t.Fatalf("heavy conversion error: %v", err) - } - case <-time.After(30 * time.Second): - t.Fatal("timeout waiting for heavy conversion") - } - - wg.Wait() - - if tx1.BlobTxSidecar().Version != types.BlobSidecarVersion1 { - t.Fatalf("tx1 sidecar version mismatch: have %d, want %d", tx1.BlobTxSidecar().Version, types.BlobSidecarVersion1) - } - if tx2.BlobTxSidecar().Version != types.BlobSidecarVersion1 { - t.Fatalf("tx2 sidecar version mismatch: have %d, want %d", tx2.BlobTxSidecar().Version, types.BlobSidecarVersion1) - } -} diff --git a/core/txpool/blobpool/evictheap.go b/core/txpool/blobpool/evictheap.go index 722a71bc9b44..a46b8e9a6f58 100644 --- a/core/txpool/blobpool/evictheap.go +++ b/core/txpool/blobpool/evictheap.go @@ -67,7 +67,7 @@ func newPriceHeap(basefee *uint256.Int, blobfee *uint256.Int, index map[common.A func (h *evictHeap) reinit(basefee *uint256.Int, blobfee *uint256.Int, force bool) { // If the update is mostly the same as the old, don't sort pointlessly basefeeJumps := dynamicFeeJumps(basefee) - blobfeeJumps := dynamicFeeJumps(blobfee) + blobfeeJumps := dynamicBlobFeeJumps(blobfee) if !force && math.Abs(h.basefeeJumps-basefeeJumps) < 0.01 && math.Abs(h.blobfeeJumps-blobfeeJumps) < 0.01 { // TODO(karalabe): 0.01 enough, maybe should be smaller? Maybe this optimization is moot? return @@ -95,13 +95,7 @@ func (h *evictHeap) Less(i, j int) bool { lastJ := txsJ[len(txsJ)-1] prioI := evictionPriority(h.basefeeJumps, lastI.evictionExecFeeJumps, h.blobfeeJumps, lastI.evictionBlobFeeJumps) - if prioI > 0 { - prioI = 0 - } prioJ := evictionPriority(h.basefeeJumps, lastJ.evictionExecFeeJumps, h.blobfeeJumps, lastJ.evictionBlobFeeJumps) - if prioJ > 0 { - prioJ = 0 - } if prioI == prioJ { return lastI.evictionExecTip.Lt(lastJ.evictionExecTip) } diff --git a/core/txpool/blobpool/evictheap_test.go b/core/txpool/blobpool/evictheap_test.go index de4076e29858..112fa77a0177 100644 --- a/core/txpool/blobpool/evictheap_test.go +++ b/core/txpool/blobpool/evictheap_test.go @@ -109,22 +109,22 @@ func TestPriceHeapSorting(t *testing.T) { order: []int{3, 2, 1, 0, 4, 5, 6}, }, // If both basefee and blobfee is specified, sort by the larger distance - // of the two from the current network conditions, splitting same (loglog) + // of the two from the current network conditions, splitting same // ones via the tip. // - // Basefee: 1000 - // Blobfee: 100 + // Basefee: 1000 , jumps: 888, 790, 702, 624 + // Blobfee: 100 , jumps: 85, 73, 62, 53 // - // Tx #0: (800, 80) - 2 jumps below both => priority -1 - // Tx #1: (630, 63) - 4 jumps below both => priority -2 - // Tx #2: (800, 63) - 2 jumps below basefee, 4 jumps below blobfee => priority -2 (blob penalty dominates) - // Tx #3: (630, 80) - 4 jumps below basefee, 2 jumps below blobfee => priority -2 (base penalty dominates) + // Tx #0: (800, 80) - 2 jumps below both => priority -2 + // Tx #1: (630, 55) - 4 jumps below both => priority -4 + // Tx #2: (800, 55) - 2 jumps below basefee, 4 jumps below blobfee => priority -4 (blob penalty dominates) + // Tx #3: (630, 80) - 4 jumps below basefee, 2 jumps below blobfee => priority -4 (base penalty dominates) // // Txs 1, 2, 3 share the same priority, split via tip, prefer 0 as the best { execTips: []uint64{1, 2, 3, 4}, execFees: []uint64{800, 630, 800, 630}, - blobFees: []uint64{80, 63, 63, 80}, + blobFees: []uint64{80, 55, 55, 80}, basefee: 1000, blobfee: 100, order: []int{1, 2, 3, 0}, @@ -142,7 +142,7 @@ func TestPriceHeapSorting(t *testing.T) { blobFee = uint256.NewInt(tt.blobFees[j]) basefeeJumps = dynamicFeeJumps(execFee) - blobfeeJumps = dynamicFeeJumps(blobFee) + blobfeeJumps = dynamicBlobFeeJumps(blobFee) ) index[addr] = []*blobTxMeta{{ id: uint64(j), @@ -201,7 +201,7 @@ func benchmarkPriceHeapReinit(b *testing.B, datacap uint64) { blobFee = uint256.NewInt(rnd.Uint64()) basefeeJumps = dynamicFeeJumps(execFee) - blobfeeJumps = dynamicFeeJumps(blobFee) + blobfeeJumps = dynamicBlobFeeJumps(blobFee) ) index[addr] = []*blobTxMeta{{ id: uint64(i), @@ -277,7 +277,7 @@ func benchmarkPriceHeapOverflow(b *testing.B, datacap uint64) { blobFee = uint256.NewInt(rnd.Uint64()) basefeeJumps = dynamicFeeJumps(execFee) - blobfeeJumps = dynamicFeeJumps(blobFee) + blobfeeJumps = dynamicBlobFeeJumps(blobFee) ) index[addr] = []*blobTxMeta{{ id: uint64(i), @@ -308,7 +308,7 @@ func benchmarkPriceHeapOverflow(b *testing.B, datacap uint64) { blobFee = uint256.NewInt(rnd.Uint64()) basefeeJumps = dynamicFeeJumps(execFee) - blobfeeJumps = dynamicFeeJumps(blobFee) + blobfeeJumps = dynamicBlobFeeJumps(blobFee) ) metas[i] = &blobTxMeta{ id: uint64(int(blobs) + i), diff --git a/core/txpool/blobpool/interface.go b/core/txpool/blobpool/interface.go index 6f296a54bd63..d7beae9b25f0 100644 --- a/core/txpool/blobpool/interface.go +++ b/core/txpool/blobpool/interface.go @@ -32,6 +32,9 @@ type BlockChain interface { // CurrentBlock returns the current head of the chain. CurrentBlock() *types.Header + // Genesis returns the genesis block of the chain. + Genesis() *types.Block + // CurrentFinalBlock returns the current block below which blobs should not // be maintained anymore for reorg purposes. CurrentFinalBlock() *types.Header @@ -39,6 +42,6 @@ type BlockChain interface { // GetBlock retrieves a specific block, used during pool resets. GetBlock(hash common.Hash, number uint64) *types.Block - // StateAt returns a state database for a given root hash (generally the head). - StateAt(root common.Hash) (*state.StateDB, error) + // StateAt returns a state database for a given chain header (generally the head). + StateAt(header *types.Header) (*state.StateDB, error) } diff --git a/core/txpool/blobpool/limbo.go b/core/txpool/blobpool/limbo.go index 50c40c9d838d..b8bee2f22afb 100644 --- a/core/txpool/blobpool/limbo.go +++ b/core/txpool/blobpool/limbo.go @@ -20,7 +20,6 @@ import ( "errors" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/consensus/misc/eip4844" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -34,7 +33,7 @@ import ( type limboBlob struct { TxHash common.Hash // Owner transaction's hash to support resurrecting reorged txs Block uint64 // Block in which the blob transaction was included - Tx *types.Transaction + Ptx *blobTxForPool } // limbo is a light, indexed database to temporarily store recently included @@ -57,7 +56,7 @@ func newLimbo(config *params.ChainConfig, datadir string) (*limbo, error) { } // Create new slotter for pre-Osaka blob configuration. - slotter := newSlotter(eip4844.LatestMaxBlobsPerBlock(config)) + slotter := newSlotter(params.BlobTxMaxBlobs) // See if we need to migrate the limbo after fusaka. slotter, err := tryMigrate(config, slotter, datadir) @@ -147,15 +146,14 @@ func (l *limbo) finalize(final *types.Header) { // push stores a new blob transaction into the limbo, waiting until finality for // it to be automatically evicted. -func (l *limbo) push(tx *types.Transaction, block uint64) error { - // If the blobs are already tracked by the limbo, consider it a programming - // error. There's not much to do against it, but be loud. - if _, ok := l.index[tx.Hash()]; ok { - log.Error("Limbo cannot push already tracked blobs", "tx", tx.Hash()) +func (l *limbo) push(ptx *blobTxForPool, block uint64) error { + hash := ptx.Tx.Hash() + if _, ok := l.index[hash]; ok { + log.Error("Limbo cannot push already tracked blobs", "tx", hash) return errors.New("already tracked blob transaction") } - if err := l.setAndIndex(tx, block); err != nil { - log.Error("Failed to set and index limboed blobs", "tx", tx.Hash(), "err", err) + if err := l.setAndIndex(ptx, block); err != nil { + log.Error("Failed to set and index limboed blobs", "tx", hash, "err", err) return err } return nil @@ -164,7 +162,7 @@ func (l *limbo) push(tx *types.Transaction, block uint64) error { // pull retrieves a previously pushed set of blobs back from the limbo, removing // it at the same time. This method should be used when a previously included blob // transaction gets reorged out. -func (l *limbo) pull(tx common.Hash) (*types.Transaction, error) { +func (l *limbo) pull(tx common.Hash) (*blobTxForPool, error) { // If the blobs are not tracked by the limbo, there's not much to do. This // can happen for example if a blob transaction is mined without pushing it // into the network first. @@ -178,7 +176,7 @@ func (l *limbo) pull(tx common.Hash) (*types.Transaction, error) { log.Error("Failed to get and drop limboed blobs", "tx", tx, "id", id, "err", err) return nil, err } - return item.Tx, nil + return item.Ptx, nil } // update changes the block number under which a blob transaction is tracked. This @@ -210,7 +208,7 @@ func (l *limbo) update(txhash common.Hash, block uint64) { log.Error("Failed to get and drop limboed blobs", "tx", txhash, "id", id, "err", err) return } - if err := l.setAndIndex(item.Tx, block); err != nil { + if err := l.setAndIndex(item.Ptx, block); err != nil { log.Error("Failed to set and index limboed blobs", "tx", txhash, "err", err) return } @@ -241,12 +239,12 @@ func (l *limbo) getAndDrop(id uint64) (*limboBlob, error) { // setAndIndex assembles a limbo blob database entry and stores it, also updating // the in-memory indices. -func (l *limbo) setAndIndex(tx *types.Transaction, block uint64) error { - txhash := tx.Hash() +func (l *limbo) setAndIndex(ptx *blobTxForPool, block uint64) error { + txhash := ptx.Tx.Hash() item := &limboBlob{ TxHash: txhash, Block: block, - Tx: tx, + Ptx: ptx, } data, err := rlp.EncodeToBytes(item) if err != nil { diff --git a/core/txpool/blobpool/lookup.go b/core/txpool/blobpool/lookup.go index 874ca85b8c2d..7607cd487a2b 100644 --- a/core/txpool/blobpool/lookup.go +++ b/core/txpool/blobpool/lookup.go @@ -110,13 +110,3 @@ func (l *lookup) untrack(tx *blobTxMeta) { } } } - -// update updates the transaction index. It should only be used in the conversion. -func (l *lookup) update(hash common.Hash, id uint64, size uint64) bool { - meta, exists := l.txIndex[hash] - if !exists { - return false - } - meta.id, meta.size = id, size - return true -} diff --git a/core/txpool/blobpool/metrics.go b/core/txpool/blobpool/metrics.go index 52419ade0978..44e2098b2204 100644 --- a/core/txpool/blobpool/metrics.go +++ b/core/txpool/blobpool/metrics.go @@ -97,9 +97,15 @@ var ( addUnderpricedMeter = metrics.NewRegisteredMeter("blobpool/add/underpriced", nil) // Gas tip too low, neutral addStaleMeter = metrics.NewRegisteredMeter("blobpool/add/stale", nil) // Nonce already filled, reject, bad-ish addGappedMeter = metrics.NewRegisteredMeter("blobpool/add/gapped", nil) // Nonce gapped, reject, bad-ish + addGappedFullMeter = metrics.NewRegisteredMeter("blobpool/add/gappedfull", nil) // Gapped queue full, reject, neutral addOverdraftedMeter = metrics.NewRegisteredMeter("blobpool/add/overdrafted", nil) // Balance exceeded, reject, neutral addOvercappedMeter = metrics.NewRegisteredMeter("blobpool/add/overcapped", nil) // Per-account cap exceeded, reject, neutral addNoreplaceMeter = metrics.NewRegisteredMeter("blobpool/add/noreplace", nil) // Replacement fees or tips too low, neutral addNonExclusiveMeter = metrics.NewRegisteredMeter("blobpool/add/nonexclusive", nil) // Plain transaction from same account exists, reject, neutral addValidMeter = metrics.NewRegisteredMeter("blobpool/add/valid", nil) // Valid transaction, add, neutral + + // Gapped queue metrics for observability + gappedGauge = metrics.NewRegisteredGauge("blobpool/gapped/count", nil) // Current gapped queue size + gappedPromotedMeter = metrics.NewRegisteredMeter("blobpool/gapped/promoted", nil) // Gapped txs successfully promoted to pool + gappedEvictedMeter = metrics.NewRegisteredMeter("blobpool/gapped/evicted", nil) // Gapped txs evicted due to timeout/stale ) diff --git a/core/txpool/blobpool/priority.go b/core/txpool/blobpool/priority.go index 7ae7f92def12..d7e8789ce730 100644 --- a/core/txpool/blobpool/priority.go +++ b/core/txpool/blobpool/priority.go @@ -18,7 +18,6 @@ package blobpool import ( "math" - "math/bits" "github.com/holiman/uint256" ) @@ -26,6 +25,13 @@ import ( // log1_125 is used in the eviction priority calculation. var log1_125 = math.Log(1.125) +// log1_17 is used in the eviction priority calculation for blob fees. +// EIP-7892 (BPO) changed the ratio of target to max blobs, and with that +// also the maximum blob fee decrease in a slot from 1.125 to approx 1.17 . +// Since we want priorities to approximate time, we should change our log +// calculation for blob fees. +var log1_17 = log1_125 * 4 / 3 + // evictionPriority calculates the eviction priority based on the algorithm // described in the BlobPool docs for both fee components. // @@ -36,23 +42,20 @@ func evictionPriority(basefeeJumps float64, txBasefeeJumps, blobfeeJumps, txBlob basefeePriority = evictionPriority1D(basefeeJumps, txBasefeeJumps) blobfeePriority = evictionPriority1D(blobfeeJumps, txBlobfeeJumps) ) - if basefeePriority < blobfeePriority { - return basefeePriority - } - return blobfeePriority + return min(0, basefeePriority, blobfeePriority) } // evictionPriority1D calculates the eviction priority based on the algorithm // described in the BlobPool docs for a single fee component. func evictionPriority1D(basefeeJumps float64, txfeeJumps float64) int { jumps := txfeeJumps - basefeeJumps - if int(jumps) == 0 { - return 0 // can't log2 0 + if jumps <= 0 { + return int(math.Floor(jumps)) } - if jumps < 0 { - return -intLog2(uint(-math.Floor(jumps))) - } - return intLog2(uint(math.Ceil(jumps))) + // We only use the negative part for ordering. The positive part is only used + // for threshold comparison (with a negative threshold), so the value is almost + // irrelevant, as long as it's positive. + return int((math.Ceil(jumps))) } // dynamicFeeJumps calculates the log1.125(fee), namely the number of fee jumps @@ -70,21 +73,9 @@ func dynamicFeeJumps(fee *uint256.Int) float64 { return math.Log(fee.Float64()) / log1_125 } -// intLog2 is a helper to calculate the integral part of a log2 of an unsigned -// integer. It is a very specific calculation that's not particularly useful in -// general, but it's what we need here (it's fast). -func intLog2(n uint) int { - switch { - case n == 0: - panic("log2(0) is undefined") - - case n < 2048: - return bits.UintSize - bits.LeadingZeros(n) - 1 - - default: - // The input is log1.125(uint256) = log2(uint256) / log2(1.125). At the - // most extreme, log2(uint256) will be a bit below 257, and the constant - // log2(1.125) ~= 0.17. The larges input thus is ~257 / ~0.17 ~= ~1511. - panic("dynamic fee jump diffs cannot reach this") +func dynamicBlobFeeJumps(fee *uint256.Int) float64 { + if fee.IsZero() { + return 0 // can't log2 zero, should never happen outside tests, but don't choke } + return math.Log(fee.Float64()) / log1_17 } diff --git a/core/txpool/blobpool/priority_test.go b/core/txpool/blobpool/priority_test.go index 1eaee6d7df98..47b3a5375f00 100644 --- a/core/txpool/blobpool/priority_test.go +++ b/core/txpool/blobpool/priority_test.go @@ -30,12 +30,12 @@ func TestPriorityCalculation(t *testing.T) { txfee uint64 result int }{ - {basefee: 7, txfee: 10, result: 2}, // 3.02 jumps, 4 ceil, 2 log2 - {basefee: 17_200_000_000, txfee: 17_200_000_000, result: 0}, // 0 jumps, special case 0 log2 - {basefee: 9_853_941_692, txfee: 11_085_092_510, result: 0}, // 0.99 jumps, 1 ceil, 0 log2 - {basefee: 11_544_106_391, txfee: 10_356_781_100, result: 0}, // -0.92 jumps, -1 floor, 0 log2 - {basefee: 17_200_000_000, txfee: 7, result: -7}, // -183.57 jumps, -184 floor, -7 log2 - {basefee: 7, txfee: 17_200_000_000, result: 7}, // 183.57 jumps, 184 ceil, 7 log2 + {basefee: 7, txfee: 10, result: 4}, // 3.02 jumps, 4 ceil + {basefee: 17_200_000_000, txfee: 17_200_000_000, result: 0}, // 0 jumps, special case 0 + {basefee: 9_853_941_692, txfee: 11_085_092_510, result: 1}, // 0.99 jumps, 1 ceil + {basefee: 11_544_106_391, txfee: 10_356_781_100, result: -1}, // -0.92 jumps, -1 floor + {basefee: 17_200_000_000, txfee: 7, result: -184}, // -183.57 jumps, -184 floor + {basefee: 7, txfee: 17_200_000_000, result: 184}, // 183.57 jumps, 184 ceil } for i, tt := range tests { var ( @@ -69,7 +69,7 @@ func BenchmarkPriorityCalculation(b *testing.B) { blobfee := uint256.NewInt(123_456_789_000) // Completely random, no idea what this will be basefeeJumps := dynamicFeeJumps(basefee) - blobfeeJumps := dynamicFeeJumps(blobfee) + blobfeeJumps := dynamicBlobFeeJumps(blobfee) // The transaction's fee cap and blob fee cap are constant across the life // of the transaction, so we can pre-calculate and cache them. @@ -77,7 +77,7 @@ func BenchmarkPriorityCalculation(b *testing.B) { txBlobfeeJumps := make([]float64, b.N) for i := 0; i < b.N; i++ { txBasefeeJumps[i] = dynamicFeeJumps(uint256.NewInt(rnd.Uint64())) - txBlobfeeJumps[i] = dynamicFeeJumps(uint256.NewInt(rnd.Uint64())) + txBlobfeeJumps[i] = dynamicBlobFeeJumps(uint256.NewInt(rnd.Uint64())) } b.ResetTimer() b.ReportAllocs() diff --git a/core/txpool/blobpool/slotter.go b/core/txpool/blobpool/slotter.go index 9b793e366c6c..3399361e55d5 100644 --- a/core/txpool/blobpool/slotter.go +++ b/core/txpool/blobpool/slotter.go @@ -17,7 +17,6 @@ package blobpool import ( - "github.com/ethereum/go-ethereum/consensus/misc/eip4844" "github.com/ethereum/go-ethereum/params" "github.com/holiman/billy" ) @@ -42,7 +41,7 @@ func tryMigrate(config *params.ChainConfig, slotter billy.SlotSizeFn, datadir st // If the version found is less than the currently configured store version, // perform a migration then write the updated version of the store. if version < storeVersion { - newSlotter := newSlotterEIP7594(eip4844.LatestMaxBlobsPerBlock(config)) + newSlotter := newSlotterEIP7594(params.BlobTxMaxBlobs) if err := billy.Migrate(billy.Options{Path: datadir, Repair: true}, slotter, newSlotter); err != nil { return nil, err } @@ -54,7 +53,7 @@ func tryMigrate(config *params.ChainConfig, slotter billy.SlotSizeFn, datadir st store.Close() } // Set the slotter to the format now that the Osaka is active. - slotter = newSlotterEIP7594(eip4844.LatestMaxBlobsPerBlock(config)) + slotter = newSlotterEIP7594(params.BlobTxMaxBlobs) } return slotter, nil } diff --git a/core/txpool/errors.go b/core/txpool/errors.go index 9bc435d67ee7..8285cbf10ede 100644 --- a/core/txpool/errors.go +++ b/core/txpool/errors.go @@ -71,4 +71,7 @@ var ( // ErrInflightTxLimitReached is returned when the maximum number of in-flight // transactions is reached for specific accounts. ErrInflightTxLimitReached = errors.New("in-flight transaction limit reached for delegated accounts") + + // ErrKZGVerificationError is returned when a KZG proof was not verified correctly. + ErrKZGVerificationError = errors.New("KZG verification error") ) diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index ceedc74a531e..3d66803fd720 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -114,6 +114,9 @@ var ( queuedGauge = metrics.NewRegisteredGauge("txpool/queued", nil) slotsGauge = metrics.NewRegisteredGauge("txpool/slots", nil) + pendingAddrsGauge = metrics.NewRegisteredGauge("txpool/pending/accounts", nil) + queuedAddrsGauge = metrics.NewRegisteredGauge("txpool/queued/accounts", nil) + reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil) ) @@ -126,11 +129,14 @@ type BlockChain interface { // CurrentBlock returns the current head of the chain. CurrentBlock() *types.Header + // Genesis returns the genesis block of the chain. + Genesis() *types.Block + // GetBlock retrieves a specific block, used during pool resets. GetBlock(hash common.Hash, number uint64) *types.Block - // StateAt returns a state database for a given root hash (generally the head). - StateAt(root common.Hash) (*state.StateDB, error) + // StateAt returns a state database for a given chain header (generally the head). + StateAt(header *types.Header) (*state.StateDB, error) } // Config are the configuration parameters of the transaction pool. @@ -148,7 +154,7 @@ type Config struct { AccountQueue uint64 // Maximum number of non-executable transaction slots permitted per account GlobalQueue uint64 // Maximum number of non-executable transaction slots for all accounts - Lifetime time.Duration // Maximum amount of time non-executable transaction are queued + Lifetime time.Duration // Maximum amount of time an account can remain stale in the non-executable pool } // DefaultConfig contains the default configurations for the transaction pool. @@ -288,7 +294,12 @@ func New(config Config, chain BlockChain) *LegacyPool { // Filter returns whether the given transaction can be consumed by the legacy // pool, specifically, whether it is a Legacy, AccessList or Dynamic transaction. func (pool *LegacyPool) Filter(tx *types.Transaction) bool { - switch tx.Type() { + return pool.FilterType(tx.Type()) +} + +// FilterType returns whether the legacy pool supports the given transaction type. +func (pool *LegacyPool) FilterType(kind byte) bool { + switch kind { case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType, types.SetCodeTxType: return true default: @@ -309,9 +320,9 @@ func (pool *LegacyPool) Init(gasTip uint64, head *types.Header, reserver txpool. // Initialize the state with head block, or fallback to empty one in // case the head state is not available (might occur when node is not // fully synced). - statedb, err := pool.chain.StateAt(head.Root) + statedb, err := pool.chain.StateAt(head) if err != nil { - statedb, err = pool.chain.StateAt(types.EmptyRootHash) + statedb, err = pool.chain.StateAt(pool.chain.Genesis().Header()) } if err != nil { return err @@ -456,8 +467,8 @@ func (pool *LegacyPool) stats() (int, int) { // Content retrieves the data content of the transaction pool, returning all the // pending as well as queued transactions, grouped by account and sorted by nonce. func (pool *LegacyPool) Content() (map[common.Address][]*types.Transaction, map[common.Address][]*types.Transaction) { - pool.mu.Lock() - defer pool.mu.Unlock() + pool.mu.RLock() + defer pool.mu.RUnlock() pending := make(map[common.Address][]*types.Transaction, len(pool.pending)) for addr, list := range pool.pending { @@ -486,15 +497,16 @@ func (pool *LegacyPool) ContentFrom(addr common.Address) ([]*types.Transaction, // // The transactions can also be pre-filtered by the dynamic fee components to // reduce allocations and load on downstream subsystems. -func (pool *LegacyPool) Pending(filter txpool.PendingFilter) map[common.Address][]*txpool.LazyTransaction { +func (pool *LegacyPool) Pending(filter txpool.PendingFilter) (map[common.Address][]*txpool.LazyTransaction, int) { // If only blob transactions are requested, this pool is unsuitable as it // contains none, don't even bother. if filter.BlobTxs { - return nil + return nil, 0 } - pool.mu.Lock() - defer pool.mu.Unlock() + pool.mu.RLock() + defer pool.mu.RUnlock() + var count int pending := make(map[common.Address][]*txpool.LazyTransaction, len(pool.pending)) for addr, list := range pool.pending { txs := list.Flatten() @@ -531,9 +543,10 @@ func (pool *LegacyPool) Pending(filter txpool.PendingFilter) map[common.Address] } } pending[addr] = lazies + count += len(lazies) } } - return pending + return pending, count } // ValidateTxBasics checks whether a transaction is valid according to the consensus @@ -770,7 +783,7 @@ func (pool *LegacyPool) add(tx *types.Transaction) (replaced bool, err error) { pool.queueTxEvent(tx) log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To()) - // Successful promotion, bump the heartbeat + // Successful replacement. If needed, bump the heartbeat giving more time to queued txs. pool.queue.bump(from) return old != nil, nil } @@ -839,6 +852,7 @@ func (pool *LegacyPool) promoteTx(addr common.Address, hash common.Hash, tx *typ // Try to insert the transaction into the pending queue if pool.pending[addr] == nil { pool.pending[addr] = newList(true) + pendingAddrsGauge.Inc(1) } list := pool.pending[addr] @@ -862,7 +876,7 @@ func (pool *LegacyPool) promoteTx(addr common.Address, hash common.Hash, tx *typ // Set the potentially new pending nonce and notify any subsystems of the new tx pool.pendingNonces.set(addr, tx.Nonce()+1) - // Successful promotion, bump the heartbeat + // Successful promotion, bump the heartbeat, giving more time to queued txs. pool.queue.bump(addr) return true } @@ -899,8 +913,8 @@ func (pool *LegacyPool) addRemoteSync(tx *types.Transaction) error { func (pool *LegacyPool) Add(txs []*types.Transaction, sync bool) []error { // Filter out known ones without obtaining the pool lock or recovering signatures var ( - errs = make([]error, len(txs)) - news = make([]*types.Transaction, 0, len(txs)) + hasValid bool + errs = make([]error, len(txs)) ) for i, tx := range txs { // If the transaction is known, pre-set the error slot @@ -918,26 +932,17 @@ func (pool *LegacyPool) Add(txs []*types.Transaction, sync bool) []error { invalidTxMeter.Mark(1) continue } - // Accumulate all unknown transactions for deeper processing - news = append(news, tx) + hasValid = true } - if len(news) == 0 { + if !hasValid { return errs } // Process all the new transaction and merge any errors into the original slice pool.mu.Lock() - newErrs, dirtyAddrs := pool.addTxsLocked(news) + dirtyAddrs := pool.addTxsLocked(txs, errs) pool.mu.Unlock() - var nilSlot = 0 - for _, err := range newErrs { - for errs[nilSlot] != nil { - nilSlot++ - } - errs[nilSlot] = err - nilSlot++ - } // Reorg the pool internals if needed and return done := pool.requestPromoteExecutables(dirtyAddrs) if sync { @@ -948,14 +953,19 @@ func (pool *LegacyPool) Add(txs []*types.Transaction, sync bool) []error { // addTxsLocked attempts to queue a batch of transactions if they are valid. // The transaction pool lock must be held. -// Returns the error for each tx, and the set of accounts that might became promotable. -func (pool *LegacyPool) addTxsLocked(txs []*types.Transaction) ([]error, *accountSet) { +// Sets the error for each tx, and the set of accounts that might became promotable. +// We only try to add txs that have no error set in the errs slice. +// If adding the transaction returns an error, we set the error in the errs slice. +// Requires len(txs) == len(errs). +func (pool *LegacyPool) addTxsLocked(txs []*types.Transaction, errs []error) *accountSet { var ( dirty = newAccountSet(pool.signer) - errs = make([]error, len(txs)) valid int64 ) for i, tx := range txs { + if errs[i] != nil { + continue + } replaced, err := pool.add(tx) errs[i] = err if err == nil { @@ -966,7 +976,7 @@ func (pool *LegacyPool) addTxsLocked(txs []*types.Transaction) ([]error, *accoun } } validTxMeter.Mark(valid) - return errs, dirty + return dirty } // Status returns the status (unknown/pending/queued) of a batch of transactions @@ -991,11 +1001,7 @@ func (pool *LegacyPool) Status(hash common.Hash) txpool.TxStatus { // Get returns a transaction if it is contained in the pool and nil otherwise. func (pool *LegacyPool) Get(hash common.Hash) *types.Transaction { - tx := pool.get(hash) - if tx == nil { - return nil - } - return tx + return pool.get(hash) } // get returns a transaction if it is contained in the pool and nil otherwise. @@ -1078,6 +1084,7 @@ func (pool *LegacyPool) removeTx(hash common.Hash, outofbound bool, unreserve bo // If no more pending transactions are left, remove the list if pending.Empty() { delete(pool.pending, addr) + pendingAddrsGauge.Dec(1) } // Postpone any invalidated transactions for _, tx := range invalids { @@ -1215,8 +1222,10 @@ func (pool *LegacyPool) runReorg(done chan struct{}, reset *txpoolResetRequest, pool.mu.Lock() if reset != nil { if reset.newHead != nil && reset.oldHead != nil { - // Discard the transactions with the gas limit higher than the cap. - if pool.chainconfig.IsOsaka(reset.newHead.Number, reset.newHead.Time) && !pool.chainconfig.IsOsaka(reset.oldHead.Number, reset.oldHead.Time) { + // Discard the transactions with the gas limit higher than the cap at the + // Osaka fork boundary. + if pool.chainconfig.IsOsaka(reset.newHead.Number, reset.newHead.Time) && + !pool.chainconfig.IsOsaka(reset.oldHead.Number, reset.oldHead.Time) { var hashes []common.Hash pool.all.Range(func(hash common.Hash, tx *types.Transaction) bool { if tx.Gas() > params.MaxTxGas { @@ -1375,7 +1384,7 @@ func (pool *LegacyPool) reset(oldHead, newHead *types.Header) { if newHead == nil { newHead = pool.chain.CurrentBlock() // Special case during testing } - statedb, err := pool.chain.StateAt(newHead.Root) + statedb, err := pool.chain.StateAt(newHead) if err != nil { log.Error("Failed to reset txpool state", "err", err) return @@ -1387,7 +1396,7 @@ func (pool *LegacyPool) reset(oldHead, newHead *types.Header) { // Inject any transactions discarded due to reorgs log.Debug("Reinjecting stale transactions", "count", len(reinject)) core.SenderCacher().Recover(pool.signer, reinject) - pool.addTxsLocked(reinject) + pool.addTxsLocked(reinject, make([]error, len(reinject))) } // promoteExecutables moves transactions that have become processable from the @@ -1400,7 +1409,7 @@ func (pool *LegacyPool) promoteExecutables(accounts []common.Address) []*types.T // promote all promotable transactions promoted := make([]*types.Transaction, 0, len(promotable)) for _, tx := range promotable { - from, _ := pool.signer.Sender(tx) + from, _ := types.Sender(pool.signer, tx) // already validated if pool.promoteTx(from, tx.Hash(), tx) { promoted = append(promoted, tx) } @@ -1558,6 +1567,7 @@ func (pool *LegacyPool) demoteUnexecutables() { // Internal shuffle shouldn't touch the lookup set. pool.enqueueTx(hash, tx, false) } + pool.priced.Removed(len(olds) + len(drops)) pendingGauge.Dec(int64(len(olds) + len(drops) + len(invalids))) // If there's a gap in front, alert (should never happen) and postpone all transactions @@ -1575,6 +1585,7 @@ func (pool *LegacyPool) demoteUnexecutables() { // Delete the entire pending entry if it became empty. if list.Empty() { delete(pool.pending, addr) + pendingAddrsGauge.Dec(1) if _, ok := pool.queue.get(addr); !ok { pool.reserver.Release(addr) } @@ -1834,6 +1845,13 @@ func (pool *LegacyPool) Clear() { pool.pending = make(map[common.Address]*list) pool.queue = newQueue(pool.config, pool.signer) pool.pendingNonces = newNoncer(pool.currentState) + + // Reset gauges + pendingGauge.Update(0) + queuedGauge.Update(0) + slotsGauge.Update(0) + pendingAddrsGauge.Update(0) + queuedAddrsGauge.Update(0) } // HasPendingAuth returns a flag indicating whether there are pending diff --git a/core/txpool/legacypool/legacypool_test.go b/core/txpool/legacypool/legacypool_test.go index fb994d82086d..f8592ba001e7 100644 --- a/core/txpool/legacypool/legacypool_test.go +++ b/core/txpool/legacypool/legacypool_test.go @@ -91,10 +91,14 @@ func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block return types.NewBlock(bc.CurrentBlock(), nil, nil, trie.NewStackTrie(nil)) } -func (bc *testBlockChain) StateAt(common.Hash) (*state.StateDB, error) { +func (bc *testBlockChain) StateAt(header *types.Header) (*state.StateDB, error) { return bc.statedb, nil } +func (bc *testBlockChain) Genesis() *types.Block { + return types.NewBlock(bc.CurrentBlock(), nil, nil, trie.NewStackTrie(nil)) +} + func (bc *testBlockChain) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription { return bc.chainHeadFeed.Subscribe(ch) } diff --git a/core/txpool/legacypool/list_test.go b/core/txpool/legacypool/list_test.go index 8587c66f7d22..dc03def26c8f 100644 --- a/core/txpool/legacypool/list_test.go +++ b/core/txpool/legacypool/list_test.go @@ -68,6 +68,43 @@ func TestListAddVeryExpensive(t *testing.T) { } } +// TestPriceHeapCmp tests that the price heap comparison function works as intended. +// It also tests combinations where the basefee is higher than the gas fee cap, which +// are useful to sort in the mempool to support basefee changes. +func TestPriceHeapCmp(t *testing.T) { + key, _ := crypto.GenerateKey() + txs := []*types.Transaction{ + // nonce, gaslimit, gasfee, gastip + dynamicFeeTx(0, 1000, big.NewInt(2), big.NewInt(1), key), + dynamicFeeTx(0, 1000, big.NewInt(1), big.NewInt(2), key), + dynamicFeeTx(0, 1000, big.NewInt(1), big.NewInt(1), key), + dynamicFeeTx(0, 1000, big.NewInt(1), big.NewInt(0), key), + } + + // create priceHeap + ph := &priceHeap{} + + // now set the basefee on the heap + for _, basefee := range []uint64{0, 1, 2, 3} { + ph.baseFee = uint256.NewInt(basefee) + + for i := 0; i < len(txs); i++ { + for j := 0; j < len(txs); j++ { + switch { + case i == j: + if c := ph.cmp(txs[i], txs[j]); c != 0 { + t.Errorf("tx %d should be equal priority to tx %d with basefee %d (cmp=%d)", i, j, basefee, c) + } + case i < j: + if c := ph.cmp(txs[i], txs[j]); c != 1 { + t.Errorf("tx %d vs tx %d comparison inconsistent with basefee %d (cmp=%d)", i, j, basefee, c) + } + } + } + } + } +} + func BenchmarkListAdd(b *testing.B) { // Generate a list of transactions to insert key, _ := crypto.GenerateKey() diff --git a/core/txpool/legacypool/queue.go b/core/txpool/legacypool/queue.go index a889debe3705..35beaded12c0 100644 --- a/core/txpool/legacypool/queue.go +++ b/core/txpool/legacypool/queue.go @@ -88,8 +88,12 @@ func (q *queue) get(addr common.Address) (*list, bool) { return l, ok } +// bump updates the heartbeat for the given account address. +// If the address is unknown, the call is a no-op. func (q *queue) bump(addr common.Address) { - q.beats[addr] = time.Now() + if _, ok := q.beats[addr]; ok { + q.beats[addr] = time.Now() + } } func (q *queue) addresses() []common.Address { @@ -114,6 +118,7 @@ func (q *queue) remove(addr common.Address, tx *types.Transaction) { if future.Empty() { delete(q.queued, addr) delete(q.beats, addr) + queuedAddrsGauge.Dec(1) } } } @@ -123,6 +128,7 @@ func (q *queue) add(tx *types.Transaction) (*common.Hash, error) { from, _ := types.Sender(q.signer, tx) // already validated if q.queued[from] == nil { q.queued[from] = newList(false) + queuedAddrsGauge.Inc(1) } inserted, old := q.queued[from].Add(tx, q.config.PriceBump) if !inserted { @@ -200,6 +206,7 @@ func (q *queue) promoteExecutables(accounts []common.Address, gasLimit uint64, c if list.Empty() { delete(q.queued, addr) delete(q.beats, addr) + queuedAddrsGauge.Dec(1) removedAddresses = append(removedAddresses, addr) } } diff --git a/core/txpool/locals/tx_tracker.go b/core/txpool/locals/tx_tracker.go index bb178f175e5d..66f324810594 100644 --- a/core/txpool/locals/tx_tracker.go +++ b/core/txpool/locals/tx_tracker.go @@ -18,6 +18,7 @@ package locals import ( + "cmp" "slices" "sync" "time" @@ -151,7 +152,7 @@ func (tracker *TxTracker) recheck(journalCheck bool) []*types.Transaction { for _, list := range rejournal { // cmp(a, b) should return a negative number when a < b, slices.SortFunc(list, func(a, b *types.Transaction) int { - return int(a.Nonce() - b.Nonce()) + return cmp.Compare(a.Nonce(), b.Nonce()) }) } // Rejournal the tracker while holding the lock. No new transactions will diff --git a/core/txpool/locals/tx_tracker_test.go b/core/txpool/locals/tx_tracker_test.go index dde875460589..34fb4d0b74bc 100644 --- a/core/txpool/locals/tx_tracker_test.go +++ b/core/txpool/locals/tx_tracker_test.go @@ -102,7 +102,7 @@ func (env *testEnv) setGasTip(gasTip uint64) { func (env *testEnv) makeTx(nonce uint64, gasPrice *big.Int) *types.Transaction { if nonce == 0 { head := env.chain.CurrentHeader() - state, _ := env.chain.StateAt(head.Root) + state, _ := env.chain.StateAt(head) nonce = state.GetNonce(address) } if gasPrice == nil { @@ -114,7 +114,7 @@ func (env *testEnv) makeTx(nonce uint64, gasPrice *big.Int) *types.Transaction { func (env *testEnv) makeTxs(n int) []*types.Transaction { head := env.chain.CurrentHeader() - state, _ := env.chain.StateAt(head.Root) + state, _ := env.chain.StateAt(head) nonce := state.GetNonce(address) var txs []*types.Transaction diff --git a/core/txpool/subpool.go b/core/txpool/subpool.go index 519ae7b989f5..4cc1b193d65f 100644 --- a/core/txpool/subpool.go +++ b/core/txpool/subpool.go @@ -100,6 +100,9 @@ type SubPool interface { // to this particular subpool. Filter(tx *types.Transaction) bool + // FilterType returns whether the subpool supports the given transaction type. + FilterType(kind byte) bool + // Init sets the base parameters of the subpool, allowing it to load any saved // transactions from disk and also permitting internal maintenance routines to // start up. @@ -151,7 +154,7 @@ type SubPool interface { // // The transactions can also be pre-filtered by the dynamic fee components to // reduce allocations and load on downstream subsystems. - Pending(filter PendingFilter) map[common.Address][]*LazyTransaction + Pending(filter PendingFilter) (map[common.Address][]*LazyTransaction, int) // SubscribeTransactions subscribes to new transaction events. The subscriber // can decide whether to receive notifications only for newly seen transactions diff --git a/core/txpool/txpool.go b/core/txpool/txpool.go index 437861efca7c..9c787484228d 100644 --- a/core/txpool/txpool.go +++ b/core/txpool/txpool.go @@ -50,11 +50,14 @@ type BlockChain interface { // CurrentBlock returns the current head of the chain. CurrentBlock() *types.Header + // Genesis returns the genesis block of the chain. + Genesis() *types.Block + // SubscribeChainHeadEvent subscribes to new blocks being added to the chain. SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription - // StateAt returns a state database for a given root hash (generally the head). - StateAt(root common.Hash) (*state.StateDB, error) + // StateAt returns a state database for a given chain header (generally the head). + StateAt(header *types.Header) (*state.StateDB, error) } // TxPool is an aggregator for various transaction specific pools, collectively @@ -87,9 +90,9 @@ func New(gasTip uint64, chain BlockChain, subpools []SubPool) (*TxPool, error) { // Initialize the state with head block, or fallback to empty one in // case the head state is not available (might occur when node is not // fully synced). - statedb, err := chain.StateAt(head.Root) + statedb, err := chain.StateAt(head) if err != nil { - statedb, err = chain.StateAt(types.EmptyRootHash) + statedb, err = chain.StateAt(chain.Genesis().Header()) } if err != nil { return nil, err @@ -185,7 +188,7 @@ func (p *TxPool) loop(head *types.Header) { case resetBusy <- struct{}{}: // Updates the statedb with the new chain head. The head state may be // unavailable if the initial state sync has not yet completed. - if statedb, err := p.chain.StateAt(newHead.Root); err != nil { + if statedb, err := p.chain.StateAt(newHead); err != nil { log.Error("Failed to reset txpool state", "err", err) } else { p.stateLock.Lock() @@ -359,14 +362,17 @@ func (p *TxPool) Add(txs []*types.Transaction, sync bool) []error { // // The transactions can also be pre-filtered by the dynamic fee components to // reduce allocations and load on downstream subsystems. -func (p *TxPool) Pending(filter PendingFilter) map[common.Address][]*LazyTransaction { +func (p *TxPool) Pending(filter PendingFilter) (map[common.Address][]*LazyTransaction, int) { + var count int txs := make(map[common.Address][]*LazyTransaction) for _, subpool := range p.subpools { - for addr, set := range subpool.Pending(filter) { - txs[addr] = set + set, n := subpool.Pending(filter) + for addr, list := range set { + txs[addr] = list } + count += n } - return txs + return txs, count } // SubscribeTransactions registers a subscription for new transaction events, @@ -489,3 +495,14 @@ func (p *TxPool) Clear() { subpool.Clear() } } + +// FilterType returns whether a transaction with the given type is supported +// (can be added) by the pool. +func (p *TxPool) FilterType(kind byte) bool { + for _, subpool := range p.subpools { + if subpool.FilterType(kind) { + return true + } + } + return false +} diff --git a/core/txpool/validation.go b/core/txpool/validation.go index 4b54eac50db8..c87bba31ac48 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto/kzg4844" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -86,10 +87,12 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types return fmt.Errorf("%w: type %d rejected, pool not yet in Prague", core.ErrTxTypeNotSupported, tx.Type()) } // Check whether the init code size has been exceeded - if rules.IsShanghai && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize { - return fmt.Errorf("%w: code size %v, limit %v", core.ErrMaxInitCodeSizeExceeded, len(tx.Data()), params.MaxInitCodeSize) + if tx.To() == nil { + if err := vm.CheckMaxInitCodeSize(&rules, uint64(len(tx.Data()))); err != nil { + return err + } } - if rules.IsOsaka && tx.Gas() > params.MaxTxGas { + if rules.IsOsaka && !rules.IsAmsterdam && tx.Gas() > params.MaxTxGas { return fmt.Errorf("%w (cap: %d, tx: %d)", core.ErrGasLimitTooHigh, params.MaxTxGas, tx.Gas()) } // Transactions can't be negative. This may never happen using RLP decoded @@ -122,16 +125,16 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types } // Ensure the transaction has more gas than the bare minimum needed to cover // the transaction metadata - intrGas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.SetCodeAuthorizations(), tx.To() == nil, true, rules.IsIstanbul, rules.IsShanghai) + intrGas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.SetCodeAuthorizations(), tx.To() == nil, true, rules.IsIstanbul, rules.IsShanghai, rules.IsAmsterdam) if err != nil { return err } - if tx.Gas() < intrGas { - return fmt.Errorf("%w: gas %v, minimum needed %v", core.ErrIntrinsicGas, tx.Gas(), intrGas) + if tx.Gas() < intrGas.RegularGas { + return fmt.Errorf("%w: gas %v, minimum needed %v", core.ErrIntrinsicGas, tx.Gas(), intrGas.RegularGas) } // Ensure the transaction can cover floor data gas. - if opts.Config.IsPrague(head.Number, head.Time) { - floorDataGas, err := core.FloorDataGas(tx.Data()) + if rules.IsPrague { + floorDataGas, err := core.FloorDataGas(rules, tx.Data(), tx.AccessList()) if err != nil { return err } @@ -160,6 +163,15 @@ func validateBlobTx(tx *types.Transaction, head *types.Header, opts *ValidationO if sidecar == nil { return errors.New("missing sidecar in blob transaction") } + // Ensure the sidecar is constructed with the correct version, consistent + // with the current fork. + version := types.BlobSidecarVersion0 + if opts.Config.IsOsaka(head.Number, head.Time) { + version = types.BlobSidecarVersion1 + } + if sidecar.Version != version { + return fmt.Errorf("unexpected sidecar version, want: %d, got: %d", version, sidecar.Version) + } // Ensure the blob fee cap satisfies the minimum blob gas price if tx.BlobGasFeeCapIntCmp(blobTxMinBlobGasPrice) < 0 { return fmt.Errorf("%w: blob fee cap %v, minimum needed %v", ErrTxGasPriceTooLow, tx.BlobGasFeeCap(), blobTxMinBlobGasPrice) @@ -193,7 +205,7 @@ func validateBlobSidecarLegacy(sidecar *types.BlobTxSidecar, hashes []common.Has } for i := range sidecar.Blobs { if err := kzg4844.VerifyBlobProof(&sidecar.Blobs[i], sidecar.Commitments[i], sidecar.Proofs[i]); err != nil { - return fmt.Errorf("invalid blob %d: %v", i, err) + return fmt.Errorf("%w: invalid blob proof: %v", ErrKZGVerificationError, err) } } return nil @@ -203,7 +215,10 @@ func validateBlobSidecarOsaka(sidecar *types.BlobTxSidecar, hashes []common.Hash if len(sidecar.Proofs) != len(hashes)*kzg4844.CellProofsPerBlob { return fmt.Errorf("invalid number of %d blob proofs expected %d", len(sidecar.Proofs), len(hashes)*kzg4844.CellProofsPerBlob) } - return kzg4844.VerifyCellProofs(sidecar.Blobs, sidecar.Commitments, sidecar.Proofs) + if err := kzg4844.VerifyCellProofs(sidecar.Blobs, sidecar.Commitments, sidecar.Proofs); err != nil { + return fmt.Errorf("%w: %v", ErrKZGVerificationError, err) + } + return nil } // ValidationOptionsWithState define certain differences between stateful transaction diff --git a/core/types.go b/core/types.go index bed20802ab51..87bbfcff5815 100644 --- a/core/types.go +++ b/core/types.go @@ -17,6 +17,7 @@ package core import ( + "context" "sync/atomic" "github.com/ethereum/go-ethereum/core/state" @@ -48,7 +49,7 @@ type Processor interface { // Process processes the state changes according to the Ethereum rules by running // the transaction messages using the statedb and applying any rewards to both // the processor (coinbase) and any included uncles. - Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (*ProcessResult, error) + Process(ctx context.Context, block *types.Block, statedb *state.StateDB, cfg vm.Config) (*ProcessResult, error) } // ProcessResult contains the values computed by Process. diff --git a/core/types/bal/bal.go b/core/types/bal/bal.go index fca54f7681f4..9cbc1faeb9fd 100644 --- a/core/types/bal/bal.go +++ b/core/types/bal/bal.go @@ -24,21 +24,14 @@ import ( "github.com/holiman/uint256" ) -// CodeChange contains the runtime bytecode deployed at an address and the -// transaction index where the deployment took place. -type CodeChange struct { - TxIndex uint16 - Code []byte `json:"code,omitempty"` -} - // ConstructionAccountAccess contains post-block account state for mutations as well as -// all storage keys that were read during execution. It is used when building block +// all storage keys that were read during execution. It is used when building block // access list during execution. type ConstructionAccountAccess struct { // StorageWrites is the post-state values of an account's storage slots // that were modified in a block, keyed by the slot key and the tx index // where the modification occurred. - StorageWrites map[common.Hash]map[uint16]common.Hash `json:"storageWrites,omitempty"` + StorageWrites map[common.Hash]map[uint32]common.Hash `json:"storageWrites,omitempty"` // StorageReads is the set of slot keys that were accessed during block // execution. @@ -49,24 +42,25 @@ type ConstructionAccountAccess struct { // BalanceChanges contains the post-transaction balances of an account, // keyed by transaction indices where it was changed. - BalanceChanges map[uint16]*uint256.Int `json:"balanceChanges,omitempty"` + BalanceChanges map[uint32]*uint256.Int `json:"balanceChanges,omitempty"` // NonceChanges contains the post-state nonce values of an account keyed // by tx index. - NonceChanges map[uint16]uint64 `json:"nonceChanges,omitempty"` + NonceChanges map[uint32]uint64 `json:"nonceChanges,omitempty"` - // CodeChange is only set for contract accounts which were deployed in - // the block. - CodeChange *CodeChange `json:"codeChange,omitempty"` + // CodeChange contains the post-state contract code of an account keyed + // by tx index. + CodeChange map[uint32][]byte `json:"codeChange,omitempty"` } // NewConstructionAccountAccess initializes the account access object. func NewConstructionAccountAccess() *ConstructionAccountAccess { return &ConstructionAccountAccess{ - StorageWrites: make(map[common.Hash]map[uint16]common.Hash), + StorageWrites: make(map[common.Hash]map[uint32]common.Hash), StorageReads: make(map[common.Hash]struct{}), - BalanceChanges: make(map[uint16]*uint256.Int), - NonceChanges: make(map[uint16]uint64), + BalanceChanges: make(map[uint32]*uint256.Int), + NonceChanges: make(map[uint32]uint64), + CodeChange: make(map[uint32][]byte), } } @@ -77,8 +71,8 @@ type ConstructionBlockAccessList struct { } // NewConstructionBlockAccessList instantiates an empty access list. -func NewConstructionBlockAccessList() ConstructionBlockAccessList { - return ConstructionBlockAccessList{ +func NewConstructionBlockAccessList() *ConstructionBlockAccessList { + return &ConstructionBlockAccessList{ Accounts: make(map[common.Address]*ConstructionAccountAccess), } } @@ -103,12 +97,12 @@ func (b *ConstructionBlockAccessList) StorageRead(address common.Address, key co // StorageWrite records the post-transaction value of a mutated storage slot. // The storage slot is removed from the list of read slots. -func (b *ConstructionBlockAccessList) StorageWrite(txIdx uint16, address common.Address, key, value common.Hash) { +func (b *ConstructionBlockAccessList) StorageWrite(txIdx uint32, address common.Address, key, value common.Hash) { if _, ok := b.Accounts[address]; !ok { b.Accounts[address] = NewConstructionAccountAccess() } if _, ok := b.Accounts[address].StorageWrites[key]; !ok { - b.Accounts[address].StorageWrites[key] = make(map[uint16]common.Hash) + b.Accounts[address].StorageWrites[key] = make(map[uint32]common.Hash) } b.Accounts[address].StorageWrites[key][txIdx] = value @@ -116,19 +110,17 @@ func (b *ConstructionBlockAccessList) StorageWrite(txIdx uint16, address common. } // CodeChange records the code of a newly-created contract. -func (b *ConstructionBlockAccessList) CodeChange(address common.Address, txIndex uint16, code []byte) { +func (b *ConstructionBlockAccessList) CodeChange(address common.Address, txIndex uint32, code []byte) { if _, ok := b.Accounts[address]; !ok { b.Accounts[address] = NewConstructionAccountAccess() } - b.Accounts[address].CodeChange = &CodeChange{ - TxIndex: txIndex, - Code: bytes.Clone(code), - } + // TODO(rjl493456442) is it essential to deep-copy the code? + b.Accounts[address].CodeChange[txIndex] = bytes.Clone(code) } // NonceChange records tx post-state nonce of any contract-like accounts whose // nonce was incremented. -func (b *ConstructionBlockAccessList) NonceChange(address common.Address, txIdx uint16, postNonce uint64) { +func (b *ConstructionBlockAccessList) NonceChange(address common.Address, txIdx uint32, postNonce uint64) { if _, ok := b.Accounts[address]; !ok { b.Accounts[address] = NewConstructionAccountAccess() } @@ -137,7 +129,7 @@ func (b *ConstructionBlockAccessList) NonceChange(address common.Address, txIdx // BalanceChange records the post-transaction balance of an account whose // balance changed. -func (b *ConstructionBlockAccessList) BalanceChange(txIdx uint16, address common.Address, balance *uint256.Int) { +func (b *ConstructionBlockAccessList) BalanceChange(txIdx uint32, address common.Address, balance *uint256.Int) { if _, ok := b.Accounts[address]; !ok { b.Accounts[address] = NewConstructionAccountAccess() } @@ -156,27 +148,26 @@ func (b *ConstructionBlockAccessList) Copy() *ConstructionBlockAccessList { for addr, aa := range b.Accounts { var aaCopy ConstructionAccountAccess - slotWrites := make(map[common.Hash]map[uint16]common.Hash, len(aa.StorageWrites)) + slotWrites := make(map[common.Hash]map[uint32]common.Hash, len(aa.StorageWrites)) for key, m := range aa.StorageWrites { slotWrites[key] = maps.Clone(m) } aaCopy.StorageWrites = slotWrites aaCopy.StorageReads = maps.Clone(aa.StorageReads) - balances := make(map[uint16]*uint256.Int, len(aa.BalanceChanges)) + balances := make(map[uint32]*uint256.Int, len(aa.BalanceChanges)) for index, balance := range aa.BalanceChanges { balances[index] = balance.Clone() } aaCopy.BalanceChanges = balances aaCopy.NonceChanges = maps.Clone(aa.NonceChanges) - if aa.CodeChange != nil { - aaCopy.CodeChange = &CodeChange{ - TxIndex: aa.CodeChange.TxIndex, - Code: bytes.Clone(aa.CodeChange.Code), - } + codes := make(map[uint32][]byte, len(aa.CodeChange)) + for index, code := range aa.CodeChange { + codes[index] = bytes.Clone(code) } + aaCopy.CodeChange = codes res.Accounts[addr] = &aaCopy } - return &res + return res } diff --git a/core/types/bal/bal_encoding.go b/core/types/bal/bal_encoding.go index 24dfafa0831f..03f97f38095d 100644 --- a/core/types/bal/bal_encoding.go +++ b/core/types/bal/bal_encoding.go @@ -33,27 +33,59 @@ import ( "github.com/holiman/uint256" ) -//go:generate go run github.com/ethereum/go-ethereum/rlp/rlpgen -out bal_encoding_rlp_generated.go -type BlockAccessList -decoder +//go:generate go run github.com/ethereum/go-ethereum/rlp/rlpgen -out bal_encoding_rlp_generated.go -type AccountAccess -decoder // These are objects used as input for the access list encoding. They mirror // the spec format. // BlockAccessList is the encoding format of ConstructionBlockAccessList. -type BlockAccessList struct { - Accesses []AccountAccess `ssz-max:"300000"` +type BlockAccessList []AccountAccess + +// EncodeRLP implements rlp.Encoder. It encodes the access list as a single +// RLP list of AccountAccess entries. +func (e BlockAccessList) EncodeRLP(w io.Writer) error { + buf := rlp.NewEncoderBuffer(w) + l := buf.List() + for i := range e { + if err := e[i].EncodeRLP(buf); err != nil { + return err + } + } + buf.ListEnd(l) + return buf.Flush() +} + +// DecodeRLP implements rlp.Decoder. +func (e *BlockAccessList) DecodeRLP(s *rlp.Stream) error { + if _, err := s.List(); err != nil { + return err + } + var list BlockAccessList + for s.MoreDataInList() { + var a AccountAccess + if err := a.DecodeRLP(s); err != nil { + return err + } + list = append(list, a) + } + if err := s.ListEnd(); err != nil { + return err + } + *e = list + return nil } // Validate returns an error if the contents of the access list are not ordered // according to the spec or any code changes are contained which exceed protocol // max code size. -func (e *BlockAccessList) Validate() error { - if !slices.IsSortedFunc(e.Accesses, func(a, b AccountAccess) int { +func (e *BlockAccessList) Validate(rules params.Rules) error { + if !slices.IsSortedFunc(*e, func(a, b AccountAccess) int { return bytes.Compare(a.Address[:], b.Address[:]) }) { return errors.New("block access list accounts not in lexicographic order") } - for _, entry := range e.Accesses { - if err := entry.validate(); err != nil { + for _, entry := range *e { + if err := entry.validate(rules); err != nil { return err } } @@ -63,79 +95,74 @@ func (e *BlockAccessList) Validate() error { // Hash computes the keccak256 hash of the access list func (e *BlockAccessList) Hash() common.Hash { var enc bytes.Buffer - err := e.EncodeRLP(&enc) - if err != nil { - // errors here are related to BAL values exceeding maximum size defined - // by the spec. Hard-fail because these cases are not expected to be hit - // under reasonable conditions. - panic(err) + if err := e.EncodeRLP(&enc); err != nil { + // Errors here are related to BAL values exceeding maximum size defined + // by the spec. Return empty hash because these cases are not expected + // to be hit under reasonable conditions. + return common.Hash{} } return crypto.Keccak256Hash(enc.Bytes()) } -// encodeBalance encodes the provided balance into 16-bytes. -func encodeBalance(val *uint256.Int) [16]byte { - valBytes := val.Bytes() - if len(valBytes) > 16 { - panic("can't encode value that is greater than 16 bytes in size") - } - var enc [16]byte - copy(enc[16-len(valBytes):], valBytes[:]) - return enc -} - // encodingBalanceChange is the encoding format of BalanceChange. type encodingBalanceChange struct { - TxIdx uint16 `ssz-size:"2"` - Balance [16]byte `ssz-size:"16"` + TxIdx uint32 + Balance *uint256.Int } // encodingAccountNonce is the encoding format of NonceChange. type encodingAccountNonce struct { - TxIdx uint16 `ssz-size:"2"` - Nonce uint64 `ssz-size:"8"` + TxIdx uint32 + Nonce uint64 } // encodingStorageWrite is the encoding format of StorageWrites. type encodingStorageWrite struct { - TxIdx uint16 - ValueAfter [32]byte `ssz-size:"32"` + TxIdx uint32 + ValueAfter *uint256.Int } // encodingStorageWrite is the encoding format of SlotWrites. type encodingSlotWrites struct { - Slot [32]byte `ssz-size:"32"` - Accesses []encodingStorageWrite `ssz-max:"300000"` + Slot *uint256.Int + Accesses []encodingStorageWrite } // validate returns an instance of the encoding-representation slot writes in // working representation. func (e *encodingSlotWrites) validate() error { if slices.IsSortedFunc(e.Accesses, func(a, b encodingStorageWrite) int { - return cmp.Compare[uint16](a.TxIdx, b.TxIdx) + return cmp.Compare[uint32](a.TxIdx, b.TxIdx) }) { return nil } return errors.New("storage write tx indices not in order") } +// encodingCodeChange contains the runtime bytecode deployed at an address +// and the transaction index where the deployment took place. +type encodingCodeChange struct { + TxIndex uint32 + Code []byte +} + // AccountAccess is the encoding format of ConstructionAccountAccess. type AccountAccess struct { - Address [20]byte `ssz-size:"20"` // 20-byte Ethereum address - StorageWrites []encodingSlotWrites `ssz-max:"300000"` // Storage changes (slot -> [tx_index -> new_value]) - StorageReads [][32]byte `ssz-max:"300000"` // Read-only storage keys - BalanceChanges []encodingBalanceChange `ssz-max:"300000"` // Balance changes ([tx_index -> post_balance]) - NonceChanges []encodingAccountNonce `ssz-max:"300000"` // Nonce changes ([tx_index -> new_nonce]) - Code []CodeChange `ssz-max:"1"` // Code changes ([tx_index -> new_code]) + Address [20]byte // 20-byte Ethereum address + StorageWrites []encodingSlotWrites // Storage changes (slot -> [tx_index -> new_value]) + StorageReads []*uint256.Int // Read-only storage keys + BalanceChanges []encodingBalanceChange // Balance changes ([tx_index -> post_balance]) + NonceChanges []encodingAccountNonce // Nonce changes ([tx_index -> new_nonce]) + CodeChanges []encodingCodeChange // Code changes ([tx_index -> new_code]) } // validate converts the account accesses out of encoding format. // If any of the keys in the encoding object are not ordered according to the // spec, an error is returned. -func (e *AccountAccess) validate() error { +func (e *AccountAccess) validate(rules params.Rules) error { // Check the storage write slots are sorted in order if !slices.IsSortedFunc(e.StorageWrites, func(a, b encodingSlotWrites) int { - return bytes.Compare(a.Slot[:], b.Slot[:]) + return a.Slot.Cmp(b.Slot) }) { return errors.New("storage writes slots not in lexicographic order") } @@ -146,29 +173,41 @@ func (e *AccountAccess) validate() error { } // Check the storage read slots are sorted in order - if !slices.IsSortedFunc(e.StorageReads, func(a, b [32]byte) int { - return bytes.Compare(a[:], b[:]) + if !slices.IsSortedFunc(e.StorageReads, func(a, b *uint256.Int) int { + return a.Cmp(b) }) { return errors.New("storage read slots not in lexicographic order") } // Check the balance changes are sorted in order if !slices.IsSortedFunc(e.BalanceChanges, func(a, b encodingBalanceChange) int { - return cmp.Compare[uint16](a.TxIdx, b.TxIdx) + return cmp.Compare[uint32](a.TxIdx, b.TxIdx) }) { return errors.New("balance changes not in ascending order by tx index") } // Check the nonce changes are sorted in order if !slices.IsSortedFunc(e.NonceChanges, func(a, b encodingAccountNonce) int { - return cmp.Compare[uint16](a.TxIdx, b.TxIdx) + return cmp.Compare[uint32](a.TxIdx, b.TxIdx) }) { return errors.New("nonce changes not in ascending order by tx index") } - // Convert code change - if len(e.Code) == 1 { - if len(e.Code[0].Code) > params.MaxCodeSize { + // Check the code changes are sorted in order + if !slices.IsSortedFunc(e.CodeChanges, func(a, b encodingCodeChange) int { + return cmp.Compare[uint32](a.TxIndex, b.TxIndex) + }) { + return errors.New("code changes not in ascending order by tx index") + } + for _, change := range e.CodeChanges { + var sizeLimit int + switch { + case rules.IsAmsterdam: + sizeLimit = params.MaxCodeSizeAmsterdam + default: + sizeLimit = params.MaxCodeSize + } + if len(change.Code) > sizeLimit { return errors.New("code change contained oversized code") } } @@ -179,23 +218,39 @@ func (e *AccountAccess) validate() error { func (e *AccountAccess) Copy() AccountAccess { res := AccountAccess{ Address: e.Address, - StorageReads: slices.Clone(e.StorageReads), - BalanceChanges: slices.Clone(e.BalanceChanges), + StorageReads: make([]*uint256.Int, 0, len(e.StorageReads)), + BalanceChanges: make([]encodingBalanceChange, 0, len(e.BalanceChanges)), NonceChanges: slices.Clone(e.NonceChanges), + StorageWrites: make([]encodingSlotWrites, 0, len(e.StorageWrites)), + CodeChanges: make([]encodingCodeChange, 0, len(e.CodeChanges)), + } + for _, slot := range e.StorageReads { + res.StorageReads = append(res.StorageReads, slot.Clone()) + } + for _, change := range e.BalanceChanges { + res.BalanceChanges = append(res.BalanceChanges, encodingBalanceChange{ + TxIdx: change.TxIdx, + Balance: change.Balance.Clone(), + }) } for _, storageWrite := range e.StorageWrites { + accesses := make([]encodingStorageWrite, 0, len(storageWrite.Accesses)) + for _, w := range storageWrite.Accesses { + accesses = append(accesses, encodingStorageWrite{ + TxIdx: w.TxIdx, + ValueAfter: w.ValueAfter.Clone(), + }) + } res.StorageWrites = append(res.StorageWrites, encodingSlotWrites{ - Slot: storageWrite.Slot, - Accesses: slices.Clone(storageWrite.Accesses), + Slot: storageWrite.Slot.Clone(), + Accesses: accesses, }) } - if len(e.Code) == 1 { - res.Code = []CodeChange{ - { - e.Code[0].TxIndex, - bytes.Clone(e.Code[0].Code), - }, - } + for _, codeChange := range e.CodeChanges { + res.CodeChanges = append(res.CodeChanges, encodingCodeChange{ + TxIndex: codeChange.TxIndex, + Code: bytes.Clone(codeChange.Code), + }) } return res } @@ -207,34 +262,35 @@ func (b *ConstructionBlockAccessList) EncodeRLP(wr io.Writer) error { var _ rlp.Encoder = &ConstructionBlockAccessList{} -// toEncodingObj creates an instance of the ConstructionAccountAccess of the type that is -// used as input for the encoding. +// toEncodingObj creates an instance of the ConstructionAccountAccess of the type +// that is used as input for the encoding. func (a *ConstructionAccountAccess) toEncodingObj(addr common.Address) AccountAccess { res := AccountAccess{ Address: addr, - StorageWrites: make([]encodingSlotWrites, 0), - StorageReads: make([][32]byte, 0), - BalanceChanges: make([]encodingBalanceChange, 0), - NonceChanges: make([]encodingAccountNonce, 0), - Code: nil, + StorageWrites: make([]encodingSlotWrites, 0, len(a.StorageWrites)), + StorageReads: make([]*uint256.Int, 0, len(a.StorageReads)), + BalanceChanges: make([]encodingBalanceChange, 0, len(a.BalanceChanges)), + NonceChanges: make([]encodingAccountNonce, 0, len(a.NonceChanges)), + CodeChanges: make([]encodingCodeChange, 0, len(a.CodeChange)), } // Convert write slots writeSlots := slices.Collect(maps.Keys(a.StorageWrites)) slices.SortFunc(writeSlots, common.Hash.Cmp) for _, slot := range writeSlots { - var obj encodingSlotWrites - obj.Slot = slot - + obj := encodingSlotWrites{ + Slot: new(uint256.Int).SetBytes(slot[:]), + } slotWrites := a.StorageWrites[slot] obj.Accesses = make([]encodingStorageWrite, 0, len(slotWrites)) indices := slices.Collect(maps.Keys(slotWrites)) - slices.SortFunc(indices, cmp.Compare[uint16]) + slices.SortFunc(indices, cmp.Compare[uint32]) for _, index := range indices { + val := slotWrites[index] obj.Accesses = append(obj.Accesses, encodingStorageWrite{ TxIdx: index, - ValueAfter: slotWrites[index], + ValueAfter: new(uint256.Int).SetBytes(val[:]), }) } res.StorageWrites = append(res.StorageWrites, obj) @@ -244,22 +300,22 @@ func (a *ConstructionAccountAccess) toEncodingObj(addr common.Address) AccountAc readSlots := slices.Collect(maps.Keys(a.StorageReads)) slices.SortFunc(readSlots, common.Hash.Cmp) for _, slot := range readSlots { - res.StorageReads = append(res.StorageReads, slot) + res.StorageReads = append(res.StorageReads, new(uint256.Int).SetBytes(slot[:])) } // Convert balance changes balanceIndices := slices.Collect(maps.Keys(a.BalanceChanges)) - slices.SortFunc(balanceIndices, cmp.Compare[uint16]) + slices.SortFunc(balanceIndices, cmp.Compare[uint32]) for _, idx := range balanceIndices { res.BalanceChanges = append(res.BalanceChanges, encodingBalanceChange{ TxIdx: idx, - Balance: encodeBalance(a.BalanceChanges[idx]), + Balance: a.BalanceChanges[idx].Clone(), }) } // Convert nonce changes nonceIndices := slices.Collect(maps.Keys(a.NonceChanges)) - slices.SortFunc(nonceIndices, cmp.Compare[uint16]) + slices.SortFunc(nonceIndices, cmp.Compare[uint32]) for _, idx := range nonceIndices { res.NonceChanges = append(res.NonceChanges, encodingAccountNonce{ TxIdx: idx, @@ -268,13 +324,18 @@ func (a *ConstructionAccountAccess) toEncodingObj(addr common.Address) AccountAc } // Convert code change - if a.CodeChange != nil { - res.Code = []CodeChange{ - { - a.CodeChange.TxIndex, - bytes.Clone(a.CodeChange.Code), - }, - } + codeIndices := slices.Collect(maps.Keys(a.CodeChange)) + slices.SortFunc(codeIndices, cmp.Compare[uint32]) + for _, idx := range codeIndices { + res.CodeChanges = append(res.CodeChanges, encodingCodeChange{ + TxIndex: idx, + + // TODO(rjl493456442) the contract code is not deep-copied. + // In theory the deep-copy is unnecessary, the semantics of + // the function should be probably changed that the returned + // AccessList is unsafe for modification. + Code: a.CodeChange[idx], + }) } return res } @@ -288,9 +349,9 @@ func (b *ConstructionBlockAccessList) toEncodingObj() *BlockAccessList { } slices.SortFunc(addresses, common.Address.Cmp) - var res BlockAccessList + res := make(BlockAccessList, 0, len(addresses)) for _, addr := range addresses { - res.Accesses = append(res.Accesses, b.Accounts[addr].toEncodingObj(addr)) + res = append(res, b.Accounts[addr].toEncodingObj(addr)) } return &res } @@ -300,26 +361,25 @@ func (e *BlockAccessList) PrettyPrint() string { printWithIndent := func(indent int, text string) { fmt.Fprintf(&res, "%s%s\n", strings.Repeat(" ", indent), text) } - for _, accountDiff := range e.Accesses { + for _, accountDiff := range *e { printWithIndent(0, fmt.Sprintf("%x:", accountDiff.Address)) printWithIndent(1, "storage writes:") for _, sWrite := range accountDiff.StorageWrites { - printWithIndent(2, fmt.Sprintf("%x:", sWrite.Slot)) + printWithIndent(2, fmt.Sprintf("%s:", sWrite.Slot.Hex())) for _, access := range sWrite.Accesses { - printWithIndent(3, fmt.Sprintf("%d: %x", access.TxIdx, access.ValueAfter)) + printWithIndent(3, fmt.Sprintf("%d: %s", access.TxIdx, access.ValueAfter.Hex())) } } printWithIndent(1, "storage reads:") for _, slot := range accountDiff.StorageReads { - printWithIndent(2, fmt.Sprintf("%x", slot)) + printWithIndent(2, slot.Hex()) } printWithIndent(1, "balance changes:") for _, change := range accountDiff.BalanceChanges { - balance := new(uint256.Int).SetBytes(change.Balance[:]).String() - printWithIndent(2, fmt.Sprintf("%d: %s", change.TxIdx, balance)) + printWithIndent(2, fmt.Sprintf("%d: %s", change.TxIdx, change.Balance)) } printWithIndent(1, "nonce changes:") @@ -327,18 +387,19 @@ func (e *BlockAccessList) PrettyPrint() string { printWithIndent(2, fmt.Sprintf("%d: %d", change.TxIdx, change.Nonce)) } - if len(accountDiff.Code) > 0 { - printWithIndent(1, "code:") - printWithIndent(2, fmt.Sprintf("%d: %x", accountDiff.Code[0].TxIndex, accountDiff.Code[0].Code)) + printWithIndent(1, "code changes:") + for _, change := range accountDiff.CodeChanges { + printWithIndent(2, fmt.Sprintf("%d: %x", change.TxIndex, change.Code)) } } return res.String() } // Copy returns a deep copy of the access list -func (e *BlockAccessList) Copy() (res BlockAccessList) { - for _, accountAccess := range e.Accesses { - res.Accesses = append(res.Accesses, accountAccess.Copy()) +func (e *BlockAccessList) Copy() *BlockAccessList { + cpy := make(BlockAccessList, 0, len(*e)) + for _, accountAccess := range *e { + cpy = append(cpy, accountAccess.Copy()) } - return + return &cpy } diff --git a/core/types/bal/bal_encoding_rlp_generated.go b/core/types/bal/bal_encoding_rlp_generated.go index 0d5239532904..540987c0766a 100644 --- a/core/types/bal/bal_encoding_rlp_generated.go +++ b/core/types/bal/bal_encoding_rlp_generated.go @@ -3,274 +3,264 @@ package bal import "github.com/ethereum/go-ethereum/rlp" +import "github.com/holiman/uint256" import "io" -func (obj *BlockAccessList) EncodeRLP(_w io.Writer) error { +func (obj *AccountAccess) EncodeRLP(_w io.Writer) error { w := rlp.NewEncoderBuffer(_w) _tmp0 := w.List() + w.WriteBytes(obj.Address[:]) _tmp1 := w.List() - for _, _tmp2 := range obj.Accesses { + for _, _tmp2 := range obj.StorageWrites { _tmp3 := w.List() - w.WriteBytes(_tmp2.Address[:]) + if _tmp2.Slot == nil { + w.Write(rlp.EmptyString) + } else { + w.WriteUint256(_tmp2.Slot) + } _tmp4 := w.List() - for _, _tmp5 := range _tmp2.StorageWrites { + for _, _tmp5 := range _tmp2.Accesses { _tmp6 := w.List() - w.WriteBytes(_tmp5.Slot[:]) - _tmp7 := w.List() - for _, _tmp8 := range _tmp5.Accesses { - _tmp9 := w.List() - w.WriteUint64(uint64(_tmp8.TxIdx)) - w.WriteBytes(_tmp8.ValueAfter[:]) - w.ListEnd(_tmp9) + w.WriteUint64(uint64(_tmp5.TxIdx)) + if _tmp5.ValueAfter == nil { + w.Write(rlp.EmptyString) + } else { + w.WriteUint256(_tmp5.ValueAfter) } - w.ListEnd(_tmp7) w.ListEnd(_tmp6) } w.ListEnd(_tmp4) - _tmp10 := w.List() - for _, _tmp11 := range _tmp2.StorageReads { - w.WriteBytes(_tmp11[:]) - } - w.ListEnd(_tmp10) - _tmp12 := w.List() - for _, _tmp13 := range _tmp2.BalanceChanges { - _tmp14 := w.List() - w.WriteUint64(uint64(_tmp13.TxIdx)) - w.WriteBytes(_tmp13.Balance[:]) - w.ListEnd(_tmp14) - } - w.ListEnd(_tmp12) - _tmp15 := w.List() - for _, _tmp16 := range _tmp2.NonceChanges { - _tmp17 := w.List() - w.WriteUint64(uint64(_tmp16.TxIdx)) - w.WriteUint64(_tmp16.Nonce) - w.ListEnd(_tmp17) - } - w.ListEnd(_tmp15) - _tmp18 := w.List() - for _, _tmp19 := range _tmp2.Code { - _tmp20 := w.List() - w.WriteUint64(uint64(_tmp19.TxIndex)) - w.WriteBytes(_tmp19.Code) - w.ListEnd(_tmp20) - } - w.ListEnd(_tmp18) w.ListEnd(_tmp3) } w.ListEnd(_tmp1) + _tmp7 := w.List() + for _, _tmp8 := range obj.StorageReads { + if _tmp8 == nil { + w.Write(rlp.EmptyString) + } else { + w.WriteUint256(_tmp8) + } + } + w.ListEnd(_tmp7) + _tmp9 := w.List() + for _, _tmp10 := range obj.BalanceChanges { + _tmp11 := w.List() + w.WriteUint64(uint64(_tmp10.TxIdx)) + if _tmp10.Balance == nil { + w.Write(rlp.EmptyString) + } else { + w.WriteUint256(_tmp10.Balance) + } + w.ListEnd(_tmp11) + } + w.ListEnd(_tmp9) + _tmp12 := w.List() + for _, _tmp13 := range obj.NonceChanges { + _tmp14 := w.List() + w.WriteUint64(uint64(_tmp13.TxIdx)) + w.WriteUint64(_tmp13.Nonce) + w.ListEnd(_tmp14) + } + w.ListEnd(_tmp12) + _tmp15 := w.List() + for _, _tmp16 := range obj.CodeChanges { + _tmp17 := w.List() + w.WriteUint64(uint64(_tmp16.TxIndex)) + w.WriteBytes(_tmp16.Code) + w.ListEnd(_tmp17) + } + w.ListEnd(_tmp15) w.ListEnd(_tmp0) return w.Flush() } -func (obj *BlockAccessList) DecodeRLP(dec *rlp.Stream) error { - var _tmp0 BlockAccessList +func (obj *AccountAccess) DecodeRLP(dec *rlp.Stream) error { + var _tmp0 AccountAccess { if _, err := dec.List(); err != nil { return err } - // Accesses: - var _tmp1 []AccountAccess + // Address: + var _tmp1 [20]byte + if err := dec.ReadBytes(_tmp1[:]); err != nil { + return err + } + _tmp0.Address = _tmp1 + // StorageWrites: + var _tmp2 []encodingSlotWrites if _, err := dec.List(); err != nil { return err } for dec.MoreDataInList() { - var _tmp2 AccountAccess + var _tmp3 encodingSlotWrites { if _, err := dec.List(); err != nil { return err } - // Address: - var _tmp3 [20]byte - if err := dec.ReadBytes(_tmp3[:]); err != nil { + // Slot: + var _tmp4 uint256.Int + if err := dec.ReadUint256(&_tmp4); err != nil { return err } - _tmp2.Address = _tmp3 - // StorageWrites: - var _tmp4 []encodingSlotWrites + _tmp3.Slot = &_tmp4 + // Accesses: + var _tmp5 []encodingStorageWrite if _, err := dec.List(); err != nil { return err } for dec.MoreDataInList() { - var _tmp5 encodingSlotWrites + var _tmp6 encodingStorageWrite { if _, err := dec.List(); err != nil { return err } - // Slot: - var _tmp6 [32]byte - if err := dec.ReadBytes(_tmp6[:]); err != nil { - return err - } - _tmp5.Slot = _tmp6 - // Accesses: - var _tmp7 []encodingStorageWrite - if _, err := dec.List(); err != nil { + // TxIdx: + _tmp7, err := dec.Uint32() + if err != nil { return err } - for dec.MoreDataInList() { - var _tmp8 encodingStorageWrite - { - if _, err := dec.List(); err != nil { - return err - } - // TxIdx: - _tmp9, err := dec.Uint16() - if err != nil { - return err - } - _tmp8.TxIdx = _tmp9 - // ValueAfter: - var _tmp10 [32]byte - if err := dec.ReadBytes(_tmp10[:]); err != nil { - return err - } - _tmp8.ValueAfter = _tmp10 - if err := dec.ListEnd(); err != nil { - return err - } - } - _tmp7 = append(_tmp7, _tmp8) - } - if err := dec.ListEnd(); err != nil { + _tmp6.TxIdx = _tmp7 + // ValueAfter: + var _tmp8 uint256.Int + if err := dec.ReadUint256(&_tmp8); err != nil { return err } - _tmp5.Accesses = _tmp7 + _tmp6.ValueAfter = &_tmp8 if err := dec.ListEnd(); err != nil { return err } } - _tmp4 = append(_tmp4, _tmp5) + _tmp5 = append(_tmp5, _tmp6) } if err := dec.ListEnd(); err != nil { return err } - _tmp2.StorageWrites = _tmp4 - // StorageReads: - var _tmp11 [][32]byte - if _, err := dec.List(); err != nil { - return err - } - for dec.MoreDataInList() { - var _tmp12 [32]byte - if err := dec.ReadBytes(_tmp12[:]); err != nil { - return err - } - _tmp11 = append(_tmp11, _tmp12) - } + _tmp3.Accesses = _tmp5 if err := dec.ListEnd(); err != nil { return err } - _tmp2.StorageReads = _tmp11 - // BalanceChanges: - var _tmp13 []encodingBalanceChange + } + _tmp2 = append(_tmp2, _tmp3) + } + if err := dec.ListEnd(); err != nil { + return err + } + _tmp0.StorageWrites = _tmp2 + // StorageReads: + var _tmp9 []*uint256.Int + if _, err := dec.List(); err != nil { + return err + } + for dec.MoreDataInList() { + var _tmp10 uint256.Int + if err := dec.ReadUint256(&_tmp10); err != nil { + return err + } + _tmp9 = append(_tmp9, &_tmp10) + } + if err := dec.ListEnd(); err != nil { + return err + } + _tmp0.StorageReads = _tmp9 + // BalanceChanges: + var _tmp11 []encodingBalanceChange + if _, err := dec.List(); err != nil { + return err + } + for dec.MoreDataInList() { + var _tmp12 encodingBalanceChange + { if _, err := dec.List(); err != nil { return err } - for dec.MoreDataInList() { - var _tmp14 encodingBalanceChange - { - if _, err := dec.List(); err != nil { - return err - } - // TxIdx: - _tmp15, err := dec.Uint16() - if err != nil { - return err - } - _tmp14.TxIdx = _tmp15 - // Balance: - var _tmp16 [16]byte - if err := dec.ReadBytes(_tmp16[:]); err != nil { - return err - } - _tmp14.Balance = _tmp16 - if err := dec.ListEnd(); err != nil { - return err - } - } - _tmp13 = append(_tmp13, _tmp14) + // TxIdx: + _tmp13, err := dec.Uint32() + if err != nil { + return err } + _tmp12.TxIdx = _tmp13 + // Balance: + var _tmp14 uint256.Int + if err := dec.ReadUint256(&_tmp14); err != nil { + return err + } + _tmp12.Balance = &_tmp14 if err := dec.ListEnd(); err != nil { return err } - _tmp2.BalanceChanges = _tmp13 - // NonceChanges: - var _tmp17 []encodingAccountNonce + } + _tmp11 = append(_tmp11, _tmp12) + } + if err := dec.ListEnd(); err != nil { + return err + } + _tmp0.BalanceChanges = _tmp11 + // NonceChanges: + var _tmp15 []encodingAccountNonce + if _, err := dec.List(); err != nil { + return err + } + for dec.MoreDataInList() { + var _tmp16 encodingAccountNonce + { if _, err := dec.List(); err != nil { return err } - for dec.MoreDataInList() { - var _tmp18 encodingAccountNonce - { - if _, err := dec.List(); err != nil { - return err - } - // TxIdx: - _tmp19, err := dec.Uint16() - if err != nil { - return err - } - _tmp18.TxIdx = _tmp19 - // Nonce: - _tmp20, err := dec.Uint64() - if err != nil { - return err - } - _tmp18.Nonce = _tmp20 - if err := dec.ListEnd(); err != nil { - return err - } - } - _tmp17 = append(_tmp17, _tmp18) + // TxIdx: + _tmp17, err := dec.Uint32() + if err != nil { + return err + } + _tmp16.TxIdx = _tmp17 + // Nonce: + _tmp18, err := dec.Uint64() + if err != nil { + return err } + _tmp16.Nonce = _tmp18 if err := dec.ListEnd(); err != nil { return err } - _tmp2.NonceChanges = _tmp17 - // Code: - var _tmp21 []CodeChange + } + _tmp15 = append(_tmp15, _tmp16) + } + if err := dec.ListEnd(); err != nil { + return err + } + _tmp0.NonceChanges = _tmp15 + // CodeChanges: + var _tmp19 []encodingCodeChange + if _, err := dec.List(); err != nil { + return err + } + for dec.MoreDataInList() { + var _tmp20 encodingCodeChange + { if _, err := dec.List(); err != nil { return err } - for dec.MoreDataInList() { - var _tmp22 CodeChange - { - if _, err := dec.List(); err != nil { - return err - } - // TxIndex: - _tmp23, err := dec.Uint16() - if err != nil { - return err - } - _tmp22.TxIndex = _tmp23 - // Code: - _tmp24, err := dec.Bytes() - if err != nil { - return err - } - _tmp22.Code = _tmp24 - if err := dec.ListEnd(); err != nil { - return err - } - } - _tmp21 = append(_tmp21, _tmp22) + // TxIndex: + _tmp21, err := dec.Uint32() + if err != nil { + return err } - if err := dec.ListEnd(); err != nil { + _tmp20.TxIndex = _tmp21 + // Code: + _tmp22, err := dec.Bytes() + if err != nil { return err } - _tmp2.Code = _tmp21 + _tmp20.Code = _tmp22 if err := dec.ListEnd(); err != nil { return err } } - _tmp1 = append(_tmp1, _tmp2) + _tmp19 = append(_tmp19, _tmp20) } if err := dec.ListEnd(); err != nil { return err } - _tmp0.Accesses = _tmp1 + _tmp0.CodeChanges = _tmp19 if err := dec.ListEnd(); err != nil { return err } diff --git a/core/types/bal/bal_test.go b/core/types/bal/bal_test.go index 29414e414e82..32a0292f2e57 100644 --- a/core/types/bal/bal_test.go +++ b/core/types/bal/bal_test.go @@ -25,22 +25,16 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/internal/testrand" + "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/holiman/uint256" ) -func equalBALs(a *BlockAccessList, b *BlockAccessList) bool { - if !reflect.DeepEqual(a, b) { - return false - } - return true -} - func makeTestConstructionBAL() *ConstructionBlockAccessList { return &ConstructionBlockAccessList{ map[common.Address]*ConstructionAccountAccess{ common.BytesToAddress([]byte{0xff, 0xff}): { - StorageWrites: map[common.Hash]map[uint16]common.Hash{ + StorageWrites: map[common.Hash]map[uint32]common.Hash{ common.BytesToHash([]byte{0x01}): { 1: common.BytesToHash([]byte{1, 2, 3, 4}), 2: common.BytesToHash([]byte{1, 2, 3, 4, 5, 6}), @@ -52,21 +46,20 @@ func makeTestConstructionBAL() *ConstructionBlockAccessList { StorageReads: map[common.Hash]struct{}{ common.BytesToHash([]byte{1, 2, 3, 4, 5, 6, 7}): {}, }, - BalanceChanges: map[uint16]*uint256.Int{ + BalanceChanges: map[uint32]*uint256.Int{ 1: uint256.NewInt(100), 2: uint256.NewInt(500), }, - NonceChanges: map[uint16]uint64{ + NonceChanges: map[uint32]uint64{ 1: 2, 2: 6, }, - CodeChange: &CodeChange{ - TxIndex: 0, - Code: common.Hex2Bytes("deadbeef"), + CodeChange: map[uint32][]byte{ + 0: common.Hex2Bytes("deadbeef"), }, }, common.BytesToAddress([]byte{0xff, 0xff, 0xff}): { - StorageWrites: map[common.Hash]map[uint16]common.Hash{ + StorageWrites: map[common.Hash]map[uint32]common.Hash{ common.BytesToHash([]byte{0x01}): { 2: common.BytesToHash([]byte{1, 2, 3, 4, 5, 6}), 3: common.BytesToHash([]byte{1, 2, 3, 4, 5, 6, 7, 8}), @@ -78,13 +71,16 @@ func makeTestConstructionBAL() *ConstructionBlockAccessList { StorageReads: map[common.Hash]struct{}{ common.BytesToHash([]byte{1, 2, 3, 4, 5, 6, 7, 8}): {}, }, - BalanceChanges: map[uint16]*uint256.Int{ + BalanceChanges: map[uint32]*uint256.Int{ 2: uint256.NewInt(100), 3: uint256.NewInt(500), }, - NonceChanges: map[uint16]uint64{ + NonceChanges: map[uint32]uint64{ 1: 2, }, + CodeChange: map[uint32][]byte{ + 0: common.Hex2Bytes("deadbeef"), + }, }, }, } @@ -99,13 +95,13 @@ func TestBALEncoding(t *testing.T) { t.Fatalf("encoding failed: %v\n", err) } var dec BlockAccessList - if err := dec.DecodeRLP(rlp.NewStream(bytes.NewReader(buf.Bytes()), 10000000)); err != nil { + if err := dec.DecodeRLP(rlp.NewStream(bytes.NewReader(buf.Bytes()), 0)); err != nil { t.Fatalf("decoding failed: %v\n", err) } if dec.Hash() != bal.toEncodingObj().Hash() { t.Fatalf("encoded block hash doesn't match decoded") } - if !equalBALs(bal.toEncodingObj(), &dec) { + if !reflect.DeepEqual(bal.toEncodingObj(), &dec) { t.Fatal("decoded BAL doesn't match") } } @@ -113,63 +109,79 @@ func TestBALEncoding(t *testing.T) { func makeTestAccountAccess(sort bool) AccountAccess { var ( storageWrites []encodingSlotWrites - storageReads [][32]byte + storageReads []*uint256.Int balances []encodingBalanceChange nonces []encodingAccountNonce + codes []encodingCodeChange ) + randSlot := func() *uint256.Int { + return new(uint256.Int).SetBytes(testrand.Bytes(32)) + } for i := 0; i < 5; i++ { slot := encodingSlotWrites{ - Slot: testrand.Hash(), + Slot: randSlot(), } for j := 0; j < 3; j++ { slot.Accesses = append(slot.Accesses, encodingStorageWrite{ - TxIdx: uint16(2 * j), - ValueAfter: testrand.Hash(), + TxIdx: uint32(2 * j), + ValueAfter: randSlot(), }) } if sort { slices.SortFunc(slot.Accesses, func(a, b encodingStorageWrite) int { - return cmp.Compare[uint16](a.TxIdx, b.TxIdx) + return cmp.Compare[uint32](a.TxIdx, b.TxIdx) }) } storageWrites = append(storageWrites, slot) } if sort { slices.SortFunc(storageWrites, func(a, b encodingSlotWrites) int { - return bytes.Compare(a.Slot[:], b.Slot[:]) + return a.Slot.Cmp(b.Slot) }) } for i := 0; i < 5; i++ { - storageReads = append(storageReads, testrand.Hash()) + storageReads = append(storageReads, randSlot()) } if sort { - slices.SortFunc(storageReads, func(a, b [32]byte) int { - return bytes.Compare(a[:], b[:]) + slices.SortFunc(storageReads, func(a, b *uint256.Int) int { + return a.Cmp(b) }) } for i := 0; i < 5; i++ { balances = append(balances, encodingBalanceChange{ - TxIdx: uint16(2 * i), - Balance: [16]byte(testrand.Bytes(16)), + TxIdx: uint32(2 * i), + Balance: new(uint256.Int).SetBytes(testrand.Bytes(16)), }) } if sort { slices.SortFunc(balances, func(a, b encodingBalanceChange) int { - return cmp.Compare[uint16](a.TxIdx, b.TxIdx) + return cmp.Compare[uint32](a.TxIdx, b.TxIdx) }) } for i := 0; i < 5; i++ { nonces = append(nonces, encodingAccountNonce{ - TxIdx: uint16(2 * i), + TxIdx: uint32(2 * i), Nonce: uint64(i + 100), }) } if sort { slices.SortFunc(nonces, func(a, b encodingAccountNonce) int { - return cmp.Compare[uint16](a.TxIdx, b.TxIdx) + return cmp.Compare[uint32](a.TxIdx, b.TxIdx) + }) + } + + for i := 0; i < 5; i++ { + codes = append(codes, encodingCodeChange{ + TxIndex: uint32(2 * i), + Code: testrand.Bytes(256), + }) + } + if sort { + slices.SortFunc(codes, func(a, b encodingCodeChange) int { + return cmp.Compare[uint32](a.TxIndex, b.TxIndex) }) } @@ -179,26 +191,21 @@ func makeTestAccountAccess(sort bool) AccountAccess { StorageReads: storageReads, BalanceChanges: balances, NonceChanges: nonces, - Code: []CodeChange{ - { - TxIndex: 100, - Code: testrand.Bytes(256), - }, - }, + CodeChanges: codes, } } -func makeTestBAL(sort bool) BlockAccessList { - list := BlockAccessList{} +func makeTestBAL(sort bool) *BlockAccessList { + list := make(BlockAccessList, 0, 5) for i := 0; i < 5; i++ { - list.Accesses = append(list.Accesses, makeTestAccountAccess(sort)) + list = append(list, makeTestAccountAccess(sort)) } if sort { - slices.SortFunc(list.Accesses, func(a, b AccountAccess) int { + slices.SortFunc(list, func(a, b AccountAccess) int { return bytes.Compare(a.Address[:], b.Address[:]) }) } - return list + return &list } func TestBlockAccessListCopy(t *testing.T) { @@ -214,9 +221,9 @@ func TestBlockAccessListCopy(t *testing.T) { } // Make sure the mutations on copy won't affect the origin - for _, aa := range cpyCpy.Accesses { + for _, aa := range *cpyCpy { for i := 0; i < len(aa.StorageReads); i++ { - aa.StorageReads[i] = [32]byte(testrand.Bytes(32)) + aa.StorageReads[i] = new(uint256.Int).SetBytes(testrand.Bytes(32)) } } if !reflect.DeepEqual(list, cpy) { @@ -227,7 +234,7 @@ func TestBlockAccessListCopy(t *testing.T) { func TestBlockAccessListValidation(t *testing.T) { // Validate the block access list after RLP decoding enc := makeTestBAL(true) - if err := enc.Validate(); err != nil { + if err := enc.Validate(params.Rules{}); err != nil { t.Fatalf("Unexpected validation error: %v", err) } var buf bytes.Buffer @@ -239,14 +246,14 @@ func TestBlockAccessListValidation(t *testing.T) { if err := dec.DecodeRLP(rlp.NewStream(bytes.NewReader(buf.Bytes()), 0)); err != nil { t.Fatalf("Unexpected RLP-decode error: %v", err) } - if err := dec.Validate(); err != nil { + if err := dec.Validate(params.Rules{}); err != nil { t.Fatalf("Unexpected validation error: %v", err) } // Validate the derived block access list cBAL := makeTestConstructionBAL() listB := cBAL.toEncodingObj() - if err := listB.Validate(); err != nil { + if err := listB.Validate(params.Rules{}); err != nil { t.Fatalf("Unexpected validation error: %v", err) } } diff --git a/core/types/block.go b/core/types/block.go index b5b6468a131c..ea576ed2329a 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -30,8 +30,8 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types/bal" "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-verkle" ) // A BlockNonce is a 64-bit hash which proves (combined with the @@ -61,13 +61,6 @@ func (n *BlockNonce) UnmarshalText(input []byte) error { return hexutil.UnmarshalFixedText("BlockNonce", input, n[:]) } -// ExecutionWitness represents the witness + proof used in a verkle context, -// to provide the ability to execute a block statelessly. -type ExecutionWitness struct { - StateDiff verkle.StateDiff `json:"stateDiff"` - VerkleProof *verkle.VerkleProof `json:"verkleProof"` -} - //go:generate go run github.com/fjl/gencodec -type Header -field-override headerMarshaling -out gen_header_json.go //go:generate go run ../../rlp/rlpgen -type Header -out gen_header_rlp.go @@ -106,6 +99,12 @@ type Header struct { // RequestsHash was added by EIP-7685 and is ignored in legacy headers. RequestsHash *common.Hash `json:"requestsHash" rlp:"optional"` + + // BlockAccessListHash was added by EIP-7928 and is ignored in legacy headers. + BlockAccessListHash *common.Hash `json:"balHash" rlp:"optional"` + + // SlotNumber was added by EIP-7843 and is ignored in legacy headers. + SlotNumber *uint64 `json:"slotNumber" rlp:"optional"` } // field type overrides for gencodec @@ -120,6 +119,7 @@ type headerMarshaling struct { Hash common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON BlobGasUsed *hexutil.Uint64 ExcessBlobGas *hexutil.Uint64 + SlotNumber *hexutil.Uint64 } // Hash returns the block hash of the header, which is simply the keccak256 hash of its @@ -208,11 +208,7 @@ type Block struct { uncles []*Header transactions Transactions withdrawals Withdrawals - - // witness is not an encoded part of the block body. - // It is held in Block in order for easy relaying to the places - // that process it. - witness *ExecutionWitness + accessList *bal.BlockAccessList // caches hash atomic.Pointer[common.Hash] @@ -329,6 +325,14 @@ func CopyHeader(h *Header) *Header { cpy.RequestsHash = new(common.Hash) *cpy.RequestsHash = *h.RequestsHash } + if h.BlockAccessListHash != nil { + cpy.BlockAccessListHash = new(common.Hash) + *cpy.BlockAccessListHash = *h.BlockAccessListHash + } + if h.SlotNumber != nil { + cpy.SlotNumber = new(uint64) + *cpy.SlotNumber = *h.SlotNumber + } return &cpy } @@ -363,9 +367,10 @@ func (b *Block) Body() *Body { // Accessors for body data. These do not return a copy because the content // of the body slices does not affect the cached hash/size in block. -func (b *Block) Uncles() []*Header { return b.uncles } -func (b *Block) Transactions() Transactions { return b.transactions } -func (b *Block) Withdrawals() Withdrawals { return b.withdrawals } +func (b *Block) Uncles() []*Header { return b.uncles } +func (b *Block) Transactions() Transactions { return b.transactions } +func (b *Block) Withdrawals() Withdrawals { return b.withdrawals } +func (b *Block) AccessList() *bal.BlockAccessList { return b.accessList } func (b *Block) Transaction(hash common.Hash) *Transaction { for _, transaction := range b.transactions { @@ -429,8 +434,14 @@ func (b *Block) BlobGasUsed() *uint64 { return blobGasUsed } -// ExecutionWitness returns the verkle execution witneess + proof for a block -func (b *Block) ExecutionWitness() *ExecutionWitness { return b.witness } +func (b *Block) SlotNumber() *uint64 { + var slotNum *uint64 + if b.header.SlotNumber != nil { + slotNum = new(uint64) + *slotNum = *b.header.SlotNumber + } + return slotNum +} // Size returns the true RLP encoded storage size of the block, either by encoding // and returning it, or returning a previously cached value. @@ -494,7 +505,7 @@ func (b *Block) WithSeal(header *Header) *Block { transactions: b.transactions, uncles: b.uncles, withdrawals: b.withdrawals, - witness: b.witness, + accessList: b.accessList, } } @@ -506,7 +517,7 @@ func (b *Block) WithBody(body Body) *Block { transactions: slices.Clone(body.Transactions), uncles: make([]*Header, len(body.Uncles)), withdrawals: slices.Clone(body.Withdrawals), - witness: b.witness, + accessList: b.accessList, } for i := range body.Uncles { block.uncles[i] = CopyHeader(body.Uncles[i]) @@ -514,13 +525,21 @@ func (b *Block) WithBody(body Body) *Block { return block } -func (b *Block) WithWitness(witness *ExecutionWitness) *Block { +// WithAccessList returns a copy of the block with the given access list embedded. +func (b *Block) WithAccessList(accessList *bal.BlockAccessList) *Block { + return b.WithAccessListUnsafe(accessList.Copy()) +} + +// WithAccessListUnsafe returns a copy of the block with the given access list +// embedded. Note that the access list is not deep-copied; use WithAccessList +// if the provided list may be modified by other actors. +func (b *Block) WithAccessListUnsafe(accessList *bal.BlockAccessList) *Block { return &Block{ header: b.header, transactions: b.transactions, uncles: b.uncles, withdrawals: b.withdrawals, - witness: witness, + accessList: accessList, } } diff --git a/core/types/gen_header_json.go b/core/types/gen_header_json.go index 0af12500bdfd..2e2f1cdca5f0 100644 --- a/core/types/gen_header_json.go +++ b/core/types/gen_header_json.go @@ -16,28 +16,30 @@ var _ = (*headerMarshaling)(nil) // MarshalJSON marshals as JSON. func (h Header) MarshalJSON() ([]byte, error) { type Header struct { - ParentHash common.Hash `json:"parentHash" gencodec:"required"` - UncleHash common.Hash `json:"sha3Uncles" gencodec:"required"` - Coinbase common.Address `json:"miner"` - Root common.Hash `json:"stateRoot" gencodec:"required"` - TxHash common.Hash `json:"transactionsRoot" gencodec:"required"` - ReceiptHash common.Hash `json:"receiptsRoot" gencodec:"required"` - Bloom Bloom `json:"logsBloom" gencodec:"required"` - Difficulty *hexutil.Big `json:"difficulty" gencodec:"required"` - Number *hexutil.Big `json:"number" gencodec:"required"` - GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Time hexutil.Uint64 `json:"timestamp" gencodec:"required"` - Extra hexutil.Bytes `json:"extraData" gencodec:"required"` - MixDigest common.Hash `json:"mixHash"` - Nonce BlockNonce `json:"nonce"` - BaseFee *hexutil.Big `json:"baseFeePerGas" rlp:"optional"` - WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed" rlp:"optional"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas" rlp:"optional"` - ParentBeaconRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` - RequestsHash *common.Hash `json:"requestsHash" rlp:"optional"` - Hash common.Hash `json:"hash"` + ParentHash common.Hash `json:"parentHash" gencodec:"required"` + UncleHash common.Hash `json:"sha3Uncles" gencodec:"required"` + Coinbase common.Address `json:"miner"` + Root common.Hash `json:"stateRoot" gencodec:"required"` + TxHash common.Hash `json:"transactionsRoot" gencodec:"required"` + ReceiptHash common.Hash `json:"receiptsRoot" gencodec:"required"` + Bloom Bloom `json:"logsBloom" gencodec:"required"` + Difficulty *hexutil.Big `json:"difficulty" gencodec:"required"` + Number *hexutil.Big `json:"number" gencodec:"required"` + GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Time hexutil.Uint64 `json:"timestamp" gencodec:"required"` + Extra hexutil.Bytes `json:"extraData" gencodec:"required"` + MixDigest common.Hash `json:"mixHash"` + Nonce BlockNonce `json:"nonce"` + BaseFee *hexutil.Big `json:"baseFeePerGas" rlp:"optional"` + WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"` + BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed" rlp:"optional"` + ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas" rlp:"optional"` + ParentBeaconRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` + RequestsHash *common.Hash `json:"requestsHash" rlp:"optional"` + BlockAccessListHash *common.Hash `json:"balHash" rlp:"optional"` + SlotNumber *hexutil.Uint64 `json:"slotNumber" rlp:"optional"` + Hash common.Hash `json:"hash"` } var enc Header enc.ParentHash = h.ParentHash @@ -61,6 +63,8 @@ func (h Header) MarshalJSON() ([]byte, error) { enc.ExcessBlobGas = (*hexutil.Uint64)(h.ExcessBlobGas) enc.ParentBeaconRoot = h.ParentBeaconRoot enc.RequestsHash = h.RequestsHash + enc.BlockAccessListHash = h.BlockAccessListHash + enc.SlotNumber = (*hexutil.Uint64)(h.SlotNumber) enc.Hash = h.Hash() return json.Marshal(&enc) } @@ -68,27 +72,29 @@ func (h Header) MarshalJSON() ([]byte, error) { // UnmarshalJSON unmarshals from JSON. func (h *Header) UnmarshalJSON(input []byte) error { type Header struct { - ParentHash *common.Hash `json:"parentHash" gencodec:"required"` - UncleHash *common.Hash `json:"sha3Uncles" gencodec:"required"` - Coinbase *common.Address `json:"miner"` - Root *common.Hash `json:"stateRoot" gencodec:"required"` - TxHash *common.Hash `json:"transactionsRoot" gencodec:"required"` - ReceiptHash *common.Hash `json:"receiptsRoot" gencodec:"required"` - Bloom *Bloom `json:"logsBloom" gencodec:"required"` - Difficulty *hexutil.Big `json:"difficulty" gencodec:"required"` - Number *hexutil.Big `json:"number" gencodec:"required"` - GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` - GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` - Time *hexutil.Uint64 `json:"timestamp" gencodec:"required"` - Extra *hexutil.Bytes `json:"extraData" gencodec:"required"` - MixDigest *common.Hash `json:"mixHash"` - Nonce *BlockNonce `json:"nonce"` - BaseFee *hexutil.Big `json:"baseFeePerGas" rlp:"optional"` - WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"` - BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed" rlp:"optional"` - ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas" rlp:"optional"` - ParentBeaconRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` - RequestsHash *common.Hash `json:"requestsHash" rlp:"optional"` + ParentHash *common.Hash `json:"parentHash" gencodec:"required"` + UncleHash *common.Hash `json:"sha3Uncles" gencodec:"required"` + Coinbase *common.Address `json:"miner"` + Root *common.Hash `json:"stateRoot" gencodec:"required"` + TxHash *common.Hash `json:"transactionsRoot" gencodec:"required"` + ReceiptHash *common.Hash `json:"receiptsRoot" gencodec:"required"` + Bloom *Bloom `json:"logsBloom" gencodec:"required"` + Difficulty *hexutil.Big `json:"difficulty" gencodec:"required"` + Number *hexutil.Big `json:"number" gencodec:"required"` + GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` + Time *hexutil.Uint64 `json:"timestamp" gencodec:"required"` + Extra *hexutil.Bytes `json:"extraData" gencodec:"required"` + MixDigest *common.Hash `json:"mixHash"` + Nonce *BlockNonce `json:"nonce"` + BaseFee *hexutil.Big `json:"baseFeePerGas" rlp:"optional"` + WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"` + BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed" rlp:"optional"` + ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas" rlp:"optional"` + ParentBeaconRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` + RequestsHash *common.Hash `json:"requestsHash" rlp:"optional"` + BlockAccessListHash *common.Hash `json:"balHash" rlp:"optional"` + SlotNumber *hexutil.Uint64 `json:"slotNumber" rlp:"optional"` } var dec Header if err := json.Unmarshal(input, &dec); err != nil { @@ -169,5 +175,11 @@ func (h *Header) UnmarshalJSON(input []byte) error { if dec.RequestsHash != nil { h.RequestsHash = dec.RequestsHash } + if dec.BlockAccessListHash != nil { + h.BlockAccessListHash = dec.BlockAccessListHash + } + if dec.SlotNumber != nil { + h.SlotNumber = (*uint64)(dec.SlotNumber) + } return nil } diff --git a/core/types/gen_header_rlp.go b/core/types/gen_header_rlp.go index c79aa8a25023..3b7eb2c926d9 100644 --- a/core/types/gen_header_rlp.go +++ b/core/types/gen_header_rlp.go @@ -43,7 +43,9 @@ func (obj *Header) EncodeRLP(_w io.Writer) error { _tmp4 := obj.ExcessBlobGas != nil _tmp5 := obj.ParentBeaconRoot != nil _tmp6 := obj.RequestsHash != nil - if _tmp1 || _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 { + _tmp7 := obj.BlockAccessListHash != nil + _tmp8 := obj.SlotNumber != nil + if _tmp1 || _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.BaseFee == nil { w.Write(rlp.EmptyString) } else { @@ -53,41 +55,55 @@ func (obj *Header) EncodeRLP(_w io.Writer) error { w.WriteBigInt(obj.BaseFee) } } - if _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 { + if _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.WithdrawalsHash == nil { w.Write([]byte{0x80}) } else { w.WriteBytes(obj.WithdrawalsHash[:]) } } - if _tmp3 || _tmp4 || _tmp5 || _tmp6 { + if _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.BlobGasUsed == nil { w.Write([]byte{0x80}) } else { w.WriteUint64((*obj.BlobGasUsed)) } } - if _tmp4 || _tmp5 || _tmp6 { + if _tmp4 || _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.ExcessBlobGas == nil { w.Write([]byte{0x80}) } else { w.WriteUint64((*obj.ExcessBlobGas)) } } - if _tmp5 || _tmp6 { + if _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.ParentBeaconRoot == nil { w.Write([]byte{0x80}) } else { w.WriteBytes(obj.ParentBeaconRoot[:]) } } - if _tmp6 { + if _tmp6 || _tmp7 || _tmp8 { if obj.RequestsHash == nil { w.Write([]byte{0x80}) } else { w.WriteBytes(obj.RequestsHash[:]) } } + if _tmp7 || _tmp8 { + if obj.BlockAccessListHash == nil { + w.Write([]byte{0x80}) + } else { + w.WriteBytes(obj.BlockAccessListHash[:]) + } + } + if _tmp8 { + if obj.SlotNumber == nil { + w.Write([]byte{0x80}) + } else { + w.WriteUint64((*obj.SlotNumber)) + } + } w.ListEnd(_tmp0) return w.Flush() } diff --git a/core/types/hashes.go b/core/types/hashes.go index 22f1f946dc30..db8912a66fb8 100644 --- a/core/types/hashes.go +++ b/core/types/hashes.go @@ -43,9 +43,6 @@ var ( // EmptyRequestsHash is the known hash of an empty request set, sha256(""). EmptyRequestsHash = common.HexToHash("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") - // EmptyVerkleHash is the known hash of an empty verkle trie. - EmptyVerkleHash = common.Hash{} - // EmptyBinaryHash is the known hash of an empty binary trie. EmptyBinaryHash = common.Hash{} ) diff --git a/core/types/log.go b/core/types/log.go index f0e6a3a74596..487ca57b5a87 100644 --- a/core/types/log.go +++ b/core/types/log.go @@ -19,6 +19,8 @@ package types import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" ) //go:generate go run ../../rlp/rlpgen -type Log -out gen_log_rlp.go @@ -62,3 +64,32 @@ type logMarshaling struct { BlockTimestamp hexutil.Uint64 Index hexutil.Uint } + +// EthTransferLog creates and ETH transfer log according to EIP-7708. +// Specification: https://eips.ethereum.org/EIPS/eip-7708 +func EthTransferLog(from, to common.Address, amount *uint256.Int) *Log { + amount32 := amount.Bytes32() + return &Log{ + Address: params.SystemAddress, + Topics: []common.Hash{ + params.EthTransferLogEvent, + common.BytesToHash(from.Bytes()), + common.BytesToHash(to.Bytes()), + }, + Data: amount32[:], + } +} + +// EthBurnLog creates an ETH burn log according to EIP-7708. +// Specification: https://eips.ethereum.org/EIPS/eip-7708 +func EthBurnLog(from common.Address, amount *uint256.Int) *Log { + amount32 := amount.Bytes32() + return &Log{ + Address: params.SystemAddress, + Topics: []common.Hash{ + params.EthBurnLogEvent, + common.BytesToHash(from.Bytes()), + }, + Data: amount32[:], + } +} diff --git a/core/types/receipt.go b/core/types/receipt.go index 5b6669f2741b..ba7d9900f018 100644 --- a/core/types/receipt.go +++ b/core/types/receipt.go @@ -424,3 +424,33 @@ func EncodeBlockReceiptLists(receipts []Receipts) []rlp.RawValue { } return result } + +// SlimReceipt is a wrapper around a Receipt with RLP serialization that omits +// the Bloom field and includes the tx type. Used for era files. +type SlimReceipt Receipt + +type slimReceiptRLP struct { + Type uint8 + StatusEncoding []byte + CumulativeGasUsed uint64 + Logs []*Log +} + +// EncodeRLP implements rlp.Encoder, encoding the receipt as +// [tx-type, post-state-or-status, cumulative-gas, logs]. +func (r *SlimReceipt) EncodeRLP(w io.Writer) error { + data := &slimReceiptRLP{r.Type, (*Receipt)(r).statusEncoding(), r.CumulativeGasUsed, r.Logs} + return rlp.Encode(w, data) +} + +// DecodeRLP implements rlp.Decoder. +func (r *SlimReceipt) DecodeRLP(s *rlp.Stream) error { + var data slimReceiptRLP + if err := s.Decode(&data); err != nil { + return err + } + r.Type = data.Type + r.CumulativeGasUsed = data.CumulativeGasUsed + r.Logs = data.Logs + return (*Receipt)(r).setStatus(data.StatusEncoding) +} diff --git a/core/types/receipt_test.go b/core/types/receipt_test.go index 8f805ff09619..676d9c3d309d 100644 --- a/core/types/receipt_test.go +++ b/core/types/receipt_test.go @@ -512,6 +512,45 @@ func TestReceiptUnmarshalBinary(t *testing.T) { } } +func TestSlimReceiptEncodingDecoding(t *testing.T) { + tests := []*Receipt{ + legacyReceipt, + accessListReceipt, + eip1559Receipt, + { + Type: BlobTxType, + Status: ReceiptStatusSuccessful, + CumulativeGasUsed: 100, + Logs: []*Log{}, + }, + } + for i, want := range tests { + enc, err := rlp.EncodeToBytes((*SlimReceipt)(want)) + if err != nil { + t.Fatalf("test %d: encode error: %v", i, err) + } + got := new(SlimReceipt) + if err := rlp.DecodeBytes(enc, got); err != nil { + t.Fatalf("test %d: decode error: %v", i, err) + } + if got.Type != want.Type { + t.Errorf("test %d: Type mismatch: got %d, want %d", i, got.Type, want.Type) + } + if got.Status != want.Status { + t.Errorf("test %d: Status mismatch: got %d, want %d", i, got.Status, want.Status) + } + if !bytes.Equal(got.PostState, want.PostState) { + t.Errorf("test %d: PostState mismatch: got %x, want %x", i, got.PostState, want.PostState) + } + if got.CumulativeGasUsed != want.CumulativeGasUsed { + t.Errorf("test %d: CumulativeGasUsed mismatch: got %d, want %d", i, got.CumulativeGasUsed, want.CumulativeGasUsed) + } + if len(got.Logs) != len(want.Logs) { + t.Errorf("test %d: Logs length mismatch: got %d, want %d", i, len(got.Logs), len(want.Logs)) + } + } +} + func clearComputedFieldsOnReceipts(receipts []*Receipt) []*Receipt { r := make([]*Receipt, len(receipts)) for i, receipt := range receipts { diff --git a/core/types/transaction.go b/core/types/transaction.go index 6af960b8c3ea..e9bf08daefce 100644 --- a/core/types/transaction.go +++ b/core/types/transaction.go @@ -317,11 +317,15 @@ func (tx *Transaction) To() *common.Address { // Cost returns (gas * gasPrice) + (blobGas * blobGasPrice) + value. func (tx *Transaction) Cost() *big.Int { - total := new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas())) - if tx.Type() == BlobTxType { - total.Add(total, new(big.Int).Mul(tx.BlobGasFeeCap(), new(big.Int).SetUint64(tx.BlobGas()))) + // Avoid allocating copies via tx.GasPrice()/tx.Value(); use inner values directly. + total := new(big.Int).SetUint64(tx.inner.gas()) + total.Mul(total, tx.inner.gasPrice()) + if blobtx, ok := tx.inner.(*BlobTx); ok { + tmp := new(big.Int).SetUint64(blobtx.blobGas()) + tmp.Mul(tmp, blobtx.BlobFeeCap.ToBig()) + total.Add(total, tmp) } - total.Add(total, tx.Value()) + total.Add(total, tx.inner.value()) return total } @@ -396,14 +400,37 @@ func (tx *Transaction) calcEffectiveGasTip(dst *uint256.Int, baseFee *uint256.In return err } +// EffectiveGasTipValue returns the effective gasTip value for the given base fee, +// even if it would be negative. This can be used for sorting purposes. +func (tx *Transaction) EffectiveGasTipValue(baseFee *big.Int) *big.Int { + // min(gasTipCap, gasFeeCap - baseFee) + dst := new(big.Int) + if baseFee == nil { + dst.Set(tx.inner.gasTipCap()) + return dst + } + + dst.Sub(tx.inner.gasFeeCap(), baseFee) // gasFeeCap - baseFee + gasTipCap := tx.inner.gasTipCap() + if gasTipCap.Cmp(dst) < 0 { // gasTipCap < (gasFeeCap - baseFee) + dst.Set(gasTipCap) + } + return dst +} + func (tx *Transaction) EffectiveGasTipCmp(other *Transaction, baseFee *uint256.Int) int { if baseFee == nil { return tx.GasTipCapCmp(other) } // Use more efficient internal method. txTip, otherTip := new(uint256.Int), new(uint256.Int) - tx.calcEffectiveGasTip(txTip, baseFee) - other.calcEffectiveGasTip(otherTip, baseFee) + err1 := tx.calcEffectiveGasTip(txTip, baseFee) + err2 := other.calcEffectiveGasTip(otherTip, baseFee) + if err1 != nil || err2 != nil { + // fall back to big int comparison in case of error + base := baseFee.ToBig() + return tx.EffectiveGasTipValue(base).Cmp(other.EffectiveGasTipValue(base)) + } return txTip.Cmp(otherTip) } diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go index ef8fb194d5f9..5854af07c57e 100644 --- a/core/types/transaction_signing.go +++ b/core/types/transaction_signing.go @@ -282,7 +282,10 @@ func (s *modernSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *bi if tx.inner.chainID().Sign() != 0 && tx.inner.chainID().Cmp(s.chainID) != 0 { return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.inner.chainID(), s.chainID) } - R, S, _ = decodeSignature(sig) + R, S, _, err = decodeSignature(sig) + if err != nil { + return nil, nil, nil, err + } V = big.NewInt(int64(sig[64])) return R, S, V, nil } @@ -327,7 +330,7 @@ func NewEIP2930Signer(chainId *big.Int) Signer { // are replay-protected as well as unprotected homestead transactions. // Deprecated: always use the Signer interface type type EIP155Signer struct { - chainId, chainIdMul *big.Int + chainId *big.Int } func NewEIP155Signer(chainId *big.Int) EIP155Signer { @@ -335,8 +338,7 @@ func NewEIP155Signer(chainId *big.Int) EIP155Signer { chainId = new(big.Int) } return EIP155Signer{ - chainId: chainId, - chainIdMul: new(big.Int).Mul(chainId, big.NewInt(2)), + chainId: chainId, } } @@ -362,7 +364,8 @@ func (s EIP155Signer) Sender(tx *Transaction) (common.Address, error) { return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) } V, R, S := tx.RawSignatureValues() - V = new(big.Int).Sub(V, s.chainIdMul) + V = new(big.Int).Sub(V, s.chainId) + V = new(big.Int).Sub(V, s.chainId) V.Sub(V, big8) return recoverPlain(s.Hash(tx), R, S, V, true) } @@ -373,10 +376,14 @@ func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big if tx.Type() != LegacyTxType { return nil, nil, nil, ErrTxTypeNotSupported } - R, S, V = decodeSignature(sig) + R, S, V, err = decodeSignature(sig) + if err != nil { + return nil, nil, nil, err + } if s.chainId.Sign() != 0 { V = big.NewInt(int64(sig[64] + 35)) - V.Add(V, s.chainIdMul) + V.Add(V, s.chainId) + V.Add(V, s.chainId) } return R, S, V, nil } @@ -442,8 +449,8 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v * if tx.Type() != LegacyTxType { return nil, nil, nil, ErrTxTypeNotSupported } - r, s, v = decodeSignature(sig) - return r, s, v, nil + r, s, v, err = decodeSignature(sig) + return r, s, v, err } // Hash returns the hash to be signed by the sender. @@ -459,14 +466,14 @@ func (fs FrontierSigner) Hash(tx *Transaction) common.Hash { }) } -func decodeSignature(sig []byte) (r, s, v *big.Int) { +func decodeSignature(sig []byte) (r, s, v *big.Int, err error) { if len(sig) != crypto.SignatureLength { - panic(fmt.Sprintf("wrong size for signature: got %d, want %d", len(sig), crypto.SignatureLength)) + return nil, nil, nil, fmt.Errorf("wrong size for signature: got %d, want %d", len(sig), crypto.SignatureLength) } r = new(big.Int).SetBytes(sig[:32]) s = new(big.Int).SetBytes(sig[32:64]) v = new(big.Int).SetBytes([]byte{sig[64] + 27}) - return r, s, v + return r, s, v, nil } func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (common.Address, error) { diff --git a/core/types/transaction_signing_test.go b/core/types/transaction_signing_test.go index 02a65fda1398..252593e87b2b 100644 --- a/core/types/transaction_signing_test.go +++ b/core/types/transaction_signing_test.go @@ -200,3 +200,28 @@ func Benchmark_modernSigner_Equal(b *testing.B) { } } } + +func TestSignatureValuesError(t *testing.T) { + // 1. Setup a valid transaction + tx := NewTransaction(0, common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil) + signer := HomesteadSigner{} + + // 2. Call WithSignature with invalid length sig (not 65 bytes) + invalidSig := make([]byte, 64) + + func() { + defer func() { + if r := recover(); r != nil { + t.Fatalf("Panicked for invalid signature length, expected error: %v", r) + } + }() + _, err := tx.WithSignature(signer, invalidSig) + if err == nil { + t.Fatal("Expected error for invalid signature length, got nil") + } else { + // This is just a sanity check to ensure we got an error, + // the exact error message is verified in unit tests elsewhere if needed. + t.Logf("Got expected error: %v", err) + } + }() +} diff --git a/core/types/tx_blob.go b/core/types/tx_blob.go index bbfd3c98db30..31aadb5419fa 100644 --- a/core/types/tx_blob.go +++ b/core/types/tx_blob.go @@ -118,8 +118,8 @@ func (sc *BlobTxSidecar) ToV1() error { } if sc.Version == BlobSidecarVersion0 { proofs := make([]kzg4844.Proof, 0, len(sc.Blobs)*kzg4844.CellProofsPerBlob) - for _, blob := range sc.Blobs { - cellProofs, err := kzg4844.ComputeCellProofs(&blob) + for i := range sc.Blobs { + cellProofs, err := kzg4844.ComputeCellProofs(&sc.Blobs[i]) if err != nil { return err } diff --git a/core/types/tx_legacy.go b/core/types/tx_legacy.go index 49f0a98809fd..eca9e210af28 100644 --- a/core/types/tx_legacy.go +++ b/core/types/tx_legacy.go @@ -121,7 +121,7 @@ func (tx *LegacyTx) encode(*bytes.Buffer) error { } func (tx *LegacyTx) decode([]byte) error { - panic("decode called on LegacyTx)") + panic("decode called on LegacyTx") } // OBS: This is the post-EIP155 hash, the pre-EIP155 does not contain a chainID. diff --git a/core/types/tx_setcode.go b/core/types/tx_setcode.go index f2281d4ae766..9487c9cc8123 100644 --- a/core/types/tx_setcode.go +++ b/core/types/tx_setcode.go @@ -94,7 +94,10 @@ func SignSetCode(prv *ecdsa.PrivateKey, auth SetCodeAuthorization) (SetCodeAutho if err != nil { return SetCodeAuthorization{}, err } - r, s, _ := decodeSignature(sig) + r, s, _, err := decodeSignature(sig) + if err != nil { + return SetCodeAuthorization{}, err + } return SetCodeAuthorization{ ChainID: auth.ChainID, Address: auth.Address, diff --git a/core/vm/common.go b/core/vm/common.go index 2990f5897248..2d631f8a55f8 100644 --- a/core/vm/common.go +++ b/core/vm/common.go @@ -17,12 +17,43 @@ package vm import ( + "fmt" "math" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" ) +// CheckMaxInitCodeSize checks the size of contract initcode against the protocol-defined limit. +func CheckMaxInitCodeSize(rules *params.Rules, size uint64) error { + if rules.IsAmsterdam { + if size > params.MaxInitCodeSizeAmsterdam { + return fmt.Errorf("%w: code size %v limit %v", ErrMaxInitCodeSizeExceeded, size, params.MaxInitCodeSizeAmsterdam) + } + } else if rules.IsShanghai { + if size > params.MaxInitCodeSize { + return fmt.Errorf("%w: code size %v limit %v", ErrMaxInitCodeSizeExceeded, size, params.MaxInitCodeSize) + } + } + + return nil +} + +// CheckMaxCodeSize checks the size of contract code against the protocol-defined limit. +func CheckMaxCodeSize(rules *params.Rules, size uint64) error { + if rules.IsAmsterdam { + if size > params.MaxCodeSizeAmsterdam { + return fmt.Errorf("%w: code size %v limit %v", ErrMaxCodeSizeExceeded, size, params.MaxCodeSizeAmsterdam) + } + } else if rules.IsEIP158 { + if size > params.MaxCodeSize { + return fmt.Errorf("%w: code size %v limit %v", ErrMaxCodeSizeExceeded, size, params.MaxCodeSize) + } + } + return nil +} + // calcMemSize64 calculates the required memory size, and returns // the size and whether the result overflowed uint64 func calcMemSize64(off, l *uint256.Int) (uint64, bool) { diff --git a/core/vm/contract.go b/core/vm/contract.go index 165ca833f885..45c879c80f20 100644 --- a/core/vm/contract.go +++ b/core/vm/contract.go @@ -42,12 +42,12 @@ type Contract struct { IsDeployment bool IsSystemCall bool - Gas uint64 + Gas GasBudget value *uint256.Int } // NewContract returns a new contract environment for the execution of EVM. -func NewContract(caller common.Address, address common.Address, value *uint256.Int, gas uint64, jumpDests JumpDestCache) *Contract { +func NewContract(caller common.Address, address common.Address, value *uint256.Int, gas GasBudget, jumpDests JumpDestCache) *Contract { // Initialize the jump analysis cache if it's nil, mostly for tests if jumpDests == nil { jumpDests = newMapJumpDests() @@ -126,26 +126,26 @@ func (c *Contract) Caller() common.Address { } // UseGas attempts the use gas and subtracts it and returns true on success -func (c *Contract) UseGas(gas uint64, logger *tracing.Hooks, reason tracing.GasChangeReason) (ok bool) { - if c.Gas < gas { +func (c *Contract) UseGas(cost GasCosts, logger *tracing.Hooks, reason tracing.GasChangeReason) (ok bool) { + prior, ok := c.Gas.Charge(cost) + if !ok { return false } - if logger != nil && logger.OnGasChange != nil && reason != tracing.GasChangeIgnored { - logger.OnGasChange(c.Gas, c.Gas-gas, reason) + if logger.HasGasHook() && reason != tracing.GasChangeIgnored { + logger.EmitGasChange(prior.AsTracing(), c.Gas.AsTracing(), reason) } - c.Gas -= gas return true } -// RefundGas refunds gas to the contract -func (c *Contract) RefundGas(gas uint64, logger *tracing.Hooks, reason tracing.GasChangeReason) { - if gas == 0 { +// RefundGas refunds the leftover gas budget back to the contract. +func (c *Contract) RefundGas(refund GasBudget, logger *tracing.Hooks, reason tracing.GasChangeReason) { + prior, changed := c.Gas.Refund(refund) + if !changed { return } - if logger != nil && logger.OnGasChange != nil && reason != tracing.GasChangeIgnored { - logger.OnGasChange(c.Gas, c.Gas+gas, reason) + if logger.HasGasHook() && reason != tracing.GasChangeIgnored { + logger.EmitGasChange(prior.AsTracing(), c.Gas.AsTracing(), reason) } - c.Gas += gas } // Address returns the contracts address diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 00ddbebd6baf..71cfdbc52773 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -213,7 +213,7 @@ func init() { func activePrecompiledContracts(rules params.Rules) PrecompiledContracts { switch { - case rules.IsVerkle: + case rules.IsUBT: return PrecompiledContractsVerkle case rules.IsOsaka: return PrecompiledContractsOsaka @@ -260,19 +260,25 @@ func ActivePrecompiles(rules params.Rules) []common.Address { // RunPrecompiledContract runs and evaluates the output of a precompiled contract. // It returns // - the returned bytes, -// - the _remaining_ gas, +// - the remaining gas budget, // - any error that occurred -func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64, logger *tracing.Hooks) (ret []byte, remainingGas uint64, err error) { +func RunPrecompiledContract(stateDB StateDB, p PrecompiledContract, address common.Address, input []byte, gas GasBudget, logger *tracing.Hooks, rules params.Rules) (ret []byte, remaining GasBudget, err error) { gasCost := p.RequiredGas(input) - if suppliedGas < gasCost { - return nil, 0, ErrOutOfGas + prior, ok := gas.Charge(GasCosts{RegularGas: gasCost}) + if !ok { + gas.Exhaust() + return nil, gas, ErrOutOfGas } - if logger != nil && logger.OnGasChange != nil { - logger.OnGasChange(suppliedGas, suppliedGas-gasCost, tracing.GasChangeCallPrecompiledContract) + if logger.HasGasHook() { + logger.EmitGasChange(prior.AsTracing(), gas.AsTracing(), tracing.GasChangeCallPrecompiledContract) + } + // Touch the precompile for block-level accessList recording once Amsterdam + // fork is activated. + if rules.IsAmsterdam { + stateDB.Touch(address) } - suppliedGas -= gasCost output, err := p.Run(input) - return output, suppliedGas, err + return output, gas, err } // ecrecover implemented as a native contract. @@ -299,11 +305,11 @@ func (c *ecrecover) Run(input []byte) ([]byte, error) { } // We must make sure not to modify the 'input', so placing the 'v' along with // the signature needs to be done on a new allocation - sig := make([]byte, 65) - copy(sig, input[64:128]) + var sig [65]byte + copy(sig[:], input[64:128]) sig[64] = v // v needs to be at the end for libsecp256k1 - pubKey, err := crypto.Ecrecover(input[:32], sig) + pubKey, err := crypto.Ecrecover(input[:32], sig[:]) // make sure the public key is a valid one if err != nil { return nil, nil diff --git a/core/vm/contracts_fuzz_test.go b/core/vm/contracts_fuzz_test.go index 1e5cc8007471..988cdb91f222 100644 --- a/core/vm/contracts_fuzz_test.go +++ b/core/vm/contracts_fuzz_test.go @@ -20,6 +20,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" ) func FuzzPrecompiledContracts(f *testing.F) { @@ -36,7 +37,7 @@ func FuzzPrecompiledContracts(f *testing.F) { return } inWant := string(input) - RunPrecompiledContract(p, input, gas, nil) + RunPrecompiledContract(nil, p, a, input, NewGasBudget(gas), nil, params.Rules{}) if inHave := string(input); inWant != inHave { t.Errorf("Precompiled %v modified input data", a) } diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go index 51bd7101ff4b..e7841c8552e7 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -25,6 +25,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" ) // precompiledTest defines the input/output pairs for precompiled contract tests. @@ -99,7 +100,7 @@ func testPrecompiled(addr string, test precompiledTest, t *testing.T) { in := common.Hex2Bytes(test.Input) gas := p.RequiredGas(in) t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) { - if res, _, err := RunPrecompiledContract(p, in, gas, nil); err != nil { + if res, _, err := RunPrecompiledContract(nil, p, common.HexToAddress(addr), in, NewGasBudget(gas), nil, params.Rules{}); err != nil { t.Error(err) } else if common.Bytes2Hex(res) != test.Expected { t.Errorf("Expected %v, got %v", test.Expected, common.Bytes2Hex(res)) @@ -121,7 +122,7 @@ func testPrecompiledOOG(addr string, test precompiledTest, t *testing.T) { gas := test.Gas - 1 t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) { - _, _, err := RunPrecompiledContract(p, in, gas, nil) + _, _, err := RunPrecompiledContract(nil, p, common.HexToAddress(addr), in, NewGasBudget(gas), nil, params.Rules{}) if err.Error() != "out of gas" { t.Errorf("Expected error [out of gas], got [%v]", err) } @@ -138,7 +139,7 @@ func testPrecompiledFailure(addr string, test precompiledFailureTest, t *testing in := common.Hex2Bytes(test.Input) gas := p.RequiredGas(in) t.Run(test.Name, func(t *testing.T) { - _, _, err := RunPrecompiledContract(p, in, gas, nil) + _, _, err := RunPrecompiledContract(nil, p, common.HexToAddress(addr), in, NewGasBudget(gas), nil, params.Rules{}) if err.Error() != test.ExpectedError { t.Errorf("Expected error [%v], got [%v]", test.ExpectedError, err) } @@ -169,7 +170,7 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) { start := time.Now() for bench.Loop() { copy(data, in) - res, _, err = RunPrecompiledContract(p, data, reqGas, nil) + res, _, err = RunPrecompiledContract(nil, p, common.HexToAddress(addr), data, NewGasBudget(reqGas), nil, params.Rules{}) } elapsed := uint64(time.Since(start)) if elapsed < 1 { diff --git a/core/vm/eip7610.go b/core/vm/eip7610.go new file mode 100644 index 000000000000..883f4502b53b --- /dev/null +++ b/core/vm/eip7610.go @@ -0,0 +1,98 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package vm + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" +) + +// eip7610Accounts lists the addresses eligible for contract deployment +// rejection under EIP-7610, keyed by chain ID. Only networks that adopted +// EIP-158 after genesis need an entry; all others have no pre-existing +// address collisions to guard against. +var eip7610Accounts = map[uint64][]common.Address{ + params.MainnetChainConfig.ChainID.Uint64(): { + common.HexToAddress("0x02820E4bEE488C40f7455fDCa53125565148708F"), + common.HexToAddress("0x14725085d004f1b10Ee07234A4ab28c5Ad2a7b9E"), + common.HexToAddress("0x19272418753B90D9a3E3Efc8430b1612c55fcB3A"), + common.HexToAddress("0x2c081Ed1949D7Dd9447F9d96e509befE576D4461"), + common.HexToAddress("0x3311c08066580cb906a7287b6786E504C2EBD09f"), + common.HexToAddress("0x361d7a60b43587c7f6bbA4f9fD9642747F65210A"), + common.HexToAddress("0x40490C9c468622d5c89646D6F3097F8Eaf80c411"), + common.HexToAddress("0x4d149EB99BDEEFC1f858f8fd22289C6beAE99f2c"), + common.HexToAddress("0x5071cb62aA170b7f66b26cae8004d90E6078Bb1E"), + common.HexToAddress("0x50b1497068bAE652Df3562EB8Ea7677ff84477FA"), + common.HexToAddress("0x5983C6aC846DcF85fbBC4303F43eb91C379F79ae"), + common.HexToAddress("0x59EC0410867828E3b8c23Dd8A29d9796ef523b17"), + common.HexToAddress("0x5cC182faBFb81A056B6080d4200BC5150673D06f"), + common.HexToAddress("0x6f156dbf8Ed30e53F7C9Df73144E69f65cBB7E94"), + common.HexToAddress("0x7D6ae067De8d44Ae1A08750e7D626D61A623C44A"), + common.HexToAddress("0x8398fF6c618e9515468c1c4b198d53666CBe8462"), + common.HexToAddress("0xA21B22389bfC1cd6Bc7BA19A4Fc96aDC3D0FE074"), + common.HexToAddress("0xaDD92e0650457C5Db0c4c08cbf7cA580175d33d2"), + common.HexToAddress("0xAE3703584494Ade958AD27EC2d289b7a67c19E90"), + common.HexToAddress("0xb619f45637C39Ca49A41ac64c11637A0A194455E"), + common.HexToAddress("0xD8253352f6044cFE55bcC0748C3FA37b7dF81F98"), + common.HexToAddress("0xDB7C577B93Baeb56dAB50aF4D6f86F99A06B96a2"), + common.HexToAddress("0xdE425ad4B8d2d9E0E12F65CBcD6D55F447B44083"), + common.HexToAddress("0xe62dc49C92fA799033644d2A9aFD7e3BAbE5A80a"), + common.HexToAddress("0xF468BcBC4a0BFDB06336E773382C5202E674db71"), + common.HexToAddress("0xF4a835ec1364809003dE3925685F24cD360bdffe"), + common.HexToAddress("0xFc4465F84B29a1F8794Dc753F41BeF1F4b025ED2"), + common.HexToAddress("0xfeE7707fa4b8C0A923A0E40399Db3e7Ce26069C6"), + }, +} + +// eip7610AccountSets is the membership-lookup form of eip7610Accounts, +// built once at init for O(1) containment checks. +var eip7610AccountSets = func() map[uint64]map[common.Address]struct{} { + sets := make(map[uint64]map[common.Address]struct{}, len(eip7610Accounts)) + for chainID, addrs := range eip7610Accounts { + set := make(map[common.Address]struct{}, len(addrs)) + for _, a := range addrs { + set[a] = struct{}{} + } + sets[chainID] = set + } + return sets +}() + +// isEIP7610RejectedAccount reports whether the account identified by the +// address is eligible for contract deployment rejection due to having +// non-empty storage. +// +// Note that, historically, there has been no case where a contract deployment +// targets an already existing account in Ethereum. This situation would only +// occur in the event of an address collision, which is extremely unlikely. +// +// This check is skipped for blocks prior to EIP-158, serving as a safeguard +// against potential address collisions in the future. Chains that are not +// registered in eip7610Accounts are assumed to have no rejected accounts, +// and false is returned for them. +func isEIP7610RejectedAccount(chainID *big.Int, addr common.Address, isEIP158 bool) bool { + // Short circuit for blocks prior to EIP-158. + if !isEIP158 { + return false + } + // Unknown chains fall through as a nil set; the second lookup then + // returns the zero value (false), treating the chain as empty. + _, exist := eip7610AccountSets[chainID.Uint64()][addr] + return exist +} diff --git a/core/vm/eip7610_test.go b/core/vm/eip7610_test.go new file mode 100644 index 000000000000..f881020c5c62 --- /dev/null +++ b/core/vm/eip7610_test.go @@ -0,0 +1,62 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package vm + +import ( + "fmt" + "slices" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/params" +) + +func Example_mainnetEIP7610Accounts() { + list := slices.Clone(eip7610Accounts[params.MainnetChainConfig.ChainID.Uint64()]) + slices.SortFunc(list, common.Address.Cmp) + for _, addr := range list { + fmt.Println(addr.Hex()) + } + // Output: + // 0x02820E4bEE488C40f7455fDCa53125565148708F + // 0x14725085d004f1b10Ee07234A4ab28c5Ad2a7b9E + // 0x19272418753B90D9a3E3Efc8430b1612c55fcB3A + // 0x2c081Ed1949D7Dd9447F9d96e509befE576D4461 + // 0x3311c08066580cb906a7287b6786E504C2EBD09f + // 0x361d7a60b43587c7f6bbA4f9fD9642747F65210A + // 0x40490C9c468622d5c89646D6F3097F8Eaf80c411 + // 0x4d149EB99BDEEFC1f858f8fd22289C6beAE99f2c + // 0x5071cb62aA170b7f66b26cae8004d90E6078Bb1E + // 0x50b1497068bAE652Df3562EB8Ea7677ff84477FA + // 0x5983C6aC846DcF85fbBC4303F43eb91C379F79ae + // 0x59EC0410867828E3b8c23Dd8A29d9796ef523b17 + // 0x5cC182faBFb81A056B6080d4200BC5150673D06f + // 0x6f156dbf8Ed30e53F7C9Df73144E69f65cBB7E94 + // 0x7D6ae067De8d44Ae1A08750e7D626D61A623C44A + // 0x8398fF6c618e9515468c1c4b198d53666CBe8462 + // 0xA21B22389bfC1cd6Bc7BA19A4Fc96aDC3D0FE074 + // 0xaDD92e0650457C5Db0c4c08cbf7cA580175d33d2 + // 0xAE3703584494Ade958AD27EC2d289b7a67c19E90 + // 0xb619f45637C39Ca49A41ac64c11637A0A194455E + // 0xD8253352f6044cFE55bcC0748C3FA37b7dF81F98 + // 0xDB7C577B93Baeb56dAB50aF4D6f86F99A06B96a2 + // 0xdE425ad4B8d2d9E0E12F65CBcD6D55F447B44083 + // 0xe62dc49C92fA799033644d2A9aFD7e3BAbE5A80a + // 0xF468BcBC4a0BFDB06336E773382C5202E674db71 + // 0xF4a835ec1364809003dE3925685F24cD360bdffe + // 0xFc4465F84B29a1F8794Dc753F41BeF1F4b025ED2 + // 0xfeE7707fa4b8C0A923A0E40399Db3e7Ce26069C6 +} diff --git a/core/vm/eips.go b/core/vm/eips.go index dfcac4b93029..33af8fd4fd9d 100644 --- a/core/vm/eips.go +++ b/core/vm/eips.go @@ -24,7 +24,6 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/params" - "github.com/holiman/uint256" ) var activators = map[int]func(*JumpTable){ @@ -43,6 +42,7 @@ var activators = map[int]func(*JumpTable){ 7702: enable7702, 7939: enable7939, 8024: enable8024, + 7843: enable7843, } // EnableEIP enables the given EIP on the config. @@ -91,8 +91,7 @@ func enable1884(jt *JumpTable) { } func opSelfBalance(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - balance := evm.StateDB.GetBalance(scope.Contract.Address()) - scope.Stack.push(balance) + scope.Stack.get().Set(evm.StateDB.GetBalance(scope.Contract.Address())) return nil, nil } @@ -110,8 +109,7 @@ func enable1344(jt *JumpTable) { // opChainID implements CHAINID opcode func opChainID(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - chainId, _ := uint256.FromBig(evm.chainConfig.ChainID) - scope.Stack.push(chainId) + scope.Stack.get().SetFromBig(evm.chainConfig.ChainID) return nil, nil } @@ -221,8 +219,7 @@ func opTstore(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // opBaseFee implements BASEFEE opcode func opBaseFee(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - baseFee, _ := uint256.FromBig(evm.Context.BaseFee) - scope.Stack.push(baseFee) + scope.Stack.get().SetFromBig(evm.Context.BaseFee) return nil, nil } @@ -239,7 +236,7 @@ func enable3855(jt *JumpTable) { // opPush0 implements the PUSH0 opcode func opPush0(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int)) + scope.Stack.get().Clear() return nil, nil } @@ -290,8 +287,7 @@ func opBlobHash(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // opBlobBaseFee implements BLOBBASEFEE opcode func opBlobBaseFee(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - blobBaseFee, _ := uint256.FromBig(evm.Context.BlobBaseFee) - scope.Stack.push(blobBaseFee) + scope.Stack.get().SetFromBig(evm.Context.BlobBaseFee) return nil, nil } @@ -380,8 +376,8 @@ func opExtCodeCopyEIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, er addr := common.Address(a.Bytes20()) code := evm.StateDB.GetCode(addr) paddedCodeCopy, copyOffset, nonPaddedCopyLength := getDataAndAdjustedBounds(code, uint64CodeOffset, length.Uint64()) - consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(addr, copyOffset, nonPaddedCopyLength, uint64(len(code)), false, scope.Contract.Gas) - scope.Contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeUnspecified) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(addr, copyOffset, nonPaddedCopyLength, uint64(len(code)), false, scope.Contract.Gas.RegularGas) + scope.Contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas } @@ -396,24 +392,24 @@ func opExtCodeCopyEIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, er func opPush1EIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { var ( codeLen = uint64(len(scope.Contract.Code)) - integer = new(uint256.Int) + elem = scope.Stack.get() ) *pc += 1 if *pc < codeLen { - scope.Stack.push(integer.SetUint64(uint64(scope.Contract.Code[*pc]))) + elem.SetUint64(uint64(scope.Contract.Code[*pc])) if !scope.Contract.IsDeployment && !scope.Contract.IsSystemCall && *pc%31 == 0 { // touch next chunk if PUSH1 is at the boundary. if so, *pc has // advanced past this boundary. contractAddr := scope.Contract.Address() - consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(contractAddr, *pc+1, uint64(1), uint64(len(scope.Contract.Code)), false, scope.Contract.Gas) - scope.Contract.UseGas(wanted, evm.Config.Tracer, tracing.GasChangeUnspecified) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(contractAddr, *pc+1, uint64(1), uint64(len(scope.Contract.Code)), false, scope.Contract.Gas.RegularGas) + scope.Contract.UseGas(GasCosts{RegularGas: wanted}, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas } } } else { - scope.Stack.push(integer.Clear()) + elem.Clear() } return nil, nil } @@ -425,17 +421,16 @@ func makePushEIP4762(size uint64, pushByteSize int) executionFunc { start = min(codeLen, int(*pc+1)) end = min(codeLen, start+pushByteSize) ) - scope.Stack.push(new(uint256.Int).SetBytes( + scope.Stack.get().SetBytes( common.RightPadBytes( scope.Contract.Code[start:end], pushByteSize, - )), - ) + )) if !scope.Contract.IsDeployment && !scope.Contract.IsSystemCall { contractAddr := scope.Contract.Address() - consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(contractAddr, uint64(start), uint64(pushByteSize), uint64(len(scope.Contract.Code)), false, scope.Contract.Gas) - scope.Contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeUnspecified) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(contractAddr, uint64(start), uint64(pushByteSize), uint64(len(scope.Contract.Code)), false, scope.Contract.Gas.RegularGas) + scope.Contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas } @@ -579,3 +574,19 @@ func enable7702(jt *JumpTable) { jt[STATICCALL].dynamicGas = gasStaticCallEIP7702 jt[DELEGATECALL].dynamicGas = gasDelegateCallEIP7702 } + +// opSlotNum enables the SLOTNUM opcode +func opSlotNum(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { + scope.Stack.get().SetUint64(evm.Context.SlotNum) + return nil, nil +} + +// enable7843 enables the SLOTNUM opcode as specified in EIP-7843. +func enable7843(jt *JumpTable) { + jt[SLOTNUM] = &operation{ + execute: opSlotNum, + constantGas: GasQuickStep, + minStack: minStack(0, 1), + maxStack: maxStack(0, 1), + } +} diff --git a/core/vm/errors.go b/core/vm/errors.go index e33c9fcb853c..b6235d44a6fe 100644 --- a/core/vm/errors.go +++ b/core/vm/errors.go @@ -76,10 +76,16 @@ func (e ErrStackOverflow) Unwrap() error { // ErrInvalidOpCode wraps an evm error when an invalid opcode is encountered. type ErrInvalidOpCode struct { - opcode OpCode + opcode OpCode + operand *byte } -func (e *ErrInvalidOpCode) Error() string { return fmt.Sprintf("invalid opcode: %s", e.opcode) } +func (e *ErrInvalidOpCode) Error() string { + if e.operand != nil { + return fmt.Sprintf("invalid opcode: %s (operand: 0x%02x)", e.opcode, *e.operand) + } + return fmt.Sprintf("invalid opcode: %s", e.opcode) +} // rpcError is the same interface as the one defined in rpc/errors.go // but we do not want to depend on rpc package here so we redefine it. diff --git a/core/vm/evm.go b/core/vm/evm.go index 8975c791c842..9fe6faa3a2fa 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -35,7 +35,7 @@ type ( // CanTransferFunc is the signature of a transfer guard function CanTransferFunc func(StateDB, common.Address, *uint256.Int) bool // TransferFunc is the signature of a transfer function - TransferFunc func(StateDB, common.Address, common.Address, *uint256.Int) + TransferFunc func(StateDB, common.Address, common.Address, *uint256.Int, *params.Rules) // GetHashFunc returns the n'th block hash in the blockchain // and is used by the BLOCKHASH EVM op code. GetHashFunc func(uint64) common.Hash @@ -66,6 +66,7 @@ type BlockContext struct { BaseFee *big.Int // Provides information for BASEFEE (0 if vm runs with NoBaseFee flag and 0 gas price) BlobBaseFee *big.Int // Provides information for BLOBBASEFEE (0 if vm runs with NoBaseFee flag and 0 blob gas price) Random *common.Hash // Provides information for PREVRANDAO + SlotNum uint64 // Provides information for SLOTNUM } // TxContext provides the EVM with information about a transaction. @@ -73,9 +74,8 @@ type BlockContext struct { type TxContext struct { // Message information Origin common.Address // Provides information for ORIGIN - GasPrice *big.Int // Provides information for GASPRICE (and is used to zero the basefee if NoBaseFee is set) + GasPrice *uint256.Int // Provides information for GASPRICE (and is used to zero the basefee if NoBaseFee is set) BlobHashes []common.Hash // Provides information for BLOBHASH - BlobFeeCap *big.Int // Is used to zero the blobbasefee if NoBaseFee is set AccessEvents *state.AccessEvents // Capture all state accesses for this tx } @@ -125,11 +125,10 @@ type EVM struct { // jumpDests stores results of JUMPDEST analysis. jumpDests JumpDestCache - hasher crypto.KeccakState // Keccak256 hasher instance shared across opcodes - hasherBuf common.Hash // Keccak256 hasher result array shared across opcodes - readOnly bool // Whether to throw on stateful modifications returnData []byte // Last CALL's return data for subsequent reuse + + arena *stackArena } // NewEVM constructs an EVM instance with the supplied block context, state @@ -144,14 +143,16 @@ func NewEVM(blockCtx BlockContext, statedb StateDB, chainConfig *params.ChainCon chainConfig: chainConfig, chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil, blockCtx.Time), jumpDests: newMapJumpDests(), - hasher: crypto.NewKeccakState(), + arena: newArena(), } evm.precompiles = activePrecompiledContracts(evm.chainRules) switch { + case evm.chainRules.IsAmsterdam: + evm.table = &amsterdamInstructionSet case evm.chainRules.IsOsaka: evm.table = &osakaInstructionSet - case evm.chainRules.IsVerkle: + case evm.chainRules.IsUBT: // TODO replace with proper instruction set when fork is specified evm.table = &verkleInstructionSet case evm.chainRules.IsPrague: @@ -214,7 +215,7 @@ func (evm *EVM) SetJumpDestCache(jumpDests JumpDestCache) { // This is not threadsafe and should only be done very cautiously. func (evm *EVM) SetTxContext(txCtx TxContext) { if evm.chainRules.IsEIP4762 { - txCtx.AccessEvents = state.NewAccessEvents(evm.StateDB.PointCache()) + txCtx.AccessEvents = state.NewAccessEvents() } evm.TxContext = txCtx } @@ -225,6 +226,12 @@ func (evm *EVM) Cancel() { evm.abort.Store(true) } +// Release returns some memory allocated by the EVM, should be called after the EVM was used +// for the last time. Not necessary, but an improvement. +func (evm *EVM) Release() { + returnStack(evm.arena) +} + // Cancelled returns true if Cancel has been called func (evm *EVM) Cancelled() bool { return evm.abort.Load() @@ -238,25 +245,26 @@ func isSystemCall(caller common.Address) bool { // parameters. It also handles any necessary value transfer required and takse // the necessary steps to create accounts and reverses the state in case of an // execution error or failed value transfer. -func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, gas uint64, value *uint256.Int) (ret []byte, leftOverGas uint64, err error) { +func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, gas GasBudget, value *uint256.Int) (ret []byte, leftOverGas GasBudget, err error) { // Capture the tracer start/end events in debug mode if evm.Config.Tracer != nil { - evm.captureBegin(evm.depth, CALL, caller, addr, input, gas, value.ToBig()) + evm.captureBegin(evm.depth, CALL, caller, addr, input, gas.RegularGas, value.ToBig()) defer func(startGas uint64) { - evm.captureEnd(evm.depth, startGas, leftOverGas, ret, err) - }(gas) + evm.captureEnd(evm.depth, startGas, leftOverGas.RegularGas, ret, err) + }(gas.RegularGas) } // Fail if we're trying to execute above the call depth limit if evm.depth > int(params.CallCreateDepth) { return nil, gas, ErrDepth } - // Fail if we're trying to transfer more than the available balance - if !value.IsZero() && !evm.Context.CanTransfer(evm.StateDB, caller, value) { + syscall := isSystemCall(caller) + + // Fail if we're trying to transfer more than the available balance. + if !syscall && !value.IsZero() && !evm.Context.CanTransfer(evm.StateDB, caller, value) { return nil, gas, ErrInsufficientBalance } snapshot := evm.StateDB.Snapshot() p, isPrecompile := evm.precompile(addr) - if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP4762 && !isSystemCall(caller) { // Add proof of absence to witness @@ -266,12 +274,12 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g // list in write mode. If there is enough gas paying for the addition of the code // hash leaf to the access list, then account creation will proceed unimpaired. // Thus, only pay for the creation of the code hash leaf here. - wgas := evm.AccessEvents.CodeHashGas(addr, true, gas, false) - if gas < wgas { + wgas := evm.AccessEvents.CodeHashGas(addr, true, gas.RegularGas, false) + if _, ok := gas.Charge(GasCosts{RegularGas: wgas}); !ok { evm.StateDB.RevertToSnapshot(snapshot) - return nil, 0, ErrOutOfGas + gas.Exhaust() + return nil, gas, ErrOutOfGas } - gas -= wgas } if !isPrecompile && evm.chainRules.IsEIP158 && value.IsZero() { @@ -280,10 +288,15 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g } evm.StateDB.CreateAccount(addr) } - evm.Context.Transfer(evm.StateDB, caller, addr, value) + // Perform the value transfer only in non-syscall mode. + // Calling this is required even for zero-value transfers, + // to ensure the state clearing mechanism is applied. + if !syscall { + evm.Context.Transfer(evm.StateDB, caller, addr, value, &evm.chainRules) + } if isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(evm.StateDB, p, addr, input, gas, evm.Config.Tracer, evm.chainRules) } else { // Initialise a new contract and set the code that is to be used by the EVM. code := evm.resolveCode(addr) @@ -304,11 +317,10 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != ErrExecutionReverted { - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } - - gas = 0 + gas.Exhaust() } // TODO: consider clearing up unused snapshots: //} else { @@ -324,13 +336,13 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g // // CallCode differs from Call in the sense that it executes the given address' // code with the caller as context. -func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byte, gas uint64, value *uint256.Int) (ret []byte, leftOverGas uint64, err error) { +func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byte, gas GasBudget, value *uint256.Int) (ret []byte, leftOverGas GasBudget, err error) { // Invoke tracer hooks that signal entering/exiting a call frame if evm.Config.Tracer != nil { - evm.captureBegin(evm.depth, CALLCODE, caller, addr, input, gas, value.ToBig()) + evm.captureBegin(evm.depth, CALLCODE, caller, addr, input, gas.RegularGas, value.ToBig()) defer func(startGas uint64) { - evm.captureEnd(evm.depth, startGas, leftOverGas, ret, err) - }(gas) + evm.captureEnd(evm.depth, startGas, leftOverGas.RegularGas, ret, err) + }(gas.RegularGas) } // Fail if we're trying to execute above the call depth limit if evm.depth > int(params.CallCreateDepth) { @@ -347,7 +359,7 @@ func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byt // It is allowed to call precompiles, even via delegatecall if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(evm.StateDB, p, addr, input, gas, evm.Config.Tracer, evm.chainRules) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -359,10 +371,10 @@ func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byt if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != ErrExecutionReverted { - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } - gas = 0 + gas.Exhaust() } } return ret, gas, err @@ -373,14 +385,14 @@ func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byt // // DelegateCall differs from CallCode in the sense that it executes the given address' // code with the caller as context and the caller is set to the caller of the caller. -func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, addr common.Address, input []byte, gas uint64, value *uint256.Int) (ret []byte, leftOverGas uint64, err error) { +func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, addr common.Address, input []byte, gas GasBudget, value *uint256.Int) (ret []byte, leftOverGas GasBudget, err error) { // Invoke tracer hooks that signal entering/exiting a call frame if evm.Config.Tracer != nil { // DELEGATECALL inherits value from parent call - evm.captureBegin(evm.depth, DELEGATECALL, caller, addr, input, gas, value.ToBig()) + evm.captureBegin(evm.depth, DELEGATECALL, caller, addr, input, gas.RegularGas, value.ToBig()) defer func(startGas uint64) { - evm.captureEnd(evm.depth, startGas, leftOverGas, ret, err) - }(gas) + evm.captureEnd(evm.depth, startGas, leftOverGas.RegularGas, ret, err) + }(gas.RegularGas) } // Fail if we're trying to execute above the call depth limit if evm.depth > int(params.CallCreateDepth) { @@ -390,7 +402,7 @@ func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, // It is allowed to call precompiles, even via delegatecall if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(evm.StateDB, p, addr, input, gas, evm.Config.Tracer, evm.chainRules) } else { // Initialise a new contract and make initialise the delegate values // @@ -403,10 +415,10 @@ func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != ErrExecutionReverted { - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } - gas = 0 + gas.Exhaust() } } return ret, gas, err @@ -416,13 +428,13 @@ func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, // as parameters while disallowing any modifications to the state during the call. // Opcodes that attempt to perform such modifications will result in exceptions // instead of performing the modifications. -func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) { +func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []byte, gas GasBudget) (ret []byte, leftOverGas GasBudget, err error) { // Invoke tracer hooks that signal entering/exiting a call frame if evm.Config.Tracer != nil { - evm.captureBegin(evm.depth, STATICCALL, caller, addr, input, gas, nil) + evm.captureBegin(evm.depth, STATICCALL, caller, addr, input, gas.RegularGas, nil) defer func(startGas uint64) { - evm.captureEnd(evm.depth, startGas, leftOverGas, ret, err) - }(gas) + evm.captureEnd(evm.depth, startGas, leftOverGas.RegularGas, ret, err) + }(gas.RegularGas) } // Fail if we're trying to execute above the call depth limit if evm.depth > int(params.CallCreateDepth) { @@ -442,7 +454,7 @@ func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []b evm.StateDB.AddBalance(addr, new(uint256.Int), tracing.BalanceChangeTouchAccount) if p, isPrecompile := evm.precompile(addr); isPrecompile { - ret, gas, err = RunPrecompiledContract(p, input, gas, evm.Config.Tracer) + ret, gas, err = RunPrecompiledContract(evm.StateDB, p, addr, input, gas, evm.Config.Tracer, evm.chainRules) } else { // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -458,23 +470,22 @@ func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []b if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != ErrExecutionReverted { - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } - - gas = 0 + gas.Exhaust() } } return ret, gas, err } // create creates a new contract using code as deployment code. -func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *uint256.Int, address common.Address, typ OpCode) (ret []byte, createAddress common.Address, leftOverGas uint64, err error) { +func (evm *EVM) create(caller common.Address, code []byte, gas GasBudget, value *uint256.Int, address common.Address, typ OpCode) (ret []byte, createAddress common.Address, leftOverGas GasBudget, err error) { if evm.Config.Tracer != nil { - evm.captureBegin(evm.depth, typ, caller, address, code, gas, value.ToBig()) + evm.captureBegin(evm.depth, typ, caller, address, code, gas.RegularGas, value.ToBig()) defer func(startGas uint64) { - evm.captureEnd(evm.depth, startGas, leftOverGas, ret, err) - }(gas) + evm.captureEnd(evm.depth, startGas, leftOverGas.RegularGas, ret, err) + }(gas.RegularGas) } // Depth check execution. Fail if we're trying to execute above the // limit. @@ -492,14 +503,15 @@ func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *ui // Charge the contract creation init gas in verkle mode if evm.chainRules.IsEIP4762 { - statelessGas := evm.AccessEvents.ContractCreatePreCheckGas(address, gas) - if statelessGas > gas { - return nil, common.Address{}, 0, ErrOutOfGas + statelessGas := evm.AccessEvents.ContractCreatePreCheckGas(address, gas.RegularGas) + prior, ok := gas.Charge(GasCosts{RegularGas: statelessGas}) + if !ok { + gas.Exhaust() + return nil, common.Address{}, gas, ErrOutOfGas } - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, gas-statelessGas, tracing.GasChangeWitnessContractCollisionCheck) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(prior.AsTracing(), gas.AsTracing(), tracing.GasChangeWitnessContractCollisionCheck) } - gas = gas - statelessGas } // We add this to the access list _before_ taking a snapshot. Even if the @@ -513,14 +525,14 @@ func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *ui // - the code is non-empty // - the storage is non-empty contractHash := evm.StateDB.GetCodeHash(address) - storageRoot := evm.StateDB.GetStorageRoot(address) if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != types.EmptyCodeHash) || // non-empty code - (storageRoot != (common.Hash{}) && storageRoot != types.EmptyRootHash) { // non-empty storage - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) + isEIP7610RejectedAccount(evm.ChainConfig().ChainID, address, evm.chainRules.IsEIP158) { + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } - return nil, common.Address{}, 0, ErrContractAddressCollision + gas.Exhaust() + return nil, common.Address{}, gas, ErrContractAddressCollision } // Create a new account on the state only if the object was not present. // It might be possible the contract code is deployed to a pre-existent @@ -540,16 +552,17 @@ func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *ui } // Charge the contract creation init gas in verkle mode if evm.chainRules.IsEIP4762 { - consumed, wanted := evm.AccessEvents.ContractCreateInitGas(address, gas) + consumed, wanted := evm.AccessEvents.ContractCreateInitGas(address, gas.RegularGas) if consumed < wanted { - return nil, common.Address{}, 0, ErrOutOfGas + gas.Exhaust() + return nil, common.Address{}, gas, ErrOutOfGas } - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, gas-consumed, tracing.GasChangeWitnessContractInit) + prior, _ := gas.Charge(GasCosts{RegularGas: consumed}) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(prior.AsTracing(), gas.AsTracing(), tracing.GasChangeWitnessContractInit) } - gas = gas - consumed } - evm.Context.Transfer(evm.StateDB, caller, address, value) + evm.Context.Transfer(evm.StateDB, caller, address, value, &evm.chainRules) // Initialise a new contract and set the code that is to be used by the EVM. // The contract is a scoped environment for this execution context only. @@ -564,7 +577,7 @@ func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *ui if err != nil && (evm.chainRules.IsHomestead || err != ErrCodeStoreOutOfGas) { evm.StateDB.RevertToSnapshot(snapshot) if err != ErrExecutionReverted { - contract.UseGas(contract.Gas, evm.Config.Tracer, tracing.GasChangeCallFailedExecution) + contract.UseGas(GasCosts{RegularGas: contract.Gas.RegularGas}, evm.Config.Tracer, tracing.GasChangeCallFailedExecution) } } return ret, address, contract.Gas, err @@ -579,8 +592,8 @@ func (evm *EVM) initNewContract(contract *Contract, address common.Address) ([]b } // Check whether the max code size has been exceeded, assign err if the case. - if evm.chainRules.IsEIP158 && len(ret) > params.MaxCodeSize { - return ret, ErrMaxCodeSizeExceeded + if err := CheckMaxCodeSize(&evm.chainRules, uint64(len(ret))); err != nil { + return ret, err } // Reject code starting with 0xEF if EIP-3541 is enabled. @@ -590,12 +603,12 @@ func (evm *EVM) initNewContract(contract *Contract, address common.Address) ([]b if !evm.chainRules.IsEIP4762 { createDataGas := uint64(len(ret)) * params.CreateDataGas - if !contract.UseGas(createDataGas, evm.Config.Tracer, tracing.GasChangeCallCodeStorage) { + if !contract.UseGas(GasCosts{RegularGas: createDataGas}, evm.Config.Tracer, tracing.GasChangeCallCodeStorage) { return ret, ErrCodeStoreOutOfGas } } else { - consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(address, 0, uint64(len(ret)), uint64(len(ret)), true, contract.Gas) - contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(address, 0, uint64(len(ret)), uint64(len(ret)), true, contract.Gas.RegularGas) + contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) if len(ret) > 0 && (consumed < wanted) { return ret, ErrCodeStoreOutOfGas } @@ -608,7 +621,7 @@ func (evm *EVM) initNewContract(contract *Contract, address common.Address) ([]b } // Create creates a new contract using code as deployment code. -func (evm *EVM) Create(caller common.Address, code []byte, gas uint64, value *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) { +func (evm *EVM) Create(caller common.Address, code []byte, gas GasBudget, value *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas GasBudget, err error) { contractAddr = crypto.CreateAddress(caller, evm.StateDB.GetNonce(caller)) return evm.create(caller, code, gas, value, contractAddr, CREATE) } @@ -617,8 +630,8 @@ func (evm *EVM) Create(caller common.Address, code []byte, gas uint64, value *ui // // The different between Create2 with Create is Create2 uses keccak256(0xff ++ msg.sender ++ salt ++ keccak256(init_code))[12:] // instead of the usual sender-and-nonce-hash as the address where the contract is initialized at. -func (evm *EVM) Create2(caller common.Address, code []byte, gas uint64, endowment *uint256.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) { - inithash := crypto.HashData(evm.hasher, code) +func (evm *EVM) Create2(caller common.Address, code []byte, gas GasBudget, endowment *uint256.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas GasBudget, err error) { + inithash := crypto.Keccak256Hash(code) contractAddr = crypto.CreateAddress2(caller, salt.Bytes32(), inithash[:]) return evm.create(caller, code, gas, endowment, contractAddr, CREATE2) } @@ -660,15 +673,17 @@ func (evm *EVM) captureBegin(depth int, typ OpCode, from common.Address, to comm if tracer.OnEnter != nil { tracer.OnEnter(depth, byte(typ), from, to, input, startGas, value) } - if tracer.OnGasChange != nil { - tracer.OnGasChange(0, startGas, tracing.GasChangeCallInitialBalance) + if tracer.HasGasHook() { + initial := NewGasBudget(startGas) + tracer.EmitGasChange(tracing.Gas{}, initial.AsTracing(), tracing.GasChangeCallInitialBalance) } } func (evm *EVM) captureEnd(depth int, startGas uint64, leftOverGas uint64, ret []byte, err error) { tracer := evm.Config.Tracer - if leftOverGas != 0 && tracer.OnGasChange != nil { - tracer.OnGasChange(leftOverGas, 0, tracing.GasChangeCallLeftOverReturned) + if leftOverGas != 0 && tracer.HasGasHook() { + leftover := NewGasBudget(leftOverGas) + tracer.EmitGasChange(leftover.AsTracing(), tracing.Gas{}, tracing.GasChangeCallLeftOverReturned) } var reverted bool if err != nil { diff --git a/core/vm/gas.go b/core/vm/gas.go index 5fe589bce696..dcb20893c540 100644 --- a/core/vm/gas.go +++ b/core/vm/gas.go @@ -49,6 +49,5 @@ func callGas(isEip150 bool, availableGas, base uint64, callCost *uint256.Int) (u if !callCost.IsUint64() { return 0, ErrGasUintOverflow } - return callCost.Uint64(), nil } diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index c7c1274bf2f3..046311f9cc1f 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -18,7 +18,6 @@ package vm import ( "errors" - "fmt" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -65,26 +64,26 @@ func memoryGasCost(mem *Memory, newMemSize uint64) (uint64, error) { // EXTCODECOPY (stack position 3) // RETURNDATACOPY (stack position 2) func memoryCopierGas(stackpos int) gasFunc { - return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { // Gas for expanding the memory gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } // And gas for copying data, charged per word at param.CopyGas - words, overflow := stack.Back(stackpos).Uint64WithOverflow() + words, overflow := stack.back(stackpos).Uint64WithOverflow() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if words, overflow = math.SafeMul(toWordSize(words), params.CopyGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if gas, overflow = math.SafeAdd(gas, words); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } } @@ -96,9 +95,12 @@ var ( gasReturnDataCopy = memoryCopierGas(2) ) -func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + if evm.readOnly { + return GasCosts{}, ErrWriteProtection + } var ( - y, x = stack.Back(1), stack.Back(0) + y, x = stack.back(1), stack.back(0) current, original = evm.StateDB.GetStateAndCommittedState(contract.Address(), x.Bytes32()) ) // The legacy gas metering only takes into consideration the current state @@ -112,12 +114,12 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi // 3. From a non-zero to a non-zero (CHANGE) switch { case current == (common.Hash{}) && y.Sign() != 0: // 0 => non 0 - return params.SstoreSetGas, nil + return GasCosts{RegularGas: params.SstoreSetGas}, nil case current != (common.Hash{}) && y.Sign() == 0: // non 0 => 0 evm.StateDB.AddRefund(params.SstoreRefundGas) - return params.SstoreClearGas, nil + return GasCosts{RegularGas: params.SstoreClearGas}, nil default: // non 0 => non 0 (or 0 => 0) - return params.SstoreResetGas, nil + return GasCosts{RegularGas: params.SstoreResetGas}, nil } } @@ -137,16 +139,16 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi // (2.2.2.2.) Otherwise, add 4800 gas to refund counter. value := common.Hash(y.Bytes32()) if current == value { // noop (1) - return params.NetSstoreNoopGas, nil + return GasCosts{RegularGas: params.NetSstoreNoopGas}, nil } if original == current { if original == (common.Hash{}) { // create slot (2.1.1) - return params.NetSstoreInitGas, nil + return GasCosts{RegularGas: params.NetSstoreInitGas}, nil } if value == (common.Hash{}) { // delete slot (2.1.2b) evm.StateDB.AddRefund(params.NetSstoreClearRefund) } - return params.NetSstoreCleanGas, nil // write existing slot (2.1.2) + return GasCosts{RegularGas: params.NetSstoreCleanGas}, nil // write existing slot (2.1.2) } if original != (common.Hash{}) { if current == (common.Hash{}) { // recreate slot (2.2.1.1) @@ -162,7 +164,7 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi evm.StateDB.AddRefund(params.NetSstoreResetRefund) } } - return params.NetSstoreDirtyGas, nil + return GasCosts{RegularGas: params.NetSstoreDirtyGas}, nil } // Here come the EIP2200 rules: @@ -180,29 +182,32 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi // (2.2.2.) If original value equals new value (this storage slot is reset): // (2.2.2.1.) If original value is 0, add SSTORE_SET_GAS - SLOAD_GAS to refund counter. // (2.2.2.2.) Otherwise, add SSTORE_RESET_GAS - SLOAD_GAS gas to refund counter. -func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + if evm.readOnly { + return GasCosts{}, ErrWriteProtection + } // If we fail the minimum gas availability invariant, fail (0) - if contract.Gas <= params.SstoreSentryGasEIP2200 { - return 0, errors.New("not enough gas for reentrancy sentry") + if contract.Gas.RegularGas <= params.SstoreSentryGasEIP2200 { + return GasCosts{}, errors.New("not enough gas for reentrancy sentry") } // Gas sentry honoured, do the actual gas calculation based on the stored value var ( - y, x = stack.Back(1), stack.Back(0) + y, x = stack.back(1), stack.back(0) current, original = evm.StateDB.GetStateAndCommittedState(contract.Address(), x.Bytes32()) ) value := common.Hash(y.Bytes32()) if current == value { // noop (1) - return params.SloadGasEIP2200, nil + return GasCosts{RegularGas: params.SloadGasEIP2200}, nil } if original == current { if original == (common.Hash{}) { // create slot (2.1.1) - return params.SstoreSetGasEIP2200, nil + return GasCosts{RegularGas: params.SstoreSetGasEIP2200}, nil } if value == (common.Hash{}) { // delete slot (2.1.2b) evm.StateDB.AddRefund(params.SstoreClearsScheduleRefundEIP2200) } - return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2) + return GasCosts{RegularGas: params.SstoreResetGasEIP2200}, nil // write existing slot (2.1.2) } if original != (common.Hash{}) { if current == (common.Hash{}) { // recreate slot (2.2.1.1) @@ -218,62 +223,66 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m evm.StateDB.AddRefund(params.SstoreResetGasEIP2200 - params.SloadGasEIP2200) } } - return params.SloadGasEIP2200, nil // dirty update (2.2) + return GasCosts{RegularGas: params.SloadGasEIP2200}, nil // dirty update (2.2) } func makeGasLog(n uint64) gasFunc { - return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - requestedSize, overflow := stack.Back(1).Uint64WithOverflow() + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + requestedSize, overflow := stack.back(1).Uint64WithOverflow() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } if gas, overflow = math.SafeAdd(gas, params.LogGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if gas, overflow = math.SafeAdd(gas, n*params.LogTopicGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } var memorySizeGas uint64 if memorySizeGas, overflow = math.SafeMul(requestedSize, params.LogDataGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if gas, overflow = math.SafeAdd(gas, memorySizeGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } } -func gasKeccak256(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasKeccak256(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } - wordGas, overflow := stack.Back(1).Uint64WithOverflow() + wordGas, overflow := stack.back(1).Uint64WithOverflow() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if wordGas, overflow = math.SafeMul(toWordSize(wordGas), params.Keccak256WordGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if gas, overflow = math.SafeAdd(gas, wordGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } // pureMemoryGascost is used by several operations, which aside from their // static cost have a dynamic cost which is solely based on the memory // expansion -func pureMemoryGascost(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - return memoryGasCost(mem, memorySize) +func pureMemoryGascost(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + gas, err := memoryGasCost(mem, memorySize) + if err != nil { + return GasCosts{}, err + } + return GasCosts{RegularGas: gas}, nil } var ( @@ -285,188 +294,200 @@ var ( gasCreate = pureMemoryGascost ) -func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } - wordGas, overflow := stack.Back(2).Uint64WithOverflow() + wordGas, overflow := stack.back(2).Uint64WithOverflow() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if wordGas, overflow = math.SafeMul(toWordSize(wordGas), params.Keccak256WordGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if gas, overflow = math.SafeAdd(gas, wordGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasCreateEip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasCreateEip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } - size, overflow := stack.Back(2).Uint64WithOverflow() + size, overflow := stack.back(2).Uint64WithOverflow() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - if size > params.MaxInitCodeSize { - return 0, fmt.Errorf("%w: size %d", ErrMaxInitCodeSizeExceeded, size) + if err := CheckMaxInitCodeSize(&evm.chainRules, size); err != nil { + return GasCosts{}, err } - // Since size <= params.MaxInitCodeSize, these multiplication cannot overflow + // Since size <= the protocol-defined maximum initcode size limit, these multiplication cannot overflow moreGas := params.InitCodeWordGas * ((size + 31) / 32) if gas, overflow = math.SafeAdd(gas, moreGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasCreate2Eip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasCreate2Eip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } - size, overflow := stack.Back(2).Uint64WithOverflow() + size, overflow := stack.back(2).Uint64WithOverflow() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - if size > params.MaxInitCodeSize { - return 0, fmt.Errorf("%w: size %d", ErrMaxInitCodeSizeExceeded, size) + if err := CheckMaxInitCodeSize(&evm.chainRules, size); err != nil { + return GasCosts{}, err } - // Since size <= params.MaxInitCodeSize, these multiplication cannot overflow + // Since size <= the protocol-defined maximum initcode size limit, these multiplication cannot overflow moreGas := (params.InitCodeWordGas + params.Keccak256WordGas) * ((size + 31) / 32) if gas, overflow = math.SafeAdd(gas, moreGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) +func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + expByteLen := uint64((stack.back(1).BitLen() + 7) / 8) var ( gas = expByteLen * params.ExpByteFrontier // no overflow check required. Max is 256 * ExpByte gas overflow bool ) if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) +func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + expByteLen := uint64((stack.back(1).BitLen() + 7) / 8) var ( gas = expByteLen * params.ExpByteEIP158 // no overflow check required. Max is 256 * ExpByte gas overflow bool ) if gas, overflow = math.SafeAdd(gas, params.ExpGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +var ( + gasCall = makeCallVariantGasCost(gasCallIntrinsic) + gasCallCode = makeCallVariantGasCost(gasCallCodeIntrinsic) + gasDelegateCall = makeCallVariantGasCost(gasDelegateCallIntrinsic) + gasStaticCall = makeCallVariantGasCost(gasStaticCallIntrinsic) +) + +func makeCallVariantGasCost(intrinsicFunc gasFunc) gasFunc { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + intrinsic, err := intrinsicFunc(evm, contract, stack, mem, memorySize) + if err != nil { + return GasCosts{}, err + } + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsic.RegularGas, stack.back(0)) + if err != nil { + return GasCosts{}, err + } + gas, overflow := math.SafeAdd(intrinsic.RegularGas, evm.callGasTemp) + if overflow { + return GasCosts{}, ErrGasUintOverflow + } + return GasCosts{RegularGas: gas}, nil + } +} + +func gasCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { var ( gas uint64 - transfersValue = !stack.Back(2).IsZero() - address = common.Address(stack.Back(1).Bytes20()) + transfersValue = !stack.back(2).IsZero() + address = common.Address(stack.back(1).Bytes20()) ) - if evm.chainRules.IsEIP158 { - if transfersValue && evm.StateDB.Empty(address) { - gas += params.CallNewAccountGas - } - } else if !evm.StateDB.Exist(address) { - gas += params.CallNewAccountGas - } - if transfersValue && !evm.chainRules.IsEIP4762 { - gas += params.CallValueTransferGas + if evm.readOnly && transfersValue { + return GasCosts{}, ErrWriteProtection } + // Stateless check memoryGas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err + } + var transferGas uint64 + if transfersValue && !evm.chainRules.IsEIP4762 { + transferGas = params.CallValueTransferGas } var overflow bool - if gas, overflow = math.SafeAdd(gas, memoryGas); overflow { - return 0, ErrGasUintOverflow + if gas, overflow = math.SafeAdd(memoryGas, transferGas); overflow { + return GasCosts{}, ErrGasUintOverflow } - - evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0)) - if err != nil { - return 0, err + // Terminate the gas measurement if the leftover gas is not sufficient, + // it can effectively prevent accessing the states in the following steps. + if contract.Gas.RegularGas < gas { + return GasCosts{}, ErrOutOfGas } - if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow { - return 0, ErrGasUintOverflow + // Stateful check + var stateGas uint64 + if evm.chainRules.IsEIP158 { + if transfersValue && evm.StateDB.Empty(address) { + stateGas += params.CallNewAccountGas + } + } else if !evm.StateDB.Exist(address) { + stateGas += params.CallNewAccountGas } - - return gas, nil + if gas, overflow = math.SafeAdd(gas, stateGas); overflow { + return GasCosts{}, ErrGasUintOverflow + } + return GasCosts{RegularGas: gas}, nil } -func gasCallCode(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasCallCodeIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { memoryGas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } var ( gas uint64 overflow bool ) - if stack.Back(2).Sign() != 0 && !evm.chainRules.IsEIP4762 { + if stack.back(2).Sign() != 0 && !evm.chainRules.IsEIP4762 { gas += params.CallValueTransferGas } if gas, overflow = math.SafeAdd(gas, memoryGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0)) - if err != nil { - return 0, err - } - if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow { - return 0, ErrGasUintOverflow - } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasDelegateCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasDelegateCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err - } - evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0)) - if err != nil { - return 0, err - } - var overflow bool - if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, err } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasStaticCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasStaticCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { gas, err := memoryGasCost(mem, memorySize) if err != nil { - return 0, err - } - evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0)) - if err != nil { - return 0, err - } - var overflow bool - if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, err } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + if evm.readOnly { + return GasCosts{}, ErrWriteProtection + } + var gas uint64 // EIP150 homestead gas reprice fork: if evm.chainRules.IsEIP150 { gas = params.SelfdestructGasEIP150 - var address = common.Address(stack.Back(0).Bytes20()) + var address = common.Address(stack.back(0).Bytes20()) if evm.chainRules.IsEIP158 { // if empty and transfers value @@ -481,5 +502,5 @@ func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me if !evm.StateDB.HasSelfDestructed(contract.Address()) { evm.StateDB.AddRefund(params.SelfdestructRefundGas) } - return gas, nil + return GasCosts{RegularGas: gas}, nil } diff --git a/core/vm/gas_table_test.go b/core/vm/gas_table_test.go index 7fe76b0a6331..16ce651a7d32 100644 --- a/core/vm/gas_table_test.go +++ b/core/vm/gas_table_test.go @@ -94,15 +94,15 @@ func TestEIP2200(t *testing.T) { vmctx := BlockContext{ CanTransfer: func(StateDB, common.Address, *uint256.Int) bool { return true }, - Transfer: func(StateDB, common.Address, common.Address, *uint256.Int) {}, + Transfer: func(StateDB, common.Address, common.Address, *uint256.Int, *params.Rules) {}, } evm := NewEVM(vmctx, statedb, params.AllEthashProtocolChanges, Config{ExtraEips: []int{2200}}) - - _, gas, err := evm.Call(common.Address{}, address, nil, tt.gaspool, new(uint256.Int)) + initialGas := NewGasBudget(tt.gaspool) + _, leftOver, err := evm.Call(common.Address{}, address, nil, initialGas.Copy(), new(uint256.Int)) if !errors.Is(err, tt.failure) { t.Errorf("test %d: failure mismatch: have %v, want %v", i, err, tt.failure) } - if used := tt.gaspool - gas; used != tt.used { + if used := leftOver.Used(initialGas); used != tt.used { t.Errorf("test %d: gas used mismatch: have %v, want %v", i, used, tt.used) } if refund := evm.StateDB.GetRefund(); refund != tt.refund { @@ -144,21 +144,25 @@ func TestCreateGas(t *testing.T) { statedb.Finalise(true) vmctx := BlockContext{ CanTransfer: func(StateDB, common.Address, *uint256.Int) bool { return true }, - Transfer: func(StateDB, common.Address, common.Address, *uint256.Int) {}, + Transfer: func(StateDB, common.Address, common.Address, *uint256.Int, *params.Rules) {}, BlockNumber: big.NewInt(0), } config := Config{} + chainConfig := params.AllEthashProtocolChanges if tt.eip3860 { config.ExtraEips = []int{3860} + vmctx.Random = new(common.Hash) + + chainConfig = params.MergedTestChainConfig } - evm := NewEVM(vmctx, statedb, params.AllEthashProtocolChanges, config) - var startGas = uint64(testGas) - ret, gas, err := evm.Call(common.Address{}, address, nil, startGas, new(uint256.Int)) + evm := NewEVM(vmctx, statedb, chainConfig, config) + initialGas := NewGasBudget(uint64(testGas)) + ret, leftOver, err := evm.Call(common.Address{}, address, nil, initialGas.Copy(), new(uint256.Int)) if err != nil { return false } - gasUsed = startGas - gas + gasUsed = leftOver.Used(initialGas) if len(ret) != 32 { t.Fatalf("test %d: expected 32 bytes returned, have %d", i, len(ret)) } diff --git a/core/vm/gascosts.go b/core/vm/gascosts.go new file mode 100644 index 000000000000..ed938ae41f9a --- /dev/null +++ b/core/vm/gascosts.go @@ -0,0 +1,106 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package vm + +import ( + "fmt" + + "github.com/ethereum/go-ethereum/core/tracing" +) + +// GasCosts denotes a vector of gas costs in the +// multidimensional metering paradigm. It represents the cost +// charged by an individual operation. +type GasCosts struct { + RegularGas uint64 + StateGas uint64 +} + +// Sum returns the total gas (regular + state). +func (g GasCosts) Sum() uint64 { + return g.RegularGas + g.StateGas +} + +// String returns a visual representation of the gas vector. +func (g GasCosts) String() string { + return fmt.Sprintf("<%v,%v>", g.RegularGas, g.StateGas) +} + +// GasBudget denotes a vector of remaining gas allowances available +// for EVM execution in the multidimensional metering paradigm. +// Unlike GasCosts which represents the price of an operation, +// GasBudget tracks how much gas is left to spend. +type GasBudget struct { + RegularGas uint64 // The leftover gas for execution and state gas usage + StateGas uint64 // The state gas reservoir +} + +// NewGasBudget creates a GasBudget with the given initial regular gas allowance. +func NewGasBudget(gas uint64) GasBudget { + return GasBudget{RegularGas: gas} +} + +// Used returns the amount of regular gas consumed so far. +func (g GasBudget) Used(initial GasBudget) uint64 { + return initial.RegularGas - g.RegularGas +} + +// Exhaust sets all remaining gas to zero, preserving the initial amount +// for usage tracking. +func (g *GasBudget) Exhaust() { + g.RegularGas = 0 + g.StateGas = 0 +} + +func (g *GasBudget) Copy() GasBudget { + return GasBudget{RegularGas: g.RegularGas, StateGas: g.StateGas} +} + +// String returns a visual representation of the gas budget vector. +func (g GasBudget) String() string { + return fmt.Sprintf("<%v,%v>", g.RegularGas, g.StateGas) +} + +// CanAfford reports whether the budget has sufficient gas to cover the cost. +func (g GasBudget) CanAfford(cost GasCosts) bool { + return g.RegularGas >= cost.RegularGas +} + +// Charge deducts the given gas cost from the budget. It returns the +// pre-charge budget and false if the budget does not have sufficient +// gas to cover the cost. +func (g *GasBudget) Charge(cost GasCosts) (GasBudget, bool) { + prior := *g + if g.RegularGas < cost.RegularGas { + return prior, false + } + g.RegularGas -= cost.RegularGas + return prior, true +} + +// Refund adds the given gas budget back. It returns the pre-refund budget +// and whether the budget was actually changed. +func (g *GasBudget) Refund(other GasBudget) (GasBudget, bool) { + prior := *g + g.RegularGas += other.RegularGas + return prior, g.RegularGas != prior.RegularGas +} + +// AsTracing converts the GasBudget into the tracing-facing Gas vector. +func (g GasBudget) AsTracing() tracing.Gas { + return tracing.Gas{Regular: g.RegularGas, State: g.StateGas} +} diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 6b04a2daff7e..4b05092cc799 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -22,8 +22,8 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/params" - "github.com/holiman/uint256" ) func opAdd(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { @@ -233,19 +233,17 @@ func opKeccak256(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { offset, size := scope.Stack.pop(), scope.Stack.peek() data := scope.Memory.GetPtr(offset.Uint64(), size.Uint64()) - evm.hasher.Reset() - evm.hasher.Write(data) - evm.hasher.Read(evm.hasherBuf[:]) + hash := crypto.Keccak256Hash(data) if evm.Config.EnablePreimageRecording { - evm.StateDB.AddPreimage(evm.hasherBuf, data) + evm.StateDB.AddPreimage(hash, data) } - size.SetBytes(evm.hasherBuf[:]) + size.SetBytes(hash[:]) return nil, nil } func opAddress(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetBytes(scope.Contract.Address().Bytes())) + scope.Stack.get().SetBytes(scope.Contract.Address().Bytes()) return nil, nil } @@ -257,17 +255,17 @@ func opBalance(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opOrigin(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetBytes(evm.Origin.Bytes())) + scope.Stack.get().SetBytes(evm.Origin.Bytes()) return nil, nil } func opCaller(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetBytes(scope.Contract.Caller().Bytes())) + scope.Stack.get().SetBytes(scope.Contract.Caller().Bytes()) return nil, nil } func opCallValue(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(scope.Contract.value) + scope.Stack.get().Set(scope.Contract.value) return nil, nil } @@ -283,7 +281,7 @@ func opCallDataLoad(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opCallDataSize(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(scope.Contract.Input)))) + scope.Stack.get().SetUint64(uint64(len(scope.Contract.Input))) return nil, nil } @@ -306,7 +304,7 @@ func opCallDataCopy(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opReturnDataSize(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(evm.returnData)))) + scope.Stack.get().SetUint64(uint64(len(evm.returnData))) return nil, nil } @@ -339,7 +337,7 @@ func opExtCodeSize(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opCodeSize(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(scope.Contract.Code)))) + scope.Stack.get().SetUint64(uint64(len(scope.Contract.Code))) return nil, nil } @@ -417,8 +415,7 @@ func opExtCodeHash(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opGasprice(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - v, _ := uint256.FromBig(evm.GasPrice) - scope.Stack.push(v) + scope.Stack.get().Set(evm.GasPrice) return nil, nil } @@ -453,35 +450,32 @@ func opBlockhash(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opCoinbase(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetBytes(evm.Context.Coinbase.Bytes())) + scope.Stack.get().SetBytes(evm.Context.Coinbase.Bytes()) return nil, nil } func opTimestamp(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(evm.Context.Time)) + scope.Stack.get().SetUint64(evm.Context.Time) return nil, nil } func opNumber(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - v, _ := uint256.FromBig(evm.Context.BlockNumber) - scope.Stack.push(v) + scope.Stack.get().SetFromBig(evm.Context.BlockNumber) return nil, nil } func opDifficulty(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - v, _ := uint256.FromBig(evm.Context.Difficulty) - scope.Stack.push(v) + scope.Stack.get().SetFromBig(evm.Context.Difficulty) return nil, nil } func opRandom(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - v := new(uint256.Int).SetBytes(evm.Context.Random.Bytes()) - scope.Stack.push(v) + scope.Stack.get().SetBytes(evm.Context.Random.Bytes()) return nil, nil } func opGasLimit(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(evm.Context.GasLimit)) + scope.Stack.get().SetUint64(evm.Context.GasLimit) return nil, nil } @@ -558,17 +552,17 @@ func opJumpdest(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opPc(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(*pc)) + scope.Stack.get().SetUint64(*pc) return nil, nil } func opMsize(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(uint64(scope.Memory.Len()))) + scope.Stack.get().SetUint64(uint64(scope.Memory.Len())) return nil, nil } func opGas(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(scope.Contract.Gas)) + scope.Stack.get().SetUint64(scope.Contract.Gas.RegularGas) return nil, nil } @@ -660,7 +654,7 @@ func opCreate(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { value = scope.Stack.pop() offset, size = scope.Stack.pop(), scope.Stack.pop() input = scope.Memory.GetCopy(offset.Uint64(), size.Uint64()) - gas = scope.Contract.Gas + gas = scope.Contract.Gas.RegularGas ) if evm.chainRules.IsEIP150 { gas -= gas / 64 @@ -669,9 +663,9 @@ func opCreate(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // reuse size int for stackvalue stackvalue := size - scope.Contract.UseGas(gas, evm.Config.Tracer, tracing.GasChangeCallContractCreation) + scope.Contract.UseGas(GasCosts{RegularGas: gas}, evm.Config.Tracer, tracing.GasChangeCallContractCreation) - res, addr, returnGas, suberr := evm.Create(scope.Contract.Address(), input, gas, &value) + res, addr, returnGas, suberr := evm.Create(scope.Contract.Address(), input, NewGasBudget(gas), &value) // Push item on the stack based on the returned error. If the ruleset is // homestead we must check for CodeStoreOutOfGasError (homestead only // rule) and treat as an error, if the ruleset is frontier we must @@ -704,15 +698,15 @@ func opCreate2(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { offset, size = scope.Stack.pop(), scope.Stack.pop() salt = scope.Stack.pop() input = scope.Memory.GetCopy(offset.Uint64(), size.Uint64()) - gas = scope.Contract.Gas + gas = scope.Contract.Gas.RegularGas ) // Apply EIP150 gas -= gas / 64 - scope.Contract.UseGas(gas, evm.Config.Tracer, tracing.GasChangeCallContractCreation2) + scope.Contract.UseGas(GasCosts{RegularGas: gas}, evm.Config.Tracer, tracing.GasChangeCallContractCreation2) // reuse size int for stackvalue stackvalue := size - res, addr, returnGas, suberr := evm.Create2(scope.Contract.Address(), input, gas, + res, addr, returnGas, suberr := evm.Create2(scope.Contract.Address(), input, NewGasBudget(gas), &endowment, &salt) // Push item on the stack based on the returned error. if suberr != nil { @@ -749,7 +743,7 @@ func opCall(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { if !value.IsZero() { gas += params.CallStipend } - ret, returnGas, err := evm.Call(scope.Contract.Address(), toAddr, args, gas, &value) + ret, returnGas, err := evm.Call(scope.Contract.Address(), toAddr, args, NewGasBudget(gas), &value) if err != nil { temp.Clear() @@ -783,7 +777,7 @@ func opCallCode(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { gas += params.CallStipend } - ret, returnGas, err := evm.CallCode(scope.Contract.Address(), toAddr, args, gas, &value) + ret, returnGas, err := evm.CallCode(scope.Contract.Address(), toAddr, args, NewGasBudget(gas), &value) if err != nil { temp.Clear() } else { @@ -812,7 +806,7 @@ func opDelegateCall(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // Get arguments from the memory. args := scope.Memory.GetPtr(inOffset.Uint64(), inSize.Uint64()) - ret, returnGas, err := evm.DelegateCall(scope.Contract.Caller(), scope.Contract.Address(), toAddr, args, gas, scope.Contract.value) + ret, returnGas, err := evm.DelegateCall(scope.Contract.Caller(), scope.Contract.Address(), toAddr, args, NewGasBudget(gas), scope.Contract.value) if err != nil { temp.Clear() } else { @@ -841,7 +835,7 @@ func opStaticCall(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // Get arguments from the memory. args := scope.Memory.GetPtr(inOffset.Uint64(), inSize.Uint64()) - ret, returnGas, err := evm.StaticCall(scope.Contract.Address(), toAddr, args, gas) + ret, returnGas, err := evm.StaticCall(scope.Contract.Address(), toAddr, args, NewGasBudget(gas)) if err != nil { temp.Clear() } else { @@ -885,13 +879,24 @@ func opSelfdestruct(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { if evm.readOnly { return nil, ErrWriteProtection } - beneficiary := scope.Stack.pop() - balance := evm.StateDB.GetBalance(scope.Contract.Address()) - evm.StateDB.AddBalance(beneficiary.Bytes20(), balance, tracing.BalanceIncreaseSelfdestruct) - evm.StateDB.SelfDestruct(scope.Contract.Address()) + var ( + this = scope.Contract.Address() + balance = evm.StateDB.GetBalance(this) + top = scope.Stack.pop() + beneficiary = common.Address(top.Bytes20()) + ) + // The funds are burned immediately if the beneficiary is the caller itself, + // in this case, the beneficiary's balance is not increased. + if this != beneficiary { + evm.StateDB.AddBalance(beneficiary, balance, tracing.BalanceIncreaseSelfdestruct) + } + // Clear any leftover funds for the account being destructed. + evm.StateDB.SubBalance(this, balance, tracing.BalanceDecreaseSelfdestruct) + evm.StateDB.SelfDestruct(this) + if tracer := evm.Config.Tracer; tracer != nil { if tracer.OnEnter != nil { - tracer.OnEnter(evm.depth, byte(SELFDESTRUCT), scope.Contract.Address(), beneficiary.Bytes20(), []byte{}, 0, balance.ToBig()) + tracer.OnEnter(evm.depth, byte(SELFDESTRUCT), this, beneficiary, []byte{}, 0, balance.ToBig()) } if tracer.OnExit != nil { tracer.OnExit(evm.depth, []byte{}, 0, nil, false) @@ -904,14 +909,38 @@ func opSelfdestruct6780(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, erro if evm.readOnly { return nil, ErrWriteProtection } - beneficiary := scope.Stack.pop() - balance := evm.StateDB.GetBalance(scope.Contract.Address()) - evm.StateDB.SubBalance(scope.Contract.Address(), balance, tracing.BalanceDecreaseSelfdestruct) - evm.StateDB.AddBalance(beneficiary.Bytes20(), balance, tracing.BalanceIncreaseSelfdestruct) - evm.StateDB.SelfDestruct6780(scope.Contract.Address()) + var ( + this = scope.Contract.Address() + balance = evm.StateDB.GetBalance(this) + top = scope.Stack.pop() + beneficiary = common.Address(top.Bytes20()) + newContract = evm.StateDB.IsNewContract(this) + ) + // Contract is new and will actually be deleted. + if newContract { + if this != beneficiary { // Skip no-op transfer when self-destructing to self. + evm.StateDB.AddBalance(beneficiary, balance, tracing.BalanceIncreaseSelfdestruct) + } + evm.StateDB.SubBalance(this, balance, tracing.BalanceDecreaseSelfdestruct) + evm.StateDB.SelfDestruct(this) + } + + // Contract already exists, only do transfer if beneficiary is not self. + if !newContract && this != beneficiary { + evm.StateDB.SubBalance(this, balance, tracing.BalanceDecreaseSelfdestruct) + evm.StateDB.AddBalance(beneficiary, balance, tracing.BalanceIncreaseSelfdestruct) + } + if evm.chainRules.IsAmsterdam && !balance.IsZero() { + if this != beneficiary { + evm.StateDB.AddLog(types.EthTransferLog(this, beneficiary, balance)) + } else if newContract { + evm.StateDB.AddLog(types.EthBurnLog(this, balance)) + } + } + if tracer := evm.Config.Tracer; tracer != nil { if tracer.OnEnter != nil { - tracer.OnEnter(evm.depth, byte(SELFDESTRUCT), scope.Contract.Address(), beneficiary.Bytes20(), []byte{}, 0, balance.ToBig()) + tracer.OnEnter(evm.depth, byte(SELFDESTRUCT), this, beneficiary, []byte{}, 0, balance.ToBig()) } if tracer.OnExit != nil { tracer.OnExit(evm.depth, []byte{}, 0, nil, false) @@ -920,24 +949,34 @@ func opSelfdestruct6780(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, erro return nil, errStopToken } +// decodeSingle decodes the immediate operand of a backward-compatible DUPN or SWAPN instruction (EIP-8024) +// https://eips.ethereum.org/EIPS/eip-8024 func decodeSingle(x byte) int { - if x <= 90 { - return int(x) + 17 - } - return int(x) - 20 -} - + // Depths 1-16 are already covered by the legacy opcodes. The forbidden byte range [91, 127] removes + // 37 values from the 256 possible immediates, leaving 219 usable values, so this encoding covers depths + // 17 through 235. The immediate is encoded as (x + 111) % 256, where 111 is chosen so that these values + // avoid the forbidden range. Decoding is simply the modular inverse (i.e. 111+145=256). + return (int(x) + 145) % 256 +} + +// decodePair decodes the immediate operand of a backward-compatible EXCHANGE +// instruction (EIP-8024) into stack indices (n, m) where 1 <= n < m +// and n + m <= 30. The forbidden byte range [82, 127] removes 46 values from +// the 256 possible immediates, leaving exactly 210 usable bytes. +// https://eips.ethereum.org/EIPS/eip-8024 func decodePair(x byte) (int, int) { - var k int - if x <= 79 { - k = int(x) - } else { - k = int(x) - 48 - } + // XOR with 143 remaps the forbidden bytes [82, 127] to an unused corner + // of the 16x16 grid below. + k := int(x ^ 143) + // Split into row q and column r of a 16x16 grid. The 210 valid pairs + // occupy two triangles within this grid. q, r := k/16, k%16 + // Upper triangle (q < r): pairs where m <= 16, encoded directly as + // (q+1, r+1). if q < r { return q + 1, r + 1 } + // Lower triangle: pairs where m > 16, recovered as (r+1, 29-q). return r + 1, 29 - q } @@ -945,15 +984,16 @@ func opDupN(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { code := scope.Contract.Code i := *pc + 1 - // Ensure an immediate byte exists after DUPN - if i >= uint64(len(code)) { - return nil, &ErrInvalidOpCode{opcode: INVALID} + // If the immediate byte is missing, treat as 0x00 (same convention as PUSHn). + var x byte + if i < uint64(len(code)) { + x = code[i] } - x := code[i] // This range is excluded to preserve compatibility with existing opcodes. if x > 90 && x < 128 { - return nil, &ErrInvalidOpCode{opcode: OpCode(x)} + operand := x + return nil, &ErrInvalidOpCode{opcode: DUPN, operand: &operand} } n := decodeSingle(x) @@ -963,7 +1003,7 @@ func opDupN(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } //The n‘th stack item is duplicated at the top of the stack. - scope.Stack.push(scope.Stack.Back(n - 1)) + scope.Stack.push(scope.Stack.back(n - 1)) *pc += 1 return nil, nil } @@ -972,15 +1012,16 @@ func opSwapN(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { code := scope.Contract.Code i := *pc + 1 - // Ensure an immediate byte exists after SWAPN - if i >= uint64(len(code)) { - return nil, &ErrInvalidOpCode{opcode: INVALID} + // If the immediate byte is missing, treat as 0x00 (same convention as PUSHn). + var x byte + if i < uint64(len(code)) { + x = code[i] } - x := code[i] // This range is excluded to preserve compatibility with existing opcodes. if x > 90 && x < 128 { - return nil, &ErrInvalidOpCode{opcode: OpCode(x)} + operand := x + return nil, &ErrInvalidOpCode{opcode: SWAPN, operand: &operand} } n := decodeSingle(x) @@ -989,10 +1030,10 @@ func opSwapN(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { return nil, &ErrStackUnderflow{stackLen: scope.Stack.len(), required: n + 1} } - // The (n+1)‘th stack item is swapped with the top of the stack. - indexTop := scope.Stack.len() - 1 - indexN := scope.Stack.len() - 1 - n - scope.Stack.data[indexTop], scope.Stack.data[indexN] = scope.Stack.data[indexN], scope.Stack.data[indexTop] + // The (n+1)’th stack item is swapped with the top of the stack. + top := scope.Stack.peek() + nth := scope.Stack.back(n) + *top, *nth = *nth, *top *pc += 1 return nil, nil } @@ -1001,16 +1042,17 @@ func opExchange(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { code := scope.Contract.Code i := *pc + 1 - // Ensure an immediate byte exists after EXCHANGE - if i >= uint64(len(code)) { - return nil, &ErrInvalidOpCode{opcode: INVALID} + // If the immediate byte is missing, treat as 0x00 (same convention as PUSHn). + var x byte + if i < uint64(len(code)) { + x = code[i] } - x := code[i] // This range is excluded both to preserve compatibility with existing opcodes - // and to keep decode_pair’s 16-aligned arithmetic mapping valid (0–79, 128–255). - if x > 79 && x < 128 { - return nil, &ErrInvalidOpCode{opcode: OpCode(x)} + // and to keep decode_pair’s 16-aligned arithmetic mapping valid (0–81, 128–255). + if x > 81 && x < 128 { + operand := x + return nil, &ErrInvalidOpCode{opcode: EXCHANGE, operand: &operand} } n, m := decodePair(x) need := max(n, m) + 1 @@ -1021,10 +1063,10 @@ func opExchange(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { return nil, &ErrStackUnderflow{stackLen: scope.Stack.len(), required: need} } - // The (n+1)‘th stack item is swapped with the (m+1)‘th stack item. - indexN := scope.Stack.len() - 1 - n - indexM := scope.Stack.len() - 1 - m - scope.Stack.data[indexN], scope.Stack.data[indexM] = scope.Stack.data[indexM], scope.Stack.data[indexN] + // The (n+1)’th stack item is swapped with the (m+1)’th stack item. + nth := scope.Stack.back(n) + mth := scope.Stack.back(m) + *nth, *mth = *mth, *nth *pc += 1 return nil, nil } @@ -1050,9 +1092,6 @@ func makeLog(size int) executionFunc { Address: scope.Contract.Address(), Topics: topics, Data: d, - // This is a non-consensus field, but assigned here because - // core/state doesn't know the current block number. - BlockNumber: evm.Context.BlockNumber.Uint64(), }) return nil, nil @@ -1063,13 +1102,13 @@ func makeLog(size int) executionFunc { func opPush1(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { var ( codeLen = uint64(len(scope.Contract.Code)) - integer = new(uint256.Int) + elem = scope.Stack.get() ) *pc += 1 if *pc < codeLen { - scope.Stack.push(integer.SetUint64(uint64(scope.Contract.Code[*pc]))) + elem.SetUint64(uint64(scope.Contract.Code[*pc])) } else { - scope.Stack.push(integer.Clear()) + elem.Clear() } return nil, nil } @@ -1078,14 +1117,14 @@ func opPush1(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { func opPush2(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { var ( codeLen = uint64(len(scope.Contract.Code)) - integer = new(uint256.Int) + elem = scope.Stack.get() ) if *pc+2 < codeLen { - scope.Stack.push(integer.SetBytes2(scope.Contract.Code[*pc+1 : *pc+3])) + elem.SetBytes2(scope.Contract.Code[*pc+1 : *pc+3]) } else if *pc+1 < codeLen { - scope.Stack.push(integer.SetUint64(uint64(scope.Contract.Code[*pc+1]) << 8)) + elem.SetUint64(uint64(scope.Contract.Code[*pc+1]) << 8) } else { - scope.Stack.push(integer.Clear()) + elem.Clear() } *pc += 2 return nil, nil @@ -1099,13 +1138,13 @@ func makePush(size uint64, pushByteSize int) executionFunc { start = min(codeLen, int(*pc+1)) end = min(codeLen, start+pushByteSize) ) - a := new(uint256.Int).SetBytes(scope.Contract.Code[start:end]) + a := scope.Stack.get() + a.SetBytes(scope.Contract.Code[start:end]) // Missing bytes: pushByteSize - len(pushData) if missing := pushByteSize - (end - start); missing > 0 { a.Lsh(a, uint(8*missing)) } - scope.Stack.push(a) *pc += size return nil, nil } diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go index f38da7fb2242..354d2ce5ab6b 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -19,11 +19,13 @@ package vm import ( "bytes" "encoding/json" + "errors" "fmt" "math/big" "os" "strings" "testing" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -97,7 +99,7 @@ func init() { func testTwoOperandOp(t *testing.T, tests []TwoOperandTestcase, opFn executionFunc, name string) { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() pc = uint64(0) ) @@ -108,8 +110,8 @@ func testTwoOperandOp(t *testing.T, tests []TwoOperandTestcase, opFn executionFu stack.push(x) stack.push(y) opFn(&pc, evm, &ScopeContext{nil, stack, nil}) - if len(stack.data) != 1 { - t.Errorf("Expected one item on stack after %v, got %d: ", name, len(stack.data)) + if stack.len() != 1 { + t.Errorf("Expected one item on stack after %v, got %d: ", name, stack.len()) } actual := stack.pop() @@ -195,7 +197,7 @@ func TestSAR(t *testing.T) { func TestAddMod(t *testing.T) { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() pc = uint64(0) ) tests := []struct { @@ -238,7 +240,7 @@ func TestWriteExpectedValues(t *testing.T) { getResult := func(args []*twoOperandParams, opFn executionFunc) []TwoOperandTestcase { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() pc = uint64(0) ) result := make([]TwoOperandTestcase, len(args)) @@ -281,23 +283,40 @@ func TestJsonTestcases(t *testing.T) { func opBenchmark(bench *testing.B, op executionFunc, args ...string) { var ( - evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() - scope = &ScopeContext{nil, stack, nil} + evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) + stack = newStackForTesting() + code = []byte{} + opPush32 = makePush(32, 32) ) // convert args intArgs := make([]*uint256.Int, len(args)) for i, arg := range args { + code = append(code, common.LeftPadBytes(common.Hex2Bytes(arg), 32)...) intArgs[i] = new(uint256.Int).SetBytes(common.Hex2Bytes(arg)) } pc := uint64(0) - for bench.Loop() { - for _, arg := range intArgs { - stack.push(arg) + scope := &ScopeContext{nil, stack, &Contract{Code: code}} + start := time.Now() + bench.ResetTimer() + for i := 0; i < bench.N; i++ { + for range len(args) { + opPush32(&pc, evm, scope) + pc += 32 } op(&pc, evm, scope) - stack.pop() + opPop(&pc, evm, scope) + } + bench.StopTimer() + elapsed := uint64(time.Since(start)) + if elapsed < 1 { + elapsed = 1 } + reqGas := uint64(len(args))*GasFastestStep + GasFastestStep + GasQuickStep + gasUsed := reqGas * uint64(bench.N) + bench.ReportMetric(float64(reqGas), "gas/op") + // Keep it as uint64, multiply 100 to get two digit float later + mgasps := (100 * 1000 * gasUsed) / elapsed + bench.ReportMetric(float64(mgasps)/100, "mgas/s") for i, arg := range args { want := new(uint256.Int).SetBytes(common.Hex2Bytes(arg)) @@ -518,7 +537,7 @@ func BenchmarkOpIsZero(b *testing.B) { func TestOpMstore(t *testing.T) { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() mem = NewMemory() ) mem.Resize(64) @@ -541,7 +560,7 @@ func TestOpMstore(t *testing.T) { func BenchmarkOpMstore(bench *testing.B) { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() mem = NewMemory() ) mem.Resize(64) @@ -560,11 +579,11 @@ func TestOpTstore(t *testing.T) { var ( statedb, _ = state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) evm = NewEVM(BlockContext{}, statedb, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() mem = NewMemory() caller = common.Address{} to = common.Address{1} - contract = NewContract(caller, to, new(uint256.Int), 0, nil) + contract = NewContract(caller, to, new(uint256.Int), GasBudget{}, nil) scopeContext = ScopeContext{mem, stack, contract} value = common.Hex2Bytes("abcdef00000000000000abba000000000deaf000000c0de00100000000133700") ) @@ -599,7 +618,7 @@ func TestOpTstore(t *testing.T) { func BenchmarkOpKeccak256(bench *testing.B) { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() mem = NewMemory() ) mem.Resize(32) @@ -671,7 +690,7 @@ func TestCreate2Addresses(t *testing.T) { codeHash := crypto.Keccak256(code) address := crypto.CreateAddress2(origin, salt, codeHash) /* - stack := newstack() + stack := newStackForTesting() // salt, but we don't need that for this test stack.push(big.NewInt(int64(len(code)))) //size stack.push(big.NewInt(0)) // memstart @@ -700,12 +719,12 @@ func TestRandom(t *testing.T) { } { var ( evm = NewEVM(BlockContext{Random: &tt.random}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() pc = uint64(0) ) opRandom(&pc, evm, &ScopeContext{nil, stack, nil}) - if len(stack.data) != 1 { - t.Errorf("Expected one item on stack after %v, got %d: ", tt.name, len(stack.data)) + if have, want := stack.len(), 1; have != want { + t.Errorf("test '%v': want %d item(s) on stack, have %d: ", tt.name, have, want) } actual := stack.pop() expected, overflow := uint256.FromBig(new(big.Int).SetBytes(tt.random.Bytes())) @@ -740,14 +759,14 @@ func TestBlobHash(t *testing.T) { } { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() pc = uint64(0) ) evm.SetTxContext(TxContext{BlobHashes: tt.hashes}) stack.push(uint256.NewInt(tt.idx)) opBlobHash(&pc, evm, &ScopeContext{nil, stack, nil}) - if len(stack.data) != 1 { - t.Errorf("Expected one item on stack after %v, got %d: ", tt.name, len(stack.data)) + if have, want := stack.len(), 1; have != want { + t.Errorf("test '%v': want %d item(s) on stack, have %d: ", tt.name, have, want) } actual := stack.pop() expected, overflow := uint256.FromBig(new(big.Int).SetBytes(tt.expect.Bytes())) @@ -843,7 +862,7 @@ func TestOpMCopy(t *testing.T) { } { var ( evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() + stack = newStackForTesting() pc = uint64(0) ) data := common.FromHex(strings.ReplaceAll(tc.pre, " ", "")) @@ -878,7 +897,7 @@ func TestOpMCopy(t *testing.T) { if dynamicCost, err := gasMcopy(evm, nil, stack, mem, memorySize); err != nil { t.Error(err) } else { - haveGas = GasFastestStep + dynamicCost + haveGas = GasFastestStep + dynamicCost.RegularGas } // Expand mem if memorySize > 0 { @@ -906,7 +925,7 @@ func TestPush(t *testing.T) { scope := &ScopeContext{ Memory: nil, - Stack: newstack(), + Stack: newStackForTesting(), Contract: &Contract{ Code: code, }, @@ -987,7 +1006,7 @@ func TestOpCLZ(t *testing.T) { } for _, tc := range tests { // prepare a fresh stack and PC - stack := newstack() + stack := newStackForTesting() pc := uint64(0) // parse input @@ -1013,14 +1032,16 @@ func TestEIP8024_Execution(t *testing.T) { evm := NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) tests := []struct { - name string - codeHex string - wantErr bool - wantVals []uint64 + name string + codeHex string + wantErr error + wantOpcode OpCode + wantOperand *byte + wantVals []uint64 }{ { name: "DUPN", - codeHex: "60016000808080808080808080808080808080e600", + codeHex: "60016000808080808080808080808080808080e680", wantVals: []uint64{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1029,7 +1050,7 @@ func TestEIP8024_Execution(t *testing.T) { }, { name: "SWAPN", - codeHex: "600160008080808080808080808080808080806002e700", + codeHex: "600160008080808080808080808080808080806002e780", wantVals: []uint64{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1037,79 +1058,70 @@ func TestEIP8024_Execution(t *testing.T) { }, }, { - name: "EXCHANGE", - codeHex: "600060016002e801", - wantVals: []uint64{2, 0, 1}, - }, - { - name: "INVALID_SWAPN_LOW", - codeHex: "e75b", - wantErr: true, - }, - { - name: "JUMP over INVALID_DUPN", - codeHex: "600456e65b", - wantErr: false, - }, - // Additional test cases - { - name: "INVALID_DUPN_LOW", - codeHex: "e65b", - wantErr: true, - }, - { - name: "INVALID_EXCHANGE_LOW", - codeHex: "e850", - wantErr: true, - }, - { - name: "INVALID_DUPN_HIGH", - codeHex: "e67f", - wantErr: true, + name: "EXCHANGE_MISSING_IMMEDIATE", + codeHex: "600260008080808080600160008080808080808080e8", + wantVals: []uint64{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, // 10th from top + 0, 0, 0, 0, 0, 0, + 1, // bottom + }, }, { - name: "INVALID_SWAPN_HIGH", - codeHex: "e77f", - wantErr: true, + name: "EXCHANGE", + codeHex: "600060016002e88e", + wantVals: []uint64{2, 0, 1}, }, { - name: "INVALID_EXCHANGE_HIGH", - codeHex: "e87f", - wantErr: true, + name: "EXCHANGE", + codeHex: "600080808080808080808080808080808080808080808080808080808060016002e88f", + wantVals: []uint64{ + 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, + }, }, { - name: "UNDERFLOW_DUPN", - codeHex: "5f5f5f5f5f5f5f5f5f5f5f5f5f5f5f5fe600", // (n=17, need 17 items, have 16) - wantErr: true, + name: "INVALID_DUPN_LOW", + codeHex: "e65b", + wantErr: &ErrInvalidOpCode{}, + wantOpcode: DUPN, + wantOperand: ptrToByte(0x5b), }, { - name: "UNDERFLOW_SWAPN", - codeHex: "5f5f5f5f5f5f5f5f5f5f5f5f5f5f5f5f5fe700", // (n=17, need 18 items, have 17) - wantErr: true, + name: "INVALID_SWAPN_LOW", + codeHex: "e75b", + wantErr: &ErrInvalidOpCode{}, + wantOpcode: SWAPN, + wantOperand: ptrToByte(0x5b), }, { - name: "UNDERFLOW_EXCHANGE", - codeHex: "60016002e801", // (n,m)=(1,2), need 3 items, have 2 - wantErr: true, + name: "JUMP_OVER_INVALID_DUPN", + codeHex: "600456e65b", + wantErr: nil, }, { - name: "MISSING_IMMEDIATE_DUPN", - codeHex: "e6", // no operand - wantErr: true, + name: "EXCHANGE", + codeHex: "60008080e88e15", + wantVals: []uint64{1, 0, 0}, }, { - name: "MISSING_IMMEDIATE_SWAPN", - codeHex: "e7", // no operand - wantErr: true, + name: "INVALID_EXCHANGE", + codeHex: "e852", + wantErr: &ErrInvalidOpCode{}, + wantOpcode: EXCHANGE, + wantOperand: ptrToByte(0x52), }, { - name: "MISSING_IMMEDIATE_EXCHANGE", - codeHex: "e8", // no operand - wantErr: true, + name: "UNDERFLOW_DUPN", + codeHex: "6000808080808080808080808080808080e680", + wantErr: &ErrStackUnderflow{}, + wantOpcode: DUPN, }, + // Additional test cases { name: "PC_INCREMENT", - codeHex: "600060006000e80115", + codeHex: "600060006000e88e15", wantVals: []uint64{1, 0, 0}, }, } @@ -1117,49 +1129,87 @@ func TestEIP8024_Execution(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { code := common.FromHex(tc.codeHex) - stack := newstack() + stack := newStackForTesting() pc := uint64(0) scope := &ScopeContext{Stack: stack, Contract: &Contract{Code: code}} var err error + var errOp OpCode for pc < uint64(len(code)) && err == nil { op := code[pc] - switch op { - case 0x00: + switch OpCode(op) { + case STOP: return - case 0x60: + case PUSH1: _, err = opPush1(&pc, evm, scope) - case 0x80: + case DUP1: dup1 := makeDup(1) _, err = dup1(&pc, evm, scope) - case 0x56: + case JUMP: _, err = opJump(&pc, evm, scope) - case 0x5b: + case JUMPDEST: _, err = opJumpdest(&pc, evm, scope) - case 0x15: + case ISZERO: _, err = opIszero(&pc, evm, scope) - case 0xe6: + case PUSH0: + _, err = opPush0(&pc, evm, scope) + case DUPN: _, err = opDupN(&pc, evm, scope) - case 0xe7: + case SWAPN: _, err = opSwapN(&pc, evm, scope) - case 0xe8: + case EXCHANGE: _, err = opExchange(&pc, evm, scope) default: - err = &ErrInvalidOpCode{opcode: OpCode(op)} + t.Fatalf("unexpected opcode %s at pc=%d", OpCode(op), pc) + } + if err != nil { + errOp = OpCode(op) } pc++ } - if tc.wantErr { + if tc.wantErr != nil { + // Fail because we wanted an error, but didn't get one. if err == nil { t.Fatalf("expected error, got nil") } + // Fail if the wrong opcode threw an error. + if errOp != tc.wantOpcode { + t.Fatalf("expected error from opcode %s, got %s", tc.wantOpcode, errOp) + } + // Fail if we don't get the error we expect. + switch tc.wantErr.(type) { + case *ErrInvalidOpCode: + var got *ErrInvalidOpCode + if !errors.As(err, &got) { + t.Fatalf("expected ErrInvalidOpCode, got %v", err) + } + if got.opcode != tc.wantOpcode { + t.Fatalf("ErrInvalidOpCode.opcode=%s; want %s", got.opcode, tc.wantOpcode) + } + if tc.wantOperand != nil { + if got.operand == nil { + t.Fatalf("ErrInvalidOpCode.operand=nil; want 0x%02x", *tc.wantOperand) + } + if *got.operand != *tc.wantOperand { + t.Fatalf("ErrInvalidOpCode.operand=0x%02x; want 0x%02x", *got.operand, *tc.wantOperand) + } + } + case *ErrStackUnderflow: + var want *ErrStackUnderflow + if !errors.As(err, &want) { + t.Fatalf("expected ErrStackUnderflow, got %v", err) + } + default: + t.Fatalf("unsupported wantErr type %T", tc.wantErr) + } return } if err != nil { t.Fatalf("unexpected error: %v", err) } got := make([]uint64, 0, stack.len()) - for i := stack.len() - 1; i >= 0; i-- { - got = append(got, stack.data[i].Uint64()) + data := stack.Data() + for i := len(data) - 1; i >= 0; i-- { + got = append(got, data[i].Uint64()) } if len(got) != len(tc.wantVals) { t.Fatalf("stack len=%d; want %d", len(got), len(tc.wantVals)) @@ -1173,3 +1223,8 @@ func TestEIP8024_Execution(t *testing.T) { }) } } + +func ptrToByte(v byte) *byte { + b := v + return &b +} diff --git a/core/vm/interface.go b/core/vm/interface.go index d7f4c10e1f5b..a9938c2a2873 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -22,8 +22,8 @@ import ( "github.com/ethereum/go-ethereum/core/stateless" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/types/bal" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie/utils" "github.com/holiman/uint256" ) @@ -53,24 +53,24 @@ type StateDB interface { GetStateAndCommittedState(common.Address, common.Hash) (common.Hash, common.Hash) GetState(common.Address, common.Hash) common.Hash SetState(common.Address, common.Hash, common.Hash) common.Hash - GetStorageRoot(addr common.Address) common.Hash GetTransientState(addr common.Address, key common.Hash) common.Hash SetTransientState(addr common.Address, key, value common.Hash) - SelfDestruct(common.Address) uint256.Int + SelfDestruct(common.Address) HasSelfDestructed(common.Address) bool - // SelfDestruct6780 is post-EIP6780 selfdestruct, which means that it's a - // send-all-to-beneficiary, unless the contract was created in this same - // transaction, in which case it will be destructed. - // This method returns the prior balance, along with a boolean which is - // true iff the object was indeed destructed. - SelfDestruct6780(common.Address) (uint256.Int, bool) - // Exist reports whether the given account exists in state. // Notably this also returns true for self-destructed accounts within the current transaction. Exist(common.Address) bool + + // Touch accesses the state without returning anything. + Touch(common.Address) + + // IsNewContract reports whether the contract at the given address was deployed + // during the current transaction. + IsNewContract(addr common.Address) bool + // Empty returns whether the given account is empty. Empty // is defined according to EIP161 (balance = nonce = code = 0). Empty(common.Address) bool @@ -84,15 +84,13 @@ type StateDB interface { // even if the feature/fork is not active yet AddSlotToAccessList(addr common.Address, slot common.Hash) - // PointCache returns the point cache used in computations - PointCache() *utils.PointCache - Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) RevertToSnapshot(int) Snapshot() int AddLog(*types.Log) + LogsForBurnAccounts() []*types.Log AddPreimage(common.Hash, []byte) Witness() *stateless.Witness @@ -100,5 +98,6 @@ type StateDB interface { AccessEvents() *state.AccessEvents // Finalise must be invoked at the end of a transaction - Finalise(bool) + Finalise(bool) *bal.ConstructionBlockAccessList + SetTxContext(thash common.Hash, ti int, blockAccessIndex uint32) } diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index 52dbe83d86c7..399432724772 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -27,13 +27,11 @@ import ( // Config are the configuration options for the Interpreter type Config struct { - Tracer *tracing.Hooks + Tracer *tracing.Hooks + NoBaseFee bool // Forces the EIP-1559 baseFee to 0 (needed for 0 price calls) EnablePreimageRecording bool // Enables recording of SHA3/keccak preimages ExtraEips []int // Additional EIPS that are to be enabled - - StatelessSelfValidation bool // Generate execution witnesses and self-check against them (testing purpose) - EnableWitnessStats bool // Whether trie access statistics collection is enabled } // ScopeContext contains the things that are per-call, such as stack and memory, @@ -118,8 +116,8 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte var ( op OpCode // current opcode jumpTable *JumpTable = evm.table - mem = NewMemory() // bound memory - stack = newstack() // local stack + mem = NewMemory() // bound memory + stack = evm.arena.stack() // local stack callContext = &ScopeContext{ Memory: mem, Stack: stack, @@ -142,7 +140,7 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte // so that it gets executed _after_: the OnOpcode needs the stacks before // they are returned to the pools defer func() { - returnStack(stack) + stack.release() mem.Free() }() contract.Input = input @@ -168,15 +166,15 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte for { if debug { // Capture pre-execution values for tracing. - logged, pcCopy, gasCopy = false, pc, contract.Gas + logged, pcCopy, gasCopy = false, pc, contract.Gas.RegularGas } if isEIP4762 && !contract.IsDeployment && !contract.IsSystemCall { // if the PC ends up in a new "chunk" of verkleized code, charge the // associated costs. contractAddr := contract.Address() - consumed, wanted := evm.TxContext.AccessEvents.CodeChunksRangeGas(contractAddr, pc, 1, uint64(len(contract.Code)), false, contract.Gas) - contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) + consumed, wanted := evm.TxContext.AccessEvents.CodeChunksRangeGas(contractAddr, pc, 1, uint64(len(contract.Code)), false, contract.Gas.RegularGas) + contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) if consumed < wanted { return nil, ErrOutOfGas } @@ -194,10 +192,10 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack} } // for tracing: this gas consumption event is emitted below in the debug section. - if contract.Gas < cost { + if contract.Gas.RegularGas < cost { return nil, ErrOutOfGas } else { - contract.Gas -= cost + contract.Gas.RegularGas -= cost } // All ops with a dynamic memory usage also has a dynamic gas cost. @@ -220,24 +218,28 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte } // Consume the gas and return an error if not enough gas is available. // cost is explicitly set so that the capture state defer method can get the proper cost - var dynamicCost uint64 + var dynamicCost GasCosts dynamicCost, err = operation.dynamicGas(evm, contract, stack, mem, memorySize) - cost += dynamicCost // for tracing + cost += dynamicCost.RegularGas // for tracing if err != nil { return nil, fmt.Errorf("%w: %v", ErrOutOfGas, err) } // for tracing: this gas consumption event is emitted below in the debug section. - if contract.Gas < dynamicCost { + if contract.Gas.RegularGas < dynamicCost.RegularGas { return nil, ErrOutOfGas } else { - contract.Gas -= dynamicCost + contract.Gas.RegularGas -= dynamicCost.RegularGas } } // Do tracing before potential memory expansion if debug { - if evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gasCopy, gasCopy-cost, tracing.GasChangeCallOpCode) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange( + tracing.Gas{Regular: gasCopy, State: contract.Gas.StateGas}, + tracing.Gas{Regular: gasCopy - cost, State: contract.Gas.StateGas}, + tracing.GasChangeCallOpCode, + ) } if evm.Config.Tracer.OnOpcode != nil { evm.Config.Tracer.OnOpcode(pc, byte(op), gasCopy, cost, callContext, evm.returnData, evm.depth, VMErrorFromErr(err)) diff --git a/core/vm/interpreter_test.go b/core/vm/interpreter_test.go index 79531f78d288..868cb12d04e3 100644 --- a/core/vm/interpreter_test.go +++ b/core/vm/interpreter_test.go @@ -40,7 +40,7 @@ var loopInterruptTests = []string{ func TestLoopInterrupt(t *testing.T) { address := common.BytesToAddress([]byte("contract")) vmctx := BlockContext{ - Transfer: func(StateDB, common.Address, common.Address, *uint256.Int) {}, + Transfer: func(StateDB, common.Address, common.Address, *uint256.Int, *params.Rules) {}, } for i, tt := range loopInterruptTests { @@ -55,7 +55,7 @@ func TestLoopInterrupt(t *testing.T) { timeout := make(chan bool) go func(evm *EVM) { - _, _, err := evm.Call(common.Address{}, address, nil, math.MaxUint64, new(uint256.Int)) + _, _, err := evm.Call(common.Address{}, address, nil, NewGasBudget(math.MaxUint64), new(uint256.Int)) errChannel <- err }(evm) @@ -83,9 +83,9 @@ func BenchmarkInterpreter(b *testing.B) { evm = NewEVM(BlockContext{BlockNumber: big.NewInt(1), Time: 1, Random: &common.Hash{}}, statedb, params.MergedTestChainConfig, Config{}) startGas uint64 = 100_000_000 value = uint256.NewInt(0) - stack = newstack() + stack = newStackForTesting() mem = NewMemory() - contract = NewContract(common.Address{}, common.Address{}, value, startGas, nil) + contract = NewContract(common.Address{}, common.Address{}, value, NewGasBudget(startGas), nil) ) stack.push(uint256.NewInt(123)) stack.push(uint256.NewInt(123)) diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go index d7a4d9da1d93..82fc43ec1327 100644 --- a/core/vm/jump_table.go +++ b/core/vm/jump_table.go @@ -24,7 +24,7 @@ import ( type ( executionFunc func(pc *uint64, evm *EVM, callContext *ScopeContext) ([]byte, error) - gasFunc func(*EVM, *Contract, *Stack, *Memory, uint64) (uint64, error) // last parameter is the requested memory size as a uint64 + gasFunc func(*EVM, *Contract, *Stack, *Memory, uint64) (GasCosts, error) // last parameter is the requested memory size as a uint64 // memorySizeFunc returns the required size, and whether the operation overflowed a uint64 memorySizeFunc func(*Stack) (size uint64, overflow bool) ) @@ -63,6 +63,7 @@ var ( verkleInstructionSet = newVerkleInstructionSet() pragueInstructionSet = newPragueInstructionSet() osakaInstructionSet = newOsakaInstructionSet() + amsterdamInstructionSet = newAmsterdamInstructionSet() ) // JumpTable contains the EVM opcodes supported at a given fork. @@ -92,6 +93,13 @@ func newVerkleInstructionSet() JumpTable { return validate(instructionSet) } +func newAmsterdamInstructionSet() JumpTable { + instructionSet := newOsakaInstructionSet() + enable7843(&instructionSet) // EIP-7843 (SLOTNUM opcode) + enable8024(&instructionSet) // EIP-8024 (Backward compatible SWAPN, DUPN, EXCHANGE) + return validate(instructionSet) +} + func newOsakaInstructionSet() JumpTable { instructionSet := newPragueInstructionSet() enable7939(&instructionSet) // EIP-7939 (CLZ opcode) diff --git a/core/vm/jump_table_export.go b/core/vm/jump_table_export.go index 89a2ebf6f4f1..a4a99ea49823 100644 --- a/core/vm/jump_table_export.go +++ b/core/vm/jump_table_export.go @@ -26,8 +26,10 @@ import ( // the rules. func LookupInstructionSet(rules params.Rules) (JumpTable, error) { switch { - case rules.IsVerkle: + case rules.IsUBT: return newCancunInstructionSet(), errors.New("verkle-fork not defined yet") + case rules.IsAmsterdam: + return newAmsterdamInstructionSet(), nil case rules.IsOsaka: return newOsakaInstructionSet(), nil case rules.IsPrague: diff --git a/core/vm/memory_table.go b/core/vm/memory_table.go index 63ad9678501e..8f30cbeee652 100644 --- a/core/vm/memory_table.go +++ b/core/vm/memory_table.go @@ -17,59 +17,59 @@ package vm func memoryKeccak256(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(1)) + return calcMemSize64(stack.back(0), stack.back(1)) } func memoryCallDataCopy(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(2)) + return calcMemSize64(stack.back(0), stack.back(2)) } func memoryReturnDataCopy(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(2)) + return calcMemSize64(stack.back(0), stack.back(2)) } func memoryCodeCopy(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(2)) + return calcMemSize64(stack.back(0), stack.back(2)) } func memoryExtCodeCopy(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(1), stack.Back(3)) + return calcMemSize64(stack.back(1), stack.back(3)) } func memoryMLoad(stack *Stack) (uint64, bool) { - return calcMemSize64WithUint(stack.Back(0), 32) + return calcMemSize64WithUint(stack.back(0), 32) } func memoryMStore8(stack *Stack) (uint64, bool) { - return calcMemSize64WithUint(stack.Back(0), 1) + return calcMemSize64WithUint(stack.back(0), 1) } func memoryMStore(stack *Stack) (uint64, bool) { - return calcMemSize64WithUint(stack.Back(0), 32) + return calcMemSize64WithUint(stack.back(0), 32) } func memoryMcopy(stack *Stack) (uint64, bool) { - mStart := stack.Back(0) // stack[0]: dest - if stack.Back(1).Gt(mStart) { - mStart = stack.Back(1) // stack[1]: source + mStart := stack.back(0) // stack[0]: dest + if stack.back(1).Gt(mStart) { + mStart = stack.back(1) // stack[1]: source } - return calcMemSize64(mStart, stack.Back(2)) // stack[2]: length + return calcMemSize64(mStart, stack.back(2)) // stack[2]: length } func memoryCreate(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(1), stack.Back(2)) + return calcMemSize64(stack.back(1), stack.back(2)) } func memoryCreate2(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(1), stack.Back(2)) + return calcMemSize64(stack.back(1), stack.back(2)) } func memoryCall(stack *Stack) (uint64, bool) { - x, overflow := calcMemSize64(stack.Back(5), stack.Back(6)) + x, overflow := calcMemSize64(stack.back(5), stack.back(6)) if overflow { return 0, true } - y, overflow := calcMemSize64(stack.Back(3), stack.Back(4)) + y, overflow := calcMemSize64(stack.back(3), stack.back(4)) if overflow { return 0, true } @@ -80,11 +80,11 @@ func memoryCall(stack *Stack) (uint64, bool) { } func memoryDelegateCall(stack *Stack) (uint64, bool) { - x, overflow := calcMemSize64(stack.Back(4), stack.Back(5)) + x, overflow := calcMemSize64(stack.back(4), stack.back(5)) if overflow { return 0, true } - y, overflow := calcMemSize64(stack.Back(2), stack.Back(3)) + y, overflow := calcMemSize64(stack.back(2), stack.back(3)) if overflow { return 0, true } @@ -95,11 +95,11 @@ func memoryDelegateCall(stack *Stack) (uint64, bool) { } func memoryStaticCall(stack *Stack) (uint64, bool) { - x, overflow := calcMemSize64(stack.Back(4), stack.Back(5)) + x, overflow := calcMemSize64(stack.back(4), stack.back(5)) if overflow { return 0, true } - y, overflow := calcMemSize64(stack.Back(2), stack.Back(3)) + y, overflow := calcMemSize64(stack.back(2), stack.back(3)) if overflow { return 0, true } @@ -110,13 +110,13 @@ func memoryStaticCall(stack *Stack) (uint64, bool) { } func memoryReturn(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(1)) + return calcMemSize64(stack.back(0), stack.back(1)) } func memoryRevert(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(1)) + return calcMemSize64(stack.back(0), stack.back(1)) } func memoryLog(stack *Stack) (uint64, bool) { - return calcMemSize64(stack.Back(0), stack.Back(1)) + return calcMemSize64(stack.back(0), stack.back(1)) } diff --git a/core/vm/opcodes.go b/core/vm/opcodes.go index 9a32126a80b7..cb871dca6db1 100644 --- a/core/vm/opcodes.go +++ b/core/vm/opcodes.go @@ -105,6 +105,7 @@ const ( BASEFEE OpCode = 0x48 BLOBHASH OpCode = 0x49 BLOBBASEFEE OpCode = 0x4a + SLOTNUM OpCode = 0x4b ) // 0x50 range - 'storage' and execution. @@ -320,6 +321,7 @@ var opCodeToString = [256]string{ BASEFEE: "BASEFEE", BLOBHASH: "BLOBHASH", BLOBBASEFEE: "BLOBBASEFEE", + SLOTNUM: "SLOTNUM", // 0x50 range - 'storage' and execution. POP: "POP", @@ -502,6 +504,7 @@ var stringToOp = map[string]OpCode{ "BASEFEE": BASEFEE, "BLOBHASH": BLOBHASH, "BLOBBASEFEE": BLOBBASEFEE, + "SLOTNUM": SLOTNUM, "DELEGATECALL": DELEGATECALL, "STATICCALL": STATICCALL, "CODESIZE": CODESIZE, diff --git a/core/vm/operations_acl.go b/core/vm/operations_acl.go index 085b018e4c42..86ac262a9349 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -27,14 +27,17 @@ import ( ) func makeGasSStoreFunc(clearingRefund uint64) gasFunc { - return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + if evm.readOnly { + return GasCosts{}, ErrWriteProtection + } // If we fail the minimum gas availability invariant, fail (0) - if contract.Gas <= params.SstoreSentryGasEIP2200 { - return 0, errors.New("not enough gas for reentrancy sentry") + if contract.Gas.RegularGas <= params.SstoreSentryGasEIP2200 { + return GasCosts{}, errors.New("not enough gas for reentrancy sentry") } // Gas sentry honoured, do the actual gas calculation based on the stored value var ( - y, x = stack.Back(1), stack.peek() + y, x = stack.back(1), stack.peek() slot = common.Hash(x.Bytes32()) current, original = evm.StateDB.GetStateAndCommittedState(contract.Address(), slot) cost = uint64(0) @@ -50,18 +53,18 @@ func makeGasSStoreFunc(clearingRefund uint64) gasFunc { if current == value { // noop (1) // EIP 2200 original clause: // return params.SloadGasEIP2200, nil - return cost + params.WarmStorageReadCostEIP2929, nil // SLOAD_GAS + return GasCosts{RegularGas: cost + params.WarmStorageReadCostEIP2929}, nil // SLOAD_GAS } if original == current { if original == (common.Hash{}) { // create slot (2.1.1) - return cost + params.SstoreSetGasEIP2200, nil + return GasCosts{RegularGas: cost + params.SstoreSetGasEIP2200}, nil } if value == (common.Hash{}) { // delete slot (2.1.2b) evm.StateDB.AddRefund(clearingRefund) } // EIP-2200 original clause: // return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2) - return cost + (params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929), nil // write existing slot (2.1.2) + return GasCosts{RegularGas: cost + (params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929)}, nil // write existing slot (2.1.2) } if original != (common.Hash{}) { if current == (common.Hash{}) { // recreate slot (2.2.1.1) @@ -86,7 +89,7 @@ func makeGasSStoreFunc(clearingRefund uint64) gasFunc { } // EIP-2200 original clause: //return params.SloadGasEIP2200, nil // dirty update (2.2) - return cost + params.WarmStorageReadCostEIP2929, nil // dirty update (2.2) + return GasCosts{RegularGas: cost + params.WarmStorageReadCostEIP2929}, nil // dirty update (2.2) } } @@ -95,7 +98,7 @@ func makeGasSStoreFunc(clearingRefund uint64) gasFunc { // whose storage is being read) is not yet in accessed_storage_keys, // charge 2100 gas and add the pair to accessed_storage_keys. // If the pair is already in accessed_storage_keys, charge 100 gas. -func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { loc := stack.peek() slot := common.Hash(loc.Bytes32()) // Check slot presence in the access list @@ -103,9 +106,9 @@ func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me // If the caller cannot afford the cost, this change will be rolled back // If he does afford it, we can skip checking the same thing later on, during execution evm.StateDB.AddSlotToAccessList(contract.Address(), slot) - return params.ColdSloadCostEIP2929, nil + return GasCosts{RegularGas: params.ColdSloadCostEIP2929}, nil } - return params.WarmStorageReadCostEIP2929, nil + return GasCosts{RegularGas: params.WarmStorageReadCostEIP2929}, nil } // gasExtCodeCopyEIP2929 implements extcodecopy according to EIP-2929 @@ -113,12 +116,13 @@ func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me // > If the target is not in accessed_addresses, // > charge COLD_ACCOUNT_ACCESS_COST gas, and add the address to accessed_addresses. // > Otherwise, charge WARM_STORAGE_READ_COST gas. -func gasExtCodeCopyEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasExtCodeCopyEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { // memory expansion first (dynamic part of pre-2929 implementation) - gas, err := gasExtCodeCopy(evm, contract, stack, mem, memorySize) + gasCost, err := gasExtCodeCopy(evm, contract, stack, mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } + gas := gasCost.RegularGas addr := common.Address(stack.peek().Bytes20()) // Check slot presence in the access list if !evm.StateDB.AddressInAccessList(addr) { @@ -126,11 +130,11 @@ func gasExtCodeCopyEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memo var overflow bool // We charge (cold-warm), since 'warm' is already charged as constantGas if gas, overflow = math.SafeAdd(gas, params.ColdAccountAccessCostEIP2929-params.WarmStorageReadCostEIP2929); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } - return gas, nil + return GasCosts{RegularGas: gas}, nil } // gasEip2929AccountCheck checks whether the first stack item (as address) is present in the access list. @@ -140,21 +144,21 @@ func gasExtCodeCopyEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memo // - extcodehash, // - extcodesize, // - (ext) balance -func gasEip2929AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasEip2929AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { addr := common.Address(stack.peek().Bytes20()) // Check slot presence in the access list if !evm.StateDB.AddressInAccessList(addr) { // If the caller cannot afford the cost, this change will be rolled back evm.StateDB.AddAddressToAccessList(addr) // The warm storage read cost is already charged as constantGas - return params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929, nil + return GasCosts{RegularGas: params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929}, nil } - return 0, nil + return GasCosts{}, nil } func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) gasFunc { - return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - addr := common.Address(stack.Back(addressPosition).Bytes20()) + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + addr := common.Address(stack.back(addressPosition).Bytes20()) // Check slot presence in the access list warmAccess := evm.StateDB.AddressInAccessList(addr) // The WarmStorageReadCostEIP2929 (100) is already deducted in the form of a constant cost, so @@ -164,8 +168,8 @@ func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) g evm.StateDB.AddAddressToAccessList(addr) // Charge the remaining difference here already, to correctly calculate available // gas for call - if !contract.UseGas(coldCost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { - return 0, ErrOutOfGas + if !contract.UseGas(GasCosts{RegularGas: coldCost}, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { + return GasCosts{}, ErrOutOfGas } } // Now call the old calculator, which takes into account @@ -173,21 +177,22 @@ func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) g // - transfer value // - memory expansion // - 63/64ths rule - gas, err := oldCalculator(evm, contract, stack, mem, memorySize) + gasCost, err := oldCalculator(evm, contract, stack, mem, memorySize) if warmAccess || err != nil { - return gas, err + return gasCost, err } // In case of a cold access, we temporarily add the cold charge back, and also // add it to the returned gas. By adding it to the return, it will be charged // outside of this function, as part of the dynamic gas, and that will make it // also become correctly reported to tracers. - contract.Gas += coldCost + contract.Gas.RegularGas += coldCost + gas := gasCost.RegularGas var overflow bool if gas, overflow = math.SafeAdd(gas, coldCost); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } } @@ -221,15 +226,24 @@ var ( // makeSelfdestructGasFn can create the selfdestruct dynamic gas function for EIP-2929 and EIP-3529 func makeSelfdestructGasFn(refundsEnabled bool) gasFunc { - gasFunc := func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + gasFunc := func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { var ( gas uint64 address = common.Address(stack.peek().Bytes20()) ) + if evm.readOnly { + return GasCosts{}, ErrWriteProtection + } if !evm.StateDB.AddressInAccessList(address) { // If the caller cannot afford the cost, this change will be rolled back evm.StateDB.AddAddressToAccessList(address) gas = params.ColdAccountAccessCostEIP2929 + + // Terminate the gas measurement if the leftover gas is not sufficient, + // it can effectively prevent accessing the states in the following steps + if contract.Gas.RegularGas < gas { + return GasCosts{}, ErrOutOfGas + } } // if empty and transfers value if evm.StateDB.Empty(address) && evm.StateDB.GetBalance(contract.Address()).Sign() != 0 { @@ -238,74 +252,109 @@ func makeSelfdestructGasFn(refundsEnabled bool) gasFunc { if refundsEnabled && !evm.StateDB.HasSelfDestructed(contract.Address()) { evm.StateDB.AddRefund(params.SelfdestructRefundGas) } - return gas, nil + return GasCosts{RegularGas: gas}, nil } return gasFunc } var ( - gasCallEIP7702 = makeCallVariantGasCallEIP7702(gasCall) - gasDelegateCallEIP7702 = makeCallVariantGasCallEIP7702(gasDelegateCall) - gasStaticCallEIP7702 = makeCallVariantGasCallEIP7702(gasStaticCall) - gasCallCodeEIP7702 = makeCallVariantGasCallEIP7702(gasCallCode) + innerGasCallEIP7702 = makeCallVariantGasCallEIP7702(gasCallIntrinsic) + gasDelegateCallEIP7702 = makeCallVariantGasCallEIP7702(gasDelegateCallIntrinsic) + gasStaticCallEIP7702 = makeCallVariantGasCallEIP7702(gasStaticCallIntrinsic) + gasCallCodeEIP7702 = makeCallVariantGasCallEIP7702(gasCallCodeIntrinsic) ) -func makeCallVariantGasCallEIP7702(oldCalculator gasFunc) gasFunc { - return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasCallEIP7702(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + // Return early if this call attempts to transfer value in a static context. + // Although it's checked in `gasCall`, EIP-7702 loads the target's code before + // to determine if it is resolving a delegation. This could incorrectly record + // the target in the block access list (BAL) if the call later fails. + transfersValue := !stack.back(2).IsZero() + if evm.readOnly && transfersValue { + return GasCosts{}, ErrWriteProtection + } + return innerGasCallEIP7702(evm, contract, stack, mem, memorySize) +} + +func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { var ( - total uint64 // total dynamic gas used - addr = common.Address(stack.Back(1).Bytes20()) + eip2929Cost uint64 + eip7702Cost uint64 + addr = common.Address(stack.back(1).Bytes20()) ) - - // Check slot presence in the access list + // Perform EIP-2929 checks (stateless), checking address presence + // in the accessList and charge the cold access accordingly. if !evm.StateDB.AddressInAccessList(addr) { evm.StateDB.AddAddressToAccessList(addr) - // The WarmStorageReadCostEIP2929 (100) is already deducted in the form of a constant cost, so - // the cost to charge for cold access, if any, is Cold - Warm - coldCost := params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929 - // Charge the remaining difference here already, to correctly calculate available - // gas for call - if !contract.UseGas(coldCost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { - return 0, ErrOutOfGas + + // The WarmStorageReadCostEIP2929 (100) is already deducted in the form + // of a constant cost, so the cost to charge for cold access, if any, + // is Cold - Warm + eip2929Cost = params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929 + + // Charge the remaining difference here already, to correctly calculate + // available gas for call + if !contract.UseGas(GasCosts{RegularGas: eip2929Cost}, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { + return GasCosts{}, ErrOutOfGas } - total += coldCost + } + + // Perform the intrinsic cost calculation including: + // + // - transfer value + // - memory expansion + // - create new account + intrinsicCost, err := intrinsicFunc(evm, contract, stack, mem, memorySize) + if err != nil { + return GasCosts{}, err + } + // Terminate the gas measurement if the leftover gas is not sufficient, + // it can effectively prevent accessing the states in the following steps. + // It's an essential safeguard before any stateful check. + if contract.Gas.RegularGas < intrinsicCost.RegularGas { + return GasCosts{}, ErrOutOfGas } // Check if code is a delegation and if so, charge for resolution. if target, ok := types.ParseDelegation(evm.StateDB.GetCode(addr)); ok { - var cost uint64 if evm.StateDB.AddressInAccessList(target) { - cost = params.WarmStorageReadCostEIP2929 + eip7702Cost = params.WarmStorageReadCostEIP2929 } else { evm.StateDB.AddAddressToAccessList(target) - cost = params.ColdAccountAccessCostEIP2929 + eip7702Cost = params.ColdAccountAccessCostEIP2929 } - if !contract.UseGas(cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { - return 0, ErrOutOfGas + if !contract.UseGas(GasCosts{RegularGas: eip7702Cost}, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { + return GasCosts{}, ErrOutOfGas } - total += cost } - - // Now call the old calculator, which takes into account - // - create new account - // - transfer value - // - memory expansion - // - 63/64ths rule - old, err := oldCalculator(evm, contract, stack, mem, memorySize) + // Calculate the gas budget for the nested call. The costs defined by + // EIP-2929 and EIP-7702 have already been applied. + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsicCost.RegularGas, stack.back(0)) if err != nil { - return old, err + return GasCosts{}, err } - // Temporarily add the gas charge back to the contract and return value. By // adding it to the return, it will be charged outside of this function, as // part of the dynamic gas. This will ensure it is correctly reported to // tracers. - contract.Gas += total + contract.Gas.RegularGas += eip2929Cost + eip7702Cost - var overflow bool - if total, overflow = math.SafeAdd(old, total); overflow { - return 0, ErrGasUintOverflow + // Aggregate the gas costs from all components, including EIP-2929, EIP-7702, + // the CALL opcode itself, and the cost incurred by nested calls. + var ( + overflow bool + totalCost uint64 + ) + if totalCost, overflow = math.SafeAdd(eip2929Cost, eip7702Cost); overflow { + return GasCosts{}, ErrGasUintOverflow + } + if totalCost, overflow = math.SafeAdd(totalCost, intrinsicCost.RegularGas); overflow { + return GasCosts{}, ErrGasUintOverflow + } + if totalCost, overflow = math.SafeAdd(totalCost, evm.callGasTemp); overflow { + return GasCosts{}, ErrGasUintOverflow } - return total, nil + return GasCosts{RegularGas: totalCost}, nil } } diff --git a/core/vm/operations_verkle.go b/core/vm/operations_verkle.go index 30f99577754c..4d3960a174b8 100644 --- a/core/vm/operations_verkle.go +++ b/core/vm/operations_verkle.go @@ -24,39 +24,39 @@ import ( "github.com/ethereum/go-ethereum/params" ) -func gasSStore4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - return evm.AccessEvents.SlotGas(contract.Address(), stack.peek().Bytes32(), true, contract.Gas, true), nil +func gasSStore4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + return GasCosts{RegularGas: evm.AccessEvents.SlotGas(contract.Address(), stack.peek().Bytes32(), true, contract.Gas.RegularGas, true)}, nil } -func gasSLoad4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - return evm.AccessEvents.SlotGas(contract.Address(), stack.peek().Bytes32(), false, contract.Gas, true), nil +func gasSLoad4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + return GasCosts{RegularGas: evm.AccessEvents.SlotGas(contract.Address(), stack.peek().Bytes32(), false, contract.Gas.RegularGas, true)}, nil } -func gasBalance4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasBalance4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { address := stack.peek().Bytes20() - return evm.AccessEvents.BasicDataGas(address, false, contract.Gas, true), nil + return GasCosts{RegularGas: evm.AccessEvents.BasicDataGas(address, false, contract.Gas.RegularGas, true)}, nil } -func gasExtCodeSize4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasExtCodeSize4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { address := stack.peek().Bytes20() if _, isPrecompile := evm.precompile(address); isPrecompile { - return 0, nil + return GasCosts{}, nil } - return evm.AccessEvents.BasicDataGas(address, false, contract.Gas, true), nil + return GasCosts{RegularGas: evm.AccessEvents.BasicDataGas(address, false, contract.Gas.RegularGas, true)}, nil } -func gasExtCodeHash4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasExtCodeHash4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { address := stack.peek().Bytes20() if _, isPrecompile := evm.precompile(address); isPrecompile { - return 0, nil + return GasCosts{}, nil } - return evm.AccessEvents.CodeHashGas(address, false, contract.Gas, true), nil + return GasCosts{RegularGas: evm.AccessEvents.CodeHashGas(address, false, contract.Gas.RegularGas, true)}, nil } func makeCallVariantGasEIP4762(oldCalculator gasFunc, withTransferCosts bool) gasFunc { - return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { var ( - target = common.Address(stack.Back(1).Bytes20()) + target = common.Address(stack.back(1).Bytes20()) witnessGas uint64 _, isPrecompile = evm.precompile(target) isSystemContract = target == params.HistoryStorageAddress @@ -64,10 +64,10 @@ func makeCallVariantGasEIP4762(oldCalculator gasFunc, withTransferCosts bool) ga // If value is transferred, it is charged before 1/64th // is subtracted from the available gas pool. - if withTransferCosts && !stack.Back(2).IsZero() { - wantedValueTransferWitnessGas := evm.AccessEvents.ValueTransferGas(contract.Address(), target, contract.Gas) - if wantedValueTransferWitnessGas > contract.Gas { - return wantedValueTransferWitnessGas, nil + if withTransferCosts && !stack.back(2).IsZero() { + wantedValueTransferWitnessGas := evm.AccessEvents.ValueTransferGas(contract.Address(), target, contract.Gas.RegularGas) + if wantedValueTransferWitnessGas > contract.Gas.RegularGas { + return GasCosts{RegularGas: wantedValueTransferWitnessGas}, nil } witnessGas = wantedValueTransferWitnessGas } else if isPrecompile || isSystemContract { @@ -78,25 +78,26 @@ func makeCallVariantGasEIP4762(oldCalculator gasFunc, withTransferCosts bool) ga // (so before we get to this point) // But the message call is part of the subcall, for which only 63/64th // of the gas should be available. - wantedMessageCallWitnessGas := evm.AccessEvents.MessageCallGas(target, contract.Gas-witnessGas) + wantedMessageCallWitnessGas := evm.AccessEvents.MessageCallGas(target, contract.Gas.RegularGas-witnessGas) var overflow bool if witnessGas, overflow = math.SafeAdd(witnessGas, wantedMessageCallWitnessGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - if witnessGas > contract.Gas { - return witnessGas, nil + if witnessGas > contract.Gas.RegularGas { + return GasCosts{RegularGas: witnessGas}, nil } } - contract.Gas -= witnessGas + contract.Gas.RegularGas -= witnessGas // if the operation fails, adds witness gas to the gas before returning the error - gas, err := oldCalculator(evm, contract, stack, mem, memorySize) - contract.Gas += witnessGas // restore witness gas so that it can be charged at the callsite + gasCost, err := oldCalculator(evm, contract, stack, mem, memorySize) + contract.Gas.RegularGas += witnessGas // restore witness gas so that it can be charged at the callsite + gas := gasCost.RegularGas var overflow bool if gas, overflow = math.SafeAdd(gas, witnessGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, err + return GasCosts{RegularGas: gas}, err } } @@ -107,18 +108,18 @@ var ( gasDelegateCallEIP4762 = makeCallVariantGasEIP4762(gasDelegateCall, false) ) -func gasSelfdestructEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasSelfdestructEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { beneficiaryAddr := common.Address(stack.peek().Bytes20()) if _, isPrecompile := evm.precompile(beneficiaryAddr); isPrecompile { - return 0, nil + return GasCosts{}, nil } if contract.IsSystemCall { - return 0, nil + return GasCosts{}, nil } contractAddr := contract.Address() - wanted := evm.AccessEvents.BasicDataGas(contractAddr, false, contract.Gas, false) - if wanted > contract.Gas { - return wanted, nil + wanted := evm.AccessEvents.BasicDataGas(contractAddr, false, contract.Gas.RegularGas, false) + if wanted > contract.Gas.RegularGas { + return GasCosts{RegularGas: wanted}, nil } statelessGas := wanted balanceIsZero := evm.StateDB.GetBalance(contractAddr).Sign() == 0 @@ -126,48 +127,49 @@ func gasSelfdestructEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Mem isSystemContract := beneficiaryAddr == params.HistoryStorageAddress if (isPrecompile || isSystemContract) && balanceIsZero { - return statelessGas, nil + return GasCosts{RegularGas: statelessGas}, nil } if contractAddr != beneficiaryAddr { - wanted := evm.AccessEvents.BasicDataGas(beneficiaryAddr, false, contract.Gas-statelessGas, false) - if wanted > contract.Gas-statelessGas { - return statelessGas + wanted, nil + wanted := evm.AccessEvents.BasicDataGas(beneficiaryAddr, false, contract.Gas.RegularGas-statelessGas, false) + if wanted > contract.Gas.RegularGas-statelessGas { + return GasCosts{RegularGas: statelessGas + wanted}, nil } statelessGas += wanted } // Charge write costs if it transfers value if !balanceIsZero { - wanted := evm.AccessEvents.BasicDataGas(contractAddr, true, contract.Gas-statelessGas, false) - if wanted > contract.Gas-statelessGas { - return statelessGas + wanted, nil + wanted := evm.AccessEvents.BasicDataGas(contractAddr, true, contract.Gas.RegularGas-statelessGas, false) + if wanted > contract.Gas.RegularGas-statelessGas { + return GasCosts{RegularGas: statelessGas + wanted}, nil } statelessGas += wanted if contractAddr != beneficiaryAddr { if evm.StateDB.Exist(beneficiaryAddr) { - wanted = evm.AccessEvents.BasicDataGas(beneficiaryAddr, true, contract.Gas-statelessGas, false) + wanted = evm.AccessEvents.BasicDataGas(beneficiaryAddr, true, contract.Gas.RegularGas-statelessGas, false) } else { - wanted = evm.AccessEvents.AddAccount(beneficiaryAddr, true, contract.Gas-statelessGas) + wanted = evm.AccessEvents.AddAccount(beneficiaryAddr, true, contract.Gas.RegularGas-statelessGas) } - if wanted > contract.Gas-statelessGas { - return statelessGas + wanted, nil + if wanted > contract.Gas.RegularGas-statelessGas { + return GasCosts{RegularGas: statelessGas + wanted}, nil } statelessGas += wanted } } - return statelessGas, nil + return GasCosts{RegularGas: statelessGas}, nil } -func gasCodeCopyEip4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - gas, err := gasCodeCopy(evm, contract, stack, mem, memorySize) +func gasCodeCopyEip4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { + gasCost, err := gasCodeCopy(evm, contract, stack, mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } + gas := gasCost.RegularGas if !contract.IsDeployment && !contract.IsSystemCall { var ( - codeOffset = stack.Back(1) - length = stack.Back(2) + codeOffset = stack.back(1) + length = stack.back(2) ) uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow() if overflow { @@ -175,31 +177,32 @@ func gasCodeCopyEip4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, } _, copyOffset, nonPaddedCopyLength := getDataAndAdjustedBounds(contract.Code, uint64CodeOffset, length.Uint64()) - _, wanted := evm.AccessEvents.CodeChunksRangeGas(contract.Address(), copyOffset, nonPaddedCopyLength, uint64(len(contract.Code)), false, contract.Gas-gas) + _, wanted := evm.AccessEvents.CodeChunksRangeGas(contract.Address(), copyOffset, nonPaddedCopyLength, uint64(len(contract.Code)), false, contract.Gas.RegularGas-gas) gas += wanted } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasExtCodeCopyEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +func gasExtCodeCopyEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { // memory expansion first (dynamic part of pre-2929 implementation) - gas, err := gasExtCodeCopy(evm, contract, stack, mem, memorySize) + gasCost, err := gasExtCodeCopy(evm, contract, stack, mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } + gas := gasCost.RegularGas addr := common.Address(stack.peek().Bytes20()) _, isPrecompile := evm.precompile(addr) if isPrecompile || addr == params.HistoryStorageAddress { var overflow bool if gas, overflow = math.SafeAdd(gas, params.WarmStorageReadCostEIP2929); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } - wgas := evm.AccessEvents.BasicDataGas(addr, false, contract.Gas-gas, true) + wgas := evm.AccessEvents.BasicDataGas(addr, false, contract.Gas.RegularGas-gas, true) var overflow bool if gas, overflow = math.SafeAdd(gas, wgas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } diff --git a/core/vm/runtime/env.go b/core/vm/runtime/env.go index e54041f7e277..4181e08ee8cc 100644 --- a/core/vm/runtime/env.go +++ b/core/vm/runtime/env.go @@ -19,14 +19,14 @@ package runtime import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/vm" + "github.com/holiman/uint256" ) func NewEnv(cfg *Config) *vm.EVM { txContext := vm.TxContext{ Origin: cfg.Origin, - GasPrice: cfg.GasPrice, + GasPrice: uint256.MustFromBig(cfg.GasPrice), BlobHashes: cfg.BlobHashes, - BlobFeeCap: cfg.BlobFeeCap, } blockContext := vm.BlockContext{ CanTransfer: core.CanTransfer, diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index b40e99d0470f..4fafdf3a5049 100644 --- a/core/vm/runtime/runtime.go +++ b/core/vm/runtime/runtime.go @@ -109,7 +109,9 @@ func setDefaults(cfg *Config) { if cfg.BlobBaseFee == nil { cfg.BlobBaseFee = big.NewInt(params.BlobTxMinBlobGasprice) } - cfg.Random = &(common.Hash{}) + if cfg.Random == nil { + cfg.Random = new(common.Hash) + } } // Execute executes the code using the input as call data during the execution. @@ -146,11 +148,11 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { cfg.Origin, common.BytesToAddress([]byte("contract")), input, - cfg.GasLimit, + vm.NewGasBudget(cfg.GasLimit), uint256.MustFromBig(cfg.Value), ) if cfg.EVMConfig.Tracer != nil && cfg.EVMConfig.Tracer.OnTxEnd != nil { - cfg.EVMConfig.Tracer.OnTxEnd(&types.Receipt{GasUsed: cfg.GasLimit - leftOverGas}, err) + cfg.EVMConfig.Tracer.OnTxEnd(&types.Receipt{GasUsed: cfg.GasLimit - leftOverGas.RegularGas}, err) } return ret, cfg.State, err } @@ -180,13 +182,13 @@ func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) { code, address, leftOverGas, err := vmenv.Create( cfg.Origin, input, - cfg.GasLimit, + vm.NewGasBudget(cfg.GasLimit), uint256.MustFromBig(cfg.Value), ) if cfg.EVMConfig.Tracer != nil && cfg.EVMConfig.Tracer.OnTxEnd != nil { - cfg.EVMConfig.Tracer.OnTxEnd(&types.Receipt{GasUsed: cfg.GasLimit - leftOverGas}, err) + cfg.EVMConfig.Tracer.OnTxEnd(&types.Receipt{GasUsed: cfg.GasLimit - leftOverGas.RegularGas}, err) } - return code, address, leftOverGas, err + return code, address, leftOverGas.RegularGas, err } // Call executes the code given by the contract's address. It will return the @@ -215,11 +217,11 @@ func Call(address common.Address, input []byte, cfg *Config) ([]byte, uint64, er cfg.Origin, address, input, - cfg.GasLimit, + vm.NewGasBudget(cfg.GasLimit), uint256.MustFromBig(cfg.Value), ) if cfg.EVMConfig.Tracer != nil && cfg.EVMConfig.Tracer.OnTxEnd != nil { - cfg.EVMConfig.Tracer.OnTxEnd(&types.Receipt{GasUsed: cfg.GasLimit - leftOverGas}, err) + cfg.EVMConfig.Tracer.OnTxEnd(&types.Receipt{GasUsed: cfg.GasLimit - leftOverGas.RegularGas}, err) } - return ret, leftOverGas, err + return ret, leftOverGas.RegularGas, err } diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go index a001d8162332..bc2ffd622db3 100644 --- a/core/vm/runtime/runtime_test.go +++ b/core/vm/runtime/runtime_test.go @@ -65,6 +65,21 @@ func TestDefaults(t *testing.T) { if cfg.BlockNumber == nil { t.Error("expected block number to be non nil") } + if cfg.Random == nil { + t.Error("expected Random to be non nil") + } +} + +func TestDefaultsPreserveRandom(t *testing.T) { + h := common.HexToHash("0x01") + cfg := &Config{Random: &h} + setDefaults(cfg) + if cfg.Random == nil { + t.Fatal("expected Random to remain non-nil") + } + if *cfg.Random != h { + t.Fatalf("expected Random to be preserved, got %x, want %x", *cfg.Random, h) + } } func TestEVM(t *testing.T) { @@ -944,3 +959,63 @@ func TestDelegatedAccountAccessCost(t *testing.T) { } } } + +func TestManyLargeStacks(t *testing.T) { + // This piece of code will push 512 items to the stack, and then call itself + // recursively. + code := make([]byte, 10) + for i := range code { + code[i] = byte(vm.PUSH0) + } + code = append(code, []byte{ + byte(vm.ADDRESS), // address to call + byte(vm.GAS), + byte(vm.CALL), + }...) + + main := common.HexToAddress("0xbb") + statedb, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) + statedb.SetCode(main, code, tracing.CodeChangeUnspecified) + + //tracer := logger.NewJSONLogger(nil, os.Stdout) + var tracer *tracing.Hooks + _, _, err := Call(main, nil, &Config{ + GasLimit: 10_000_000, + State: statedb, + EVMConfig: vm.Config{ + Tracer: tracer, + }}) + if err != nil { + t.Fatal("didn't expect error", err) + } +} + +func BenchmarkLargeDeepStacks(b *testing.B) { + // This piece of code will push 512 items to the stack, and then call itself + // recursively. + code := make([]byte, 512) + for i := range code { + code[i] = byte(vm.PUSH0) + } + code = append(code, []byte{ + byte(vm.ADDRESS), // address to call + byte(vm.GAS), + byte(vm.CALL), + }...) + benchmarkNonModifyingCode(10_000_000, code, "deep-large-stacks-10M", "", b) +} + +func BenchmarkShortDeepStacks(b *testing.B) { + // This piece of code will push a few items to the stack, and then call itself + // recursively. + code := make([]byte, 8) + for i := range code { + code[i] = byte(vm.PUSH0) + } + code = append(code, []byte{ + byte(vm.ADDRESS), // address to call + byte(vm.GAS), + byte(vm.CALL), + }...) + benchmarkNonModifyingCode(10_000_000, code, "deep-short-stacks-10M", "", b) +} diff --git a/core/vm/stack.go b/core/vm/stack.go index 879dc9aa6d82..d8000bc86d66 100644 --- a/core/vm/stack.go +++ b/core/vm/stack.go @@ -17,111 +17,170 @@ package vm import ( + "slices" "sync" "github.com/holiman/uint256" ) +// stackArena is an arena which actual evm stacks use for data storage +type stackArena struct { + data []uint256.Int + top int // first free slot +} + +func newArena() *stackArena { + return stackPool.Get().(*stackArena) +} + +// 1025, because in stack() there is a condition check +// for the stack size that would fail if it was set to +// 1024. +const initialStackSize = 1025 + var stackPool = sync.Pool{ - New: func() interface{} { - return &Stack{data: make([]uint256.Int, 0, 16)} + New: func() any { + return &stackArena{ + data: make([]uint256.Int, initialStackSize), + } }, } +func returnStack(arena *stackArena) { + arena.top = 0 // defensive, not strictly needed as s.inner.top = s.bottom in release() + stackPool.Put(arena) +} + +// stack returns an instance of a stack which uses the underlying arena. The instance +// must be released by invoking the (*Stack).release() method +func (sa *stackArena) stack() *Stack { + // make sure every substack has at least 1024 elements + if len(sa.data) <= sa.top+1024 { + // we need to grow the arena + sa.data = slices.Grow(sa.data, 1024) + sa.data = sa.data[:cap(sa.data)] + } + return &Stack{ + bottom: sa.top, + size: 0, + inner: sa, + } +} + +// newStackForTesting is meant to be used solely for testing. It creates a stack +// backed by a newly allocated arena. +func newStackForTesting() *Stack { + arena := &stackArena{ + data: make([]uint256.Int, 1025), + } + return arena.stack() +} + // Stack is an object for basic stack operations. Items popped to the stack are // expected to be changed and modified. stack does not take care of adding newly // initialized objects. type Stack struct { - data []uint256.Int + bottom int // bottom is the index of the first element of this stack + size int // size is the number of elements in this stack + inner *stackArena } -func newstack() *Stack { - return stackPool.Get().(*Stack) +// release un-claims the area of the arena which was claimed by the stack. +func (s *Stack) release() { + // When the stack is returned, need to notify the arena that the new 'top' is + // the returned stack's bottom. + s.inner.top = s.bottom } -func returnStack(s *Stack) { - s.data = s.data[:0] - stackPool.Put(s) +// Data returns the underlying uint256.Int array. +func (s *Stack) Data() []uint256.Int { + return s.inner.data[s.bottom : s.bottom+s.size] } -// Data returns the underlying uint256.Int array. -func (st *Stack) Data() []uint256.Int { - return st.data +func (s *Stack) push(d *uint256.Int) { + elem := s.get() + *elem = *d } -func (st *Stack) push(d *uint256.Int) { - // NOTE push limit (1024) is checked in baseCheck - st.data = append(st.data, *d) +// get returns a pointer to a newly created element +// on top of the stack +func (s *Stack) get() *uint256.Int { + elem := &s.inner.data[s.inner.top] + s.inner.top++ + s.size++ + return elem } -func (st *Stack) pop() (ret uint256.Int) { - ret = st.data[len(st.data)-1] - st.data = st.data[:len(st.data)-1] - return +func (s *Stack) pop() uint256.Int { + s.inner.top-- + s.size-- + return s.inner.data[s.inner.top] } -func (st *Stack) len() int { - return len(st.data) +func (s *Stack) len() int { + return s.size } -func (st *Stack) swap1() { - st.data[st.len()-2], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-2] +func (s *Stack) swap1() { + s.inner.data[s.bottom+s.size-2], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-2] } -func (st *Stack) swap2() { - st.data[st.len()-3], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-3] +func (s *Stack) swap2() { + s.inner.data[s.bottom+s.size-3], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-3] } -func (st *Stack) swap3() { - st.data[st.len()-4], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-4] +func (s *Stack) swap3() { + s.inner.data[s.bottom+s.size-4], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-4] } -func (st *Stack) swap4() { - st.data[st.len()-5], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-5] +func (s *Stack) swap4() { + s.inner.data[s.bottom+s.size-5], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-5] } -func (st *Stack) swap5() { - st.data[st.len()-6], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-6] +func (s *Stack) swap5() { + s.inner.data[s.bottom+s.size-6], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-6] } -func (st *Stack) swap6() { - st.data[st.len()-7], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-7] +func (s *Stack) swap6() { + s.inner.data[s.bottom+s.size-7], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-7] } -func (st *Stack) swap7() { - st.data[st.len()-8], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-8] +func (s *Stack) swap7() { + s.inner.data[s.bottom+s.size-8], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-8] } -func (st *Stack) swap8() { - st.data[st.len()-9], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-9] +func (s *Stack) swap8() { + s.inner.data[s.bottom+s.size-9], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-9] } -func (st *Stack) swap9() { - st.data[st.len()-10], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-10] +func (s *Stack) swap9() { + s.inner.data[s.bottom+s.size-10], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-10] } -func (st *Stack) swap10() { - st.data[st.len()-11], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-11] +func (s *Stack) swap10() { + s.inner.data[s.bottom+s.size-11], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-11] } -func (st *Stack) swap11() { - st.data[st.len()-12], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-12] +func (s *Stack) swap11() { + s.inner.data[s.bottom+s.size-12], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-12] } -func (st *Stack) swap12() { - st.data[st.len()-13], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-13] +func (s *Stack) swap12() { + s.inner.data[s.bottom+s.size-13], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-13] } -func (st *Stack) swap13() { - st.data[st.len()-14], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-14] +func (s *Stack) swap13() { + s.inner.data[s.bottom+s.size-14], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-14] } -func (st *Stack) swap14() { - st.data[st.len()-15], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-15] +func (s *Stack) swap14() { + s.inner.data[s.bottom+s.size-15], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-15] } -func (st *Stack) swap15() { - st.data[st.len()-16], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-16] +func (s *Stack) swap15() { + s.inner.data[s.bottom+s.size-16], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-16] } -func (st *Stack) swap16() { - st.data[st.len()-17], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-17] +func (s *Stack) swap16() { + s.inner.data[s.bottom+s.size-17], s.inner.data[s.bottom+s.size-1] = s.inner.data[s.bottom+s.size-1], s.inner.data[s.bottom+s.size-17] } -func (st *Stack) dup(n int) { - st.push(&st.data[st.len()-n]) +func (s *Stack) dup(n int) { + s.inner.data[s.bottom+s.size] = s.inner.data[s.bottom+s.size-n] + s.size++ + s.inner.top++ } -func (st *Stack) peek() *uint256.Int { - return &st.data[st.len()-1] +func (s *Stack) peek() *uint256.Int { + return &s.inner.data[s.bottom+s.size-1] } -// Back returns the n'th item in stack -func (st *Stack) Back(n int) *uint256.Int { - return &st.data[st.len()-n-1] +// back returns the n'th item in stack +func (s *Stack) back(n int) *uint256.Int { + return &s.inner.data[s.bottom+s.size-n-1] } diff --git a/crypto/bn256/google/gfp2.go b/crypto/bn256/google/gfp2.go index 3981f6cb4f6d..394ef835488b 100644 --- a/crypto/bn256/google/gfp2.go +++ b/crypto/bn256/google/gfp2.go @@ -153,7 +153,7 @@ func (e *gfP2) MulScalar(a *gfP2, b *big.Int) *gfP2 { // MulXi sets e=ξa where ξ=i+9 and then returns e. func (e *gfP2) MulXi(a *gfP2, pool *bnPool) *gfP2 { - // (xi+y)(i+3) = (9x+y)i+(9y-x) + // (xi+y)(i+9) = (9x+y)i+(9y-x) tx := pool.Get().Lsh(a.x, 3) tx.Add(tx, a.x) tx.Add(tx, a.y) diff --git a/crypto/crypto_test.go b/crypto/crypto_test.go index d803ab27c5d9..0636427a4fba 100644 --- a/crypto/crypto_test.go +++ b/crypto/crypto_test.go @@ -293,7 +293,7 @@ func TestPythonIntegration(t *testing.T) { sig0, _ := Sign(msg0, k0) msg1 := common.FromHex("00000000000000000000000000000000") - sig1, _ := Sign(msg0, k0) + sig1, _ := Sign(msg1, k0) t.Logf("msg: %x, privkey: %s sig: %x\n", msg0, kh, sig0) t.Logf("msg: %x, privkey: %s sig: %x\n", msg1, kh, sig1) diff --git a/crypto/ecies/ecies.go b/crypto/ecies/ecies.go index 76f934c72da6..378d764a1993 100644 --- a/crypto/ecies/ecies.go +++ b/crypto/ecies/ecies.go @@ -124,6 +124,9 @@ func (prv *PrivateKey) GenerateShared(pub *PublicKey, skLen, macLen int) (sk []b if prv.PublicKey.Curve != pub.Curve { return nil, ErrInvalidCurve } + if pub.X == nil || pub.Y == nil || !pub.Curve.IsOnCurve(pub.X, pub.Y) { + return nil, ErrInvalidPublicKey + } if skLen+macLen > MaxSharedKeyLength(pub) { return nil, ErrSharedKeyTooBig } @@ -290,7 +293,7 @@ func (prv *PrivateKey) Decrypt(c, s1, s2 []byte) (m []byte, err error) { switch c[0] { case 2, 3, 4: rLen = (prv.PublicKey.Curve.Params().BitSize + 7) / 4 - if len(c) < (rLen + hLen + 1) { + if len(c) < (rLen + hLen + params.BlockSize) { return nil, ErrInvalidMessage } default: diff --git a/crypto/keccak.go b/crypto/keccak.go index 0ad79a63c101..3fafddc92e12 100644 --- a/crypto/keccak.go +++ b/crypto/keccak.go @@ -22,17 +22,17 @@ import ( "sync" "github.com/ethereum/go-ethereum/common" - "golang.org/x/crypto/sha3" + "github.com/ethereum/go-ethereum/crypto/keccak" ) // NewKeccakState creates a new KeccakState func NewKeccakState() KeccakState { - return sha3.NewLegacyKeccak256().(KeccakState) + return keccak.NewLegacyKeccak256().(KeccakState) } var hasherPool = sync.Pool{ New: func() any { - return sha3.NewLegacyKeccak256().(KeccakState) + return keccak.NewLegacyKeccak256().(KeccakState) }, } diff --git a/crypto/keccak/LICENSE b/crypto/keccak/LICENSE new file mode 100644 index 000000000000..2a7cf70da6e4 --- /dev/null +++ b/crypto/keccak/LICENSE @@ -0,0 +1,27 @@ +Copyright 2009 The Go Authors. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google LLC nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/crypto/keccak/README.md b/crypto/keccak/README.md new file mode 100644 index 000000000000..295a5b958c73 --- /dev/null +++ b/crypto/keccak/README.md @@ -0,0 +1,6 @@ +This is a vendored and modified copy of golang.org/x/crypto/sha3, with an assembly +implementation of keccak256. We wish to retain the assembly implementation, +which was removed in v0.44.0. + +Ethereum uses a 'legacy' variant of Keccak, which was defined before it became SHA3. As +such, we cannot use the standard library crypto/sha3 package. diff --git a/crypto/keccak/hashes.go b/crypto/keccak/hashes.go new file mode 100644 index 000000000000..c78c5fe9920c --- /dev/null +++ b/crypto/keccak/hashes.go @@ -0,0 +1,44 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package keccak + +// This file provides functions for creating instances of the SHA-3 +// and SHAKE hash functions, as well as utility functions for hashing +// bytes. + +import ( + "hash" +) + +const ( + dsbyteSHA3 = 0b00000110 + dsbyteKeccak = 0b00000001 + dsbyteShake = 0b00011111 + dsbyteCShake = 0b00000100 + + // rateK[c] is the rate in bytes for Keccak[c] where c is the capacity in + // bits. Given the sponge size is 1600 bits, the rate is 1600 - c bits. + rateK256 = (1600 - 256) / 8 + rateK448 = (1600 - 448) / 8 + rateK512 = (1600 - 512) / 8 + rateK768 = (1600 - 768) / 8 + rateK1024 = (1600 - 1024) / 8 +) + +// NewLegacyKeccak256 creates a new Keccak-256 hash. +// +// Only use this function if you require compatibility with an existing cryptosystem +// that uses non-standard padding. All other users should use New256 instead. +func NewLegacyKeccak256() hash.Hash { + return &state{rate: rateK512, outputLen: 32, dsbyte: dsbyteKeccak} +} + +// NewLegacyKeccak512 creates a new Keccak-512 hash. +// +// Only use this function if you require compatibility with an existing cryptosystem +// that uses non-standard padding. All other users should use New512 instead. +func NewLegacyKeccak512() hash.Hash { + return &state{rate: rateK1024, outputLen: 64, dsbyte: dsbyteKeccak} +} diff --git a/crypto/keccak/keccakf.go b/crypto/keccak/keccakf.go new file mode 100644 index 000000000000..82694fa4a378 --- /dev/null +++ b/crypto/keccak/keccakf.go @@ -0,0 +1,414 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build !amd64 || purego || !gc + +package keccak + +import "math/bits" + +// rc stores the round constants for use in the ι step. +var rc = [24]uint64{ + 0x0000000000000001, + 0x0000000000008082, + 0x800000000000808A, + 0x8000000080008000, + 0x000000000000808B, + 0x0000000080000001, + 0x8000000080008081, + 0x8000000000008009, + 0x000000000000008A, + 0x0000000000000088, + 0x0000000080008009, + 0x000000008000000A, + 0x000000008000808B, + 0x800000000000008B, + 0x8000000000008089, + 0x8000000000008003, + 0x8000000000008002, + 0x8000000000000080, + 0x000000000000800A, + 0x800000008000000A, + 0x8000000080008081, + 0x8000000000008080, + 0x0000000080000001, + 0x8000000080008008, +} + +// keccakF1600 applies the Keccak permutation to a 1600b-wide +// state represented as a slice of 25 uint64s. +func keccakF1600(a *[25]uint64) { + // Implementation translated from Keccak-inplace.c + // in the keccak reference code. + var t, bc0, bc1, bc2, bc3, bc4, d0, d1, d2, d3, d4 uint64 + + for i := 0; i < 24; i += 4 { + // Combines the 5 steps in each round into 2 steps. + // Unrolls 4 rounds per loop and spreads some steps across rounds. + + // Round 1 + bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20] + bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21] + bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22] + bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23] + bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24] + d0 = bc4 ^ (bc1<<1 | bc1>>63) + d1 = bc0 ^ (bc2<<1 | bc2>>63) + d2 = bc1 ^ (bc3<<1 | bc3>>63) + d3 = bc2 ^ (bc4<<1 | bc4>>63) + d4 = bc3 ^ (bc0<<1 | bc0>>63) + + bc0 = a[0] ^ d0 + t = a[6] ^ d1 + bc1 = bits.RotateLeft64(t, 44) + t = a[12] ^ d2 + bc2 = bits.RotateLeft64(t, 43) + t = a[18] ^ d3 + bc3 = bits.RotateLeft64(t, 21) + t = a[24] ^ d4 + bc4 = bits.RotateLeft64(t, 14) + a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i] + a[6] = bc1 ^ (bc3 &^ bc2) + a[12] = bc2 ^ (bc4 &^ bc3) + a[18] = bc3 ^ (bc0 &^ bc4) + a[24] = bc4 ^ (bc1 &^ bc0) + + t = a[10] ^ d0 + bc2 = bits.RotateLeft64(t, 3) + t = a[16] ^ d1 + bc3 = bits.RotateLeft64(t, 45) + t = a[22] ^ d2 + bc4 = bits.RotateLeft64(t, 61) + t = a[3] ^ d3 + bc0 = bits.RotateLeft64(t, 28) + t = a[9] ^ d4 + bc1 = bits.RotateLeft64(t, 20) + a[10] = bc0 ^ (bc2 &^ bc1) + a[16] = bc1 ^ (bc3 &^ bc2) + a[22] = bc2 ^ (bc4 &^ bc3) + a[3] = bc3 ^ (bc0 &^ bc4) + a[9] = bc4 ^ (bc1 &^ bc0) + + t = a[20] ^ d0 + bc4 = bits.RotateLeft64(t, 18) + t = a[1] ^ d1 + bc0 = bits.RotateLeft64(t, 1) + t = a[7] ^ d2 + bc1 = bits.RotateLeft64(t, 6) + t = a[13] ^ d3 + bc2 = bits.RotateLeft64(t, 25) + t = a[19] ^ d4 + bc3 = bits.RotateLeft64(t, 8) + a[20] = bc0 ^ (bc2 &^ bc1) + a[1] = bc1 ^ (bc3 &^ bc2) + a[7] = bc2 ^ (bc4 &^ bc3) + a[13] = bc3 ^ (bc0 &^ bc4) + a[19] = bc4 ^ (bc1 &^ bc0) + + t = a[5] ^ d0 + bc1 = bits.RotateLeft64(t, 36) + t = a[11] ^ d1 + bc2 = bits.RotateLeft64(t, 10) + t = a[17] ^ d2 + bc3 = bits.RotateLeft64(t, 15) + t = a[23] ^ d3 + bc4 = bits.RotateLeft64(t, 56) + t = a[4] ^ d4 + bc0 = bits.RotateLeft64(t, 27) + a[5] = bc0 ^ (bc2 &^ bc1) + a[11] = bc1 ^ (bc3 &^ bc2) + a[17] = bc2 ^ (bc4 &^ bc3) + a[23] = bc3 ^ (bc0 &^ bc4) + a[4] = bc4 ^ (bc1 &^ bc0) + + t = a[15] ^ d0 + bc3 = bits.RotateLeft64(t, 41) + t = a[21] ^ d1 + bc4 = bits.RotateLeft64(t, 2) + t = a[2] ^ d2 + bc0 = bits.RotateLeft64(t, 62) + t = a[8] ^ d3 + bc1 = bits.RotateLeft64(t, 55) + t = a[14] ^ d4 + bc2 = bits.RotateLeft64(t, 39) + a[15] = bc0 ^ (bc2 &^ bc1) + a[21] = bc1 ^ (bc3 &^ bc2) + a[2] = bc2 ^ (bc4 &^ bc3) + a[8] = bc3 ^ (bc0 &^ bc4) + a[14] = bc4 ^ (bc1 &^ bc0) + + // Round 2 + bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20] + bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21] + bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22] + bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23] + bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24] + d0 = bc4 ^ (bc1<<1 | bc1>>63) + d1 = bc0 ^ (bc2<<1 | bc2>>63) + d2 = bc1 ^ (bc3<<1 | bc3>>63) + d3 = bc2 ^ (bc4<<1 | bc4>>63) + d4 = bc3 ^ (bc0<<1 | bc0>>63) + + bc0 = a[0] ^ d0 + t = a[16] ^ d1 + bc1 = bits.RotateLeft64(t, 44) + t = a[7] ^ d2 + bc2 = bits.RotateLeft64(t, 43) + t = a[23] ^ d3 + bc3 = bits.RotateLeft64(t, 21) + t = a[14] ^ d4 + bc4 = bits.RotateLeft64(t, 14) + a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i+1] + a[16] = bc1 ^ (bc3 &^ bc2) + a[7] = bc2 ^ (bc4 &^ bc3) + a[23] = bc3 ^ (bc0 &^ bc4) + a[14] = bc4 ^ (bc1 &^ bc0) + + t = a[20] ^ d0 + bc2 = bits.RotateLeft64(t, 3) + t = a[11] ^ d1 + bc3 = bits.RotateLeft64(t, 45) + t = a[2] ^ d2 + bc4 = bits.RotateLeft64(t, 61) + t = a[18] ^ d3 + bc0 = bits.RotateLeft64(t, 28) + t = a[9] ^ d4 + bc1 = bits.RotateLeft64(t, 20) + a[20] = bc0 ^ (bc2 &^ bc1) + a[11] = bc1 ^ (bc3 &^ bc2) + a[2] = bc2 ^ (bc4 &^ bc3) + a[18] = bc3 ^ (bc0 &^ bc4) + a[9] = bc4 ^ (bc1 &^ bc0) + + t = a[15] ^ d0 + bc4 = bits.RotateLeft64(t, 18) + t = a[6] ^ d1 + bc0 = bits.RotateLeft64(t, 1) + t = a[22] ^ d2 + bc1 = bits.RotateLeft64(t, 6) + t = a[13] ^ d3 + bc2 = bits.RotateLeft64(t, 25) + t = a[4] ^ d4 + bc3 = bits.RotateLeft64(t, 8) + a[15] = bc0 ^ (bc2 &^ bc1) + a[6] = bc1 ^ (bc3 &^ bc2) + a[22] = bc2 ^ (bc4 &^ bc3) + a[13] = bc3 ^ (bc0 &^ bc4) + a[4] = bc4 ^ (bc1 &^ bc0) + + t = a[10] ^ d0 + bc1 = bits.RotateLeft64(t, 36) + t = a[1] ^ d1 + bc2 = bits.RotateLeft64(t, 10) + t = a[17] ^ d2 + bc3 = bits.RotateLeft64(t, 15) + t = a[8] ^ d3 + bc4 = bits.RotateLeft64(t, 56) + t = a[24] ^ d4 + bc0 = bits.RotateLeft64(t, 27) + a[10] = bc0 ^ (bc2 &^ bc1) + a[1] = bc1 ^ (bc3 &^ bc2) + a[17] = bc2 ^ (bc4 &^ bc3) + a[8] = bc3 ^ (bc0 &^ bc4) + a[24] = bc4 ^ (bc1 &^ bc0) + + t = a[5] ^ d0 + bc3 = bits.RotateLeft64(t, 41) + t = a[21] ^ d1 + bc4 = bits.RotateLeft64(t, 2) + t = a[12] ^ d2 + bc0 = bits.RotateLeft64(t, 62) + t = a[3] ^ d3 + bc1 = bits.RotateLeft64(t, 55) + t = a[19] ^ d4 + bc2 = bits.RotateLeft64(t, 39) + a[5] = bc0 ^ (bc2 &^ bc1) + a[21] = bc1 ^ (bc3 &^ bc2) + a[12] = bc2 ^ (bc4 &^ bc3) + a[3] = bc3 ^ (bc0 &^ bc4) + a[19] = bc4 ^ (bc1 &^ bc0) + + // Round 3 + bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20] + bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21] + bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22] + bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23] + bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24] + d0 = bc4 ^ (bc1<<1 | bc1>>63) + d1 = bc0 ^ (bc2<<1 | bc2>>63) + d2 = bc1 ^ (bc3<<1 | bc3>>63) + d3 = bc2 ^ (bc4<<1 | bc4>>63) + d4 = bc3 ^ (bc0<<1 | bc0>>63) + + bc0 = a[0] ^ d0 + t = a[11] ^ d1 + bc1 = bits.RotateLeft64(t, 44) + t = a[22] ^ d2 + bc2 = bits.RotateLeft64(t, 43) + t = a[8] ^ d3 + bc3 = bits.RotateLeft64(t, 21) + t = a[19] ^ d4 + bc4 = bits.RotateLeft64(t, 14) + a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i+2] + a[11] = bc1 ^ (bc3 &^ bc2) + a[22] = bc2 ^ (bc4 &^ bc3) + a[8] = bc3 ^ (bc0 &^ bc4) + a[19] = bc4 ^ (bc1 &^ bc0) + + t = a[15] ^ d0 + bc2 = bits.RotateLeft64(t, 3) + t = a[1] ^ d1 + bc3 = bits.RotateLeft64(t, 45) + t = a[12] ^ d2 + bc4 = bits.RotateLeft64(t, 61) + t = a[23] ^ d3 + bc0 = bits.RotateLeft64(t, 28) + t = a[9] ^ d4 + bc1 = bits.RotateLeft64(t, 20) + a[15] = bc0 ^ (bc2 &^ bc1) + a[1] = bc1 ^ (bc3 &^ bc2) + a[12] = bc2 ^ (bc4 &^ bc3) + a[23] = bc3 ^ (bc0 &^ bc4) + a[9] = bc4 ^ (bc1 &^ bc0) + + t = a[5] ^ d0 + bc4 = bits.RotateLeft64(t, 18) + t = a[16] ^ d1 + bc0 = bits.RotateLeft64(t, 1) + t = a[2] ^ d2 + bc1 = bits.RotateLeft64(t, 6) + t = a[13] ^ d3 + bc2 = bits.RotateLeft64(t, 25) + t = a[24] ^ d4 + bc3 = bits.RotateLeft64(t, 8) + a[5] = bc0 ^ (bc2 &^ bc1) + a[16] = bc1 ^ (bc3 &^ bc2) + a[2] = bc2 ^ (bc4 &^ bc3) + a[13] = bc3 ^ (bc0 &^ bc4) + a[24] = bc4 ^ (bc1 &^ bc0) + + t = a[20] ^ d0 + bc1 = bits.RotateLeft64(t, 36) + t = a[6] ^ d1 + bc2 = bits.RotateLeft64(t, 10) + t = a[17] ^ d2 + bc3 = bits.RotateLeft64(t, 15) + t = a[3] ^ d3 + bc4 = bits.RotateLeft64(t, 56) + t = a[14] ^ d4 + bc0 = bits.RotateLeft64(t, 27) + a[20] = bc0 ^ (bc2 &^ bc1) + a[6] = bc1 ^ (bc3 &^ bc2) + a[17] = bc2 ^ (bc4 &^ bc3) + a[3] = bc3 ^ (bc0 &^ bc4) + a[14] = bc4 ^ (bc1 &^ bc0) + + t = a[10] ^ d0 + bc3 = bits.RotateLeft64(t, 41) + t = a[21] ^ d1 + bc4 = bits.RotateLeft64(t, 2) + t = a[7] ^ d2 + bc0 = bits.RotateLeft64(t, 62) + t = a[18] ^ d3 + bc1 = bits.RotateLeft64(t, 55) + t = a[4] ^ d4 + bc2 = bits.RotateLeft64(t, 39) + a[10] = bc0 ^ (bc2 &^ bc1) + a[21] = bc1 ^ (bc3 &^ bc2) + a[7] = bc2 ^ (bc4 &^ bc3) + a[18] = bc3 ^ (bc0 &^ bc4) + a[4] = bc4 ^ (bc1 &^ bc0) + + // Round 4 + bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20] + bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21] + bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22] + bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23] + bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24] + d0 = bc4 ^ (bc1<<1 | bc1>>63) + d1 = bc0 ^ (bc2<<1 | bc2>>63) + d2 = bc1 ^ (bc3<<1 | bc3>>63) + d3 = bc2 ^ (bc4<<1 | bc4>>63) + d4 = bc3 ^ (bc0<<1 | bc0>>63) + + bc0 = a[0] ^ d0 + t = a[1] ^ d1 + bc1 = bits.RotateLeft64(t, 44) + t = a[2] ^ d2 + bc2 = bits.RotateLeft64(t, 43) + t = a[3] ^ d3 + bc3 = bits.RotateLeft64(t, 21) + t = a[4] ^ d4 + bc4 = bits.RotateLeft64(t, 14) + a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i+3] + a[1] = bc1 ^ (bc3 &^ bc2) + a[2] = bc2 ^ (bc4 &^ bc3) + a[3] = bc3 ^ (bc0 &^ bc4) + a[4] = bc4 ^ (bc1 &^ bc0) + + t = a[5] ^ d0 + bc2 = bits.RotateLeft64(t, 3) + t = a[6] ^ d1 + bc3 = bits.RotateLeft64(t, 45) + t = a[7] ^ d2 + bc4 = bits.RotateLeft64(t, 61) + t = a[8] ^ d3 + bc0 = bits.RotateLeft64(t, 28) + t = a[9] ^ d4 + bc1 = bits.RotateLeft64(t, 20) + a[5] = bc0 ^ (bc2 &^ bc1) + a[6] = bc1 ^ (bc3 &^ bc2) + a[7] = bc2 ^ (bc4 &^ bc3) + a[8] = bc3 ^ (bc0 &^ bc4) + a[9] = bc4 ^ (bc1 &^ bc0) + + t = a[10] ^ d0 + bc4 = bits.RotateLeft64(t, 18) + t = a[11] ^ d1 + bc0 = bits.RotateLeft64(t, 1) + t = a[12] ^ d2 + bc1 = bits.RotateLeft64(t, 6) + t = a[13] ^ d3 + bc2 = bits.RotateLeft64(t, 25) + t = a[14] ^ d4 + bc3 = bits.RotateLeft64(t, 8) + a[10] = bc0 ^ (bc2 &^ bc1) + a[11] = bc1 ^ (bc3 &^ bc2) + a[12] = bc2 ^ (bc4 &^ bc3) + a[13] = bc3 ^ (bc0 &^ bc4) + a[14] = bc4 ^ (bc1 &^ bc0) + + t = a[15] ^ d0 + bc1 = bits.RotateLeft64(t, 36) + t = a[16] ^ d1 + bc2 = bits.RotateLeft64(t, 10) + t = a[17] ^ d2 + bc3 = bits.RotateLeft64(t, 15) + t = a[18] ^ d3 + bc4 = bits.RotateLeft64(t, 56) + t = a[19] ^ d4 + bc0 = bits.RotateLeft64(t, 27) + a[15] = bc0 ^ (bc2 &^ bc1) + a[16] = bc1 ^ (bc3 &^ bc2) + a[17] = bc2 ^ (bc4 &^ bc3) + a[18] = bc3 ^ (bc0 &^ bc4) + a[19] = bc4 ^ (bc1 &^ bc0) + + t = a[20] ^ d0 + bc3 = bits.RotateLeft64(t, 41) + t = a[21] ^ d1 + bc4 = bits.RotateLeft64(t, 2) + t = a[22] ^ d2 + bc0 = bits.RotateLeft64(t, 62) + t = a[23] ^ d3 + bc1 = bits.RotateLeft64(t, 55) + t = a[24] ^ d4 + bc2 = bits.RotateLeft64(t, 39) + a[20] = bc0 ^ (bc2 &^ bc1) + a[21] = bc1 ^ (bc3 &^ bc2) + a[22] = bc2 ^ (bc4 &^ bc3) + a[23] = bc3 ^ (bc0 &^ bc4) + a[24] = bc4 ^ (bc1 &^ bc0) + } +} diff --git a/crypto/keccak/keccakf_amd64.go b/crypto/keccak/keccakf_amd64.go new file mode 100644 index 000000000000..cb6eca44c3bb --- /dev/null +++ b/crypto/keccak/keccakf_amd64.go @@ -0,0 +1,13 @@ +// Copyright 2015 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build amd64 && !purego && gc + +package keccak + +// This function is implemented in keccakf_amd64.s. + +//go:noescape + +func keccakF1600(a *[25]uint64) diff --git a/crypto/keccak/keccakf_amd64.s b/crypto/keccak/keccakf_amd64.s new file mode 100644 index 000000000000..99e2f16e9719 --- /dev/null +++ b/crypto/keccak/keccakf_amd64.s @@ -0,0 +1,5419 @@ +// Code generated by command: go run keccakf_amd64_asm.go -out ../keccakf_amd64.s -pkg sha3. DO NOT EDIT. + +//go:build amd64 && !purego && gc + +// func keccakF1600(a *[25]uint64) +TEXT ·keccakF1600(SB), $200-8 + MOVQ a+0(FP), DI + + // Convert the user state into an internal state + NOTQ 8(DI) + NOTQ 16(DI) + NOTQ 64(DI) + NOTQ 96(DI) + NOTQ 136(DI) + NOTQ 160(DI) + + // Execute the KeccakF permutation + MOVQ (DI), SI + MOVQ 8(DI), BP + MOVQ 32(DI), R15 + XORQ 40(DI), SI + XORQ 48(DI), BP + XORQ 72(DI), R15 + XORQ 80(DI), SI + XORQ 88(DI), BP + XORQ 112(DI), R15 + XORQ 120(DI), SI + XORQ 128(DI), BP + XORQ 152(DI), R15 + XORQ 160(DI), SI + XORQ 168(DI), BP + MOVQ 176(DI), DX + MOVQ 184(DI), R8 + XORQ 192(DI), R15 + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x0000000000000001, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x0000000000008082, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x800000000000808a, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000080008000, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x000000000000808b, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x0000000080000001, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000080008081, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000000008009, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x000000000000008a, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x0000000000000088, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x0000000080008009, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x000000008000000a, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x000000008000808b, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x800000000000008b, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000000008089, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000000008003, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000000008002, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000000000080, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x000000000000800a, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x800000008000000a, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000080008081, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000000008080, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + MOVQ R12, BP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + XORQ R10, R15 + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + XORQ R11, R15 + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(DI), R12 + XORQ 56(DI), DX + XORQ R15, BX + XORQ 96(DI), R12 + XORQ 136(DI), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(DI), R13 + XORQ 64(DI), R8 + XORQ SI, CX + XORQ 104(DI), R13 + XORQ 144(DI), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (DI), R10 + MOVQ 48(DI), R11 + XORQ R13, R9 + MOVQ 96(DI), R12 + MOVQ 144(DI), R13 + MOVQ 192(DI), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x0000000080000001, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (SP) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(SP) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(SP) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(SP) + MOVQ R12, 8(SP) + MOVQ R12, BP + + // Result g + MOVQ 72(DI), R11 + XORQ R9, R11 + MOVQ 80(DI), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(DI), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(DI), R13 + MOVQ 176(DI), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(SP) + XORQ AX, SI + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(SP) + XORQ AX, BP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(SP) + NOTQ R14 + XORQ R10, R15 + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(SP) + + // Result k + MOVQ 8(DI), R10 + MOVQ 56(DI), R11 + MOVQ 104(DI), R12 + MOVQ 152(DI), R13 + MOVQ 160(DI), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(SP) + XORQ AX, SI + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(SP) + XORQ AX, BP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(SP) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(SP) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(SP) + XORQ R10, R15 + + // Result m + MOVQ 40(DI), R11 + XORQ BX, R11 + MOVQ 88(DI), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(DI), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(DI), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(DI), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(SP) + XORQ AX, SI + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(SP) + XORQ AX, BP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(SP) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(SP) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(SP) + XORQ R11, R15 + + // Result s + MOVQ 16(DI), R10 + MOVQ 64(DI), R11 + MOVQ 112(DI), R12 + XORQ DX, R10 + MOVQ 120(DI), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(DI), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(SP) + ROLQ $0x27, R12 + XORQ R9, R15 + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(SP) + XORQ BX, SI + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(SP) + XORQ CX, BP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(SP) + MOVQ R8, 184(SP) + + // Prepare round + MOVQ BP, BX + ROLQ $0x01, BX + MOVQ 16(SP), R12 + XORQ 56(SP), DX + XORQ R15, BX + XORQ 96(SP), R12 + XORQ 136(SP), DX + XORQ DX, R12 + MOVQ R12, CX + ROLQ $0x01, CX + MOVQ 24(SP), R13 + XORQ 64(SP), R8 + XORQ SI, CX + XORQ 104(SP), R13 + XORQ 144(SP), R8 + XORQ R8, R13 + MOVQ R13, DX + ROLQ $0x01, DX + MOVQ R15, R8 + XORQ BP, DX + ROLQ $0x01, R8 + MOVQ SI, R9 + XORQ R12, R8 + ROLQ $0x01, R9 + + // Result b + MOVQ (SP), R10 + MOVQ 48(SP), R11 + XORQ R13, R9 + MOVQ 96(SP), R12 + MOVQ 144(SP), R13 + MOVQ 192(SP), R14 + XORQ CX, R11 + ROLQ $0x2c, R11 + XORQ DX, R12 + XORQ BX, R10 + ROLQ $0x2b, R12 + MOVQ R11, SI + MOVQ $0x8000000080008008, AX + ORQ R12, SI + XORQ R10, AX + XORQ AX, SI + MOVQ SI, (DI) + XORQ R9, R14 + ROLQ $0x0e, R14 + MOVQ R10, R15 + ANDQ R11, R15 + XORQ R14, R15 + MOVQ R15, 32(DI) + XORQ R8, R13 + ROLQ $0x15, R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 16(DI) + NOTQ R12 + ORQ R10, R14 + ORQ R13, R12 + XORQ R13, R14 + XORQ R11, R12 + MOVQ R14, 24(DI) + MOVQ R12, 8(DI) + NOP + + // Result g + MOVQ 72(SP), R11 + XORQ R9, R11 + MOVQ 80(SP), R12 + ROLQ $0x14, R11 + XORQ BX, R12 + ROLQ $0x03, R12 + MOVQ 24(SP), R10 + MOVQ R11, AX + ORQ R12, AX + XORQ R8, R10 + MOVQ 128(SP), R13 + MOVQ 176(SP), R14 + ROLQ $0x1c, R10 + XORQ R10, AX + MOVQ AX, 40(DI) + NOP + XORQ CX, R13 + ROLQ $0x2d, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 48(DI) + NOP + XORQ DX, R14 + ROLQ $0x3d, R14 + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 64(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 72(DI) + NOTQ R14 + NOP + ORQ R14, R13 + XORQ R12, R13 + MOVQ R13, 56(DI) + + // Result k + MOVQ 8(SP), R10 + MOVQ 56(SP), R11 + MOVQ 104(SP), R12 + MOVQ 152(SP), R13 + MOVQ 160(SP), R14 + XORQ DX, R11 + ROLQ $0x06, R11 + XORQ R8, R12 + ROLQ $0x19, R12 + MOVQ R11, AX + ORQ R12, AX + XORQ CX, R10 + ROLQ $0x01, R10 + XORQ R10, AX + MOVQ AX, 80(DI) + NOP + XORQ R9, R13 + ROLQ $0x08, R13 + MOVQ R12, AX + ANDQ R13, AX + XORQ R11, AX + MOVQ AX, 88(DI) + NOP + XORQ BX, R14 + ROLQ $0x12, R14 + NOTQ R13 + MOVQ R13, AX + ANDQ R14, AX + XORQ R12, AX + MOVQ AX, 96(DI) + MOVQ R14, AX + ORQ R10, AX + XORQ R13, AX + MOVQ AX, 104(DI) + ANDQ R11, R10 + XORQ R14, R10 + MOVQ R10, 112(DI) + NOP + + // Result m + MOVQ 40(SP), R11 + XORQ BX, R11 + MOVQ 88(SP), R12 + ROLQ $0x24, R11 + XORQ CX, R12 + MOVQ 32(SP), R10 + ROLQ $0x0a, R12 + MOVQ R11, AX + MOVQ 136(SP), R13 + ANDQ R12, AX + XORQ R9, R10 + MOVQ 184(SP), R14 + ROLQ $0x1b, R10 + XORQ R10, AX + MOVQ AX, 120(DI) + NOP + XORQ DX, R13 + ROLQ $0x0f, R13 + MOVQ R12, AX + ORQ R13, AX + XORQ R11, AX + MOVQ AX, 128(DI) + NOP + XORQ R8, R14 + ROLQ $0x38, R14 + NOTQ R13 + MOVQ R13, AX + ORQ R14, AX + XORQ R12, AX + MOVQ AX, 136(DI) + ORQ R10, R11 + XORQ R14, R11 + MOVQ R11, 152(DI) + ANDQ R10, R14 + XORQ R13, R14 + MOVQ R14, 144(DI) + NOP + + // Result s + MOVQ 16(SP), R10 + MOVQ 64(SP), R11 + MOVQ 112(SP), R12 + XORQ DX, R10 + MOVQ 120(SP), R13 + ROLQ $0x3e, R10 + XORQ R8, R11 + MOVQ 168(SP), R14 + ROLQ $0x37, R11 + XORQ R9, R12 + MOVQ R10, R9 + XORQ CX, R14 + ROLQ $0x02, R14 + ANDQ R11, R9 + XORQ R14, R9 + MOVQ R9, 192(DI) + ROLQ $0x27, R12 + NOP + NOTQ R11 + XORQ BX, R13 + MOVQ R11, BX + ANDQ R12, BX + XORQ R10, BX + MOVQ BX, 160(DI) + NOP + ROLQ $0x29, R13 + MOVQ R12, CX + ORQ R13, CX + XORQ R11, CX + MOVQ CX, 168(DI) + NOP + MOVQ R13, DX + MOVQ R14, R8 + ANDQ R14, DX + ORQ R10, R8 + XORQ R12, DX + XORQ R13, R8 + MOVQ DX, 176(DI) + MOVQ R8, 184(DI) + + // Revert the internal state to the user state + NOTQ 8(DI) + NOTQ 16(DI) + NOTQ 64(DI) + NOTQ 96(DI) + NOTQ 136(DI) + NOTQ 160(DI) + RET diff --git a/crypto/keccak/sha3.go b/crypto/keccak/sha3.go new file mode 100644 index 000000000000..a554323244b4 --- /dev/null +++ b/crypto/keccak/sha3.go @@ -0,0 +1,244 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package keccak + +import ( + "crypto/subtle" + "encoding/binary" + "errors" + "unsafe" + + "golang.org/x/sys/cpu" +) + +// spongeDirection indicates the direction bytes are flowing through the sponge. +type spongeDirection int + +const ( + // spongeAbsorbing indicates that the sponge is absorbing input. + spongeAbsorbing spongeDirection = iota + // spongeSqueezing indicates that the sponge is being squeezed. + spongeSqueezing +) + +type state struct { + a [1600 / 8]byte // main state of the hash + + // a[n:rate] is the buffer. If absorbing, it's the remaining space to XOR + // into before running the permutation. If squeezing, it's the remaining + // output to produce before running the permutation. + n, rate int + + // dsbyte contains the "domain separation" bits and the first bit of + // the padding. Sections 6.1 and 6.2 of [1] separate the outputs of the + // SHA-3 and SHAKE functions by appending bitstrings to the message. + // Using a little-endian bit-ordering convention, these are "01" for SHA-3 + // and "1111" for SHAKE, or 00000010b and 00001111b, respectively. Then the + // padding rule from section 5.1 is applied to pad the message to a multiple + // of the rate, which involves adding a "1" bit, zero or more "0" bits, and + // a final "1" bit. We merge the first "1" bit from the padding into dsbyte, + // giving 00000110b (0x06) and 00011111b (0x1f). + // [1] http://csrc.nist.gov/publications/drafts/fips-202/fips_202_draft.pdf + // "Draft FIPS 202: SHA-3 Standard: Permutation-Based Hash and + // Extendable-Output Functions (May 2014)" + dsbyte byte + + outputLen int // the default output size in bytes + state spongeDirection // whether the sponge is absorbing or squeezing +} + +// BlockSize returns the rate of sponge underlying this hash function. +func (d *state) BlockSize() int { return d.rate } + +// Size returns the output size of the hash function in bytes. +func (d *state) Size() int { return d.outputLen } + +// Reset clears the internal state by zeroing the sponge state and +// the buffer indexes, and setting Sponge.state to absorbing. +func (d *state) Reset() { + // Zero the permutation's state. + for i := range d.a { + d.a[i] = 0 + } + d.state = spongeAbsorbing + d.n = 0 +} + +func (d *state) clone() *state { + ret := *d + return &ret +} + +// permute applies the KeccakF-1600 permutation. +func (d *state) permute() { + var a *[25]uint64 + if cpu.IsBigEndian { + a = new([25]uint64) + for i := range a { + a[i] = binary.LittleEndian.Uint64(d.a[i*8:]) + } + } else { + a = (*[25]uint64)(unsafe.Pointer(&d.a)) + } + + keccakF1600(a) + d.n = 0 + + if cpu.IsBigEndian { + for i := range a { + binary.LittleEndian.PutUint64(d.a[i*8:], a[i]) + } + } +} + +// pads appends the domain separation bits in dsbyte, applies +// the multi-bitrate 10..1 padding rule, and permutes the state. +func (d *state) padAndPermute() { + // Pad with this instance's domain-separator bits. We know that there's + // at least one byte of space in the sponge because, if it were full, + // permute would have been called to empty it. dsbyte also contains the + // first one bit for the padding. See the comment in the state struct. + d.a[d.n] ^= d.dsbyte + // This adds the final one bit for the padding. Because of the way that + // bits are numbered from the LSB upwards, the final bit is the MSB of + // the last byte. + d.a[d.rate-1] ^= 0x80 + // Apply the permutation + d.permute() + d.state = spongeSqueezing +} + +// Write absorbs more data into the hash's state. It panics if any +// output has already been read. +func (d *state) Write(p []byte) (n int, err error) { + if d.state != spongeAbsorbing { + panic("sha3: Write after Read") + } + + n = len(p) + + for len(p) > 0 { + x := subtle.XORBytes(d.a[d.n:d.rate], d.a[d.n:d.rate], p) + d.n += x + p = p[x:] + + // If the sponge is full, apply the permutation. + if d.n == d.rate { + d.permute() + } + } + + return +} + +// Read squeezes an arbitrary number of bytes from the sponge. +func (d *state) Read(out []byte) (n int, err error) { + // If we're still absorbing, pad and apply the permutation. + if d.state == spongeAbsorbing { + d.padAndPermute() + } + + n = len(out) + + // Now, do the squeezing. + for len(out) > 0 { + // Apply the permutation if we've squeezed the sponge dry. + if d.n == d.rate { + d.permute() + } + + x := copy(out, d.a[d.n:d.rate]) + d.n += x + out = out[x:] + } + + return +} + +// Sum applies padding to the hash state and then squeezes out the desired +// number of output bytes. It panics if any output has already been read. +func (d *state) Sum(in []byte) []byte { + if d.state != spongeAbsorbing { + panic("sha3: Sum after Read") + } + + // Make a copy of the original hash so that caller can keep writing + // and summing. + dup := d.clone() + hash := make([]byte, dup.outputLen, 64) // explicit cap to allow stack allocation + dup.Read(hash) + return append(in, hash...) +} + +const ( + magicSHA3 = "sha\x08" + magicShake = "sha\x09" + magicCShake = "sha\x0a" + magicKeccak = "sha\x0b" + // magic || rate || main state || n || sponge direction + marshaledSize = len(magicSHA3) + 1 + 200 + 1 + 1 +) + +func (d *state) MarshalBinary() ([]byte, error) { + return d.AppendBinary(make([]byte, 0, marshaledSize)) +} + +func (d *state) AppendBinary(b []byte) ([]byte, error) { + switch d.dsbyte { + case dsbyteSHA3: + b = append(b, magicSHA3...) + case dsbyteShake: + b = append(b, magicShake...) + case dsbyteCShake: + b = append(b, magicCShake...) + case dsbyteKeccak: + b = append(b, magicKeccak...) + default: + panic("unknown dsbyte") + } + // rate is at most 168, and n is at most rate. + b = append(b, byte(d.rate)) + b = append(b, d.a[:]...) + b = append(b, byte(d.n), byte(d.state)) + return b, nil +} + +func (d *state) UnmarshalBinary(b []byte) error { + if len(b) != marshaledSize { + return errors.New("sha3: invalid hash state") + } + + magic := string(b[:len(magicSHA3)]) + b = b[len(magicSHA3):] + switch { + case magic == magicSHA3 && d.dsbyte == dsbyteSHA3: + case magic == magicShake && d.dsbyte == dsbyteShake: + case magic == magicCShake && d.dsbyte == dsbyteCShake: + case magic == magicKeccak && d.dsbyte == dsbyteKeccak: + default: + return errors.New("sha3: invalid hash state identifier") + } + + rate := int(b[0]) + b = b[1:] + if rate != d.rate { + return errors.New("sha3: invalid hash state function") + } + + copy(d.a[:], b) + b = b[len(d.a):] + + n, state := int(b[0]), spongeDirection(b[1]) + if n > d.rate { + return errors.New("sha3: invalid hash state") + } + d.n = n + if state != spongeAbsorbing && state != spongeSqueezing { + return errors.New("sha3: invalid hash state") + } + d.state = state + + return nil +} diff --git a/crypto/keccak/sha3_test.go b/crypto/keccak/sha3_test.go new file mode 100644 index 000000000000..28a20ec72d74 --- /dev/null +++ b/crypto/keccak/sha3_test.go @@ -0,0 +1,210 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package keccak + +// Tests include all the ShortMsgKATs provided by the Keccak team at +// https://github.com/gvanas/KeccakCodePackage +// +// They only include the zero-bit case of the bitwise testvectors +// published by NIST in the draft of FIPS-202. + +import ( + "bytes" + "compress/flate" + "encoding" + "encoding/hex" + "encoding/json" + "hash" + "math/rand" + "os" + "strings" + "testing" +) + +const ( + testString = "brekeccakkeccak koax koax" + katFilename = "testdata/keccakKats.json.deflate" +) + +// testDigests contains functions returning hash.Hash instances +// with output-length equal to the KAT length for SHA-3, Keccak +// and SHAKE instances. +var testDigests = map[string]func() hash.Hash{ + "Keccak-256": NewLegacyKeccak256, + "Keccak-512": NewLegacyKeccak512, +} + +// decodeHex converts a hex-encoded string into a raw byte string. +func decodeHex(s string) []byte { + b, err := hex.DecodeString(s) + if err != nil { + panic(err) + } + return b +} + +// structs used to marshal JSON test-cases. +type KeccakKats struct { + Kats map[string][]struct { + Digest string `json:"digest"` + Length int64 `json:"length"` + Message string `json:"message"` + + // Defined only for cSHAKE + N string `json:"N"` + S string `json:"S"` + } +} + +// TestKeccakKats tests the SHA-3 and Shake implementations against all the +// ShortMsgKATs from https://github.com/gvanas/KeccakCodePackage +// (The testvectors are stored in keccakKats.json.deflate due to their length.) +func TestKeccakKats(t *testing.T) { + // Read the KATs. + deflated, err := os.Open(katFilename) + if err != nil { + t.Errorf("error opening %s: %s", katFilename, err) + } + file := flate.NewReader(deflated) + dec := json.NewDecoder(file) + var katSet KeccakKats + err = dec.Decode(&katSet) + if err != nil { + t.Errorf("error decoding KATs: %s", err) + } + + for algo, function := range testDigests { + d := function() + for _, kat := range katSet.Kats[algo] { + d.Reset() + in, err := hex.DecodeString(kat.Message) + if err != nil { + t.Errorf("error decoding KAT: %s", err) + } + d.Write(in[:kat.Length/8]) + got := strings.ToUpper(hex.EncodeToString(d.Sum(nil))) + if got != kat.Digest { + t.Errorf("function=%s, length=%d\nmessage:\n %s\ngot:\n %s\nwanted:\n %s", + algo, kat.Length, kat.Message, got, kat.Digest) + t.Logf("wanted %+v", kat) + t.FailNow() + } + continue + } + } +} + +// TestKeccak does a basic test of the non-standardized Keccak hash functions. +func TestKeccak(t *testing.T) { + tests := []struct { + fn func() hash.Hash + data []byte + want string + }{ + { + NewLegacyKeccak256, + []byte("abc"), + "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45", + }, + { + NewLegacyKeccak512, + []byte("abc"), + "18587dc2ea106b9a1563e32b3312421ca164c7f1f07bc922a9c83d77cea3a1e5d0c69910739025372dc14ac9642629379540c17e2a65b19d77aa511a9d00bb96", + }, + } + + for _, u := range tests { + h := u.fn() + h.Write(u.data) + got := h.Sum(nil) + want := decodeHex(u.want) + if !bytes.Equal(got, want) { + t.Errorf("unexpected hash for size %d: got '%x' want '%s'", h.Size()*8, got, u.want) + } + } +} + +// TestUnalignedWrite tests that writing data in an arbitrary pattern with +// small input buffers. +func TestUnalignedWrite(t *testing.T) { + buf := sequentialBytes(0x10000) + for alg, df := range testDigests { + d := df() + d.Reset() + d.Write(buf) + want := d.Sum(nil) + d.Reset() + for i := 0; i < len(buf); { + // Cycle through offsets which make a 137 byte sequence. + // Because 137 is prime this sequence should exercise all corner cases. + offsets := [17]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1} + for _, j := range offsets { + if v := len(buf) - i; v < j { + j = v + } + d.Write(buf[i : i+j]) + i += j + } + } + got := d.Sum(nil) + if !bytes.Equal(got, want) { + t.Errorf("Unaligned writes, alg=%s\ngot %q, want %q", alg, got, want) + } + } +} + +// sequentialBytes produces a buffer of size consecutive bytes 0x00, 0x01, ..., used for testing. +// +// The alignment of each slice is intentionally randomized to detect alignment +// issues in the implementation. See https://golang.org/issue/37644. +// Ideally, the compiler should fuzz the alignment itself. +// (See https://golang.org/issue/35128.) +func sequentialBytes(size int) []byte { + alignmentOffset := rand.Intn(8) + result := make([]byte, size+alignmentOffset)[alignmentOffset:] + for i := range result { + result[i] = byte(i) + } + return result +} + +func TestMarshalUnmarshal(t *testing.T) { + t.Run("Keccak-256", func(t *testing.T) { testMarshalUnmarshal(t, NewLegacyKeccak256()) }) + t.Run("Keccak-512", func(t *testing.T) { testMarshalUnmarshal(t, NewLegacyKeccak512()) }) +} + +// TODO(filippo): move this to crypto/internal/cryptotest. +func testMarshalUnmarshal(t *testing.T, h hash.Hash) { + buf := make([]byte, 200) + rand.Read(buf) + n := rand.Intn(200) + h.Write(buf) + want := h.Sum(nil) + h.Reset() + h.Write(buf[:n]) + b, err := h.(encoding.BinaryMarshaler).MarshalBinary() + if err != nil { + t.Errorf("MarshalBinary: %v", err) + } + h.Write(bytes.Repeat([]byte{0}, 200)) + if err := h.(encoding.BinaryUnmarshaler).UnmarshalBinary(b); err != nil { + t.Errorf("UnmarshalBinary: %v", err) + } + h.Write(buf[n:]) + got := h.Sum(nil) + if !bytes.Equal(got, want) { + t.Errorf("got %x, want %x", got, want) + } +} + +// BenchmarkPermutationFunction measures the speed of the permutation function +// with no input data. +func BenchmarkPermutationFunction(b *testing.B) { + b.SetBytes(int64(200)) + var lanes [25]uint64 + for i := 0; i < b.N; i++ { + keccakF1600(&lanes) + } +} diff --git a/crypto/keccak/testdata/keccakKats.json.deflate b/crypto/keccak/testdata/keccakKats.json.deflate new file mode 100644 index 000000000000..7a94c2f8bce6 Binary files /dev/null and b/crypto/keccak/testdata/keccakKats.json.deflate differ diff --git a/crypto/kzg4844/kzg4844.go b/crypto/kzg4844/kzg4844.go index 3ccc20483844..1e021d64a692 100644 --- a/crypto/kzg4844/kzg4844.go +++ b/crypto/kzg4844/kzg4844.go @@ -34,9 +34,27 @@ var ( blobT = reflect.TypeFor[Blob]() commitmentT = reflect.TypeFor[Commitment]() proofT = reflect.TypeFor[Proof]() + cellT = reflect.TypeFor[Cell]() ) -const CellProofsPerBlob = 128 +const ( + CellProofsPerBlob = 128 + CellsPerBlob = 128 + DataPerBlob = 64 +) + +// Cell represents a single cell in a blob. +type Cell [2048]byte + +// UnmarshalJSON parses a cell in hex syntax. +func (c *Cell) UnmarshalJSON(input []byte) error { + return hexutil.UnmarshalFixedJSON(cellT, input, c[:]) +} + +// MarshalText returns the hex representation of c. +func (c *Cell) MarshalText() ([]byte, error) { + return hexutil.Bytes(c[:]).MarshalText() +} // Blob represents a 4844 data blob. type Blob [131072]byte @@ -189,3 +207,75 @@ func CalcBlobHashV1(hasher hash.Hash, commit *Commitment) (vh [32]byte) { func IsValidVersionedHash(h []byte) bool { return len(h) == 32 && h[0] == 0x01 } + +// VerifyCells verifies a batch of proofs corresponding to the cells and blob commitments. +// +// For this function, it is sufficient to only provide some of the cells. +// +// The `cellIndices` specify which of the 128 cells of each blob are given. +// Indices must be given in ascending order. +// +// Note the list of indices is shared among all blobs, i.e. for a given list of indices +// [1, 2, 13], the cells slice must contain cells [1, 2, 13] of each blob. +// Thus, `len(cells)` must be a multiple of `len(cellIndices)`. +// +// One proof must be given for each cell. As such, `len(proofs)` must equal `len(cells)`. +func VerifyCells(cells []Cell, commitments []Commitment, proofs []Proof, cellIndices []uint64) error { + // commitments/proofs/cells validation + switch { + case len(commitments) == 0: + return errors.New("no commitments") + case len(proofs)%len(commitments) != 0: + return errors.New("len(proofs) must be a multiple of len(commitments)") + case len(cells) != len(proofs): + return errors.New("mismatched len(cellProofs) and len(cells)") + } + if err := validateCellIndices(cells, cellIndices); err != nil { + return err + } + if len(cells)/len(cellIndices) != len(commitments) { + return errors.New("invalid number of cells for blob count") + } + + if useCKZG.Load() { + return ckzgVerifyCells(cells, commitments, proofs, cellIndices) + } + return gokzgVerifyCells(cells, commitments, proofs, cellIndices) +} + +// ComputeCells computes the cells from the given blobs. +func ComputeCells(blobs []Blob) ([]Cell, error) { + if useCKZG.Load() { + return ckzgComputeCells(blobs) + } + return gokzgComputeCells(blobs) +} + +// RecoverBlobs recovers blobs from the given cells and cell indices. +// In order to successfully recover, at least DataPerBlob (64) cells must be provided. +// +// For the layout of cells and cellIndices, please see [VerifyCells]. +func RecoverBlobs(cells []Cell, cellIndices []uint64) ([]Blob, error) { + if err := validateCellIndices(cells, cellIndices); err != nil { + return nil, err + } + if useCKZG.Load() { + return ckzgRecoverBlobs(cells, cellIndices) + } + return gokzgRecoverBlobs(cells, cellIndices) +} + +func validateCellIndices(cells []Cell, cellIndices []uint64) error { + switch { + case len(cellIndices) == 0: + return errors.New("no cellIndices given") + case len(cellIndices) > len(cells): + return errors.New("less cells than cellIndices") + case len(cellIndices) > CellsPerBlob: + return errors.New("too many cellIndices") + case len(cells)%len(cellIndices) != 0: + return errors.New("len(cells) must be a multiple of len(cellIndices)") + } + // The library checks the canonical ordering of indices, so we don't have to do it here. + return nil +} diff --git a/crypto/kzg4844/kzg4844_ckzg_cgo.go b/crypto/kzg4844/kzg4844_ckzg_cgo.go index 46509674b64e..bacfa7095a2f 100644 --- a/crypto/kzg4844/kzg4844_ckzg_cgo.go +++ b/crypto/kzg4844/kzg4844_ckzg_cgo.go @@ -143,9 +143,9 @@ func ckzgComputeCellProofs(blob *Blob) ([]Proof, error) { if err != nil { return []Proof{}, err } - var p []Proof - for _, proof := range proofs { - p = append(p, (Proof)(proof)) + p := make([]Proof, len(proofs)) + for i, proof := range proofs { + p[i] = (Proof)(proof) } return p, nil } @@ -190,3 +190,92 @@ func ckzgVerifyCellProofBatch(blobs []Blob, commitments []Commitment, cellProofs } return nil } + +// ckzgVerifyCells verifies that the cell data corresponds to the provided commitments. +func ckzgVerifyCells(cells []Cell, commitments []Commitment, cellProofs []Proof, cellIndices []uint64) error { + ckzgIniter.Do(ckzgInit) + var ( + proofs = make([]ckzg4844.Bytes48, len(cellProofs)) + commits = make([]ckzg4844.Bytes48, 0, len(cellProofs)) + indices = make([]uint64, 0, len(cellProofs)) + kzgcells = make([]ckzg4844.Cell, 0, len(cellProofs)) + ) + for i := range cellProofs { + proofs[i] = (ckzg4844.Bytes48)(cellProofs[i]) + kzgcells = append(kzgcells, (ckzg4844.Cell)(cells[i])) + } + if len(cellProofs)%len(commitments) != 0 { + return errors.New("wrong cell proofs and commitments length") + } + cellCounts := len(cellProofs) / len(commitments) + for _, commitment := range commitments { + for j := 0; j < cellCounts; j++ { + commits = append(commits, (ckzg4844.Bytes48)(commitment)) + } + } + for j := 0; j < len(commitments); j++ { + indices = append(indices, cellIndices...) + } + + valid, err := ckzg4844.VerifyCellKZGProofBatch(commits, indices, kzgcells, proofs) + if err != nil { + return err + } + if !valid { + return errors.New("invalid proof") + } + return nil +} + +// ckzgComputeCells computes cells from blobs. +func ckzgComputeCells(blobs []Blob) ([]Cell, error) { + ckzgIniter.Do(ckzgInit) + cells := make([]Cell, 0, ckzg4844.CellsPerExtBlob*len(blobs)) + + for i := range blobs { + cellsI, err := ckzg4844.ComputeCells((*ckzg4844.Blob)(&blobs[i])) + if err != nil { + return []Cell{}, err + } + for _, c := range cellsI { + cells = append(cells, Cell(c)) + } + } + return cells, nil +} + +// ckzgRecoverBlobs recovers blobs from cells and cell indices. +func ckzgRecoverBlobs(cells []Cell, cellIndices []uint64) ([]Blob, error) { + ckzgIniter.Do(ckzgInit) + + if len(cellIndices) == 0 || len(cells)%len(cellIndices) != 0 { + return []Blob{}, errors.New("cells with wrong length") + } + + blobCount := len(cells) / len(cellIndices) + blobs := make([]Blob, 0, blobCount) + + offset := 0 + for range blobCount { + kzgcells := make([]ckzg4844.Cell, 0, len(cellIndices)) + + for _, cell := range cells[offset : offset+len(cellIndices)] { + kzgcells = append(kzgcells, ckzg4844.Cell(cell)) + } + + extCells, err := ckzg4844.RecoverCells(cellIndices, kzgcells) + if err != nil { + return []Blob{}, err + } + + var blob Blob + for i, cell := range extCells[:DataPerBlob] { + copy(blob[i*len(cell):], cell[:]) + } + blobs = append(blobs, blob) + + offset = offset + len(cellIndices) + } + + return blobs, nil +} diff --git a/crypto/kzg4844/kzg4844_ckzg_nocgo.go b/crypto/kzg4844/kzg4844_ckzg_nocgo.go index 7c552e9a18bb..e1a3c0af1e80 100644 --- a/crypto/kzg4844/kzg4844_ckzg_nocgo.go +++ b/crypto/kzg4844/kzg4844_ckzg_nocgo.go @@ -73,3 +73,15 @@ func ckzgVerifyCellProofBatch(blobs []Blob, commitments []Commitment, proof []Pr func ckzgComputeCellProofs(blob *Blob) ([]Proof, error) { panic("unsupported platform") } + +func ckzgVerifyCells(cells []Cell, commitments []Commitment, cellProofs []Proof, cellIndices []uint64) error { + panic("unsupported platform") +} + +func ckzgComputeCells(blobs []Blob) ([]Cell, error) { + panic("unsupported platform") +} + +func ckzgRecoverBlobs(cells []Cell, cellIndices []uint64) ([]Blob, error) { + panic("unsupported platform") +} diff --git a/crypto/kzg4844/kzg4844_gokzg.go b/crypto/kzg4844/kzg4844_gokzg.go index e9676ff1b820..ca45a6a560a8 100644 --- a/crypto/kzg4844/kzg4844_gokzg.go +++ b/crypto/kzg4844/kzg4844_gokzg.go @@ -108,9 +108,9 @@ func gokzgComputeCellProofs(blob *Blob) ([]Proof, error) { if err != nil { return []Proof{}, err } - var p []Proof - for _, proof := range proofs { - p = append(p, (Proof)(proof)) + p := make([]Proof, len(proofs)) + for i, proof := range proofs { + p[i] = (Proof)(proof) } return p, nil } @@ -148,3 +148,85 @@ func gokzgVerifyCellProofBatch(blobs []Blob, commitments []Commitment, cellProof } return context.VerifyCellKZGProofBatch(commits, cellIndices, cells[:], proofs) } + +// gokzgVerifyCells verifies that the cell data corresponds to the provided commitment. +func gokzgVerifyCells(cells []Cell, commitments []Commitment, cellProofs []Proof, cellIndices []uint64) error { + gokzgIniter.Do(gokzgInit) + + var ( + proofs = make([]gokzg4844.KZGProof, len(cellProofs)) + commits = make([]gokzg4844.KZGCommitment, 0, len(cellProofs)) + indices = make([]uint64, 0, len(cellProofs)) + kzgcells = make([]*gokzg4844.Cell, 0, len(cellProofs)) + ) + // Copy over the cell proofs and cells + for i := range cellProofs { + proofs[i] = gokzg4844.KZGProof(cellProofs[i]) + gc := gokzg4844.Cell(cells[i]) + kzgcells = append(kzgcells, &gc) + } + cellCounts := len(cellProofs) / len(commitments) + // Blow up the commitments to be the same length as the proofs + for _, commitment := range commitments { + for j := 0; j < cellCounts; j++ { + commits = append(commits, gokzg4844.KZGCommitment(commitment)) + } + } + for j := 0; j < len(commitments); j++ { + indices = append(indices, cellIndices...) + } + + return context.VerifyCellKZGProofBatch(commits, indices, kzgcells, proofs) +} + +// gokzgComputeCells computes cells from blobs. +func gokzgComputeCells(blobs []Blob) ([]Cell, error) { + gokzgIniter.Do(gokzgInit) + cells := make([]Cell, 0, gokzg4844.CellsPerExtBlob*len(blobs)) + + for i := range blobs { + cellsI, err := context.ComputeCells((*gokzg4844.Blob)(&blobs[i]), 2) + if err != nil { + return []Cell{}, err + } + for _, c := range cellsI { + if c != nil { + cells = append(cells, Cell(*c)) + } + } + } + return cells, nil +} + +// gokzgRecoverBlobs recovers blobs from cells and cell indices. +func gokzgRecoverBlobs(cells []Cell, cellIndices []uint64) ([]Blob, error) { + gokzgIniter.Do(gokzgInit) + + blobCount := len(cells) / len(cellIndices) + blobs := make([]Blob, 0, blobCount) + + offset := 0 + for range blobCount { + kzgcells := make([]*gokzg4844.Cell, 0, len(cellIndices)) + + for _, cell := range cells[offset : offset+len(cellIndices)] { + gc := gokzg4844.Cell(cell) + kzgcells = append(kzgcells, &gc) + } + + extCells, err := context.RecoverCells(cellIndices, kzgcells, 2) + if err != nil { + return []Blob{}, err + } + + var blob Blob + for i, cell := range extCells[:DataPerBlob] { + copy(blob[i*len(cell):], cell[:]) + } + blobs = append(blobs, blob) + + offset = offset + len(cellIndices) + } + + return blobs, nil +} diff --git a/crypto/kzg4844/kzg4844_test.go b/crypto/kzg4844/kzg4844_test.go index 743a27719981..056decfb8b45 100644 --- a/crypto/kzg4844/kzg4844_test.go +++ b/crypto/kzg4844/kzg4844_test.go @@ -18,6 +18,8 @@ package kzg4844 import ( "crypto/rand" + mrand "math/rand" + "slices" "testing" "github.com/consensys/gnark-crypto/ecc/bls12-381/fr" @@ -45,14 +47,20 @@ func randBlob() *Blob { return &blob } -func TestCKZGWithPoint(t *testing.T) { testKZGWithPoint(t, true) } -func TestGoKZGWithPoint(t *testing.T) { testKZGWithPoint(t, false) } -func testKZGWithPoint(t *testing.T, ckzg bool) { +func switchBackend(t testing.TB, ckzg bool) (switchBack func()) { + t.Helper() if ckzg && !ckzgAvailable { t.Skip("CKZG unavailable in this test build") } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) + prev := useCKZG.Load() useCKZG.Store(ckzg) + return func() { useCKZG.Store(prev) } +} + +func TestCKZGWithPoint(t *testing.T) { testKZGWithPoint(t, true) } +func TestGoKZGWithPoint(t *testing.T) { testKZGWithPoint(t, false) } +func testKZGWithPoint(t *testing.T, ckzg bool) { + defer switchBackend(t, ckzg)() blob := randBlob() @@ -73,11 +81,7 @@ func testKZGWithPoint(t *testing.T, ckzg bool) { func TestCKZGWithBlob(t *testing.T) { testKZGWithBlob(t, true) } func TestGoKZGWithBlob(t *testing.T) { testKZGWithBlob(t, false) } func testKZGWithBlob(t *testing.T, ckzg bool) { - if ckzg && !ckzgAvailable { - t.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(t, ckzg)() blob := randBlob() @@ -97,11 +101,7 @@ func testKZGWithBlob(t *testing.T, ckzg bool) { func BenchmarkCKZGBlobToCommitment(b *testing.B) { benchmarkBlobToCommitment(b, true) } func BenchmarkGoKZGBlobToCommitment(b *testing.B) { benchmarkBlobToCommitment(b, false) } func benchmarkBlobToCommitment(b *testing.B, ckzg bool) { - if ckzg && !ckzgAvailable { - b.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(b, ckzg)() blob := randBlob() @@ -113,11 +113,7 @@ func benchmarkBlobToCommitment(b *testing.B, ckzg bool) { func BenchmarkCKZGComputeProof(b *testing.B) { benchmarkComputeProof(b, true) } func BenchmarkGoKZGComputeProof(b *testing.B) { benchmarkComputeProof(b, false) } func benchmarkComputeProof(b *testing.B, ckzg bool) { - if ckzg && !ckzgAvailable { - b.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(b, ckzg)() var ( blob = randBlob() @@ -132,11 +128,7 @@ func benchmarkComputeProof(b *testing.B, ckzg bool) { func BenchmarkCKZGVerifyProof(b *testing.B) { benchmarkVerifyProof(b, true) } func BenchmarkGoKZGVerifyProof(b *testing.B) { benchmarkVerifyProof(b, false) } func benchmarkVerifyProof(b *testing.B, ckzg bool) { - if ckzg && !ckzgAvailable { - b.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(b, ckzg)() var ( blob = randBlob() @@ -153,11 +145,7 @@ func benchmarkVerifyProof(b *testing.B, ckzg bool) { func BenchmarkCKZGComputeBlobProof(b *testing.B) { benchmarkComputeBlobProof(b, true) } func BenchmarkGoKZGComputeBlobProof(b *testing.B) { benchmarkComputeBlobProof(b, false) } func benchmarkComputeBlobProof(b *testing.B, ckzg bool) { - if ckzg && !ckzgAvailable { - b.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(b, ckzg)() var ( blob = randBlob() @@ -172,11 +160,7 @@ func benchmarkComputeBlobProof(b *testing.B, ckzg bool) { func BenchmarkCKZGVerifyBlobProof(b *testing.B) { benchmarkVerifyBlobProof(b, true) } func BenchmarkGoKZGVerifyBlobProof(b *testing.B) { benchmarkVerifyBlobProof(b, false) } func benchmarkVerifyBlobProof(b *testing.B, ckzg bool) { - if ckzg && !ckzgAvailable { - b.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(b, ckzg)() var ( blob = randBlob() @@ -192,11 +176,7 @@ func benchmarkVerifyBlobProof(b *testing.B, ckzg bool) { func TestCKZGCells(t *testing.T) { testKZGCells(t, true) } func TestGoKZGCells(t *testing.T) { testKZGCells(t, false) } func testKZGCells(t *testing.T, ckzg bool) { - if ckzg && !ckzgAvailable { - t.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(t, ckzg)() blob1 := randBlob() blob2 := randBlob() @@ -236,11 +216,7 @@ func BenchmarkGOKZGComputeCellProofs(b *testing.B) { benchmarkComputeCellProofs( func BenchmarkCKZGComputeCellProofs(b *testing.B) { benchmarkComputeCellProofs(b, true) } func benchmarkComputeCellProofs(b *testing.B, ckzg bool) { - if ckzg && !ckzgAvailable { - b.Skip("CKZG unavailable in this test build") - } - defer func(old bool) { useCKZG.Store(old) }(useCKZG.Load()) - useCKZG.Store(ckzg) + defer switchBackend(b, ckzg)() blob := randBlob() _, _ = ComputeCellProofs(blob) // for kzg initialization @@ -253,3 +229,208 @@ func benchmarkComputeCellProofs(b *testing.B, ckzg bool) { } } } + +// randCellIndices picks n random unique indices from [0, CellsPerBlob) in sorted order. +func randCellIndices(rng *mrand.Rand, n int) []uint64 { + perm := rng.Perm(CellsPerBlob) + indices := make([]uint64, n) + for i := 0; i < n; i++ { + indices[i] = uint64(perm[i]) + } + slices.Sort(indices) + return indices +} + +// randBlobAndProofs generates random blobs and precomputes their cells, proofs, and commitments. +type randBlobAndProofs struct { + blobs []Blob + commitments []Commitment + cells []Cell // flat: blobs[i] cells at [i*CellsPerBlob : (i+1)*CellsPerBlob] + proofs []Proof +} + +func newBlobs(t *testing.T, blobCount int) *randBlobAndProofs { + d := &randBlobAndProofs{ + blobs: make([]Blob, blobCount), + commitments: make([]Commitment, blobCount), + } + for i := range blobCount { + d.blobs[i] = *randBlob() + commitment, err := BlobToCommitment(&d.blobs[i]) + if err != nil { + t.Fatalf("failed to compute commitment: %v", err) + } + d.commitments[i] = commitment + proofs, err := ComputeCellProofs(&d.blobs[i]) + if err != nil { + t.Fatalf("failed to compute cell proofs: %v", err) + } + d.proofs = append(d.proofs, proofs...) + } + cells, err := ComputeCells(d.blobs) + if err != nil { + t.Fatalf("failed to compute cells: %v", err) + } + d.cells = cells + return d +} + +func TestCKZGVerifyPartialCells(t *testing.T) { testVerifyPartialCells(t, true) } +func TestGoKZGVerifyPartialCells(t *testing.T) { testVerifyPartialCells(t, false) } + +func testVerifyPartialCells(t *testing.T, ckzg bool) { + defer switchBackend(t, ckzg)() + + const ( + iterations = 50 + blobCount = 3 + cellsCount = 8 + ) + // Precompute blobs once, vary only cell indices per iteration + d := newBlobs(t, blobCount) + + for iter := range iterations { + rng := mrand.New(mrand.NewSource(int64(iter))) + indices := randCellIndices(rng, cellsCount) + + var partialCells []Cell + var partialProofs []Proof + for i := range blobCount { + for _, idx := range indices { + partialCells = append(partialCells, d.cells[i*CellsPerBlob+int(idx)]) + partialProofs = append(partialProofs, d.proofs[i*CellProofsPerBlob+int(idx)]) + } + } + if err := VerifyCells(partialCells, d.commitments, partialProofs, indices); err != nil { + t.Fatalf("iter %d: failed to verify partial cells: %v", iter, err) + } + } +} + +func TestCKZGVerifyCellsWithCorruptedCells(t *testing.T) { + testVerifyCellsWithCorruptedCells(t, true) +} +func TestGoKZGVerifyCellsWithCorruptedCells(t *testing.T) { + testVerifyCellsWithCorruptedCells(t, false) +} + +func testVerifyCellsWithCorruptedCells(t *testing.T, ckzg bool) { + defer switchBackend(t, ckzg)() + + const blobCount = 3 + d := newBlobs(t, blobCount) + indices := []uint64{0, 15, 63, 64, 95, 100, 120, 127} + + var partialCells []Cell + var partialProofs []Proof + for i := range blobCount { + for _, idx := range indices { + partialCells = append(partialCells, d.cells[i*CellsPerBlob+int(idx)]) + partialProofs = append(partialProofs, d.proofs[i*CellProofsPerBlob+int(idx)]) + } + } + // Corrupt the first cell + corruptedCells := make([]Cell, len(partialCells)) + copy(corruptedCells, partialCells) + corruptedCells[0][0] ^= 0xff + + if err := VerifyCells(corruptedCells, d.commitments, partialProofs, indices); err == nil { + t.Fatal("expected verification failure with corrupted cell") + } +} + +func TestCKZGVerifyCellsWithCorruptedProofs(t *testing.T) { + testVerifyCellsWithCorruptedProofs(t, true) +} +func TestGoKZGVerifyCellsWithCorruptedProofs(t *testing.T) { + testVerifyCellsWithCorruptedProofs(t, false) +} + +func testVerifyCellsWithCorruptedProofs(t *testing.T, ckzg bool) { + defer switchBackend(t, ckzg)() + + const blobCount = 3 + d := newBlobs(t, blobCount) + indices := []uint64{0, 15, 63, 64, 95, 100, 120, 127} + + var partialCells []Cell + var partialProofs []Proof + for i := range blobCount { + for _, idx := range indices { + partialCells = append(partialCells, d.cells[i*CellsPerBlob+int(idx)]) + partialProofs = append(partialProofs, d.proofs[i*CellProofsPerBlob+int(idx)]) + } + } + // Swap first and last proof + wrongProofs := make([]Proof, len(partialProofs)) + copy(wrongProofs, partialProofs) + wrongProofs[0], wrongProofs[len(wrongProofs)-1] = wrongProofs[len(wrongProofs)-1], wrongProofs[0] + + if err := VerifyCells(partialCells, d.commitments, wrongProofs, indices); err == nil { + t.Fatal("expected verification failure with swapped proofs") + } +} + +func TestCKZGRecoverBlob(t *testing.T) { testRecoverBlob(t, true) } +func TestGoKZGRecoverBlob(t *testing.T) { testRecoverBlob(t, false) } + +func testRecoverBlob(t *testing.T, ckzg bool) { + defer switchBackend(t, ckzg)() + + // Precompute blobs once, vary only cell indices per iteration + d := newBlobs(t, 3) + + for iter := range 50 { + rng := mrand.New(mrand.NewSource(int64(iter))) + numCells := DataPerBlob + rng.Intn(CellsPerBlob-DataPerBlob+1) + indices := randCellIndices(rng, numCells) + + var partialCells []Cell + for bi := range 3 { + for _, idx := range indices { + partialCells = append(partialCells, d.cells[bi*CellsPerBlob+int(idx)]) + } + } + recovered, err := RecoverBlobs(partialCells, indices) + if err != nil { + t.Fatalf("iter %d: failed to recover blob with %d cells: %v", iter, numCells, err) + } + if err := VerifyCellProofs(recovered, d.commitments, d.proofs); err != nil { + t.Fatalf("iter %d: recovered blobs failed verification: %v", iter, err) + } + for i := range d.blobs { + if recovered[i] != d.blobs[i] { + t.Fatalf("iter %d: recovered blob %d does not match original", iter, i) + } + } + } +} + +func TestCKZGRecoverBlobWithInsufficientCells(t *testing.T) { + testRecoverBlobWithInsufficientCells(t, true) +} +func TestGoKZGRecoverBlobWithInsufficientCells(t *testing.T) { + testRecoverBlobWithInsufficientCells(t, false) +} + +func testRecoverBlobWithInsufficientCells(t *testing.T, ckzg bool) { + defer switchBackend(t, ckzg)() + + const blobCount = 3 + d := newBlobs(t, blobCount) + + // Use DataPerBlob-1 cells (one short of minimum required) + indices := make([]uint64, DataPerBlob-1) + for i := range indices { + indices[i] = uint64(i) + } + var partialCells []Cell + for bi := range blobCount { + for _, idx := range indices { + partialCells = append(partialCells, d.cells[bi*CellsPerBlob+int(idx)]) + } + } + if _, err := RecoverBlobs(partialCells, indices); err == nil { + t.Fatalf("expected error with only %d cells, got none", len(indices)) + } +} diff --git a/crypto/secp256k1/curve.go b/crypto/secp256k1/curve.go index b82b147e3c7f..504602f5bef1 100644 --- a/crypto/secp256k1/curve.go +++ b/crypto/secp256k1/curve.go @@ -73,6 +73,10 @@ func (bitCurve *BitCurve) Params() *elliptic.CurveParams { // IsOnCurve returns true if the given (x,y) lies on the BitCurve. func (bitCurve *BitCurve) IsOnCurve(x, y *big.Int) bool { + if x.Cmp(bitCurve.P) >= 0 || y.Cmp(bitCurve.P) >= 0 { + return false + } + // y² = x³ + b y2 := new(big.Int).Mul(y, y) //y² y2.Mod(y2, bitCurve.P) //y²%P diff --git a/crypto/secp256k1/ext.h b/crypto/secp256k1/ext.h index 1c485e260320..baafb4404bbd 100644 --- a/crypto/secp256k1/ext.h +++ b/crypto/secp256k1/ext.h @@ -109,8 +109,10 @@ int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, unsigned char *point, ARG_CHECK(scalar != NULL); (void)ctx; - secp256k1_fe_set_b32_limit(&feX, point); - secp256k1_fe_set_b32_limit(&feY, point+32); + if (!secp256k1_fe_set_b32_limit(&feX, point) || + !secp256k1_fe_set_b32_limit(&feY, point+32)) { + return 0; + } secp256k1_ge_set_xy(&ge, &feX, &feY); secp256k1_scalar_set_b32(&s, scalar, &overflow); if (overflow || secp256k1_scalar_is_zero(&s)) { diff --git a/crypto/signature_nocgo.go b/crypto/signature_nocgo.go index 9dce1057faf1..bf273612e988 100644 --- a/crypto/signature_nocgo.go +++ b/crypto/signature_nocgo.go @@ -103,7 +103,7 @@ func Sign(hash []byte, prv *ecdsa.PrivateKey) ([]byte, error) { // The public key should be in compressed (33 bytes) or uncompressed (65 bytes) format. // The signature should have the 64 byte [R || S] format. func VerifySignature(pubkey, hash, signature []byte) bool { - if len(signature) != 64 { + if len(signature) != 64 || len(hash) != DigestLength { return false } var r, s secp256k1.ModNScalar @@ -167,6 +167,13 @@ type btCurve struct { *secp256k1.KoblitzCurve } +func (curve btCurve) IsOnCurve(x, y *big.Int) bool { + if x.Cmp(secp256k1.Params().P) >= 0 || y.Cmp(secp256k1.Params().P) >= 0 { + return false + } + return curve.KoblitzCurve.IsOnCurve(x, y) +} + // Marshal converts a point given as (x, y) into a byte slice. func (curve btCurve) Marshal(x, y *big.Int) []byte { byteLen := (curve.Params().BitSize + 7) / 8 diff --git a/crypto/signify/signify_fuzz.go b/crypto/signify/signify_fuzz.go index 239a2134df8f..d11125c69746 100644 --- a/crypto/signify/signify_fuzz.go +++ b/crypto/signify/signify_fuzz.go @@ -56,7 +56,7 @@ func Fuzz(data []byte) int { fmt.Printf("untrusted: %v\n", untrustedComment) fmt.Printf("trusted: %v\n", trustedComment) - err = SignifySignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, untrustedComment, trustedComment) + err = SignFile(tmpFile.Name(), tmpFile.Name()+".sig", testSecKey, untrustedComment, trustedComment) if err != nil { panic(err) } @@ -68,7 +68,7 @@ func Fuzz(data []byte) int { signify = path } - _, err := exec.LookPath(signify) + _, err = exec.LookPath(signify) if err != nil { panic(err) } diff --git a/eth/api_backend.go b/eth/api_backend.go index 766a99fc1ef6..33fe4fe5d946 100644 --- a/eth/api_backend.go +++ b/eth/api_backend.go @@ -236,9 +236,9 @@ func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.B if header == nil { return nil, nil, errors.New("header not found") } - stateDb, err := b.eth.BlockChain().StateAt(header.Root) + stateDb, err := b.eth.BlockChain().StateAt(header) if err != nil { - stateDb, err = b.eth.BlockChain().HistoricState(header.Root) + stateDb, err = b.eth.BlockChain().HistoricState(header) if err != nil { return nil, nil, err } @@ -261,9 +261,9 @@ func (b *EthAPIBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockN if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash { return nil, nil, errors.New("hash is not currently canonical") } - stateDb, err := b.eth.BlockChain().StateAt(header.Root) + stateDb, err := b.eth.BlockChain().StateAt(header) if err != nil { - stateDb, err = b.eth.BlockChain().HistoricState(header.Root) + stateDb, err = b.eth.BlockChain().HistoricState(header) if err != nil { return nil, nil, err } @@ -315,6 +315,11 @@ func (b *EthAPIBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) e return b.eth.BlockChain().SubscribeChainHeadEvent(ch) } +// SubscribeNewPayloadEvent registers a subscription for NewPayloadEvent. +func (b *EthAPIBackend) SubscribeNewPayloadEvent(ch chan<- core.NewPayloadEvent) event.Subscription { + return b.eth.BlockChain().SubscribeNewPayloadEvent(ch) +} + func (b *EthAPIBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription { return b.eth.BlockChain().SubscribeLogsEvent(ch) } @@ -342,7 +347,7 @@ func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) } func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) { - pending := b.eth.txPool.Pending(txpool.PendingFilter{}) + pending, _ := b.eth.txPool.Pending(txpool.PendingFilter{}) var txs types.Transactions for _, batch := range pending { for _, lazy := range batch { @@ -409,9 +414,10 @@ func (b *EthAPIBackend) SyncProgress(ctx context.Context) ethereum.SyncProgress prog.TxIndexFinishedBlocks = txProg.Indexed prog.TxIndexRemainingBlocks = txProg.Remaining } - remain, err := b.eth.blockchain.StateIndexProgress() + stateRemain, trienodeRemain, err := b.eth.blockchain.StateIndexProgress() if err == nil { - prog.StateIndexRemaining = remain + prog.StateIndexRemaining = stateRemain + prog.TrienodeIndexRemaining = trienodeRemain } return prog } @@ -479,12 +485,12 @@ func (b *EthAPIBackend) CurrentHeader() *types.Header { return b.eth.blockchain.CurrentHeader() } -func (b *EthAPIBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) { - return b.eth.stateAtBlock(ctx, block, reexec, base, readOnly, preferDisk) +func (b *EthAPIBackend) StateAtBlock(ctx context.Context, block *types.Block, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) { + return b.eth.stateAtBlock(ctx, block, base, readOnly, preferDisk) } -func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*types.Transaction, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { - return b.eth.stateAtTransaction(ctx, block, txIndex, reexec) +func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int) (*types.Transaction, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { + return b.eth.stateAtTransaction(ctx, block, txIndex) } func (b *EthAPIBackend) RPCTxSyncDefaultTimeout() time.Duration { diff --git a/eth/api_debug.go b/eth/api_debug.go index db1b842e90ff..260e24c2eec8 100644 --- a/eth/api_debug.go +++ b/eth/api_debug.go @@ -24,6 +24,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/stateless" @@ -81,7 +82,7 @@ func (api *DebugAPI) DumpBlock(blockNr rpc.BlockNumber) (state.Dump, error) { if header == nil { return state.Dump{}, fmt.Errorf("block #%d not found", blockNr) } - stateDb, err := api.eth.BlockChain().StateAt(header.Root) + stateDb, err := api.eth.BlockChain().StateAt(header) if err != nil { return state.Dump{}, err } @@ -166,7 +167,7 @@ func (api *DebugAPI) AccountRange(blockNrOrHash rpc.BlockNumberOrHash, start hex if header == nil { return state.Dump{}, fmt.Errorf("block #%d not found", number) } - stateDb, err = api.eth.BlockChain().StateAt(header.Root) + stateDb, err = api.eth.BlockChain().StateAt(header) if err != nil { return state.Dump{}, err } @@ -176,7 +177,7 @@ func (api *DebugAPI) AccountRange(blockNrOrHash rpc.BlockNumberOrHash, start hex if block == nil { return state.Dump{}, fmt.Errorf("block %s not found", hash.Hex()) } - stateDb, err = api.eth.BlockChain().StateAt(block.Root()) + stateDb, err = api.eth.BlockChain().StateAt(block.Header()) if err != nil { return state.Dump{}, err } @@ -221,7 +222,7 @@ func (api *DebugAPI) StorageRangeAt(ctx context.Context, blockNrOrHash rpc.Block if block == nil { return StorageRangeResult{}, fmt.Errorf("block %v not found", blockNrOrHash) } - _, _, statedb, release, err := api.eth.stateAtTransaction(ctx, block, txIndex, 0) + _, _, statedb, release, err := api.eth.stateAtTransaction(ctx, block, txIndex) if err != nil { return StorageRangeResult{}, err } @@ -235,6 +236,8 @@ func storageRangeAt(statedb *state.StateDB, root common.Hash, address common.Add if storageRoot == types.EmptyRootHash || storageRoot == (common.Hash{}) { return StorageRangeResult{}, nil // empty storage } + // TODO(rjl493456442) it's problematic for traversing the state with in-memory + // state mutations, specifically txIndex != 0. id := trie.StorageTrieID(root, crypto.Keccak256Hash(address.Bytes()), storageRoot) tr, err := trie.NewStateTrie(id, statedb.Database().TrieDB()) if err != nil { @@ -493,34 +496,22 @@ func (api *DebugAPI) StateSize(blockHashOrNumber *rpc.BlockNumberOrHash) (interf }, nil } -func (api *DebugAPI) ExecutionWitness(bn rpc.BlockNumber) (*stateless.ExtWitness, error) { +func (api *DebugAPI) ExecutionWitness(bn rpc.BlockNumberOrHash) (*stateless.ExtWitness, error) { bc := api.eth.blockchain - block, err := api.eth.APIBackend.BlockByNumber(context.Background(), bn) + block, err := api.eth.APIBackend.BlockByNumberOrHash(context.Background(), bn) if err != nil { - return &stateless.ExtWitness{}, fmt.Errorf("block number %v not found", bn) + return &stateless.ExtWitness{}, fmt.Errorf("block %v not found", bn) } parent := bc.GetHeader(block.ParentHash(), block.NumberU64()-1) if parent == nil { - return &stateless.ExtWitness{}, fmt.Errorf("block number %v found, but parent missing", bn) + return &stateless.ExtWitness{}, fmt.Errorf("block %v found, but parent missing", bn) } - result, err := bc.ProcessBlock(parent.Root, block, false, true) - if err != nil { - return nil, err - } - return result.Witness().ToExtWitness(), nil -} - -func (api *DebugAPI) ExecutionWitnessByHash(hash common.Hash) (*stateless.ExtWitness, error) { - bc := api.eth.blockchain - block := bc.GetBlockByHash(hash) - if block == nil { - return &stateless.ExtWitness{}, fmt.Errorf("block hash %x not found", hash) - } - parent := bc.GetHeader(block.ParentHash(), block.NumberU64()-1) - if parent == nil { - return &stateless.ExtWitness{}, fmt.Errorf("block number %x found, but parent missing", hash) + config := core.ExecuteConfig{ + WriteState: false, + EnableTracer: false, + MakeWitness: true, } - result, err := bc.ProcessBlock(parent.Root, block, false, true) + result, err := bc.ProcessBlock(context.Background(), parent.Root, block, config) if err != nil { return nil, err } diff --git a/eth/backend.go b/eth/backend.go index cae2aabe30e7..0b5eab2462cb 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -33,6 +33,7 @@ import ( "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/filtermaps" + "github.com/ethereum/go-ethereum/core/history" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state/pruner" "github.com/ethereum/go-ethereum/core/txpool" @@ -48,7 +49,6 @@ import ( "github.com/ethereum/go-ethereum/eth/protocols/snap" "github.com/ethereum/go-ethereum/eth/tracers" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/internal/shutdowncheck" "github.com/ethereum/go-ethereum/internal/version" @@ -104,7 +104,6 @@ type Ethereum struct { // DB interfaces chainDb ethdb.Database // Block chain database - eventMux *event.TypeMux engine consensus.Engine accountManager *accounts.Manager @@ -175,7 +174,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { // Here we determine genesis hash and active ChainConfig. // We need these to figure out the consensus parameters and to set up history pruning. - chainConfig, _, err := core.LoadChainConfig(chainDb, config.Genesis) + chainConfig, genesisHash, err := core.LoadChainConfig(chainDb, config.Genesis) if err != nil { return nil, err } @@ -193,7 +192,6 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { eth := &Ethereum{ config: config, chainDb: chainDb, - eventMux: stack.EventMux(), accountManager: stack.AccountManager(), engine: engine, networkID: networkID, @@ -220,31 +218,40 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { rawdb.WriteDatabaseVersion(chainDb, core.BlockChainVersion) } } + histPolicy, err := history.NewPolicy(config.HistoryMode, genesisHash) + if err != nil { + return nil, err + } var ( options = &core.BlockChainConfig{ - TrieCleanLimit: config.TrieCleanCache, - NoPrefetch: config.NoPrefetch, - TrieDirtyLimit: config.TrieDirtyCache, - ArchiveMode: config.NoPruning, - TrieTimeLimit: config.TrieTimeout, - SnapshotLimit: config.SnapshotCache, - Preimages: config.Preimages, - StateHistory: config.StateHistory, - StateScheme: scheme, - ChainHistoryMode: config.HistoryMode, - TxLookupLimit: int64(min(config.TransactionHistory, math.MaxInt64)), + TrieCleanLimit: config.TrieCleanCache, + NoPrefetch: config.NoPrefetch, + TrieDirtyLimit: config.TrieDirtyCache, + ArchiveMode: config.NoPruning, + TrieTimeLimit: config.TrieTimeout, + SnapshotLimit: config.SnapshotCache, + Preimages: config.Preimages, + StateHistory: config.StateHistory, + TrienodeHistory: config.TrienodeHistory, + NodeFullValueCheckpoint: config.NodeFullValueCheckpoint, + BinTrieGroupDepth: config.BinTrieGroupDepth, + StateScheme: scheme, + HistoryPolicy: histPolicy, + TxLookupLimit: int64(min(config.TransactionHistory, math.MaxInt64)), VmConfig: vm.Config{ EnablePreimageRecording: config.EnablePreimageRecording, - EnableWitnessStats: config.EnableWitnessStats, - StatelessSelfValidation: config.StatelessSelfValidation, }, // Enables file journaling for the trie database. The journal files will be stored // within the data directory. The corresponding paths will be either: // - DATADIR/triedb/merkle.journal // - DATADIR/triedb/verkle.journal - TrieJournalDirectory: stack.ResolvePath("triedb"), - StateSizeTracking: config.EnableStateSizeTracking, - SlowBlockThreshold: config.SlowBlockThreshold, + TrieJournalDirectory: stack.ResolvePath("triedb"), + StateSizeTracking: config.EnableStateSizeTracking, + StateSizeTrackingDepth: config.StateSizeTrackingDepth, + SlowBlockThreshold: config.SlowBlockThreshold, + + StatelessSelfValidation: config.StatelessSelfValidation, + EnableWitnessStats: config.EnableWitnessStats, } ) if config.VMTrace != "" { @@ -269,8 +276,8 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { if config.OverrideBPO2 != nil { overrides.OverrideBPO2 = config.OverrideBPO2 } - if config.OverrideVerkle != nil { - overrides.OverrideVerkle = config.OverrideVerkle + if config.OverrideUBT != nil { + overrides.OverrideUBT = config.OverrideUBT } options.Overrides = &overrides @@ -335,7 +342,6 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { Network: networkID, Sync: config.SyncMode, BloomCache: uint64(cacheLimit), - EventMux: eth.eventMux, RequiredBlocks: config.RequiredBlocks, }); err != nil { return nil, err @@ -396,7 +402,7 @@ func (s *Ethereum) APIs() []rpc.API { Service: NewMinerAPI(s), }, { Namespace: "eth", - Service: downloader.NewDownloaderAPI(s.handler.downloader, s.blockchain, s.eventMux), + Service: downloader.NewDownloaderAPI(s.handler.downloader, s.blockchain), }, { Namespace: "admin", Service: NewAdminAPI(s), @@ -493,6 +499,9 @@ func (s *Ethereum) updateFilterMapsHeads() { if head == nil || newHead.Hash() != head.Hash() { head = newHead chainView := s.newChainView(head) + if chainView == nil { + return + } historyCutoff, _ := s.blockchain.HistoryPruningCutoff() var finalBlock uint64 if fb := s.blockchain.CurrentFinalBlock(); fb != nil { @@ -588,7 +597,6 @@ func (s *Ethereum) Stop() error { s.shutdownTracker.Stop() s.chainDb.Close() - s.eventMux.Stop() return nil } diff --git a/eth/catalyst/api.go b/eth/catalyst/api.go index d6d3f579364d..1def169ae0c9 100644 --- a/eth/catalyst/api.go +++ b/eth/catalyst/api.go @@ -18,6 +18,7 @@ package catalyst import ( + "context" "errors" "fmt" "reflect" @@ -30,13 +31,14 @@ import ( "github.com/ethereum/go-ethereum/beacon/engine" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/internal/version" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" @@ -45,9 +47,10 @@ import ( "github.com/ethereum/go-ethereum/rpc" ) -// Register adds the engine API to the full node. +// Register adds the engine API and related APIs to the full node. func Register(stack *node.Node, backend *eth.Ethereum) error { stack.RegisterAPIs([]rpc.API{ + newTestingAPI(backend), { Namespace: "engine", Service: NewConsensusAPI(backend), @@ -79,20 +82,9 @@ const ( // beaconUpdateWarnFrequency is the frequency at which to warn the user that // the beacon client is offline. beaconUpdateWarnFrequency = 5 * time.Minute -) - -var ( - // Number of blobs requested via getBlobsV2 - getBlobsRequestedCounter = metrics.NewRegisteredCounter("engine/getblobs/requested", nil) - - // Number of blobs requested via getBlobsV2 that are present in the blobpool - getBlobsAvailableCounter = metrics.NewRegisteredCounter("engine/getblobs/available", nil) - // Number of times getBlobsV2 responded with “hit” - getBlobsV2RequestHit = metrics.NewRegisteredCounter("engine/getblobs/hit", nil) - - // Number of times getBlobsV2 responded with “miss” - getBlobsV2RequestMiss = metrics.NewRegisteredCounter("engine/getblobs/miss", nil) + // maxReorgDepth is the maximum reorg depth accepted via forkchoiceUpdated. + maxReorgDepth = 32 ) type ConsensusAPI struct { @@ -137,6 +129,9 @@ type ConsensusAPI struct { // NewConsensusAPI creates a new consensus api for the given backend. // The underlying blockchain needs to have a valid terminal total difficulty set. +// +// This function creates a long-lived object with an attached background thread. +// For testing or other short-term use cases, please use newConsensusAPIWithoutHeartbeat. func NewConsensusAPI(eth *eth.Ethereum) *ConsensusAPI { api := newConsensusAPIWithoutHeartbeat(eth) go api.heartbeat() @@ -170,7 +165,7 @@ func newConsensusAPIWithoutHeartbeat(eth *eth.Ethereum) *ConsensusAPI { // // If there are payloadAttributes: we try to assemble a block with the payloadAttributes // and return its payloadID. -func (api *ConsensusAPI) ForkchoiceUpdatedV1(update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { +func (api *ConsensusAPI) ForkchoiceUpdatedV1(ctx context.Context, update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { if payloadAttributes != nil { switch { case payloadAttributes.Withdrawals != nil || payloadAttributes.BeaconRoot != nil: @@ -179,12 +174,12 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV1(update engine.ForkchoiceStateV1, pa return engine.STATUS_INVALID, paramsErr("fcuV1 called post-shanghai") } } - return api.forkchoiceUpdated(update, payloadAttributes, engine.PayloadV1, false) + return api.forkchoiceUpdated(ctx, update, payloadAttributes, engine.PayloadV1, false) } // ForkchoiceUpdatedV2 is equivalent to V1 with the addition of withdrawals in the payload // attributes. It supports both PayloadAttributesV1 and PayloadAttributesV2. -func (api *ConsensusAPI) ForkchoiceUpdatedV2(update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { +func (api *ConsensusAPI) ForkchoiceUpdatedV2(ctx context.Context, update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { if params != nil { switch { case params.BeaconRoot != nil: @@ -197,12 +192,12 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV2(update engine.ForkchoiceStateV1, pa return engine.STATUS_INVALID, unsupportedForkErr("fcuV2 must only be called with paris or shanghai payloads") } } - return api.forkchoiceUpdated(update, params, engine.PayloadV2, false) + return api.forkchoiceUpdated(ctx, update, params, engine.PayloadV2, false) } // ForkchoiceUpdatedV3 is equivalent to V2 with the addition of parent beacon block root // in the payload attributes. It supports only PayloadAttributesV3. -func (api *ConsensusAPI) ForkchoiceUpdatedV3(update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { +func (api *ConsensusAPI) ForkchoiceUpdatedV3(ctx context.Context, update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { if params != nil { switch { case params.Withdrawals == nil: @@ -217,10 +212,35 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV3(update engine.ForkchoiceStateV1, pa // hash, even if params are wrong. To do this we need to split up // forkchoiceUpdate into a function that only updates the head and then a // function that kicks off block construction. - return api.forkchoiceUpdated(update, params, engine.PayloadV3, false) + return api.forkchoiceUpdated(ctx, update, params, engine.PayloadV3, false) } -func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes, payloadVersion engine.PayloadVersion, payloadWitness bool) (engine.ForkChoiceResponse, error) { +// ForkchoiceUpdatedV4 is equivalent to V3 with the addition of slot number +// in the payload attributes. It supports only PayloadAttributesV4. +func (api *ConsensusAPI) ForkchoiceUpdatedV4(ctx context.Context, update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { + if params != nil { + switch { + case params.Withdrawals == nil: + return engine.STATUS_INVALID, attributesErr("missing withdrawals") + case params.BeaconRoot == nil: + return engine.STATUS_INVALID, attributesErr("missing beacon root") + case params.SlotNumber == nil: + return engine.STATUS_INVALID, attributesErr("missing slot number") + case !api.checkFork(params.Timestamp, forks.Amsterdam): + return engine.STATUS_INVALID, unsupportedForkErr("fcuV4 must only be called for amsterdam payloads") + } + } + // TODO(matt): the spec requires that fcu is applied when called on a valid + // hash, even if params are wrong. To do this we need to split up + // forkchoiceUpdate into a function that only updates the head and then a + // function that kicks off block construction. + return api.forkchoiceUpdated(ctx, update, params, engine.PayloadV4, false) +} + +func (api *ConsensusAPI) forkchoiceUpdated(ctx context.Context, update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes, payloadVersion engine.PayloadVersion, payloadWitness bool) (result engine.ForkChoiceResponse, err error) { + ctx, _, spanEnd := telemetry.StartSpan(ctx, "engine.forkchoiceUpdated") + defer spanEnd(&err) + api.forkchoiceLock.Lock() defer api.forkchoiceLock.Unlock() @@ -241,12 +261,9 @@ func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payl if res := api.checkInvalidAncestor(update.HeadBlockHash, update.HeadBlockHash); res != nil { return engine.ForkChoiceResponse{PayloadStatus: *res, PayloadID: nil}, nil } - // If the head hash is unknown (was not given to us in a newPayload request), - // we cannot resolve the header, so not much to do. This could be extended in - // the future to resolve from the `eth` network, but it's an unexpected case - // that should be fixed, not papered over. header := api.remoteBlocks.get(update.HeadBlockHash) if header == nil { + // The head hash is unknown locally, try to resolve it from the `eth` network log.Warn("Fetching the unknown forkchoice head from network", "hash", update.HeadBlockHash) retrievedHead, err := api.eth.Downloader().GetHeader(update.HeadBlockHash) if err != nil { @@ -259,7 +276,9 @@ func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payl // If the finalized hash is known, we can direct the downloader to move // potentially more data to the freezer from the get go. finalized := api.remoteBlocks.get(update.FinalizedBlockHash) - + if finalized == nil { + finalized = api.eth.BlockChain().GetHeaderByHash(update.FinalizedBlockHash) + } // Header advertised via a past newPayload request. Start syncing to it. context := []interface{}{"number", header.Number, "hash", header.Hash()} if update.FinalizedBlockHash != (common.Hash{}) { @@ -306,10 +325,23 @@ func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payl // generating the payload. It's a special corner case that a few slots are // missing and we are requested to generate the payload in slot. } else { - // If the head block is already in our canonical chain, the beacon client is - // probably resyncing. Ignore the update. - log.Info("Ignoring beacon update to old head", "number", block.NumberU64(), "hash", update.HeadBlockHash, "age", common.PrettyAge(time.Unix(int64(block.Time()), 0)), "have", api.eth.BlockChain().CurrentBlock().Number) - return valid(nil), nil + if finalized := api.eth.BlockChain().CurrentFinalBlock(); finalized != nil && block.NumberU64() <= finalized.Number.Uint64() { + log.Info("Skipping beacon update to finalized ancestor", "number", block.NumberU64(), "hash", update.HeadBlockHash) + return valid(nil), nil + } + depth := api.eth.BlockChain().CurrentBlock().Number.Uint64() - block.NumberU64() + if depth >= maxReorgDepth { + log.Warn("Refusing too deep reorg", "depth", depth, "head", update.HeadBlockHash) + return engine.STATUS_INVALID, engine.TooDeepReorg.With(fmt.Errorf("reorg depth %d exceeds limit %d", depth, maxReorgDepth)) + } + if !api.eth.Synced() { + log.Info("Ignoring beacon update to old head while syncing", "number", block.NumberU64(), "hash", update.HeadBlockHash) + return valid(nil), nil + } + if latestValid, err := api.eth.BlockChain().SetCanonical(block); err != nil { + log.Error("Error setting canonical", "number", block.NumberU64(), "hash", update.HeadBlockHash, "error", err) + return engine.ForkChoiceResponse{PayloadStatus: engine.PayloadStatusV1{Status: engine.INVALID, LatestValidHash: &latestValid}}, err + } } api.eth.SetSynced() @@ -353,6 +385,7 @@ func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payl Random: payloadAttributes.Random, Withdrawals: payloadAttributes.Withdrawals, BeaconRoot: payloadAttributes.BeaconRoot, + SlotNum: payloadAttributes.SlotNumber, Version: payloadVersion, } id := args.Id() @@ -361,7 +394,7 @@ func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payl if api.localBlocks.has(id) { return valid(&id), nil } - payload, err := api.eth.Miner().BuildPayload(args, payloadWitness) + payload, err := api.eth.Miner().BuildPayload(ctx, args, payloadWitness) if err != nil { log.Error("Failed to build payload", "err", err) return valid(nil), engine.InvalidPayloadAttributes.With(err) @@ -420,7 +453,7 @@ func (api *ConsensusAPI) GetPayloadV2(payloadID engine.PayloadID) (*engine.Execu payloadID, false, []engine.PayloadVersion{engine.PayloadV1, engine.PayloadV2}, - []forks.Fork{forks.Shanghai}, + []forks.Fork{forks.Paris, forks.Shanghai}, ) } @@ -466,6 +499,18 @@ func (api *ConsensusAPI) GetPayloadV5(payloadID engine.PayloadID) (*engine.Execu }) } +// GetPayloadV6 returns a cached payload by id. This endpoint should only +// be used after the Amsterdam fork. +func (api *ConsensusAPI) GetPayloadV6(payloadID engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) { + return api.getPayload( + payloadID, + false, + []engine.PayloadVersion{engine.PayloadV4}, + []forks.Fork{ + forks.Amsterdam, + }) +} + // getPayload will retrieve the specified payload and verify it conforms to the // endpoint's allowed payload versions and forks. // @@ -517,7 +562,7 @@ func (api *ConsensusAPI) GetBlobsV1(hashes []common.Hash) ([]*engine.BlobAndProo if len(hashes) > 128 { return nil, engine.TooLargeRequest.With(fmt.Errorf("requested blob count too large: %v", len(hashes))) } - blobs, _, proofs, err := api.eth.BlobTxPool().GetBlobs(hashes, types.BlobSidecarVersion0, false) + blobs, _, proofs, err := api.eth.BlobTxPool().GetBlobs(hashes, types.BlobSidecarVersion0) if err != nil { return nil, engine.InvalidParams.With(err) } @@ -563,8 +608,25 @@ func (api *ConsensusAPI) GetBlobsV1(hashes []common.Hash) ([]*engine.BlobAndProo func (api *ConsensusAPI) GetBlobsV2(hashes []common.Hash) ([]*engine.BlobAndProofV2, error) { head := api.eth.BlockChain().CurrentHeader() if api.config().LatestFork(head.Time) < forks.Osaka { - return nil, unsupportedForkErr("engine_getBlobsV2 is not available before Osaka fork") + return nil, nil } + return api.getBlobs(hashes, true) +} + +// GetBlobsV3 returns a set of blobs from the transaction pool. Same as +// GetBlobsV2, except will return partial responses in case there is a missing +// blob. +func (api *ConsensusAPI) GetBlobsV3(hashes []common.Hash) ([]*engine.BlobAndProofV2, error) { + head := api.eth.BlockChain().CurrentHeader() + if api.config().LatestFork(head.Time) < forks.Osaka { + return nil, nil + } + return api.getBlobs(hashes, false) +} + +// getBlobs returns all available blobs. In v2, partial responses are not allowed, +// while v3 supports partial responses. +func (api *ConsensusAPI) getBlobs(hashes []common.Hash, v2 bool) ([]*engine.BlobAndProofV2, error) { if len(hashes) > 128 { return nil, engine.TooLargeRequest.With(fmt.Errorf("requested blob count too large: %v", len(hashes))) } @@ -572,28 +634,31 @@ func (api *ConsensusAPI) GetBlobsV2(hashes []common.Hash) ([]*engine.BlobAndProo getBlobsRequestedCounter.Inc(int64(len(hashes))) getBlobsAvailableCounter.Inc(int64(available)) - // Optimization: check first if all blobs are available, if not, return empty response - if available != len(hashes) { - getBlobsV2RequestMiss.Inc(1) + // Short circuit if partial response is not allowed + if v2 && available != len(hashes) { + getBlobsRequestMiss.Inc(1) return nil, nil } - - blobs, _, proofs, err := api.eth.BlobTxPool().GetBlobs(hashes, types.BlobSidecarVersion1, false) + // Retrieve blobs from the pool. This operation is expensive and may involve + // heavy disk I/O. + blobs, _, proofs, err := api.eth.BlobTxPool().GetBlobs(hashes, types.BlobSidecarVersion1) if err != nil { return nil, engine.InvalidParams.With(err) } - - // To comply with API spec, check again that we really got all data needed - for _, blob := range blobs { - if blob == nil { - getBlobsV2RequestMiss.Inc(1) - return nil, nil - } - } - getBlobsV2RequestHit.Inc(1) - + // Validate the blobs from the pool and assemble the response + filled := 0 res := make([]*engine.BlobAndProofV2, len(hashes)) - for i := 0; i < len(blobs); i++ { + for i := range blobs { + // The blob has been evicted since the last AvailableBlobs call. + // Return null if partial response is not allowed. + if blobs[i] == nil { + if !v2 { + continue + } else { + getBlobsRequestMiss.Inc(1) + return nil, nil + } + } var cellProofs []hexutil.Bytes for _, proof := range proofs[i] { cellProofs = append(cellProofs, proof[:]) @@ -602,6 +667,14 @@ func (api *ConsensusAPI) GetBlobsV2(hashes []common.Hash) ([]*engine.BlobAndProo Blob: blobs[i][:], CellProofs: cellProofs, } + filled++ + } + if filled == len(hashes) { + getBlobsRequestCompleteHit.Inc(1) + } else if filled > 0 { + getBlobsRequestPartialHit.Inc(1) + } else { + getBlobsRequestMiss.Inc(1) } return res, nil } @@ -610,15 +683,15 @@ func (api *ConsensusAPI) GetBlobsV2(hashes []common.Hash) ([]*engine.BlobAndProo var invalidStatus = engine.PayloadStatusV1{Status: engine.INVALID} // NewPayloadV1 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. -func (api *ConsensusAPI) NewPayloadV1(params engine.ExecutableData) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadV1(ctx context.Context, params engine.ExecutableData) (engine.PayloadStatusV1, error) { if params.Withdrawals != nil { return invalidStatus, paramsErr("withdrawals not supported in V1") } - return api.newPayload(params, nil, nil, nil, false) + return api.newPayload(ctx, params, nil, nil, nil, false) } // NewPayloadV2 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. -func (api *ConsensusAPI) NewPayloadV2(params engine.ExecutableData) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadV2(ctx context.Context, params engine.ExecutableData) (engine.PayloadStatusV1, error) { var ( cancun = api.config().IsCancun(api.config().LondonBlock, params.Timestamp) shanghai = api.config().IsShanghai(api.config().LondonBlock, params.Timestamp) @@ -635,11 +708,11 @@ func (api *ConsensusAPI) NewPayloadV2(params engine.ExecutableData) (engine.Payl case params.BlobGasUsed != nil: return invalidStatus, paramsErr("non-nil blobGasUsed pre-cancun") } - return api.newPayload(params, nil, nil, nil, false) + return api.newPayload(ctx, params, nil, nil, nil, false) } // NewPayloadV3 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. -func (api *ConsensusAPI) NewPayloadV3(params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadV3(ctx context.Context, params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (engine.PayloadStatusV1, error) { switch { case params.Withdrawals == nil: return invalidStatus, paramsErr("nil withdrawals post-shanghai") @@ -654,11 +727,11 @@ func (api *ConsensusAPI) NewPayloadV3(params engine.ExecutableData, versionedHas case !api.checkFork(params.Timestamp, forks.Cancun): return invalidStatus, unsupportedForkErr("newPayloadV3 must only be called for cancun payloads") } - return api.newPayload(params, versionedHashes, beaconRoot, nil, false) + return api.newPayload(ctx, params, versionedHashes, beaconRoot, nil, false) } // NewPayloadV4 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. -func (api *ConsensusAPI) NewPayloadV4(params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, executionRequests []hexutil.Bytes) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadV4(ctx context.Context, params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, executionRequests []hexutil.Bytes) (engine.PayloadStatusV1, error) { switch { case params.Withdrawals == nil: return invalidStatus, paramsErr("nil withdrawals post-shanghai") @@ -679,10 +752,37 @@ func (api *ConsensusAPI) NewPayloadV4(params engine.ExecutableData, versionedHas if err := validateRequests(requests); err != nil { return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(err) } - return api.newPayload(params, versionedHashes, beaconRoot, requests, false) + return api.newPayload(ctx, params, versionedHashes, beaconRoot, requests, false) +} + +// NewPayloadV5 creates an Eth1 block, inserts it in the chain, and returns the status of the chain. +func (api *ConsensusAPI) NewPayloadV5(ctx context.Context, params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, executionRequests []hexutil.Bytes) (engine.PayloadStatusV1, error) { + switch { + case params.Withdrawals == nil: + return invalidStatus, paramsErr("nil withdrawals post-shanghai") + case params.ExcessBlobGas == nil: + return invalidStatus, paramsErr("nil excessBlobGas post-cancun") + case params.BlobGasUsed == nil: + return invalidStatus, paramsErr("nil blobGasUsed post-cancun") + case versionedHashes == nil: + return invalidStatus, paramsErr("nil versionedHashes post-cancun") + case beaconRoot == nil: + return invalidStatus, paramsErr("nil beaconRoot post-cancun") + case executionRequests == nil: + return invalidStatus, paramsErr("nil executionRequests post-prague") + case params.SlotNumber == nil: + return invalidStatus, paramsErr("nil slotnumber post-amsterdam") + case !api.checkFork(params.Timestamp, forks.Amsterdam): + return invalidStatus, unsupportedForkErr("newPayloadV5 must only be called for amsterdam payloads") + } + requests := convertRequests(executionRequests) + if err := validateRequests(requests); err != nil { + return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(err) + } + return api.newPayload(ctx, params, versionedHashes, beaconRoot, requests, false) } -func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, requests [][]byte, witness bool) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) newPayload(ctx context.Context, params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, requests [][]byte, witness bool) (result engine.PayloadStatusV1, err error) { // The locking here is, strictly, not required. Without these locks, this can happen: // // 1. NewPayload( execdata-N ) is invoked from the CL. It goes all the way down to @@ -696,6 +796,13 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe // sequentially. // Hence, we use a lock here, to be sure that the previous call has finished before we // check whether we already have the block locally. + var attrs = []telemetry.Attribute{ + telemetry.Int64Attribute("block.number", int64(params.Number)), + telemetry.StringAttribute("block.hash", params.BlockHash.Hex()), + telemetry.Int64Attribute("tx.count", int64(len(params.Transactions))), + } + ctx, _, spanEnd := telemetry.StartSpan(ctx, "engine.newPayload", attrs...) + defer spanEnd(&err) api.newPayloadLock.Lock() defer api.newPayloadLock.Unlock() @@ -710,6 +817,10 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe if params.ExcessBlobGas != nil { ebg = strconv.Itoa(int(*params.ExcessBlobGas)) } + slotNum := "nil" + if params.SlotNumber != nil { + slotNum = strconv.Itoa(int(*params.SlotNumber)) + } log.Warn("Invalid NewPayload params", "params.Number", params.Number, "params.ParentHash", params.ParentHash, @@ -725,6 +836,7 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe "params.BaseFeePerGas", params.BaseFeePerGas, "params.BlobGasUsed", bgu, "params.ExcessBlobGas", ebg, + "params.SlotNumber", slotNum, "len(params.Transactions)", len(params.Transactions), "len(params.Withdrawals)", len(params.Withdrawals), "beaconRoot", beaconRoot, @@ -757,7 +869,7 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe return api.delayPayloadImport(block), nil } if block.Time() <= parent.Time() { - log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time()) + log.Warn("Invalid timestamp", "parent", parent.Time(), "block", block.Time()) return api.invalid(errors.New("invalid timestamp"), parent.Header()), nil } // Another corner case: if the node is in snap sync mode, but the CL client @@ -773,7 +885,9 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe return engine.PayloadStatusV1{Status: engine.ACCEPTED}, nil } log.Trace("Inserting block without sethead", "hash", block.Hash(), "number", block.Number()) - proofs, err := api.eth.BlockChain().InsertBlockWithoutSetHead(block, witness) + start := time.Now() + proofs, err := api.eth.BlockChain().InsertBlockWithoutSetHead(ctx, block, witness) + processingTime := time.Since(start) if err != nil { log.Warn("NewPayload: inserting block failed", "error", err) @@ -786,6 +900,13 @@ func (api *ConsensusAPI) newPayload(params engine.ExecutableData, versionedHashe } hash := block.Hash() + // Emit NewPayloadEvent for ethstats reporting + api.eth.BlockChain().SendNewPayloadEvent(core.NewPayloadEvent{ + Hash: hash, + Number: block.NumberU64(), + ProcessingTime: processingTime, + }) + // If witness collection was requested, inject that into the result too var ow *hexutil.Bytes if proofs != nil { @@ -818,7 +939,7 @@ func (api *ConsensusAPI) delayPayloadImport(block *types.Block) engine.PayloadSt return engine.PayloadStatusV1{Status: engine.SYNCING} } // Either no beacon sync was started yet, or it rejected the delivered - // payload as non-integratable on top of the existing sync. We'll just + // payload as non-integrate on top of the existing sync. We'll just // have to rely on the beacon client to forcefully update the head with // a forkchoice update request. if api.eth.Downloader().ConfigSyncMode() == ethconfig.FullSync { @@ -916,8 +1037,6 @@ func (api *ConsensusAPI) invalid(err error, latestValid *types.Header) engine.Pa // heartbeat loops indefinitely, and checks if there have been beacon client updates // received in the last while. If not - or if they but strange ones - it warns the // user that something might be off with their consensus node. -// -// TODO(karalabe): Spin this goroutine down somehow func (api *ConsensusAPI) heartbeat() { // Sleep a bit on startup since there's obviously no beacon client yet // attached, so no need to print scary warnings to the user. diff --git a/eth/catalyst/api_test.go b/eth/catalyst/api_test.go index a023962b81dd..1f38c4dd8a36 100644 --- a/eth/catalyst/api_test.go +++ b/eth/catalyst/api_test.go @@ -190,7 +190,7 @@ func TestEth2PrepareAndGetPayload(t *testing.T) { SafeBlockHash: common.Hash{}, FinalizedBlockHash: common.Hash{}, } - _, err := api.ForkchoiceUpdatedV1(fcState, &blockParams) + _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, &blockParams) if err != nil { t.Fatalf("error preparing payload, err=%v", err) } @@ -270,7 +270,7 @@ func TestInvalidPayloadTimestamp(t *testing.T) { SafeBlockHash: common.Hash{}, FinalizedBlockHash: common.Hash{}, } - _, err := api.ForkchoiceUpdatedV1(fcState, ¶ms) + _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, ¶ms) if test.shouldErr && err == nil { t.Fatalf("expected error preparing payload with invalid timestamp, err=%v", err) } else if !test.shouldErr && err != nil { @@ -299,7 +299,7 @@ func TestEth2NewBlock(t *testing.T) { ethservice.BlockChain().SubscribeRemovedLogsEvent(rmLogsCh) for i := 0; i < 10; i++ { - statedb, _ := ethservice.BlockChain().StateAt(parent.Root()) + statedb, _ := ethservice.BlockChain().StateAt(parent.Header()) nonce := statedb.GetNonce(testAddr) tx, _ := types.SignTx(types.NewContractCreation(nonce, new(big.Int), 1000000, big.NewInt(2*params.InitialBaseFee), logCode), types.LatestSigner(ethservice.BlockChain().Config()), testKey) ethservice.TxPool().Add([]*types.Transaction{tx}, true) @@ -314,7 +314,7 @@ func TestEth2NewBlock(t *testing.T) { if err != nil { t.Fatalf("Failed to convert executable data to block %v", err) } - newResp, err := api.NewPayloadV1(*execData) + newResp, err := api.NewPayloadV1(context.Background(), *execData) switch { case err != nil: t.Fatalf("Failed to insert block: %v", err) @@ -329,7 +329,7 @@ func TestEth2NewBlock(t *testing.T) { SafeBlockHash: block.Hash(), FinalizedBlockHash: block.Hash(), } - if _, err := api.ForkchoiceUpdatedV1(fcState, nil); err != nil { + if _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, nil); err != nil { t.Fatalf("Failed to insert block: %v", err) } if have, want := ethservice.BlockChain().CurrentBlock().Number.Uint64(), block.NumberU64(); have != want { @@ -356,7 +356,7 @@ func TestEth2NewBlock(t *testing.T) { if err != nil { t.Fatalf("Failed to convert executable data to block %v", err) } - newResp, err := api.NewPayloadV1(*execData) + newResp, err := api.NewPayloadV1(context.Background(), *execData) if err != nil || newResp.Status != "VALID" { t.Fatalf("Failed to insert block: %v", err) } @@ -369,7 +369,7 @@ func TestEth2NewBlock(t *testing.T) { SafeBlockHash: block.Hash(), FinalizedBlockHash: block.Hash(), } - if _, err := api.ForkchoiceUpdatedV1(fcState, nil); err != nil { + if _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, nil); err != nil { t.Fatalf("Failed to insert block: %v", err) } if ethservice.BlockChain().CurrentBlock().Number.Uint64() != block.NumberU64() { @@ -478,7 +478,7 @@ func TestFullAPI(t *testing.T) { ) callback := func(parent *types.Header) { - statedb, _ := ethservice.BlockChain().StateAt(parent.Root) + statedb, _ := ethservice.BlockChain().StateAt(parent) nonce := statedb.GetNonce(testAddr) tx, _ := types.SignTx(types.NewContractCreation(nonce, new(big.Int), 1000000, big.NewInt(2*params.InitialBaseFee), logCode), types.LatestSigner(ethservice.BlockChain().Config()), testKey) ethservice.TxPool().Add([]*types.Transaction{tx}, false) @@ -502,7 +502,7 @@ func setupBlocks(t *testing.T, ethservice *eth.Ethereum, n int, parent *types.He } envelope := getNewEnvelope(t, api, parent, w, h) - execResp, err := api.newPayload(*envelope.ExecutionPayload, []common.Hash{}, h, envelope.Requests, false) + execResp, err := api.newPayload(context.Background(), *envelope.ExecutionPayload, []common.Hash{}, h, envelope.Requests, false) if err != nil { t.Fatalf("can't execute payload: %v", err) } @@ -515,7 +515,7 @@ func setupBlocks(t *testing.T, ethservice *eth.Ethereum, n int, parent *types.He SafeBlockHash: payload.ParentHash, FinalizedBlockHash: payload.ParentHash, } - if _, err := api.ForkchoiceUpdatedV1(fcState, nil); err != nil { + if _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, nil); err != nil { t.Fatalf("Failed to insert block: %v", err) } if ethservice.BlockChain().CurrentBlock().Number.Uint64() != payload.Number { @@ -604,7 +604,7 @@ func TestNewPayloadOnInvalidChain(t *testing.T) { logCode = common.Hex2Bytes("60606040525b7f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405180905060405180910390a15b600a8060416000396000f360606040526008565b00") ) for i := 0; i < 10; i++ { - statedb, _ := ethservice.BlockChain().StateAt(parent.Root) + statedb, _ := ethservice.BlockChain().StateAt(parent) tx := types.MustSignNewTx(testKey, signer, &types.LegacyTx{ Nonce: statedb.GetNonce(testAddr), Value: new(big.Int), @@ -629,7 +629,7 @@ func TestNewPayloadOnInvalidChain(t *testing.T) { err error ) for i := 0; ; i++ { - if resp, err = api.ForkchoiceUpdatedV1(fcState, ¶ms); err != nil { + if resp, err = api.ForkchoiceUpdatedV1(context.Background(), fcState, ¶ms); err != nil { t.Fatalf("error preparing payload, err=%v", err) } if resp.PayloadStatus.Status != engine.VALID { @@ -648,7 +648,7 @@ func TestNewPayloadOnInvalidChain(t *testing.T) { t.Fatalf("payload should not be empty") } } - execResp, err := api.NewPayloadV1(*payload.ExecutionPayload) + execResp, err := api.NewPayloadV1(context.Background(), *payload.ExecutionPayload) if err != nil { t.Fatalf("can't execute payload: %v", err) } @@ -660,7 +660,7 @@ func TestNewPayloadOnInvalidChain(t *testing.T) { SafeBlockHash: payload.ExecutionPayload.ParentHash, FinalizedBlockHash: payload.ExecutionPayload.ParentHash, } - if _, err := api.ForkchoiceUpdatedV1(fcState, nil); err != nil { + if _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, nil); err != nil { t.Fatalf("Failed to insert block: %v", err) } if ethservice.BlockChain().CurrentBlock().Number.Uint64() != payload.ExecutionPayload.Number { @@ -679,7 +679,7 @@ func assembleEnvelope(api *ConsensusAPI, parentHash common.Hash, params *engine. Withdrawals: params.Withdrawals, BeaconRoot: params.BeaconRoot, } - payload, err := api.eth.Miner().BuildPayload(args, false) + payload, err := api.eth.Miner().BuildPayload(context.Background(), args, false) if err != nil { return nil, err } @@ -708,7 +708,7 @@ func TestEmptyBlocks(t *testing.T) { // (1) check LatestValidHash by sending a normal payload (P1'') payload := getNewPayload(t, api, commonAncestor, nil, nil) - status, err := api.NewPayloadV1(*payload) + status, err := api.NewPayloadV1(context.Background(), *payload) if err != nil { t.Fatal(err) } @@ -724,7 +724,7 @@ func TestEmptyBlocks(t *testing.T) { payload.GasUsed += 1 payload = setBlockhash(payload) // Now latestValidHash should be the common ancestor - status, err = api.NewPayloadV1(*payload) + status, err = api.NewPayloadV1(context.Background(), *payload) if err != nil { t.Fatal(err) } @@ -742,7 +742,7 @@ func TestEmptyBlocks(t *testing.T) { payload.ParentHash = common.Hash{1} payload = setBlockhash(payload) // Now latestValidHash should be the common ancestor - status, err = api.NewPayloadV1(*payload) + status, err = api.NewPayloadV1(context.Background(), *payload) if err != nil { t.Fatal(err) } @@ -859,7 +859,7 @@ func TestTrickRemoteBlockCache(t *testing.T) { // feed the payloads to node B for _, payload := range invalidChain { - status, err := apiB.NewPayloadV1(*payload) + status, err := apiB.NewPayloadV1(context.Background(), *payload) if err != nil { panic(err) } @@ -867,7 +867,7 @@ func TestTrickRemoteBlockCache(t *testing.T) { t.Error("invalid status: VALID on an invalid chain") } // Now reorg to the head of the invalid chain - resp, err := apiB.ForkchoiceUpdatedV1(engine.ForkchoiceStateV1{HeadBlockHash: payload.BlockHash, SafeBlockHash: payload.BlockHash, FinalizedBlockHash: payload.ParentHash}, nil) + resp, err := apiB.ForkchoiceUpdatedV1(context.Background(), engine.ForkchoiceStateV1{HeadBlockHash: payload.BlockHash, SafeBlockHash: payload.BlockHash, FinalizedBlockHash: payload.ParentHash}, nil) if err != nil { t.Fatal(err) } @@ -892,7 +892,7 @@ func TestInvalidBloom(t *testing.T) { // (1) check LatestValidHash by sending a normal payload (P1'') payload := getNewPayload(t, api, commonAncestor, nil, nil) payload.LogsBloom = append(payload.LogsBloom, byte(1)) - status, err := api.NewPayloadV1(*payload) + status, err := api.NewPayloadV1(context.Background(), *payload) if err != nil { t.Fatal(err) } @@ -931,7 +931,7 @@ func TestSimultaneousNewBlock(t *testing.T) { for ii := 0; ii < 10; ii++ { go func() { defer wg.Done() - if newResp, err := api.NewPayloadV1(*execData); err != nil { + if newResp, err := api.NewPayloadV1(context.Background(), *execData); err != nil { errMu.Lock() testErr = fmt.Errorf("failed to insert block: %w", err) errMu.Unlock() @@ -970,7 +970,7 @@ func TestSimultaneousNewBlock(t *testing.T) { for ii := 0; ii < 10; ii++ { go func() { defer wg.Done() - if _, err := api.ForkchoiceUpdatedV1(fcState, nil); err != nil { + if _, err := api.ForkchoiceUpdatedV1(context.Background(), fcState, nil); err != nil { errMu.Lock() testErr = fmt.Errorf("failed to insert block: %w", err) errMu.Unlock() @@ -1011,7 +1011,7 @@ func TestWithdrawals(t *testing.T) { fcState := engine.ForkchoiceStateV1{ HeadBlockHash: parent.Hash(), } - resp, err := api.ForkchoiceUpdatedV2(fcState, &blockParams) + resp, err := api.ForkchoiceUpdatedV2(context.Background(), fcState, &blockParams) if err != nil { t.Fatalf("error preparing payload, err=%v", err) } @@ -1038,7 +1038,7 @@ func TestWithdrawals(t *testing.T) { } // 10: verify locally built block - if status, err := api.NewPayloadV2(*execData.ExecutionPayload); err != nil { + if status, err := api.NewPayloadV2(context.Background(), *execData.ExecutionPayload); err != nil { t.Fatalf("error validating payload: %v", err) } else if status.Status != engine.VALID { t.Fatalf("invalid payload") @@ -1063,7 +1063,7 @@ func TestWithdrawals(t *testing.T) { }, } fcState.HeadBlockHash = execData.ExecutionPayload.BlockHash - _, err = api.ForkchoiceUpdatedV2(fcState, &blockParams) + _, err = api.ForkchoiceUpdatedV2(context.Background(), fcState, &blockParams) if err != nil { t.Fatalf("error preparing payload, err=%v", err) } @@ -1082,7 +1082,7 @@ func TestWithdrawals(t *testing.T) { if err != nil { t.Fatalf("error getting payload, err=%v", err) } - if status, err := api.NewPayloadV2(*execData.ExecutionPayload); err != nil { + if status, err := api.NewPayloadV2(context.Background(), *execData.ExecutionPayload); err != nil { t.Fatalf("error validating payload: %v", err) } else if status.Status != engine.VALID { t.Fatalf("invalid payload") @@ -1090,7 +1090,7 @@ func TestWithdrawals(t *testing.T) { // 11: set block as head. fcState.HeadBlockHash = execData.ExecutionPayload.BlockHash - _, err = api.ForkchoiceUpdatedV2(fcState, nil) + _, err = api.ForkchoiceUpdatedV2(context.Background(), fcState, nil) if err != nil { t.Fatalf("error preparing payload, err=%v", err) } @@ -1196,10 +1196,10 @@ func TestNilWithdrawals(t *testing.T) { ) if !shanghai { payloadVersion = engine.PayloadV1 - _, err = api.ForkchoiceUpdatedV1(fcState, &test.blockParams) + _, err = api.ForkchoiceUpdatedV1(context.Background(), fcState, &test.blockParams) } else { payloadVersion = engine.PayloadV2 - _, err = api.ForkchoiceUpdatedV2(fcState, &test.blockParams) + _, err = api.ForkchoiceUpdatedV2(context.Background(), fcState, &test.blockParams) } if test.wantErr { if err == nil { @@ -1219,15 +1219,20 @@ func TestNilWithdrawals(t *testing.T) { Random: test.blockParams.Random, Version: payloadVersion, }).Id() + if !shanghai { + if _, err := api.GetPayloadV2(payloadID); err != nil { + t.Fatalf("GetPayloadV2 rejected pre-shanghai payload: %v", err) + } + } execData, err := api.getPayload(payloadID, false, nil, nil) if err != nil { t.Fatalf("error getting payload, err=%v", err) } var status engine.PayloadStatusV1 if !shanghai { - status, err = api.NewPayloadV1(*execData.ExecutionPayload) + status, err = api.NewPayloadV1(context.Background(), *execData.ExecutionPayload) } else { - status, err = api.NewPayloadV2(*execData.ExecutionPayload) + status, err = api.NewPayloadV2(context.Background(), *execData.ExecutionPayload) } if err != nil { t.Fatalf("error validating payload: %v", err.(*engine.EngineAPIError).ErrorData()) @@ -1258,7 +1263,7 @@ func setupBodies(t *testing.T) (*node.Node, *eth.Ethereum, []*types.Block) { // Each block, this callback will include two txs that generate body values like logs and requests. callback := func(parent *types.Header) { var ( - statedb, _ = ethservice.BlockChain().StateAt(parent.Root) + statedb, _ = ethservice.BlockChain().StateAt(parent) // Create tx to trigger log generator. tx1, _ = types.SignTx(types.NewContractCreation(statedb.GetNonce(testAddr), new(big.Int), 1000000, big.NewInt(2*params.InitialBaseFee), logCode), types.LatestSigner(ethservice.BlockChain().Config()), testKey) // Create tx to trigger deposit generator. @@ -1574,7 +1579,7 @@ func TestParentBeaconBlockRoot(t *testing.T) { fcState := engine.ForkchoiceStateV1{ HeadBlockHash: parent.Hash(), } - resp, err := api.ForkchoiceUpdatedV3(fcState, &blockParams) + resp, err := api.ForkchoiceUpdatedV3(context.Background(), fcState, &blockParams) if err != nil { t.Fatalf("error preparing payload, err=%v", err.(*engine.EngineAPIError).ErrorData()) } @@ -1598,14 +1603,14 @@ func TestParentBeaconBlockRoot(t *testing.T) { } // 11: verify locally built block - if status, err := api.NewPayloadV3(*execData.ExecutionPayload, []common.Hash{}, &common.Hash{42}); err != nil { + if status, err := api.NewPayloadV3(context.Background(), *execData.ExecutionPayload, []common.Hash{}, &common.Hash{42}); err != nil { t.Fatalf("error validating payload: %v", err) } else if status.Status != engine.VALID { t.Fatalf("invalid payload") } fcState.HeadBlockHash = execData.ExecutionPayload.BlockHash - resp, err = api.ForkchoiceUpdatedV3(fcState, nil) + resp, err = api.ForkchoiceUpdatedV3(context.Background(), fcState, nil) if err != nil { t.Fatalf("error preparing payload, err=%v", err.(*engine.EngineAPIError).ErrorData()) } @@ -1661,7 +1666,7 @@ func TestWitnessCreationAndConsumption(t *testing.T) { SafeBlockHash: common.Hash{}, FinalizedBlockHash: common.Hash{}, } - _, err := api.ForkchoiceUpdatedWithWitnessV3(fcState, &blockParams) + _, err := api.ForkchoiceUpdatedWithWitnessV3(context.Background(), fcState, &blockParams) if err != nil { t.Fatalf("error preparing payload, err=%v", err) } @@ -1705,7 +1710,7 @@ func TestWitnessCreationAndConsumption(t *testing.T) { envelope.ExecutionPayload.StateRoot = wantStateRoot envelope.ExecutionPayload.ReceiptsRoot = wantReceiptRoot - res2, err := api.NewPayloadWithWitnessV3(*envelope.ExecutionPayload, []common.Hash{}, &common.Hash{42}) + res2, err := api.NewPayloadWithWitnessV3(context.Background(), *envelope.ExecutionPayload, []common.Hash{}, &common.Hash{42}) if err != nil { t.Fatalf("error executing stateless payload witness: %v", err) } @@ -2016,7 +2021,7 @@ func TestGetBlobsV1AfterOsakaFork(t *testing.T) { } } -func TestGetBlobsV2(t *testing.T) { +func TestGetBlobsV2And3(t *testing.T) { n, api := newGetBlobEnv(t, 1) defer n.Close() @@ -2045,7 +2050,8 @@ func TestGetBlobsV2(t *testing.T) { }, } for i, suite := range suites { - runGetBlobsV2(t, api, suite.start, suite.limit, suite.fillRandom, fmt.Sprintf("suite=%d", i)) + runGetBlobs(t, api.GetBlobsV2, suite.start, suite.limit, suite.fillRandom, false, fmt.Sprintf("GetBlobsV2 suite=%d", i)) + runGetBlobs(t, api.GetBlobsV3, suite.start, suite.limit, suite.fillRandom, true, fmt.Sprintf("GetBlobsV3 suite=%d %v", i, suite)) } } @@ -2060,22 +2066,20 @@ func BenchmarkGetBlobsV2(b *testing.B) { name := fmt.Sprintf("blobs=%d", blobs) b.Run(name, func(b *testing.B) { for b.Loop() { - runGetBlobsV2(b, api, 0, blobs, false, name) + runGetBlobs(b, api.GetBlobsV2, 0, blobs, false, false, name) } }) } } -func runGetBlobsV2(t testing.TB, api *ConsensusAPI, start, limit int, fillRandom bool, name string) { +type getBlobsFn func(hashes []common.Hash) ([]*engine.BlobAndProofV2, error) + +func runGetBlobs(t testing.TB, getBlobs getBlobsFn, start, limit int, fillRandom bool, expectPartialResponse bool, name string) { // Fill the request for retrieving blobs var ( vhashes []common.Hash expect []*engine.BlobAndProofV2 ) - // fill missing blob - if fillRandom { - vhashes = append(vhashes, testrand.Hash()) - } for j := start; j < limit; j++ { vhashes = append(vhashes, testBlobVHashes[j]) var cellProofs []hexutil.Bytes @@ -2087,13 +2091,21 @@ func runGetBlobsV2(t testing.TB, api *ConsensusAPI, start, limit int, fillRandom CellProofs: cellProofs, }) } - result, err := api.GetBlobsV2(vhashes) + // fill missing blob + if fillRandom { + vhashes = append(vhashes, testrand.Hash()) + } + result, err := getBlobs(vhashes) if err != nil { t.Errorf("Unexpected error for case %s, %v", name, err) } - // null is responded if any blob is missing if fillRandom { - expect = nil + if expectPartialResponse { + expect = append(expect, nil) + } else { + // Nil is expected if getBlobs can not return a partial response + expect = nil + } } if !reflect.DeepEqual(result, expect) { t.Fatalf("Unexpected result for case %s", name) diff --git a/eth/catalyst/api_testing.go b/eth/catalyst/api_testing.go new file mode 100644 index 000000000000..2818d7f0bbc4 --- /dev/null +++ b/eth/catalyst/api_testing.go @@ -0,0 +1,80 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package catalyst + +import ( + "errors" + + "github.com/ethereum/go-ethereum/beacon/engine" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/miner" + "github.com/ethereum/go-ethereum/rpc" +) + +// testingAPI implements the testing_ namespace. +// It's an engine-API adjacent namespace for testing purposes. +type testingAPI struct { + eth *eth.Ethereum +} + +func newTestingAPI(backend *eth.Ethereum) rpc.API { + return rpc.API{ + Namespace: "testing", + Service: &testingAPI{backend}, + Version: "1.0", + Authenticated: false, + } +} + +func (api *testingAPI) BuildBlockV1(parentHash common.Hash, payloadAttributes engine.PayloadAttributes, transactions *[]hexutil.Bytes, extraData *hexutil.Bytes) (*engine.ExecutionPayloadEnvelope, error) { + if api.eth.BlockChain().CurrentBlock().Hash() != parentHash { + return nil, errors.New("parentHash is not current head") + } + // If transactions is empty but not nil, build an empty block + // If the transactions is nil, build a block with the current transactions from the txpool + // If the transactions is not nil and not empty, build a block with the transactions + buildEmpty := transactions != nil && len(*transactions) == 0 + var txs []*types.Transaction + if transactions != nil { + dec := make([][]byte, 0, len(*transactions)) + for _, tx := range *transactions { + dec = append(dec, tx) + } + var err error + txs, err = engine.DecodeTransactions(dec) + if err != nil { + return nil, err + } + } + extra := make([]byte, 0) + if extraData != nil { + extra = *extraData + } + args := &miner.BuildPayloadArgs{ + Parent: parentHash, + Timestamp: payloadAttributes.Timestamp, + FeeRecipient: payloadAttributes.SuggestedFeeRecipient, + Random: payloadAttributes.Random, + Withdrawals: payloadAttributes.Withdrawals, + BeaconRoot: payloadAttributes.BeaconRoot, + SlotNum: payloadAttributes.SlotNumber, + } + return api.eth.Miner().BuildTestingPayload(args, txs, buildEmpty, extra) +} diff --git a/eth/catalyst/api_testing_test.go b/eth/catalyst/api_testing_test.go new file mode 100644 index 000000000000..fd4d28d26aa5 --- /dev/null +++ b/eth/catalyst/api_testing_test.go @@ -0,0 +1,121 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package catalyst + +import ( + "context" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/beacon/engine" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/params" +) + +func TestBuildBlockV1(t *testing.T) { + genesis, blocks := generateMergeChain(5, true) + n, ethservice := startEthService(t, genesis, blocks) + defer n.Close() + + parent := ethservice.BlockChain().CurrentBlock() + attrs := engine.PayloadAttributes{ + Timestamp: parent.Time + 1, + Random: crypto.Keccak256Hash([]byte("test")), + SuggestedFeeRecipient: parent.Coinbase, + Withdrawals: nil, + BeaconRoot: nil, + } + + currentNonce, _ := ethservice.APIBackend.GetPoolNonce(context.Background(), testAddr) + tx, _ := types.SignTx(types.NewTransaction(currentNonce, testAddr, big.NewInt(1), params.TxGas, big.NewInt(params.InitialBaseFee*2), nil), types.LatestSigner(ethservice.BlockChain().Config()), testKey) + + api := &testingAPI{eth: ethservice} + + t.Run("buildOnCurrentHead", func(t *testing.T) { + envelope, err := api.BuildBlockV1(parent.Hash(), attrs, nil, nil) + if err != nil { + t.Fatalf("BuildBlockV1 failed: %v", err) + } + if envelope == nil || envelope.ExecutionPayload == nil { + t.Fatal("expected non-nil envelope and payload") + } + payload := envelope.ExecutionPayload + if payload.ParentHash != parent.Hash() { + t.Errorf("parent hash mismatch: got %x want %x", payload.ParentHash, parent.Hash()) + } + if payload.Number != parent.Number.Uint64()+1 { + t.Errorf("block number mismatch: got %d want %d", payload.Number, parent.Number.Uint64()+1) + } + if payload.Timestamp != attrs.Timestamp { + t.Errorf("timestamp mismatch: got %d want %d", payload.Timestamp, attrs.Timestamp) + } + if payload.FeeRecipient != attrs.SuggestedFeeRecipient { + t.Errorf("fee recipient mismatch: got %x want %x", payload.FeeRecipient, attrs.SuggestedFeeRecipient) + } + }) + + t.Run("wrongParentHash", func(t *testing.T) { + wrongParent := common.Hash{0x01} + _, err := api.BuildBlockV1(wrongParent, attrs, nil, nil) + if err == nil { + t.Fatal("expected error when parentHash is not current head") + } + if err.Error() != "parentHash is not current head" { + t.Errorf("unexpected error: %v", err) + } + }) + + t.Run("buildEmptyBlock", func(t *testing.T) { + emptyTxs := []hexutil.Bytes{} + envelope, err := api.BuildBlockV1(parent.Hash(), attrs, &emptyTxs, nil) + if err != nil { + t.Fatalf("BuildBlockV1 with empty txs failed: %v", err) + } + if envelope == nil || envelope.ExecutionPayload == nil { + t.Fatal("expected non-nil envelope and payload") + } + if len(envelope.ExecutionPayload.Transactions) != 0 { + t.Errorf("expected empty block, got %d transactions", len(envelope.ExecutionPayload.Transactions)) + } + }) + + t.Run("buildBlockWithTransactions", func(t *testing.T) { + enc, _ := tx.MarshalBinary() + txs := []hexutil.Bytes{enc} + envelope, err := api.BuildBlockV1(parent.Hash(), attrs, &txs, nil) + if err != nil { + t.Fatalf("BuildBlockV1 with transaction failed: %v", err) + } + if len(envelope.ExecutionPayload.Transactions) != 1 { + t.Errorf("expected 1 transaction, got %d", len(envelope.ExecutionPayload.Transactions)) + } + }) + + t.Run("buildBlockWithTransactionsFromTxPool", func(t *testing.T) { + ethservice.TxPool().Add([]*types.Transaction{tx}, true) + envelope, err := api.BuildBlockV1(parent.Hash(), attrs, nil, nil) + if err != nil { + t.Fatalf("BuildBlockV1 with transaction failed: %v", err) + } + if len(envelope.ExecutionPayload.Transactions) != 1 { + t.Errorf("expected 1 transaction, got %d", len(envelope.ExecutionPayload.Transactions)) + } + }) +} diff --git a/eth/catalyst/metrics.go b/eth/catalyst/metrics.go new file mode 100644 index 000000000000..01a24191b0c6 --- /dev/null +++ b/eth/catalyst/metrics.go @@ -0,0 +1,37 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package catalyst + +import "github.com/ethereum/go-ethereum/metrics" + +var ( + // Number of blobs requested via getBlobsV2 + getBlobsRequestedCounter = metrics.NewRegisteredCounter("engine/getblobs/requested", nil) + + // Number of blobs requested via getBlobsV2 that are present in the blobpool + getBlobsAvailableCounter = metrics.NewRegisteredCounter("engine/getblobs/available", nil) + + // Number of times getBlobsV2/V3 responded with all blobs + getBlobsRequestCompleteHit = metrics.NewRegisteredCounter("engine/getblobs/hit", nil) + + // Number of times getBlobsV2/V3 responded with no blobs. V2 will return no + // blobs if it doesn't have all the blobs (all or nothing). + getBlobsRequestMiss = metrics.NewRegisteredCounter("engine/getblobs/miss", nil) + + // Number of times getBlobsV3 responded with some, but not all, blobs + getBlobsRequestPartialHit = metrics.NewRegisteredCounter("engine/getblobs/partial", nil) +) diff --git a/eth/catalyst/simulated_beacon.go b/eth/catalyst/simulated_beacon.go index 92f9798e717f..8a77cd8abe67 100644 --- a/eth/catalyst/simulated_beacon.go +++ b/eth/catalyst/simulated_beacon.go @@ -17,6 +17,7 @@ package catalyst import ( + "context" "crypto/rand" "crypto/sha256" "errors" @@ -32,11 +33,13 @@ import ( "github.com/ethereum/go-ethereum/crypto/kzg4844" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params/forks" "github.com/ethereum/go-ethereum/rpc" + "go.opentelemetry.io/otel" ) const devEpochLength = 32 @@ -100,6 +103,8 @@ type SimulatedBeacon struct { func payloadVersion(config *params.ChainConfig, time uint64) engine.PayloadVersion { switch config.LatestFork(time) { + case forks.Amsterdam: + return engine.PayloadV4 case forks.BPO5, forks.BPO4, forks.BPO3, forks.BPO2, forks.BPO1, forks.Osaka, forks.Prague, forks.Cancun: return engine.PayloadV3 case forks.Paris, forks.Shanghai: @@ -121,7 +126,7 @@ func NewSimulatedBeacon(period uint64, feeRecipient common.Address, eth *eth.Eth // if genesis block, send forkchoiceUpdated to trigger transition to PoS if block.Number.Sign() == 0 { version := payloadVersion(eth.BlockChain().Config(), block.Time) - if _, err := engineAPI.forkchoiceUpdated(current, nil, version, false); err != nil { + if _, err := engineAPI.forkchoiceUpdated(context.Background(), current, nil, version, false); err != nil { return nil, err } } @@ -191,16 +196,32 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u } version := payloadVersion(c.eth.BlockChain().Config(), timestamp) + tracer := otel.Tracer("") var random [32]byte rand.Read(random[:]) - fcResponse, err := c.engineAPI.forkchoiceUpdated(c.curForkchoiceState, &engine.PayloadAttributes{ + + attribute := &engine.PayloadAttributes{ Timestamp: timestamp, SuggestedFeeRecipient: feeRecipient, Withdrawals: withdrawals, Random: random, BeaconRoot: &common.Hash{}, - }, version, false) + } + if c.eth.BlockChain().Config().LatestFork(timestamp) == forks.Amsterdam { + slotNumber := uint64(0) + attribute.SlotNumber = &slotNumber + } + + // Create a server span for forkchoiceUpdated with payload attributes, + // simulating an incoming engine API request from a real consensus client. + fcCtx, fcSpanEnd := telemetry.StartServerSpan(context.Background(), tracer, telemetry.RPCInfo{ + System: "jsonrpc", + Service: "engine", + Method: "forkchoiceUpdatedV" + fmt.Sprintf("%d", version), + }) + fcResponse, err := c.engineAPI.forkchoiceUpdated(fcCtx, c.curForkchoiceState, attribute, version, false) + fcSpanEnd(&err) if err != nil { return err } @@ -214,7 +235,15 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u return nil } + // Create a server span for getPayload, simulating the consensus client + // coming back to retrieve the built payload. + _, gpSpanEnd := telemetry.StartServerSpan(context.Background(), tracer, telemetry.RPCInfo{ + System: "jsonrpc", + Service: "engine", + Method: "getPayloadV" + fmt.Sprintf("%d", version), + }) envelope, err := c.engineAPI.getPayload(*fcResponse.PayloadID, true, nil, nil) + gpSpanEnd(&err) if err != nil { return err } @@ -255,15 +284,32 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u requests = envelope.Requests } + // Create a server span for newPayload, simulating the consensus client + // sending the execution payload for validation. + npCtx, npSpanEnd := telemetry.StartServerSpan(context.Background(), tracer, telemetry.RPCInfo{ + System: "jsonrpc", + Service: "engine", + Method: "newPayloadV" + fmt.Sprintf("%d", version), + }) + // Mark the payload as canon - _, err = c.engineAPI.newPayload(*payload, blobHashes, beaconRoot, requests, false) + _, err = c.engineAPI.newPayload(npCtx, *payload, blobHashes, beaconRoot, requests, false) + npSpanEnd(&err) if err != nil { return err } c.setCurrentState(payload.BlockHash, finalizedHash) - // Mark the block containing the payload as canonical - if _, err = c.engineAPI.forkchoiceUpdated(c.curForkchoiceState, nil, version, false); err != nil { + // Create a server span for the final forkchoiceUpdated (no payload attributes), + // which sets the new block as the canonical chain head. + fcuCtx, fcuSpanEnd := telemetry.StartServerSpan(context.Background(), tracer, telemetry.RPCInfo{ + System: "jsonrpc", + Service: "engine", + Method: "forkchoiceUpdatedV" + fmt.Sprintf("%d", version), + }) + _, err = c.engineAPI.forkchoiceUpdated(fcuCtx, c.curForkchoiceState, nil, version, false) + fcuSpanEnd(&err) + if err != nil { return err } c.lastBlockTime = payload.Timestamp @@ -329,7 +375,7 @@ func (c *SimulatedBeacon) Rollback() { func (c *SimulatedBeacon) Fork(parentHash common.Hash) error { // Ensure no pending transactions. c.eth.TxPool().Sync() - if len(c.eth.TxPool().Pending(txpool.PendingFilter{})) != 0 { + if pending, _ := c.eth.TxPool().Pending(txpool.PendingFilter{}); len(pending) != 0 { return errors.New("pending block dirty") } @@ -343,7 +389,7 @@ func (c *SimulatedBeacon) Fork(parentHash common.Hash) error { // AdjustTime creates a new block with an adjusted timestamp. func (c *SimulatedBeacon) AdjustTime(adjustment time.Duration) error { - if len(c.eth.TxPool().Pending(txpool.PendingFilter{})) != 0 { + if pending, _ := c.eth.TxPool().Pending(txpool.PendingFilter{}); len(pending) != 0 { return errors.New("could not adjust time on non-empty block") } parent := c.eth.BlockChain().CurrentBlock() @@ -364,5 +410,6 @@ func RegisterSimulatedBeaconAPIs(stack *node.Node, sim *SimulatedBeacon) { Service: api, Version: "1.0", }, + newTestingAPI(sim.eth), }) } diff --git a/eth/catalyst/witness.go b/eth/catalyst/witness.go index 0df612a69550..fe75c6690875 100644 --- a/eth/catalyst/witness.go +++ b/eth/catalyst/witness.go @@ -17,6 +17,7 @@ package catalyst import ( + "context" "errors" "strconv" "time" @@ -34,7 +35,7 @@ import ( // ForkchoiceUpdatedWithWitnessV1 is analogous to ForkchoiceUpdatedV1, only it // generates an execution witness too if block building was requested. -func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV1(update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { +func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV1(ctx context.Context, update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { if payloadAttributes != nil { switch { case payloadAttributes.Withdrawals != nil || payloadAttributes.BeaconRoot != nil: @@ -43,12 +44,12 @@ func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV1(update engine.Forkchoice return engine.STATUS_INVALID, paramsErr("fcuV1 called post-shanghai") } } - return api.forkchoiceUpdated(update, payloadAttributes, engine.PayloadV1, true) + return api.forkchoiceUpdated(ctx, update, payloadAttributes, engine.PayloadV1, true) } // ForkchoiceUpdatedWithWitnessV2 is analogous to ForkchoiceUpdatedV2, only it // generates an execution witness too if block building was requested. -func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV2(update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { +func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV2(ctx context.Context, update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { if params != nil { switch { case params.BeaconRoot != nil: @@ -61,12 +62,12 @@ func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV2(update engine.Forkchoice return engine.STATUS_INVALID, unsupportedForkErr("fcuV2 must only be called with paris or shanghai payloads") } } - return api.forkchoiceUpdated(update, params, engine.PayloadV2, true) + return api.forkchoiceUpdated(ctx, update, params, engine.PayloadV2, true) } // ForkchoiceUpdatedWithWitnessV3 is analogous to ForkchoiceUpdatedV3, only it // generates an execution witness too if block building was requested. -func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV3(update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { +func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV3(ctx context.Context, update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) { if params != nil { switch { case params.Withdrawals == nil: @@ -81,21 +82,21 @@ func (api *ConsensusAPI) ForkchoiceUpdatedWithWitnessV3(update engine.Forkchoice // hash, even if params are wrong. To do this we need to split up // forkchoiceUpdate into a function that only updates the head and then a // function that kicks off block construction. - return api.forkchoiceUpdated(update, params, engine.PayloadV3, true) + return api.forkchoiceUpdated(ctx, update, params, engine.PayloadV3, true) } // NewPayloadWithWitnessV1 is analogous to NewPayloadV1, only it also generates // and returns a stateless witness after running the payload. -func (api *ConsensusAPI) NewPayloadWithWitnessV1(params engine.ExecutableData) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadWithWitnessV1(ctx context.Context, params engine.ExecutableData) (engine.PayloadStatusV1, error) { if params.Withdrawals != nil { return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(errors.New("withdrawals not supported in V1")) } - return api.newPayload(params, nil, nil, nil, true) + return api.newPayload(ctx, params, nil, nil, nil, true) } // NewPayloadWithWitnessV2 is analogous to NewPayloadV2, only it also generates // and returns a stateless witness after running the payload. -func (api *ConsensusAPI) NewPayloadWithWitnessV2(params engine.ExecutableData) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadWithWitnessV2(ctx context.Context, params engine.ExecutableData) (engine.PayloadStatusV1, error) { var ( cancun = api.config().IsCancun(api.config().LondonBlock, params.Timestamp) shanghai = api.config().IsShanghai(api.config().LondonBlock, params.Timestamp) @@ -112,12 +113,12 @@ func (api *ConsensusAPI) NewPayloadWithWitnessV2(params engine.ExecutableData) ( case params.BlobGasUsed != nil: return invalidStatus, paramsErr("non-nil blobGasUsed pre-cancun") } - return api.newPayload(params, nil, nil, nil, true) + return api.newPayload(ctx, params, nil, nil, nil, true) } // NewPayloadWithWitnessV3 is analogous to NewPayloadV3, only it also generates // and returns a stateless witness after running the payload. -func (api *ConsensusAPI) NewPayloadWithWitnessV3(params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadWithWitnessV3(ctx context.Context, params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (engine.PayloadStatusV1, error) { switch { case params.Withdrawals == nil: return invalidStatus, paramsErr("nil withdrawals post-shanghai") @@ -132,12 +133,12 @@ func (api *ConsensusAPI) NewPayloadWithWitnessV3(params engine.ExecutableData, v case !api.checkFork(params.Timestamp, forks.Cancun): return invalidStatus, unsupportedForkErr("newPayloadV3 must only be called for cancun payloads") } - return api.newPayload(params, versionedHashes, beaconRoot, nil, true) + return api.newPayload(ctx, params, versionedHashes, beaconRoot, nil, true) } // NewPayloadWithWitnessV4 is analogous to NewPayloadV4, only it also generates // and returns a stateless witness after running the payload. -func (api *ConsensusAPI) NewPayloadWithWitnessV4(params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, executionRequests []hexutil.Bytes) (engine.PayloadStatusV1, error) { +func (api *ConsensusAPI) NewPayloadWithWitnessV4(ctx context.Context, params engine.ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, executionRequests []hexutil.Bytes) (engine.PayloadStatusV1, error) { switch { case params.Withdrawals == nil: return invalidStatus, paramsErr("nil withdrawals post-shanghai") @@ -158,7 +159,7 @@ func (api *ConsensusAPI) NewPayloadWithWitnessV4(params engine.ExecutableData, v if err := validateRequests(requests); err != nil { return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(err) } - return api.newPayload(params, versionedHashes, beaconRoot, requests, true) + return api.newPayload(ctx, params, versionedHashes, beaconRoot, requests, true) } // ExecuteStatelessPayloadV1 is analogous to NewPayloadV1, only it operates in @@ -283,7 +284,7 @@ func (api *ConsensusAPI) executeStatelessPayload(params engine.ExecutableData, v api.lastNewPayloadUpdate.Store(time.Now().Unix()) log.Trace("Executing block statelessly", "number", block.Number(), "hash", params.BlockHash) - stateRoot, receiptRoot, err := core.ExecuteStateless(api.config(), vm.Config{}, block, witness) + stateRoot, receiptRoot, err := core.ExecuteStateless(context.Background(), api.config(), vm.Config{}, block, witness) if err != nil { log.Warn("ExecuteStatelessPayload: execution failed", "err", err) errorMsg := err.Error() diff --git a/eth/downloader/api.go b/eth/downloader/api.go index f97371de5f21..6033e4447400 100644 --- a/eth/downloader/api.go +++ b/eth/downloader/api.go @@ -23,7 +23,6 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/rpc" ) @@ -33,20 +32,18 @@ import ( type DownloaderAPI struct { d *Downloader chain *core.BlockChain - mux *event.TypeMux installSyncSubscription chan chan interface{} uninstallSyncSubscription chan *uninstallSyncSubscriptionRequest } // NewDownloaderAPI creates a new DownloaderAPI. The API has an internal event loop that -// listens for events from the downloader through the global event mux. In case it receives one of +// listens for events from the downloader through the event feed. In case it receives one of // these events it broadcasts it to all syncing subscriptions that are installed through the // installSyncSubscription channel. -func NewDownloaderAPI(d *Downloader, chain *core.BlockChain, m *event.TypeMux) *DownloaderAPI { +func NewDownloaderAPI(d *Downloader, chain *core.BlockChain) *DownloaderAPI { api := &DownloaderAPI{ d: d, chain: chain, - mux: m, installSyncSubscription: make(chan chan interface{}), uninstallSyncSubscription: make(chan *uninstallSyncSubscriptionRequest), } @@ -66,7 +63,8 @@ func NewDownloaderAPI(d *Downloader, chain *core.BlockChain, m *event.TypeMux) * // receive is {false}. func (api *DownloaderAPI) eventLoop() { var ( - sub = api.mux.Subscribe(StartEvent{}) + events = make(chan SyncEvent, 16) + sub = api.d.SubscribeSyncEvents(events) syncSubscriptions = make(map[chan interface{}]struct{}) checkInterval = time.Second * 60 checkTimer = time.NewTimer(checkInterval) @@ -81,14 +79,16 @@ func (api *DownloaderAPI) eventLoop() { prog.TxIndexFinishedBlocks = txProg.Indexed prog.TxIndexRemainingBlocks = txProg.Remaining } - remain, err := api.chain.StateIndexProgress() + stateRemain, trienodeRemain, err := api.chain.StateIndexProgress() if err == nil { - prog.StateIndexRemaining = remain + prog.StateIndexRemaining = stateRemain + prog.TrienodeIndexRemaining = trienodeRemain } return prog } ) defer checkTimer.Stop() + defer sub.Unsubscribe() for { select { @@ -100,14 +100,13 @@ func (api *DownloaderAPI) eventLoop() { case u := <-api.uninstallSyncSubscription: delete(syncSubscriptions, u.c) close(u.uninstalled) - case event := <-sub.Chan(): - if event == nil { - return - } - switch event.Data.(type) { - case StartEvent: + case ev := <-events: + if ev.Type == SyncStarted { started = true } + case <-sub.Err(): + // The downloader is terminated or other internal error occurs + return case <-checkTimer.C: if !started { checkTimer.Reset(checkInterval) diff --git a/eth/downloader/beaconsync.go b/eth/downloader/beaconsync.go index 405643e576f5..914e1dfada71 100644 --- a/eth/downloader/beaconsync.go +++ b/eth/downloader/beaconsync.go @@ -36,7 +36,6 @@ type beaconBackfiller struct { downloader *Downloader // Downloader to direct via this callback implementation success func() // Callback to run on successful sync cycle completion filling bool // Flag whether the downloader is backfilling or not - filled *types.Header // Last header filled by the last terminated sync loop started chan struct{} // Notification channel whether the downloader inited lock sync.Mutex // Mutex protecting the sync lock } @@ -56,12 +55,15 @@ func (b *beaconBackfiller) suspend() *types.Header { // If no filling is running, don't waste cycles b.lock.Lock() filling := b.filling - filled := b.filled started := b.started b.lock.Unlock() if !filling { - return filled // Return the filled header on the previous sync completion + // Sync cycle was inactive, retrieve and return the latest snap block + // as the filled header. + log.Debug("Backfiller was inactive") + + return b.downloader.blockchain.CurrentSnapBlock() } // A previous filling should be running, though it may happen that it hasn't // yet started (being done on a new goroutine). Many concurrent beacon head @@ -73,9 +75,9 @@ func (b *beaconBackfiller) suspend() *types.Header { // Now that we're sure the downloader successfully started up, we can cancel // it safely without running the risk of data races. b.downloader.Cancel() + log.Debug("Backfiller has been suspended") // Sync cycle was just terminated, retrieve and return the last filled header. - // Can't use `filled` as that contains a stale value from before cancellation. return b.downloader.blockchain.CurrentSnapBlock() } @@ -86,10 +88,10 @@ func (b *beaconBackfiller) resume() { // If a previous filling cycle is still running, just ignore this start // request. // TODO(karalabe): We should make this channel driven b.lock.Unlock() + log.Debug("Backfiller is running") return } b.filling = true - b.filled = nil b.started = make(chan struct{}) b.lock.Unlock() @@ -100,7 +102,6 @@ func (b *beaconBackfiller) resume() { defer func() { b.lock.Lock() b.filling = false - b.filled = b.downloader.blockchain.CurrentSnapBlock() b.lock.Unlock() }() // If the downloader fails, report an error as in beacon chain mode there @@ -110,11 +111,13 @@ func (b *beaconBackfiller) resume() { return } // Synchronization succeeded. Since this happens async, notify the outer - // context to disable snap syncing and enable transaction propagation. + // context to enable transaction propagation. if b.success != nil { b.success() } + log.Debug("Backfilling completed") }() + log.Debug("Backfilling started") } // SetBadBlockCallback sets the callback to run when a bad block is hit by the @@ -183,6 +186,8 @@ func (d *Downloader) findBeaconAncestor() (uint64, error) { log.Error("Failed to retrieve beacon bounds", "err", err) return 0, err } + log.Debug("Searching beacon ancestor", "local", number, "beaconhead", beaconHead.Number, "beacontail", beaconTail.Number) + var linked bool switch d.getMode() { case ethconfig.FullSync: @@ -236,6 +241,7 @@ func (d *Downloader) findBeaconAncestor() (uint64, error) { } start = check } + log.Debug("Found beacon ancestor", "number", start) return start, nil } diff --git a/eth/downloader/downloader.go b/eth/downloader/downloader.go index 020dd7314bec..4a575d6856b5 100644 --- a/eth/downloader/downloader.go +++ b/eth/downloader/downloader.go @@ -97,9 +97,12 @@ type headerTask struct { } type Downloader struct { - mode atomic.Uint32 // Synchronisation mode defining the strategy used (per sync cycle), use d.getMode() to get the SyncMode - moder *syncModer // Sync mode management, deliver the appropriate sync mode choice for each cycle - mux *event.TypeMux // Event multiplexer to announce sync operation events + mode atomic.Uint32 // Synchronisation mode defining the strategy used (per sync cycle), use d.getMode() to get the SyncMode + moder *syncModer // Sync mode management, deliver the appropriate sync mode choice for each cycle + + // Event feed for downloader events + feed event.FeedOf[SyncEvent] + scope event.SubscriptionScope queue *queue // Scheduler for selecting the hashes to download peers *peerSet // Set of active peers from which download can proceed @@ -193,8 +196,12 @@ type BlockChain interface { // CurrentSnapBlock retrieves the head snap block from the local chain. CurrentSnapBlock() *types.Header - // SnapSyncCommitHead directly commits the head block to a certain entity. - SnapSyncCommitHead(common.Hash) error + // SnapSyncStart explicitly notifies the chain that snap sync is scheduled and + // marks chain mutations as disallowed. + SnapSyncStart() error + + // SnapSyncComplete directly commits the head block to a certain entity. + SnapSyncComplete(common.Hash) error // InsertHeadersBeforeCutoff inserts a batch of headers before the configured // chain cutoff into the ancient store. @@ -225,12 +232,11 @@ type BlockChain interface { } // New creates a new downloader to fetch hashes and blocks from remote peers. -func New(stateDb ethdb.Database, mode ethconfig.SyncMode, mux *event.TypeMux, chain BlockChain, dropPeer peerDropFn, success func()) *Downloader { +func New(stateDb ethdb.Database, mode ethconfig.SyncMode, chain BlockChain, dropPeer peerDropFn, success func()) *Downloader { cutoffNumber, cutoffHash := chain.HistoryPruningCutoff() dl := &Downloader{ stateDB: stateDb, moder: newSyncModer(mode, chain, stateDb), - mux: mux, queue: newQueue(blockCacheMaxItems, blockCacheInitialItems), peers: newPeerSet(), blockchain: chain, @@ -244,7 +250,7 @@ func New(stateDb ethdb.Database, mode ethconfig.SyncMode, mux *event.TypeMux, ch syncStartBlock: chain.CurrentSnapBlock().Number.Uint64(), } // Create the post-merge skeleton syncer and start the process - dl.skeleton = newSkeleton(stateDb, dl.peers, dropPeer, newBeaconBackfiller(dl, success)) + dl.skeleton = newSkeleton(stateDb, dl.peers, dropPeer, newBeaconBackfiller(dl, success), chain) go dl.stateFetcher() return dl @@ -361,28 +367,21 @@ func (d *Downloader) synchronise(beaconPing chan struct{}) (err error) { if d.notified.CompareAndSwap(false, true) { log.Info("Block synchronisation started") } - mode := d.moder.get() + + // Obtain the synchronized used in this cycle + mode := d.moder.get(true) defer func() { if err == nil && mode == ethconfig.SnapSync { d.moder.disableSnap() log.Info("Disabled snap-sync after the initial sync cycle") } }() + + // Disable chain mutations when snap sync is selected, ensuring the + // downloader is the sole mutator. if mode == ethconfig.SnapSync { - // Snap sync will directly modify the persistent state, making the entire - // trie database unusable until the state is fully synced. To prevent any - // subsequent state reads, explicitly disable the trie database and state - // syncer is responsible to address and correct any state missing. - if d.blockchain.TrieDB().Scheme() == rawdb.PathScheme { - if err := d.blockchain.TrieDB().Disable(); err != nil { - return err - } - } - // Snap sync uses the snapshot namespace to store potentially flaky data until - // sync completely heals and finishes. Pause snapshot maintenance in the mean- - // time to prevent access. - if snapshots := d.blockchain.Snapshots(); snapshots != nil { // Only nil in tests - snapshots.Disable() + if err := d.blockchain.SnapSyncStart(); err != nil { + return err } } // Reset the queue, peer set and wake channels to clean any internal leftover state @@ -427,23 +426,28 @@ func (d *Downloader) getMode() SyncMode { // ConfigSyncMode returns the sync mode configured for the node. // The actual running sync mode can differ from this. func (d *Downloader) ConfigSyncMode() SyncMode { - return d.moder.get() + return d.moder.get(false) +} + +// SubscribeSyncEvents creates a subscription for downloader sync events +func (d *Downloader) SubscribeSyncEvents(ch chan<- SyncEvent) event.Subscription { + return d.scope.Track(d.feed.Subscribe(ch)) } // syncToHead starts a block synchronization based on the hash chain from // the specified head hash. func (d *Downloader) syncToHead() (err error) { - d.mux.Post(StartEvent{}) + mode := d.getMode() + d.feed.Send(SyncEvent{Type: SyncStarted, Mode: mode}) defer func() { // reset on error if err != nil { - d.mux.Post(FailedEvent{err}) + d.feed.Send(SyncEvent{Type: SyncFailed, Mode: mode, Err: err}) } else { latest := d.blockchain.CurrentHeader() - d.mux.Post(DoneEvent{latest}) + d.feed.Send(SyncEvent{Type: SyncCompleted, Mode: mode, Latest: latest}) } }() - mode := d.getMode() log.Debug("Backfilling with the network", "mode", mode) defer func(start time.Time) { @@ -665,6 +669,9 @@ func (d *Downloader) Cancel() { // Terminate interrupts the downloader, canceling all pending operations. // The downloader cannot be reused after calling Terminate. func (d *Downloader) Terminate() { + // Unsubscribe all subscriptions registered from downloader + d.scope.Close() + // Close the termination channel (make sure double close is allowed) d.quitLock.Lock() select { @@ -962,29 +969,6 @@ func (d *Downloader) processSnapSyncContent() error { } else { // results already piled up, consume before handling pivot move results = append(append([]*fetchResult{oldPivot}, oldTail...), results...) } - // Split around the pivot block and process the two sides via snap/full sync - if !d.committed.Load() { - latest := results[len(results)-1].Header - // If the height is above the pivot block by 2 sets, it means the pivot - // became stale in the network, and it was garbage collected, move to a - // new pivot. - // - // Note, we have `reorgProtHeaderDelay` number of blocks withheld, Those - // need to be taken into account, otherwise we're detecting the pivot move - // late and will drop peers due to unavailable state!!! - if height := latest.Number.Uint64(); height >= pivot.Number.Uint64()+2*uint64(fsMinFullBlocks)-uint64(reorgProtHeaderDelay) { - log.Warn("Pivot became stale, moving", "old", pivot.Number.Uint64(), "new", height-uint64(fsMinFullBlocks)+uint64(reorgProtHeaderDelay)) - pivot = results[len(results)-1-fsMinFullBlocks+reorgProtHeaderDelay].Header // must exist as lower old pivot is uncommitted - - d.pivotLock.Lock() - d.pivotHeader = pivot - d.pivotLock.Unlock() - - // Write out the pivot into the database so a rollback beyond it will - // reenable snap sync - rawdb.WriteLastPivotNumber(d.stateDB, pivot.Number.Uint64()) - } - } P, beforeP, afterP := splitAroundPivot(pivot.Number.Uint64(), results) if err := d.commitSnapSyncData(beforeP, sync); err != nil { return err @@ -1086,7 +1070,7 @@ func (d *Downloader) commitPivotBlock(result *fetchResult) error { if _, err := d.blockchain.InsertReceiptChain([]*types.Block{block}, []rlp.RawValue{result.Receipts}, d.ancientLimit); err != nil { return err } - if err := d.blockchain.SnapSyncCommitHead(block.Hash()); err != nil { + if err := d.blockchain.SnapSyncComplete(block.Hash()); err != nil { return err } d.committed.Store(true) diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go index 7fa2522a3d43..e6c477cd3304 100644 --- a/eth/downloader/downloader_test.go +++ b/eth/downloader/downloader_test.go @@ -17,7 +17,6 @@ package downloader import ( - "fmt" "math/big" "sync" "sync/atomic" @@ -33,7 +32,6 @@ import ( "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/eth/protocols/eth" "github.com/ethereum/go-ethereum/eth/protocols/snap" - "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" @@ -76,7 +74,7 @@ func newTesterWithNotification(t *testing.T, mode ethconfig.SyncMode, success fu chain: chain, peers: make(map[string]*downloadTesterPeer), } - tester.downloader = New(db, mode, new(event.TypeMux), tester.chain, tester.dropPeer, success) + tester.downloader = New(db, mode, tester.chain, tester.dropPeer, success) return tester } @@ -97,6 +95,7 @@ func (dl *downloadTester) newPeer(id string, version uint, blocks []*types.Block id: id, chain: newTestBlockchain(blocks), withholdBodies: make(map[common.Hash]struct{}), + dropped: make(chan error, 1), } dl.peers[id] = peer @@ -122,8 +121,11 @@ func (dl *downloadTester) dropPeer(id string) { type downloadTesterPeer struct { dl *downloadTester withholdBodies map[common.Hash]struct{} + corruptBodies bool // if set, the peer serves incorrect blocks id string chain *core.BlockChain + + dropped chan error // signaled when res.Done receives an error } func unmarshalRlpHeaders(rlpdata []rlp.RawValue) []*types.Header { @@ -214,10 +216,12 @@ func (dlp *downloadTesterPeer) RequestHeadersByNumber(origin uint64, amount int, func (dlp *downloadTesterPeer) RequestBodies(hashes []common.Hash, sink chan *eth.Response) (*eth.Request, error) { blobs := eth.ServiceGetBlockBodiesQuery(dlp.chain, hashes) - bodies := make([]*eth.BlockBody, len(blobs)) + bodies := make([]*types.Body, len(blobs)) + ethbodies := make([]eth.BlockBody, len(blobs)) for i, blob := range blobs { - bodies[i] = new(eth.BlockBody) + bodies[i] = new(types.Body) rlp.DecodeBytes(blob, bodies[i]) + rlp.DecodeBytes(blob, ðbodies[i]) } var ( txsHashes = make([]common.Hash, len(bodies)) @@ -235,18 +239,33 @@ func (dlp *downloadTesterPeer) RequestBodies(hashes []common.Hash, sink chan *et txsHashes[i] = hash uncleHashes[i] = types.CalcUncleHash(body.Uncles) } + if dlp.corruptBodies { + for i := range txsHashes { + txsHashes[i] = common.Hash{0xff} + } + } req := ð.Request{ Peer: dlp.id, } res := ð.Response{ - Req: req, - Res: (*eth.BlockBodiesResponse)(&bodies), - Meta: [][]common.Hash{txsHashes, uncleHashes, withdrawalHashes}, + Req: req, + Res: (*eth.BlockBodiesResponse)(ðbodies), + Meta: eth.BlockBodyHashes{ + TransactionRoots: txsHashes, + UncleHashes: uncleHashes, + WithdrawalRoots: withdrawalHashes, + }, Time: 1, - Done: make(chan error, 1), // Ignore the returned status + Done: make(chan error), } go func() { sink <- res + if err := <-res.Done; err != nil { + select { + case dlp.dropped <- err: + default: + } + } }() return req, nil } @@ -254,24 +273,25 @@ func (dlp *downloadTesterPeer) RequestBodies(hashes []common.Hash, sink chan *et // RequestReceipts constructs a getReceipts method associated with a particular // peer in the download tester. The returned function can be used to retrieve // batches of block receipts from the particularly requested peer. -func (dlp *downloadTesterPeer) RequestReceipts(hashes []common.Hash, sink chan *eth.Response) (*eth.Request, error) { - blobs := eth.ServiceGetReceiptsQuery68(dlp.chain, hashes) +func (dlp *downloadTesterPeer) RequestReceipts(hashes []common.Hash, gasUsed []uint64, timestamps []uint64, sink chan *eth.Response) (*eth.Request, error) { + blobs := eth.ServiceGetReceiptsQuery69(dlp.chain, hashes) + receipts := make([]types.Receipts, blobs.Len()) - receipts := make([]types.Receipts, len(blobs)) - for i, blob := range blobs { - rlp.DecodeBytes(blob, &receipts[i]) - } + // compute hashes + hashes = make([]common.Hash, blobs.Len()) hasher := trie.NewStackTrie(nil) - hashes = make([]common.Hash, len(receipts)) - for i, receipt := range receipts { - hashes[i] = types.DeriveSha(receipt, hasher) + receiptLists, err := blobs.Items() + if err != nil { + panic(err) } - req := ð.Request{ - Peer: dlp.id, + for i, rl := range receiptLists { + hashes[i] = types.DeriveSha(rl.Derivable(), hasher) } + + // deliver the response right away resp := eth.ReceiptsRLPResponse(types.EncodeBlockReceiptLists(receipts)) res := ð.Response{ - Req: req, + Req: ð.Request{Peer: dlp.id}, Res: &resp, Meta: hashes, Time: 1, @@ -280,7 +300,7 @@ func (dlp *downloadTesterPeer) RequestReceipts(hashes []common.Hash, sink chan * go func() { sink <- res }() - return req, nil + return res.Req, nil } // ID retrieves the peer's unique identifier. @@ -290,14 +310,14 @@ func (dlp *downloadTesterPeer) ID() string { // RequestAccountRange fetches a batch of accounts rooted in a specific account // trie, starting with the origin. -func (dlp *downloadTesterPeer) RequestAccountRange(id uint64, root, origin, limit common.Hash, bytes uint64) error { +func (dlp *downloadTesterPeer) RequestAccountRange(id uint64, root, origin, limit common.Hash, bytes int) error { // Create the request and service it req := &snap.GetAccountRangePacket{ ID: id, Root: root, Origin: origin, Limit: limit, - Bytes: bytes, + Bytes: uint64(bytes), } slimaccs, proofs := snap.ServiceGetAccountRangeQuery(dlp.chain, req) @@ -316,7 +336,7 @@ func (dlp *downloadTesterPeer) RequestAccountRange(id uint64, root, origin, limi // RequestStorageRanges fetches a batch of storage slots belonging to one or // more accounts. If slots from only one account is requested, an origin marker // may also be used to retrieve from there. -func (dlp *downloadTesterPeer) RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes uint64) error { +func (dlp *downloadTesterPeer) RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes int) error { // Create the request and service it req := &snap.GetStorageRangesPacket{ ID: id, @@ -324,7 +344,7 @@ func (dlp *downloadTesterPeer) RequestStorageRanges(id uint64, root common.Hash, Root: root, Origin: origin, Limit: limit, - Bytes: bytes, + Bytes: uint64(bytes), } storage, proofs := snap.ServiceGetStorageRangesQuery(dlp.chain, req) @@ -341,27 +361,30 @@ func (dlp *downloadTesterPeer) RequestStorageRanges(id uint64, root common.Hash, } // RequestByteCodes fetches a batch of bytecodes by hash. -func (dlp *downloadTesterPeer) RequestByteCodes(id uint64, hashes []common.Hash, bytes uint64) error { +func (dlp *downloadTesterPeer) RequestByteCodes(id uint64, hashes []common.Hash, bytes int) error { req := &snap.GetByteCodesPacket{ ID: id, Hashes: hashes, - Bytes: bytes, + Bytes: uint64(bytes), } codes := snap.ServiceGetByteCodesQuery(dlp.chain, req) go dlp.dl.downloader.SnapSyncer.OnByteCodes(dlp, id, codes) return nil } -// RequestTrieNodes fetches a batch of account or storage trie nodes rooted in -// a specific state trie. -func (dlp *downloadTesterPeer) RequestTrieNodes(id uint64, root common.Hash, paths []snap.TrieNodePathSet, bytes uint64) error { +// RequestTrieNodes fetches a batch of account or storage trie nodes. +func (dlp *downloadTesterPeer) RequestTrieNodes(id uint64, root common.Hash, count int, paths []snap.TrieNodePathSet, bytes int) error { + encPaths, err := rlp.EncodeToRawList(paths) + if err != nil { + panic(err) + } req := &snap.GetTrieNodesPacket{ ID: id, Root: root, - Paths: paths, - Bytes: bytes, + Paths: encPaths, + Bytes: uint64(bytes), } - nodes, _ := snap.ServiceGetTrieNodesQuery(dlp.chain, req, time.Now()) + nodes, _ := snap.ServiceGetTrieNodesQuery(dlp.chain, req) go dlp.dl.downloader.SnapSyncer.OnTrieNodes(dlp, id, nodes) return nil } @@ -389,8 +412,8 @@ func assertOwnChain(t *testing.T, tester *downloadTester, length int) { } } -func TestCanonicalSynchronisation68Full(t *testing.T) { testCanonSync(t, eth.ETH68, FullSync) } -func TestCanonicalSynchronisation68Snap(t *testing.T) { testCanonSync(t, eth.ETH68, SnapSync) } +func TestCanonicalSynchronisationFull(t *testing.T) { testCanonSync(t, eth.ETH69, FullSync) } +func TestCanonicalSynchronisationSnap(t *testing.T) { testCanonSync(t, eth.ETH69, SnapSync) } func testCanonSync(t *testing.T, protocol uint, mode SyncMode) { success := make(chan struct{}) @@ -417,8 +440,8 @@ func testCanonSync(t *testing.T, protocol uint, mode SyncMode) { // Tests that if a large batch of blocks are being downloaded, it is throttled // until the cached blocks are retrieved. -func TestThrottling68Full(t *testing.T) { testThrottling(t, eth.ETH68, FullSync) } -func TestThrottling68Snap(t *testing.T) { testThrottling(t, eth.ETH68, SnapSync) } +func TestThrottlingFull(t *testing.T) { testThrottling(t, eth.ETH69, FullSync) } +func TestThrottlingSnap(t *testing.T) { testThrottling(t, eth.ETH69, SnapSync) } func testThrottling(t *testing.T, protocol uint, mode SyncMode) { tester := newTester(t, mode) @@ -495,8 +518,8 @@ func testThrottling(t *testing.T, protocol uint, mode SyncMode) { } // Tests that a canceled download wipes all previously accumulated state. -func TestCancel68Full(t *testing.T) { testCancel(t, eth.ETH68, FullSync) } -func TestCancel68Snap(t *testing.T) { testCancel(t, eth.ETH68, SnapSync) } +func TestCancelFull(t *testing.T) { testCancel(t, eth.ETH69, FullSync) } +func TestCancelSnap(t *testing.T) { testCancel(t, eth.ETH69, SnapSync) } func testCancel(t *testing.T, protocol uint, mode SyncMode) { complete := make(chan struct{}) @@ -525,49 +548,10 @@ func testCancel(t *testing.T, protocol uint, mode SyncMode) { } } -// Tests that synchronisations behave well in multi-version protocol environments -// and not wreak havoc on other nodes in the network. -func TestMultiProtoSynchronisation68Full(t *testing.T) { testMultiProtoSync(t, eth.ETH68, FullSync) } -func TestMultiProtoSynchronisation68Snap(t *testing.T) { testMultiProtoSync(t, eth.ETH68, SnapSync) } - -func testMultiProtoSync(t *testing.T, protocol uint, mode SyncMode) { - complete := make(chan struct{}) - success := func() { - close(complete) - } - tester := newTesterWithNotification(t, mode, success) - defer tester.terminate() - - // Create a small enough block chain to download - chain := testChainBase.shorten(blockCacheMaxItems - 15) - - // Create peers of every type - tester.newPeer("peer 68", eth.ETH68, chain.blocks[1:]) - - if err := tester.downloader.BeaconSync(chain.blocks[len(chain.blocks)-1].Header(), nil); err != nil { - t.Fatalf("failed to start beacon sync: %v", err) - } - select { - case <-complete: - break - case <-time.NewTimer(time.Second * 3).C: - t.Fatalf("Failed to sync chain in three seconds") - } - assertOwnChain(t, tester, len(chain.blocks)) - - // Check that no peers have been dropped off - for _, version := range []int{68} { - peer := fmt.Sprintf("peer %d", version) - if _, ok := tester.peers[peer]; !ok { - t.Errorf("%s dropped", peer) - } - } -} - // Tests that if a block is empty (e.g. header only), no body request should be // made, and instead the header should be assembled into a whole block in itself. -func TestEmptyShortCircuit68Full(t *testing.T) { testEmptyShortCircuit(t, eth.ETH68, FullSync) } -func TestEmptyShortCircuit68Snap(t *testing.T) { testEmptyShortCircuit(t, eth.ETH68, SnapSync) } +func TestEmptyShortCircuitFull(t *testing.T) { testEmptyShortCircuit(t, eth.ETH69, FullSync) } +func TestEmptyShortCircuitSnap(t *testing.T) { testEmptyShortCircuit(t, eth.ETH69, SnapSync) } func testEmptyShortCircuit(t *testing.T, protocol uint, mode SyncMode) { success := make(chan struct{}) @@ -635,8 +619,8 @@ func checkProgress(t *testing.T, d *Downloader, stage string, want ethereum.Sync // Tests that peers below a pre-configured checkpoint block are prevented from // being fast-synced from, avoiding potential cheap eclipse attacks. -func TestBeaconSync68Full(t *testing.T) { testBeaconSync(t, eth.ETH68, FullSync) } -func TestBeaconSync68Snap(t *testing.T) { testBeaconSync(t, eth.ETH68, SnapSync) } +func TestBeaconSyncFull(t *testing.T) { testBeaconSync(t, eth.ETH69, FullSync) } +func TestBeaconSyncSnap(t *testing.T) { testBeaconSync(t, eth.ETH69, SnapSync) } func testBeaconSync(t *testing.T, protocol uint, mode SyncMode) { var cases = []struct { @@ -681,8 +665,8 @@ func testBeaconSync(t *testing.T, protocol uint, mode SyncMode) { // Tests that synchronisation progress (origin block number, current block number // and highest block number) is tracked and updated correctly. -func TestSyncProgress68Full(t *testing.T) { testSyncProgress(t, eth.ETH68, FullSync) } -func TestSyncProgress68Snap(t *testing.T) { testSyncProgress(t, eth.ETH68, SnapSync) } +func TestSyncProgressFull(t *testing.T) { testSyncProgress(t, eth.ETH69, FullSync) } +func TestSyncProgressSnap(t *testing.T) { testSyncProgress(t, eth.ETH69, SnapSync) } func testSyncProgress(t *testing.T, protocol uint, mode SyncMode) { success := make(chan struct{}) @@ -734,3 +718,21 @@ func testSyncProgress(t *testing.T, protocol uint, mode SyncMode) { t.Fatalf("Failed to sync chain in three seconds") } } + +func TestInvalidBodyPeerDrop(t *testing.T) { + tester := newTester(t, FullSync) + defer tester.terminate() + + chain := testChainBase.shorten(blockCacheMaxItems - 15) + peer := tester.newPeer("corrupt", eth.ETH69, chain.blocks[1:]) + peer.corruptBodies = true + + if err := tester.downloader.BeaconSync(chain.blocks[len(chain.blocks)-1].Header(), nil); err != nil { + t.Fatalf("failed to beacon-sync chain: %v", err) + } + select { + case <-peer.dropped: + case <-time.After(1 * time.Minute): + t.Fatal("peer was not dropped") + } +} diff --git a/eth/downloader/events.go b/eth/downloader/events.go index 25255a3a72e5..0fb380a85760 100644 --- a/eth/downloader/events.go +++ b/eth/downloader/events.go @@ -16,10 +16,24 @@ package downloader -import "github.com/ethereum/go-ethereum/core/types" +import ( + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth/ethconfig" +) -type DoneEvent struct { - Latest *types.Header +// SyncEventType represents the type of sync event +type SyncEventType int + +const ( + SyncStarted SyncEventType = iota + SyncFailed + SyncCompleted +) + +// SyncEvent represents a downloader synchronization event +type SyncEvent struct { + Type SyncEventType + Mode ethconfig.SyncMode + Err error // Set when Type is SyncFailed + Latest *types.Header // Set when Type is SyncCompleted } -type StartEvent struct{} -type FailedEvent struct{ Err error } diff --git a/eth/downloader/fetchers_concurrent.go b/eth/downloader/fetchers_concurrent.go index 9d8cd114c12a..51bf3404bda0 100644 --- a/eth/downloader/fetchers_concurrent.go +++ b/eth/downloader/fetchers_concurrent.go @@ -323,25 +323,32 @@ func (d *Downloader) concurrentFetch(queue typedQueue) error { delete(pending, res.Req.Peer) delete(stales, res.Req.Peer) - // Signal the dispatcher that the round trip is done. We'll drop the - // peer if the data turns out to be junk. - res.Done <- nil - res.Req.Close() - // If the peer was previously banned and failed to deliver its pack // in a reasonable time frame, ignore its message. - if peer := d.peers.Peer(res.Req.Peer); peer != nil { - // Deliver the received chunk of data and check chain validity - accepted, err := queue.deliver(peer, res) - if errors.Is(err, errInvalidChain) { - return err - } - // Unless a peer delivered something completely else than requested (usually - // caused by a timed out request which came through in the end), set it to - // idle. If the delivery's stale, the peer should have already been idled. - if !errors.Is(err, errStaleDelivery) { - queue.updateCapacity(peer, accepted, res.Time) - } + peer := d.peers.Peer(res.Req.Peer) + if peer == nil { + res.Done <- nil + res.Req.Close() + continue + } + // Deliver the received chunk of data and check chain validity + accepted, err := queue.deliver(peer, res) + // Unless a peer delivered something completely else than requested (usually + // caused by a timed out request which came through in the end), set it to + // idle. If the delivery's stale, the peer should have already been idled. + if !errors.Is(err, errStaleDelivery) { + queue.updateCapacity(peer, accepted, res.Time) + } + res.Done <- validityErrorOfRequest(err) + res.Req.Close() + + if errors.Is(err, errInvalidChain) { + // errInvalidChain is the signal that processing of items failed internally, + // even though the items were validly encoded. + // + // This can be due to invalid blocks, or a database error. + // The sync cycle should be aborted for such errors, so we return it here. + return err } case cont := <-queue.waker(): @@ -352,3 +359,11 @@ func (d *Downloader) concurrentFetch(queue typedQueue) error { } } } + +// validityErrorOfRequest returns err if it is related to block validity, and nil otherwise. +func validityErrorOfRequest(err error) error { + if errors.Is(err, errInvalidBody) || errors.Is(err, errInvalidReceipt) { + return err + } + return nil +} diff --git a/eth/downloader/fetchers_concurrent_bodies.go b/eth/downloader/fetchers_concurrent_bodies.go index 56359b33c94e..6a8eb3521916 100644 --- a/eth/downloader/fetchers_concurrent_bodies.go +++ b/eth/downloader/fetchers_concurrent_bodies.go @@ -88,15 +88,14 @@ func (q *bodyQueue) request(peer *peerConnection, req *fetchRequest, resCh chan // deliver is responsible for taking a generic response packet from the concurrent // fetcher, unpacking the body data and delivering it to the downloader's queue. func (q *bodyQueue) deliver(peer *peerConnection, packet *eth.Response) (int, error) { - txs, uncles, withdrawals := packet.Res.(*eth.BlockBodiesResponse).Unpack() - hashsets := packet.Meta.([][]common.Hash) // {txs hashes, uncle hashes, withdrawal hashes} - - accepted, err := q.queue.DeliverBodies(peer.id, txs, hashsets[0], uncles, hashsets[1], withdrawals, hashsets[2]) + resp := packet.Res.(*eth.BlockBodiesResponse) + meta := packet.Meta.(eth.BlockBodyHashes) + accepted, err := q.queue.DeliverBodies(peer.id, meta, *resp) switch { - case err == nil && len(txs) == 0: + case err == nil && len(*resp) == 0: peer.log.Trace("Requested bodies delivered") case err == nil: - peer.log.Trace("Delivered new batch of bodies", "count", len(txs), "accepted", accepted) + peer.log.Trace("Delivered new batch of bodies", "count", len(*resp), "accepted", accepted) default: peer.log.Debug("Failed to deliver retrieved bodies", "err", err) } diff --git a/eth/downloader/fetchers_concurrent_receipts.go b/eth/downloader/fetchers_concurrent_receipts.go index dbea30e881ed..74dbc67af34d 100644 --- a/eth/downloader/fetchers_concurrent_receipts.go +++ b/eth/downloader/fetchers_concurrent_receipts.go @@ -78,11 +78,17 @@ func (q *receiptQueue) request(peer *peerConnection, req *fetchRequest, resCh ch if q.receiptFetchHook != nil { q.receiptFetchHook(req.Headers) } - hashes := make([]common.Hash, 0, len(req.Headers)) + var ( + gasUsed = make([]uint64, 0, len(req.Headers)) + timestamps = make([]uint64, 0, len(req.Headers)) + hashes = make([]common.Hash, 0, len(req.Headers)) + ) for _, header := range req.Headers { hashes = append(hashes, header.Hash()) + gasUsed = append(gasUsed, header.GasUsed) + timestamps = append(timestamps, header.Time) } - return peer.peer.RequestReceipts(hashes, resCh) + return peer.peer.RequestReceipts(hashes, gasUsed, timestamps, resCh) } // deliver is responsible for taking a generic response packet from the concurrent diff --git a/eth/downloader/peer.go b/eth/downloader/peer.go index 0848e92a2682..d20bda69e967 100644 --- a/eth/downloader/peer.go +++ b/eth/downloader/peer.go @@ -60,7 +60,7 @@ type Peer interface { RequestHeadersByNumber(uint64, int, int, bool, chan *eth.Response) (*eth.Request, error) RequestBodies([]common.Hash, chan *eth.Response) (*eth.Request, error) - RequestReceipts([]common.Hash, chan *eth.Response) (*eth.Request, error) + RequestReceipts([]common.Hash, []uint64, []uint64, chan *eth.Response) (*eth.Request, error) } // newPeerConnection creates a new downloader peer. diff --git a/eth/downloader/queue.go b/eth/downloader/queue.go index 76a14345e5fd..585906b8bd4e 100644 --- a/eth/downloader/queue.go +++ b/eth/downloader/queue.go @@ -29,11 +29,10 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/prque" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto/kzg4844" "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/eth/protocols/eth" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" - "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" ) @@ -559,63 +558,54 @@ func (q *queue) expire(peer string, pendPool map[string]*fetchRequest, taskQueue // DeliverBodies injects a block body retrieval response into the results queue. // The method returns the number of blocks bodies accepted from the delivery and // also wakes any threads waiting for data delivery. -func (q *queue) DeliverBodies(id string, txLists [][]*types.Transaction, txListHashes []common.Hash, - uncleLists [][]*types.Header, uncleListHashes []common.Hash, - withdrawalLists [][]*types.Withdrawal, withdrawalListHashes []common.Hash, -) (int, error) { +func (q *queue) DeliverBodies(id string, hashes eth.BlockBodyHashes, bodies []eth.BlockBody) (int, error) { q.lock.Lock() defer q.lock.Unlock() + var txLists [][]*types.Transaction + var uncleLists [][]*types.Header + var withdrawalLists [][]*types.Withdrawal + validate := func(index int, header *types.Header) error { - if txListHashes[index] != header.TxHash { + if hashes.TransactionRoots[index] != header.TxHash { return errInvalidBody } - if uncleListHashes[index] != header.UncleHash { + if hashes.UncleHashes[index] != header.UncleHash { return errInvalidBody } if header.WithdrawalsHash == nil { // nil hash means that withdrawals should not be present in body - if withdrawalLists[index] != nil { + if bodies[index].Withdrawals != nil { return errInvalidBody } } else { // non-nil hash: body must have withdrawals - if withdrawalLists[index] == nil { + if bodies[index].Withdrawals == nil { return errInvalidBody } - if withdrawalListHashes[index] != *header.WithdrawalsHash { + if hashes.WithdrawalRoots[index] != *header.WithdrawalsHash { return errInvalidBody } } - // Blocks must have a number of blobs corresponding to the header gas usage, - // and zero before the Cancun hardfork. - var blobs int - for _, tx := range txLists[index] { - // Count the number of blobs to validate against the header's blobGasUsed - blobs += len(tx.BlobHashes()) - - // Validate the data blobs individually too - if tx.Type() == types.BlobTxType { - if len(tx.BlobHashes()) == 0 { - return errInvalidBody - } - for _, hash := range tx.BlobHashes() { - if !kzg4844.IsValidVersionedHash(hash[:]) { - return errInvalidBody - } - } - if tx.BlobTxSidecar() != nil { - return errInvalidBody - } - } + + // decode + txs, err := bodies[index].Transactions.Items() + if err != nil { + return fmt.Errorf("%w: bad transactions: %v", errInvalidBody, err) } - if header.BlobGasUsed != nil { - if want := *header.BlobGasUsed / params.BlobTxBlobGasPerBlob; uint64(blobs) != want { // div because the header is surely good vs the body might be bloated - return errInvalidBody + txLists = append(txLists, txs) + uncles, err := bodies[index].Uncles.Items() + if err != nil { + return fmt.Errorf("%w: bad uncles: %v", errInvalidBody, err) + } + uncleLists = append(uncleLists, uncles) + if bodies[index].Withdrawals != nil { + withdrawals, err := bodies[index].Withdrawals.Items() + if err != nil { + return fmt.Errorf("%w: bad withdrawals: %v", errInvalidBody, err) } + withdrawalLists = append(withdrawalLists, withdrawals) } else { - if blobs != 0 { - return errInvalidBody - } + withdrawalLists = append(withdrawalLists, nil) } return nil } @@ -626,8 +616,9 @@ func (q *queue) DeliverBodies(id string, txLists [][]*types.Transaction, txListH result.Withdrawals = withdrawalLists[index] result.SetBodyDone() } + nresults := len(hashes.TransactionRoots) return q.deliver(id, q.blockTaskPool, q.blockTaskQueue, q.blockPendPool, - bodyReqTimer, bodyInMeter, bodyDropMeter, len(txLists), validate, reconstruct) + bodyReqTimer, bodyInMeter, bodyDropMeter, nresults, validate, reconstruct) } // DeliverReceipts injects a receipt retrieval response into the results queue. @@ -680,10 +671,10 @@ func (q *queue) deliver(id string, taskPool map[common.Hash]*types.Header, } // Assemble each of the results with their headers and retrieved data parts var ( - accepted int - failure error - i int - hashes []common.Hash + accepted int + failure error + i int + foundStale bool ) for _, header := range request.Headers { // Short circuit assembly if no more fetch results are found @@ -695,42 +686,41 @@ func (q *queue) deliver(id string, taskPool map[common.Hash]*types.Header, failure = err break } - hashes = append(hashes, header.Hash()) i++ } - for _, header := range request.Headers[:i] { + for k, header := range request.Headers[:i] { if res, stale, err := q.resultCache.GetDeliverySlot(header.Number.Uint64()); err == nil && !stale { - reconstruct(accepted, res) + reconstruct(k, res) + accepted++ } else { - // else: between here and above, some other peer filled this result, + // Between here and above, some other peer filled this result, // or it was indeed a no-op. This should not happen, but if it does it's // not something to panic about log.Error("Delivery stale", "stale", stale, "number", header.Number.Uint64(), "err", err) - failure = errStaleDelivery + foundStale = true } // Clean up a successful fetch - delete(taskPool, hashes[accepted]) - accepted++ + delete(taskPool, header.Hash()) } resDropMeter.Mark(int64(results - accepted)) // Return all failed or missing fetches to the queue - for _, header := range request.Headers[accepted:] { + for _, header := range request.Headers[i:] { taskQueue.Push(header, -int64(header.Number.Uint64())) } // Wake up Results if accepted > 0 { q.active.Signal() } - if failure == nil { - return accepted, nil + if failure != nil { + return accepted, failure } // If none of the data was good, it's a stale delivery - if accepted > 0 { - return accepted, fmt.Errorf("partial failure: %v", failure) + if foundStale { + return accepted, errStaleDelivery } - return accepted, fmt.Errorf("%w: %v", failure, errStaleDelivery) + return accepted, nil } // Prepare configures the result cache to allow accepting and caching inbound diff --git a/eth/downloader/queue_test.go b/eth/downloader/queue_test.go index ca71a769de29..c7e8a0d1d638 100644 --- a/eth/downloader/queue_test.go +++ b/eth/downloader/queue_test.go @@ -30,8 +30,10 @@ import ( "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth/protocols/eth" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) @@ -323,26 +325,31 @@ func XTestDelivery(t *testing.T) { emptyList []*types.Header txset [][]*types.Transaction uncleset [][]*types.Header + bodies []eth.BlockBody ) numToSkip := rand.Intn(len(f.Headers)) for _, hdr := range f.Headers[0 : len(f.Headers)-numToSkip] { - txset = append(txset, world.getTransactions(hdr.Number.Uint64())) + txs := world.getTransactions(hdr.Number.Uint64()) + txset = append(txset, txs) uncleset = append(uncleset, emptyList) + txsList, _ := rlp.EncodeToRawList(txs) + bodies = append(bodies, eth.BlockBody{Transactions: txsList}) + } + hashes := eth.BlockBodyHashes{ + TransactionRoots: make([]common.Hash, len(txset)), + UncleHashes: make([]common.Hash, len(uncleset)), + WithdrawalRoots: make([]common.Hash, len(txset)), } - var ( - txsHashes = make([]common.Hash, len(txset)) - uncleHashes = make([]common.Hash, len(uncleset)) - ) hasher := trie.NewStackTrie(nil) for i, txs := range txset { - txsHashes[i] = types.DeriveSha(types.Transactions(txs), hasher) + hashes.TransactionRoots[i] = types.DeriveSha(types.Transactions(txs), hasher) } for i, uncles := range uncleset { - uncleHashes[i] = types.CalcUncleHash(uncles) + hashes.UncleHashes[i] = types.CalcUncleHash(uncles) } + time.Sleep(100 * time.Millisecond) - _, err := q.DeliverBodies(peer.id, txset, txsHashes, uncleset, uncleHashes, nil, nil) - if err != nil { + if _, err := q.DeliverBodies(peer.id, hashes, bodies); err != nil { fmt.Printf("delivered %d bodies %v\n", len(txset), err) } } else { diff --git a/eth/downloader/skeleton.go b/eth/downloader/skeleton.go index 2cf9c4672b16..e693bfc06687 100644 --- a/eth/downloader/skeleton.go +++ b/eth/downloader/skeleton.go @@ -64,6 +64,12 @@ var errSyncMerged = errors.New("sync merged") // should abort and restart with the new state. var errSyncReorged = errors.New("sync reorged") +// errSyncTrimmed is an internal helper error to signal that the local chain +// has been trimmed (e.g, via debug_setHead explicitly) and the skeleton chain +// is no longer linked with the local chain. In this case, the skeleton sync +// should be re-scheduled again. +var errSyncTrimmed = errors.New("sync trimmed") + // errTerminated is returned if the sync mechanism was terminated for this run of // the process. This is usually the case when Geth is shutting down and some events // might still be propagating. @@ -201,6 +207,7 @@ type backfiller interface { type skeleton struct { db ethdb.Database // Database backing the skeleton filler backfiller // Chain syncer suspended/resumed by head events + chain chainReader // Underlying block chain peers *peerSet // Set of peers we can sync from idles map[string]*peerConnection // Set of idle peers in the current sync cycle @@ -225,12 +232,19 @@ type skeleton struct { syncStarting func() // callback triggered after a sync cycle is inited but before started } +// chainReader wraps the method to retrieve the head of the local chain. +type chainReader interface { + // CurrentSnapBlock retrieves the head snap block from the local chain. + CurrentSnapBlock() *types.Header +} + // newSkeleton creates a new sync skeleton that tracks a potentially dangling // header chain until it's linked into an existing set of blocks. -func newSkeleton(db ethdb.Database, peers *peerSet, drop peerDropFn, filler backfiller) *skeleton { +func newSkeleton(db ethdb.Database, peers *peerSet, drop peerDropFn, filler backfiller, chain chainReader) *skeleton { sk := &skeleton{ db: db, filler: filler, + chain: chain, peers: peers, drop: drop, requests: make(map[uint64]*headerRequest), @@ -296,6 +310,11 @@ func (s *skeleton) startup() { // head to force a cleanup. head = newhead + case err == errSyncTrimmed: + // The skeleton chain is not linked with the local chain anymore, + // restart the sync. + head = nil + case err == errTerminated: // Sync was requested to be terminated from within, stop and // return (no need to pass a message, was already done internally) @@ -343,6 +362,29 @@ func (s *skeleton) Sync(head *types.Header, final *types.Header, force bool) err } } +// linked returns the flag indicating whether the skeleton has been linked with +// the local chain. +func (s *skeleton) linked(number uint64, hash common.Hash) bool { + linked := rawdb.HasHeader(s.db, hash, number) && + rawdb.HasBody(s.db, hash, number) && + rawdb.HasReceipts(s.db, hash, number) + + // Ensure the skeleton chain links to the local chain below the chain head. + // This accounts for edge cases where leftover chain segments above the head + // may still link to the skeleton chain. In such cases, synchronization is + // likely to fail due to potentially missing segments in the middle. + // + // You can try to produce the edge case by these steps: + // - sync the chain + // - debug.setHead(`0x1`) + // - kill the geth process (the chain segment will be left with chain head rewound) + // - restart + if s.chain.CurrentSnapBlock() != nil { + linked = linked && s.chain.CurrentSnapBlock().Number.Uint64() >= number + } + return linked +} + // sync is the internal version of Sync that executes a single sync cycle, either // until some termination condition is reached, or until the current cycle merges // with a previously aborted run. @@ -367,10 +409,7 @@ func (s *skeleton) sync(head *types.Header) (*types.Header, error) { // If the sync is already done, resume the backfiller. When the loop stops, // terminate the backfiller too. - linked := len(s.progress.Subchains) == 1 && - rawdb.HasHeader(s.db, s.progress.Subchains[0].Next, s.scratchHead) && - rawdb.HasBody(s.db, s.progress.Subchains[0].Next, s.scratchHead) && - rawdb.HasReceipts(s.db, s.progress.Subchains[0].Next, s.scratchHead) + linked := len(s.progress.Subchains) == 1 && s.linked(s.scratchHead, s.progress.Subchains[0].Next) if linked { s.filler.resume() } @@ -486,7 +525,17 @@ func (s *skeleton) sync(head *types.Header) (*types.Header, error) { // is still running, it will pick it up. If it already terminated, // a new cycle needs to be spun up. if linked { - s.filler.resume() + if len(s.progress.Subchains) == 1 && s.linked(s.scratchHead, s.progress.Subchains[0].Next) { + // The skeleton chain has been extended and is still linked with the local + // chain, try to re-schedule the backfiller if it's already terminated. + s.filler.resume() + } else { + // The skeleton chain is no longer linked to the local chain for some reason + // (e.g. debug_setHead was used to trim the local chain). Re-schedule the + // skeleton sync to fill the chain gap. + log.Warn("Local chain has been trimmed", "tailnumber", s.scratchHead, "tailhash", s.progress.Subchains[0].Next) + return nil, errSyncTrimmed + } } case req := <-requestFails: @@ -649,9 +698,19 @@ func (s *skeleton) processNewHead(head *types.Header, final *types.Header) error // Not a noop / double head announce, abort with a reorg return fmt.Errorf("%w, tail: %d, head: %d, newHead: %d", errChainReorged, lastchain.Tail, lastchain.Head, number) } + // Terminate the sync if the chain head is gapped if lastchain.Head+1 < number { return fmt.Errorf("%w, head: %d, newHead: %d", errChainGapped, lastchain.Head, number) } + // Ignore the duplicated beacon header announcement + if lastchain.Head == number { + local := rawdb.ReadSkeletonHeader(s.db, number) + if local != nil && local.Hash() == head.Hash() { + log.Debug("Ignored the identical beacon header", "number", number, "hash", local.Hash()) + return nil + } + } + // Terminate the sync if the chain head is forked if parent := rawdb.ReadSkeletonHeader(s.db, number-1); parent.Hash() != head.ParentHash { return fmt.Errorf("%w, ancestor: %d, hash: %s, want: %s", errChainForked, number-1, parent.Hash(), head.ParentHash) } @@ -669,6 +728,7 @@ func (s *skeleton) processNewHead(head *types.Header, final *types.Header) error if err := batch.Write(); err != nil { log.Crit("Failed to write skeleton sync status", "err", err) } + log.Debug("Extended beacon header chain", "number", head.Number, "hash", head.Hash()) return nil } @@ -909,6 +969,45 @@ func (s *skeleton) revertRequest(req *headerRequest) { s.scratchOwners[(s.scratchHead-req.head)/requestHeaders] = "" } +// mergeSubchains is invoked once certain beacon headers have been persisted locally +// and the subchains should be merged in case there are some overlaps between. An +// indicator will be returned if the last subchain is merged with previous subchain. +func (s *skeleton) mergeSubchains() bool { + // If the subchain extended into the next subchain, we need to handle + // the overlap. Since there could be many overlaps, do this in a loop. + var merged bool + for len(s.progress.Subchains) > 1 && s.progress.Subchains[1].Head >= s.progress.Subchains[0].Tail { + // Extract some stats from the second subchain + head := s.progress.Subchains[1].Head + tail := s.progress.Subchains[1].Tail + next := s.progress.Subchains[1].Next + + // Since we just overwrote part of the next subchain, we need to trim + // its head independent of matching or mismatching content + if s.progress.Subchains[1].Tail >= s.progress.Subchains[0].Tail { + // Fully overwritten, get rid of the subchain as a whole + log.Debug("Previous subchain fully overwritten", "head", head, "tail", tail, "next", next) + s.progress.Subchains = append(s.progress.Subchains[:1], s.progress.Subchains[2:]...) + continue + } else { + // Partially overwritten, trim the head to the overwritten size + log.Debug("Previous subchain partially overwritten", "head", head, "tail", tail, "next", next) + s.progress.Subchains[1].Head = s.progress.Subchains[0].Tail - 1 + } + // If the old subchain is an extension of the new one, merge the two + // and let the skeleton syncer restart (to clean internal state) + if rawdb.ReadSkeletonHeader(s.db, s.progress.Subchains[1].Head).Hash() == s.progress.Subchains[0].Next { + log.Debug("Previous subchain merged", "head", head, "tail", tail, "next", next) + s.progress.Subchains[0].Tail = s.progress.Subchains[1].Tail + s.progress.Subchains[0].Next = s.progress.Subchains[1].Next + + s.progress.Subchains = append(s.progress.Subchains[:1], s.progress.Subchains[2:]...) + merged = true + } + } + return merged +} + func (s *skeleton) processResponse(res *headerResponse) (linked bool, merged bool) { res.peer.log.Trace("Processing header response", "head", res.headers[0].Number, "hash", res.headers[0].Hash(), "count", len(res.headers)) @@ -982,10 +1081,9 @@ func (s *skeleton) processResponse(res *headerResponse) (linked bool, merged boo // processing is done, so it's just one more "needless" check. // // The weird cascading checks are done to minimize the database reads. - linked = rawdb.HasHeader(s.db, header.ParentHash, header.Number.Uint64()-1) && - rawdb.HasBody(s.db, header.ParentHash, header.Number.Uint64()-1) && - rawdb.HasReceipts(s.db, header.ParentHash, header.Number.Uint64()-1) + linked = s.linked(header.Number.Uint64()-1, header.ParentHash) if linked { + log.Debug("Primary subchain linked", "number", header.Number.Uint64()-1, "hash", header.ParentHash) break } } @@ -999,6 +1097,9 @@ func (s *skeleton) processResponse(res *headerResponse) (linked bool, merged boo // If the beacon chain was linked to the local chain, completely swap out // all internal progress and abort header synchronization. if linked { + // Merge all overlapped subchains beforehand + s.mergeSubchains() + // Linking into the local chain should also mean that there are no // leftover subchains, but in the case of importing the blocks via // the engine API, we will not push the subchains forward. This will @@ -1056,41 +1157,10 @@ func (s *skeleton) processResponse(res *headerResponse) (linked bool, merged boo s.scratchHead -= uint64(consumed) - // If the subchain extended into the next subchain, we need to handle - // the overlap. Since there could be many overlaps (come on), do this - // in a loop. - for len(s.progress.Subchains) > 1 && s.progress.Subchains[1].Head >= s.progress.Subchains[0].Tail { - // Extract some stats from the second subchain - head := s.progress.Subchains[1].Head - tail := s.progress.Subchains[1].Tail - next := s.progress.Subchains[1].Next - - // Since we just overwrote part of the next subchain, we need to trim - // its head independent of matching or mismatching content - if s.progress.Subchains[1].Tail >= s.progress.Subchains[0].Tail { - // Fully overwritten, get rid of the subchain as a whole - log.Debug("Previous subchain fully overwritten", "head", head, "tail", tail, "next", next) - s.progress.Subchains = append(s.progress.Subchains[:1], s.progress.Subchains[2:]...) - continue - } else { - // Partially overwritten, trim the head to the overwritten size - log.Debug("Previous subchain partially overwritten", "head", head, "tail", tail, "next", next) - s.progress.Subchains[1].Head = s.progress.Subchains[0].Tail - 1 - } - // If the old subchain is an extension of the new one, merge the two - // and let the skeleton syncer restart (to clean internal state) - if rawdb.ReadSkeletonHeader(s.db, s.progress.Subchains[1].Head).Hash() == s.progress.Subchains[0].Next { - log.Debug("Previous subchain merged", "head", head, "tail", tail, "next", next) - s.progress.Subchains[0].Tail = s.progress.Subchains[1].Tail - s.progress.Subchains[0].Next = s.progress.Subchains[1].Next - - s.progress.Subchains = append(s.progress.Subchains[:1], s.progress.Subchains[2:]...) - merged = true - } - } // If subchains were merged, all further available headers in the scratch // space are invalid since we skipped ahead. Stop processing the scratch // space to avoid dropping peers thinking they delivered invalid data. + merged = s.mergeSubchains() if merged { break } @@ -1121,15 +1191,17 @@ func (s *skeleton) processResponse(res *headerResponse) (linked bool, merged boo // due to the downloader backfilling past the tracked tail. func (s *skeleton) cleanStales(filled *types.Header) error { number := filled.Number.Uint64() - log.Trace("Cleaning stale beacon headers", "filled", number, "hash", filled.Hash()) + log.Debug("Cleaning stale beacon headers", "filled", number, "hash", filled.Hash()) - // If the filled header is below the linked subchain, something's corrupted - // internally. Report and error and refuse to do anything. + // If the filled header is below the subchain, it means the skeleton is not + // linked with local chain yet, don't bother to do cleanup. if number+1 < s.progress.Subchains[0].Tail { - return fmt.Errorf("filled header below beacon header tail: %d < %d", number, s.progress.Subchains[0].Tail) + log.Debug("filled header below beacon header tail", "filled", number, "tail", s.progress.Subchains[0].Tail) + return nil } // If nothing in subchain is filled, don't bother to do cleanup. if number+1 == s.progress.Subchains[0].Tail { + log.Debug("Skeleton chain not yet consumed", "filled", number, "hash", filled.Hash(), "tail", s.progress.Subchains[0].Tail) return nil } // If the latest fill was on a different subchain, it means the backfiller @@ -1206,6 +1278,7 @@ func (s *skeleton) cleanStales(filled *types.Header) error { if err := batch.Write(); err != nil { log.Crit("Failed to write beacon trim data", "err", err) } + log.Debug("Cleaned stale beacon headers", "start", start, "end", end) return nil } diff --git a/eth/downloader/skeleton_test.go b/eth/downloader/skeleton_test.go index 4aa97cf1f797..b9e7dba6ee6d 100644 --- a/eth/downloader/skeleton_test.go +++ b/eth/downloader/skeleton_test.go @@ -20,6 +20,7 @@ import ( "encoding/json" "errors" "fmt" + "math" "math/big" "sync/atomic" "testing" @@ -71,6 +72,12 @@ func (hf *hookedBackfiller) resume() { } } +type fakeChainReader struct{} + +func (fc *fakeChainReader) CurrentSnapBlock() *types.Header { + return &types.Header{Number: big.NewInt(math.MaxInt64)} +} + // skeletonTestPeer is a mock peer that can only serve header requests from a // pre-perated header chain (which may be arbitrarily wrong for testing). // @@ -201,7 +208,7 @@ func (p *skeletonTestPeer) RequestBodies([]common.Hash, chan *eth.Response) (*et panic("skeleton sync must not request block bodies") } -func (p *skeletonTestPeer) RequestReceipts([]common.Hash, chan *eth.Response) (*eth.Request, error) { +func (p *skeletonTestPeer) RequestReceipts([]common.Hash, []uint64, []uint64, chan *eth.Response) (*eth.Request, error) { panic("skeleton sync must not request receipts") } @@ -369,7 +376,7 @@ func TestSkeletonSyncInit(t *testing.T) { // Create a skeleton sync and run a cycle wait := make(chan struct{}) - skeleton := newSkeleton(db, newPeerSet(), nil, newHookedBackfiller()) + skeleton := newSkeleton(db, newPeerSet(), nil, newHookedBackfiller(), &fakeChainReader{}) skeleton.syncStarting = func() { close(wait) } skeleton.Sync(tt.head, nil, true) @@ -472,7 +479,7 @@ func TestSkeletonSyncExtend(t *testing.T) { // Create a skeleton sync and run a cycle wait := make(chan struct{}) - skeleton := newSkeleton(db, newPeerSet(), nil, newHookedBackfiller()) + skeleton := newSkeleton(db, newPeerSet(), nil, newHookedBackfiller(), &fakeChainReader{}) skeleton.syncStarting = func() { close(wait) } skeleton.Sync(tt.head, nil, true) @@ -838,7 +845,7 @@ func TestSkeletonSyncRetrievals(t *testing.T) { // Create a peer set to feed headers through peerset := newPeerSet() for _, peer := range tt.peers { - peerset.Register(newPeerConnection(peer.id, eth.ETH68, peer, log.New("id", peer.id))) + peerset.Register(newPeerConnection(peer.id, eth.ETH69, peer, log.New("id", peer.id))) } // Create a peer dropper to track malicious peers dropped := make(map[string]int) @@ -885,7 +892,7 @@ func TestSkeletonSyncRetrievals(t *testing.T) { } } // Create a skeleton sync and run a cycle - skeleton := newSkeleton(db, peerset, drop, filler) + skeleton := newSkeleton(db, peerset, drop, filler, &fakeChainReader{}) skeleton.Sync(tt.head, nil, true) // Wait a bit (bleah) for the initial sync loop to go to idle. This might @@ -905,7 +912,7 @@ func TestSkeletonSyncRetrievals(t *testing.T) { // Apply the post-init events if there's any endpeers := tt.peers if tt.newPeer != nil { - if err := peerset.Register(newPeerConnection(tt.newPeer.id, eth.ETH68, tt.newPeer, log.New("id", tt.newPeer.id))); err != nil { + if err := peerset.Register(newPeerConnection(tt.newPeer.id, eth.ETH69, tt.newPeer, log.New("id", tt.newPeer.id))); err != nil { t.Errorf("test %d: failed to register new peer: %v", i, err) } time.Sleep(time.Millisecond * 50) // given time for peer registration diff --git a/eth/downloader/syncmode.go b/eth/downloader/syncmode.go index 7983d39e3a2c..036119ce3dbc 100644 --- a/eth/downloader/syncmode.go +++ b/eth/downloader/syncmode.go @@ -75,7 +75,7 @@ func newSyncModer(mode ethconfig.SyncMode, chain BlockChain, disk ethdb.KeyValue // get retrieves the current sync mode, either explicitly set, or derived // from the chain status. -func (m *syncModer) get() ethconfig.SyncMode { +func (m *syncModer) get(report bool) ethconfig.SyncMode { m.lock.Lock() defer m.lock.Unlock() @@ -83,12 +83,16 @@ func (m *syncModer) get() ethconfig.SyncMode { if m.mode == ethconfig.SnapSync { return ethconfig.SnapSync } + logger := log.Debug + if report { + logger = log.Info + } // We are probably in full sync, but we might have rewound to before the // snap sync pivot, check if we should re-enable snap sync. head := m.chain.CurrentBlock() if pivot := rawdb.ReadLastPivotNumber(m.disk); pivot != nil { if head.Number.Uint64() < *pivot { - log.Info("Reenabled snap-sync as chain is lagging behind the pivot", "head", head.Number, "pivot", pivot) + logger("Reenabled snap-sync as chain is lagging behind the pivot", "head", head.Number, "pivot", pivot) return ethconfig.SnapSync } } @@ -96,7 +100,7 @@ func (m *syncModer) get() ethconfig.SyncMode { // the head state, forcefully rerun the snap sync. Note it doesn't mean the // persistent state is corrupted, just mismatch with the head block. if !m.chain.HasState(head.Root) { - log.Info("Reenabled snap-sync as chain is stateless") + logger("Reenabled snap-sync as chain is stateless") return ethconfig.SnapSync } // Nope, we're really full syncing diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go index d6ed2c2576cc..ee84c486a28a 100644 --- a/eth/ethconfig/config.go +++ b/eth/ethconfig/config.go @@ -35,6 +35,8 @@ import ( "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/triedb" + "github.com/ethereum/go-ethereum/triedb/pathdb" ) // FullNodeGPO contains default gasprice oracle settings for full node. @@ -49,30 +51,34 @@ var FullNodeGPO = gasprice.Config{ // Defaults contains default settings for use on the Ethereum main net. var Defaults = Config{ - HistoryMode: history.KeepAll, - SyncMode: SnapSync, - NetworkId: 0, // enable auto configuration of networkID == chainID - TxLookupLimit: 2350000, - TransactionHistory: 2350000, - LogHistory: 2350000, - StateHistory: params.FullImmutabilityThreshold, - DatabaseCache: 512, - TrieCleanCache: 154, - TrieDirtyCache: 256, - TrieTimeout: 60 * time.Minute, - SnapshotCache: 102, - FilterLogCacheSize: 32, - LogQueryLimit: 1000, - Miner: miner.DefaultConfig, - TxPool: legacypool.DefaultConfig, - BlobPool: blobpool.DefaultConfig, - RPCGasCap: 50000000, - RPCEVMTimeout: 5 * time.Second, - GPO: FullNodeGPO, - RPCTxFeeCap: 1, // 1 ether - TxSyncDefaultTimeout: 20 * time.Second, - TxSyncMaxTimeout: 1 * time.Minute, - SlowBlockThreshold: time.Second * 2, + HistoryMode: history.KeepAll, + SyncMode: SnapSync, + NetworkId: 0, // enable auto configuration of networkID == chainID + TxLookupLimit: 2350000, + TransactionHistory: 2350000, + LogHistory: 2350000, + StateHistory: pathdb.Defaults.StateHistory, + TrienodeHistory: pathdb.Defaults.TrienodeHistory, + NodeFullValueCheckpoint: pathdb.Defaults.FullValueCheckpoint, + BinTrieGroupDepth: triedb.DefaultBinTrieGroupDepth, + DatabaseCache: 2048, + TrieCleanCache: 614, + TrieDirtyCache: 1024, + SnapshotCache: 409, + TrieTimeout: 60 * time.Minute, + FilterLogCacheSize: 32, + LogQueryLimit: 1000, + Miner: miner.DefaultConfig, + TxPool: legacypool.DefaultConfig, + BlobPool: blobpool.DefaultConfig, + RPCGasCap: 50000000, + RPCEVMTimeout: 5 * time.Second, + GPO: FullNodeGPO, + RPCTxFeeCap: 1, // 1 ether + TxSyncDefaultTimeout: 20 * time.Second, + TxSyncMaxTimeout: 1 * time.Minute, + SlowBlockThreshold: -1, // Disabled by default; set via --debug.logslowblock flag + RangeLimit: 0, } //go:generate go run github.com/fjl/gencodec -type Config -formats toml -out gen_config.go @@ -108,19 +114,32 @@ type Config struct { LogNoHistory bool `toml:",omitempty"` // No log search index is maintained. LogExportCheckpoints string // export log index checkpoints to file StateHistory uint64 `toml:",omitempty"` // The maximum number of blocks from head whose state histories are reserved. + TrienodeHistory int64 `toml:",omitempty"` // Number of blocks from the chain head for which trienode histories are retained + + // The frequency of full-value encoding. For example, a value of 16 means + // that, on average, for a given trie node across its 16 consecutive historical + // versions, only one version is stored in full format, while the others + // are stored in diff mode for storage compression. + NodeFullValueCheckpoint uint32 `toml:",omitempty"` // State scheme represents the scheme used to store ethereum states and trie // nodes on top. It can be 'hash', 'path', or none which means use the scheme // consistent with persistent state. StateScheme string `toml:",omitempty"` + // BinTrieGroupDepth is the number of levels per serialized group in binary trie. + // Valid values are 1-8, with 8 being the default (byte-aligned groups). + // Lower values create smaller groups with more nodes. + BinTrieGroupDepth int `toml:",omitempty"` + // RequiredBlocks is a set of block number -> hash mappings which must be in the // canonical chain of all remote peers. Setting the option makes geth verify the // presence of these blocks for every new peer connection. RequiredBlocks map[uint64]common.Hash `toml:"-"` - // SlowBlockThreshold is the block execution speed threshold (Mgas/s) - // below which detailed statistics are logged. + // SlowBlockThreshold is the block execution time threshold beyond which + // detailed statistics are logged. Negative means disabled (default), zero + // logs all blocks, positive filters by execution time. SlowBlockThreshold time.Duration `toml:",omitempty"` // Database options @@ -165,6 +184,9 @@ type Config struct { // Enables tracking of state size EnableStateSizeTracking bool + // Number of recent block state sizes to track + StateSizeTrackingDepth uint64 + // Enables VM tracing VMTrace string VMTraceJsonConfig string @@ -188,12 +210,15 @@ type Config struct { // OverrideBPO2 (TODO: remove after the fork) OverrideBPO2 *uint64 `toml:",omitempty"` - // OverrideVerkle (TODO: remove after the fork) - OverrideVerkle *uint64 `toml:",omitempty"` + // OverrideUBT (TODO: remove after the fork) + OverrideUBT *uint64 `toml:",omitempty"` // EIP-7966: eth_sendRawTransactionSync timeouts TxSyncDefaultTimeout time.Duration `toml:",omitempty"` TxSyncMaxTimeout time.Duration `toml:",omitempty"` + + // RangeLimit restricts the maximum range (end - start) for range queries. + RangeLimit uint64 `toml:",omitempty"` } // CreateConsensusEngine creates a consensus engine for the given chain config. diff --git a/eth/ethconfig/gen_config.go b/eth/ethconfig/gen_config.go index 97c5db3ecdbb..c5e45348be03 100644 --- a/eth/ethconfig/gen_config.go +++ b/eth/ethconfig/gen_config.go @@ -31,7 +31,10 @@ func (c Config) MarshalTOML() (interface{}, error) { LogNoHistory bool `toml:",omitempty"` LogExportCheckpoints string StateHistory uint64 `toml:",omitempty"` + TrienodeHistory int64 `toml:",omitempty"` + NodeFullValueCheckpoint uint32 `toml:",omitempty"` StateScheme string `toml:",omitempty"` + BinTrieGroupDepth int `toml:",omitempty"` RequiredBlocks map[uint64]common.Hash `toml:"-"` SlowBlockThreshold time.Duration `toml:",omitempty"` SkipBcVersionCheck bool `toml:"-"` @@ -62,9 +65,10 @@ func (c Config) MarshalTOML() (interface{}, error) { OverrideOsaka *uint64 `toml:",omitempty"` OverrideBPO1 *uint64 `toml:",omitempty"` OverrideBPO2 *uint64 `toml:",omitempty"` - OverrideVerkle *uint64 `toml:",omitempty"` + OverrideUBT *uint64 `toml:",omitempty"` TxSyncDefaultTimeout time.Duration `toml:",omitempty"` TxSyncMaxTimeout time.Duration `toml:",omitempty"` + RangeLimit uint64 `toml:",omitempty"` } var enc Config enc.Genesis = c.Genesis @@ -81,7 +85,10 @@ func (c Config) MarshalTOML() (interface{}, error) { enc.LogNoHistory = c.LogNoHistory enc.LogExportCheckpoints = c.LogExportCheckpoints enc.StateHistory = c.StateHistory + enc.TrienodeHistory = c.TrienodeHistory + enc.NodeFullValueCheckpoint = c.NodeFullValueCheckpoint enc.StateScheme = c.StateScheme + enc.BinTrieGroupDepth = c.BinTrieGroupDepth enc.RequiredBlocks = c.RequiredBlocks enc.SlowBlockThreshold = c.SlowBlockThreshold enc.SkipBcVersionCheck = c.SkipBcVersionCheck @@ -112,9 +119,10 @@ func (c Config) MarshalTOML() (interface{}, error) { enc.OverrideOsaka = c.OverrideOsaka enc.OverrideBPO1 = c.OverrideBPO1 enc.OverrideBPO2 = c.OverrideBPO2 - enc.OverrideVerkle = c.OverrideVerkle + enc.OverrideUBT = c.OverrideUBT enc.TxSyncDefaultTimeout = c.TxSyncDefaultTimeout enc.TxSyncMaxTimeout = c.TxSyncMaxTimeout + enc.RangeLimit = c.RangeLimit return &enc, nil } @@ -135,7 +143,10 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { LogNoHistory *bool `toml:",omitempty"` LogExportCheckpoints *string StateHistory *uint64 `toml:",omitempty"` + TrienodeHistory *int64 `toml:",omitempty"` + NodeFullValueCheckpoint *uint32 `toml:",omitempty"` StateScheme *string `toml:",omitempty"` + BinTrieGroupDepth *int `toml:",omitempty"` RequiredBlocks map[uint64]common.Hash `toml:"-"` SlowBlockThreshold *time.Duration `toml:",omitempty"` SkipBcVersionCheck *bool `toml:"-"` @@ -166,9 +177,10 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { OverrideOsaka *uint64 `toml:",omitempty"` OverrideBPO1 *uint64 `toml:",omitempty"` OverrideBPO2 *uint64 `toml:",omitempty"` - OverrideVerkle *uint64 `toml:",omitempty"` + OverrideUBT *uint64 `toml:",omitempty"` TxSyncDefaultTimeout *time.Duration `toml:",omitempty"` TxSyncMaxTimeout *time.Duration `toml:",omitempty"` + RangeLimit *uint64 `toml:",omitempty"` } var dec Config if err := unmarshal(&dec); err != nil { @@ -216,9 +228,18 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { if dec.StateHistory != nil { c.StateHistory = *dec.StateHistory } + if dec.TrienodeHistory != nil { + c.TrienodeHistory = *dec.TrienodeHistory + } + if dec.NodeFullValueCheckpoint != nil { + c.NodeFullValueCheckpoint = *dec.NodeFullValueCheckpoint + } if dec.StateScheme != nil { c.StateScheme = *dec.StateScheme } + if dec.BinTrieGroupDepth != nil { + c.BinTrieGroupDepth = *dec.BinTrieGroupDepth + } if dec.RequiredBlocks != nil { c.RequiredBlocks = dec.RequiredBlocks } @@ -309,8 +330,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { if dec.OverrideBPO2 != nil { c.OverrideBPO2 = dec.OverrideBPO2 } - if dec.OverrideVerkle != nil { - c.OverrideVerkle = dec.OverrideVerkle + if dec.OverrideUBT != nil { + c.OverrideUBT = dec.OverrideUBT } if dec.TxSyncDefaultTimeout != nil { c.TxSyncDefaultTimeout = *dec.TxSyncDefaultTimeout @@ -318,5 +339,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { if dec.TxSyncMaxTimeout != nil { c.TxSyncMaxTimeout = *dec.TxSyncMaxTimeout } + if dec.RangeLimit != nil { + c.RangeLimit = *dec.RangeLimit + } return nil } diff --git a/eth/fetcher/metrics.go b/eth/fetcher/metrics.go index fd1678dd3060..3c0d6a8fd859 100644 --- a/eth/fetcher/metrics.go +++ b/eth/fetcher/metrics.go @@ -24,6 +24,7 @@ var ( txAnnounceInMeter = metrics.NewRegisteredMeter("eth/fetcher/transaction/announces/in", nil) txAnnounceKnownMeter = metrics.NewRegisteredMeter("eth/fetcher/transaction/announces/known", nil) txAnnounceUnderpricedMeter = metrics.NewRegisteredMeter("eth/fetcher/transaction/announces/underpriced", nil) + txAnnounceOnchainMeter = metrics.NewRegisteredMeter("eth/fetcher/transaction/announces/onchain", nil) txAnnounceDOSMeter = metrics.NewRegisteredMeter("eth/fetcher/transaction/announces/dos", nil) txBroadcastInMeter = metrics.NewRegisteredMeter("eth/fetcher/transaction/broadcasts/in", nil) diff --git a/eth/fetcher/tx_fetcher.go b/eth/fetcher/tx_fetcher.go index d919ac8a5f3d..20621c531d28 100644 --- a/eth/fetcher/tx_fetcher.go +++ b/eth/fetcher/tx_fetcher.go @@ -27,6 +27,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/lru" "github.com/ethereum/go-ethereum/common/mclock" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/txpool" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/log" @@ -71,6 +72,11 @@ const ( // addTxsBatchSize it the max number of transactions to add in a single batch from a peer. addTxsBatchSize = 128 + + // txOnChainCacheLimit is number of on-chain transactions to keep in a cache to avoid + // re-fetching them soon after they are mined. + // Approx 1MB for 30 minutes of transactions at 18 tps + txOnChainCacheLimit = 32768 ) var ( @@ -114,10 +120,11 @@ type txRequest struct { // txDelivery is the notification that a batch of transactions have been added // to the pool and should be untracked. type txDelivery struct { - origin string // Identifier of the peer originating the notification - hashes []common.Hash // Batch of transaction hashes having been delivered - metas []txMetadata // Batch of metadata associated with the delivered hashes - direct bool // Whether this is a direct reply or a broadcast + origin string // Identifier of the peer originating the notification + hashes []common.Hash // Batch of transaction hashes having been delivered + metas []txMetadata // Batch of metadata associated with the delivered hashes + direct bool // Whether this is a direct reply or a broadcast + violation error // Whether we encountered a protocol violation } // txDrop is the notification that a peer has disconnected. @@ -151,6 +158,9 @@ type TxFetcher struct { txSeq uint64 // Unique transaction sequence number underpriced *lru.Cache[common.Hash, time.Time] // Transactions discarded as too cheap (don't re-fetch) + chain *core.BlockChain // Blockchain interface for on-chain checks + txOnChainCache *lru.Cache[common.Hash, struct{}] // Cache to avoid fetching once the tx gets on chain + // Stage 1: Waiting lists for newly discovered transactions that might be // broadcast without needing explicit request/reply round trips. waitlist map[common.Hash]map[string]struct{} // Transactions waiting for an potential broadcast @@ -170,10 +180,10 @@ type TxFetcher struct { alternates map[common.Hash]map[string]struct{} // In-flight transaction alternate origins if retrieval fails // Callbacks - hasTx func(common.Hash) bool // Retrieves a tx from the local txpool - addTxs func([]*types.Transaction) []error // Insert a batch of transactions into local txpool - fetchTxs func(string, []common.Hash) error // Retrieves a set of txs from a remote peer - dropPeer func(string) // Drops a peer in case of announcement violation + validateMeta func(common.Hash, byte) error // Validate a tx metadata based on the local txpool + addTxs func([]*types.Transaction) []error // Insert a batch of transactions into local txpool + fetchTxs func(string, []common.Hash) error // Retrieves a set of txs from a remote peer + dropPeer func(string) // Drops a peer in case of announcement violation step chan struct{} // Notification channel when the fetcher loop iterates clock mclock.Clock // Monotonic clock or simulated clock for tests @@ -183,36 +193,40 @@ type TxFetcher struct { // NewTxFetcher creates a transaction fetcher to retrieve transaction // based on hash announcements. -func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, dropPeer func(string)) *TxFetcher { - return NewTxFetcherForTests(hasTx, addTxs, fetchTxs, dropPeer, mclock.System{}, time.Now, nil) +// Chain can be nil to disable on-chain checks. +func NewTxFetcher(chain *core.BlockChain, validateMeta func(common.Hash, byte) error, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, dropPeer func(string)) *TxFetcher { + return NewTxFetcherForTests(chain, validateMeta, addTxs, fetchTxs, dropPeer, mclock.System{}, time.Now, nil) } // NewTxFetcherForTests is a testing method to mock out the realtime clock with // a simulated version and the internal randomness with a deterministic one. +// Chain can be nil to disable on-chain checks. func NewTxFetcherForTests( - hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, dropPeer func(string), + chain *core.BlockChain, validateMeta func(common.Hash, byte) error, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, dropPeer func(string), clock mclock.Clock, realTime func() time.Time, rand *mrand.Rand) *TxFetcher { return &TxFetcher{ - notify: make(chan *txAnnounce), - cleanup: make(chan *txDelivery), - drop: make(chan *txDrop), - quit: make(chan struct{}), - waitlist: make(map[common.Hash]map[string]struct{}), - waittime: make(map[common.Hash]mclock.AbsTime), - waitslots: make(map[string]map[common.Hash]*txMetadataWithSeq), - announces: make(map[string]map[common.Hash]*txMetadataWithSeq), - announced: make(map[common.Hash]map[string]struct{}), - fetching: make(map[common.Hash]string), - requests: make(map[string]*txRequest), - alternates: make(map[common.Hash]map[string]struct{}), - underpriced: lru.NewCache[common.Hash, time.Time](maxTxUnderpricedSetSize), - hasTx: hasTx, - addTxs: addTxs, - fetchTxs: fetchTxs, - dropPeer: dropPeer, - clock: clock, - realTime: realTime, - rand: rand, + notify: make(chan *txAnnounce), + cleanup: make(chan *txDelivery), + drop: make(chan *txDrop), + quit: make(chan struct{}), + waitlist: make(map[common.Hash]map[string]struct{}), + waittime: make(map[common.Hash]mclock.AbsTime), + waitslots: make(map[string]map[common.Hash]*txMetadataWithSeq), + announces: make(map[string]map[common.Hash]*txMetadataWithSeq), + announced: make(map[common.Hash]map[string]struct{}), + fetching: make(map[common.Hash]string), + requests: make(map[string]*txRequest), + alternates: make(map[common.Hash]map[string]struct{}), + underpriced: lru.NewCache[common.Hash, time.Time](maxTxUnderpricedSetSize), + txOnChainCache: lru.NewCache[common.Hash, struct{}](txOnChainCacheLimit), + chain: chain, + validateMeta: validateMeta, + addTxs: addTxs, + fetchTxs: fetchTxs, + dropPeer: dropPeer, + clock: clock, + realTime: realTime, + rand: rand, } } @@ -232,25 +246,40 @@ func (f *TxFetcher) Notify(peer string, types []byte, sizes []uint32, hashes []c unknownMetas = make([]txMetadata, 0, len(hashes)) duplicate int64 + onchain int64 underpriced int64 ) for i, hash := range hashes { - switch { - case f.hasTx(hash): + err := f.validateMeta(hash, types[i]) + if errors.Is(err, txpool.ErrAlreadyKnown) { duplicate++ - case f.isKnownUnderpriced(hash): - underpriced++ - default: - unknownHashes = append(unknownHashes, hash) + continue + } + if err != nil { + continue + } - // Transaction metadata has been available since eth68, and all - // legacy eth protocols (prior to eth68) have been deprecated. - // Therefore, metadata is always expected in the announcement. - unknownMetas = append(unknownMetas, txMetadata{kind: types[i], size: sizes[i]}) + // check on chain as well (no need to check limbo separately, as chain checks limbo too) + if _, exist := f.txOnChainCache.Get(hash); exist { + onchain++ + continue } + + if f.isKnownUnderpriced(hash) { + underpriced++ + continue + } + + unknownHashes = append(unknownHashes, hash) + + // Transaction metadata has been available since eth68, and all + // legacy eth protocols (prior to eth68) have been deprecated. + // Therefore, metadata is always expected in the announcement. + unknownMetas = append(unknownMetas, txMetadata{kind: types[i], size: sizes[i]}) } txAnnounceKnownMeter.Mark(duplicate) txAnnounceUnderpricedMeter.Mark(underpriced) + txAnnounceOnchainMeter.Mark(onchain) // If anything's left to announce, push it into the internal loop if len(unknownHashes) == 0 { @@ -285,6 +314,7 @@ func (f *TxFetcher) Enqueue(peer string, txs []*types.Transaction, direct bool) knownMeter = txReplyKnownMeter underpricedMeter = txReplyUnderpricedMeter otherRejectMeter = txReplyOtherRejectMeter + violation error ) if !direct { inMeter = txBroadcastInMeter @@ -331,6 +361,12 @@ func (f *TxFetcher) Enqueue(peer string, txs []*types.Transaction, direct bool) case errors.Is(err, txpool.ErrUnderpriced) || errors.Is(err, txpool.ErrReplaceUnderpriced) || errors.Is(err, txpool.ErrTxGasPriceTooLow): underpriced++ + case errors.Is(err, txpool.ErrKZGVerificationError): + // KZG verification failed, terminate transaction processing immediately. + // Since KZG verification is computationally expensive, this acts as a + // defensive measure against potential DoS attacks. + violation = err + default: otherreject++ } @@ -339,19 +375,28 @@ func (f *TxFetcher) Enqueue(peer string, txs []*types.Transaction, direct bool) kind: batch[j].Type(), size: uint32(batch[j].Size()), }) + // Terminate the transaction processing if violation is encountered. All + // the remaining transactions in response will be silently discarded. + if violation != nil { + break + } } knownMeter.Mark(duplicate) underpricedMeter.Mark(underpriced) otherRejectMeter.Mark(otherreject) // If 'other reject' is >25% of the deliveries in any batch, sleep a bit. - if otherreject > addTxsBatchSize/4 { + if otherreject > int64((len(batch)+3)/4) { + log.Debug("Peer delivering stale or invalid transactions", "peer", peer, "rejected", otherreject) time.Sleep(200 * time.Millisecond) - log.Debug("Peer delivering stale transactions", "peer", peer, "rejected", otherreject) + } + // If we encountered a protocol violation, disconnect this peer. + if violation != nil { + break } } select { - case f.cleanup <- &txDelivery{origin: peer, hashes: added, metas: metas, direct: direct}: + case f.cleanup <- &txDelivery{origin: peer, hashes: added, metas: metas, direct: direct, violation: violation}: return nil case <-f.quit: return errTerminated @@ -388,7 +433,20 @@ func (f *TxFetcher) loop() { waitTrigger = make(chan struct{}, 1) timeoutTrigger = make(chan struct{}, 1) + + oldHead *types.Header ) + + // Subscribe to chain events to know when transactions are added to chain + var headEventCh chan core.ChainEvent + if f.chain != nil { + headEventCh = make(chan core.ChainEvent, 10) + sub := f.chain.SubscribeChainEvent(headEventCh) + if sub != nil { + defer sub.Unsubscribe() + } + } + for { select { case ann := <-f.notify: @@ -746,6 +804,11 @@ func (f *TxFetcher) loop() { // Something was delivered, try to reschedule requests f.scheduleFetches(timeoutTimer, timeoutTrigger, nil) // Partial delivery may enable others to deliver too } + // If we encountered a protocol violation, disconnect the peer + if delivery.violation != nil { + log.Warn("Disconnect peer for protocol violation", "peer", delivery.origin, "error", delivery.violation) + f.dropPeer(delivery.origin) + } case drop := <-f.drop: // A peer was dropped, remove all traces of it @@ -808,6 +871,21 @@ func (f *TxFetcher) loop() { f.rescheduleTimeout(timeoutTimer, timeoutTrigger) } + case ev := <-headEventCh: + // New head(s) added + newHead := ev.Header + if oldHead != nil && newHead.ParentHash != oldHead.Hash() { + // Reorg or setHead detected, clear the cache. We could be smarter here and + // only remove/add the diff, but this is simpler and not being exact here + // only results in a few more fetches. + f.txOnChainCache.Purge() + } + oldHead = newHead + // Add all transactions from the new block to the on-chain cache + for _, tx := range ev.Transactions { + f.txOnChainCache.Add(tx.Hash(), struct{}{}) + } + case <-f.quit: return } @@ -914,7 +992,7 @@ func (f *TxFetcher) scheduleFetches(timer *mclock.Timer, timeout chan struct{}, return // continue in the for-each } var ( - hashes = make([]common.Hash, 0, maxTxRetrievals) + hashes []common.Hash bytes uint64 ) f.forEachAnnounce(f.announces[peer], func(hash common.Hash, meta txMetadata) bool { @@ -931,6 +1009,9 @@ func (f *TxFetcher) scheduleFetches(timer *mclock.Timer, timeout chan struct{}, f.alternates[hash] = f.announced[hash] delete(f.announced, hash) + if hashes == nil { + hashes = make([]common.Hash, 0, maxTxRetrievals) + } // Accumulate the hash and stop if the limit was reached hashes = append(hashes, hash) if len(hashes) >= maxTxRetrievals { diff --git a/eth/fetcher/tx_fetcher_test.go b/eth/fetcher/tx_fetcher_test.go index bb41f6293202..6c2719631e86 100644 --- a/eth/fetcher/tx_fetcher_test.go +++ b/eth/fetcher/tx_fetcher_test.go @@ -17,6 +17,7 @@ package fetcher import ( + "crypto/sha256" "errors" "math/big" "math/rand" @@ -28,7 +29,10 @@ import ( "github.com/ethereum/go-ethereum/common/mclock" "github.com/ethereum/go-ethereum/core/txpool" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/kzg4844" "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" ) var ( @@ -83,6 +87,20 @@ type txFetcherTest struct { steps []interface{} } +// newTestTxFetcher creates a tx fetcher with noop callbacks, simulated clock, +// and deterministic randomness. +func newTestTxFetcher() *TxFetcher { + return NewTxFetcher( + nil, + func(common.Hash, byte) error { return nil }, + func(txs []*types.Transaction) []error { + return make([]error, len(txs)) + }, + func(string, []common.Hash) error { return nil }, + nil, + ) +} + // Tests that transaction announcements with associated metadata are added to a // waitlist, and none of them are scheduled for retrieval until the wait expires. // @@ -91,14 +109,7 @@ type txFetcherTest struct { // with all the useless extra fields. func TestTransactionFetcherWaiting(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Initial announcement to get something into the waitlist doTxNotify{peer: "A", hashes: []common.Hash{{0x01}, {0x02}}, types: []byte{types.LegacyTxType, types.LegacyTxType}, sizes: []uint32{111, 222}}, @@ -293,14 +304,7 @@ func TestTransactionFetcherWaiting(t *testing.T) { // already scheduled. func TestTransactionFetcherSkipWaiting(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{ @@ -383,14 +387,7 @@ func TestTransactionFetcherSkipWaiting(t *testing.T) { // and subsequent announces block or get allotted to someone else. func TestTransactionFetcherSingletonRequesting(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{peer: "A", hashes: []common.Hash{{0x01}, {0x02}}, types: []byte{types.LegacyTxType, types.LegacyTxType}, sizes: []uint32{111, 222}}, @@ -489,15 +486,12 @@ func TestTransactionFetcherFailedRescheduling(t *testing.T) { proceed := make(chan struct{}) testTransactionFetcherParallel(t, txFetcherTest{ init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(origin string, hashes []common.Hash) error { - <-proceed - return errors.New("peer disconnected") - }, - nil, - ) + f := newTestTxFetcher() + f.fetchTxs = func(origin string, hashes []common.Hash) error { + <-proceed + return errors.New("peer disconnected") + } + return f }, steps: []interface{}{ // Push an initial announcement through to the scheduled stage @@ -572,16 +566,7 @@ func TestTransactionFetcherFailedRescheduling(t *testing.T) { // are cleaned up. func TestTransactionFetcherCleanup(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{peer: "A", hashes: []common.Hash{testTxsHashes[0]}, types: []byte{testTxs[0].Type()}, sizes: []uint32{uint32(testTxs[0].Size())}}, @@ -616,16 +601,7 @@ func TestTransactionFetcherCleanup(t *testing.T) { // this was a bug)). func TestTransactionFetcherCleanupEmpty(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{peer: "A", hashes: []common.Hash{testTxsHashes[0]}, types: []byte{testTxs[0].Type()}, sizes: []uint32{uint32(testTxs[0].Size())}}, @@ -659,16 +635,7 @@ func TestTransactionFetcherCleanupEmpty(t *testing.T) { // different peer, or self if they are after the cutoff point. func TestTransactionFetcherMissingRescheduling(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{peer: "A", @@ -720,16 +687,7 @@ func TestTransactionFetcherMissingRescheduling(t *testing.T) { // delivered, the peer gets properly cleaned out from the internal state. func TestTransactionFetcherMissingCleanup(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{peer: "A", @@ -769,16 +727,7 @@ func TestTransactionFetcherMissingCleanup(t *testing.T) { // Tests that transaction broadcasts properly clean up announcements. func TestTransactionFetcherBroadcasts(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Set up three transactions to be in different stats, waiting, queued and fetching doTxNotify{peer: "A", hashes: []common.Hash{testTxsHashes[0]}, types: []byte{testTxs[0].Type()}, sizes: []uint32{uint32(testTxs[0].Size())}}, @@ -825,14 +774,7 @@ func TestTransactionFetcherBroadcasts(t *testing.T) { // Tests that the waiting list timers properly reset and reschedule. func TestTransactionFetcherWaitTimerResets(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ doTxNotify{peer: "A", hashes: []common.Hash{{0x01}}, types: []byte{types.LegacyTxType}, sizes: []uint32{111}}, isWaiting(map[string][]announce{ @@ -895,16 +837,7 @@ func TestTransactionFetcherWaitTimerResets(t *testing.T) { // out and be re-scheduled for someone else. func TestTransactionFetcherTimeoutRescheduling(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Push an initial announcement through to the scheduled stage doTxNotify{ @@ -973,14 +906,7 @@ func TestTransactionFetcherTimeoutRescheduling(t *testing.T) { // Tests that the fetching timeout timers properly reset and reschedule. func TestTransactionFetcherTimeoutTimerResets(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ doTxNotify{peer: "A", hashes: []common.Hash{{0x01}}, types: []byte{types.LegacyTxType}, sizes: []uint32{111}}, doWait{time: txArriveTimeout, step: true}, @@ -1051,14 +977,7 @@ func TestTransactionFetcherRateLimiting(t *testing.T) { }) } testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Announce all the transactions, wait a bit and ensure only a small // percentage gets requested @@ -1081,14 +1000,7 @@ func TestTransactionFetcherRateLimiting(t *testing.T) { // be requested at a time, to keep the responses below a reasonable level. func TestTransactionFetcherBandwidthLimiting(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Announce mid size transactions from A to verify that multiple // ones can be piled into a single request. @@ -1198,14 +1110,7 @@ func TestTransactionFetcherDoSProtection(t *testing.T) { }) } testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Announce half of the transaction and wait for them to be scheduled doTxNotify{peer: "A", hashes: hashesA[:maxTxAnnounces/2], types: typesA[:maxTxAnnounces/2], sizes: sizesA[:maxTxAnnounces/2]}, @@ -1266,24 +1171,21 @@ func TestTransactionFetcherDoSProtection(t *testing.T) { func TestTransactionFetcherUnderpricedDedup(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - errs := make([]error, len(txs)) - for i := 0; i < len(errs); i++ { - if i%3 == 0 { - errs[i] = txpool.ErrUnderpriced - } else if i%3 == 1 { - errs[i] = txpool.ErrReplaceUnderpriced - } else { - errs[i] = txpool.ErrTxGasPriceTooLow - } + f := newTestTxFetcher() + f.addTxs = func(txs []*types.Transaction) []error { + errs := make([]error, len(txs)) + for i := 0; i < len(errs); i++ { + if i%3 == 0 { + errs[i] = txpool.ErrUnderpriced + } else if i%3 == 1 { + errs[i] = txpool.ErrReplaceUnderpriced + } else { + errs[i] = txpool.ErrTxGasPriceTooLow } - return errs - }, - func(string, []common.Hash) error { return nil }, - nil, - ) + } + return errs + } + return f }, steps: []interface{}{ // Deliver a transaction through the fetcher, but reject as underpriced @@ -1367,18 +1269,15 @@ func TestTransactionFetcherUnderpricedDoSProtection(t *testing.T) { } testTransactionFetcher(t, txFetcherTest{ init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - errs := make([]error, len(txs)) - for i := 0; i < len(errs); i++ { - errs[i] = txpool.ErrUnderpriced - } - return errs - }, - func(string, []common.Hash) error { return nil }, - nil, - ) + f := newTestTxFetcher() + f.addTxs = func(txs []*types.Transaction) []error { + errs := make([]error, len(txs)) + for i := 0; i < len(errs); i++ { + errs[i] = txpool.ErrUnderpriced + } + return errs + } + return f }, steps: append(steps, []interface{}{ // The preparation of the test has already been done in `steps`, add the last check @@ -1398,16 +1297,7 @@ func TestTransactionFetcherUnderpricedDoSProtection(t *testing.T) { // Tests that unexpected deliveries don't corrupt the internal state. func TestTransactionFetcherOutOfBoundDeliveries(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Deliver something out of the blue isWaiting(nil), @@ -1457,16 +1347,7 @@ func TestTransactionFetcherOutOfBoundDeliveries(t *testing.T) { // live or dangling stages. func TestTransactionFetcherDrop(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Set up a few hashes into various stages doTxNotify{peer: "A", hashes: []common.Hash{{0x01}}, types: []byte{types.LegacyTxType}, sizes: []uint32{111}}, @@ -1531,16 +1412,7 @@ func TestTransactionFetcherDrop(t *testing.T) { // available peer. func TestTransactionFetcherDropRescheduling(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Set up a few hashes into various stages doTxNotify{peer: "A", hashes: []common.Hash{{0x01}}, types: []byte{types.LegacyTxType}, sizes: []uint32{111}}, @@ -1578,14 +1450,9 @@ func TestInvalidAnnounceMetadata(t *testing.T) { drop := make(chan string, 2) testTransactionFetcherParallel(t, txFetcherTest{ init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - func(peer string) { drop <- peer }, - ) + f := newTestTxFetcher() + f.dropPeer = func(peer string) { drop <- peer } + return f }, steps: []interface{}{ // Initial announcement to get something into the waitlist @@ -1660,16 +1527,7 @@ func TestInvalidAnnounceMetadata(t *testing.T) { // announced one. func TestTransactionFetcherFuzzCrash01(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Get a transaction into fetching mode and make it dangling with a broadcast doTxNotify{peer: "A", hashes: []common.Hash{testTxsHashes[0]}, types: []byte{testTxs[0].Type()}, sizes: []uint32{uint32(testTxs[0].Size())}}, @@ -1688,16 +1546,7 @@ func TestTransactionFetcherFuzzCrash01(t *testing.T) { // concurrently announced one. func TestTransactionFetcherFuzzCrash02(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Get a transaction into fetching mode and make it dangling with a broadcast doTxNotify{peer: "A", hashes: []common.Hash{testTxsHashes[0]}, types: []byte{testTxs[0].Type()}, sizes: []uint32{uint32(testTxs[0].Size())}}, @@ -1718,16 +1567,7 @@ func TestTransactionFetcherFuzzCrash02(t *testing.T) { // with a concurrent notify. func TestTransactionFetcherFuzzCrash03(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Get a transaction into fetching mode and make it dangling with a broadcast doTxNotify{ @@ -1758,17 +1598,12 @@ func TestTransactionFetcherFuzzCrash04(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { - <-proceed - return errors.New("peer disconnected") - }, - nil, - ) + f := newTestTxFetcher() + f.fetchTxs = func(string, []common.Hash) error { + <-proceed + return errors.New("peer disconnected") + } + return f }, steps: []interface{}{ // Get a transaction into fetching mode and make it dangling with a broadcast @@ -1792,14 +1627,7 @@ func TestTransactionFetcherFuzzCrash04(t *testing.T) { // once they are announced in the network. func TestBlobTransactionAnnounce(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - nil, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ // Initial announcement to get something into the waitlist doTxNotify{peer: "A", hashes: []common.Hash{{0x01}, {0x02}}, types: []byte{types.LegacyTxType, types.LegacyTxType}, sizes: []uint32{111, 222}}, @@ -1860,16 +1688,7 @@ func TestBlobTransactionAnnounce(t *testing.T) { func TestTransactionFetcherDropAlternates(t *testing.T) { testTransactionFetcherParallel(t, txFetcherTest{ - init: func() *TxFetcher { - return NewTxFetcher( - func(common.Hash) bool { return false }, - func(txs []*types.Transaction) []error { - return make([]error, len(txs)) - }, - func(string, []common.Hash) error { return nil }, - nil, - ) - }, + init: newTestTxFetcher, steps: []interface{}{ doTxNotify{peer: "A", hashes: []common.Hash{testTxsHashes[0]}, types: []byte{testTxs[0].Type()}, sizes: []uint32{uint32(testTxs[0].Size())}}, doWait{time: txArriveTimeout, step: true}, @@ -1908,6 +1727,134 @@ func TestTransactionFetcherDropAlternates(t *testing.T) { }) } +func TestTransactionFetcherWrongMetadata(t *testing.T) { + testTransactionFetcherParallel(t, txFetcherTest{ + init: func() *TxFetcher { + f := newTestTxFetcher() + f.validateMeta = func(name common.Hash, kind byte) error { + switch kind { + case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType, types.BlobTxType, types.SetCodeTxType: + return nil + } + return types.ErrTxTypeNotSupported + } + return f + }, + steps: []interface{}{ + doTxNotify{peer: "A", hashes: []common.Hash{{0x01}, {0x02}}, types: []byte{0xff, types.LegacyTxType}, sizes: []uint32{111, 222}}, + isWaiting(map[string][]announce{ + "A": { + {common.Hash{0x02}, types.LegacyTxType, 222}, + }, + }), + }, + }) +} + +func makeInvalidBlobTx() *types.Transaction { + key, _ := crypto.GenerateKey() + blob := &kzg4844.Blob{byte(0xa)} + commitment, _ := kzg4844.BlobToCommitment(blob) + blobHash := kzg4844.CalcBlobHashV1(sha256.New(), &commitment) + cellProof, _ := kzg4844.ComputeCellProofs(blob) + + // Mutate the cell proof + cellProof[0][0] = 0x0 + + blobtx := &types.BlobTx{ + ChainID: uint256.MustFromBig(params.MainnetChainConfig.ChainID), + Nonce: 0, + GasTipCap: uint256.NewInt(100), + GasFeeCap: uint256.NewInt(200), + Gas: 21000, + BlobFeeCap: uint256.NewInt(200), + BlobHashes: []common.Hash{blobHash}, + Value: uint256.NewInt(100), + Sidecar: types.NewBlobTxSidecar(types.BlobSidecarVersion1, []kzg4844.Blob{*blob}, []kzg4844.Commitment{commitment}, cellProof), + } + return types.MustSignNewTx(key, types.LatestSigner(params.MainnetChainConfig), blobtx) +} + +// This test ensures that the peer will be disconnected for protocol violation +// and all its internal traces should be removed properly. +func TestTransactionProtocolViolation(t *testing.T) { + //log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelDebug, true))) + + var ( + badTx = makeInvalidBlobTx() + drop = make(chan struct{}, 1) + ) + testTransactionFetcherParallel(t, txFetcherTest{ + init: func() *TxFetcher { + f := newTestTxFetcher() + f.addTxs = func(txs []*types.Transaction) []error { + var errs []error + for range txs { + errs = append(errs, txpool.ErrKZGVerificationError) + } + return errs + } + f.dropPeer = func(string) { drop <- struct{}{} } + return f + }, + steps: []interface{}{ + // Initial announcement to get something into the waitlist + doTxNotify{ + peer: "A", + hashes: []common.Hash{testTxs[0].Hash(), badTx.Hash(), testTxs[1].Hash()}, + types: []byte{types.LegacyTxType, types.BlobTxType, types.LegacyTxType}, + sizes: []uint32{uint32(testTxs[0].Size()), uint32(badTx.Size()), uint32(testTxs[1].Size())}, + }, + isWaiting(map[string][]announce{ + "A": { + {testTxs[0].Hash(), types.LegacyTxType, uint32(testTxs[0].Size())}, + {badTx.Hash(), types.BlobTxType, uint32(badTx.Size())}, + {testTxs[1].Hash(), types.LegacyTxType, uint32(testTxs[1].Size())}, + }, + }), + doWait{time: 0, step: true}, // zero time, but the blob fetching should be scheduled + + isWaiting(map[string][]announce{ + "A": { + {testTxs[0].Hash(), types.LegacyTxType, uint32(testTxs[0].Size())}, + {testTxs[1].Hash(), types.LegacyTxType, uint32(testTxs[1].Size())}, + }, + }), + isScheduled{ + tracking: map[string][]announce{ + "A": { + {badTx.Hash(), types.BlobTxType, uint32(badTx.Size())}, + }, + }, + fetching: map[string][]common.Hash{ + "A": {badTx.Hash()}, + }, + }, + + doTxEnqueue{ + peer: "A", + txs: []*types.Transaction{badTx}, + direct: true, + }, + // Some internal traces are left and will be cleaned by a following drop + // operation. + isWaiting(map[string][]announce{ + "A": { + {testTxs[0].Hash(), types.LegacyTxType, uint32(testTxs[0].Size())}, + {testTxs[1].Hash(), types.LegacyTxType, uint32(testTxs[1].Size())}, + }, + }), + isScheduled{}, + doFunc(func() { <-drop }), + + // Simulate the drop operation emitted by the server + doDrop("A"), + isWaiting(nil), + isScheduled{nil, nil, nil}, + }, + }) +} + func testTransactionFetcherParallel(t *testing.T, tt txFetcherTest) { t.Parallel() testTransactionFetcher(t, tt) @@ -2245,7 +2192,8 @@ func TestTransactionForgotten(t *testing.T) { } fetcher := NewTxFetcherForTests( - func(common.Hash) bool { return false }, + nil, + func(common.Hash, byte) error { return nil }, func(txs []*types.Transaction) []error { errs := make([]error, len(txs)) for i := 0; i < len(errs); i++ { diff --git a/eth/filters/api.go b/eth/filters/api.go index 4ed7e5be0ad5..e4ade96598d6 100644 --- a/eth/filters/api.go +++ b/eth/filters/api.go @@ -89,6 +89,7 @@ type FilterAPI struct { filters map[rpc.ID]*filter timeout time.Duration logQueryLimit int + rangeLimit uint64 } // NewFilterAPI returns a new FilterAPI instance. @@ -99,6 +100,7 @@ func NewFilterAPI(system *FilterSystem) *FilterAPI { filters: make(map[rpc.ID]*filter), timeout: system.cfg.Timeout, logQueryLimit: system.cfg.LogQueryLimit, + rangeLimit: system.cfg.RangeLimit, } go api.timeoutLoop(system.cfg.Timeout) @@ -185,11 +187,13 @@ func (api *FilterAPI) NewPendingTransactions(ctx context.Context, fullTx *bool) return &rpc.Subscription{}, rpc.ErrNotificationsUnsupported } - rpcSub := notifier.CreateSubscription() + var ( + rpcSub = notifier.CreateSubscription() + txs = make(chan []*types.Transaction, 128) + pendingTxSub = api.events.SubscribePendingTxs(txs) + ) go func() { - txs := make(chan []*types.Transaction, 128) - pendingTxSub := api.events.SubscribePendingTxs(txs) defer pendingTxSub.Unsubscribe() chainConfig := api.sys.backend.ChainConfig() @@ -258,11 +262,13 @@ func (api *FilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, error) { return &rpc.Subscription{}, rpc.ErrNotificationsUnsupported } - rpcSub := notifier.CreateSubscription() + var ( + rpcSub = notifier.CreateSubscription() + headers = make(chan *types.Header) + headersSub = api.events.SubscribeNewHeads(headers) + ) go func() { - headers := make(chan *types.Header) - headersSub := api.events.SubscribeNewHeads(headers) defer headersSub.Unsubscribe() for { @@ -479,7 +485,7 @@ func (api *FilterAPI) GetLogs(ctx context.Context, crit FilterCriteria) ([]*type return nil, &history.PrunedHistoryError{} } // Construct the range filter - filter = api.sys.NewRangeFilter(begin, end, crit.Addresses, crit.Topics) + filter = api.sys.NewRangeFilter(begin, end, crit.Addresses, crit.Topics, api.rangeLimit) } // Run the filter and return all the logs @@ -530,8 +536,11 @@ func (api *FilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*types.Lo if f.crit.ToBlock != nil { end = f.crit.ToBlock.Int64() } + if begin >= 0 && begin < int64(api.events.backend.HistoryPruningCutoff()) { + return nil, &history.PrunedHistoryError{} + } // Construct the range filter - filter = api.sys.NewRangeFilter(begin, end, f.crit.Addresses, f.crit.Topics) + filter = api.sys.NewRangeFilter(begin, end, f.crit.Addresses, f.crit.Topics, api.rangeLimit) } // Run the filter and return all the logs logs, err := filter.Logs(ctx) diff --git a/eth/filters/filter.go b/eth/filters/filter.go index 10afc84fe995..f31b9568cd02 100644 --- a/eth/filters/filter.go +++ b/eth/filters/filter.go @@ -44,15 +44,17 @@ type Filter struct { begin, end int64 // Range interval if filtering multiple blocks rangeLogsTestHook chan rangeLogsTestEvent + rangeLimit uint64 } // NewRangeFilter creates a new filter which uses a bloom filter on blocks to // figure out whether a particular block is interesting or not. -func (sys *FilterSystem) NewRangeFilter(begin, end int64, addresses []common.Address, topics [][]common.Hash) *Filter { +func (sys *FilterSystem) NewRangeFilter(begin, end int64, addresses []common.Address, topics [][]common.Hash, rangeLimit uint64) *Filter { // Create a generic filter and convert it into a range filter filter := newFilter(sys, addresses, topics) filter.begin = begin filter.end = end + filter.rangeLimit = rangeLimit return filter } @@ -143,6 +145,9 @@ func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) { if err != nil { return nil, err } + if f.rangeLimit != 0 && (end-begin) > f.rangeLimit { + return nil, invalidParamsErr("exceed maximum block range %d", f.rangeLimit) + } return f.rangeLogs(ctx, begin, end) } @@ -384,7 +389,7 @@ func (f *Filter) rangeLogs(ctx context.Context, firstBlock, lastBlock uint64) ([ } if firstBlock > lastBlock { - return nil, nil + return nil, errInvalidBlockRange } mb := f.sys.backend.NewMatcherBackend() defer mb.Close() @@ -494,7 +499,7 @@ func (f *Filter) checkMatches(ctx context.Context, header *types.Header) ([]*typ // filterLogs creates a slice of logs matching the given criteria. func filterLogs(logs []*types.Log, fromBlock, toBlock *big.Int, addresses []common.Address, topics [][]common.Hash) []*types.Log { - var check = func(log *types.Log) bool { + check := func(log *types.Log) bool { if fromBlock != nil && fromBlock.Int64() >= 0 && fromBlock.Uint64() > log.BlockNumber { return false } diff --git a/eth/filters/filter_system.go b/eth/filters/filter_system.go index 8b9bce47b911..1f92c4e36fc8 100644 --- a/eth/filters/filter_system.go +++ b/eth/filters/filter_system.go @@ -44,6 +44,7 @@ type Config struct { LogCacheSize int // maximum number of cached blocks (default: 32) Timeout time.Duration // how long filters stay active (default: 5min) LogQueryLimit int // maximum number of addresses allowed in filter criteria (default: 1000) + RangeLimit uint64 // maximum block range allowed in filter criteria (default: 0) } func (cfg Config) withDefaults() Config { diff --git a/eth/filters/filter_system_test.go b/eth/filters/filter_system_test.go index e5a1a2b25f1b..6f97d5b66470 100644 --- a/eth/filters/filter_system_test.go +++ b/eth/filters/filter_system_test.go @@ -546,7 +546,7 @@ func TestExceedLogQueryLimit(t *testing.T) { } ) - _, err := gspec.Commit(db, triedb.NewDatabase(db, nil)) + _, err := gspec.Commit(db, triedb.NewDatabase(db, nil), nil) if err != nil { t.Fatal(err) } diff --git a/eth/filters/filter_test.go b/eth/filters/filter_test.go index edec3e027f94..c133438c64be 100644 --- a/eth/filters/filter_test.go +++ b/eth/filters/filter_test.go @@ -19,6 +19,7 @@ package filters import ( "context" "encoding/json" + "errors" "math/big" "strings" "testing" @@ -109,7 +110,7 @@ func benchmarkFilters(b *testing.B, history uint64, noHistory bool) { backend.startFilterMaps(history, noHistory, filtermaps.DefaultParams) defer backend.stopFilterMaps() - filter := sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{addr1, addr2, addr3, addr4}, nil) + filter := sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{addr1, addr2, addr3, addr4}, nil, 0) for b.Loop() { filter.begin = 0 logs, _ := filter.Logs(context.Background()) @@ -205,7 +206,7 @@ func testFilters(t *testing.T, history uint64, noHistory bool) { // Hack: GenerateChainWithGenesis creates a new db. // Commit the genesis manually and use GenerateChain. - _, err = gspec.Commit(db, triedb.NewDatabase(db, nil)) + _, err = gspec.Commit(db, triedb.NewDatabase(db, nil), nil) if err != nil { t.Fatal(err) } @@ -317,70 +318,71 @@ func testFilters(t *testing.T, history uint64, noHistory bool) { want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","blockTimestamp":"0x1e","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{contract}, [][]common.Hash{{hash1, hash2, hash3, hash4}}), + f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{contract}, [][]common.Hash{{hash1, hash2, hash3, hash4}}, 0), want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xa8028c655b6423204c8edfbc339f57b042d6bec2b6a61145d76b7c08b4cccd42","transactionIndex":"0x0","blockHash":"0x24417bb49ce44cfad65da68f33b510bf2a129c0d89ccf06acb6958b8585ccf34","blockTimestamp":"0x14","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","blockTimestamp":"0x1e","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","blockTimestamp":"0x2710","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(900, 999, []common.Address{contract}, [][]common.Hash{{hash3}}), + f: sys.NewRangeFilter(900, 999, []common.Address{contract}, [][]common.Hash{{hash3}}, 0), }, { - f: sys.NewRangeFilter(990, int64(rpc.LatestBlockNumber), []common.Address{contract2}, [][]common.Hash{{hash3}}), + f: sys.NewRangeFilter(990, int64(rpc.LatestBlockNumber), []common.Address{contract2}, [][]common.Hash{{hash3}}, 0), want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x2e4620a2b426b0612ec6cad9603f466723edaed87f98c9137405dd4f7a2409ff","blockTimestamp":"0x2706","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(1, 10, []common.Address{contract}, [][]common.Hash{{hash2}, {hash1}}), + f: sys.NewRangeFilter(1, 10, []common.Address{contract}, [][]common.Hash{{hash2}, {hash1}}, 0), want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","blockTimestamp":"0x1e","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(1, 10, nil, [][]common.Hash{{hash1, hash2}}), + f: sys.NewRangeFilter(1, 10, nil, [][]common.Hash{{hash1, hash2}}, 0), want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xa8028c655b6423204c8edfbc339f57b042d6bec2b6a61145d76b7c08b4cccd42","transactionIndex":"0x0","blockHash":"0x24417bb49ce44cfad65da68f33b510bf2a129c0d89ccf06acb6958b8585ccf34","blockTimestamp":"0x14","logIndex":"0x0","removed":false},{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x2","transactionHash":"0xdba3e2ea9a7d690b722d70ee605fd67ba4c00d1d3aecd5cf187a7b92ad8eb3df","transactionIndex":"0x1","blockHash":"0x24417bb49ce44cfad65da68f33b510bf2a129c0d89ccf06acb6958b8585ccf34","blockTimestamp":"0x14","logIndex":"0x1","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332","0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x3","transactionHash":"0xdefe471992a07a02acdfbe33edaae22fbb86d7d3cec3f1b8e4e77702fb3acc1d","transactionIndex":"0x0","blockHash":"0x7a7556792ca7d37882882e2b001fe14833eaf81c2c7f865c9c771ec37a024f6b","blockTimestamp":"0x1e","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}}), + f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}}, 0), }, { - f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{common.BytesToAddress([]byte("failmenow"))}, nil), + f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), []common.Address{common.BytesToAddress([]byte("failmenow"))}, nil, 0), }, { - f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}, {hash1}}), + f: sys.NewRangeFilter(0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}, {hash1}}, 0), }, { - f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil, 0), want: `[{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","blockTimestamp":"0x2710","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.LatestBlockNumber), nil, nil, 0), want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x2e4620a2b426b0612ec6cad9603f466723edaed87f98c9137405dd4f7a2409ff","blockTimestamp":"0x2706","logIndex":"0x0","removed":false},{"address":"0xfe00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x3e8","transactionHash":"0x9a87842100a638dfa5da8842b4beda691d2fd77b0c84b57f24ecfa9fb208f747","transactionIndex":"0x0","blockHash":"0xb360bad5265261c075ece02d3bf0e39498a6a76310482cdfd90588748e6c5ee0","blockTimestamp":"0x2710","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.FinalizedBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil, 0), want: `[{"address":"0xff00000000000000000000000000000000000000","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x3e7","transactionHash":"0x53e3675800c6908424b61b35a44e51ca4c73ca603e58a65b32c67968b4f42200","transactionIndex":"0x0","blockHash":"0x2e4620a2b426b0612ec6cad9603f466723edaed87f98c9137405dd4f7a2409ff","blockTimestamp":"0x2706","logIndex":"0x0","removed":false}]`, }, { - f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.FinalizedBlockNumber), nil, nil, 0), + err: errInvalidBlockRange.Error(), }, { - f: sys.NewRangeFilter(int64(rpc.SafeBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.SafeBlockNumber), int64(rpc.LatestBlockNumber), nil, nil, 0), err: "safe header not found", }, { - f: sys.NewRangeFilter(int64(rpc.SafeBlockNumber), int64(rpc.SafeBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.SafeBlockNumber), int64(rpc.SafeBlockNumber), nil, nil, 0), err: "safe header not found", }, { - f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.SafeBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.SafeBlockNumber), nil, nil, 0), err: "safe header not found", }, { - f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil, 0), err: errPendingLogsUnsupported.Error(), }, { - f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.PendingBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.LatestBlockNumber), int64(rpc.PendingBlockNumber), nil, nil, 0), err: errPendingLogsUnsupported.Error(), }, { - f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.LatestBlockNumber), nil, nil), + f: sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.LatestBlockNumber), nil, nil, 0), err: errPendingLogsUnsupported.Error(), }, } { @@ -403,7 +405,7 @@ func testFilters(t *testing.T, history uint64, noHistory bool) { } t.Run("timeout", func(t *testing.T) { - f := sys.NewRangeFilter(0, rpc.LatestBlockNumber.Int64(), nil, nil) + f := sys.NewRangeFilter(0, rpc.LatestBlockNumber.Int64(), nil, nil, 0) ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Hour)) defer cancel() _, err := f.Logs(ctx) @@ -426,7 +428,7 @@ func TestRangeLogs(t *testing.T) { BaseFee: big.NewInt(params.InitialBaseFee), } ) - _, err := gspec.Commit(db, triedb.NewDatabase(db, nil)) + _, err := gspec.Commit(db, triedb.NewDatabase(db, nil), nil) if err != nil { t.Fatal(err) } @@ -464,7 +466,7 @@ func TestRangeLogs(t *testing.T) { newFilter := func(begin, end int64) { testCase++ event = 0 - filter = sys.NewRangeFilter(begin, end, addresses, nil) + filter = sys.NewRangeFilter(begin, end, addresses, nil, 0) filter.rangeLogsTestHook = make(chan rangeLogsTestEvent) go func(filter *Filter) { filter.Logs(context.Background()) @@ -601,3 +603,51 @@ func TestRangeLogs(t *testing.T) { expEvent(rangeLogsTestReorg, 400, 901) expEvent(rangeLogsTestDone, 0, 0) } + +func TestRangeLimit(t *testing.T) { + db := rawdb.NewMemoryDatabase() + backend, sys := newTestFilterSystem(db, Config{}) + defer db.Close() + + gspec := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{}, + BaseFee: big.NewInt(params.InitialBaseFee), + } + _, err := gspec.Commit(db, triedb.NewDatabase(db, nil), nil) + if err != nil { + t.Fatal(err) + } + chain, _ := core.GenerateChain(gspec.Config, gspec.ToBlock(), ethash.NewFaker(), db, 10, func(i int, gen *core.BlockGen) {}) + options := core.DefaultConfig().WithStateScheme(rawdb.HashScheme) + options.TxLookupLimit = 0 + bc, err := core.NewBlockChain(db, gspec, ethash.NewFaker(), options) + if err != nil { + t.Fatal(err) + } + _, err = bc.InsertChain(chain) + if err != nil { + t.Fatal(err) + } + backend.startFilterMaps(0, false, filtermaps.DefaultParams) + defer backend.stopFilterMaps() + + // Set rangeLimit to 5, but request a range of 9 (end - begin = 9, from 0 to 9) + filter := sys.NewRangeFilter(0, 9, nil, nil, 5) + _, err = filter.Logs(context.Background()) + if err == nil { + t.Fatal("expected range limit error, got nil") + } + + var re rpc.Error + if errors.As(err, &re) { + if re.ErrorCode() != -32602 { + t.Fatalf("expected error code -32602, got %d", re.ErrorCode()) + } + if re.Error() != "exceed maximum block range 5" { + t.Fatalf("expected error message 'exceed maximum block range 5', got %q", re.Error()) + } + } else { + t.Fatalf("expected rpc error, got %v", err) + } +} diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index 6e79fbd62b0e..f45fc0d8c99d 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -20,17 +20,15 @@ import ( "context" "errors" "fmt" - "math" "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" - "github.com/ethereum/go-ethereum/internal/ethapi/override" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" ) // Options are the contextual parameters to execute the requested call. @@ -39,11 +37,12 @@ import ( // these together, it would be excessively hard to test. Splitting the parts out // allows testing without needing a proper live chain. type Options struct { - Config *params.ChainConfig // Chain configuration for hard fork selection - Chain core.ChainContext // Chain context to access past block hashes - Header *types.Header // Header defining the block context to execute in - State *state.StateDB // Pre-state on top of which to estimate the gas - BlockOverrides *override.BlockOverrides // Block overrides to apply during the estimation + Config *params.ChainConfig // Chain configuration for hard fork selection + Chain core.ChainContext // Chain context to access past block hashes + Header *types.Header // Header defining the block context to execute in + State *state.StateDB // Pre-state on top of which to estimate the gas + + BlobBaseFee *big.Int // BlobBaseFee optionally overrides the blob base fee in the execution context. ErrorRatio float64 // Allowed overestimation ratio for faster estimation termination } @@ -64,33 +63,24 @@ func Estimate(ctx context.Context, call *core.Message, opts *Options, gasCap uin } // Cap the maximum gas allowance according to EIP-7825 if the estimation targets Osaka - if hi > params.MaxTxGas { - blockNumber, blockTime := opts.Header.Number, opts.Header.Time - if opts.BlockOverrides != nil { - if opts.BlockOverrides.Number != nil { - blockNumber = opts.BlockOverrides.Number.ToInt() - } - if opts.BlockOverrides.Time != nil { - blockTime = uint64(*opts.BlockOverrides.Time) - } - } - if opts.Config.IsOsaka(blockNumber, blockTime) { - hi = params.MaxTxGas - } + isOsaka := opts.Config.IsOsaka(opts.Header.Number, opts.Header.Time) + isAmsterdam := opts.Config.IsAmsterdam(opts.Header.Number, opts.Header.Time) + if hi > params.MaxTxGas && isOsaka && !isAmsterdam { + hi = params.MaxTxGas } // Normalize the max fee per gas the call is willing to spend. - var feeCap *big.Int + var feeCap *uint256.Int if call.GasFeeCap != nil { feeCap = call.GasFeeCap } else if call.GasPrice != nil { feeCap = call.GasPrice } else { - feeCap = common.Big0 + feeCap = uint256.NewInt(0) } // Recap the highest gas limit with account's available balance. if feeCap.BitLen() != 0 { - balance := opts.State.GetBalance(call.From).ToBig() + balance := opts.State.GetBalance(call.From).Clone() available := balance if call.Value != nil { @@ -100,8 +90,8 @@ func Estimate(ctx context.Context, call *core.Message, opts *Options, gasCap uin available.Sub(available, call.Value) } if opts.Config.IsCancun(opts.Header.Number, opts.Header.Time) && len(call.BlobHashes) > 0 { - blobGasPerBlob := new(big.Int).SetInt64(params.BlobTxBlobGasPerBlob) - blobBalanceUsage := new(big.Int).SetInt64(int64(len(call.BlobHashes))) + blobGasPerBlob := uint256.NewInt(params.BlobTxBlobGasPerBlob) + blobBalanceUsage := uint256.NewInt(uint64(len(call.BlobHashes))) blobBalanceUsage.Mul(blobBalanceUsage, blobGasPerBlob) blobBalanceUsage.Mul(blobBalanceUsage, call.BlobGasFeeCap) if blobBalanceUsage.Cmp(available) >= 0 { @@ -109,13 +99,13 @@ func Estimate(ctx context.Context, call *core.Message, opts *Options, gasCap uin } available.Sub(available, blobBalanceUsage) } - allowance := new(big.Int).Div(available, feeCap) + allowance := new(uint256.Int).Div(available, feeCap) // If the allowance is larger than maximum uint64, skip checking if allowance.IsUint64() && hi > allowance.Uint64() { transfer := call.Value if transfer == nil { - transfer = new(big.Int) + transfer = new(uint256.Int) } log.Debug("Gas estimation capped by limited funds", "original", hi, "balance", balance, "sent", transfer, "maxFeePerGas", feeCap, "fundable", allowance) @@ -242,10 +232,8 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.Executio evmContext = core.NewEVMBlockContext(opts.Header, opts.Chain, nil) dirtyState = opts.State.Copy() ) - if opts.BlockOverrides != nil { - if err := opts.BlockOverrides.Apply(&evmContext); err != nil { - return nil, err - } + if opts.BlobBaseFee != nil { + evmContext.BlobBaseFee = new(big.Int).Set(opts.BlobBaseFee) } // Lower the basefee to 0 to avoid breaking EVM // invariants (basefee < feecap). @@ -256,6 +244,7 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.Executio evmContext.BlobBaseFee = new(big.Int) } evm := vm.NewEVM(evmContext, dirtyState, opts.Config, vm.Config{NoBaseFee: true}) + defer evm.Release() // Monitor the outer context and interrupt the EVM upon cancellation. To avoid // a dangling goroutine until the outer estimation finishes, create an internal @@ -268,7 +257,7 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.Executio evm.Cancel() }() // Execute the call, returning a wrapped error or the result - result, err := core.ApplyMessage(evm, call, new(core.GasPool).AddGas(math.MaxUint64)) + result, err := core.ApplyMessage(evm, call, nil) if vmerr := dirtyState.Error(); vmerr != nil { return nil, vmerr } diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go index 4fd3df742853..a922eab6750b 100644 --- a/eth/gasprice/gasprice.go +++ b/eth/gasprice/gasprice.go @@ -31,6 +31,7 @@ import ( "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rpc" + "github.com/holiman/uint256" ) const sampleNumber = 3 // Number of transactions sampled in a block @@ -257,12 +258,12 @@ func (oracle *Oracle) getBlockValues(ctx context.Context, blockNum uint64, limit sortedTxs := make([]*types.Transaction, len(txs)) copy(sortedTxs, txs) baseFee := block.BaseFee() + baseFee256 := new(uint256.Int) + if baseFee != nil { + baseFee256.SetFromBig(baseFee) + } slices.SortFunc(sortedTxs, func(a, b *types.Transaction) int { - // It's okay to discard the error because a tx would never be - // accepted into a block with an invalid effective tip. - tip1, _ := a.EffectiveGasTip(baseFee) - tip2, _ := b.EffectiveGasTip(baseFee) - return tip1.Cmp(tip2) + return a.EffectiveGasTipCmp(b, baseFee256) }) var prices []*big.Int diff --git a/eth/gasprice/gasprice_test.go b/eth/gasprice/gasprice_test.go index 02a25bc4d822..e57c6e11c51d 100644 --- a/eth/gasprice/gasprice_test.go +++ b/eth/gasprice/gasprice_test.go @@ -104,7 +104,7 @@ func (b *testBackend) GetReceipts(ctx context.Context, hash common.Hash) (types. func (b *testBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) { if b.pending { block := b.chain.GetBlockByNumber(testHead + 1) - state, _ := b.chain.StateAt(block.Root()) + state, _ := b.chain.StateAt(block.Header()) return block, b.chain.GetReceiptsByHash(block.Hash()), state } return nil, nil, nil diff --git a/eth/handler.go b/eth/handler.go index 4510dd32f0b5..76df635fb047 100644 --- a/eth/handler.go +++ b/eth/handler.go @@ -86,12 +86,15 @@ type txPool interface { // Pending should return pending transactions. // The slice should be modifiable by the caller. - Pending(filter txpool.PendingFilter) map[common.Address][]*txpool.LazyTransaction + Pending(filter txpool.PendingFilter) (map[common.Address][]*txpool.LazyTransaction, int) // SubscribeTransactions subscribes to new transaction events. The subscriber // can decide whether to receive notifications only for newly seen transactions // or also for reorged out ones. SubscribeTransactions(ch chan<- core.NewTxsEvent, reorgs bool) event.Subscription + + // FilterType returns whether the given tx type is supported by the txPool. + FilterType(kind byte) bool } // handlerConfig is the collection of initialization parameters to create a full @@ -104,7 +107,6 @@ type handlerConfig struct { Network uint64 // Network identifier to advertise Sync ethconfig.SyncMode // Whether to snap or full sync BloomCache uint64 // Megabytes to alloc for snap sync bloom - EventMux *event.TypeMux // Legacy event mux, deprecate for `feed` RequiredBlocks map[uint64]common.Hash // Hard coded map of required block hashes for sync challenges } @@ -123,7 +125,6 @@ type handler struct { peers *peerSet txBroadcastKey [16]byte - eventMux *event.TypeMux txsCh chan core.NewTxsEvent txsSub event.Subscription blockRange *blockRangeState @@ -141,14 +142,9 @@ type handler struct { // newHandler returns a handler for all Ethereum chain management protocol. func newHandler(config *handlerConfig) (*handler, error) { - // Create the protocol manager with the base fields - if config.EventMux == nil { - config.EventMux = new(event.TypeMux) // Nicety initialization for tests - } h := &handler{ nodeID: config.NodeID, networkID: config.Network, - eventMux: config.EventMux, database: config.Database, txpool: config.TxPool, chain: config.Chain, @@ -160,7 +156,7 @@ func newHandler(config *handlerConfig) (*handler, error) { handlerStartCh: make(chan struct{}), } // Construct the downloader (long sync) - h.downloader = downloader.New(config.Database, config.Sync, h.eventMux, h.chain, h.removePeer, h.enableSyncedFeatures) + h.downloader = downloader.New(config.Database, config.Sync, h.chain, h.removePeer, h.enableSyncedFeatures) // If snap sync is requested but snapshots are disabled, fail loudly if h.downloader.ConfigSyncMode() == ethconfig.SnapSync && (config.Chain.Snapshots() == nil && config.Chain.TrieDB().Scheme() == rawdb.HashScheme) { @@ -176,7 +172,16 @@ func newHandler(config *handlerConfig) (*handler, error) { addTxs := func(txs []*types.Transaction) []error { return h.txpool.Add(txs, false) } - h.txFetcher = fetcher.NewTxFetcher(h.txpool.Has, addTxs, fetchTx, h.removePeer) + validateMeta := func(tx common.Hash, kind byte) error { + if h.txpool.Has(tx) { + return txpool.ErrAlreadyKnown + } + if !h.txpool.FilterType(kind) { + return types.ErrTxTypeNotSupported + } + return nil + } + h.txFetcher = fetcher.NewTxFetcher(h.chain, validateMeta, addTxs, fetchTx, h.removePeer) return h, nil } @@ -408,7 +413,7 @@ func (h *handler) Start(maxPeers int) { // broadcast block range h.wg.Add(1) - h.blockRange = newBlockRangeState(h.chain, h.eventMux) + h.blockRange = newBlockRangeState(h.chain, h.downloader) go h.blockRangeLoop(h.blockRange) // start sync handlers @@ -495,7 +500,7 @@ func (h *handler) BroadcastTransactions(txs types.Transactions) { annCount += len(hashes) peer.AsyncSendPooledTransactionHashes(hashes) } - log.Debug("Distributed transactions", "plaintxs", len(txs)-blobTxs-largeTxs, "blobtxs", blobTxs, "largetxs", largeTxs, + log.Trace("Distributed transactions", "plaintxs", len(txs)-blobTxs-largeTxs, "blobtxs", blobTxs, "largetxs", largeTxs, "bcastpeers", len(txset), "bcastcount", directCount, "annpeers", len(annos), "anncount", annCount) } @@ -524,16 +529,19 @@ type blockRangeState struct { next atomic.Pointer[eth.BlockRangeUpdatePacket] headCh chan core.ChainHeadEvent headSub event.Subscription - syncSub *event.TypeMuxSubscription + syncCh chan downloader.SyncEvent + syncSub event.Subscription } -func newBlockRangeState(chain *core.BlockChain, typeMux *event.TypeMux) *blockRangeState { +func newBlockRangeState(chain *core.BlockChain, dl *downloader.Downloader) *blockRangeState { headCh := make(chan core.ChainHeadEvent, chainHeadChanSize) headSub := chain.SubscribeChainHeadEvent(headCh) - syncSub := typeMux.Subscribe(downloader.StartEvent{}, downloader.DoneEvent{}, downloader.FailedEvent{}) + syncCh := make(chan downloader.SyncEvent, 16) + syncSub := dl.SubscribeSyncEvents(syncCh) st := &blockRangeState{ headCh: headCh, headSub: headSub, + syncCh: syncCh, syncSub: syncSub, } st.update(chain, chain.CurrentBlock()) @@ -549,11 +557,8 @@ func (h *handler) blockRangeLoop(st *blockRangeState) { for { select { - case ev := <-st.syncSub.Chan(): - if ev == nil { - continue - } - if _, ok := ev.Data.(downloader.StartEvent); ok && h.downloader.ConfigSyncMode() == ethconfig.SnapSync { + case ev := <-st.syncCh: + if ev.Type == downloader.SyncStarted && ev.Mode == ethconfig.SnapSync { h.blockRangeWhileSnapSyncing(st) } case <-st.headCh: @@ -581,12 +586,8 @@ func (h *handler) blockRangeWhileSnapSyncing(st *blockRangeState) { h.broadcastBlockRange(st) } // back to processing head block updates when sync is done - case ev := <-st.syncSub.Chan(): - if ev == nil { - continue - } - switch ev.Data.(type) { - case downloader.FailedEvent, downloader.DoneEvent: + case ev := <-st.syncCh: + if ev.Type == downloader.SyncFailed || ev.Type == downloader.SyncCompleted { return } // ignore head updates, but exit when the subscription ends diff --git a/eth/handler_eth.go b/eth/handler_eth.go index 11742b14adad..8704a86af4bc 100644 --- a/eth/handler_eth.go +++ b/eth/handler_eth.go @@ -20,6 +20,7 @@ import ( "errors" "fmt" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth/protocols/eth" @@ -61,19 +62,42 @@ func (h *ethHandler) Handle(peer *eth.Peer, packet eth.Packet) error { return h.txFetcher.Notify(peer.ID(), packet.Types, packet.Sizes, packet.Hashes) case *eth.TransactionsPacket: - for _, tx := range *packet { - if tx.Type() == types.BlobTxType { - return errors.New("disallowed broadcast blob transaction") - } + txs, err := packet.Items() + if err != nil { + return fmt.Errorf("Transactions: %v", err) + } + if err := handleTransactions(peer, txs, true); err != nil { + return fmt.Errorf("Transactions: %v", err) } - return h.txFetcher.Enqueue(peer.ID(), *packet, false) + return h.txFetcher.Enqueue(peer.ID(), txs, false) - case *eth.PooledTransactionsResponse: - // If we receive any blob transactions missing sidecars, or with - // sidecars that don't correspond to the versioned hashes reported - // in the header, disconnect from the sending peer. - for _, tx := range *packet { - if tx.Type() == types.BlobTxType { + case *eth.PooledTransactionsPacket: + txs, err := packet.List.Items() + if err != nil { + return fmt.Errorf("PooledTransactions: %v", err) + } + if err := handleTransactions(peer, txs, false); err != nil { + return fmt.Errorf("PooledTransactions: %v", err) + } + return h.txFetcher.Enqueue(peer.ID(), txs, true) + + default: + return fmt.Errorf("unexpected eth packet type: %T", packet) + } +} + +// handleTransactions marks all given transactions as known to the peer +// and performs basic validations. +func handleTransactions(peer *eth.Peer, list []*types.Transaction, directBroadcast bool) error { + seen := make(map[common.Hash]struct{}) + for _, tx := range list { + if tx.Type() == types.BlobTxType { + if directBroadcast { + return errors.New("disallowed broadcast blob transaction") + } else { + // If we receive any blob transactions missing sidecars, or with + // sidecars that don't correspond to the versioned hashes reported + // in the header, disconnect from the sending peer. if tx.BlobTxSidecar() == nil { return errors.New("received sidecar-less blob transaction") } @@ -82,9 +106,16 @@ func (h *ethHandler) Handle(peer *eth.Peer, packet eth.Packet) error { } } } - return h.txFetcher.Enqueue(peer.ID(), *packet, true) - default: - return fmt.Errorf("unexpected eth packet type: %T", packet) + // Check for duplicates. + hash := tx.Hash() + if _, exists := seen[hash]; exists { + return fmt.Errorf("multiple copies of the same hash %v", hash) + } + seen[hash] = struct{}{} + + // Mark as known. + peer.MarkTransaction(hash) } + return nil } diff --git a/eth/handler_eth_test.go b/eth/handler_eth_test.go index 1343cae03e79..4f74f7672fb8 100644 --- a/eth/handler_eth_test.go +++ b/eth/handler_eth_test.go @@ -38,9 +38,8 @@ import ( // testEthHandler is a mock event handler to listen for inbound network requests // on the `eth` protocol and convert them into a more easily testable form. type testEthHandler struct { - blockBroadcasts event.Feed - txAnnounces event.Feed - txBroadcasts event.Feed + txAnnounces event.Feed + txBroadcasts event.Feed } func (h *testEthHandler) Chain() *core.BlockChain { panic("no backing chain") } @@ -51,20 +50,24 @@ func (h *testEthHandler) PeerInfo(enode.ID) interface{} { panic("not used func (h *testEthHandler) Handle(peer *eth.Peer, packet eth.Packet) error { switch packet := packet.(type) { - case *eth.NewBlockPacket: - h.blockBroadcasts.Send(packet.Block) - return nil - case *eth.NewPooledTransactionHashesPacket: h.txAnnounces.Send(packet.Hashes) return nil case *eth.TransactionsPacket: - h.txBroadcasts.Send(([]*types.Transaction)(*packet)) + txs, err := packet.Items() + if err != nil { + return err + } + h.txBroadcasts.Send(txs) return nil - case *eth.PooledTransactionsResponse: - h.txBroadcasts.Send(([]*types.Transaction)(*packet)) + case *eth.PooledTransactionsPacket: + txs, err := packet.List.Items() + if err != nil { + return err + } + h.txBroadcasts.Send(txs) return nil default: @@ -74,7 +77,7 @@ func (h *testEthHandler) Handle(peer *eth.Peer, packet eth.Packet) error { // Tests that peers are correctly accepted (or rejected) based on the advertised // fork IDs in the protocol handshake. -func TestForkIDSplit68(t *testing.T) { testForkIDSplit(t, eth.ETH68) } +func TestForkIDSplit69(t *testing.T) { testForkIDSplit(t, eth.ETH69) } func testForkIDSplit(t *testing.T, protocol uint) { t.Parallel() @@ -134,8 +137,8 @@ func testForkIDSplit(t *testing.T, protocol uint) { defer p2pNoFork.Close() defer p2pProFork.Close() - peerNoFork := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pNoFork), p2pNoFork, nil) - peerProFork := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pProFork), p2pProFork, nil) + peerNoFork := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pNoFork), p2pNoFork, nil, nil) + peerProFork := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pProFork), p2pProFork, nil, nil) defer peerNoFork.Close() defer peerProFork.Close() @@ -165,8 +168,8 @@ func testForkIDSplit(t *testing.T, protocol uint) { defer p2pNoFork.Close() defer p2pProFork.Close() - peerNoFork = eth.NewPeer(protocol, p2p.NewPeer(enode.ID{1}, "", nil), p2pNoFork, nil) - peerProFork = eth.NewPeer(protocol, p2p.NewPeer(enode.ID{2}, "", nil), p2pProFork, nil) + peerNoFork = eth.NewPeer(protocol, p2p.NewPeer(enode.ID{1}, "", nil), p2pNoFork, nil, nil) + peerProFork = eth.NewPeer(protocol, p2p.NewPeer(enode.ID{2}, "", nil), p2pProFork, nil, nil) defer peerNoFork.Close() defer peerProFork.Close() @@ -196,8 +199,8 @@ func testForkIDSplit(t *testing.T, protocol uint) { defer p2pNoFork.Close() defer p2pProFork.Close() - peerNoFork = eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pNoFork), p2pNoFork, nil) - peerProFork = eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pProFork), p2pProFork, nil) + peerNoFork = eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pNoFork), p2pNoFork, nil, nil) + peerProFork = eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pProFork), p2pProFork, nil, nil) defer peerNoFork.Close() defer peerProFork.Close() @@ -226,7 +229,7 @@ func testForkIDSplit(t *testing.T, protocol uint) { } // Tests that received transactions are added to the local pool. -func TestRecvTransactions68(t *testing.T) { testRecvTransactions(t, eth.ETH68) } +func TestRecvTransactions69(t *testing.T) { testRecvTransactions(t, eth.ETH69) } func testRecvTransactions(t *testing.T, protocol uint) { t.Parallel() @@ -246,8 +249,8 @@ func testRecvTransactions(t *testing.T, protocol uint) { defer p2pSrc.Close() defer p2pSink.Close() - src := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pSrc), p2pSrc, handler.txpool) - sink := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pSink), p2pSink, handler.txpool) + src := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pSrc), p2pSrc, handler.txpool, nil) + sink := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pSink), p2pSink, handler.txpool, nil) defer src.Close() defer sink.Close() @@ -255,7 +258,8 @@ func testRecvTransactions(t *testing.T, protocol uint) { return eth.Handle((*ethHandler)(handler.handler), peer) }) // Run the handshake locally to avoid spinning up a source handler - if err := src.Handshake(1, handler.chain, eth.BlockRangeUpdatePacket{}); err != nil { + head := handler.chain.CurrentBlock() + if err := src.Handshake(1, handler.chain, eth.BlockRangeUpdatePacket{EarliestBlock: 0, LatestBlock: head.Number.Uint64(), LatestBlockHash: head.Hash()}); err != nil { t.Fatalf("failed to run protocol handshake") } // Send the transaction to the sink and verify that it's added to the tx pool @@ -278,7 +282,7 @@ func testRecvTransactions(t *testing.T, protocol uint) { } // This test checks that pending transactions are sent. -func TestSendTransactions68(t *testing.T) { testSendTransactions(t, eth.ETH68) } +func TestSendTransactions69(t *testing.T) { testSendTransactions(t, eth.ETH69) } func testSendTransactions(t *testing.T, protocol uint) { t.Parallel() @@ -301,8 +305,8 @@ func testSendTransactions(t *testing.T, protocol uint) { defer p2pSrc.Close() defer p2pSink.Close() - src := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pSrc), p2pSrc, handler.txpool) - sink := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pSink), p2pSink, handler.txpool) + src := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{1}, "", nil, p2pSrc), p2pSrc, handler.txpool, nil) + sink := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{2}, "", nil, p2pSink), p2pSink, handler.txpool, nil) defer src.Close() defer sink.Close() @@ -310,7 +314,8 @@ func testSendTransactions(t *testing.T, protocol uint) { return eth.Handle((*ethHandler)(handler.handler), peer) }) // Run the handshake locally to avoid spinning up a source handler - if err := sink.Handshake(1, handler.chain, eth.BlockRangeUpdatePacket{}); err != nil { + head := handler.chain.CurrentBlock() + if err := sink.Handshake(1, handler.chain, eth.BlockRangeUpdatePacket{EarliestBlock: 0, LatestBlock: head.Number.Uint64(), LatestBlockHash: head.Hash()}); err != nil { t.Fatalf("failed to run protocol handshake") } // After the handshake completes, the source handler should stream the sink @@ -330,22 +335,16 @@ func testSendTransactions(t *testing.T, protocol uint) { // Make sure we get all the transactions on the correct channels seen := make(map[common.Hash]struct{}) for len(seen) < len(insert) { - switch protocol { - case 68: - select { - case hashes := <-anns: - for _, hash := range hashes { - if _, ok := seen[hash]; ok { - t.Errorf("duplicate transaction announced: %x", hash) - } - seen[hash] = struct{}{} + select { + case hashes := <-anns: + for _, hash := range hashes { + if _, ok := seen[hash]; ok { + t.Errorf("duplicate transaction announced: %x", hash) } - case <-bcasts: - t.Errorf("initial tx broadcast received on post eth/66") + seen[hash] = struct{}{} } - - default: - panic("unsupported protocol, please extend test") + case <-bcasts: + t.Errorf("initial tx broadcast received on post eth/66") } } for _, tx := range insert { @@ -357,7 +356,7 @@ func testSendTransactions(t *testing.T, protocol uint) { // Tests that transactions get propagated to all attached peers, either via direct // broadcasts or via announcements/retrievals. -func TestTransactionPropagation68(t *testing.T) { testTransactionPropagation(t, eth.ETH68) } +func TestTransactionPropagation69(t *testing.T) { testTransactionPropagation(t, eth.ETH69) } func testTransactionPropagation(t *testing.T, protocol uint) { t.Parallel() @@ -381,8 +380,8 @@ func testTransactionPropagation(t *testing.T, protocol uint) { defer sourcePipe.Close() defer sinkPipe.Close() - sourcePeer := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{byte(i + 1)}, "", nil, sourcePipe), sourcePipe, source.txpool) - sinkPeer := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{0}, "", nil, sinkPipe), sinkPipe, sink.txpool) + sourcePeer := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{byte(i + 1)}, "", nil, sourcePipe), sourcePipe, source.txpool, nil) + sinkPeer := eth.NewPeer(protocol, p2p.NewPeerPipe(enode.ID{0}, "", nil, sinkPipe), sinkPipe, sink.txpool, nil) defer sourcePeer.Close() defer sinkPeer.Close() diff --git a/eth/handler_test.go b/eth/handler_test.go index 312e5625ba27..9cd955d29d36 100644 --- a/eth/handler_test.go +++ b/eth/handler_test.go @@ -128,10 +128,11 @@ func (p *testTxPool) Add(txs []*types.Transaction, sync bool) []error { } // Pending returns all the transactions known to the pool -func (p *testTxPool) Pending(filter txpool.PendingFilter) map[common.Address][]*txpool.LazyTransaction { +func (p *testTxPool) Pending(filter txpool.PendingFilter) (map[common.Address][]*txpool.LazyTransaction, int) { p.lock.RLock() defer p.lock.RUnlock() + var count int batches := make(map[common.Address][]*types.Transaction) for _, tx := range p.pool { from, _ := types.Sender(types.HomesteadSigner{}, tx) @@ -152,9 +153,10 @@ func (p *testTxPool) Pending(filter txpool.PendingFilter) map[common.Address][]* Gas: tx.Gas(), BlobGas: tx.BlobGas(), }) + count++ } } - return pending + return pending, count } // SubscribeTransactions should return an event subscription of NewTxsEvent and @@ -163,6 +165,15 @@ func (p *testTxPool) SubscribeTransactions(ch chan<- core.NewTxsEvent, reorgs bo return p.txFeed.Subscribe(ch) } +// FilterType should check whether the pool supports the given type of transactions. +func (p *testTxPool) FilterType(kind byte) bool { + switch kind { + case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType, types.BlobTxType, types.SetCodeTxType: + return true + } + return false +} + // testHandler is a live implementation of the Ethereum protocol handler, just // preinitialized with some sane testing defaults and the transaction pool mocked // out. @@ -306,7 +317,7 @@ func createTestPeers(rand *rand.Rand, n int) []*ethPeer { var id enode.ID rand.Read(id[:]) p2pPeer := p2p.NewPeer(id, "test", nil) - ep := eth.NewPeer(eth.ETH69, p2pPeer, nil, nil) + ep := eth.NewPeer(eth.ETH69, p2pPeer, nil, nil, nil) peers[i] = ðPeer{Peer: ep} } return peers diff --git a/eth/protocols/eth/dispatcher.go b/eth/protocols/eth/dispatcher.go index cba40596fcf3..5a01ab32e0e5 100644 --- a/eth/protocols/eth/dispatcher.go +++ b/eth/protocols/eth/dispatcher.go @@ -22,6 +22,7 @@ import ( "time" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/p2p/tracker" ) var ( @@ -47,9 +48,10 @@ type Request struct { sink chan *Response // Channel to deliver the response on cancel chan struct{} // Channel to cancel requests ahead of time - code uint64 // Message code of the request packet - want uint64 // Message code of the response packet - data interface{} // Data content of the request packet + code uint64 // Message code of the request packet + want uint64 // Message code of the response packet + numItems int // Number of requested items + data interface{} // Data content of the request packet Peer string // Demultiplexer if cross-peer requests are batched together Sent time.Time // Timestamp when the request was sent @@ -190,19 +192,33 @@ func (p *Peer) dispatchResponse(res *Response, metadata func() interface{}) erro func (p *Peer) dispatcher() { pending := make(map[uint64]*Request) +loop: for { select { case reqOp := <-p.reqDispatch: req := reqOp.req req.Sent = time.Now() - requestTracker.Track(p.id, p.version, req.code, req.want, req.id) - err := p2p.Send(p.rw, req.code, req.data) - reqOp.fail <- err + treq := tracker.Request{ + ID: req.id, + ReqCode: req.code, + RespCode: req.want, + Size: req.numItems, + } + if err := p.tracker.Track(treq); err != nil { + reqOp.fail <- err + continue loop + } + if err := p2p.Send(p.rw, req.code, req.data); err != nil { + reqOp.fail <- err + continue loop + } - if err == nil { + // do not overwrite if it is re-request + if _, ok := pending[req.id]; !ok { pending[req.id] = req } + reqOp.fail <- nil case cancelOp := <-p.reqCancel: // Retrieve the pending request to cancel and short circuit if it @@ -214,15 +230,19 @@ func (p *Peer) dispatcher() { } // Stop tracking the request delete(pending, cancelOp.id) + + // Not sure if the request is about the receipt, but remove it anyway. + // TODO(rjl493456442, bosul): investigate whether we can avoid leaking peer fields here. + p.receiptBufferLock.Lock() + delete(p.receiptBuffer, cancelOp.id) + p.receiptBufferLock.Unlock() + cancelOp.fail <- nil case resOp := <-p.resDispatch: res := resOp.res res.Req = pending[res.id] - // Independent if the request exists or not, track this packet - requestTracker.Fulfil(p.id, p.version, res.code, res.id) - switch { case res.Req == nil: // Response arrived with an untracked ID. Since even cancelled @@ -249,6 +269,7 @@ func (p *Peer) dispatcher() { } case <-p.term: + p.tracker.Stop() return } } diff --git a/eth/protocols/eth/handler.go b/eth/protocols/eth/handler.go index 2467e0c713b0..f7d25bd8caeb 100644 --- a/eth/protocols/eth/handler.go +++ b/eth/protocols/eth/handler.go @@ -35,6 +35,10 @@ const ( // softResponseLimit is the target maximum size of replies to data retrievals. softResponseLimit = 2 * 1024 * 1024 + // maxPacketSize is the devp2p message size limit commonly enforced by clients. + // Any packet exceeding this limit must be rejected. + maxPacketSize = 10 * 1024 * 1024 + // maxHeadersServe is the maximum number of block headers to serve. This number // is there to limit the number of disk lookups. maxHeadersServe = 1024 @@ -106,7 +110,7 @@ func MakeProtocols(backend Backend, network uint64, disc enode.Iterator) []p2p.P Version: version, Length: protocolLengths[version], Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error { - peer := NewPeer(version, p, rw, backend.TxPool()) + peer := NewPeer(version, p, rw, backend.TxPool(), backend.Chain().Config()) defer peer.Close() return backend.RunPeer(peer, func(peer *Peer) error { @@ -163,33 +167,31 @@ func Handle(backend Backend, peer *Peer) error { type msgHandler func(backend Backend, msg Decoder, peer *Peer) error type Decoder interface { Decode(val interface{}) error - Time() time.Time } -var eth68 = map[uint64]msgHandler{ - NewBlockHashesMsg: handleNewBlockhashes, - NewBlockMsg: handleNewBlock, +var eth69 = map[uint64]msgHandler{ TransactionsMsg: handleTransactions, NewPooledTransactionHashesMsg: handleNewPooledTransactionHashes, GetBlockHeadersMsg: handleGetBlockHeaders, BlockHeadersMsg: handleBlockHeaders, GetBlockBodiesMsg: handleGetBlockBodies, BlockBodiesMsg: handleBlockBodies, - GetReceiptsMsg: handleGetReceipts68, - ReceiptsMsg: handleReceipts[*ReceiptList68], + GetReceiptsMsg: handleGetReceipts69, + ReceiptsMsg: handleReceipts69, GetPooledTransactionsMsg: handleGetPooledTransactions, PooledTransactionsMsg: handlePooledTransactions, + BlockRangeUpdateMsg: handleBlockRangeUpdate, } -var eth69 = map[uint64]msgHandler{ +var eth70 = map[uint64]msgHandler{ TransactionsMsg: handleTransactions, NewPooledTransactionHashesMsg: handleNewPooledTransactionHashes, GetBlockHeadersMsg: handleGetBlockHeaders, BlockHeadersMsg: handleBlockHeaders, GetBlockBodiesMsg: handleGetBlockBodies, BlockBodiesMsg: handleBlockBodies, - GetReceiptsMsg: handleGetReceipts69, - ReceiptsMsg: handleReceipts[*ReceiptList69], + GetReceiptsMsg: handleGetReceipts70, + ReceiptsMsg: handleReceipts70, GetPooledTransactionsMsg: handleGetPooledTransactions, PooledTransactionsMsg: handlePooledTransactions, BlockRangeUpdateMsg: handleBlockRangeUpdate, @@ -209,11 +211,12 @@ func handleMessage(backend Backend, peer *Peer) error { defer msg.Discard() var handlers map[uint64]msgHandler - if peer.version == ETH68 { - handlers = eth68 - } else if peer.version == ETH69 { + switch peer.version { + case ETH69: handlers = eth69 - } else { + case ETH70: + handlers = eth70 + default: return fmt.Errorf("unknown eth protocol version: %v", peer.version) } diff --git a/eth/protocols/eth/handler_test.go b/eth/protocols/eth/handler_test.go index 65c491f815f6..d056d121d9b9 100644 --- a/eth/protocols/eth/handler_test.go +++ b/eth/protocols/eth/handler_test.go @@ -23,9 +23,11 @@ import ( "math/big" "math/rand" "os" + "reflect" "testing" "time" + "github.com/davecgh/go-spew/spew" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus/beacon" "github.com/ethereum/go-ethereum/consensus/ethash" @@ -42,6 +44,7 @@ import ( "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" "github.com/holiman/uint256" ) @@ -171,7 +174,7 @@ func (b *testBackend) Handle(*Peer, Packet) error { } // Tests that block headers can be retrieved from a remote chain based on user queries. -func TestGetBlockHeaders68(t *testing.T) { testGetBlockHeaders(t, ETH68) } +func TestGetBlockHeaders69(t *testing.T) { testGetBlockHeaders(t, ETH69) } func testGetBlockHeaders(t *testing.T, protocol uint) { t.Parallel() @@ -360,8 +363,8 @@ func testGetBlockHeaders(t *testing.T, protocol uint) { GetBlockHeadersRequest: tt.query, }) if err := p2p.ExpectMsg(peer.app, BlockHeadersMsg, &BlockHeadersPacket{ - RequestId: 123, - BlockHeadersRequest: headers, + RequestId: 123, + List: encodeRL(headers), }); err != nil { t.Errorf("test %d: headers mismatch: %v", i, err) } @@ -374,7 +377,7 @@ func testGetBlockHeaders(t *testing.T, protocol uint) { RequestId: 456, GetBlockHeadersRequest: tt.query, }) - expected := &BlockHeadersPacket{RequestId: 456, BlockHeadersRequest: headers} + expected := &BlockHeadersPacket{RequestId: 456, List: encodeRL(headers)} if err := p2p.ExpectMsg(peer.app, BlockHeadersMsg, expected); err != nil { t.Errorf("test %d by hash: headers mismatch: %v", i, err) } @@ -384,7 +387,7 @@ func testGetBlockHeaders(t *testing.T, protocol uint) { } // Tests that block contents can be retrieved from a remote chain based on their hashes. -func TestGetBlockBodies68(t *testing.T) { testGetBlockBodies(t, ETH68) } +func TestGetBlockBodies69(t *testing.T) { testGetBlockBodies(t, ETH69) } func testGetBlockBodies(t *testing.T, protocol uint) { t.Parallel() @@ -421,23 +424,27 @@ func testGetBlockBodies(t *testing.T, protocol uint) { {0, []common.Hash{backend.chain.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable {0, []common.Hash{{}}, []bool{false}, 0}, // A non existent block should not be returned - // Existing and non-existing blocks interleaved should not cause problems + // Existing blocks followed by a non-existing one should stop at the gap {0, []common.Hash{ - {}, backend.chain.GetBlockByNumber(1).Hash(), - {}, backend.chain.GetBlockByNumber(10).Hash(), - {}, backend.chain.GetBlockByNumber(100).Hash(), {}, - }, []bool{false, true, false, true, false, true, false}, 3}, + }, []bool{true, true, true, false}, 3}, + + // A non-existing block at the start should return nothing + {0, []common.Hash{ + {}, + backend.chain.GetBlockByNumber(1).Hash(), + backend.chain.GetBlockByNumber(10).Hash(), + }, []bool{false, true, true}, 0}, } // Run each of the tests and verify the results against the chain for i, tt := range tests { // Collect the hashes to request, and the response to expect var ( hashes []common.Hash - bodies []*BlockBody + bodies []BlockBody seen = make(map[int64]bool) ) for j := 0; j < tt.random; j++ { @@ -449,7 +456,7 @@ func testGetBlockBodies(t *testing.T, protocol uint) { block := backend.chain.GetBlockByNumber(uint64(num)) hashes = append(hashes, block.Hash()) if len(bodies) < tt.expected { - bodies = append(bodies, &BlockBody{Transactions: block.Transactions(), Uncles: block.Uncles(), Withdrawals: block.Withdrawals()}) + bodies = append(bodies, encodeBody(block)) } break } @@ -459,7 +466,7 @@ func testGetBlockBodies(t *testing.T, protocol uint) { hashes = append(hashes, hash) if tt.available[j] && len(bodies) < tt.expected { block := backend.chain.GetBlockByHash(hash) - bodies = append(bodies, &BlockBody{Transactions: block.Transactions(), Uncles: block.Uncles(), Withdrawals: block.Withdrawals()}) + bodies = append(bodies, encodeBody(block)) } } @@ -469,16 +476,71 @@ func testGetBlockBodies(t *testing.T, protocol uint) { GetBlockBodiesRequest: hashes, }) if err := p2p.ExpectMsg(peer.app, BlockBodiesMsg, &BlockBodiesPacket{ - RequestId: 123, - BlockBodiesResponse: bodies, + RequestId: 123, + List: encodeRL(bodies), }); err != nil { t.Fatalf("test %d: bodies mismatch: %v", i, err) } } } +func encodeBody(b *types.Block) BlockBody { + body := BlockBody{ + Transactions: encodeRL([]*types.Transaction(b.Transactions())), + Uncles: encodeRL(b.Uncles()), + } + if b.Withdrawals() != nil { + wd := encodeRL([]*types.Withdrawal(b.Withdrawals())) + body.Withdrawals = &wd + } + return body +} + +func TestHashBody(t *testing.T) { + key, _ := crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a") + signer := types.NewCancunSigner(big.NewInt(1)) + + // create block 1 + header := &types.Header{Number: big.NewInt(11)} + txs := []*types.Transaction{ + types.MustSignNewTx(key, signer, &types.DynamicFeeTx{ + ChainID: big.NewInt(1), + Nonce: 1, + Data: []byte("testing"), + }), + types.MustSignNewTx(key, signer, &types.LegacyTx{ + Nonce: 2, + Data: []byte("testing"), + }), + } + uncles := []*types.Header{{Number: big.NewInt(10)}} + body1 := &types.Body{Transactions: txs, Uncles: uncles} + block1 := types.NewBlock(header, body1, nil, trie.NewStackTrie(nil)) + + // create block 2 (has withdrawals) + header2 := &types.Header{Number: big.NewInt(12)} + body2 := &types.Body{ + Withdrawals: []*types.Withdrawal{{Index: 10}, {Index: 11}}, + } + block2 := types.NewBlock(header2, body2, nil, trie.NewStackTrie(nil)) + + expectedHashes := BlockBodyHashes{ + TransactionRoots: []common.Hash{block1.TxHash(), block2.TxHash()}, + WithdrawalRoots: []common.Hash{common.Hash{}, *block2.Header().WithdrawalsHash}, + UncleHashes: []common.Hash{block1.UncleHash(), block2.UncleHash()}, + } + + // compute hash like protocol handler does + protocolBodies := []BlockBody{encodeBody(block1), encodeBody(block2)} + hashes := hashBodyParts(protocolBodies) + if !reflect.DeepEqual(hashes, expectedHashes) { + t.Errorf("wrong hashes: %s", spew.Sdump(hashes)) + t.Logf("expected: %s", spew.Sdump(expectedHashes)) + } +} + // Tests that the transaction receipts can be retrieved based on hashes. -func TestGetBlockReceipts68(t *testing.T) { testGetBlockReceipts(t, ETH68) } +func TestGetBlockReceipts69(t *testing.T) { testGetBlockReceipts(t, ETH69) } func testGetBlockReceipts(t *testing.T, protocol uint) { t.Parallel() @@ -528,21 +590,21 @@ func testGetBlockReceipts(t *testing.T, protocol uint) { // Collect the hashes to request, and the response to expect var ( hashes []common.Hash - receipts []*ReceiptList68 + receipts rlp.RawList[*ReceiptList] ) for i := uint64(0); i <= backend.chain.CurrentBlock().Number.Uint64(); i++ { block := backend.chain.GetBlockByNumber(i) hashes = append(hashes, block.Hash()) - trs := backend.chain.GetReceiptsByHash(block.Hash()) - receipts = append(receipts, NewReceiptList68(trs)) + br := backend.chain.GetReceiptsByHash(block.Hash()) + receipts.Append(NewReceiptList(br)) } // Send the hash request and verify the response - p2p.Send(peer.app, GetReceiptsMsg, &GetReceiptsPacket{ + p2p.Send(peer.app, GetReceiptsMsg, &GetReceiptsPacket69{ RequestId: 123, GetReceiptsRequest: hashes, }) - if err := p2p.ExpectMsg(peer.app, ReceiptsMsg, &ReceiptsPacket[*ReceiptList68]{ + if err := p2p.ExpectMsg(peer.app, ReceiptsMsg, &ReceiptsPacket69{ RequestId: 123, List: receipts, }); err != nil { @@ -550,6 +612,103 @@ func testGetBlockReceipts(t *testing.T, protocol uint) { } } +func TestGetBlockPartialReceipts(t *testing.T) { testGetBlockPartialReceipts(t, ETH70) } + +func testGetBlockPartialReceipts(t *testing.T, protocol int) { + // First, generate the chain and overwrite the receipts. + generator := func(_ int, block *core.BlockGen) { + for j := 0; j < 5; j++ { + tx, err := types.SignTx( + types.NewTransaction(block.TxNonce(testAddr), testAddr, big.NewInt(1000), params.TxGas, block.BaseFee(), nil), + types.LatestSignerForChainID(params.TestChainConfig.ChainID), + testKey, + ) + if err != nil { + t.Fatalf("failed to sign tx: %v", err) + } + block.AddTx(tx) + } + } + backend := newTestBackendWithGenerator(4, true, false, generator) + defer backend.close() + + blockCutoff := 2 + receiptCutoff := 4 + + // Replace the receipts in the database with larger receipts. + targetBlock := backend.chain.GetBlockByNumber(uint64(blockCutoff)) + receipts := backend.chain.GetReceiptsByHash(targetBlock.Hash()) + receiptSize := params.MaxTxGas / params.LogDataGas // ~2MiB per receipt + for i := range receipts { + payload := make([]byte, receiptSize) + for j := range payload { + payload[j] = byte(i + j) + } + receipts[i].Logs = []*types.Log{ + { + Address: common.BytesToAddress([]byte{byte(i + 1)}), + Data: payload, + }, + } + } + + rawdb.WriteReceipts(backend.db, targetBlock.Hash(), targetBlock.NumberU64(), receipts) + + peer, _ := newTestPeer("peer", uint(protocol), backend) + defer peer.close() + + var ( + hashes []common.Hash + partialReceipt []*ReceiptList + ) + for i := uint64(0); i <= backend.chain.CurrentBlock().Number.Uint64(); i++ { + block := backend.chain.GetBlockByNumber(i) + hashes = append(hashes, block.Hash()) + } + for i := 0; i <= blockCutoff; i++ { + block := backend.chain.GetBlockByNumber(uint64(i)) + trs := backend.chain.GetReceiptsByHash(block.Hash()) + limit := len(trs) + if i == blockCutoff { + limit = receiptCutoff + } + partialReceipt = append(partialReceipt, NewReceiptList(trs[:limit])) + } + + rawPartialReceipt, _ := rlp.EncodeToRawList(partialReceipt) + + p2p.Send(peer.app, GetReceiptsMsg, &GetReceiptsPacket70{ + RequestId: 123, + FirstBlockReceiptIndex: 0, + GetReceiptsRequest: hashes, + }) + if err := p2p.ExpectMsg(peer.app, ReceiptsMsg, &ReceiptsPacket70{ + RequestId: 123, + LastBlockIncomplete: true, + List: rawPartialReceipt, + }); err != nil { + t.Errorf("receipts mismatch: %v", err) + } + + // Simulate the continued request + partialReceipt = []*ReceiptList{NewReceiptList(receipts[receiptCutoff:])} + rawPartialReceipt, _ = rlp.EncodeToRawList(partialReceipt) + + p2p.Send(peer.app, GetReceiptsMsg, &GetReceiptsPacket70{ + RequestId: 123, + FirstBlockReceiptIndex: uint64(receiptCutoff), + GetReceiptsRequest: []common.Hash{hashes[blockCutoff]}, + }) + + if err := p2p.ExpectMsg(peer.app, ReceiptsMsg, &ReceiptsPacket70{ + RequestId: 123, + LastBlockIncomplete: false, + List: rawPartialReceipt, + }); err != nil { + t.Errorf("receipts mismatch: %v", err) + } +} + type decoder struct { msg []byte } @@ -598,7 +757,7 @@ func setup() (*testBackend, *testPeer) { } } backend := newTestBackendWithGenerator(maxBodiesServe+15, true, false, gen) - peer, _ := newTestPeer("peer", ETH68, backend) + peer, _ := newTestPeer("peer", ETH69, backend) // Discard all messages go func() { for { @@ -612,10 +771,10 @@ func setup() (*testBackend, *testPeer) { } func FuzzEthProtocolHandlers(f *testing.F) { - handlers := eth69 + handlers := eth70 backend, peer := setup() f.Fuzz(func(t *testing.T, code byte, msg []byte) { - handler := handlers[uint64(code)%protocolLengths[ETH69]] + handler := handlers[uint64(code)%protocolLengths[ETH70]] if handler == nil { return } @@ -643,7 +802,7 @@ func testGetPooledTransaction(t *testing.T, blobTx bool) { backend := newTestBackendWithGenerator(0, true, true, nil) defer backend.close() - peer, _ := newTestPeer("peer", ETH68, backend) + peer, _ := newTestPeer("peer", ETH69, backend) defer peer.close() var ( @@ -688,10 +847,18 @@ func testGetPooledTransaction(t *testing.T, blobTx bool) { RequestId: 123, GetPooledTransactionsRequest: []common.Hash{tx.Hash()}, }) - if err := p2p.ExpectMsg(peer.app, PooledTransactionsMsg, PooledTransactionsPacket{ - RequestId: 123, - PooledTransactionsResponse: []*types.Transaction{tx}, + if err := p2p.ExpectMsg(peer.app, PooledTransactionsMsg, &PooledTransactionsPacket{ + RequestId: 123, + List: encodeRL([]*types.Transaction{tx}), }); err != nil { t.Errorf("pooled transaction mismatch: %v", err) } } + +func encodeRL[T any](slice []T) rlp.RawList[T] { + rl, err := rlp.EncodeToRawList(slice) + if err != nil { + panic(err) + } + return rl +} diff --git a/eth/protocols/eth/handlers.go b/eth/protocols/eth/handlers.go index aad3353d88d7..3254a0abc2ab 100644 --- a/eth/protocols/eth/handlers.go +++ b/eth/protocols/eth/handlers.go @@ -17,23 +17,21 @@ package eth import ( + "bytes" "encoding/json" - "errors" "fmt" - "time" + "math" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p/tracker" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) -// requestTracker is a singleton tracker for eth/66 and newer request times. -var requestTracker = tracker.New(ProtocolName, 5*time.Minute) - func handleGetBlockHeaders(backend Backend, msg Decoder, peer *Peer) error { // Decode the complex header query var query GetBlockHeadersPacket @@ -240,114 +238,111 @@ func ServiceGetBlockBodiesQuery(chain *core.BlockChain, query GetBlockBodiesRequ lookups >= 2*maxBodiesServe { break } - if data := chain.GetBodyRLP(hash); len(data) != 0 { - bodies = append(bodies, data) - bytes += len(data) + data := chain.GetBodyRLP(hash) + if len(data) == 0 { + break // If we don't have this block's body, stop serving. } + bodies = append(bodies, data) + bytes += len(data) } return bodies } -func handleGetReceipts68(backend Backend, msg Decoder, peer *Peer) error { +func handleGetReceipts69(backend Backend, msg Decoder, peer *Peer) error { // Decode the block receipts retrieval message - var query GetReceiptsPacket + var query GetReceiptsPacket69 if err := msg.Decode(&query); err != nil { return err } - response := ServiceGetReceiptsQuery68(backend.Chain(), query.GetReceiptsRequest) - return peer.ReplyReceiptsRLP(query.RequestId, response) + response := ServiceGetReceiptsQuery69(backend.Chain(), query.GetReceiptsRequest) + return peer.ReplyReceiptsRLP69(query.RequestId, response) } -func handleGetReceipts69(backend Backend, msg Decoder, peer *Peer) error { - // Decode the block receipts retrieval message - var query GetReceiptsPacket +func handleGetReceipts70(backend Backend, msg Decoder, peer *Peer) error { + var query GetReceiptsPacket70 if err := msg.Decode(&query); err != nil { return err } - response := serviceGetReceiptsQuery69(backend.Chain(), query.GetReceiptsRequest) - return peer.ReplyReceiptsRLP(query.RequestId, response) + response, lastBlockIncomplete := serviceGetReceiptsQuery70(backend.Chain(), query.GetReceiptsRequest, query.FirstBlockReceiptIndex) + return peer.ReplyReceiptsRLP70(query.RequestId, response, lastBlockIncomplete) } -// ServiceGetReceiptsQuery68 assembles the response to a receipt query. It is -// exposed to allow external packages to test protocol behavior. -func ServiceGetReceiptsQuery68(chain *core.BlockChain, query GetReceiptsRequest) []rlp.RawValue { - // Gather state data until the fetch or network limits is reached +// ServiceGetReceiptsQuery69 assembles the response to a receipt query. +// It does not send the bloom filters for the receipts. It is exposed +// to allow external packages to test protocol behavior. +func ServiceGetReceiptsQuery69(chain *core.BlockChain, query GetReceiptsRequest) rlp.RawList[*ReceiptList] { var ( bytes int - receipts []rlp.RawValue + receipts rlp.RawList[*ReceiptList] ) for lookups, hash := range query { - if bytes >= softResponseLimit || len(receipts) >= maxReceiptsServe || - lookups >= 2*maxReceiptsServe { + if bytes >= softResponseLimit || receipts.Len() >= maxReceiptsServe || lookups >= 2*maxReceiptsServe { break } + // Retrieve the requested block's receipts results := chain.GetReceiptsRLP(hash) if results == nil { - if header := chain.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyRootHash { - continue - } - } else { - body := chain.GetBodyRLP(hash) - if body == nil { - continue - } - var err error - results, err = blockReceiptsToNetwork68(results, body) - if err != nil { - log.Error("Error in block receipts conversion", "hash", hash, "err", err) - continue - } + break // Don't have this block's receipts, stop serving. + } + body := chain.GetBodyRLP(hash) + if body == nil { + break // The block body is missing, stop serving. + } + results, _, err := blockReceiptsToNetwork(results, body, receiptQueryParams{}) + if err != nil { + log.Error("Error in block receipts conversion", "hash", hash, "err", err) + break } - receipts = append(receipts, results) + receipts.AppendRaw(results) bytes += len(results) } return receipts } -// serviceGetReceiptsQuery69 assembles the response to a receipt query. -// It does not send the bloom filters for the receipts -func serviceGetReceiptsQuery69(chain *core.BlockChain, query GetReceiptsRequest) []rlp.RawValue { - // Gather state data until the fetch or network limits is reached +// serviceGetReceiptsQuery70 assembles the response to a receipt query. +// If the receipts exceed 10 MiB, it trims them and sets the +// lastBlockIncomplete flag. Indices smaller than firstBlockReceiptIndex +// are omitted from the first block receipt list. +func serviceGetReceiptsQuery70(chain *core.BlockChain, query GetReceiptsRequest, firstBlockReceiptIndex uint64) (rlp.RawList[*ReceiptList], bool) { var ( bytes int - receipts []rlp.RawValue + receipts rlp.RawList[*ReceiptList] ) - for lookups, hash := range query { - if bytes >= softResponseLimit || len(receipts) >= maxReceiptsServe || - lookups >= 2*maxReceiptsServe { + for i, hash := range query { + if bytes >= softResponseLimit || receipts.Len() >= maxReceiptsServe { break } - // Retrieve the requested block's receipts results := chain.GetReceiptsRLP(hash) + // If we don't have this block's receipts or body, stop serving. if results == nil { - if header := chain.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyRootHash { - continue - } - } else { - body := chain.GetBodyRLP(hash) - if body == nil { - continue - } - var err error - results, err = blockReceiptsToNetwork69(results, body) - if err != nil { - log.Error("Error in block receipts conversion", "hash", hash, "err", err) - continue - } + break + } + body := chain.GetBodyRLP(hash) + if body == nil { + break + } + q := receiptQueryParams{sizeLimit: uint64(maxPacketSize - bytes)} + if i == 0 { + q.firstIndex = firstBlockReceiptIndex } - receipts = append(receipts, results) + results, incomplete, err := blockReceiptsToNetwork(results, body, q) + if err != nil { + log.Error("Error in block receipts conversion", "hash", hash, "err", err) + break + } + if results == nil { + // This case triggers when the first receipt of the block receipts list doesn't + // fit. We don't append anything to the response here and consider it finished. + break + } + receipts.AppendRaw(results) bytes += len(results) + if incomplete { + return receipts, true + } } - return receipts -} - -func handleNewBlockhashes(backend Backend, msg Decoder, peer *Peer) error { - return errors.New("block announcements disallowed") // We dropped support for non-merge networks -} - -func handleNewBlock(backend Backend, msg Decoder, peer *Peer) error { - return errors.New("block broadcasts disallowed") // We dropped support for non-merge networks + return receipts, false } func handleBlockHeaders(backend Backend, msg Decoder, peer *Peer) error { @@ -356,9 +351,18 @@ func handleBlockHeaders(backend Backend, msg Decoder, peer *Peer) error { if err := msg.Decode(res); err != nil { return err } + tresp := tracker.Response{ID: res.RequestId, MsgCode: BlockHeadersMsg, Size: res.List.Len()} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("BlockHeaders: %w", err) + } + headers, err := res.List.Items() + if err != nil { + return fmt.Errorf("BlockHeaders: %w", err) + } + metadata := func() interface{} { - hashes := make([]common.Hash, len(res.BlockHeadersRequest)) - for i, header := range res.BlockHeadersRequest { + hashes := make([]common.Hash, len(headers)) + for i, header := range headers { hashes[i] = header.Hash() } return hashes @@ -366,7 +370,7 @@ func handleBlockHeaders(backend Backend, msg Decoder, peer *Peer) error { return peer.dispatchResponse(&Response{ id: res.RequestId, code: BlockHeadersMsg, - Res: &res.BlockHeadersRequest, + Res: (*BlockHeadersRequest)(&headers), }, metadata) } @@ -376,56 +380,183 @@ func handleBlockBodies(backend Backend, msg Decoder, peer *Peer) error { if err := msg.Decode(res); err != nil { return err } - metadata := func() interface{} { - var ( - txsHashes = make([]common.Hash, len(res.BlockBodiesResponse)) - uncleHashes = make([]common.Hash, len(res.BlockBodiesResponse)) - withdrawalHashes = make([]common.Hash, len(res.BlockBodiesResponse)) - ) - hasher := trie.NewStackTrie(nil) - for i, body := range res.BlockBodiesResponse { - txsHashes[i] = types.DeriveSha(types.Transactions(body.Transactions), hasher) - uncleHashes[i] = types.CalcUncleHash(body.Uncles) - if body.Withdrawals != nil { - withdrawalHashes[i] = types.DeriveSha(types.Withdrawals(body.Withdrawals), hasher) - } - } - return [][]common.Hash{txsHashes, uncleHashes, withdrawalHashes} + + // Check against the request. + length := res.List.Len() + tresp := tracker.Response{ID: res.RequestId, MsgCode: BlockBodiesMsg, Size: length} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("BlockBodies: %w", err) } + + // Collect items and dispatch. + items, err := res.List.Items() + if err != nil { + return fmt.Errorf("BlockBodies: %w", err) + } + metadata := func() any { return hashBodyParts(items) } return peer.dispatchResponse(&Response{ id: res.RequestId, code: BlockBodiesMsg, - Res: &res.BlockBodiesResponse, + Res: (*BlockBodiesResponse)(&items), }, metadata) } -func handleReceipts[L ReceiptsList](backend Backend, msg Decoder, peer *Peer) error { +// BlockBodyHashes contains the lists of block body part roots for a list of block bodies. +type BlockBodyHashes struct { + TransactionRoots []common.Hash + WithdrawalRoots []common.Hash + UncleHashes []common.Hash +} + +func hashBodyParts(items []BlockBody) BlockBodyHashes { + h := BlockBodyHashes{ + TransactionRoots: make([]common.Hash, len(items)), + WithdrawalRoots: make([]common.Hash, len(items)), + UncleHashes: make([]common.Hash, len(items)), + } + hasher := trie.NewStackTrie(nil) + for i, body := range items { + // txs + txsList := newDerivableRawList(&body.Transactions, writeTxForHash) + h.TransactionRoots[i] = types.DeriveSha(txsList, hasher) + // uncles + if body.Uncles.Len() == 0 { + h.UncleHashes[i] = types.EmptyUncleHash + } else { + h.UncleHashes[i] = crypto.Keccak256Hash(body.Uncles.Bytes()) + } + // withdrawals + if body.Withdrawals != nil { + wdlist := newDerivableRawList(body.Withdrawals, nil) + h.WithdrawalRoots[i] = types.DeriveSha(wdlist, hasher) + } + } + return h +} + +// derivableRawList implements types.DerivableList for a serialized RLP list. +type derivableRawList struct { + data []byte + offsets []uint32 + write func([]byte, *bytes.Buffer) +} + +func newDerivableRawList[T any](list *rlp.RawList[T], write func([]byte, *bytes.Buffer)) *derivableRawList { + dl := derivableRawList{data: list.Content(), write: write} + if dl.write == nil { + // default transform is identity + dl.write = func(b []byte, buf *bytes.Buffer) { buf.Write(b) } + } + // Assert to ensure 32-bit offsets are valid. This can never trigger + // unless a block body component or p2p receipt list is larger than 4GB. + if uint(len(dl.data)) > math.MaxUint32 { + panic("list data too big for derivableRawList") + } + it := list.ContentIterator() + dl.offsets = make([]uint32, list.Len()) + for i := 0; it.Next(); i++ { + dl.offsets[i] = uint32(it.Offset()) + } + return &dl +} + +// Len returns the number of items in the list. +func (dl *derivableRawList) Len() int { + return len(dl.offsets) +} + +// EncodeIndex writes the i'th item to the buffer. +func (dl *derivableRawList) EncodeIndex(i int, buf *bytes.Buffer) { + start := dl.offsets[i] + end := uint32(len(dl.data)) + if i != len(dl.offsets)-1 { + end = dl.offsets[i+1] + } + dl.write(dl.data[start:end], buf) +} + +// writeTxForHash changes a transaction in 'network encoding' into the format used for +// the transactions MPT. +func writeTxForHash(tx []byte, buf *bytes.Buffer) { + k, content, _, _ := rlp.Split(tx) + if k == rlp.List { + buf.Write(tx) // legacy tx + } else { + buf.Write(content) // typed tx + } +} + +func handleReceipts69(backend Backend, msg Decoder, peer *Peer) error { // A batch of receipts arrived to one of our previous requests - res := new(ReceiptsPacket[L]) + res := new(ReceiptsPacket69) if err := msg.Decode(res); err != nil { return err } - // Assign temporary hashing buffer to each list item, the same buffer is shared - // between all receipt list instances. - buffers := new(receiptListBuffers) - for i := range res.List { - res.List[i].setBuffers(buffers) + + tresp := tracker.Response{ID: res.RequestId, MsgCode: ReceiptsMsg, Size: res.List.Len()} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("Receipts: %w", err) + } + + receiptLists, err := res.List.Items() + if err != nil { + return fmt.Errorf("Receipts: %w", err) } + return dispatchReceipts(res.RequestId, receiptLists, peer) +} + +func handleReceipts70(backend Backend, msg Decoder, peer *Peer) error { + res := new(ReceiptsPacket70) + if err := msg.Decode(res); err != nil { + return err + } + + tresp := tracker.Response{ID: res.RequestId, MsgCode: ReceiptsMsg, Size: res.List.Len()} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("Receipts: %w", err) + } + receiptLists, err := res.List.Items() + if err != nil { + return fmt.Errorf("Receipts: %w", err) + } + + err = peer.bufferReceipts(res.RequestId, receiptLists, res.LastBlockIncomplete, backend) + if err != nil { + return err + } + if res.LastBlockIncomplete { + // Request the remaining receipts from the same peer. + return peer.requestPartialReceipts(res.RequestId) + } + if complete := peer.flushReceipts(res.RequestId); complete != nil { + receiptLists = complete + } + + return dispatchReceipts(res.RequestId, receiptLists, peer) +} + +// dispatchReceipts submits a receipt response to the dispatcher. +func dispatchReceipts(requestId uint64, receiptLists []*ReceiptList, peer *Peer) error { metadata := func() interface{} { hasher := trie.NewStackTrie(nil) - hashes := make([]common.Hash, len(res.List)) - for i := range res.List { - hashes[i] = types.DeriveSha(res.List[i], hasher) + hashes := make([]common.Hash, len(receiptLists)) + for i := range receiptLists { + hashes[i] = types.DeriveSha(receiptLists[i].Derivable(), hasher) } return hashes } + var enc ReceiptsRLPResponse - for i := range res.List { - enc = append(enc, res.List[i].EncodeForStorage()) + for i := range receiptLists { + encReceipts, err := receiptLists[i].EncodeForStorage() + if err != nil { + return fmt.Errorf("Receipts: invalid list %d: %v", i, err) + } + enc = append(enc, encReceipts) } return peer.dispatchResponse(&Response{ - id: res.RequestId, + id: requestId, code: ReceiptsMsg, Res: &enc, }, metadata) @@ -446,7 +577,7 @@ func handleNewPooledTransactionHashes(backend Backend, msg Decoder, peer *Peer) } // Schedule all the unknown hashes for retrieval for _, hash := range ann.Hashes { - peer.markTransaction(hash) + peer.MarkTransaction(hash) } return backend.Handle(peer, ann) } @@ -494,19 +625,8 @@ func handleTransactions(backend Backend, msg Decoder, peer *Peer) error { if err := msg.Decode(&txs); err != nil { return err } - // Duplicate transactions are not allowed - seen := make(map[common.Hash]struct{}) - for i, tx := range txs { - // Validate and mark the remote transaction - if tx == nil { - return fmt.Errorf("Transactions: transaction %d is nil", i) - } - hash := tx.Hash() - if _, exists := seen[hash]; exists { - return fmt.Errorf("Transactions: multiple copies of the same hash %v", hash) - } - seen[hash] = struct{}{} - peer.markTransaction(hash) + if txs.Len() > maxTransactionAnnouncements { + return fmt.Errorf("too many transactions") } return backend.Handle(peer, &txs) } @@ -516,28 +636,22 @@ func handlePooledTransactions(backend Backend, msg Decoder, peer *Peer) error { if !backend.AcceptTxs() { return nil } - // Transactions can be processed, parse all of them and deliver to the pool - var txs PooledTransactionsPacket - if err := msg.Decode(&txs); err != nil { + + // Check against request and decode. + var resp PooledTransactionsPacket + if err := msg.Decode(&resp); err != nil { return err } - // Duplicate transactions are not allowed - seen := make(map[common.Hash]struct{}) - for i, tx := range txs.PooledTransactionsResponse { - // Validate and mark the remote transaction - if tx == nil { - return fmt.Errorf("PooledTransactions: transaction %d is nil", i) - } - hash := tx.Hash() - if _, exists := seen[hash]; exists { - return fmt.Errorf("PooledTransactions: multiple copies of the same hash %v", hash) - } - seen[hash] = struct{}{} - peer.markTransaction(hash) + tresp := tracker.Response{ + ID: resp.RequestId, + MsgCode: PooledTransactionsMsg, + Size: resp.List.Len(), + } + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("PooledTransactions: %w", err) } - requestTracker.Fulfil(peer.id, peer.version, PooledTransactionsMsg, txs.RequestId) - return backend.Handle(peer, &txs.PooledTransactionsResponse) + return backend.Handle(peer, &resp) } func handleBlockRangeUpdate(backend Backend, msg Decoder, peer *Peer) error { diff --git a/eth/protocols/eth/handshake.go b/eth/protocols/eth/handshake.go index bb3d1b8eb42c..359e4e36bbf6 100644 --- a/eth/protocols/eth/handshake.go +++ b/eth/protocols/eth/handshake.go @@ -36,62 +36,6 @@ const ( // Handshake executes the eth protocol handshake, negotiating version number, // network IDs, difficulties, head and genesis blocks. func (p *Peer) Handshake(networkID uint64, chain forkid.Blockchain, rangeMsg BlockRangeUpdatePacket) error { - switch p.version { - case ETH69: - return p.handshake69(networkID, chain, rangeMsg) - case ETH68: - return p.handshake68(networkID, chain) - default: - return errors.New("unsupported protocol version") - } -} - -func (p *Peer) handshake68(networkID uint64, chain forkid.Blockchain) error { - var ( - genesis = chain.Genesis() - latest = chain.CurrentHeader() - forkID = forkid.NewID(chain.Config(), genesis, latest.Number.Uint64(), latest.Time) - forkFilter = forkid.NewFilter(chain) - ) - errc := make(chan error, 2) - go func() { - pkt := &StatusPacket68{ - ProtocolVersion: uint32(p.version), - NetworkID: networkID, - Head: latest.Hash(), - Genesis: genesis.Hash(), - ForkID: forkID, - } - errc <- p2p.Send(p.rw, StatusMsg, pkt) - }() - var status StatusPacket68 // safe to read after two values have been received from errc - go func() { - errc <- p.readStatus68(networkID, &status, genesis.Hash(), forkFilter) - }() - - return waitForHandshake(errc, p) -} - -func (p *Peer) readStatus68(networkID uint64, status *StatusPacket68, genesis common.Hash, forkFilter forkid.Filter) error { - if err := p.readStatusMsg(status); err != nil { - return err - } - if status.NetworkID != networkID { - return fmt.Errorf("%w: %d (!= %d)", errNetworkIDMismatch, status.NetworkID, networkID) - } - if uint(status.ProtocolVersion) != p.version { - return fmt.Errorf("%w: %d (!= %d)", errProtocolVersionMismatch, status.ProtocolVersion, p.version) - } - if status.Genesis != genesis { - return fmt.Errorf("%w: %x (!= %x)", errGenesisMismatch, status.Genesis, genesis) - } - if err := forkFilter(status.ForkID); err != nil { - return fmt.Errorf("%w: %v", errForkIDRejected, err) - } - return nil -} - -func (p *Peer) handshake69(networkID uint64, chain forkid.Blockchain, rangeMsg BlockRangeUpdatePacket) error { var ( genesis = chain.Genesis() latest = chain.CurrentHeader() @@ -101,7 +45,7 @@ func (p *Peer) handshake69(networkID uint64, chain forkid.Blockchain, rangeMsg B errc := make(chan error, 2) go func() { - pkt := &StatusPacket69{ + pkt := &StatusPacket{ ProtocolVersion: uint32(p.version), NetworkID: networkID, Genesis: genesis.Hash(), @@ -112,15 +56,15 @@ func (p *Peer) handshake69(networkID uint64, chain forkid.Blockchain, rangeMsg B } errc <- p2p.Send(p.rw, StatusMsg, pkt) }() - var status StatusPacket69 // safe to read after two values have been received from errc + var status StatusPacket // safe to read after two values have been received from errc go func() { - errc <- p.readStatus69(networkID, &status, genesis.Hash(), forkFilter) + errc <- p.readStatus(networkID, &status, genesis.Hash(), forkFilter) }() return waitForHandshake(errc, p) } -func (p *Peer) readStatus69(networkID uint64, status *StatusPacket69, genesis common.Hash, forkFilter forkid.Filter) error { +func (p *Peer) readStatus(networkID uint64, status *StatusPacket, genesis common.Hash, forkFilter forkid.Filter) error { if err := p.readStatusMsg(status); err != nil { return err } @@ -191,16 +135,16 @@ func markError(p *Peer, err error) { return } m := meters.get(p.Inbound()) - switch errors.Unwrap(err) { - case errNetworkIDMismatch: + switch { + case errors.Is(err, errNetworkIDMismatch): m.networkIDMismatch.Mark(1) - case errProtocolVersionMismatch: + case errors.Is(err, errProtocolVersionMismatch): m.protocolVersionMismatch.Mark(1) - case errGenesisMismatch: + case errors.Is(err, errGenesisMismatch): m.genesisMismatch.Mark(1) - case errForkIDRejected: + case errors.Is(err, errForkIDRejected): m.forkidRejected.Mark(1) - case p2p.DiscReadTimeout: + case errors.Is(err, p2p.DiscReadTimeout): m.timeoutError.Mark(1) default: m.peerError.Mark(1) diff --git a/eth/protocols/eth/handshake_test.go b/eth/protocols/eth/handshake_test.go index 2fab3ea5a879..5746d5896d9c 100644 --- a/eth/protocols/eth/handshake_test.go +++ b/eth/protocols/eth/handshake_test.go @@ -18,7 +18,6 @@ package eth import ( "errors" - "math/big" "testing" "github.com/ethereum/go-ethereum/common" @@ -28,7 +27,7 @@ import ( ) // Tests that handshake failures are detected and reported correctly. -func TestHandshake68(t *testing.T) { testHandshake(t, ETH68) } +func TestHandshake69(t *testing.T) { testHandshake(t, ETH69) } func testHandshake(t *testing.T, protocol uint) { t.Parallel() @@ -52,21 +51,25 @@ func testHandshake(t *testing.T, protocol uint) { want: errNoStatusMsg, }, { - code: StatusMsg, data: StatusPacket68{10, 1, new(big.Int), head.Hash(), genesis.Hash(), forkID}, + code: StatusMsg, data: StatusPacket{10, 1, genesis.Hash(), forkID, 0, head.Number.Uint64(), head.Hash()}, want: errProtocolVersionMismatch, }, { - code: StatusMsg, data: StatusPacket68{uint32(protocol), 999, new(big.Int), head.Hash(), genesis.Hash(), forkID}, + code: StatusMsg, data: StatusPacket{uint32(protocol), 999, genesis.Hash(), forkID, 0, head.Number.Uint64(), head.Hash()}, want: errNetworkIDMismatch, }, { - code: StatusMsg, data: StatusPacket68{uint32(protocol), 1, new(big.Int), head.Hash(), common.Hash{3}, forkID}, + code: StatusMsg, data: StatusPacket{uint32(protocol), 1, common.Hash{3}, forkID, 0, head.Number.Uint64(), head.Hash()}, want: errGenesisMismatch, }, { - code: StatusMsg, data: StatusPacket68{uint32(protocol), 1, new(big.Int), head.Hash(), genesis.Hash(), forkid.ID{Hash: [4]byte{0x00, 0x01, 0x02, 0x03}}}, + code: StatusMsg, data: StatusPacket{uint32(protocol), 1, genesis.Hash(), forkid.ID{Hash: [4]byte{0x00, 0x01, 0x02, 0x03}}, 0, head.Number.Uint64(), head.Hash()}, want: errForkIDRejected, }, + { + code: StatusMsg, data: StatusPacket{uint32(protocol), 1, genesis.Hash(), forkID, head.Number.Uint64() + 1, head.Number.Uint64(), head.Hash()}, + want: errInvalidBlockRange, + }, } for i, test := range tests { // Create the two peers to shake with each other @@ -74,7 +77,7 @@ func testHandshake(t *testing.T, protocol uint) { defer app.Close() defer net.Close() - peer := NewPeer(protocol, p2p.NewPeer(enode.ID{}, "peer", nil), net, nil) + peer := NewPeer(protocol, p2p.NewPeer(enode.ID{}, "peer", nil), net, nil, nil) defer peer.Close() // Send the junk test with one peer, check the handshake failure diff --git a/eth/protocols/eth/peer.go b/eth/protocols/eth/peer.go index 40c54a357054..754fd02be32b 100644 --- a/eth/protocols/eth/peer.go +++ b/eth/protocols/eth/peer.go @@ -17,13 +17,19 @@ package eth import ( + "errors" + "fmt" "math/rand" + "sync" "sync/atomic" + "time" mapset "github.com/deckarep/golang-set/v2" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/p2p/tracker" + "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" ) @@ -41,11 +47,21 @@ const ( maxQueuedTxAnns = 4096 ) +// receiptRequest tracks the state of an in-flight receipt retrieval operation. +type receiptRequest struct { + request []common.Hash // block hashes corresponding to the requested receipts + gasUsed []uint64 // block gas used corresponding to the requested receipts + timestamps []uint64 // block timestamps corresponding to the requested receipts + list []*ReceiptList // list of partially collected receipts + lastLogSize uint64 // log size of last receipt list +} + // Peer is a collection of relevant information we have about a `eth` peer. type Peer struct { + *p2p.Peer // The embedded P2P package peer + id string // Unique ID for the peer, cached - *p2p.Peer // The embedded P2P package peer rw p2p.MsgReadWriter // Input/output streams for snap version uint // Protocol version negotiated lastRange atomic.Pointer[BlockRangeUpdatePacket] @@ -55,29 +71,40 @@ type Peer struct { txBroadcast chan []common.Hash // Channel used to queue transaction propagation requests txAnnounce chan []common.Hash // Channel used to queue transaction announcement requests + tracker *tracker.Tracker reqDispatch chan *request // Dispatch channel to send requests and track then until fulfillment reqCancel chan *cancel // Dispatch channel to cancel pending requests and untrack them resDispatch chan *response // Dispatch channel to fulfil pending requests and untrack them + chainConfig *params.ChainConfig // Chain configuration for fork-aware validation + + receiptBuffer map[uint64]*receiptRequest // Previously requested receipts to buffer partial receipts + receiptBufferLock sync.Mutex // Lock for protecting the receiptBuffer + term chan struct{} // Termination channel to stop the broadcasters } // NewPeer creates a wrapper for a network connection and negotiated protocol // version. -func NewPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter, txpool TxPool) *Peer { +func NewPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter, txpool TxPool, chainConfig *params.ChainConfig) *Peer { + cap := p2p.Cap{Name: ProtocolName, Version: version} + id := p.ID().String() peer := &Peer{ - id: p.ID().String(), - Peer: p, - rw: rw, - version: version, - knownTxs: newKnownCache(maxKnownTxs), - txBroadcast: make(chan []common.Hash), - txAnnounce: make(chan []common.Hash), - reqDispatch: make(chan *request), - reqCancel: make(chan *cancel), - resDispatch: make(chan *response), - txpool: txpool, - term: make(chan struct{}), + id: p.ID().String(), + Peer: p, + rw: rw, + version: version, + knownTxs: newKnownCache(maxKnownTxs), + txBroadcast: make(chan []common.Hash), + txAnnounce: make(chan []common.Hash), + tracker: tracker.New(cap, id, 5*time.Minute), + reqDispatch: make(chan *request), + reqCancel: make(chan *cancel), + resDispatch: make(chan *response), + txpool: txpool, + chainConfig: chainConfig, + receiptBuffer: make(map[uint64]*receiptRequest), + term: make(chan struct{}), } // Start up all the broadcasters go peer.broadcastTransactions() @@ -115,9 +142,9 @@ func (p *Peer) KnownTransaction(hash common.Hash) bool { return p.knownTxs.Contains(hash) } -// markTransaction marks a transaction as known for the peer, ensuring that it +// MarkTransaction marks a transaction as known for the peer, ensuring that it // will never be propagated to this particular peer. -func (p *Peer) markTransaction(hash common.Hash) { +func (p *Peer) MarkTransaction(hash common.Hash) { // If we reached the memory allowance, drop a previously known transaction hash p.knownTxs.Add(hash) } @@ -207,11 +234,20 @@ func (p *Peer) ReplyBlockBodiesRLP(id uint64, bodies []rlp.RawValue) error { }) } -// ReplyReceiptsRLP is the response to GetReceipts. -func (p *Peer) ReplyReceiptsRLP(id uint64, receipts []rlp.RawValue) error { - return p2p.Send(p.rw, ReceiptsMsg, &ReceiptsRLPPacket{ +// ReplyReceiptsRLP69 is the response to GetReceipts. +func (p *Peer) ReplyReceiptsRLP69(id uint64, receipts rlp.RawList[*ReceiptList]) error { + return p2p.Send(p.rw, ReceiptsMsg, &ReceiptsPacket69{ + RequestId: id, + List: receipts, + }) +} + +// ReplyReceiptsRLP70 is the response to GetReceipts. +func (p *Peer) ReplyReceiptsRLP70(id uint64, receipts rlp.RawList[*ReceiptList], lastBlockIncomplete bool) error { + return p2p.Send(p.rw, ReceiptsMsg, &ReceiptsPacket70{ RequestId: id, - ReceiptsRLPResponse: receipts, + List: receipts, + LastBlockIncomplete: lastBlockIncomplete, }) } @@ -222,10 +258,11 @@ func (p *Peer) RequestOneHeader(hash common.Hash, sink chan *Response) (*Request id := rand.Uint64() req := &Request{ - id: id, - sink: sink, - code: GetBlockHeadersMsg, - want: BlockHeadersMsg, + id: id, + sink: sink, + code: GetBlockHeadersMsg, + want: BlockHeadersMsg, + numItems: 1, data: &GetBlockHeadersPacket{ RequestId: id, GetBlockHeadersRequest: &GetBlockHeadersRequest{ @@ -249,10 +286,11 @@ func (p *Peer) RequestHeadersByHash(origin common.Hash, amount int, skip int, re id := rand.Uint64() req := &Request{ - id: id, - sink: sink, - code: GetBlockHeadersMsg, - want: BlockHeadersMsg, + id: id, + sink: sink, + code: GetBlockHeadersMsg, + want: BlockHeadersMsg, + numItems: amount, data: &GetBlockHeadersPacket{ RequestId: id, GetBlockHeadersRequest: &GetBlockHeadersRequest{ @@ -276,10 +314,11 @@ func (p *Peer) RequestHeadersByNumber(origin uint64, amount int, skip int, rever id := rand.Uint64() req := &Request{ - id: id, - sink: sink, - code: GetBlockHeadersMsg, - want: BlockHeadersMsg, + id: id, + sink: sink, + code: GetBlockHeadersMsg, + want: BlockHeadersMsg, + numItems: amount, data: &GetBlockHeadersPacket{ RequestId: id, GetBlockHeadersRequest: &GetBlockHeadersRequest{ @@ -303,10 +342,11 @@ func (p *Peer) RequestBodies(hashes []common.Hash, sink chan *Response) (*Reques id := rand.Uint64() req := &Request{ - id: id, - sink: sink, - code: GetBlockBodiesMsg, - want: BlockBodiesMsg, + id: id, + sink: sink, + code: GetBlockBodiesMsg, + want: BlockBodiesMsg, + numItems: len(hashes), data: &GetBlockBodiesPacket{ RequestId: id, GetBlockBodiesRequest: hashes, @@ -319,32 +359,213 @@ func (p *Peer) RequestBodies(hashes []common.Hash, sink chan *Response) (*Reques } // RequestReceipts fetches a batch of transaction receipts from a remote node. -func (p *Peer) RequestReceipts(hashes []common.Hash, sink chan *Response) (*Request, error) { +// `gasUsed` provides the total gas used per block, used to estimate the maximum +// log byte size. `timestamps` provides the block timestamps for fork aware validation. +func (p *Peer) RequestReceipts(hashes []common.Hash, gasUsed []uint64, timestamps []uint64, sink chan *Response) (*Request, error) { p.Log().Debug("Fetching batch of receipts", "count", len(hashes)) id := rand.Uint64() + var req *Request + if p.version > ETH69 { + req = &Request{ + id: id, + sink: sink, + code: GetReceiptsMsg, + want: ReceiptsMsg, + numItems: len(hashes), + data: &GetReceiptsPacket70{ + RequestId: id, + FirstBlockReceiptIndex: 0, + GetReceiptsRequest: hashes, + }, + } + p.receiptBufferLock.Lock() + p.receiptBuffer[id] = &receiptRequest{ + request: hashes, + gasUsed: gasUsed, + timestamps: timestamps, + } + p.receiptBufferLock.Unlock() + } else { + req = &Request{ + id: id, + sink: sink, + code: GetReceiptsMsg, + want: ReceiptsMsg, + numItems: len(hashes), + data: &GetReceiptsPacket69{ + RequestId: id, + GetReceiptsRequest: hashes, + }, + } + } + if err := p.dispatchRequest(req); err != nil { + return nil, err + } + return req, nil +} + +// HandlePartialReceipts re-request partial receipts +func (p *Peer) requestPartialReceipts(id uint64) error { + p.receiptBufferLock.Lock() + defer p.receiptBufferLock.Unlock() + + // Do not re-request for the stale request + if _, ok := p.receiptBuffer[id]; !ok { + return nil + } + lastBlock := len(p.receiptBuffer[id].list) - 1 + lastReceipt := p.receiptBuffer[id].list[lastBlock].items.Len() + + hashes := p.receiptBuffer[id].request[lastBlock:] + req := &Request{ id: id, - sink: sink, + sink: nil, code: GetReceiptsMsg, want: ReceiptsMsg, - data: &GetReceiptsPacket{ - RequestId: id, - GetReceiptsRequest: hashes, + data: &GetReceiptsPacket70{ + RequestId: id, + FirstBlockReceiptIndex: uint64(lastReceipt), + GetReceiptsRequest: hashes, }, + numItems: len(hashes), } - if err := p.dispatchRequest(req); err != nil { - return nil, err + return p.dispatchRequest(req) +} + +// bufferReceipts validates a receipt packet and buffer the incomplete packet. +// If the request is completed, it appends previously collected receipts. +func (p *Peer) bufferReceipts(requestId uint64, receiptLists []*ReceiptList, lastBlockIncomplete bool, backend Backend) error { + p.receiptBufferLock.Lock() + defer p.receiptBufferLock.Unlock() + + buffer := p.receiptBuffer[requestId] + + // Short circuit for the canceled response + if buffer == nil { + return nil } - return req, nil + // If the response is empty, the peer likely does not have the requested receipts. + // Forward the empty response to the internal handler regardless. However, note + // that an empty response marked as incomplete is considered invalid. + if len(receiptLists) == 0 { + delete(p.receiptBuffer, requestId) + + if lastBlockIncomplete { + return errors.New("invalid empty receipt response with incomplete flag") + } + return nil + } + // Buffer the last block when the response is incomplete. + if lastBlockIncomplete { + lastBlock := len(receiptLists) - 1 + if len(buffer.list) > 0 { + lastBlock += len(buffer.list) - 1 + } + gasUsed := buffer.gasUsed[lastBlock] + timestamp := buffer.timestamps[lastBlock] + logSize, err := p.validateLastBlockReceipt(receiptLists, requestId, gasUsed, timestamp) + if err != nil { + delete(p.receiptBuffer, requestId) + return err + } + // Update the buffered data and trim the packet to exclude the incomplete block. + if len(buffer.list) > 0 { + // If the buffer is already allocated, it means that the previous response + // was incomplete Append the first block receipts. + buffer.list[len(buffer.list)-1].Append(receiptLists[0]) + buffer.list = append(buffer.list, receiptLists[1:]...) + buffer.lastLogSize = logSize + } else { + buffer.list = receiptLists + buffer.lastLogSize = logSize + } + return nil + } + // Short circuit if there is nothing cached previously. + if len(buffer.list) == 0 { + delete(p.receiptBuffer, requestId) + return nil + } + // Aggregate the cached result into the packet. + buffer.list[len(buffer.list)-1].Append(receiptLists[0]) + buffer.list = append(buffer.list, receiptLists[1:]...) + return nil +} + +// flushReceipts retrieves the merged receipt lists from the buffer +// and removes the buffer entry. Returns nil if no buffered data exists. +func (p *Peer) flushReceipts(requestId uint64) []*ReceiptList { + p.receiptBufferLock.Lock() + defer p.receiptBufferLock.Unlock() + + buffer, ok := p.receiptBuffer[requestId] + if !ok { + return nil + } + delete(p.receiptBuffer, requestId) + return buffer.list +} + +// validateLastBlockReceipt validates receipts and return log size of last block receipt. +// This function is called only when the `lastBlockincomplete == true`. +// +// Note that the last receipt response (which completes receiptLists of a pending block) +// is not verified here. Those response doesn't need hueristics below since they can be +// verified by its trie root. +func (p *Peer) validateLastBlockReceipt(receiptLists []*ReceiptList, id uint64, gasUsed uint64, timestamp uint64) (uint64, error) { + lastReceipts := receiptLists[len(receiptLists)-1] + + // If the receipt is in the middle of retrieval, use the buffered data. + // e.g. [[receipt1], [receipt1, receipt2], incomplete = true] + // [[receipt3, receipt4], incomplete = true] <<-- + // [[receipt5], [receipt1], incomplete = false] + // This case happens only if len(receiptLists) == 1 && incomplete == true && buffered before. + var previousTxs int + var previousLog uint64 + if buffer, ok := p.receiptBuffer[id]; ok && len(buffer.list) > 0 && len(receiptLists) == 1 { + previousTxs = buffer.list[len(buffer.list)-1].items.Len() + previousLog = buffer.lastLogSize + } + + // Verify that the total number of transactions delivered is under the limit. + var minTxGas uint64 + if p.chainConfig != nil && p.chainConfig.AmsterdamTime != nil && *p.chainConfig.AmsterdamTime <= timestamp { + minTxGas = 4500 + } else { + minTxGas = 21000 + } + if uint64(previousTxs+lastReceipts.items.Len()) > gasUsed/minTxGas { + // should be dropped, don't clear the buffer + return 0, fmt.Errorf("total number of tx exceeded limit") + } + // Count log size per receipt + log, err := lastReceipts.LogsSize() + if err != nil { + return 0, err + } + // Verify that the overall downloaded receipt size does not exceed the block gas limit. + if previousLog+log > gasUsed/params.LogDataGas { + return 0, fmt.Errorf("total download receipt size exceeded the limit") + } + return previousLog + log, nil } // RequestTxs fetches a batch of transactions from a remote node. func (p *Peer) RequestTxs(hashes []common.Hash) error { - p.Log().Debug("Fetching batch of transactions", "count", len(hashes)) + p.Log().Trace("Fetching batch of transactions", "count", len(hashes)) id := rand.Uint64() - requestTracker.Track(p.id, p.version, GetPooledTransactionsMsg, PooledTransactionsMsg, id) + err := p.tracker.Track(tracker.Request{ + ID: id, + ReqCode: GetPooledTransactionsMsg, + RespCode: PooledTransactionsMsg, + Size: len(hashes), + }) + if err != nil { + return err + } return p2p.Send(p.rw, GetPooledTransactionsMsg, &GetPooledTransactionsPacket{ RequestId: id, GetPooledTransactionsRequest: hashes, diff --git a/eth/protocols/eth/peer_test.go b/eth/protocols/eth/peer_test.go index efbbbc6fff88..81b762452e5e 100644 --- a/eth/protocols/eth/peer_test.go +++ b/eth/protocols/eth/peer_test.go @@ -45,7 +45,7 @@ func newTestPeer(name string, version uint, backend Backend) (*testPeer, <-chan var id enode.ID rand.Read(id[:]) - peer := NewPeer(version, p2p.NewPeer(id, name, nil), net, backend.TxPool()) + peer := NewPeer(version, p2p.NewPeer(id, name, nil), net, backend.TxPool(), nil) errc := make(chan error, 1) go func() { defer app.Close() diff --git a/eth/protocols/eth/protocol.go b/eth/protocols/eth/protocol.go index 7c41e7a99631..0df0776c27ad 100644 --- a/eth/protocols/eth/protocol.go +++ b/eth/protocols/eth/protocol.go @@ -20,7 +20,6 @@ import ( "errors" "fmt" "io" - "math/big" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/forkid" @@ -30,8 +29,8 @@ import ( // Constants to match up protocol versions and messages const ( - ETH68 = 68 ETH69 = 69 + ETH70 = 70 ) // ProtocolName is the official short name of the `eth` protocol used during @@ -40,15 +39,18 @@ const ProtocolName = "eth" // ProtocolVersions are the supported versions of the `eth` protocol (first // is primary). -var ProtocolVersions = []uint{ETH69, ETH68} +var ProtocolVersions = []uint{ETH70, ETH69} // protocolLengths are the number of implemented message corresponding to // different protocol versions. -var protocolLengths = map[uint]uint64{ETH68: 17, ETH69: 18} +var protocolLengths = map[uint]uint64{ETH69: 18, ETH70: 18} // maxMessageSize is the maximum cap on the size of a protocol message. const maxMessageSize = 10 * 1024 * 1024 +// This is the maximum number of transactions in a Transactions message. +const maxTransactionAnnouncements = 5000 + const ( StatusMsg = 0x00 NewBlockHashesMsg = 0x01 @@ -85,17 +87,7 @@ type Packet interface { } // StatusPacket is the network packet for the status message. -type StatusPacket68 struct { - ProtocolVersion uint32 - NetworkID uint64 - TD *big.Int - Head common.Hash - Genesis common.Hash - ForkID forkid.ID -} - -// StatusPacket69 is the network packet for the status message. -type StatusPacket69 struct { +type StatusPacket struct { ProtocolVersion uint32 NetworkID uint64 Genesis common.Hash @@ -106,28 +98,10 @@ type StatusPacket69 struct { LatestBlockHash common.Hash } -// NewBlockHashesPacket is the network packet for the block announcements. -type NewBlockHashesPacket []struct { - Hash common.Hash // Hash of one particular block being announced - Number uint64 // Number of one particular block being announced -} - -// Unpack retrieves the block hashes and numbers from the announcement packet -// and returns them in a split flat format that's more consistent with the -// internal data structures. -func (p *NewBlockHashesPacket) Unpack() ([]common.Hash, []uint64) { - var ( - hashes = make([]common.Hash, len(*p)) - numbers = make([]uint64, len(*p)) - ) - for i, body := range *p { - hashes[i], numbers[i] = body.Hash, body.Number - } - return hashes, numbers -} - // TransactionsPacket is the network packet for broadcasting new transactions. -type TransactionsPacket []*types.Transaction +type TransactionsPacket struct { + rlp.RawList[*types.Transaction] +} // GetBlockHeadersRequest represents a block header query. type GetBlockHeadersRequest struct { @@ -185,7 +159,7 @@ type BlockHeadersRequest []*types.Header // BlockHeadersPacket represents a block header response over with request ID wrapping. type BlockHeadersPacket struct { RequestId uint64 - BlockHeadersRequest + List rlp.RawList[*types.Header] } // BlockHeadersRLPResponse represents a block header response, to use when we already @@ -198,12 +172,6 @@ type BlockHeadersRLPPacket struct { BlockHeadersRLPResponse } -// NewBlockPacket is the network packet for the block propagation message. -type NewBlockPacket struct { - Block *types.Block - TD *big.Int -} - // GetBlockBodiesRequest represents a block body query. type GetBlockBodiesRequest []common.Hash @@ -213,14 +181,11 @@ type GetBlockBodiesPacket struct { GetBlockBodiesRequest } -// BlockBodiesResponse is the network packet for block content distribution. -type BlockBodiesResponse []*BlockBody - // BlockBodiesPacket is the network packet for block content distribution with // request ID wrapping. type BlockBodiesPacket struct { RequestId uint64 - BlockBodiesResponse + List rlp.RawList[BlockBody] } // BlockBodiesRLPResponse is used for replying to block body requests, in cases @@ -234,63 +199,52 @@ type BlockBodiesRLPPacket struct { BlockBodiesRLPResponse } +// BlockBodiesResponse is the network packet for block content distribution. +type BlockBodiesResponse []BlockBody + // BlockBody represents the data content of a single block. type BlockBody struct { - Transactions []*types.Transaction // Transactions contained within a block - Uncles []*types.Header // Uncles contained within a block - Withdrawals []*types.Withdrawal `rlp:"optional"` // Withdrawals contained within a block -} - -// Unpack retrieves the transactions and uncles from the range packet and returns -// them in a split flat format that's more consistent with the internal data structures. -func (p *BlockBodiesResponse) Unpack() ([][]*types.Transaction, [][]*types.Header, [][]*types.Withdrawal) { - var ( - txset = make([][]*types.Transaction, len(*p)) - uncleset = make([][]*types.Header, len(*p)) - withdrawalset = make([][]*types.Withdrawal, len(*p)) - ) - for i, body := range *p { - txset[i], uncleset[i], withdrawalset[i] = body.Transactions, body.Uncles, body.Withdrawals - } - return txset, uncleset, withdrawalset + Transactions rlp.RawList[*types.Transaction] + Uncles rlp.RawList[*types.Header] + Withdrawals *rlp.RawList[*types.Withdrawal] `rlp:"optional"` } // GetReceiptsRequest represents a block receipts query. type GetReceiptsRequest []common.Hash -// GetReceiptsPacket represents a block receipts query with request ID wrapping. -type GetReceiptsPacket struct { +// GetReceiptsPacket69 represents a block receipts query with request ID wrapping. +type GetReceiptsPacket69 struct { RequestId uint64 GetReceiptsRequest } +// GetReceiptsPacket70 represents a block receipts query with request ID and +// FirstBlockReceiptIndex wrapping. +type GetReceiptsPacket70 struct { + RequestId uint64 + FirstBlockReceiptIndex uint64 + GetReceiptsRequest +} + // ReceiptsResponse is the network packet for block receipts distribution. type ReceiptsResponse []types.Receipts -// ReceiptsList is a type constraint for block receceipt list types. -type ReceiptsList interface { - *ReceiptList68 | *ReceiptList69 - setBuffers(*receiptListBuffers) - EncodeForStorage() rlp.RawValue - types.DerivableList -} - -// ReceiptsPacket is the network packet for block receipts distribution with +// ReceiptsPacket69 is the network packet for block receipts distribution with // request ID wrapping. -type ReceiptsPacket[L ReceiptsList] struct { +type ReceiptsPacket69 struct { RequestId uint64 - List []L + List rlp.RawList[*ReceiptList] +} + +type ReceiptsPacket70 struct { + RequestId uint64 + LastBlockIncomplete bool + List rlp.RawList[*ReceiptList] } // ReceiptsRLPResponse is used for receipts, when we already have it encoded type ReceiptsRLPResponse []rlp.RawValue -// ReceiptsRLPPacket is ReceiptsRLPResponse with request ID wrapping. -type ReceiptsRLPPacket struct { - RequestId uint64 - ReceiptsRLPResponse -} - // NewPooledTransactionHashesPacket represents a transaction announcement packet on eth/68 and newer. type NewPooledTransactionHashesPacket struct { Types []byte @@ -314,7 +268,7 @@ type PooledTransactionsResponse []*types.Transaction // with request ID wrapping. type PooledTransactionsPacket struct { RequestId uint64 - PooledTransactionsResponse + List rlp.RawList[*types.Transaction] } // PooledTransactionsRLPResponse is the network packet for transaction distribution, used @@ -334,14 +288,8 @@ type BlockRangeUpdatePacket struct { LatestBlockHash common.Hash } -func (*StatusPacket68) Name() string { return "Status" } -func (*StatusPacket68) Kind() byte { return StatusMsg } - -func (*StatusPacket69) Name() string { return "Status" } -func (*StatusPacket69) Kind() byte { return StatusMsg } - -func (*NewBlockHashesPacket) Name() string { return "NewBlockHashes" } -func (*NewBlockHashesPacket) Kind() byte { return NewBlockHashesMsg } +func (*StatusPacket) Name() string { return "Status" } +func (*StatusPacket) Kind() byte { return StatusMsg } func (*TransactionsPacket) Name() string { return "Transactions" } func (*TransactionsPacket) Kind() byte { return TransactionsMsg } @@ -358,17 +306,14 @@ func (*GetBlockBodiesRequest) Kind() byte { return GetBlockBodiesMsg } func (*BlockBodiesResponse) Name() string { return "BlockBodies" } func (*BlockBodiesResponse) Kind() byte { return BlockBodiesMsg } -func (*NewBlockPacket) Name() string { return "NewBlock" } -func (*NewBlockPacket) Kind() byte { return NewBlockMsg } - func (*NewPooledTransactionHashesPacket) Name() string { return "NewPooledTransactionHashes" } func (*NewPooledTransactionHashesPacket) Kind() byte { return NewPooledTransactionHashesMsg } func (*GetPooledTransactionsRequest) Name() string { return "GetPooledTransactions" } func (*GetPooledTransactionsRequest) Kind() byte { return GetPooledTransactionsMsg } -func (*PooledTransactionsResponse) Name() string { return "PooledTransactions" } -func (*PooledTransactionsResponse) Kind() byte { return PooledTransactionsMsg } +func (*PooledTransactionsPacket) Name() string { return "PooledTransactions" } +func (*PooledTransactionsPacket) Kind() byte { return PooledTransactionsMsg } func (*GetReceiptsRequest) Name() string { return "GetReceipts" } func (*GetReceiptsRequest) Kind() byte { return GetReceiptsMsg } diff --git a/eth/protocols/eth/protocol_test.go b/eth/protocols/eth/protocol_test.go index 8a2559a6c501..04c4c0fc0680 100644 --- a/eth/protocols/eth/protocol_test.go +++ b/eth/protocols/eth/protocol_test.go @@ -78,34 +78,32 @@ func TestEmptyMessages(t *testing.T) { for i, msg := range []any{ // Headers GetBlockHeadersPacket{1111, nil}, - BlockHeadersPacket{1111, nil}, // Bodies GetBlockBodiesPacket{1111, nil}, - BlockBodiesPacket{1111, nil}, BlockBodiesRLPPacket{1111, nil}, // Receipts - GetReceiptsPacket{1111, nil}, + GetReceiptsPacket69{1111, nil}, // Transactions GetPooledTransactionsPacket{1111, nil}, - PooledTransactionsPacket{1111, nil}, PooledTransactionsRLPPacket{1111, nil}, - // Headers - BlockHeadersPacket{1111, BlockHeadersRequest([]*types.Header{})}, + BlockHeadersPacket{1111, encodeRL([]*types.Header{})}, // Bodies GetBlockBodiesPacket{1111, GetBlockBodiesRequest([]common.Hash{})}, - BlockBodiesPacket{1111, BlockBodiesResponse([]*BlockBody{})}, + BlockBodiesPacket{1111, encodeRL([]BlockBody{})}, BlockBodiesRLPPacket{1111, BlockBodiesRLPResponse([]rlp.RawValue{})}, // Receipts - GetReceiptsPacket{1111, GetReceiptsRequest([]common.Hash{})}, - ReceiptsPacket[*ReceiptList68]{1111, []*ReceiptList68{}}, - ReceiptsPacket[*ReceiptList69]{1111, []*ReceiptList69{}}, + GetReceiptsPacket69{1111, GetReceiptsRequest([]common.Hash{})}, + ReceiptsPacket69{1111, encodeRL([]*ReceiptList{})}, // Transactions GetPooledTransactionsPacket{1111, GetPooledTransactionsRequest([]common.Hash{})}, - PooledTransactionsPacket{1111, PooledTransactionsResponse([]*types.Transaction{})}, + PooledTransactionsPacket{1111, encodeRL([]*types.Transaction{})}, PooledTransactionsRLPPacket{1111, PooledTransactionsRLPResponse([]rlp.RawValue{})}, } { - if have, _ := rlp.EncodeToBytes(msg); !bytes.Equal(have, want) { + have, err := rlp.EncodeToBytes(msg) + if err != nil { + t.Errorf("test %d, type %T, error: %v", i, msg, err) + } else if !bytes.Equal(have, want) { t.Errorf("test %d, type %T, have\n\t%x\nwant\n\t%x", i, msg, have, want) } } @@ -116,13 +114,12 @@ func TestMessages(t *testing.T) { // Some basic structs used during testing var ( header *types.Header - blockBody *BlockBody + blockBody BlockBody blockBodyRlp rlp.RawValue txs []*types.Transaction txRlps []rlp.RawValue hashes []common.Hash receipts []*types.Receipt - receiptsRlp rlp.RawValue err error ) @@ -150,9 +147,9 @@ func TestMessages(t *testing.T) { } } // init the block body data, both object and rlp form - blockBody = &BlockBody{ - Transactions: txs, - Uncles: []*types.Header{header}, + blockBody = BlockBody{ + Transactions: encodeRL(txs), + Uncles: encodeRL([]*types.Header{header}), } blockBodyRlp, err = rlp.EncodeToBytes(blockBody) if err != nil { @@ -191,11 +188,6 @@ func TestMessages(t *testing.T) { } miniDeriveFields(receipts[0], 0) miniDeriveFields(receipts[1], 1) - rlpData, err := rlp.EncodeToBytes(receipts) - if err != nil { - t.Fatal(err) - } - receiptsRlp = rlpData } for i, tc := range []struct { @@ -211,7 +203,7 @@ func TestMessages(t *testing.T) { common.FromHex("ca820457c682270f050580"), }, { - BlockHeadersPacket{1111, BlockHeadersRequest{header}}, + BlockHeadersPacket{1111, encodeRL([]*types.Header{header})}, common.FromHex("f90202820457f901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000"), }, { @@ -219,7 +211,7 @@ func TestMessages(t *testing.T) { common.FromHex("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef"), }, { - BlockBodiesPacket{1111, BlockBodiesResponse([]*BlockBody{blockBody})}, + BlockBodiesPacket{1111, encodeRL([]BlockBody{blockBody})}, common.FromHex("f902dc820457f902d6f902d3f8d2f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afbf901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000"), }, { // Identical to non-rlp-shortcut version @@ -227,20 +219,11 @@ func TestMessages(t *testing.T) { common.FromHex("f902dc820457f902d6f902d3f8d2f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afbf901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000"), }, { - GetReceiptsPacket{1111, GetReceiptsRequest(hashes)}, + GetReceiptsPacket69{1111, GetReceiptsRequest(hashes)}, common.FromHex("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef"), }, { - ReceiptsPacket[*ReceiptList68]{1111, []*ReceiptList68{NewReceiptList68(receipts)}}, - common.FromHex("f902e6820457f902e0f902ddf901688082014db9010000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000004000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000f85ff85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100ffb9016f01f9016b018201bcb9010000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000001000000000000000000000000000000000000000000000000040000000000000000000000000004000000000000000000000000000000000000000000000000000000008000400000000000000000000000000000000000000000000000000000000000000000000000000000040f862f860940000000000000000000000000000000000000022f842a00000000000000000000000000000000000000000000000000000000000005668a0000000000000000000000000000000000000000000000000000000000000977386020f0f0f0608"), - }, - { - // Identical to the eth/68 encoding above. - ReceiptsRLPPacket{1111, ReceiptsRLPResponse([]rlp.RawValue{receiptsRlp})}, - common.FromHex("f902e6820457f902e0f902ddf901688082014db9010000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000004000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000f85ff85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100ffb9016f01f9016b018201bcb9010000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000001000000000000000000000000000000000000000000000000040000000000000000000000000004000000000000000000000000000000000000000000000000000000008000400000000000000000000000000000000000000000000000000000000000000000000000000000040f862f860940000000000000000000000000000000000000022f842a00000000000000000000000000000000000000000000000000000000000005668a0000000000000000000000000000000000000000000000000000000000000977386020f0f0f0608"), - }, - { - ReceiptsPacket[*ReceiptList69]{1111, []*ReceiptList69{NewReceiptList69(receipts)}}, + ReceiptsPacket69{1111, encodeRL([]*ReceiptList{NewReceiptList(receipts)})}, common.FromHex("f8da820457f8d5f8d3f866808082014df85ff85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100fff86901018201bcf862f860940000000000000000000000000000000000000022f842a00000000000000000000000000000000000000000000000000000000000005668a0000000000000000000000000000000000000000000000000000000000000977386020f0f0f0608"), }, { @@ -248,7 +231,7 @@ func TestMessages(t *testing.T) { common.FromHex("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef"), }, { - PooledTransactionsPacket{1111, PooledTransactionsResponse(txs)}, + PooledTransactionsPacket{1111, encodeRL(txs)}, common.FromHex("f8d7820457f8d2f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb"), }, { diff --git a/eth/protocols/eth/receipt.go b/eth/protocols/eth/receipt.go index 45c4766b1738..84185bea4a4f 100644 --- a/eth/protocols/eth/receipt.go +++ b/eth/protocols/eth/receipt.go @@ -27,9 +27,6 @@ import ( "github.com/ethereum/go-ethereum/rlp" ) -// This is just a sanity limit for the size of a single receipt. -const maxReceiptSize = 16 * 1024 * 1024 - // Receipt is the representation of receipts for networking purposes. type Receipt struct { TxType byte @@ -49,135 +46,18 @@ func newReceipt(tr *types.Receipt) Receipt { return r } -// decode68 parses a receipt in the eth/68 network encoding. -func (r *Receipt) decode68(buf *receiptListBuffers, s *rlp.Stream) error { - k, size, err := s.Kind() - if err != nil { - return err - } - - *r = Receipt{} - if k == rlp.List { - // Legacy receipt. - return r.decodeInnerList(s, false, true) - } - // Typed receipt. - if size < 2 || size > maxReceiptSize { - return fmt.Errorf("invalid receipt size %d", size) - } - buf.tmp.Reset() - buf.tmp.Grow(int(size)) - payload := buf.tmp.Bytes()[:int(size)] - if err := s.ReadBytes(payload); err != nil { - return err - } - r.TxType = payload[0] - s2 := rlp.NewStream(bytes.NewReader(payload[1:]), 0) - return r.decodeInnerList(s2, false, true) -} - -// decode69 parses a receipt in the eth/69 network encoding. -func (r *Receipt) decode69(s *rlp.Stream) error { - *r = Receipt{} - return r.decodeInnerList(s, true, false) -} - -// decodeDatabase parses a receipt in the basic database encoding. -func (r *Receipt) decodeDatabase(txType byte, s *rlp.Stream) error { - *r = Receipt{TxType: txType} - return r.decodeInnerList(s, false, false) -} - -func (r *Receipt) decodeInnerList(s *rlp.Stream, readTxType, readBloom bool) error { - _, err := s.List() - if err != nil { - return err - } - if readTxType { - r.TxType, err = s.Uint8() - if err != nil { - return fmt.Errorf("invalid txType: %w", err) - } - } - r.PostStateOrStatus, err = s.Bytes() - if err != nil { - return fmt.Errorf("invalid postStateOrStatus: %w", err) - } - r.GasUsed, err = s.Uint64() - if err != nil { - return fmt.Errorf("invalid gasUsed: %w", err) - } - if readBloom { - var b types.Bloom - if err := s.ReadBytes(b[:]); err != nil { - return fmt.Errorf("invalid bloom: %v", err) - } - } - r.Logs, err = s.Raw() - if err != nil { - return fmt.Errorf("invalid logs: %w", err) - } - return s.ListEnd() -} - -// encodeForStorage produces the the storage encoding, i.e. the result matches -// the RLP encoding of types.ReceiptForStorage. -func (r *Receipt) encodeForStorage(w *rlp.EncoderBuffer) { - list := w.List() - w.WriteBytes(r.PostStateOrStatus) - w.WriteUint64(r.GasUsed) - w.Write(r.Logs) - w.ListEnd(list) -} - -// encodeForNetwork68 produces the eth/68 network protocol encoding of a receipt. -// Note this recomputes the bloom filter of the receipt. -func (r *Receipt) encodeForNetwork68(buf *receiptListBuffers, w *rlp.EncoderBuffer) { - writeInner := func(w *rlp.EncoderBuffer) { - list := w.List() - w.WriteBytes(r.PostStateOrStatus) - w.WriteUint64(r.GasUsed) - bloom := r.bloom(&buf.bloom) - w.WriteBytes(bloom[:]) - w.Write(r.Logs) - w.ListEnd(list) - } - - if r.TxType == 0 { - writeInner(w) - } else { - buf.tmp.Reset() - buf.tmp.WriteByte(r.TxType) - buf.enc.Reset(&buf.tmp) - writeInner(&buf.enc) - buf.enc.Flush() - w.WriteBytes(buf.tmp.Bytes()) - } -} - -// encodeForNetwork69 produces the eth/69 network protocol encoding of a receipt. -func (r *Receipt) encodeForNetwork69(w *rlp.EncoderBuffer) { - list := w.List() - w.WriteUint64(uint64(r.TxType)) - w.WriteBytes(r.PostStateOrStatus) - w.WriteUint64(r.GasUsed) - w.Write(r.Logs) - w.ListEnd(list) -} - // encodeForHash encodes a receipt for the block receiptsRoot derivation. -func (r *Receipt) encodeForHash(buf *receiptListBuffers, out *bytes.Buffer) { +func (r *Receipt) encodeForHash(bloomBuf *[6]byte, out *bytes.Buffer) { // For typed receipts, add the tx type. if r.TxType != 0 { out.WriteByte(r.TxType) } // Encode list = [postStateOrStatus, gasUsed, bloom, logs]. - w := &buf.enc - w.Reset(out) + w := rlp.NewEncoderBuffer(out) l := w.List() w.WriteBytes(r.PostStateOrStatus) w.WriteUint64(r.GasUsed) - bloom := r.bloom(&buf.bloom) + bloom := r.bloom(bloomBuf) w.WriteBytes(bloom[:]) w.Write(r.Logs) w.ListEnd(l) @@ -210,206 +90,167 @@ func (r *Receipt) bloom(buffer *[6]byte) types.Bloom { return b } -type receiptListBuffers struct { - enc rlp.EncoderBuffer - bloom [6]byte - tmp bytes.Buffer -} - -func initBuffers(buf **receiptListBuffers) { - if *buf == nil { - *buf = new(receiptListBuffers) +// decode assigns the fields of r by decoding the network format. +func (r *Receipt) decode(input []byte) error { + input, _, err := rlp.SplitList(input) + if err != nil { + return fmt.Errorf("inner list: %v", err) } -} -// encodeForStorage encodes a list of receipts for the database. -func (buf *receiptListBuffers) encodeForStorage(rs []Receipt) rlp.RawValue { - var out bytes.Buffer - w := &buf.enc - w.Reset(&out) - outer := w.List() - for _, receipts := range rs { - receipts.encodeForStorage(w) + // txType + var txType uint64 + txType, input, err = rlp.SplitUint64(input) + if err != nil { + return fmt.Errorf("invalid txType: %w", err) } - w.ListEnd(outer) - w.Flush() - return out.Bytes() -} - -// ReceiptList68 is a block receipt list as downloaded by eth/68. -// This also implements types.DerivableList for validation purposes. -type ReceiptList68 struct { - buf *receiptListBuffers - items []Receipt -} - -// NewReceiptList68 creates a receipt list. -// This is slow, and exists for testing purposes. -func NewReceiptList68(trs []*types.Receipt) *ReceiptList68 { - rl := &ReceiptList68{items: make([]Receipt, len(trs))} - for i, tr := range trs { - rl.items[i] = newReceipt(tr) + if txType > 0x7f { + return fmt.Errorf("invalid txType: too large") } - return rl -} + r.TxType = byte(txType) -func blockReceiptsToNetwork68(blockReceipts, blockBody rlp.RawValue) ([]byte, error) { - txTypesIter, err := txTypesInBody(blockBody) + // status + r.PostStateOrStatus, input, err = rlp.SplitString(input) if err != nil { - return nil, fmt.Errorf("invalid block body: %v", err) + return fmt.Errorf("invalid postStateOrStatus: %w", err) } - nextTxType, stopTxTypes := iter.Pull(txTypesIter) - defer stopTxTypes() - - var ( - out bytes.Buffer - buf receiptListBuffers - ) - blockReceiptIter, _ := rlp.NewListIterator(blockReceipts) - innerReader := bytes.NewReader(nil) - innerStream := rlp.NewStream(innerReader, 0) - w := rlp.NewEncoderBuffer(&out) - outer := w.List() - for i := 0; blockReceiptIter.Next(); i++ { - content := blockReceiptIter.Value() - innerReader.Reset(content) - innerStream.Reset(innerReader, uint64(len(content))) - var r Receipt - txType, _ := nextTxType() - if err := r.decodeDatabase(txType, innerStream); err != nil { - return nil, fmt.Errorf("invalid database receipt %d: %v", i, err) - } - r.encodeForNetwork68(&buf, &w) + if len(r.PostStateOrStatus) > 1 && len(r.PostStateOrStatus) != 32 { + return fmt.Errorf("invalid postStateOrStatus length %d", len(r.PostStateOrStatus)) } - w.ListEnd(outer) - w.Flush() - return out.Bytes(), nil -} - -// setBuffers implements ReceiptsList. -func (rl *ReceiptList68) setBuffers(buf *receiptListBuffers) { - rl.buf = buf -} - -// EncodeForStorage encodes the receipts for storage into the database. -func (rl *ReceiptList68) EncodeForStorage() rlp.RawValue { - initBuffers(&rl.buf) - return rl.buf.encodeForStorage(rl.items) -} -// Len implements types.DerivableList. -func (rl *ReceiptList68) Len() int { - return len(rl.items) -} - -// EncodeIndex implements types.DerivableList. -func (rl *ReceiptList68) EncodeIndex(i int, out *bytes.Buffer) { - initBuffers(&rl.buf) - rl.items[i].encodeForHash(rl.buf, out) -} - -// DecodeRLP decodes a list of receipts from the network format. -func (rl *ReceiptList68) DecodeRLP(s *rlp.Stream) error { - initBuffers(&rl.buf) - if _, err := s.List(); err != nil { - return err - } - for i := 0; s.MoreDataInList(); i++ { - var item Receipt - err := item.decode68(rl.buf, s) - if err != nil { - return fmt.Errorf("receipt %d: %v", i, err) - } - rl.items = append(rl.items, item) + // gas + r.GasUsed, input, err = rlp.SplitUint64(input) + if err != nil { + return fmt.Errorf("invalid gasUsed: %w", err) } - return s.ListEnd() -} -// EncodeRLP encodes the list into the network format of eth/68. -func (rl *ReceiptList68) EncodeRLP(_w io.Writer) error { - initBuffers(&rl.buf) - w := rlp.NewEncoderBuffer(_w) - outer := w.List() - for i := range rl.items { - rl.items[i].encodeForNetwork68(rl.buf, &w) + // logs + _, rest, err := rlp.SplitList(input) + if err != nil { + return fmt.Errorf("invalid logs: %w", err) } - w.ListEnd(outer) - return w.Flush() + if len(rest) != 0 { + return fmt.Errorf("junk at end of receipt") + } + r.Logs = input + return nil } -// ReceiptList69 is the block receipt list as downloaded by eth/69. -// This implements types.DerivableList for validation purposes. -type ReceiptList69 struct { - buf *receiptListBuffers - items []Receipt +// ReceiptList is the block receipt list as downloaded by eth/69. +type ReceiptList struct { + items rlp.RawList[Receipt] } -// NewReceiptList69 creates a receipt list. +// NewReceiptList creates a receipt list. // This is slow, and exists for testing purposes. -func NewReceiptList69(trs []*types.Receipt) *ReceiptList69 { - rl := &ReceiptList69{items: make([]Receipt, len(trs))} - for i, tr := range trs { - rl.items[i] = newReceipt(tr) +func NewReceiptList(trs []*types.Receipt) *ReceiptList { + rl := new(ReceiptList) + for _, tr := range trs { + r := newReceipt(tr) + encoded, _ := rlp.EncodeToBytes(&r) + rl.items.AppendRaw(encoded) } return rl } -// setBuffers implements ReceiptsList. -func (rl *ReceiptList69) setBuffers(buf *receiptListBuffers) { - rl.buf = buf -} - -// EncodeForStorage encodes the receipts for storage into the database. -func (rl *ReceiptList69) EncodeForStorage() rlp.RawValue { - initBuffers(&rl.buf) - return rl.buf.encodeForStorage(rl.items) +// DecodeRLP decodes a list receipts from the network format. +func (rl *ReceiptList) DecodeRLP(s *rlp.Stream) error { + return rl.items.DecodeRLP(s) } -// Len implements types.DerivableList. -func (rl *ReceiptList69) Len() int { - return len(rl.items) +// EncodeRLP encodes the list into the network format of eth/69. +func (rl *ReceiptList) EncodeRLP(w io.Writer) error { + return rl.items.EncodeRLP(w) } -// EncodeIndex implements types.DerivableList. -func (rl *ReceiptList69) EncodeIndex(i int, out *bytes.Buffer) { - initBuffers(&rl.buf) - rl.items[i].encodeForHash(rl.buf, out) +// EncodeForStorage encodes a list of receipts for the database. +// It only strips the first element (TxType) from each receipt's +// raw RLP without the actual decoding and re-encoding. +func (rl *ReceiptList) EncodeForStorage() (rlp.RawValue, error) { + var out bytes.Buffer + w := rlp.NewEncoderBuffer(&out) + outer := w.List() + it := rl.items.ContentIterator() + for it.Next() { + content, _, err := rlp.SplitList(it.Value()) + if err != nil { + return nil, fmt.Errorf("bad receipt: %v", err) + } + _, _, rest, err := rlp.Split(content) + if err != nil { + return nil, fmt.Errorf("bad receipt: %v", err) + } + inner := w.List() + w.Write(rest) + w.ListEnd(inner) + } + if it.Err() != nil { + return nil, fmt.Errorf("bad list: %v", it.Err()) + } + w.ListEnd(outer) + w.Flush() + return out.Bytes(), nil } -// DecodeRLP decodes a list receipts from the network format. -func (rl *ReceiptList69) DecodeRLP(s *rlp.Stream) error { - if _, err := s.List(); err != nil { - return err - } - for i := 0; s.MoreDataInList(); i++ { - var item Receipt - err := item.decode69(s) +// Derivable returns a DerivableList, which can be used to decode +func (rl *ReceiptList) Derivable() types.DerivableList { + var bloomBuf [6]byte + return newDerivableRawList(&rl.items, func(data []byte, outbuf *bytes.Buffer) { + var r Receipt + if r.decode(data) == nil { + r.encodeForHash(&bloomBuf, outbuf) + } + }) +} + +// Append appends all items from another ReceiptList to this list. +func (rl *ReceiptList) Append(other *ReceiptList) { + rl.items.AppendList(&other.items) +} + +// LogsSize returns the total size of log data across all receipts of the list. +func (rl *ReceiptList) LogsSize() (uint64, error) { + var size uint64 + it := rl.items.ContentIterator() + for it.Next() { + // The encoded receipts are of the form: + // + // [txType, status, cumulativeGasUsed, [logs...]] + // + // We want to count the size of logs. + // So we strip the outer list first: + content, _, err := rlp.SplitList(it.Value()) + if err != nil { + return 0, fmt.Errorf("invalid receipt structure: %v", err) + } + // then skip over txType, status, cumulativeGasUsed: + rest := content + for range 3 { + _, _, rest, err = rlp.Split(rest) + if err != nil { + return 0, fmt.Errorf("invalid receipt structure: %v", err) + } + } + // and finally access the logs list to get its inner size: + logsContent, _, err := rlp.SplitList(rest) if err != nil { - return fmt.Errorf("receipt %d: %v", i, err) + return 0, fmt.Errorf("invalid receipt logs: %v", err) } - rl.items = append(rl.items, item) + size += uint64(len(logsContent)) } - return s.ListEnd() + return size, nil } -// EncodeRLP encodes the list into the network format of eth/69. -func (rl *ReceiptList69) EncodeRLP(_w io.Writer) error { - w := rlp.NewEncoderBuffer(_w) - outer := w.List() - for i := range rl.items { - rl.items[i].encodeForNetwork69(&w) - } - w.ListEnd(outer) - return w.Flush() +type receiptQueryParams struct { + firstIndex uint64 + sizeLimit uint64 } -// blockReceiptsToNetwork69 takes a slice of rlp-encoded receipts, and transactions, -// and applies the type-encoding on the receipts (for non-legacy receipts). -// e.g. for non-legacy receipts: receipt-data -> {tx-type || receipt-data} -func blockReceiptsToNetwork69(blockReceipts, blockBody rlp.RawValue) ([]byte, error) { +// blockReceiptsToNetwork takes a slice of rlp-encoded receipts (in the 'storage' encoding), +// and an encoded block body, and re-encodes the receipts for the network protocol. +func blockReceiptsToNetwork(blockReceipts, blockBody rlp.RawValue, q receiptQueryParams) (output []byte, incomplete bool, err error) { txTypesIter, err := txTypesInBody(blockBody) if err != nil { - return nil, fmt.Errorf("invalid block body: %v", err) + return nil, false, fmt.Errorf("invalid block body: %v", err) } nextTxType, stopTxTypes := iter.Pull(txTypesIter) defer stopTxTypes() @@ -421,8 +262,28 @@ func blockReceiptsToNetwork69(blockReceipts, blockBody rlp.RawValue) ([]byte, er ) outer := enc.List() for i := 0; it.Next(); i++ { - txType, _ := nextTxType() + txType, ok := nextTxType() + if !ok { + return nil, false, fmt.Errorf("block has less txs than receipts (%d)", i) + } + // Skip receipts before the requested index. + if uint64(i) < q.firstIndex { + continue + } content, _, _ := rlp.SplitList(it.Value()) + // Stop appending receipts when they would go over the size limit. + // Note we rely on the assumption that the txType is encoded as a single byte, + // which is always true because EIP-2718 does not allow tx types > 0x7f. + size := rlp.ListSize(1 + uint64(len(content))) + if q.sizeLimit > 0 && (uint64(enc.Size())+size) > q.sizeLimit { + if uint(i) == uint(q.firstIndex) { + // The first receipt doesn't fit into the size limit. + return nil, false, nil + } + incomplete = true + break + } + receiptList := enc.List() enc.WriteUint64(uint64(txType)) enc.Write(content) @@ -430,7 +291,7 @@ func blockReceiptsToNetwork69(blockReceipts, blockBody rlp.RawValue) ([]byte, er } enc.ListEnd(outer) enc.Flush() - return out.Bytes(), nil + return out.Bytes(), incomplete, nil } // txTypesInBody parses the transactions list of an encoded block body, returning just the types. diff --git a/eth/protocols/eth/receipt_test.go b/eth/protocols/eth/receipt_test.go index 3c73c07396da..237f7b9420f5 100644 --- a/eth/protocols/eth/receipt_test.go +++ b/eth/protocols/eth/receipt_test.go @@ -63,6 +63,18 @@ var receiptsTests = []struct { input: []types.ReceiptForStorage{{CumulativeGasUsed: 555, Status: 1, Logs: receiptsTestLogs2}}, txs: []*types.Transaction{types.NewTx(&types.AccessListTx{})}, }, + { + input: []types.ReceiptForStorage{ + {CumulativeGasUsed: 111, PostState: common.HexToHash("0x1111").Bytes(), Logs: receiptsTestLogs1}, + {CumulativeGasUsed: 222, Status: 0, Logs: receiptsTestLogs2}, + {CumulativeGasUsed: 333, Status: 1, Logs: nil}, + }, + txs: []*types.Transaction{ + types.NewTx(&types.LegacyTx{}), + types.NewTx(&types.AccessListTx{}), + types.NewTx(&types.DynamicFeeTx{}), + }, + }, } func init() { @@ -83,7 +95,7 @@ func init() { } } -func TestReceiptList69(t *testing.T) { +func TestReceiptList(t *testing.T) { for i, test := range receiptsTests { // encode receipts from types.ReceiptForStorage object. canonDB, _ := rlp.EncodeToBytes(test.input) @@ -93,54 +105,23 @@ func TestReceiptList69(t *testing.T) { canonBody, _ := rlp.EncodeToBytes(blockBody) // convert from storage encoding to network encoding - network, err := blockReceiptsToNetwork69(canonDB, canonBody) + network, incomplete, err := blockReceiptsToNetwork(canonDB, canonBody, receiptQueryParams{}) if err != nil { - t.Fatalf("test[%d]: blockReceiptsToNetwork69 error: %v", i, err) + t.Fatalf("test[%d]: blockReceiptsToNetwork error: %v", i, err) + } + if incomplete { + t.Fatalf("test[%d]: blockReceiptsToNetwork returned incomplete == true", i) } // parse as Receipts response list from network encoding - var rl ReceiptList69 + var rl ReceiptList if err := rlp.DecodeBytes(network, &rl); err != nil { t.Fatalf("test[%d]: can't decode network receipts: %v", i, err) } - rlStorageEnc := rl.EncodeForStorage() - if !bytes.Equal(rlStorageEnc, canonDB) { - t.Fatalf("test[%d]: re-encoded receipts not equal\nhave: %x\nwant: %x", i, rlStorageEnc, canonDB) - } - rlNetworkEnc, _ := rlp.EncodeToBytes(&rl) - if !bytes.Equal(rlNetworkEnc, network) { - t.Fatalf("test[%d]: re-encoded network receipt list not equal\nhave: %x\nwant: %x", i, rlNetworkEnc, network) - } - - // compute root hash from ReceiptList69 and compare. - responseHash := types.DeriveSha(&rl, trie.NewStackTrie(nil)) - if responseHash != test.root { - t.Fatalf("test[%d]: wrong root hash from ReceiptList69\nhave: %v\nwant: %v", i, responseHash, test.root) - } - } -} - -func TestReceiptList68(t *testing.T) { - for i, test := range receiptsTests { - // encode receipts from types.ReceiptForStorage object. - canonDB, _ := rlp.EncodeToBytes(test.input) - - // encode block body from types object. - blockBody := types.Body{Transactions: test.txs} - canonBody, _ := rlp.EncodeToBytes(blockBody) - - // convert from storage encoding to network encoding - network, err := blockReceiptsToNetwork68(canonDB, canonBody) + rlStorageEnc, err := rl.EncodeForStorage() if err != nil { - t.Fatalf("test[%d]: blockReceiptsToNetwork68 error: %v", i, err) - } - - // parse as Receipts response list from network encoding - var rl ReceiptList68 - if err := rlp.DecodeBytes(network, &rl); err != nil { - t.Fatalf("test[%d]: can't decode network receipts: %v", i, err) + t.Fatalf("test[%d]: error from EncodeForStorage: %v", i, err) } - rlStorageEnc := rl.EncodeForStorage() if !bytes.Equal(rlStorageEnc, canonDB) { t.Fatalf("test[%d]: re-encoded receipts not equal\nhave: %x\nwant: %x", i, rlStorageEnc, canonDB) } @@ -149,10 +130,10 @@ func TestReceiptList68(t *testing.T) { t.Fatalf("test[%d]: re-encoded network receipt list not equal\nhave: %x\nwant: %x", i, rlNetworkEnc, network) } - // compute root hash from ReceiptList68 and compare. - responseHash := types.DeriveSha(&rl, trie.NewStackTrie(nil)) + // compute root hash from ReceiptList and compare. + responseHash := types.DeriveSha(rl.Derivable(), trie.NewStackTrie(nil)) if responseHash != test.root { - t.Fatalf("test[%d]: wrong root hash from ReceiptList68\nhave: %v\nwant: %v", i, responseHash, test.root) + t.Fatalf("test[%d]: wrong root hash from ReceiptList\nhave: %v\nwant: %v", i, responseHash, test.root) } } } diff --git a/eth/protocols/snap/handler.go b/eth/protocols/snap/handler.go index 3249720f9015..26545f2960d7 100644 --- a/eth/protocols/snap/handler.go +++ b/eth/protocols/snap/handler.go @@ -17,23 +17,14 @@ package snap import ( - "bytes" "fmt" "time" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/rawdb" - "github.com/ethereum/go-ethereum/core/state/snapshot" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/enr" - "github.com/ethereum/go-ethereum/trie" - "github.com/ethereum/go-ethereum/trie/trienode" - "github.com/ethereum/go-ethereum/triedb/database" ) const ( @@ -53,6 +44,10 @@ const ( // number is there to limit the number of disk lookups. maxTrieNodeLookups = 1024 + // maxAccessListLookups is the maximum number of BALs to server. This number + // is there to limit the number of disk lookups. + maxAccessListLookups = 1024 + // maxTrieNodeTimeSpent is the maximum time we should spend on looking up trie nodes. // If we spend too much time, then it's a fairly high chance of timing out // at the remote side, which means all the work is in vain. @@ -94,6 +89,7 @@ func MakeProtocols(backend Backend) []p2p.Protocol { Length: protocolLengths[version], Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error { return backend.RunPeer(NewPeer(version, p, rw), func(peer *Peer) error { + defer peer.Close() return Handle(backend, peer) }) }, @@ -120,6 +116,34 @@ func Handle(backend Backend, peer *Peer) error { } } +type msgHandler func(backend Backend, msg Decoder, peer *Peer) error +type Decoder interface { + Decode(val interface{}) error +} + +var snap1 = map[uint64]msgHandler{ + GetAccountRangeMsg: handleGetAccountRange, + AccountRangeMsg: handleAccountRange, + GetStorageRangesMsg: handleGetStorageRanges, + StorageRangesMsg: handleStorageRanges, + GetByteCodesMsg: handleGetByteCodes, + ByteCodesMsg: handleByteCodes, + GetTrieNodesMsg: handleGetTrienodes, + TrieNodesMsg: handleTrieNodes, +} + +// nolint:unused +var snap2 = map[uint64]msgHandler{ + GetAccountRangeMsg: handleGetAccountRange, + AccountRangeMsg: handleAccountRange, + GetStorageRangesMsg: handleGetStorageRanges, + StorageRangesMsg: handleStorageRanges, + GetByteCodesMsg: handleGetByteCodes, + ByteCodesMsg: handleByteCodes, + GetAccessListsMsg: handleGetAccessLists, + // AccessListsMsg: TODO +} + // HandleMessage is invoked whenever an inbound message is received from a // remote peer on the `snap` protocol. The remote connection is torn down upon // returning any error. @@ -133,8 +157,19 @@ func HandleMessage(backend Backend, peer *Peer) error { return fmt.Errorf("%w: %v > %v", errMsgTooLarge, msg.Size, maxMessageSize) } defer msg.Discard() - start := time.Now() + + var handlers map[uint64]msgHandler + switch peer.version { + case SNAP1: + handlers = snap1 + //case SNAP2: + // handlers = snap2 + default: + return fmt.Errorf("unknown eth protocol version: %v", peer.version) + } + // Track the amount of time it takes to serve the request and run the handler + start := time.Now() if metrics.Enabled() { h := fmt.Sprintf("%s/%s/%d/%#02x", p2p.HandleHistName, ProtocolName, peer.Version(), msg.Code) defer func(start time.Time) { @@ -146,442 +181,11 @@ func HandleMessage(backend Backend, peer *Peer) error { metrics.GetOrRegisterHistogramLazy(h, nil, sampler).Update(time.Since(start).Microseconds()) }(start) } - // Handle the message depending on its contents - switch { - case msg.Code == GetAccountRangeMsg: - // Decode the account retrieval request - var req GetAccountRangePacket - if err := msg.Decode(&req); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - // Service the request, potentially returning nothing in case of errors - accounts, proofs := ServiceGetAccountRangeQuery(backend.Chain(), &req) - - // Send back anything accumulated (or empty in case of errors) - return p2p.Send(peer.rw, AccountRangeMsg, &AccountRangePacket{ - ID: req.ID, - Accounts: accounts, - Proof: proofs, - }) - - case msg.Code == AccountRangeMsg: - // A range of accounts arrived to one of our previous requests - res := new(AccountRangePacket) - if err := msg.Decode(res); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - // Ensure the range is monotonically increasing - for i := 1; i < len(res.Accounts); i++ { - if bytes.Compare(res.Accounts[i-1].Hash[:], res.Accounts[i].Hash[:]) >= 0 { - return fmt.Errorf("accounts not monotonically increasing: #%d [%x] vs #%d [%x]", i-1, res.Accounts[i-1].Hash[:], i, res.Accounts[i].Hash[:]) - } - } - requestTracker.Fulfil(peer.id, peer.version, AccountRangeMsg, res.ID) - - return backend.Handle(peer, res) - - case msg.Code == GetStorageRangesMsg: - // Decode the storage retrieval request - var req GetStorageRangesPacket - if err := msg.Decode(&req); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - // Service the request, potentially returning nothing in case of errors - slots, proofs := ServiceGetStorageRangesQuery(backend.Chain(), &req) - - // Send back anything accumulated (or empty in case of errors) - return p2p.Send(peer.rw, StorageRangesMsg, &StorageRangesPacket{ - ID: req.ID, - Slots: slots, - Proof: proofs, - }) - - case msg.Code == StorageRangesMsg: - // A range of storage slots arrived to one of our previous requests - res := new(StorageRangesPacket) - if err := msg.Decode(res); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - // Ensure the ranges are monotonically increasing - for i, slots := range res.Slots { - for j := 1; j < len(slots); j++ { - if bytes.Compare(slots[j-1].Hash[:], slots[j].Hash[:]) >= 0 { - return fmt.Errorf("storage slots not monotonically increasing for account #%d: #%d [%x] vs #%d [%x]", i, j-1, slots[j-1].Hash[:], j, slots[j].Hash[:]) - } - } - } - requestTracker.Fulfil(peer.id, peer.version, StorageRangesMsg, res.ID) - - return backend.Handle(peer, res) - case msg.Code == GetByteCodesMsg: - // Decode bytecode retrieval request - var req GetByteCodesPacket - if err := msg.Decode(&req); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - // Service the request, potentially returning nothing in case of errors - codes := ServiceGetByteCodesQuery(backend.Chain(), &req) - - // Send back anything accumulated (or empty in case of errors) - return p2p.Send(peer.rw, ByteCodesMsg, &ByteCodesPacket{ - ID: req.ID, - Codes: codes, - }) - - case msg.Code == ByteCodesMsg: - // A batch of byte codes arrived to one of our previous requests - res := new(ByteCodesPacket) - if err := msg.Decode(res); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - requestTracker.Fulfil(peer.id, peer.version, ByteCodesMsg, res.ID) - - return backend.Handle(peer, res) - - case msg.Code == GetTrieNodesMsg: - // Decode trie node retrieval request - var req GetTrieNodesPacket - if err := msg.Decode(&req); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - // Service the request, potentially returning nothing in case of errors - nodes, err := ServiceGetTrieNodesQuery(backend.Chain(), &req, start) - if err != nil { - return err - } - // Send back anything accumulated (or empty in case of errors) - return p2p.Send(peer.rw, TrieNodesMsg, &TrieNodesPacket{ - ID: req.ID, - Nodes: nodes, - }) - - case msg.Code == TrieNodesMsg: - // A batch of trie nodes arrived to one of our previous requests - res := new(TrieNodesPacket) - if err := msg.Decode(res); err != nil { - return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) - } - requestTracker.Fulfil(peer.id, peer.version, TrieNodesMsg, res.ID) - - return backend.Handle(peer, res) - - default: - return fmt.Errorf("%w: %v", errInvalidMsgCode, msg.Code) - } -} - -// ServiceGetAccountRangeQuery assembles the response to an account range query. -// It is exposed to allow external packages to test protocol behavior. -func ServiceGetAccountRangeQuery(chain *core.BlockChain, req *GetAccountRangePacket) ([]*AccountData, [][]byte) { - if req.Bytes > softResponseLimit { - req.Bytes = softResponseLimit - } - // Retrieve the requested state and bail out if non existent - tr, err := trie.New(trie.StateTrieID(req.Root), chain.TrieDB()) - if err != nil { - return nil, nil - } - // Temporary solution: using the snapshot interface for both cases. - // This can be removed once the hash scheme is deprecated. - var it snapshot.AccountIterator - if chain.TrieDB().Scheme() == rawdb.HashScheme { - // The snapshot is assumed to be available in hash mode if - // the SNAP protocol is enabled. - it, err = chain.Snapshots().AccountIterator(req.Root, req.Origin) - } else { - it, err = chain.TrieDB().AccountIterator(req.Root, req.Origin) - } - if err != nil { - return nil, nil - } - // Iterate over the requested range and pile accounts up - var ( - accounts []*AccountData - size uint64 - last common.Hash - ) - for it.Next() { - hash, account := it.Hash(), common.CopyBytes(it.Account()) - - // Track the returned interval for the Merkle proofs - last = hash - - // Assemble the reply item - size += uint64(common.HashLength + len(account)) - accounts = append(accounts, &AccountData{ - Hash: hash, - Body: account, - }) - // If we've exceeded the request threshold, abort - if bytes.Compare(hash[:], req.Limit[:]) >= 0 { - break - } - if size > req.Bytes { - break - } - } - it.Release() - - // Generate the Merkle proofs for the first and last account - proof := trienode.NewProofSet() - if err := tr.Prove(req.Origin[:], proof); err != nil { - log.Warn("Failed to prove account range", "origin", req.Origin, "err", err) - return nil, nil - } - if last != (common.Hash{}) { - if err := tr.Prove(last[:], proof); err != nil { - log.Warn("Failed to prove account range", "last", last, "err", err) - return nil, nil - } - } - return accounts, proof.List() -} - -func ServiceGetStorageRangesQuery(chain *core.BlockChain, req *GetStorageRangesPacket) ([][]*StorageData, [][]byte) { - if req.Bytes > softResponseLimit { - req.Bytes = softResponseLimit - } - // TODO(karalabe): Do we want to enforce > 0 accounts and 1 account if origin is set? - // TODO(karalabe): - Logging locally is not ideal as remote faults annoy the local user - // TODO(karalabe): - Dropping the remote peer is less flexible wrt client bugs (slow is better than non-functional) - - // Calculate the hard limit at which to abort, even if mid storage trie - hardLimit := uint64(float64(req.Bytes) * (1 + stateLookupSlack)) - - // Retrieve storage ranges until the packet limit is reached - var ( - slots [][]*StorageData - proofs [][]byte - size uint64 - ) - for _, account := range req.Accounts { - // If we've exceeded the requested data limit, abort without opening - // a new storage range (that we'd need to prove due to exceeded size) - if size >= req.Bytes { - break - } - // The first account might start from a different origin and end sooner - var origin common.Hash - if len(req.Origin) > 0 { - origin, req.Origin = common.BytesToHash(req.Origin), nil - } - var limit = common.MaxHash - if len(req.Limit) > 0 { - limit, req.Limit = common.BytesToHash(req.Limit), nil - } - // Retrieve the requested state and bail out if non existent - var ( - err error - it snapshot.StorageIterator - ) - // Temporary solution: using the snapshot interface for both cases. - // This can be removed once the hash scheme is deprecated. - if chain.TrieDB().Scheme() == rawdb.HashScheme { - // The snapshot is assumed to be available in hash mode if - // the SNAP protocol is enabled. - it, err = chain.Snapshots().StorageIterator(req.Root, account, origin) - } else { - it, err = chain.TrieDB().StorageIterator(req.Root, account, origin) - } - if err != nil { - return nil, nil - } - // Iterate over the requested range and pile slots up - var ( - storage []*StorageData - last common.Hash - abort bool - ) - for it.Next() { - if size >= hardLimit { - abort = true - break - } - hash, slot := it.Hash(), common.CopyBytes(it.Slot()) - - // Track the returned interval for the Merkle proofs - last = hash - - // Assemble the reply item - size += uint64(common.HashLength + len(slot)) - storage = append(storage, &StorageData{ - Hash: hash, - Body: slot, - }) - // If we've exceeded the request threshold, abort - if bytes.Compare(hash[:], limit[:]) >= 0 { - break - } - } - if len(storage) > 0 { - slots = append(slots, storage) - } - it.Release() - - // Generate the Merkle proofs for the first and last storage slot, but - // only if the response was capped. If the entire storage trie included - // in the response, no need for any proofs. - if origin != (common.Hash{}) || (abort && len(storage) > 0) { - // Request started at a non-zero hash or was capped prematurely, add - // the endpoint Merkle proofs - accTrie, err := trie.NewStateTrie(trie.StateTrieID(req.Root), chain.TrieDB()) - if err != nil { - return nil, nil - } - acc, err := accTrie.GetAccountByHash(account) - if err != nil || acc == nil { - return nil, nil - } - id := trie.StorageTrieID(req.Root, account, acc.Root) - stTrie, err := trie.NewStateTrie(id, chain.TrieDB()) - if err != nil { - return nil, nil - } - proof := trienode.NewProofSet() - if err := stTrie.Prove(origin[:], proof); err != nil { - log.Warn("Failed to prove storage range", "origin", req.Origin, "err", err) - return nil, nil - } - if last != (common.Hash{}) { - if err := stTrie.Prove(last[:], proof); err != nil { - log.Warn("Failed to prove storage range", "last", last, "err", err) - return nil, nil - } - } - proofs = append(proofs, proof.List()...) - // Proof terminates the reply as proofs are only added if a node - // refuses to serve more data (exception when a contract fetch is - // finishing, but that's that). - break - } - } - return slots, proofs -} - -// ServiceGetByteCodesQuery assembles the response to a byte codes query. -// It is exposed to allow external packages to test protocol behavior. -func ServiceGetByteCodesQuery(chain *core.BlockChain, req *GetByteCodesPacket) [][]byte { - if req.Bytes > softResponseLimit { - req.Bytes = softResponseLimit - } - if len(req.Hashes) > maxCodeLookups { - req.Hashes = req.Hashes[:maxCodeLookups] - } - // Retrieve bytecodes until the packet size limit is reached - var ( - codes [][]byte - bytes uint64 - ) - for _, hash := range req.Hashes { - if hash == types.EmptyCodeHash { - // Peers should not request the empty code, but if they do, at - // least sent them back a correct response without db lookups - codes = append(codes, []byte{}) - } else if blob := chain.ContractCodeWithPrefix(hash); len(blob) > 0 { - codes = append(codes, blob) - bytes += uint64(len(blob)) - } - if bytes > req.Bytes { - break - } - } - return codes -} - -// ServiceGetTrieNodesQuery assembles the response to a trie nodes query. -// It is exposed to allow external packages to test protocol behavior. -func ServiceGetTrieNodesQuery(chain *core.BlockChain, req *GetTrieNodesPacket, start time.Time) ([][]byte, error) { - if req.Bytes > softResponseLimit { - req.Bytes = softResponseLimit - } - // Make sure we have the state associated with the request - triedb := chain.TrieDB() - - accTrie, err := trie.NewStateTrie(trie.StateTrieID(req.Root), triedb) - if err != nil { - // We don't have the requested state available, bail out - return nil, nil - } - // The 'reader' might be nil, in which case we cannot serve storage slots - // via snapshot. - var reader database.StateReader - if chain.Snapshots() != nil { - reader = chain.Snapshots().Snapshot(req.Root) - } - if reader == nil { - reader, _ = triedb.StateReader(req.Root) - } - // Retrieve trie nodes until the packet size limit is reached - var ( - nodes [][]byte - bytes uint64 - loads int // Trie hash expansions to count database reads - ) - for _, pathset := range req.Paths { - switch len(pathset) { - case 0: - // Ensure we penalize invalid requests - return nil, fmt.Errorf("%w: zero-item pathset requested", errBadRequest) - - case 1: - // If we're only retrieving an account trie node, fetch it directly - blob, resolved, err := accTrie.GetNode(pathset[0]) - loads += resolved // always account database reads, even for failures - if err != nil { - break - } - nodes = append(nodes, blob) - bytes += uint64(len(blob)) - - default: - var stRoot common.Hash - - // Storage slots requested, open the storage trie and retrieve from there - if reader == nil { - // We don't have the requested state snapshotted yet (or it is stale), - // but can look up the account via the trie instead. - account, err := accTrie.GetAccountByHash(common.BytesToHash(pathset[0])) - loads += 8 // We don't know the exact cost of lookup, this is an estimate - if err != nil || account == nil { - break - } - stRoot = account.Root - } else { - account, err := reader.Account(common.BytesToHash(pathset[0])) - loads++ // always account database reads, even for failures - if err != nil || account == nil { - break - } - stRoot = common.BytesToHash(account.Root) - } - id := trie.StorageTrieID(req.Root, common.BytesToHash(pathset[0]), stRoot) - stTrie, err := trie.NewStateTrie(id, triedb) - loads++ // always account database reads, even for failures - if err != nil { - break - } - for _, path := range pathset[1:] { - blob, resolved, err := stTrie.GetNode(path) - loads += resolved // always account database reads, even for failures - if err != nil { - break - } - nodes = append(nodes, blob) - bytes += uint64(len(blob)) - - // Sanity check limits to avoid DoS on the store trie loads - if bytes > req.Bytes || loads > maxTrieNodeLookups || time.Since(start) > maxTrieNodeTimeSpent { - break - } - } - } - // Abort request processing if we've exceeded our limits - if bytes > req.Bytes || loads > maxTrieNodeLookups || time.Since(start) > maxTrieNodeTimeSpent { - break - } + if handler := handlers[msg.Code]; handler != nil { + return handler(backend, msg, peer) } - return nodes, nil + return fmt.Errorf("%w: %v", errInvalidMsgCode, msg.Code) } // NodeInfo represents a short summary of the `snap` sub-protocol metadata diff --git a/eth/protocols/snap/handler_fuzzing_test.go b/eth/protocols/snap/handler_fuzzing_test.go index 4930ae9ae625..a52da0aac593 100644 --- a/eth/protocols/snap/handler_fuzzing_test.go +++ b/eth/protocols/snap/handler_fuzzing_test.go @@ -60,6 +60,12 @@ func FuzzTrieNodes(f *testing.F) { }) } +func FuzzAccessLists(f *testing.F) { + f.Fuzz(func(t *testing.T, data []byte) { + doFuzz(data, &GetAccessListsPacket{}, GetAccessListsMsg) + }) +} + func doFuzz(input []byte, obj interface{}, code int) { bc := getChain() defer bc.Stop() diff --git a/eth/protocols/snap/handler_test.go b/eth/protocols/snap/handler_test.go new file mode 100644 index 000000000000..b0522c20bb47 --- /dev/null +++ b/eth/protocols/snap/handler_test.go @@ -0,0 +1,320 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package snap + +import ( + "bytes" + "encoding/binary" + "reflect" + "testing" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/beacon" + "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types/bal" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rlp" + "github.com/holiman/uint256" +) + +func makeTestBAL(minSize int) *bal.BlockAccessList { + n := minSize/33 + 1 // 33 bytes per storage read slot in RLP + access := bal.AccountAccess{ + Address: common.HexToAddress("0x01"), + StorageReads: make([]*uint256.Int, n), + } + // Use a full-width 32-byte value (top byte 0xff) so each slot still + // encodes to 33 RLP bytes regardless of the index. + for i := range access.StorageReads { + var b [32]byte + b[0] = 0xff + binary.BigEndian.PutUint64(b[24:], uint64(i)) + access.StorageReads[i] = new(uint256.Int).SetBytes(b[:]) + } + return &bal.BlockAccessList{access} +} + +// getChainWithBALs creates a minimal test chain with BALs stored for each block. +// It returns the chain, block hashes, and the stored BAL data. +func getChainWithBALs(nBlocks int, balSize int) (*core.BlockChain, []common.Hash, []rlp.RawValue) { + gspec := &core.Genesis{ + Config: params.MergedTestChainConfig, + } + db := rawdb.NewMemoryDatabase() + engine := beacon.New(ethash.NewFaker()) + _, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, nBlocks, func(i int, gen *core.BlockGen) {}) + options := &core.BlockChainConfig{ + StateScheme: rawdb.PathScheme, + TrieTimeLimit: 5 * time.Minute, + NoPrefetch: true, + } + bc, err := core.NewBlockChain(db, gspec, engine, options) + if err != nil { + panic(err) + } + if _, err := bc.InsertChain(blocks); err != nil { + panic(err) + } + + // Store BALs for each block + var ( + hashes []common.Hash + bals []rlp.RawValue + ) + for _, block := range blocks { + hash := block.Hash() + number := block.NumberU64() + + // Fill with data based on block number + bytes, err := rlp.EncodeToBytes(makeTestBAL(balSize)) + if err != nil { + panic(err) + } + rawdb.WriteAccessListRLP(db, hash, number, bytes) + hashes = append(hashes, hash) + bals = append(bals, bytes) + } + return bc, hashes, bals +} + +// TestServiceGetAccessListsQuery verifies that known block hashes return the +// correct BALs with positional correspondence. +func TestServiceGetAccessListsQuery(t *testing.T) { + t.Parallel() + bc, hashes, bals := getChainWithBALs(5, 100) + defer bc.Stop() + req := &GetAccessListsPacket{ + ID: 1, + Hashes: hashes, + Bytes: softResponseLimit, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Verify the results + if result.Len() != len(hashes) { + t.Fatalf("expected %d results, got %d", len(hashes), result.Len()) + } + var ( + index int + it = result.ContentIterator() + ) + for it.Next() { + if !bytes.Equal(it.Value(), bals[index]) { + t.Errorf("BAL %d mismatch: got %x, want %x", index, it.Value(), bals[index]) + } + index++ + } +} + +// TestServiceGetAccessListsQueryEmpty verifies that unknown block hashes return +// nil placeholders and that mixed known/unknown hashes preserve alignment. +func TestServiceGetAccessListsQueryEmpty(t *testing.T) { + t.Parallel() + bc, hashes, bals := getChainWithBALs(3, 100) + defer bc.Stop() + unknown := common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef") + mixed := []common.Hash{hashes[0], unknown, hashes[1], unknown, hashes[2]} + req := &GetAccessListsPacket{ + ID: 2, + Hashes: mixed, + Bytes: softResponseLimit, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Verify length + if result.Len() != len(mixed) { + t.Fatalf("expected %d results, got %d", len(mixed), result.Len()) + } + + // Check positional correspondence + var expectVal = []rlp.RawValue{ + bals[0], rlp.EmptyString, bals[1], rlp.EmptyString, bals[2], + } + var ( + index int + it = result.ContentIterator() + ) + for it.Next() { + if !bytes.Equal(it.Value(), expectVal[index]) { + t.Errorf("BAL %d mismatch: got %x, want %x", index, it.Value(), expectVal[index]) + } + index++ + } +} + +// TestServiceGetAccessListsQueryCap verifies that requests exceeding +// maxAccessListLookups are capped. +func TestServiceGetAccessListsQueryCap(t *testing.T) { + t.Parallel() + + bc, _, _ := getChainWithBALs(2, 100) + defer bc.Stop() + + // Create a request with more hashes than the cap + hashes := make([]common.Hash, maxAccessListLookups+100) + for i := range hashes { + hashes[i] = common.BytesToHash([]byte{byte(i), byte(i >> 8)}) + } + req := &GetAccessListsPacket{ + ID: 3, + Hashes: hashes, + Bytes: softResponseLimit, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Can't get more than maxAccessListLookups results + if result.Len() > maxAccessListLookups { + t.Fatalf("expected at most %d results, got %d", maxAccessListLookups, result.Len()) + } +} + +// TestServiceGetAccessListsQueryByteLimit verifies that the response stops +// once the byte limit is exceeded. The handler appends the entry that crosses +// the limit before breaking, so the total size will exceed the limit by at +// most one BAL. +func TestServiceGetAccessListsQueryByteLimit(t *testing.T) { + t.Parallel() + + // The handler will return 3/5 entries (3MB total) then break. + balSize := 1024 * 1024 + nBlocks := 5 + bc, hashes, _ := getChainWithBALs(nBlocks, balSize) + defer bc.Stop() + req := &GetAccessListsPacket{ + ID: 0, + Hashes: hashes, + Bytes: softResponseLimit, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Should have stopped before returning all blocks + if result.Len() >= nBlocks { + t.Fatalf("expected fewer than %d results due to byte limit, got %d", nBlocks, result.Len()) + } + + // Should have returned at least one + if result.Len() == 0 { + t.Fatal("expected at least one result") + } + + // The total size should exceed the limit (the entry that crosses it is included) + if result.Size() <= softResponseLimit { + t.Errorf("total response size %d should exceed soft limit %d (includes one entry past limit)", result.Size(), softResponseLimit) + } +} + +// TestGetAccessListResponseDecoding verifies that an AccessListsPacket +// round-trips through RLP encode/decode, preserving positional +// correspondence and correctly representing absent BALs as empty strings. +func TestGetAccessListResponseDecoding(t *testing.T) { + t.Parallel() + + // Build two real BALs of different sizes. + bal1 := makeTestBAL(100) + bal2 := makeTestBAL(200) + bytes1, _ := rlp.EncodeToBytes(bal1) + bytes2, _ := rlp.EncodeToBytes(bal2) + + tests := []struct { + name string + items []rlp.RawValue // nil entry = unavailable BAL + counts int // expected decoded length + }{ + { + name: "all present", + items: []rlp.RawValue{bytes1, bytes2}, + counts: 2, + }, + { + name: "all absent", + items: []rlp.RawValue{rlp.EmptyString, rlp.EmptyString, rlp.EmptyString}, + counts: 3, + }, + { + name: "mixed present and absent", + items: []rlp.RawValue{bytes1, rlp.EmptyString, bytes2, rlp.EmptyString}, + counts: 4, + }, + { + name: "empty response", + items: []rlp.RawValue{}, + counts: 0, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Build the packet using Append. + var orig AccessListsPacket + orig.ID = 42 + for _, item := range tt.items { + if err := orig.AccessLists.AppendRaw(item); err != nil { + t.Fatalf("AppendRaw failed: %v", err) + } + } + + // Encode -> Decode round-trip. + enc, err := rlp.EncodeToBytes(&orig) + if err != nil { + t.Fatalf("encode failed: %v", err) + } + var dec AccessListsPacket + if err := rlp.DecodeBytes(enc, &dec); err != nil { + t.Fatalf("decode failed: %v", err) + } + + // Verify ID preserved. + if dec.ID != orig.ID { + t.Fatalf("ID mismatch: got %d, want %d", dec.ID, orig.ID) + } + + // Verify element count. + if dec.AccessLists.Len() != tt.counts { + t.Fatalf("length mismatch: got %d, want %d", dec.AccessLists.Len(), tt.counts) + } + + // Verify each element positionally. + it := dec.AccessLists.ContentIterator() + for i, want := range tt.items { + if !it.Next() { + t.Fatalf("iterator exhausted at index %d", i) + } + got := it.Value() + if !bytes.Equal(got, want) { + t.Errorf("element %d: got %x, want %x", i, got, want) + } + if !bytes.Equal(got, rlp.EmptyString) { + obj := new(bal.BlockAccessList) + if err := rlp.DecodeBytes(got, obj); err != nil { + t.Fatalf("decode failed: %v", err) + } + if bytes.Equal(got, bytes1) && !reflect.DeepEqual(obj, bal1) { + t.Fatalf("decode failed: got %x, want %x", obj, bal1) + } + if bytes.Equal(got, bytes2) && !reflect.DeepEqual(obj, bal2) { + t.Fatalf("decode failed: got %x, want %x", obj, bal2) + } + } + } + if it.Next() { + t.Error("iterator has extra elements after expected end") + } + }) + } +} diff --git a/eth/protocols/snap/handlers.go b/eth/protocols/snap/handlers.go new file mode 100644 index 000000000000..5a5733bdb4c1 --- /dev/null +++ b/eth/protocols/snap/handlers.go @@ -0,0 +1,600 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see + +package snap + +import ( + "bytes" + "fmt" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/state/snapshot" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/p2p/tracker" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" + "github.com/ethereum/go-ethereum/trie/trienode" + "github.com/ethereum/go-ethereum/triedb/database" +) + +func handleGetAccountRange(backend Backend, msg Decoder, peer *Peer) error { + var req GetAccountRangePacket + if err := msg.Decode(&req); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + // Service the request, potentially returning nothing in case of errors + accounts, proofs := ServiceGetAccountRangeQuery(backend.Chain(), &req) + + // Send back anything accumulated (or empty in case of errors) + return p2p.Send(peer.rw, AccountRangeMsg, &AccountRangePacket{ + ID: req.ID, + Accounts: accounts, + Proof: proofs, + }) +} + +// ServiceGetAccountRangeQuery assembles the response to an account range query. +// It is exposed to allow external packages to test protocol behavior. +func ServiceGetAccountRangeQuery(chain *core.BlockChain, req *GetAccountRangePacket) ([]*AccountData, [][]byte) { + if req.Bytes > softResponseLimit { + req.Bytes = softResponseLimit + } + // Retrieve the requested state and bail out if non existent + tr, err := trie.New(trie.StateTrieID(req.Root), chain.TrieDB()) + if err != nil { + return nil, nil + } + // Temporary solution: using the snapshot interface for both cases. + // This can be removed once the hash scheme is deprecated. + var it snapshot.AccountIterator + if chain.TrieDB().Scheme() == rawdb.HashScheme { + // The snapshot is assumed to be available in hash mode if + // the SNAP protocol is enabled. + it, err = chain.Snapshots().AccountIterator(req.Root, req.Origin) + } else { + it, err = chain.TrieDB().AccountIterator(req.Root, req.Origin) + } + if err != nil { + return nil, nil + } + // Iterate over the requested range and pile accounts up + var ( + accounts []*AccountData + size uint64 + last common.Hash + ) + for it.Next() { + hash, account := it.Hash(), common.CopyBytes(it.Account()) + + // Track the returned interval for the Merkle proofs + last = hash + + // Assemble the reply item + size += uint64(common.HashLength + len(account)) + accounts = append(accounts, &AccountData{ + Hash: hash, + Body: account, + }) + // If we've exceeded the request threshold, abort + if bytes.Compare(hash[:], req.Limit[:]) >= 0 { + break + } + if size > req.Bytes { + break + } + } + it.Release() + + // Generate the Merkle proofs for the first and last account + proof := trienode.NewProofSet() + if err := tr.Prove(req.Origin[:], proof); err != nil { + log.Warn("Failed to prove account range", "origin", req.Origin, "err", err) + return nil, nil + } + if last != (common.Hash{}) { + if err := tr.Prove(last[:], proof); err != nil { + log.Warn("Failed to prove account range", "last", last, "err", err) + return nil, nil + } + } + return accounts, proof.List() +} + +func handleAccountRange(backend Backend, msg Decoder, peer *Peer) error { + res := new(accountRangeInput) + if err := msg.Decode(res); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + + // Check response validity. + if len := res.Proof.Len(); len > 128 { + return fmt.Errorf("AccountRange: invalid proof (length %d)", len) + } + tresp := tracker.Response{ID: res.ID, MsgCode: AccountRangeMsg, Size: len(res.Accounts.Content())} + if err := peer.tracker.Fulfil(tresp); err != nil { + return err + } + + // Decode. + accounts, err := res.Accounts.Items() + if err != nil { + return fmt.Errorf("AccountRange: invalid accounts list: %v", err) + } + proof, err := res.Proof.Items() + if err != nil { + return fmt.Errorf("AccountRange: invalid proof: %v", err) + } + + // Ensure the range is monotonically increasing + for i := 1; i < len(accounts); i++ { + if bytes.Compare(accounts[i-1].Hash[:], accounts[i].Hash[:]) >= 0 { + return fmt.Errorf("accounts not monotonically increasing: #%d [%x] vs #%d [%x]", i-1, accounts[i-1].Hash[:], i, accounts[i].Hash[:]) + } + } + + return backend.Handle(peer, &AccountRangePacket{res.ID, accounts, proof}) +} + +func handleGetStorageRanges(backend Backend, msg Decoder, peer *Peer) error { + var req GetStorageRangesPacket + if err := msg.Decode(&req); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + // Service the request, potentially returning nothing in case of errors + slots, proofs := ServiceGetStorageRangesQuery(backend.Chain(), &req) + + // Send back anything accumulated (or empty in case of errors) + return p2p.Send(peer.rw, StorageRangesMsg, &StorageRangesPacket{ + ID: req.ID, + Slots: slots, + Proof: proofs, + }) +} + +func ServiceGetStorageRangesQuery(chain *core.BlockChain, req *GetStorageRangesPacket) ([][]*StorageData, [][]byte) { + if req.Bytes > softResponseLimit { + req.Bytes = softResponseLimit + } + // TODO(karalabe): Do we want to enforce > 0 accounts and 1 account if origin is set? + // TODO(karalabe): - Logging locally is not ideal as remote faults annoy the local user + // TODO(karalabe): - Dropping the remote peer is less flexible wrt client bugs (slow is better than non-functional) + + // Calculate the hard limit at which to abort, even if mid storage trie + hardLimit := uint64(float64(req.Bytes) * (1 + stateLookupSlack)) + + // Retrieve storage ranges until the packet limit is reached + var ( + slots [][]*StorageData + proofs [][]byte + size uint64 + ) + for _, account := range req.Accounts { + // If we've exceeded the requested data limit, abort without opening + // a new storage range (that we'd need to prove due to exceeded size) + if size >= req.Bytes { + break + } + // The first account might start from a different origin and end sooner + var origin common.Hash + if len(req.Origin) > 0 { + origin, req.Origin = common.BytesToHash(req.Origin), nil + } + var limit = common.MaxHash + if len(req.Limit) > 0 { + limit, req.Limit = common.BytesToHash(req.Limit), nil + } + // Retrieve the requested state and bail out if non existent + var ( + err error + it snapshot.StorageIterator + ) + // Temporary solution: using the snapshot interface for both cases. + // This can be removed once the hash scheme is deprecated. + if chain.TrieDB().Scheme() == rawdb.HashScheme { + // The snapshot is assumed to be available in hash mode if + // the SNAP protocol is enabled. + it, err = chain.Snapshots().StorageIterator(req.Root, account, origin) + } else { + it, err = chain.TrieDB().StorageIterator(req.Root, account, origin) + } + if err != nil { + return nil, nil + } + // Iterate over the requested range and pile slots up + var ( + storage []*StorageData + last common.Hash + abort bool + ) + for it.Next() { + if size >= hardLimit { + abort = true + break + } + hash, slot := it.Hash(), common.CopyBytes(it.Slot()) + + // Track the returned interval for the Merkle proofs + last = hash + + // Assemble the reply item + size += uint64(common.HashLength + len(slot)) + storage = append(storage, &StorageData{ + Hash: hash, + Body: slot, + }) + // If we've exceeded the request threshold, abort + if bytes.Compare(hash[:], limit[:]) >= 0 { + break + } + } + if len(storage) > 0 { + slots = append(slots, storage) + } + it.Release() + + // Generate the Merkle proofs for the first and last storage slot, but + // only if the response was capped. If the entire storage trie included + // in the response, no need for any proofs. + if origin != (common.Hash{}) || (abort && len(storage) > 0) { + // Request started at a non-zero hash or was capped prematurely, add + // the endpoint Merkle proofs + accTrie, err := trie.NewStateTrie(trie.StateTrieID(req.Root), chain.TrieDB()) + if err != nil { + return nil, nil + } + acc, err := accTrie.GetAccountByHash(account) + if err != nil || acc == nil { + return nil, nil + } + id := trie.StorageTrieID(req.Root, account, acc.Root) + stTrie, err := trie.NewStateTrie(id, chain.TrieDB()) + if err != nil { + return nil, nil + } + proof := trienode.NewProofSet() + if err := stTrie.Prove(origin[:], proof); err != nil { + log.Warn("Failed to prove storage range", "origin", req.Origin, "err", err) + return nil, nil + } + if last != (common.Hash{}) { + if err := stTrie.Prove(last[:], proof); err != nil { + log.Warn("Failed to prove storage range", "last", last, "err", err) + return nil, nil + } + } + proofs = append(proofs, proof.List()...) + // Proof terminates the reply as proofs are only added if a node + // refuses to serve more data (exception when a contract fetch is + // finishing, but that's that). + break + } + } + return slots, proofs +} + +func handleStorageRanges(backend Backend, msg Decoder, peer *Peer) error { + res := new(storageRangesInput) + if err := msg.Decode(res); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + + // Check response validity. + if len := res.Proof.Len(); len > 128 { + return fmt.Errorf("StorageRangesMsg: invalid proof (length %d)", len) + } + tresp := tracker.Response{ID: res.ID, MsgCode: StorageRangesMsg, Size: len(res.Slots.Content())} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("StorageRangesMsg: %w", err) + } + + // Decode. + slotLists, err := res.Slots.Items() + if err != nil { + return fmt.Errorf("AccountRange: invalid accounts list: %v", err) + } + proof, err := res.Proof.Items() + if err != nil { + return fmt.Errorf("AccountRange: invalid proof: %v", err) + } + + // Ensure the ranges are monotonically increasing + for i, slots := range slotLists { + for j := 1; j < len(slots); j++ { + if bytes.Compare(slots[j-1].Hash[:], slots[j].Hash[:]) >= 0 { + return fmt.Errorf("storage slots not monotonically increasing for account #%d: #%d [%x] vs #%d [%x]", i, j-1, slots[j-1].Hash[:], j, slots[j].Hash[:]) + } + } + } + + return backend.Handle(peer, &StorageRangesPacket{res.ID, slotLists, proof}) +} + +func handleGetByteCodes(backend Backend, msg Decoder, peer *Peer) error { + var req GetByteCodesPacket + if err := msg.Decode(&req); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + // Service the request, potentially returning nothing in case of errors + codes := ServiceGetByteCodesQuery(backend.Chain(), &req) + + // Send back anything accumulated (or empty in case of errors) + return p2p.Send(peer.rw, ByteCodesMsg, &ByteCodesPacket{ + ID: req.ID, + Codes: codes, + }) +} + +// ServiceGetByteCodesQuery assembles the response to a byte codes query. +// It is exposed to allow external packages to test protocol behavior. +func ServiceGetByteCodesQuery(chain *core.BlockChain, req *GetByteCodesPacket) [][]byte { + if req.Bytes > softResponseLimit { + req.Bytes = softResponseLimit + } + if len(req.Hashes) > maxCodeLookups { + req.Hashes = req.Hashes[:maxCodeLookups] + } + // Retrieve bytecodes until the packet size limit is reached + var ( + codes [][]byte + bytes uint64 + ) + for _, hash := range req.Hashes { + if hash == types.EmptyCodeHash { + // Peers should not request the empty code, but if they do, at + // least sent them back a correct response without db lookups + codes = append(codes, []byte{}) + } else if blob := chain.ContractCodeWithPrefix(hash); len(blob) > 0 { + codes = append(codes, blob) + bytes += uint64(len(blob)) + } + if bytes > req.Bytes { + break + } + } + return codes +} + +func handleByteCodes(backend Backend, msg Decoder, peer *Peer) error { + res := new(byteCodesInput) + if err := msg.Decode(res); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + + length := res.Codes.Len() + tresp := tracker.Response{ID: res.ID, MsgCode: ByteCodesMsg, Size: length} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("ByteCodes: %w", err) + } + + codes, err := res.Codes.Items() + if err != nil { + return fmt.Errorf("ByteCodes: %w", err) + } + + return backend.Handle(peer, &ByteCodesPacket{res.ID, codes}) +} + +func handleGetTrienodes(backend Backend, msg Decoder, peer *Peer) error { + var req GetTrieNodesPacket + if err := msg.Decode(&req); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + // Service the request, potentially returning nothing in case of errors + nodes, err := ServiceGetTrieNodesQuery(backend.Chain(), &req) + if err != nil { + return err + } + // Send back anything accumulated (or empty in case of errors) + return p2p.Send(peer.rw, TrieNodesMsg, &TrieNodesPacket{ + ID: req.ID, + Nodes: nodes, + }) +} + +func nextBytes(it *rlp.Iterator) []byte { + if !it.Next() { + return nil + } + content, _, err := rlp.SplitString(it.Value()) + if err != nil { + return nil + } + return content +} + +// ServiceGetTrieNodesQuery assembles the response to a trie nodes query. +// It is exposed to allow external packages to test protocol behavior. +func ServiceGetTrieNodesQuery(chain *core.BlockChain, req *GetTrieNodesPacket) ([][]byte, error) { + start := time.Now() + if req.Bytes > softResponseLimit { + req.Bytes = softResponseLimit + } + // Make sure we have the state associated with the request + triedb := chain.TrieDB() + + accTrie, err := trie.NewStateTrie(trie.StateTrieID(req.Root), triedb) + if err != nil { + // We don't have the requested state available, bail out + return nil, nil + } + // The 'reader' might be nil, in which case we cannot serve storage slots + // via snapshot. + var reader database.StateReader + if chain.Snapshots() != nil { + reader = chain.Snapshots().Snapshot(req.Root) + } + if reader == nil { + reader, _ = triedb.StateReader(req.Root) + } + + // Retrieve trie nodes until the packet size limit is reached + var ( + outerIt = req.Paths.ContentIterator() + nodes [][]byte + bytes uint64 + loads int // Trie hash expansions to count database reads + ) + for outerIt.Next() { + innerIt, err := rlp.NewListIterator(outerIt.Value()) + if err != nil { + return nodes, err + } + + switch innerIt.Count() { + case 0: + // Ensure we penalize invalid requests + return nil, fmt.Errorf("%w: zero-item pathset requested", errBadRequest) + + case 1: + // If we're only retrieving an account trie node, fetch it directly + accKey := nextBytes(&innerIt) + if accKey == nil { + return nodes, fmt.Errorf("%w: invalid account node request", errBadRequest) + } + blob, resolved, err := accTrie.GetNode(accKey) + loads += resolved // always account database reads, even for failures + if err != nil { + break + } + nodes = append(nodes, blob) + bytes += uint64(len(blob)) + + default: + // Storage slots requested, open the storage trie and retrieve from there + accKey := nextBytes(&innerIt) + if accKey == nil { + return nodes, fmt.Errorf("%w: invalid account storage request", errBadRequest) + } + var stRoot common.Hash + if reader == nil { + // We don't have the requested state snapshotted yet (or it is stale), + // but can look up the account via the trie instead. + account, err := accTrie.GetAccountByHash(common.BytesToHash(accKey)) + loads += 8 // We don't know the exact cost of lookup, this is an estimate + if err != nil || account == nil { + break + } + stRoot = account.Root + } else { + account, err := reader.Account(common.BytesToHash(accKey)) + loads++ // always account database reads, even for failures + if err != nil || account == nil { + break + } + stRoot = common.BytesToHash(account.Root) + } + + id := trie.StorageTrieID(req.Root, common.BytesToHash(accKey), stRoot) + stTrie, err := trie.NewStateTrie(id, triedb) + loads++ // always account database reads, even for failures + if err != nil { + break + } + for innerIt.Next() { + path, _, err := rlp.SplitString(innerIt.Value()) + if err != nil { + return nil, fmt.Errorf("%w: invalid storage key: %v", errBadRequest, err) + } + blob, resolved, err := stTrie.GetNode(path) + loads += resolved // always account database reads, even for failures + if err != nil { + break + } + nodes = append(nodes, blob) + bytes += uint64(len(blob)) + + // Sanity check limits to avoid DoS on the store trie loads + if bytes > req.Bytes || loads > maxTrieNodeLookups || time.Since(start) > maxTrieNodeTimeSpent { + break + } + } + } + // Abort request processing if we've exceeded our limits + if bytes > req.Bytes || loads > maxTrieNodeLookups || time.Since(start) > maxTrieNodeTimeSpent { + break + } + } + return nodes, nil +} + +func handleTrieNodes(backend Backend, msg Decoder, peer *Peer) error { + res := new(trieNodesInput) + if err := msg.Decode(res); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + + tresp := tracker.Response{ID: res.ID, MsgCode: TrieNodesMsg, Size: res.Nodes.Len()} + if err := peer.tracker.Fulfil(tresp); err != nil { + return fmt.Errorf("TrieNodes: %w", err) + } + nodes, err := res.Nodes.Items() + if err != nil { + return fmt.Errorf("TrieNodes: %w", err) + } + + return backend.Handle(peer, &TrieNodesPacket{res.ID, nodes}) +} + +// nolint:unused +func handleGetAccessLists(backend Backend, msg Decoder, peer *Peer) error { + var req GetAccessListsPacket + if err := msg.Decode(&req); err != nil { + return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) + } + return p2p.Send(peer.rw, AccessListsMsg, &AccessListsPacket{ + ID: req.ID, + AccessLists: ServiceGetAccessListsQuery(backend.Chain(), &req), + }) +} + +// ServiceGetAccessListsQuery assembles the response to an access list query. +// It is exposed to allow external packages to test protocol behavior. +func ServiceGetAccessListsQuery(chain *core.BlockChain, req *GetAccessListsPacket) rlp.RawList[rlp.RawValue] { + if req.Bytes > softResponseLimit { + req.Bytes = softResponseLimit + } + // Cap the number of lookups + if len(req.Hashes) > maxAccessListLookups { + req.Hashes = req.Hashes[:maxAccessListLookups] + } + var ( + err error + bytes uint64 + response = rlp.RawList[rlp.RawValue]{} + ) + for _, hash := range req.Hashes { + if bal := chain.GetAccessListRLP(hash); len(bal) > 0 { + err = response.AppendRaw(bal) + bytes += uint64(len(bal)) + } else { + // Either the block is unknown or the BAL doesn't exist + err = response.AppendRaw(rlp.EmptyString) + bytes += 1 + } + if err != nil { + break + } + if bytes > req.Bytes { + break + } + } + return response +} diff --git a/eth/protocols/snap/peer.go b/eth/protocols/snap/peer.go index c57931678cec..0b96de4158af 100644 --- a/eth/protocols/snap/peer.go +++ b/eth/protocols/snap/peer.go @@ -17,9 +17,13 @@ package snap import ( + "time" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/p2p/tracker" + "github.com/ethereum/go-ethereum/rlp" ) // Peer is a collection of relevant information we have about a `snap` peer. @@ -29,6 +33,7 @@ type Peer struct { *p2p.Peer // The embedded P2P package peer rw p2p.MsgReadWriter // Input/output streams for snap version uint // Protocol version negotiated + tracker *tracker.Tracker logger log.Logger // Contextual logger with the peer id injected } @@ -36,22 +41,26 @@ type Peer struct { // NewPeer creates a wrapper for a network connection and negotiated protocol // version. func NewPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter) *Peer { + cap := p2p.Cap{Name: ProtocolName, Version: version} id := p.ID().String() return &Peer{ id: id, Peer: p, rw: rw, version: version, + tracker: tracker.New(cap, id, 1*time.Minute), logger: log.New("peer", id[:8]), } } // NewFakePeer creates a fake snap peer without a backing p2p peer, for testing purposes. func NewFakePeer(version uint, id string, rw p2p.MsgReadWriter) *Peer { + cap := p2p.Cap{Name: ProtocolName, Version: version} return &Peer{ id: id, rw: rw, version: version, + tracker: tracker.New(cap, id, 1*time.Minute), logger: log.New("peer", id[:8]), } } @@ -71,63 +80,99 @@ func (p *Peer) Log() log.Logger { return p.logger } +// Close releases resources associated with the peer. +func (p *Peer) Close() { + p.tracker.Stop() +} + // RequestAccountRange fetches a batch of accounts rooted in a specific account // trie, starting with the origin. -func (p *Peer) RequestAccountRange(id uint64, root common.Hash, origin, limit common.Hash, bytes uint64) error { +func (p *Peer) RequestAccountRange(id uint64, root common.Hash, origin, limit common.Hash, bytes int) error { p.logger.Trace("Fetching range of accounts", "reqid", id, "root", root, "origin", origin, "limit", limit, "bytes", common.StorageSize(bytes)) - requestTracker.Track(p.id, p.version, GetAccountRangeMsg, AccountRangeMsg, id) + err := p.tracker.Track(tracker.Request{ + ReqCode: GetAccountRangeMsg, + RespCode: AccountRangeMsg, + ID: id, + Size: 2 * bytes, + }) + if err != nil { + return err + } return p2p.Send(p.rw, GetAccountRangeMsg, &GetAccountRangePacket{ ID: id, Root: root, Origin: origin, Limit: limit, - Bytes: bytes, + Bytes: uint64(bytes), }) } // RequestStorageRanges fetches a batch of storage slots belonging to one or more // accounts. If slots from only one account is requested, an origin marker may also // be used to retrieve from there. -func (p *Peer) RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes uint64) error { +func (p *Peer) RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes int) error { if len(accounts) == 1 && origin != nil { p.logger.Trace("Fetching range of large storage slots", "reqid", id, "root", root, "account", accounts[0], "origin", common.BytesToHash(origin), "limit", common.BytesToHash(limit), "bytes", common.StorageSize(bytes)) } else { p.logger.Trace("Fetching ranges of small storage slots", "reqid", id, "root", root, "accounts", len(accounts), "first", accounts[0], "bytes", common.StorageSize(bytes)) } - requestTracker.Track(p.id, p.version, GetStorageRangesMsg, StorageRangesMsg, id) + + p.tracker.Track(tracker.Request{ + ReqCode: GetStorageRangesMsg, + RespCode: StorageRangesMsg, + ID: id, + Size: 2 * bytes, + }) return p2p.Send(p.rw, GetStorageRangesMsg, &GetStorageRangesPacket{ ID: id, Root: root, Accounts: accounts, Origin: origin, Limit: limit, - Bytes: bytes, + Bytes: uint64(bytes), }) } // RequestByteCodes fetches a batch of bytecodes by hash. -func (p *Peer) RequestByteCodes(id uint64, hashes []common.Hash, bytes uint64) error { +func (p *Peer) RequestByteCodes(id uint64, hashes []common.Hash, bytes int) error { p.logger.Trace("Fetching set of byte codes", "reqid", id, "hashes", len(hashes), "bytes", common.StorageSize(bytes)) - requestTracker.Track(p.id, p.version, GetByteCodesMsg, ByteCodesMsg, id) + err := p.tracker.Track(tracker.Request{ + ReqCode: GetByteCodesMsg, + RespCode: ByteCodesMsg, + ID: id, + Size: len(hashes), // ByteCodes is limited by the length of the hash list. + }) + if err != nil { + return err + } return p2p.Send(p.rw, GetByteCodesMsg, &GetByteCodesPacket{ ID: id, Hashes: hashes, - Bytes: bytes, + Bytes: uint64(bytes), }) } // RequestTrieNodes fetches a batch of account or storage trie nodes rooted in -// a specific state trie. -func (p *Peer) RequestTrieNodes(id uint64, root common.Hash, paths []TrieNodePathSet, bytes uint64) error { +// a specific state trie. The `count` is the total count of paths being requested. +func (p *Peer) RequestTrieNodes(id uint64, root common.Hash, count int, paths []TrieNodePathSet, bytes int) error { p.logger.Trace("Fetching set of trie nodes", "reqid", id, "root", root, "pathsets", len(paths), "bytes", common.StorageSize(bytes)) - requestTracker.Track(p.id, p.version, GetTrieNodesMsg, TrieNodesMsg, id) + err := p.tracker.Track(tracker.Request{ + ReqCode: GetTrieNodesMsg, + RespCode: TrieNodesMsg, + ID: id, + Size: count, // TrieNodes is limited by number of items. + }) + if err != nil { + return err + } + encPaths, _ := rlp.EncodeToRawList(paths) return p2p.Send(p.rw, GetTrieNodesMsg, &GetTrieNodesPacket{ ID: id, Root: root, - Paths: paths, - Bytes: bytes, + Paths: encPaths, + Bytes: uint64(bytes), }) } diff --git a/eth/protocols/snap/protocol.go b/eth/protocols/snap/protocol.go index 0db206b0810e..685f468da3da 100644 --- a/eth/protocols/snap/protocol.go +++ b/eth/protocols/snap/protocol.go @@ -28,6 +28,7 @@ import ( // Constants to match up protocol versions and messages const ( SNAP1 = 1 + //SNAP2 = 2 ) // ProtocolName is the official short name of the `snap` protocol used during @@ -40,7 +41,7 @@ var ProtocolVersions = []uint{SNAP1} // protocolLengths are the number of implemented message corresponding to // different protocol versions. -var protocolLengths = map[uint]uint64{SNAP1: 8} +var protocolLengths = map[uint]uint64{ /*SNAP2: 10,*/ SNAP1: 8} // maxMessageSize is the maximum cap on the size of a protocol message. const maxMessageSize = 10 * 1024 * 1024 @@ -54,6 +55,8 @@ const ( ByteCodesMsg = 0x05 GetTrieNodesMsg = 0x06 TrieNodesMsg = 0x07 + GetAccessListsMsg = 0x08 + AccessListsMsg = 0x09 ) var ( @@ -78,6 +81,12 @@ type GetAccountRangePacket struct { Bytes uint64 // Soft limit at which to stop returning data } +type accountRangeInput struct { + ID uint64 // ID of the request this is a response for + Accounts rlp.RawList[*AccountData] // List of consecutive accounts from the trie + Proof rlp.RawList[[]byte] // List of trie nodes proving the account range +} + // AccountRangePacket represents an account query response. type AccountRangePacket struct { ID uint64 // ID of the request this is a response for @@ -123,6 +132,12 @@ type GetStorageRangesPacket struct { Bytes uint64 // Soft limit at which to stop returning data } +type storageRangesInput struct { + ID uint64 // ID of the request this is a response for + Slots rlp.RawList[[]*StorageData] // Lists of consecutive storage slots for the requested accounts + Proof rlp.RawList[[]byte] // Merkle proofs for the *last* slot range, if it's incomplete +} + // StorageRangesPacket represents a storage slot query response. type StorageRangesPacket struct { ID uint64 // ID of the request this is a response for @@ -161,6 +176,11 @@ type GetByteCodesPacket struct { Bytes uint64 // Soft limit at which to stop returning data } +type byteCodesInput struct { + ID uint64 // ID of the request this is a response for + Codes rlp.RawList[[]byte] // Requested contract bytecodes +} + // ByteCodesPacket represents a contract bytecode query response. type ByteCodesPacket struct { ID uint64 // ID of the request this is a response for @@ -169,10 +189,10 @@ type ByteCodesPacket struct { // GetTrieNodesPacket represents a state trie node query. type GetTrieNodesPacket struct { - ID uint64 // Request ID to match up responses with - Root common.Hash // Root hash of the account trie to serve - Paths []TrieNodePathSet // Trie node hashes to retrieve the nodes for - Bytes uint64 // Soft limit at which to stop returning data + ID uint64 // Request ID to match up responses with + Root common.Hash // Root hash of the account trie to serve + Paths rlp.RawList[TrieNodePathSet] // Trie node hashes to retrieve the nodes for + Bytes uint64 // Soft limit at which to stop returning data } // TrieNodePathSet is a list of trie node paths to retrieve. A naive way to @@ -187,12 +207,32 @@ type GetTrieNodesPacket struct { // that a slot is accessed before the account path is fully expanded. type TrieNodePathSet [][]byte +type trieNodesInput struct { + ID uint64 // ID of the request this is a response for + Nodes rlp.RawList[[]byte] // Requested state trie nodes +} + // TrieNodesPacket represents a state trie node query response. type TrieNodesPacket struct { ID uint64 // ID of the request this is a response for Nodes [][]byte // Requested state trie nodes } +// GetAccessListsPacket requests BALs for a set of block hashes. +type GetAccessListsPacket struct { + ID uint64 // Request ID to match up responses with + Hashes []common.Hash // Block hashes to retrieve BALs for + Bytes uint64 // Soft limit at which to stop returning data +} + +// AccessListsPacket is the response to GetAccessListsPacket. +// Each entry corresponds to the requested hash at the same index. +// Empty entries indicate the BAL is unavailable. +type AccessListsPacket struct { + ID uint64 // ID of the request this is a response for + AccessLists rlp.RawList[rlp.RawValue] // Requested BALs +} + func (*GetAccountRangePacket) Name() string { return "GetAccountRange" } func (*GetAccountRangePacket) Kind() byte { return GetAccountRangeMsg } @@ -216,3 +256,9 @@ func (*GetTrieNodesPacket) Kind() byte { return GetTrieNodesMsg } func (*TrieNodesPacket) Name() string { return "TrieNodes" } func (*TrieNodesPacket) Kind() byte { return TrieNodesMsg } + +func (*GetAccessListsPacket) Name() string { return "GetAccessLists" } +func (*GetAccessListsPacket) Kind() byte { return GetAccessListsMsg } + +func (*AccessListsPacket) Name() string { return "AccessLists" } +func (*AccessListsPacket) Kind() byte { return AccessListsMsg } diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go index cf4e49464530..841bfb446ebd 100644 --- a/eth/protocols/snap/sync.go +++ b/eth/protocols/snap/sync.go @@ -412,19 +412,19 @@ type SyncPeer interface { // RequestAccountRange fetches a batch of accounts rooted in a specific account // trie, starting with the origin. - RequestAccountRange(id uint64, root, origin, limit common.Hash, bytes uint64) error + RequestAccountRange(id uint64, root, origin, limit common.Hash, bytes int) error // RequestStorageRanges fetches a batch of storage slots belonging to one or // more accounts. If slots from only one account is requested, an origin marker // may also be used to retrieve from there. - RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes uint64) error + RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes int) error // RequestByteCodes fetches a batch of bytecodes by hash. - RequestByteCodes(id uint64, hashes []common.Hash, bytes uint64) error + RequestByteCodes(id uint64, hashes []common.Hash, bytes int) error // RequestTrieNodes fetches a batch of account or storage trie nodes rooted in // a specific state trie. - RequestTrieNodes(id uint64, root common.Hash, paths []TrieNodePathSet, bytes uint64) error + RequestTrieNodes(id uint64, root common.Hash, count int, paths []TrieNodePathSet, bytes int) error // Log retrieves the peer's own contextual logger. Log() log.Logger @@ -1102,7 +1102,7 @@ func (s *Syncer) assignAccountTasks(success chan *accountResponse, fail chan *ac if cap < minRequestSize { // Don't bother with peers below a bare minimum performance cap = minRequestSize } - if err := peer.RequestAccountRange(reqid, root, req.origin, req.limit, uint64(cap)); err != nil { + if err := peer.RequestAccountRange(reqid, root, req.origin, req.limit, cap); err != nil { peer.Log().Debug("Failed to request account range", "err", err) s.scheduleRevertAccountRequest(req) } @@ -1359,7 +1359,7 @@ func (s *Syncer) assignStorageTasks(success chan *storageResponse, fail chan *st if subtask != nil { origin, limit = req.origin[:], req.limit[:] } - if err := peer.RequestStorageRanges(reqid, root, accounts, origin, limit, uint64(cap)); err != nil { + if err := peer.RequestStorageRanges(reqid, root, accounts, origin, limit, cap); err != nil { log.Debug("Failed to request storage", "err", err) s.scheduleRevertStorageRequest(req) } @@ -1492,7 +1492,7 @@ func (s *Syncer) assignTrienodeHealTasks(success chan *trienodeHealResponse, fai defer s.pend.Done() // Attempt to send the remote request and revert if it fails - if err := peer.RequestTrieNodes(reqid, root, pathsets, maxRequestSize); err != nil { + if err := peer.RequestTrieNodes(reqid, root, len(paths), pathsets, maxRequestSize); err != nil { log.Debug("Failed to request trienode healers", "err", err) s.scheduleRevertTrienodeHealRequest(req) } @@ -1699,9 +1699,13 @@ func (s *Syncer) revertAccountRequest(req *accountRequest) { } close(req.stale) - // Remove the request from the tracked set + // Remove the request from the tracked set and restore the peer to the + // idle pool so it can be reassigned work (skip if peer already left). s.lock.Lock() delete(s.accountReqs, req.id) + if _, ok := s.peers[req.peer]; ok { + s.accountIdlers[req.peer] = struct{}{} + } s.lock.Unlock() // If there's a timeout timer still running, abort it and mark the account @@ -1740,9 +1744,13 @@ func (s *Syncer) revertBytecodeRequest(req *bytecodeRequest) { } close(req.stale) - // Remove the request from the tracked set + // Remove the request from the tracked set and restore the peer to the + // idle pool so it can be reassigned work (skip if peer already left). s.lock.Lock() delete(s.bytecodeReqs, req.id) + if _, ok := s.peers[req.peer]; ok { + s.bytecodeIdlers[req.peer] = struct{}{} + } s.lock.Unlock() // If there's a timeout timer still running, abort it and mark the code @@ -1781,9 +1789,13 @@ func (s *Syncer) revertStorageRequest(req *storageRequest) { } close(req.stale) - // Remove the request from the tracked set + // Remove the request from the tracked set and restore the peer to the + // idle pool so it can be reassigned work (skip if peer already left). s.lock.Lock() delete(s.storageReqs, req.id) + if _, ok := s.peers[req.peer]; ok { + s.storageIdlers[req.peer] = struct{}{} + } s.lock.Unlock() // If there's a timeout timer still running, abort it and mark the storage @@ -1826,9 +1838,13 @@ func (s *Syncer) revertTrienodeHealRequest(req *trienodeHealRequest) { } close(req.stale) - // Remove the request from the tracked set + // Remove the request from the tracked set and restore the peer to the + // idle pool so it can be reassigned work (skip if peer already left). s.lock.Lock() delete(s.trienodeHealReqs, req.id) + if _, ok := s.peers[req.peer]; ok { + s.trienodeHealIdlers[req.peer] = struct{}{} + } s.lock.Unlock() // If there's a timeout timer still running, abort it and mark the trie node @@ -1867,9 +1883,13 @@ func (s *Syncer) revertBytecodeHealRequest(req *bytecodeHealRequest) { } close(req.stale) - // Remove the request from the tracked set + // Remove the request from the tracked set and restore the peer to the + // idle pool so it can be reassigned work (skip if peer already left). s.lock.Lock() delete(s.bytecodeHealReqs, req.id) + if _, ok := s.peers[req.peer]; ok { + s.bytecodeHealIdlers[req.peer] = struct{}{} + } s.lock.Unlock() // If there's a timeout timer still running, abort it and mark the code diff --git a/eth/protocols/snap/sync_test.go b/eth/protocols/snap/sync_test.go index 713b358ff8f9..c506488e91c1 100644 --- a/eth/protocols/snap/sync_test.go +++ b/eth/protocols/snap/sync_test.go @@ -25,6 +25,7 @@ import ( mrand "math/rand" "slices" "sync" + "sync/atomic" "testing" "time" @@ -32,6 +33,7 @@ import ( "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/internal/testrand" "github.com/ethereum/go-ethereum/log" @@ -41,7 +43,6 @@ import ( "github.com/ethereum/go-ethereum/triedb" "github.com/ethereum/go-ethereum/triedb/pathdb" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) func TestHashing(t *testing.T) { @@ -55,7 +56,7 @@ func TestHashing(t *testing.T) { } var want, got string var old = func() { - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() for i := 0; i < len(bytecodes); i++ { hasher.Reset() hasher.Write(bytecodes[i]) @@ -88,7 +89,7 @@ func BenchmarkHashing(b *testing.B) { bytecodes[i] = buf } var old = func() { - hasher := sha3.NewLegacyKeccak256() + hasher := keccak.NewLegacyKeccak256() for i := 0; i < len(bytecodes); i++ { hasher.Reset() hasher.Write(bytecodes[i]) @@ -119,10 +120,10 @@ func BenchmarkHashing(b *testing.B) { } type ( - accountHandlerFunc func(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error - storageHandlerFunc func(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error - trieHandlerFunc func(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap uint64) error - codeHandlerFunc func(t *testPeer, id uint64, hashes []common.Hash, max uint64) error + accountHandlerFunc func(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error + storageHandlerFunc func(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error + trieHandlerFunc func(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap int) error + codeHandlerFunc func(t *testPeer, id uint64, hashes []common.Hash, max int) error ) type testPeer struct { @@ -142,10 +143,10 @@ type testPeer struct { term func() // counters - nAccountRequests int - nStorageRequests int - nBytecodeRequests int - nTrienodeRequests int + nAccountRequests atomic.Int64 + nStorageRequests atomic.Int64 + nBytecodeRequests atomic.Int64 + nTrienodeRequests atomic.Int64 } func newTestPeer(id string, t *testing.T, term func()) *testPeer { @@ -179,25 +180,25 @@ func (t *testPeer) Stats() string { Storage requests: %d Bytecode requests: %d Trienode requests: %d -`, t.nAccountRequests, t.nStorageRequests, t.nBytecodeRequests, t.nTrienodeRequests) +`, t.nAccountRequests.Load(), t.nStorageRequests.Load(), t.nBytecodeRequests.Load(), t.nTrienodeRequests.Load()) } -func (t *testPeer) RequestAccountRange(id uint64, root, origin, limit common.Hash, bytes uint64) error { +func (t *testPeer) RequestAccountRange(id uint64, root, origin, limit common.Hash, bytes int) error { t.logger.Trace("Fetching range of accounts", "reqid", id, "root", root, "origin", origin, "limit", limit, "bytes", common.StorageSize(bytes)) - t.nAccountRequests++ + t.nAccountRequests.Add(1) go t.accountRequestHandler(t, id, root, origin, limit, bytes) return nil } -func (t *testPeer) RequestTrieNodes(id uint64, root common.Hash, paths []TrieNodePathSet, bytes uint64) error { +func (t *testPeer) RequestTrieNodes(id uint64, root common.Hash, count int, paths []TrieNodePathSet, bytes int) error { t.logger.Trace("Fetching set of trie nodes", "reqid", id, "root", root, "pathsets", len(paths), "bytes", common.StorageSize(bytes)) - t.nTrienodeRequests++ + t.nTrienodeRequests.Add(1) go t.trieRequestHandler(t, id, root, paths, bytes) return nil } -func (t *testPeer) RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes uint64) error { - t.nStorageRequests++ +func (t *testPeer) RequestStorageRanges(id uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, bytes int) error { + t.nStorageRequests.Add(1) if len(accounts) == 1 && origin != nil { t.logger.Trace("Fetching range of large storage slots", "reqid", id, "root", root, "account", accounts[0], "origin", common.BytesToHash(origin), "limit", common.BytesToHash(limit), "bytes", common.StorageSize(bytes)) } else { @@ -207,15 +208,15 @@ func (t *testPeer) RequestStorageRanges(id uint64, root common.Hash, accounts [] return nil } -func (t *testPeer) RequestByteCodes(id uint64, hashes []common.Hash, bytes uint64) error { - t.nBytecodeRequests++ +func (t *testPeer) RequestByteCodes(id uint64, hashes []common.Hash, bytes int) error { + t.nBytecodeRequests.Add(1) t.logger.Trace("Fetching set of byte codes", "reqid", id, "hashes", len(hashes), "bytes", common.StorageSize(bytes)) go t.codeRequestHandler(t, id, hashes, bytes) return nil } // defaultTrieRequestHandler is a well-behaving handler for trie healing requests -func defaultTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap uint64) error { +func defaultTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap int) error { // Pass the response var nodes [][]byte for _, pathset := range paths { @@ -244,7 +245,7 @@ func defaultTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, } // defaultAccountRequestHandler is a well-behaving handler for AccountRangeRequests -func defaultAccountRequestHandler(t *testPeer, id uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error { +func defaultAccountRequestHandler(t *testPeer, id uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error { keys, vals, proofs := createAccountRequestResponse(t, root, origin, limit, cap) if err := t.remote.OnAccounts(t, id, keys, vals, proofs); err != nil { t.test.Errorf("Remote side rejected our delivery: %v", err) @@ -254,8 +255,8 @@ func defaultAccountRequestHandler(t *testPeer, id uint64, root common.Hash, orig return nil } -func createAccountRequestResponse(t *testPeer, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) (keys []common.Hash, vals [][]byte, proofs [][]byte) { - var size uint64 +func createAccountRequestResponse(t *testPeer, root common.Hash, origin common.Hash, limit common.Hash, cap int) (keys []common.Hash, vals [][]byte, proofs [][]byte) { + var size int if limit == (common.Hash{}) { limit = common.MaxHash } @@ -266,7 +267,7 @@ func createAccountRequestResponse(t *testPeer, root common.Hash, origin common.H if bytes.Compare(origin[:], entry.k) <= 0 { keys = append(keys, common.BytesToHash(entry.k)) vals = append(vals, entry.v) - size += uint64(32 + len(entry.v)) + size += 32 + len(entry.v) } // If we've exceeded the request threshold, abort if bytes.Compare(entry.k, limit[:]) >= 0 { @@ -290,7 +291,7 @@ func createAccountRequestResponse(t *testPeer, root common.Hash, origin common.H } // defaultStorageRequestHandler is a well-behaving storage request handler -func defaultStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, bOrigin, bLimit []byte, max uint64) error { +func defaultStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, bOrigin, bLimit []byte, max int) error { hashes, slots, proofs := createStorageRequestResponse(t, root, accounts, bOrigin, bLimit, max) if err := t.remote.OnStorage(t, requestId, hashes, slots, proofs); err != nil { t.test.Errorf("Remote side rejected our delivery: %v", err) @@ -299,7 +300,7 @@ func defaultStorageRequestHandler(t *testPeer, requestId uint64, root common.Has return nil } -func defaultCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max uint64) error { +func defaultCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max int) error { var bytecodes [][]byte for _, h := range hashes { bytecodes = append(bytecodes, getCodeByHash(h)) @@ -311,8 +312,8 @@ func defaultCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max return nil } -func createStorageRequestResponse(t *testPeer, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) (hashes [][]common.Hash, slots [][][]byte, proofs [][]byte) { - var size uint64 +func createStorageRequestResponse(t *testPeer, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) (hashes [][]common.Hash, slots [][][]byte, proofs [][]byte) { + var size int for _, account := range accounts { // The first account might start from a different origin and end sooner var originHash common.Hash @@ -338,7 +339,7 @@ func createStorageRequestResponse(t *testPeer, root common.Hash, accounts []comm } keys = append(keys, common.BytesToHash(entry.k)) vals = append(vals, entry.v) - size += uint64(32 + len(entry.v)) + size += 32 + len(entry.v) if bytes.Compare(entry.k, limitHash[:]) >= 0 { break } @@ -377,8 +378,8 @@ func createStorageRequestResponse(t *testPeer, root common.Hash, accounts []comm // createStorageRequestResponseAlwaysProve tests a cornercase, where the peer always // supplies the proof for the last account, even if it is 'complete'. -func createStorageRequestResponseAlwaysProve(t *testPeer, root common.Hash, accounts []common.Hash, bOrigin, bLimit []byte, max uint64) (hashes [][]common.Hash, slots [][][]byte, proofs [][]byte) { - var size uint64 +func createStorageRequestResponseAlwaysProve(t *testPeer, root common.Hash, accounts []common.Hash, bOrigin, bLimit []byte, max int) (hashes [][]common.Hash, slots [][][]byte, proofs [][]byte) { + var size int max = max * 3 / 4 var origin common.Hash @@ -395,7 +396,7 @@ func createStorageRequestResponseAlwaysProve(t *testPeer, root common.Hash, acco } keys = append(keys, common.BytesToHash(entry.k)) vals = append(vals, entry.v) - size += uint64(32 + len(entry.v)) + size += 32 + len(entry.v) if size > max { exit = true } @@ -433,34 +434,34 @@ func createStorageRequestResponseAlwaysProve(t *testPeer, root common.Hash, acco } // emptyRequestAccountRangeFn is a rejects AccountRangeRequests -func emptyRequestAccountRangeFn(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error { +func emptyRequestAccountRangeFn(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error { t.remote.OnAccounts(t, requestId, nil, nil, nil) return nil } -func nonResponsiveRequestAccountRangeFn(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error { +func nonResponsiveRequestAccountRangeFn(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error { return nil } -func emptyTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap uint64) error { +func emptyTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap int) error { t.remote.OnTrieNodes(t, requestId, nil) return nil } -func nonResponsiveTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap uint64) error { +func nonResponsiveTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash, paths []TrieNodePathSet, cap int) error { return nil } -func emptyStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { +func emptyStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { t.remote.OnStorage(t, requestId, nil, nil, nil) return nil } -func nonResponsiveStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { +func nonResponsiveStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { return nil } -func proofHappyStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { +func proofHappyStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { hashes, slots, proofs := createStorageRequestResponseAlwaysProve(t, root, accounts, origin, limit, max) if err := t.remote.OnStorage(t, requestId, hashes, slots, proofs); err != nil { t.test.Errorf("Remote side rejected our delivery: %v", err) @@ -475,7 +476,7 @@ func proofHappyStorageRequestHandler(t *testPeer, requestId uint64, root common. // return nil //} -func corruptCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max uint64) error { +func corruptCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max int) error { var bytecodes [][]byte for _, h := range hashes { // Send back the hashes @@ -489,7 +490,7 @@ func corruptCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max return nil } -func cappedCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max uint64) error { +func cappedCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max int) error { var bytecodes [][]byte for _, h := range hashes[:1] { bytecodes = append(bytecodes, getCodeByHash(h)) @@ -503,11 +504,11 @@ func cappedCodeRequestHandler(t *testPeer, id uint64, hashes []common.Hash, max } // starvingStorageRequestHandler is somewhat well-behaving storage handler, but it caps the returned results to be very small -func starvingStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { +func starvingStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { return defaultStorageRequestHandler(t, requestId, root, accounts, origin, limit, 500) } -func starvingAccountRequestHandler(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error { +func starvingAccountRequestHandler(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error { return defaultAccountRequestHandler(t, requestId, root, origin, limit, 500) } @@ -515,7 +516,7 @@ func starvingAccountRequestHandler(t *testPeer, requestId uint64, root common.Ha // return defaultAccountRequestHandler(t, requestId-1, root, origin, 500) //} -func corruptAccountRequestHandler(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error { +func corruptAccountRequestHandler(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error { hashes, accounts, proofs := createAccountRequestResponse(t, root, origin, limit, cap) if len(proofs) > 0 { proofs = proofs[1:] @@ -529,7 +530,7 @@ func corruptAccountRequestHandler(t *testPeer, requestId uint64, root common.Has } // corruptStorageRequestHandler doesn't provide good proofs -func corruptStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { +func corruptStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { hashes, slots, proofs := createStorageRequestResponse(t, root, accounts, origin, limit, max) if len(proofs) > 0 { proofs = proofs[1:] @@ -542,7 +543,7 @@ func corruptStorageRequestHandler(t *testPeer, requestId uint64, root common.Has return nil } -func noProofStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { +func noProofStorageRequestHandler(t *testPeer, requestId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { hashes, slots, _ := createStorageRequestResponse(t, root, accounts, origin, limit, max) if err := t.remote.OnStorage(t, requestId, hashes, slots, nil); err != nil { t.logger.Info("remote error on delivery (as expected)", "error", err) @@ -577,7 +578,7 @@ func testSyncBloatedProof(t *testing.T, scheme string) { source.accountTrie = sourceAccountTrie.Copy() source.accountValues = elems - source.accountRequestHandler = func(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap uint64) error { + source.accountRequestHandler = func(t *testPeer, requestId uint64, root common.Hash, origin common.Hash, limit common.Hash, cap int) error { var ( keys []common.Hash vals [][]byte @@ -1165,7 +1166,7 @@ func testSyncNoStorageAndOneCodeCappedPeer(t *testing.T, scheme string) { var counter int syncer := setupSyncer( nodeScheme, - mkSource("capped", func(t *testPeer, id uint64, hashes []common.Hash, max uint64) error { + mkSource("capped", func(t *testPeer, id uint64, hashes []common.Hash, max int) error { counter++ return cappedCodeRequestHandler(t, id, hashes, max) }), @@ -1432,7 +1433,7 @@ func testSyncWithUnevenStorage(t *testing.T, scheme string) { source.accountValues = accounts source.setStorageTries(storageTries) source.storageValues = storageElems - source.storageRequestHandler = func(t *testPeer, reqId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max uint64) error { + source.storageRequestHandler = func(t *testPeer, reqId uint64, root common.Hash, accounts []common.Hash, origin, limit []byte, max int) error { return defaultStorageRequestHandler(t, reqId, root, accounts, origin, limit, 128) // retrieve storage in large mode } return source @@ -1901,7 +1902,7 @@ func testSyncAccountPerformance(t *testing.T, scheme string) { // sync cycle starts. When popping the queue, we do not look it up again. // Doing so would bring this number down to zero in this artificial testcase, // but only add extra IO for no reason in practice. - if have, want := src.nTrienodeRequests, 1; have != want { + if have, want := src.nTrienodeRequests.Load(), int64(1); have != want { fmt.Print(src.Stats()) t.Errorf("trie node heal requests wrong, want %d, have %d", want, have) } diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 79c91043a3c7..284ddf430518 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -38,7 +38,11 @@ import ( // for releasing state. var noopReleaser = tracers.StateReleaseFunc(func() {}) -func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (statedb *state.StateDB, release tracers.StateReleaseFunc, err error) { +// reexecLimit is the maximum number of ancestor blocks to walk back when +// attempting to reconstruct missing historical state for hash-scheme nodes. +const reexecLimit = uint64(128) + +func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, base *state.StateDB, readOnly bool, preferDisk bool) (statedb *state.StateDB, release tracers.StateReleaseFunc, err error) { var ( current *types.Block database state.Database @@ -52,7 +56,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u // The state is available in live database, create a reference // on top to prevent garbage collection and return a release // function to deref it. - if statedb, err = eth.blockchain.StateAt(block.Root()); err == nil { + if statedb, err = eth.blockchain.StateAt(block.Header()); err == nil { eth.blockchain.TrieDB().Reference(block.Root(), common.Hash{}) return statedb, func() { eth.blockchain.TrieDB().Dereference(block.Root()) @@ -99,7 +103,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u } } // Database does not have the state for the given block, try to regenerate - for i := uint64(0); i < reexec; i++ { + for i := uint64(0); i < reexecLimit; i++ { if err := ctx.Err(); err != nil { return nil, nil, err } @@ -120,7 +124,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u if err != nil { switch err.(type) { case *trie.MissingNodeError: - return nil, nil, fmt.Errorf("required historical state unavailable (reexec=%d)", reexec) + return nil, nil, fmt.Errorf("required historical state unavailable (reexec=%d)", reexecLimit) default: return nil, nil, err } @@ -147,7 +151,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u if current = eth.blockchain.GetBlockByNumber(next); current == nil { return nil, nil, fmt.Errorf("block #%d not found", next) } - _, err := eth.blockchain.Processor().Process(current, statedb, vm.Config{}) + _, err := eth.blockchain.Processor().Process(ctx, current, statedb, vm.Config{}) if err != nil { return nil, nil, fmt.Errorf("processing block %d failed: %v", current.NumberU64(), err) } @@ -178,11 +182,12 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u func (eth *Ethereum) pathState(block *types.Block) (*state.StateDB, func(), error) { // Check if the requested state is available in the live chain. - statedb, err := eth.blockchain.StateAt(block.Root()) + header := block.Header() + statedb, err := eth.blockchain.StateAt(header) if err == nil { return statedb, noopReleaser, nil } - statedb, err = eth.blockchain.HistoricState(block.Root()) + statedb, err = eth.blockchain.HistoricState(header) if err == nil { return statedb, noopReleaser, nil } @@ -190,10 +195,9 @@ func (eth *Ethereum) pathState(block *types.Block) (*state.StateDB, func(), erro } // stateAtBlock retrieves the state database associated with a certain block. -// If no state is locally available for the given block, a number of blocks -// are attempted to be reexecuted to generate the desired state. The optional -// base layer statedb can be provided which is regarded as the statedb of the -// parent block. +// If no state is locally available for the given block, up to reexecLimit ancestor +// blocks are reexecuted to generate the desired state. The optional base layer +// statedb can be provided which is regarded as the statedb of the parent block. // // An additional release function will be returned if the requested state is // available. Release is expected to be invoked when the returned state is no @@ -202,7 +206,6 @@ func (eth *Ethereum) pathState(block *types.Block) (*state.StateDB, func(), erro // // Parameters: // - block: The block for which we want the state(state = block.Root) -// - reexec: The maximum number of blocks to reprocess trying to obtain the desired state // - base: If the caller is tracing multiple blocks, the caller can provide the parent // state continuously from the callsite. // - readOnly: If true, then the live 'blockchain' state database is used. No mutation should @@ -211,9 +214,9 @@ func (eth *Ethereum) pathState(block *types.Block) (*state.StateDB, func(), erro // - preferDisk: This arg can be used by the caller to signal that even though the 'base' is // provided, it would be preferable to start from a fresh state, if we have it // on disk. -func (eth *Ethereum) stateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (statedb *state.StateDB, release tracers.StateReleaseFunc, err error) { +func (eth *Ethereum) stateAtBlock(ctx context.Context, block *types.Block, base *state.StateDB, readOnly bool, preferDisk bool) (statedb *state.StateDB, release tracers.StateReleaseFunc, err error) { if eth.blockchain.TrieDB().Scheme() == rawdb.HashScheme { - return eth.hashState(ctx, block, reexec, base, readOnly, preferDisk) + return eth.hashState(ctx, block, base, readOnly, preferDisk) } return eth.pathState(block) } @@ -225,7 +228,7 @@ func (eth *Ethereum) stateAtBlock(ctx context.Context, block *types.Block, reexe // function will return the state of block after the pre-block operations have // been completed (e.g. updating system contracts), but before post-block // operations are completed (e.g. processing withdrawals). -func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*types.Transaction, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { +func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int) (*types.Transaction, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) { // Short circuit if it's genesis block. if block.NumberU64() == 0 { return nil, vm.BlockContext{}, nil, nil, errors.New("no transaction in genesis") @@ -237,20 +240,18 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, } // Lookup the statedb of parent block from the live database, // otherwise regenerate it on the flight. - statedb, release, err := eth.stateAtBlock(ctx, parent, reexec, nil, true, false) + statedb, release, err := eth.stateAtBlock(ctx, parent, nil, true, false) if err != nil { return nil, vm.BlockContext{}, nil, nil, err } // Insert parent beacon block root in the state as per EIP-4788. context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil) evm := vm.NewEVM(context, statedb, eth.blockchain.Config(), vm.Config{}) - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - // If prague hardfork, insert parent block hash in the state as per EIP-2935. - if eth.blockchain.Config().IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + defer evm.Release() + + // Run pre-execution system calls + core.PreExecution(ctx, block.BeaconRoot(), block.ParentHash(), eth.blockchain.Config(), evm, block.Number(), block.Time()) + if txIndex == 0 && len(block.Transactions()) == 0 { return nil, context, statedb, release, nil } @@ -264,8 +265,8 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) // Not yet the searched for transaction, execute on top of the current state - statedb.SetTxContext(tx.Hash(), idx) - if _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil { + statedb.SetTxContext(tx.Hash(), idx, uint32(idx+1)) + if _, err := core.ApplyMessage(evm, msg, nil); err != nil { return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err) } // Ensure any modifications are committed to the state diff --git a/eth/sync.go b/eth/sync.go index ddae8443a321..8b4bd90abfd8 100644 --- a/eth/sync.go +++ b/eth/sync.go @@ -25,7 +25,8 @@ import ( // syncTransactions starts sending all currently pending transactions to the given peer. func (h *handler) syncTransactions(p *eth.Peer) { var hashes []common.Hash - for _, batch := range h.txpool.Pending(txpool.PendingFilter{BlobTxs: false}) { + pending, _ := h.txpool.Pending(txpool.PendingFilter{BlobTxs: false}) + for _, batch := range pending { for _, tx := range batch { hashes = append(hashes, tx.Hash) } diff --git a/eth/sync_test.go b/eth/sync_test.go index 509b836f828d..e22c49527550 100644 --- a/eth/sync_test.go +++ b/eth/sync_test.go @@ -28,7 +28,7 @@ import ( ) // Tests that snap sync is disabled after a successful sync cycle. -func TestSnapSyncDisabling68(t *testing.T) { testSnapSyncDisabling(t, eth.ETH68, snap.SNAP1) } +func TestSnapSyncDisabling69(t *testing.T) { testSnapSyncDisabling(t, eth.ETH69, snap.SNAP1) } // Tests that snap sync gets disabled as soon as a real block is successfully // imported into the blockchain. @@ -50,8 +50,8 @@ func testSnapSyncDisabling(t *testing.T, ethVer uint, snapVer uint) { defer emptyPipeEth.Close() defer fullPipeEth.Close() - emptyPeerEth := eth.NewPeer(ethVer, p2p.NewPeer(enode.ID{1}, "", caps), emptyPipeEth, empty.txpool) - fullPeerEth := eth.NewPeer(ethVer, p2p.NewPeer(enode.ID{2}, "", caps), fullPipeEth, full.txpool) + emptyPeerEth := eth.NewPeer(ethVer, p2p.NewPeer(enode.ID{1}, "", caps), emptyPipeEth, empty.txpool, nil) + fullPeerEth := eth.NewPeer(ethVer, p2p.NewPeer(enode.ID{2}, "", caps), fullPipeEth, full.txpool, nil) defer emptyPeerEth.Close() defer fullPeerEth.Close() @@ -82,15 +82,18 @@ func testSnapSyncDisabling(t *testing.T, ethVer uint, snapVer uint) { if err := empty.handler.downloader.BeaconSync(full.chain.CurrentBlock(), nil); err != nil { t.Fatal("sync failed:", err) } - // Downloader internally has to wait for a timer (3s) to be expired before - // exiting. Poll after to determine if sync is disabled. - time.Sleep(time.Second * 3) - for timeout := time.After(time.Second); ; { + // Snap sync and mode switching happen asynchronously, poll for completion. + timeout := time.NewTimer(15 * time.Second) + tick := time.NewTicker(100 * time.Millisecond) + defer timeout.Stop() + defer tick.Stop() + + for { select { - case <-timeout: + case <-timeout.C: t.Fatalf("snap sync not disabled after successful synchronisation") - case <-time.After(100 * time.Millisecond): - if empty.handler.downloader.ConfigSyncMode() == ethconfig.FullSync { + case <-tick.C: + if empty.handler.synced.Load() && empty.handler.downloader.ConfigSyncMode() == ethconfig.FullSync { return } } diff --git a/eth/syncer/syncer.go b/eth/syncer/syncer.go index c0d54b953b08..b04d8f22e8f6 100644 --- a/eth/syncer/syncer.go +++ b/eth/syncer/syncer.go @@ -26,6 +26,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/eth/downloader" "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" @@ -37,32 +38,40 @@ type syncReq struct { errc chan error } +type Config struct { + TargetBlock common.Hash // if set, sync is triggered at startup + ExitWhenSynced bool // if true, the node shuts down after sync has finished +} + // Syncer is an auxiliary service that allows Geth to perform full sync // alone without consensus-layer attached. Users must specify a valid block hash // as the sync target. // +// Additionally, the syncer can be used to monitor state synchronization. +// It will exit once the specified target has been reached or when the +// most recent chain head is caught up. +// // This tool can be applied to different networks, no matter it's pre-merge or // post-merge, but only for full-sync. type Syncer struct { - stack *node.Node - backend *eth.Ethereum - target common.Hash - request chan *syncReq - closed chan struct{} - wg sync.WaitGroup - exitWhenSynced bool + stack *node.Node + backend *eth.Ethereum + request chan *syncReq + closed chan struct{} + wg sync.WaitGroup + + config Config } // Register registers the synchronization override service into the node // stack for launching and stopping the service controlled by node. -func Register(stack *node.Node, backend *eth.Ethereum, target common.Hash, exitWhenSynced bool) (*Syncer, error) { +func Register(stack *node.Node, backend *eth.Ethereum, cfg Config) (*Syncer, error) { s := &Syncer{ - stack: stack, - backend: backend, - target: target, - request: make(chan *syncReq), - closed: make(chan struct{}), - exitWhenSynced: exitWhenSynced, + stack: stack, + backend: backend, + request: make(chan *syncReq), + closed: make(chan struct{}), + config: cfg, } stack.RegisterAPIs(s.APIs()) stack.RegisterLifecycle(s) @@ -88,9 +97,11 @@ func (s *Syncer) run() { var ( target *types.Header - ticker = time.NewTicker(time.Second * 5) + syncCh = make(chan downloader.SyncEvent, 10) ) - defer ticker.Stop() + sub := s.backend.Downloader().SubscribeSyncEvents(syncCh) + defer sub.Unsubscribe() + for { select { case req := <-s.request: @@ -137,35 +148,50 @@ func (s *Syncer) run() { } } - case <-ticker.C: - if target == nil { + case ev := <-syncCh: + if ev.Type == downloader.SyncStarted { + log.Debug("Synchronization started") continue } - - // Terminate the node if the target has been reached - if s.exitWhenSynced { - if block := s.backend.BlockChain().GetBlockByHash(target.Hash()); block != nil { - log.Info("Sync target reached", "number", block.NumberU64(), "hash", block.Hash()) - go s.stack.Close() // async since we need to close ourselves - return - } + if ev.Type == downloader.SyncFailed { + log.Debug("Synchronization failed", "err", ev.Err) + continue } - // Set the finalized and safe markers relative to the current head. - // The finalized marker is set two epochs behind the target, - // and the safe marker is set one epoch behind the target. head := s.backend.BlockChain().CurrentHeader() - if head == nil { - continue - } - if header := s.backend.BlockChain().GetHeaderByNumber(head.Number.Uint64() - params.EpochLength*2); header != nil { - if final := s.backend.BlockChain().CurrentFinalBlock(); final == nil || final.Number.Cmp(header.Number) < 0 { - s.backend.BlockChain().SetFinalized(header) + if head != nil { + // Set the finalized and safe markers relative to the current head. + // The finalized marker is set two epochs behind the target, + // and the safe marker is set one epoch behind the target. + if header := s.backend.BlockChain().GetHeaderByNumber(head.Number.Uint64() - params.EpochLength*2); header != nil { + if final := s.backend.BlockChain().CurrentFinalBlock(); final == nil || final.Number.Cmp(header.Number) < 0 { + s.backend.BlockChain().SetFinalized(header) + } + } + if header := s.backend.BlockChain().GetHeaderByNumber(head.Number.Uint64() - params.EpochLength); header != nil { + if safe := s.backend.BlockChain().CurrentSafeBlock(); safe == nil || safe.Number.Cmp(header.Number) < 0 { + s.backend.BlockChain().SetSafe(header) + } } } - if header := s.backend.BlockChain().GetHeaderByNumber(head.Number.Uint64() - params.EpochLength); header != nil { - if safe := s.backend.BlockChain().CurrentSafeBlock(); safe == nil || safe.Number.Cmp(header.Number) < 0 { - s.backend.BlockChain().SetSafe(header) + + // Terminate the node if the target has been reached + if s.config.ExitWhenSynced { + var synced bool + var block *types.Header + if target != nil { + tb := s.backend.BlockChain().GetBlockByHash(target.Hash()) + synced = tb != nil + block = tb.Header() + } else { + timestamp := time.Unix(int64(ev.Latest.Time), 0) + synced = time.Since(timestamp) < 10*time.Minute + block = ev.Latest + } + + if synced { + log.Info("Sync target reached", "number", block.Number.Uint64(), "hash", block.Hash()) + go s.stack.Close() // async since we need to close ourselves } } @@ -179,10 +205,10 @@ func (s *Syncer) run() { func (s *Syncer) Start() error { s.wg.Add(1) go s.run() - if s.target == (common.Hash{}) { + if s.config.TargetBlock == (common.Hash{}) { return nil } - return s.Sync(s.target) + return s.Sync(s.config.TargetBlock) } // Stop terminates the synchronization service and stop all background activities. diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 5f2f16627a2c..0df02388b33f 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -51,11 +51,6 @@ const ( // by default before being forcefully aborted. defaultTraceTimeout = 5 * time.Second - // defaultTraceReexec is the number of blocks the tracer is willing to go back - // and reexecute to produce missing historical state necessary to run a specific - // trace. - defaultTraceReexec = uint64(128) - // defaultTracechainMemLimit is the size of the triedb, at which traceChain // switches over and tries to use a disk-backed database instead of building // on top of memory. @@ -89,8 +84,8 @@ type Backend interface { ChainConfig() *params.ChainConfig Engine() consensus.Engine ChainDb() ethdb.Database - StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error) - StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*types.Transaction, vm.BlockContext, *state.StateDB, StateReleaseFunc, error) + StateAtBlock(ctx context.Context, block *types.Block, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error) + StateAtTransaction(ctx context.Context, block *types.Block, txIndex int) (*types.Transaction, vm.BlockContext, *state.StateDB, StateReleaseFunc, error) } // API is the collection of tracing APIs exposed over the private debugging endpoint. @@ -156,7 +151,6 @@ type TraceConfig struct { *logger.Config Tracer *string Timeout *string - Reexec *uint64 // Config specific to given tracer. Note struct logger // config are historically embedded in main object. TracerConfig json.RawMessage @@ -174,7 +168,6 @@ type TraceCallConfig struct { // StdTraceConfig holds extra parameters to standard-json trace functions. type StdTraceConfig struct { logger.Config - Reexec *uint64 TxHash common.Hash } @@ -245,10 +238,6 @@ func (api *API) TraceChain(ctx context.Context, start, end rpc.BlockNumber, conf // transaction, dependent on the requested tracer. // The tracing procedure should be aborted in case the closed signal is received. func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed <-chan error) chan *blockTraceResult { - reexec := defaultTraceReexec - if config != nil && config.Reexec != nil { - reexec = *config.Reexec - } blocks := int(end.NumberU64() - start.NumberU64()) threads := runtime.NumCPU() if threads > blocks { @@ -374,7 +363,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed s1, s2, s3 := statedb.Database().TrieDB().Size() preferDisk = s1+s2+s3 > defaultTracechainMemLimit } - statedb, release, err = api.backend.StateAtBlock(ctx, block, reexec, statedb, false, preferDisk) + statedb, release, err = api.backend.StateAtBlock(ctx, block, statedb, false, preferDisk) if err != nil { failed = err break @@ -383,13 +372,9 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed // as per EIP-4788. context := core.NewEVMBlockContext(next.Header(), api.chainContext(ctx), nil) evm := vm.NewEVM(context, statedb, api.backend.ChainConfig(), vm.Config{}) - if beaconRoot := next.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - // Insert parent hash in history contract. - if api.backend.ChainConfig().IsPrague(next.Number(), next.Time()) { - core.ProcessParentBlockHash(next.ParentHash(), evm) - } + + core.PreExecution(ctx, next.BeaconRoot(), next.ParentHash(), api.backend.ChainConfig(), evm, next.Number(), next.Time()) + evm.Release() // Clean out any pending release functions of trace state. Note this // step must be done after constructing tracing state, because the // tracing state of block next depends on the parent state and construction @@ -504,8 +489,8 @@ func (api *API) StandardTraceBlockToFile(ctx context.Context, hash common.Hash, return api.standardTraceBlockToFile(ctx, block, config) } -// IntermediateRoots executes a block (bad- or canon- or side-), and returns a list -// of intermediate roots: the stateroot after each transaction. +// IntermediateRoots executes a block, and returns a list of intermediate roots: +// the stateroot after each transaction. func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config *TraceConfig) ([]common.Hash, error) { block, _ := api.blockByHash(ctx, hash) if block == nil { @@ -522,36 +507,31 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config if err != nil { return nil, err } - reexec := defaultTraceReexec - if config != nil && config.Reexec != nil { - reexec = *config.Reexec - } - statedb, release, err := api.backend.StateAtBlock(ctx, parent, reexec, nil, true, false) + statedb, release, err := api.backend.StateAtBlock(ctx, parent, nil, true, false) if err != nil { return nil, err } defer release() + var ( roots []common.Hash signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time()) chainConfig = api.backend.ChainConfig() vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil) deleteEmptyObjects = chainConfig.IsEIP158(block.Number()) + evm = vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{}) ) - evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{}) - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if chainConfig.IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + defer evm.Release() + // Run pre-execution system calls + core.PreExecution(ctx, block.BeaconRoot(), block.ParentHash(), chainConfig, evm, block.Number(), block.Time()) + for i, tx := range block.Transactions() { if err := ctx.Err(); err != nil { return nil, err } msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) - statedb.SetTxContext(tx.Hash(), i) - if _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(msg.GasLimit)); err != nil { + statedb.SetTxContext(tx.Hash(), i, uint32(i+1)) + if _, err := core.ApplyMessage(evm, msg, nil); err != nil { log.Warn("Tracing intermediate roots did not complete", "txindex", i, "txhash", tx.Hash(), "err", err) // We intentionally don't return the error here: if we do, then the RPC server will not // return the roots. Most likely, the caller already knows that a certain transaction fails to @@ -561,7 +541,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config // N.B: This should never happen while tracing canon blocks, only when tracing bad blocks. return roots, nil } - // calling IntermediateRoot will internally call Finalize on the state + // Calling IntermediateRoot will internally call Finalize on the state // so any modifications are written to the trie roots = append(roots, statedb.IntermediateRoot(deleteEmptyObjects)) } @@ -591,11 +571,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac if err != nil { return nil, err } - reexec := defaultTraceReexec - if config != nil && config.Reexec != nil { - reexec = *config.Reexec - } - statedb, release, err := api.backend.StateAtBlock(ctx, parent, reexec, nil, true, false) + statedb, release, err := api.backend.StateAtBlock(ctx, parent, nil, true, false) if err != nil { return nil, err } @@ -603,12 +579,10 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil) evm := vm.NewEVM(blockCtx, statedb, api.backend.ChainConfig(), vm.Config{}) - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if api.backend.ChainConfig().IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + defer evm.Release() + + // Run pre-execution system calls + core.PreExecution(ctx, block.BeaconRoot(), block.ParentHash(), api.backend.ChainConfig(), evm, block.Number(), block.Time()) // JS tracers have high overhead. In this case run a parallel // process that generates states in one thread and traces txes @@ -692,6 +666,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat var failed error blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil) evm := vm.NewEVM(blockCtx, statedb, api.backend.ChainConfig(), vm.Config{}) + defer evm.Release() txloop: for i, tx := range txs { @@ -706,8 +681,8 @@ txloop: // Generate the next state snapshot fast without tracing msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) - statedb.SetTxContext(tx.Hash(), i) - if _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(msg.GasLimit)); err != nil { + statedb.SetTxContext(tx.Hash(), i, uint32(i+1)) + if _, err := core.ApplyMessage(evm, msg, nil); err != nil { failed = err break txloop } @@ -743,11 +718,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block if err != nil { return nil, err } - reexec := defaultTraceReexec - if config != nil && config.Reexec != nil { - reexec = *config.Reexec - } - statedb, release, err := api.backend.StateAtBlock(ctx, parent, reexec, nil, true, false) + statedb, release, err := api.backend.StateAtBlock(ctx, parent, nil, true, false) if err != nil { return nil, err } @@ -779,20 +750,18 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block // Note: This copies the config, to not screw up the main config chainConfig, canon = overrideConfig(chainConfig, config.Overrides) } - evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{}) - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if chainConfig.IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + defer evm.Release() + + // Run pre-execution system calls + core.PreExecution(ctx, block.BeaconRoot(), block.ParentHash(), chainConfig, evm, block.Number(), block.Time()) + for i, tx := range block.Transactions() { // Prepare the transaction for un-traced execution msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) if txHash != (common.Hash{}) && tx.Hash() != txHash { // Process the tx to update state, but don't trace it. - _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(msg.GasLimit)) + _, err := core.ApplyMessage(evm, msg, nil) if err != nil { return dumps, err } @@ -813,6 +782,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block return nil, err } dumps = append(dumps, dump.Name()) + // Set up the tracer and EVM for the transaction. var ( writer = bufio.NewWriter(dump) @@ -823,11 +793,12 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block }) ) // Execute the transaction and flush any traces to disk - statedb.SetTxContext(tx.Hash(), i) + statedb.SetTxContext(tx.Hash(), i, uint32(i+1)) if tracer.OnTxStart != nil { tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) } - _, err = core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(msg.GasLimit)) + _, err = core.ApplyMessage(evm, msg, nil) + evm.Release() if writer != nil { writer.Flush() } @@ -840,7 +811,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block } // Finalize the state so any modifications are written to the trie // Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect - statedb.Finalise(evm.ChainConfig().IsEIP158(block.Number())) + statedb.Finalise(chainConfig.IsEIP158(block.Number())) // If we've traced the transaction we were looking for, abort if tx.Hash() == txHash { @@ -877,15 +848,11 @@ func (api *API) TraceTransaction(ctx context.Context, hash common.Hash, config * if blockNumber == 0 { return nil, errors.New("genesis is not traceable") } - reexec := defaultTraceReexec - if config != nil && config.Reexec != nil { - reexec = *config.Reexec - } block, err := api.blockByNumberAndHash(ctx, rpc.BlockNumber(blockNumber), blockHash) if err != nil { return nil, err } - tx, vmctx, statedb, release, err := api.backend.StateAtTransaction(ctx, block, int(index), reexec) + tx, vmctx, statedb, release, err := api.backend.StateAtTransaction(ctx, block, int(index)) if err != nil { return nil, err } @@ -939,15 +906,10 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc return nil, err } // try to recompute the state - reexec := defaultTraceReexec - if config != nil && config.Reexec != nil { - reexec = *config.Reexec - } - if config != nil && config.TxIndex != nil { - _, _, statedb, release, err = api.backend.StateAtTransaction(ctx, block, int(*config.TxIndex), reexec) + _, _, statedb, release, err = api.backend.StateAtTransaction(ctx, block, int(*config.TxIndex)) } else { - statedb, release, err = api.backend.StateAtBlock(ctx, block, reexec, nil, true, false) + statedb, release, err = api.backend.StateAtBlock(ctx, block, nil, true, false) } if err != nil { return nil, err @@ -1011,7 +973,6 @@ func (api *API) traceTx(ctx context.Context, tx *types.Transaction, message *cor tracer *Tracer err error timeout = defaultTraceTimeout - usedGas uint64 ) if config == nil { config = &TraceConfig{} @@ -1032,6 +993,7 @@ func (api *API) traceTx(ctx context.Context, tx *types.Transaction, message *cor } tracingStateDB := state.NewHookedState(statedb, tracer.Hooks) evm := vm.NewEVM(vmctx, tracingStateDB, api.backend.ChainConfig(), vm.Config{Tracer: tracer.Hooks, NoBaseFee: true}) + defer evm.Release() if precompiles != nil { evm.SetPrecompiles(precompiles) } @@ -1054,8 +1016,9 @@ func (api *API) traceTx(ctx context.Context, tx *types.Transaction, message *cor defer cancel() // Call Prepare to clear out the statedb access list - statedb.SetTxContext(txctx.TxHash, txctx.TxIndex) - _, err = core.ApplyTransactionWithEVM(message, new(core.GasPool).AddGas(message.GasLimit), statedb, vmctx.BlockNumber, txctx.BlockHash, vmctx.Time, tx, &usedGas, evm) + statedb.SetTxContext(txctx.TxHash, txctx.TxIndex, uint32(txctx.TxIndex+1)) + + _, err = core.ApplyTransactionWithEVM(message, core.NewGasPool(message.GasLimit), statedb, vmctx.BlockNumber, txctx.BlockHash, vmctx.Time, tx, evm) if err != nil { return nil, fmt.Errorf("tracing failed: %w", err) } @@ -1118,8 +1081,8 @@ func overrideConfig(original *params.ChainConfig, override *params.ChainConfig) copy.OsakaTime = timestamp canon = false } - if timestamp := override.VerkleTime; timestamp != nil { - copy.VerkleTime = timestamp + if timestamp := override.UBTTime; timestamp != nil { + copy.UBTTime = timestamp canon = false } diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 609c3f4d8b3b..0e62b9631ded 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -151,8 +151,8 @@ func (b *testBackend) teardown() { b.chain.Stop() } -func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error) { - statedb, err := b.chain.StateAt(block.Root()) +func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error) { + statedb, err := b.chain.StateAt(block.Header()) if err != nil { return nil, nil, errStateNotFound } @@ -167,12 +167,12 @@ func (b *testBackend) StateAtBlock(ctx context.Context, block *types.Block, reex return statedb, release, nil } -func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*types.Transaction, vm.BlockContext, *state.StateDB, StateReleaseFunc, error) { +func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int) (*types.Transaction, vm.BlockContext, *state.StateDB, StateReleaseFunc, error) { parent := b.chain.GetBlock(block.ParentHash(), block.NumberU64()-1) if parent == nil { return nil, vm.BlockContext{}, nil, nil, errBlockNotFound } - statedb, release, err := b.StateAtBlock(ctx, parent, reexec, nil, true, false) + statedb, release, err := b.StateAtBlock(ctx, parent, nil, true, false) if err != nil { return nil, vm.BlockContext{}, nil, nil, errStateNotFound } @@ -188,7 +188,7 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block return tx, context, statedb, release, nil } msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) - if _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil { + if _, err := core.ApplyMessage(evm, msg, nil); err != nil { return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err) } statedb.Finalise(evm.ChainConfig().IsEIP158(block.Number())) @@ -202,6 +202,18 @@ type stateTracer struct { Storage map[common.Address]map[common.Hash]common.Hash } +type tracedOpcodeLog struct { + Op string `json:"op"` + Refund *uint64 `json:"refund,omitempty"` + Storage map[string]string `json:"storage,omitempty"` +} + +type tracedOpcodeResult struct { + Failed bool `json:"failed"` + ReturnValue string `json:"returnValue"` + StructLogs []tracedOpcodeLog `json:"structLogs"` +} + func newStateTracer(ctx *Context, cfg json.RawMessage, chainCfg *params.ChainConfig) (*Tracer, error) { t := &stateTracer{ Balance: make(map[common.Address]*hexutil.Big), @@ -1058,6 +1070,176 @@ func TestTracingWithOverrides(t *testing.T) { } } +func TestTraceTransactionRefundAndStorageSnapshots(t *testing.T) { + t.Parallel() + + accounts := newAccounts(1) + contract := common.HexToAddress("0x00000000000000000000000000000000deadbeef") + slot0 := common.BigToHash(big.NewInt(0)) + txSigner := types.HomesteadSigner{} + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + contract: { + Nonce: 1, + Code: []byte{ + byte(vm.PUSH1), 0x00, + byte(vm.SLOAD), + byte(vm.POP), + byte(vm.PUSH1), 0x00, + byte(vm.PUSH1), 0x00, + byte(vm.SSTORE), + byte(vm.STOP), + }, + Storage: map[common.Hash]common.Hash{ + slot0: common.BigToHash(big.NewInt(1)), + }, + }, + }, + } + var target common.Hash + backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) { + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 0, + To: &contract, + Value: big.NewInt(0), + Gas: 100000, + GasPrice: b.BaseFee(), + }), txSigner, accounts[0].key) + b.AddTx(tx) + target = tx.Hash() + }) + defer backend.teardown() + + api := NewAPI(backend) + result, err := api.TraceTransaction(context.Background(), target, nil) + if err != nil { + t.Fatalf("failed to trace refunding transaction: %v", err) + } + var traced tracedOpcodeResult + if err := json.Unmarshal(result.(json.RawMessage), &traced); err != nil { + t.Fatalf("failed to unmarshal trace result: %v", err) + } + if traced.Failed { + t.Fatal("expected refunding transaction to succeed") + } + if traced.ReturnValue != "0x" { + t.Fatalf("unexpected return value: have %s want 0x", traced.ReturnValue) + } + slotHex := slot0.Hex() + oneHex := common.BigToHash(big.NewInt(1)).Hex() + zeroHex := common.Hash{}.Hex() + var ( + foundSloadSnapshot bool + foundSstoreSnapshot bool + foundRefund bool + ) + for _, log := range traced.StructLogs { + switch log.Op { + case "SLOAD": + if got := log.Storage[slotHex]; got == oneHex { + foundSloadSnapshot = true + } + case "SSTORE": + if got := log.Storage[slotHex]; got == zeroHex { + foundSstoreSnapshot = true + } + } + if log.Refund != nil && *log.Refund > 0 { + foundRefund = true + } + } + if !foundSloadSnapshot { + t.Fatal("expected SLOAD snapshot to include the pre-existing non-zero storage value") + } + if !foundSstoreSnapshot { + t.Fatal("expected SSTORE snapshot to include the post-write zeroed storage value") + } + if !foundRefund { + t.Fatal("expected at least one structLog entry with a non-zero refund field") + } +} + +func TestTraceTransactionFailureReturnValues(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + code []byte + wantReturnValue string + }{ + { + name: "revert preserves return data", + code: []byte{ + byte(vm.PUSH1), 0x2a, + byte(vm.PUSH1), 0x00, + byte(vm.MSTORE), + byte(vm.PUSH1), 0x20, + byte(vm.PUSH1), 0x00, + byte(vm.REVERT), + }, + wantReturnValue: "0x000000000000000000000000000000000000000000000000000000000000002a", + }, + { + name: "hard failure clears return data", + code: []byte{ + byte(vm.INVALID), + }, + wantReturnValue: "0x", + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + accounts := newAccounts(1) + contract := common.HexToAddress("0x00000000000000000000000000000000deadbeef") + txSigner := types.HomesteadSigner{} + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + contract: { + Nonce: 1, + Code: tc.code, + }, + }, + } + var target common.Hash + backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) { + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 0, + To: &contract, + Value: big.NewInt(0), + Gas: 100000, + GasPrice: b.BaseFee(), + }), txSigner, accounts[0].key) + b.AddTx(tx) + target = tx.Hash() + }) + defer backend.teardown() + + api := NewAPI(backend) + result, err := api.TraceTransaction(context.Background(), target, nil) + if err != nil { + t.Fatalf("failed to trace transaction: %v", err) + } + var traced tracedOpcodeResult + if err := json.Unmarshal(result.(json.RawMessage), &traced); err != nil { + t.Fatalf("failed to unmarshal trace result: %v", err) + } + if !traced.Failed { + t.Fatal("expected traced transaction to fail") + } + if traced.ReturnValue != tc.wantReturnValue { + t.Fatalf("unexpected returnValue: have %s want %s", traced.ReturnValue, tc.wantReturnValue) + } + if len(traced.StructLogs) == 0 { + t.Fatal("expected failing trace to still include structLogs") + } + }) + } +} + type Account struct { key *ecdsa.PrivateKey addr common.Address @@ -1373,3 +1555,350 @@ func TestStandardTraceBlockToFile(t *testing.T) { } } } + +func TestTraceBadBlock(t *testing.T) { + t.Parallel() + + var ( + accounts = newAccounts(2) + storageContract = common.HexToAddress("0x00000000000000000000000000000000deadbeef") + signer = types.HomesteadSigner{} + txHashs = make([]common.Hash, 0, 2) + genesis = &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + accounts[1].addr: {Balance: big.NewInt(params.Ether)}, + storageContract: { + Nonce: 1, + Balance: big.NewInt(0), + Code: []byte{ + byte(vm.PUSH1), 0x2a, // push 42 + byte(vm.PUSH1), 0x00, // push slot 0 + byte(vm.SSTORE), // sstore(0, 42) + byte(vm.STOP), + }, + }, + }, + } + ) + backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) { + // tx 0: plain transfer + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 0, + To: &accounts[1].addr, + Value: big.NewInt(1000), + Gas: params.TxGas, + GasPrice: b.BaseFee(), + Data: nil}), + signer, accounts[0].key) + b.AddTx(tx) + txHashs = append(txHashs, tx.Hash()) + + // tx 1: call storage contract (executes PUSH1, PUSH1, SSTORE, STOP) + tx, _ = types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 1, + To: &storageContract, + Value: big.NewInt(0), + Gas: 50000, + GasPrice: b.BaseFee(), + Data: nil}), + signer, accounts[0].key) + b.AddTx(tx) + txHashs = append(txHashs, tx.Hash()) + }) + defer backend.teardown() + + // Write the block as a bad block so parent state is available + block := backend.chain.GetBlockByNumber(1) + rawdb.WriteBadBlock(backend.chaindb, block) + + api := NewAPI(backend) + result, err := api.TraceBadBlock(context.Background(), block.Hash(), nil) + if err != nil { + t.Fatalf("want no error, have %v", err) + } + if len(result) != 2 { + t.Fatalf("expected 2 tx traces, got %d", len(result)) + } + + // First tx: plain transfer + have, _ := json.Marshal(result) + var traces []struct { + TxHash common.Hash `json:"txHash"` + Result struct { + Gas uint64 `json:"gas"` + Failed bool `json:"failed"` + StructLogs []json.RawMessage `json:"structLogs"` + } `json:"result"` + } + if err := json.Unmarshal(have, &traces); err != nil { + t.Fatalf("failed to unmarshal traces: %v", err) + } + if traces[0].TxHash != txHashs[0] { + t.Errorf("tx 0: hash mismatch, have %v, want %v", traces[0].TxHash, txHashs[0]) + } + if traces[0].Result.Gas != params.TxGas { + t.Errorf("tx 0: gas mismatch, have %d, want %d", traces[0].Result.Gas, params.TxGas) + } + if len(traces[0].Result.StructLogs) != 0 { + t.Errorf("tx 0: expected empty structLogs for plain transfer, got %d entries", len(traces[0].Result.StructLogs)) + } + + // Second tx: contract call + if traces[1].TxHash != txHashs[1] { + t.Errorf("tx 1: hash mismatch, have %v, want %v", traces[1].TxHash, txHashs[1]) + } + if traces[1].Result.Failed { + t.Error("tx 1: expected success, got failed") + } + // Contract has 4 opcodes: PUSH1, PUSH1, SSTORE, STOP + if len(traces[1].Result.StructLogs) != 4 { + t.Errorf("tx 1: expected 4 structLog entries for contract call, got %d", len(traces[1].Result.StructLogs)) + } + + // Non-existent bad block + _, err = api.TraceBadBlock(context.Background(), common.Hash{42}, nil) + if err == nil { + t.Fatal("want error for non-existent bad block, have none") + } + wantErr := fmt.Sprintf("bad block %#x not found", common.Hash{42}) + if err.Error() != wantErr { + t.Errorf("error mismatch, want '%s', have '%v'", wantErr, err) + } +} + +func TestIntermediateRoots(t *testing.T) { + t.Parallel() + + // Initialize test accounts and a contract that writes to storage. + var ( + accounts = newAccounts(2) + storageContract = common.HexToAddress("0x00000000000000000000000000000000deadbeef") + signer = types.HomesteadSigner{} + genesis = &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + accounts[1].addr: {Balance: big.NewInt(params.Ether)}, + // Contract: SSTORE(CALLVALUE, CALLVALUE) + storageContract: { + Nonce: 1, + Balance: big.NewInt(0), + Code: []byte{ + byte(vm.CALLVALUE), + byte(vm.CALLVALUE), + byte(vm.SSTORE), + byte(vm.STOP), + }, + }, + }, + } + ) + backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) { + // tx 0: plain transfer + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 0, + To: &accounts[1].addr, + Value: big.NewInt(1000), + Gas: params.TxGas, + GasPrice: b.BaseFee(), + Data: nil}), + signer, accounts[0].key) + b.AddTx(tx) + + // tx 1: sstore(1, 1) + tx, _ = types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 1, + To: &storageContract, + Value: big.NewInt(1), + Gas: 50000, + GasPrice: b.BaseFee(), + Data: nil}), + signer, accounts[0].key) + b.AddTx(tx) + + // tx 2: sstore(2, 2) + tx, _ = types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 2, + To: &storageContract, + Value: big.NewInt(2), + Gas: 50000, + GasPrice: b.BaseFee(), + Data: nil}), + signer, accounts[0].key) + b.AddTx(tx) + }) + defer backend.teardown() + + api := NewAPI(backend) + block := backend.chain.GetBlockByNumber(1) + + // Should return one root per tx + roots, err := api.IntermediateRoots(context.Background(), block.Hash(), nil) + if err != nil { + t.Fatalf("want no error, have %v", err) + } + if len(roots) != 3 { + t.Fatalf("root count mismatch, have %d, want 3", len(roots)) + } + for i, root := range roots { + if root == (common.Hash{}) { + t.Errorf("root[%d] should not be zero", i) + } + } + if roots[0] == roots[1] { + t.Error("root[0] and root[1] should differ (transfer vs sstore)") + } + if roots[1] == roots[2] { + t.Error("root[1] and root[2] should differ (sstore to different slots)") + } + + // Intermediate roots of a bad block + rawdb.WriteBadBlock(backend.chaindb, block) + badRoots, err := api.IntermediateRoots(context.Background(), block.Hash(), nil) + if err != nil { + t.Fatalf("want no error for bad block fallback, have %v", err) + } + if !reflect.DeepEqual(roots, badRoots) { + t.Errorf("bad block roots mismatch, have %v, want %v", badRoots, roots) + } + + // Genesis block: should return error + genesisBlock := backend.chain.GetBlockByNumber(0) + _, err = api.IntermediateRoots(context.Background(), genesisBlock.Hash(), nil) + if err == nil || err.Error() != "genesis is not traceable" { + t.Fatalf("want 'genesis is not traceable' error, have %v", err) + } + + // Non-existent block: should return error + _, err = api.IntermediateRoots(context.Background(), common.Hash{42}, nil) + if err == nil { + t.Fatal("want error for non-existent block, have none") + } + wantErr := fmt.Sprintf("block %#x not found", common.Hash{42}) + if err.Error() != wantErr { + t.Errorf("error mismatch, want '%s', have '%v'", wantErr, err) + } +} + +func TestStandardTraceBadBlockToFile(t *testing.T) { + var ( + key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + address = crypto.PubkeyToAddress(key.PublicKey) + funds = big.NewInt(1000000000000000) + + aa = common.HexToAddress("0x7217d81b76bdd8707601e959454e3d776aee5f43") + aaCode = []byte{byte(vm.PUSH1), 0x00, byte(vm.POP)} + + bb = common.HexToAddress("0x7217d81b76bdd8707601e959454e3d776aee5f44") + bbCode = []byte{byte(vm.PUSH2), 0x00, 0x01, byte(vm.POP)} + ) + + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + address: {Balance: funds}, + aa: { + Code: aaCode, + Nonce: 1, + Balance: big.NewInt(0), + }, + bb: { + Code: bbCode, + Nonce: 1, + Balance: big.NewInt(0), + }, + }, + } + txHashs := make([]common.Hash, 0, 2) + backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) { + b.SetCoinbase(common.Address{1}) + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 0, + To: &aa, + Value: big.NewInt(0), + Gas: 50000, + GasPrice: b.BaseFee(), + Data: nil, + }), types.HomesteadSigner{}, key) + b.AddTx(tx) + txHashs = append(txHashs, tx.Hash()) + + tx, _ = types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 1, + To: &bb, + Value: big.NewInt(1), + Gas: 100000, + GasPrice: b.BaseFee(), + Data: nil, + }), types.HomesteadSigner{}, key) + b.AddTx(tx) + txHashs = append(txHashs, tx.Hash()) + }) + defer backend.teardown() + + // Write the block as a bad block + block := backend.chain.GetBlockByNumber(1) + rawdb.WriteBadBlock(backend.chaindb, block) + + var testSuite = []struct { + config *StdTraceConfig + want []string + }{ + { + // All txs traced + config: nil, + want: []string{ + `{"pc":0,"op":96,"gas":"0x7148","gasCost":"0x3","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"PUSH1"} +{"pc":2,"op":80,"gas":"0x7145","gasCost":"0x2","memSize":0,"stack":["0x0"],"depth":1,"refund":0,"opName":"POP"} +{"pc":3,"op":0,"gas":"0x7143","gasCost":"0x0","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"STOP"} +{"output":"","gasUsed":"0x5"} +`, + `{"pc":0,"op":97,"gas":"0x13498","gasCost":"0x3","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"PUSH2"} +{"pc":3,"op":80,"gas":"0x13495","gasCost":"0x2","memSize":0,"stack":["0x1"],"depth":1,"refund":0,"opName":"POP"} +{"pc":4,"op":0,"gas":"0x13493","gasCost":"0x0","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"STOP"} +{"output":"","gasUsed":"0x5"} +`, + }, + }, + { + // Specific tx traced + config: &StdTraceConfig{TxHash: txHashs[1]}, + want: []string{ + `{"pc":0,"op":97,"gas":"0x13498","gasCost":"0x3","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"PUSH2"} +{"pc":3,"op":80,"gas":"0x13495","gasCost":"0x2","memSize":0,"stack":["0x1"],"depth":1,"refund":0,"opName":"POP"} +{"pc":4,"op":0,"gas":"0x13493","gasCost":"0x0","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"STOP"} +{"output":"","gasUsed":"0x5"} +`, + }, + }, + } + + api := NewAPI(backend) + for i, tc := range testSuite { + txTraces, err := api.StandardTraceBadBlockToFile(context.Background(), block.Hash(), tc.config) + if err != nil { + t.Fatalf("test %d: unexpected error %v", i, err) + } + if len(txTraces) != len(tc.want) { + t.Fatalf("test %d: file count mismatch, have %d, want %d", i, len(txTraces), len(tc.want)) + } + for j, traceFileName := range txTraces { + defer os.Remove(traceFileName) + traceReceived, err := os.ReadFile(traceFileName) + if err != nil { + t.Fatalf("test %d: could not read trace file: %v", i, err) + } + if tc.want[j] != string(traceReceived) { + t.Fatalf("test %d, trace %d: result mismatch\nhave:\n%s\nwant:\n%s", i, j, string(traceReceived), tc.want[j]) + } + } + } + + // Non-existent bad block + _, err := api.StandardTraceBadBlockToFile(context.Background(), common.Hash{42}, nil) + if err == nil { + t.Fatal("want error for non-existent bad block, have none") + } +} diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go index ba0706c5986d..85eaef32ce95 100644 --- a/eth/tracers/internal/tracetest/calltrace_test.go +++ b/eth/tracers/internal/tracetest/calltrace_test.go @@ -43,6 +43,7 @@ type callLog struct { Address common.Address `json:"address"` Topics []common.Hash `json:"topics"` Data hexutil.Bytes `json:"data"` + Index hexutil.Uint `json:"index"` Position hexutil.Uint `json:"position"` } @@ -131,7 +132,7 @@ func testCallTracer(tracerName string, dirPath string, t *testing.T) { } evm := vm.NewEVM(context, logState, test.Genesis.Config, vm.Config{Tracer: tracer.Hooks}) tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) - vmRet, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + vmRet, err := core.ApplyMessage(evm, msg, nil) if err != nil { t.Fatalf("failed to execute transaction: %v", err) } @@ -223,7 +224,7 @@ func benchTracer(tracerName string, test *callTracerTest, b *testing.B) { if tracer.OnTxStart != nil { tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) } - _, err = core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + _, err = core.ApplyMessage(evm, msg, nil) if err != nil { b.Fatalf("failed to execute transaction: %v", err) } @@ -300,7 +301,7 @@ func TestInternals(t *testing.T) { byte(vm.LOG0), }, tracer: mkTracer("callTracer", json.RawMessage(`{ "withLog": true }`)), - want: fmt.Sprintf(`{"from":"%s","gas":"0x13880","gasUsed":"0x5b9e","to":"0x00000000000000000000000000000000deadbeef","input":"0x","logs":[{"address":"0x00000000000000000000000000000000deadbeef","topics":[],"data":"0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","position":"0x0"}],"value":"0x0","type":"CALL"}`, originHex), + want: fmt.Sprintf(`{"from":"%s","gas":"0x13880","gasUsed":"0x5b9e","to":"0x00000000000000000000000000000000deadbeef","input":"0x","logs":[{"address":"0x00000000000000000000000000000000deadbeef","topics":[],"data":"0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","index":"0x0","position":"0x0"}],"value":"0x0","type":"CALL"}`, originHex), }, { // Leads to OOM on the prestate tracer @@ -373,7 +374,7 @@ func TestInternals(t *testing.T) { t.Fatalf("test %v: failed to create message: %v", tc.name, err) } tc.tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) - vmRet, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + vmRet, err := core.ApplyMessage(evm, msg, nil) if err != nil { t.Fatalf("test %v: failed to execute transaction: %v", tc.name, err) } diff --git a/eth/tracers/internal/tracetest/erc7562_tracer_test.go b/eth/tracers/internal/tracetest/erc7562_tracer_test.go index f6e81f5886fd..02377b8dcbd1 100644 --- a/eth/tracers/internal/tracetest/erc7562_tracer_test.go +++ b/eth/tracers/internal/tracetest/erc7562_tracer_test.go @@ -124,7 +124,7 @@ func TestErc7562Tracer(t *testing.T) { } evm := vm.NewEVM(context, logState, test.Genesis.Config, vm.Config{Tracer: tracer.Hooks}) tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) - vmRet, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + vmRet, err := core.ApplyMessage(evm, msg, nil) if err != nil { t.Fatalf("failed to execute transaction: %v", err) } diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go index 1882ef315e06..37a05966eec0 100644 --- a/eth/tracers/internal/tracetest/flat_calltrace_test.go +++ b/eth/tracers/internal/tracetest/flat_calltrace_test.go @@ -113,7 +113,7 @@ func flatCallTracerTestRunner(tracerName string, filename string, dirPath string } evm := vm.NewEVM(context, state.StateDB, test.Genesis.Config, vm.Config{Tracer: tracer.Hooks}) tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) - vmRet, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + vmRet, err := core.ApplyMessage(evm, msg, nil) if err != nil { return fmt.Errorf("failed to execute transaction: %v", err) } diff --git a/eth/tracers/internal/tracetest/prestate_test.go b/eth/tracers/internal/tracetest/prestate_test.go index 456d962c6926..23216fa78c60 100644 --- a/eth/tracers/internal/tracetest/prestate_test.go +++ b/eth/tracers/internal/tracetest/prestate_test.go @@ -105,7 +105,7 @@ func testPrestateTracer(tracerName string, dirPath string, t *testing.T) { } evm := vm.NewEVM(context, state.StateDB, test.Genesis.Config, vm.Config{Tracer: tracer.Hooks}) tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) - vmRet, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + vmRet, err := core.ApplyMessage(evm, msg, nil) if err != nil { t.Fatalf("failed to execute transaction: %v", err) } diff --git a/eth/tracers/internal/tracetest/selfdestruct_state_test.go b/eth/tracers/internal/tracetest/selfdestruct_state_test.go new file mode 100644 index 000000000000..692c5eb77507 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_state_test.go @@ -0,0 +1,652 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package tracetest + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus" + "github.com/ethereum/go-ethereum/consensus/beacon" + "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/params" +) + +// accountState represents the expected final state of an account +type accountState struct { + Balance *big.Int + Nonce uint64 + Code []byte + Exists bool +} + +// selfdestructStateTracer tracks state changes during selfdestruct operations +type selfdestructStateTracer struct { + env *tracing.VMContext + accounts map[common.Address]*accountState +} + +func newSelfdestructStateTracer() *selfdestructStateTracer { + return &selfdestructStateTracer{ + accounts: make(map[common.Address]*accountState), + } +} + +func (t *selfdestructStateTracer) OnTxStart(env *tracing.VMContext, tx *types.Transaction, from common.Address) { + t.env = env +} + +func (t *selfdestructStateTracer) OnTxEnd(receipt *types.Receipt, err error) { + // Nothing to do +} + +func (t *selfdestructStateTracer) getOrCreateAccount(addr common.Address) *accountState { + if acc, ok := t.accounts[addr]; ok { + return acc + } + + // Initialize with current state from statedb + acc := &accountState{ + Balance: t.env.StateDB.GetBalance(addr).ToBig(), + Nonce: t.env.StateDB.GetNonce(addr), + Code: t.env.StateDB.GetCode(addr), + Exists: t.env.StateDB.Exist(addr), + } + t.accounts[addr] = acc + return acc +} + +func (t *selfdestructStateTracer) OnBalanceChange(addr common.Address, prev, new *big.Int, reason tracing.BalanceChangeReason) { + acc := t.getOrCreateAccount(addr) + acc.Balance = new +} + +func (t *selfdestructStateTracer) OnNonceChangeV2(addr common.Address, prev, new uint64, reason tracing.NonceChangeReason) { + acc := t.getOrCreateAccount(addr) + acc.Nonce = new + + // If this is a selfdestruct nonce change, mark account as not existing + if reason == tracing.NonceChangeSelfdestruct { + acc.Exists = false + } +} + +func (t *selfdestructStateTracer) OnCodeChangeV2(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte, reason tracing.CodeChangeReason) { + acc := t.getOrCreateAccount(addr) + acc.Code = code + + // If this is a selfdestruct code change, mark account as not existing + if reason == tracing.CodeChangeSelfDestruct { + acc.Exists = false + } +} + +func (t *selfdestructStateTracer) Hooks() *tracing.Hooks { + return &tracing.Hooks{ + OnTxStart: t.OnTxStart, + OnTxEnd: t.OnTxEnd, + OnBalanceChange: t.OnBalanceChange, + OnNonceChangeV2: t.OnNonceChangeV2, + OnCodeChangeV2: t.OnCodeChangeV2, + } +} + +func (t *selfdestructStateTracer) Accounts() map[common.Address]*accountState { + return t.accounts +} + +// verifyAccountState compares actual and expected account state and reports any mismatches +func verifyAccountState(t *testing.T, addr common.Address, actual, expected *accountState) { + if actual.Balance.Cmp(expected.Balance) != 0 { + t.Errorf("address %s: balance mismatch: have %s, want %s", + addr.Hex(), actual.Balance, expected.Balance) + } + if actual.Nonce != expected.Nonce { + t.Errorf("address %s: nonce mismatch: have %d, want %d", + addr.Hex(), actual.Nonce, expected.Nonce) + } + if len(actual.Code) != len(expected.Code) { + t.Errorf("address %s: code length mismatch: have %d, want %d", + addr.Hex(), len(actual.Code), len(expected.Code)) + } + if actual.Exists != expected.Exists { + t.Errorf("address %s: exists mismatch: have %v, want %v", + addr.Hex(), actual.Exists, expected.Exists) + } +} + +// setupTestBlockchain creates a blockchain with the given genesis and transaction, +// returns the blockchain, the first block, and a statedb at genesis for testing +func setupTestBlockchain(t *testing.T, genesis *core.Genesis, tx *types.Transaction, useBeacon bool) (*core.BlockChain, *types.Block, *state.StateDB) { + var engine consensus.Engine + if useBeacon { + engine = beacon.New(ethash.NewFaker()) + } else { + engine = ethash.NewFaker() + } + + _, blocks, _ := core.GenerateChainWithGenesis(genesis, engine, 1, func(i int, b *core.BlockGen) { + b.AddTx(tx) + }) + db := rawdb.NewMemoryDatabase() + blockchain, err := core.NewBlockChain(db, genesis, engine, nil) + if err != nil { + t.Fatalf("failed to create blockchain: %v", err) + } + if _, err := blockchain.InsertChain(blocks); err != nil { + t.Fatalf("failed to insert chain: %v", err) + } + genesisBlock := blockchain.GetBlockByNumber(0) + if genesisBlock == nil { + t.Fatalf("failed to get genesis block") + } + statedb, err := blockchain.StateAt(genesisBlock.Header()) + if err != nil { + t.Fatalf("failed to get state: %v", err) + } + + return blockchain, blocks[0], statedb +} + +func TestSelfdestructStateTracer(t *testing.T) { + t.Parallel() + + const ( + // Gas limit high enough for all test scenarios (factory creation + multiple calls) + testGasLimit = 500000 + + // Common balance amounts used across tests + testBalanceInitial = 100 // Initial balance for contracts being tested + testBalanceSent = 50 // Amount sent back in sendback tests + testBalanceFactory = 200 // Factory needs extra balance for contract creation + ) + + // Helper to create *big.Int for wei amounts + wei := func(amount int64) *big.Int { + return big.NewInt(amount) + } + + // Test account (transaction sender) + var ( + key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + caller = crypto.PubkeyToAddress(key.PublicKey) + ) + + // Simple selfdestruct test contracts + var ( + contract = common.HexToAddress("0x00000000000000000000000000000000000000bb") + recipient = common.HexToAddress("0x00000000000000000000000000000000000000cc") + ) + // Build selfdestruct code: PUSH20 SELFDESTRUCT + selfdestructCode := []byte{byte(vm.PUSH20)} + selfdestructCode = append(selfdestructCode, recipient.Bytes()...) + selfdestructCode = append(selfdestructCode, byte(vm.SELFDESTRUCT)) + + // Factory test contracts (create-and-destroy pattern) + var ( + factory = common.HexToAddress("0x00000000000000000000000000000000000000ff") + ) + // Factory code: creates a contract with 100 wei and calls it to trigger selfdestruct back to factory + // See selfdestruct_test_contracts/factory.yul for source + // Runtime bytecode compiled with: solc --strict-assembly --evm-version paris factory.yul --bin + // (Using paris to avoid PUSH0 opcode which is not available pre-Shanghai) + var ( + factoryCode = common.Hex2Bytes("6a6133ff6000526002601ef360a81b600052600080808080600b816064f05af100") + createdContractAddr = crypto.CreateAddress(factory, 0) // Address where factory creates the contract + ) + + // Sendback test contracts (A→B→A pattern) + // For the refund test: Coordinator calls A, then B + // A selfdestructs to B, B sends funds back to A + var ( + contractA = common.HexToAddress("0x00000000000000000000000000000000000000aa") + contractB = common.HexToAddress("0x00000000000000000000000000000000000000bb") + coordinator = common.HexToAddress("0x00000000000000000000000000000000000000cc") + ) + // Contract A: if msg.value > 0, accept funds; else selfdestruct to B + // See selfdestruct_test_contracts/contractA.yul for source + // Runtime bytecode compiled with: solc --strict-assembly --evm-version paris contractA.yul --bin + contractACode := common.Hex2Bytes("60003411600a5760bbff5b00") + + // Contract B: sends 50 wei back to contract A + // See selfdestruct_test_contracts/contractB.yul for source + // Runtime bytecode compiled with: solc --strict-assembly --evm-version paris contractB.yul --bin + contractBCode := common.Hex2Bytes("6000808080603260aa5af100") + + // Coordinator: calls A (A selfdestructs to B), then calls B (B sends funds to A) + // See selfdestruct_test_contracts/coordinator.yul for source + // Runtime bytecode compiled with: solc --strict-assembly --evm-version paris coordinator.yul --bin + coordinatorCode := common.Hex2Bytes("60008080808060aa818080808060bb955af1505af100") + + // Factory for create-and-refund test: creates A with 100 wei, calls A, calls B + // See selfdestruct_test_contracts/factoryRefund.yul for source + // Runtime bytecode compiled with: solc --strict-assembly --evm-version paris factoryRefund.yul --bin + var ( + factoryRefund = common.HexToAddress("0x00000000000000000000000000000000000000dd") + factoryRefundCode = common.Hex2Bytes("60008080808060bb78600c600d600039600c6000f3fe60003411600a5760bbff5b0082528180808080601960076064f05af1505af100") + createdContractAddrA = crypto.CreateAddress(factoryRefund, 0) // Address where factory creates contract A + ) + + // Self-destruct-to-self test contracts + var ( + contractSelfDestruct = common.HexToAddress("0x00000000000000000000000000000000000000aa") + coordinatorSendAfter = common.HexToAddress("0x00000000000000000000000000000000000000ee") + ) + // Contract that selfdestructs to self + // See selfdestruct_test_contracts/contractSelfDestruct.yul + contractSelfDestructCode := common.Hex2Bytes("30ff") + + // Coordinator: calls contract (triggers selfdestruct to self), stores balance, sends 50 wei, stores balance again + // See selfdestruct_test_contracts/coordinatorSendAfter.yul + coordinatorSendAfterCode := common.Hex2Bytes("60aa600080808080855af150803160005560008080806032855af1503160015500") + + // Factory with balance checking: creates contract, calls it, checks balances + // See selfdestruct_test_contracts/factorySelfDestructBalanceCheck.yul + var ( + factorySelfDestructBalanceCheck = common.HexToAddress("0x00000000000000000000000000000000000000fd") + factorySelfDestructBalanceCheckCode = common.Hex2Bytes("6e6002600d60003960026000f3fe30ff600052600f60116064f0600080808080855af150803160005560008080806032855af1503160015500") + createdContractAddrSelfBalanceCheck = crypto.CreateAddress(factorySelfDestructBalanceCheck, 0) + ) + + tests := []struct { + name string + description string + targetContract common.Address + genesis *core.Genesis + useBeacon bool + expectedResults map[common.Address]accountState + expectedStorage map[common.Address]map[uint64]*big.Int + }{ + { + name: "pre_6780_existing", + description: "Pre-EIP-6780: Existing contract selfdestructs to recipient. Contract should be destroyed and balance transferred.", + targetContract: contract, + genesis: &core.Genesis{ + Config: params.AllEthashProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + contract: { + Balance: wei(testBalanceInitial), + Code: selfdestructCode, + }, + }, + }, + useBeacon: false, + expectedResults: map[common.Address]accountState{ + contract: { + Balance: wei(0), + Nonce: 0, + Code: []byte{}, + Exists: false, + }, + recipient: { + Balance: wei(testBalanceInitial), // Received contract's balance + Nonce: 0, + Code: []byte{}, + Exists: true, + }, + }, + }, + { + name: "post_6780_existing", + description: "Post-EIP-6780: Existing contract selfdestructs to recipient. Balance transferred but contract NOT destroyed (code/storage remain).", + targetContract: contract, + genesis: &core.Genesis{ + Config: params.AllDevChainProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + contract: { + Balance: wei(testBalanceInitial), + Code: selfdestructCode, + }, + }, + }, + useBeacon: true, + expectedResults: map[common.Address]accountState{ + contract: { + Balance: wei(0), + Nonce: 0, + Code: selfdestructCode, + Exists: true, + }, + recipient: { + Balance: wei(testBalanceInitial), + Nonce: 0, + Code: []byte{}, + Exists: true, + }, + }, + }, + { + name: "pre_6780_create_destroy", + description: "Pre-EIP-6780: Factory creates contract with 100 wei, contract selfdestructs back to factory. Contract destroyed, factory gets refund.", + targetContract: factory, + genesis: &core.Genesis{ + Config: params.AllEthashProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + factory: { + Balance: wei(testBalanceFactory), + Code: factoryCode, + }, + }, + }, + useBeacon: false, + expectedResults: map[common.Address]accountState{ + factory: { + Balance: wei(testBalanceFactory), + Nonce: 1, + Code: factoryCode, + Exists: true, + }, + createdContractAddr: { + Balance: wei(0), + Nonce: 0, + Code: []byte{}, + Exists: false, + }, + }, + }, + { + name: "post_6780_create_destroy", + description: "Post-EIP-6780: Factory creates contract with 100 wei, contract selfdestructs back to factory. Contract destroyed (EIP-6780 exception for same-tx creation).", + targetContract: factory, + genesis: &core.Genesis{ + Config: params.AllDevChainProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + factory: { + Balance: wei(testBalanceFactory), + Code: factoryCode, + }, + }, + }, + useBeacon: true, + expectedResults: map[common.Address]accountState{ + factory: { + Balance: wei(testBalanceFactory), + Nonce: 1, + Code: factoryCode, + Exists: true, + }, + createdContractAddr: { + Balance: wei(0), + Nonce: 0, + Code: []byte{}, + Exists: false, + }, + }, + }, + { + name: "pre_6780_sendback", + description: "Pre-EIP-6780: Contract A selfdestructs sending funds to B, then B sends funds back to A's address. Funds sent to destroyed address are burnt.", + targetContract: coordinator, + genesis: &core.Genesis{ + Config: params.AllEthashProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + contractA: { + Balance: wei(testBalanceInitial), + Code: contractACode, + }, + contractB: { + Balance: wei(0), + Code: contractBCode, + }, + coordinator: { + Code: coordinatorCode, + }, + }, + }, + useBeacon: false, + expectedResults: map[common.Address]accountState{ + contractA: { + Balance: wei(0), + Nonce: 0, + Code: []byte{}, + Exists: false, + }, + contractB: { + // 100 received - 50 sent back + Balance: wei(testBalanceSent), + Nonce: 0, + Code: contractBCode, + Exists: true, + }, + }, + }, + { + name: "post_6780_existing_sendback", + description: "Post-EIP-6780: Existing contract A selfdestructs to B, then B sends funds back to A. Funds are NOT burnt (A still exists post-6780).", + targetContract: coordinator, + genesis: &core.Genesis{ + Config: params.AllDevChainProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + contractA: { + Balance: wei(testBalanceInitial), + Code: contractACode, + }, + contractB: { + Balance: wei(0), + Code: contractBCode, + }, + coordinator: { + Code: coordinatorCode, + }, + }, + }, + useBeacon: true, + expectedResults: map[common.Address]accountState{ + contractA: { + Balance: wei(testBalanceSent), + Nonce: 0, + Code: contractACode, + Exists: true, + }, + contractB: { + Balance: wei(testBalanceSent), + Nonce: 0, + Code: contractBCode, + Exists: true, + }, + }, + }, + { + name: "post_6780_create_destroy_sendback", + description: "Post-EIP-6780: Factory creates A, A selfdestructs to B, B sends funds back to A. Funds are burnt (A was destroyed via EIP-6780 exception).", + targetContract: factoryRefund, + genesis: &core.Genesis{ + Config: params.AllDevChainProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + contractB: { + Balance: wei(0), + Code: contractBCode, + }, + factoryRefund: { + Balance: wei(testBalanceFactory), + Code: factoryRefundCode, + }, + }, + }, + useBeacon: true, + expectedResults: map[common.Address]accountState{ + createdContractAddrA: { + // Funds sent back are burnt! + Balance: wei(0), + Nonce: 0, + Code: []byte{}, + Exists: false, + }, + contractB: { + Balance: wei(testBalanceSent), + Nonce: 0, + Code: contractBCode, + Exists: true, + }, + }, + }, + { + name: "post_6780_existing_to_self", + description: "Post-EIP-6780: Pre-existing contract selfdestructs to itself. Balance NOT burnt (selfdestruct-to-self is no-op for existing contracts).", + targetContract: coordinatorSendAfter, + genesis: &core.Genesis{ + Config: params.AllDevChainProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + contractSelfDestruct: { + Balance: wei(testBalanceInitial), + Code: contractSelfDestructCode, + }, + coordinatorSendAfter: { + Balance: wei(testBalanceInitial), + Code: coordinatorSendAfterCode, + }, + }, + }, + useBeacon: true, + expectedResults: map[common.Address]accountState{ + contractSelfDestruct: { + Balance: wei(150), + Nonce: 0, + Code: contractSelfDestructCode, + Exists: true, + }, + coordinatorSendAfter: { + Balance: wei(testBalanceSent), + Nonce: 0, + Code: coordinatorSendAfterCode, + Exists: true, + }, + }, + expectedStorage: map[common.Address]map[uint64]*big.Int{ + coordinatorSendAfter: { + 0: wei(testBalanceInitial), + 1: wei(150), + }, + }, + }, + { + name: "post_6780_create_destroy_to_self", + description: "Post-EIP-6780: Factory creates contract, contract selfdestructs to itself. Balance IS burnt and contract destroyed (EIP-6780 exception for same-tx creation).", + targetContract: factorySelfDestructBalanceCheck, + genesis: &core.Genesis{ + Config: params.AllDevChainProtocolChanges, + Alloc: types.GenesisAlloc{ + caller: {Balance: big.NewInt(params.Ether)}, + factorySelfDestructBalanceCheck: { + Balance: wei(testBalanceFactory), + Code: factorySelfDestructBalanceCheckCode, + }, + }, + }, + useBeacon: true, + expectedResults: map[common.Address]accountState{ + createdContractAddrSelfBalanceCheck: { + Balance: wei(0), + Nonce: 0, + Code: []byte{}, + Exists: false, + }, + factorySelfDestructBalanceCheck: { + Balance: wei(testBalanceSent), + Nonce: 1, + Code: factorySelfDestructBalanceCheckCode, + Exists: true, + }, + }, + expectedStorage: map[common.Address]map[uint64]*big.Int{ + factorySelfDestructBalanceCheck: { + 0: wei(0), + 1: wei(0), + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + var ( + signer = types.HomesteadSigner{} + tx *types.Transaction + err error + ) + + tx, err = types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: 0, + To: &tt.targetContract, + Value: big.NewInt(0), + Gas: testGasLimit, + GasPrice: big.NewInt(params.InitialBaseFee * 2), + Data: nil, + }), signer, key) + if err != nil { + t.Fatalf("failed to sign transaction: %v", err) + } + + blockchain, block, statedb := setupTestBlockchain(t, tt.genesis, tx, tt.useBeacon) + defer blockchain.Stop() + + tracer := newSelfdestructStateTracer() + hookedState := state.NewHookedState(statedb, tracer.Hooks()) + msg, err := core.TransactionToMessage(tx, signer, nil) + if err != nil { + t.Fatalf("failed to prepare transaction for tracing: %v", err) + } + context := core.NewEVMBlockContext(block.Header(), blockchain, nil) + evm := vm.NewEVM(context, hookedState, tt.genesis.Config, vm.Config{Tracer: tracer.Hooks()}) + _, err = core.ApplyTransactionWithEVM(msg, core.NewGasPool(msg.GasLimit), statedb, block.Number(), block.Hash(), block.Time(), tx, evm) + if err != nil { + t.Fatalf("failed to execute transaction: %v", err) + } + + results := tracer.Accounts() + + // Verify storage + for addr, expectedSlots := range tt.expectedStorage { + for slot, expectedValue := range expectedSlots { + actualValue := statedb.GetState(addr, common.BigToHash(big.NewInt(int64(slot)))) + if actualValue.Big().Cmp(expectedValue) != 0 { + t.Errorf("address %s slot %d: storage mismatch: have %s, want %s", + addr.Hex(), slot, actualValue.Big(), expectedValue) + } + } + } + + // Verify results + for addr, expected := range tt.expectedResults { + actual, ok := results[addr] + if !ok { + t.Errorf("address %s missing from results", addr.Hex()) + continue + } + verifyAccountState(t, addr, actual, &expected) + } + }) + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractA.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractA.yul new file mode 100644 index 000000000000..109551f26e51 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractA.yul @@ -0,0 +1,18 @@ +object "ContractA" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + // If receiving funds (msg.value > 0), just accept them and return + if gt(callvalue(), 0) { + stop() + } + + // Otherwise, selfdestruct to B (transfers balance immediately, then stops execution) + let contractB := 0x00000000000000000000000000000000000000bb + selfdestruct(contractB) + } + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractB.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractB.yul new file mode 100644 index 000000000000..c737355fb640 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractB.yul @@ -0,0 +1,14 @@ +object "ContractB" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + // Send 50 wei back to contract A + let contractA := 0x00000000000000000000000000000000000000aa + let success := call(gas(), contractA, 50, 0, 0, 0, 0) + stop() + } + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractSelfDestruct.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractSelfDestruct.yul new file mode 100644 index 000000000000..73884c5dd4a4 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/contractSelfDestruct.yul @@ -0,0 +1,12 @@ +object "ContractSelfDestruct" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + // Simply selfdestruct to self + selfdestruct(address()) + } + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/coordinator.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/coordinator.yul new file mode 100644 index 000000000000..54bd5c08f3b1 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/coordinator.yul @@ -0,0 +1,20 @@ +object "Coordinator" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + let contractA := 0x00000000000000000000000000000000000000aa + let contractB := 0x00000000000000000000000000000000000000bb + + // First, call A (A will selfdestruct to B) + pop(call(gas(), contractA, 0, 0, 0, 0, 0)) + + // Then, call B (B will send funds back to A) + pop(call(gas(), contractB, 0, 0, 0, 0, 0)) + + stop() + } + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/coordinatorSendAfter.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/coordinatorSendAfter.yul new file mode 100644 index 000000000000..9473d1f3ef67 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/coordinatorSendAfter.yul @@ -0,0 +1,27 @@ +object "CoordinatorSendAfter" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + let contractAddr := 0x00000000000000000000000000000000000000aa + + // Call contract (triggers selfdestruct to self, burning its balance) + pop(call(gas(), contractAddr, 0, 0, 0, 0, 0)) + + // Check contract's balance immediately after selfdestruct + // Store in slot 0 to verify it's 0 (proving immediate burn) + sstore(0, balance(contractAddr)) + + // Send 50 wei to the contract (after it selfdestructed) + pop(call(gas(), contractAddr, 50, 0, 0, 0, 0)) + + // Check balance again after sending funds + // Store in slot 1 to verify it's 50 (new funds not burnt) + sstore(1, balance(contractAddr)) + + stop() + } + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/factoryRefund.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/factoryRefund.yul new file mode 100644 index 000000000000..f52a46fcc306 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/factoryRefund.yul @@ -0,0 +1,28 @@ +object "FactoryRefund" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + let contractB := 0x00000000000000000000000000000000000000bb + + // Store the deploy bytecode for contract A in memory + // Full deploy bytecode from: solc --strict-assembly --evm-version paris contractA.yul --bin + // Including the 0xfe separator: 600c600d600039600c6000f3fe60003411600a5760bbff5b00 + // That's 25 bytes, padded to 32 bytes with 7 zero bytes at the front + mstore(0, 0x0000000000000000000000000000600c600d600039600c6000f3fe60003411600a5760bbff5b00) + + // CREATE contract A with 100 wei, using 25 bytes starting at position 7 + let contractA := create(100, 7, 25) + + // Call contract A (triggers selfdestruct to B) + pop(call(gas(), contractA, 0, 0, 0, 0, 0)) + + // Call contract B (B sends 50 wei back to A) + pop(call(gas(), contractB, 0, 0, 0, 0, 0)) + + stop() + } + } +} diff --git a/eth/tracers/internal/tracetest/selfdestruct_test_contracts/factorySelfDestructBalanceCheck.yul b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/factorySelfDestructBalanceCheck.yul new file mode 100644 index 000000000000..46f462841969 --- /dev/null +++ b/eth/tracers/internal/tracetest/selfdestruct_test_contracts/factorySelfDestructBalanceCheck.yul @@ -0,0 +1,35 @@ +object "FactorySelfDestructBalanceCheck" { + code { + datacopy(0, dataoffset("Runtime"), datasize("Runtime")) + return(0, datasize("Runtime")) + } + object "Runtime" { + code { + // Get the full deploy bytecode for ContractSelfDestruct + // Compiled with: solc --strict-assembly --evm-version paris contractSelfDestruct.yul --bin + // Full bytecode: 6002600d60003960026000f3fe30ff + // That's 15 bytes total, padded to 32 bytes with 17 zero bytes at front + mstore(0, 0x0000000000000000000000000000000000000000006002600d60003960026000f3fe30ff) + + // CREATE contract with 100 wei, using deploy bytecode + // The bytecode is 15 bytes, starts at position 17 in the 32-byte word + let contractAddr := create(100, 17, 15) + + // Call the created contract (triggers selfdestruct to self) + pop(call(gas(), contractAddr, 0, 0, 0, 0, 0)) + + // Check contract's balance immediately after selfdestruct + // Store in slot 0 to verify it's 0 (proving immediate burn) + sstore(0, balance(contractAddr)) + + // Send 50 wei to the contract (after it selfdestructed) + pop(call(gas(), contractAddr, 50, 0, 0, 0, 0)) + + // Check balance again after sending funds + // Store in slot 1 to verify it's 0 (funds sent to destroyed contract are burnt) + sstore(1, balance(contractAddr)) + + stop() + } + } +} diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/calldata.json b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/calldata.json index 30991edafb2c..854252470346 100644 --- a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/calldata.json +++ b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/calldata.json @@ -94,7 +94,8 @@ "0xe1c52dc63b719ade82e8bea94cc41a0d5d28e4aaf536adb5e9cccc9ff8c1aeda" ], "data": "0x0000000000000000000000004f5777744b500616697cb655dcb02ee6cd51deb5be96016bb57376da7a6d296e0a405ee1501778227dfa604df0a81cb1ae018598", - "position": "0x0" + "position": "0x0", + "index": "0x0" }, { "address": "0x200edd17f30485a8735878661960cd7a9a95733f", @@ -102,7 +103,8 @@ "0xacbdb084c721332ac59f9b8e392196c9eb0e4932862da8eb9beaf0dad4f550da" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000000", - "position": "0x0" + "position": "0x0", + "index": "0x1" } ], "value": "0x8ac7230489e80000", @@ -112,4 +114,4 @@ "value": "0x8ac7230489e80000", "type": "CALL" } -} +} \ No newline at end of file diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/delegatecall.json b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/delegatecall.json index cdb0dda5f82b..8e991f2ba2c2 100644 --- a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/delegatecall.json +++ b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/delegatecall.json @@ -256,6 +256,7 @@ "0x0000000000000000000000006ca7f214ab2ddbb9a8e1a1e2c8550e3164e9dba5" ], "data": "0x00000000000000000000000000000000000000000000000080d29fa5cccfadac", + "index": "0x0", "position": "0x0" } ], @@ -278,6 +279,7 @@ "0x0000000000000000000000005aae5c59d642e5fd45b427df6ed478b49d55fefd" ], "data": "0x00000000000000000000000000000000000000000000000080d29fa5cccfadac", + "index": "0x1", "position": "0x0" } ], @@ -308,6 +310,7 @@ "0x0000000000000000000000005aae5c59d642e5fd45b427df6ed478b49d55fefd" ], "data": "0x00000000000000000000000000000000000000000000000080d29fa5cccfadac", + "index": "0x2", "position": "0x0" } ], @@ -330,6 +333,7 @@ "0x000000000000000000000000950ca4a06c78934a148b7a3ff3ea8fc366f77a06" ], "data": "0x0000000000000000000000000000000000000000000000000041f50e27d56848", + "index": "0x3", "position": "0x0" } ], @@ -394,6 +398,7 @@ "0x0000000000000000000000003de712784baf97260455ae25fb74f574ec9c1add" ], "data": "0x000000000000000000000000000000000000000000000000de0b6b3a76400000", + "index": "0x4", "position": "0x0" } ], @@ -408,4 +413,4 @@ "value": "0x0", "type": "CALL" } -} +} \ No newline at end of file diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multi_contracts.json b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multi_contracts.json index 43d6be2be9c9..32a267fed0d1 100644 --- a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multi_contracts.json +++ b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multi_contracts.json @@ -356,6 +356,7 @@ "0x0000000000000000000000004fd27b205895e698fa350f7ea57cec8a21927fcd" ], "data": "0x00000000000000000000000000000000000000000001819451f999d617dafa93", + "index": "0x0", "position": "0x0" } ], @@ -370,6 +371,7 @@ "0x69ca02dd4edd7bf0a4abb9ed3b7af3f14778db5d61921c7dc7cd545266326de2" ], "data": "0x0000000000000000000000004fd27b205895e698fa350f7ea57cec8a21927fcd00000000000000000000000000000000000000000001819451f999d617dafa93", + "index": "0x1", "position": "0x1" } ], @@ -492,6 +494,7 @@ "0x0000000000000000000000004fd27b205895e698fa350f7ea57cec8a21927fcd" ], "data": "0x00000000000000000000000000000000000000000001819451f999d617dafa76", + "index": "0x2", "position": "0x0" } ], @@ -506,6 +509,7 @@ "0x69ca02dd4edd7bf0a4abb9ed3b7af3f14778db5d61921c7dc7cd545266326de2" ], "data": "0x0000000000000000000000004fd27b205895e698fa350f7ea57cec8a21927fcd00000000000000000000000000000000000000000001819451f999d617dafa76", + "index": "0x3", "position": "0x1" } ], @@ -695,6 +699,7 @@ "0x0000000000000000000000006e715ab4f598eacf0016b9b35ef33e4141844ccc" ], "data": "0x0000000000000000000000000000000000000000000181a7ae53ea2f0bef8ccd", + "index": "0x5", "position": "0x0" } ], @@ -878,6 +883,7 @@ "0x0000000000000000000000004fd27b205895e698fa350f7ea57cec8a21927fcd" ], "data": "0x0000000000000000000000000000000000000000000181a7ae53ea2f0bef8ccc", + "index": "0x7", "position": "0x0" } ], @@ -897,6 +903,7 @@ "0x0000000000000000000000006e715ab4f598eacf0016b9b35ef33e4141844ccc" ], "data": "0x0000000000000000000000000000000000000000000000022b1c8c12279fffff", + "index": "0x8", "position": "0x1" } ], @@ -920,6 +927,7 @@ "0x0000000000000000000000006e715ab4f598eacf0016b9b35ef33e4141844ccc" ], "data": "0x0000000000000000000000000000000000000000000000022b1c8c12279fffff", + "index": "0x9", "position": "0x1" } ], @@ -946,6 +954,7 @@ "0x0000000000000000000000006dbfc63479ffc031f23e94dc91befa38bec2c25f" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "index": "0xa", "position": "0x0" } ], @@ -960,6 +969,7 @@ "0x07cf7e805770612a8b2ee8e0bcbba8aa908df5f85fbc4f9e2ef384cf75315038" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000000", + "index": "0x4", "position": "0x6" }, { @@ -968,6 +978,7 @@ "0x7027eecbd2a688fc1fa281702b311ed7168571514adfd17014a55d828cb43382" ], "data": "0x000000000000000000000000000000000000000000000004563918244f400000", + "index": "0x6", "position": "0x8" } ], @@ -1045,6 +1056,7 @@ "0x0000000000000000000000006dbfc63479ffc031f23e94dc91befa38bec2c25f" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000063", + "index": "0xb", "position": "0x0" } ], @@ -1173,6 +1185,7 @@ "0x000000000000000000000000da4a4626d3e16e094de3225a751aab7128e96526" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000064", + "index": "0xe", "position": "0x0" } ], @@ -1187,6 +1200,7 @@ "0x4b0bc4f25f8d0b92d2e12b686ba96cd75e4e69325e6cf7b1f3119d14eaf2cbdf" ], "data": "0x000000000000000000000000da4a4626d3e16e094de3225a751aab7128e96526", + "index": "0xc", "position": "0x6" }, { @@ -1195,6 +1209,7 @@ "0xf340c079d598119636d42046c6a2d2faf7a68c04aecee516f0e0b8a9e79b8666" ], "data": "0x000000000000000000000000da4a4626d3e16e094de3225a751aab7128e9652600000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000000", + "index": "0xd", "position": "0x9" } ], @@ -1245,6 +1260,7 @@ "0x0000000000000000000000007498bb5749c9801f1f7e490baf5f966dbfe4e97b" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000001", + "index": "0xf", "position": "0x0" } ], @@ -1339,6 +1355,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000001" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x10", "position": "0x2" } ], @@ -1433,6 +1450,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000002" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x11", "position": "0x2" } ], @@ -1527,6 +1545,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000003" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x12", "position": "0x2" } ], @@ -1621,6 +1640,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000004" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x13", "position": "0x2" } ], @@ -1715,6 +1735,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000005" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x14", "position": "0x2" } ], @@ -1809,6 +1830,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000006" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x15", "position": "0x2" } ], @@ -1903,6 +1925,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000007" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x16", "position": "0x2" } ], @@ -1997,6 +2020,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000008" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x17", "position": "0x2" } ], @@ -2091,6 +2115,7 @@ "0x0000000000000000000000000000000000000000000000000000000000000009" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x18", "position": "0x2" } ], @@ -2185,6 +2210,7 @@ "0x000000000000000000000000000000000000000000000000000000000000000a" ], "data": "0x000000000000000000000000be3ae5cb97c253dda67181c6e34e43f5c275e08b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000", + "index": "0x19", "position": "0x2" } ], @@ -2238,6 +2264,7 @@ "0x0000000000000000000000007ccbc69292c7a6d7b538c91f3b283de97906cf30" ], "data": "0x00000000000000000000000000000000000000000001010d8bfbbbe40fe7518c", + "index": "0x1a", "position": "0x0" } ], @@ -2260,6 +2287,7 @@ "0x0000000000000000000000001b9ec8ba24630b75a7a958153ffff56dd6d4b6a2" ], "data": "0x00000000000000000000000000000000000000000001010d8bfbbbe40fe7518c", + "index": "0x1c", "position": "0x0" } ], @@ -2282,6 +2310,7 @@ "0x000000000000000000000000c3a2c744ad1f5253c736875b93bacce5b01b060b" ], "data": "0x00000000000000000000000000000000000000000001010d8bfbbbe40fe7518c", + "index": "0x1e", "position": "0x0" } ], @@ -2296,6 +2325,7 @@ "0xc6d8c0af6d21f291e7c359603aa97e0ed500f04db6e983b9fce75a91c6b8da6b" ], "data": "0x00000000000000000000000000000000000000000001010d8bfbbbe40fe7518c", + "index": "0x1b", "position": "0x2" }, { @@ -2304,6 +2334,7 @@ "0xc6d8c0af6d21f291e7c359603aa97e0ed500f04db6e983b9fce75a91c6b8da6b" ], "data": "0x00000000000000000000000000000000000000000001010d8bfbbbe40fe7518c", + "index": "0x1d", "position": "0x3" }, { @@ -2312,6 +2343,7 @@ "0xc6d8c0af6d21f291e7c359603aa97e0ed500f04db6e983b9fce75a91c6b8da6b" ], "data": "0x00000000000000000000000000000000000000000001010d8bfbbbe40fe7518c", + "index": "0x1f", "position": "0x4" } ], @@ -2322,4 +2354,4 @@ "value": "0x0", "type": "CALL" } -} +} \ No newline at end of file diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multilogs.json b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multilogs.json index 3434dd31031d..721e300774d7 100644 --- a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multilogs.json +++ b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/multilogs.json @@ -177,6 +177,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034100000000000000000000000000000000000000000000000000000000000000390000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffefefe0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x0", "position": "0x0" }, { @@ -185,6 +186,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdfdfd0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x1", "position": "0x0" }, { @@ -193,6 +195,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034100000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffebebeb0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x2", "position": "0x0" }, { @@ -201,6 +204,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8888880000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x3", "position": "0x0" }, { @@ -209,6 +213,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000341000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb3b3b30000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x4", "position": "0x0" }, { @@ -217,6 +222,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000000350000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcfcfc0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x5", "position": "0x0" }, { @@ -225,6 +231,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034100000000000000000000000000000000000000000000000000000000000000350000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x6", "position": "0x0" }, { @@ -233,6 +240,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff000000000000000000000000000000000000000000000000000000000000003b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe3e3e30000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x7", "position": "0x0" }, { @@ -241,6 +249,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000341000000000000000000000000000000000000000000000000000000000000003b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3e3e3e0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x8", "position": "0x0" }, { @@ -249,6 +258,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000000340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x9", "position": "0x0" }, { @@ -257,6 +267,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034100000000000000000000000000000000000000000000000000000000000000340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0xa", "position": "0x0" }, { @@ -265,6 +276,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0xb", "position": "0x0" }, { @@ -273,6 +285,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000341000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdbdbdb0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0xc", "position": "0x0" }, { @@ -281,6 +294,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000000330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0xd", "position": "0x0" }, { @@ -289,6 +303,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034100000000000000000000000000000000000000000000000000000000000000330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4f4f40000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0xe", "position": "0x0" }, { @@ -297,6 +312,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff000000000000000000000000000000000000000000000000000000000000003d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0xf", "position": "0x0" }, { @@ -305,6 +321,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000341000000000000000000000000000000000000000000000000000000000000003d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x10", "position": "0x0" }, { @@ -313,6 +330,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff00000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x11", "position": "0x0" }, { @@ -321,6 +339,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034100000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbfbfb0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x12", "position": "0x0" }, { @@ -329,6 +348,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002ff000000000000000000000000000000000000000000000000000000000000003e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x13", "position": "0x0" }, { @@ -337,6 +357,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000341000000000000000000000000000000000000000000000000000000000000003e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x14", "position": "0x0" }, { @@ -345,6 +366,7 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb0b0b00000000000000000000000000000000000000000000000000011c37937e08000", + "index": "0x15", "position": "0x0" }, { @@ -353,7 +375,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffefefe0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x16", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -361,7 +384,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000370000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa0a0a00000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x17", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -369,7 +393,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000370000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b5b5b0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x18", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -377,7 +402,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000390000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbababa0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x19", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -385,7 +411,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000390000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x1a", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -393,7 +420,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeaeaea0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x1b", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -401,7 +429,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa9a9a90000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x1c", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -409,7 +438,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb9b9b90000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x1d", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -417,7 +447,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000342000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbfbfb0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x1e", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -425,7 +456,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000350000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffefefe0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x1f", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -433,7 +465,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000350000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffefefe0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x20", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -441,7 +474,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe000000000000000000000000000000000000000000000000000000000000003b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffbababa0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x21", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -449,7 +483,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000342000000000000000000000000000000000000000000000000000000000000003b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6363630000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x22", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -457,7 +492,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x23", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -465,7 +501,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9f9f90000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x24", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -473,7 +510,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeaeaea0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x25", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -481,7 +519,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000342000000000000000000000000000000000000000000000000000000000000003c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff9c9c9c0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x26", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -489,7 +528,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8f8f80000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x27", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -497,7 +537,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x28", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -505,7 +546,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe000000000000000000000000000000000000000000000000000000000000003d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdfdfd0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x29", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -513,7 +555,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000342000000000000000000000000000000000000000000000000000000000000003d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x2a", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -521,7 +564,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe00000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x2b", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -529,7 +573,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034200000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcfcfc0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x2c", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -537,7 +582,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fe000000000000000000000000000000000000000000000000000000000000003e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdfdfd0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x2d", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -545,7 +591,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000342000000000000000000000000000000000000000000000000000000000000003e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x2e", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -553,7 +600,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fd00000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4d4e530000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x2f", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -561,7 +609,8 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x000000000000000000000000000000000000000000000000000000000000034300000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x30", + "position": "0x0" }, { "address": "0x350e0ffc780a6a75b44cc52e1ff9092870668945", @@ -569,10 +618,11 @@ "0xcacb62d8acea4678658eb5dc4aaa889b34d893b967c96a5f8c066e6549fa3f42" ], "data": "0x00000000000000000000000000000000000000000000000000000000000002fd00000000000000000000000000000000000000000000000000000000000000370000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003fcb0342353c541e210013aaddc2e740b9a33d08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4f494b0000000000000000000000000000000000000000000000000011c37937e08000", - "position": "0x0" + "index": "0x31", + "position": "0x0" } ], "value": "0x3782dace9d90000", "type": "CALL" } -} +} \ No newline at end of file diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/notopic.json b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/notopic.json index 814189dc6b35..13f286b7ca2a 100644 --- a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/notopic.json +++ b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/notopic.json @@ -265,6 +265,7 @@ "0xaf30e4d66b2f1f23e63ef4591058a897f67e6867233e33ca3508b982dcc4129b" ], "data": "0x00000000000000000000000050739060a2c32dc076e507ae1a893aab28ecfe68d1b13c1538a940417bf0e73b2498634436753c854c7fb971224d971bd2ae3e8800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000249f011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000355524c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000436a736f6e2868747470733a2f2f6170692e72616e646f6d2e6f72672f6a736f6e2d7270632f312f696e766f6b65292e726573756c742e72616e646f6d2e646174612e300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012c4244584a68725670424a35336f3243786c4a526c51745a4a4b5a714c5974354951652b37335944533448744e6a5335486f64624942337476666f773755717579416b303835566b4c6e4c3945704b67777157517a375a4c64477673516c526432734b78496f6c4e673944626e6650737047714c684c62625953566e4e38437776736a7041586353536f33632b34634e774339307946346f4e69626b764433797461706f5a37676f5453796f5559546677536a6e773374692b484a5648374e332b633069774f43715a6a4464734751556358336d33532f494857624f4f5151356f734f344c626a33476730783155644e7466557a5943465937396e7a596757495145464375524249306e364e42764251573732372b4f73445259304a2f392f676a74387563696248576963303d0000000000000000000000000000000000000000", + "index": "0x1", "position": "0x4" } ], @@ -277,10 +278,11 @@ "address": "0x50739060a2c32dc076e507ae1a893aab28ecfe68", "topics": [], "data": "0x62616e6b726f6c6c5f6d69736d61746368", + "index": "0x0", "position": "0x2" } ], "value": "0x429d069189e0000", "type": "CALL" } -} +} \ No newline at end of file diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/simple.json b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/simple.json index c00f0831599e..c9de111a2c15 100644 --- a/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/simple.json +++ b/eth/tracers/internal/tracetest/testdata/call_tracer_withLog/simple.json @@ -74,10 +74,11 @@ "0x000000000000000000000000dbf03b407c01e7cd3cbea99509d93f8dddc8c6fb" ], "data": "0x0000000000000000000000000000000000000000000000000000000000989680", + "index": "0x0", "position": "0x0" } ], "value": "0x0", "type": "CALL" } -} +} \ No newline at end of file diff --git a/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/eip7702_deauth.json b/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/eip7702_deauth.json new file mode 100644 index 000000000000..e376a98946de --- /dev/null +++ b/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/eip7702_deauth.json @@ -0,0 +1,98 @@ +{ + "genesis": { + "blobGasUsed": "0", + "difficulty": "0", + "excessBlobGas": "0", + "extraData": "0x", + "gasLimit": "11511229", + "hash": "0x455b93a512baa4ed5e117508b184a6bb03904b94d665ce38931728eca9cdd8fe", + "miner": "0x71562b71999873db5b286df957af199ec94617f7", + "mixHash": "0x042877c4fab9f022d29590ae83bad89d6181afb1d6e107619911ea52e5901364", + "nonce": "0x0000000000000000", + "number": "1", + "parentBeaconBlockRoot": "0x0000000000000000000000000000000000000000000000000000000000000000", + "stateRoot": "0xc8688ad6433e6b9f4edeb82360d2b99c8e919f493a01cacbe7c4a97184f5d043", + "timestamp": "1775654796", + "alloc": { + "0x71562b71999873db5b286df957af199ec94617f7": { + "balance": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffdb64910c3bf7", + "nonce": "1" + }, + "0xe85a1c0e9d5b1c9b417c6c1b34c22cd77f623f50": { + "balance": "0x0", + "code": "0xef0100d313d93607c016a85e63e557a11ca5ab0b53ad83", + "codeHash": "0x9eea9f41ed2b35e6234d1e1c14e88c1136f85d56ed1f32a7efc0096d998dad3d", + "nonce": "1" + } + }, + "config": { + "chainId": 1337, + "homesteadBlock": 0, + "eip150Block": 0, + "eip155Block": 0, + "eip158Block": 0, + "byzantiumBlock": 0, + "constantinopleBlock": 0, + "petersburgBlock": 0, + "istanbulBlock": 0, + "muirGlacierBlock": 0, + "berlinBlock": 0, + "londonBlock": 0, + "arrowGlacierBlock": 0, + "grayGlacierBlock": 0, + "shanghaiTime": 0, + "cancunTime": 0, + "pragueTime": 0, + "terminalTotalDifficulty": 0, + "blobSchedule": { + "cancun": { + "target": 3, + "max": 6, + "baseFeeUpdateFraction": 3338477 + }, + "prague": { + "target": 6, + "max": 9, + "baseFeeUpdateFraction": 5007716 + } + } + } + }, + "context": { + "number": "2", + "difficulty": "0", + "timestamp": "1775654797", + "gasLimit": "11522469", + "miner": "0x71562b71999873db5b286df957af199ec94617f7", + "baseFeePerGas": "766499147" + }, + "input": "0x04f8cd82053901843b9aca008477359400830186a09471562b71999873db5b286df957af199ec94617f78080c0f85ef85c8205399400000000000000000000000000000000000000000101a011fc0271f2566e7ebe5ddbff6d48ea97a19afa248452a392781096b7e3b89177a0020107ecefe99c90429b416fe4d1eead5a7fa253761e85cd7cdc7df6e5032d7f80a098495fb16c904f0b67b49afe868b28b0159c8df07522bed99ef6ff2cc2ac2935a048857a9c385d91735a9fdccabc66de7a5ea1897f523a5b9a352e281642a76e6b", + "tracerConfig": { + "diffMode": true + }, + "result": { + "post": { + "0x71562b71999873db5b286df957af199ec94617f7": { + "balance": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffc1bd12c85eb7", + "nonce": 2 + }, + "0xe85a1c0e9d5b1c9b417c6c1b34c22cd77f623f50": { + "code": "0x", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "nonce": 2 + } + }, + "pre": { + "0x71562b71999873db5b286df957af199ec94617f7": { + "balance": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffdb64910c3bf7", + "nonce": 1 + }, + "0xe85a1c0e9d5b1c9b417c6c1b34c22cd77f623f50": { + "balance": "0x0", + "code": "0xef0100d313d93607c016a85e63e557a11ca5ab0b53ad83", + "codeHash": "0x9eea9f41ed2b35e6234d1e1c14e88c1136f85d56ed1f32a7efc0096d998dad3d", + "nonce": 1 + } + } + } +} diff --git a/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go index 7f376a27fc29..6570d735755c 100644 --- a/eth/tracers/js/tracer_test.go +++ b/eth/tracers/js/tracer_test.go @@ -46,7 +46,7 @@ type vmContext struct { } func testCtx() *vmContext { - return &vmContext{blockCtx: vm.BlockContext{BlockNumber: big.NewInt(1), BaseFee: big.NewInt(0)}, txCtx: vm.TxContext{GasPrice: big.NewInt(100000)}} + return &vmContext{blockCtx: vm.BlockContext{BlockNumber: big.NewInt(1), BaseFee: big.NewInt(0)}, txCtx: vm.TxContext{GasPrice: uint256.NewInt(100000)}} } func runTrace(tracer *tracers.Tracer, vmctx *vmContext, chaincfg *params.ChainConfig, contractCode []byte) (json.RawMessage, error) { @@ -55,7 +55,7 @@ func runTrace(tracer *tracers.Tracer, vmctx *vmContext, chaincfg *params.ChainCo gasLimit uint64 = 31000 startGas uint64 = 10000 value = uint256.NewInt(0) - contract = vm.NewContract(common.Address{}, common.Address{}, value, startGas, nil) + contract = vm.NewContract(common.Address{}, common.Address{}, value, vm.NewGasBudget(startGas), nil) ) evm.SetTxContext(vmctx.txCtx) contract.Code = []byte{byte(vm.PUSH1), 0x1, byte(vm.PUSH1), 0x1, 0x0} @@ -63,12 +63,12 @@ func runTrace(tracer *tracers.Tracer, vmctx *vmContext, chaincfg *params.ChainCo contract.Code = contractCode } - tracer.OnTxStart(evm.GetVMContext(), types.NewTx(&types.LegacyTx{Gas: gasLimit, GasPrice: vmctx.txCtx.GasPrice}), contract.Caller()) + tracer.OnTxStart(evm.GetVMContext(), types.NewTx(&types.LegacyTx{Gas: gasLimit, GasPrice: vmctx.txCtx.GasPrice.ToBig()}), contract.Caller()) tracer.OnEnter(0, byte(vm.CALL), contract.Caller(), contract.Address(), []byte{}, startGas, value.ToBig()) ret, err := evm.Run(contract, []byte{}, false) - tracer.OnExit(0, ret, startGas-contract.Gas, err, true) + tracer.OnExit(0, ret, startGas-contract.Gas.RegularGas, err, true) // Rest gas assumes no refund - tracer.OnTxEnd(&types.Receipt{GasUsed: gasLimit - contract.Gas}, nil) + tracer.OnTxEnd(&types.Receipt{GasUsed: gasLimit - contract.Gas.RegularGas}, nil) if err != nil { return nil, err } @@ -183,10 +183,10 @@ func TestHaltBetweenSteps(t *testing.T) { t.Fatal(err) } scope := &vm.ScopeContext{ - Contract: vm.NewContract(common.Address{}, common.Address{}, uint256.NewInt(0), 0, nil), + Contract: vm.NewContract(common.Address{}, common.Address{}, uint256.NewInt(0), vm.GasBudget{}, nil), } evm := vm.NewEVM(vm.BlockContext{BlockNumber: big.NewInt(1)}, &dummyStatedb{}, chainConfig, vm.Config{Tracer: tracer.Hooks}) - evm.SetTxContext(vm.TxContext{GasPrice: big.NewInt(1)}) + evm.SetTxContext(vm.TxContext{GasPrice: uint256.NewInt(1)}) tracer.OnTxStart(evm.GetVMContext(), types.NewTx(&types.LegacyTx{}), common.Address{}) tracer.OnEnter(0, byte(vm.CALL), common.Address{}, common.Address{}, []byte{}, 0, big.NewInt(0)) tracer.OnOpcode(0, 0, 0, 0, scope, nil, 0, nil) @@ -210,7 +210,7 @@ func TestNoStepExec(t *testing.T) { t.Fatal(err) } evm := vm.NewEVM(vm.BlockContext{BlockNumber: big.NewInt(1)}, &dummyStatedb{}, chainConfig, vm.Config{Tracer: tracer.Hooks}) - evm.SetTxContext(vm.TxContext{GasPrice: big.NewInt(100)}) + evm.SetTxContext(vm.TxContext{GasPrice: uint256.NewInt(100)}) tracer.OnTxStart(evm.GetVMContext(), types.NewTx(&types.LegacyTx{}), common.Address{}) tracer.OnEnter(0, byte(vm.CALL), common.Address{}, common.Address{}, []byte{}, 1000, big.NewInt(0)) tracer.OnExit(0, nil, 0, nil, false) @@ -240,7 +240,7 @@ func TestIsPrecompile(t *testing.T) { chaincfg.ByzantiumBlock = big.NewInt(100) chaincfg.IstanbulBlock = big.NewInt(200) chaincfg.BerlinBlock = big.NewInt(300) - txCtx := vm.TxContext{GasPrice: big.NewInt(100000)} + txCtx := vm.TxContext{GasPrice: uint256.NewInt(100000)} tracer, err := newJsTracer("{addr: toAddress('0000000000000000000000000000000000000009'), res: null, step: function() { this.res = isPrecompiled(this.addr); }, fault: function() {}, result: function() { return this.res; }}", nil, nil, chaincfg) if err != nil { t.Fatal(err) @@ -281,7 +281,7 @@ func TestEnterExit(t *testing.T) { t.Fatal(err) } scope := &vm.ScopeContext{ - Contract: vm.NewContract(common.Address{}, common.Address{}, uint256.NewInt(0), 0, nil), + Contract: vm.NewContract(common.Address{}, common.Address{}, uint256.NewInt(0), vm.GasBudget{}, nil), } tracer.OnEnter(1, byte(vm.CALL), scope.Contract.Caller(), scope.Contract.Address(), []byte{}, 1000, new(big.Int)) tracer.OnExit(1, []byte{}, 400, nil, false) diff --git a/eth/tracers/live/noop.go b/eth/tracers/live/noop.go index f3def8560646..b1784dbd91ba 100644 --- a/eth/tracers/live/noop.go +++ b/eth/tracers/live/noop.go @@ -47,6 +47,7 @@ func newNoopTracer(_ json.RawMessage) (*tracing.Hooks, error) { OnOpcode: t.OnOpcode, OnFault: t.OnFault, OnGasChange: t.OnGasChange, + OnGasChangeV2: t.OnGasChangeV2, OnBlockchainInit: t.OnBlockchainInit, OnBlockStart: t.OnBlockStart, OnBlockEnd: t.OnBlockEnd, @@ -113,3 +114,6 @@ func (t *noop) OnBlockHashRead(number uint64, hash common.Hash) {} func (t *noop) OnGasChange(old, new uint64, reason tracing.GasChangeReason) { } + +func (t *noop) OnGasChangeV2(old, new tracing.Gas, reason tracing.GasChangeReason) { +} diff --git a/eth/tracers/live/statesize.go b/eth/tracers/live/statesize.go new file mode 100644 index 000000000000..0f057aa28748 --- /dev/null +++ b/eth/tracers/live/statesize.go @@ -0,0 +1,467 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package live + +import ( + "encoding/json" + "slices" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" +) + +func init() { + tracers.LiveDirectory.Register("statesize", newStateSizeTracer) +} + +// Database key size constants matching core/state/state_sizer.go +var ( + accountKeySize = int64(len(rawdb.SnapshotAccountPrefix) + common.HashLength) + storageKeySize = int64(len(rawdb.SnapshotStoragePrefix) + common.HashLength*2) + accountTrienodePrefixSize = int64(len(rawdb.TrieNodeAccountPrefix)) + storageTrienodePrefixSize = int64(len(rawdb.TrieNodeStoragePrefix) + common.HashLength) + codeKeySize = int64(len(rawdb.CodePrefix) + common.HashLength) +) + +// depthStats holds node count and byte size for a single depth level. +type depthStats struct { + Count int64 + Bytes int64 +} + +// stateSizeChanges represents the gross write/delete activity for a single block. +// Updates are accounted as BOTH a write (of the new value) AND a delete (of the +// previous value), so net delta = writes - deletes for all five categories. +// +// ContractCodeDeletes / ContractCodeDeleteBytes are present for schema parity +// but always 0 — see the comment on the contract-code loop in +// calculateStateSizeChanges. +type stateSizeChanges struct { + AccountWrites int64 + AccountWriteBytes int64 + AccountDeletes int64 + AccountDeleteBytes int64 + AccountTrienodeWrites int64 + AccountTrienodeWriteBytes int64 + AccountTrienodeDeletes int64 + AccountTrienodeDeleteBytes int64 + ContractCodeWrites int64 + ContractCodeWriteBytes int64 + ContractCodeDeletes int64 + ContractCodeDeleteBytes int64 + StorageWrites int64 + StorageWriteBytes int64 + StorageDeletes int64 + StorageDeleteBytes int64 + StorageTrienodeWrites int64 + StorageTrienodeWriteBytes int64 + StorageTrienodeDeletes int64 + StorageTrienodeDeleteBytes int64 +} + +// JSON log output types following the "Slow block" pattern in blockchain_stats.go. +// These structs control the exact JSON format captured by the sentry-logs Vector pipeline. + +type stateMetricsLog struct { + Level string `json:"level"` + Msg string `json:"msg"` + BlockNumber uint64 `json:"block_number"` + StateRoot string `json:"state_root"` + ParentStateRoot string `json:"parent_state_root"` + Writes stateMetricsSizes `json:"writes"` + Deletes stateMetricsSizes `json:"deletes"` + Depth stateMetricsDepth `json:"depth"` +} + +// stateMetricsSizes is the per-category count + bytes payload, used twice in +// stateMetricsLog: once for writes and once for deletes. +type stateMetricsSizes struct { + Account int64 `json:"account"` + AccountBytes int64 `json:"account_bytes"` + AccountTrienode int64 `json:"account_trienode"` + AccountTrienodeBytes int64 `json:"account_trienode_bytes"` + ContractCode int64 `json:"contract_code"` + ContractCodeBytes int64 `json:"contract_code_bytes"` + Storage int64 `json:"storage"` + StorageBytes int64 `json:"storage_bytes"` + StorageTrienode int64 `json:"storage_trienode"` + StorageTrienodeBytes int64 `json:"storage_trienode_bytes"` +} + +type stateMetricsDepth struct { + TotalAccountWrittenNodes uint64 `json:"total_account_written_nodes"` + TotalAccountWrittenBytes uint64 `json:"total_account_written_bytes"` + TotalAccountDeletedNodes uint64 `json:"total_account_deleted_nodes"` + TotalAccountDeletedBytes uint64 `json:"total_account_deleted_bytes"` + TotalStorageWrittenNodes uint64 `json:"total_storage_written_nodes"` + TotalStorageWrittenBytes uint64 `json:"total_storage_written_bytes"` + TotalStorageDeletedNodes uint64 `json:"total_storage_deleted_nodes"` + TotalStorageDeletedBytes uint64 `json:"total_storage_deleted_bytes"` + AccountWrittenNodes map[uint8]uint64 `json:"account_written_nodes"` + AccountWrittenBytes map[uint8]uint64 `json:"account_written_bytes"` + AccountDeletedNodes map[uint8]uint64 `json:"account_deleted_nodes"` + AccountDeletedBytes map[uint8]uint64 `json:"account_deleted_bytes"` + StorageWrittenNodes map[uint8]uint64 `json:"storage_written_nodes"` + StorageWrittenBytes map[uint8]uint64 `json:"storage_written_bytes"` + StorageDeletedNodes map[uint8]uint64 `json:"storage_deleted_nodes"` + StorageDeletedBytes map[uint8]uint64 `json:"storage_deleted_bytes"` +} + +type stateSizeTracer struct{} + +func newStateSizeTracer(cfg json.RawMessage) (*tracing.Hooks, error) { + t := &stateSizeTracer{} + + log.Info("State size tracer initialized (sentry-logs mode)") + + return &tracing.Hooks{ + OnStateUpdate: t.onStateUpdate, + }, nil +} + +func (s *stateSizeTracer) onStateUpdate(update *tracing.StateUpdate) { + if update == nil { + return + } + + changes, accountDepthCreated, storageDepthCreated, accountDepthDeleted, storageDepthDeleted := calculateStateSizeChanges(update) + + depth := buildDepthMetrics(accountDepthCreated, storageDepthCreated, accountDepthDeleted, storageDepthDeleted) + + entry := stateMetricsLog{ + Level: "info", + Msg: "State metrics", + BlockNumber: update.BlockNumber, + StateRoot: update.Root.Hex(), + ParentStateRoot: update.OriginRoot.Hex(), + Writes: stateMetricsSizes{ + Account: changes.AccountWrites, + AccountBytes: changes.AccountWriteBytes, + AccountTrienode: changes.AccountTrienodeWrites, + AccountTrienodeBytes: changes.AccountTrienodeWriteBytes, + ContractCode: changes.ContractCodeWrites, + ContractCodeBytes: changes.ContractCodeWriteBytes, + Storage: changes.StorageWrites, + StorageBytes: changes.StorageWriteBytes, + StorageTrienode: changes.StorageTrienodeWrites, + StorageTrienodeBytes: changes.StorageTrienodeWriteBytes, + }, + Deletes: stateMetricsSizes{ + Account: changes.AccountDeletes, + AccountBytes: changes.AccountDeleteBytes, + AccountTrienode: changes.AccountTrienodeDeletes, + AccountTrienodeBytes: changes.AccountTrienodeDeleteBytes, + ContractCode: changes.ContractCodeDeletes, + ContractCodeBytes: changes.ContractCodeDeleteBytes, + Storage: changes.StorageDeletes, + StorageBytes: changes.StorageDeleteBytes, + StorageTrienode: changes.StorageTrienodeDeletes, + StorageTrienodeBytes: changes.StorageTrienodeDeleteBytes, + }, + Depth: depth, + } + + jsonBytes, err := json.Marshal(entry) + if err != nil { + log.Error("Failed to marshal state metrics log", "error", err) + return + } + log.Info(string(jsonBytes)) +} + +// buildDepthMetrics converts [65]depthStats arrays into map-based metrics with totals. +func buildDepthMetrics( + accountCreated, storageCreated, accountDeleted, storageDeleted [65]depthStats, +) stateMetricsDepth { + d := stateMetricsDepth{ + AccountWrittenNodes: make(map[uint8]uint64, 10), + AccountWrittenBytes: make(map[uint8]uint64, 10), + AccountDeletedNodes: make(map[uint8]uint64, 10), + AccountDeletedBytes: make(map[uint8]uint64, 10), + StorageWrittenNodes: make(map[uint8]uint64, 10), + StorageWrittenBytes: make(map[uint8]uint64, 10), + StorageDeletedNodes: make(map[uint8]uint64, 10), + StorageDeletedBytes: make(map[uint8]uint64, 10), + } + + for i := range 65 { + depth := uint8(i) + + if accountCreated[i].Count > 0 { + d.AccountWrittenNodes[depth] = uint64(accountCreated[i].Count) + d.TotalAccountWrittenNodes += uint64(accountCreated[i].Count) + } + if accountCreated[i].Bytes > 0 { + d.AccountWrittenBytes[depth] = uint64(accountCreated[i].Bytes) + d.TotalAccountWrittenBytes += uint64(accountCreated[i].Bytes) + } + if accountDeleted[i].Count > 0 { + d.AccountDeletedNodes[depth] = uint64(accountDeleted[i].Count) + d.TotalAccountDeletedNodes += uint64(accountDeleted[i].Count) + } + if accountDeleted[i].Bytes > 0 { + d.AccountDeletedBytes[depth] = uint64(accountDeleted[i].Bytes) + d.TotalAccountDeletedBytes += uint64(accountDeleted[i].Bytes) + } + if storageCreated[i].Count > 0 { + d.StorageWrittenNodes[depth] = uint64(storageCreated[i].Count) + d.TotalStorageWrittenNodes += uint64(storageCreated[i].Count) + } + if storageCreated[i].Bytes > 0 { + d.StorageWrittenBytes[depth] = uint64(storageCreated[i].Bytes) + d.TotalStorageWrittenBytes += uint64(storageCreated[i].Bytes) + } + if storageDeleted[i].Count > 0 { + d.StorageDeletedNodes[depth] = uint64(storageDeleted[i].Count) + d.TotalStorageDeletedNodes += uint64(storageDeleted[i].Count) + } + if storageDeleted[i].Bytes > 0 { + d.StorageDeletedBytes[depth] = uint64(storageDeleted[i].Bytes) + d.TotalStorageDeletedBytes += uint64(storageDeleted[i].Bytes) + } + } + return d +} + +// calculateStateSizeChanges computes write/delete counts and bytes per category +// from a state update. An "update" (both prev and new present) is accounted as +// BOTH a write of the new value and a delete of the previous one — so a query +// of `writes - deletes` recovers the net delta exactly. +// +// Returns the changes plus per-depth stats for account/storage trie nodes. +func calculateStateSizeChanges(update *tracing.StateUpdate) ( + changes stateSizeChanges, + accountDepthCreated, storageDepthCreated, accountDepthDeleted, storageDepthDeleted [65]depthStats, +) { + // Account size changes. + for _, change := range update.AccountChanges { + prevLen := slimAccountSize(change.Prev) + newLen := slimAccountSize(change.New) + + switch { + case prevLen > 0 && newLen == 0: + changes.AccountDeletes++ + changes.AccountDeleteBytes += accountKeySize + int64(prevLen) + case prevLen == 0 && newLen > 0: + changes.AccountWrites++ + changes.AccountWriteBytes += accountKeySize + int64(newLen) + default: + // Update: overwrite semantics — count as both a write and a delete. + changes.AccountWrites++ + changes.AccountWriteBytes += accountKeySize + int64(newLen) + changes.AccountDeletes++ + changes.AccountDeleteBytes += accountKeySize + int64(prevLen) + } + } + + // Storage slot changes. + for _, slots := range update.StorageChanges { + for _, change := range slots { + prevLen := len(encodeStorageValue(change.Prev)) + newLen := len(encodeStorageValue(change.New)) + + switch { + case prevLen > 0 && newLen == 0: + changes.StorageDeletes++ + changes.StorageDeleteBytes += storageKeySize + int64(prevLen) + case prevLen == 0 && newLen > 0: + changes.StorageWrites++ + changes.StorageWriteBytes += storageKeySize + int64(newLen) + default: + changes.StorageWrites++ + changes.StorageWriteBytes += storageKeySize + int64(newLen) + changes.StorageDeletes++ + changes.StorageDeleteBytes += storageKeySize + int64(prevLen) + } + } + } + + // Trie node changes (both account and storage tries) — and depth stats. + for owner, nodes := range update.TrieChanges { + var ( + keyPrefix int64 + isAccount = owner == (common.Hash{}) + ) + if isAccount { + keyPrefix = accountTrienodePrefixSize + } else { + keyPrefix = storageTrienodePrefixSize + } + + createdStats, deletedStats := calculateDepthStatsByType(nodes) + + for path, change := range nodes { + var prevLen, newLen int + if change.Prev != nil { + prevLen = len(change.Prev.Blob) + } + if change.New != nil { + newLen = len(change.New.Blob) + } + keySize := keyPrefix + int64(len(path)) + + switch { + case prevLen > 0 && newLen == 0: + if isAccount { + changes.AccountTrienodeDeletes++ + changes.AccountTrienodeDeleteBytes += keySize + int64(prevLen) + } else { + changes.StorageTrienodeDeletes++ + changes.StorageTrienodeDeleteBytes += keySize + int64(prevLen) + } + case prevLen == 0 && newLen > 0: + if isAccount { + changes.AccountTrienodeWrites++ + changes.AccountTrienodeWriteBytes += keySize + int64(newLen) + } else { + changes.StorageTrienodeWrites++ + changes.StorageTrienodeWriteBytes += keySize + int64(newLen) + } + default: + if isAccount { + changes.AccountTrienodeWrites++ + changes.AccountTrienodeWriteBytes += keySize + int64(newLen) + changes.AccountTrienodeDeletes++ + changes.AccountTrienodeDeleteBytes += keySize + int64(prevLen) + } else { + changes.StorageTrienodeWrites++ + changes.StorageTrienodeWriteBytes += keySize + int64(newLen) + changes.StorageTrienodeDeletes++ + changes.StorageTrienodeDeleteBytes += keySize + int64(prevLen) + } + } + } + + if isAccount { + for i := range 65 { + accountDepthCreated[i].Count += createdStats[i].Count + accountDepthCreated[i].Bytes += createdStats[i].Bytes + accountDepthDeleted[i].Count += deletedStats[i].Count + accountDepthDeleted[i].Bytes += deletedStats[i].Bytes + } + } else { + for i := range 65 { + storageDepthCreated[i].Count += createdStats[i].Count + storageDepthCreated[i].Bytes += createdStats[i].Bytes + storageDepthDeleted[i].Count += deletedStats[i].Count + storageDepthDeleted[i].Bytes += deletedStats[i].Bytes + } + } + } + + // Contract code: write-only by design. Counts unique new code blobs by hash + // (deduped — adding the same bytecode to two accounts only adds it to the DB + // once). Deletes are not tracked here because reliably attributing a "last + // reference gone" event would require ref-counting that state_sizer.go + // deliberately omits. ContractCodeDeletes / ContractCodeDeleteBytes stay 0. + codeExists := make(map[common.Hash]struct{}) + for _, change := range update.CodeChanges { + if change.New == nil { + continue + } + if _, ok := codeExists[change.New.Hash]; ok || change.New.Exists { + continue + } + changes.ContractCodeWrites++ + changes.ContractCodeWriteBytes += codeKeySize + int64(len(change.New.Code)) + codeExists[change.New.Hash] = struct{}{} + } + + return +} + +// encodeStorageValue RLP-encodes a storage value for size calculation. +func encodeStorageValue(val common.Hash) []byte { + if val == (common.Hash{}) { + return nil + } + blob, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(val[:])) + return blob +} + +// slimAccountSize calculates the RLP-encoded size of an account in slim format. +func slimAccountSize(acct *types.StateAccount) int { + if acct == nil { + return 0 + } + data := types.SlimAccountRLP(*acct) + return len(data) +} + +// calculateDepthStatsByType calculates the depth of each node and separates stats +// (count and bytes) into created/modified nodes and deleted nodes. +// - Created/Modified: nodes that exist after the update (New has data) +// - Deleted: nodes that existed before but don't exist after (Prev has data, New is empty) +func calculateDepthStatsByType(pathMap map[string]*tracing.TrieNodeChange) (created, deleted [65]depthStats) { + n := len(pathMap) + if n == 0 { + return + } + + paths := make([]string, 0, n) + for path := range pathMap { + paths = append(paths, path) + } + slices.Sort(paths) + + depthMap := make(map[string]int, n) + + stack := make([]string, 0, 65) + + for _, path := range paths { + for len(stack) > 0 { + top := stack[len(stack)-1] + if len(top) < len(path) && path[:len(top)] == top { + break + } + stack = stack[:len(stack)-1] + } + + depth := len(stack) + depthMap[path] = depth + + stack = append(stack, path) + } + + for path, change := range pathMap { + depth := depthMap[path] + + var prevLen, newLen int + if change.Prev != nil { + prevLen = len(change.Prev.Blob) + } + if change.New != nil { + newLen = len(change.New.Blob) + } + + if newLen > 0 { + created[depth].Count++ + created[depth].Bytes += int64(newLen) + } + if prevLen > 0 && newLen == 0 { + deleted[depth].Count++ + deleted[depth].Bytes += int64(prevLen) + } + } + + return +} diff --git a/eth/tracers/logger/access_list_tracer.go b/eth/tracers/logger/access_list_tracer.go index 0d51f405225a..31c3ebde937e 100644 --- a/eth/tracers/logger/access_list_tracer.go +++ b/eth/tracers/logger/access_list_tracer.go @@ -18,6 +18,7 @@ package logger import ( "maps" + "slices" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/tracing" @@ -84,12 +85,17 @@ func (al accessList) equal(other accessList) bool { func (al accessList) accessList() types.AccessList { acl := make(types.AccessList, 0, len(al)) for addr, slots := range al { - tuple := types.AccessTuple{Address: addr, StorageKeys: []common.Hash{}} - for slot := range slots { - tuple.StorageKeys = append(tuple.StorageKeys, slot) + keys := slices.SortedFunc(maps.Keys(slots), common.Hash.Cmp) + // Ensure keys is never nil to avoid JSON serialization issues. + // When slots is empty, slices.SortedFunc returns nil, but JSON marshaling + // will serialize nil slice as null instead of [], which breaks clients + // that expect storageKeys to always be an array. + if keys == nil { + keys = []common.Hash{} } - acl = append(acl, tuple) + acl = append(acl, types.AccessTuple{Address: addr, StorageKeys: keys}) } + slices.SortFunc(acl, func(a, b types.AccessTuple) int { return a.Address.Cmp(b.Address) }) return acl } @@ -106,9 +112,10 @@ type AccessListTracer struct { func NewAccessListTracer(acl types.AccessList, addressesToExclude map[common.Address]struct{}) *AccessListTracer { list := newAccessList() for _, al := range acl { - if _, ok := addressesToExclude[al.Address]; !ok { - list.addAddress(al.Address) + if _, ok := addressesToExclude[al.Address]; ok { + continue } + list.addAddress(al.Address) for _, slot := range al.StorageKeys { list.addSlot(al.Address, slot) } diff --git a/eth/tracers/logger/access_list_tracer_test.go b/eth/tracers/logger/access_list_tracer_test.go new file mode 100644 index 000000000000..04b2b4b31b32 --- /dev/null +++ b/eth/tracers/logger/access_list_tracer_test.go @@ -0,0 +1,39 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package logger + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +func TestNewAccessListTracerExcludedAddress(t *testing.T) { + excluded := common.HexToAddress("0x2222222222222222222222222222222222222222") + slot := common.HexToHash("0x01") + prelude := types.AccessList{{ + Address: excluded, + StorageKeys: []common.Hash{slot}, + }} + excl := map[common.Address]struct{}{excluded: {}} + tracer := NewAccessListTracer(prelude, excl) + got := tracer.AccessList() + if len(got) != 0 { + t.Fatalf("excluded prelude address must not contribute tuples, got %+v", got) + } +} diff --git a/eth/tracers/logger/logger.go b/eth/tracers/logger/logger.go index 67e07f78d0a2..8e445818ef48 100644 --- a/eth/tracers/logger/logger.go +++ b/eth/tracers/logger/logger.go @@ -148,7 +148,7 @@ type structLogLegacy struct { Gas uint64 `json:"gas"` GasCost uint64 `json:"gasCost"` Depth int `json:"depth"` - Error string `json:"error,omitempty"` + Error string `json:"error,omitempty,omitzero"` Stack *[]string `json:"stack,omitempty"` ReturnData string `json:"returnData,omitempty"` Memory *[]string `json:"memory,omitempty"` @@ -156,6 +156,15 @@ type structLogLegacy struct { RefundCounter uint64 `json:"refund,omitempty"` } +func formatMemoryWord(chunk []byte) string { + if len(chunk) == 32 { + return hexutil.Encode(chunk) + } + var word [32]byte + copy(word[:], chunk) + return hexutil.Encode(word[:]) +} + // toLegacyJSON converts the structLog to legacy json-encoded legacy form. func (s *StructLog) toLegacyJSON() json.RawMessage { msg := structLogLegacy{ @@ -175,7 +184,7 @@ func (s *StructLog) toLegacyJSON() json.RawMessage { msg.Stack = &stack } if len(s.ReturnData) > 0 { - msg.ReturnData = hexutil.Bytes(s.ReturnData).String() + msg.ReturnData = hexutil.Encode(s.ReturnData) } if len(s.Memory) > 0 { memory := make([]string, 0, (len(s.Memory)+31)/32) @@ -184,14 +193,14 @@ func (s *StructLog) toLegacyJSON() json.RawMessage { if end > len(s.Memory) { end = len(s.Memory) } - memory = append(memory, fmt.Sprintf("%x", s.Memory[i:end])) + memory = append(memory, formatMemoryWord(s.Memory[i:end])) } msg.Memory = &memory } if len(s.Storage) > 0 { storage := make(map[string]string) for i, storageValue := range s.Storage { - storage[fmt.Sprintf("%x", i)] = fmt.Sprintf("%x", storageValue) + storage[i.Hex()] = storageValue.Hex() } msg.Storage = &storage } @@ -220,9 +229,9 @@ type StructLogger struct { logs []json.RawMessage // buffer of json-encoded logs resultSize int - interrupt atomic.Bool // Atomic flag to signal execution interruption - reason error // Textual reason for the interruption - skip bool // skip processing hooks. + interrupt atomic.Bool // Atomic flag to signal execution interruption + reason atomic.Pointer[error] // Reason for the interruption, populated by Stop + skip bool // skip processing hooks. } // NewStreamingStructLogger returns a new streaming logger. @@ -348,8 +357,8 @@ func (l *StructLogger) OnExit(depth int, output []byte, gasUsed uint64, err erro func (l *StructLogger) GetResult() (json.RawMessage, error) { // Tracing aborted - if l.reason != nil { - return nil, l.reason + if p := l.reason.Load(); p != nil { + return nil, *p } failed := l.err != nil returnData := common.CopyBytes(l.output) @@ -367,7 +376,7 @@ func (l *StructLogger) GetResult() (json.RawMessage, error) { // Stop terminates execution of the tracer at the first opportune moment. func (l *StructLogger) Stop(err error) { - l.reason = err + l.reason.Store(&err) l.interrupt.Store(true) } diff --git a/eth/tracers/logger/logger_test.go b/eth/tracers/logger/logger_test.go index acc3069e70a9..decdf588e133 100644 --- a/eth/tracers/logger/logger_test.go +++ b/eth/tracers/logger/logger_test.go @@ -47,7 +47,7 @@ func TestStoreCapture(t *testing.T) { var ( logger = NewStructLogger(nil) evm = vm.NewEVM(vm.BlockContext{}, &dummyStatedb{}, params.TestChainConfig, vm.Config{Tracer: logger.Hooks()}) - contract = vm.NewContract(common.Address{}, common.Address{}, new(uint256.Int), 100000, nil) + contract = vm.NewContract(common.Address{}, common.Address{}, new(uint256.Int), vm.NewGasBudget(100000), nil) ) contract.Code = []byte{byte(vm.PUSH1), 0x1, byte(vm.PUSH1), 0x0, byte(vm.SSTORE)} var index common.Hash @@ -96,3 +96,46 @@ func TestStructLogMarshalingOmitEmpty(t *testing.T) { }) } } + +func TestStructLogLegacyJSONSpecFormatting(t *testing.T) { + tests := []struct { + name string + log *StructLog + want string + }{ + { + name: "omits empty error and pads memory/storage", + log: &StructLog{ + Pc: 7, + Op: vm.SSTORE, + Gas: 100, + GasCost: 20, + Memory: []byte{0xaa, 0xbb}, + Storage: map[common.Hash]common.Hash{common.BigToHash(big.NewInt(1)): common.BigToHash(big.NewInt(2))}, + Depth: 1, + ReturnData: []byte{0x12, 0x34}, + }, + want: `{"pc":7,"op":"SSTORE","gas":100,"gasCost":20,"depth":1,"returnData":"0x1234","memory":["0xaabb000000000000000000000000000000000000000000000000000000000000"],"storage":{"0x0000000000000000000000000000000000000000000000000000000000000001":"0x0000000000000000000000000000000000000000000000000000000000000002"}}`, + }, + { + name: "includes error only when present", + log: &StructLog{ + Pc: 1, + Op: vm.STOP, + Gas: 2, + GasCost: 3, + Depth: 1, + Err: errors.New("boom"), + }, + want: `{"pc":1,"op":"STOP","gas":2,"gasCost":3,"depth":1,"error":"boom"}`, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + have := string(tt.log.toLegacyJSON()) + if have != tt.want { + t.Fatalf("mismatched results\n\thave: %v\n\twant: %v", have, tt.want) + } + }) + } +} diff --git a/eth/tracers/native/4byte.go b/eth/tracers/native/4byte.go index cec45a1e7a58..a542eeffa2e7 100644 --- a/eth/tracers/native/4byte.go +++ b/eth/tracers/native/4byte.go @@ -49,9 +49,9 @@ func init() { // 0xc281d19e-0: 1 // } type fourByteTracer struct { - ids map[string]int // ids aggregates the 4byte ids found - interrupt atomic.Bool // Atomic flag to signal execution interruption - reason error // Textual reason for the interruption + ids map[string]int // ids aggregates the 4byte ids found + interrupt atomic.Bool // Atomic flag to signal execution interruption + reason atomic.Pointer[error] // Reason for the interruption, populated by Stop chainConfig *params.ChainConfig activePrecompiles []common.Address // Updated on tx start based on given rules } @@ -124,12 +124,15 @@ func (t *fourByteTracer) GetResult() (json.RawMessage, error) { if err != nil { return nil, err } - return res, t.reason + if p := t.reason.Load(); p != nil { + return res, *p + } + return res, nil } // Stop terminates execution of the tracer at the first opportune moment. func (t *fourByteTracer) Stop(err error) { - t.reason = err + t.reason.Store(&err) t.interrupt.Store(true) } diff --git a/eth/tracers/native/call.go b/eth/tracers/native/call.go index c2247d1ce491..dfa804827bf5 100644 --- a/eth/tracers/native/call.go +++ b/eth/tracers/native/call.go @@ -42,6 +42,7 @@ type callLog struct { Address common.Address `json:"address"` Topics []common.Hash `json:"topics"` Data hexutil.Bytes `json:"data"` + Index hexutil.Uint `json:"index"` // Position of the log relative to subcalls within the same trace // See https://github.com/ethereum/go-ethereum/pull/28389 for details Position hexutil.Uint `json:"position"` @@ -115,8 +116,8 @@ type callTracer struct { config callTracerConfig gasLimit uint64 depth int - interrupt atomic.Bool // Atomic flag to signal execution interruption - reason error // Textual reason for the interruption + interrupt atomic.Bool // Atomic flag to signal execution interruption + reason atomic.Pointer[error] // Reason for the interruption, populated by Stop } type callTracerConfig struct { @@ -250,6 +251,7 @@ func (t *callTracer) OnLog(log *types.Log) { Address: log.Address, Topics: log.Topics, Data: log.Data, + Index: hexutil.Uint(log.Index), Position: hexutil.Uint(len(t.callstack[len(t.callstack)-1].Calls)), } t.callstack[len(t.callstack)-1].Logs = append(t.callstack[len(t.callstack)-1].Logs, l) @@ -266,12 +268,15 @@ func (t *callTracer) GetResult() (json.RawMessage, error) { if err != nil { return nil, err } - return res, t.reason + if p := t.reason.Load(); p != nil { + return res, *p + } + return res, nil } // Stop terminates execution of the tracer at the first opportune moment. func (t *callTracer) Stop(err error) { - t.reason = err + t.reason.Store(&err) t.interrupt.Store(true) } diff --git a/eth/tracers/native/call_flat.go b/eth/tracers/native/call_flat.go index 4e7fc31a9c6e..484f2d4e3b1e 100644 --- a/eth/tracers/native/call_flat.go +++ b/eth/tracers/native/call_flat.go @@ -233,7 +233,10 @@ func (t *flatCallTracer) GetResult() (json.RawMessage, error) { if err != nil { return nil, err } - return res, t.tracer.reason + if p := t.tracer.reason.Load(); p != nil { + return res, *p + } + return res, nil } // Stop terminates execution of the tracer at the first opportune moment. diff --git a/eth/tracers/native/erc7562.go b/eth/tracers/native/erc7562.go index 3ab98c7132ae..0bf80d77b53c 100644 --- a/eth/tracers/native/erc7562.go +++ b/eth/tracers/native/erc7562.go @@ -135,8 +135,8 @@ type opcodeWithPartialStack struct { type erc7562Tracer struct { config erc7562TracerConfig gasLimit uint64 - interrupt atomic.Bool // Atomic flag to signal execution interruption - reason error // Textual reason for the interruption + interrupt atomic.Bool // Atomic flag to signal execution interruption + reason atomic.Pointer[error] // Reason for the interruption, populated by Stop env *tracing.VMContext ignoredOpcodes map[vm.OpCode]struct{} @@ -317,7 +317,10 @@ func (t *erc7562Tracer) OnLog(log1 *types.Log) { // error arising from the encoding or forceful termination (via `Stop`). func (t *erc7562Tracer) GetResult() (json.RawMessage, error) { if t.interrupt.Load() { - return nil, t.reason + if p := t.reason.Load(); p != nil { + return nil, *p + } + return nil, nil } if len(t.callstackWithOpcodes) != 1 { return nil, errors.New("incorrect number of top-level calls") @@ -337,12 +340,15 @@ func (t *erc7562Tracer) GetResult() (json.RawMessage, error) { return nil, err } - return enc, t.reason + if p := t.reason.Load(); p != nil { + return enc, *p + } + return enc, nil } // Stop terminates execution of the tracer at the first opportune moment. func (t *erc7562Tracer) Stop(err error) { - t.reason = err + t.reason.Store(&err) t.interrupt.Store(true) } @@ -513,7 +519,7 @@ func defaultIgnoredOpcodes() []hexutil.Uint64 { ignored := make([]hexutil.Uint64, 0, 64) // Allow all PUSHx, DUPx and SWAPx opcodes as they have sequential codes - for op := vm.PUSH0; op < vm.SWAP16; op++ { + for op := vm.PUSH0; op <= vm.SWAP16; op++ { ignored = append(ignored, hexutil.Uint64(op)) } diff --git a/eth/tracers/native/gen_account_json.go b/eth/tracers/native/gen_account_json.go index 5fec2648b7fc..9417536a235a 100644 --- a/eth/tracers/native/gen_account_json.go +++ b/eth/tracers/native/gen_account_json.go @@ -16,14 +16,14 @@ var _ = (*accountMarshaling)(nil) func (a account) MarshalJSON() ([]byte, error) { type account struct { Balance *hexutil.Big `json:"balance,omitempty"` - Code hexutil.Bytes `json:"code,omitempty"` + Code *hexutil.Bytes `json:"code,omitempty"` CodeHash *common.Hash `json:"codeHash,omitempty"` Nonce uint64 `json:"nonce,omitempty"` Storage map[common.Hash]common.Hash `json:"storage,omitempty"` } var enc account enc.Balance = (*hexutil.Big)(a.Balance) - enc.Code = a.Code + enc.Code = (*hexutil.Bytes)(a.Code) enc.CodeHash = a.CodeHash enc.Nonce = a.Nonce enc.Storage = a.Storage @@ -47,7 +47,7 @@ func (a *account) UnmarshalJSON(input []byte) error { a.Balance = (*big.Int)(dec.Balance) } if dec.Code != nil { - a.Code = *dec.Code + a.Code = (*[]byte)(dec.Code) } if dec.CodeHash != nil { a.CodeHash = dec.CodeHash diff --git a/eth/tracers/native/mux.go b/eth/tracers/native/mux.go index 37fc64f3f5e2..73f8585a6b57 100644 --- a/eth/tracers/native/mux.go +++ b/eth/tracers/native/mux.go @@ -28,7 +28,7 @@ import ( ) func init() { - tracers.DefaultDirectory.Register("muxTracer", newMuxTracer, false) + tracers.DefaultDirectory.Register("muxTracer", newMuxTracerFromConfig, false) } // muxTracer is a go implementation of the Tracer interface which @@ -38,8 +38,8 @@ type muxTracer struct { tracers []*tracers.Tracer } -// newMuxTracer returns a new mux tracer. -func newMuxTracer(ctx *tracers.Context, cfg json.RawMessage, chainConfig *params.ChainConfig) (*tracers.Tracer, error) { +// newMuxTracerFromConfig returns a new mux tracer. +func newMuxTracerFromConfig(ctx *tracers.Context, cfg json.RawMessage, chainConfig *params.ChainConfig) (*tracers.Tracer, error) { var config map[string]json.RawMessage if err := json.Unmarshal(cfg, &config); err != nil { return nil, err @@ -54,22 +54,40 @@ func newMuxTracer(ctx *tracers.Context, cfg json.RawMessage, chainConfig *params objects = append(objects, t) names = append(names, k) } + return NewMuxTracer(names, objects) +} +// NewMuxTracer creates a multiplexing tracer that fans out tracing hooks to +// multiple child tracers. Each hook invocation is forwarded to all children, +// in the order they are provided. +// +// The names parameter associates a label with each tracer, used as keys in +// the aggregated JSON result returned by GetResult. +// +// For hooks that have both a V1 and V2 form (OnCodeChange / OnCodeChangeV2, +// OnNonceChange / OnNonceChangeV2, OnGasChange / OnGasChangeV2, +// OnSystemCallStart / OnSystemCallStartV2), the mux exposes only the V2 +// variant upward. The fanout then prefers each child's V2 hook and falls +// back to V1 if only V1 is set, mirroring the precedence already used in +// core/state_processor.go. +func NewMuxTracer(names []string, objects []*tracers.Tracer) (*tracers.Tracer, error) { t := &muxTracer{names: names, tracers: objects} return &tracers.Tracer{ Hooks: &tracing.Hooks{ - OnTxStart: t.OnTxStart, - OnTxEnd: t.OnTxEnd, - OnEnter: t.OnEnter, - OnExit: t.OnExit, - OnOpcode: t.OnOpcode, - OnFault: t.OnFault, - OnGasChange: t.OnGasChange, - OnBalanceChange: t.OnBalanceChange, - OnNonceChange: t.OnNonceChange, - OnCodeChange: t.OnCodeChange, - OnStorageChange: t.OnStorageChange, - OnLog: t.OnLog, + OnTxStart: t.OnTxStart, + OnTxEnd: t.OnTxEnd, + OnEnter: t.OnEnter, + OnExit: t.OnExit, + OnOpcode: t.OnOpcode, + OnFault: t.OnFault, + OnGasChangeV2: t.OnGasChangeV2, + OnBalanceChange: t.OnBalanceChange, + OnNonceChangeV2: t.OnNonceChangeV2, + OnCodeChangeV2: t.OnCodeChangeV2, + OnStorageChange: t.OnStorageChange, + OnLog: t.OnLog, + OnSystemCallStartV2: t.OnSystemCallStart, + OnSystemCallEnd: t.OnSystemCallEnd, }, GetResult: t.GetResult, Stop: t.Stop, @@ -92,10 +110,12 @@ func (t *muxTracer) OnFault(pc uint64, op byte, gas, cost uint64, scope tracing. } } -func (t *muxTracer) OnGasChange(old, new uint64, reason tracing.GasChangeReason) { +func (t *muxTracer) OnGasChangeV2(old, new tracing.Gas, reason tracing.GasChangeReason) { for _, t := range t.tracers { - if t.OnGasChange != nil { - t.OnGasChange(old, new, reason) + if t.OnGasChangeV2 != nil { + t.OnGasChangeV2(old, new, reason) + } else if t.OnGasChange != nil { + t.OnGasChange(old.Regular, new.Regular, reason) } } } @@ -140,26 +160,22 @@ func (t *muxTracer) OnBalanceChange(a common.Address, prev, new *big.Int, reason } } -func (t *muxTracer) OnNonceChange(a common.Address, prev, new uint64) { +func (t *muxTracer) OnNonceChangeV2(a common.Address, prev, new uint64, reason tracing.NonceChangeReason) { for _, t := range t.tracers { - if t.OnNonceChange != nil { + if t.OnNonceChangeV2 != nil { + t.OnNonceChangeV2(a, prev, new, reason) + } else if t.OnNonceChange != nil { t.OnNonceChange(a, prev, new) } } } -func (t *muxTracer) OnCodeChange(a common.Address, prevCodeHash common.Hash, prev []byte, codeHash common.Hash, code []byte) { - for _, t := range t.tracers { - if t.OnCodeChange != nil { - t.OnCodeChange(a, prevCodeHash, prev, codeHash, code) - } - } -} - func (t *muxTracer) OnCodeChangeV2(a common.Address, prevCodeHash common.Hash, prev []byte, codeHash common.Hash, code []byte, reason tracing.CodeChangeReason) { for _, t := range t.tracers { if t.OnCodeChangeV2 != nil { t.OnCodeChangeV2(a, prevCodeHash, prev, codeHash, code, reason) + } else if t.OnCodeChange != nil { + t.OnCodeChange(a, prevCodeHash, prev, codeHash, code) } } } @@ -180,6 +196,24 @@ func (t *muxTracer) OnLog(log *types.Log) { } } +func (t *muxTracer) OnSystemCallStart(vm *tracing.VMContext) { + for _, t := range t.tracers { + if t.OnSystemCallStartV2 != nil { + t.OnSystemCallStartV2(vm) + } else if t.OnSystemCallStart != nil { + t.OnSystemCallStart() + } + } +} + +func (t *muxTracer) OnSystemCallEnd() { + for _, t := range t.tracers { + if t.OnSystemCallEnd != nil { + t.OnSystemCallEnd() + } + } +} + // GetResult returns an empty json object. func (t *muxTracer) GetResult() (json.RawMessage, error) { resObject := make(map[string]json.RawMessage) diff --git a/eth/tracers/native/mux_test.go b/eth/tracers/native/mux_test.go new file mode 100644 index 000000000000..902b7a026a7c --- /dev/null +++ b/eth/tracers/native/mux_test.go @@ -0,0 +1,87 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package native + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/eth/tracers" +) + +// TestMuxForwardsV2StateHooks verifies that the mux tracer fans out the V2 +// variants of state-change hooks to child tracers. A child tracer that only +// implements OnCodeChangeV2 / OnNonceChangeV2 must still receive events when +// wrapped behind the mux. The mux must also fall back to the V1 hook when a +// child only implements V1, mirroring the precedence used in +// core/state_processor.go. +func TestMuxForwardsV2StateHooks(t *testing.T) { + var ( + codeV2Calls int + nonceV2Calls int + codeV1Calls int + nonceV1Calls int + ) + v2Child := &tracers.Tracer{ + Hooks: &tracing.Hooks{ + OnCodeChangeV2: func(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte, reason tracing.CodeChangeReason) { + codeV2Calls++ + }, + OnNonceChangeV2: func(addr common.Address, prev, new uint64, reason tracing.NonceChangeReason) { + nonceV2Calls++ + }, + }, + } + v1Child := &tracers.Tracer{ + Hooks: &tracing.Hooks{ + OnCodeChange: func(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte) { + codeV1Calls++ + }, + OnNonceChange: func(addr common.Address, prev, new uint64) { + nonceV1Calls++ + }, + }, + } + mux, err := NewMuxTracer([]string{"v2", "v1"}, []*tracers.Tracer{v2Child, v1Child}) + if err != nil { + t.Fatalf("NewMuxTracer: %v", err) + } + + if mux.Hooks.OnCodeChangeV2 == nil { + t.Fatal("mux does not expose OnCodeChangeV2; V2-only child tracers will miss code changes") + } + if mux.Hooks.OnNonceChangeV2 == nil { + t.Fatal("mux does not expose OnNonceChangeV2; V2-only child tracers will miss nonce changes") + } + + mux.Hooks.OnCodeChangeV2(common.Address{}, common.Hash{}, nil, common.Hash{}, nil, tracing.CodeChangeContractCreation) + mux.Hooks.OnNonceChangeV2(common.Address{}, 0, 1, tracing.NonceChangeEoACall) + + if codeV2Calls != 1 { + t.Fatalf("V2 child OnCodeChangeV2 got %d calls, want 1", codeV2Calls) + } + if nonceV2Calls != 1 { + t.Fatalf("V2 child OnNonceChangeV2 got %d calls, want 1", nonceV2Calls) + } + if codeV1Calls != 1 { + t.Fatalf("V1 child OnCodeChange got %d calls, want 1 (mux should fall back from V2 to V1)", codeV1Calls) + } + if nonceV1Calls != 1 { + t.Fatalf("V1 child OnNonceChange got %d calls, want 1 (mux should fall back from V2 to V1)", nonceV1Calls) + } +} diff --git a/eth/tracers/native/noop.go b/eth/tracers/native/noop.go index ac174cc25e7f..323bf4338f84 100644 --- a/eth/tracers/native/noop.go +++ b/eth/tracers/native/noop.go @@ -47,6 +47,7 @@ func newNoopTracer(ctx *tracers.Context, cfg json.RawMessage, chainConfig *param OnOpcode: t.OnOpcode, OnFault: t.OnFault, OnGasChange: t.OnGasChange, + OnGasChangeV2: t.OnGasChangeV2, OnBalanceChange: t.OnBalanceChange, OnNonceChange: t.OnNonceChange, OnCodeChange: t.OnCodeChange, @@ -66,6 +67,8 @@ func (t *noopTracer) OnFault(pc uint64, op byte, gas, cost uint64, _ tracing.OpC func (t *noopTracer) OnGasChange(old, new uint64, reason tracing.GasChangeReason) {} +func (t *noopTracer) OnGasChangeV2(old, new tracing.Gas, reason tracing.GasChangeReason) {} + func (t *noopTracer) OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) { } diff --git a/eth/tracers/native/opcode_counter.go b/eth/tracers/native/opcode_counter.go new file mode 100644 index 000000000000..d859b275f028 --- /dev/null +++ b/eth/tracers/native/opcode_counter.go @@ -0,0 +1,55 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package native + +import ( + "encoding/json" + + "github.com/ethereum/go-ethereum/core/tracing" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/eth/tracers" +) + +// opcodeCounter is a simple tracer that counts how many times each opcode is executed. +type opcodeCounter struct { + counts [256]uint64 +} + +// NewOpcodeCounter returns a new opcodeCounter tracer. +func NewOpcodeCounter() *tracers.Tracer { + c := &opcodeCounter{} + return &tracers.Tracer{ + Hooks: &tracing.Hooks{ + OnOpcode: func(pc uint64, op byte, gas, cost uint64, scope tracing.OpContext, rData []byte, depth int, err error) { + c.counts[op]++ + }, + }, + GetResult: c.getResult, + Stop: func(err error) {}, + } +} + +// getResult returns the opcode counts keyed by opcode name. +func (c *opcodeCounter) getResult() (json.RawMessage, error) { + out := make(map[string]uint64) + for op, count := range c.counts { + if count != 0 { + out[vm.OpCode(op).String()] = count + } + } + return json.Marshal(out) +} diff --git a/eth/tracers/native/prestate.go b/eth/tracers/native/prestate.go index 2e446f729bc2..7026cca7f3a0 100644 --- a/eth/tracers/native/prestate.go +++ b/eth/tracers/native/prestate.go @@ -44,21 +44,24 @@ func init() { type stateMap = map[common.Address]*account type account struct { - Balance *big.Int `json:"balance,omitempty"` - Code []byte `json:"code,omitempty"` + Balance *big.Int `json:"balance,omitempty"` + // Code is a pointer so omitempty can omit unchanged code (nil) while + // still emitting "0x" when code is cleared (e.g. EIP-7702 deauth). + Code *[]byte `json:"code,omitempty"` CodeHash *common.Hash `json:"codeHash,omitempty"` Nonce uint64 `json:"nonce,omitempty"` Storage map[common.Hash]common.Hash `json:"storage,omitempty"` - empty bool + + empty bool } func (a *account) exists() bool { - return a.Nonce > 0 || len(a.Code) > 0 || len(a.Storage) > 0 || (a.Balance != nil && a.Balance.Sign() != 0) + return a.Nonce > 0 || (a.Code != nil && len(*a.Code) > 0) || len(a.Storage) > 0 || (a.Balance != nil && a.Balance.Sign() != 0) } type accountMarshaling struct { Balance *hexutil.Big - Code hexutil.Bytes + Code *hexutil.Bytes } type prestateTracer struct { @@ -66,15 +69,15 @@ type prestateTracer struct { pre stateMap post stateMap to common.Address - config prestateTracerConfig + config PrestateTracerConfig chainConfig *params.ChainConfig - interrupt atomic.Bool // Atomic flag to signal execution interruption - reason error // Textual reason for the interruption + interrupt atomic.Bool // Atomic flag to signal execution interruption + reason atomic.Pointer[error] // Reason for the interruption, populated by Stop created map[common.Address]bool deleted map[common.Address]bool } -type prestateTracerConfig struct { +type PrestateTracerConfig struct { DiffMode bool `json:"diffMode"` // If true, this tracer will return state modifications DisableCode bool `json:"disableCode"` // If true, this tracer will not return the contract code DisableStorage bool `json:"disableStorage"` // If true, this tracer will not return the contract storage @@ -82,7 +85,7 @@ type prestateTracerConfig struct { } func newPrestateTracer(ctx *tracers.Context, cfg json.RawMessage, chainConfig *params.ChainConfig) (*tracers.Tracer, error) { - var config prestateTracerConfig + var config PrestateTracerConfig if err := json.Unmarshal(cfg, &config); err != nil { return nil, err } @@ -237,12 +240,15 @@ func (t *prestateTracer) GetResult() (json.RawMessage, error) { if err != nil { return nil, err } - return json.RawMessage(res), t.reason + if p := t.reason.Load(); p != nil { + return json.RawMessage(res), *p + } + return json.RawMessage(res), nil } // Stop terminates execution of the tracer at the first opportune moment. func (t *prestateTracer) Stop(err error) { - t.reason = err + t.reason.Store(&err) t.interrupt.Store(true) } @@ -266,24 +272,28 @@ func (t *prestateTracer) processDiffState() { modified = true postAccount.Nonce = newNonce } - prevCodeHash := common.Hash{} + // Empty code hashes are excluded from the prestate, so default + // to EmptyCodeHash to match what GetCodeHash returns for codeless accounts. + prevCodeHash := types.EmptyCodeHash if t.pre[addr].CodeHash != nil { prevCodeHash = *t.pre[addr].CodeHash } - // Empty code hashes are excluded from the prestate. Normalize - // the empty code hash to a zero hash to make it comparable. - if newCodeHash == types.EmptyCodeHash { - newCodeHash = common.Hash{} - } if newCodeHash != prevCodeHash { modified = true postAccount.CodeHash = &newCodeHash } if !t.config.DisableCode { newCode := t.env.StateDB.GetCode(addr) - if !bytes.Equal(newCode, t.pre[addr].Code) { + var prevCode []byte + if t.pre[addr].Code != nil { + prevCode = *t.pre[addr].Code + } + if !bytes.Equal(newCode, prevCode) { modified = true - postAccount.Code = newCode + if newCode == nil { + newCode = []byte{} + } + postAccount.Code = &newCode } } @@ -323,10 +333,13 @@ func (t *prestateTracer) lookupAccount(addr common.Address) { return } + code := t.env.StateDB.GetCode(addr) acc := &account{ Balance: t.env.StateDB.GetBalance(addr).ToBig(), Nonce: t.env.StateDB.GetNonce(addr), - Code: t.env.StateDB.GetCode(addr), + } + if len(code) > 0 { + acc.Code = &code } codeHash := t.env.StateDB.GetCodeHash(addr) // If the code is empty, we don't need to store it in the prestate. diff --git a/eth/tracers/native/tracer_test.go b/eth/tracers/native/tracer_test.go new file mode 100644 index 000000000000..70e6283d342a --- /dev/null +++ b/eth/tracers/native/tracer_test.go @@ -0,0 +1,80 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package native_test + +import ( + "errors" + "math/big" + "sync" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/params" + "github.com/stretchr/testify/require" +) + +// TestTracerStopRace exercises the concurrent Stop / GetResult path that the +// trace RPC handler uses: a timeout watchdog goroutine calls Stop while the +// main goroutine is still running the trace and will eventually call +// GetResult. Under -race, writes to the interruption reason field must not +// race with reads, for every tracer that implements it. +// +// callTracer, flatCallTracer and erc7562Tracer's GetResult short-circuits on +// an empty callstack ("incorrect number of top-level calls") before loading +// the reason. For those tracers the test pushes a single top-level call frame +// via OnEnter so GetResult reaches the reason.Load() path where the race can +// be observed under -race. +func TestTracerStopRace(t *testing.T) { + type setup struct { + name string + needsFrame bool // whether GetResult requires a top-level call frame + } + cases := []setup{ + {"callTracer", true}, + {"flatCallTracer", true}, + {"4byteTracer", false}, + {"prestateTracer", false}, + {"erc7562Tracer", true}, + } + for _, s := range cases { + t.Run(s.name, func(t *testing.T) { + tr, err := tracers.DefaultDirectory.New(s.name, &tracers.Context{}, nil, params.MainnetChainConfig) + require.NoError(t, err) + + if s.needsFrame && tr.OnEnter != nil { + // Push a single top-level call frame so GetResult doesn't + // short-circuit before reading the interruption reason. + tr.OnEnter(0, byte(vm.CALL), common.Address{}, common.Address{}, nil, 0, big.NewInt(0)) + } + + stopErr := errors.New("execution timeout") + var wg sync.WaitGroup + wg.Add(2) + go func() { + defer wg.Done() + tr.Stop(stopErr) + }() + go func() { + defer wg.Done() + _, _ = tr.GetResult() + }() + wg.Wait() + }) + } +} diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go index 06edeaf6986e..24f9b3701eb8 100644 --- a/eth/tracers/tracers_test.go +++ b/eth/tracers/tracers_test.go @@ -91,7 +91,7 @@ func BenchmarkTransactionTraceV2(b *testing.B) { evm.Config.Tracer = tracer snap := state.StateDB.Snapshot() - _, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + _, err := core.ApplyMessage(evm, msg, nil) if err != nil { b.Fatal(err) } diff --git a/ethclient/ethclient.go b/ethclient/ethclient.go index 5008378da6a6..1d8573f982a4 100644 --- a/ethclient/ethclient.go +++ b/ethclient/ethclient.go @@ -124,7 +124,7 @@ func (ec *Client) PeerCount(ctx context.Context) (uint64, error) { // BlockReceipts returns the receipts of a given block number or hash. func (ec *Client) BlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) ([]*types.Receipt, error) { var r []*types.Receipt - err := ec.c.CallContext(ctx, &r, "eth_getBlockReceipts", blockNrOrHash.String()) + err := ec.c.CallContext(ctx, &r, "eth_getBlockReceipts", blockNrOrHash) if err == nil && r == nil { return nil, ethereum.NotFound } @@ -497,9 +497,16 @@ func (ec *Client) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuer } func toFilterArg(q ethereum.FilterQuery) (interface{}, error) { - arg := map[string]interface{}{ - "address": q.Addresses, - "topics": q.Topics, + arg := map[string]interface{}{} + // Only include "address" when there are actual address filters. + // An empty slice is treated the same as nil (no filter), and omitting + // the field avoids sending "address":[] to nodes that reject empty arrays + // (e.g. Hedera, some non-Geth implementations). + if len(q.Addresses) > 0 { + arg["address"] = q.Addresses + } + if q.Topics != nil { + arg["topics"] = q.Topics } if q.BlockHash != nil { arg["blockHash"] = *q.BlockHash @@ -726,9 +733,11 @@ func (ec *Client) SendRawTransactionSync( rawTx []byte, timeout *time.Duration, ) (*types.Receipt, error) { - var ms *hexutil.Uint64 + var ms *uint64 if timeout != nil { - if d := hexutil.Uint64(timeout.Milliseconds()); d > 0 { + msInt := timeout.Milliseconds() + if msInt > 0 { + d := uint64(msInt) ms = &d } } @@ -833,6 +842,7 @@ type rpcProgress struct { TxIndexFinishedBlocks hexutil.Uint64 TxIndexRemainingBlocks hexutil.Uint64 StateIndexRemaining hexutil.Uint64 + TrienodeIndexRemaining hexutil.Uint64 } func (p *rpcProgress) toSyncProgress() *ethereum.SyncProgress { @@ -860,6 +870,7 @@ func (p *rpcProgress) toSyncProgress() *ethereum.SyncProgress { TxIndexFinishedBlocks: uint64(p.TxIndexFinishedBlocks), TxIndexRemainingBlocks: uint64(p.TxIndexRemainingBlocks), StateIndexRemaining: uint64(p.StateIndexRemaining), + TrienodeIndexRemaining: uint64(p.TrienodeIndexRemaining), } } @@ -903,6 +914,7 @@ type SimulateCallResult struct { ReturnValue []byte `json:"returnData"` Logs []*types.Log `json:"logs"` GasUsed uint64 `json:"gasUsed"` + MaxUsedGas uint64 `json:"maxUsedGas"` Status uint64 `json:"status"` Error *CallError `json:"error,omitempty"` } @@ -910,6 +922,7 @@ type SimulateCallResult struct { type simulateCallResultMarshaling struct { ReturnValue hexutil.Bytes GasUsed hexutil.Uint64 + MaxUsedGas hexutil.Uint64 Status hexutil.Uint64 } diff --git a/ethclient/ethclient_test.go b/ethclient/ethclient_test.go index 302ccf2e16c2..fb04d776699d 100644 --- a/ethclient/ethclient_test.go +++ b/ethclient/ethclient_test.go @@ -687,6 +687,49 @@ func testTransactionSender(t *testing.T, client *rpc.Client) { } } +func TestBlockReceiptsPreservesCanonicalFlag(t *testing.T) { + srv := rpc.NewServer() + service := &blockReceiptsTestService{calls: make(chan rpc.BlockNumberOrHash, 1)} + if err := srv.RegisterName("eth", service); err != nil { + t.Fatalf("failed to register service: %v", err) + } + defer srv.Stop() + + client := rpc.DialInProc(srv) + defer client.Close() + + ec := ethclient.NewClient(client) + defer ec.Close() + + hash := common.HexToHash("0x01") + ref := rpc.BlockNumberOrHashWithHash(hash, true) + + if _, err := ec.BlockReceipts(context.Background(), ref); err != nil { + t.Fatalf("BlockReceipts returned error: %v", err) + } + + select { + case call := <-service.calls: + if call.BlockHash == nil || *call.BlockHash != hash { + t.Fatalf("unexpected block hash: got %v, want %v", call.BlockHash, hash) + } + if !call.RequireCanonical { + t.Fatalf("requireCanonical flag was lost: %+v", call) + } + default: + t.Fatal("service was not called") + } +} + +type blockReceiptsTestService struct { + calls chan rpc.BlockNumberOrHash +} + +func (s *blockReceiptsTestService) GetBlockReceipts(ctx context.Context, block rpc.BlockNumberOrHash) ([]*types.Receipt, error) { + s.calls <- block + return []*types.Receipt{}, nil +} + func newCanceledContext() context.Context { ctx, cancel := context.WithCancel(context.Background()) cancel() @@ -818,6 +861,12 @@ func TestSimulateV1(t *testing.T) { if results[0].Calls[0].Error != nil { t.Errorf("expected no error, got %v", results[0].Calls[0].Error) } + if results[0].Calls[0].MaxUsedGas == 0 { + t.Error("expected maxUsedGas to be set") + } + if results[0].Calls[0].MaxUsedGas < results[0].Calls[0].GasUsed { + t.Errorf("expected maxUsedGas >= gasUsed, got %d < %d", results[0].Calls[0].MaxUsedGas, results[0].Calls[0].GasUsed) + } } func TestSimulateV1WithBlockOverrides(t *testing.T) { diff --git a/ethclient/gen_simulate_call_result.go b/ethclient/gen_simulate_call_result.go index 55e14cd697f6..18373bbb881c 100644 --- a/ethclient/gen_simulate_call_result.go +++ b/ethclient/gen_simulate_call_result.go @@ -17,6 +17,7 @@ func (s SimulateCallResult) MarshalJSON() ([]byte, error) { ReturnValue hexutil.Bytes `json:"returnData"` Logs []*types.Log `json:"logs"` GasUsed hexutil.Uint64 `json:"gasUsed"` + MaxUsedGas hexutil.Uint64 `json:"maxUsedGas"` Status hexutil.Uint64 `json:"status"` Error *CallError `json:"error,omitempty"` } @@ -24,6 +25,7 @@ func (s SimulateCallResult) MarshalJSON() ([]byte, error) { enc.ReturnValue = s.ReturnValue enc.Logs = s.Logs enc.GasUsed = hexutil.Uint64(s.GasUsed) + enc.MaxUsedGas = hexutil.Uint64(s.MaxUsedGas) enc.Status = hexutil.Uint64(s.Status) enc.Error = s.Error return json.Marshal(&enc) @@ -35,6 +37,7 @@ func (s *SimulateCallResult) UnmarshalJSON(input []byte) error { ReturnValue *hexutil.Bytes `json:"returnData"` Logs []*types.Log `json:"logs"` GasUsed *hexutil.Uint64 `json:"gasUsed"` + MaxUsedGas *hexutil.Uint64 `json:"maxUsedGas"` Status *hexutil.Uint64 `json:"status"` Error *CallError `json:"error,omitempty"` } @@ -51,6 +54,9 @@ func (s *SimulateCallResult) UnmarshalJSON(input []byte) error { if dec.GasUsed != nil { s.GasUsed = uint64(*dec.GasUsed) } + if dec.MaxUsedGas != nil { + s.MaxUsedGas = uint64(*dec.MaxUsedGas) + } if dec.Status != nil { s.Status = uint64(*dec.Status) } diff --git a/ethclient/gethclient/gen_callframe_json.go b/ethclient/gethclient/gen_callframe_json.go new file mode 100644 index 000000000000..48df2790cca8 --- /dev/null +++ b/ethclient/gethclient/gen_callframe_json.go @@ -0,0 +1,104 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package gethclient + +import ( + "encoding/json" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" +) + +var _ = (*callFrameMarshaling)(nil) + +// MarshalJSON marshals as JSON. +func (c CallFrame) MarshalJSON() ([]byte, error) { + type CallFrame0 struct { + Type string `json:"type"` + From common.Address `json:"from"` + Gas hexutil.Uint64 `json:"gas"` + GasUsed hexutil.Uint64 `json:"gasUsed"` + To *common.Address `json:"to,omitempty"` + Input hexutil.Bytes `json:"input"` + Output hexutil.Bytes `json:"output,omitempty"` + Error string `json:"error,omitempty"` + RevertReason string `json:"revertReason,omitempty"` + Calls []CallFrame `json:"calls,omitempty"` + Logs []CallLog `json:"logs,omitempty"` + Value *hexutil.Big `json:"value,omitempty"` + } + var enc CallFrame0 + enc.Type = c.Type + enc.From = c.From + enc.Gas = hexutil.Uint64(c.Gas) + enc.GasUsed = hexutil.Uint64(c.GasUsed) + enc.To = c.To + enc.Input = c.Input + enc.Output = c.Output + enc.Error = c.Error + enc.RevertReason = c.RevertReason + enc.Calls = c.Calls + enc.Logs = c.Logs + enc.Value = (*hexutil.Big)(c.Value) + return json.Marshal(&enc) +} + +// UnmarshalJSON unmarshals from JSON. +func (c *CallFrame) UnmarshalJSON(input []byte) error { + type CallFrame0 struct { + Type *string `json:"type"` + From *common.Address `json:"from"` + Gas *hexutil.Uint64 `json:"gas"` + GasUsed *hexutil.Uint64 `json:"gasUsed"` + To *common.Address `json:"to,omitempty"` + Input *hexutil.Bytes `json:"input"` + Output *hexutil.Bytes `json:"output,omitempty"` + Error *string `json:"error,omitempty"` + RevertReason *string `json:"revertReason,omitempty"` + Calls []CallFrame `json:"calls,omitempty"` + Logs []CallLog `json:"logs,omitempty"` + Value *hexutil.Big `json:"value,omitempty"` + } + var dec CallFrame0 + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Type != nil { + c.Type = *dec.Type + } + if dec.From != nil { + c.From = *dec.From + } + if dec.Gas != nil { + c.Gas = uint64(*dec.Gas) + } + if dec.GasUsed != nil { + c.GasUsed = uint64(*dec.GasUsed) + } + if dec.To != nil { + c.To = dec.To + } + if dec.Input != nil { + c.Input = *dec.Input + } + if dec.Output != nil { + c.Output = *dec.Output + } + if dec.Error != nil { + c.Error = *dec.Error + } + if dec.RevertReason != nil { + c.RevertReason = *dec.RevertReason + } + if dec.Calls != nil { + c.Calls = dec.Calls + } + if dec.Logs != nil { + c.Logs = dec.Logs + } + if dec.Value != nil { + c.Value = (*big.Int)(dec.Value) + } + return nil +} diff --git a/ethclient/gethclient/gen_calllog_json.go b/ethclient/gethclient/gen_calllog_json.go new file mode 100644 index 000000000000..50e25d4bb39a --- /dev/null +++ b/ethclient/gethclient/gen_calllog_json.go @@ -0,0 +1,61 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package gethclient + +import ( + "encoding/json" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" +) + +var _ = (*callLogMarshaling)(nil) + +// MarshalJSON marshals as JSON. +func (c CallLog) MarshalJSON() ([]byte, error) { + type CallLog struct { + Address common.Address `json:"address"` + Topics []common.Hash `json:"topics"` + Data hexutil.Bytes `json:"data"` + Index hexutil.Uint `json:"index"` + Position hexutil.Uint `json:"position"` + } + var enc CallLog + enc.Address = c.Address + enc.Topics = c.Topics + enc.Data = c.Data + enc.Index = hexutil.Uint(c.Index) + enc.Position = hexutil.Uint(c.Position) + return json.Marshal(&enc) +} + +// UnmarshalJSON unmarshals from JSON. +func (c *CallLog) UnmarshalJSON(input []byte) error { + type CallLog struct { + Address *common.Address `json:"address"` + Topics []common.Hash `json:"topics"` + Data *hexutil.Bytes `json:"data"` + Index *hexutil.Uint `json:"index"` + Position *hexutil.Uint `json:"position"` + } + var dec CallLog + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Address != nil { + c.Address = *dec.Address + } + if dec.Topics != nil { + c.Topics = dec.Topics + } + if dec.Data != nil { + c.Data = *dec.Data + } + if dec.Index != nil { + c.Index = uint(*dec.Index) + } + if dec.Position != nil { + c.Position = uint(*dec.Position) + } + return nil +} diff --git a/ethclient/gethclient/gethclient.go b/ethclient/gethclient/gethclient.go index 6a0f5eb31233..e677e2bb2145 100644 --- a/ethclient/gethclient/gethclient.go +++ b/ethclient/gethclient/gethclient.go @@ -19,10 +19,12 @@ package gethclient import ( "context" + "encoding/json" "fmt" "math/big" "runtime" "runtime/debug" + "time" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" @@ -104,7 +106,10 @@ func (ec *Client) GetProof(ctx context.Context, account common.Address, keys []s var res accountResult err := ec.c.CallContext(ctx, &res, "eth_getProof", account, keys, toBlockNumArg(blockNumber)) - // Turn hexutils back to normal datatypes + if err != nil { + return nil, err + } + // Turn hexutils back to normal data types storageResults := make([]StorageResult, 0, len(res.StorageProof)) for _, st := range res.StorageProof { storageResults = append(storageResults, StorageResult{ @@ -122,7 +127,7 @@ func (ec *Client) GetProof(ctx context.Context, account common.Address, keys []s StorageHash: res.StorageHash, StorageProof: storageResults, } - return &result, err + return &result, nil } // CallContract executes a message call transaction, which is directly executed in the VM @@ -226,6 +231,124 @@ func (ec *Client) TraceBlock(ctx context.Context, hash common.Hash, config *trac return result, nil } +// CallTracerConfig configures the call tracer for +// TraceTransactionWithCallTracer and TraceCallWithCallTracer. +type CallTracerConfig struct { + // OnlyTopCall, when true, limits tracing to the main (top-level) call only. + OnlyTopCall bool + // WithLog, when true, includes log emissions in the trace output. + WithLog bool + // Timeout is the maximum duration the tracer may run. + // Zero means the server default (5s). + Timeout time.Duration +} + +//go:generate go run github.com/fjl/gencodec -type CallLog -field-override callLogMarshaling -out gen_calllog_json.go + +// CallLog represents a log emitted during a traced call. +type CallLog struct { + Address common.Address `json:"address"` + Topics []common.Hash `json:"topics"` + Data []byte `json:"data"` + Index uint `json:"index"` + Position uint `json:"position"` +} + +type callLogMarshaling struct { + Data hexutil.Bytes + Index hexutil.Uint + Position hexutil.Uint +} + +//go:generate go run github.com/fjl/gencodec -type CallFrame -field-override callFrameMarshaling -out gen_callframe_json.go + +// CallFrame contains the result of a call tracer run. +type CallFrame struct { + Type string `json:"type"` + From common.Address `json:"from"` + Gas uint64 `json:"gas"` + GasUsed uint64 `json:"gasUsed"` + To *common.Address `json:"to,omitempty"` + Input []byte `json:"input"` + Output []byte `json:"output,omitempty"` + Error string `json:"error,omitempty"` + RevertReason string `json:"revertReason,omitempty"` + Calls []CallFrame `json:"calls,omitempty"` + Logs []CallLog `json:"logs,omitempty"` + Value *big.Int `json:"value,omitempty"` +} + +type callFrameMarshaling struct { + Gas hexutil.Uint64 + GasUsed hexutil.Uint64 + Input hexutil.Bytes + Output hexutil.Bytes + Value *hexutil.Big +} + +// TraceTransactionWithCallTracer traces a transaction with the call tracer +// and returns a typed CallFrame. If config is nil, defaults are used. +func (ec *Client) TraceTransactionWithCallTracer(ctx context.Context, txHash common.Hash, config *CallTracerConfig) (*CallFrame, error) { + var result CallFrame + err := ec.c.CallContext(ctx, &result, "debug_traceTransaction", txHash, callTracerConfig(config)) + if err != nil { + return nil, err + } + return &result, nil +} + +// TraceCallWithCallTracer executes a call with the call tracer and returns +// a typed CallFrame. blockNrOrHash selects the block context for the call. +// overrides specifies state overrides (nil for none), blockOverrides specifies +// block header overrides (nil for none), and config configures the tracer +// (nil for defaults). +func (ec *Client) TraceCallWithCallTracer(ctx context.Context, msg ethereum.CallMsg, blockNrOrHash rpc.BlockNumberOrHash, overrides map[common.Address]OverrideAccount, blockOverrides *BlockOverrides, config *CallTracerConfig) (*CallFrame, error) { + var result CallFrame + err := ec.c.CallContext(ctx, &result, "debug_traceCall", toCallArg(msg), blockNrOrHash, callTraceCallConfig(config, overrides, blockOverrides)) + if err != nil { + return nil, err + } + return &result, nil +} + +// callTracerConfig converts a CallTracerConfig to the wire-format TraceConfig. +func callTracerConfig(config *CallTracerConfig) *tracers.TraceConfig { + tracer := "callTracer" + tc := &tracers.TraceConfig{Tracer: &tracer} + if config != nil { + if config.OnlyTopCall || config.WithLog { + cfg, _ := json.Marshal(struct { + OnlyTopCall bool `json:"onlyTopCall"` + WithLog bool `json:"withLog"` + }{config.OnlyTopCall, config.WithLog}) + tc.TracerConfig = cfg + } + if config.Timeout != 0 { + s := config.Timeout.String() + tc.Timeout = &s + } + } + return tc +} + +// callTraceCallConfig builds the wire-format TraceCallConfig for debug_traceCall, +// bundling tracer settings with optional state and block overrides. +func callTraceCallConfig(config *CallTracerConfig, overrides map[common.Address]OverrideAccount, blockOverrides *BlockOverrides) interface{} { + tc := callTracerConfig(config) + // debug_traceCall expects a single config object that includes both + // tracer settings and any state/block overrides. + type traceCallConfig struct { + *tracers.TraceConfig + StateOverrides map[common.Address]OverrideAccount `json:"stateOverrides,omitempty"` + BlockOverrides *BlockOverrides `json:"blockOverrides,omitempty"` + } + return &traceCallConfig{ + TraceConfig: tc, + StateOverrides: overrides, + BlockOverrides: blockOverrides, + } +} + func toBlockNumArg(number *big.Int) string { if number == nil { return "latest" diff --git a/ethclient/gethclient/gethclient_test.go b/ethclient/gethclient/gethclient_test.go index 0eed63cacfec..4d8ccfcb6f69 100644 --- a/ethclient/gethclient/gethclient_test.go +++ b/ethclient/gethclient/gethclient_test.go @@ -34,6 +34,7 @@ import ( "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/eth/filters" "github.com/ethereum/go-ethereum/eth/tracers" + _ "github.com/ethereum/go-ethereum/eth/tracers/native" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" @@ -161,6 +162,12 @@ func TestGethClient(t *testing.T) { }, { "TestCallContractWithBlockOverrides", func(t *testing.T) { testCallContractWithBlockOverrides(t, client) }, + }, { + "TestTraceTransactionWithCallTracer", + func(t *testing.T) { testTraceTransactionWithCallTracer(t, client, txHashes) }, + }, { + "TestTraceCallWithCallTracer", + func(t *testing.T) { testTraceCallWithCallTracer(t, client) }, }, // The testaccesslist is a bit time-sensitive: the newTestBackend imports // one block. The `testAccessList` fails if the miner has not yet created a @@ -620,3 +627,60 @@ func testCallContractWithBlockOverrides(t *testing.T, client *rpc.Client) { t.Fatalf("unexpected result: %x", res) } } + +func testTraceTransactionWithCallTracer(t *testing.T, client *rpc.Client, txHashes []common.Hash) { + ec := New(client) + for _, txHash := range txHashes { + // With nil config (defaults). + result, err := ec.TraceTransactionWithCallTracer(context.Background(), txHash, nil) + if err != nil { + t.Fatalf("nil config: %v", err) + } + if result.Type != "CALL" { + t.Fatalf("unexpected type: %s", result.Type) + } + if result.From == (common.Address{}) { + t.Fatal("from is zero") + } + if result.Gas == 0 { + t.Fatal("gas is zero") + } + + // With explicit config. + result, err = ec.TraceTransactionWithCallTracer(context.Background(), txHash, + &CallTracerConfig{}, + ) + if err != nil { + t.Fatalf("explicit config: %v", err) + } + if result.Type != "CALL" { + t.Fatalf("unexpected type: %s", result.Type) + } + } +} + +func testTraceCallWithCallTracer(t *testing.T, client *rpc.Client) { + ec := New(client) + msg := ethereum.CallMsg{ + From: testAddr, + To: &common.Address{}, + Gas: 21000, + GasPrice: big.NewInt(1000000000), + Value: big.NewInt(1), + } + result, err := ec.TraceCallWithCallTracer(context.Background(), msg, + rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber), nil, nil, nil, + ) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.Type != "CALL" { + t.Fatalf("unexpected type: %s", result.Type) + } + if result.From == (common.Address{}) { + t.Fatal("from is zero") + } + if result.Gas == 0 { + t.Fatal("gas is zero") + } +} diff --git a/ethclient/simulated/backend.go b/ethclient/simulated/backend.go index d573c7e7507f..160ad924bfff 100644 --- a/ethclient/simulated/backend.go +++ b/ethclient/simulated/backend.go @@ -86,6 +86,8 @@ func NewBackend(alloc types.GenesisAlloc, options ...func(nodeConf *node.Config, } ethConf.SyncMode = ethconfig.FullSync ethConf.TxPool.NoLocals = true + // Disable log indexing to force unindexed log search + ethConf.LogNoHistory = true for _, option := range options { option(&nodeConf, ðConf) diff --git a/ethclient/types_test.go b/ethclient/types_test.go index 02f9f2175880..8820b11162bf 100644 --- a/ethclient/types_test.go +++ b/ethclient/types_test.go @@ -41,6 +41,34 @@ func TestToFilterArg(t *testing.T) { output interface{} err error }{ + { + "without addresses", + ethereum.FilterQuery{ + FromBlock: big.NewInt(1), + ToBlock: big.NewInt(2), + }, + map[string]interface{}{ + "fromBlock": "0x1", + "toBlock": "0x2", + }, + nil, + }, + { + // empty Addresses slice must be treated same as nil: + // the "address" field must be omitted so that non-Geth nodes + // (e.g. Hedera) do not reject the request with an error. + "with empty addresses slice", + ethereum.FilterQuery{ + Addresses: []common.Address{}, + FromBlock: big.NewInt(1), + ToBlock: big.NewInt(2), + }, + map[string]interface{}{ + "fromBlock": "0x1", + "toBlock": "0x2", + }, + nil, + }, { "without BlockHash", ethereum.FilterQuery{ diff --git a/ethdb/batch.go b/ethdb/batch.go index 45b3781cb04e..b93636c86512 100644 --- a/ethdb/batch.go +++ b/ethdb/batch.go @@ -37,6 +37,9 @@ type Batch interface { // Replay replays the batch contents. Replay(w KeyValueWriter) error + + // Close closes the batch and releases all associated resources. + Close() } // Batcher wraps the NewBatch method of a backing data store. diff --git a/ethdb/leveldb/leveldb.go b/ethdb/leveldb/leveldb.go index b6c93907b19c..c235d5f4455b 100644 --- a/ethdb/leveldb/leveldb.go +++ b/ethdb/leveldb/leveldb.go @@ -518,6 +518,9 @@ func (b *batch) Replay(w ethdb.KeyValueWriter) error { return b.b.Replay(&replayer{writer: w}) } +// Close closes the batch and releases all associated resources. +func (b *batch) Close() {} + // replayer is a small wrapper to implement the correct replay methods. type replayer struct { writer ethdb.KeyValueWriter diff --git a/ethdb/memorydb/memorydb.go b/ethdb/memorydb/memorydb.go index 200ad6024568..29ed0aaea135 100644 --- a/ethdb/memorydb/memorydb.go +++ b/ethdb/memorydb/memorydb.go @@ -338,6 +338,9 @@ func (b *batch) Replay(w ethdb.KeyValueWriter) error { return nil } +// Close closes the batch and releases all associated resources. +func (b *batch) Close() {} + // iterator can walk over the (potentially partial) keyspace of a memory key // value store. Internally it is a deep copy of the entire iterated state, // sorted by keys. diff --git a/ethdb/pebble/pebble.go b/ethdb/pebble/pebble.go index 800559ab4bd1..7654d582c483 100644 --- a/ethdb/pebble/pebble.go +++ b/ethdb/pebble/pebble.go @@ -300,10 +300,14 @@ func New(file string, cache int, handles int, namespace string, readonly bool) ( // debt will be less than 1GB, but with more frequent compactions scheduled. L0CompactionThreshold: 2, } + // Disable seek compaction explicitly. Check https://github.com/ethereum/go-ethereum/pull/20130 + // for more details. + opt.Experimental.ReadSamplingMultiplier = -1 + // These two settings define the conditions under which compaction concurrency // is increased. Specifically, one additional compaction job will be enabled when: // - there is one more overlapping sub-level0; - // - there is an additional 512 MB of compaction debt; + // - there is an additional 256 MB of compaction debt; // // The maximum concurrency is still capped by MaxConcurrentCompactions, but with // these settings compactions can scale up more readily. @@ -727,6 +731,12 @@ func (b *batch) Replay(w ethdb.KeyValueWriter) error { } } +// Close closes the batch and releases all associated resources. After it is +// closed, any subsequent operations on this batch are undefined. +func (b *batch) Close() { + b.b.Close() +} + // pebbleIterator is a wrapper of underlying iterator in storage engine. // The purpose of this structure is to implement the missing APIs. // diff --git a/ethstats/ethstats.go b/ethstats/ethstats.go index b6191baa12b9..c17e22516504 100644 --- a/ethstats/ethstats.go +++ b/ethstats/ethstats.go @@ -63,6 +63,7 @@ const ( type backend interface { SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription + SubscribeNewPayloadEvent(ch chan<- core.NewPayloadEvent) event.Subscription CurrentHeader() *types.Header HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) Stats() (pending int, queued int) @@ -92,8 +93,9 @@ type Service struct { pongCh chan struct{} // Pong notifications are fed into this channel histCh chan []uint64 // History request block numbers are fed into this channel - headSub event.Subscription - txSub event.Subscription + headSub event.Subscription + txSub event.Subscription + newPayloadSub event.Subscription } // connWrapper is a wrapper to prevent concurrent-write or concurrent-read on the @@ -198,7 +200,9 @@ func (s *Service) Start() error { s.headSub = s.backend.SubscribeChainHeadEvent(chainHeadCh) txEventCh := make(chan core.NewTxsEvent, txChanSize) s.txSub = s.backend.SubscribeNewTxsEvent(txEventCh) - go s.loop(chainHeadCh, txEventCh) + newPayloadCh := make(chan core.NewPayloadEvent, chainHeadChanSize) + s.newPayloadSub = s.backend.SubscribeNewPayloadEvent(newPayloadCh) + go s.loop(chainHeadCh, txEventCh, newPayloadCh) log.Info("Stats daemon started") return nil @@ -208,18 +212,20 @@ func (s *Service) Start() error { func (s *Service) Stop() error { s.headSub.Unsubscribe() s.txSub.Unsubscribe() + s.newPayloadSub.Unsubscribe() log.Info("Stats daemon stopped") return nil } // loop keeps trying to connect to the netstats server, reporting chain events // until termination. -func (s *Service) loop(chainHeadCh chan core.ChainHeadEvent, txEventCh chan core.NewTxsEvent) { +func (s *Service) loop(chainHeadCh chan core.ChainHeadEvent, txEventCh chan core.NewTxsEvent, newPayloadCh chan core.NewPayloadEvent) { // Start a goroutine that exhausts the subscriptions to avoid events piling up var ( - quitCh = make(chan struct{}) - headCh = make(chan *types.Header, 1) - txCh = make(chan struct{}, 1) + quitCh = make(chan struct{}) + headCh = make(chan *types.Header, 1) + txCh = make(chan struct{}, 1) + newPayloadEvCh = make(chan core.NewPayloadEvent, 1) ) go func() { var lastTx mclock.AbsTime @@ -246,11 +252,20 @@ func (s *Service) loop(chainHeadCh chan core.ChainHeadEvent, txEventCh chan core default: } + // Notify of new payload events, but drop if too frequent + case ev := <-newPayloadCh: + select { + case newPayloadEvCh <- ev: + default: + } + // node stopped case <-s.txSub.Err(): break HandleLoop case <-s.headSub.Err(): break HandleLoop + case <-s.newPayloadSub.Err(): + break HandleLoop } } close(quitCh) @@ -336,6 +351,10 @@ func (s *Service) loop(chainHeadCh chan core.ChainHeadEvent, txEventCh chan core if err = s.reportPending(conn); err != nil { log.Warn("Post-block transaction stats report failed", "err", err) } + case ev := <-newPayloadEvCh: + if err = s.reportNewPayload(conn, ev); err != nil { + log.Warn("New payload stats report failed", "err", err) + } case <-txCh: if err = s.reportPending(conn); err != nil { log.Warn("Transaction stats report failed", "err", err) @@ -600,6 +619,33 @@ func (s uncleStats) MarshalJSON() ([]byte, error) { return []byte("[]"), nil } +// newPayloadStats is the information to report about new payload events. +type newPayloadStats struct { + Number uint64 `json:"number"` + Hash common.Hash `json:"hash"` + ProcessingTime uint64 `json:"processingTime"` // nanoseconds +} + +// reportNewPayload reports a new payload event to the stats server. +func (s *Service) reportNewPayload(conn *connWrapper, ev core.NewPayloadEvent) error { + details := &newPayloadStats{ + Number: ev.Number, + Hash: ev.Hash, + ProcessingTime: uint64(ev.ProcessingTime.Nanoseconds()), + } + + log.Trace("Sending new payload to ethstats", "number", details.Number, "hash", details.Hash) + + stats := map[string]interface{}{ + "id": s.node, + "block": details, + } + report := map[string][]interface{}{ + "emit": {"block_new_payload", stats}, + } + return conn.WriteJSON(report) +} + // reportBlock retrieves the current chain head and reports it to the stats server. func (s *Service) reportBlock(conn *connWrapper, header *types.Header) error { // Gather the block details from the header or block chain diff --git a/go.mod b/go.mod index aff1d53923cd..17897a62c0b8 100644 --- a/go.mod +++ b/go.mod @@ -14,17 +14,16 @@ require ( github.com/cloudflare/cloudflare-go v0.114.0 github.com/cockroachdb/pebble v1.1.5 github.com/consensys/gnark-crypto v0.18.1 - github.com/crate-crypto/go-eth-kzg v1.4.0 - github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a + github.com/crate-crypto/go-eth-kzg v1.5.0 github.com/davecgh/go-spew v1.1.1 github.com/dchest/siphash v1.2.3 github.com/deckarep/golang-set/v2 v2.6.0 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 github.com/donovanhide/eventsource v0.0.0-20210830082556-c59027999da0 github.com/dop251/goja v0.0.0-20230605162241-28ee0ee714f3 - github.com/ethereum/c-kzg-4844/v2 v2.1.5 + github.com/ethereum/c-kzg-4844/v2 v2.1.6 github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab - github.com/ethereum/go-verkle v0.2.2 + github.com/ethereum/hid v1.0.1-0.20260421154323-c2ab8d9bf68a github.com/fatih/color v1.16.0 github.com/ferranbt/fastssz v0.1.4 github.com/fsnotify/fsnotify v1.6.0 @@ -33,7 +32,7 @@ require ( github.com/golang-jwt/jwt/v4 v4.5.2 github.com/golang/snappy v1.0.0 github.com/google/gofuzz v1.2.0 - github.com/google/uuid v1.3.0 + github.com/google/uuid v1.6.0 github.com/gorilla/websocket v1.4.2 github.com/graph-gophers/graphql-go v1.3.0 github.com/hashicorp/go-bexpr v0.1.10 @@ -45,7 +44,7 @@ require ( github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c github.com/jackpal/go-nat-pmp v1.0.2 github.com/jedisct1/go-minisign v0.0.0-20230811132847-661be99b8267 - github.com/karalabe/hid v1.0.1-0.20240306101548-573246063e52 + github.com/klauspost/compress v1.17.8 github.com/kylelemons/godebug v1.1.0 github.com/mattn/go-colorable v0.1.13 github.com/mattn/go-isatty v0.0.20 @@ -58,24 +57,43 @@ require ( github.com/rs/cors v1.7.0 github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible github.com/status-im/keycard-go v0.2.0 - github.com/stretchr/testify v1.10.0 - github.com/supranational/blst v0.3.16-0.20250831170142-f48500c1fdbe + github.com/stretchr/testify v1.11.1 + github.com/supranational/blst v0.3.16 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 github.com/urfave/cli/v2 v2.27.5 + go.opentelemetry.io/otel v1.40.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.40.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.40.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.40.0 + go.opentelemetry.io/otel/sdk v1.40.0 + go.opentelemetry.io/otel/trace v1.40.0 go.uber.org/automaxprocs v1.5.2 go.uber.org/goleak v1.3.0 - golang.org/x/crypto v0.36.0 + golang.org/x/crypto v0.47.0 golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df - golang.org/x/sync v0.12.0 - golang.org/x/sys v0.36.0 - golang.org/x/text v0.23.0 + golang.org/x/sync v0.19.0 + golang.org/x/sys v0.40.0 + golang.org/x/text v0.33.0 golang.org/x/time v0.9.0 - golang.org/x/tools v0.29.0 - google.golang.org/protobuf v1.34.2 + golang.org/x/tools v0.40.0 + google.golang.org/protobuf v1.36.11 gopkg.in/natefinch/lumberjack.v2 v2.2.1 gopkg.in/yaml.v3 v3.0.1 ) +require ( + github.com/cenkalti/backoff/v5 v5.0.3 // indirect + github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.7 // indirect + go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.opentelemetry.io/otel/metric v1.40.0 // indirect + go.opentelemetry.io/proto/otlp v1.9.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260128011058-8636f8732409 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260128011058-8636f8732409 // indirect + google.golang.org/grpc v1.78.0 // indirect +) + require ( github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0 // indirect github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0 // indirect @@ -113,10 +131,11 @@ require ( github.com/golang/protobuf v1.5.4 // indirect github.com/google/go-querystring v1.1.0 // indirect github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect + github.com/grafana/pyroscope-go v1.2.7 + github.com/grafana/pyroscope-go/godeltaprof v0.1.9 // indirect github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/kilic/bls12-381 v0.1.0 // indirect - github.com/klauspost/compress v1.16.0 // indirect github.com/klauspost/cpuid/v2 v2.0.9 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect @@ -138,13 +157,13 @@ require ( github.com/prometheus/common v0.42.0 // indirect github.com/prometheus/procfs v0.9.0 // indirect github.com/rivo/uniseg v0.2.0 // indirect - github.com/rogpeppe/go-internal v1.12.0 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/tklauser/go-sysconf v0.3.12 // indirect github.com/tklauser/numcpus v0.6.1 // indirect github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect - golang.org/x/mod v0.22.0 // indirect - golang.org/x/net v0.38.0 // indirect + golang.org/x/mod v0.31.0 // indirect + golang.org/x/net v0.49.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/go.sum b/go.sum index 503e0975d658..bad8a44cfd76 100644 --- a/go.sum +++ b/go.sum @@ -52,6 +52,8 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bits-and-blooms/bitset v1.20.0 h1:2F+rfL86jE2d/bmw7OhqUg2Sj/1rURkBn3MdfoPyRVU= github.com/bits-and-blooms/bitset v1.20.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= +github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= @@ -79,10 +81,8 @@ github.com/consensys/gnark-crypto v0.18.1 h1:RyLV6UhPRoYYzaFnPQA4qK3DyuDgkTgskDd github.com/consensys/gnark-crypto v0.18.1/go.mod h1:L3mXGFTe1ZN+RSJ+CLjUt9x7PNdx8ubaYfDROyp2Z8c= github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc= github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-eth-kzg v1.4.0 h1:WzDGjHk4gFg6YzV0rJOAsTK4z3Qkz5jd4RE3DAvPFkg= -github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= -github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg= -github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM= +github.com/crate-crypto/go-eth-kzg v1.5.0 h1:FYRiJMJG2iv+2Dy3fi14SVGjcPteZ5HAAUe4YWlJygc= +github.com/crate-crypto/go-eth-kzg v1.5.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -113,12 +113,12 @@ github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d/go.mod h1:DngW8aVqWbuLRMHItjPUyqdj+HWPvnQe8V8y1nDpIbM= github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A= github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= -github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s= -github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs= +github.com/ethereum/c-kzg-4844/v2 v2.1.6 h1:xQymkKCT5E2Jiaoqf3v4wsNgjZLY0lRSkZn27fRjSls= +github.com/ethereum/c-kzg-4844/v2 v2.1.6/go.mod h1:8HMkUZ5JRv4hpw/XUrYWSQNAUzhHMg2UDb/U+5m+XNw= github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab h1:rvv6MJhy07IMfEKuARQ9TKojGqLVNxQajaXEp/BoqSk= github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab/go.mod h1:IuLm4IsPipXKF7CW5Lzf68PIbZ5yl7FFd74l/E0o9A8= -github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8= -github.com/ethereum/go-verkle v0.2.2/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= +github.com/ethereum/hid v1.0.1-0.20260421154323-c2ab8d9bf68a h1:eIFUceK3U/z9UV0D/kAI6cxA27eH7MPqt2ks7fbzj/k= +github.com/ethereum/hid v1.0.1-0.20260421154323-c2ab8d9bf68a/go.mod h1:nABYy4hsKZpuN0mu0uybdjrIOuGb1eE7b1lci/ezUAo= github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= github.com/ferranbt/fastssz v0.1.4 h1:OCDB+dYDEQDvAgtAGnTSidK1Pe2tW3nFV40XyMkTeDY= @@ -140,6 +140,11 @@ github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeME github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs= github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= @@ -174,21 +179,27 @@ github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/pprof v0.0.0-20230207041349-798e818bf904 h1:4/hN5RUoecvl+RmJRE2YxKWtnnQls6rQjjW5oV7qg2U= github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= -github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/grafana/pyroscope-go v1.2.7 h1:VWBBlqxjyR0Cwk2W6UrE8CdcdD80GOFNutj0Kb1T8ac= +github.com/grafana/pyroscope-go v1.2.7/go.mod h1:o/bpSLiJYYP6HQtvcoVKiE9s5RiNgjYTj1DhiddP2Pc= +github.com/grafana/pyroscope-go/godeltaprof v0.1.9 h1:c1Us8i6eSmkW+Ez05d3co8kasnuOY813tbMN8i/a3Og= +github.com/grafana/pyroscope-go/godeltaprof v0.1.9/go.mod h1:2+l7K7twW49Ct4wFluZD3tZ6e0SjanjcUUBPVD/UuGU= github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0= github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.7 h1:X+2YciYSxvMQK0UZ7sg45ZVabVZBeBuvMkmuI2V3Fak= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.7/go.mod h1:lW34nIZuQ8UDPdkon5fmfp2l3+ZkQ2me/+oecHYLOII= github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db h1:IZUYC/xb3giYwBLMnr8d0TGTzPKFGNTCGgGLoyeX330= @@ -216,14 +227,12 @@ github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9Y github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= -github.com/karalabe/hid v1.0.1-0.20240306101548-573246063e52 h1:msKODTL1m0wigztaqILOtla9HeW1ciscYG4xjLtvk5I= -github.com/karalabe/hid v1.0.1-0.20240306101548-573246063e52/go.mod h1:qk1sX/IBgppQNcGCRoj90u6EGC056EBoIc1oEjCWla8= github.com/kilic/bls12-381 v0.1.0 h1:encrdjqKMEvabVQ7qYOKu1OvhqpK4s47wDYtNiPtlp4= github.com/kilic/bls12-381 v0.1.0/go.mod h1:vDTTHJONJ6G+P2R74EhnyotQDTliQDnFEwhdmfzw1ig= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4= -github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU= +github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= @@ -326,8 +335,8 @@ github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= @@ -339,6 +348,8 @@ github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= @@ -347,10 +358,10 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/supranational/blst v0.3.16-0.20250831170142-f48500c1fdbe h1:nbdqkIGOGfUAD54q1s2YBcBz/WcsxCO9HUQ4aGV5hUw= -github.com/supranational/blst v0.3.16-0.20250831170142-f48500c1fdbe/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/supranational/blst v0.3.16 h1:bTDadT+3fK497EvLdWRQEjiGnUtzJ7jjIUMF0jqwYhE= +github.com/supranational/blst v0.3.16/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= @@ -367,6 +378,26 @@ github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBi github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/otel v1.40.0 h1:oA5YeOcpRTXq6NN7frwmwFR0Cn3RhTVZvXsP4duvCms= +go.opentelemetry.io/otel v1.40.0/go.mod h1:IMb+uXZUKkMXdPddhwAHm6UfOwJyh4ct1ybIlV14J0g= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.40.0 h1:QKdN8ly8zEMrByybbQgv8cWBcdAarwmIPZ6FThrWXJs= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.40.0/go.mod h1:bTdK1nhqF76qiPoCCdyFIV+N/sRHYXYCTQc+3VCi3MI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.40.0 h1:DvJDOPmSWQHWywQS6lKL+pb8s3gBLOZUtw4N+mavW1I= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.40.0/go.mod h1:EtekO9DEJb4/jRyN4v4Qjc2yA7AtfCBuz2FynRUWTXs= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.40.0 h1:wVZXIWjQSeSmMoxF74LzAnpVQOAFDo3pPji9Y4SOFKc= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.40.0/go.mod h1:khvBS2IggMFNwZK/6lEeHg/W57h/IX6J4URh57fuI40= +go.opentelemetry.io/otel/metric v1.40.0 h1:rcZe317KPftE2rstWIBitCdVp89A2HqjkxR3c11+p9g= +go.opentelemetry.io/otel/metric v1.40.0/go.mod h1:ib/crwQH7N3r5kfiBZQbwrTge743UDc7DTFVZrrXnqc= +go.opentelemetry.io/otel/sdk v1.40.0 h1:KHW/jUzgo6wsPh9At46+h4upjtccTmuZCFAc9OJ71f8= +go.opentelemetry.io/otel/sdk v1.40.0/go.mod h1:Ph7EFdYvxq72Y8Li9q8KebuYUr2KoeyHx0DRMKrYBUE= +go.opentelemetry.io/otel/sdk/metric v1.40.0 h1:mtmdVqgQkeRxHgRv4qhyJduP3fYJRMX4AtAlbuWdCYw= +go.opentelemetry.io/otel/sdk/metric v1.40.0/go.mod h1:4Z2bGMf0KSK3uRjlczMOeMhKU2rhUqdWNoKcYrtcBPg= +go.opentelemetry.io/otel/trace v1.40.0 h1:WA4etStDttCSYuhwvEa8OP8I5EWu24lkOzp+ZYblVjw= +go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTqQ5RgdEJcawiA= +go.opentelemetry.io/proto/otlp v1.9.0 h1:l706jCMITVouPOqEnii2fIAuO3IVGBRPV5ICjceRb/A= +go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4= go.uber.org/automaxprocs v1.5.2 h1:2LxUOGiR3O6tw8ui5sZa2LAaHnsviZdVOUZw4fvbnME= go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= @@ -379,16 +410,16 @@ golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWP golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE= golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= -golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= -golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8= +golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A= golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df h1:UA2aFVmmsIlefxMk29Dp2juaUSth8Pyn3Tq5Y5mJGME= golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= -golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= +golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI= +golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -404,8 +435,8 @@ golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= -golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8= -golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= +golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o= +golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -414,8 +445,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= -golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -448,8 +479,8 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k= -golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ= +golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= @@ -467,8 +498,8 @@ golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= -golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE= +golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8= golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY= @@ -480,21 +511,29 @@ golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roY golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= -golang.org/x/tools v0.29.0 h1:Xx0h3TtM9rzQpQuR4dKLrdglAmCEN5Oi+P74JdhdzXE= -golang.org/x/tools v0.29.0/go.mod h1:KMQVMRsVxU6nHCFXrBPhDB8XncLNLM0lIy/F14RP588= +golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA= +golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= +gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= +google.golang.org/genproto/googleapis/api v0.0.0-20260128011058-8636f8732409 h1:merA0rdPeUV3YIIfHHcH4qBkiQAc1nfCKSI7lB4cV2M= +google.golang.org/genproto/googleapis/api v0.0.0-20260128011058-8636f8732409/go.mod h1:fl8J1IvUjCilwZzQowmw2b7HQB2eAuYBabMXzWurF+I= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260128011058-8636f8732409 h1:H86B94AW+VfJWDqFeEbBPhEtHzJwJfTbgE2lZa54ZAQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260128011058-8636f8732409/go.mod h1:j9x/tPzZkyxcgEFkiKEEGxfvyumM01BEtsW8xzOahRQ= +google.golang.org/grpc v1.78.0 h1:K1XZG/yGDJnzMdd/uZHAkVqJE+xIDOcmdSFZkBUicNc= +google.golang.org/grpc v1.78.0/go.mod h1:I47qjTo4OKbMkjA/aOOwxDIiPSBofUtQUI5EfpWvW7U= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= +google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= diff --git a/graphql/graphql.go b/graphql/graphql.go index 55da3185dda1..dadc91fac033 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -272,7 +272,7 @@ func (t *Transaction) GasPrice(ctx context.Context) hexutil.Big { return hexutil.Big{} } switch tx.Type() { - case types.DynamicFeeTxType: + case types.DynamicFeeTxType, types.BlobTxType, types.SetCodeTxType: if block != nil { if baseFee, _ := block.BaseFeePerGas(ctx); baseFee != nil { // price = min(gasTipCap + baseFee, gasFeeCap) @@ -707,6 +707,9 @@ func (b *Block) resolveHeader(ctx context.Context) (*types.Header, error) { if err != nil { return nil, err } + if b.header == nil { + return nil, nil + } if b.hash == (common.Hash{}) { b.hash = b.header.Hash() } @@ -1090,6 +1093,18 @@ func (b *Block) ExcessBlobGas(ctx context.Context) (*hexutil.Uint64, error) { return &ret, nil } +func (b *Block) SlotNumber(ctx context.Context) (*hexutil.Uint64, error) { + header, err := b.resolveHeader(ctx) + if err != nil { + return nil, err + } + if header.SlotNumber == nil { + return nil, nil + } + ret := hexutil.Uint64(*header.SlotNumber) + return &ret, nil +} + // BlockFilterCriteria encapsulates criteria passed to a `logs` accessor inside // a block. type BlockFilterCriteria struct { @@ -1430,7 +1445,7 @@ func (r *Resolver) Logs(ctx context.Context, args struct{ Filter FilterCriteria topics = *args.Filter.Topics } // Construct the range filter - filter := r.filterSystem.NewRangeFilter(begin, end, addresses, topics) + filter := r.filterSystem.NewRangeFilter(begin, end, addresses, topics, 0) return runFilter(ctx, r, filter) } @@ -1516,6 +1531,9 @@ func (s *SyncState) TxIndexRemainingBlocks() hexutil.Uint64 { func (s *SyncState) StateIndexRemaining() hexutil.Uint64 { return hexutil.Uint64(s.progress.StateIndexRemaining) } +func (s *SyncState) TrienodeIndexRemaining() hexutil.Uint64 { + return hexutil.Uint64(s.progress.TrienodeIndexRemaining) +} // Syncing returns false in case the node is currently not syncing with the network. It can be up-to-date or has not // yet received the latest block headers from its peers. In case it is synchronizing: diff --git a/interfaces.go b/interfaces.go index 21d42c6d3479..8b3dbe3a42a9 100644 --- a/interfaces.go +++ b/interfaces.go @@ -139,8 +139,9 @@ type SyncProgress struct { TxIndexFinishedBlocks uint64 // Number of blocks whose transactions are already indexed TxIndexRemainingBlocks uint64 // Number of blocks whose transactions are not indexed yet - // "historical state indexing" fields - StateIndexRemaining uint64 // Number of states remain unindexed + // "historical data indexing" fields + StateIndexRemaining uint64 // Number of states remain unindexed + TrienodeIndexRemaining uint64 // Number of trienodes remain unindexed } // Done returns the indicator if the initial sync is finished or not. @@ -148,7 +149,7 @@ func (prog SyncProgress) Done() bool { if prog.CurrentBlock < prog.HighestBlock { return false } - return prog.TxIndexRemainingBlocks == 0 && prog.StateIndexRemaining == 0 + return prog.TxIndexRemainingBlocks == 0 && prog.StateIndexRemaining == 0 && prog.TrienodeIndexRemaining == 0 } // ChainSyncReader wraps access to the node's current sync status. If there's no diff --git a/internal/blocktest/test_hash.go b/internal/blocktest/test_hash.go index b3e7098e2bb6..5e5b1202ded9 100644 --- a/internal/blocktest/test_hash.go +++ b/internal/blocktest/test_hash.go @@ -27,7 +27,7 @@ import ( "hash" "github.com/ethereum/go-ethereum/common" - "golang.org/x/crypto/sha3" + "github.com/ethereum/go-ethereum/crypto/keccak" ) // testHasher is the helper tool for transaction/receipt list hashing. @@ -39,7 +39,7 @@ type testHasher struct { // NewHasher returns a new testHasher instance. func NewHasher() *testHasher { - return &testHasher{hasher: sha3.NewLegacyKeccak256()} + return &testHasher{hasher: keccak.NewLegacyKeccak256()} } // Reset resets the hash state. diff --git a/internal/build/gotool.go b/internal/build/gotool.go index 172fa134647f..00aa9d6f029e 100644 --- a/internal/build/gotool.go +++ b/internal/build/gotool.go @@ -41,12 +41,19 @@ type GoToolchain struct { func (g *GoToolchain) Go(command string, args ...string) *exec.Cmd { tool := g.goTool(command, args...) - // Configure environment for cross build. - if g.GOARCH != "" && g.GOARCH != runtime.GOARCH { + // Configure environment for cross build. Force CGO_ENABLED=1 whenever + // either GOOS or GOARCH differs from the host: Go's default is + // CGO_ENABLED=0 for any cross-compile, but geth's release builds rely + // on cgo (c-kzg-4844, secp256k1) regardless of which axis is crossing. + crossArch := g.GOARCH != "" && g.GOARCH != runtime.GOARCH + crossOS := g.GOOS != "" && g.GOOS != runtime.GOOS + if crossArch || crossOS { tool.Env = append(tool.Env, "CGO_ENABLED=1") + } + if crossArch { tool.Env = append(tool.Env, "GOARCH="+g.GOARCH) } - if g.GOOS != "" && g.GOOS != runtime.GOOS { + if crossOS { tool.Env = append(tool.Env, "GOOS="+g.GOOS) } // Configure C compiler. diff --git a/internal/debug/flags.go b/internal/debug/flags.go index 30b0ddb3be22..b4e55c46c106 100644 --- a/internal/debug/flags.go +++ b/internal/debug/flags.go @@ -162,6 +162,11 @@ var Flags = []cli.Flag{ blockprofilerateFlag, cpuprofileFlag, traceFlag, + pyroscopeFlag, + pyroscopeServerFlag, + pyroscopeAuthUsernameFlag, + pyroscopeAuthPasswordFlag, + pyroscopeTagsFlag, } var ( @@ -298,6 +303,14 @@ func Setup(ctx *cli.Context) error { // It cannot be imported because it will cause a cyclical dependency. StartPProf(address, !ctx.IsSet("metrics.addr")) } + + // Pyroscope profiling + if ctx.Bool(pyroscopeFlag.Name) { + if err := startPyroscope(ctx); err != nil { + return err + } + } + if len(logFile) > 0 || rotation { log.Info("Logging configured", context...) } @@ -321,6 +334,7 @@ func StartPProf(address string, withMetrics bool) { // Exit stops all running profiles, flushing their output to the // respective file. func Exit() { + stopPyroscope() Handler.StopCPUProfile() Handler.StopGoTrace() if logOutputFile != nil { diff --git a/internal/debug/pyroscope.go b/internal/debug/pyroscope.go new file mode 100644 index 000000000000..d0804cb89169 --- /dev/null +++ b/internal/debug/pyroscope.go @@ -0,0 +1,134 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package debug + +import ( + "fmt" + "strings" + + "github.com/ethereum/go-ethereum/internal/flags" + "github.com/ethereum/go-ethereum/log" + "github.com/grafana/pyroscope-go" + "github.com/urfave/cli/v2" +) + +var ( + pyroscopeFlag = &cli.BoolFlag{ + Name: "pyroscope", + Usage: "Enable Pyroscope profiling", + Value: false, + Category: flags.LoggingCategory, + } + pyroscopeServerFlag = &cli.StringFlag{ + Name: "pyroscope.server", + Usage: "Pyroscope server URL to push profiling data to", + Value: "http://localhost:4040", + Category: flags.LoggingCategory, + } + pyroscopeAuthUsernameFlag = &cli.StringFlag{ + Name: "pyroscope.username", + Usage: "Pyroscope basic authentication username", + Value: "", + Category: flags.LoggingCategory, + } + pyroscopeAuthPasswordFlag = &cli.StringFlag{ + Name: "pyroscope.password", + Usage: "Pyroscope basic authentication password", + Value: "", + Category: flags.LoggingCategory, + } + pyroscopeTagsFlag = &cli.StringFlag{ + Name: "pyroscope.tags", + Usage: "Comma separated list of key=value tags to add to profiling data", + Value: "", + Category: flags.LoggingCategory, + } +) + +// This holds the globally-configured Pyroscope instance. +var pyroscopeProfiler *pyroscope.Profiler + +func startPyroscope(ctx *cli.Context) error { + server := ctx.String(pyroscopeServerFlag.Name) + authUsername := ctx.String(pyroscopeAuthUsernameFlag.Name) + authPassword := ctx.String(pyroscopeAuthPasswordFlag.Name) + + rawTags := ctx.String(pyroscopeTagsFlag.Name) + tags := make(map[string]string) + for tag := range strings.SplitSeq(rawTags, ",") { + tag = strings.TrimSpace(tag) + if tag == "" { + continue + } + k, v, _ := strings.Cut(tag, "=") + tags[k] = v + } + + config := pyroscope.Config{ + ApplicationName: "geth", + ServerAddress: server, + BasicAuthUser: authUsername, + BasicAuthPassword: authPassword, + Logger: &pyroscopeLogger{Logger: log.Root()}, + Tags: tags, + ProfileTypes: []pyroscope.ProfileType{ + // Enabling all profile types + pyroscope.ProfileCPU, + pyroscope.ProfileAllocObjects, + pyroscope.ProfileAllocSpace, + pyroscope.ProfileInuseObjects, + pyroscope.ProfileInuseSpace, + pyroscope.ProfileGoroutines, + pyroscope.ProfileMutexCount, + pyroscope.ProfileMutexDuration, + pyroscope.ProfileBlockCount, + pyroscope.ProfileBlockDuration, + }, + } + + profiler, err := pyroscope.Start(config) + if err != nil { + return err + } + pyroscopeProfiler = profiler + log.Info("Enabled Pyroscope") + return nil +} + +func stopPyroscope() { + if pyroscopeProfiler != nil { + pyroscopeProfiler.Stop() + pyroscopeProfiler = nil + } +} + +// Small wrapper for log.Logger to satisfy pyroscope.Logger interface +type pyroscopeLogger struct { + Logger log.Logger +} + +func (l *pyroscopeLogger) Infof(format string, v ...any) { + l.Logger.Info(fmt.Sprintf("Pyroscope: "+format, v...)) +} + +func (l *pyroscopeLogger) Debugf(format string, v ...any) { + l.Logger.Debug(fmt.Sprintf("Pyroscope: "+format, v...)) +} + +func (l *pyroscopeLogger) Errorf(format string, v ...any) { + l.Logger.Error(fmt.Sprintf("Pyroscope: "+format, v...)) +} diff --git a/internal/download/download.go b/internal/download/download.go index 26c7795ce59f..94517166f534 100644 --- a/internal/download/download.go +++ b/internal/download/download.go @@ -22,6 +22,7 @@ import ( "bytes" "crypto/sha256" "encoding/hex" + "errors" "fmt" "io" "iter" @@ -180,12 +181,13 @@ func (db *ChecksumDB) DownloadFile(url, dstPath string) error { return fmt.Errorf("no known hash for file %q", basename) } // Shortcut if already downloaded. - if verifyHash(dstPath, hash) == nil { + if err := verifyHash(dstPath, hash); err == nil { fmt.Printf("%s is up-to-date\n", dstPath) return nil + } else if !errors.Is(err, os.ErrNotExist) { + fmt.Printf("%s is stale\n", dstPath) } - fmt.Printf("%s is stale\n", dstPath) fmt.Printf("downloading from %s\n", url) resp, err := http.Get(url) if err != nil { @@ -205,10 +207,16 @@ func (db *ChecksumDB) DownloadFile(url, dstPath string) error { if err != nil { return err } - dst := newDownloadWriter(fd, resp.ContentLength) - _, err = io.Copy(dst, resp.Body) - dst.Close() - if err != nil { + var dst io.WriteCloser = fd + if resp.ContentLength > 0 { + dst = newDownloadWriter(fd, resp.ContentLength) + } + if _, err = io.Copy(dst, resp.Body); err != nil { + dst.Close() + os.Remove(tmpfile) + return err + } + if err = dst.Close(); err != nil { os.Remove(tmpfile) return err } diff --git a/internal/era/accumulator.go b/internal/era/accumulator.go index 83a761f1fdca..72e36fe00fee 100644 --- a/internal/era/accumulator.go +++ b/internal/era/accumulator.go @@ -20,6 +20,7 @@ import ( "errors" "fmt" "math/big" + "slices" "github.com/ethereum/go-ethereum/common" ssz "github.com/ferranbt/fastssz" @@ -31,8 +32,8 @@ func ComputeAccumulator(hashes []common.Hash, tds []*big.Int) (common.Hash, erro if len(hashes) != len(tds) { return common.Hash{}, errors.New("must have equal number hashes as td values") } - if len(hashes) > MaxEra1Size { - return common.Hash{}, fmt.Errorf("too many records: have %d, max %d", len(hashes), MaxEra1Size) + if len(hashes) > MaxSize { + return common.Hash{}, fmt.Errorf("too many records: have %d, max %d", len(hashes), MaxSize) } hh := ssz.NewHasher() for i := range hashes { @@ -43,7 +44,7 @@ func ComputeAccumulator(hashes []common.Hash, tds []*big.Int) (common.Hash, erro } hh.Append(root[:]) } - hh.MerkleizeWithMixin(0, uint64(len(hashes)), uint64(MaxEra1Size)) + hh.MerkleizeWithMixin(0, uint64(len(hashes)), uint64(MaxSize)) return hh.HashRoot() } @@ -69,23 +70,15 @@ func (h *headerRecord) HashTreeRoot() ([32]byte, error) { // HashTreeRootWith ssz hashes the headerRecord object with a hasher. func (h *headerRecord) HashTreeRootWith(hh ssz.HashWalker) (err error) { hh.PutBytes(h.Hash[:]) - td := bigToBytes32(h.TotalDifficulty) + td := BigToBytes32(h.TotalDifficulty) hh.PutBytes(td[:]) hh.Merkleize(0) return } // bigToBytes32 converts a big.Int into a little-endian 32-byte array. -func bigToBytes32(n *big.Int) (b [32]byte) { +func BigToBytes32(n *big.Int) (b [32]byte) { n.FillBytes(b[:]) - reverseOrder(b[:]) + slices.Reverse(b[:]) return } - -// reverseOrder reverses the byte order of a slice. -func reverseOrder(b []byte) []byte { - for i := 0; i < 16; i++ { - b[i], b[32-i-1] = b[32-i-1], b[i] - } - return b -} diff --git a/internal/era/era.go b/internal/era/era.go index 118c67abfd7c..a3c8465bc408 100644 --- a/internal/era/era.go +++ b/internal/era/era.go @@ -1,4 +1,4 @@ -// Copyright 2024 The go-ethereum Authors +// Copyright 2025 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify @@ -17,7 +17,6 @@ package era import ( - "encoding/binary" "fmt" "io" "math/big" @@ -25,293 +24,132 @@ import ( "path" "strconv" "strings" - "sync" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/internal/era/e2store" - "github.com/ethereum/go-ethereum/rlp" - "github.com/golang/snappy" ) +// Type constants for the e2store entries in the Era1 and EraE formats. var ( - TypeVersion uint16 = 0x3265 - TypeCompressedHeader uint16 = 0x03 - TypeCompressedBody uint16 = 0x04 - TypeCompressedReceipts uint16 = 0x05 - TypeTotalDifficulty uint16 = 0x06 - TypeAccumulator uint16 = 0x07 - TypeBlockIndex uint16 = 0x3266 - - MaxEra1Size = 8192 + TypeVersion uint16 = 0x3265 + TypeCompressedHeader uint16 = 0x03 + TypeCompressedBody uint16 = 0x04 + TypeCompressedReceipts uint16 = 0x05 + TypeTotalDifficulty uint16 = 0x06 + TypeAccumulator uint16 = 0x07 + TypeCompressedSlimReceipts uint16 = 0x0a // uses eth/69 encoding + TypeProof uint16 = 0x0b + TypeBlockIndex uint16 = 0x3266 + TypeComponentIndex uint16 = 0x3267 + + MaxSize = 8192 + // headerSize uint64 = 8 ) -// Filename returns a recognizable Era1-formatted file name for the specified -// epoch and network. -func Filename(network string, epoch int, root common.Hash) string { - return fmt.Sprintf("%s-%05d-%s.era1", network, epoch, root.Hex()[2:10]) +type ReadAtSeekCloser interface { + io.ReaderAt + io.Seeker + io.Closer } -// ReadDir reads all the era1 files in a directory for a given network. -// Format: --.era1 +// Iterator provides sequential access to blocks in an era file. +type Iterator interface { + // Next advances to the next block. Returns true if a block is available, + // false when iteration is complete or an error occurred. + Next() bool + + // Number returns the block number of the current block. + Number() uint64 + + // Block returns the current block. + Block() (*types.Block, error) + + // BlockAndReceipts returns the current block and its receipts. + BlockAndReceipts() (*types.Block, types.Receipts, error) + + // Receipts returns the receipts for the current block. + Receipts() (types.Receipts, error) + + // Error returns any error encountered during iteration. + Error() error +} + +// Builder constructs era files from blocks and receipts. +// +// Builders handle three epoch types automatically: +// - Pre-merge: all blocks have difficulty > 0, TD is stored for each block +// - Transition: starts pre-merge, ends post-merge; TD stored for all blocks +// - Post-merge: all blocks have difficulty == 0, no TD stored +type Builder interface { + // Add appends a block and its receipts to the era file. + // For pre-merge blocks, td must be provided. + // For post-merge blocks, td should be nil. + Add(block *types.Block, receipts types.Receipts, td *big.Int) error + + // AddRLP appends RLP-encoded block components to the era file. + // For pre-merge blocks, td and difficulty must be provided. + // For post-merge blocks, td and difficulty should be nil. + AddRLP(header, body, receipts []byte, number uint64, hash common.Hash, td, difficulty *big.Int) error + + // Finalize writes all collected entries and returns the epoch identifier. + // For Era1 (onedb): returns the accumulator root. + // For EraE (execdb): returns the last block hash. + Finalize() (common.Hash, error) + + // Accumulator returns the accumulator root after Finalize has been called. + // Returns nil for post-merge epochs where no accumulator exists. + Accumulator() *common.Hash +} + +// Era represents the interface for reading era data. +type Era interface { + Close() error + Start() uint64 + Count() uint64 + Iterator() (Iterator, error) + GetBlockByNumber(num uint64) (*types.Block, error) + GetRawBodyByNumber(num uint64) ([]byte, error) + GetRawReceiptsByNumber(num uint64) ([]byte, error) + InitialTD() (*big.Int, error) + Accumulator() (common.Hash, error) +} + +// ReadDir reads all the era files in a directory for a given network. +// Format: --.erae or --.era1 func ReadDir(dir, network string) ([]string, error) { entries, err := os.ReadDir(dir) + if err != nil { return nil, fmt.Errorf("error reading directory %s: %w", dir, err) } var ( - next = uint64(0) - eras []string + next = uint64(0) + eras []string + dirType string ) for _, entry := range entries { - if path.Ext(entry.Name()) != ".era1" { + ext := path.Ext(entry.Name()) + if ext != ".erae" && ext != ".era1" { continue } + if dirType == "" { + dirType = ext + } parts := strings.Split(entry.Name(), "-") if len(parts) != 3 || parts[0] != network { - // Invalid era1 filename, skip. + // Invalid era filename, skip. continue } if epoch, err := strconv.ParseUint(parts[1], 10, 64); err != nil { - return nil, fmt.Errorf("malformed era1 filename: %s", entry.Name()) + return nil, fmt.Errorf("malformed era filenames: %s", entry.Name()) } else if epoch != next { return nil, fmt.Errorf("missing epoch %d", next) } + if dirType != ext { + return nil, fmt.Errorf("directory %s contains mixed era file formats: want %s, have %s", dir, dirType, ext) + } next += 1 eras = append(eras, entry.Name()) } return eras, nil } - -type ReadAtSeekCloser interface { - io.ReaderAt - io.Seeker - io.Closer -} - -// Era reads and Era1 file. -type Era struct { - f ReadAtSeekCloser // backing era1 file - s *e2store.Reader // e2store reader over f - m metadata // start, count, length info - mu *sync.Mutex // lock for buf - buf [8]byte // buffer reading entry offsets -} - -// From returns an Era backed by f. -func From(f ReadAtSeekCloser) (*Era, error) { - m, err := readMetadata(f) - if err != nil { - return nil, err - } - return &Era{ - f: f, - s: e2store.NewReader(f), - m: m, - mu: new(sync.Mutex), - }, nil -} - -// Open returns an Era backed by the given filename. -func Open(filename string) (*Era, error) { - f, err := os.Open(filename) - if err != nil { - return nil, err - } - return From(f) -} - -func (e *Era) Close() error { - return e.f.Close() -} - -// GetBlockByNumber returns the block for the given block number. -func (e *Era) GetBlockByNumber(num uint64) (*types.Block, error) { - if e.m.start > num || e.m.start+e.m.count <= num { - return nil, fmt.Errorf("out-of-bounds: %d not in [%d, %d)", num, e.m.start, e.m.start+e.m.count) - } - off, err := e.readOffset(num) - if err != nil { - return nil, err - } - r, n, err := newSnappyReader(e.s, TypeCompressedHeader, off) - if err != nil { - return nil, err - } - var header types.Header - if err := rlp.Decode(r, &header); err != nil { - return nil, err - } - off += n - r, _, err = newSnappyReader(e.s, TypeCompressedBody, off) - if err != nil { - return nil, err - } - var body types.Body - if err := rlp.Decode(r, &body); err != nil { - return nil, err - } - return types.NewBlockWithHeader(&header).WithBody(body), nil -} - -// GetRawBodyByNumber returns the RLP-encoded body for the given block number. -func (e *Era) GetRawBodyByNumber(num uint64) ([]byte, error) { - if e.m.start > num || e.m.start+e.m.count <= num { - return nil, fmt.Errorf("out-of-bounds: %d not in [%d, %d)", num, e.m.start, e.m.start+e.m.count) - } - off, err := e.readOffset(num) - if err != nil { - return nil, err - } - off, err = e.s.SkipN(off, 1) - if err != nil { - return nil, err - } - r, _, err := newSnappyReader(e.s, TypeCompressedBody, off) - if err != nil { - return nil, err - } - return io.ReadAll(r) -} - -// GetRawReceiptsByNumber returns the RLP-encoded receipts for the given block number. -func (e *Era) GetRawReceiptsByNumber(num uint64) ([]byte, error) { - if e.m.start > num || e.m.start+e.m.count <= num { - return nil, fmt.Errorf("out-of-bounds: %d not in [%d, %d)", num, e.m.start, e.m.start+e.m.count) - } - off, err := e.readOffset(num) - if err != nil { - return nil, err - } - - // Skip over header and body. - off, err = e.s.SkipN(off, 2) - if err != nil { - return nil, err - } - - r, _, err := newSnappyReader(e.s, TypeCompressedReceipts, off) - if err != nil { - return nil, err - } - return io.ReadAll(r) -} - -// Accumulator reads the accumulator entry in the Era1 file. -func (e *Era) Accumulator() (common.Hash, error) { - entry, err := e.s.Find(TypeAccumulator) - if err != nil { - return common.Hash{}, err - } - return common.BytesToHash(entry.Value), nil -} - -// InitialTD returns initial total difficulty before the difficulty of the -// first block of the Era1 is applied. -func (e *Era) InitialTD() (*big.Int, error) { - var ( - r io.Reader - header types.Header - rawTd []byte - n int64 - off int64 - err error - ) - - // Read first header. - if off, err = e.readOffset(e.m.start); err != nil { - return nil, err - } - if r, n, err = newSnappyReader(e.s, TypeCompressedHeader, off); err != nil { - return nil, err - } - if err := rlp.Decode(r, &header); err != nil { - return nil, err - } - off += n - - // Skip over header and body. - off, err = e.s.SkipN(off, 2) - if err != nil { - return nil, err - } - - // Read total difficulty after first block. - if r, _, err = e.s.ReaderAt(TypeTotalDifficulty, off); err != nil { - return nil, err - } - rawTd, err = io.ReadAll(r) - if err != nil { - return nil, err - } - td := new(big.Int).SetBytes(reverseOrder(rawTd)) - return td.Sub(td, header.Difficulty), nil -} - -// Start returns the listed start block. -func (e *Era) Start() uint64 { - return e.m.start -} - -// Count returns the total number of blocks in the Era1. -func (e *Era) Count() uint64 { - return e.m.count -} - -// readOffset reads a specific block's offset from the block index. The value n -// is the absolute block number desired. -func (e *Era) readOffset(n uint64) (int64, error) { - var ( - blockIndexRecordOffset = e.m.length - 24 - int64(e.m.count)*8 // skips start, count, and header - firstIndex = blockIndexRecordOffset + 16 // first index after header / start-num - indexOffset = int64(n-e.m.start) * 8 // desired index * size of indexes - offOffset = firstIndex + indexOffset // offset of block offset - ) - e.mu.Lock() - defer e.mu.Unlock() - clear(e.buf[:]) - if _, err := e.f.ReadAt(e.buf[:], offOffset); err != nil { - return 0, err - } - // Since the block offset is relative from the start of the block index record - // we need to add the record offset to it's offset to get the block's absolute - // offset. - return blockIndexRecordOffset + int64(binary.LittleEndian.Uint64(e.buf[:])), nil -} - -// newSnappyReader returns a snappy.Reader for the e2store entry value at off. -func newSnappyReader(e *e2store.Reader, expectedType uint16, off int64) (io.Reader, int64, error) { - r, n, err := e.ReaderAt(expectedType, off) - if err != nil { - return nil, 0, err - } - return snappy.NewReader(r), int64(n), err -} - -// metadata wraps the metadata in the block index. -type metadata struct { - start uint64 - count uint64 - length int64 -} - -// readMetadata reads the metadata stored in an Era1 file's block index. -func readMetadata(f ReadAtSeekCloser) (m metadata, err error) { - // Determine length of reader. - if m.length, err = f.Seek(0, io.SeekEnd); err != nil { - return - } - b := make([]byte, 16) - // Read count. It's the last 8 bytes of the file. - if _, err = f.ReadAt(b[:8], m.length-8); err != nil { - return - } - m.count = binary.LittleEndian.Uint64(b) - // Read start. It's at the offset -sizeof(m.count) - - // count*sizeof(indexEntry) - sizeof(m.start) - if _, err = f.ReadAt(b[8:], m.length-16-int64(m.count*8)); err != nil { - return - } - m.start = binary.LittleEndian.Uint64(b[8:]) - return -} diff --git a/internal/era/eradl/eradl.go b/internal/era/eradl/eradl.go index 30bd2bc0d543..375b9ad15bc1 100644 --- a/internal/era/eradl/eradl.go +++ b/internal/era/eradl/eradl.go @@ -86,8 +86,8 @@ func (l *Loader) DownloadAll(destDir string) error { // DownloadBlockRange fetches the era1 files for the given block range. func (l *Loader) DownloadBlockRange(start, end uint64, destDir string) error { - startEpoch := start / uint64(era.MaxEra1Size) - endEpoch := end / uint64(era.MaxEra1Size) + startEpoch := start / uint64(era.MaxSize) + endEpoch := end / uint64(era.MaxSize) return l.DownloadEpochRange(startEpoch, endEpoch, destDir) } diff --git a/internal/era/execdb/builder.go b/internal/era/execdb/builder.go new file mode 100644 index 000000000000..6246b9caae46 --- /dev/null +++ b/internal/era/execdb/builder.go @@ -0,0 +1,332 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package execdb + +// EraE file format specification. +// +// The format can be summarized with the following expression: +// +// eraE := Version | CompressedHeader* | CompressedBody* | CompressedSlimReceipts* | TotalDifficulty* | other-entries* | Accumulator? | ComponentIndex +// +// Each basic element is its own e2store entry: +// +// Version = { type: 0x3265, data: nil } +// CompressedHeader = { type: 0x03, data: snappyFramed(rlp(header)) } +// CompressedBody = { type: 0x04, data: snappyFramed(rlp(body)) } +// CompressedSlimReceipts = { type: 0x0a, data: snappyFramed(rlp([tx-type, post-state-or-status, cumulative-gas, logs])) } +// TotalDifficulty = { type: 0x06, data: uint256 (header.total_difficulty) } +// AccumulatorRoot = { type: 0x07, data: hash_tree_root(List(HeaderRecord, 8192)) } +// ComponentIndex = { type: 0x3267, data: component-index } +// +// Notes: +// - TotalDifficulty is present for pre-merge and merge transition epochs. +// For pure post-merge epochs, TotalDifficulty is omitted entirely. +// - In merge transition epochs, post-merge blocks store the final total +// difficulty (the TD at which the merge occurred). +// - AccumulatorRoot is only written for pre-merge epochs. +// - HeaderRecord is defined in the Portal Network specification. +// - Proofs (type 0x09) are defined in the spec but not yet supported in this implementation. +// +// ComponentIndex stores relative offsets to each block's components: +// +// component-index := starting-number | indexes | indexes | ... | component-count | count +// indexes := header-offset | body-offset | receipts-offset | td-offset? +// +// All values are little-endian uint64. +// +// Due to the accumulator size limit of 8192, the maximum number of blocks in an +// EraE file is also 8192. + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "io" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/e2store" + "github.com/ethereum/go-ethereum/rlp" + "github.com/golang/snappy" +) + +// Builder is used to build an EraE e2store file. It collects block entries and +// writes them to the underlying e2store.Writer. +type Builder struct { + w *e2store.Writer + + headers [][]byte + hashes []common.Hash // only pre-merge block hashes, for accumulator + bodies [][]byte + receipts [][]byte + tds []*big.Int + + startNum *uint64 + ttd *big.Int // terminal total difficulty + last common.Hash // hash of last block added + accumulator *common.Hash // accumulator root, set by Finalize (nil for post-merge) + + written uint64 + + buf *bytes.Buffer + snappy *snappy.Writer +} + +// NewBuilder returns a new Builder instance. +func NewBuilder(w io.Writer) era.Builder { + return &Builder{ + w: e2store.NewWriter(w), + } +} + +// Add writes a block entry and its receipts into the e2store file. +func (b *Builder) Add(block *types.Block, receipts types.Receipts, td *big.Int) error { + eh, err := rlp.EncodeToBytes(block.Header()) + if err != nil { + return fmt.Errorf("encode header: %w", err) + } + eb, err := rlp.EncodeToBytes(block.Body()) + if err != nil { + return fmt.Errorf("encode body: %w", err) + } + + rs := make([]*types.SlimReceipt, len(receipts)) + for i, receipt := range receipts { + rs[i] = (*types.SlimReceipt)(receipt) + } + er, err := rlp.EncodeToBytes(rs) + if err != nil { + return fmt.Errorf("encode receipts: %w", err) + } + + return b.AddRLP(eh, eb, er, block.Number().Uint64(), block.Hash(), td, block.Difficulty()) +} + +// AddRLP takes the RLP encoded block components and writes them to the underlying e2store file. +// The builder automatically handles transition epochs where both pre and post-merge blocks exist. +func (b *Builder) AddRLP(header, body, receipts []byte, number uint64, blockHash common.Hash, td, difficulty *big.Int) error { + if len(b.headers) >= era.MaxSize { + return fmt.Errorf("exceeds max size %d", era.MaxSize) + } + // Set starting block number on first add. + if b.startNum == nil { + b.startNum = new(uint64) + *b.startNum = number + } + + if difficulty == nil { + return fmt.Errorf("invalid block: difficulty is nil") + } + hasDifficulty := difficulty.Sign() > 0 + // Expect td to be nil for post-merge blocks + // and non-nil for pre-merge blocks. + if hasDifficulty != (td != nil) { + return fmt.Errorf("TD and difficulty mismatch: expected both nil or both non-nil") + } + // After the merge, difficulty must be nil. + post := (b.tds == nil && len(b.headers) > 0) || b.ttd != nil + if post && hasDifficulty { + return fmt.Errorf("post-merge epoch: cannot accept total difficulty for block %d", number) + } + + // If this marks the start of the transition, record final total + // difficulty value. + if b.ttd == nil && len(b.tds) > 0 && !hasDifficulty { + b.ttd = new(big.Int).Set(b.tds[len(b.tds)-1]) + } + + // Record block data. + b.headers = append(b.headers, header) + b.bodies = append(b.bodies, body) + b.receipts = append(b.receipts, receipts) + b.last = blockHash + + // Conditionally write the total difficulty and block hashes. + // - Pre-merge: store total difficulty and block hashes. + // - Transition: only store total difficulty. + // - Post-merge: store neither. + if hasDifficulty { + b.hashes = append(b.hashes, blockHash) + b.tds = append(b.tds, new(big.Int).Set(td)) + } else if b.ttd != nil { + b.tds = append(b.tds, new(big.Int).Set(b.ttd)) + } else { + // Post-merge: no TD or block hashes stored. + } + + return nil +} + +// Accumulator returns the accumulator root after Finalize has been called. +// Returns nil for post-merge epochs where no accumulator exists. +func (b *Builder) Accumulator() *common.Hash { + return b.accumulator +} + +type offsets struct { + headers []uint64 + bodies []uint64 + receipts []uint64 + tds []uint64 +} + +// Finalize writes all collected block entries to the e2store file. +// For pre-merge or transition epochs, the accumulator root is computed over +// pre-merge blocks and written. For pure post-merge epochs, no accumulator +// is written. Always returns the last block hash as the epoch identifier. +func (b *Builder) Finalize() (common.Hash, error) { + if b.startNum == nil { + return common.Hash{}, errors.New("no blocks added, cannot finalize") + } + // Write version before writing any blocks. + if n, err := b.w.Write(era.TypeVersion, nil); err != nil { + return common.Hash{}, fmt.Errorf("write version entry: %w", err) + } else { + b.written += uint64(n) + } + + // Convert TD values to byte-level LE representation. + var tds [][]byte + for _, td := range b.tds { + tds = append(tds, uint256LE(td)) + } + + // Create snappy writer. + b.buf = bytes.NewBuffer(nil) + b.snappy = snappy.NewBufferedWriter(b.buf) + + var o offsets + for _, section := range []struct { + typ uint16 + data [][]byte + compressed bool + offsets *[]uint64 + }{ + {era.TypeCompressedHeader, b.headers, true, &o.headers}, + {era.TypeCompressedBody, b.bodies, true, &o.bodies}, + {era.TypeCompressedSlimReceipts, b.receipts, true, &o.receipts}, + {era.TypeTotalDifficulty, tds, false, &o.tds}, + } { + for _, data := range section.data { + *section.offsets = append(*section.offsets, b.written) + if section.compressed { + // Write snappy compressed data. + if err := b.snappyWrite(section.typ, data); err != nil { + return common.Hash{}, err + } + } else { + // Directly write uncompressed data. + n, err := b.w.Write(section.typ, data) + if err != nil { + return common.Hash{}, err + } + b.written += uint64(n) + } + } + } + + // Compute and write accumulator root only for epochs that started pre-merge. + // The accumulator is computed over only the pre-merge blocks (b.hashes). + // Pure post-merge epochs have no accumulator. + if len(b.tds) > 0 { + accRoot, err := era.ComputeAccumulator(b.hashes, b.tds[:len(b.hashes)]) + if err != nil { + return common.Hash{}, fmt.Errorf("compute accumulator: %w", err) + } + if n, err := b.w.Write(era.TypeAccumulator, accRoot[:]); err != nil { + return common.Hash{}, fmt.Errorf("write accumulator: %w", err) + } else { + b.written += uint64(n) + } + b.accumulator = &accRoot + if err := b.writeIndex(&o); err != nil { + return common.Hash{}, err + } + return b.last, nil + } + + // Pure post-merge epoch: no accumulator. + if err := b.writeIndex(&o); err != nil { + return common.Hash{}, err + } + return b.last, nil +} + +// uin256LE writes 32 byte big integers to little endian. +func uint256LE(v *big.Int) []byte { + b := v.FillBytes(make([]byte, 32)) + for i := 0; i < 16; i++ { + b[i], b[31-i] = b[31-i], b[i] + } + return b +} + +// SnappyWrite compresses the input data using snappy and writes it to the e2store file. +func (b *Builder) snappyWrite(typ uint16, in []byte) error { + b.buf.Reset() + b.snappy.Reset(b.buf) + if _, err := b.snappy.Write(in); err != nil { + return fmt.Errorf("error snappy encoding: %w", err) + } + if err := b.snappy.Flush(); err != nil { + return fmt.Errorf("error flushing snappy encoding: %w", err) + } + n, err := b.w.Write(typ, b.buf.Bytes()) + b.written += uint64(n) + if err != nil { + return fmt.Errorf("error writing e2store entry: %w", err) + } + return nil +} + +// writeIndex writes the component index to the file. +func (b *Builder) writeIndex(o *offsets) error { + count := len(o.headers) + + // Post-merge, we only index headers, bodies, and receipts. Pre-merge, we also + // need to index the total difficulties. + componentCount := 3 + if len(o.tds) > 0 { + componentCount++ + } + + // Offsets are stored relative to the index position (negative, stored as uint64). + base := int64(b.written) + rel := func(abs uint64) uint64 { return uint64(int64(abs) - base) } + + var buf bytes.Buffer + write := func(v uint64) { binary.Write(&buf, binary.LittleEndian, v) } + + write(*b.startNum) + for i := range o.headers { + write(rel(o.headers[i])) + write(rel(o.bodies[i])) + write(rel(o.receipts[i])) + if len(o.tds) > 0 { + write(rel(o.tds[i])) + } + } + write(uint64(componentCount)) + write(uint64(count)) + + n, err := b.w.Write(era.TypeComponentIndex, buf.Bytes()) + b.written += uint64(n) + return err +} diff --git a/internal/era/execdb/era_test.go b/internal/era/execdb/era_test.go new file mode 100644 index 000000000000..f66931b9ed36 --- /dev/null +++ b/internal/era/execdb/era_test.go @@ -0,0 +1,348 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package execdb + +import ( + "bytes" + "fmt" + "io" + "math/big" + "os" + "slices" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" +) + +func TestEraE(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + start uint64 + preMerge int + postMerge int + accumulator bool // whether accumulator should exist + }{ + { + name: "pre-merge", + start: 0, + preMerge: 128, + postMerge: 0, + accumulator: true, + }, + { + name: "post-merge", + start: 0, + preMerge: 0, + postMerge: 64, + accumulator: false, + }, + { + name: "transition", + start: 0, + preMerge: 32, + postMerge: 32, + accumulator: true, + }, + { + name: "non-zero-start", + start: 8192, + preMerge: 64, + postMerge: 0, + accumulator: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + f, err := os.CreateTemp(t.TempDir(), "erae-test") + if err != nil { + t.Fatalf("error creating temp file: %v", err) + } + defer f.Close() + + // Build test data. + type blockData struct { + header, body, receipts []byte + hash common.Hash + td *big.Int + difficulty *big.Int + } + var ( + builder = NewBuilder(f) + blocks []blockData + totalBlocks = tt.preMerge + tt.postMerge + finalTD = big.NewInt(int64(tt.preMerge)) + ) + + // Add pre-merge blocks. + for i := 0; i < tt.preMerge; i++ { + num := tt.start + uint64(i) + blk := blockData{ + header: mustEncode(&types.Header{Number: big.NewInt(int64(num)), Difficulty: big.NewInt(1)}), + body: mustEncode(&types.Body{Transactions: []*types.Transaction{types.NewTransaction(0, common.Address{byte(i)}, nil, 0, nil, nil)}}), + receipts: mustEncode([]types.SlimReceipt{{CumulativeGasUsed: uint64(i)}}), + hash: common.Hash{byte(i)}, + td: big.NewInt(int64(i + 1)), + difficulty: big.NewInt(1), + } + blocks = append(blocks, blk) + if err := builder.AddRLP(blk.header, blk.body, blk.receipts, num, blk.hash, blk.td, blk.difficulty); err != nil { + t.Fatalf("error adding pre-merge block %d: %v", i, err) + } + } + + // Add post-merge blocks. + for i := 0; i < tt.postMerge; i++ { + idx := tt.preMerge + i + num := tt.start + uint64(idx) + blk := blockData{ + header: mustEncode(&types.Header{Number: big.NewInt(int64(num)), Difficulty: big.NewInt(0)}), + body: mustEncode(&types.Body{}), + receipts: mustEncode([]types.SlimReceipt{}), + hash: common.Hash{byte(idx)}, + difficulty: big.NewInt(0), + } + blocks = append(blocks, blk) + if err := builder.AddRLP(blk.header, blk.body, blk.receipts, num, blk.hash, nil, big.NewInt(0)); err != nil { + t.Fatalf("error adding post-merge block %d: %v", idx, err) + } + } + + // Finalize and check return values. + epochID, err := builder.Finalize() + if err != nil { + t.Fatalf("error finalizing: %v", err) + } + + // Verify epoch ID is always the last block hash. + expectedLastHash := blocks[len(blocks)-1].hash + if epochID != expectedLastHash { + t.Fatalf("wrong epoch ID: want %s, got %s", expectedLastHash.Hex(), epochID.Hex()) + } + + // Verify accumulator presence. + if tt.accumulator { + if builder.Accumulator() == nil { + t.Fatal("expected non-nil accumulator") + } + } else { + if builder.Accumulator() != nil { + t.Fatalf("expected nil accumulator, got %s", builder.Accumulator().Hex()) + } + } + + // Open and verify the era file. + e, err := Open(f.Name()) + if err != nil { + t.Fatalf("failed to open era: %v", err) + } + defer e.Close() + + // Verify metadata. + if e.Start() != tt.start { + t.Fatalf("wrong start block: want %d, got %d", tt.start, e.Start()) + } + if e.Count() != uint64(totalBlocks) { + t.Fatalf("wrong block count: want %d, got %d", totalBlocks, e.Count()) + } + + // Verify accumulator in file. + if tt.accumulator { + accRoot, err := e.Accumulator() + if err != nil { + t.Fatalf("error getting accumulator: %v", err) + } + if accRoot != *builder.Accumulator() { + t.Fatalf("accumulator mismatch: builder has %s, file contains %s", + builder.Accumulator().Hex(), accRoot.Hex()) + } + } else { + if _, err := e.Accumulator(); err == nil { + t.Fatal("expected error when reading accumulator from post-merge epoch") + } + } + + // Verify blocks via raw iterator. + it, err := NewRawIterator(e) + if err != nil { + t.Fatalf("failed to make iterator: %v", err) + } + for i := 0; i < totalBlocks; i++ { + if !it.Next() { + t.Fatalf("expected more entries at %d", i) + } + if it.Error() != nil { + t.Fatalf("unexpected error: %v", it.Error()) + } + + // Check header. + rawHeader, err := io.ReadAll(it.Header) + if err != nil { + t.Fatalf("error reading header: %v", err) + } + if !bytes.Equal(rawHeader, blocks[i].header) { + t.Fatalf("mismatched header at %d", i) + } + + // Check body. + rawBody, err := io.ReadAll(it.Body) + if err != nil { + t.Fatalf("error reading body: %v", err) + } + if !bytes.Equal(rawBody, blocks[i].body) { + t.Fatalf("mismatched body at %d", i) + } + + // Check receipts. + rawReceipts, err := io.ReadAll(it.Receipts) + if err != nil { + t.Fatalf("error reading receipts: %v", err) + } + if !bytes.Equal(rawReceipts, blocks[i].receipts) { + t.Fatalf("mismatched receipts at %d", i) + } + + // Check TD (only for epochs that have TD stored). + if tt.preMerge > 0 && it.TotalDifficulty != nil { + rawTd, err := io.ReadAll(it.TotalDifficulty) + if err != nil { + t.Fatalf("error reading TD: %v", err) + } + slices.Reverse(rawTd) + td := new(big.Int).SetBytes(rawTd) + var expectedTD *big.Int + if i < tt.preMerge { + expectedTD = blocks[i].td + } else { + // Post-merge blocks in transition epoch use final TD. + expectedTD = finalTD + } + if td.Cmp(expectedTD) != 0 { + t.Fatalf("mismatched TD at %d: want %s, got %s", i, expectedTD, td) + } + } + } + + // Verify random access. + for _, blockNum := range []uint64{tt.start, tt.start + uint64(totalBlocks) - 1} { + blk, err := e.GetBlockByNumber(blockNum) + if err != nil { + t.Fatalf("error getting block %d: %v", blockNum, err) + } + if blk.Number().Uint64() != blockNum { + t.Fatalf("wrong block number: want %d, got %d", blockNum, blk.Number().Uint64()) + } + } + + // Verify out-of-range access fails. + if _, err := e.GetBlockByNumber(tt.start + uint64(totalBlocks)); err == nil { + t.Fatal("expected error for out-of-range block") + } + if tt.start > 0 { + if _, err := e.GetBlockByNumber(tt.start - 1); err == nil { + t.Fatal("expected error for block before start") + } + } + + // Verify high-level iterator. + hlIt, err := e.Iterator() + if err != nil { + t.Fatalf("failed to create iterator: %v", err) + } + count := 0 + for hlIt.Next() { + blk, err := hlIt.Block() + if err != nil { + t.Fatalf("error getting block: %v", err) + } + if blk.Number().Uint64() != tt.start+uint64(count) { + t.Fatalf("wrong block number: want %d, got %d", tt.start+uint64(count), blk.Number().Uint64()) + } + count++ + } + if hlIt.Error() != nil { + t.Fatalf("iterator error: %v", hlIt.Error()) + } + if count != totalBlocks { + t.Fatalf("wrong iteration count: want %d, got %d", totalBlocks, count) + } + }) + } +} + +// TestInitialTD tests the InitialTD calculation separately since it requires +// specific TD/difficulty values. +func TestInitialTD(t *testing.T) { + t.Parallel() + + f, err := os.CreateTemp(t.TempDir(), "erae-initial-td-test") + if err != nil { + t.Fatalf("error creating temp file: %v", err) + } + defer f.Close() + + builder := NewBuilder(f) + + // First block: difficulty=5, TD=10, so initial TD = 10-5 = 5. + header := mustEncode(&types.Header{Number: big.NewInt(0), Difficulty: big.NewInt(5)}) + body := mustEncode(&types.Body{}) + receipts := mustEncode([]types.SlimReceipt{}) + + if err := builder.AddRLP(header, body, receipts, 0, common.Hash{0}, big.NewInt(10), big.NewInt(5)); err != nil { + t.Fatalf("error adding block: %v", err) + } + + // Second block: difficulty=3, TD=13. + header2 := mustEncode(&types.Header{Number: big.NewInt(1), Difficulty: big.NewInt(3)}) + if err := builder.AddRLP(header2, body, receipts, 1, common.Hash{1}, big.NewInt(13), big.NewInt(3)); err != nil { + t.Fatalf("error adding block: %v", err) + } + + if _, err := builder.Finalize(); err != nil { + t.Fatalf("error finalizing: %v", err) + } + + e, err := Open(f.Name()) + if err != nil { + t.Fatalf("failed to open era: %v", err) + } + defer e.Close() + + initialTD, err := e.InitialTD() + if err != nil { + t.Fatalf("error getting initial TD: %v", err) + } + + // Initial TD should be TD[0] - Difficulty[0] = 10 - 5 = 5. + if initialTD.Cmp(big.NewInt(5)) != 0 { + t.Fatalf("wrong initial TD: want 5, got %s", initialTD) + } +} + +func mustEncode(obj any) []byte { + b, err := rlp.EncodeToBytes(obj) + if err != nil { + panic(fmt.Sprintf("failed to encode obj: %v", err)) + } + return b +} diff --git a/internal/era/execdb/iterator.go b/internal/era/execdb/iterator.go new file mode 100644 index 000000000000..8d17ac00a9f9 --- /dev/null +++ b/internal/era/execdb/iterator.go @@ -0,0 +1,240 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package execdb + +import ( + "errors" + "io" + "math/big" + "slices" + + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/e2store" + "github.com/ethereum/go-ethereum/rlp" + "github.com/klauspost/compress/snappy" +) + +type Iterator struct { + inner *RawIterator + block *types.Block // cache for decoded block +} + +// NewIterator returns a header/body/receipt iterator over the archive. +// Call Next immediately to position on the first block. +func NewIterator(e era.Era) (era.Iterator, error) { + inner, err := NewRawIterator(e.(*Era)) + if err != nil { + return nil, err + } + return &Iterator{inner: inner}, nil +} + +// Next advances to the next block entry. +func (it *Iterator) Next() bool { + it.block = nil + return it.inner.Next() +} + +// Number is the number of the block currently loaded. +func (it *Iterator) Number() uint64 { return it.inner.next - 1 } + +// Error returns any iteration error (EOF is reported as nil, identical +// to the Era‑1 iterator behaviour). +func (it *Iterator) Error() error { return it.inner.Error() } + +// Block decodes the current header+body into a *types.Block. +func (it *Iterator) Block() (*types.Block, error) { + if it.block != nil { + return it.block, nil + } + if it.inner.Header == nil || it.inner.Body == nil { + return nil, errors.New("header and body must be non‑nil") + } + var ( + h types.Header + b types.Body + ) + if err := rlp.Decode(it.inner.Header, &h); err != nil { + return nil, err + } + if err := rlp.Decode(it.inner.Body, &b); err != nil { + return nil, err + } + it.block = types.NewBlockWithHeader(&h).WithBody(b) + return it.block, nil +} + +// Receipts decodes receipts for the current block. +func (it *Iterator) Receipts() (types.Receipts, error) { + block, err := it.Block() + if err != nil { + return nil, err + } + if it.inner.Receipts == nil { + return nil, errors.New("receipts must be non‑nil") + } + var rs []*types.SlimReceipt + if err := rlp.Decode(it.inner.Receipts, &rs); err != nil { + return nil, err + } + if len(rs) != len(block.Transactions()) { + return nil, errors.New("number of txs does not match receipts") + } + receipts := make([]*types.Receipt, len(rs)) + for i, receipt := range rs { + receipts[i] = (*types.Receipt)(receipt) + receipts[i].Bloom = types.CreateBloom(receipts[i]) + } + return receipts, nil +} + +// BlockAndReceipts is a convenience wrapper. +func (it *Iterator) BlockAndReceipts() (*types.Block, types.Receipts, error) { + b, err := it.Block() + if err != nil { + return nil, nil, err + } + r, err := it.Receipts() + if err != nil { + return nil, nil, err + } + return b, r, nil +} + +// TotalDifficulty returns the TD at the current position (if present). +func (it *Iterator) TotalDifficulty() (*big.Int, error) { + if it.inner.TotalDifficulty == nil { + return nil, errors.New("total‑difficulty stream is nil") + } + tdBytes, err := io.ReadAll(it.inner.TotalDifficulty) + if err != nil { + return nil, err + } + slices.Reverse(tdBytes) + return new(big.Int).SetBytes(tdBytes), nil +} + +// ----------------------------------------------------------------------------- +// Low‑level iterator (raw TLV/offset handling, no decoding) +// ----------------------------------------------------------------------------- + +type RawIterator struct { + e *Era + next uint64 // next block to pull + err error + + Header io.Reader + Body io.Reader + Receipts io.Reader + TotalDifficulty io.Reader // nil when archive omits TD +} + +// NewRawIterator creates an iterator positioned *before* the first block. +func NewRawIterator(e *Era) (*RawIterator, error) { + return &RawIterator{e: e, next: e.m.start}, nil +} + +// Next loads the next block’s components; returns false on EOF or error. +func (it *RawIterator) Next() bool { + it.err = nil // clear previous error + + if it.next >= it.e.m.start+it.e.m.count { + it.clear() + return false + } + + headerOffset, err := it.e.headerOff(it.next) + if err != nil { + it.setErr(err) + return false + } + it.Header, _, err = newSnappyReader(it.e.s, era.TypeCompressedHeader, headerOffset) + if err != nil { + it.setErr(err) + return false + } + + bodyOffset, err := it.e.bodyOff(it.next) + if err != nil { + it.setErr(err) + return false + } + it.Body, _, err = newSnappyReader(it.e.s, era.TypeCompressedBody, bodyOffset) + if err != nil { + it.setErr(err) + return false + } + + receiptsOffset, err := it.e.receiptOff(it.next) + if err != nil { + it.setErr(err) + return false + } + it.Receipts, _, err = newSnappyReader(it.e.s, era.TypeCompressedSlimReceipts, receiptsOffset) + if err != nil { + it.setErr(err) + return false + } + + // Check if TD component is present in this file (pre-merge or merge-transition epoch). + if int(td) < int(it.e.m.components) { + tdOffset, err := it.e.tdOff(it.next) + if err != nil { + it.setErr(err) + return false + } + it.TotalDifficulty, _, err = it.e.s.ReaderAt(era.TypeTotalDifficulty, tdOffset) + if err != nil { + it.setErr(err) + return false + } + } else { + it.TotalDifficulty = nil + } + + it.next++ + return true +} + +func (it *RawIterator) Number() uint64 { return it.next - 1 } + +func (it *RawIterator) Error() error { + if it.err == io.EOF { + return nil + } + return it.err +} + +func (it *RawIterator) setErr(err error) { + it.err = err + it.clear() +} + +func (it *RawIterator) clear() { + it.Header, it.Body, it.Receipts, it.TotalDifficulty = nil, nil, nil, nil +} + +// newSnappyReader behaves like era.newSnappyReader: returns a snappy.Reader +// plus the length of the underlying TLV payload so callers can advance offsets. +func newSnappyReader(r *e2store.Reader, typ uint16, off int64) (io.Reader, int64, error) { + raw, n, err := r.ReaderAt(typ, off) + if err != nil { + return nil, 0, err + } + return snappy.NewReader(raw), int64(n), nil +} diff --git a/internal/era/execdb/reader.go b/internal/era/execdb/reader.go new file mode 100644 index 000000000000..d0aaad174854 --- /dev/null +++ b/internal/era/execdb/reader.go @@ -0,0 +1,296 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package execdb + +import ( + "encoding/binary" + "fmt" + "io" + "math/big" + "os" + "slices" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/e2store" + "github.com/ethereum/go-ethereum/rlp" + "github.com/klauspost/compress/snappy" +) + +// Era object represents an era file that contains blocks and their components. +type Era struct { + f era.ReadAtSeekCloser + s *e2store.Reader + m metadata // metadata for the Era file +} + +// Filename returns a recognizable filename for an EraE file. +// The filename uses the last block hash to uniquely identify the epoch's content. +func Filename(network string, epoch int, lastBlockHash common.Hash) string { + return fmt.Sprintf("%s-%05d-%s.erae", network, epoch, lastBlockHash.Hex()[2:10]) +} + +// Open accesses the era file. +func Open(path string) (*Era, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + e := &Era{f: f, s: e2store.NewReader(f)} + if err := e.loadIndex(); err != nil { + f.Close() + return nil, err + } + return e, nil +} + +// Close closes the era file safely. +func (e *Era) Close() error { + if e.f == nil { + return nil + } + err := e.f.Close() + e.f = nil + return err +} + +// From returns an Era backed by f. +func From(f era.ReadAtSeekCloser) (era.Era, error) { + e := &Era{f: f, s: e2store.NewReader(f)} + if err := e.loadIndex(); err != nil { + f.Close() + return nil, err + } + return e, nil +} + +// Start retrieves the starting block number. +func (e *Era) Start() uint64 { + return e.m.start +} + +// Count retrieves the count of blocks present. +func (e *Era) Count() uint64 { + return e.m.count +} + +// Iterator returns an iterator over the era file. +func (e *Era) Iterator() (era.Iterator, error) { + return NewIterator(e) +} + +// GetBlockByNumber retrieves the block if present within the era file. +func (e *Era) GetBlockByNumber(blockNum uint64) (*types.Block, error) { + h, err := e.GetHeader(blockNum) + if err != nil { + return nil, err + } + b, err := e.GetBody(blockNum) + if err != nil { + return nil, err + } + return types.NewBlockWithHeader(h).WithBody(*b), nil +} + +// GetHeader retrieves the header from the era file through the cached offset table. +func (e *Era) GetHeader(num uint64) (*types.Header, error) { + off, err := e.headerOff(num) + if err != nil { + return nil, err + } + + r, _, err := e.s.ReaderAt(era.TypeCompressedHeader, off) + if err != nil { + return nil, err + } + + r = snappy.NewReader(r) + var h types.Header + return &h, rlp.Decode(r, &h) +} + +// GetBody retrieves the body from the era file through cached offset table. +func (e *Era) GetBody(num uint64) (*types.Body, error) { + off, err := e.bodyOff(num) + if err != nil { + return nil, err + } + + r, _, err := e.s.ReaderAt(era.TypeCompressedBody, off) + if err != nil { + return nil, err + } + + r = snappy.NewReader(r) + var b types.Body + return &b, rlp.Decode(r, &b) +} + +// GetTD retrieves the td from the era file through cached offset table. +func (e *Era) GetTD(blockNum uint64) (*big.Int, error) { + off, err := e.tdOff(blockNum) + if err != nil { + return nil, err + } + r, _, err := e.s.ReaderAt(era.TypeTotalDifficulty, off) + if err != nil { + return nil, err + } + buf, _ := io.ReadAll(r) + slices.Reverse(buf) + td := new(big.Int).SetBytes(buf) + return td, nil +} + +// GetRawBodyByNumber returns the RLP-encoded body for the given block number. +func (e *Era) GetRawBodyByNumber(blockNum uint64) ([]byte, error) { + off, err := e.bodyOff(blockNum) + if err != nil { + return nil, err + } + r, _, err := e.s.ReaderAt(era.TypeCompressedBody, off) + if err != nil { + return nil, err + } + r = snappy.NewReader(r) + return io.ReadAll(r) +} + +// GetRawReceiptsByNumber returns the RLP-encoded receipts for the given block number. +func (e *Era) GetRawReceiptsByNumber(blockNum uint64) ([]byte, error) { + off, err := e.receiptOff(blockNum) + if err != nil { + return nil, err + } + r, _, err := e.s.ReaderAt(era.TypeCompressedSlimReceipts, off) + if err != nil { + return nil, err + } + r = snappy.NewReader(r) + return io.ReadAll(r) +} + +// InitialTD returns initial total difficulty before the difficulty of the +// first block of the Era is applied. Returns an error if TD is not available +// (e.g., post-merge epoch). +func (e *Era) InitialTD() (*big.Int, error) { + // Check if TD component exists. + if int(td) >= int(e.m.components) { + return nil, fmt.Errorf("total difficulty not available in this epoch") + } + + // Get first header to read its difficulty. + header, err := e.GetHeader(e.m.start) + if err != nil { + return nil, fmt.Errorf("read first header: %w", err) + } + + // Get TD after first block using the index. + firstTD, err := e.GetTD(e.m.start) + if err != nil { + return nil, fmt.Errorf("read first TD: %w", err) + } + + // Initial TD = TD[0] - Difficulty[0] + return new(big.Int).Sub(firstTD, header.Difficulty), nil +} + +// Accumulator reads the accumulator entry in the EraE file if it exists. +// Note that one premerge erae files will contain an accumulator entry. +func (e *Era) Accumulator() (common.Hash, error) { + entry, err := e.s.Find(era.TypeAccumulator) + if err != nil { + return common.Hash{}, err + } + return common.BytesToHash(entry.Value), nil +} + +// loadIndex loads in the index table containing all offsets and caches it. +func (e *Era) loadIndex() error { + var err error + e.m.length, err = e.f.Seek(0, io.SeekEnd) + if err != nil { + return err + } + + b := make([]byte, 16) + if _, err = e.f.ReadAt(b, e.m.length-16); err != nil { + return err + } + e.m.components = binary.LittleEndian.Uint64(b[0:8]) + e.m.count = binary.LittleEndian.Uint64(b[8:16]) + + payloadlen := 8 + 8*e.m.count*e.m.components + 16 // 8 for start block, 8 per property per block, 16 for the number of properties and the number of blocks + tlvstart := e.m.length - int64(payloadlen) - 8 + _, err = e.f.ReadAt(b[:8], tlvstart+8) + if err != nil { + return err + } + + e.m.start = binary.LittleEndian.Uint64(b[:8]) + return nil +} + +// headerOff, bodyOff, receiptOff, and tdOff return the offsets of the respective components for a given block number. +func (e *Era) headerOff(num uint64) (int64, error) { return e.indexOffset(num, header) } +func (e *Era) bodyOff(num uint64) (int64, error) { return e.indexOffset(num, body) } +func (e *Era) receiptOff(num uint64) (int64, error) { return e.indexOffset(num, receipts) } +func (e *Era) tdOff(num uint64) (int64, error) { return e.indexOffset(num, td) } + +// indexOffset calculates offset to a certain component for a block number within a file. +func (e *Era) indexOffset(n uint64, component componentType) (int64, error) { + if n < e.m.start || n >= e.m.start+e.m.count { + return 0, fmt.Errorf("block %d out of range [%d,%d)", n, e.m.start, e.m.start+e.m.count) + } + if int(component) >= int(e.m.components) { + return 0, fmt.Errorf("component %d not present", component) + } + + payloadlen := 8 + 8*e.m.count*e.m.components + 16 // 8 for start block, 8 per property per block, 16 for the number of properties and the number of blocks + indstart := e.m.length - int64(payloadlen) - 8 + + rec := (n-e.m.start)*e.m.components + uint64(component) + pos := indstart + 8 + 8 + int64(rec*8) + + var buf [8]byte + if _, err := e.f.ReadAt(buf[:], pos); err != nil { + return 0, err + } + rel := binary.LittleEndian.Uint64(buf[:]) + return int64(rel) + indstart, nil +} + +// metadata contains the information about the era file that is written into the file. +type metadata struct { + start uint64 // start block number + count uint64 // number of blocks in the era + components uint64 // number of properties + length int64 // length of the file in bytes +} + +// componentType represents the integer form of a specific type that can be present in the era file. +type componentType int + +// header, body, receipts, td, and proof are the different types of components that can be present in the era file. +const ( + header componentType = iota + body + receipts + td + proof +) diff --git a/internal/era/builder.go b/internal/era/onedb/builder.go similarity index 84% rename from internal/era/builder.go rename to internal/era/onedb/builder.go index 975561564ccd..6497bf4f602b 100644 --- a/internal/era/builder.go +++ b/internal/era/onedb/builder.go @@ -14,7 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package era +package onedb import ( "bytes" @@ -26,6 +26,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/era" "github.com/ethereum/go-ethereum/internal/era/e2store" "github.com/ethereum/go-ethereum/rlp" "github.com/golang/snappy" @@ -72,20 +73,22 @@ import ( // Due to the accumulator size limit of 8192, the maximum number of blocks in // an Era1 batch is also 8192. type Builder struct { - w *e2store.Writer - startNum *uint64 - startTd *big.Int - indexes []uint64 - hashes []common.Hash - tds []*big.Int - written int + w *e2store.Writer + startNum *uint64 + startTd *big.Int + indexes []uint64 + hashes []common.Hash + tds []*big.Int + accumulator *common.Hash // accumulator root, set by Finalize + + written int buf *bytes.Buffer snappy *snappy.Writer } // NewBuilder returns a new Builder instance. -func NewBuilder(w io.Writer) *Builder { +func NewBuilder(w io.Writer) era.Builder { buf := bytes.NewBuffer(nil) return &Builder{ w: e2store.NewWriter(w), @@ -117,7 +120,7 @@ func (b *Builder) Add(block *types.Block, receipts types.Receipts, td *big.Int) func (b *Builder) AddRLP(header, body, receipts []byte, number uint64, hash common.Hash, td, difficulty *big.Int) error { // Write Era1 version entry before first block. if b.startNum == nil { - n, err := b.w.Write(TypeVersion, nil) + n, err := b.w.Write(era.TypeVersion, nil) if err != nil { return err } @@ -126,8 +129,8 @@ func (b *Builder) AddRLP(header, body, receipts []byte, number uint64, hash comm b.startTd = new(big.Int).Sub(td, difficulty) b.written += n } - if len(b.indexes) >= MaxEra1Size { - return fmt.Errorf("exceeds maximum batch size of %d", MaxEra1Size) + if len(b.indexes) >= era.MaxSize { + return fmt.Errorf("exceeds maximum batch size of %d", era.MaxSize) } b.indexes = append(b.indexes, uint64(b.written)) @@ -135,19 +138,19 @@ func (b *Builder) AddRLP(header, body, receipts []byte, number uint64, hash comm b.tds = append(b.tds, td) // Write block data. - if err := b.snappyWrite(TypeCompressedHeader, header); err != nil { + if err := b.snappyWrite(era.TypeCompressedHeader, header); err != nil { return err } - if err := b.snappyWrite(TypeCompressedBody, body); err != nil { + if err := b.snappyWrite(era.TypeCompressedBody, body); err != nil { return err } - if err := b.snappyWrite(TypeCompressedReceipts, receipts); err != nil { + if err := b.snappyWrite(era.TypeCompressedReceipts, receipts); err != nil { return err } // Also write total difficulty, but don't snappy encode. - btd := bigToBytes32(td) - n, err := b.w.Write(TypeTotalDifficulty, btd[:]) + btd := era.BigToBytes32(td) + n, err := b.w.Write(era.TypeTotalDifficulty, btd[:]) b.written += n if err != nil { return err @@ -157,21 +160,24 @@ func (b *Builder) AddRLP(header, body, receipts []byte, number uint64, hash comm } // Finalize computes the accumulator and block index values, then writes the -// corresponding e2store entries. +// corresponding e2store entries. Era1 always has an accumulator, so this +// always returns a valid hash. func (b *Builder) Finalize() (common.Hash, error) { if b.startNum == nil { return common.Hash{}, errors.New("finalize called on empty builder") } // Compute accumulator root and write entry. - root, err := ComputeAccumulator(b.hashes, b.tds) + root, err := era.ComputeAccumulator(b.hashes, b.tds) if err != nil { return common.Hash{}, fmt.Errorf("error calculating accumulator root: %w", err) } - n, err := b.w.Write(TypeAccumulator, root[:]) + n, err := b.w.Write(era.TypeAccumulator, root[:]) b.written += n if err != nil { return common.Hash{}, fmt.Errorf("error writing accumulator: %w", err) } + b.accumulator = &root + // Get beginning of index entry to calculate block relative offset. base := int64(b.written) @@ -196,13 +202,19 @@ func (b *Builder) Finalize() (common.Hash, error) { binary.LittleEndian.PutUint64(index[8+count*8:], uint64(count)) // Finally, write the block index entry. - if _, err := b.w.Write(TypeBlockIndex, index); err != nil { + if _, err := b.w.Write(era.TypeBlockIndex, index); err != nil { return common.Hash{}, fmt.Errorf("unable to write block index: %w", err) } return root, nil } +// Accumulator returns the accumulator root after Finalize has been called. +// For Era1, this always returns a non-nil value since all blocks are pre-merge. +func (b *Builder) Accumulator() *common.Hash { + return b.accumulator +} + // snappyWrite is a small helper to take care snappy encoding and writing an e2store entry. func (b *Builder) snappyWrite(typ uint16, in []byte) error { var ( diff --git a/internal/era/era_test.go b/internal/era/onedb/builder_test.go similarity index 95% rename from internal/era/era_test.go rename to internal/era/onedb/builder_test.go index 31fa0076a65f..bc7a1d9e6383 100644 --- a/internal/era/era_test.go +++ b/internal/era/onedb/builder_test.go @@ -14,7 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package era +package onedb import ( "bytes" @@ -22,6 +22,7 @@ import ( "io" "math/big" "os" + "slices" "testing" "github.com/ethereum/go-ethereum/common" @@ -82,7 +83,11 @@ func TestEra1Builder(t *testing.T) { t.Fatalf("failed to open era: %v", err) } defer e.Close() - it, err := NewRawIterator(e) + eraPtr, ok := e.(*Era) + if !ok { + t.Fatalf("failed to assert *Era type") + } + it, err := NewRawIterator(eraPtr) if err != nil { t.Fatalf("failed to make iterator: %s", err) } @@ -119,7 +124,7 @@ func TestEra1Builder(t *testing.T) { if !bytes.Equal(rawReceipts, chain.receipts[i]) { t.Fatalf("mismatched receipts: want %s, got %s", chain.receipts[i], rawReceipts) } - receipts, err := getReceiptsByNumber(e, i) + receipts, err := getReceiptsByNumber(eraPtr, i) if err != nil { t.Fatalf("error reading receipts: %v", err) } @@ -136,7 +141,8 @@ func TestEra1Builder(t *testing.T) { if err != nil { t.Fatalf("error reading td: %v", err) } - td := new(big.Int).SetBytes(reverseOrder(rawTd)) + slices.Reverse(rawTd) + td := new(big.Int).SetBytes(rawTd) if td.Cmp(chain.tds[i]) != 0 { t.Fatalf("mismatched tds: want %s, got %s", chain.tds[i], td) } diff --git a/internal/era/iterator.go b/internal/era/onedb/iterator.go similarity index 88% rename from internal/era/iterator.go rename to internal/era/onedb/iterator.go index 3c4f82d85066..21dc5acbe03d 100644 --- a/internal/era/iterator.go +++ b/internal/era/onedb/iterator.go @@ -14,14 +14,16 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package era +package onedb import ( "errors" "io" "math/big" + "slices" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/era" "github.com/ethereum/go-ethereum/rlp" ) @@ -32,8 +34,8 @@ type Iterator struct { // NewIterator returns a new Iterator instance. Next must be immediately // called on new iterators to load the first item. -func NewIterator(e *Era) (*Iterator, error) { - inner, err := NewRawIterator(e) +func NewIterator(e era.Era) (era.Iterator, error) { + inner, err := NewRawIterator(e.(*Era)) if err != nil { return nil, err } @@ -107,7 +109,8 @@ func (it *Iterator) TotalDifficulty() (*big.Int, error) { if err != nil { return nil, err } - return new(big.Int).SetBytes(reverseOrder(td)), nil + slices.Reverse(td) + return new(big.Int).SetBytes(td), nil } // RawIterator reads an RLP-encode Era1 entries. @@ -151,24 +154,24 @@ func (it *RawIterator) Next() bool { return false } var n int64 - if it.Header, n, it.err = newSnappyReader(it.e.s, TypeCompressedHeader, off); it.err != nil { + if it.Header, n, it.err = newSnappyReader(it.e.s, era.TypeCompressedHeader, off); it.err != nil { it.clear() - return true + return false } off += n - if it.Body, n, it.err = newSnappyReader(it.e.s, TypeCompressedBody, off); it.err != nil { + if it.Body, n, it.err = newSnappyReader(it.e.s, era.TypeCompressedBody, off); it.err != nil { it.clear() - return true + return false } off += n - if it.Receipts, n, it.err = newSnappyReader(it.e.s, TypeCompressedReceipts, off); it.err != nil { + if it.Receipts, n, it.err = newSnappyReader(it.e.s, era.TypeCompressedReceipts, off); it.err != nil { it.clear() - return true + return false } off += n - if it.TotalDifficulty, _, it.err = it.e.s.ReaderAt(TypeTotalDifficulty, off); it.err != nil { + if it.TotalDifficulty, _, it.err = it.e.s.ReaderAt(era.TypeTotalDifficulty, off); it.err != nil { it.clear() - return true + return false } it.next += 1 return true diff --git a/internal/era/onedb/reader.go b/internal/era/onedb/reader.go new file mode 100644 index 000000000000..df93ca8211bb --- /dev/null +++ b/internal/era/onedb/reader.go @@ -0,0 +1,279 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package onedb + +import ( + "encoding/binary" + "fmt" + "io" + "math/big" + "os" + "slices" + "sync" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/era" + "github.com/ethereum/go-ethereum/internal/era/e2store" + "github.com/ethereum/go-ethereum/rlp" + "github.com/golang/snappy" +) + +// Filename returns a recognizable Era1-formatted file name for the specified +// epoch and network. +func Filename(network string, epoch int, root common.Hash) string { + return fmt.Sprintf("%s-%05d-%s.era1", network, epoch, root.Hex()[2:10]) +} + +type ReadAtSeekCloser interface { + io.ReaderAt + io.Seeker + io.Closer +} + +// Era reads and Era1 file. +type Era struct { + f ReadAtSeekCloser // backing era1 file + s *e2store.Reader // e2store reader over f + m metadata // start, count, length info + mu *sync.Mutex // lock for buf + buf [8]byte // buffer reading entry offsets +} + +// From returns an Era backed by f. +func From(f era.ReadAtSeekCloser) (era.Era, error) { + m, err := readMetadata(f) + if err != nil { + return nil, err + } + return &Era{ + f: f, + s: e2store.NewReader(f), + m: m, + mu: new(sync.Mutex), + }, nil +} + +// Open returns an Era backed by the given filename. +func Open(filename string) (era.Era, error) { + f, err := os.Open(filename) + if err != nil { + return nil, err + } + return From(f) +} + +func (e *Era) Close() error { + return e.f.Close() +} + +// Iterator returns an iterator over the era file. +func (e *Era) Iterator() (era.Iterator, error) { + return NewIterator(e) +} + +// GetBlockByNumber returns the block for the given block number. +func (e *Era) GetBlockByNumber(num uint64) (*types.Block, error) { + if e.m.start > num || e.m.start+e.m.count <= num { + return nil, fmt.Errorf("out-of-bounds: %d not in [%d, %d)", num, e.m.start, e.m.start+e.m.count) + } + off, err := e.readOffset(num) + if err != nil { + return nil, err + } + r, n, err := newSnappyReader(e.s, era.TypeCompressedHeader, off) + if err != nil { + return nil, err + } + var header types.Header + if err := rlp.Decode(r, &header); err != nil { + return nil, err + } + off += n + r, _, err = newSnappyReader(e.s, era.TypeCompressedBody, off) + if err != nil { + return nil, err + } + var body types.Body + if err := rlp.Decode(r, &body); err != nil { + return nil, err + } + return types.NewBlockWithHeader(&header).WithBody(body), nil +} + +// GetRawBodyByNumber returns the RLP-encoded body for the given block number. +func (e *Era) GetRawBodyByNumber(num uint64) ([]byte, error) { + if e.m.start > num || e.m.start+e.m.count <= num { + return nil, fmt.Errorf("out-of-bounds: %d not in [%d, %d)", num, e.m.start, e.m.start+e.m.count) + } + off, err := e.readOffset(num) + if err != nil { + return nil, err + } + off, err = e.s.SkipN(off, 1) + if err != nil { + return nil, err + } + r, _, err := newSnappyReader(e.s, era.TypeCompressedBody, off) + if err != nil { + return nil, err + } + return io.ReadAll(r) +} + +// GetRawReceiptsByNumber returns the RLP-encoded receipts for the given block number. +func (e *Era) GetRawReceiptsByNumber(num uint64) ([]byte, error) { + if e.m.start > num || e.m.start+e.m.count <= num { + return nil, fmt.Errorf("out-of-bounds: %d not in [%d, %d)", num, e.m.start, e.m.start+e.m.count) + } + off, err := e.readOffset(num) + if err != nil { + return nil, err + } + + // Skip over header and body. + off, err = e.s.SkipN(off, 2) + if err != nil { + return nil, err + } + + r, _, err := newSnappyReader(e.s, era.TypeCompressedReceipts, off) + if err != nil { + return nil, err + } + return io.ReadAll(r) +} + +// Accumulator reads the accumulator entry in the Era1 file. +func (e *Era) Accumulator() (common.Hash, error) { + entry, err := e.s.Find(era.TypeAccumulator) + if err != nil { + return common.Hash{}, err + } + return common.BytesToHash(entry.Value), nil +} + +// InitialTD returns initial total difficulty before the difficulty of the +// first block of the Era1 is applied. +func (e *Era) InitialTD() (*big.Int, error) { + var ( + r io.Reader + header types.Header + rawTd []byte + n int64 + off int64 + err error + ) + + // Read first header. + if off, err = e.readOffset(e.m.start); err != nil { + return nil, err + } + if r, n, err = newSnappyReader(e.s, era.TypeCompressedHeader, off); err != nil { + return nil, err + } + if err := rlp.Decode(r, &header); err != nil { + return nil, err + } + off += n + + // Skip over header and body. + off, err = e.s.SkipN(off, 2) + if err != nil { + return nil, err + } + + // Read total difficulty after first block. + if r, _, err = e.s.ReaderAt(era.TypeTotalDifficulty, off); err != nil { + return nil, err + } + rawTd, err = io.ReadAll(r) + if err != nil { + return nil, err + } + slices.Reverse(rawTd) + td := new(big.Int).SetBytes(rawTd) + return td.Sub(td, header.Difficulty), nil +} + +// Start returns the listed start block. +func (e *Era) Start() uint64 { + return e.m.start +} + +// Count returns the total number of blocks in the Era1. +func (e *Era) Count() uint64 { + return e.m.count +} + +// readOffset reads a specific block's offset from the block index. The value n +// is the absolute block number desired. +func (e *Era) readOffset(n uint64) (int64, error) { + var ( + blockIndexRecordOffset = e.m.length - 24 - int64(e.m.count)*8 // skips start, count, and header + firstIndex = blockIndexRecordOffset + 16 // first index after header / start-num + indexOffset = int64(n-e.m.start) * 8 // desired index * size of indexes + offOffset = firstIndex + indexOffset // offset of block offset + ) + e.mu.Lock() + defer e.mu.Unlock() + clear(e.buf[:]) + if _, err := e.f.ReadAt(e.buf[:], offOffset); err != nil { + return 0, err + } + // Since the block offset is relative from the start of the block index record + // we need to add the record offset to it's offset to get the block's absolute + // offset. + return blockIndexRecordOffset + int64(binary.LittleEndian.Uint64(e.buf[:])), nil +} + +// newSnappyReader returns a snappy.Reader for the e2store entry value at off. +func newSnappyReader(e *e2store.Reader, expectedType uint16, off int64) (io.Reader, int64, error) { + r, n, err := e.ReaderAt(expectedType, off) + if err != nil { + return nil, 0, err + } + return snappy.NewReader(r), int64(n), err +} + +// metadata wraps the metadata in the block index. +type metadata struct { + start uint64 + count uint64 + length int64 +} + +// readMetadata reads the metadata stored in an Era1 file's block index. +func readMetadata(f ReadAtSeekCloser) (m metadata, err error) { + // Determine length of reader. + if m.length, err = f.Seek(0, io.SeekEnd); err != nil { + return + } + b := make([]byte, 16) + // Read count. It's the last 8 bytes of the file. + if _, err = f.ReadAt(b[:8], m.length-8); err != nil { + return + } + m.count = binary.LittleEndian.Uint64(b) + // Read start. It's at the offset -sizeof(m.count) - + // count*sizeof(indexEntry) - sizeof(m.start) + if _, err = f.ReadAt(b[8:], m.length-16-int64(m.count*8)); err != nil { + return + } + m.start = binary.LittleEndian.Uint64(b[8:]) + return +} diff --git a/internal/era/proof.go b/internal/era/proof.go new file mode 100644 index 000000000000..464d9e6fe5b5 --- /dev/null +++ b/internal/era/proof.go @@ -0,0 +1,36 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . +package era + +import ( + "io" + + "github.com/ethereum/go-ethereum/rlp" +) + +type ProofVariant uint16 + +const ( + ProofNone ProofVariant = iota +) + +// Proof is the interface for all block proof types in the package. +// It's a stub for later integration into Era. +type Proof interface { + EncodeRLP(w io.Writer) error + DecodeRLP(s *rlp.Stream) error + Variant() ProofVariant +} diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index eb437201d5dd..6d38c6c7c8d5 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -47,13 +47,20 @@ import ( "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rpc" - "github.com/ethereum/go-ethereum/trie" ) // estimateGasErrorRatio is the amount of overestimation eth_estimateGas is // allowed to produce in order to speed up calculations. const estimateGasErrorRatio = 0.015 +// maxGetStorageSlots is the maximum total number of storage slots that can +// be requested in a single eth_getStorageValues call. +const maxGetStorageSlots = 1024 + +// maxGetProofKeys is the maximum number of storage keys that can be +// requested in a single eth_getProof call. +const maxGetProofKeys = 1024 + var errBlobTxNotSupported = errors.New("signing blob transactions not supported") var errSubClosed = errors.New("chain subscription closed") @@ -173,6 +180,7 @@ func (api *EthereumAPI) Syncing(ctx context.Context) (interface{}, error) { "txIndexFinishedBlocks": hexutil.Uint64(progress.TxIndexFinishedBlocks), "txIndexRemainingBlocks": hexutil.Uint64(progress.TxIndexRemainingBlocks), "stateIndexRemaining": hexutil.Uint64(progress.StateIndexRemaining), + "trienodeIndexRemaining": hexutil.Uint64(progress.TrienodeIndexRemaining), }, nil } @@ -186,6 +194,15 @@ func NewTxPoolAPI(b Backend) *TxPoolAPI { return &TxPoolAPI{b} } +// flattenTxs builds the RPC transaction map keyed by nonce for a set of pool txs. +func flattenTxs(txs types.Transactions, header *types.Header, cfg *params.ChainConfig) map[string]*RPCTransaction { + dump := make(map[string]*RPCTransaction, len(txs)) + for _, tx := range txs { + dump[fmt.Sprintf("%d", tx.Nonce())] = NewRPCPendingTransaction(tx, header, cfg) + } + return dump +} + // Content returns the transactions contained within the transaction pool. func (api *TxPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction { pending, queue := api.b.TxPoolContent() @@ -196,19 +213,11 @@ func (api *TxPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction curHeader := api.b.CurrentHeader() // Flatten the pending transactions for account, txs := range pending { - dump := make(map[string]*RPCTransaction, len(txs)) - for _, tx := range txs { - dump[fmt.Sprintf("%d", tx.Nonce())] = NewRPCPendingTransaction(tx, curHeader, api.b.ChainConfig()) - } - content["pending"][account.Hex()] = dump + content["pending"][account.Hex()] = flattenTxs(txs, curHeader, api.b.ChainConfig()) } // Flatten the queued transactions for account, txs := range queue { - dump := make(map[string]*RPCTransaction, len(txs)) - for _, tx := range txs { - dump[fmt.Sprintf("%d", tx.Nonce())] = NewRPCPendingTransaction(tx, curHeader, api.b.ChainConfig()) - } - content["queued"][account.Hex()] = dump + content["queued"][account.Hex()] = flattenTxs(txs, curHeader, api.b.ChainConfig()) } return content } @@ -220,18 +229,10 @@ func (api *TxPoolAPI) ContentFrom(addr common.Address) map[string]map[string]*RP curHeader := api.b.CurrentHeader() // Build the pending transactions - dump := make(map[string]*RPCTransaction, len(pending)) - for _, tx := range pending { - dump[fmt.Sprintf("%d", tx.Nonce())] = NewRPCPendingTransaction(tx, curHeader, api.b.ChainConfig()) - } - content["pending"] = dump + content["pending"] = flattenTxs(pending, curHeader, api.b.ChainConfig()) // Build the queued transactions - dump = make(map[string]*RPCTransaction, len(queue)) - for _, tx := range queue { - dump[fmt.Sprintf("%d", tx.Nonce())] = NewRPCPendingTransaction(tx, curHeader, api.b.ChainConfig()) - } - content["queued"] = dump + content["queued"] = flattenTxs(queue, curHeader, api.b.ChainConfig()) return content } @@ -366,6 +367,9 @@ func (n *proofList) Delete(key []byte) error { // GetProof returns the Merkle-proof for a given account and optionally some storage keys. func (api *BlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) { + if len(storageKeys) > maxGetProofKeys { + return nil, &invalidParamsError{fmt.Sprintf("too many storage keys requested (max %d, got %d)", maxGetProofKeys, len(storageKeys))} + } var ( keys = make([]common.Hash, len(storageKeys)) keyLengths = make([]int, len(storageKeys)) @@ -389,8 +393,7 @@ func (api *BlockChainAPI) GetProof(ctx context.Context, address common.Address, if len(keys) > 0 { var storageTrie state.Trie if storageRoot != types.EmptyRootHash && storageRoot != (common.Hash{}) { - id := trie.StorageTrieID(header.Root, crypto.Keccak256Hash(address.Bytes()), storageRoot) - st, err := trie.NewStateTrie(id, statedb.Database().TrieDB()) + st, err := statedb.Database().OpenStorageTrie(header.Root, address, storageRoot, nil) if err != nil { return nil, err } @@ -398,6 +401,9 @@ func (api *BlockChainAPI) GetProof(ctx context.Context, address common.Address, } // Create the proofs for the storageKeys. for i, key := range keys { + if err := ctx.Err(); err != nil { + return nil, err + } // Output key encoding is a bit special: if the input was a 32-byte hash, it is // returned as such. Otherwise, we apply the QUANTITY encoding mandated by the // JSON-RPC spec for getProof. This behavior exists to preserve backwards @@ -421,7 +427,7 @@ func (api *BlockChainAPI) GetProof(ctx context.Context, address common.Address, } } // Create the accountProof. - tr, err := trie.NewStateTrie(trie.StateTrieID(header.Root), statedb.Database().TrieDB()) + tr, err := statedb.Database().OpenTrie(header.Root) if err != nil { return nil, err } @@ -598,6 +604,41 @@ func (api *BlockChainAPI) GetStorageAt(ctx context.Context, address common.Addre return res[:], state.Error() } +// GetStorageValues returns multiple storage slot values for multiple accounts +// at the given block. +func (api *BlockChainAPI) GetStorageValues(ctx context.Context, requests map[common.Address][]common.Hash, blockNrOrHash rpc.BlockNumberOrHash) (map[common.Address][]hexutil.Bytes, error) { + // Count total slots requested. + var totalSlots int + for _, keys := range requests { + totalSlots += len(keys) + if totalSlots > maxGetStorageSlots { + return nil, &clientLimitExceededError{message: fmt.Sprintf("too many slots (max %d)", maxGetStorageSlots)} + } + } + if totalSlots == 0 { + return nil, &invalidParamsError{message: "empty request"} + } + + state, _, err := api.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) + if state == nil || err != nil { + return nil, err + } + + result := make(map[common.Address][]hexutil.Bytes, len(requests)) + for addr, keys := range requests { + vals := make([]hexutil.Bytes, len(keys)) + for i, key := range keys { + v := state.GetState(addr, key) + vals[i] = v[:] + } + if err := state.Error(); err != nil { + return nil, err + } + result[addr] = vals + } + return result, nil +} + // GetBlockReceipts returns the block receipts for the given block hash or number or tag. func (api *BlockChainAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) ([]map[string]interface{}, error) { var ( @@ -693,6 +734,10 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S if err := blockOverrides.Apply(&blockCtx); err != nil { return nil, err } + // Override the header so callers that compute gas price from 1559 fee + // fields see the overridden basefee. Otherwise GASPRICE/effectiveTip + // would be derived from the pre-override basefee. + header = blockOverrides.MakeHeader(header) } rules := b.ChainConfig().Rules(blockCtx.BlockNumber, blockCtx.Random != nil, blockCtx.Time) precompiles := vm.ActivePrecompiledContracts(rules) @@ -711,11 +756,10 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S // Make sure the context is cancelled when the call has completed // this makes sure resources are cleaned up. defer cancel() - gp := new(core.GasPool) + + gp := core.NewGasPool(globalGasCap) if globalGasCap == 0 { - gp.AddGas(gomath.MaxUint64) - } else { - gp.AddGas(globalGasCap) + gp = core.NewGasPool(gomath.MaxUint64) } return applyMessage(ctx, b, args, state, header, timeout, gp, &blockCtx, &vm.Config{NoBaseFee: true}, precompiles) } @@ -735,6 +779,7 @@ func applyMessage(ctx context.Context, b Backend, args TransactionArgs, state *s blockContext.BlobBaseFee = new(big.Int) } evm := b.GetEVM(ctx, state, header, vmConfig, blockContext) + defer evm.Release() if precompiles != nil { evm.SetPrecompiles(precompiles) } @@ -812,6 +857,16 @@ func (api *BlockChainAPI) SimulateV1(ctx context.Context, opts simOpts, blockNrO } else if len(opts.BlockStateCalls) > maxSimulateBlocks { return nil, &clientLimitExceededError{message: "too many blocks"} } + var totalCalls int + for _, block := range opts.BlockStateCalls { + if len(block.Calls) > maxSimulateCallsPerBlock { + return nil, &clientLimitExceededError{message: fmt.Sprintf("too many calls in block: %d > %d", len(block.Calls), maxSimulateCallsPerBlock)} + } + totalCalls += len(block.Calls) + if totalCalls > maxSimulateTotalCalls { + return nil, &clientLimitExceededError{message: fmt.Sprintf("too many calls: %d > %d", totalCalls, maxSimulateTotalCalls)} + } + } if blockNrOrHash == nil { n := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber) blockNrOrHash = &n @@ -820,17 +875,12 @@ func (api *BlockChainAPI) SimulateV1(ctx context.Context, opts simOpts, blockNrO if state == nil || err != nil { return nil, err } - gasCap := api.b.RPCGasCap() - if gasCap == 0 { - gasCap = gomath.MaxUint64 - } sim := &simulator{ - b: api.b, - state: state, - base: base, - chainConfig: api.b.ChainConfig(), - // Each tx and all the series of txes shouldn't consume more gas than cap - gp: new(core.GasPool).AddGas(gasCap), + b: api.b, + state: state, + base: base, + chainConfig: api.b.ChainConfig(), + budget: newGasBudget(api.b.RPCGasCap()), traceTransfers: opts.TraceTransfers, validate: opts.Validation, fullTx: opts.ReturnFullTransactions, @@ -853,6 +903,7 @@ func DoEstimateGas(ctx context.Context, b Backend, args TransactionArgs, blockNr if err := blockOverrides.Apply(&blockCtx); err != nil { return 0, err } + header = blockOverrides.MakeHeader(header) } rules := b.ChainConfig().Rules(blockCtx.BlockNumber, blockCtx.Random != nil, blockCtx.Time) precompiles := vm.ActivePrecompiledContracts(rules) @@ -860,13 +911,17 @@ func DoEstimateGas(ctx context.Context, b Backend, args TransactionArgs, blockNr return 0, err } // Construct the gas estimator option from the user input + var blobBaseFee *big.Int + if blockOverrides != nil && blockOverrides.BlobBaseFee != nil { + blobBaseFee = blockOverrides.BlobBaseFee.ToInt() + } opts := &gasestimator.Options{ - Config: b.ChainConfig(), - Chain: NewChainContext(ctx, b), - Header: header, - BlockOverrides: blockOverrides, - State: state, - ErrorRatio: estimateGasErrorRatio, + Config: b.ChainConfig(), + Chain: NewChainContext(ctx, b), + Header: header, + State: state, + BlobBaseFee: blobBaseFee, + ErrorRatio: estimateGasErrorRatio, } // Set any required transaction default, but make sure the gas cap itself is not messed with // if it was not specified in the original argument list. @@ -941,6 +996,12 @@ func RPCMarshalHeader(head *types.Header) map[string]interface{} { if head.RequestsHash != nil { result["requestsHash"] = head.RequestsHash } + if head.BlockAccessListHash != nil { + result["balHash"] = head.BlockAccessListHash + } + if head.SlotNumber != nil { + result["slotNumber"] = hexutil.Uint64(*head.SlotNumber) + } return result } @@ -983,6 +1044,7 @@ func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *param type RPCTransaction struct { BlockHash *common.Hash `json:"blockHash"` BlockNumber *hexutil.Big `json:"blockNumber"` + BlockTimestamp *hexutil.Uint64 `json:"blockTimestamp"` From common.Address `json:"from"` Gas hexutil.Uint64 `json:"gas"` GasPrice *hexutil.Big `json:"gasPrice"` @@ -1029,6 +1091,7 @@ func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber if blockHash != (common.Hash{}) { result.BlockHash = &blockHash result.BlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(blockNumber)) + result.BlockTimestamp = (*hexutil.Uint64)(&blockTime) result.TransactionIndex = (*hexutil.Uint64)(&index) } @@ -1334,7 +1397,8 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH if msg.BlobGasFeeCap != nil && msg.BlobGasFeeCap.BitLen() == 0 { evm.Context.BlobBaseFee = new(big.Int) } - res, err := core.ApplyMessage(evm, msg, new(core.GasPool).AddGas(msg.GasLimit)) + res, err := core.ApplyMessage(evm, msg, nil) + evm.Release() if err != nil { return nil, 0, nil, fmt.Errorf("failed to apply transaction: %v err: %v", args.ToTransaction(types.LegacyTxType).Hash(), err) } @@ -1670,7 +1734,7 @@ func (api *TransactionAPI) SendRawTransaction(ctx context.Context, input hexutil // SendRawTransactionSync will add the signed transaction to the transaction pool // and wait until the transaction has been included in a block and return the receipt, or the timeout. -func (api *TransactionAPI) SendRawTransactionSync(ctx context.Context, input hexutil.Bytes, timeoutMs *hexutil.Uint64) (map[string]interface{}, error) { +func (api *TransactionAPI) SendRawTransactionSync(ctx context.Context, input hexutil.Bytes, timeoutMs *uint64) (map[string]interface{}, error) { tx := new(types.Transaction) if err := tx.UnmarshalBinary(input); err != nil { return nil, err diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go index aaa002b5ec00..63e75bd3e3dc 100644 --- a/internal/ethapi/api_test.go +++ b/internal/ethapi/api_test.go @@ -24,7 +24,6 @@ import ( "encoding/json" "errors" "fmt" - "math" "math/big" "os" "path/filepath" @@ -140,6 +139,7 @@ func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txDa Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x7", "gasPrice": "0x6", @@ -170,6 +170,7 @@ func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txDa Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x7", "gasPrice": "0x6", @@ -208,6 +209,7 @@ func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txDa Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x7", "gasPrice": "0x6", @@ -254,6 +256,7 @@ func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txDa Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x7", "gasPrice": "0x6", @@ -301,6 +304,7 @@ func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txDa Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x7", "gasPrice": "0x9", @@ -345,6 +349,7 @@ func allTransactionTypes(addr common.Address, config *params.ChainConfig) []txDa Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x7", "gasPrice": "0x9", @@ -387,6 +392,7 @@ func allBlobTxs(addr common.Address, config *params.ChainConfig) []txData { Want: `{ "blockHash": null, "blockNumber": null, + "blockTimestamp": null, "from": "0x71562b71999873db5b286df957af199ec94617f7", "gas": "0x6", "gasPrice": "0x5", @@ -566,7 +572,7 @@ func (b testBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.Bloc if header == nil { return nil, nil, errors.New("header not found") } - stateDb, err := b.chain.StateAt(header.Root) + stateDb, err := b.chain.StateAt(header) return stateDb, header, err } func (b testBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) { @@ -774,6 +780,17 @@ func TestEstimateGas(t *testing.T) { expectErr: core.ErrInsufficientFunds, want: 21000, }, + // block override gas limit should bound estimation search space. + { + blockNumber: rpc.LatestBlockNumber, + call: TransactionArgs{ + From: &accounts[0].addr, + Input: hex2Bytes("6080604052348015600f57600080fd5b50483a1015601c57600080fd5b60003a111560315760004811603057600080fd5b5b603f80603e6000396000f3fe6080604052600080fdfea264697066735822122060729c2cee02b10748fae5200f1c9da4661963354973d9154c13a8e9ce9dee1564736f6c63430008130033"), + Gas: func() *hexutil.Uint64 { v := hexutil.Uint64(0); return &v }(), + }, + blockOverrides: override.BlockOverrides{GasLimit: func() *hexutil.Uint64 { v := hexutil.Uint64(50000); return &v }()}, + expectErr: errors.New("gas required exceeds allowance (50000)"), + }, // empty create { blockNumber: rpc.LatestBlockNumber, @@ -855,6 +872,19 @@ func TestEstimateGas(t *testing.T) { }, want: 21000, }, + // blob base fee block override should be applied during estimation. + { + blockNumber: rpc.LatestBlockNumber, + call: TransactionArgs{ + From: &accounts[0].addr, + To: &accounts[1].addr, + Value: (*hexutil.Big)(big.NewInt(1)), + BlobHashes: []common.Hash{{0x01, 0x22}}, + BlobFeeCap: (*hexutil.Big)(big.NewInt(1)), + }, + blockOverrides: override.BlockOverrides{BlobBaseFee: (*hexutil.Big)(big.NewInt(2))}, + expectErr: core.ErrBlobFeeCapTooLow, + }, // // SPDX-License-Identifier: GPL-3.0 //pragma solidity >=0.8.2 <0.9.0; // @@ -1008,7 +1038,7 @@ func TestCall(t *testing.T) { Balance: big.NewInt(params.Ether), Nonce: 1, Storage: map[common.Hash]common.Hash{ - common.Hash{}: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"), + {}: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"), }, }, }, @@ -1285,6 +1315,27 @@ func TestCall(t *testing.T) { }, expectErr: errors.New(`block override "withdrawals" is not supported for this RPC method`), }, + // Verify that an overridden basefee is honored when computing gasPrice + // from the 1559 fee fields. Returning GASPRICE opcode; expected value + // is min(MaxFeePerGas, MaxPriorityFeePerGas + overridden BaseFee). + // + // BaseFee override = 0xa (10); MaxFeePerGas = 0x64 (100); + // MaxPriorityFeePerGas = 0x2 (2); expected GASPRICE = 12. + { + name: "basefee-override-used-in-gasprice", + blockNumber: rpc.LatestBlockNumber, + call: TransactionArgs{ + From: &accounts[0].addr, + // Contract: GASPRICE; PUSH1 0; MSTORE; PUSH1 32; PUSH1 0; RETURN + Input: hex2Bytes("3a60005260206000f3"), + MaxFeePerGas: (*hexutil.Big)(big.NewInt(100)), + MaxPriorityFeePerGas: (*hexutil.Big)(big.NewInt(2)), + }, + blockOverrides: override.BlockOverrides{ + BaseFeePerGas: (*hexutil.Big)(big.NewInt(10)), + }, + want: "0x000000000000000000000000000000000000000000000000000000000000000c", + }, } for _, tc := range testSuite { result, err := api.Call(context.Background(), tc.call, &rpc.BlockNumberOrHash{BlockNumber: &tc.blockNumber}, &tc.overrides, &tc.blockOverrides) @@ -2500,7 +2551,7 @@ func TestSimulateV1ChainLinkage(t *testing.T) { state: stateDB, base: baseHeader, chainConfig: backend.ChainConfig(), - gp: new(core.GasPool).AddGas(math.MaxUint64), + budget: newGasBudget(0), traceTransfers: false, validate: false, fullTx: false, @@ -2585,7 +2636,7 @@ func TestSimulateV1TxSender(t *testing.T) { state: stateDB, base: baseHeader, chainConfig: backend.ChainConfig(), - gp: new(core.GasPool).AddGas(math.MaxUint64), + budget: newGasBudget(0), traceTransfers: false, validate: false, fullTx: true, @@ -2629,6 +2680,67 @@ func TestSimulateV1TxSender(t *testing.T) { require.Equal(t, sender2, summary[1].Transactions[0].From, "sender address mismatch") } +// TestSimulateV1WithdrawalsByFork verifies that withdrawals and withdrawalsRoot +// are only emitted in the simulated block result when the simulated block is +// post-Shanghai. Pre-Shanghai blocks must omit both fields, otherwise the +// header hash and size would not match a valid pre-Shanghai block. +func TestSimulateV1WithdrawalsByFork(t *testing.T) { + t.Parallel() + + run := func(t *testing.T, cfg *params.ChainConfig, blockTime *uint64, wantWithdrawals bool) { + t.Helper() + gspec := &core.Genesis{Config: cfg, Alloc: types.GenesisAlloc{}} + backend := newTestBackend(t, 1, gspec, beacon.New(ethash.NewFaker()), func(i int, b *core.BlockGen) {}) + + ctx := context.Background() + stateDB, baseHeader, err := backend.StateAndHeaderByNumberOrHash(ctx, rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)) + if err != nil { + t.Fatalf("failed to get state and header: %v", err) + } + sim := &simulator{ + b: backend, + state: stateDB, + base: baseHeader, + chainConfig: backend.ChainConfig(), + budget: newGasBudget(0), + } + + block := simBlock{} + if blockTime != nil { + t := hexutil.Uint64(*blockTime) + block.BlockOverrides = &override.BlockOverrides{Time: &t} + } + results, err := sim.execute(ctx, []simBlock{block}) + if err != nil { + t.Fatalf("simulation execution failed: %v", err) + } + require.Len(t, results, 1) + + enc, err := json.Marshal(results[0]) + if err != nil { + t.Fatalf("failed to marshal result: %v", err) + } + var raw map[string]json.RawMessage + if err := json.Unmarshal(enc, &raw); err != nil { + t.Fatalf("failed to unmarshal result: %v", err) + } + _, hasWithdrawals := raw["withdrawals"] + _, hasWithdrawalsRoot := raw["withdrawalsRoot"] + if hasWithdrawals != wantWithdrawals || hasWithdrawalsRoot != wantWithdrawals { + t.Fatalf("unexpected withdrawals fields: withdrawals=%v withdrawalsRoot=%v want=%v\n%s", hasWithdrawals, hasWithdrawalsRoot, wantWithdrawals, enc) + } + } + + t.Run("pre-shanghai", func(t *testing.T) { + // TestChainConfig has ShanghaiTime=nil, so all simulated blocks are pre-Shanghai. + run(t, params.TestChainConfig, nil, false) + }) + t.Run("post-shanghai", func(t *testing.T) { + // MergedTestChainConfig has every fork active from genesis. + run(t, params.MergedTestChainConfig, nil, true) + }) +} + func TestSignTransaction(t *testing.T) { t.Parallel() // Initialize test accounts @@ -3138,6 +3250,7 @@ func TestRPCMarshalBlock(t *testing.T) { { "blockHash": "0x9b73c83b25d0faf7eab854e3684c7e394336d6e135625aafa5c183f27baa8fee", "blockNumber": "0x64", + "blockTimestamp": "0x0", "from": "0x0000000000000000000000000000000000000000", "gas": "0x457", "gasPrice": "0x2b67", @@ -3158,6 +3271,7 @@ func TestRPCMarshalBlock(t *testing.T) { { "blockHash": "0x9b73c83b25d0faf7eab854e3684c7e394336d6e135625aafa5c183f27baa8fee", "blockNumber": "0x64", + "blockTimestamp": "0x0", "from": "0x0000000000000000000000000000000000000000", "gas": "0x457", "gasPrice": "0x2b67", @@ -3176,6 +3290,7 @@ func TestRPCMarshalBlock(t *testing.T) { { "blockHash": "0x9b73c83b25d0faf7eab854e3684c7e394336d6e135625aafa5c183f27baa8fee", "blockNumber": "0x64", + "blockTimestamp": "0x0", "from": "0x0000000000000000000000000000000000000000", "gas": "0x457", "gasPrice": "0x2b67", @@ -3196,6 +3311,7 @@ func TestRPCMarshalBlock(t *testing.T) { { "blockHash": "0x9b73c83b25d0faf7eab854e3684c7e394336d6e135625aafa5c183f27baa8fee", "blockNumber": "0x64", + "blockTimestamp": "0x0", "from": "0x0000000000000000000000000000000000000000", "gas": "0x457", "gasPrice": "0x2b67", @@ -3785,7 +3901,7 @@ func TestCreateAccessListWithStateOverrides(t *testing.T) { Balance: (*hexutil.Big)(big.NewInt(1000000000000000000)), Nonce: &nonce, State: map[common.Hash]common.Hash{ - common.Hash{}: common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000002a"), + {}: common.HexToHash("0x000000000000000000000000000000000000000000000000000000000000002a"), }, }, } @@ -4026,7 +4142,7 @@ func TestSendRawTransactionSync_Timeout(t *testing.T) { raw, _ := makeSelfSignedRaw(t, api, b.acc.Address) - timeout := hexutil.Uint64(200) // 200ms + timeout := uint64(200) // 200ms receipt, err := api.SendRawTransactionSync(context.Background(), raw, &timeout) if receipt != nil { @@ -4054,3 +4170,91 @@ func TestSendRawTransactionSync_Timeout(t *testing.T) { t.Fatalf("expected ErrorData=%s, got %v", want, got) } } + +func TestGetStorageValues(t *testing.T) { + t.Parallel() + + var ( + addr1 = common.HexToAddress("0x1111") + addr2 = common.HexToAddress("0x2222") + slot0 = common.Hash{} + slot1 = common.BigToHash(big.NewInt(1)) + slot2 = common.BigToHash(big.NewInt(2)) + val0 = common.BigToHash(big.NewInt(42)) + val1 = common.BigToHash(big.NewInt(100)) + val2 = common.BigToHash(big.NewInt(200)) + + genesis = &core.Genesis{ + Config: params.MergedTestChainConfig, + Alloc: types.GenesisAlloc{ + addr1: { + Balance: big.NewInt(params.Ether), + Storage: map[common.Hash]common.Hash{ + slot0: val0, + slot1: val1, + }, + }, + addr2: { + Balance: big.NewInt(params.Ether), + Storage: map[common.Hash]common.Hash{ + slot2: val2, + }, + }, + }, + } + ) + api := NewBlockChainAPI(newTestBackend(t, 1, genesis, beacon.New(ethash.NewFaker()), func(i int, b *core.BlockGen) { + b.SetPoS() + })) + latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber) + + // Happy path: multiple addresses, multiple slots. + result, err := api.GetStorageValues(context.Background(), map[common.Address][]common.Hash{ + addr1: {slot0, slot1}, + addr2: {slot2}, + }, latest) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(result) != 2 { + t.Fatalf("expected 2 addresses in result, got %d", len(result)) + } + if got := common.BytesToHash(result[addr1][0]); got != val0 { + t.Errorf("addr1 slot0: want %x, got %x", val0, got) + } + if got := common.BytesToHash(result[addr1][1]); got != val1 { + t.Errorf("addr1 slot1: want %x, got %x", val1, got) + } + if got := common.BytesToHash(result[addr2][0]); got != val2 { + t.Errorf("addr2 slot2: want %x, got %x", val2, got) + } + + // Missing slot returns zero. + result, err = api.GetStorageValues(context.Background(), map[common.Address][]common.Hash{ + addr1: {common.HexToHash("0xff")}, + }, latest) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got := common.BytesToHash(result[addr1][0]); got != (common.Hash{}) { + t.Errorf("missing slot: want zero, got %x", got) + } + + // Empty request returns error. + _, err = api.GetStorageValues(context.Background(), map[common.Address][]common.Hash{}, latest) + if err == nil { + t.Fatal("expected error for empty request") + } + + // Exceeding slot limit returns error. + tooMany := make([]common.Hash, maxGetStorageSlots+1) + for i := range tooMany { + tooMany[i] = common.BigToHash(big.NewInt(int64(i))) + } + _, err = api.GetStorageValues(context.Background(), map[common.Address][]common.Hash{ + addr1: tooMany, + }, latest) + if err == nil { + t.Fatal("expected error for exceeding slot limit") + } +} diff --git a/internal/ethapi/errors.go b/internal/ethapi/errors.go index 30711a016790..cc79af6f3c1b 100644 --- a/internal/ethapi/errors.go +++ b/internal/ethapi/errors.go @@ -112,7 +112,6 @@ const ( errCodeClientLimitExceeded = -38026 errCodeInternalError = -32603 errCodeInvalidParams = -32602 - errCodeReverted = -32000 errCodeVMError = -32015 errCodeTxSyncTimeout = 4 ) @@ -142,7 +141,7 @@ func txValidationError(err error) *invalidTxError { return &invalidTxError{Message: err.Error(), Code: errCodeIntrinsicGas} case errors.Is(err, core.ErrInsufficientFundsForTransfer): return &invalidTxError{Message: err.Error(), Code: errCodeInsufficientFunds} - case errors.Is(err, core.ErrMaxInitCodeSizeExceeded): + case errors.Is(err, vm.ErrMaxInitCodeSizeExceeded): return &invalidTxError{Message: err.Error(), Code: errCodeMaxInitCodeSizeExceeded} } return &invalidTxError{ diff --git a/internal/ethapi/override/override.go b/internal/ethapi/override/override.go index 9d57a78651da..96ba77ab0a7f 100644 --- a/internal/ethapi/override/override.go +++ b/internal/ethapi/override/override.go @@ -19,7 +19,9 @@ package override import ( "errors" "fmt" + "maps" "math/big" + "slices" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -58,9 +60,13 @@ func (diff *StateOverride) Apply(statedb *state.StateDB, precompiles vm.Precompi if diff == nil { return nil } + // Iterate in deterministic order so error messages and behavior are stable (e.g. for tests). + addrs := slices.SortedFunc(maps.Keys(*diff), common.Address.Cmp) + // Tracks destinations of precompiles that were moved. dirtyAddrs := make(map[common.Address]struct{}) - for addr, account := range *diff { + for _, addr := range addrs { + account := (*diff)[addr] // If a precompile was moved to this address already, it can't be overridden. if _, ok := dirtyAddrs[addr]; ok { return fmt.Errorf("account %s has already been overridden by a precompile", addr.Hex()) diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index e0732c327aa2..fa2ff2c32b35 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -21,6 +21,7 @@ import ( "encoding/json" "errors" "fmt" + "math" "math/big" "time" @@ -43,6 +44,14 @@ const ( // in a single request. maxSimulateBlocks = 256 + // maxSimulateCallsPerBlock is the maximum number of calls allowed in a + // single simulated block. + maxSimulateCallsPerBlock = 5000 + + // maxSimulateTotalCalls is the maximum total number of calls allowed + // across all simulated blocks in a single request. + maxSimulateTotalCalls = 10000 + // timestampIncrement is the default increment between block timestamps. timestampIncrement = 12 ) @@ -59,6 +68,7 @@ type simCallResult struct { ReturnValue hexutil.Bytes `json:"returnData"` Logs []*types.Log `json:"logs"` GasUsed hexutil.Uint64 `json:"gasUsed"` + MaxUsedGas hexutil.Uint64 `json:"maxUsedGas"` Status hexutil.Uint64 `json:"status"` Error *callError `json:"error,omitempty"` } @@ -149,6 +159,39 @@ func (m *simChainHeadReader) GetHeaderByHash(hash common.Hash) *types.Header { return header } +// gasBudget tracks the remaining gas allowed across all simulated blocks. +// It enforces the RPC-level gas cap to prevent DoS. +type gasBudget struct { + remaining uint64 +} + +// newGasBudget creates a gas budget with the given cap. +// A cap of 0 is treated as unlimited. +func newGasBudget(cap uint64) *gasBudget { + if cap == 0 { + cap = math.MaxUint64 + } + return &gasBudget{remaining: cap} +} + +// cap returns the given gas value clamped to the remaining budget. +func (b *gasBudget) cap(gas uint64) uint64 { + if gas > b.remaining { + return b.remaining + } + return gas +} + +// consume deducts the given amount from the budget. +// Returns an error if the amount exceeds the remaining budget. +func (b *gasBudget) consume(amount uint64) error { + if amount > b.remaining { + return fmt.Errorf("RPC gas cap exhausted: need %d, remaining %d", amount, b.remaining) + } + b.remaining -= amount + return nil +} + // simulator is a stateful object that simulates a series of blocks. // it is not safe for concurrent use. type simulator struct { @@ -156,7 +199,7 @@ type simulator struct { state *state.StateDB base *types.Header chainConfig *params.ChainConfig - gp *core.GasPool + budget *gasBudget traceTransfers bool validate bool fullTx bool @@ -200,7 +243,13 @@ func (sim *simulator) execute(ctx context.Context, blocks []simBlock) ([]*simBlo return nil, err } headers[bi] = result.Header() - results[bi] = &simBlockResult{fullTx: sim.fullTx, chainConfig: sim.chainConfig, Block: result, Calls: callResults, senders: senders} + results[bi] = &simBlockResult{ + fullTx: sim.fullTx, + chainConfig: sim.chainConfig, + Block: result, + Calls: callResults, + senders: senders, + } parent = result.Header() } return results, nil @@ -233,16 +282,20 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, if block.BlockOverrides.BlobBaseFee != nil { blockContext.BlobBaseFee = block.BlockOverrides.BlobBaseFee.ToInt() } - precompiles := sim.activePrecompiles(sim.base) + precompiles := sim.activePrecompiles(header) + // State overrides are applied prior to execution of a block if err := block.StateOverrides.Apply(sim.state, precompiles); err != nil { return nil, nil, nil, err } var ( - gasUsed, blobGasUsed uint64 - txes = make([]*types.Transaction, len(block.Calls)) - callResults = make([]simCallResult, len(block.Calls)) - receipts = make([]*types.Receipt, len(block.Calls)) + gp = core.NewGasPool(blockContext.GasLimit) + blobGasUsed uint64 + + txes = make([]*types.Transaction, len(block.Calls)) + callResults = make([]simCallResult, len(block.Calls)) + receipts = make([]*types.Receipt, len(block.Calls)) + // Block hash will be repaired after execution. tracer = newTracer(sim.traceTransfers, blockContext.BlockNumber.Uint64(), blockContext.Time, common.Hash{}, common.Hash{}, 0) vmConfig = &vm.Config{ @@ -259,23 +312,23 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, tracingStateDB = state.NewHookedState(sim.state, hooks) } evm := vm.NewEVM(blockContext, tracingStateDB, sim.chainConfig, *vmConfig) + defer evm.Release() // It is possible to override precompiles with EVM bytecode, or // move them to another address. if precompiles != nil { evm.SetPrecompiles(precompiles) } - if sim.chainConfig.IsPrague(header.Number, header.Time) || sim.chainConfig.IsVerkle(header.Number, header.Time) { - core.ProcessParentBlockHash(header.ParentHash, evm) - } - if header.ParentBeaconRoot != nil { - core.ProcessBeaconBlockRoot(*header.ParentBeaconRoot, evm) - } + // Run pre-execution system calls + core.PreExecution(ctx, header.ParentBeaconRoot, header.ParentHash, sim.chainConfig, evm, header.Number, header.Time) + var allLogs []*types.Log for i, call := range block.Calls { + // Terminate if the context is cancelled if err := ctx.Err(); err != nil { return nil, nil, nil, err } - if err := sim.sanitizeCall(&call, sim.state, header, blockContext, &gasUsed); err != nil { + gasCapped, err := sim.sanitizeCall(&call, sim.state, header, gp) + if err != nil { return nil, nil, nil, err } var ( @@ -285,10 +338,11 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, txes[i] = tx senders[txHash] = call.from() tracer.reset(txHash, uint(i)) - sim.state.SetTxContext(txHash, i) + // EoA check is always skipped, even in validation mode. + sim.state.SetTxContext(txHash, i, uint32(i+1)) msg := call.ToMessage(header.BaseFee, !sim.validate) - result, err := applyMessageWithEVM(ctx, evm, msg, timeout, sim.gp) + result, err := applyMessageWithEVM(ctx, evm, msg, timeout, gp) if err != nil { txErr := txValidationError(err) return nil, nil, nil, txErr @@ -300,19 +354,29 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, } else { root = sim.state.IntermediateRoot(sim.chainConfig.IsEIP158(blockContext.BlockNumber)).Bytes() } - gasUsed += result.UsedGas - receipts[i] = core.MakeReceipt(evm, result, sim.state, blockContext.BlockNumber, common.Hash{}, blockContext.Time, tx, gasUsed, root) + receipts[i] = core.MakeReceipt(evm, result, sim.state, blockContext.BlockNumber, common.Hash{}, blockContext.Time, tx, gp.CumulativeUsed(), root) blobGasUsed += receipts[i].BlobGasUsed + + // Make sure the gas cap is still enforced. It's only for + // internally protection. + if err := sim.budget.consume(result.UsedGas); err != nil { + return nil, nil, nil, err + } + logs := tracer.Logs() - callRes := simCallResult{ReturnValue: result.Return(), Logs: logs, GasUsed: hexutil.Uint64(result.UsedGas)} + callRes := simCallResult{ReturnValue: result.Return(), Logs: logs, GasUsed: hexutil.Uint64(result.UsedGas), MaxUsedGas: hexutil.Uint64(result.MaxUsedGas)} if result.Failed() { callRes.Status = hexutil.Uint64(types.ReceiptStatusFailed) if errors.Is(result.Err, vm.ErrExecutionReverted) { // If the result contains a revert reason, try to unpack it. revertErr := newRevertError(result.Revert()) - callRes.Error = &callError{Message: revertErr.Error(), Code: errCodeReverted, Data: revertErr.ErrorData().(string)} + callRes.Error = &callError{Message: revertErr.Error(), Code: revertErr.ErrorCode(), Data: revertErr.ErrorData().(string)} } else { - callRes.Error = &callError{Message: result.Err.Error(), Code: errCodeVMError} + msg := result.Err.Error() + if gasCapped { + msg += " (gas limit was capped by the RPC server's global gas cap)" + } + callRes.Error = &callError{Message: msg, Code: errCodeVMError} } } else { callRes.Status = hexutil.Uint64(types.ReceiptStatusSuccessful) @@ -320,37 +384,36 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, } callResults[i] = callRes } - header.GasUsed = gasUsed + // Assign total consumed gas to the header + header.GasUsed = gp.Used() if sim.chainConfig.IsCancun(header.Number, header.Time) { header.BlobGasUsed = &blobGasUsed } - var requests [][]byte + // Process EIP-7685 requests - if sim.chainConfig.IsPrague(header.Number, header.Time) { - requests = [][]byte{} - // EIP-6110 - if err := core.ParseDepositLogs(&requests, allLogs, sim.chainConfig); err != nil { - return nil, nil, nil, err - } - // EIP-7002 - if err := core.ProcessWithdrawalQueue(&requests, evm); err != nil { - return nil, nil, nil, err - } - // EIP-7251 - if err := core.ProcessConsolidationQueue(&requests, evm); err != nil { - return nil, nil, nil, err - } + requests, err := core.PostExecution(ctx, sim.chainConfig, header.Number, header.Time, allLogs, evm, uint32(len(block.Calls)+1)) + if err != nil { + return nil, nil, nil, err } if requests != nil { reqHash := types.CalcRequestsHash(requests) header.RequestsHash = &reqHash } - blockBody := &types.Body{Transactions: txes, Withdrawals: *block.BlockOverrides.Withdrawals} - chainHeadReader := &simChainHeadReader{ctx, sim.b} - b, err := sim.b.Engine().FinalizeAndAssemble(chainHeadReader, header, sim.state, blockBody, receipts) - if err != nil { - return nil, nil, nil, err + + blockBody := &types.Body{ + Transactions: txes, } + // Withdrawals are a post-Shanghai field. Attaching a non-nil withdrawals + // slice would cause types.NewBlock to populate WithdrawalsHash on the + // header and emit withdrawals fields for pre-Shanghai blocks. + if sim.chainConfig.IsShanghai(header.Number, header.Time) { + blockBody.Withdrawals = *block.BlockOverrides.Withdrawals + } + chainHeadReader := &simChainHeadReader{ctx, sim.b} + + // Assemble the block + b := core.AssembleBlock(sim.b.Engine(), chainHeadReader, header, sim.state, blockBody, receipts) + repairLogs(callResults, b.Hash()) return b, callResults, senders, nil } @@ -366,23 +429,25 @@ func repairLogs(calls []simCallResult, hash common.Hash) { } } -func (sim *simulator) sanitizeCall(call *TransactionArgs, state vm.StateDB, header *types.Header, blockContext vm.BlockContext, gasUsed *uint64) error { +func (sim *simulator) sanitizeCall(call *TransactionArgs, state vm.StateDB, header *types.Header, gp *core.GasPool) (bool, error) { if call.Nonce == nil { nonce := state.GetNonce(call.from()) call.Nonce = (*hexutil.Uint64)(&nonce) } // Let the call run wild unless explicitly specified. + remaining := gp.Gas() if call.Gas == nil { - remaining := blockContext.GasLimit - *gasUsed call.Gas = (*hexutil.Uint64)(&remaining) } - if *gasUsed+uint64(*call.Gas) > blockContext.GasLimit { - return &blockGasLimitReachedError{fmt.Sprintf("block gas limit reached: %d >= %d", *gasUsed, blockContext.GasLimit)} - } - if err := call.CallDefaults(sim.gp.Gas(), header.BaseFee, sim.chainConfig.ChainID); err != nil { - return err + if remaining < uint64(*call.Gas) { + return false, &blockGasLimitReachedError{fmt.Sprintf("block gas limit reached: remaining: %d, required: %d", remaining, *call.Gas)} } - return nil + // Clamp to the cross-block gas budget. + gas := sim.budget.cap(uint64(*call.Gas)) + gasCapped := gas < uint64(*call.Gas) + call.Gas = (*hexutil.Uint64)(&gas) + + return gasCapped, call.CallDefaults(0, header.BaseFee, sim.chainConfig.ChainID) } func (sim *simulator) activePrecompiles(base *types.Header) vm.PrecompiledContracts { @@ -473,12 +538,14 @@ func (sim *simulator) makeHeaders(blocks []simBlock) ([]*types.Header, error) { } overrides := block.BlockOverrides - var withdrawalsHash *common.Hash number := overrides.Number.ToInt() timestamp := (uint64)(*overrides.Time) + + var withdrawalsHash *common.Hash if sim.chainConfig.IsShanghai(number, timestamp) { withdrawalsHash = &types.EmptyWithdrawalsHash } + var parentBeaconRoot *common.Hash if sim.chainConfig.IsCancun(number, timestamp) { parentBeaconRoot = &common.Hash{} @@ -508,7 +575,11 @@ func (sim *simulator) makeHeaders(blocks []simBlock) ([]*types.Header, error) { } func (sim *simulator) newSimulatedChainContext(ctx context.Context, headers []*types.Header) *ChainContext { - return NewChainContext(ctx, &simBackend{base: sim.base, b: sim.b, headers: headers}) + return NewChainContext(ctx, &simBackend{ + base: sim.base, + b: sim.b, + headers: headers, + }) } type simBackend struct { diff --git a/internal/ethapi/simulate_test.go b/internal/ethapi/simulate_test.go index c747b76477b8..6a83e744deda 100644 --- a/internal/ethapi/simulate_test.go +++ b/internal/ethapi/simulate_test.go @@ -80,7 +80,10 @@ func TestSimulateSanitizeBlockOrder(t *testing.T) { err: "block timestamps must be in order: 72 <= 72", }, } { - sim := &simulator{base: &types.Header{Number: big.NewInt(int64(tc.baseNumber)), Time: tc.baseTimestamp}} + sim := &simulator{ + base: &types.Header{Number: big.NewInt(int64(tc.baseNumber)), Time: tc.baseTimestamp}, + budget: newGasBudget(0), + } res, err := sim.sanitizeChain(tc.blocks) if err != nil { if err.Error() == tc.err { diff --git a/internal/ethapi/testdata/eth_getBlockByHash-hash-latest-1-fullTx.json b/internal/ethapi/testdata/eth_getBlockByHash-hash-latest-1-fullTx.json index 3c8d42c9a946..6aac5b682e51 100644 --- a/internal/ethapi/testdata/eth_getBlockByHash-hash-latest-1-fullTx.json +++ b/internal/ethapi/testdata/eth_getBlockByHash-hash-latest-1-fullTx.json @@ -20,6 +20,7 @@ { "blockHash": "0xedb9ccf3a85f67c095ad48abfb0fa09d47179bb0f902078d289042d12428aca5", "blockNumber": "0x9", + "blockTimestamp": "0x5a", "from": "0x703c4b2bd70c169f5717101caee543299fc946c7", "gas": "0x5208", "gasPrice": "0x121a9cca", diff --git a/internal/ethapi/testdata/eth_getBlockByNumber-number-latest-1.json b/internal/ethapi/testdata/eth_getBlockByNumber-number-latest-1.json index 3c8d42c9a946..6aac5b682e51 100644 --- a/internal/ethapi/testdata/eth_getBlockByNumber-number-latest-1.json +++ b/internal/ethapi/testdata/eth_getBlockByNumber-number-latest-1.json @@ -20,6 +20,7 @@ { "blockHash": "0xedb9ccf3a85f67c095ad48abfb0fa09d47179bb0f902078d289042d12428aca5", "blockNumber": "0x9", + "blockTimestamp": "0x5a", "from": "0x703c4b2bd70c169f5717101caee543299fc946c7", "gas": "0x5208", "gasPrice": "0x121a9cca", diff --git a/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json b/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json index 2e323dcfe7e1..fc60111244b1 100644 --- a/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json +++ b/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json @@ -20,6 +20,7 @@ { "blockHash": "0xfda6c7cb7a3a712e0c424909a7724cab0448e89e286617fa8d5fd27f63f28bd2", "blockNumber": "0xb", + "blockTimestamp": "0x6e", "from": "0x703c4b2bd70c169f5717101caee543299fc946c7", "gas": "0x5208", "gasPrice": "0xde56ab3", diff --git a/internal/ethapi/transaction_args.go b/internal/ethapi/transaction_args.go index 23aa8e5947a6..1032d067f1e7 100644 --- a/internal/ethapi/transaction_args.go +++ b/internal/ethapi/transaction_args.go @@ -155,6 +155,7 @@ func (args *TransactionArgs) setDefaults(ctx context.Context, b Backend, config AccessList: args.AccessList, BlobFeeCap: args.BlobFeeCap, BlobHashes: args.BlobHashes, + AuthorizationList: args.AuthorizationList, } latestBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber) estimated, err := DoEstimateGas(ctx, b, callArgs, latestBlockNr, nil, nil, b.RPCGasCap()) @@ -329,8 +330,8 @@ func (args *TransactionArgs) setBlobTxSidecar(ctx context.Context, config sideca commitments = make([]kzg4844.Commitment, n) proofs = make([]kzg4844.Proof, 0, proofLen) ) - for i, b := range args.Blobs { - c, err := kzg4844.BlobToCommitment(&b) + for i := range args.Blobs { + c, err := kzg4844.BlobToCommitment(&args.Blobs[i]) if err != nil { return fmt.Errorf("blobs[%d]: error computing commitment: %v", i, err) } @@ -338,13 +339,13 @@ func (args *TransactionArgs) setBlobTxSidecar(ctx context.Context, config sideca switch config.blobSidecarVersion { case types.BlobSidecarVersion0: - p, err := kzg4844.ComputeBlobProof(&b, c) + p, err := kzg4844.ComputeBlobProof(&args.Blobs[i], c) if err != nil { return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err) } proofs = append(proofs, p) case types.BlobSidecarVersion1: - ps, err := kzg4844.ComputeCellProofs(&b) + ps, err := kzg4844.ComputeCellProofs(&args.Blobs[i]) if err != nil { return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err) } @@ -356,8 +357,8 @@ func (args *TransactionArgs) setBlobTxSidecar(ctx context.Context, config sideca } else { switch config.blobSidecarVersion { case types.BlobSidecarVersion0: - for i, b := range args.Blobs { - if err := kzg4844.VerifyBlobProof(&b, args.Commitments[i], args.Proofs[i]); err != nil { + for i := range args.Blobs { + if err := kzg4844.VerifyBlobProof(&args.Blobs[i], args.Commitments[i], args.Proofs[i]); err != nil { return fmt.Errorf("failed to verify blob proof: %v", err) } } @@ -445,27 +446,27 @@ func (args *TransactionArgs) CallDefaults(globalGasCap uint64, baseFee *big.Int, // Assumes that fields are not nil, i.e. setDefaults or CallDefaults has been called. func (args *TransactionArgs) ToMessage(baseFee *big.Int, skipNonceCheck bool) *core.Message { var ( - gasPrice *big.Int - gasFeeCap *big.Int - gasTipCap *big.Int + gasPrice *uint256.Int + gasFeeCap *uint256.Int + gasTipCap *uint256.Int ) if baseFee == nil { - gasPrice = args.GasPrice.ToInt() + gasPrice, _ = args.GasPrice.ToUint256() gasFeeCap, gasTipCap = gasPrice, gasPrice } else { // A basefee is provided, necessitating 1559-type execution if args.GasPrice != nil { // User specified the legacy gas field, convert to 1559 gas typing - gasPrice = args.GasPrice.ToInt() + gasPrice, _ = args.GasPrice.ToUint256() gasFeeCap, gasTipCap = gasPrice, gasPrice } else { // User specified 1559 gas fields (or none), use those - gasFeeCap = args.MaxFeePerGas.ToInt() - gasTipCap = args.MaxPriorityFeePerGas.ToInt() + gasFeeCap, _ = args.MaxFeePerGas.ToUint256() + gasTipCap, _ = args.MaxPriorityFeePerGas.ToUint256() // Backfill the legacy gasPrice for EVM execution, unless we're all zeroes - gasPrice = new(big.Int) + gasPrice = uint256.NewInt(0) if gasFeeCap.BitLen() > 0 || gasTipCap.BitLen() > 0 { - gasPrice = gasPrice.Add(gasTipCap, baseFee) + gasPrice = gasPrice.Add(gasTipCap, uint256.MustFromBig(baseFee)) if gasPrice.Cmp(gasFeeCap) > 0 { gasPrice = gasFeeCap } @@ -476,10 +477,12 @@ func (args *TransactionArgs) ToMessage(baseFee *big.Int, skipNonceCheck bool) *c if args.AccessList != nil { accessList = *args.AccessList } + value, _ := args.Value.ToUint256() + blobFeeCap, _ := args.BlobFeeCap.ToUint256() return &core.Message{ From: args.from(), To: args.To, - Value: (*big.Int)(args.Value), + Value: value, Nonce: uint64(*args.Nonce), GasLimit: uint64(*args.Gas), GasPrice: gasPrice, @@ -487,7 +490,7 @@ func (args *TransactionArgs) ToMessage(baseFee *big.Int, skipNonceCheck bool) *c GasTipCap: gasTipCap, Data: args.data(), AccessList: accessList, - BlobGasFeeCap: (*big.Int)(args.BlobFeeCap), + BlobGasFeeCap: blobFeeCap, BlobHashes: args.BlobHashes, SetCodeAuthorizations: args.AuthorizationList, SkipNonceChecks: skipNonceCheck, diff --git a/internal/flags/helpers.go b/internal/flags/helpers.go index fc84ae85da84..e6a6966d9ffa 100644 --- a/internal/flags/helpers.go +++ b/internal/flags/helpers.go @@ -40,7 +40,7 @@ func NewApp(usage string) *cli.App { app.EnableBashCompletion = true app.Version = version.WithCommit(git.Commit, git.Date) app.Usage = usage - app.Copyright = "Copyright 2013-2025 The go-ethereum Authors" + app.Copyright = "Copyright 2013-2026 The go-ethereum Authors" app.Before = func(ctx *cli.Context) error { MigrateGlobalFlags(ctx) return nil diff --git a/core/rawdb/database_tablewriter.go b/internal/tablewriter/database_tablewriter.go similarity index 97% rename from core/rawdb/database_tablewriter.go rename to internal/tablewriter/database_tablewriter.go index e1cda5c93fa5..c080a69c1541 100644 --- a/core/rawdb/database_tablewriter.go +++ b/internal/tablewriter/database_tablewriter.go @@ -16,7 +16,7 @@ // Naive stub implementation for tablewriter -package rawdb +package tablewriter import ( "errors" @@ -37,7 +37,7 @@ type Table struct { rows [][]string } -func NewTableWriter(w io.Writer) *Table { +func NewWriter(w io.Writer) *Table { return &Table{out: w} } @@ -58,12 +58,12 @@ func (t *Table) SetFooter(footer []string) { t.footer = footer } -// AppendBulk sets all data rows for the table at once, replacing any existing rows. +// AppendBulk appends one or more data rows to the table. // // Each row must have the same number of columns as the headers, or validation // will fail during Render(). func (t *Table) AppendBulk(rows [][]string) { - t.rows = rows + t.rows = append(t.rows, rows...) } // Render outputs the complete table to the configured writer. The table is rendered diff --git a/core/rawdb/database_tablewriter_test.go b/internal/tablewriter/database_tablewriter_test.go similarity index 94% rename from core/rawdb/database_tablewriter_test.go rename to internal/tablewriter/database_tablewriter_test.go index e9de5d8ce864..b915dcdda8ca 100644 --- a/core/rawdb/database_tablewriter_test.go +++ b/internal/tablewriter/database_tablewriter_test.go @@ -14,7 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package rawdb +package tablewriter import ( "bytes" @@ -24,7 +24,7 @@ import ( func TestTableWriterTinyGo(t *testing.T) { var buf bytes.Buffer - table := NewTableWriter(&buf) + table := NewWriter(&buf) headers := []string{"Database", "Size", "Items", "Status"} rows := [][]string{ @@ -48,7 +48,7 @@ func TestTableWriterValidationErrors(t *testing.T) { // Test missing headers t.Run("MissingHeaders", func(t *testing.T) { var buf bytes.Buffer - table := NewTableWriter(&buf) + table := NewWriter(&buf) rows := [][]string{{"x", "y", "z"}} @@ -63,7 +63,7 @@ func TestTableWriterValidationErrors(t *testing.T) { t.Run("NotEnoughRowColumns", func(t *testing.T) { var buf bytes.Buffer - table := NewTableWriter(&buf) + table := NewWriter(&buf) headers := []string{"A", "B", "C"} badRows := [][]string{ @@ -82,7 +82,7 @@ func TestTableWriterValidationErrors(t *testing.T) { t.Run("TooManyRowColumns", func(t *testing.T) { var buf bytes.Buffer - table := NewTableWriter(&buf) + table := NewWriter(&buf) headers := []string{"A", "B", "C"} badRows := [][]string{ @@ -102,7 +102,7 @@ func TestTableWriterValidationErrors(t *testing.T) { // Test mismatched footer columns t.Run("MismatchedFooterColumns", func(t *testing.T) { var buf bytes.Buffer - table := NewTableWriter(&buf) + table := NewWriter(&buf) headers := []string{"A", "B", "C"} rows := [][]string{{"x", "y", "z"}} diff --git a/internal/telemetry/telemetry.go b/internal/telemetry/telemetry.go new file mode 100644 index 000000000000..27fe9b0a7a44 --- /dev/null +++ b/internal/telemetry/telemetry.go @@ -0,0 +1,109 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package telemetry + +import ( + "context" + "fmt" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + semconv "go.opentelemetry.io/otel/semconv/v1.38.0" + "go.opentelemetry.io/otel/trace" +) + +// Attribute is an alias for attribute.KeyValue. +type Attribute = attribute.KeyValue + +// StringAttribute creates an attribute with a string value. +func StringAttribute(key, val string) Attribute { + return attribute.String(key, val) +} + +// Int64Attribute creates an attribute with an int64 value. +func Int64Attribute(key string, val int64) Attribute { + return attribute.Int64(key, val) +} + +// BoolAttribute creates an attribute with a bool value. +func BoolAttribute(key string, val bool) Attribute { + return attribute.Bool(key, val) +} + +// StartSpan creates a SpanKind=INTERNAL span. +func StartSpan(ctx context.Context, spanName string, attributes ...Attribute) (context.Context, trace.Span, func(*error)) { + return StartSpanWithTracer(ctx, otel.Tracer(""), spanName, attributes...) +} + +// StartSpanWithTracer requires a tracer to be passed in and creates a SpanKind=INTERNAL span. +func StartSpanWithTracer(ctx context.Context, tracer trace.Tracer, name string, attributes ...Attribute) (context.Context, trace.Span, func(*error)) { + // Don't create a span if there's no parent span in the context. + parent := trace.SpanFromContext(ctx) + if !parent.SpanContext().IsValid() { + return ctx, parent, func(*error) {} + } + return startSpan(ctx, tracer, trace.SpanKindInternal, name, attributes...) +} + +// RPCInfo contains information about the RPC request. +type RPCInfo struct { + System string + Service string + Method string + RequestID string +} + +// StartServerSpan creates a SpanKind=SERVER span at the JSON-RPC boundary. +// The span name is formatted as $rpcSystem.$rpcService/$rpcMethod +// (e.g. "jsonrpc.engine/newPayloadV4") which follows the Open Telemetry +// semantic convensions: https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/#span-name. +func StartServerSpan(ctx context.Context, tracer trace.Tracer, rpc RPCInfo, others ...Attribute) (context.Context, func(*error)) { + var ( + name = fmt.Sprintf("%s.%s/%s", rpc.System, rpc.Service, rpc.Method) + attributes = append([]Attribute{ + semconv.RPCSystemKey.String(rpc.System), + semconv.RPCServiceKey.String(rpc.Service), + semconv.RPCMethodKey.String(rpc.Method), + semconv.RPCJSONRPCRequestID(rpc.RequestID), + }, + others..., + ) + ) + ctx, _, end := startSpan(ctx, tracer, trace.SpanKindServer, name, attributes...) + return ctx, end +} + +// startSpan creates a span with the given kind. +func startSpan(ctx context.Context, tracer trace.Tracer, kind trace.SpanKind, spanName string, attributes ...Attribute) (context.Context, trace.Span, func(*error)) { + ctx, span := tracer.Start(ctx, spanName, trace.WithSpanKind(kind)) + if len(attributes) > 0 { + span.SetAttributes(attributes...) + } + return ctx, span, endSpan(span) +} + +// endSpan ends the span and handles error recording. +func endSpan(span trace.Span) func(*error) { + return func(err *error) { + if err != nil && *err != nil { + span.RecordError(*err) + span.SetStatus(codes.Error, (*err).Error()) + } + span.End() + } +} diff --git a/internal/telemetry/telemetry_test.go b/internal/telemetry/telemetry_test.go new file mode 100644 index 000000000000..def85b735ed6 --- /dev/null +++ b/internal/telemetry/telemetry_test.go @@ -0,0 +1,98 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package telemetry + +import ( + "context" + "testing" + + sdktrace "go.opentelemetry.io/otel/sdk/trace" + "go.opentelemetry.io/otel/sdk/trace/tracetest" + "go.opentelemetry.io/otel/trace" +) + +// newTestTracer creates a TracerProvider backed by an in-memory exporter. +func newTestTracer(t *testing.T) (trace.Tracer, *sdktrace.TracerProvider, *tracetest.InMemoryExporter) { + t.Helper() + exporter := tracetest.NewInMemoryExporter() + tp := sdktrace.NewTracerProvider(sdktrace.WithSyncer(exporter)) + t.Cleanup(func() { _ = tp.Shutdown(context.Background()) }) + return tp.Tracer("test"), tp, exporter +} + +func TestStartSpanWithTracer_NoParent(t *testing.T) { + t.Parallel() + tracer, tp, exporter := newTestTracer(t) + + // Create a span without a parent. + ctx := context.Background() + retCtx, _, endSpan := StartSpanWithTracer(ctx, tracer, "should-not-exist") + endSpan(nil) + + // The returned context should be the original context (unchanged). + if retCtx != ctx { + t.Fatal("expected original context to be returned unchanged") + } + + // Flush and verify no spans were recorded. + if err := tp.ForceFlush(context.Background()); err != nil { + t.Fatalf("failed to flush: %v", err) + } + spans := exporter.GetSpans() + if len(spans) != 0 { + t.Fatalf("expected no spans, got %d", len(spans)) + } +} + +func TestStartSpanWithTracer_WithParent(t *testing.T) { + t.Parallel() + tracer, tp, exporter := newTestTracer(t) + + // Create a parent span to establish a valid span context. + ctx, parentSpan := tracer.Start(context.Background(), "parent") + defer parentSpan.End() + + // Should create a real child span. + _, _, endSpan := StartSpanWithTracer(ctx, tracer, "child") + endSpan(nil) + + // Flush and verify the child span was recorded. + parentSpan.End() + if err := tp.ForceFlush(context.Background()); err != nil { + t.Fatalf("failed to flush: %v", err) + } + spans := exporter.GetSpans() + var childSpan *tracetest.SpanStub + for i := range spans { + if spans[i].Name == "child" { + childSpan = &spans[i] + break + } + } + if childSpan == nil { + t.Fatal("child span not found") + } + + // Verify it is parented to the correct trace. + if childSpan.Parent.TraceID() != parentSpan.SpanContext().TraceID() { + t.Errorf("trace ID mismatch: got %s, want %s", + childSpan.Parent.TraceID(), parentSpan.SpanContext().TraceID()) + } + if childSpan.SpanKind != trace.SpanKindInternal { + t.Errorf("expected SpanKindInternal, got %v", childSpan.SpanKind) + } +} diff --git a/internal/telemetry/tracesetup/setup.go b/internal/telemetry/tracesetup/setup.go new file mode 100644 index 000000000000..08c5f739b64a --- /dev/null +++ b/internal/telemetry/tracesetup/setup.go @@ -0,0 +1,183 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package tracesetup + +import ( + "context" + "encoding/base64" + "fmt" + "net/url" + "strings" + "time" + + "github.com/ethereum/go-ethereum/internal/version" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/node" + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/exporters/otlp/otlptrace" + "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc" + "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp" + "go.opentelemetry.io/otel/propagation" + "go.opentelemetry.io/otel/sdk/resource" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + semconv "go.opentelemetry.io/otel/semconv/v1.38.0" +) + +const startStopTimeout = 10 * time.Second + +// Service wraps the provider to implement node.Lifecycle. +type Service struct { + endpoint string + exporter *otlptrace.Exporter + provider *sdktrace.TracerProvider +} + +// Start implements node.Lifecycle. +func (t *Service) Start() error { + ctx, cancel := context.WithTimeout(context.Background(), startStopTimeout) + defer cancel() + if err := t.exporter.Start(ctx); err != nil { + log.Error("OpenTelemetry exporter didn't start", "endpoint", t.endpoint, "err", err) + return err + } + log.Info("OpenTelemetry trace export enabled", "endpoint", t.endpoint) + return nil +} + +// Stop implements node.Lifecycle. +func (t *Service) Stop() error { + ctx, cancel := context.WithTimeout(context.Background(), startStopTimeout) + defer cancel() + if err := t.provider.Shutdown(ctx); err != nil { + log.Error("Failed to stop OpenTelemetry service", "err", err) + return err + } + log.Debug("OpenTelemetry stopped") + return nil +} + +// SetupTelemetry initializes telemetry with the given parameters. +func SetupTelemetry(cfg node.OpenTelemetryConfig, stack *node.Node) error { + if !cfg.Enabled { + return nil + } + if cfg.SampleRatio < 0 || cfg.SampleRatio > 1 { + return fmt.Errorf("invalid sample ratio: %f", cfg.SampleRatio) + } + // Create exporter based on endpoint URL + u, err := url.Parse(cfg.Endpoint) + if err != nil { + return fmt.Errorf("invalid rpc tracing endpoint URL: %w", err) + } + // Build auth headers once, shared across transports. + var authHeaders map[string]string + if cfg.AuthUser != "" { + authHeaders = map[string]string{ + "Authorization": "Basic " + base64.StdEncoding.EncodeToString([]byte(cfg.AuthUser+":"+cfg.AuthPassword)), + } + } + + var exporter *otlptrace.Exporter + switch u.Scheme { + case "http", "https": + opts := []otlptracehttp.Option{ + otlptracehttp.WithEndpoint(u.Host), + } + if u.Scheme == "http" { + opts = append(opts, otlptracehttp.WithInsecure()) + } + if u.Path != "" && u.Path != "/" { + opts = append(opts, otlptracehttp.WithURLPath(u.Path)) + } + if authHeaders != nil { + opts = append(opts, otlptracehttp.WithHeaders(authHeaders)) + } + exporter = otlptracehttp.NewUnstarted(opts...) + case "grpc", "grpcs": + if u.Path != "" && u.Path != "/" { + return fmt.Errorf("gRPC endpoints do not support URL paths: %s", u.Path) + } + opts := []otlptracegrpc.Option{ + otlptracegrpc.WithEndpoint(u.Host), + } + if u.Scheme == "grpc" { + opts = append(opts, otlptracegrpc.WithInsecure()) + } + if authHeaders != nil { + opts = append(opts, otlptracegrpc.WithHeaders(authHeaders)) + } + exporter = otlptracegrpc.NewUnstarted(opts...) + default: + return fmt.Errorf("unsupported telemetry url scheme: %s", u.Scheme) + } + + // Define sampler such that if no parent span is available, + // then sampleRatio of traces are sampled; otherwise, inherit + // the parent's sampling decision. + sampler := sdktrace.ParentBased(sdktrace.TraceIDRatioBased(cfg.SampleRatio)) + + // Define batch span processor options + batchOpts := []sdktrace.BatchSpanProcessorOption{ + // The maximum number of spans that can be queued before dropping + sdktrace.WithMaxQueueSize(sdktrace.DefaultMaxQueueSize), + // The maximum number of spans to export in a single batch + sdktrace.WithMaxExportBatchSize(sdktrace.DefaultMaxExportBatchSize), + // How long an export operation can take before timing out + sdktrace.WithExportTimeout(time.Duration(sdktrace.DefaultExportTimeout) * time.Millisecond), + // How often to export, even if the batch isn't full + sdktrace.WithBatchTimeout(time.Duration(sdktrace.DefaultScheduleDelay) * time.Millisecond), + } + + // Define resource attributes + var attr = []attribute.KeyValue{ + semconv.ServiceName("geth"), + attribute.String("client.name", version.ClientName("geth")), + } + // Add instance ID if provided + if cfg.InstanceID != "" { + attr = append(attr, semconv.ServiceInstanceID(cfg.InstanceID)) + } + // Add custom tags if provided + if cfg.Tags != "" { + for tag := range strings.SplitSeq(cfg.Tags, ",") { + key, value, ok := strings.Cut(tag, "=") + if ok { + attr = append(attr, attribute.String(key, value)) + } + } + } + res := resource.NewWithAttributes(semconv.SchemaURL, attr...) + + // Configure TracerProvider and set it as the global tracer provider + tp := sdktrace.NewTracerProvider( + sdktrace.WithSampler(sampler), + sdktrace.WithBatcher(exporter, batchOpts...), + sdktrace.WithResource(res), + ) + otel.SetTracerProvider(tp) + + // Set global propagator for context propagation + // Note: This is needed for distributed tracing + otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator( + propagation.TraceContext{}, + propagation.Baggage{}, + )) + service := &Service{endpoint: cfg.Endpoint, exporter: exporter, provider: tp} + stack.RegisterLifecycle(service) + return nil +} diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go index 0aedffe2307a..1d1b5fbcd1e0 100644 --- a/internal/web3ext/web3ext.go +++ b/internal/web3ext/web3ext.go @@ -427,11 +427,6 @@ web3._extend({ params: 2, inputFormatter:[null, null], }), - new web3._extend.Method({ - name: 'freezeClient', - call: 'debug_freezeClient', - params: 1, - }), new web3._extend.Method({ name: 'getAccessibleState', call: 'debug_getAccessibleState', @@ -474,6 +469,12 @@ web3._extend({ params: 1, inputFormatter: [null], }), + new web3._extend.Method({ + name: 'executionWitness', + call: 'debug_executionWitness', + params: 1, + inputFormatter: [null], + }), ], properties: [] }); @@ -567,6 +568,12 @@ web3._extend({ params: 3, inputFormatter: [web3._extend.formatters.inputAddressFormatter, null, web3._extend.formatters.inputBlockNumberFormatter] }), + new web3._extend.Method({ + name: 'getStorageValues', + call: 'eth_getStorageValues', + params: 2, + inputFormatter: [null, web3._extend.formatters.inputBlockNumberFormatter] + }), new web3._extend.Method({ name: 'createAccessList', call: 'eth_createAccessList', diff --git a/log/handler_glog.go b/log/handler_glog.go index 739f8c5b427d..13afb62ca437 100644 --- a/log/handler_glog.go +++ b/log/handler_glog.go @@ -19,9 +19,7 @@ package log import ( "context" "errors" - "fmt" "log/slog" - "maps" "regexp" "runtime" "strconv" @@ -38,22 +36,22 @@ var errVmoduleSyntax = errors.New("expect comma-separated list of filename=N") // matches; and requesting backtraces at certain positions. type GlogHandler struct { origin slog.Handler // The origin handler this wraps + lock sync.Mutex // synchronizes writes to config + config atomic.Pointer[glogConfig] +} - level atomic.Int32 // Current log level, atomically accessible - override atomic.Bool // Flag whether overrides are used, atomically accessible - - patterns []pattern // Current list of patterns to override with - siteCache map[uintptr]slog.Level // Cache of callsite pattern evaluations - location string // file:line location where to do a stackdump at - lock sync.RWMutex // Lock protecting the override pattern list +type glogConfig struct { + patterns []pattern + cache sync.Map + level slog.Level } // NewGlogHandler creates a new log handler with filtering functionality similar // to Google's glog logger. The returned handler implements Handler. -func NewGlogHandler(h slog.Handler) *GlogHandler { - return &GlogHandler{ - origin: h, - } +func NewGlogHandler(origin slog.Handler) *GlogHandler { + h := &GlogHandler{origin: origin} + h.config.Store(new(glogConfig)) + return h } // pattern contains a filter for the Vmodule option, holding a verbosity level @@ -66,7 +64,12 @@ type pattern struct { // Verbosity sets the glog verbosity ceiling. The verbosity of individual packages // and source files can be raised using Vmodule. func (h *GlogHandler) Verbosity(level slog.Level) { - h.level.Store(int32(level)) + h.lock.Lock() + defer h.lock.Unlock() + + cfg := h.config.Load() + newcfg := &glogConfig{level: level, patterns: cfg.patterns} + h.config.Store(newcfg) } // Vmodule sets the glog verbosity pattern. @@ -128,13 +131,13 @@ func (h *GlogHandler) Vmodule(ruleset string) error { re, _ := regexp.Compile(matcher) filter = append(filter, pattern{re, level}) } + // Swap out the vmodule pattern for the new filter system h.lock.Lock() - defer h.lock.Unlock() - - h.patterns = filter - h.siteCache = make(map[uintptr]slog.Level) - h.override.Store(len(filter) != 0) + cfg := h.config.Load() + newcfg := &glogConfig{level: cfg.level, patterns: filter} + h.config.Store(newcfg) + h.lock.Unlock() return nil } @@ -142,30 +145,9 @@ func (h *GlogHandler) Vmodule(ruleset string) error { // Enabled implements slog.Handler, reporting whether the handler handles records // at the given level. func (h *GlogHandler) Enabled(ctx context.Context, lvl slog.Level) bool { - // fast-track skipping logging if override not enabled and the provided verbosity is above configured - return h.override.Load() || slog.Level(h.level.Load()) <= lvl -} - -// WithAttrs implements slog.Handler, returning a new Handler whose attributes -// consist of both the receiver's attributes and the arguments. -func (h *GlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler { - h.lock.RLock() - siteCache := maps.Clone(h.siteCache) - h.lock.RUnlock() - - patterns := []pattern{} - patterns = append(patterns, h.patterns...) - - res := GlogHandler{ - origin: h.origin.WithAttrs(attrs), - patterns: patterns, - siteCache: siteCache, - location: h.location, - } - - res.level.Store(h.level.Load()) - res.override.Store(h.override.Load()) - return &res + // fast-track skipping logging if vmodule is not enabled or level too low + cfg := h.config.Load() + return len(cfg.patterns) > 0 || cfg.level <= lvl } // WithGroup implements slog.Handler, returning a new Handler with the given @@ -178,37 +160,70 @@ func (h *GlogHandler) WithGroup(name string) slog.Handler { // Handle implements slog.Handler, filtering a log record through the global, // local and backtrace filters, finally emitting it if either allow it through. -func (h *GlogHandler) Handle(_ context.Context, r slog.Record) error { - // If the global log level allows, fast track logging - if slog.Level(h.level.Load()) <= r.Level { - return h.origin.Handle(context.Background(), r) - } - - // Check callsite cache for previously calculated log levels - h.lock.RLock() - lvl, ok := h.siteCache[r.PC] - h.lock.RUnlock() +func (h *GlogHandler) Handle(ctx context.Context, r slog.Record) error { + return h.handle(ctx, r, h.origin) +} - // If we didn't cache the callsite yet, calculate it - if !ok { - h.lock.Lock() +func (h *GlogHandler) handle(ctx context.Context, r slog.Record, origin slog.Handler) error { + cfg := h.config.Load() + var lvl slog.Level + cachedLvl, ok := cfg.cache.Load(r.PC) + if ok { + // Fast path: cache hit + lvl = cachedLvl.(slog.Level) + } else { + // Resolve the callsite file. fs := runtime.CallersFrames([]uintptr{r.PC}) frame, _ := fs.Next() - - for _, rule := range h.patterns { - if rule.pattern.MatchString(fmt.Sprintf("+%s", frame.File)) { - h.siteCache[r.PC], lvl, ok = rule.level, rule.level, true + file := frame.File + // Match against patterns and cache the level applied at this callsite. + lvl = cfg.level // default: use global level + for _, rule := range cfg.patterns { + if rule.pattern.MatchString("+" + file) { + lvl = rule.level } } - // If no rule matched, remember to drop log the next time - if !ok { - h.siteCache[r.PC] = 0 - } - h.lock.Unlock() + cfg.cache.Store(r.PC, lvl) } + + // Handle the message. if lvl <= r.Level { - return h.origin.Handle(context.Background(), r) + return origin.Handle(ctx, r) } return nil } + +// WithAttrs implements slog.Handler, returning a new Handler whose attributes +// consist of both the receiver's attributes and the arguments. +// +// Note the handler created here will still listen to Verbosity and Vmodule settings +// done on the original handler. +func (h *GlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler { + return &glogWithAttrs{base: h, origin: h.origin.WithAttrs(attrs)} +} + +type glogWithAttrs struct { + base *GlogHandler + origin slog.Handler +} + +func (wh *glogWithAttrs) Enabled(ctx context.Context, lvl slog.Level) bool { + return wh.base.Enabled(ctx, lvl) +} + +func (wh *glogWithAttrs) Handle(ctx context.Context, r slog.Record) error { + return wh.base.handle(ctx, r, wh.origin) +} + +func (wh *glogWithAttrs) WithAttrs(attrs []slog.Attr) slog.Handler { + return &glogWithAttrs{base: wh.base, origin: wh.origin.WithAttrs(attrs)} +} + +// WithGroup implements slog.Handler, returning a new Handler with the given +// group appended to the receiver's existing groups. +// +// Note, this function is not implemented. +func (wh *glogWithAttrs) WithGroup(name string) slog.Handler { + panic("not implemented") +} diff --git a/log/logger_test.go b/log/logger_test.go index dae84972048a..c585ddab6699 100644 --- a/log/logger_test.go +++ b/log/logger_test.go @@ -33,6 +33,64 @@ func TestLoggingWithVmodule(t *testing.T) { } } +// TestLoggingWithVmoduleDowngrade checks that vmodule can be downgraded. +func TestLoggingWithVmoduleDowngrade(t *testing.T) { + out := new(bytes.Buffer) + glog := NewGlogHandler(NewTerminalHandlerWithLevel(out, LevelTrace, false)) + glog.Verbosity(LevelTrace) // Allow all logs globally + logger := NewLogger(glog) + + // This should appear (global level allows it) + logger.Info("before vmodule downgrade, this should be logged") + if !bytes.Contains(out.Bytes(), []byte("before vmodule downgrade")) { + t.Fatal("expected 'before vmodule downgrade' to be logged") + } + out.Reset() + + // Downgrade this file to only allow Warn and above + glog.Vmodule("logger_test.go=2") + + // Info should now be filtered out + logger.Info("after vmodule downgrade, this should be filtered") + if bytes.Contains(out.Bytes(), []byte("after vmodule downgrade, this should be filtered")) { + t.Fatal("expected 'after vmodule downgrade, this should be filtered' to NOT be logged after vmodule downgrade") + } + + // Warn should still appear + logger.Warn("after vmodule downgrade, this should be logged") + if !bytes.Contains(out.Bytes(), []byte("after vmodule downgrade, this should be logged")) { + t.Fatal("expected 'should appear' to be logged") + } +} + +// TestWithAttrsVerbosityChange checks that verbosity changes affect child loggers. +func TestWithAttrsVerbosityChange(t *testing.T) { + out := new(bytes.Buffer) + glog := NewGlogHandler(NewTerminalHandlerWithLevel(out, LevelTrace, false)) + glog.Verbosity(LevelInfo) + + // Create a child logger with an extra attribute. + child := slog.New(glog.WithAttrs([]slog.Attr{slog.String("peer", "foo")})) + + // Debug should be filtered at Info level. + child.Debug("this should be filtered") + if bytes.Contains(out.Bytes(), []byte("this should be filtered")) { + t.Fatal("expected debug message to be filtered at Info level") + } + + // Change verbosity on the parent to allow Debug. + glog.Verbosity(LevelDebug) + + // Child should pick up the new level and include its attributes. + child.Debug("this should be logged") + if !bytes.Contains(out.Bytes(), []byte("this should be logged")) { + t.Fatal("expected child logger to pick up verbosity change") + } + if !bytes.Contains(out.Bytes(), []byte("peer=foo")) { + t.Fatal("expected child logger to include WithAttrs attributes") + } +} + func TestTerminalHandlerWithAttrs(t *testing.T) { out := new(bytes.Buffer) glog := NewGlogHandler(NewTerminalHandlerWithLevel(out, LevelTrace, false).WithAttrs([]slog.Attr{slog.String("baz", "bat")})) diff --git a/metrics/config.go b/metrics/config.go index 72f94dd194c9..3d3cb693fd0a 100644 --- a/metrics/config.go +++ b/metrics/config.go @@ -16,18 +16,21 @@ package metrics +import "time" + // Config contains the configuration for the metric collection. type Config struct { - Enabled bool `toml:",omitempty"` - EnabledExpensive bool `toml:"-"` - HTTP string `toml:",omitempty"` - Port int `toml:",omitempty"` - EnableInfluxDB bool `toml:",omitempty"` - InfluxDBEndpoint string `toml:",omitempty"` - InfluxDBDatabase string `toml:",omitempty"` - InfluxDBUsername string `toml:",omitempty"` - InfluxDBPassword string `toml:",omitempty"` - InfluxDBTags string `toml:",omitempty"` + Enabled bool `toml:",omitempty"` + EnabledExpensive bool `toml:"-"` + HTTP string `toml:",omitempty"` + Port int `toml:",omitempty"` + EnableInfluxDB bool `toml:",omitempty"` + InfluxDBEndpoint string `toml:",omitempty"` + InfluxDBDatabase string `toml:",omitempty"` + InfluxDBUsername string `toml:",omitempty"` + InfluxDBPassword string `toml:",omitempty"` + InfluxDBTags string `toml:",omitempty"` + InfluxDBInterval time.Duration `toml:",omitempty"` EnableInfluxDBV2 bool `toml:",omitempty"` InfluxDBToken string `toml:",omitempty"` @@ -47,6 +50,7 @@ var DefaultConfig = Config{ InfluxDBUsername: "test", InfluxDBPassword: "test", InfluxDBTags: "host=localhost", + InfluxDBInterval: 10 * time.Second, // influxdbv2-specific flags EnableInfluxDBV2: false, diff --git a/metrics/counter.go b/metrics/counter.go index c884e9a17845..0e4d93bfbc91 100644 --- a/metrics/counter.go +++ b/metrics/counter.go @@ -7,7 +7,10 @@ import ( // GetOrRegisterCounter returns an existing Counter or constructs and registers // a new Counter. func GetOrRegisterCounter(name string, r Registry) *Counter { - return getOrRegister(name, NewCounter, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewCounter() }).(*Counter) } // NewCounter constructs a new Counter. diff --git a/metrics/counter_float64.go b/metrics/counter_float64.go index 6cc73d89a292..caaaeb7be788 100644 --- a/metrics/counter_float64.go +++ b/metrics/counter_float64.go @@ -8,7 +8,10 @@ import ( // GetOrRegisterCounterFloat64 returns an existing *CounterFloat64 or constructs and registers // a new CounterFloat64. func GetOrRegisterCounterFloat64(name string, r Registry) *CounterFloat64 { - return getOrRegister(name, NewCounterFloat64, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewCounterFloat64() }).(*CounterFloat64) } // NewCounterFloat64 constructs a new CounterFloat64. diff --git a/metrics/gauge.go b/metrics/gauge.go index 20de95255bdd..39d5ccb3bca5 100644 --- a/metrics/gauge.go +++ b/metrics/gauge.go @@ -11,7 +11,10 @@ func (g GaugeSnapshot) Value() int64 { return int64(g) } // GetOrRegisterGauge returns an existing Gauge or constructs and registers a // new Gauge. func GetOrRegisterGauge(name string, r Registry) *Gauge { - return getOrRegister(name, NewGauge, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewGauge() }).(*Gauge) } // NewGauge constructs a new Gauge. diff --git a/metrics/gauge_float64.go b/metrics/gauge_float64.go index 48524e4c3f70..c7a1df0a230d 100644 --- a/metrics/gauge_float64.go +++ b/metrics/gauge_float64.go @@ -8,7 +8,10 @@ import ( // GetOrRegisterGaugeFloat64 returns an existing GaugeFloat64 or constructs and registers a // new GaugeFloat64. func GetOrRegisterGaugeFloat64(name string, r Registry) *GaugeFloat64 { - return getOrRegister(name, NewGaugeFloat64, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewGaugeFloat64() }).(*GaugeFloat64) } // GaugeFloat64Snapshot is a read-only copy of a GaugeFloat64. diff --git a/metrics/gauge_info.go b/metrics/gauge_info.go index 34ac91791949..30c511408508 100644 --- a/metrics/gauge_info.go +++ b/metrics/gauge_info.go @@ -16,7 +16,10 @@ func (val GaugeInfoValue) String() string { // GetOrRegisterGaugeInfo returns an existing GaugeInfo or constructs and registers a // new GaugeInfo. func GetOrRegisterGaugeInfo(name string, r Registry) *GaugeInfo { - return getOrRegister(name, NewGaugeInfo, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewGaugeInfo() }).(*GaugeInfo) } // NewGaugeInfo constructs a new GaugeInfo. diff --git a/metrics/histogram.go b/metrics/histogram.go index 18bf6e3d2b7f..467457abdbe3 100644 --- a/metrics/histogram.go +++ b/metrics/histogram.go @@ -23,13 +23,19 @@ type Histogram interface { // GetOrRegisterHistogram returns an existing Histogram or constructs and // registers a new StandardHistogram. func GetOrRegisterHistogram(name string, r Registry, s Sample) Histogram { - return getOrRegister(name, func() Histogram { return NewHistogram(s) }, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewHistogram(s) }).(Histogram) } // GetOrRegisterHistogramLazy returns an existing Histogram or constructs and // registers a new StandardHistogram. func GetOrRegisterHistogramLazy(name string, r Registry, s func() Sample) Histogram { - return getOrRegister(name, func() Histogram { return NewHistogram(s()) }, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewHistogram(s()) }).(Histogram) } // NewHistogram constructs a new StandardHistogram from a Sample. diff --git a/metrics/meter.go b/metrics/meter.go index ee23af10ebe3..2829774d8cc0 100644 --- a/metrics/meter.go +++ b/metrics/meter.go @@ -12,7 +12,10 @@ import ( // Be sure to unregister the meter from the registry once it is of no use to // allow for garbage collection. func GetOrRegisterMeter(name string, r Registry) *Meter { - return getOrRegister(name, NewMeter, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewMeter() }).(*Meter) } // NewMeter constructs a new Meter and launches a goroutine. diff --git a/metrics/registry.go b/metrics/registry.go index 6070f3d0e9eb..298598a9aac3 100644 --- a/metrics/registry.go +++ b/metrics/registry.go @@ -143,6 +143,8 @@ func (r *StandardRegistry) GetAll() map[string]map[string]interface{} { values["value"] = metric.Snapshot().Value() case *GaugeFloat64: values["value"] = metric.Snapshot().Value() + case *GaugeInfo: + values["value"] = metric.Snapshot().Value() case *Healthcheck: values["error"] = nil metric.Check() @@ -186,6 +188,18 @@ func (r *StandardRegistry) GetAll() map[string]map[string]interface{} { values["5m.rate"] = t.Rate5() values["15m.rate"] = t.Rate15() values["mean.rate"] = t.RateMean() + case *ResettingTimer: + t := metric.Snapshot() + ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + values["count"] = t.Count() + values["min"] = t.Min() + values["max"] = t.Max() + values["mean"] = t.Mean() + values["median"] = ps[0] + values["75%"] = ps[1] + values["95%"] = ps[2] + values["99%"] = ps[3] + values["99.9%"] = ps[4] } data[name] = values }) @@ -331,13 +345,6 @@ func GetOrRegister(name string, i func() interface{}) interface{} { return DefaultRegistry.GetOrRegister(name, i) } -func getOrRegister[T any](name string, ctor func() T, r Registry) T { - if r == nil { - r = DefaultRegistry - } - return r.GetOrRegister(name, func() any { return ctor() }).(T) -} - // Register the given metric under the given name. Returns a ErrDuplicateMetric // if a metric by the given name is already registered. func Register(name string, i interface{}) error { diff --git a/metrics/registry_test.go b/metrics/registry_test.go index 6af0796da951..1aad7a002870 100644 --- a/metrics/registry_test.go +++ b/metrics/registry_test.go @@ -14,6 +14,31 @@ func BenchmarkRegistry(b *testing.B) { } } +func BenchmarkRegistryGetOrRegister(b *testing.B) { + sample := func() Sample { return nil } + tests := []struct { + name string + ctor func() any + }{ + {name: "counter", ctor: func() any { return GetOrRegisterCounter("counter", DefaultRegistry) }}, + {name: "gauge", ctor: func() any { return GetOrRegisterGauge("gauge", DefaultRegistry) }}, + {name: "gaugefloat64", ctor: func() any { return GetOrRegisterGaugeFloat64("gaugefloat64", DefaultRegistry) }}, + {name: "histogram", ctor: func() any { return GetOrRegisterHistogram("histogram", DefaultRegistry, sample()) }}, + {name: "meter", ctor: func() any { return GetOrRegisterMeter("meter", DefaultRegistry) }}, + {name: "timer", ctor: func() any { return GetOrRegisterTimer("timer", DefaultRegistry) }}, + {name: "gaugeinfo", ctor: func() any { return GetOrRegisterGaugeInfo("gaugeinfo", DefaultRegistry) }}, + {name: "resettingtimer", ctor: func() any { return GetOrRegisterResettingTimer("resettingtimer", DefaultRegistry) }}, + {name: "runtimehistogramlazy", ctor: func() any { return GetOrRegisterHistogramLazy("runtimehistogramlazy", DefaultRegistry, sample) }}, + } + for _, test := range tests { + b.Run(test.name, func(b *testing.B) { + for i := 0; i < b.N; i++ { + test.ctor() + } + }) + } +} + func BenchmarkRegistryGetOrRegisterParallel_8(b *testing.B) { benchmarkRegistryGetOrRegisterParallel(b, 8) } @@ -268,7 +293,7 @@ func TestPrefixedChildRegistryGet(t *testing.T) { } func TestChildPrefixedRegistryRegister(t *testing.T) { - r := NewPrefixedChildRegistry(DefaultRegistry, "prefix.") + r := NewPrefixedChildRegistry(NewRegistry(), "prefix.") err := r.Register("foo", NewCounter()) c := NewCounter() Register("bar", c) diff --git a/metrics/resetting_timer.go b/metrics/resetting_timer.go index 8aa7dc1488f8..a3f46e52e0c8 100644 --- a/metrics/resetting_timer.go +++ b/metrics/resetting_timer.go @@ -8,7 +8,10 @@ import ( // GetOrRegisterResettingTimer returns an existing ResettingTimer or constructs and registers a // new ResettingTimer. func GetOrRegisterResettingTimer(name string, r Registry) *ResettingTimer { - return getOrRegister(name, NewResettingTimer, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewResettingTimer() }).(*ResettingTimer) } // NewRegisteredResettingTimer constructs and registers a new ResettingTimer. diff --git a/metrics/runtimehistogram.go b/metrics/runtimehistogram.go index efbed498af8e..e975a570a464 100644 --- a/metrics/runtimehistogram.go +++ b/metrics/runtimehistogram.go @@ -8,8 +8,10 @@ import ( ) func getOrRegisterRuntimeHistogram(name string, scale float64, r Registry) *runtimeHistogram { - constructor := func() Histogram { return newRuntimeHistogram(scale) } - return getOrRegister(name, constructor, r).(*runtimeHistogram) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return newRuntimeHistogram(scale) }).(*runtimeHistogram) } // runtimeHistogram wraps a runtime/metrics histogram. diff --git a/metrics/sample.go b/metrics/sample.go index dc8167809fdd..95092ffc3c4f 100644 --- a/metrics/sample.go +++ b/metrics/sample.go @@ -314,7 +314,7 @@ func (s *UniformSample) Clear() { s.mutex.Lock() defer s.mutex.Unlock() s.count = 0 - clear(s.values) + s.values = s.values[:0] } // Snapshot returns a read-only copy of the sample. diff --git a/metrics/timer.go b/metrics/timer.go index 894bdfc32732..8082b3194768 100644 --- a/metrics/timer.go +++ b/metrics/timer.go @@ -10,7 +10,10 @@ import ( // Be sure to unregister the meter from the registry once it is of no use to // allow for garbage collection. func GetOrRegisterTimer(name string, r Registry) *Timer { - return getOrRegister(name, NewTimer, r) + if r == nil { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() any { return NewTimer() }).(*Timer) } // NewCustomTimer constructs a new Timer from a Histogram and a Meter. diff --git a/miner/miner.go b/miner/miner.go index ee890b5e5488..0ff0237a083c 100644 --- a/miner/miner.go +++ b/miner/miner.go @@ -18,6 +18,7 @@ package miner import ( + "context" "fmt" "math/big" "sync" @@ -135,8 +136,8 @@ func (miner *Miner) SetGasTip(tip *big.Int) error { } // BuildPayload builds the payload according to the provided parameters. -func (miner *Miner) BuildPayload(args *BuildPayloadArgs, witness bool) (*Payload, error) { - return miner.buildPayload(args, witness) +func (miner *Miner) BuildPayload(ctx context.Context, args *BuildPayloadArgs, witness bool) (*Payload, error) { + return miner.buildPayload(ctx, args, witness) } // getPending retrieves the pending block based on the current head block. @@ -156,16 +157,17 @@ func (miner *Miner) getPending() *newPayloadResult { if miner.chainConfig.IsShanghai(new(big.Int).Add(header.Number, big.NewInt(1)), timestamp) { withdrawal = []*types.Withdrawal{} } - ret := miner.generateWork(&generateParams{ - timestamp: timestamp, - forceTime: false, - parentHash: header.Hash(), - coinbase: miner.config.PendingFeeRecipient, - random: common.Hash{}, - withdrawals: withdrawal, - beaconRoot: nil, - noTxs: false, - }, false) // we will never make a witness for a pending block + ret := miner.generateWork(context.Background(), + &generateParams{ + timestamp: timestamp, + forceTime: false, + parentHash: header.Hash(), + coinbase: miner.config.PendingFeeRecipient, + random: common.Hash{}, + withdrawals: withdrawal, + beaconRoot: nil, + noTxs: false, + }, false) // we will never make a witness for a pending block if ret.err != nil { return nil } diff --git a/miner/miner_test.go b/miner/miner_test.go index 575ee4d0fd59..5411418b133b 100644 --- a/miner/miner_test.go +++ b/miner/miner_test.go @@ -80,10 +80,14 @@ func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block return types.NewBlock(bc.CurrentBlock(), nil, nil, trie.NewStackTrie(nil)) } -func (bc *testBlockChain) StateAt(common.Hash) (*state.StateDB, error) { +func (bc *testBlockChain) StateAt(header *types.Header) (*state.StateDB, error) { return bc.statedb, nil } +func (bc *testBlockChain) Genesis() *types.Block { + return types.NewBlock(bc.CurrentBlock(), nil, nil, trie.NewStackTrie(nil)) +} + func (bc *testBlockChain) HasState(root common.Hash) bool { return bc.root == root } @@ -155,7 +159,7 @@ func createMiner(t *testing.T) *Miner { if err != nil { t.Fatalf("can't create new chain %v", err) } - statedb, _ := state.New(bc.Genesis().Root(), bc.StateCache()) + statedb, _ := state.New(bc.Genesis().Root(), state.NewDatabase(bc.TrieDB(), bc.CodeDB())) blockchain := &testBlockChain{bc.Genesis().Root(), chainConfig, statedb, 10000000, new(event.Feed)} pool := legacypool.New(testTxPoolConfig, blockchain) diff --git a/miner/payload_building.go b/miner/payload_building.go index 6b010186bf99..db8126828abd 100644 --- a/miner/payload_building.go +++ b/miner/payload_building.go @@ -17,6 +17,7 @@ package miner import ( + "context" "crypto/sha256" "encoding/binary" "math/big" @@ -28,9 +29,11 @@ import ( "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/stateless" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" + "go.opentelemetry.io/otel/trace" ) // BuildPayloadArgs contains the provided parameters for building payload. @@ -43,6 +46,7 @@ type BuildPayloadArgs struct { Random common.Hash // The provided randomness value Withdrawals types.Withdrawals // The provided withdrawals BeaconRoot *common.Hash // The provided beaconRoot (Cancun) + SlotNum *uint64 // The provided slotNumber Version engine.PayloadVersion // Versioning byte for payload id calculation. } @@ -57,6 +61,9 @@ func (args *BuildPayloadArgs) Id() engine.PayloadID { if args.BeaconRoot != nil { hasher.Write(args.BeaconRoot[:]) } + if args.SlotNum != nil { + binary.Write(hasher, binary.BigEndian, args.SlotNum) + } var out engine.PayloadID copy(out[:], hasher.Sum(nil)[:8]) out[0] = byte(args.Version) @@ -97,14 +104,15 @@ func newPayload(empty *types.Block, emptyRequests [][]byte, witness *stateless.W return payload } -// update updates the full-block with latest built version. -func (payload *Payload) update(r *newPayloadResult, elapsed time.Duration) { +// update updates the full-block with latest built version. It returns true if +// the update was accepted (i.e. the new block has higher fees than the previous). +func (payload *Payload) update(r *newPayloadResult, elapsed time.Duration) (result bool) { payload.lock.Lock() defer payload.lock.Unlock() select { case <-payload.stop: - return // reject stale update + return false // reject stale update default: } // Ensure the newly provided full block has a higher transaction fee. @@ -129,8 +137,10 @@ func (payload *Payload) update(r *newPayloadResult, elapsed time.Duration) { "root", r.block.Root(), "elapsed", common.PrettyDuration(elapsed), ) + result = true } payload.cond.Broadcast() // fire signal for notifying full block + return } // Resolve returns the latest built payload and also terminates the background @@ -205,8 +215,33 @@ func (payload *Payload) ResolveFull() *engine.ExecutionPayloadEnvelope { return envelope } +func (miner *Miner) runBuildIteration(ctx context.Context, start time.Time, iteration int, payload *Payload, params *generateParams, witness bool) { + ctx, span, spanEnd := telemetry.StartSpan(ctx, "miner.buildIteration", + telemetry.Int64Attribute("iteration", int64(iteration)), + ) + var err error + defer spanEnd(&err) + + r := miner.generateWork(ctx, params, witness) + err = r.err + if err == nil { + accepted := payload.update(r, time.Since(start)) + span.SetAttributes(telemetry.BoolAttribute("update.accepted", accepted)) + } else { + log.Info("Error while generating work", "id", payload.id, "err", err) + } +} + // buildPayload builds the payload according to the provided parameters. -func (miner *Miner) buildPayload(args *BuildPayloadArgs, witness bool) (*Payload, error) { +func (miner *Miner) buildPayload(ctx context.Context, args *BuildPayloadArgs, witness bool) (result *Payload, err error) { + payloadID := args.Id() + ctx, _, spanEnd := telemetry.StartSpan(ctx, "miner.buildPayload", + telemetry.StringAttribute("payload.id", payloadID.String()), + telemetry.StringAttribute("parent.hash", args.Parent.String()), + telemetry.Int64Attribute("timestamp", int64(args.Timestamp)), + ) + defer spanEnd(&err) + // Build the initial version with no transaction included. It should be fast // enough to run. The empty payload can at least make sure there is something // to deliver for not missing slot. @@ -218,18 +253,28 @@ func (miner *Miner) buildPayload(args *BuildPayloadArgs, witness bool) (*Payload random: args.Random, withdrawals: args.Withdrawals, beaconRoot: args.BeaconRoot, + slotNum: args.SlotNum, noTxs: true, } - empty := miner.generateWork(emptyParams, witness) + empty := miner.generateWork(ctx, emptyParams, witness) if empty.err != nil { return nil, empty.err } // Construct a payload object for return. - payload := newPayload(empty.block, empty.requests, empty.witness, args.Id()) + payload := newPayload(empty.block, empty.requests, empty.witness, payloadID) // Spin up a routine for updating the payload in background. This strategy // can maximum the revenue for including transactions with highest fee. go func() { + var iteration int + bCtx, bSpan, bSpanEnd := telemetry.StartSpan(ctx, "miner.background", + telemetry.Int64Attribute("block.number", int64(empty.block.NumberU64())), + ) + defer func() { + bSpan.SetAttributes(telemetry.Int64Attribute("iterations.total", int64(iteration))) + bSpanEnd(nil) + }() + // Setup the timer for re-building the payload. The initial clock is kept // for triggering process immediately. timer := time.NewTimer(0) @@ -248,24 +293,34 @@ func (miner *Miner) buildPayload(args *BuildPayloadArgs, witness bool) (*Payload random: args.Random, withdrawals: args.Withdrawals, beaconRoot: args.BeaconRoot, + slotNum: args.SlotNum, noTxs: false, } - for { select { case <-timer.C: - start := time.Now() - r := miner.generateWork(fullParams, witness) - if r.err == nil { - payload.update(r, time.Since(start)) - } else { - log.Info("Error while generating work", "id", payload.id, "err", r.err) + // When block building takes close to the full recommit interval, + // the timer fires near-instantly on the next iteration. If the + // payload was resolved during that build, both timer.C and + // payload.stop are ready and Go's select picks one at random. + // Check payload.stop first to avoid an unnecessary generateWork. + select { + case <-payload.stop: + payload.updateSpanForDelivery(bSpan) + log.Info("Stopping work on payload", "id", payload.id, "reason", "delivery") + return + default: } - timer.Reset(miner.config.Recommit) + start := time.Now() + iteration++ + miner.runBuildIteration(bCtx, start, iteration, payload, fullParams, witness) + timer.Reset(max(0, miner.config.Recommit-time.Since(start))) case <-payload.stop: + payload.updateSpanForDelivery(bSpan) log.Info("Stopping work on payload", "id", payload.id, "reason", "delivery") return case <-endTimer.C: + bSpan.SetAttributes(telemetry.StringAttribute("exit.reason", "timeout")) log.Info("Stopping work on payload", "id", payload.id, "reason", "timeout") return } @@ -273,3 +328,37 @@ func (miner *Miner) buildPayload(args *BuildPayloadArgs, witness bool) (*Payload }() return payload, nil } + +func (payload *Payload) updateSpanForDelivery(bSpan trace.Span) { + payload.lock.Lock() + emptyDelivered := payload.full == nil + payload.lock.Unlock() + bSpan.SetAttributes( + telemetry.StringAttribute("exit.reason", "delivery"), + telemetry.BoolAttribute("empty.delivered", emptyDelivered), + ) +} + +// BuildTestingPayload is for testing_buildBlockV*. It creates a block with the exact content given +// by the parameters instead of using the locally available transactions. +func (miner *Miner) BuildTestingPayload(args *BuildPayloadArgs, transactions []*types.Transaction, empty bool, extraData []byte) (*engine.ExecutionPayloadEnvelope, error) { + fullParams := &generateParams{ + timestamp: args.Timestamp, + forceTime: true, + parentHash: args.Parent, + coinbase: args.FeeRecipient, + random: args.Random, + withdrawals: args.Withdrawals, + beaconRoot: args.BeaconRoot, + slotNum: args.SlotNum, + noTxs: empty, + forceOverrides: true, + overrideExtraData: extraData, + overrideTxs: transactions, + } + res := miner.generateWork(context.Background(), fullParams, false) + if res.err != nil { + return nil, res.err + } + return engine.BlockToExecutableData(res.block, res.fees, res.sidecars, res.requests), nil +} diff --git a/miner/payload_building_test.go b/miner/payload_building_test.go index 295962d7ef43..f8e495cc99fe 100644 --- a/miner/payload_building_test.go +++ b/miner/payload_building_test.go @@ -17,6 +17,7 @@ package miner import ( + "context" "math/big" "reflect" "testing" @@ -156,7 +157,7 @@ func TestBuildPayload(t *testing.T) { Random: common.Hash{}, FeeRecipient: recipient, } - payload, err := w.buildPayload(args, false) + payload, err := w.buildPayload(context.Background(), args, false) if err != nil { t.Fatalf("Failed to build payload %v", err) } diff --git a/miner/stress/main.go b/miner/stress/main.go new file mode 100644 index 000000000000..aaf0993c37aa --- /dev/null +++ b/miner/stress/main.go @@ -0,0 +1,210 @@ +// Copyright 2018 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// This file contains a miner stress test based on the Engine API flow. +package main + +import ( + "crypto/ecdsa" + "math/big" + "math/rand" + "os" + "os/signal" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/fdlimit" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/txpool/legacypool" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/eth/catalyst" + "github.com/ethereum/go-ethereum/eth/downloader" + "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/params" +) + +var refundContract = common.HexToAddress("0x1000000000000000000000000000000000000001") + +func main() { + log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelInfo, true))) + fdlimit.Raise(2048) + + // Generate a batch of accounts to seal and fund with + faucets := make([]*ecdsa.PrivateKey, 128) + for i := 0; i < len(faucets); i++ { + faucets[i], _ = crypto.GenerateKey() + } + // Create a post-merge network where blocks are built/inserted through + // engine API calls driven by a simulated beacon client. + genesis := makeGenesis(faucets) + + // Handle interrupts. + interruptCh := make(chan os.Signal, 5) + signal.Notify(interruptCh, os.Interrupt) + + // Start one node that accepts transactions and builds/inserts blocks via + // Engine API (through the simulated beacon driver). + stack, backend, beacon, err := makeNode(genesis) + if err != nil { + panic(err) + } + defer stack.Close() + defer beacon.Stop() + + // Start injecting transactions from the faucet like crazy + var ( + sent uint64 + nonces = make([]uint64, len(faucets)) + signer = types.LatestSigner(genesis.Config) + refundSet = true // slot 0 starts as non-zero in genesis + ) + for { + // Stop when interrupted. + select { + case <-interruptCh: + return + default: + } + + var ( + tx *types.Transaction + err error + ) + // Every third tx targets a contract path that alternates set/clear. + // Clearing a previously non-zero slot triggers gas refund. + if sent%3 == 0 { + var data []byte + if refundSet { + data = nil // empty calldata => clear slot to zero (refund path) + } else { + data = []byte{0x01} // non-empty calldata => set slot to one + } + tx, err = types.SignTx(types.NewTransaction(nonces[0], refundContract, new(big.Int), 50000, big.NewInt(100000000000), data), signer, faucets[0]) + if err != nil { + panic(err) + } + nonces[0]++ + refundSet = !refundSet + } else { + index := 1 + rand.Intn(len(faucets)-1) + tx, err = types.SignTx(types.NewTransaction(nonces[index], crypto.PubkeyToAddress(faucets[index].PublicKey), new(big.Int), 21000, big.NewInt(100000000000), nil), signer, faucets[index]) + if err != nil { + panic(err) + } + nonces[index]++ + } + errs := backend.TxPool().Add([]*types.Transaction{tx}, true) + for _, err := range errs { + if err != nil { + panic(err) + } + } + sent++ + + // Create and import blocks through the engine API path. + if sent%256 == 0 { + beacon.Commit() + } + + // Wait if we're too saturated + if pend, _ := backend.TxPool().Stats(); pend > 4096 { + beacon.Commit() + time.Sleep(50 * time.Millisecond) + } + } +} + +// makeGenesis creates a post-merge genesis block. +func makeGenesis(faucets []*ecdsa.PrivateKey) *core.Genesis { + config := *params.AllDevChainProtocolChanges + config.ChainID = big.NewInt(18) + + blockZero := uint64(0) + config.AmsterdamTime = &blockZero + config.BlobScheduleConfig.Amsterdam = ¶ms.BlobConfig{ + Target: 14, + Max: 21, + UpdateFraction: 13739630, + } + + genesis := &core.Genesis{ + Config: &config, + GasLimit: 25000000, + Alloc: types.GenesisAlloc{}, + } + for _, faucet := range faucets { + genesis.Alloc[crypto.PubkeyToAddress(faucet.PublicKey)] = types.Account{ + Balance: new(big.Int).Exp(big.NewInt(2), big.NewInt(128), nil), + } + } + // Runtime code: + // - empty calldata: SSTORE(0,0) + // - non-empty calldata: SSTORE(0,1) + // Slot 0 is initialized to 1 so the first clear includes gas refund. + genesis.Alloc[refundContract] = types.Account{ + Code: common.FromHex("0x3615600b576001600055005b600060005500"), + Storage: map[common.Hash]common.Hash{ + common.Hash{}: common.BigToHash(big.NewInt(1)), + }, + } + return genesis +} + +func makeNode(genesis *core.Genesis) (*node.Node, *eth.Ethereum, *catalyst.SimulatedBeacon, error) { + // Define the basic configurations for the Ethereum node + datadir, _ := os.MkdirTemp("", "") + + config := &node.Config{ + Name: "geth", + DataDir: datadir, + } + // Start the node and configure a full Ethereum node on it + stack, err := node.New(config) + if err != nil { + return nil, nil, nil, err + } + // Create and register the backend + ethBackend, err := eth.New(stack, ðconfig.Config{ + Genesis: genesis, + NetworkId: genesis.Config.ChainID.Uint64(), + SyncMode: downloader.FullSync, + DatabaseCache: 256, + DatabaseHandles: 256, + TxPool: legacypool.DefaultConfig, + GPO: ethconfig.Defaults.GPO, + Miner: ethconfig.Defaults.Miner, + SlowBlockThreshold: time.Second, + }) + if err != nil { + return nil, nil, nil, err + } + + if err := stack.Start(); err != nil { + return nil, nil, nil, err + } + driver, err := catalyst.NewSimulatedBeacon(0, common.Address{}, ethBackend) + if err != nil { + return nil, nil, nil, err + } + if err := driver.Start(); err != nil { + return nil, nil, nil, err + } + return stack, ethBackend, driver, nil +} diff --git a/miner/worker.go b/miner/worker.go index 45d7073ed76f..026bafc4e576 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -17,6 +17,7 @@ package miner import ( + "context" "errors" "fmt" "math/big" @@ -32,6 +33,7 @@ import ( "github.com/ethereum/go-ethereum/core/txpool" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" @@ -73,11 +75,19 @@ type environment struct { witness *stateless.Witness } -// txFits reports whether the transaction fits into the block size limit. +// txFitsSize reports whether the transaction fits into the block size limit. func (env *environment) txFitsSize(tx *types.Transaction) bool { return env.size+tx.Size() < params.MaxBlockSize-maxBlockSizeBufferZone } +// discard terminates the background threads before discarding it. +func (env *environment) discard() { + env.state.StopPrefetcher() + if env.evm != nil { + env.evm.Release() + } +} + const ( commitInterruptNone int32 = iota commitInterruptNewHead @@ -111,15 +121,36 @@ type generateParams struct { random common.Hash // The randomness generated by beacon chain, empty before the merge withdrawals types.Withdrawals // List of withdrawals to include in block (shanghai field) beaconRoot *common.Hash // The beacon root (cancun field). + slotNum *uint64 // The slot number (amsterdam field). noTxs bool // Flag whether an empty block without any transaction is expected + + forceOverrides bool // Flag whether we should overwrite extraData and transactions + overrideExtraData []byte + overrideTxs []*types.Transaction } // generateWork generates a sealing block based on the given parameters. -func (miner *Miner) generateWork(genParam *generateParams, witness bool) *newPayloadResult { - work, err := miner.prepareWork(genParam, witness) +func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams, witness bool) (result *newPayloadResult) { + ctx, span, spanEnd := telemetry.StartSpan(ctx, "miner.generateWork") + defer func() { + if result != nil && result.err == nil { + span.SetAttributes( + telemetry.Int64Attribute("txs.count", int64(len(result.block.Transactions()))), + telemetry.Int64Attribute("gas.used", int64(result.block.GasUsed())), + telemetry.StringAttribute("fees", result.fees.String()), + ) + } + if result != nil { + spanEnd(&result.err) + } else { + spanEnd(nil) + } + }() + work, err := miner.prepareWork(ctx, genParam, witness) if err != nil { return &newPayloadResult{err: err} } + defer work.discard() // Check withdrawals fit max block size. // Due to the cap on withdrawal count, this can actually never happen, but we still need to @@ -132,18 +163,44 @@ func (miner *Miner) generateWork(genParam *generateParams, witness bool) *newPay work.size += uint64(genParam.withdrawals.Size()) if !genParam.noTxs { - interrupt := new(atomic.Int32) - timer := time.AfterFunc(miner.config.Recommit, func() { - interrupt.Store(commitInterruptTimeout) - }) - defer timer.Stop() - - err := miner.fillTransactions(interrupt, work) - if errors.Is(err, errBlockInterruptedByTimeout) { - log.Warn("Block building is interrupted", "allowance", common.PrettyDuration(miner.config.Recommit)) + // If forceOverrides is true and overrideTxs is not empty, commit the override transactions + // otherwise, fill the block with the current transactions from the txpool + if genParam.forceOverrides && len(genParam.overrideTxs) > 0 { + for _, tx := range genParam.overrideTxs { + work.state.SetTxContext(tx.Hash(), work.tcount, uint32(work.tcount+1)) + if err := miner.commitTransaction(ctx, work, tx); err != nil { + // all passed transactions HAVE to be valid at this point + return &newPayloadResult{err: err} + } + } + } else { + interrupt := new(atomic.Int32) + timer := time.AfterFunc(miner.config.Recommit, func() { + interrupt.Store(commitInterruptTimeout) + }) + defer timer.Stop() + + err := miner.fillTransactions(ctx, interrupt, work) + if errors.Is(err, errBlockInterruptedByTimeout) { + log.Warn("Block building is interrupted", "allowance", common.PrettyDuration(miner.config.Recommit)) + } + } + } + // Construct the block body, the withdrawal list should never be null + // if Shanghai has been activated. + body := types.Body{ + Transactions: work.txs, + Withdrawals: genParam.withdrawals, + } + if !miner.chainConfig.IsShanghai(work.header.Number, work.header.Time) { + if body.Withdrawals != nil { + return &newPayloadResult{err: errors.New("unexpected withdrawals before shanghai")} + } + } else { + if body.Withdrawals == nil { + body.Withdrawals = make([]*types.Withdrawal, 0) } } - body := types.Body{Transactions: work.txs, Withdrawals: genParam.withdrawals} allLogs := make([]*types.Log, 0) for _, r := range work.receipts { @@ -151,31 +208,19 @@ func (miner *Miner) generateWork(genParam *generateParams, witness bool) *newPay } // Collect consensus-layer requests if Prague is enabled. - var requests [][]byte - if miner.chainConfig.IsPrague(work.header.Number, work.header.Time) { - requests = [][]byte{} - // EIP-6110 deposits - if err := core.ParseDepositLogs(&requests, allLogs, miner.chainConfig); err != nil { - return &newPayloadResult{err: err} - } - // EIP-7002 - if err := core.ProcessWithdrawalQueue(&requests, work.evm); err != nil { - return &newPayloadResult{err: err} - } - // EIP-7251 consolidations - if err := core.ProcessConsolidationQueue(&requests, work.evm); err != nil { - return &newPayloadResult{err: err} - } + requests, err := core.PostExecution(ctx, miner.chainConfig, work.header.Number, work.header.Time, allLogs, work.evm, uint32(work.tcount+1)) + if err != nil { + return &newPayloadResult{err: err} } if requests != nil { reqHash := types.CalcRequestsHash(requests) work.header.RequestsHash = &reqHash } + // Assemble the block for delivery. + _, _, assembleSpanEnd := telemetry.StartSpan(ctx, "miner.AssembleBlock") + block := core.AssembleBlock(miner.engine, miner.chain, work.header, work.state, &body, work.receipts) + assembleSpanEnd(nil) - block, err := miner.engine.FinalizeAndAssemble(miner.chain, work.header, work.state, &body, work.receipts) - if err != nil { - return &newPayloadResult{err: err} - } return &newPayloadResult{ block: block, fees: totalFees(block, work.receipts), @@ -190,7 +235,9 @@ func (miner *Miner) generateWork(genParam *generateParams, witness bool) *newPay // prepareWork constructs the sealing task according to the given parameters, // either based on the last chain head or specified parent. In this function // the pending transactions are not filled yet, only the empty task returned. -func (miner *Miner) prepareWork(genParams *generateParams, witness bool) (*environment, error) { +func (miner *Miner) prepareWork(ctx context.Context, genParams *generateParams, witness bool) (result *environment, err error) { + _, _, spanEnd := telemetry.StartSpan(ctx, "miner.prepareWork") + defer spanEnd(&err) miner.confMu.RLock() defer miner.confMu.RUnlock() @@ -224,6 +271,9 @@ func (miner *Miner) prepareWork(genParams *generateParams, witness bool) (*envir if len(miner.config.ExtraData) != 0 { header.Extra = miner.config.ExtraData } + if genParams.forceOverrides { + header.Extra = genParams.overrideExtraData + } // Set the randomness field from the beacon chain if it's available. if genParams.random != (common.Hash{}) { header.MixDigest = genParams.random @@ -252,6 +302,13 @@ func (miner *Miner) prepareWork(genParams *generateParams, witness bool) (*envir header.ExcessBlobGas = &excessBlobGas header.ParentBeaconRoot = genParams.beaconRoot } + // Apply EIP-7843. + if miner.chainConfig.IsAmsterdam(header.Number, header.Time) { + if genParams.slotNum == nil { + return nil, errors.New("no slot number set post-amsterdam") + } + header.SlotNumber = genParams.slotNum + } // Could potentially happen if starting to mine in an odd state. // Note genParams.coinbase can be different with header.Coinbase // since clique algorithm can modify the coinbase field in header. @@ -260,42 +317,42 @@ func (miner *Miner) prepareWork(genParams *generateParams, witness bool) (*envir log.Error("Failed to create sealing context", "err", err) return nil, err } - if header.ParentBeaconRoot != nil { - core.ProcessBeaconBlockRoot(*header.ParentBeaconRoot, env.evm) - } - if miner.chainConfig.IsPrague(header.Number, header.Time) { - core.ProcessParentBlockHash(header.ParentHash, env.evm) - } + // Run pre-execution system calls + core.PreExecution(ctx, header.ParentBeaconRoot, header.ParentHash, miner.chainConfig, env.evm, header.Number, header.Time) return env, nil } // makeEnv creates a new environment for the sealing block. func (miner *Miner) makeEnv(parent *types.Header, header *types.Header, coinbase common.Address, witness bool) (*environment, error) { // Retrieve the parent state to execute on top. - state, err := miner.chain.StateAt(parent.Root) + state, err := miner.chain.StateAtForkBoundary(parent, header) if err != nil { return nil, err } + var bundle *stateless.Witness if witness { - bundle, err := stateless.NewWitness(header, miner.chain) + bundle, err = stateless.NewWitness(header, miner.chain, false) if err != nil { return nil, err } - state.StartPrefetcher("miner", bundle, nil) } + state.StartPrefetcher("miner", bundle) // Note the passed coinbase may be different with header.Coinbase. return &environment{ signer: types.MakeSigner(miner.chainConfig, header.Number, header.Time), state: state, size: uint64(header.Size()), coinbase: coinbase, + gasPool: core.NewGasPool(header.GasLimit), header: header, witness: state.Witness(), evm: vm.NewEVM(core.NewEVMBlockContext(header, miner.chain, &coinbase), state, miner.chainConfig, vm.Config{}), }, nil } -func (miner *Miner) commitTransaction(env *environment, tx *types.Transaction) error { +func (miner *Miner) commitTransaction(ctx context.Context, env *environment, tx *types.Transaction) (err error) { + _, _, spanEnd := telemetry.StartSpan(ctx, "miner.commitTransaction") + defer spanEnd(&err) if tx.Type() == types.BlobTxType { return miner.commitBlobTransaction(env, tx) } @@ -342,24 +399,23 @@ func (miner *Miner) commitBlobTransaction(env *environment, tx *types.Transactio func (miner *Miner) applyTransaction(env *environment, tx *types.Transaction) (*types.Receipt, error) { var ( snap = env.state.Snapshot() - gp = env.gasPool.Gas() + gp = env.gasPool.Snapshot() ) - receipt, err := core.ApplyTransaction(env.evm, env.gasPool, env.state, env.header, tx, &env.header.GasUsed) + receipt, err := core.ApplyTransaction(env.evm, env.gasPool, env.state, env.header, tx) if err != nil { env.state.RevertToSnapshot(snap) - env.gasPool.SetGas(gp) + env.gasPool.Set(gp) + return nil, err } - return receipt, err + env.header.GasUsed = env.gasPool.Used() + return receipt, nil } -func (miner *Miner) commitTransactions(env *environment, plainTxs, blobTxs *transactionsByPriceAndNonce, interrupt *atomic.Int32) error { - var ( - isCancun = miner.chainConfig.IsCancun(env.header.Number, env.header.Time) - gasLimit = env.header.GasLimit - ) - if env.gasPool == nil { - env.gasPool = new(core.GasPool).AddGas(gasLimit) - } +func (miner *Miner) commitTransactions(ctx context.Context, env *environment, plainTxs, blobTxs *transactionsByPriceAndNonce, interrupt *atomic.Int32) error { + ctx, _, spanEnd := telemetry.StartSpan(ctx, "miner.commitTransactions") + defer spanEnd(nil) + + isCancun := miner.chainConfig.IsCancun(env.header.Number, env.header.Time) for { // Check interruption signal and abort building if it's fired. if interrupt != nil { @@ -446,9 +502,9 @@ func (miner *Miner) commitTransactions(env *environment, plainTxs, blobTxs *tran continue } // Start executing the transaction - env.state.SetTxContext(tx.Hash(), env.tcount) + env.state.SetTxContext(tx.Hash(), env.tcount, uint32(env.tcount+1)) - err := miner.commitTransaction(env, tx) + err := miner.commitTransaction(ctx, env, tx) switch { case errors.Is(err, core.ErrNonceTooLow): // New head notification data race between the transaction pool and miner, shift @@ -472,7 +528,10 @@ func (miner *Miner) commitTransactions(env *environment, plainTxs, blobTxs *tran // fillTransactions retrieves the pending transactions from the txpool and fills them // into the given sealing block. The transaction selection and ordering strategy can // be customized with the plugin in the future. -func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) error { +func (miner *Miner) fillTransactions(ctx context.Context, interrupt *atomic.Int32, env *environment) (err error) { + ctx, span, spanEnd := telemetry.StartSpan(ctx, "miner.fillTransactions") + defer spanEnd(&err) + miner.confMu.RLock() tip := miner.config.GasPrice prio := miner.prio @@ -488,11 +547,11 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) if env.header.ExcessBlobGas != nil { filter.BlobFee = uint256.MustFromBig(eip4844.CalcBlobFee(miner.chainConfig, env.header)) } - if miner.chainConfig.IsOsaka(env.header.Number, env.header.Time) { + if miner.chainConfig.IsOsaka(env.header.Number, env.header.Time) && !miner.chainConfig.IsAmsterdam(env.header.Number, env.header.Time) { filter.GasLimitCap = params.MaxTxGas } filter.BlobTxs = false - pendingPlainTxs := miner.txpool.Pending(filter) + pendingPlainTxs, plainTxCount := miner.txpool.Pending(filter) filter.BlobTxs = true if miner.chainConfig.IsOsaka(env.header.Number, env.header.Time) { @@ -500,7 +559,11 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) } else { filter.BlobVersion = types.BlobSidecarVersion0 } - pendingBlobTxs := miner.txpool.Pending(filter) + pendingBlobTxs, blobTxCount := miner.txpool.Pending(filter) + span.SetAttributes( + telemetry.Int64Attribute("pending.plain.count", int64(plainTxCount)), + telemetry.Int64Attribute("pending.blob.count", int64(blobTxCount)), + ) // Split the pending transactions into locals and remotes. prioPlainTxs, normalPlainTxs := make(map[common.Address][]*txpool.LazyTransaction), pendingPlainTxs @@ -521,7 +584,7 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) plainTxs := newTransactionsByPriceAndNonce(env.signer, prioPlainTxs, env.header.BaseFee) blobTxs := newTransactionsByPriceAndNonce(env.signer, prioBlobTxs, env.header.BaseFee) - if err := miner.commitTransactions(env, plainTxs, blobTxs, interrupt); err != nil { + if err := miner.commitTransactions(ctx, env, plainTxs, blobTxs, interrupt); err != nil { return err } } @@ -529,7 +592,7 @@ func (miner *Miner) fillTransactions(interrupt *atomic.Int32, env *environment) plainTxs := newTransactionsByPriceAndNonce(env.signer, normalPlainTxs, env.header.BaseFee) blobTxs := newTransactionsByPriceAndNonce(env.signer, normalBlobTxs, env.header.BaseFee) - if err := miner.commitTransactions(env, plainTxs, blobTxs, interrupt); err != nil { + if err := miner.commitTransactions(ctx, env, plainTxs, blobTxs, interrupt); err != nil { return err } } diff --git a/node/config.go b/node/config.go index dc436876cce9..255b0f0aa9e2 100644 --- a/node/config.go +++ b/node/config.go @@ -191,9 +191,7 @@ type Config struct { GraphQLVirtualHosts []string `toml:",omitempty"` // Logger is a custom logger to use with the p2p.Server. - Logger log.Logger `toml:",omitempty"` - - oldGethResourceWarning bool + Logger log.Logger `toml:"-,omitempty"` // AllowUnprotectedTxs allows non EIP-155 protected transactions to be send over RPC. AllowUnprotectedTxs bool `toml:",omitempty"` @@ -210,7 +208,29 @@ type Config struct { // EnablePersonal enables the deprecated personal namespace. EnablePersonal bool `toml:"-"` + // Configures database engine used by the node. DBEngine string `toml:",omitempty"` + + // Configures OpenTelemetry reporting. + OpenTelemetry OpenTelemetryConfig `toml:",omitempty"` + + oldGethResourceWarning bool +} + +// OpenTelemetryConfig has settings for +type OpenTelemetryConfig struct { + Enabled bool `toml:",omitempty"` + + Tags string `toml:",omitempty"` + InstanceID string `toml:",omitempty"` + + // Exporter endpoint. + Endpoint string `toml:",omitempty"` + AuthUser string `toml:",omitempty"` + AuthPassword string `toml:",omitempty"` + + // Percentage of sampled traces. + SampleRatio float64 `toml:",omitempty"` } // IPCEndpoint resolves an IPC endpoint based on a configured value, taking into diff --git a/node/defaults.go b/node/defaults.go index 403a7f88a35e..3410fa2ae572 100644 --- a/node/defaults.go +++ b/node/defaults.go @@ -76,6 +76,9 @@ var DefaultConfig = Config{ DiscoveryV5: true, }, DBEngine: "", // Use whatever exists, will default to Pebble if non-existent and supported + OpenTelemetry: OpenTelemetryConfig{ + SampleRatio: 1.0, + }, } // DefaultDataDir is the default data directory to use for the databases and other diff --git a/node/node.go b/node/node.go index f9ebb243b03e..56ecd7d52278 100644 --- a/node/node.go +++ b/node/node.go @@ -35,7 +35,6 @@ import ( "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb/memorydb" - "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/rpc" @@ -44,7 +43,6 @@ import ( // Node is a container on which services can be registered. type Node struct { - eventmux *event.TypeMux config *Config accman *accounts.Manager log log.Logger @@ -108,7 +106,6 @@ func New(conf *Config) (*Node, error) { node := &Node{ config: conf, inprocHandler: server, - eventmux: new(event.TypeMux), log: conf.Logger, stop: make(chan struct{}), server: &p2p.Server{Config: conf.P2P}, @@ -152,8 +149,10 @@ func New(conf *Config) (*Node, error) { // Configure RPC servers. node.http = newHTTPServer(node.log, conf.HTTPTimeouts) node.httpAuth = newHTTPServer(node.log, conf.HTTPTimeouts) + node.httpAuth.disableHTTP2 = true // Engine API does not need HTTP/2 node.ws = newHTTPServer(node.log, rpc.DefaultHTTPTimeouts) node.wsAuth = newHTTPServer(node.log, rpc.DefaultHTTPTimeouts) + node.wsAuth.disableHTTP2 = true node.ipc = newIPCServer(node.log, conf.IPCEndpoint()) return node, nil @@ -690,12 +689,6 @@ func (n *Node) WSAuthEndpoint() string { return "ws://" + n.wsAuth.listenAddr() + n.wsAuth.wsConfig.prefix } -// EventMux retrieves the event multiplexer used by all the network services in -// the current protocol stack. -func (n *Node) EventMux() *event.TypeMux { - return n.eventmux -} - // OpenDatabaseWithOptions opens an existing database with the given name (or creates one if no // previous can be found) from within the node's instance directory. If the node has no // data directory, an in-memory database is returned. diff --git a/node/rpcstack.go b/node/rpcstack.go index a1cc832f9f3e..20d488b734e5 100644 --- a/node/rpcstack.go +++ b/node/rpcstack.go @@ -90,6 +90,9 @@ type httpServer struct { port int handlerNames map[string]string + + // disableHTTP2 disables HTTP/2 support on this server when set to true. + disableHTTP2 bool } const ( @@ -138,6 +141,11 @@ func (h *httpServer) start() error { // Initialize the server. h.server = &http.Server{Handler: h} + h.server.Protocols = new(http.Protocols) + h.server.Protocols.SetHTTP1(true) + if !h.disableHTTP2 { + h.server.Protocols.SetUnencryptedHTTP2(true) + } if h.timeouts != (rpc.HTTPTimeouts{}) { CheckTimeouts(&h.timeouts) h.server.ReadTimeout = h.timeouts.ReadTimeout diff --git a/node/rpcstack_test.go b/node/rpcstack_test.go index 54e58cccb2b5..bd75dac4eb7a 100644 --- a/node/rpcstack_test.go +++ b/node/rpcstack_test.go @@ -593,6 +593,38 @@ func TestHTTPWriteTimeout(t *testing.T) { }) } +func TestHTTP2H2C(t *testing.T) { + srv := createAndStartServer(t, &httpConfig{}, false, &wsConfig{}, nil) + defer srv.stop() + + // Create an HTTP/2 cleartext client. + transport := &http.Transport{} + transport.Protocols = new(http.Protocols) + transport.Protocols.SetUnencryptedHTTP2(true) + client := &http.Client{Transport: transport} + + body := strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"rpc_modules","params":[]}`) + resp, err := client.Post("http://"+srv.listenAddr(), "application/json", body) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + t.Fatalf("expected status 200, got %d", resp.StatusCode) + } + if resp.Proto != "HTTP/2.0" { + t.Fatalf("expected HTTP/2.0, got %s", resp.Proto) + } + result, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(result), "jsonrpc") { + t.Fatalf("unexpected response: %s", result) + } +} + func apis() []rpc.API { return []rpc.API{ { diff --git a/oss-fuzz.sh b/oss-fuzz.sh index 020b6fee273b..73209fd8c8cd 100644 --- a/oss-fuzz.sh +++ b/oss-fuzz.sh @@ -35,7 +35,7 @@ function coverbuild { sed -i -e 's/TestFuzzCorpus/Test'$function'Corpus/' ./"${function,,}"_test.go cat << DOG > $OUT/$fuzzer -#/bin/sh +#!/bin/sh cd $OUT/$path go test -run Test${function}Corpus -v $tags -coverprofile \$1 -coverpkg $coverpkg @@ -64,7 +64,7 @@ function compile_fuzzer() { go get github.com/holiman/gofuzz-shim/testing if [[ $SANITIZER == *coverage* ]]; then - coverbuild $path $function $fuzzer $coverpkg + coverbuild $path $function $fuzzer else gofuzz-shim --func $function --package $package -f $file -o $fuzzer.a $CXX $CXXFLAGS $LIB_FUZZING_ENGINE $fuzzer.a -o $OUT/$fuzzer diff --git a/p2p/dial.go b/p2p/dial.go index 225709427c21..0ffcd1049730 100644 --- a/p2p/dial.go +++ b/p2p/dial.go @@ -67,7 +67,10 @@ type tcpDialer struct { } func (t tcpDialer) Dial(ctx context.Context, dest *enode.Node) (net.Conn, error) { - addr, _ := dest.TCPEndpoint() + addr, ok := dest.TCPEndpoint() + if !ok { + return nil, errNoPort + } return t.d.DialContext(ctx, "tcp", addr.String()) } @@ -76,6 +79,7 @@ var ( errSelf = errors.New("is self") errAlreadyDialing = errors.New("already dialing") errAlreadyConnected = errors.New("already connected") + errPendingInbound = errors.New("peer has pending inbound connection") errRecentlyDialed = errors.New("recently dialed") errNetRestrict = errors.New("not contained in netrestrict list") errNoPort = errors.New("node does not provide TCP port") @@ -104,12 +108,15 @@ type dialScheduler struct { remStaticCh chan *enode.Node addPeerCh chan *conn remPeerCh chan *conn + addPendingCh chan enode.ID + remPendingCh chan enode.ID // Everything below here belongs to loop and // should only be accessed by code on the loop goroutine. - dialing map[enode.ID]*dialTask // active tasks - peers map[enode.ID]struct{} // all connected peers - dialPeers int // current number of dialed peers + dialing map[enode.ID]*dialTask // active tasks + peers map[enode.ID]struct{} // all connected peers + pendingInbound map[enode.ID]struct{} // in-progress inbound connections + dialPeers int // current number of dialed peers // The static map tracks all static dial tasks. The subset of usable static dial tasks // (i.e. those passing checkDial) is kept in staticPool. The scheduler prefers @@ -163,19 +170,22 @@ func (cfg dialConfig) withDefaults() dialConfig { func newDialScheduler(config dialConfig, it enode.Iterator, setupFunc dialSetupFunc) *dialScheduler { cfg := config.withDefaults() d := &dialScheduler{ - dialConfig: cfg, - historyTimer: mclock.NewAlarm(cfg.clock), - setupFunc: setupFunc, - dnsLookupFunc: net.DefaultResolver.LookupNetIP, - dialing: make(map[enode.ID]*dialTask), - static: make(map[enode.ID]*dialTask), - peers: make(map[enode.ID]struct{}), - doneCh: make(chan *dialTask), - nodesIn: make(chan *enode.Node), - addStaticCh: make(chan *enode.Node), - remStaticCh: make(chan *enode.Node), - addPeerCh: make(chan *conn), - remPeerCh: make(chan *conn), + dialConfig: cfg, + historyTimer: mclock.NewAlarm(cfg.clock), + setupFunc: setupFunc, + dnsLookupFunc: net.DefaultResolver.LookupNetIP, + dialing: make(map[enode.ID]*dialTask), + static: make(map[enode.ID]*dialTask), + peers: make(map[enode.ID]struct{}), + pendingInbound: make(map[enode.ID]struct{}), + doneCh: make(chan *dialTask), + nodesIn: make(chan *enode.Node), + addStaticCh: make(chan *enode.Node), + remStaticCh: make(chan *enode.Node), + addPeerCh: make(chan *conn), + remPeerCh: make(chan *conn), + addPendingCh: make(chan enode.ID), + remPendingCh: make(chan enode.ID), } d.lastStatsLog = d.clock.Now() d.ctx, d.cancel = context.WithCancel(context.Background()) @@ -223,6 +233,22 @@ func (d *dialScheduler) peerRemoved(c *conn) { } } +// inboundPending notifies the scheduler about a pending inbound connection. +func (d *dialScheduler) inboundPending(id enode.ID) { + select { + case d.addPendingCh <- id: + case <-d.ctx.Done(): + } +} + +// inboundCompleted notifies the scheduler that an inbound connection completed or failed. +func (d *dialScheduler) inboundCompleted(id enode.ID) { + select { + case d.remPendingCh <- id: + case <-d.ctx.Done(): + } +} + // loop is the main loop of the dialer. func (d *dialScheduler) loop(it enode.Iterator) { var ( @@ -276,6 +302,15 @@ loop: delete(d.peers, c.node.ID()) d.updateStaticPool(c.node.ID()) + case id := <-d.addPendingCh: + d.pendingInbound[id] = struct{}{} + d.log.Trace("Marked node as pending inbound", "id", id) + + case id := <-d.remPendingCh: + delete(d.pendingInbound, id) + d.updateStaticPool(id) + d.log.Trace("Unmarked node as pending inbound", "id", id) + case node := <-d.addStaticCh: id := node.ID() _, exists := d.static[id] @@ -390,6 +425,9 @@ func (d *dialScheduler) checkDial(n *enode.Node) error { if _, ok := d.peers[n.ID()]; ok { return errAlreadyConnected } + if _, ok := d.pendingInbound[n.ID()]; ok { + return errPendingInbound + } if d.netRestrict != nil && !d.netRestrict.ContainsAddr(n.IPAddr()) { return errNetRestrict } diff --git a/p2p/dial_test.go b/p2p/dial_test.go index f18dacce2abd..9684aa6e91ff 100644 --- a/p2p/dial_test.go +++ b/p2p/dial_test.go @@ -423,6 +423,82 @@ func TestDialSchedDNSHostname(t *testing.T) { }) } +// This test checks that nodes with pending inbound connections are not dialed. +func TestDialSchedPendingInbound(t *testing.T) { + t.Parallel() + + config := dialConfig{ + maxActiveDials: 5, + maxDialPeers: 4, + } + runDialTest(t, config, []dialTestRound{ + // 2 peers are connected, leaving 2 dial slots. + // Node 0x03 has a pending inbound connection. + // Discovered nodes 0x03, 0x04, 0x05 but only 0x04 and 0x05 should be dialed. + { + peersAdded: []*conn{ + {flags: dynDialedConn, node: newNode(uintID(0x01), "127.0.0.1:30303")}, + {flags: dynDialedConn, node: newNode(uintID(0x02), "127.0.0.2:30303")}, + }, + update: func(d *dialScheduler) { + d.inboundPending(uintID(0x03)) + }, + discovered: []*enode.Node{ + newNode(uintID(0x03), "127.0.0.3:30303"), // not dialed because pending inbound + newNode(uintID(0x04), "127.0.0.4:30303"), + newNode(uintID(0x05), "127.0.0.5:30303"), + }, + wantNewDials: []*enode.Node{ + newNode(uintID(0x04), "127.0.0.4:30303"), + newNode(uintID(0x05), "127.0.0.5:30303"), + }, + }, + // Pending inbound connection for 0x03 completes successfully. + // Node 0x03 becomes a connected peer. + // One dial slot remains, node 0x06 is dialed. + { + update: func(d *dialScheduler) { + // Pending inbound completes + d.inboundCompleted(uintID(0x03)) + }, + peersAdded: []*conn{ + {flags: inboundConn, node: newNode(uintID(0x03), "127.0.0.3:30303")}, + }, + succeeded: []enode.ID{ + uintID(0x04), + }, + failed: []enode.ID{ + uintID(0x05), + }, + discovered: []*enode.Node{ + newNode(uintID(0x03), "127.0.0.3:30303"), // not dialed, now connected + newNode(uintID(0x06), "127.0.0.6:30303"), + }, + wantNewDials: []*enode.Node{ + newNode(uintID(0x06), "127.0.0.6:30303"), + }, + }, + // Inbound peer 0x03 disconnects. + // Another pending inbound starts for 0x07. + // Only 0x03 should be dialed, not 0x07. + { + peersRemoved: []enode.ID{ + uintID(0x03), + }, + update: func(d *dialScheduler) { + d.inboundPending(uintID(0x07)) + }, + discovered: []*enode.Node{ + newNode(uintID(0x03), "127.0.0.3:30303"), + newNode(uintID(0x07), "127.0.0.7:30303"), // not dialed because pending inbound + }, + wantNewDials: []*enode.Node{ + newNode(uintID(0x03), "127.0.0.3:30303"), + }, + }, + }) +} + // ------- // Code below here is the framework for the tests above. diff --git a/p2p/discover/common.go b/p2p/discover/common.go index 767cc23b9242..5513afd54d0d 100644 --- a/p2p/discover/common.go +++ b/p2p/discover/common.go @@ -17,9 +17,11 @@ package discover import ( + "container/list" "crypto/ecdsa" crand "crypto/rand" "encoding/binary" + "iter" "math/rand" "net" "net/netip" @@ -143,3 +145,16 @@ func (r *reseedingRandom) Shuffle(n int, swap func(i, j int)) { defer r.mu.Unlock() r.cur.Shuffle(n, swap) } + +// iterList iterates over the elements of the given list. +func iterList[T any](l *list.List) iter.Seq2[T, *list.Element] { + return func(yield func(T, *list.Element) bool) { + for el := l.Front(); el != nil; { + next := el.Next() + if !yield(el.Value.(T), el) { + return + } + el = next + } + } +} diff --git a/p2p/discover/table.go b/p2p/discover/table.go index e5b2c7c8c5f7..016a2d1af329 100644 --- a/p2p/discover/table.go +++ b/p2p/discover/table.go @@ -25,6 +25,7 @@ package discover import ( "context" "fmt" + "net" "net/netip" "slices" "sync" @@ -36,6 +37,7 @@ import ( "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/p2p/enode" + "github.com/ethereum/go-ethereum/p2p/enr" "github.com/ethereum/go-ethereum/p2p/netutil" ) @@ -205,6 +207,13 @@ func (tab *Table) close() { func (tab *Table) setFallbackNodes(nodes []*enode.Node) error { nursery := make([]*enode.Node, 0, len(nodes)) for _, n := range nodes { + if n.Hostname() != "" && !n.IPAddr().IsValid() { + resolved, err := resolveBootnodeHostname(n, tab.log) + if err != nil { + return fmt.Errorf("bad bootstrap node %q: %v", n, err) + } + n = resolved + } if err := n.ValidateComplete(); err != nil { return fmt.Errorf("bad bootstrap node %q: %v", n, err) } @@ -218,6 +227,42 @@ func (tab *Table) setFallbackNodes(nodes []*enode.Node) error { return nil } +// resolveBootnodeHostname resolves the DNS hostname of a bootstrap node to an IP address. +func resolveBootnodeHostname(n *enode.Node, logger log.Logger) (*enode.Node, error) { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + ips, err := net.DefaultResolver.LookupNetIP(ctx, "ip", n.Hostname()) + if err != nil { + return nil, fmt.Errorf("DNS lookup failed for %q: %v", n.Hostname(), err) + } + + var ip4, ip6 netip.Addr + for _, ip := range ips { + if ip.Is4() && !ip4.IsValid() { + ip4 = ip + } + if ip.Is6() && !ip6.IsValid() { + ip6 = ip + } + } + if !ip4.IsValid() && !ip6.IsValid() { + return nil, fmt.Errorf("no IP addresses found for hostname %q", n.Hostname()) + } + + rec := n.Record() + if ip4.IsValid() { + rec.Set(enr.IPv4Addr(ip4)) + } + if ip6.IsValid() { + rec.Set(enr.IPv6Addr(ip6)) + } + rec.SetSeq(n.Seq()) + resolved := enode.SignNull(rec, n.ID()).WithHostname(n.Hostname()) + logger.Debug("Resolved bootstrap node hostname", "name", n.Hostname(), "ip", resolved.IP()) + return resolved, nil +} + // isInitDone returns whether the table's initial seeding procedure has completed. func (tab *Table) isInitDone() bool { select { @@ -708,6 +753,41 @@ func (tab *Table) deleteNode(n *enode.Node) { // waitForNodes blocks until the table contains at least n nodes. func (tab *Table) waitForNodes(ctx context.Context, n int) error { + // Wrap ctx so the forwarder goroutine exits when waitForNodes returns, + // regardless of whether the caller's ctx is canceled. + ctx, cancel := context.WithCancel(ctx) + defer cancel() + + // Set up a notification channel that gets unblocked when there was any activity on + // the table. Ultimately this reads from the table's nodeFeed, but can't use the feed + // directly on the same goroutine that takes Table.mutex, it would deadlock. + var notify chan struct{} + var notifyErr error + initsub := func() event.Subscription { + notify = make(chan struct{}, 1) + newnode := make(chan *enode.Node, 1) + sub := tab.nodeFeed.Subscribe(newnode) + go func() { + defer close(notify) + for { + select { + case <-newnode: + select { + case notify <- struct{}{}: + default: + } + case <-ctx.Done(): + notifyErr = ctx.Err() + return + case <-tab.closeReq: + notifyErr = errClosed + return + } + } + }() + return sub + } + getlength := func() (count int) { for _, b := range &tab.buckets { count += len(b.entries) @@ -715,28 +795,24 @@ func (tab *Table) waitForNodes(ctx context.Context, n int) error { return count } - var ch chan *enode.Node for { tab.mutex.Lock() if getlength() >= n { tab.mutex.Unlock() return nil } - if ch == nil { - // Init subscription. - ch = make(chan *enode.Node) - sub := tab.nodeFeed.Subscribe(ch) + if notify == nil { + // Lazily init the subscription. Do this while holding the + // lock so we don't miss any events that change the node count. + sub := initsub() defer sub.Unsubscribe() } tab.mutex.Unlock() - // Wait for a node add event. - select { - case <-ch: - case <-ctx.Done(): - return ctx.Err() - case <-tab.closeReq: - return errClosed + // Wait for table event. + if _, ok := <-notify; !ok { + break } } + return notifyErr } diff --git a/p2p/discover/table_test.go b/p2p/discover/table_test.go index 8cc4ae33b2eb..a16b4d9cab2c 100644 --- a/p2p/discover/table_test.go +++ b/p2p/discover/table_test.go @@ -17,6 +17,7 @@ package discover import ( + "context" "crypto/ecdsa" "fmt" "math/rand" @@ -490,6 +491,105 @@ func quickcfg() *quick.Config { } } +func TestSetFallbackNodes_DNSHostname(t *testing.T) { + // Create a node with a DNS hostname but no IP, simulating an enode URL + // like enode://@localhost:30303. + key := newkey() + node := enode.NewV4(&key.PublicKey, nil, 30303, 30303).WithHostname("localhost") + + // Verify the node has a hostname but no valid IP. + if node.Hostname() != "localhost" { + t.Fatal("expected hostname to be set") + } + if node.IPAddr().IsValid() { + t.Fatal("expected no IP address") + } + + // Create a table and set the hostname node as a bootnode. + // This should resolve the hostname to an IP address. + db, _ := enode.OpenDB(t.TempDir() + "/node.db") + defer db.Close() + + cfg := Config{Log: testlog.Logger(t, log.LvlTrace)} + cfg = cfg.withDefaults() + tab := &Table{ + cfg: cfg, + log: cfg.Log, + refreshReq: make(chan chan struct{}), + revalResponseCh: make(chan revalidationResponse), + addNodeCh: make(chan addNodeOp), + addNodeHandled: make(chan bool), + trackRequestCh: make(chan trackRequestOp), + initDone: make(chan struct{}), + closeReq: make(chan struct{}), + closed: make(chan struct{}), + ips: netutil.DistinctNetSet{Subnet: tableSubnet, Limit: tableIPLimit}, + } + for i := range tab.buckets { + tab.buckets[i] = &bucket{ + index: i, + ips: netutil.DistinctNetSet{Subnet: bucketSubnet, Limit: bucketIPLimit}, + } + } + + err := tab.setFallbackNodes([]*enode.Node{node}) + if err != nil { + t.Fatalf("setFallbackNodes failed: %v", err) + } + if len(tab.nursery) != 1 { + t.Fatalf("expected 1 nursery node, got %d", len(tab.nursery)) + } + + // The resolved node should have a valid IP and retain the hostname. + resolved := tab.nursery[0] + if !resolved.IPAddr().IsValid() { + t.Fatal("expected resolved node to have a valid IP") + } + if resolved.Hostname() != "localhost" { + t.Errorf("expected hostname to be preserved, got %q", resolved.Hostname()) + } + t.Logf("resolved localhost to %v", resolved.IPAddr()) +} + +// This test checks that waitForNodes does not block addFoundNode. +// See https://github.com/ethereum/go-ethereum/issues/34881. +func TestTable_waitForNodesLocking(t *testing.T) { + transport := newPingRecorder() + tab, db := newTestTable(transport, Config{}) + defer db.Close() + defer tab.close() + <-tab.initDone + + // waitForNodes will never reach this count, so it stays subscribed + // to nodeFeed and looping for the duration of the test. + waitCtx, cancelWait := context.WithCancel(context.Background()) + defer cancelWait() + waitDone := make(chan struct{}) + go func() { + defer close(waitDone) + tab.waitForNodes(waitCtx, 1<<20) + }() + + // Call addFoundNode in loop to send to the feed. + addDone := make(chan struct{}) + go func() { + defer close(addDone) + for i := range 10000 { + d := 240 + (i % 17) + n := nodeAtDistance(tab.self().ID(), d, intIP(i)) + tab.addFoundNode(n, true) + } + }() + + select { + case <-addDone: + cancelWait() + <-waitDone + case <-time.After(10 * time.Second): + t.Fatal("deadlock detected: add loop did not finish within 10s") + } +} + func newkey() *ecdsa.PrivateKey { key, err := crypto.GenerateKey() if err != nil { diff --git a/p2p/discover/v4_udp.go b/p2p/discover/v4_udp.go index dd3f363f7ec0..ae8cbec3e2df 100644 --- a/p2p/discover/v4_udp.go +++ b/p2p/discover/v4_udp.go @@ -446,16 +446,16 @@ func (t *UDPv4) loop() { } // Start the timer so it fires when the next pending reply has expired. now := time.Now() - for el := plist.Front(); el != nil; el = el.Next() { - nextTimeout = el.Value.(*replyMatcher) - if dist := nextTimeout.deadline.Sub(now); dist < 2*respTimeout { + for p, el := range iterList[*replyMatcher](plist) { + nextTimeout = p + if dist := p.deadline.Sub(now); dist < 2*respTimeout { timeout.Reset(dist) return } // Remove pending replies whose deadline is too far in the // future. These can occur if the system clock jumped // backwards after the deadline was assigned. - nextTimeout.errc <- errClockWarp + p.errc <- errClockWarp plist.Remove(el) } nextTimeout = nil @@ -478,8 +478,7 @@ func (t *UDPv4) loop() { case r := <-t.gotreply: var matched bool // whether any replyMatcher considered the reply acceptable. - for el := plist.Front(); el != nil; el = el.Next() { - p := el.Value.(*replyMatcher) + for p, el := range iterList[*replyMatcher](plist) { if p.from == r.from && p.ptype == r.data.Kind() && p.ip == r.ip { ok, requestDone := p.callback(r.data) matched = matched || ok @@ -499,8 +498,7 @@ func (t *UDPv4) loop() { nextTimeout = nil // Notify and remove callbacks whose deadline is in the past. - for el := plist.Front(); el != nil; el = el.Next() { - p := el.Value.(*replyMatcher) + for p, el := range iterList[*replyMatcher](plist) { if now.After(p.deadline) || now.Equal(p.deadline) { p.errc <- errTimeout plist.Remove(el) @@ -557,8 +555,9 @@ func (t *UDPv4) readLoop(unhandled chan<- ReadPacket) { if err := t.handlePacket(from, buf[:nbytes]); err != nil && unhandled == nil { t.log.Debug("Bad discv4 packet", "addr", from, "err", err) } else if err != nil && unhandled != nil { + p := ReadPacket{bytes.Clone(buf[:nbytes]), from} select { - case unhandled <- ReadPacket{buf[:nbytes], from}: + case unhandled <- p: default: } } diff --git a/p2p/discover/v5_udp_test.go b/p2p/discover/v5_udp_test.go index 6abe20d7a4c4..1c41941c7099 100644 --- a/p2p/discover/v5_udp_test.go +++ b/p2p/discover/v5_udp_test.go @@ -856,10 +856,10 @@ type testCodecFrame struct { } func (c *testCodec) Encode(toID enode.ID, addr string, p v5wire.Packet, _ *v5wire.Whoareyou) ([]byte, v5wire.Nonce, error) { - // To match the behavior of v5wire.Codec, we return the cached encoding of - // WHOAREYOU challenges. - if wp, ok := p.(*v5wire.Whoareyou); ok && len(wp.Encoded) > 0 { - return wp.Encoded, wp.Nonce, nil + if wp, ok := p.(*v5wire.Whoareyou); ok && len(wp.ChallengeData) > 0 { + // To match the behavior of v5wire.Codec, we return the cached encoding of + // WHOAREYOU challenges. + return wp.ChallengeData, wp.Nonce, nil } c.ctr++ @@ -874,7 +874,7 @@ func (c *testCodec) Encode(toID enode.ID, addr string, p v5wire.Packet, _ *v5wir // Store recently sent challenges. if w, ok := p.(*v5wire.Whoareyou); ok { w.Nonce = authTag - w.Encoded = frame + w.ChallengeData = frame if c.sentChallenges == nil { c.sentChallenges = make(map[enode.ID]*v5wire.Whoareyou) } @@ -911,6 +911,7 @@ func (c *testCodec) decodeFrame(input []byte) (frame testCodecFrame, p v5wire.Pa case v5wire.WhoareyouPacket: dec := new(v5wire.Whoareyou) err = rlp.DecodeBytes(frame.Packet, &dec) + dec.ChallengeData = bytes.Clone(input) p = dec default: p, err = v5wire.DecodeMessage(frame.Ptype, frame.Packet) @@ -936,6 +937,7 @@ func newUDPV5Test(t *testing.T) *udpV5Test { PrivateKey: test.localkey, Log: testlog.Logger(t, log.LvlTrace), ValidSchemes: enode.ValidSchemesForTesting, + PingInterval: 1000 * time.Hour, }) test.udp.codec = &testCodec{test: test, id: ln.ID()} test.table = test.udp.tab diff --git a/p2p/discover/v5wire/encoding.go b/p2p/discover/v5wire/encoding.go index d6a30a17ca87..9a5bbd461297 100644 --- a/p2p/discover/v5wire/encoding.go +++ b/p2p/discover/v5wire/encoding.go @@ -190,10 +190,16 @@ func (c *Codec) Encode(id enode.ID, addr string, packet Packet, challenge *Whoar ) switch { case packet.Kind() == WhoareyouPacket: - // just send the WHOAREYOU packet raw again, rather than the re-encoded challenge data w := packet.(*Whoareyou) - if len(w.Encoded) > 0 { - return w.Encoded, w.Nonce, nil + if len(w.ChallengeData) > 0 { + // This WHOAREYOU packet was encoded before, so it's a resend. + // The unmasked packet content is stored in w.ChallengeData. + // Just apply the masking again to finish encoding. + c.buf.Reset() + c.buf.Write(w.ChallengeData) + copy(head.IV[:], w.ChallengeData) + enc := applyMasking(id, head.IV, c.buf.Bytes()) + return enc, w.Nonce, nil } head, err = c.encodeWhoareyou(id, packet.(*Whoareyou)) case challenge != nil: @@ -228,7 +234,6 @@ func (c *Codec) Encode(id enode.ID, addr string, packet Packet, challenge *Whoar if err != nil { return nil, Nonce{}, err } - challenge.Encoded = bytes.Clone(enc) c.sc.storeSentHandshake(id, addr, challenge) return enc, head.Nonce, err } @@ -246,14 +251,10 @@ func (c *Codec) Encode(id enode.ID, addr string, packet Packet, challenge *Whoar // EncodeRaw encodes a packet with the given header. func (c *Codec) EncodeRaw(id enode.ID, head Header, msgdata []byte) ([]byte, error) { + // header c.writeHeaders(&head) - - // Apply masking. - masked := c.buf.Bytes()[sizeofMaskingIV:] - mask := head.mask(id) - mask.XORKeyStream(masked[:], masked[:]) - - // Write message data. + applyMasking(id, head.IV, c.buf.Bytes()) + // message data c.buf.Write(msgdata) return c.buf.Bytes(), nil } @@ -463,7 +464,7 @@ func (c *Codec) Decode(inputData []byte, addr string) (src enode.ID, n *enode.No // Unmask the static header. var head Header copy(head.IV[:], input[:sizeofMaskingIV]) - mask := head.mask(c.localnode.ID()) + mask := createMask(c.localnode.ID(), head.IV) staticHeader := input[sizeofMaskingIV:sizeofStaticPacketData] mask.XORKeyStream(staticHeader, staticHeader) @@ -679,10 +680,17 @@ func (h *StaticHeader) checkValid(packetLen int, protocolID [6]byte) error { } // mask returns a cipher for 'masking' / 'unmasking' packet headers. -func (h *Header) mask(destID enode.ID) cipher.Stream { +func createMask(destID enode.ID, iv [16]byte) cipher.Stream { block, err := aes.NewCipher(destID[:16]) if err != nil { panic("can't create cipher") } - return cipher.NewCTR(block, h.IV[:]) + return cipher.NewCTR(block, iv[:]) +} + +func applyMasking(destID enode.ID, iv [16]byte, packet []byte) []byte { + masked := packet[sizeofMaskingIV:] + mask := createMask(destID, iv) + mask.XORKeyStream(masked[:], masked[:]) + return packet } diff --git a/p2p/discover/v5wire/encoding_test.go b/p2p/discover/v5wire/encoding_test.go index 5774cb3d8c4c..dd7ec6d53c78 100644 --- a/p2p/discover/v5wire/encoding_test.go +++ b/p2p/discover/v5wire/encoding_test.go @@ -269,6 +269,35 @@ func TestHandshake_BadHandshakeAttack(t *testing.T) { net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, findnode) } +func TestEncodeWhoareyouResend(t *testing.T) { + t.Parallel() + net := newHandshakeTest() + defer net.close() + + // A -> B WHOAREYOU + challenge := &Whoareyou{ + Nonce: Nonce{1, 2, 3, 4}, + IDNonce: testIDnonce, + RecordSeq: 0, + } + enc, _ := net.nodeA.encode(t, net.nodeB, challenge) + net.nodeB.expectDecode(t, WhoareyouPacket, enc) + whoareyou1 := bytes.Clone(enc) + + if len(challenge.ChallengeData) == 0 { + t.Fatal("ChallengeData not assigned by encode") + } + + // A -> B WHOAREYOU + // Send the same challenge again. This should produce exactly + // the same bytes as the first send. + enc, _ = net.nodeA.encode(t, net.nodeB, challenge) + whoareyou2 := bytes.Clone(enc) + if !bytes.Equal(whoareyou2, whoareyou1) { + t.Fatal("re-encoded challenge not equal to first") + } +} + // This test checks some malformed packets. func TestDecodeErrorsV5(t *testing.T) { t.Parallel() diff --git a/p2p/discover/v5wire/msg.go b/p2p/discover/v5wire/msg.go index 089fd4ebdc8f..e5c29276cab0 100644 --- a/p2p/discover/v5wire/msg.go +++ b/p2p/discover/v5wire/msg.go @@ -63,19 +63,20 @@ type ( // WHOAREYOU contains the handshake challenge. Whoareyou struct { - ChallengeData []byte // Encoded challenge - Nonce Nonce // Nonce of request packet - IDNonce [16]byte // Identity proof data - RecordSeq uint64 // ENR sequence number of recipient + Nonce Nonce // Nonce of request packet + IDNonce [16]byte // Identity proof data + RecordSeq uint64 // ENR sequence number of recipient // Node is the locally known node record of recipient. // This must be set by the caller of Encode. - Node *enode.Node + Node *enode.Node `rlp:"-"` - sent mclock.AbsTime // for handshake GC. + // ChallengeData stores the unmasked encoding of the whole packet. This is the + // input data for verification. It is assigned by both Encode and Decode + // operations. + ChallengeData []byte `rlp:"-"` - // Encoded is packet raw data for sending out, but should not be include in the RLP encoding. - Encoded []byte `rlp:"-"` + sent mclock.AbsTime // for handshake GC. } // PING is sent during liveness checks. diff --git a/p2p/dnsdisc/tree.go b/p2p/dnsdisc/tree.go index a8295ac9eba6..a629d6291faa 100644 --- a/p2p/dnsdisc/tree.go +++ b/p2p/dnsdisc/tree.go @@ -28,10 +28,10 @@ import ( "strings" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/enr" "github.com/ethereum/go-ethereum/rlp" - "golang.org/x/crypto/sha3" ) // Tree is a merkle tree of node records. @@ -262,7 +262,7 @@ const ( ) func subdomain(e entry) string { - h := sha3.NewLegacyKeccak256() + h := keccak.NewLegacyKeccak256() io.WriteString(h, e.String()) return b32format.EncodeToString(h.Sum(nil)[:16]) } @@ -272,7 +272,7 @@ func (e *rootEntry) String() string { } func (e *rootEntry) sigHash() []byte { - h := sha3.NewLegacyKeccak256() + h := keccak.NewLegacyKeccak256() fmt.Fprintf(h, rootPrefix+" e=%s l=%s seq=%d", e.eroot, e.lroot, e.seq) return h.Sum(nil) } diff --git a/p2p/enode/idscheme.go b/p2p/enode/idscheme.go index db7841c047a1..313815c4650c 100644 --- a/p2p/enode/idscheme.go +++ b/p2p/enode/idscheme.go @@ -23,9 +23,9 @@ import ( "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/p2p/enr" "github.com/ethereum/go-ethereum/rlp" - "golang.org/x/crypto/sha3" ) // ValidSchemes is a List of known secure identity schemes. @@ -49,7 +49,7 @@ func SignV4(r *enr.Record, privkey *ecdsa.PrivateKey) error { cpy.Set(enr.ID("v4")) cpy.Set(Secp256k1(privkey.PublicKey)) - h := sha3.NewLegacyKeccak256() + h := keccak.NewLegacyKeccak256() rlp.Encode(h, cpy.AppendElements(nil)) sig, err := crypto.Sign(h.Sum(nil), privkey) if err != nil { @@ -70,7 +70,7 @@ func (V4ID) Verify(r *enr.Record, sig []byte) error { return errors.New("invalid public key") } - h := sha3.NewLegacyKeccak256() + h := keccak.NewLegacyKeccak256() rlp.Encode(h, r.AppendElements(nil)) if !crypto.VerifySignature(entry, h.Sum(nil), sig) { return enr.ErrInvalidSig diff --git a/p2p/rlpx/rlpx.go b/p2p/rlpx/rlpx.go index 0dc4ecbe2d3f..40a5c38fcb34 100644 --- a/p2p/rlpx/rlpx.go +++ b/p2p/rlpx/rlpx.go @@ -36,9 +36,9 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/ecies" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/rlp" "github.com/golang/snappy" - "golang.org/x/crypto/sha3" ) // Conn is an RLPx network connection. It wraps a low-level network connection. The @@ -486,10 +486,10 @@ func (h *handshakeState) secrets(auth, authResp []byte) (Secrets, error) { } // setup sha3 instances for the MACs - mac1 := sha3.NewLegacyKeccak256() + mac1 := keccak.NewLegacyKeccak256() mac1.Write(xor(s.MAC, h.respNonce)) mac1.Write(auth) - mac2 := sha3.NewLegacyKeccak256() + mac2 := keccak.NewLegacyKeccak256() mac2.Write(xor(s.MAC, h.initNonce)) mac2.Write(authResp) if h.initiator { diff --git a/p2p/rlpx/rlpx_oracle_poc_test.go b/p2p/rlpx/rlpx_oracle_poc_test.go new file mode 100644 index 000000000000..3497f0026e33 --- /dev/null +++ b/p2p/rlpx/rlpx_oracle_poc_test.go @@ -0,0 +1,57 @@ +package rlpx + +import ( + "bytes" + "errors" + "testing" + + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/ecies" +) + +func TestHandshakeECIESInvalidCurveOracle(t *testing.T) { + initKey, err := crypto.GenerateKey() + if err != nil { + t.Fatal(err) + } + respKey, err := crypto.GenerateKey() + if err != nil { + t.Fatal(err) + } + + init := handshakeState{ + initiator: true, + remote: ecies.ImportECDSAPublic(&respKey.PublicKey), + } + authMsg, err := init.makeAuthMsg(initKey) + if err != nil { + t.Fatal(err) + } + packet, err := init.sealEIP8(authMsg) + if err != nil { + t.Fatal(err) + } + + var recv handshakeState + if _, err := recv.readMsg(new(authMsgV4), respKey, bytes.NewReader(packet)); err != nil { + t.Fatalf("expected valid packet to decrypt: %v", err) + } + + tampered := append([]byte(nil), packet...) + if len(tampered) < 2+65 { + t.Fatalf("unexpected packet length %d", len(tampered)) + } + tampered[2] = 0x04 + for i := 1; i < 65; i++ { + tampered[2+i] = 0x00 + } + + var recv2 handshakeState + _, err = recv2.readMsg(new(authMsgV4), respKey, bytes.NewReader(tampered)) + if err == nil { + t.Fatal("expected decryption failure for invalid curve point") + } + if !errors.Is(err, ecies.ErrInvalidPublicKey) { + t.Fatalf("unexpected error: %v", err) + } +} diff --git a/p2p/server.go b/p2p/server.go index 10c855f1c463..6d2323f9ce21 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -686,8 +686,11 @@ running: // Ensure that the trusted flag is set before checking against MaxPeers. c.flags |= trustedConn } - // TODO: track in-progress inbound node IDs (pre-Peer) to avoid dialing them. - c.cont <- srv.postHandshakeChecks(peers, inboundCount, c) + err := srv.postHandshakeChecks(peers, inboundCount, c) + if err == nil && c.flags&inboundConn != 0 { + srv.dialsched.inboundPending(c.node.ID()) + } + c.cont <- err case c := <-srv.checkpointAddPeer: // At this point the connection is past the protocol handshake. @@ -870,6 +873,11 @@ func (srv *Server) checkInboundConn(remoteIP netip.Addr) error { // or the handshakes have failed. func (srv *Server) SetupConn(fd net.Conn, flags connFlag, dialDest *enode.Node) error { c := &conn{fd: fd, flags: flags, cont: make(chan error)} + defer func() { + if c.is(inboundConn) && c.node != nil { + srv.dialsched.inboundCompleted(c.node.ID()) + } + }() if dialDest == nil { c.transport = srv.newTransport(fd, nil) } else { diff --git a/p2p/tracker/tracker.go b/p2p/tracker/tracker.go index 5b72eb2b881b..a5c790d7802a 100644 --- a/p2p/tracker/tracker.go +++ b/p2p/tracker/tracker.go @@ -18,52 +18,63 @@ package tracker import ( "container/list" + "errors" "fmt" "sync" "time" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" + "github.com/ethereum/go-ethereum/p2p" ) const ( - // trackedGaugeName is the prefix of the per-packet request tracking. trackedGaugeName = "p2p/tracked" - - // lostMeterName is the prefix of the per-packet request expirations. - lostMeterName = "p2p/lost" - - // staleMeterName is the prefix of the per-packet stale responses. - staleMeterName = "p2p/stale" - - // waitHistName is the prefix of the per-packet (req only) waiting time histograms. - waitHistName = "p2p/wait" + lostMeterName = "p2p/lost" + staleMeterName = "p2p/stale" + waitHistName = "p2p/wait" // maxTrackedPackets is a huge number to act as a failsafe on the number of // pending requests the node will track. It should never be hit unless an // attacker figures out a way to spin requests. - maxTrackedPackets = 100000 + maxTrackedPackets = 10000 ) -// request tracks sent network requests which have not yet received a response. -type request struct { - peer string - version uint // Protocol version +var ( + ErrNoMatchingRequest = errors.New("no matching request") + ErrTooManyItems = errors.New("response is larger than request allows") + ErrCollision = errors.New("request ID collision") + ErrCodeMismatch = errors.New("wrong response code for request") + ErrLimitReached = errors.New("request limit reached") + ErrStopped = errors.New("tracker stopped") +) - reqCode uint64 // Protocol message code of the request - resCode uint64 // Protocol message code of the expected response +// Request tracks sent network requests which have not yet received a response. +type Request struct { + ID uint64 // Request ID + Size int // Number/size of requested items + ReqCode uint64 // Protocol message code of the request + RespCode uint64 // Protocol message code of the expected response time time.Time // Timestamp when the request was made expire *list.Element // Expiration marker to untrack it } +type Response struct { + ID uint64 // Request ID of the response + MsgCode uint64 // Protocol message code + Size int // number/size of items in response +} + // Tracker is a pending network request tracker to measure how much time it takes // a remote peer to respond. type Tracker struct { - protocol string // Protocol capability identifier for the metrics - timeout time.Duration // Global timeout after which to drop a tracked packet + cap p2p.Cap // Protocol capability identifier for the metrics - pending map[uint64]*request // Currently pending requests + peer string // Peer ID + timeout time.Duration // Global timeout after which to drop a tracked packet + + pending map[uint64]*Request // Currently pending requests expire *list.List // Linked list tracking the expiration order wake *time.Timer // Timer tracking the expiration of the next item @@ -72,52 +83,53 @@ type Tracker struct { // New creates a new network request tracker to monitor how much time it takes to // fill certain requests and how individual peers perform. -func New(protocol string, timeout time.Duration) *Tracker { +func New(cap p2p.Cap, peerID string, timeout time.Duration) *Tracker { return &Tracker{ - protocol: protocol, - timeout: timeout, - pending: make(map[uint64]*request), - expire: list.New(), + cap: cap, + peer: peerID, + timeout: timeout, + pending: make(map[uint64]*Request), + expire: list.New(), } } // Track adds a network request to the tracker to wait for a response to arrive // or until the request it cancelled or times out. -func (t *Tracker) Track(peer string, version uint, reqCode uint64, resCode uint64, id uint64) { - if !metrics.Enabled() { - return - } +func (t *Tracker) Track(req Request) error { t.lock.Lock() defer t.lock.Unlock() + if t.expire == nil { + return ErrStopped + } + // If there's a duplicate request, we've just random-collided (or more probably, // we have a bug), report it. We could also add a metric, but we're not really // expecting ourselves to be buggy, so a noisy warning should be enough. - if _, ok := t.pending[id]; ok { - log.Error("Network request id collision", "protocol", t.protocol, "version", version, "code", reqCode, "id", id) - return + if _, ok := t.pending[req.ID]; ok { + log.Error("Network request id collision", "cap", t.cap, "code", req.ReqCode, "id", req.ID) + return ErrCollision } // If we have too many pending requests, bail out instead of leaking memory if pending := len(t.pending); pending >= maxTrackedPackets { - log.Error("Request tracker exceeded allowance", "pending", pending, "peer", peer, "protocol", t.protocol, "version", version, "code", reqCode) - return + log.Error("Request tracker exceeded allowance", "pending", pending, "peer", t.peer, "cap", t.cap, "code", req.ReqCode) + return ErrLimitReached } + // Id doesn't exist yet, start tracking it - t.pending[id] = &request{ - peer: peer, - version: version, - reqCode: reqCode, - resCode: resCode, - time: time.Now(), - expire: t.expire.PushBack(id), + req.time = time.Now() + req.expire = t.expire.PushBack(req.ID) + t.pending[req.ID] = &req + + if metrics.Enabled() { + t.trackedGauge(req.ReqCode).Inc(1) } - g := fmt.Sprintf("%s/%s/%d/%#02x", trackedGaugeName, t.protocol, version, reqCode) - metrics.GetOrRegisterGauge(g, nil).Inc(1) // If we've just inserted the first item, start the expiration timer if t.wake == nil { t.wake = time.AfterFunc(t.timeout, t.clean) } + return nil } // clean is called automatically when a preset time passes without a response @@ -126,6 +138,10 @@ func (t *Tracker) clean() { t.lock.Lock() defer t.lock.Unlock() + if t.expire == nil { + return // Tracker was stopped. + } + // Expire anything within a certain threshold (might be no items at all if // we raced with the delivery) for t.expire.Len() > 0 { @@ -142,64 +158,111 @@ func (t *Tracker) clean() { t.expire.Remove(head) delete(t.pending, id) - g := fmt.Sprintf("%s/%s/%d/%#02x", trackedGaugeName, t.protocol, req.version, req.reqCode) - metrics.GetOrRegisterGauge(g, nil).Dec(1) - - m := fmt.Sprintf("%s/%s/%d/%#02x", lostMeterName, t.protocol, req.version, req.reqCode) - metrics.GetOrRegisterMeter(m, nil).Mark(1) + if metrics.Enabled() { + t.trackedGauge(req.ReqCode).Dec(1) + t.lostMeter(req.ReqCode).Mark(1) + } } t.schedule() } -// schedule starts a timer to trigger on the expiration of the first network -// packet. +// schedule starts a timer to trigger on the expiration of the first network packet. func (t *Tracker) schedule() { if t.expire.Len() == 0 { t.wake = nil return } - t.wake = time.AfterFunc(time.Until(t.pending[t.expire.Front().Value.(uint64)].time.Add(t.timeout)), t.clean) + nextID := t.expire.Front().Value.(uint64) + nextTime := t.pending[nextID].time + t.wake = time.AfterFunc(time.Until(nextTime.Add(t.timeout)), t.clean) } -// Fulfil fills a pending request, if any is available, reporting on various metrics. -func (t *Tracker) Fulfil(peer string, version uint, code uint64, id uint64) { - if !metrics.Enabled() { - return +// Stop reclaims resources of the tracker. +func (t *Tracker) Stop() { + t.lock.Lock() + defer t.lock.Unlock() + + if t.wake != nil { + t.wake.Stop() + t.wake = nil + } + if metrics.Enabled() { + // Ensure metrics are decremented for pending requests. + counts := make(map[uint64]int64) + for _, req := range t.pending { + counts[req.ReqCode]++ + } + for code, count := range counts { + t.trackedGauge(code).Dec(count) + } } + clear(t.pending) + t.expire = nil +} + +// Fulfil fills a pending request, if any is available, reporting on various metrics. +func (t *Tracker) Fulfil(resp Response) error { t.lock.Lock() defer t.lock.Unlock() // If it's a non existing request, track as stale response - req, ok := t.pending[id] + req, ok := t.pending[resp.ID] if !ok { - m := fmt.Sprintf("%s/%s/%d/%#02x", staleMeterName, t.protocol, version, code) - metrics.GetOrRegisterMeter(m, nil).Mark(1) - return + if metrics.Enabled() { + t.staleMeter(resp.MsgCode).Mark(1) + } + return ErrNoMatchingRequest } + // If the response is funky, it might be some active attack - if req.peer != peer || req.version != version || req.resCode != code { - log.Warn("Network response id collision", - "have", fmt.Sprintf("%s:%s/%d:%d", peer, t.protocol, version, code), - "want", fmt.Sprintf("%s:%s/%d:%d", peer, t.protocol, req.version, req.resCode), + if req.RespCode != resp.MsgCode { + log.Warn("Network response code collision", + "have", fmt.Sprintf("%s:%s/%d:%d", t.peer, t.cap.Name, t.cap.Version, resp.MsgCode), + "want", fmt.Sprintf("%s:%s/%d:%d", t.peer, t.cap.Name, t.cap.Version, req.RespCode), ) - return + return ErrCodeMismatch + } + if resp.Size > req.Size { + return ErrTooManyItems } + // Everything matches, mark the request serviced and meter it + wasHead := req.expire.Prev() == nil t.expire.Remove(req.expire) - delete(t.pending, id) - if req.expire.Prev() == nil { + delete(t.pending, req.ID) + if wasHead { if t.wake.Stop() { t.schedule() } } - g := fmt.Sprintf("%s/%s/%d/%#02x", trackedGaugeName, t.protocol, req.version, req.reqCode) - metrics.GetOrRegisterGauge(g, nil).Dec(1) - h := fmt.Sprintf("%s/%s/%d/%#02x", waitHistName, t.protocol, req.version, req.reqCode) + // Update request metrics. + if metrics.Enabled() { + t.trackedGauge(req.ReqCode).Dec(1) + t.waitHistogram(req.ReqCode).Update(time.Since(req.time).Microseconds()) + } + return nil +} + +func (t *Tracker) trackedGauge(code uint64) *metrics.Gauge { + name := fmt.Sprintf("%s/%s/%d/%#02x", trackedGaugeName, t.cap.Name, t.cap.Version, code) + return metrics.GetOrRegisterGauge(name, nil) +} + +func (t *Tracker) lostMeter(code uint64) *metrics.Meter { + name := fmt.Sprintf("%s/%s/%d/%#02x", lostMeterName, t.cap.Name, t.cap.Version, code) + return metrics.GetOrRegisterMeter(name, nil) +} + +func (t *Tracker) staleMeter(code uint64) *metrics.Meter { + name := fmt.Sprintf("%s/%s/%d/%#02x", staleMeterName, t.cap.Name, t.cap.Version, code) + return metrics.GetOrRegisterMeter(name, nil) +} + +func (t *Tracker) waitHistogram(code uint64) metrics.Histogram { + name := fmt.Sprintf("%s/%s/%d/%#02x", waitHistName, t.cap.Name, t.cap.Version, code) sampler := func() metrics.Sample { - return metrics.ResettingSample( - metrics.NewExpDecaySample(1028, 0.015), - ) + return metrics.ResettingSample(metrics.NewExpDecaySample(1028, 0.015)) } - metrics.GetOrRegisterHistogramLazy(h, nil, sampler).Update(time.Since(req.time).Microseconds()) + return metrics.GetOrRegisterHistogramLazy(name, nil, sampler) } diff --git a/p2p/tracker/tracker_test.go b/p2p/tracker/tracker_test.go new file mode 100644 index 000000000000..95e96296412a --- /dev/null +++ b/p2p/tracker/tracker_test.go @@ -0,0 +1,83 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package tracker + +import ( + "testing" + "time" + + "github.com/ethereum/go-ethereum/metrics" + "github.com/ethereum/go-ethereum/p2p" +) + +// TestCleanAfterStop verifies that the clean method does not crash when called +// after Stop. This can happen because clean is scheduled via time.AfterFunc and +// may fire after Stop sets t.expire to nil. +func TestCleanAfterStop(t *testing.T) { + cap := p2p.Cap{Name: "test", Version: 1} + timeout := 50 * time.Millisecond + tr := New(cap, "peer1", timeout) + + // Track a request to start the expiration timer. + tr.Track(Request{ID: 1, ReqCode: 0x01, RespCode: 0x02, Size: 1}) + + // Stop the tracker, then wait for the timer to fire. + tr.Stop() + time.Sleep(timeout + 50*time.Millisecond) + + // Also verify that calling clean directly after stop doesn't panic. + tr.clean() +} + +// This checks that metrics gauges for pending requests are be decremented when a +// Tracker is stopped. +func TestMetricsOnStop(t *testing.T) { + metrics.Enable() + + cap := p2p.Cap{Name: "test", Version: 1} + tr := New(cap, "peer1", time.Minute) + + // Track some requests with different ReqCodes. + var id uint64 + for i := 0; i < 3; i++ { + tr.Track(Request{ID: id, ReqCode: 0x01, RespCode: 0x02, Size: 1}) + id++ + } + for i := 0; i < 5; i++ { + tr.Track(Request{ID: id, ReqCode: 0x03, RespCode: 0x04, Size: 1}) + id++ + } + + gauge1 := tr.trackedGauge(0x01) + gauge2 := tr.trackedGauge(0x03) + + if gauge1.Snapshot().Value() != 3 { + t.Fatalf("gauge1 value mismatch: got %d, want 3", gauge1.Snapshot().Value()) + } + if gauge2.Snapshot().Value() != 5 { + t.Fatalf("gauge2 value mismatch: got %d, want 5", gauge2.Snapshot().Value()) + } + + tr.Stop() + + if gauge1.Snapshot().Value() != 0 { + t.Fatalf("gauge1 value after stop: got %d, want 0", gauge1.Snapshot().Value()) + } + if gauge2.Snapshot().Value() != 0 { + t.Fatalf("gauge2 value after stop: got %d, want 0", gauge2.Snapshot().Value()) + } +} diff --git a/params/config.go b/params/config.go index c5dfad1cd39e..17508cbf27e5 100644 --- a/params/config.go +++ b/params/config.go @@ -207,7 +207,7 @@ var ( CancunTime: nil, PragueTime: nil, OsakaTime: nil, - VerkleTime: nil, + UBTTime: nil, Ethash: new(EthashConfig), Clique: nil, } @@ -263,7 +263,7 @@ var ( CancunTime: nil, PragueTime: nil, OsakaTime: nil, - VerkleTime: nil, + UBTTime: nil, TerminalTotalDifficulty: big.NewInt(math.MaxInt64), Ethash: nil, Clique: &CliqueConfig{Period: 0, Epoch: 30000}, @@ -293,7 +293,7 @@ var ( CancunTime: nil, PragueTime: nil, OsakaTime: nil, - VerkleTime: nil, + UBTTime: nil, TerminalTotalDifficulty: big.NewInt(math.MaxInt64), Ethash: new(EthashConfig), Clique: nil, @@ -323,7 +323,7 @@ var ( CancunTime: newUint64(0), PragueTime: newUint64(0), OsakaTime: newUint64(0), - VerkleTime: nil, + UBTTime: nil, TerminalTotalDifficulty: big.NewInt(0), Ethash: new(EthashConfig), Clique: nil, @@ -358,7 +358,7 @@ var ( CancunTime: nil, PragueTime: nil, OsakaTime: nil, - VerkleTime: nil, + UBTTime: nil, TerminalTotalDifficulty: big.NewInt(math.MaxInt64), Ethash: new(EthashConfig), Clique: nil, @@ -466,7 +466,7 @@ type ChainConfig struct { BPO4Time *uint64 `json:"bpo4Time,omitempty"` // BPO4 switch time (nil = no fork, 0 = already on bpo4) BPO5Time *uint64 `json:"bpo5Time,omitempty"` // BPO5 switch time (nil = no fork, 0 = already on bpo5) AmsterdamTime *uint64 `json:"amsterdamTime,omitempty"` // Amsterdam switch time (nil = no fork, 0 = already on amsterdam) - VerkleTime *uint64 `json:"verkleTime,omitempty"` // Verkle switch time (nil = no fork, 0 = already on verkle) + UBTTime *uint64 `json:"ubtTime,omitempty"` // UBT switch time (nil = no fork, 0 = already on UBT) // TerminalTotalDifficulty is the amount of total difficulty reached by // the network that triggers the consensus upgrade. @@ -474,18 +474,18 @@ type ChainConfig struct { DepositContractAddress common.Address `json:"depositContractAddress,omitempty"` - // EnableVerkleAtGenesis is a flag that specifies whether the network uses + // EnableUBTAtGenesis is a flag that specifies whether the network uses // the Verkle tree starting from the genesis block. If set to true, the - // genesis state will be committed using the Verkle tree, eliminating the - // need for any Verkle transition later. + // genesis state will be committed using the Binary tree, eliminating the + // need for any Binary transition later. // - // This is a temporary flag only for verkle devnet testing, where verkle is + // This is a temporary flag only for binary devnet testing, where binary is // activated at genesis, and the configured activation date has already passed. // - // In production networks (mainnet and public testnets), verkle activation + // In production networks (mainnet and public testnets), binary activation // always occurs after the genesis block, making this flag irrelevant in // those cases. - EnableVerkleAtGenesis bool `json:"enableVerkleAtGenesis,omitempty"` + EnableUBTAtGenesis bool `json:"enableUBTAtGenesis,omitempty"` // Various consensus engines Ethash *EthashConfig `json:"ethash,omitempty"` @@ -595,8 +595,8 @@ func (c *ChainConfig) String() string { if c.AmsterdamTime != nil { result += fmt.Sprintf(", AmsterdamTime: %v", *c.AmsterdamTime) } - if c.VerkleTime != nil { - result += fmt.Sprintf(", VerkleTime: %v", *c.VerkleTime) + if c.UBTTime != nil { + result += fmt.Sprintf(", UBTTime: %v", *c.UBTTime) } result += "}" return result @@ -690,8 +690,8 @@ func (c *ChainConfig) Description() string { if c.AmsterdamTime != nil { banner += fmt.Sprintf(" - Amsterdam: @%-10v blob: (%s)\n", *c.AmsterdamTime, c.BlobScheduleConfig.Amsterdam) } - if c.VerkleTime != nil { - banner += fmt.Sprintf(" - Verkle: @%-10v blob: (%s)\n", *c.VerkleTime, c.BlobScheduleConfig.Verkle) + if c.UBTTime != nil { + banner += fmt.Sprintf(" - UBT: @%-10v blob: (%s)\n", *c.UBTTime, c.BlobScheduleConfig.UBT) } banner += fmt.Sprintf("\nAll fork specifications can be found at https://ethereum.github.io/execution-specs/src/ethereum/forks/\n") return banner @@ -717,13 +717,13 @@ type BlobScheduleConfig struct { Cancun *BlobConfig `json:"cancun,omitempty"` Prague *BlobConfig `json:"prague,omitempty"` Osaka *BlobConfig `json:"osaka,omitempty"` - Verkle *BlobConfig `json:"verkle,omitempty"` BPO1 *BlobConfig `json:"bpo1,omitempty"` BPO2 *BlobConfig `json:"bpo2,omitempty"` BPO3 *BlobConfig `json:"bpo3,omitempty"` BPO4 *BlobConfig `json:"bpo4,omitempty"` BPO5 *BlobConfig `json:"bpo5,omitempty"` Amsterdam *BlobConfig `json:"amsterdam,omitempty"` + UBT *BlobConfig `json:"ubt,omitempty"` } // IsHomestead returns whether num is either equal to the homestead block or greater. @@ -866,12 +866,12 @@ func (c *ChainConfig) IsAmsterdam(num *big.Int, time uint64) bool { return c.IsLondon(num) && isTimestampForked(c.AmsterdamTime, time) } -// IsVerkle returns whether time is either equal to the Verkle fork time or greater. -func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool { - return c.IsLondon(num) && isTimestampForked(c.VerkleTime, time) +// IsUBT returns whether time is either equal to the Verkle fork time or greater. +func (c *ChainConfig) IsUBT(num *big.Int, time uint64) bool { + return c.IsLondon(num) && isTimestampForked(c.UBTTime, time) } -// IsVerkleGenesis checks whether the verkle fork is activated at the genesis block. +// IsUBTGenesis checks whether the verkle fork is activated at the genesis block. // // Verkle mode is considered enabled if the verkle fork time is configured, // regardless of whether the local time has surpassed the fork activation time. @@ -881,13 +881,13 @@ func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool { // In production networks (mainnet and public testnets), verkle activation // always occurs after the genesis block, making this function irrelevant in // those cases. -func (c *ChainConfig) IsVerkleGenesis() bool { - return c.EnableVerkleAtGenesis +func (c *ChainConfig) IsUBTGenesis() bool { + return c.EnableUBTAtGenesis } // IsEIP4762 returns whether eip 4762 has been activated at given block. func (c *ChainConfig) IsEIP4762(num *big.Int, time uint64) bool { - return c.IsVerkle(num, time) + return c.IsUBT(num, time) } // CheckCompatible checks whether scheduled fork transitions have been imported @@ -945,7 +945,7 @@ func (c *ChainConfig) CheckConfigForkOrder() error { {name: "cancunTime", timestamp: c.CancunTime, optional: true}, {name: "pragueTime", timestamp: c.PragueTime, optional: true}, {name: "osakaTime", timestamp: c.OsakaTime, optional: true}, - {name: "verkleTime", timestamp: c.VerkleTime, optional: true}, + {name: "ubtTime", timestamp: c.UBTTime, optional: true}, {name: "bpo1", timestamp: c.BPO1Time, optional: true}, {name: "bpo2", timestamp: c.BPO2Time, optional: true}, {name: "bpo3", timestamp: c.BPO3Time, optional: true}, @@ -1104,8 +1104,8 @@ func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, headNumber *big.Int, if isForkTimestampIncompatible(c.OsakaTime, newcfg.OsakaTime, headTimestamp) { return newTimestampCompatError("Osaka fork timestamp", c.OsakaTime, newcfg.OsakaTime) } - if isForkTimestampIncompatible(c.VerkleTime, newcfg.VerkleTime, headTimestamp) { - return newTimestampCompatError("Verkle fork timestamp", c.VerkleTime, newcfg.VerkleTime) + if isForkTimestampIncompatible(c.UBTTime, newcfg.UBTTime, headTimestamp) { + return newTimestampCompatError("UBT fork timestamp", c.UBTTime, newcfg.UBTTime) } if isForkTimestampIncompatible(c.BPO1Time, newcfg.BPO1Time, headTimestamp) { return newTimestampCompatError("BPO1 fork timestamp", c.BPO1Time, newcfg.BPO1Time) @@ -1375,26 +1375,20 @@ func (err *ConfigCompatError) Error() string { // Rules is a one time interface meaning that it shouldn't be used in between transition // phases. type Rules struct { - ChainID *big.Int IsHomestead, IsEIP150, IsEIP155, IsEIP158 bool IsEIP2929, IsEIP4762 bool IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool IsBerlin, IsLondon bool IsMerge, IsShanghai, IsCancun, IsPrague, IsOsaka bool - IsAmsterdam, IsVerkle bool + IsAmsterdam, IsUBT bool } // Rules ensures c's ChainID is not nil. func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules { - chainID := c.ChainID - if chainID == nil { - chainID = new(big.Int) - } // disallow setting Merge out of order isMerge = isMerge && c.IsLondon(num) - isVerkle := isMerge && c.IsVerkle(num, timestamp) + isUBT := isMerge && c.IsUBT(num, timestamp) return Rules{ - ChainID: new(big.Int).Set(chainID), IsHomestead: c.IsHomestead(num), IsEIP150: c.IsEIP150(num), IsEIP155: c.IsEIP155(num), @@ -1404,7 +1398,7 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules IsPetersburg: c.IsPetersburg(num), IsIstanbul: c.IsIstanbul(num), IsBerlin: c.IsBerlin(num), - IsEIP2929: c.IsBerlin(num) && !isVerkle, + IsEIP2929: c.IsBerlin(num) && !isUBT, IsLondon: c.IsLondon(num), IsMerge: isMerge, IsShanghai: isMerge && c.IsShanghai(num, timestamp), @@ -1412,7 +1406,7 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules IsPrague: isMerge && c.IsPrague(num, timestamp), IsOsaka: isMerge && c.IsOsaka(num, timestamp), IsAmsterdam: isMerge && c.IsAmsterdam(num, timestamp), - IsVerkle: isVerkle, - IsEIP4762: isVerkle, + IsUBT: isUBT, + IsEIP4762: isUBT, } } diff --git a/params/protocol_params.go b/params/protocol_params.go index e8b044f45016..9da275c486f3 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -32,7 +32,7 @@ const ( MaximumExtraDataSize uint64 = 32 // Maximum size extra data may be after Genesis. ExpByteGas uint64 = 10 // Times ceil(log256(exponent)) for the EXP instruction. - SloadGas uint64 = 50 // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added. + SloadGas uint64 = 50 // CallValueTransferGas uint64 = 9000 // Paid for CALL when the value transfer is non-zero. CallNewAccountGas uint64 = 25000 // Paid for CALL when the destination address didn't exist prior. TxGas uint64 = 21000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions. @@ -82,7 +82,7 @@ const ( CallCreateDepth uint64 = 1024 // Maximum depth of call/create stack. ExpGas uint64 = 10 // Once per EXP instruction LogGas uint64 = 375 // Per LOG* operation. - CopyGas uint64 = 3 // + CopyGas uint64 = 3 // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added. StackLimit uint64 = 1024 // Maximum size of VM stack allowed. TierStepGas uint64 = 0 // Once per operation, for a selection of them. LogTopicGas uint64 = 375 // Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas. @@ -96,6 +96,7 @@ const ( TxDataNonZeroGasEIP2028 uint64 = 16 // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul) TxTokenPerNonZeroByte uint64 = 4 // Token cost per non-zero byte as specified by EIP-7623. TxCostFloorPerToken uint64 = 10 // Cost floor per byte of data as specified by EIP-7623. + TxCostFloorPerToken7976 uint64 = 16 // Cost floor per byte of data as specified by EIP-7976. TxAccessListAddressGas uint64 = 2400 // Per address specified in EIP 2930 access list TxAccessListStorageKeyGas uint64 = 1900 // Per storage key specified in EIP 2930 access list TxAuthTupleGas uint64 = 12500 // Per auth tuple code specified in EIP-7702 @@ -134,8 +135,10 @@ const ( DefaultElasticityMultiplier = 2 // Bounds the maximum gas limit an EIP-1559 block may have. InitialBaseFee = 1000000000 // Initial base fee for EIP-1559 blocks. - MaxCodeSize = 24576 // Maximum bytecode to permit for a contract - MaxInitCodeSize = 2 * MaxCodeSize // Maximum initcode to permit in a creation transaction and create instructions + MaxCodeSize = 24576 // Maximum bytecode to permit for a contract + MaxInitCodeSize = 2 * MaxCodeSize // Maximum initcode to permit in a creation transaction and create instructions + MaxCodeSizeAmsterdam = 32768 // Maximum bytecode to permit for a contract post Amsterdam + MaxInitCodeSizeAmsterdam = 2 * MaxCodeSizeAmsterdam // Maximum initcode to permit in a creation transaction and create instructions post Amsterdam // Precompiled contract gas prices @@ -220,3 +223,11 @@ var ( ConsolidationQueueAddress = common.HexToAddress("0x0000BBdDc7CE488642fb579F8B00f3a590007251") ConsolidationQueueCode = common.FromHex("3373fffffffffffffffffffffffffffffffffffffffe1460d35760115f54807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1461019a57600182026001905f5b5f82111560685781019083028483029004916001019190604d565b9093900492505050366060146088573661019a573461019a575f5260205ff35b341061019a57600154600101600155600354806004026004013381556001015f358155600101602035815560010160403590553360601b5f5260605f60143760745fa0600101600355005b6003546002548082038060021160e7575060025b5f5b8181146101295782810160040260040181607402815460601b815260140181600101548152602001816002015481526020019060030154905260010160e9565b910180921461013b5790600255610146565b90505f6002555f6003555b5f54807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff141561017357505f5b6001546001828201116101885750505f61018e565b01600190035b5f555f6001556074025ff35b5f5ffd") ) + +// System log events. +var ( + // EIP-7708 - System logs emitted for ETH transfer and burn + EthTransferLogEvent = common.HexToHash("0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") // keccak256('Transfer(address,address,uint256)') + EthBurnLogEvent = common.HexToHash("0xcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5") // keccak256('Burn(address,uint256)') + +) diff --git a/rlp/encbuffer.go b/rlp/encbuffer.go index 61d8bd059c85..ca0aa290fea4 100644 --- a/rlp/encbuffer.go +++ b/rlp/encbuffer.go @@ -366,6 +366,16 @@ func (w *EncoderBuffer) AppendToBytes(dst []byte) []byte { return out } +// Size returns the total size of the content that was encoded up to this point. +// Note this does not count the size of any lists which are still 'open' (i.e. for +// which ListEnd has not been called yet). +func (w EncoderBuffer) Size() int { + if w.buf == nil { + return 0 + } + return w.buf.size() +} + // Write appends b directly to the encoder output. func (w EncoderBuffer) Write(b []byte) (int, error) { return w.buf.Write(b) diff --git a/rlp/encode.go b/rlp/encode.go index ed9927573901..9d04e6324aa3 100644 --- a/rlp/encode.go +++ b/rlp/encode.go @@ -102,6 +102,29 @@ func EncodeToReader(val interface{}) (size int, r io.Reader, err error) { return buf.size(), &encReader{buf: buf}, nil } +// EncodeToRawList encodes val as an RLP list and returns it as a RawList. +func EncodeToRawList[T any](val []T) (RawList[T], error) { + if len(val) == 0 { + return RawList[T]{}, nil + } + + // Encode the value to an internal buffer. + buf := getEncBuffer() + defer encBufferPool.Put(buf) + if err := buf.encode(val); err != nil { + return RawList[T]{}, err + } + + // Create the RawList. RawList assumes the initial list header is padded + // 9 bytes, so we have to determine the offset where the value should be + // placed. + contentSize := buf.lheads[0].size + bytes := make([]byte, contentSize+9) + offset := 9 - headsize(uint64(contentSize)) + buf.copyTo(bytes[offset:]) + return RawList[T]{enc: bytes, length: len(val)}, nil +} + type listhead struct { offset int // index of this header in string data size int // total size of encoded data (including list headers) diff --git a/rlp/encode_test.go b/rlp/encode_test.go index e63ea319b42c..8dc9fdaf1f87 100644 --- a/rlp/encode_test.go +++ b/rlp/encode_test.go @@ -507,6 +507,39 @@ func TestEncodeToReaderReturnToPool(t *testing.T) { wg.Wait() } +func TestEncoderBufferSize(t *testing.T) { + var output bytes.Buffer + eb := NewEncoderBuffer(&output) + + assertSize := func(state string, expectedSize int) { + t.Helper() + if s := eb.Size(); s != expectedSize { + t.Fatalf("wrong size %s: %d", state, s) + } + } + + assertSize("empty buffer", 0) + outerList := eb.List() + assertSize("after outer List()", 0) + eb.WriteString("abc") + assertSize("after string write", 4) + innerList := eb.List() + assertSize("after inner List()", 4) + eb.WriteUint64(1) + eb.WriteUint64(2) + assertSize("after inner list writes", 6) + eb.ListEnd(innerList) + assertSize("after end of inner list", 7) + eb.ListEnd(outerList) + assertSize("after end of outer list", 8) + eb.Flush() + assertSize("after Flush()", 0) + + if output.Len() != 8 { + t.Fatalf("wrong final output size %d", output.Len()) + } +} + var sink interface{} func BenchmarkIntsize(b *testing.B) { diff --git a/rlp/iterator.go b/rlp/iterator.go index 05567fa05b90..9e41cec947d1 100644 --- a/rlp/iterator.go +++ b/rlp/iterator.go @@ -16,31 +16,35 @@ package rlp -type listIterator struct { - data []byte - next []byte - err error +// Iterator is an iterator over the elements of an encoded container. +type Iterator struct { + data []byte + next []byte + offset int + err error } -// NewListIterator creates an iterator for the (list) represented by data -func NewListIterator(data RawValue) (*listIterator, error) { +// NewListIterator creates an iterator for the (list) represented by data. +func NewListIterator(data RawValue) (Iterator, error) { k, t, c, err := readKind(data) if err != nil { - return nil, err + return Iterator{}, err } if k != List { - return nil, ErrExpectedList - } - it := &listIterator{ - data: data[t : t+c], + return Iterator{}, ErrExpectedList } + it := newIterator(data[t:t+c], int(t)) return it, nil } +func newIterator(data []byte, initialOffset int) Iterator { + return Iterator{data: data, offset: initialOffset} +} + // Next forwards the iterator one step. // Returns true if there is a next item or an error occurred on this step (check Err()). // On parse error, the iterator is marked finished and subsequent calls return false. -func (it *listIterator) Next() bool { +func (it *Iterator) Next() bool { if len(it.data) == 0 { return false } @@ -52,17 +56,34 @@ func (it *listIterator) Next() bool { it.data = nil return true } - it.next = it.data[:t+c] - it.data = it.data[t+c:] + length := t + c + it.next = it.data[:length] + it.data = it.data[length:] + it.offset += int(length) it.err = nil return true } -// Value returns the current value -func (it *listIterator) Value() []byte { +// Value returns the current value. +func (it *Iterator) Value() []byte { return it.next } -func (it *listIterator) Err() error { +// Count returns the remaining number of items. +// Note this is O(n) and the result may be incorrect if the list data is invalid. +// The returned count is always an upper bound on the remaining items +// that will be visited by the iterator. +func (it *Iterator) Count() int { + count, _ := CountValues(it.data) + return count +} + +// Offset returns the offset of the current value into the list data. +func (it *Iterator) Offset() int { + return it.offset - len(it.next) +} + +// Err returns the error that caused Next to return false, if any. +func (it *Iterator) Err() error { return it.err } diff --git a/rlp/iterator_test.go b/rlp/iterator_test.go index a22aaec86212..275d4371c776 100644 --- a/rlp/iterator_test.go +++ b/rlp/iterator_test.go @@ -17,6 +17,7 @@ package rlp import ( + "io" "testing" "github.com/ethereum/go-ethereum/common/hexutil" @@ -38,14 +39,25 @@ func TestIterator(t *testing.T) { t.Fatal("expected two elems, got zero") } txs := it.Value() + if offset := it.Offset(); offset != 3 { + t.Fatal("wrong offset", offset, "want 3") + } + // Check that uncles exist if !it.Next() { t.Fatal("expected two elems, got one") } + if offset := it.Offset(); offset != 219 { + t.Fatal("wrong offset", offset, "want 219") + } + txit, err := NewListIterator(txs) if err != nil { t.Fatal(err) } + if c := txit.Count(); c != 2 { + t.Fatal("wrong Count:", c) + } var i = 0 for txit.Next() { if txit.err != nil { @@ -57,3 +69,65 @@ func TestIterator(t *testing.T) { t.Errorf("count wrong, expected %d got %d", i, exp) } } + +func TestIteratorErrors(t *testing.T) { + tests := []struct { + input []byte + wantCount int // expected Count before iterating + wantErr error + }{ + // Second item string header claims 3 bytes content, but only 2 remain. + {unhex("C4 01 83AABB"), 2, ErrValueTooLarge}, + // Second item truncated: B9 requires 2 size bytes, none available. + {unhex("C2 01 B9"), 2, io.ErrUnexpectedEOF}, + // 0x05 should be encoded directly, not as 81 05. + {unhex("C3 01 8105"), 2, ErrCanonSize}, + // Long-form string header B8 used for 1-byte content (< 56). + {unhex("C4 01 B801AA"), 2, ErrCanonSize}, + // Long-form list header F8 used for 1-byte content (< 56). + {unhex("C4 01 F80101"), 2, ErrCanonSize}, + } + for _, tt := range tests { + it, err := NewListIterator(tt.input) + if err != nil { + t.Fatal("NewListIterator error:", err) + } + if c := it.Count(); c != tt.wantCount { + t.Fatalf("%x: Count = %d, want %d", tt.input, c, tt.wantCount) + } + n := 0 + for it.Next() { + if it.Err() != nil { + break + } + n++ + } + if wantN := tt.wantCount - 1; n != wantN { + t.Fatalf("%x: got %d valid items, want %d", tt.input, n, wantN) + } + if it.Err() != tt.wantErr { + t.Fatalf("%x: got error %v, want %v", tt.input, it.Err(), tt.wantErr) + } + if it.Next() { + t.Fatalf("%x: Next returned true after error", tt.input) + } + } +} + +func FuzzIteratorCount(f *testing.F) { + examples := [][]byte{unhex("010203"), unhex("018142"), unhex("01830202")} + for _, e := range examples { + f.Add(e) + } + f.Fuzz(func(t *testing.T, in []byte) { + it := newIterator(in, 0) + count := it.Count() + i := 0 + for it.Next() { + i++ + } + if i != count { + t.Fatalf("%x: count %d not equal to %d iterations", in, count, i) + } + }) +} diff --git a/rlp/raw.go b/rlp/raw.go index cec90346a105..5f41cad5c497 100644 --- a/rlp/raw.go +++ b/rlp/raw.go @@ -17,8 +17,10 @@ package rlp import ( + "fmt" "io" "reflect" + "slices" ) // RawValue represents an encoded RLP value and can be used to delay @@ -28,6 +30,156 @@ type RawValue []byte var rawValueType = reflect.TypeFor[RawValue]() +// RawList represents an encoded RLP list. +type RawList[T any] struct { + // The list is stored in encoded form. + // Note this buffer has some special properties: + // + // - if the buffer is nil, it's the zero value, representing + // an empty list. + // - if the buffer is non-nil, it must have a length of at least + // 9 bytes, which is reserved padding for the encoded list header. + // The remaining bytes, enc[9:], store the content bytes of the list. + // + // The implementation code mostly works with the Content method because it + // returns something valid either way. + enc []byte + + // length holds the number of items in the list. + length int +} + +// Content returns the RLP-encoded data of the list. +// This does not include the list-header. +// The return value is a direct reference to the internal buffer, not a copy. +func (r *RawList[T]) Content() []byte { + if r.enc == nil { + return nil + } else { + return r.enc[9:] + } +} + +// EncodeRLP writes the encoded list to the writer. +func (r RawList[T]) EncodeRLP(w io.Writer) error { + _, err := w.Write(r.Bytes()) + return err +} + +// Bytes returns the RLP encoding of the list. +// Note the return value aliases the internal buffer. +func (r *RawList[T]) Bytes() []byte { + if r == nil || r.enc == nil { + return []byte{0xC0} // zero value encodes as empty list + } + n := puthead(r.enc, 0xC0, 0xF7, uint64(len(r.Content()))) + copy(r.enc[9-n:], r.enc[:n]) + return r.enc[9-n:] +} + +// DecodeRLP decodes the list. This does not perform validation of the items! +func (r *RawList[T]) DecodeRLP(s *Stream) error { + k, size, err := s.Kind() + if err != nil { + return err + } + if k != List { + return fmt.Errorf("%w for %T", ErrExpectedList, r) + } + enc := make([]byte, 9+size) + if err := s.readFull(enc[9:]); err != nil { + return err + } + n, err := CountValues(enc[9:]) + if err != nil { + if err == ErrValueTooLarge { + return ErrElemTooLarge + } + return err + } + *r = RawList[T]{enc: enc, length: n} + return nil +} + +// Items decodes and returns all items in the list. +func (r *RawList[T]) Items() ([]T, error) { + items := make([]T, r.Len()) + it := r.ContentIterator() + for i := 0; it.Next(); i++ { + if err := DecodeBytes(it.Value(), &items[i]); err != nil { + return items[:i], err + } + } + return items, nil +} + +// Len returns the number of items in the list. +func (r *RawList[T]) Len() int { + return r.length +} + +// Size returns the encoded size of the list. +func (r *RawList[T]) Size() uint64 { + return ListSize(uint64(len(r.Content()))) +} + +// ContentIterator returns an iterator over the content of the list. +// Note the offsets returned by iterator.Offset are relative to the +// Content bytes of the list. +func (r *RawList[T]) ContentIterator() Iterator { + return newIterator(r.Content(), 0) +} + +// Append adds an item to the end of the list. +func (r *RawList[T]) Append(item T) error { + if r.enc == nil { + r.enc = make([]byte, 9) + } + + eb := getEncBuffer() + defer encBufferPool.Put(eb) + + if err := eb.encode(item); err != nil { + return err + } + prevEnd := len(r.enc) + end := prevEnd + eb.size() + r.enc = slices.Grow(r.enc, eb.size())[:end] + eb.copyTo(r.enc[prevEnd:end]) + r.length++ + return nil +} + +// AppendRaw adds an encoded item to the list. +// The given byte slice must contain exactly one RLP value. +func (r *RawList[T]) AppendRaw(b []byte) error { + _, tagsize, contentsize, err := readKind(b) + if err != nil { + return err + } + if tagsize+contentsize != uint64(len(b)) { + return fmt.Errorf("rlp: input has trailing bytes in AppendRaw") + } + if r.enc == nil { + r.enc = make([]byte, 9) + } + r.enc = append(r.enc, b...) + r.length++ + return nil +} + +// AppendList appends all items from another RawList to this list. +func (r *RawList[T]) AppendList(other *RawList[T]) { + if other.enc == nil || other.length == 0 { + return + } + if r.enc == nil { + r.enc = make([]byte, 9) + } + r.enc = append(r.enc, other.Content()...) + r.length += other.length +} + // StringSize returns the encoded size of a string. func StringSize(s string) uint64 { switch n := len(s); n { @@ -145,13 +297,52 @@ func CountValues(b []byte) (int, error) { for ; len(b) > 0; i++ { _, tagsize, size, err := readKind(b) if err != nil { - return 0, err + return i + 1, err } b = b[tagsize+size:] } return i, nil } +// SplitListValues extracts the raw elements from the list RLP-encoding blob. +// +// Note: the returned slice must not be modified, as it shares the same +// backing array as the original slice. It's acceptable to deep-copy the elements +// out if necessary, but let's stick with this approach for less allocation +// overhead. +func SplitListValues(b []byte) ([][]byte, error) { + b, _, err := SplitList(b) + if err != nil { + return nil, err + } + n, err := CountValues(b) + if err != nil { + return nil, err + } + var elements = make([][]byte, 0, n) + + for len(b) > 0 { + _, tagsize, size, err := readKind(b) + if err != nil { + return nil, err + } + elements = append(elements, b[:tagsize+size]) + b = b[tagsize+size:] + } + return elements, nil +} + +// MergeListValues takes a list of raw elements and rlp-encodes them as list. +func MergeListValues(elems [][]byte) ([]byte, error) { + w := NewEncoderBuffer(nil) + offset := w.List() + for _, elem := range elems { + w.Write(elem) + } + w.ListEnd(offset) + return w.ToBytes(), nil +} + func readKind(buf []byte) (k Kind, tagsize, contentsize uint64, err error) { if len(buf) == 0 { return 0, 0, 0, io.ErrUnexpectedEOF diff --git a/rlp/raw_test.go b/rlp/raw_test.go index 7b3255eca36b..ed7d3524c264 100644 --- a/rlp/raw_test.go +++ b/rlp/raw_test.go @@ -19,11 +19,307 @@ package rlp import ( "bytes" "errors" + "fmt" "io" + "reflect" "testing" "testing/quick" ) +type rawListTest[T any] struct { + input string + content string + items []T + length int +} + +func (test rawListTest[T]) name() string { + return fmt.Sprintf("%T-%d", *new(T), test.length) +} + +func (test rawListTest[T]) run(t *testing.T) { + // check decoding and properties + input := unhex(test.input) + inputSize := len(input) + var rl RawList[T] + if err := DecodeBytes(input, &rl); err != nil { + t.Fatal("decode failed:", err) + } + if l := rl.Len(); l != test.length { + t.Fatalf("wrong Len %d, want %d", l, test.length) + } + if sz := rl.Size(); sz != uint64(inputSize) { + t.Fatalf("wrong Size %d, want %d", sz, inputSize) + } + items, err := rl.Items() + if err != nil { + t.Fatal("Items failed:", err) + } + if !reflect.DeepEqual(items, test.items) { + t.Fatal("wrong items:", items) + } + if !bytes.Equal(rl.Content(), unhex(test.content)) { + t.Fatalf("wrong Content %x, want %s", rl.Content(), test.content) + } + if !bytes.Equal(rl.Bytes(), unhex(test.input)) { + t.Fatalf("wrong Bytes %x, want %s", rl.Bytes(), test.input) + } + + // check iterator + it := rl.ContentIterator() + i := 0 + for it.Next() { + var item T + if err := DecodeBytes(it.Value(), &item); err != nil { + t.Fatalf("item %d decode error: %v", i, err) + } + if !reflect.DeepEqual(item, items[i]) { + t.Fatalf("iterator has wrong item %v at %d", item, i) + } + i++ + } + if i != test.length { + t.Fatalf("iterator produced %d values, want %d", i, test.length) + } + if it.Err() != nil { + t.Fatalf("iterator error: %v", it.Err()) + } + + // check encoding round trip + output, err := EncodeToBytes(&rl) + if err != nil { + t.Fatal("encode error:", err) + } + if !bytes.Equal(output, unhex(test.input)) { + t.Fatalf("encoding does not round trip: %x", output) + } + + // check EncodeToRawList on items produces same bytes + encRL, err := EncodeToRawList(test.items) + if err != nil { + t.Fatal("EncodeToRawList error:", err) + } + encRLOutput, err := EncodeToBytes(&encRL) + if err != nil { + t.Fatal("EncodeToBytes of encoded list failed:", err) + } + if !bytes.Equal(encRLOutput, output) { + t.Fatalf("wrong encoding of EncodeToRawList result: %x", encRLOutput) + } +} + +func TestRawList(t *testing.T) { + tests := []interface { + name() string + run(t *testing.T) + }{ + rawListTest[uint64]{ + input: "C0", + content: "", + items: []uint64{}, + length: 0, + }, + rawListTest[uint64]{ + input: "C3010203", + content: "010203", + items: []uint64{1, 2, 3}, + length: 3, + }, + rawListTest[simplestruct]{ + input: "C6C20102C20304", + content: "C20102C20304", + items: []simplestruct{{1, "\x02"}, {3, "\x04"}}, + length: 2, + }, + rawListTest[string]{ + input: "F83C836161618362626283636363836464648365656583666666836767678368686883696969836A6A6A836B6B6B836C6C6C836D6D6D836E6E6E836F6F6F", + content: "836161618362626283636363836464648365656583666666836767678368686883696969836A6A6A836B6B6B836C6C6C836D6D6D836E6E6E836F6F6F", + items: []string{"aaa", "bbb", "ccc", "ddd", "eee", "fff", "ggg", "hhh", "iii", "jjj", "kkk", "lll", "mmm", "nnn", "ooo"}, + length: 15, + }, + } + + for _, test := range tests { + t.Run(test.name(), test.run) + } +} + +func TestRawListEmpty(t *testing.T) { + // zero value list + var rl RawList[uint64] + b, _ := EncodeToBytes(&rl) + if !bytes.Equal(b, unhex("C0")) { + t.Fatalf("empty RawList has wrong encoding %x", b) + } + if rl.Len() != 0 { + t.Fatalf("empty list has Len %d", rl.Len()) + } + if rl.Size() != 1 { + t.Fatalf("empty list has Size %d", rl.Size()) + } + if len(rl.Content()) > 0 { + t.Fatalf("empty list has non-empty Content") + } + if !bytes.Equal(rl.Bytes(), []byte{0xC0}) { + t.Fatalf("empty list has wrong encoding") + } + + // nil pointer + var nilptr *RawList[uint64] + b, _ = EncodeToBytes(nilptr) + if !bytes.Equal(b, unhex("C0")) { + t.Fatalf("nil pointer to RawList has wrong encoding %x", b) + } +} + +// This checks that *RawList works in an 'optional' context. +func TestRawListOptional(t *testing.T) { + type foo struct { + L *RawList[uint64] `rlp:"optional"` + } + // nil pointer encoding + var empty foo + b, _ := EncodeToBytes(empty) + if !bytes.Equal(b, unhex("C0")) { + t.Fatalf("nil pointer to RawList has wrong encoding %x", b) + } + // decoding + var dec foo + if err := DecodeBytes(unhex("C0"), &dec); err != nil { + t.Fatal(err) + } + if dec.L != nil { + t.Fatal("rawlist was decoded as non-nil") + } +} + +func TestRawListAppend(t *testing.T) { + var rl RawList[simplestruct] + + v1 := simplestruct{1, "one"} + v2 := simplestruct{2, "two"} + if err := rl.Append(v1); err != nil { + t.Fatal("append 1 failed:", err) + } + if err := rl.Append(v2); err != nil { + t.Fatal("append 2 failed:", err) + } + + if rl.Len() != 2 { + t.Fatalf("wrong Len %d", rl.Len()) + } + if rl.Size() != 13 { + t.Fatalf("wrong Size %d", rl.Size()) + } + if !bytes.Equal(rl.Content(), unhex("C501836F6E65 C5028374776F")) { + t.Fatalf("wrong Content %x", rl.Content()) + } + encoded, _ := EncodeToBytes(&rl) + if !bytes.Equal(encoded, unhex("CC C501836F6E65 C5028374776F")) { + t.Fatalf("wrong encoding %x", encoded) + } +} + +func TestRawListAppendRaw(t *testing.T) { + var rl RawList[uint64] + + if err := rl.AppendRaw(unhex("01")); err != nil { + t.Fatal("AppendRaw(01) failed:", err) + } + if err := rl.AppendRaw(unhex("820102")); err != nil { + t.Fatal("AppendRaw(820102) failed:", err) + } + if rl.Len() != 2 { + t.Fatalf("wrong Len %d after valid appends", rl.Len()) + } + + if err := rl.AppendRaw(nil); err == nil { + t.Fatal("AppendRaw(nil) should fail") + } + if err := rl.AppendRaw(unhex("0102")); err == nil { + t.Fatal("AppendRaw(0102) should fail due to trailing bytes") + } + if err := rl.AppendRaw(unhex("8201")); err == nil { + t.Fatal("AppendRaw(8201) should fail due to truncated value") + } + if rl.Len() != 2 { + t.Fatalf("wrong Len %d after invalid appends, want 2", rl.Len()) + } +} +func TestRawListAppendList(t *testing.T) { + var rl1 RawList[uint64] + if err := rl1.Append(uint64(1)); err != nil { + t.Fatal("append 1 failed:", err) + } + if err := rl1.Append(uint64(2)); err != nil { + t.Fatal("append 2 failed:", err) + } + + var rl2 RawList[uint64] + if err := rl2.Append(uint64(3)); err != nil { + t.Fatal("append 3 failed:", err) + } + if err := rl2.Append(uint64(4)); err != nil { + t.Fatal("append 4 failed:", err) + } + + rl1.AppendList(&rl2) + + if rl1.Len() != 4 { + t.Fatalf("wrong Len %d, want 4", rl1.Len()) + } + if rl1.Size() != 5 { + t.Fatalf("wrong Size %d, want 5", rl1.Size()) + } + + items, err := rl1.Items() + if err != nil { + t.Fatal("Items failed:", err) + } + if !reflect.DeepEqual(items, []uint64{1, 2, 3, 4}) { + t.Fatalf("wrong items: %v", items) + } + + var empty RawList[uint64] + prevLen := rl1.Len() + rl1.AppendList(&empty) + + if rl1.Len() != prevLen { + t.Fatalf("appending empty list changed Len: got %d, want %d", rl1.Len(), prevLen) + } + + empty.AppendList(&rl1) + + if empty.Len() != 4 { + t.Fatalf("wrong Len %d, want 4", empty.Len()) + } +} + +func TestRawListDecodeInvalid(t *testing.T) { + tests := []struct { + input string + err error + }{ + // Single item with non-canonical size (0x81 wrapping byte <= 0x7F). + {input: "C28142", err: ErrCanonSize}, + // Single item claiming more bytes than available in the list. + {input: "C484020202", err: ErrElemTooLarge}, + // Two items, second has non-canonical size. + {input: "C3018142", err: ErrCanonSize}, + // Two items, second claims more bytes than remain in the list. + {input: "C401830202", err: ErrElemTooLarge}, + // Item is a sub-list whose declared size exceeds available bytes. + {input: "C3C40102", err: ErrElemTooLarge}, + } + for _, test := range tests { + var rl RawList[RawValue] + err := DecodeBytes(unhex(test.input), &rl) + if !errors.Is(err, test.err) { + t.Errorf("input %s: error mismatch: got %v, want %v", test.input, err, test.err) + } + } +} + func TestCountValues(t *testing.T) { tests := []struct { input string // note: spaces in input are stripped by unhex @@ -40,9 +336,9 @@ func TestCountValues(t *testing.T) { {"820101 820202 8403030303 04", 4, nil}, // size errors - {"8142", 0, ErrCanonSize}, - {"01 01 8142", 0, ErrCanonSize}, - {"02 84020202", 0, ErrValueTooLarge}, + {"8142", 1, ErrCanonSize}, + {"01 01 8142", 3, ErrCanonSize}, + {"02 84020202", 2, ErrValueTooLarge}, { input: "A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", @@ -336,3 +632,269 @@ func TestBytesSize(t *testing.T) { } } } + +func TestSplitListValues(t *testing.T) { + tests := []struct { + name string + input string // hex-encoded RLP list + want []string // hex-encoded expected elements + wantErr error + }{ + { + name: "empty list", + input: "C0", + want: []string{}, + }, + { + name: "single byte element", + input: "C101", + want: []string{"01"}, + }, + { + name: "single empty string", + input: "C180", + want: []string{"80"}, + }, + { + name: "two byte elements", + input: "C20102", + want: []string{"01", "02"}, + }, + { + name: "three elements", + input: "C3010203", + want: []string{"01", "02", "03"}, + }, + { + name: "mixed size elements", + input: "C80182020283030303", + want: []string{"01", "820202", "83030303"}, + }, + { + name: "string elements", + input: "C88363617483646F67", + want: []string{"83636174", "83646F67"}, // cat,dog + }, + { + name: "nested list element", + input: "C4C3010203", // [[1,2,3]] + want: []string{"C3010203"}, // [1,2,3] + }, + { + name: "multiple nested lists", + input: "C6C20102C20304", // [[1,2],[3,4]] + want: []string{"C20102", "C20304"}, // [1,2], [3,4] + }, + { + name: "large list", + input: "C6010203040506", + want: []string{"01", "02", "03", "04", "05", "06"}, + }, + { + name: "list with empty strings", + input: "C3808080", + want: []string{"80", "80", "80"}, + }, + // Error cases + { + name: "single byte", + input: "01", + wantErr: ErrExpectedList, + }, + { + name: "string", + input: "83636174", + wantErr: ErrExpectedList, + }, + { + name: "empty input", + input: "", + wantErr: io.ErrUnexpectedEOF, + }, + { + name: "invalid list - value too large", + input: "C60102030405", + wantErr: ErrValueTooLarge, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := SplitListValues(unhex(tt.input)) + if !errors.Is(err, tt.wantErr) { + t.Errorf("SplitListValues() error = %v, wantErr %v", err, tt.wantErr) + return + } + if err != nil { + return + } + if len(got) != len(tt.want) { + t.Errorf("SplitListValues() got %d elements, want %d", len(got), len(tt.want)) + return + } + for i, elem := range got { + want := unhex(tt.want[i]) + if !bytes.Equal(elem, want) { + t.Errorf("SplitListValues() element[%d] = %x, want %x", i, elem, want) + } + } + }) + } +} + +func TestMergeListValues(t *testing.T) { + tests := []struct { + name string + elems []string // hex-encoded RLP elements + want string // hex-encoded expected result + wantErr error + }{ + { + name: "empty list", + elems: []string{}, + want: "C0", + }, + { + name: "single byte element", + elems: []string{"01"}, + want: "C101", + }, + { + name: "single empty string", + elems: []string{"80"}, + want: "C180", + }, + { + name: "two byte elements", + elems: []string{"01", "02"}, + want: "C20102", + }, + { + name: "three elements", + elems: []string{"01", "02", "03"}, + want: "C3010203", + }, + { + name: "mixed size elements", + elems: []string{"01", "820202", "83030303"}, + want: "C80182020283030303", + }, + { + name: "string elements", + elems: []string{"83636174", "83646F67"}, // cat, dog + want: "C88363617483646F67", + }, + { + name: "nested list element", + elems: []string{"C20102", "03"}, // [[1, 2], 3] + want: "C4C2010203", + }, + { + name: "multiple nested lists", + elems: []string{"C20102", "C3030405"}, // [[1,2],[3,4,5]], + want: "C7C20102C3030405", + }, + { + name: "large list", + elems: []string{"01", "02", "03", "04", "05", "06"}, + want: "C6010203040506", + }, + { + name: "list with empty strings", + elems: []string{"80", "80", "80"}, + want: "C3808080", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + elems := make([][]byte, len(tt.elems)) + for i, s := range tt.elems { + elems[i] = unhex(s) + } + got, err := MergeListValues(elems) + if !errors.Is(err, tt.wantErr) { + t.Errorf("MergeListValues() error = %v, wantErr %v", err, tt.wantErr) + return + } + if err != nil { + return + } + want := unhex(tt.want) + if !bytes.Equal(got, want) { + t.Errorf("MergeListValues() = %x, want %x", got, want) + } + }) + } +} + +func TestSplitMergeList(t *testing.T) { + tests := []struct { + name string + input string // hex-encoded RLP list + }{ + { + name: "empty list", + input: "C0", + }, + { + name: "single byte element", + input: "C101", + }, + { + name: "two byte elements", + input: "C20102", + }, + { + name: "three elements", + input: "C3010203", + }, + { + name: "mixed size elements", + input: "C80182020283030303", + }, + { + name: "string elements", + input: "C88363617483646F67", // [cat, dog] + }, + { + name: "nested list element", + input: "C4C2010203", // [[1,2],3] + }, + { + name: "multiple nested lists", + input: "C6C20102C20304", // [[1,2],[3,4]] + }, + { + name: "large list", + input: "C6010203040506", // [1,2,3,4,5,6] + }, + { + name: "list with empty strings", + input: "C3808080", // ["", "", ""] + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + original := unhex(tt.input) + + // Split the list + elements, err := SplitListValues(original) + if err != nil { + t.Fatalf("SplitListValues() error = %v", err) + } + + // Merge back + merged, err := MergeListValues(elements) + if err != nil { + t.Fatalf("MergeListValues() error = %v", err) + } + + // The merged result should match the original + if !bytes.Equal(merged, original) { + t.Errorf("Round trip failed: original = %x, merged = %x", original, merged) + } + }) + } +} diff --git a/rlp/rlpgen/gen_test.go b/rlp/rlpgen/gen_test.go index 4bfb1b9d255f..2e35ef933d1c 100644 --- a/rlp/rlpgen/gen_test.go +++ b/rlp/rlpgen/gen_test.go @@ -26,6 +26,7 @@ import ( "go/types" "os" "path/filepath" + "runtime" "testing" ) @@ -52,6 +53,9 @@ var tests = []string{"uints", "nil", "rawvalue", "optional", "bigint", "uint256" func TestOutput(t *testing.T) { for _, test := range tests { t.Run(test, func(t *testing.T) { + if test == "pkgclash" && runtime.GOOS == "windows" { + t.Skip("source-based importer is pathologically slow on Windows/NTFS") + } inputFile := filepath.Join("testdata", test+".in.txt") outputFile := filepath.Join("testdata", test+".out.txt") bctx, typ, err := loadTestSource(inputFile, "Test") diff --git a/rlp/rlpgen/testdata/pkgclash.in.txt b/rlp/rlpgen/testdata/pkgclash.in.txt index 1d407881ce41..a8c4092601a9 100644 --- a/rlp/rlpgen/testdata/pkgclash.in.txt +++ b/rlp/rlpgen/testdata/pkgclash.in.txt @@ -9,5 +9,5 @@ import ( type Test struct { A eth1.MinerAPI - B eth2.GetReceiptsPacket + B eth2.GetReceiptsPacket69 } diff --git a/rlp/rlpgen/testdata/pkgclash.out.txt b/rlp/rlpgen/testdata/pkgclash.out.txt index d119639b9978..302f1ec1cdfa 100644 --- a/rlp/rlpgen/testdata/pkgclash.out.txt +++ b/rlp/rlpgen/testdata/pkgclash.out.txt @@ -41,7 +41,7 @@ func (obj *Test) DecodeRLP(dec *rlp.Stream) error { } _tmp0.A = _tmp1 // B: - var _tmp2 eth1.GetReceiptsPacket + var _tmp2 eth1.GetReceiptsPacket69 { if _, err := dec.List(); err != nil { return err diff --git a/rpc/client.go b/rpc/client.go index 9dc36a6105ec..8d81503d598f 100644 --- a/rpc/client.go +++ b/rpc/client.go @@ -119,7 +119,7 @@ func (c *Client) newClientConn(conn ServerCodec) *clientConn { ctx := context.Background() ctx = context.WithValue(ctx, clientContextKey{}, c) ctx = context.WithValue(ctx, peerInfoContextKey{}, conn.peerInfo()) - handler := newHandler(ctx, conn, c.idgen, c.services, c.batchItemLimit, c.batchResponseMaxSize) + handler := newHandler(ctx, conn, c.idgen, c.services, c.batchItemLimit, c.batchResponseMaxSize, nil) return &clientConn{conn, handler} } diff --git a/rpc/handler.go b/rpc/handler.go index 45558d5821c8..c0af162f1324 100644 --- a/rpc/handler.go +++ b/rpc/handler.go @@ -28,7 +28,10 @@ import ( "sync" "time" + "github.com/ethereum/go-ethereum/internal/telemetry" "github.com/ethereum/go-ethereum/log" + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/trace" ) // handler handles JSON-RPC messages. There is one handler per connection. Note that @@ -65,6 +68,7 @@ type handler struct { allowSubscribe bool batchRequestLimit int batchResponseMaxSize int + tracerProvider trace.TracerProvider subLock sync.Mutex serverSubs map[ID]*Subscription @@ -73,9 +77,10 @@ type handler struct { type callProc struct { ctx context.Context notifiers []*Notifier + isBatch bool } -func newHandler(connCtx context.Context, conn jsonWriter, idgen func() ID, reg *serviceRegistry, batchRequestLimit, batchResponseMaxSize int) *handler { +func newHandler(connCtx context.Context, conn jsonWriter, idgen func() ID, reg *serviceRegistry, batchRequestLimit, batchResponseMaxSize int, tracerProvider trace.TracerProvider) *handler { rootCtx, cancelRoot := context.WithCancel(connCtx) h := &handler{ reg: reg, @@ -90,6 +95,7 @@ func newHandler(connCtx context.Context, conn jsonWriter, idgen func() ID, reg * log: log.Root(), batchRequestLimit: batchRequestLimit, batchResponseMaxSize: batchResponseMaxSize, + tracerProvider: tracerProvider, } if conn.remoteAddr() != "" { h.log = h.log.New("conn", conn.remoteAddr()) @@ -197,6 +203,7 @@ func (h *handler) handleBatch(msgs []*jsonrpcMessage) { // Process calls on a goroutine because they may block indefinitely: h.startCallProc(func(cp *callProc) { + cp.isBatch = true var ( timer *time.Timer cancel context.CancelFunc @@ -497,40 +504,65 @@ func (h *handler) handleCall(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage if msg.isSubscribe() { return h.handleSubscribe(cp, msg) } - var callb *callback if msg.isUnsubscribe() { - callb = h.unsubscribeCb - } else { - // Check method name length - if len(msg.Method) > maxMethodNameLength { - return msg.errorResponse(&invalidRequestError{fmt.Sprintf("method name too long: %d > %d", len(msg.Method), maxMethodNameLength)}) + args, err := parsePositionalArguments(msg.Params, h.unsubscribeCb.argTypes) + if err != nil { + return msg.errorResponse(&invalidParamsError{err.Error()}) } - callb = h.reg.callback(msg.Method) + return h.runMethod(cp.ctx, msg, h.unsubscribeCb, args) + } + + // Check method name length + if len(msg.Method) > maxMethodNameLength { + return msg.errorResponse(&invalidRequestError{fmt.Sprintf("method name too long: %d > %d", len(msg.Method), maxMethodNameLength)}) } + callb, service, method := h.reg.callback(msg.Method) + + // If the method is not found, return an error. if callb == nil { return msg.errorResponse(&methodNotFoundError{method: msg.Method}) } - args, err := parsePositionalArguments(msg.Params, callb.argTypes) - if err != nil { - return msg.errorResponse(&invalidParamsError{err.Error()}) + // Start root span for the request. + rpcInfo := telemetry.RPCInfo{ + System: "jsonrpc", + Service: service, + Method: method, + RequestID: string(msg.ID), + } + attrib := []telemetry.Attribute{ + telemetry.BoolAttribute("rpc.batch", cp.isBatch), + } + ctx, spanEnd := telemetry.StartServerSpan(cp.ctx, h.tracer(), rpcInfo, attrib...) + defer spanEnd(nil) // don't propagate errors to parent spans + + // Start tracing span before parsing arguments. + _, _, pSpanEnd := telemetry.StartSpanWithTracer(ctx, h.tracer(), "rpc.parsePositionalArguments") + args, pErr := parsePositionalArguments(msg.Params, callb.argTypes) + pSpanEnd(&pErr) + if pErr != nil { + return msg.errorResponse(&invalidParamsError{pErr.Error()}) } start := time.Now() - answer := h.runMethod(cp.ctx, msg, callb, args) - // Collect the statistics for RPC calls if metrics is enabled. - // We only care about pure rpc call. Filter out subscription. - if callb != h.unsubscribeCb { - rpcRequestGauge.Inc(1) - if answer.Error != nil { - failedRequestGauge.Inc(1) - } else { - successfulRequestGauge.Inc(1) - } - rpcServingTimer.UpdateSince(start) - updateServeTimeHistogram(msg.Method, answer.Error == nil, time.Since(start)) + // Start tracing span before running the method. + rctx, _, rSpanEnd := telemetry.StartSpanWithTracer(ctx, h.tracer(), "rpc.runMethod") + answer := h.runMethod(rctx, msg, callb, args) + var rErr error + if answer.Error != nil { + rErr = errors.New(answer.Error.Message) } + rSpanEnd(&rErr) + // Collect the statistics for RPC calls if metrics is enabled. + rpcRequestGauge.Inc(1) + if answer.Error != nil { + failedRequestGauge.Inc(1) + } else { + successfulRequestGauge.Inc(1) + } + rpcServingTimer.UpdateSince(start) + updateServeTimeHistogram(msg.Method, answer.Error == nil, time.Since(start)) return answer } @@ -568,17 +600,33 @@ func (h *handler) handleSubscribe(cp *callProc, msg *jsonrpcMessage) *jsonrpcMes n := &Notifier{h: h, namespace: namespace} cp.notifiers = append(cp.notifiers, n) ctx := context.WithValue(cp.ctx, notifierKey{}, n) - return h.runMethod(ctx, msg, callb, args) } +// tracer returns the OpenTelemetry Tracer for RPC call tracing. +func (h *handler) tracer() trace.Tracer { + if h.tracerProvider == nil { + // Default to global TracerProvider if none is set. + // Note: If no TracerProvider is set, the default is a no-op TracerProvider. + // See https://pkg.go.dev/go.opentelemetry.io/otel#GetTracerProvider + return otel.Tracer("") + } + return h.tracerProvider.Tracer("") +} + // runMethod runs the Go callback for an RPC method. -func (h *handler) runMethod(ctx context.Context, msg *jsonrpcMessage, callb *callback, args []reflect.Value) *jsonrpcMessage { +func (h *handler) runMethod(ctx context.Context, msg *jsonrpcMessage, callb *callback, args []reflect.Value, attributes ...telemetry.Attribute) *jsonrpcMessage { result, err := callb.call(ctx, msg.Method, args) if err != nil { return msg.errorResponse(err) } - return msg.response(result) + _, _, spanEnd := telemetry.StartSpanWithTracer(ctx, h.tracer(), "rpc.encodeJSONResponse", attributes...) + response := msg.response(result) + if response.Error != nil { + err = errors.New(response.Error.Message) + } + spanEnd(&err) + return response } // unsubscribe is the callback function for all *_unsubscribe calls. @@ -612,8 +660,11 @@ type limitedBuffer struct { } func (buf *limitedBuffer) Write(data []byte) (int, error) { - avail := max(buf.limit, len(buf.output)) - if len(data) < avail { + avail := buf.limit - len(buf.output) + if avail <= 0 { + return 0, errTruncatedOutput + } + if len(data) <= avail { buf.output = append(buf.output, data...) return len(data), nil } diff --git a/rpc/http.go b/rpc/http.go index a74f36a1b07f..55f0abfa72a8 100644 --- a/rpc/http.go +++ b/rpc/http.go @@ -30,6 +30,9 @@ import ( "strconv" "sync" "time" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/propagation" ) const ( @@ -334,6 +337,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { ctx := r.Context() ctx = context.WithValue(ctx, peerInfoContextKey{}, connInfo) + // Extract trace context from incoming headers. + ctx = otel.GetTextMapPropagator().Extract(ctx, propagation.HeaderCarrier(r.Header)) + // All checks passed, create a codec that reads directly from the request body // until EOF, writes the response to w, and orders the server to process a // single request. diff --git a/rpc/server.go b/rpc/server.go index 599e31fb4178..94d4a3e13ebf 100644 --- a/rpc/server.go +++ b/rpc/server.go @@ -25,6 +25,7 @@ import ( "sync/atomic" "github.com/ethereum/go-ethereum/log" + "go.opentelemetry.io/otel/trace" ) const MetadataApi = "rpc" @@ -55,15 +56,17 @@ type Server struct { batchResponseLimit int httpBodyLimit int wsReadLimit int64 + tracerProvider trace.TracerProvider } // NewServer creates a new server instance with no registered handlers. func NewServer() *Server { server := &Server{ - idgen: randomIDGenerator(), - codecs: make(map[ServerCodec]struct{}), - httpBodyLimit: defaultBodyLimit, - wsReadLimit: wsDefaultReadLimit, + idgen: randomIDGenerator(), + codecs: make(map[ServerCodec]struct{}), + httpBodyLimit: defaultBodyLimit, + wsReadLimit: wsDefaultReadLimit, + tracerProvider: nil, } server.run.Store(true) // Register the default service providing meta information about the RPC service such @@ -129,6 +132,15 @@ func (s *Server) ServeCodec(codec ServerCodec, options CodecOption) { c.Close() } +// setTracerProvider configures the OpenTelemetry TracerProvider for RPC call tracing. +// Note: This method (and the TracerProvider field in the Server/Handler struct) is +// primarily intended for testing. In particular, it allows tests to configure an +// isolated TracerProvider without changing the global provider, avoiding +// interference between tests running in parallel. +func (s *Server) setTracerProvider(tp trace.TracerProvider) { + s.tracerProvider = tp +} + func (s *Server) trackCodec(codec ServerCodec) bool { s.mutex.Lock() defer s.mutex.Unlock() @@ -156,7 +168,7 @@ func (s *Server) serveSingleRequest(ctx context.Context, codec ServerCodec) { return } - h := newHandler(ctx, codec, s.idgen, &s.services, s.batchItemLimit, s.batchResponseLimit) + h := newHandler(ctx, codec, s.idgen, &s.services, s.batchItemLimit, s.batchResponseLimit, s.tracerProvider) h.allowSubscribe = false defer h.close(io.EOF, nil) diff --git a/rpc/service.go b/rpc/service.go index 0f62d7eb7c2c..8462a5a59a4f 100644 --- a/rpc/service.go +++ b/rpc/service.go @@ -92,14 +92,14 @@ func (r *serviceRegistry) registerName(name string, rcvr interface{}) error { } // callback returns the callback corresponding to the given RPC method name. -func (r *serviceRegistry) callback(method string) *callback { +func (r *serviceRegistry) callback(method string) (cb *callback, service, methodName string) { before, after, found := strings.Cut(method, serviceMethodSeparator) if !found { - return nil + return nil, "", "" } r.mu.Lock() defer r.mu.Unlock() - return r.services[before].callbacks[after] + return r.services[before].callbacks[after], before, after } // subscription returns a subscription callback in the given service. diff --git a/rpc/tracing_test.go b/rpc/tracing_test.go new file mode 100644 index 000000000000..5a04c901fdb8 --- /dev/null +++ b/rpc/tracing_test.go @@ -0,0 +1,268 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package rpc + +import ( + "context" + "net/http/httptest" + "testing" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/propagation" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + "go.opentelemetry.io/otel/sdk/trace/tracetest" +) + +// attributeMap converts a slice of attributes to a map. +func attributeMap(attrs []attribute.KeyValue) map[string]string { + m := make(map[string]string) + for _, a := range attrs { + switch a.Value.Type() { + case attribute.STRING: + m[string(a.Key)] = a.Value.AsString() + case attribute.BOOL: + if a.Value.AsBool() { + m[string(a.Key)] = "true" + } else { + m[string(a.Key)] = "false" + } + default: + m[string(a.Key)] = a.Value.Emit() + } + } + return m +} + +// newTracingServer creates a new server with tracing enabled. +func newTracingServer(t *testing.T) (*Server, *sdktrace.TracerProvider, *tracetest.InMemoryExporter) { + t.Helper() + exporter := tracetest.NewInMemoryExporter() + tp := sdktrace.NewTracerProvider(sdktrace.WithSyncer(exporter)) + t.Cleanup(func() { _ = tp.Shutdown(context.Background()) }) + server := newTestServer() + server.setTracerProvider(tp) + t.Cleanup(server.Stop) + return server, tp, exporter +} + +// TestTracingHTTP verifies that RPC spans are emitted when processing HTTP requests. +func TestTracingHTTP(t *testing.T) { + // Not parallel: this test modifies the global otel TextMapPropagator. + + // Set up a propagator to extract W3C Trace Context headers. + originalPropagator := otel.GetTextMapPropagator() + otel.SetTextMapPropagator(propagation.TraceContext{}) + t.Cleanup(func() { otel.SetTextMapPropagator(originalPropagator) }) + + server, tracer, exporter := newTracingServer(t) + httpsrv := httptest.NewServer(server) + t.Cleanup(httpsrv.Close) + + // Define the expected trace and span IDs for context propagation. + const ( + traceID = "4bf92f3577b34da6a3ce929d0e0e4736" + parentSpanID = "00f067aa0ba902b7" + traceparent = "00-" + traceID + "-" + parentSpanID + "-01" + ) + + client, err := DialHTTP(httpsrv.URL) + if err != nil { + t.Fatalf("failed to dial: %v", err) + } + t.Cleanup(client.Close) + + // Set trace context headers. + client.SetHeader("traceparent", traceparent) + + // Make a successful RPC call. + var result echoResult + if err := client.Call(&result, "test_echo", "hello", 42, &echoArgs{S: "world"}); err != nil { + t.Fatalf("RPC call failed: %v", err) + } + + // Flush and verify that we emitted the expected span. + if err := tracer.ForceFlush(context.Background()); err != nil { + t.Fatalf("failed to flush: %v", err) + } + spans := exporter.GetSpans() + if len(spans) == 0 { + t.Fatal("no spans were emitted") + } + var rpcSpan *tracetest.SpanStub + for i := range spans { + if spans[i].Name == "jsonrpc.test/echo" { + rpcSpan = &spans[i] + break + } + } + if rpcSpan == nil { + t.Fatalf("jsonrpc.test/echo span not found") + } + + // Verify span attributes. + attrs := attributeMap(rpcSpan.Attributes) + if attrs["rpc.system"] != "jsonrpc" { + t.Errorf("expected rpc.system=jsonrpc, got %v", attrs["rpc.system"]) + } + if attrs["rpc.service"] != "test" { + t.Errorf("expected rpc.service=test, got %v", attrs["rpc.service"]) + } + if attrs["rpc.method"] != "echo" { + t.Errorf("expected rpc.method=echo, got %v", attrs["rpc.method"]) + } + if _, ok := attrs["rpc.jsonrpc.request_id"]; !ok { + t.Errorf("expected rpc.jsonrpc.request_id attribute to be set") + } + + // Verify the span's parent matches the traceparent header values. + if got := rpcSpan.Parent.TraceID().String(); got != traceID { + t.Errorf("parent trace ID mismatch: got %s, want %s", got, traceID) + } + if got := rpcSpan.Parent.SpanID().String(); got != parentSpanID { + t.Errorf("parent span ID mismatch: got %s, want %s", got, parentSpanID) + } + if !rpcSpan.Parent.IsRemote() { + t.Error("expected parent span context to be marked as remote") + } +} + +// TestTracingErrorRecording verifies that errors are recorded on spans. +func TestTracingHTTPErrorRecording(t *testing.T) { + t.Parallel() + server, tracer, exporter := newTracingServer(t) + httpsrv := httptest.NewServer(server) + t.Cleanup(httpsrv.Close) + client, err := DialHTTP(httpsrv.URL) + if err != nil { + t.Fatalf("failed to dial: %v", err) + } + t.Cleanup(client.Close) + + // Call a method that returns an error. + var result any + err = client.Call(&result, "test_returnError") + if err == nil { + t.Fatal("expected error from test_returnError") + } + + // Flush and verify spans recorded the error. + if err := tracer.ForceFlush(context.Background()); err != nil { + t.Fatalf("failed to flush: %v", err) + } + spans := exporter.GetSpans() + + // Only the runMethod span should have error status. + if len(spans) == 0 { + t.Fatal("no spans were emitted") + } + for _, span := range spans { + switch span.Name { + case "rpc.runMethod": + if span.Status.Code != codes.Error { + t.Errorf("expected %s span status Error, got %v", span.Name, span.Status.Code) + } + default: + if span.Status.Code == codes.Error { + t.Errorf("unexpected error status on span %s", span.Name) + } + } + } +} + +// TestTracingBatchHTTP verifies that RPC spans are emitted for batched JSON-RPC calls over HTTP. +func TestTracingBatchHTTP(t *testing.T) { + t.Parallel() + server, tracer, exporter := newTracingServer(t) + httpsrv := httptest.NewServer(server) + t.Cleanup(httpsrv.Close) + client, err := DialHTTP(httpsrv.URL) + if err != nil { + t.Fatalf("failed to dial: %v", err) + } + t.Cleanup(client.Close) + + // Make a successful batch RPC call. + batch := []BatchElem{ + { + Method: "test_echo", + Args: []any{"hello", 42, &echoArgs{S: "world"}}, + Result: new(echoResult), + }, + { + Method: "test_echo", + Args: []any{"your", 7, &echoArgs{S: "mom"}}, + Result: new(echoResult), + }, + } + if err := client.BatchCall(batch); err != nil { + t.Fatalf("batch RPC call failed: %v", err) + } + + // Flush and verify we emitted spans for each batch element. + if err := tracer.ForceFlush(context.Background()); err != nil { + t.Fatalf("failed to flush: %v", err) + } + spans := exporter.GetSpans() + if len(spans) == 0 { + t.Fatal("no spans were emitted") + } + var found int + for i := range spans { + if spans[i].Name == "jsonrpc.test/echo" { + attrs := attributeMap(spans[i].Attributes) + if attrs["rpc.system"] == "jsonrpc" && + attrs["rpc.service"] == "test" && + attrs["rpc.method"] == "echo" && + attrs["rpc.batch"] == "true" { + found++ + } + } + } + if found != len(batch) { + t.Fatalf("expected %d matching batch spans, got %d", len(batch), found) + } +} + +// TestTracingSubscribeUnsubscribe verifies that subscribe and unsubscribe calls +// do not emit any spans. +// Note: This works because client.newClientConn() passes nil as the tracer provider. +func TestTracingSubscribeUnsubscribe(t *testing.T) { + t.Parallel() + server, tracer, exporter := newTracingServer(t) + client := DialInProc(server) + t.Cleanup(client.Close) + + // Subscribe to notifications. + sub, err := client.Subscribe(context.Background(), "nftest", make(chan int), "someSubscription", 1, 1) + if err != nil { + t.Fatalf("subscribe failed: %v", err) + } + + // Unsubscribe. + sub.Unsubscribe() + + // Flush and check that no spans were emitted. + if err := tracer.ForceFlush(context.Background()); err != nil { + t.Fatalf("failed to flush: %v", err) + } + spans := exporter.GetSpans() + if len(spans) != 0 { + t.Errorf("expected no spans for subscribe/unsubscribe, got %d", len(spans)) + } +} diff --git a/rpc/websocket.go b/rpc/websocket.go index 543ff617baac..ec676b9caf03 100644 --- a/rpc/websocket.go +++ b/rpc/websocket.go @@ -324,6 +324,16 @@ func newWebsocketCodec(conn *websocket.Conn, host string, req http.Header, readL } func (wc *websocketCodec) close() { + // Send a WebSocket Close frame before closing the underlying connection, + // so the server sees a clean 1000 (normal closure) instead of 1006 (abnormal). + wc.jsonCodec.encMu.Lock() + wc.conn.WriteControl( + websocket.CloseMessage, + websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""), + time.Now().Add(wsPingWriteTimeout), + ) + wc.jsonCodec.encMu.Unlock() + wc.jsonCodec.close() wc.wg.Wait() } diff --git a/signer/core/apitypes/types.go b/signer/core/apitypes/types.go index 9034e7e9ca0a..ee12bb263e4a 100644 --- a/signer/core/apitypes/types.go +++ b/signer/core/apitypes/types.go @@ -108,6 +108,7 @@ type SendTxArgs struct { BlobHashes []common.Hash `json:"blobVersionedHashes,omitempty"` // For BlobTxType transactions with blob sidecar + BlobVersion byte `json:"blobVersion,omitempty"` Blobs []kzg4844.Blob `json:"blobs,omitempty"` Commitments []kzg4844.Commitment `json:"commitments,omitempty"` Proofs []kzg4844.Proof `json:"proofs,omitempty"` @@ -235,37 +236,58 @@ func (args *SendTxArgs) validateTxSidecar() error { if args.Commitments != nil && len(args.Commitments) != n { return fmt.Errorf("number of blobs and commitments mismatch (have=%d, want=%d)", len(args.Commitments), n) } - if args.Proofs != nil && len(args.Proofs) != n { - return fmt.Errorf("number of blobs and proofs mismatch (have=%d, want=%d)", len(args.Proofs), n) - } if args.BlobHashes != nil && len(args.BlobHashes) != n { return fmt.Errorf("number of blobs and hashes mismatch (have=%d, want=%d)", len(args.BlobHashes), n) } - + if args.Proofs != nil { + if len(args.Proofs) == n { + // v1 transaction + for i := range args.Blobs { + if err := kzg4844.VerifyBlobProof(&args.Blobs[i], args.Commitments[i], args.Proofs[i]); err != nil { + return fmt.Errorf("failed to verify blob proof: %v", err) + } + } + } else if len(args.Proofs) == n*kzg4844.CellProofsPerBlob { + // v2 transaction + if err := kzg4844.VerifyCellProofs(args.Blobs, args.Commitments, args.Proofs); err != nil { + return fmt.Errorf("failed to verify blob proof: %v", err) + } + } else { + return fmt.Errorf("number of proofs and blobs mismatch (have=%d, want=%d or %d)", len(args.Proofs), n, n*kzg4844.CellProofsPerBlob) + } + } if args.Commitments == nil { // Generate commitment and proof. commitments := make([]kzg4844.Commitment, n) - proofs := make([]kzg4844.Proof, n) - for i, b := range args.Blobs { - c, err := kzg4844.BlobToCommitment(&b) + for i := range args.Blobs { + c, err := kzg4844.BlobToCommitment(&args.Blobs[i]) if err != nil { return fmt.Errorf("blobs[%d]: error computing commitment: %v", i, err) } commitments[i] = c - p, err := kzg4844.ComputeBlobProof(&b, c) - if err != nil { - return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err) + } + var proofs []kzg4844.Proof + if args.BlobVersion == types.BlobSidecarVersion1 { + proofs = make([]kzg4844.Proof, 0, n*kzg4844.CellProofsPerBlob) + for i := range args.Blobs { + p, err := kzg4844.ComputeCellProofs(&args.Blobs[i]) + if err != nil { + return fmt.Errorf("blobs[%d]: error computing cell proof: %v", i, err) + } + proofs = append(proofs, p...) + } + } else { + proofs = make([]kzg4844.Proof, 0, n) + for i := range args.Blobs { + p, err := kzg4844.ComputeBlobProof(&args.Blobs[i], commitments[i]) + if err != nil { + return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err) + } + proofs = append(proofs, p) } - proofs[i] = p } args.Commitments = commitments args.Proofs = proofs - } else { - for i, b := range args.Blobs { - if err := kzg4844.VerifyBlobProof(&b, args.Commitments[i], args.Proofs[i]); err != nil { - return fmt.Errorf("failed to verify blob proof: %v", err) - } - } } hashes := make([]common.Hash, n) @@ -432,7 +454,9 @@ func (typedData *TypedData) EncodeType(primaryType string) hexutil.Bytes { buffer.WriteString(obj.Name) buffer.WriteString(",") } - buffer.Truncate(buffer.Len() - 1) + if len(typedData.Types[dep]) > 0 { + buffer.Truncate(buffer.Len() - 1) + } buffer.WriteString(")") } return buffer.Bytes() diff --git a/signer/core/apitypes/types_test.go b/signer/core/apitypes/types_test.go index ab9d1b22d858..f010cef207e8 100644 --- a/signer/core/apitypes/types_test.go +++ b/signer/core/apitypes/types_test.go @@ -17,6 +17,7 @@ package apitypes import ( + "crypto/rand" "crypto/sha256" "encoding/json" "testing" @@ -229,3 +230,183 @@ func TestType_TypeName(t *testing.T) { } } } + +func TestValidateTxSidecar(t *testing.T) { + t.Parallel() + + // Helper function to create a test blob and its commitment/proof + createTestBlob := func() (kzg4844.Blob, kzg4844.Commitment, kzg4844.Proof, common.Hash) { + b := make([]byte, 31) + rand.Read(b) + var blob kzg4844.Blob + for i := range b { + blob[i+1] = b[i] + } + commitment, err := kzg4844.BlobToCommitment(&blob) + if err != nil { + t.Fatal(err) + } + proof, err := kzg4844.ComputeBlobProof(&blob, commitment) + if err != nil { + t.Fatal(err) + } + hash := kzg4844.CalcBlobHashV1(sha256.New(), &commitment) + return blob, commitment, proof, hash + } + + // Helper function to create test cell proofs for v1 transactions + createTestCellProofs := func(blob kzg4844.Blob) []kzg4844.Proof { + cellProofs, err := kzg4844.ComputeCellProofs(&blob) + if err != nil { + t.Fatal(err) + } + return cellProofs + } + + blob1, commitment1, proof1, hash1 := createTestBlob() + blob2, commitment2, proof2, hash2 := createTestBlob() + + tests := []struct { + name string + args SendTxArgs + wantErr bool + }{ + { + name: "no blobs - should pass", + args: SendTxArgs{}, + wantErr: false, + }, + { + name: "valid blobs with commitments and proofs", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1, blob2}, + Commitments: []kzg4844.Commitment{commitment1, commitment2}, + Proofs: []kzg4844.Proof{proof1, proof2}, + BlobHashes: []common.Hash{hash1, hash2}, + }, + wantErr: false, + }, + { + name: "valid blobs without commitments/proofs - should generate them", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1}, + }, + wantErr: false, + }, + { + name: "valid blobs with v1 cell proofs", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1}, + Commitments: []kzg4844.Commitment{commitment1}, + Proofs: createTestCellProofs(blob1), + BlobHashes: []common.Hash{hash1}, + }, + wantErr: false, + }, + { + name: "blobs with v1 version flag - should generate cell proofs", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1}, + BlobVersion: types.BlobSidecarVersion1, + }, + wantErr: false, + }, + { + name: "proofs provided but commitments not", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1}, + Proofs: []kzg4844.Proof{proof1}, + }, + wantErr: true, + }, + { + name: "commitments provided but proofs not", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1}, + Commitments: []kzg4844.Commitment{commitment1}, + }, + wantErr: true, + }, + { + name: "mismatch between blobs and commitments", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1, blob2}, + Commitments: []kzg4844.Commitment{commitment1}, // Only one commitment for two blobs + Proofs: []kzg4844.Proof{proof1}, + }, + wantErr: true, + }, + { + name: "mismatch between blobs and hashes", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1, blob2}, + Commitments: []kzg4844.Commitment{commitment1, commitment2}, + Proofs: []kzg4844.Proof{proof1, proof2}, + BlobHashes: []common.Hash{hash1}, // Only one hash for two blobs + }, + wantErr: true, + }, + { + name: "wrong number of proofs", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1, blob2}, + Commitments: []kzg4844.Commitment{commitment1, commitment2}, + Proofs: []kzg4844.Proof{proof1, proof2, proof1}, // 3 proofs for 2 blobs + }, + wantErr: true, + }, + { + name: "invalid blob hash", + args: SendTxArgs{ + Blobs: []kzg4844.Blob{blob1}, + Commitments: []kzg4844.Commitment{commitment1}, + Proofs: []kzg4844.Proof{proof1}, + BlobHashes: []common.Hash{hash2}, // Wrong hash + }, + wantErr: true, + }, + { + name: "invalid proof", + args: SendTxArgs{ + BlobVersion: types.BlobSidecarVersion1, + Blobs: []kzg4844.Blob{blob1}, + Commitments: []kzg4844.Commitment{commitment1}, + Proofs: []kzg4844.Proof{proof1, proof2}, // wrong proof + BlobHashes: []common.Hash{hash1}, + }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Make a copy to avoid modifying the original test case + args := tt.args + err := args.validateTxSidecar() + + if tt.wantErr { + if err == nil { + t.Errorf("validateTxSidecar() expected error but got none") + return + } + } else { + if err != nil { + t.Errorf("validateTxSidecar() unexpected error = %v", err) + } + + // For successful cases, verify that commitments and proofs were generated if they weren't provided + if len(args.Blobs) > 0 { + if args.Commitments == nil || len(args.Commitments) != len(args.Blobs) { + t.Errorf("validateTxSidecar() should have generated commitments") + } + if args.Proofs == nil || (len(args.Proofs) != len(args.Blobs) && len(args.Proofs) != len(args.Blobs)*kzg4844.CellProofsPerBlob) { + t.Errorf("validateTxSidecar() should have generated proofs") + } + if args.BlobHashes == nil || len(args.BlobHashes) != len(args.Blobs) { + t.Errorf("validateTxSidecar() should have generated blob hashes") + } + } + } + }) + } +} diff --git a/signer/core/signed_data.go b/signer/core/signed_data.go index c62b51314522..d8b6ef0674b3 100644 --- a/signer/core/signed_data.go +++ b/signer/core/signed_data.go @@ -17,6 +17,7 @@ package core import ( + "bytes" "context" "encoding/json" "errors" @@ -309,7 +310,8 @@ func (api *SignerAPI) EcRecover(ctx context.Context, data hexutil.Bytes, sig hex if sig[64] != 27 && sig[64] != 28 { return common.Address{}, errors.New("invalid Ethereum signature (V is not 27 or 28)") } - sig[64] -= 27 // Transform yellow paper V from 27/28 to 0/1 + sig = bytes.Clone(sig) // Avoid mutating the input + sig[64] -= 27 // Transform yellow paper V from 27/28 to 0/1 hash := accounts.TextHash(data) rpk, err := crypto.SigToPub(hash, sig) if err != nil { diff --git a/signer/core/uiapi.go b/signer/core/uiapi.go index 2f511c7e19fd..09ee4b492f0c 100644 --- a/signer/core/uiapi.go +++ b/signer/core/uiapi.go @@ -73,8 +73,9 @@ type rawWallet struct { // Example call // {"jsonrpc":"2.0","method":"clef_listWallets","params":[], "id":5} func (api *UIServerAPI) ListWallets() []rawWallet { - wallets := make([]rawWallet, 0) // return [] instead of nil if empty - for _, wallet := range api.am.Wallets() { + allWallets := api.am.Wallets() + wallets := make([]rawWallet, 0, len(allWallets)) // return [] instead of nil if empty + for _, wallet := range allWallets { status, failure := wallet.Status() raw := rawWallet{ @@ -130,8 +131,12 @@ func (api *UIServerAPI) ImportRawKey(privkey string, password string) (accounts. if err := ValidatePasswordFormat(password); err != nil { return accounts.Account{}, fmt.Errorf("password requirements not met: %v", err) } + ks := fetchKeystore(api.am) + if ks == nil { + return accounts.Account{}, errors.New("password based accounts not supported") + } // No error - return fetchKeystore(api.am).ImportECDSA(key, password) + return ks.ImportECDSA(key, password) } // OpenWallet initiates a hardware wallet opening procedure, establishing a USB diff --git a/tests/block_test.go b/tests/block_test.go index c718b304b6f5..0f087967bb68 100644 --- a/tests/block_test.go +++ b/tests/block_test.go @@ -66,6 +66,12 @@ func TestBlockchain(t *testing.T) { // This directory contains no test. bt.skipLoad(`.*\.meta/.*`) + // Broken tests + bt.skipLoad(`RevertInCreateInInit`) + bt.skipLoad(`InitCollisionParis`) + bt.skipLoad(`dynamicAccountOverwriteEmpty_Paris`) + bt.skipLoad(`create2collisionStorageParis`) + bt.walk(t, blockTestDir, func(t *testing.T, name string, test *BlockTest) { execBlockTest(t, bt, test) }) @@ -85,6 +91,12 @@ func TestExecutionSpecBlocktests(t *testing.T) { bt.skipLoad(".*prague/eip7251_consolidations/test_system_contract_deployment.json") bt.skipLoad(".*prague/eip7002_el_triggerable_withdrawals/test_system_contract_deployment.json") + // Broken tests + bt.skipLoad(`RevertInCreateInInit`) + bt.skipLoad(`InitCollisionParis`) + bt.skipLoad(`dynamicAccountOverwriteEmpty_Paris`) + bt.skipLoad(`create2collisionStorageParis`) + bt.walk(t, executionSpecBlockchainTestDir, func(t *testing.T, name string, test *BlockTest) { execBlockTest(t, bt, test) }) diff --git a/tests/block_test_util.go b/tests/block_test_util.go index 52fe58e7026e..bece8ae61064 100644 --- a/tests/block_test_util.go +++ b/tests/block_test_util.go @@ -97,6 +97,7 @@ type btHeader struct { BlobGasUsed *uint64 ExcessBlobGas *uint64 ParentBeaconBlockRoot *common.Hash + SlotNumber *uint64 } type btHeaderMarshaling struct { @@ -109,6 +110,7 @@ type btHeaderMarshaling struct { BaseFeePerGas *math.HexOrDecimal256 BlobGasUsed *math.HexOrDecimal64 ExcessBlobGas *math.HexOrDecimal64 + SlotNumber *math.HexOrDecimal64 } func (t *BlockTest) Run(snapshotter bool, scheme string, witness bool, tracer *tracing.Hooks, postCheck func(error, *core.BlockChain)) (result error) { @@ -116,15 +118,7 @@ func (t *BlockTest) Run(snapshotter bool, scheme string, witness bool, tracer *t if !ok { return UnsupportedForkError{t.json.Network} } - return t.run(config, snapshotter, scheme, witness, tracer, postCheck) -} - -// Network returns the network/fork name for this test. -func (t *BlockTest) Network() string { - return t.json.Network -} -func (t *BlockTest) run(config *params.ChainConfig, snapshotter bool, scheme string, witness bool, tracer *tracing.Hooks, postCheck func(error, *core.BlockChain)) (result error) { // import pre accounts & construct test genesis block & state root // Commit genesis state var ( @@ -132,10 +126,10 @@ func (t *BlockTest) run(config *params.ChainConfig, snapshotter bool, scheme str db = rawdb.NewMemoryDatabase() tconf = &triedb.Config{ Preimages: true, - IsVerkle: gspec.Config.VerkleTime != nil && *gspec.Config.VerkleTime <= gspec.Timestamp, + IsUBT: gspec.Config.UBTTime != nil && *gspec.Config.UBTTime <= gspec.Timestamp, } ) - if scheme == rawdb.PathScheme || tconf.IsVerkle { + if scheme == rawdb.PathScheme || tconf.IsUBT { tconf.PathDB = pathdb.Defaults } else { tconf.HashDB = hashdb.Defaults @@ -146,7 +140,7 @@ func (t *BlockTest) run(config *params.ChainConfig, snapshotter bool, scheme str gspec.Config.TerminalTotalDifficulty = big.NewInt(stdmath.MaxInt64) } triedb := triedb.NewDatabase(db, tconf) - gblock, err := gspec.Commit(db, triedb) + gblock, err := gspec.Commit(db, triedb, nil) if err != nil { return err } @@ -167,9 +161,9 @@ func (t *BlockTest) run(config *params.ChainConfig, snapshotter bool, scheme str Preimages: true, TxLookupLimit: -1, // disable tx indexing VmConfig: vm.Config{ - Tracer: tracer, - StatelessSelfValidation: witness, + Tracer: tracer, }, + StatelessSelfValidation: witness, } if snapshotter { options.SnapshotLimit = 1 @@ -212,6 +206,11 @@ func (t *BlockTest) run(config *params.ChainConfig, snapshotter bool, scheme str return t.validateImportedHeaders(chain, validBlocks) } +// Network returns the network/fork name for this test. +func (t *BlockTest) Network() string { + return t.json.Network +} + func (t *BlockTest) genesis(config *params.ChainConfig) *core.Genesis { return &core.Genesis{ Config: config, @@ -346,6 +345,9 @@ func validateHeader(h *btHeader, h2 *types.Header) error { if !reflect.DeepEqual(h.ParentBeaconBlockRoot, h2.ParentBeaconRoot) { return fmt.Errorf("parentBeaconBlockRoot: want: %v have: %v", h.ParentBeaconBlockRoot, h2.ParentBeaconRoot) } + if !reflect.DeepEqual(h.SlotNumber, h2.SlotNumber) { + return fmt.Errorf("slotNumber: want: %v have: %v", h.SlotNumber, h2.SlotNumber) + } return nil } diff --git a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go index 4d94d31c0ca1..c60c9cb6e6e0 100644 --- a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go +++ b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go @@ -32,7 +32,6 @@ import ( type kv struct { k, v []byte - t bool } type fuzzer struct { @@ -62,8 +61,8 @@ func (f *fuzzer) randomTrie(n int) (*trie.Trie, map[string]*kv) { size := f.readInt() // Fill it with some fluff for i := byte(0); i < byte(size); i++ { - value := &kv{common.LeftPadBytes([]byte{i}, 32), []byte{i}, false} - value2 := &kv{common.LeftPadBytes([]byte{i + 10}, 32), []byte{i}, false} + value := &kv{common.LeftPadBytes([]byte{i}, 32), []byte{i}} + value2 := &kv{common.LeftPadBytes([]byte{i + 10}, 32), []byte{i}} trie.MustUpdate(value.k, value.v) trie.MustUpdate(value2.k, value2.v) vals[string(value.k)] = value @@ -76,7 +75,7 @@ func (f *fuzzer) randomTrie(n int) (*trie.Trie, map[string]*kv) { for i := 0; i < n; i++ { k := f.randBytes(32) v := f.randBytes(20) - value := &kv{k, v, false} + value := &kv{k, v} trie.MustUpdate(k, v) vals[string(k)] = value if f.exhausted { diff --git a/tests/fuzzers/txfetcher/txfetcher_fuzzer.go b/tests/fuzzers/txfetcher/txfetcher_fuzzer.go index c136253a62be..bcceaff383f0 100644 --- a/tests/fuzzers/txfetcher/txfetcher_fuzzer.go +++ b/tests/fuzzers/txfetcher/txfetcher_fuzzer.go @@ -78,7 +78,8 @@ func fuzz(input []byte) int { rand := rand.New(rand.NewSource(0x3a29)) // Same used in package tests!!! f := fetcher.NewTxFetcherForTests( - func(common.Hash) bool { return false }, + nil, + func(common.Hash, byte) error { return nil }, func(txs []*types.Transaction) []error { return make([]error, len(txs)) }, diff --git a/tests/gen_btheader.go b/tests/gen_btheader.go index 80ad89e03bf5..eb6d9a827164 100644 --- a/tests/gen_btheader.go +++ b/tests/gen_btheader.go @@ -38,6 +38,7 @@ func (b btHeader) MarshalJSON() ([]byte, error) { BlobGasUsed *math.HexOrDecimal64 ExcessBlobGas *math.HexOrDecimal64 ParentBeaconBlockRoot *common.Hash + SlotNumber *math.HexOrDecimal64 } var enc btHeader enc.Bloom = b.Bloom @@ -61,6 +62,7 @@ func (b btHeader) MarshalJSON() ([]byte, error) { enc.BlobGasUsed = (*math.HexOrDecimal64)(b.BlobGasUsed) enc.ExcessBlobGas = (*math.HexOrDecimal64)(b.ExcessBlobGas) enc.ParentBeaconBlockRoot = b.ParentBeaconBlockRoot + enc.SlotNumber = (*math.HexOrDecimal64)(b.SlotNumber) return json.Marshal(&enc) } @@ -88,6 +90,7 @@ func (b *btHeader) UnmarshalJSON(input []byte) error { BlobGasUsed *math.HexOrDecimal64 ExcessBlobGas *math.HexOrDecimal64 ParentBeaconBlockRoot *common.Hash + SlotNumber *math.HexOrDecimal64 } var dec btHeader if err := json.Unmarshal(input, &dec); err != nil { @@ -156,5 +159,8 @@ func (b *btHeader) UnmarshalJSON(input []byte) error { if dec.ParentBeaconBlockRoot != nil { b.ParentBeaconBlockRoot = dec.ParentBeaconBlockRoot } + if dec.SlotNumber != nil { + b.SlotNumber = (*uint64)(dec.SlotNumber) + } return nil } diff --git a/tests/init.go b/tests/init.go index d10b47986cd4..3db988a99375 100644 --- a/tests/init.go +++ b/tests/init.go @@ -720,6 +720,43 @@ var Forks = map[string]*params.ChainConfig{ BPO4: params.DefaultBPO4BlobConfig, }, }, + "Amsterdam": { + ChainID: big.NewInt(1), + HomesteadBlock: big.NewInt(0), + EIP150Block: big.NewInt(0), + EIP155Block: big.NewInt(0), + EIP158Block: big.NewInt(0), + ByzantiumBlock: big.NewInt(0), + ConstantinopleBlock: big.NewInt(0), + PetersburgBlock: big.NewInt(0), + IstanbulBlock: big.NewInt(0), + MuirGlacierBlock: big.NewInt(0), + BerlinBlock: big.NewInt(0), + LondonBlock: big.NewInt(0), + ArrowGlacierBlock: big.NewInt(0), + MergeNetsplitBlock: big.NewInt(0), + TerminalTotalDifficulty: big.NewInt(0), + ShanghaiTime: u64(0), + CancunTime: u64(0), + PragueTime: u64(0), + OsakaTime: u64(0), + BPO1Time: u64(0), + BPO2Time: u64(0), + BPO3Time: u64(0), + BPO4Time: u64(0), + AmsterdamTime: u64(0), + DepositContractAddress: params.MainnetChainConfig.DepositContractAddress, + BlobScheduleConfig: ¶ms.BlobScheduleConfig{ + Cancun: params.DefaultCancunBlobConfig, + Prague: params.DefaultPragueBlobConfig, + Osaka: params.DefaultOsakaBlobConfig, + BPO1: bpo1BlobConfig, + BPO2: bpo2BlobConfig, + BPO3: params.DefaultBPO3BlobConfig, + BPO4: params.DefaultBPO4BlobConfig, + Amsterdam: params.DefaultBPO4BlobConfig, // TODO update when defined + }, + }, "Verkle": { ChainID: big.NewInt(1), HomesteadBlock: big.NewInt(0), @@ -737,7 +774,7 @@ var Forks = map[string]*params.ChainConfig{ MergeNetsplitBlock: big.NewInt(0), TerminalTotalDifficulty: big.NewInt(0), ShanghaiTime: u64(0), - VerkleTime: u64(0), + UBTTime: u64(0), }, } diff --git a/tests/state_test.go b/tests/state_test.go index f80bda4372c8..cf1d4bce4c90 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -35,7 +35,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers/logger" - "github.com/holiman/uint256" ) func initMatcher(st *testMatcher) { @@ -57,6 +56,11 @@ func initMatcher(st *testMatcher) { // Broken tests: // EOF is not part of cancun st.skipLoad(`^stEOF/`) + + st.skipLoad(`RevertInCreateInInit`) + st.skipLoad(`InitCollisionParis`) + st.skipLoad(`dynamicAccountOverwriteEmpty_Paris`) + st.skipLoad(`create2collisionStorageParis`) } func TestState(t *testing.T) { @@ -92,6 +96,12 @@ func TestExecutionSpecState(t *testing.T) { } st := new(testMatcher) + // Broken tests + st.skipLoad(`RevertInCreateInInit`) + st.skipLoad(`InitCollisionParis`) + st.skipLoad(`dynamicAccountOverwriteEmpty_Paris`) + st.skipLoad(`create2collisionStorageParis`) + st.walk(t, executionSpecStateTestDir, func(t *testing.T, name string, test *StateTest) { execStateTest(t, st, test) }) @@ -301,7 +311,7 @@ func runBenchmark(b *testing.B, t *StateTest) { evm.SetTxContext(txContext) // Create "contract" for sender to cache code analysis. - sender := vm.NewContract(msg.From, msg.From, nil, 0, nil) + sender := vm.NewContract(msg.From, msg.From, nil, vm.GasBudget{}, nil) var ( gasUsed uint64 @@ -315,8 +325,10 @@ func runBenchmark(b *testing.B, t *StateTest) { b.StartTimer() start := time.Now() + initialGas := vm.NewGasBudget(msg.GasLimit) + // Execute the message. - _, leftOverGas, err := evm.Call(sender.Address(), *msg.To, msg.Data, msg.GasLimit, uint256.MustFromBig(msg.Value)) + _, leftOverGas, err := evm.Call(sender.Address(), *msg.To, msg.Data, initialGas.Copy(), msg.Value) if err != nil { b.Error(err) return @@ -325,7 +337,7 @@ func runBenchmark(b *testing.B, t *StateTest) { b.StopTimer() elapsed += uint64(time.Since(start)) refund += state.StateDB.GetRefund() - gasUsed += msg.GasLimit - leftOverGas + gasUsed += leftOverGas.Used(initialGas) state.StateDB.RevertToSnapshot(snapshot) } diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 1d6cc8db70f9..e33e15fc8c72 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -38,6 +38,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" @@ -45,7 +46,6 @@ import ( "github.com/ethereum/go-ethereum/triedb/hashdb" "github.com/ethereum/go-ethereum/triedb/pathdb" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) // StateTest checks transaction processing without block context. @@ -173,7 +173,7 @@ func GetChainConfig(forkString string) (baseConfig *params.ChainConfig, eips []i } for _, eip := range eipsStrings { if eipNum, err := strconv.Atoi(eip); err != nil { - return nil, nil, fmt.Errorf("syntax error, invalid eip number %v", eipNum) + return nil, nil, fmt.Errorf("syntax error, invalid eip number %v", eip) } else { if !vm.ValidEip(eipNum) { return nil, nil, fmt.Errorf("syntax error, invalid eip number %v", eipNum) @@ -234,6 +234,20 @@ func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config, snapshotter bo if err != nil { // Here, an error exists but it was expected. // We do not check the post state or logs. + // However, if the test defines a post state root, we should check it. + // In case of an error, the state is reverted to the snapshot, so we need to + // recalculate the root. + post := t.json.Post[subtest.Fork][subtest.Index] + if post.Root != (common.UnprefixedHash{}) { + config, _, err := GetChainConfig(subtest.Fork) + if err != nil { + return fmt.Errorf("failed to get chain config: %w", err) + } + root = st.StateDB.IntermediateRoot(config.IsEIP158(new(big.Int).SetUint64(t.json.Env.Number))) + if root != common.Hash(post.Root) { + return fmt.Errorf("post-state root does not match the pre-state root, indicates an error in the test: got %x, want %x", root, post.Root) + } + } return nil } post := t.json.Post[subtest.Fork][subtest.Index] @@ -328,9 +342,7 @@ func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapsh } // Execute the message. snapshot := st.StateDB.Snapshot() - gaspool := new(core.GasPool) - gaspool.AddGas(block.GasLimit()) - vmRet, err := core.ApplyMessage(evm, msg, gaspool) + vmRet, err := core.ApplyMessage(evm, msg, core.NewGasPool(block.GasLimit())) if err != nil { st.StateDB.RevertToSnapshot(snapshot) if tracer := evm.Config.Tracer; tracer != nil && tracer.OnTxEnd != nil { @@ -467,22 +479,22 @@ func (tx *stTransaction) toMessage(ps stPostState, baseFee *big.Int) (*core.Mess From: from, To: to, Nonce: tx.Nonce, - Value: value, + Value: uint256.MustFromBig(value), GasLimit: gasLimit, - GasPrice: gasPrice, - GasFeeCap: tx.MaxFeePerGas, - GasTipCap: tx.MaxPriorityFeePerGas, + GasPrice: uint256.MustFromBig(gasPrice), + GasFeeCap: uint256.MustFromBig(tx.MaxFeePerGas), + GasTipCap: uint256.MustFromBig(tx.MaxPriorityFeePerGas), Data: data, AccessList: accessList, BlobHashes: tx.BlobVersionedHashes, - BlobGasFeeCap: tx.BlobGasFeeCap, + BlobGasFeeCap: uint256.MustFromBig(tx.BlobGasFeeCap), SetCodeAuthorizations: authList, } return msg, nil } func rlpHash(x interface{}) (h common.Hash) { - hw := sha3.NewLegacyKeccak256() + hw := keccak.NewLegacyKeccak256() rlp.Encode(hw, x) hw.Sum(h[:0]) return h @@ -532,7 +544,7 @@ func MakePreState(db ethdb.Database, accounts types.GenesisAlloc, snapshotter bo } snaps, _ = snapshot.New(snapconfig, db, triedb, root) } - sdb = state.NewDatabase(triedb, snaps) + sdb = state.NewMPTDatabase(triedb, nil).WithSnapshot(snaps) statedb, _ = state.New(root, sdb) return StateTestState{statedb, triedb, snaps} } diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index a90c2d522f64..572c109f1ea4 100644 --- a/tests/transaction_test_util.go +++ b/tests/transaction_test_util.go @@ -71,7 +71,7 @@ func (tt *TransactionTest) Run() error { if err := tt.validate(); err != nil { return err } - validateTx := func(rlpData hexutil.Bytes, signer types.Signer, rules *params.Rules) (sender common.Address, hash common.Hash, requiredGas uint64, err error) { + validateTx := func(rlpData hexutil.Bytes, signer types.Signer, rules params.Rules) (sender common.Address, hash common.Hash, requiredGas uint64, err error) { tx := new(types.Transaction) if err = tx.UnmarshalBinary(rlpData); err != nil { return @@ -81,17 +81,18 @@ func (tt *TransactionTest) Run() error { return } // Intrinsic gas - requiredGas, err = core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.SetCodeAuthorizations(), tx.To() == nil, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai) + cost, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.SetCodeAuthorizations(), tx.To() == nil, rules.IsHomestead, rules.IsIstanbul, rules.IsShanghai, rules.IsAmsterdam) if err != nil { return } + requiredGas = cost.RegularGas if requiredGas > tx.Gas() { return sender, hash, 0, fmt.Errorf("insufficient gas ( %d < %d )", tx.Gas(), requiredGas) } if rules.IsPrague { var floorDataGas uint64 - floorDataGas, err = core.FloorDataGas(tx.Data()) + floorDataGas, err = core.FloorDataGas(rules, tx.Data(), tx.AccessList()) if err != nil { return } @@ -132,7 +133,7 @@ func (tt *TransactionTest) Run() error { rules = config.Rules(new(big.Int), testcase.isMerge, 0) signer = types.MakeSigner(config, new(big.Int), 0) ) - sender, hash, gas, err := validateTx(tt.Txbytes, signer, &rules) + sender, hash, gas, err := validateTx(tt.Txbytes, signer, rules) if err != nil { if expected.Hash != nil { return fmt.Errorf("unexpected error fork %s: %v", testcase.name, err) diff --git a/trie/bintrie/binary_node.go b/trie/bintrie/binary_node.go index 690489b2aa16..3516bf6bd5aa 100644 --- a/trie/bintrie/binary_node.go +++ b/trie/bintrie/binary_node.go @@ -16,124 +16,43 @@ package bintrie -import ( - "errors" - - "github.com/ethereum/go-ethereum/common" -) - -type ( - NodeFlushFn func([]byte, BinaryNode) - NodeResolverFn func([]byte, common.Hash) ([]byte, error) -) +import "github.com/ethereum/go-ethereum/common" // zero is the zero value for a 32-byte array. var zero [32]byte const ( - StemNodeWidth = 256 // Number of child per leaf node - StemSize = 31 // Number of bytes to travel before reaching a group of leaves - NodeTypeBytes = 1 // Size of node type prefix in serialization - HashSize = 32 // Size of a hash in bytes - BitmapSize = 32 // Size of the bitmap in a stem node -) + StemNodeWidth = 256 // Number of children per leaf node + StemSize = 31 // Number of bytes to travel before reaching a group of leaves + NodeTypeBytes = 1 // Size of node type prefix in serialization + HashSize = 32 // Size of a hash in bytes + StemBitmapSize = 32 // Size of the bitmap in a stem node (256 values = 32 bytes) -const ( - nodeTypeStem = iota + 1 // Stem node, contains a stem and a bitmap of values - nodeTypeInternal + MaxGroupDepth = 8 ) -// BinaryNode is an interface for a binary trie node. -type BinaryNode interface { - Get([]byte, NodeResolverFn) ([]byte, error) - Insert([]byte, []byte, NodeResolverFn, int) (BinaryNode, error) - Copy() BinaryNode - Hash() common.Hash - GetValuesAtStem([]byte, NodeResolverFn) ([][]byte, error) - InsertValuesAtStem([]byte, [][]byte, NodeResolverFn, int) (BinaryNode, error) - CollectNodes([]byte, NodeFlushFn) error - - toDot(parent, path string) string - GetHeight() int -} - -// SerializeNode serializes a binary trie node into a byte slice. -func SerializeNode(node BinaryNode) []byte { - switch n := (node).(type) { - case *InternalNode: - // InternalNode: 1 byte type + 32 bytes left hash + 32 bytes right hash - var serialized [NodeTypeBytes + HashSize + HashSize]byte - serialized[0] = nodeTypeInternal - copy(serialized[1:33], n.left.Hash().Bytes()) - copy(serialized[33:65], n.right.Hash().Bytes()) - return serialized[:] - case *StemNode: - // StemNode: 1 byte type + 31 bytes stem + 32 bytes bitmap + 256*32 bytes values - var serialized [NodeTypeBytes + StemSize + BitmapSize + StemNodeWidth*HashSize]byte - serialized[0] = nodeTypeStem - copy(serialized[NodeTypeBytes:NodeTypeBytes+StemSize], n.Stem) - bitmap := serialized[NodeTypeBytes+StemSize : NodeTypeBytes+StemSize+BitmapSize] - offset := NodeTypeBytes + StemSize + BitmapSize - for i, v := range n.Values { - if v != nil { - bitmap[i/8] |= 1 << (7 - (i % 8)) - copy(serialized[offset:offset+HashSize], v) - offset += HashSize - } - } - // Only return the actual data, not the entire array - return serialized[:offset] - default: - panic("invalid node type") +// bitmapSizeForDepth returns the bitmap size in bytes for a given group depth. +// For depths 1-3, returns 1 byte. For depths 4-8, returns 2^(depth-3) bytes. +func bitmapSizeForDepth(groupDepth int) int { + if groupDepth <= 3 { + return 1 } + return 1 << (groupDepth - 3) } -var invalidSerializedLength = errors.New("invalid serialized node length") - -// DeserializeNode deserializes a binary trie node from a byte slice. -func DeserializeNode(serialized []byte, depth int) (BinaryNode, error) { - if len(serialized) == 0 { - return Empty{}, nil - } - - switch serialized[0] { - case nodeTypeInternal: - if len(serialized) != 65 { - return nil, invalidSerializedLength - } - return &InternalNode{ - depth: depth, - left: HashedNode(common.BytesToHash(serialized[1:33])), - right: HashedNode(common.BytesToHash(serialized[33:65])), - }, nil - case nodeTypeStem: - if len(serialized) < 64 { - return nil, invalidSerializedLength - } - var values [StemNodeWidth][]byte - bitmap := serialized[NodeTypeBytes+StemSize : NodeTypeBytes+StemSize+BitmapSize] - offset := NodeTypeBytes + StemSize + BitmapSize +const ( + nodeTypeStem = iota + 1 + nodeTypeInternal +) - for i := range StemNodeWidth { - if bitmap[i/8]>>(7-(i%8))&1 == 1 { - if len(serialized) < offset+HashSize { - return nil, invalidSerializedLength - } - values[i] = serialized[offset : offset+HashSize] - offset += HashSize - } - } - return &StemNode{ - Stem: serialized[NodeTypeBytes : NodeTypeBytes+StemSize], - Values: values[:], - depth: depth, - }, nil - default: - return nil, errors.New("invalid node type") +// DeserializeAndHash deserializes a node from bytes and returns its hash. +// This is a convenience function for external callers that need to compute +// the hash of a serialized node without maintaining a nodeStore. +func DeserializeAndHash(blob []byte, depth int) (common.Hash, error) { + s := newNodeStore() + ref, err := s.deserializeNode(blob, depth) + if err != nil { + return common.Hash{}, err } -} - -// ToDot converts the binary trie to a DOT language representation. Useful for debugging. -func ToDot(root BinaryNode) string { - return root.toDot("", "") + return s.computeHash(ref), nil } diff --git a/trie/bintrie/binary_node_test.go b/trie/bintrie/binary_node_test.go index 242743ba53bb..857060a0c0ae 100644 --- a/trie/bintrie/binary_node_test.go +++ b/trie/bintrie/binary_node_test.go @@ -23,79 +23,108 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestSerializeDeserializeInternalNode tests serialization and deserialization of InternalNode +// TestSerializeDeserializeInternalNode tests grouped serialization and +// deserialization of InternalNode through nodeStore at groupDepth=1. func TestSerializeDeserializeInternalNode(t *testing.T) { - // Create an internal node with two hashed children leftHash := common.HexToHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef") rightHash := common.HexToHash("0xfedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321") - node := &InternalNode{ - depth: 5, - left: HashedNode(leftHash), - right: HashedNode(rightHash), - } + s := newNodeStore() + leftRef := s.newHashedRef(leftHash) + rightRef := s.newHashedRef(rightHash) - // Serialize the node - serialized := SerializeNode(node) + rootRef := s.newInternalRef(0) + rootNode := s.getInternal(rootRef.Index()) + rootNode.left = leftRef + rootNode.right = rightRef + s.root = rootRef + + // Serialize the node — grouped format at groupDepth=1: + // [type(1)][groupDepth(1)][bitmap(1)][leftHash(32)][rightHash(32)] = 67 bytes + serialized := s.serializeNode(rootRef, 1) - // Check the serialized format if serialized[0] != nodeTypeInternal { t.Errorf("Expected type byte to be %d, got %d", nodeTypeInternal, serialized[0]) } + if serialized[1] != 1 { + t.Errorf("Expected groupDepth byte to be 1, got %d", serialized[1]) + } - if len(serialized) != 65 { - t.Errorf("Expected serialized length to be 65, got %d", len(serialized)) + expectedLen := NodeTypeBytes + 1 + 1 + 2*HashSize // type + groupDepth + bitmap + 2 hashes = 67 + if len(serialized) != expectedLen { + t.Errorf("Expected serialized length to be %d, got %d", expectedLen, len(serialized)) + } + + // Both children present at a 1-level group → bitmap byte = 0b11000000. + if serialized[2] != 0xc0 { + t.Errorf("Expected bitmap byte 0xc0, got 0x%02x", serialized[2]) + } + + hashesStart := NodeTypeBytes + 1 + 1 + if !bytes.Equal(serialized[hashesStart:hashesStart+HashSize], leftHash[:]) { + t.Error("Left hash not found at expected position") + } + if !bytes.Equal(serialized[hashesStart+HashSize:], rightHash[:]) { + t.Error("Right hash not found at expected position") } - // Deserialize the node - deserialized, err := DeserializeNode(serialized, 5) + // Deserialize into a new store + ds := newNodeStore() + deserialized, err := ds.deserializeNode(serialized, 0) if err != nil { t.Fatalf("Failed to deserialize node: %v", err) } - // Check that it's an internal node - internalNode, ok := deserialized.(*InternalNode) - if !ok { - t.Fatalf("Expected InternalNode, got %T", deserialized) + // Root should be an InternalNode + if deserialized.Kind() != kindInternal { + t.Fatalf("Expected kindInternal, got kind %d", deserialized.Kind()) } - // Check the depth - if internalNode.depth != 5 { - t.Errorf("Expected depth 5, got %d", internalNode.depth) + internalNode := ds.getInternal(deserialized.Index()) + if internalNode.depth != 0 { + t.Errorf("Expected depth 0, got %d", internalNode.depth) } - // Check the left and right hashes - if internalNode.left.Hash() != leftHash { - t.Errorf("Left hash mismatch: expected %x, got %x", leftHash, internalNode.left.Hash()) + // Left child should be a HashedNode with the correct hash + if internalNode.left.Kind() != kindHashed { + t.Fatalf("Expected left child to be kindHashed, got %d", internalNode.left.Kind()) + } + if ds.computeHash(internalNode.left) != leftHash { + t.Errorf("Left hash mismatch: expected %x, got %x", leftHash, ds.computeHash(internalNode.left)) } - if internalNode.right.Hash() != rightHash { - t.Errorf("Right hash mismatch: expected %x, got %x", rightHash, internalNode.right.Hash()) + // Right child should be a HashedNode with the correct hash + if internalNode.right.Kind() != kindHashed { + t.Fatalf("Expected right child to be kindHashed, got %d", internalNode.right.Kind()) + } + if ds.computeHash(internalNode.right) != rightHash { + t.Errorf("Right hash mismatch: expected %x, got %x", rightHash, ds.computeHash(internalNode.right)) } } -// TestSerializeDeserializeStemNode tests serialization and deserialization of StemNode +// TestSerializeDeserializeStemNode tests serialization and deserialization of StemNode through nodeStore. func TestSerializeDeserializeStemNode(t *testing.T) { - // Create a stem node with some values stem := make([]byte, StemSize) for i := range stem { stem[i] = byte(i) } var values [StemNodeWidth][]byte - // Add some values at different indices values[0] = common.HexToHash("0x0101010101010101010101010101010101010101010101010101010101010101").Bytes() values[10] = common.HexToHash("0x0202020202020202020202020202020202020202020202020202020202020202").Bytes() values[255] = common.HexToHash("0x0303030303030303030303030303030303030303030303030303030303030303").Bytes() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 10, + s := newNodeStore() + ref := s.newStemRef(stem, 10) + sn := s.getStem(ref.Index()) + for i, v := range values { + if v != nil { + sn.setValue(byte(i), v) + } } // Serialize the node - serialized := SerializeNode(node) + serialized := s.serializeNode(ref, 8) // Check the serialized format if serialized[0] != nodeTypeStem { @@ -107,31 +136,32 @@ func TestSerializeDeserializeStemNode(t *testing.T) { t.Errorf("Stem mismatch in serialized data") } - // Deserialize the node - deserialized, err := DeserializeNode(serialized, 10) + // Deserialize into a new store + ds := newNodeStore() + deserializedRef, err := ds.deserializeNode(serialized, 10) if err != nil { t.Fatalf("Failed to deserialize node: %v", err) } - // Check that it's a stem node - stemNode, ok := deserialized.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", deserialized) + if deserializedRef.Kind() != kindStem { + t.Fatalf("Expected kindStem, got kind %d", deserializedRef.Kind()) } + stemNode := ds.getStem(deserializedRef.Index()) + // Check the stem - if !bytes.Equal(stemNode.Stem, stem) { + if !bytes.Equal(stemNode.Stem[:], stem) { t.Errorf("Stem mismatch after deserialization") } // Check the values - if !bytes.Equal(stemNode.Values[0], values[0]) { + if !bytes.Equal(stemNode.getValue(0), values[0]) { t.Errorf("Value at index 0 mismatch") } - if !bytes.Equal(stemNode.Values[10], values[10]) { + if !bytes.Equal(stemNode.getValue(10), values[10]) { t.Errorf("Value at index 10 mismatch") } - if !bytes.Equal(stemNode.Values[255], values[255]) { + if !bytes.Equal(stemNode.getValue(255), values[255]) { t.Errorf("Value at index 255 mismatch") } @@ -140,43 +170,44 @@ func TestSerializeDeserializeStemNode(t *testing.T) { if i == 0 || i == 10 || i == 255 { continue } - if stemNode.Values[i] != nil { - t.Errorf("Expected nil value at index %d, got %x", i, stemNode.Values[i]) + if stemNode.hasValue(byte(i)) { + t.Errorf("Expected no value at index %d, got %x", i, stemNode.getValue(byte(i))) } } } -// TestDeserializeEmptyNode tests deserialization of empty node +// TestDeserializeEmptyNode tests deserialization of empty node. func TestDeserializeEmptyNode(t *testing.T) { - // Empty byte slice should deserialize to Empty node - deserialized, err := DeserializeNode([]byte{}, 0) + s := newNodeStore() + deserialized, err := s.deserializeNode([]byte{}, 0) if err != nil { t.Fatalf("Failed to deserialize empty node: %v", err) } - _, ok := deserialized.(Empty) - if !ok { - t.Fatalf("Expected Empty node, got %T", deserialized) + if !deserialized.IsEmpty() { + t.Fatalf("Expected emptyRef, got kind %d", deserialized.Kind()) } } -// TestDeserializeInvalidType tests deserialization with invalid type byte +// TestDeserializeInvalidType tests deserialization with invalid type byte. func TestDeserializeInvalidType(t *testing.T) { - // Create invalid serialized data with unknown type byte + s := newNodeStore() invalidData := []byte{99, 0, 0, 0} // Type byte 99 is invalid - _, err := DeserializeNode(invalidData, 0) + _, err := s.deserializeNode(invalidData, 0) if err == nil { t.Fatal("Expected error for invalid type byte, got nil") } } -// TestDeserializeInvalidLength tests deserialization with invalid data length +// TestDeserializeInvalidLength tests deserialization with invalid data length. func TestDeserializeInvalidLength(t *testing.T) { - // InternalNode with type byte 1 but wrong length - invalidData := []byte{nodeTypeInternal, 0, 0} // Too short for internal node + s := newNodeStore() + // InternalNode group header with groupDepth=1 (valid) and a 1-byte bitmap + // announcing two present hashes, but the hash payload is missing. + invalidData := []byte{nodeTypeInternal, 1, 0xc0} - _, err := DeserializeNode(invalidData, 0) + _, err := s.deserializeNode(invalidData, 0) if err == nil { t.Fatal("Expected error for invalid data length, got nil") } @@ -186,7 +217,22 @@ func TestDeserializeInvalidLength(t *testing.T) { } } -// TestKeyToPath tests the keyToPath function +// TestDeserializeInvalidGroupDepth tests deserialization when the group depth +// byte is out of the supported 1..MaxGroupDepth range. +func TestDeserializeInvalidGroupDepth(t *testing.T) { + s := newNodeStore() + invalidData := []byte{nodeTypeInternal, 0, 0, 0} + + _, err := s.deserializeNode(invalidData, 0) + if err == nil { + t.Fatal("Expected error for invalid group depth, got nil") + } + if err.Error() != "invalid group depth" { + t.Errorf("Expected 'invalid group depth' error, got: %v", err) + } +} + +// TestKeyToPath tests the keyToPath function. func TestKeyToPath(t *testing.T) { tests := []struct { name string @@ -218,14 +264,14 @@ func TestKeyToPath(t *testing.T) { }, { name: "max valid depth", - depth: StemSize * 8, + depth: StemSize*8 - 1, key: make([]byte, HashSize), - expected: make([]byte, StemSize*8+1), + expected: make([]byte, StemSize*8), wantErr: false, }, { name: "depth too large", - depth: StemSize*8 + 1, + depth: StemSize * 8, key: make([]byte, HashSize), wantErr: true, }, diff --git a/trie/bintrie/empty.go b/trie/bintrie/empty.go deleted file mode 100644 index 7cfe373b35b0..000000000000 --- a/trie/bintrie/empty.go +++ /dev/null @@ -1,72 +0,0 @@ -// Copyright 2025 go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package bintrie - -import ( - "slices" - - "github.com/ethereum/go-ethereum/common" -) - -type Empty struct{} - -func (e Empty) Get(_ []byte, _ NodeResolverFn) ([]byte, error) { - return nil, nil -} - -func (e Empty) Insert(key []byte, value []byte, _ NodeResolverFn, depth int) (BinaryNode, error) { - var values [256][]byte - values[key[31]] = value - return &StemNode{ - Stem: slices.Clone(key[:31]), - Values: values[:], - depth: depth, - }, nil -} - -func (e Empty) Copy() BinaryNode { - return Empty{} -} - -func (e Empty) Hash() common.Hash { - return common.Hash{} -} - -func (e Empty) GetValuesAtStem(_ []byte, _ NodeResolverFn) ([][]byte, error) { - var values [256][]byte - return values[:], nil -} - -func (e Empty) InsertValuesAtStem(key []byte, values [][]byte, _ NodeResolverFn, depth int) (BinaryNode, error) { - return &StemNode{ - Stem: slices.Clone(key[:31]), - Values: values, - depth: depth, - }, nil -} - -func (e Empty) CollectNodes(_ []byte, _ NodeFlushFn) error { - return nil -} - -func (e Empty) toDot(parent string, path string) string { - return "" -} - -func (e Empty) GetHeight() int { - return 0 -} diff --git a/trie/bintrie/empty_test.go b/trie/bintrie/empty_test.go deleted file mode 100644 index 574ae1830bed..000000000000 --- a/trie/bintrie/empty_test.go +++ /dev/null @@ -1,222 +0,0 @@ -// Copyright 2025 go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package bintrie - -import ( - "bytes" - "testing" - - "github.com/ethereum/go-ethereum/common" -) - -// TestEmptyGet tests the Get method -func TestEmptyGet(t *testing.T) { - node := Empty{} - - key := make([]byte, 32) - value, err := node.Get(key, nil) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - - if value != nil { - t.Errorf("Expected nil value from empty node, got %x", value) - } -} - -// TestEmptyInsert tests the Insert method -func TestEmptyInsert(t *testing.T) { - node := Empty{} - - key := make([]byte, 32) - key[0] = 0x12 - key[31] = 0x34 - value := common.HexToHash("0xabcd").Bytes() - - newNode, err := node.Insert(key, value, nil, 0) - if err != nil { - t.Fatalf("Failed to insert: %v", err) - } - - // Should create a StemNode - stemNode, ok := newNode.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", newNode) - } - - // Check the stem (first 31 bytes of key) - if !bytes.Equal(stemNode.Stem, key[:31]) { - t.Errorf("Stem mismatch: expected %x, got %x", key[:31], stemNode.Stem) - } - - // Check the value at the correct index (last byte of key) - if !bytes.Equal(stemNode.Values[key[31]], value) { - t.Errorf("Value mismatch at index %d: expected %x, got %x", key[31], value, stemNode.Values[key[31]]) - } - - // Check that other values are nil - for i := 0; i < 256; i++ { - if i != int(key[31]) && stemNode.Values[i] != nil { - t.Errorf("Expected nil value at index %d, got %x", i, stemNode.Values[i]) - } - } -} - -// TestEmptyCopy tests the Copy method -func TestEmptyCopy(t *testing.T) { - node := Empty{} - - copied := node.Copy() - copiedEmpty, ok := copied.(Empty) - if !ok { - t.Fatalf("Expected Empty, got %T", copied) - } - - // Both should be empty - if node != copiedEmpty { - // Empty is a zero-value struct, so copies should be equal - t.Errorf("Empty nodes should be equal") - } -} - -// TestEmptyHash tests the Hash method -func TestEmptyHash(t *testing.T) { - node := Empty{} - - hash := node.Hash() - - // Empty node should have zero hash - if hash != (common.Hash{}) { - t.Errorf("Expected zero hash for empty node, got %x", hash) - } -} - -// TestEmptyGetValuesAtStem tests the GetValuesAtStem method -func TestEmptyGetValuesAtStem(t *testing.T) { - node := Empty{} - - stem := make([]byte, 31) - values, err := node.GetValuesAtStem(stem, nil) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - - // Should return an array of 256 nil values - if len(values) != 256 { - t.Errorf("Expected 256 values, got %d", len(values)) - } - - for i, v := range values { - if v != nil { - t.Errorf("Expected nil value at index %d, got %x", i, v) - } - } -} - -// TestEmptyInsertValuesAtStem tests the InsertValuesAtStem method -func TestEmptyInsertValuesAtStem(t *testing.T) { - node := Empty{} - - stem := make([]byte, 31) - stem[0] = 0x42 - - var values [256][]byte - values[0] = common.HexToHash("0x0101").Bytes() - values[10] = common.HexToHash("0x0202").Bytes() - values[255] = common.HexToHash("0x0303").Bytes() - - newNode, err := node.InsertValuesAtStem(stem, values[:], nil, 5) - if err != nil { - t.Fatalf("Failed to insert values: %v", err) - } - - // Should create a StemNode - stemNode, ok := newNode.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", newNode) - } - - // Check the stem - if !bytes.Equal(stemNode.Stem, stem) { - t.Errorf("Stem mismatch: expected %x, got %x", stem, stemNode.Stem) - } - - // Check the depth - if stemNode.depth != 5 { - t.Errorf("Depth mismatch: expected 5, got %d", stemNode.depth) - } - - // Check the values - if !bytes.Equal(stemNode.Values[0], values[0]) { - t.Error("Value at index 0 mismatch") - } - if !bytes.Equal(stemNode.Values[10], values[10]) { - t.Error("Value at index 10 mismatch") - } - if !bytes.Equal(stemNode.Values[255], values[255]) { - t.Error("Value at index 255 mismatch") - } - - // Check that values is the same slice (not a copy) - if &stemNode.Values[0] != &values[0] { - t.Error("Expected values to be the same slice reference") - } -} - -// TestEmptyCollectNodes tests the CollectNodes method -func TestEmptyCollectNodes(t *testing.T) { - node := Empty{} - - var collected []BinaryNode - flushFn := func(path []byte, n BinaryNode) { - collected = append(collected, n) - } - - err := node.CollectNodes([]byte{0, 1, 0}, flushFn) - if err != nil { - t.Fatalf("Unexpected error: %v", err) - } - - // Should not collect anything for empty node - if len(collected) != 0 { - t.Errorf("Expected no collected nodes for empty, got %d", len(collected)) - } -} - -// TestEmptyToDot tests the toDot method -func TestEmptyToDot(t *testing.T) { - node := Empty{} - - dot := node.toDot("parent", "010") - - // Should return empty string for empty node - if dot != "" { - t.Errorf("Expected empty string for empty node toDot, got %s", dot) - } -} - -// TestEmptyGetHeight tests the GetHeight method -func TestEmptyGetHeight(t *testing.T) { - node := Empty{} - - height := node.GetHeight() - - // Empty node should have height 0 - if height != 0 { - t.Errorf("Expected height 0 for empty node, got %d", height) - } -} diff --git a/trie/bintrie/hashed_node.go b/trie/bintrie/hashed_node.go index e4d8c2e7ac7d..b176df079b3a 100644 --- a/trie/bintrie/hashed_node.go +++ b/trie/bintrie/hashed_node.go @@ -16,75 +16,10 @@ package bintrie -import ( - "errors" - "fmt" - - "github.com/ethereum/go-ethereum/common" -) +import "github.com/ethereum/go-ethereum/common" +// HashedNode is an unresolved node — only its hash is known. type HashedNode common.Hash -func (h HashedNode) Get(_ []byte, _ NodeResolverFn) ([]byte, error) { - panic("not implemented") // TODO: Implement -} - -func (h HashedNode) Insert(key []byte, value []byte, resolver NodeResolverFn, depth int) (BinaryNode, error) { - return nil, errors.New("insert not implemented for hashed node") -} - -func (h HashedNode) Copy() BinaryNode { - nh := common.Hash(h) - return HashedNode(nh) -} - -func (h HashedNode) Hash() common.Hash { - return common.Hash(h) -} - -func (h HashedNode) GetValuesAtStem(_ []byte, _ NodeResolverFn) ([][]byte, error) { - return nil, errors.New("attempted to get values from an unresolved node") -} - -func (h HashedNode) InsertValuesAtStem(stem []byte, values [][]byte, resolver NodeResolverFn, depth int) (BinaryNode, error) { - // Step 1: Generate the path for this node's position in the tree - path, err := keyToPath(depth, stem) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem path generation error: %w", err) - } - - if resolver == nil { - return nil, errors.New("InsertValuesAtStem resolve error: resolver is nil") - } - - // Step 2: Resolve the hashed node to get the actual node data - data, err := resolver(path, common.Hash(h)) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) - } - - // Step 3: Deserialize the resolved data into a concrete node - node, err := DeserializeNode(data, depth) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem node deserialization error: %w", err) - } - - // Step 4: Call InsertValuesAtStem on the resolved concrete node - return node.InsertValuesAtStem(stem, values, resolver, depth) -} - -func (h HashedNode) toDot(parent string, path string) string { - me := fmt.Sprintf("hash%s", path) - ret := fmt.Sprintf("%s [label=\"%x\"]\n", me, h) - ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) - return ret -} - -func (h HashedNode) CollectNodes([]byte, NodeFlushFn) error { - // HashedNodes are already persisted in the database and don't need to be collected. - return nil -} - -func (h HashedNode) GetHeight() int { - panic("tried to get the height of a hashed node, this is a bug") -} +// Hash returns the node's hash. +func (h HashedNode) Hash() common.Hash { return common.Hash(h) } diff --git a/trie/bintrie/hashed_node_test.go b/trie/bintrie/hashed_node_test.go index f9e69848884a..2e12bfba5eab 100644 --- a/trie/bintrie/hashed_node_test.go +++ b/trie/bintrie/hashed_node_test.go @@ -18,180 +18,137 @@ package bintrie import ( "bytes" + "errors" "testing" "github.com/ethereum/go-ethereum/common" ) -// TestHashedNodeHash tests the Hash method +// TestHashedNodeHash tests the Hash method via nodeStore. func TestHashedNodeHash(t *testing.T) { hash := common.HexToHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef") - node := HashedNode(hash) + s := newNodeStore() + ref := s.newHashedRef(hash) - // Hash should return the stored hash - if node.Hash() != hash { - t.Errorf("Hash mismatch: expected %x, got %x", hash, node.Hash()) + if s.computeHash(ref) != hash { + t.Errorf("Hash mismatch: expected %x, got %x", hash, s.computeHash(ref)) } } -// TestHashedNodeCopy tests the Copy method +// TestHashedNodeCopy tests the Copy method via nodeStore. func TestHashedNodeCopy(t *testing.T) { hash := common.HexToHash("0xabcdef") - node := HashedNode(hash) + s := newNodeStore() + ref := s.newHashedRef(hash) + s.root = ref - copied := node.Copy() - copiedHash, ok := copied.(HashedNode) - if !ok { - t.Fatalf("Expected HashedNode, got %T", copied) - } + ns := s.Copy() + copiedHash := ns.computeHash(ns.root) - // Hash should be the same - if common.Hash(copiedHash) != hash { + if copiedHash != hash { t.Errorf("Hash mismatch after copy: expected %x, got %x", hash, copiedHash) } - - // But should be a different object - if &node == &copiedHash { - t.Error("Copy returned same object reference") - } -} - -// TestHashedNodeInsert tests that Insert returns an error -func TestHashedNodeInsert(t *testing.T) { - node := HashedNode(common.HexToHash("0x1234")) - - key := make([]byte, HashSize) - value := make([]byte, HashSize) - - _, err := node.Insert(key, value, nil, 0) - if err == nil { - t.Fatal("Expected error for Insert on HashedNode") - } - - if err.Error() != "insert not implemented for hashed node" { - t.Errorf("Unexpected error message: %v", err) - } -} - -// TestHashedNodeGetValuesAtStem tests that GetValuesAtStem returns an error -func TestHashedNodeGetValuesAtStem(t *testing.T) { - node := HashedNode(common.HexToHash("0x1234")) - - stem := make([]byte, StemSize) - _, err := node.GetValuesAtStem(stem, nil) - if err == nil { - t.Fatal("Expected error for GetValuesAtStem on HashedNode") - } - - if err.Error() != "attempted to get values from an unresolved node" { - t.Errorf("Unexpected error message: %v", err) - } } -// TestHashedNodeInsertValuesAtStem tests that InsertValuesAtStem returns an error +// TestHashedNodeInsertValuesAtStem tests InsertValuesAtStem resolution via nodeStore. func TestHashedNodeInsertValuesAtStem(t *testing.T) { - node := HashedNode(common.HexToHash("0x1234")) + // Test 1: nil resolver should return an error + s := newNodeStore() + hashedRef := s.newHashedRef(common.HexToHash("0x1234")) + s.root = hashedRef stem := make([]byte, StemSize) values := make([][]byte, StemNodeWidth) - // Test 1: nil resolver should return an error - _, err := node.InsertValuesAtStem(stem, values, nil, 0) + err := s.InsertValuesAtStem(stem, values, nil) if err == nil { - t.Fatal("Expected error for InsertValuesAtStem on HashedNode with nil resolver") - } - - if err.Error() != "InsertValuesAtStem resolve error: resolver is nil" { - t.Errorf("Unexpected error message: %v", err) + t.Fatal("Expected error for InsertValuesAtStem with nil resolver") } // Test 2: mock resolver returning invalid data should return deserialization error mockResolver := func(path []byte, hash common.Hash) ([]byte, error) { - // Return invalid/nonsense data that cannot be deserialized return []byte{0xff, 0xff, 0xff}, nil } - _, err = node.InsertValuesAtStem(stem, values, mockResolver, 0) - if err == nil { - t.Fatal("Expected error for InsertValuesAtStem on HashedNode with invalid resolver data") - } + s2 := newNodeStore() + hashedRef2 := s2.newHashedRef(common.HexToHash("0x1234")) + s2.root = hashedRef2 - expectedPrefix := "InsertValuesAtStem node deserialization error:" - if len(err.Error()) < len(expectedPrefix) || err.Error()[:len(expectedPrefix)] != expectedPrefix { - t.Errorf("Expected deserialization error, got: %v", err) + err = s2.InsertValuesAtStem(stem, values, mockResolver) + if err == nil { + t.Fatal("Expected error for InsertValuesAtStem with invalid resolver data") } // Test 3: mock resolver returning valid serialized node should succeed stem = make([]byte, StemSize) stem[0] = 0xaa - var originalValues [StemNodeWidth][]byte + originalValues := make([][]byte, StemNodeWidth) originalValues[0] = common.HexToHash("0x1111111111111111111111111111111111111111111111111111111111111111").Bytes() originalValues[1] = common.HexToHash("0x2222222222222222222222222222222222222222222222222222222222222222").Bytes() - originalNode := &StemNode{ - Stem: stem, - Values: originalValues[:], - depth: 0, + // Build the serialized node + rs := newNodeStore() + ref := rs.newStemRef(stem, 0) + sn := rs.getStem(ref.Index()) + for i, v := range originalValues { + if v != nil { + sn.setValue(byte(i), v) + } } + serialized := rs.serializeNode(ref, 8) - // Serialize the node - serialized := SerializeNode(originalNode) - - // Create a mock resolver that returns the serialized node validResolver := func(path []byte, hash common.Hash) ([]byte, error) { return serialized, nil } - var newValues [StemNodeWidth][]byte + s3 := newNodeStore() + hashedRef3 := s3.newHashedRef(common.HexToHash("0x1234")) + s3.root = hashedRef3 + + newValues := make([][]byte, StemNodeWidth) newValues[2] = common.HexToHash("0x3333333333333333333333333333333333333333333333333333333333333333").Bytes() - resolvedNode, err := node.InsertValuesAtStem(stem, newValues[:], validResolver, 0) + err = s3.InsertValuesAtStem(stem, newValues, validResolver) if err != nil { t.Fatalf("Expected successful resolution and insertion, got error: %v", err) } - resultStem, ok := resolvedNode.(*StemNode) - if !ok { - t.Fatalf("Expected resolved node to be *StemNode, got %T", resolvedNode) + // Verify original values are preserved + retrieved, err := s3.GetValuesAtStem(stem, nil) + if err != nil { + t.Fatal(err) } - - if !bytes.Equal(resultStem.Stem, stem) { - t.Errorf("Stem mismatch: expected %x, got %x", stem, resultStem.Stem) + if !bytes.Equal(retrieved[0], originalValues[0]) { + t.Errorf("Original value at index 0 not preserved") } - - // Verify the original values are preserved - if !bytes.Equal(resultStem.Values[0], originalValues[0]) { - t.Errorf("Original value at index 0 not preserved: expected %x, got %x", originalValues[0], resultStem.Values[0]) + if !bytes.Equal(retrieved[1], originalValues[1]) { + t.Errorf("Original value at index 1 not preserved") } - if !bytes.Equal(resultStem.Values[1], originalValues[1]) { - t.Errorf("Original value at index 1 not preserved: expected %x, got %x", originalValues[1], resultStem.Values[1]) - } - - // Verify the new value was inserted - if !bytes.Equal(resultStem.Values[2], newValues[2]) { - t.Errorf("New value at index 2 not inserted correctly: expected %x, got %x", newValues[2], resultStem.Values[2]) + if !bytes.Equal(retrieved[2], newValues[2]) { + t.Errorf("New value at index 2 not inserted correctly") } } -// TestHashedNodeToDot tests the toDot method for visualization -func TestHashedNodeToDot(t *testing.T) { - hash := common.HexToHash("0x1234") - node := HashedNode(hash) +// TestHashedNodeGetError tests that getting through an unresolved HashedNode root returns error. +func TestHashedNodeGetError(t *testing.T) { + s := newNodeStore() + // Create root as hashed, then try to resolve through InternalNode parent + rootRef := s.newInternalRef(0) + rootNode := s.getInternal(rootRef.Index()) + hashedLeft := s.newHashedRef(common.HexToHash("0x1234")) + rootNode.left = hashedLeft + rootNode.right = emptyRef + s.root = rootRef - dot := node.toDot("parent", "010") + key := make([]byte, 32) // goes left + key[31] = 5 - // Should contain the hash value and parent connection - expectedHash := "hash010" - if !contains(dot, expectedHash) { - t.Errorf("Expected dot output to contain %s", expectedHash) + resolver := func(path []byte, hash common.Hash) ([]byte, error) { + return nil, errors.New("node not found") } - if !contains(dot, "parent -> hash010") { - t.Error("Expected dot output to contain parent connection") + _, err := s.Get(key, resolver) + if err == nil { + t.Fatal("Expected error when resolver fails") } } - -// Helper function -func contains(s, substr string) bool { - return len(s) >= len(substr) && s != "" && len(substr) > 0 -} diff --git a/trie/bintrie/hasher.go b/trie/bintrie/hasher.go new file mode 100644 index 000000000000..b81c1457236d --- /dev/null +++ b/trie/bintrie/hasher.go @@ -0,0 +1,39 @@ +// Copyright 2026 go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bintrie + +import ( + "crypto/sha256" + "hash" + "sync" +) + +var sha256Pool = sync.Pool{ + New: func() any { + return sha256.New() + }, +} + +func newSha256() hash.Hash { + h := sha256Pool.Get().(hash.Hash) + h.Reset() + return h +} + +func returnSha256(h hash.Hash) { + sha256Pool.Put(h) +} diff --git a/trie/bintrie/internal_node.go b/trie/bintrie/internal_node.go index 0a7bece521fd..b83cb92d8712 100644 --- a/trie/bintrie/internal_node.go +++ b/trie/bintrie/internal_node.go @@ -17,15 +17,13 @@ package bintrie import ( - "crypto/sha256" "errors" - "fmt" "github.com/ethereum/go-ethereum/common" ) func keyToPath(depth int, key []byte) ([]byte, error) { - if depth > 31*8 { + if depth >= 31*8 { return nil, errors.New("node too deep") } path := make([]byte, 0, depth+1) @@ -36,206 +34,12 @@ func keyToPath(depth int, key []byte) ([]byte, error) { return path, nil } -// InternalNode is a binary trie internal node. +// Invariant: dirty=false implies mustRecompute=false. Every mutation that +// invalidates the cached hash MUST also mark the blob for re-flush. type InternalNode struct { - left, right BinaryNode - depth int -} - -// GetValuesAtStem retrieves the group of values located at the given stem key. -func (bt *InternalNode) GetValuesAtStem(stem []byte, resolver NodeResolverFn) ([][]byte, error) { - if bt.depth > 31*8 { - return nil, errors.New("node too deep") - } - - bit := stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1 - if bit == 0 { - if hn, ok := bt.left.(HashedNode); ok { - path, err := keyToPath(bt.depth, stem) - if err != nil { - return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err) - } - data, err := resolver(path, common.Hash(hn)) - if err != nil { - return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err) - } - node, err := DeserializeNode(data, bt.depth+1) - if err != nil { - return nil, fmt.Errorf("GetValuesAtStem node deserialization error: %w", err) - } - bt.left = node - } - return bt.left.GetValuesAtStem(stem, resolver) - } - - if hn, ok := bt.right.(HashedNode); ok { - path, err := keyToPath(bt.depth, stem) - if err != nil { - return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err) - } - data, err := resolver(path, common.Hash(hn)) - if err != nil { - return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err) - } - node, err := DeserializeNode(data, bt.depth+1) - if err != nil { - return nil, fmt.Errorf("GetValuesAtStem node deserialization error: %w", err) - } - bt.right = node - } - return bt.right.GetValuesAtStem(stem, resolver) -} - -// Get retrieves the value for the given key. -func (bt *InternalNode) Get(key []byte, resolver NodeResolverFn) ([]byte, error) { - values, err := bt.GetValuesAtStem(key[:31], resolver) - if err != nil { - return nil, fmt.Errorf("get error: %w", err) - } - if values == nil { - return nil, nil - } - return values[key[31]], nil -} - -// Insert inserts a new key-value pair into the trie. -func (bt *InternalNode) Insert(key []byte, value []byte, resolver NodeResolverFn, depth int) (BinaryNode, error) { - var values [256][]byte - values[key[31]] = value - return bt.InsertValuesAtStem(key[:31], values[:], resolver, depth) -} - -// Copy creates a deep copy of the node. -func (bt *InternalNode) Copy() BinaryNode { - return &InternalNode{ - left: bt.left.Copy(), - right: bt.right.Copy(), - depth: bt.depth, - } -} - -// Hash returns the hash of the node. -func (bt *InternalNode) Hash() common.Hash { - h := sha256.New() - if bt.left != nil { - h.Write(bt.left.Hash().Bytes()) - } else { - h.Write(zero[:]) - } - if bt.right != nil { - h.Write(bt.right.Hash().Bytes()) - } else { - h.Write(zero[:]) - } - return common.BytesToHash(h.Sum(nil)) -} - -// InsertValuesAtStem inserts a full value group at the given stem in the internal node. -// Already-existing values will be overwritten. -func (bt *InternalNode) InsertValuesAtStem(stem []byte, values [][]byte, resolver NodeResolverFn, depth int) (BinaryNode, error) { - var err error - bit := stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1 - if bit == 0 { - if bt.left == nil { - bt.left = Empty{} - } - - if hn, ok := bt.left.(HashedNode); ok { - path, err := keyToPath(bt.depth, stem) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) - } - data, err := resolver(path, common.Hash(hn)) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) - } - node, err := DeserializeNode(data, bt.depth+1) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem node deserialization error: %w", err) - } - bt.left = node - } - - bt.left, err = bt.left.InsertValuesAtStem(stem, values, resolver, depth+1) - return bt, err - } - - if bt.right == nil { - bt.right = Empty{} - } - - if hn, ok := bt.right.(HashedNode); ok { - path, err := keyToPath(bt.depth, stem) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) - } - data, err := resolver(path, common.Hash(hn)) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) - } - node, err := DeserializeNode(data, bt.depth+1) - if err != nil { - return nil, fmt.Errorf("InsertValuesAtStem node deserialization error: %w", err) - } - bt.right = node - } - - bt.right, err = bt.right.InsertValuesAtStem(stem, values, resolver, depth+1) - return bt, err -} - -// CollectNodes collects all child nodes at a given path, and flushes it -// into the provided node collector. -func (bt *InternalNode) CollectNodes(path []byte, flushfn NodeFlushFn) error { - if bt.left != nil { - var p [256]byte - copy(p[:], path) - childpath := p[:len(path)] - childpath = append(childpath, 0) - if err := bt.left.CollectNodes(childpath, flushfn); err != nil { - return err - } - } - if bt.right != nil { - var p [256]byte - copy(p[:], path) - childpath := p[:len(path)] - childpath = append(childpath, 1) - if err := bt.right.CollectNodes(childpath, flushfn); err != nil { - return err - } - } - flushfn(path, bt) - return nil -} - -// GetHeight returns the height of the node. -func (bt *InternalNode) GetHeight() int { - var ( - leftHeight int - rightHeight int - ) - if bt.left != nil { - leftHeight = bt.left.GetHeight() - } - if bt.right != nil { - rightHeight = bt.right.GetHeight() - } - return 1 + max(leftHeight, rightHeight) -} - -func (bt *InternalNode) toDot(parent, path string) string { - me := fmt.Sprintf("internal%s", path) - ret := fmt.Sprintf("%s [label=\"I: %x\"]\n", me, bt.Hash()) - if len(parent) > 0 { - ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) - } - - if bt.left != nil { - ret = fmt.Sprintf("%s%s", ret, bt.left.toDot(me, fmt.Sprintf("%s%02x", path, 0))) - } - if bt.right != nil { - ret = fmt.Sprintf("%s%s", ret, bt.right.toDot(me, fmt.Sprintf("%s%02x", path, 1))) - } - return ret + left, right nodeRef + depth uint8 + mustRecompute bool // hash is stale (cleared by Hash) + dirty bool // on-disk blob is stale (cleared by CollectNodes) + hash common.Hash } diff --git a/trie/bintrie/internal_node_test.go b/trie/bintrie/internal_node_test.go index 158d8b7147d5..4d8da8af374a 100644 --- a/trie/bintrie/internal_node_test.go +++ b/trie/bintrie/internal_node_test.go @@ -24,35 +24,33 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestInternalNodeGet tests the Get method +// TestInternalNodeGet tests the Get method via nodeStore. func TestInternalNodeGet(t *testing.T) { - // Create a simple tree structure + s := newNodeStore() + leftStem := make([]byte, 31) rightStem := make([]byte, 31) - rightStem[0] = 0x80 // First bit is 1 + rightStem[0] = 0x80 - var leftValues, rightValues [256][]byte + leftValues := make([][]byte, 256) leftValues[0] = common.HexToHash("0x0101").Bytes() + rightValues := make([][]byte, 256) rightValues[0] = common.HexToHash("0x0202").Bytes() - node := &InternalNode{ - depth: 0, - left: &StemNode{ - Stem: leftStem, - Values: leftValues[:], - depth: 1, - }, - right: &StemNode{ - Stem: rightStem, - Values: rightValues[:], - depth: 1, - }, + // Build tree: root -> left stem, right stem + // Insert left stem values + s.root = emptyRef + if err := s.InsertValuesAtStem(leftStem, leftValues, nil); err != nil { + t.Fatal(err) + } + if err := s.InsertValuesAtStem(rightStem, rightValues, nil); err != nil { + t.Fatal(err) } // Get value from left subtree leftKey := make([]byte, 32) leftKey[31] = 0 - value, err := node.Get(leftKey, nil) + value, err := s.Get(leftKey, nil) if err != nil { t.Fatalf("Failed to get left value: %v", err) } @@ -64,7 +62,7 @@ func TestInternalNodeGet(t *testing.T) { rightKey := make([]byte, 32) rightKey[0] = 0x80 rightKey[31] = 0 - value, err = node.Get(rightKey, nil) + value, err = s.Get(rightKey, nil) if err != nil { t.Fatalf("Failed to get right value: %v", err) } @@ -73,29 +71,26 @@ func TestInternalNodeGet(t *testing.T) { } } -// TestInternalNodeGetWithResolver tests Get with HashedNode resolution +// TestInternalNodeGetWithResolver tests Get with HashedNode resolution via nodeStore. func TestInternalNodeGetWithResolver(t *testing.T) { - // Create an internal node with a hashed child - hashedChild := HashedNode(common.HexToHash("0x1234")) - - node := &InternalNode{ - depth: 0, - left: hashedChild, - right: Empty{}, - } + // Create a store with an internal node containing a hashed child + s := newNodeStore() + hashedChild := s.newHashedRef(common.HexToHash("0x1234")) + rootRef := s.newInternalRef(0) + rootNode := s.getInternal(rootRef.Index()) + rootNode.left = hashedChild + rootNode.right = emptyRef + s.root = rootRef // Mock resolver that returns a stem node resolver := func(path []byte, hash common.Hash) ([]byte, error) { - if hash == common.Hash(hashedChild) { + if hash == common.HexToHash("0x1234") { + rs := newNodeStore() stem := make([]byte, 31) - var values [256][]byte - values[5] = common.HexToHash("0xabcd").Bytes() - stemNode := &StemNode{ - Stem: stem, - Values: values[:], - depth: 1, - } - return SerializeNode(stemNode), nil + ref := rs.newStemRef(stem, 1) + sn := rs.getStem(ref.Index()) + sn.setValue(5, common.HexToHash("0xabcd").Bytes()) + return rs.serializeNode(ref, 8), nil } return nil, errors.New("node not found") } @@ -103,7 +98,7 @@ func TestInternalNodeGetWithResolver(t *testing.T) { // Get value through the hashed node key := make([]byte, 32) key[31] = 5 - value, err := node.Get(key, resolver) + value, err := s.Get(key, resolver) if err != nil { t.Fatalf("Failed to get value: %v", err) } @@ -114,177 +109,113 @@ func TestInternalNodeGetWithResolver(t *testing.T) { } } -// TestInternalNodeInsert tests the Insert method +// TestInternalNodeInsert tests the Insert method via nodeStore. func TestInternalNodeInsert(t *testing.T) { - // Start with an internal node with empty children - node := &InternalNode{ - depth: 0, - left: Empty{}, - right: Empty{}, - } + s := newNodeStore() - // Insert a value into the left subtree leftKey := make([]byte, 32) leftKey[31] = 10 leftValue := common.HexToHash("0x0101").Bytes() - newNode, err := node.Insert(leftKey, leftValue, nil, 0) - if err != nil { + if err := s.Insert(leftKey, leftValue, nil); err != nil { t.Fatalf("Failed to insert: %v", err) } - internalNode, ok := newNode.(*InternalNode) - if !ok { - t.Fatalf("Expected InternalNode, got %T", newNode) - } - - // Check that left child is now a StemNode - leftStem, ok := internalNode.left.(*StemNode) - if !ok { - t.Fatalf("Expected left child to be StemNode, got %T", internalNode.left) - } - - // Check the inserted value - if !bytes.Equal(leftStem.Values[10], leftValue) { - t.Errorf("Value mismatch: expected %x, got %x", leftValue, leftStem.Values[10]) + // Verify the value was stored + value, err := s.Get(leftKey, nil) + if err != nil { + t.Fatalf("Failed to get: %v", err) } - - // Right child should still be Empty - _, ok = internalNode.right.(Empty) - if !ok { - t.Errorf("Expected right child to remain Empty, got %T", internalNode.right) + if !bytes.Equal(value, leftValue) { + t.Errorf("Value mismatch: expected %x, got %x", leftValue, value) } } -// TestInternalNodeCopy tests the Copy method +// TestInternalNodeCopy tests the Copy method via nodeStore. func TestInternalNodeCopy(t *testing.T) { - // Create an internal node with stem children - leftStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - leftStem.Values[0] = common.HexToHash("0x0101").Bytes() - - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - rightStem.Stem[0] = 0x80 - rightStem.Values[0] = common.HexToHash("0x0202").Bytes() + s := newNodeStore() - node := &InternalNode{ - depth: 0, - left: leftStem, - right: rightStem, - } - - // Create a copy - copied := node.Copy() - copiedInternal, ok := copied.(*InternalNode) - if !ok { - t.Fatalf("Expected InternalNode, got %T", copied) - } + leftKey := make([]byte, 32) + leftKey[31] = 0 + leftValue := common.HexToHash("0x0101").Bytes() - // Check depth - if copiedInternal.depth != node.depth { - t.Errorf("Depth mismatch: expected %d, got %d", node.depth, copiedInternal.depth) - } + rightKey := make([]byte, 32) + rightKey[0] = 0x80 + rightKey[31] = 0 + rightValue := common.HexToHash("0x0202").Bytes() - // Check that children are copied - copiedLeft, ok := copiedInternal.left.(*StemNode) - if !ok { - t.Fatalf("Expected left child to be StemNode, got %T", copiedInternal.left) + if err := s.Insert(leftKey, leftValue, nil); err != nil { + t.Fatal(err) } - - copiedRight, ok := copiedInternal.right.(*StemNode) - if !ok { - t.Fatalf("Expected right child to be StemNode, got %T", copiedInternal.right) + if err := s.Insert(rightKey, rightValue, nil); err != nil { + t.Fatal(err) } - // Verify deep copy (children should be different objects) - if copiedLeft == leftStem { - t.Error("Left child not properly copied") - } - if copiedRight == rightStem { - t.Error("Right child not properly copied") - } + ns := s.Copy() - // But values should be equal - if !bytes.Equal(copiedLeft.Values[0], leftStem.Values[0]) { + // Values should be equal + v1, _ := ns.Get(leftKey, nil) + if !bytes.Equal(v1, leftValue) { t.Error("Left child value mismatch after copy") } - if !bytes.Equal(copiedRight.Values[0], rightStem.Values[0]) { + v2, _ := ns.Get(rightKey, nil) + if !bytes.Equal(v2, rightValue) { t.Error("Right child value mismatch after copy") } } -// TestInternalNodeHash tests the Hash method +// TestInternalNodeHash tests the Hash method via nodeStore. func TestInternalNodeHash(t *testing.T) { - // Create an internal node - node := &InternalNode{ - depth: 0, - left: HashedNode(common.HexToHash("0x1111")), - right: HashedNode(common.HexToHash("0x2222")), - } + s := newNodeStore() + leftRef := s.newHashedRef(common.HexToHash("0x1111")) + rightRef := s.newHashedRef(common.HexToHash("0x2222")) + rootRef := s.newInternalRef(0) + rootNode := s.getInternal(rootRef.Index()) + rootNode.left = leftRef + rootNode.right = rightRef + s.root = rootRef - hash1 := node.Hash() + hash1 := s.computeHash(rootRef) // Hash should be deterministic - hash2 := node.Hash() + hash2 := s.computeHash(rootRef) if hash1 != hash2 { t.Errorf("Hash not deterministic: %x != %x", hash1, hash2) } // Changing a child should change the hash - node.left = HashedNode(common.HexToHash("0x3333")) - hash3 := node.Hash() + rootNode.left = s.newHashedRef(common.HexToHash("0x3333")) + rootNode.mustRecompute = true + hash3 := s.computeHash(rootRef) if hash1 == hash3 { t.Error("Hash didn't change after modifying left child") } - - // Test with nil children (should use zero hash) - nodeWithNil := &InternalNode{ - depth: 0, - left: nil, - right: HashedNode(common.HexToHash("0x4444")), - } - hashWithNil := nodeWithNil.Hash() - if hashWithNil == (common.Hash{}) { - t.Error("Hash shouldn't be zero even with nil child") - } } -// TestInternalNodeGetValuesAtStem tests GetValuesAtStem method +// TestInternalNodeGetValuesAtStem tests GetValuesAtStem method via nodeStore. func TestInternalNodeGetValuesAtStem(t *testing.T) { - // Create a tree with values at different stems + s := newNodeStore() + leftStem := make([]byte, 31) rightStem := make([]byte, 31) rightStem[0] = 0x80 - var leftValues, rightValues [256][]byte + leftValues := make([][]byte, 256) leftValues[0] = common.HexToHash("0x0101").Bytes() leftValues[10] = common.HexToHash("0x0102").Bytes() + rightValues := make([][]byte, 256) rightValues[0] = common.HexToHash("0x0201").Bytes() rightValues[20] = common.HexToHash("0x0202").Bytes() - node := &InternalNode{ - depth: 0, - left: &StemNode{ - Stem: leftStem, - Values: leftValues[:], - depth: 1, - }, - right: &StemNode{ - Stem: rightStem, - Values: rightValues[:], - depth: 1, - }, + if err := s.InsertValuesAtStem(leftStem, leftValues, nil); err != nil { + t.Fatal(err) + } + if err := s.InsertValuesAtStem(rightStem, rightValues, nil); err != nil { + t.Fatal(err) } // Get values from left stem - values, err := node.GetValuesAtStem(leftStem, nil) + values, err := s.GetValuesAtStem(leftStem, nil) if err != nil { t.Fatalf("Failed to get left values: %v", err) } @@ -296,7 +227,7 @@ func TestInternalNodeGetValuesAtStem(t *testing.T) { } // Get values from right stem - values, err = node.GetValuesAtStem(rightStem, nil) + values, err = s.GetValuesAtStem(rightStem, nil) if err != nil { t.Fatalf("Failed to get right values: %v", err) } @@ -308,151 +239,100 @@ func TestInternalNodeGetValuesAtStem(t *testing.T) { } } -// TestInternalNodeInsertValuesAtStem tests InsertValuesAtStem method +// TestInternalNodeInsertValuesAtStem tests InsertValuesAtStem method via nodeStore. func TestInternalNodeInsertValuesAtStem(t *testing.T) { - // Start with an internal node with empty children - node := &InternalNode{ - depth: 0, - left: Empty{}, - right: Empty{}, - } + s := newNodeStore() - // Insert values at a stem in the left subtree stem := make([]byte, 31) - var values [256][]byte + values := make([][]byte, 256) values[5] = common.HexToHash("0x0505").Bytes() values[10] = common.HexToHash("0x1010").Bytes() - newNode, err := node.InsertValuesAtStem(stem, values[:], nil, 0) - if err != nil { + if err := s.InsertValuesAtStem(stem, values, nil); err != nil { t.Fatalf("Failed to insert values: %v", err) } - internalNode, ok := newNode.(*InternalNode) - if !ok { - t.Fatalf("Expected InternalNode, got %T", newNode) - } - - // Check that left child is now a StemNode with the values - leftStem, ok := internalNode.left.(*StemNode) - if !ok { - t.Fatalf("Expected left child to be StemNode, got %T", internalNode.left) + // Check that the values are stored + retrieved, err := s.GetValuesAtStem(stem, nil) + if err != nil { + t.Fatalf("Failed to get values: %v", err) } - - if !bytes.Equal(leftStem.Values[5], values[5]) { + if !bytes.Equal(retrieved[5], values[5]) { t.Error("Value at index 5 mismatch") } - if !bytes.Equal(leftStem.Values[10], values[10]) { + if !bytes.Equal(retrieved[10], values[10]) { t.Error("Value at index 10 mismatch") } } -// TestInternalNodeCollectNodes tests CollectNodes method +// TestInternalNodeCollectNodes tests CollectNodes method via nodeStore. func TestInternalNodeCollectNodes(t *testing.T) { - // Create an internal node with two stem children - leftStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } + s := newNodeStore() - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - rightStem.Stem[0] = 0x80 + leftStem := make([]byte, 31) + rightStem := make([]byte, 31) + rightStem[0] = 0x80 - node := &InternalNode{ - depth: 0, - left: leftStem, - right: rightStem, + leftValues := make([][]byte, 256) + rightValues := make([][]byte, 256) + + if err := s.InsertValuesAtStem(leftStem, leftValues, nil); err != nil { + t.Fatal(err) + } + if err := s.InsertValuesAtStem(rightStem, rightValues, nil); err != nil { + t.Fatal(err) } var collectedPaths [][]byte - var collectedNodes []BinaryNode - - flushFn := func(path []byte, n BinaryNode) { + flushFn := func(path []byte, hash common.Hash, serialized []byte) { pathCopy := make([]byte, len(path)) copy(pathCopy, path) collectedPaths = append(collectedPaths, pathCopy) - collectedNodes = append(collectedNodes, n) } - err := node.CollectNodes([]byte{1}, flushFn) - if err != nil { - t.Fatalf("Failed to collect nodes: %v", err) - } + s.collectNodes(s.root, []byte{1}, flushFn, 8) // Should have collected 3 nodes: left stem, right stem, and the internal node itself - if len(collectedNodes) != 3 { - t.Errorf("Expected 3 collected nodes, got %d", len(collectedNodes)) - } - - // Check paths - expectedPaths := [][]byte{ - {1, 0}, // left child - {1, 1}, // right child - {1}, // internal node itself - } - - for i, expectedPath := range expectedPaths { - if !bytes.Equal(collectedPaths[i], expectedPath) { - t.Errorf("Path %d mismatch: expected %v, got %v", i, expectedPath, collectedPaths[i]) - } + if len(collectedPaths) != 3 { + t.Errorf("Expected 3 collected nodes, got %d", len(collectedPaths)) } } -// TestInternalNodeGetHeight tests GetHeight method +// TestInternalNodeGetHeight tests GetHeight method via nodeStore. func TestInternalNodeGetHeight(t *testing.T) { - // Create a tree with different heights - // Left subtree: depth 2 (internal -> stem) - // Right subtree: depth 1 (stem) - leftInternal := &InternalNode{ - depth: 1, - left: &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 2, - }, - right: Empty{}, - } + s := newNodeStore() - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } + // Insert values that create a deeper tree + stem1 := make([]byte, 31) // left + stem2 := make([]byte, 31) + stem2[0] = 0x40 // 01... -> goes left at depth 0, right at depth 1 - node := &InternalNode{ - depth: 0, - left: leftInternal, - right: rightStem, + values1 := make([][]byte, 256) + values1[0] = common.HexToHash("0x01").Bytes() + values2 := make([][]byte, 256) + values2[0] = common.HexToHash("0x02").Bytes() + + if err := s.InsertValuesAtStem(stem1, values1, nil); err != nil { + t.Fatal(err) + } + if err := s.InsertValuesAtStem(stem2, values2, nil); err != nil { + t.Fatal(err) } - height := node.GetHeight() - // Height should be max(left height, right height) + 1 - // Left height: 2, Right height: 1, so total: 3 - if height != 3 { - t.Errorf("Expected height 3, got %d", height) + height := s.getHeight(s.root) + if height < 2 { + t.Errorf("Expected height >= 2, got %d", height) } } -// TestInternalNodeDepthTooLarge tests handling of excessive depth +// TestInternalNodeDepthTooLarge tests handling of excessive depth via nodeStore. func TestInternalNodeDepthTooLarge(t *testing.T) { - // Create an internal node at max depth - node := &InternalNode{ - depth: 31*8 + 1, - left: Empty{}, - right: Empty{}, - } - - stem := make([]byte, 31) - _, err := node.GetValuesAtStem(stem, nil) - if err == nil { - t.Fatal("Expected error for excessive depth") - } - if err.Error() != "node too deep" { - t.Errorf("Expected 'node too deep' error, got: %v", err) - } + s := newNodeStore() + // Creating an internal node beyond max depth should panic + defer func() { + if r := recover(); r == nil { + t.Fatal("Expected panic for excessive depth") + } + }() + s.newInternalRef(31*8 + 1) } diff --git a/trie/bintrie/iterator.go b/trie/bintrie/iterator.go index 9b863ed1e3f8..a920f91378a6 100644 --- a/trie/bintrie/iterator.go +++ b/trie/bintrie/iterator.go @@ -26,13 +26,14 @@ import ( var errIteratorEnd = errors.New("end of iteration") type binaryNodeIteratorState struct { - Node BinaryNode + Node nodeRef Index int } type binaryNodeIterator struct { trie *BinaryTrie - current BinaryNode + store *nodeStore + current nodeRef lastErr error stack []binaryNodeIteratorState @@ -40,56 +41,63 @@ type binaryNodeIterator struct { func newBinaryNodeIterator(t *BinaryTrie, _ []byte) (trie.NodeIterator, error) { if t.Hash() == zero { - return &binaryNodeIterator{trie: t, lastErr: errIteratorEnd}, nil + return &binaryNodeIterator{trie: t, store: t.store, lastErr: errIteratorEnd}, nil } - it := &binaryNodeIterator{trie: t, current: t.root} - // it.err = it.seek(start) + it := &binaryNodeIterator{trie: t, store: t.store, current: t.store.root} return it, nil } -// Next moves the iterator to the next node. If the parameter is false, any child -// nodes will be skipped. +// Next moves the iterator to the next node. If descend is false, children of +// the current node are skipped. func (it *binaryNodeIterator) Next(descend bool) bool { if it.lastErr == errIteratorEnd { - it.lastErr = errIteratorEnd return false } if len(it.stack) == 0 { - it.stack = append(it.stack, binaryNodeIteratorState{Node: it.trie.root}) - it.current = it.trie.root - + it.stack = append(it.stack, binaryNodeIteratorState{Node: it.trie.store.root}) + it.current = it.trie.store.root return true } - switch node := it.current.(type) { - case *InternalNode: - // index: 0 = nothing visited, 1=left visited, 2=right visited + switch it.current.Kind() { + case kindInternal: + // index: 0 = nothing visited, 1 = left visited, 2 = right visited. + node := it.store.getInternal(it.current.Index()) context := &it.stack[len(it.stack)-1] - // recurse into both children + if !descend { + // Skip children: pop this node and advance parent. + if len(it.stack) == 1 { + it.lastErr = errIteratorEnd + return false + } + it.stack = it.stack[:len(it.stack)-1] + it.current = it.stack[len(it.stack)-1].Node + it.stack[len(it.stack)-1].Index++ + return it.Next(true) + } + + // Recurse into both children. if context.Index == 0 { - if _, isempty := node.left.(Empty); node.left != nil && !isempty { + if !node.left.IsEmpty() { it.stack = append(it.stack, binaryNodeIteratorState{Node: node.left}) it.current = node.left return it.Next(descend) } - context.Index++ } if context.Index == 1 { - if _, isempty := node.right.(Empty); node.right != nil && !isempty { + if !node.right.IsEmpty() { it.stack = append(it.stack, binaryNodeIteratorState{Node: node.right}) it.current = node.right return it.Next(descend) } - context.Index++ } - // Reached the end of this node, go back to the parent, if - // this isn't root. + // Reached the end of this node; go back to the parent unless we're at the root. if len(it.stack) == 1 { it.lastErr = errIteratorEnd return false @@ -98,17 +106,18 @@ func (it *binaryNodeIterator) Next(descend bool) bool { it.current = it.stack[len(it.stack)-1].Node it.stack[len(it.stack)-1].Index++ return it.Next(descend) - case *StemNode: - // Look for the next non-empty value + + case kindStem: + // Look for the next non-empty value in this stem. + sn := it.store.getStem(it.current.Index()) for i := it.stack[len(it.stack)-1].Index; i < 256; i++ { - if node.Values[i] != nil { + if sn.hasValue(byte(i)) { it.stack[len(it.stack)-1].Index = i + 1 return true } } - // go back to parent to get the next leaf - // Check if we're at the root before popping + // No more values in this stem; go back to parent to get the next leaf. if len(it.stack) == 1 { it.lastErr = errIteratorEnd return false @@ -117,35 +126,47 @@ func (it *binaryNodeIterator) Next(descend bool) bool { it.current = it.stack[len(it.stack)-1].Node it.stack[len(it.stack)-1].Index++ return it.Next(descend) - case HashedNode: - // resolve the node - data, err := it.trie.nodeResolver(it.Path(), common.Hash(node)) + + case kindHashed: + // Resolve the hashed node from disk, then rewire the parent to point at the + // resolved node in place. + if len(it.stack) < 2 { + it.lastErr = errors.New("cannot resolve hashed root during iteration") + return false + } + hn := it.store.getHashed(it.current.Index()) + data, err := it.trie.nodeResolver(it.Path(), hn.Hash()) if err != nil { - panic(err) + it.lastErr = err + return false } - it.current, err = DeserializeNode(data, len(it.stack)-1) + resolved, err := it.store.deserializeNodeWithHash(data, len(it.stack)-1, hn.Hash()) if err != nil { - panic(err) + it.lastErr = err + return false } - // update the stack and parent with the resolved node - it.stack[len(it.stack)-1].Node = it.current + oldHashedIdx := it.current.Index() + it.current = resolved + it.stack[len(it.stack)-1].Node = resolved parent := &it.stack[len(it.stack)-2] + parentNode := it.store.getInternal(parent.Node.Index()) if parent.Index == 0 { - parent.Node.(*InternalNode).left = it.current + parentNode.left = resolved } else { - parent.Node.(*InternalNode).right = it.current + parentNode.right = resolved } + it.store.freeHashedNode(oldHashedIdx) return it.Next(descend) - case Empty: - // do nothing + + case kindEmpty: return false + default: panic("invalid node type") } } -// Error returns the error status of the iterator. func (it *binaryNodeIterator) Error() error { if it.lastErr == errIteratorEnd { return nil @@ -153,27 +174,28 @@ func (it *binaryNodeIterator) Error() error { return it.lastErr } -// Hash returns the hash of the current node. func (it *binaryNodeIterator) Hash() common.Hash { - return it.current.Hash() + return it.store.computeHash(it.current) } -// Parent returns the hash of the parent of the current node. The hash may be the one -// grandparent if the immediate parent is an internal node with no hash. +// Parent returns the hash of the current node's parent. When the immediate +// parent is an internal node whose hash has not been materialised, the +// returned hash may be the one of a grandparent instead. func (it *binaryNodeIterator) Parent() common.Hash { - return it.stack[len(it.stack)-1].Node.Hash() + if len(it.stack) < 2 { + return common.Hash{} + } + return it.store.computeHash(it.stack[len(it.stack)-2].Node) } -// Path returns the hex-encoded path to the current node. -// Callers must not retain references to the return value after calling Next. -// For leaf nodes, the last element of the path is the 'terminator symbol' 0x10. +// Path returns the bit-path to the current node. +// Callers must not retain references to the returned slice after calling Next. func (it *binaryNodeIterator) Path() []byte { if it.Leaf() { return it.LeafKey() } var path []byte for i, state := range it.stack { - // skip the last byte if i >= len(it.stack)-1 { break } @@ -182,107 +204,94 @@ func (it *binaryNodeIterator) Path() []byte { return path } -// NodeBlob returns the serialized bytes of the current node. func (it *binaryNodeIterator) NodeBlob() []byte { - return SerializeNode(it.current) + return it.store.serializeNode(it.current, it.trie.groupDepth) } -// Leaf returns true iff the current node is a leaf node. -// In a Binary Trie, a StemNode contains up to 256 leaf values. -// The iterator is only considered to be "at a leaf" when it's positioned -// at a specific non-nil value within the StemNode, not just at the StemNode itself. +// Leaf reports whether the iterator is currently positioned at a leaf value. +// A StemNode holds up to 256 values; the iterator is only "at a leaf" when +// positioned at a specific non-nil value inside the stem, not merely at the +// StemNode itself. The stack Index points to the NEXT position after the +// current value, so Index == 0 means we haven't yielded anything yet. func (it *binaryNodeIterator) Leaf() bool { - sn, ok := it.current.(*StemNode) - if !ok { + if it.current.Kind() != kindStem { return false } - // Check if we have a valid stack position if len(it.stack) == 0 { return false } - // The Index in the stack state points to the NEXT position after the current value. - // So if Index is 0, we haven't started iterating through the values yet. - // If Index is 5, we're currently at value[4] (the 5th value, 0-indexed). idx := it.stack[len(it.stack)-1].Index if idx == 0 || idx > 256 { return false } - // Check if there's actually a value at the current position + sn := it.store.getStem(it.current.Index()) currentValueIndex := idx - 1 - return sn.Values[currentValueIndex] != nil + return sn.hasValue(byte(currentValueIndex)) } -// LeafKey returns the key of the leaf. The method panics if the iterator is not -// positioned at a leaf. Callers must not retain references to the value after -// calling Next. +// LeafKey returns the key of the leaf. Panics if the iterator is not +// positioned at a leaf. Callers must not retain references to the returned +// slice after calling Next. func (it *binaryNodeIterator) LeafKey() []byte { - leaf, ok := it.current.(*StemNode) - if !ok { + if it.current.Kind() != kindStem { panic("Leaf() called on an binary node iterator not at a leaf location") } - return leaf.Key(it.stack[len(it.stack)-1].Index - 1) + sn := it.store.getStem(it.current.Index()) + return sn.Key(it.stack[len(it.stack)-1].Index - 1) } -// LeafBlob returns the content of the leaf. The method panics if the iterator -// is not positioned at a leaf. Callers must not retain references to the value -// after calling Next. +// LeafBlob returns the leaf value. Panics if the iterator is not positioned +// at a leaf. Callers must not retain references to the returned slice after +// calling Next. func (it *binaryNodeIterator) LeafBlob() []byte { - leaf, ok := it.current.(*StemNode) - if !ok { + if it.current.Kind() != kindStem { panic("LeafBlob() called on an binary node iterator not at a leaf location") } - return leaf.Values[it.stack[len(it.stack)-1].Index-1] + sn := it.store.getStem(it.current.Index()) + return sn.getValue(byte(it.stack[len(it.stack)-1].Index - 1)) } -// LeafProof returns the Merkle proof of the leaf. The method panics if the -// iterator is not positioned at a leaf. Callers must not retain references -// to the value after calling Next. +// LeafProof returns the Merkle proof of the leaf. Panics if the iterator is +// not positioned at a leaf. Callers must not retain references to the +// returned slices after calling Next. func (it *binaryNodeIterator) LeafProof() [][]byte { - sn, ok := it.current.(*StemNode) - if !ok { + if it.current.Kind() != kindStem { panic("LeafProof() called on an binary node iterator not at a leaf location") } + sn := it.store.getStem(it.current.Index()) proof := make([][]byte, 0, len(it.stack)+StemNodeWidth) - // Build proof by walking up the stack and collecting sibling hashes + if len(it.stack) < 2 { + proof = append(proof, sn.Stem[:]) + proof = append(proof, sn.allValues()...) + return proof + } + for i := range it.stack[:len(it.stack)-2] { state := it.stack[i] - internalNode := state.Node.(*InternalNode) // should panic if the node isn't an InternalNode + internalNode := it.store.getInternal(state.Node.Index()) - // Add the sibling hash to the proof if state.Index == 0 { - // We came from left, so include right sibling - proof = append(proof, internalNode.right.Hash().Bytes()) + rh := it.store.computeHash(internalNode.right) + proof = append(proof, rh.Bytes()) } else { - // We came from right, so include left sibling - proof = append(proof, internalNode.left.Hash().Bytes()) + lh := it.store.computeHash(internalNode.left) + proof = append(proof, lh.Bytes()) } } // Add the stem and siblings - proof = append(proof, sn.Stem) - for _, v := range sn.Values { - proof = append(proof, v) - } + proof = append(proof, sn.Stem[:]) + proof = append(proof, sn.allValues()...) return proof } -// AddResolver sets an intermediate database to use for looking up trie nodes -// before reaching into the real persistent layer. -// -// This is not required for normal operation, rather is an optimization for -// cases where trie nodes can be recovered from some external mechanism without -// reading from disk. In those cases, this resolver allows short circuiting -// accesses and returning them from memory. -// -// Before adding a similar mechanism to any other place in Geth, consider -// making trie.Database an interface and wrapping at that level. It's a huge -// refactor, but it could be worth it if another occurrence arises. +// AddResolver is a no-op (satisfies the NodeIterator interface). func (it *binaryNodeIterator) AddResolver(trie.NodeResolver) { // Not implemented, but should not panic } diff --git a/trie/bintrie/iterator_test.go b/trie/bintrie/iterator_test.go new file mode 100644 index 000000000000..746f6e8c0fc4 --- /dev/null +++ b/trie/bintrie/iterator_test.go @@ -0,0 +1,251 @@ +// Copyright 2026 go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bintrie + +import ( + "bytes" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/trie" +) + +// makeTrie creates a BinaryTrie populated with the given key-value pairs. +func makeTrie(t *testing.T, entries [][2]common.Hash) *BinaryTrie { + t.Helper() + store := newNodeStore() + tr := &BinaryTrie{ + store: store, + tracer: trie.NewPrevalueTracer(), + } + for _, kv := range entries { + if err := store.Insert(kv[0][:], kv[1][:], nil); err != nil { + t.Fatal(err) + } + } + return tr +} + +// countLeaves iterates the trie and returns the number of leaves visited. +func countLeaves(t *testing.T, tr *BinaryTrie) int { + t.Helper() + it, err := newBinaryNodeIterator(tr, nil) + if err != nil { + t.Fatal(err) + } + leaves := 0 + for it.Next(true) { + if it.Leaf() { + leaves++ + } + } + if it.Error() != nil { + t.Fatalf("iterator error: %v", it.Error()) + } + return leaves +} + +// TestIteratorEmptyTrie verifies that iterating over an empty trie returns +// no nodes and reports no error. +func TestIteratorEmptyTrie(t *testing.T) { + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + } + it, err := newBinaryNodeIterator(tr, nil) + if err != nil { + t.Fatal(err) + } + if it.Next(true) { + t.Fatal("expected no iteration over empty trie") + } + if it.Error() != nil { + t.Fatalf("unexpected error: %v", it.Error()) + } +} + +// TestIteratorSingleStem verifies iteration over a trie with a single stem +// node containing multiple values. +func TestIteratorSingleStem(t *testing.T) { + tr := makeTrie(t, [][2]common.Hash{ + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000003"), oneKey}, + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000007"), oneKey}, + {common.HexToHash("00000000000000000000000000000000000000000000000000000000000000FF"), oneKey}, + }) + if leaves := countLeaves(t, tr); leaves != 3 { + t.Fatalf("expected 3 leaves, got %d", leaves) + } +} + +// TestIteratorTwoStems verifies iteration over a trie with two stems +// separated by internal nodes, ensuring all leaves from both stems are visited. +func TestIteratorTwoStems(t *testing.T) { + tr := makeTrie(t, [][2]common.Hash{ + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000002"), oneKey}, + {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000002"), oneKey}, + }) + if leaves := countLeaves(t, tr); leaves != 4 { + t.Fatalf("expected 4 leaves, got %d", leaves) + } +} + +// TestIteratorLeafKeyAndBlob verifies that the iterator returns correct +// leaf keys and values. +func TestIteratorLeafKeyAndBlob(t *testing.T) { + key := common.HexToHash("0000000000000000000000000000000000000000000000000000000000000005") + val := common.HexToHash("00000000000000000000000000000000000000000000000000000000deadbeef") + tr := makeTrie(t, [][2]common.Hash{{key, val}}) + + it, err := newBinaryNodeIterator(tr, nil) + if err != nil { + t.Fatal(err) + } + + found := false + for it.Next(true) { + if it.Leaf() { + found = true + if !bytes.Equal(it.LeafKey(), key[:]) { + t.Fatalf("leaf key mismatch: got %x, want %x", it.LeafKey(), key) + } + if !bytes.Equal(it.LeafBlob(), val[:]) { + t.Fatalf("leaf blob mismatch: got %x, want %x", it.LeafBlob(), val) + } + } + } + if !found { + t.Fatal("expected to find a leaf") + } +} + +// TestIteratorEmptyNodeBacktrack is a regression test for the Empty node +// backtracking bug. Before the fix, encountering an Empty child during +// iteration would terminate the walk prematurely instead of backtracking +// to the parent and continuing with the next sibling. +func TestIteratorEmptyNodeBacktrack(t *testing.T) { + tr := makeTrie(t, [][2]common.Hash{ + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + }) + + if tr.store.root.Kind() != kindInternal { + t.Fatalf("expected InternalNode root, got kind %d", tr.store.root.Kind()) + } + if leaves := countLeaves(t, tr); leaves != 2 { + t.Fatalf("expected 2 leaves, got %d (Empty backtrack bug?)", leaves) + } +} + +// TestIteratorHashedNodeNilData is a regression test for the nil-data guard. +// When nodeResolver encounters a zero-hash HashedNode, it returns (nil, nil). +// The iterator should treat this as Empty and continue rather than panicking. +func TestIteratorHashedNodeNilData(t *testing.T) { + tr := makeTrie(t, [][2]common.Hash{ + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + }) + + root := tr.store.root + if root.Kind() != kindInternal { + t.Fatalf("expected InternalNode root, got kind %d", root.Kind()) + } + rootNode := tr.store.getInternal(root.Index()) + + // Replace right child with a zero-hash HashedNode. nodeResolver + // short-circuits on common.Hash{} and returns (nil, nil), which + // triggers the nil-data guard in the iterator. + rootNode.right = tr.store.newHashedRef(common.Hash{}) + + // Should not panic; the zero-hash right child should be treated as Empty. + // Since the hashed node can't be resolved (nil data -> empty deserialization), + // only the left leaf should be counted. + it, err := newBinaryNodeIterator(tr, nil) + if err != nil { + t.Fatal(err) + } + leaves := 0 + for it.Next(true) { + if it.Leaf() { + leaves++ + } + } + if leaves != 1 { + t.Fatalf("expected 1 leaf (zero-hash right node skipped), got %d", leaves) + } +} + +// TestIteratorManyStems verifies iteration correctness with many stems, +// producing a deep tree structure. +func TestIteratorManyStems(t *testing.T) { + entries := make([][2]common.Hash, 16) + for i := range entries { + var key common.Hash + key[0] = byte(i << 4) + key[31] = 1 + entries[i] = [2]common.Hash{key, oneKey} + } + tr := makeTrie(t, entries) + if leaves := countLeaves(t, tr); leaves != 16 { + t.Fatalf("expected 16 leaves, got %d", leaves) + } +} + +// TestIteratorDeepTree verifies iteration over a trie with stems that share +// a long common prefix, producing many intermediate InternalNodes. +func TestIteratorDeepTree(t *testing.T) { + tr := makeTrie(t, [][2]common.Hash{ + {common.HexToHash("0000000000C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0"), oneKey}, + {common.HexToHash("0000000000E00000000000000000000000000000000000000000000000000000"), twoKey}, + }) + if leaves := countLeaves(t, tr); leaves != 2 { + t.Fatalf("expected 2 leaves in deep tree, got %d", leaves) + } +} + +// TestIteratorNodeCount verifies the total number of Next(true) calls +// for a known tree structure. +func TestIteratorNodeCount(t *testing.T) { + tr := makeTrie(t, [][2]common.Hash{ + {common.HexToHash("0000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000001"), oneKey}, + }) + + it, err := newBinaryNodeIterator(tr, nil) + if err != nil { + t.Fatal(err) + } + + total := 0 + leaves := 0 + for it.Next(true) { + total++ + if it.Leaf() { + leaves++ + } + } + if leaves != 2 { + t.Fatalf("expected 2 leaves, got %d", leaves) + } + // Root(InternalNode) + leaf1 (from left StemNode) + leaf2 (from right StemNode) = 3 + // StemNodes are not returned as separate steps; the iterator advances + // directly to the first non-nil value within the stem. + if total != 3 { + t.Fatalf("expected 3 total nodes, got %d", total) + } +} diff --git a/trie/bintrie/key_encoding.go b/trie/bintrie/key_encoding.go index cda797521a66..265935293bd8 100644 --- a/trie/bintrie/key_encoding.go +++ b/trie/bintrie/key_encoding.go @@ -18,7 +18,6 @@ package bintrie import ( "bytes" - "crypto/sha256" "github.com/ethereum/go-ethereum/common" "github.com/holiman/uint256" @@ -33,17 +32,38 @@ const ( ) var ( - zeroHash = common.Hash{} - codeOffset = uint256.NewInt(128) + zeroInt = uint256.NewInt(0) + zeroHash = common.Hash{} + verkleNodeWidthLog2 = 8 + headerStorageOffset = uint256.NewInt(64) + codeOffset = uint256.NewInt(128) + codeStorageDelta = uint256.NewInt(0).Sub(codeOffset, headerStorageOffset) + mainStorageOffsetLshVerkleNodeWidth = new(uint256.Int).Lsh(uint256.NewInt(1), 248-uint(verkleNodeWidthLog2)) + CodeOffset = uint256.NewInt(128) + VerkleNodeWidth = uint256.NewInt(256) + HeaderStorageOffset = uint256.NewInt(64) + VerkleNodeWidthLog2 = 8 ) func GetBinaryTreeKey(addr common.Address, key []byte) []byte { - hasher := sha256.New() + return getBinaryTreeKey(addr, key, false) +} + +func getBinaryTreeKey(addr common.Address, offset []byte, overflow bool) []byte { + hasher := newSha256() + defer returnSha256(hasher) hasher.Write(zeroHash[:12]) hasher.Write(addr[:]) - hasher.Write(key[:31]) + var buf [32]byte // TODO: make offset a 33-byte value to avoid an extra stack alloc + copy(buf[1:32], offset[:31]) + if overflow { + // Overflow detected when adding MAIN_STORAGE_OFFSET, + // reporting it in the shifter 32 byte value. + buf[0] = 1 + } + hasher.Write(buf[:]) k := hasher.Sum(nil) - k[31] = key[31] + k[31] = offset[31] return k } @@ -59,27 +79,67 @@ func GetBinaryTreeKeyCodeHash(addr common.Address) []byte { return GetBinaryTreeKey(addr, k[:]) } -func GetBinaryTreeKeyStorageSlot(address common.Address, key []byte) []byte { - var k [32]byte +func GetBinaryTreeKeyStorageSlot(address common.Address, slotnum []byte) []byte { + var offset [32]byte // Case when the key belongs to the account header - if bytes.Equal(key[:31], zeroHash[:31]) && key[31] < 64 { - k[31] = 64 + key[31] - return GetBinaryTreeKey(address, k[:]) + if bytes.Equal(slotnum[:31], zeroHash[:31]) && slotnum[31] < 64 { + offset[31] = 64 + slotnum[31] + return GetBinaryTreeKey(address, offset[:]) } - // Set the main storage offset - // note that the first 64 bytes of the main offset storage - // are unreachable, which is consistent with the spec and - // what verkle does. - k[0] = 1 // 1 << 248 - copy(k[1:], key[:31]) - k[31] = key[31] + // Set the main storage offset offset = MAIN_STORAGE_OFFSET + slotnum + // * Note that MAIN_STORAGE_OFFSET is 1 << 248, so the number + // can overflow into a 33rd byte, but since the value is + // shifted by one byte in getBinaryTreeKey, this only takes + // note of the overflow, and the value will be added after + // the shift, in order to avoid allocating an extra byte. + // * Note that the first 64 bytes of the main offset storage + // are unreachable, which is consistent with the spec. + // * Note that `slotnum` is big-endian + overflow := slotnum[0] == 255 + copy(offset[:], slotnum) + offset[0] += 1 // 1 << 248, handle overflow out of band - return GetBinaryTreeKey(address, k[:]) + return getBinaryTreeKey(address, offset[:], overflow) } func GetBinaryTreeKeyCodeChunk(address common.Address, chunknr *uint256.Int) []byte { chunkOffset := new(uint256.Int).Add(codeOffset, chunknr).Bytes() return GetBinaryTreeKey(address, chunkOffset) } + +func StorageIndex(storageKey []byte) (*uint256.Int, byte) { + // If the storage slot is in the header, we need to add the header offset. + var key uint256.Int + key.SetBytes(storageKey) + if key.Cmp(codeStorageDelta) < 0 { + // This addition is always safe; it can't ever overflow since pos. + +package bintrie + +// nodeKind identifies the type of a trie node stored in a nodeRef. +type nodeKind uint8 + +const ( + kindEmpty nodeKind = iota + kindInternal + kindStem // up to 256 values per stem + kindHashed +) + +// nodeRef is a compact, GC-invisible reference to a node in a nodeStore. +// It packs a 2-bit type tag (bits 31-30) and a 30-bit index (bits 29-0) +// into a single uint32. Because nodeRef contains no Go pointers, slices +// of structs containing nodeRef fields are allocated in noscan spans — +// the garbage collector never examines them. +type nodeRef uint32 + +const ( + kindShift uint32 = 30 + indexMask uint32 = (1 << kindShift) - 1 + + // emptyRef represents an empty node. + emptyRef nodeRef = 0 +) + +func makeRef(kind nodeKind, idx uint32) nodeRef { + if idx > indexMask { + panic("nodeRef index overflow") + } + return nodeRef(uint32(kind)<> kindShift) } + +// Index within the typed pool. +func (r nodeRef) Index() uint32 { return uint32(r) & indexMask } + +func (r nodeRef) IsEmpty() bool { return r.Kind() == kindEmpty } diff --git a/trie/bintrie/node_store.go b/trie/bintrie/node_store.go new file mode 100644 index 000000000000..8a35f06ee14c --- /dev/null +++ b/trie/bintrie/node_store.go @@ -0,0 +1,184 @@ +// Copyright 2026 go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bintrie + +import "github.com/ethereum/go-ethereum/common" + +// storeChunkSize is the number of nodes per chunk in each typed pool. +const storeChunkSize = 4096 + +// nodeStore is a GC-friendly arena for binary trie nodes. Nodes are packed +// into typed chunked pools so pointer-free types (InternalNode, HashedNode) +// land in noscan spans the GC skips entirely. +type nodeStore struct { + internalChunks []*[storeChunkSize]InternalNode + internalCount uint32 + + stemChunks []*[storeChunkSize]StemNode + stemCount uint32 + + hashedChunks []*[storeChunkSize]HashedNode + hashedCount uint32 + + root nodeRef + + // Free list for recycling hashed-node slots after resolve. Internal and + // stem nodes are never freed under current semantics (no delete path, + // stem-split keeps the old stem at a deeper position), so they don't + // have free lists. + freeHashed []uint32 +} + +func newNodeStore() *nodeStore { + return &nodeStore{root: emptyRef} +} + +func (s *nodeStore) allocInternal() uint32 { + idx := s.internalCount + chunkIdx := idx / storeChunkSize + if uint32(len(s.internalChunks)) <= chunkIdx { + s.internalChunks = append(s.internalChunks, new([storeChunkSize]InternalNode)) + } + s.internalCount++ + if s.internalCount > indexMask { + panic("internal node pool overflow") + } + return idx +} + +func (s *nodeStore) getInternal(idx uint32) *InternalNode { + return &s.internalChunks[idx/storeChunkSize][idx%storeChunkSize] +} + +func (s *nodeStore) newInternalRef(depth int) nodeRef { + if depth > 248 { + panic("node depth exceeds maximum binary trie depth") + } + idx := s.allocInternal() + n := s.getInternal(idx) + n.depth = uint8(depth) + n.mustRecompute = true + n.dirty = true + return makeRef(kindInternal, idx) +} + +func (s *nodeStore) allocStem() uint32 { + idx := s.stemCount + chunkIdx := idx / storeChunkSize + if uint32(len(s.stemChunks)) <= chunkIdx { + s.stemChunks = append(s.stemChunks, new([storeChunkSize]StemNode)) + } + s.stemCount++ + if s.stemCount > indexMask { + panic("stem node pool overflow") + } + return idx +} + +func (s *nodeStore) getStem(idx uint32) *StemNode { + return &s.stemChunks[idx/storeChunkSize][idx%storeChunkSize] +} + +func (s *nodeStore) newStemRef(stem []byte, depth int) nodeRef { + if depth > 248 { + panic("node depth exceeds maximum binary trie depth") + } + idx := s.allocStem() + sn := s.getStem(idx) + copy(sn.Stem[:], stem[:StemSize]) + sn.depth = uint8(depth) + sn.mustRecompute = true + sn.dirty = true + return makeRef(kindStem, idx) +} + +func (s *nodeStore) allocHashed() uint32 { + if n := len(s.freeHashed); n > 0 { + idx := s.freeHashed[n-1] + s.freeHashed = s.freeHashed[:n-1] + *s.getHashed(idx) = HashedNode{} + return idx + } + idx := s.hashedCount + chunkIdx := idx / storeChunkSize + if uint32(len(s.hashedChunks)) <= chunkIdx { + s.hashedChunks = append(s.hashedChunks, new([storeChunkSize]HashedNode)) + } + s.hashedCount++ + if s.hashedCount > indexMask { + panic("hashed node pool overflow") + } + return idx +} + +func (s *nodeStore) getHashed(idx uint32) *HashedNode { + return &s.hashedChunks[idx/storeChunkSize][idx%storeChunkSize] +} + +func (s *nodeStore) freeHashedNode(idx uint32) { + s.freeHashed = append(s.freeHashed, idx) +} + +func (s *nodeStore) newHashedRef(hash common.Hash) nodeRef { + idx := s.allocHashed() + *s.getHashed(idx) = HashedNode(hash) + return makeRef(kindHashed, idx) +} + +func (s *nodeStore) Copy() *nodeStore { + ns := &nodeStore{ + root: s.root, + internalCount: s.internalCount, + stemCount: s.stemCount, + hashedCount: s.hashedCount, + } + ns.internalChunks = make([]*[storeChunkSize]InternalNode, len(s.internalChunks)) + for i, chunk := range s.internalChunks { + cp := *chunk + ns.internalChunks[i] = &cp + } + ns.stemChunks = make([]*[storeChunkSize]StemNode, len(s.stemChunks)) + for i, chunk := range s.stemChunks { + cp := *chunk + ns.stemChunks[i] = &cp + } + // Deep-copy each stem's value slots — they may alias serialized buffers, + // so we can't rely on the chunk-wise struct copy above. + for i := uint32(0); i < s.stemCount; i++ { + src := s.getStem(i) + dst := ns.getStem(i) + for j, v := range src.values { + if v == nil { + continue + } + cp := make([]byte, len(v)) + copy(cp, v) + dst.values[j] = cp + } + } + ns.hashedChunks = make([]*[storeChunkSize]HashedNode, len(s.hashedChunks)) + for i, chunk := range s.hashedChunks { + cp := *chunk + ns.hashedChunks[i] = &cp + } + if len(s.freeHashed) > 0 { + ns.freeHashed = make([]uint32, len(s.freeHashed)) + copy(ns.freeHashed, s.freeHashed) + } + + return ns +} diff --git a/trie/bintrie/stem_node.go b/trie/bintrie/stem_node.go index 60856b42ce60..93c55acefa0b 100644 --- a/trie/bintrie/stem_node.go +++ b/trie/bintrie/stem_node.go @@ -17,200 +17,93 @@ package bintrie import ( - "bytes" "crypto/sha256" - "errors" - "fmt" - "slices" "github.com/ethereum/go-ethereum/common" ) -// StemNode represents a group of `NodeWith` values sharing the same stem. +// StemNode holds up to 256 values sharing a 31-byte stem. +// +// Invariant: dirty=false implies mustRecompute=false. Every mutation that +// invalidates the cached hash MUST also mark the blob for re-flush. type StemNode struct { - Stem []byte // Stem path to get to StemNodeWidth values - Values [][]byte // All values, indexed by the last byte of the key. - depth int // Depth of the node -} + Stem [StemSize]byte + values [StemNodeWidth][]byte // nil == slot absent + + depth uint8 -// Get retrieves the value for the given key. -func (bt *StemNode) Get(key []byte, _ NodeResolverFn) ([]byte, error) { - panic("this should not be called directly") + mustRecompute bool // hash is stale (cleared by Hash) + dirty bool // on-disk blob is stale (cleared by CollectNodes) + hash common.Hash // cached hash when mustRecompute == false } -// Insert inserts a new key-value pair into the node. -func (bt *StemNode) Insert(key []byte, value []byte, _ NodeResolverFn, depth int) (BinaryNode, error) { - if !bytes.Equal(bt.Stem, key[:StemSize]) { - bitStem := bt.Stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1 - - n := &InternalNode{depth: bt.depth} - bt.depth++ - var child, other *BinaryNode - if bitStem == 0 { - n.left = bt - child = &n.left - other = &n.right - } else { - n.right = bt - child = &n.right - other = &n.left - } +func (sn *StemNode) getValue(suffix byte) []byte { + return sn.values[suffix] +} - bitKey := key[n.depth/8] >> (7 - (n.depth % 8)) & 1 - if bitKey == bitStem { - var err error - *child, err = (*child).Insert(key, value, nil, depth+1) - if err != nil { - return n, fmt.Errorf("insert error: %w", err) - } - *other = Empty{} - } else { - var values [StemNodeWidth][]byte - values[key[StemSize]] = value - *other = &StemNode{ - Stem: slices.Clone(key[:StemSize]), - Values: values[:], - depth: depth + 1, - } - } - return n, nil - } - if len(value) != HashSize { - return bt, errors.New("invalid insertion: value length") - } - bt.Values[key[StemSize]] = value - return bt, nil +func (sn *StemNode) hasValue(suffix byte) bool { + return sn.values[suffix] != nil } -// Copy creates a deep copy of the node. -func (bt *StemNode) Copy() BinaryNode { - var values [StemNodeWidth][]byte - for i, v := range bt.Values { - values[i] = slices.Clone(v) - } - return &StemNode{ - Stem: slices.Clone(bt.Stem), - Values: values[:], - depth: bt.depth, - } +// allValues returns the underlying slot array as a slice. nil entries mean +// absent. Callers must treat it as read-only. +func (sn *StemNode) allValues() [][]byte { + return sn.values[:] } -// GetHeight returns the height of the node. -func (bt *StemNode) GetHeight() int { - return 1 +// setValue mutates a value slot and marks the stem for re-hash and +// re-flush. This is the only API for post-load value mutation; direct +// values[...] writes are reserved for the on-disk load path in +// decodeNode, which must leave mustRecompute/dirty at their loaded +// state. +func (sn *StemNode) setValue(suffix byte, value []byte) { + sn.values[suffix] = value + sn.mustRecompute = true + sn.dirty = true } -// Hash returns the hash of the node. -func (bt *StemNode) Hash() common.Hash { +func (sn *StemNode) Hash() common.Hash { + if !sn.mustRecompute { + return sn.hash + } + + // Use sha256.Sum256 (returns [32]byte by value) instead of a pooled + // hash.Hash: feeding data[i][:0] into the interface method Sum forces + // data to heap (escape analysis is conservative through interfaces). + // Sum256 takes []byte and returns by value, so data stays on stack. var data [StemNodeWidth]common.Hash - for i, v := range bt.Values { + + for i, v := range sn.values { if v != nil { - h := sha256.Sum256(v) - data[i] = common.BytesToHash(h[:]) + data[i] = sha256.Sum256(v) } } - h := sha256.New() + var pair [2 * HashSize]byte for level := 1; level <= 8; level++ { for i := range StemNodeWidth / (1 << level) { - h.Reset() - if data[i*2] == (common.Hash{}) && data[i*2+1] == (common.Hash{}) { data[i] = common.Hash{} continue } - - h.Write(data[i*2][:]) - h.Write(data[i*2+1][:]) - data[i] = common.Hash(h.Sum(nil)) + copy(pair[:HashSize], data[i*2][:]) + copy(pair[HashSize:], data[i*2+1][:]) + data[i] = sha256.Sum256(pair[:]) } } - h.Reset() - h.Write(bt.Stem) - h.Write([]byte{0}) - h.Write(data[0][:]) - return common.BytesToHash(h.Sum(nil)) -} - -// CollectNodes collects all child nodes at a given path, and flushes it -// into the provided node collector. -func (bt *StemNode) CollectNodes(path []byte, flush NodeFlushFn) error { - flush(path, bt) - return nil -} - -// GetValuesAtStem retrieves the group of values located at the given stem key. -func (bt *StemNode) GetValuesAtStem(stem []byte, _ NodeResolverFn) ([][]byte, error) { - if !bytes.Equal(bt.Stem, stem) { - return nil, nil - } - return bt.Values[:], nil -} - -// InsertValuesAtStem inserts a full value group at the given stem in the internal node. -// Already-existing values will be overwritten. -func (bt *StemNode) InsertValuesAtStem(key []byte, values [][]byte, _ NodeResolverFn, depth int) (BinaryNode, error) { - if !bytes.Equal(bt.Stem, key[:StemSize]) { - bitStem := bt.Stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1 - - n := &InternalNode{depth: bt.depth} - bt.depth++ - var child, other *BinaryNode - if bitStem == 0 { - n.left = bt - child = &n.left - other = &n.right - } else { - n.right = bt - child = &n.right - other = &n.left - } - - bitKey := key[n.depth/8] >> (7 - (n.depth % 8)) & 1 - if bitKey == bitStem { - var err error - *child, err = (*child).InsertValuesAtStem(key, values, nil, depth+1) - if err != nil { - return n, fmt.Errorf("insert error: %w", err) - } - *other = Empty{} - } else { - *other = &StemNode{ - Stem: slices.Clone(key[:StemSize]), - Values: values, - depth: n.depth + 1, - } - } - return n, nil - } - - // same stem, just merge the two value lists - for i, v := range values { - if v != nil { - bt.Values[i] = v - } - } - return bt, nil -} - -func (bt *StemNode) toDot(parent, path string) string { - me := fmt.Sprintf("stem%s", path) - ret := fmt.Sprintf("%s [label=\"stem=%x c=%x\"]\n", me, bt.Stem, bt.Hash()) - ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) - for i, v := range bt.Values { - if v != nil { - ret = fmt.Sprintf("%s%s%x [label=\"%x\"]\n", ret, me, i, v) - ret = fmt.Sprintf("%s%s -> %s%x\n", ret, me, me, i) - } - } - return ret + var final [StemSize + 1 + HashSize]byte + copy(final[:StemSize], sn.Stem[:]) + final[StemSize] = 0 + copy(final[StemSize+1:], data[0][:]) + sn.hash = sha256.Sum256(final[:]) + sn.mustRecompute = false + return sn.hash } -// Key returns the full key for the given index. -func (bt *StemNode) Key(i int) []byte { +func (sn *StemNode) Key(i int) []byte { var ret [HashSize]byte - copy(ret[:], bt.Stem) + copy(ret[:], sn.Stem[:]) ret[StemSize] = byte(i) return ret[:] } diff --git a/trie/bintrie/stem_node_test.go b/trie/bintrie/stem_node_test.go index d8d6844427de..ae6b57ab34a5 100644 --- a/trie/bintrie/stem_node_test.go +++ b/trie/bintrie/stem_node_test.go @@ -23,121 +23,99 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestStemNodeInsertSameStem tests inserting values with the same stem +// TestStemNodeInsertSameStem tests inserting values with the same stem via nodeStore. func TestStemNodeInsertSameStem(t *testing.T) { + s := newNodeStore() + stem := make([]byte, 31) for i := range stem { stem[i] = byte(i) } - var values [256][]byte - values[0] = common.HexToHash("0x0101").Bytes() - - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, + // Insert first value + key1 := make([]byte, 32) + copy(key1[:31], stem) + key1[31] = 0 + value1 := common.HexToHash("0x0101").Bytes() + if err := s.Insert(key1, value1, nil); err != nil { + t.Fatal(err) } // Insert another value with the same stem but different last byte - key := make([]byte, 32) - copy(key[:31], stem) - key[31] = 10 - value := common.HexToHash("0x0202").Bytes() - - newNode, err := node.Insert(key, value, nil, 0) - if err != nil { - t.Fatalf("Failed to insert: %v", err) + key2 := make([]byte, 32) + copy(key2[:31], stem) + key2[31] = 10 + value2 := common.HexToHash("0x0202").Bytes() + if err := s.Insert(key2, value2, nil); err != nil { + t.Fatal(err) } - // Should still be a StemNode - stemNode, ok := newNode.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", newNode) + // Root should still be a StemNode + if s.root.Kind() != kindStem { + t.Fatalf("Expected kindStem root, got kind %d", s.root.Kind()) } // Check that both values are present - if !bytes.Equal(stemNode.Values[0], values[0]) { + v1, _ := s.Get(key1, nil) + if !bytes.Equal(v1, value1) { t.Errorf("Value at index 0 mismatch") } - if !bytes.Equal(stemNode.Values[10], value) { + v2, _ := s.Get(key2, nil) + if !bytes.Equal(v2, value2) { t.Errorf("Value at index 10 mismatch") } } -// TestStemNodeInsertDifferentStem tests inserting values with different stems +// TestStemNodeInsertDifferentStem tests inserting values with different stems via nodeStore. func TestStemNodeInsertDifferentStem(t *testing.T) { - stem1 := make([]byte, 31) - for i := range stem1 { - stem1[i] = 0x00 - } + s := newNodeStore() - var values [256][]byte - values[0] = common.HexToHash("0x0101").Bytes() - - node := &StemNode{ - Stem: stem1, - Values: values[:], - depth: 0, + // Insert first value with stem of all zeros + key1 := make([]byte, 32) + key1[31] = 0 + value1 := common.HexToHash("0x0101").Bytes() + if err := s.Insert(key1, value1, nil); err != nil { + t.Fatal(err) } // Insert with a different stem (first bit different) - key := make([]byte, 32) - key[0] = 0x80 // First bit is 1 instead of 0 - value := common.HexToHash("0x0202").Bytes() - - newNode, err := node.Insert(key, value, nil, 0) - if err != nil { - t.Fatalf("Failed to insert: %v", err) + key2 := make([]byte, 32) + key2[0] = 0x80 // First bit is 1 instead of 0 + value2 := common.HexToHash("0x0202").Bytes() + if err := s.Insert(key2, value2, nil); err != nil { + t.Fatal(err) } // Should now be an InternalNode - internalNode, ok := newNode.(*InternalNode) - if !ok { - t.Fatalf("Expected InternalNode, got %T", newNode) + if s.root.Kind() != kindInternal { + t.Fatalf("Expected kindInternal root, got kind %d", s.root.Kind()) } // Check depth - if internalNode.depth != 0 { - t.Errorf("Expected depth 0, got %d", internalNode.depth) - } - - // Original stem should be on the left (bit 0) - leftStem, ok := internalNode.left.(*StemNode) - if !ok { - t.Fatalf("Expected left child to be StemNode, got %T", internalNode.left) - } - if !bytes.Equal(leftStem.Stem, stem1) { - t.Errorf("Left stem mismatch") + rootNode := s.getInternal(s.root.Index()) + if rootNode.depth != 0 { + t.Errorf("Expected depth 0, got %d", rootNode.depth) } - // New stem should be on the right (bit 1) - rightStem, ok := internalNode.right.(*StemNode) - if !ok { - t.Fatalf("Expected right child to be StemNode, got %T", internalNode.right) + // Verify both values are retrievable + v1, _ := s.Get(key1, nil) + if !bytes.Equal(v1, value1) { + t.Error("Value 1 mismatch") } - if !bytes.Equal(rightStem.Stem, key[:31]) { - t.Errorf("Right stem mismatch") + v2, _ := s.Get(key2, nil) + if !bytes.Equal(v2, value2) { + t.Error("Value 2 mismatch") } } -// TestStemNodeInsertInvalidValueLength tests inserting value with invalid length +// TestStemNodeInsertInvalidValueLength tests inserting value with invalid length via nodeStore. func TestStemNodeInsertInvalidValueLength(t *testing.T) { - stem := make([]byte, 31) - var values [256][]byte - - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, - } + s := newNodeStore() - // Try to insert value with wrong length key := make([]byte, 32) - copy(key[:31], stem) invalidValue := []byte{1, 2, 3} // Not 32 bytes - _, err := node.Insert(key, invalidValue, nil, 0) + err := s.Insert(key, invalidValue, nil) if err == nil { t.Fatal("Expected error for invalid value length") } @@ -147,219 +125,206 @@ func TestStemNodeInsertInvalidValueLength(t *testing.T) { } } -// TestStemNodeCopy tests the Copy method +// TestStemNodeCopy tests the Copy method via nodeStore. func TestStemNodeCopy(t *testing.T) { - stem := make([]byte, 31) - for i := range stem { - stem[i] = byte(i) - } - - var values [256][]byte - values[0] = common.HexToHash("0x0101").Bytes() - values[255] = common.HexToHash("0x0202").Bytes() + s := newNodeStore() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 10, + key1 := make([]byte, 32) + for i := range 31 { + key1[i] = byte(i) } + key1[31] = 0 + value1 := common.HexToHash("0x0101").Bytes() - // Create a copy - copied := node.Copy() - copiedStem, ok := copied.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", copied) - } + key2 := make([]byte, 32) + copy(key2[:31], key1[:31]) + key2[31] = 255 + value2 := common.HexToHash("0x0202").Bytes() - // Check that values are equal but not the same slice - if !bytes.Equal(copiedStem.Stem, node.Stem) { - t.Errorf("Stem mismatch after copy") + if err := s.Insert(key1, value1, nil); err != nil { + t.Fatal(err) } - if &copiedStem.Stem[0] == &node.Stem[0] { - t.Error("Stem slice not properly cloned") + if err := s.Insert(key2, value2, nil); err != nil { + t.Fatal(err) } - // Check values - if !bytes.Equal(copiedStem.Values[0], node.Values[0]) { + ns := s.Copy() + + // Check that values are equal + v1, _ := ns.Get(key1, nil) + if !bytes.Equal(v1, value1) { t.Errorf("Value at index 0 mismatch after copy") } - if !bytes.Equal(copiedStem.Values[255], node.Values[255]) { + v2, _ := ns.Get(key2, nil) + if !bytes.Equal(v2, value2) { t.Errorf("Value at index 255 mismatch after copy") } - - // Check that value slices are cloned - if copiedStem.Values[0] != nil && &copiedStem.Values[0][0] == &node.Values[0][0] { - t.Error("Value slice not properly cloned") - } - - // Check depth - if copiedStem.depth != node.depth { - t.Errorf("Depth mismatch: expected %d, got %d", node.depth, copiedStem.depth) - } } -// TestStemNodeHash tests the Hash method +// TestStemNodeHash tests the Hash method. func TestStemNodeHash(t *testing.T) { - stem := make([]byte, 31) - var values [256][]byte - values[0] = common.HexToHash("0x0101").Bytes() + s := newNodeStore() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, + key := make([]byte, 32) + key[31] = 0 + value := common.HexToHash("0x0101").Bytes() + if err := s.Insert(key, value, nil); err != nil { + t.Fatal(err) } - hash1 := node.Hash() + hash1 := s.computeHash(s.root) // Hash should be deterministic - hash2 := node.Hash() + hash2 := s.computeHash(s.root) if hash1 != hash2 { t.Errorf("Hash not deterministic: %x != %x", hash1, hash2) } // Changing a value should change the hash - node.Values[1] = common.HexToHash("0x0202").Bytes() - hash3 := node.Hash() + key2 := make([]byte, 32) + key2[31] = 1 + value2 := common.HexToHash("0x0202").Bytes() + if err := s.Insert(key2, value2, nil); err != nil { + t.Fatal(err) + } + hash3 := s.computeHash(s.root) if hash1 == hash3 { t.Error("Hash didn't change after modifying values") } } -// TestStemNodeGetValuesAtStem tests GetValuesAtStem method +// TestStemNodeGetValuesAtStem tests GetValuesAtStem method via nodeStore. func TestStemNodeGetValuesAtStem(t *testing.T) { + s := newNodeStore() + stem := make([]byte, 31) for i := range stem { stem[i] = byte(i) } - var values [256][]byte + values := make([][]byte, 256) values[0] = common.HexToHash("0x0101").Bytes() values[10] = common.HexToHash("0x0202").Bytes() values[255] = common.HexToHash("0x0303").Bytes() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, + if err := s.InsertValuesAtStem(stem, values, nil); err != nil { + t.Fatal(err) } // GetValuesAtStem with matching stem - retrievedValues, err := node.GetValuesAtStem(stem, nil) + retrievedValues, err := s.GetValuesAtStem(stem, nil) if err != nil { t.Fatalf("Failed to get values: %v", err) } - // Check that all values match - for i := range 256 { - if !bytes.Equal(retrievedValues[i], values[i]) { - t.Errorf("Value mismatch at index %d", i) - } + if !bytes.Equal(retrievedValues[0], values[0]) { + t.Error("Value at index 0 mismatch") + } + if !bytes.Equal(retrievedValues[10], values[10]) { + t.Error("Value at index 10 mismatch") + } + if !bytes.Equal(retrievedValues[255], values[255]) { + t.Error("Value at index 255 mismatch") } - // GetValuesAtStem with different stem should return nil + // GetValuesAtStem with different stem should return nil values differentStem := make([]byte, 31) differentStem[0] = 0xFF - shouldBeNil, err := node.GetValuesAtStem(differentStem, nil) + shouldBeEmpty, err := s.GetValuesAtStem(differentStem, nil) if err != nil { t.Fatalf("Failed to get values with different stem: %v", err) } - if shouldBeNil != nil { - t.Error("Expected nil for different stem, got non-nil") + allNil := true + for _, v := range shouldBeEmpty { + if v != nil { + allNil = false + break + } + } + if !allNil { + t.Error("Expected all nil values for different stem") } } -// TestStemNodeInsertValuesAtStem tests InsertValuesAtStem method +// TestStemNodeInsertValuesAtStem tests InsertValuesAtStem method via nodeStore. func TestStemNodeInsertValuesAtStem(t *testing.T) { + s := newNodeStore() + stem := make([]byte, 31) - var values [256][]byte + values := make([][]byte, 256) values[0] = common.HexToHash("0x0101").Bytes() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, + if err := s.InsertValuesAtStem(stem, values, nil); err != nil { + t.Fatal(err) } // Insert new values at the same stem - var newValues [256][]byte + newValues := make([][]byte, 256) newValues[1] = common.HexToHash("0x0202").Bytes() newValues[2] = common.HexToHash("0x0303").Bytes() - newNode, err := node.InsertValuesAtStem(stem, newValues[:], nil, 0) - if err != nil { - t.Fatalf("Failed to insert values: %v", err) - } - - stemNode, ok := newNode.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", newNode) + if err := s.InsertValuesAtStem(stem, newValues, nil); err != nil { + t.Fatal(err) } // Check that all values are present - if !bytes.Equal(stemNode.Values[0], values[0]) { + retrieved, err := s.GetValuesAtStem(stem, nil) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(retrieved[0], values[0]) { t.Error("Original value at index 0 missing") } - if !bytes.Equal(stemNode.Values[1], newValues[1]) { + if !bytes.Equal(retrieved[1], newValues[1]) { t.Error("New value at index 1 missing") } - if !bytes.Equal(stemNode.Values[2], newValues[2]) { + if !bytes.Equal(retrieved[2], newValues[2]) { t.Error("New value at index 2 missing") } } -// TestStemNodeGetHeight tests GetHeight method +// TestStemNodeGetHeight tests GetHeight method via nodeStore. func TestStemNodeGetHeight(t *testing.T) { - node := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 0, + s := newNodeStore() + + key := make([]byte, 32) + value := common.HexToHash("0x01").Bytes() + if err := s.Insert(key, value, nil); err != nil { + t.Fatal(err) } - height := node.GetHeight() + height := s.getHeight(s.root) if height != 1 { t.Errorf("Expected height 1, got %d", height) } } -// TestStemNodeCollectNodes tests CollectNodes method +// TestStemNodeCollectNodes tests CollectNodes method via nodeStore. func TestStemNodeCollectNodes(t *testing.T) { + s := newNodeStore() + stem := make([]byte, 31) - var values [256][]byte + values := make([][]byte, 256) values[0] = common.HexToHash("0x0101").Bytes() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, + if err := s.InsertValuesAtStem(stem, values, nil); err != nil { + t.Fatal(err) } var collectedPaths [][]byte - var collectedNodes []BinaryNode - - flushFn := func(path []byte, n BinaryNode) { - // Make a copy of the path + flushFn := func(path []byte, hash common.Hash, serialized []byte) { pathCopy := make([]byte, len(path)) copy(pathCopy, path) collectedPaths = append(collectedPaths, pathCopy) - collectedNodes = append(collectedNodes, n) } - err := node.CollectNodes([]byte{0, 1, 0}, flushFn) - if err != nil { - t.Fatalf("Failed to collect nodes: %v", err) - } + s.collectNodes(s.root, []byte{0, 1, 0}, flushFn, 8) // Should have collected one node (itself) - if len(collectedNodes) != 1 { - t.Errorf("Expected 1 collected node, got %d", len(collectedNodes)) - } - - // Check that the collected node is the same - if collectedNodes[0] != node { - t.Error("Collected node doesn't match original") + if len(collectedPaths) != 1 { + t.Errorf("Expected 1 collected node, got %d", len(collectedPaths)) } // Check the path diff --git a/trie/bintrie/store_commit.go b/trie/bintrie/store_commit.go new file mode 100644 index 000000000000..b14bffbc6cfb --- /dev/null +++ b/trie/bintrie/store_commit.go @@ -0,0 +1,487 @@ +// Copyright 2026 go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bintrie + +import ( + "crypto/sha256" + "errors" + "fmt" + "math/bits" + "runtime" + "sync" + + "github.com/ethereum/go-ethereum/common" +) + +type nodeFlushFn func(path []byte, hash common.Hash, serialized []byte) + +func (s *nodeStore) Hash() common.Hash { + return s.computeHash(s.root) +} + +func (s *nodeStore) computeHash(ref nodeRef) common.Hash { + switch ref.Kind() { + case kindInternal: + return s.hashInternal(ref.Index()) + case kindStem: + return s.getStem(ref.Index()).Hash() + case kindHashed: + return s.getHashed(ref.Index()).Hash() + case kindEmpty: + return common.Hash{} + default: + return common.Hash{} + } +} + +// parallelHashDepth is the tree depth below which hashInternal spawns +// goroutines for shallow-depth parallelism. Computed once at init because +// NumCPU() never changes after startup. +var parallelHashDepth = min(bits.Len(uint(runtime.NumCPU())), 8) + +// hashInternal hashes an InternalNode and caches the result. +// +// At shallow depths (< parallelHashDepth) the left subtree is hashed in a +// goroutine while the right subtree is hashed inline, then the two digests +// are combined. Below that threshold the goroutine spawn cost outweighs the +// hashing work, so deeper nodes hash both children sequentially. +func (s *nodeStore) hashInternal(idx uint32) common.Hash { + node := s.getInternal(idx) + if !node.mustRecompute { + return node.hash + } + + if int(node.depth) < parallelHashDepth { + var input [64]byte + var lh common.Hash + var wg sync.WaitGroup + if !node.left.IsEmpty() { + wg.Add(1) + go func() { + // defer wg.Done() so a panic in computeHash still releases + // the waiter; without this, a recover() higher in the call + // stack would leave the parent stuck in wg.Wait forever. + defer wg.Done() + lh = s.computeHash(node.left) + }() + } + if !node.right.IsEmpty() { + rh := s.computeHash(node.right) + copy(input[32:], rh[:]) + } + wg.Wait() + copy(input[:32], lh[:]) + node.hash = sha256.Sum256(input[:]) + node.mustRecompute = false + return node.hash + } + + // Deep sequential branch — mirrors the shallow branch's shape to keep + // input on the stack. Writing lh/rh through hash.Hash (interface) + // forces escape; copy into a local [64]byte and hash it in one shot. + var input [64]byte + if !node.left.IsEmpty() { + lh := s.computeHash(node.left) + copy(input[:HashSize], lh[:]) + } + if !node.right.IsEmpty() { + rh := s.computeHash(node.right) + copy(input[HashSize:], rh[:]) + } + node.hash = sha256.Sum256(input[:]) + node.mustRecompute = false + return node.hash +} + +// serializeSubtree recursively collects child hashes from a subtree of InternalNodes. +// It traverses up to `remainingDepth` levels, storing hashes of bottom-layer children. +// position tracks the current index (0 to 2^groupDepth - 1) for bitmap placement. +// hashes collects the hashes of present children, bitmap tracks which positions are present. +func (s *nodeStore) serializeSubtree(ref nodeRef, remainingDepth int, position int, absoluteDepth int, bitmap []byte, hashes *[]common.Hash) { + if remainingDepth == 0 { + // Bottom layer: store hash if not empty + switch ref.Kind() { + case kindEmpty: + // Leave bitmap bit unset, don't add hash + return + default: + // StemNode, HashedNode, or InternalNode at boundary: store hash + bitmap[position/8] |= 1 << (7 - (position % 8)) + *hashes = append(*hashes, s.computeHash(ref)) + } + return + } + + switch ref.Kind() { + case kindInternal: + leftPos := position * 2 + rightPos := position*2 + 1 + s.serializeSubtree(s.getInternal(ref.Index()).left, remainingDepth-1, leftPos, absoluteDepth+1, bitmap, hashes) + s.serializeSubtree(s.getInternal(ref.Index()).right, remainingDepth-1, rightPos, absoluteDepth+1, bitmap, hashes) + case kindEmpty: + return + default: + // StemNode or HashedNode encountered before reaching the group's bottom + // layer. Compute the leaf bitmap position where this node's hash will + // be stored. + leafPos := position + switch ref.Kind() { + case kindStem: + sn := s.getStem(ref.Index()) + // Extend position using the stem's key bits so that + // GetValuesAtStem traversal (which follows key bits) finds the hash. + for d := 0; d < remainingDepth; d++ { + bit := sn.Stem[(absoluteDepth+d)/8] >> (7 - ((absoluteDepth + d) % 8)) & 1 + leafPos = leafPos*2 + int(bit) + } + default: + // HashedNode or unknown: extend all-left (no key bits available). + // This matches the all-zero path that resolveNode would follow. + leafPos = position << remainingDepth + } + bitmap[leafPos/8] |= 1 << (7 - (leafPos % 8)) + *hashes = append(*hashes, s.computeHash(ref)) + } +} + +// SerializeNode serializes a node into the flat on-disk format. +func (s *nodeStore) serializeNode(ref nodeRef, groupDepth int) []byte { + switch ref.Kind() { + case kindInternal: + // InternalNode group: 1 byte type + 1 byte group depth + variable bitmap + N×32 byte hashes + bitmapSize := bitmapSizeForDepth(groupDepth) + bitmap := make([]byte, bitmapSize) + var hashes []common.Hash + + node := s.getInternal(ref.Index()) + s.serializeSubtree(ref, groupDepth, 0, int(node.depth), bitmap, &hashes) + + // Build serialized output + serializedLen := NodeTypeBytes + 1 + bitmapSize + len(hashes)*HashSize + serialized := make([]byte, serializedLen) + serialized[0] = nodeTypeInternal + serialized[1] = byte(groupDepth) // group depth => bitmap size for a sparse group + copy(serialized[2:2+bitmapSize], bitmap) + + offset := NodeTypeBytes + 1 + bitmapSize + for _, h := range hashes { + copy(serialized[offset:offset+HashSize], h.Bytes()) + offset += HashSize + } + + return serialized + + case kindStem: + sn := s.getStem(ref.Index()) + // Count present slots to size the blob. + var count int + for _, v := range sn.values { + if v != nil { + count++ + } + } + serializedLen := NodeTypeBytes + StemSize + StemBitmapSize + count*HashSize + serialized := make([]byte, serializedLen) + serialized[0] = nodeTypeStem + copy(serialized[NodeTypeBytes:NodeTypeBytes+StemSize], sn.Stem[:]) + bitmap := serialized[NodeTypeBytes+StemSize : NodeTypeBytes+StemSize+StemBitmapSize] + offset := NodeTypeBytes + StemSize + StemBitmapSize + for i, v := range sn.values { + if v != nil { + bitmap[i/8] |= 1 << (7 - (i % 8)) + copy(serialized[offset:offset+HashSize], v) + offset += HashSize + } + } + return serialized + + default: + panic(fmt.Sprintf("SerializeNode: unexpected node kind %d", ref.Kind())) + } +} + +var errInvalidSerializedLength = errors.New("invalid serialized node length") + +// DeserializeNode deserializes a node from bytes, recomputing its hash. The +// returned node is marked dirty (provenance unknown, safe re-flush default). +func (s *nodeStore) deserializeNode(serialized []byte, depth int) (nodeRef, error) { + return s.decodeNode(serialized, depth, common.Hash{}, true, true) +} + +// DeserializeNodeWithHash deserializes a node whose hash is already known and +// whose blob is already on disk (mustRecompute=false, dirty=false). +func (s *nodeStore) deserializeNodeWithHash(serialized []byte, depth int, hn common.Hash) (nodeRef, error) { + return s.decodeNode(serialized, depth, hn, false, false) +} + +// deserializeSubtree reconstructs an InternalNode subtree from grouped serialization. +// remainingDepth is how many more levels to build, position is current index in the bitmap, +// nodeDepth is the actual trie depth for the node being created. +// hashIdx tracks the current position in the hash data (incremented as hashes are consumed). +func (s *nodeStore) deserializeSubtree(hn common.Hash, remainingDepth int, position int, nodeDepth int, bitmap []byte, hashData []byte, hashIdx *int, mustRecompute bool, dirty bool) (nodeRef, error) { + if remainingDepth == 0 { + // Bottom layer: check bitmap and return HashedNode or Empty + if bitmap[position/8]>>(7-(position%8))&1 == 1 { + if len(hashData) < (*hashIdx+1)*HashSize { + return emptyRef, errInvalidSerializedLength + } + hash := common.BytesToHash(hashData[*hashIdx*HashSize : (*hashIdx+1)*HashSize]) + *hashIdx++ + return s.newHashedRef(hash), nil + } + return emptyRef, nil + } + + // Check if this entire subtree is empty by examining all relevant bitmap bits + leftPos := position * 2 + rightPos := position*2 + 1 + + // note that the parent might not need root computations, but the children + // do, because their hash isn't saved. Hence `mustRecompute` is set to `true`. + left, err := s.deserializeSubtree(common.Hash{}, remainingDepth-1, leftPos, nodeDepth+1, bitmap, hashData, hashIdx, true, dirty) + if err != nil { + return emptyRef, err + } + right, err := s.deserializeSubtree(common.Hash{}, remainingDepth-1, rightPos, nodeDepth+1, bitmap, hashData, hashIdx, true, dirty) + if err != nil { + return emptyRef, err + } + + // If both children are empty, return Empty + if left.IsEmpty() && right.IsEmpty() { + return emptyRef, nil + } + + ref := s.newInternalRef(nodeDepth) + node := s.getInternal(ref.Index()) + node.left = left + node.right = right + node.mustRecompute = mustRecompute + if !mustRecompute { + // mustRecompute will only be false for the root of the subtree, + // for which we already know the hash. + node.hash = hn + node.mustRecompute = false + } + node.dirty = dirty + return ref, nil +} + +func (s *nodeStore) decodeNode(serialized []byte, depth int, hn common.Hash, mustRecompute, dirty bool) (nodeRef, error) { + if len(serialized) == 0 { + return emptyRef, nil + } + + switch serialized[0] { + case nodeTypeInternal: + // Grouped format: 1 byte type + 1 byte group depth + variable bitmap + N×32 byte hashes + if len(serialized) < NodeTypeBytes+1 { + return emptyRef, errInvalidSerializedLength + } + groupDepth := int(serialized[1]) + if groupDepth < 1 || groupDepth > MaxGroupDepth { + return 0, errors.New("invalid group depth") + } + bitmapSize := bitmapSizeForDepth(groupDepth) + if len(serialized) < NodeTypeBytes+1+bitmapSize { + return 0, errInvalidSerializedLength + } + bitmap := serialized[2 : 2+bitmapSize] + hashData := serialized[2+bitmapSize:] + + hashIdx := 0 + return s.deserializeSubtree(hn, groupDepth, 0, depth, bitmap, hashData, &hashIdx, mustRecompute, dirty) + + case nodeTypeStem: + if len(serialized) < NodeTypeBytes+StemSize+StemBitmapSize { + return emptyRef, errInvalidSerializedLength + } + stemIdx := s.allocStem() + sn := s.getStem(stemIdx) + copy(sn.Stem[:], serialized[NodeTypeBytes:NodeTypeBytes+StemSize]) + bitmap := serialized[NodeTypeBytes+StemSize : NodeTypeBytes+StemSize+StemBitmapSize] + offset := NodeTypeBytes + StemSize + StemBitmapSize + for i := range StemNodeWidth { + if bitmap[i/8]>>(7-(i%8))&1 != 1 { + continue + } + if len(serialized) < offset+HashSize { + return emptyRef, errInvalidSerializedLength + } + // Zero-copy: each slot aliases the serialized input buffer. + sn.values[i] = serialized[offset : offset+HashSize] + offset += HashSize + } + sn.depth = uint8(depth) + sn.hash = hn + sn.mustRecompute = mustRecompute + sn.dirty = dirty + return makeRef(kindStem, stemIdx), nil + + default: + return emptyRef, errors.New("invalid node type") + } +} + +// CollectNodes flushes every node that needs flushing via flushfn in post-order. +// Invariant: any ancestor of a node that needs flushing is itself marked, so a +// clean root means the whole subtree is clean. +func (s *nodeStore) collectNodes(ref nodeRef, path []byte, flushfn nodeFlushFn, groupDepth int) { + switch ref.Kind() { + case kindInternal: + node := s.getInternal(ref.Index()) + if !node.dirty { + return + } + // Only flush at group boundaries (depth % groupDepth == 0) + if int(node.depth)%groupDepth == 0 { + // We're at a group boundary - first collect any nodes in deeper groups, + // then flush this group + s.collectChildGroups(node, path, flushfn, groupDepth, groupDepth-1) + flushfn(path, s.computeHash(ref), s.serializeNode(ref, groupDepth)) + node.dirty = false + return + } + // Not at a group boundary - this shouldn't happen if we're called correctly from root + // but handle it by continuing to traverse + s.collectChildGroups(node, path, flushfn, groupDepth, groupDepth-(int(node.depth)%groupDepth)-1) + case kindStem: + sn := s.getStem(ref.Index()) + if !sn.dirty { + return + } + flushfn(path, s.computeHash(ref), s.serializeNode(ref, groupDepth)) + sn.dirty = false + case kindHashed, kindEmpty: + default: + panic(fmt.Sprintf("CollectNodes: unexpected kind %d", ref.Kind())) + } +} + +// collectChildGroups traverses within a group to find and collect nodes in the next group. +// remainingLevels is how many more levels below the current node until we reach the group boundary. +// When remainingLevels=0, the current node's children are at the next group boundary. +func (s *nodeStore) collectChildGroups(node *InternalNode, path []byte, flushfn nodeFlushFn, groupDepth int, remainingLevels int) error { + if remainingLevels == 0 { + // Current node is at depth (groupBoundary - 1), its children are at the next group boundary + if !node.left.IsEmpty() { + s.collectNodes(node.left, appendBit(path, 0), flushfn, groupDepth) + } + if !node.right.IsEmpty() { + s.collectNodes(node.right, appendBit(path, 1), flushfn, groupDepth) + } + return nil + } + + if !node.left.IsEmpty() { + switch node.left.Kind() { + case kindInternal: + n := s.getInternal(node.left.Index()) + if err := s.collectChildGroups(n, appendBit(path, 0), flushfn, groupDepth, remainingLevels-1); err != nil { + return err + } + default: + extPath := s.extendPathToGroupLeaf(appendBit(path, 0), node.left, remainingLevels) + s.collectNodes(node.left, extPath, flushfn, groupDepth) + } + } + if !node.right.IsEmpty() { + switch node.right.Kind() { + case kindInternal: + n := s.getInternal(node.right.Index()) + if err := s.collectChildGroups(n, appendBit(path, 1), flushfn, groupDepth, remainingLevels-1); err != nil { + return err + } + default: + extPath := s.extendPathToGroupLeaf(appendBit(path, 1), node.right, remainingLevels) + s.collectNodes(node.right, extPath, flushfn, groupDepth) + } + } + return nil +} + +// extendPathToGroupLeaf extends a storage path to the group's leaf boundary, +// matching the projection done by serializeSubtree. For StemNodes, the path +// is extended using the stem's key bits (same as serializeSubtree). For other +// node types, the path is extended with all-zero (left) bits. +func (s *nodeStore) extendPathToGroupLeaf(path []byte, node nodeRef, remainingLevels int) []byte { + if remainingLevels <= 0 { + return path + } + if node.Kind() == kindStem { + sn := s.getStem(node.Index()) + for _ = range remainingLevels { + bit := sn.Stem[len(path)/8] >> (7 - (len(path) % 8)) & 1 + path = appendBit(path, bit) + } + } else { + // HashedNode or other: all-left extension (matches serializeSubtree's + // position << remainingDepth behavior). + for _ = range remainingLevels { + path = appendBit(path, 0) + } + } + return path +} + +// appendBit appends a bit to a path, returning a new slice +func appendBit(path []byte, bit byte) []byte { + var p [256]byte + copy(p[:], path) + result := p[:len(path)] + return append(result, bit) +} + +func (s *nodeStore) toDot(ref nodeRef, parent, path string) string { + switch ref.Kind() { + case kindInternal: + node := s.getInternal(ref.Index()) + me := fmt.Sprintf("internal%s", path) + ret := fmt.Sprintf("%s [label=\"I: %x\"]\n", me, s.computeHash(ref)) + if len(parent) > 0 { + ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) + } + if !node.left.IsEmpty() { + ret += s.toDot(node.left, me, fmt.Sprintf("%s%b", path, 0)) + } + if !node.right.IsEmpty() { + ret += s.toDot(node.right, me, fmt.Sprintf("%s%b", path, 1)) + } + return ret + case kindStem: + sn := s.getStem(ref.Index()) + me := fmt.Sprintf("stem%s", path) + ret := fmt.Sprintf("%s [label=\"stem=%x c=%x\"]\n", me, sn.Stem, sn.Hash()) + ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) + for i, v := range sn.values { + if v == nil { + continue + } + ret += fmt.Sprintf("%s%x [label=\"%x\"]\n", me, i, v) + ret += fmt.Sprintf("%s -> %s%x\n", me, me, i) + } + return ret + case kindHashed: + hn := s.getHashed(ref.Index()) + me := fmt.Sprintf("hash%s", path) + ret := fmt.Sprintf("%s [label=\"%x\"]\n", me, hn.Hash()) + ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) + return ret + default: + return "" + } +} diff --git a/trie/bintrie/store_ops.go b/trie/bintrie/store_ops.go new file mode 100644 index 000000000000..9a73c8bd642d --- /dev/null +++ b/trie/bintrie/store_ops.go @@ -0,0 +1,345 @@ +// Copyright 2026 go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bintrie + +import ( + "errors" + "fmt" + + "github.com/ethereum/go-ethereum/common" +) + +// nodeResolverFn resolves a hashed node from the database. +type nodeResolverFn func([]byte, common.Hash) ([]byte, error) + +// GetValue returns the value at (stem, suffix) or nil if absent. Thin +// wrapper over GetValuesAtStem — the underlying StemNode returns its +// 256-slot array as a slice header (no allocation), so the per-call cost +// is the tree walk plus one index. +func (s *nodeStore) GetValue(stem []byte, suffix byte, resolver nodeResolverFn) ([]byte, error) { + values, err := s.GetValuesAtStem(stem, resolver) + if err != nil || values == nil { + return nil, err + } + return values[suffix], nil +} + +// GetValuesAtStem returns the 256 value slots at stem, or nil if the stem +// is not in the trie. The returned slice is a view over the in-place +// StemNode values array (no allocation) and must be treated read-only. +func (s *nodeStore) GetValuesAtStem(stem []byte, resolver nodeResolverFn) ([][]byte, error) { + cur := s.root + var parentIdx uint32 + var parentIsLeft bool + + for { + switch cur.Kind() { + case kindInternal: + node := s.getInternal(cur.Index()) + if node.depth >= 31*8 { + return nil, errors.New("node too deep") + } + bit := stem[node.depth/8] >> (7 - (node.depth % 8)) & 1 + parentIdx = cur.Index() + if bit == 0 { + parentIsLeft = true + cur = node.left + } else { + parentIsLeft = false + cur = node.right + } + + case kindStem: + sn := s.getStem(cur.Index()) + if sn.Stem != [StemSize]byte(stem[:StemSize]) { + return nil, nil + } + return sn.allValues(), nil + + case kindHashed: + // HashedNode at root is impossible: NewBinaryTrie resolves the + // root eagerly before any query. Any HashedNode we encounter here + // is necessarily a child of a previously-visited internal node. + if resolver == nil { + return nil, errors.New("getValuesAtStem: cannot resolve hashed node without resolver") + } + hn := s.getHashed(cur.Index()) + parentNode := s.getInternal(parentIdx) + path, err := keyToPath(int(parentNode.depth), stem) + if err != nil { + return nil, fmt.Errorf("getValuesAtStem path error: %w", err) + } + data, err := resolver(path, hn.Hash()) + if err != nil { + return nil, fmt.Errorf("getValuesAtStem resolve error: %w", err) + } + resolved, err := s.deserializeNodeWithHash(data, int(parentNode.depth)+1, hn.Hash()) + if err != nil { + return nil, fmt.Errorf("getValuesAtStem deserialization error: %w", err) + } + s.freeHashedNode(cur.Index()) + if parentIsLeft { + parentNode.left = resolved + } else { + parentNode.right = resolved + } + cur = resolved + + case kindEmpty: + var values [StemNodeWidth][]byte + return values[:], nil + + default: + return nil, fmt.Errorf("getValuesAtStem: unexpected node kind %d", cur.Kind()) + } + } +} + +// InsertSingle writes a single value slot at (stem, suffix). Thin wrapper +// over InsertValuesAtStem — builds a stack-allocated 256-slot array with +// only the target slot set and delegates. Matches the original design +// gballet referenced (comment 3101751325): one primary insert path; the +// single-slot variant dispatches through it so the split / resolve logic +// lives in one place. +func (s *nodeStore) InsertSingle(stem []byte, suffix byte, value []byte, resolver nodeResolverFn) error { + if len(value) != HashSize { + return errors.New("invalid insertion: value length") + } + var values [StemNodeWidth][]byte + values[suffix] = value + return s.InsertValuesAtStem(stem, values[:], resolver) +} + +// InsertValuesAtStem writes the supplied value slots at stem. values may be +// sparse (nil entries are ignored). The recursive implementation dispatches +// through the same body, so a single code path handles internal descent, +// HashedNode resolution, stem merge, and stem split. +func (s *nodeStore) InsertValuesAtStem(stem []byte, values [][]byte, resolver nodeResolverFn) error { + var err error + s.root, err = s.insertValuesAtStem(s.root, stem, values, resolver, 0) + return err +} + +func (s *nodeStore) insertValuesAtStem(ref nodeRef, stem []byte, values [][]byte, resolver nodeResolverFn, depth int) (nodeRef, error) { + switch ref.Kind() { + case kindInternal: + node := s.getInternal(ref.Index()) + bit := stem[node.depth/8] >> (7 - (node.depth % 8)) & 1 + if bit == 0 { + if node.left.Kind() == kindHashed { + if resolver == nil { + return ref, errors.New("insertValuesAtStem: cannot resolve hashed node without resolver") + } + hn := s.getHashed(node.left.Index()) + path, err := keyToPath(int(node.depth), stem) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem path error: %w", err) + } + data, err := resolver(path, hn.Hash()) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) + } + resolved, err := s.deserializeNodeWithHash(data, int(node.depth)+1, hn.Hash()) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem deserialization error: %w", err) + } + s.freeHashedNode(node.left.Index()) + node.left = resolved + } + newChild, err := s.insertValuesAtStem(node.left, stem, values, resolver, depth+1) + if err != nil { + return ref, err + } + node.left = newChild + } else { + if node.right.Kind() == kindHashed { + if resolver == nil { + return ref, errors.New("insertValuesAtStem: cannot resolve hashed node without resolver") + } + hn := s.getHashed(node.right.Index()) + path, err := keyToPath(int(node.depth), stem) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem path error: %w", err) + } + data, err := resolver(path, hn.Hash()) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) + } + resolved, err := s.deserializeNodeWithHash(data, int(node.depth)+1, hn.Hash()) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem deserialization error: %w", err) + } + s.freeHashedNode(node.right.Index()) + node.right = resolved + } + newChild, err := s.insertValuesAtStem(node.right, stem, values, resolver, depth+1) + if err != nil { + return ref, err + } + node.right = newChild + } + node.mustRecompute = true + node.dirty = true + return ref, nil + + case kindStem: + sn := s.getStem(ref.Index()) + if sn.Stem == [StemSize]byte(stem[:StemSize]) { + // Same stem — merge values (setValue marks dirty+mustRecompute) + for i, v := range values { + if v != nil { + sn.setValue(byte(i), v) + } + } + return ref, nil + } + // Different stem — split + return s.splitStemValuesInsert(ref, stem, values, resolver, depth) + + case kindHashed: + hn := s.getHashed(ref.Index()) + path, err := keyToPath(depth, stem) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem path error: %w", err) + } + if resolver == nil { + return ref, errors.New("InsertValuesAtStem: resolver is nil") + } + data, err := resolver(path, hn.Hash()) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) + } + resolved, err := s.deserializeNodeWithHash(data, depth, hn.Hash()) + if err != nil { + return ref, fmt.Errorf("InsertValuesAtStem deserialization error: %w", err) + } + s.freeHashedNode(ref.Index()) + return s.insertValuesAtStem(resolved, stem, values, resolver, depth) + + case kindEmpty: + // Create new StemNode. Flag flips before the value loop so an + // all-nil values input still marks the newly-created stem dirty. + stemIdx := s.allocStem() + sn := s.getStem(stemIdx) + copy(sn.Stem[:], stem[:StemSize]) + sn.depth = uint8(depth) + sn.mustRecompute = true + sn.dirty = true + for i, v := range values { + if v != nil { + sn.setValue(byte(i), v) + } + } + return makeRef(kindStem, stemIdx), nil + + default: + return ref, fmt.Errorf("insertValuesAtStem: unexpected kind %d", ref.Kind()) + } +} + +// splitStemValuesInsert splits a StemNode when the new stem diverges. +func (s *nodeStore) splitStemValuesInsert(existingRef nodeRef, newStem []byte, values [][]byte, resolver nodeResolverFn, depth int) (nodeRef, error) { + existing := s.getStem(existingRef.Index()) + + if int(existing.depth) >= StemSize*8 { + panic("splitStemValuesInsert: identical stems") + } + + bitStem := existing.Stem[existing.depth/8] >> (7 - (existing.depth % 8)) & 1 + nRef := s.newInternalRef(int(existing.depth)) + nNode := s.getInternal(nRef.Index()) + existing.depth++ + + bitKey := newStem[nNode.depth/8] >> (7 - (nNode.depth % 8)) & 1 + if bitKey == bitStem { + // Same direction — need deeper split + var child nodeRef + if bitStem == 0 { + nNode.left = existingRef + child = nNode.left + } else { + nNode.right = existingRef + child = nNode.right + } + newChild, err := s.insertValuesAtStem(child, newStem, values, resolver, depth+1) + if err != nil { + // Roll back the depth increment so a retry sees the same + // existing state and extracts bitStem at the correct offset. + // nRef itself leaks (no internal free-list), but the slot is + // unreachable from the tree and harmless. + existing.depth-- + return nRef, err + } + if bitStem == 0 { + nNode.left = newChild + nNode.right = emptyRef + } else { + nNode.right = newChild + nNode.left = emptyRef + } + } else { + // Divergence — create new StemNode for the new values + newStemIdx := s.allocStem() + newSn := s.getStem(newStemIdx) + copy(newSn.Stem[:], newStem[:StemSize]) + newSn.depth = nNode.depth + 1 + newSn.mustRecompute = true + newSn.dirty = true + for i, v := range values { + if v != nil { + newSn.setValue(byte(i), v) + } + } + newStemRef := makeRef(kindStem, newStemIdx) + + if bitStem == 0 { + nNode.left = existingRef + nNode.right = newStemRef + } else { + nNode.left = newStemRef + nNode.right = existingRef + } + } + return nRef, nil +} + +func (s *nodeStore) Insert(key []byte, value []byte, resolver nodeResolverFn) error { + return s.InsertSingle(key[:StemSize], key[StemSize], value, resolver) +} + +func (s *nodeStore) Get(key []byte, resolver nodeResolverFn) ([]byte, error) { + return s.GetValue(key[:StemSize], key[StemSize], resolver) +} + +func (s *nodeStore) getHeight(ref nodeRef) int { + switch ref.Kind() { + case kindInternal: + node := s.getInternal(ref.Index()) + lh := s.getHeight(node.left) + rh := s.getHeight(node.right) + if lh > rh { + return 1 + lh + } + return 1 + rh + case kindStem: + return 1 + case kindEmpty: + return 0 + default: + return 0 + } +} diff --git a/trie/bintrie/trie.go b/trie/bintrie/trie.go index a7ee342b7452..e3436e3df1bf 100644 --- a/trie/bintrie/trie.go +++ b/trie/bintrie/trie.go @@ -19,7 +19,6 @@ package bintrie import ( "bytes" "encoding/binary" - "errors" "fmt" "github.com/ethereum/go-ethereum/common" @@ -31,8 +30,6 @@ import ( "github.com/holiman/uint256" ) -var errInvalidRootType = errors.New("invalid root type") - // ChunkedCode represents a sequence of HashSize-byte chunks of code (StemSize bytes of which // are actual code, and NodeTypeBytes byte is the pushdata offset). type ChunkedCode []byte @@ -79,10 +76,7 @@ func ChunkifyCode(code []byte) ChunkedCode { chunks := make([]byte, chunkCount*HashSize) for i := 0; i < chunkCount; i++ { // number of bytes to copy, StemSize unless the end of the code has been reached. - end := StemSize * (i + 1) - if len(code) < end { - end = len(code) - } + end := min(len(code), StemSize*(i+1)) copy(chunks[i*HashSize+1:], code[StemSize*i:end]) // copy the code itself // chunk offset = taken from the last chunk. @@ -111,34 +105,39 @@ func ChunkifyCode(code []byte) ChunkedCode { return chunks } -// NewBinaryNode creates a new empty binary trie -func NewBinaryNode() BinaryNode { - return Empty{} -} - // BinaryTrie is the implementation of https://eips.ethereum.org/EIPS/eip-7864. type BinaryTrie struct { - root BinaryNode - reader *trie.Reader - tracer *trie.PrevalueTracer + store *nodeStore + reader *trie.Reader + tracer *trie.PrevalueTracer + groupDepth int // Number of levels per serialized group (1-8, default 8) +} + +func (t *BinaryTrie) GroupDepth() int { + return t.groupDepth } // ToDot converts the binary trie to a DOT language representation. Useful for debugging. func (t *BinaryTrie) ToDot() string { - t.root.Hash() - return ToDot(t.root) + t.store.computeHash(t.store.root) + return t.store.toDot(t.store.root, "", "") } // NewBinaryTrie creates a new binary trie. -func NewBinaryTrie(root common.Hash, db database.NodeDatabase) (*BinaryTrie, error) { +// groupDepth specifies the number of levels per serialized group (1-8). +func NewBinaryTrie(root common.Hash, db database.NodeDatabase, groupDepth int) (*BinaryTrie, error) { + if groupDepth < 1 || groupDepth > MaxGroupDepth { + panic("invalid group depth size") + } reader, err := trie.NewReader(root, common.Hash{}, db) if err != nil { return nil, err } t := &BinaryTrie{ - root: NewBinaryNode(), - reader: reader, - tracer: trie.NewPrevalueTracer(), + store: newNodeStore(), + reader: reader, + tracer: trie.NewPrevalueTracer(), + groupDepth: groupDepth, } // Parse the root node if it's not empty if root != types.EmptyBinaryHash && root != types.EmptyRootHash { @@ -146,11 +145,11 @@ func NewBinaryTrie(root common.Hash, db database.NodeDatabase) (*BinaryTrie, err if err != nil { return nil, err } - node, err := DeserializeNode(blob, 0) + ref, err := t.store.deserializeNodeWithHash(blob, 0, root) if err != nil { return nil, err } - t.root = node + t.store.root = ref } return t, nil } @@ -179,29 +178,18 @@ func (t *BinaryTrie) GetKey(key []byte) []byte { // GetWithHashedKey returns the value, assuming that the key has already // been hashed. func (t *BinaryTrie) GetWithHashedKey(key []byte) ([]byte, error) { - return t.root.Get(key, t.nodeResolver) + return t.store.Get(key, t.nodeResolver) } // GetAccount returns the account information for the given address. func (t *BinaryTrie) GetAccount(addr common.Address) (*types.StateAccount, error) { var ( - values [][]byte - err error - acc = &types.StateAccount{} - key = GetBinaryTreeKey(addr, zero[:]) + err error + acc = &types.StateAccount{} + key = GetBinaryTreeKey(addr, zero[:]) ) - switch r := t.root.(type) { - case *InternalNode: - values, err = r.GetValuesAtStem(key[:StemSize], t.nodeResolver) - case *StemNode: - values = r.Values - case Empty: - return nil, nil - default: - // This will cover HashedNode but that should be fine since the - // root node should always be resolved. - return nil, errInvalidRootType - } + + values, err := t.store.GetValuesAtStem(key[:StemSize], t.nodeResolver) if err != nil { return nil, fmt.Errorf("GetAccount (%x) error: %v", addr, err) } @@ -219,10 +207,12 @@ func (t *BinaryTrie) GetAccount(addr common.Address) (*types.StateAccount, error return nil, nil } - // If the account has been deleted, then values[10] will be 0 and not nil. If it has - // been recreated after that, then its code keccak will NOT be 0. So return `nil` if - // the nonce, and values[10], and code keccak is 0. - if bytes.Equal(values[BasicDataLeafKey], zero[:]) && len(values) > 10 && len(values[10]) > 0 && bytes.Equal(values[CodeHashLeafKey], zero[:]) { + // If the account has been deleted, BasicData and CodeHash will both be + // 32-byte zero blobs (not nil). If the account is recreated afterwards, + // UpdateAccount overwrites BasicData and CodeHash with non-zero values, + // so this branch won't activate. + if bytes.Equal(values[BasicDataLeafKey], zero[:]) && + bytes.Equal(values[CodeHashLeafKey], zero[:]) { return nil, nil } @@ -239,13 +229,12 @@ func (t *BinaryTrie) GetAccount(addr common.Address) (*types.StateAccount, error // not be modified by the caller. If a node was not found in the database, a // trie.MissingNodeError is returned. func (t *BinaryTrie) GetStorage(addr common.Address, key []byte) ([]byte, error) { - return t.root.Get(GetBinaryTreeKey(addr, key), t.nodeResolver) + return t.store.Get(GetBinaryTreeKeyStorageSlot(addr, key), t.nodeResolver) } // UpdateAccount updates the account information for the given address. func (t *BinaryTrie) UpdateAccount(addr common.Address, acc *types.StateAccount, codeLen int) error { var ( - err error basicData [HashSize]byte values = make([][]byte, StemNodeWidth) stem = GetBinaryTreeKey(addr, zero[:]) @@ -266,15 +255,12 @@ func (t *BinaryTrie) UpdateAccount(addr common.Address, acc *types.StateAccount, values[BasicDataLeafKey] = basicData[:] values[CodeHashLeafKey] = acc.CodeHash[:] - t.root, err = t.root.InsertValuesAtStem(stem, values, t.nodeResolver, 0) - return err + return t.store.InsertValuesAtStem(stem, values, t.nodeResolver) } // UpdateStem updates the values for the given stem key. func (t *BinaryTrie) UpdateStem(key []byte, values [][]byte) error { - var err error - t.root, err = t.root.InsertValuesAtStem(key, values, t.nodeResolver, 0) - return err + return t.store.InsertValuesAtStem(key, values, t.nodeResolver) } // UpdateStorage associates key with value in the trie. If value has length zero, any @@ -289,36 +275,43 @@ func (t *BinaryTrie) UpdateStorage(address common.Address, key, value []byte) er } else { copy(v[HashSize-len(value):], value[:]) } - root, err := t.root.Insert(k, v[:], t.nodeResolver, 0) + err := t.store.Insert(k, v[:], t.nodeResolver) if err != nil { return fmt.Errorf("UpdateStorage (%x) error: %v", address, err) } - t.root = root return nil } -// DeleteAccount is a no-op as it is disabled in stateless. +// DeleteAccount erases an account by overwriting the account +// descriptors with 0s. func (t *BinaryTrie) DeleteAccount(addr common.Address) error { - return nil + var ( + values = make([][]byte, StemNodeWidth) + stem = GetBinaryTreeKey(addr, zero[:]) + ) + // Clear BasicData (nonce, balance, code size) and CodeHash. + values[BasicDataLeafKey] = zero[:] + values[CodeHashLeafKey] = zero[:] + + return t.store.InsertValuesAtStem(stem, values, t.nodeResolver) } // DeleteStorage removes any existing value for key from the trie. If a node was not // found in the database, a trie.MissingNodeError is returned. func (t *BinaryTrie) DeleteStorage(addr common.Address, key []byte) error { - k := GetBinaryTreeKey(addr, key) + k := GetBinaryTreeKeyStorageSlot(addr, key) var zero [HashSize]byte - root, err := t.root.Insert(k, zero[:], t.nodeResolver, 0) + err := t.store.Insert(k, zero[:], t.nodeResolver) if err != nil { return fmt.Errorf("DeleteStorage (%x) error: %v", addr, err) } - t.root = root return nil } // Hash returns the root hash of the trie. It does not write to the database and // can be used even if the trie doesn't have one. func (t *BinaryTrie) Hash() common.Hash { - return t.root.Hash() + return t.store.computeHash(t.store.root) } // Commit writes all nodes to the trie's memory database, tracking the internal @@ -326,15 +319,12 @@ func (t *BinaryTrie) Hash() common.Hash { func (t *BinaryTrie) Commit(_ bool) (common.Hash, *trienode.NodeSet) { nodeset := trienode.NewNodeSet(common.Hash{}) - // The root can be any type of BinaryNode (InternalNode, StemNode, etc.) - err := t.root.CollectNodes(nil, func(path []byte, node BinaryNode) { - serialized := SerializeNode(node) - nodeset.AddNode(path, trienode.NewNodeWithPrev(node.Hash(), serialized, t.tracer.Get(path))) - }) - if err != nil { - panic(fmt.Errorf("CollectNodes failed: %v", err)) - } - // Serialize root commitment form + // Pre-size the path buffer: collectNodes reuses it in-place via + // append/truncate; 32 covers typical binary-trie depth without regrowth. + pathBuf := make([]byte, 0, 32) + t.store.collectNodes(t.store.root, pathBuf, func(path []byte, hash common.Hash, serialized []byte) { + nodeset.AddNode(path, trienode.NewNodeWithPrev(hash, serialized, t.tracer.Get(path))) + }, t.groupDepth) return t.Hash(), nodeset } @@ -358,14 +348,15 @@ func (t *BinaryTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error { // Copy creates a deep copy of the trie. func (t *BinaryTrie) Copy() *BinaryTrie { return &BinaryTrie{ - root: t.root.Copy(), - reader: t.reader, - tracer: t.tracer.Copy(), + store: t.store.Copy(), + reader: t.reader, + tracer: t.tracer.Copy(), + groupDepth: t.groupDepth, } } -// IsVerkle returns true if the trie is a Verkle tree. -func (t *BinaryTrie) IsVerkle() bool { +// IsUBT returns true if the trie is a Verkle tree. +func (t *BinaryTrie) IsUBT() bool { // TODO @gballet This is technically NOT a verkle tree, but it has the same // behavior and basic structure, so for all intents and purposes, it can be // treated as such. Rename this when verkle gets removed. @@ -387,14 +378,13 @@ func (t *BinaryTrie) UpdateContractCode(addr common.Address, codeHash common.Has if groupOffset == 0 /* start of new group */ || chunknr == 0 /* first chunk in header group */ { values = make([][]byte, StemNodeWidth) var offset [HashSize]byte - binary.LittleEndian.PutUint64(offset[24:], chunknr+128) + binary.BigEndian.PutUint64(offset[24:], chunknr+128) key = GetBinaryTreeKey(addr, offset[:]) } values[groupOffset] = chunks[i : i+HashSize] if groupOffset == StemNodeWidth-1 || len(chunks)-i <= HashSize { err = t.UpdateStem(key[:StemSize], values) - if err != nil { return fmt.Errorf("UpdateContractCode (addr=%x) error: %w", addr[:], err) } @@ -427,5 +417,5 @@ func (t *BinaryTrie) PrefetchStorage(addr common.Address, keys [][]byte) error { // Witness returns a set containing all trie nodes that have been accessed. func (t *BinaryTrie) Witness() map[string][]byte { - panic("not implemented") + return t.tracer.Values() } diff --git a/trie/bintrie/trie_test.go b/trie/bintrie/trie_test.go index ca02cfaa1f3a..8b7d9e46d607 100644 --- a/trie/bintrie/trie_test.go +++ b/trie/bintrie/trie_test.go @@ -22,6 +22,9 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/trie" + "github.com/holiman/uint256" ) var ( @@ -34,147 +37,130 @@ var ( ) func TestSingleEntry(t *testing.T) { - tree := NewBinaryNode() - tree, err := tree.Insert(zeroKey[:], oneKey[:], nil, 0) - if err != nil { + s := newNodeStore() + if err := s.Insert(zeroKey[:], oneKey[:], nil); err != nil { t.Fatal(err) } - if tree.GetHeight() != 1 { + if s.getHeight(s.root) != 1 { t.Fatal("invalid depth") } expected := common.HexToHash("aab1060e04cb4f5dc6f697ae93156a95714debbf77d54238766adc5709282b6f") - got := tree.Hash() + got := s.Hash() if got != expected { t.Fatalf("invalid tree root, got %x, want %x", got, expected) } } func TestTwoEntriesDiffFirstBit(t *testing.T) { - var err error - tree := NewBinaryNode() - tree, err = tree.Insert(zeroKey[:], oneKey[:], nil, 0) - if err != nil { + s := newNodeStore() + if err := s.Insert(zeroKey[:], oneKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(common.HexToHash("8000000000000000000000000000000000000000000000000000000000000000").Bytes(), twoKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("8000000000000000000000000000000000000000000000000000000000000000").Bytes(), twoKey[:], nil); err != nil { t.Fatal(err) } - if tree.GetHeight() != 2 { + if s.getHeight(s.root) != 2 { t.Fatal("invalid height") } - if tree.Hash() != common.HexToHash("dfc69c94013a8b3c65395625a719a87534a7cfd38719251ad8c8ea7fe79f065e") { + if s.Hash() != common.HexToHash("dfc69c94013a8b3c65395625a719a87534a7cfd38719251ad8c8ea7fe79f065e") { t.Fatal("invalid tree root") } } func TestOneStemColocatedValues(t *testing.T) { - var err error - tree := NewBinaryNode() - tree, err = tree.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000003").Bytes(), oneKey[:], nil, 0) - if err != nil { + s := newNodeStore() + if err := s.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000003").Bytes(), oneKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000004").Bytes(), twoKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000004").Bytes(), twoKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000009").Bytes(), threeKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000009").Bytes(), threeKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(common.HexToHash("00000000000000000000000000000000000000000000000000000000000000FF").Bytes(), fourKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("00000000000000000000000000000000000000000000000000000000000000FF").Bytes(), fourKey[:], nil); err != nil { t.Fatal(err) } - if tree.GetHeight() != 1 { + if s.getHeight(s.root) != 1 { t.Fatal("invalid height") } } func TestTwoStemColocatedValues(t *testing.T) { - var err error - tree := NewBinaryNode() + s := newNodeStore() // stem: 0...0 - tree, err = tree.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000003").Bytes(), oneKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000003").Bytes(), oneKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000004").Bytes(), twoKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("0000000000000000000000000000000000000000000000000000000000000004").Bytes(), twoKey[:], nil); err != nil { t.Fatal(err) } // stem: 10...0 - tree, err = tree.Insert(common.HexToHash("8000000000000000000000000000000000000000000000000000000000000003").Bytes(), oneKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("8000000000000000000000000000000000000000000000000000000000000003").Bytes(), oneKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(common.HexToHash("8000000000000000000000000000000000000000000000000000000000000004").Bytes(), twoKey[:], nil, 0) - if err != nil { + if err := s.Insert(common.HexToHash("8000000000000000000000000000000000000000000000000000000000000004").Bytes(), twoKey[:], nil); err != nil { t.Fatal(err) } - if tree.GetHeight() != 2 { + if s.getHeight(s.root) != 2 { t.Fatal("invalid height") } } func TestTwoKeysMatchFirst42Bits(t *testing.T) { - var err error - tree := NewBinaryNode() + s := newNodeStore() // key1 and key 2 have the same prefix of 42 bits (b0*42+b1+b1) and differ after. key1 := common.HexToHash("0000000000C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0").Bytes() key2 := common.HexToHash("0000000000E00000000000000000000000000000000000000000000000000000").Bytes() - tree, err = tree.Insert(key1, oneKey[:], nil, 0) - if err != nil { + if err := s.Insert(key1, oneKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(key2, twoKey[:], nil, 0) - if err != nil { + if err := s.Insert(key2, twoKey[:], nil); err != nil { t.Fatal(err) } - if tree.GetHeight() != 1+42+1 { + if s.getHeight(s.root) != 1+42+1 { t.Fatal("invalid height") } } + func TestInsertDuplicateKey(t *testing.T) { - var err error - tree := NewBinaryNode() - tree, err = tree.Insert(oneKey[:], oneKey[:], nil, 0) - if err != nil { + s := newNodeStore() + if err := s.Insert(oneKey[:], oneKey[:], nil); err != nil { t.Fatal(err) } - tree, err = tree.Insert(oneKey[:], twoKey[:], nil, 0) - if err != nil { + if err := s.Insert(oneKey[:], twoKey[:], nil); err != nil { t.Fatal(err) } - if tree.GetHeight() != 1 { + if s.getHeight(s.root) != 1 { t.Fatal("invalid height") } // Verify that the value is updated - if !bytes.Equal(tree.(*StemNode).Values[1], twoKey[:]) { - t.Fatal("invalid height") + v, err := s.Get(oneKey[:], nil) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(v, twoKey[:]) { + t.Fatal("value not updated") } } + func TestLargeNumberOfEntries(t *testing.T) { - var err error - tree := NewBinaryNode() + s := newNodeStore() for i := range StemNodeWidth { var key [HashSize]byte key[0] = byte(i) - tree, err = tree.Insert(key[:], ffKey[:], nil, 0) - if err != nil { + if err := s.Insert(key[:], ffKey[:], nil); err != nil { t.Fatal(err) } } - height := tree.GetHeight() + height := s.getHeight(s.root) if height != 1+8 { t.Fatalf("invalid height, wanted %d, got %d", 1+8, height) } } func TestMerkleizeMultipleEntries(t *testing.T) { - var err error - tree := NewBinaryNode() + s := newNodeStore() keys := [][]byte{ zeroKey[:], common.HexToHash("8000000000000000000000000000000000000000000000000000000000000000").Bytes(), @@ -184,14 +170,692 @@ func TestMerkleizeMultipleEntries(t *testing.T) { for i, key := range keys { var v [HashSize]byte binary.LittleEndian.PutUint64(v[:8], uint64(i)) - tree, err = tree.Insert(key, v[:], nil, 0) - if err != nil { + if err := s.Insert(key, v[:], nil); err != nil { t.Fatal(err) } } - got := tree.Hash() + got := s.Hash() expected := common.HexToHash("9317155862f7a3867660ddd0966ff799a3d16aa4df1e70a7516eaa4a675191b5") if got != expected { t.Fatalf("invalid root, expected=%x, got = %x", expected, got) } } + +// TestStorageRoundTrip verifies that GetStorage and DeleteStorage use the same +// key mapping as UpdateStorage (GetBinaryTreeKeyStorageSlot). This is a regression +// test: previously GetStorage and DeleteStorage used GetBinaryTreeKey directly, +// which produced different tree keys and broke the read/delete path. +func TestStorageRoundTrip(t *testing.T) { + tracer := trie.NewPrevalueTracer() + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: tracer, + } + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + + // Create an account first so the root becomes an InternalNode, + // which is the realistic state when storage operations happen. + acc := &types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(1000), + CodeHash: common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").Bytes(), + } + if err := tr.UpdateAccount(addr, acc, 0); err != nil { + t.Fatalf("UpdateAccount error: %v", err) + } + + // Test main storage slots (key[31] >= 64 or key[:31] != 0). + // These produce a different stem than the account data, so after + // UpdateAccount + UpdateStorage the root is an InternalNode. + // Note: header slots (key[31] < 64, key[:31] == 0) share the same + // stem as account data and are covered by GetAccount/UpdateAccount path. + slots := []common.Hash{ + common.HexToHash("00000000000000000000000000000000000000000000000000000000000000FF"), // main storage (slot 255) + common.HexToHash("0100000000000000000000000000000000000000000000000000000000000001"), // main storage (non-zero prefix) + } + val := common.TrimLeftZeroes(common.HexToHash("00000000000000000000000000000000000000000000000000000000deadbeef").Bytes()) + + for _, slot := range slots { + // Write + if err := tr.UpdateStorage(addr, slot[:], val); err != nil { + t.Fatalf("UpdateStorage(%x) error: %v", slot, err) + } + // Read back + got, err := tr.GetStorage(addr, slot[:]) + if err != nil { + t.Fatalf("GetStorage(%x) error: %v", slot, err) + } + if len(got) == 0 { + t.Fatalf("GetStorage(%x) returned empty, expected value", slot) + } + // Verify value (right-justified in 32 bytes) + var expected [HashSize]byte + copy(expected[HashSize-len(val):], val) + if !bytes.Equal(got, expected[:]) { + t.Fatalf("GetStorage(%x) = %x, want %x", slot, got, expected) + } + // Delete + if err := tr.DeleteStorage(addr, slot[:]); err != nil { + t.Fatalf("DeleteStorage(%x) error: %v", slot, err) + } + // Verify deleted (should read as zero, not the old value) + got, err = tr.GetStorage(addr, slot[:]) + if err != nil { + t.Fatalf("GetStorage(%x) after delete error: %v", slot, err) + } + if len(got) > 0 && !bytes.Equal(got, zero[:]) { + t.Fatalf("GetStorage(%x) after delete = %x, expected zero", slot, got) + } + } +} + +// newEmptyTestTrie creates a fresh BinaryTrie with an empty root and a +// default prevalue tracer. Use this for tests that populate the trie +// incrementally via Update*; for tests that want a pre-populated trie with +// a fixed entry set, use makeTrie (in iterator_test.go) instead. +func newEmptyTestTrie(t *testing.T) *BinaryTrie { + t.Helper() + return &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + } +} + +// makeAccount constructs a StateAccount with the given fields. The Root is +// zeroed out because the bintrie has no per-account storage root. +func makeAccount(nonce uint64, balance uint64, codeHash common.Hash) *types.StateAccount { + return &types.StateAccount{ + Nonce: nonce, + Balance: uint256.NewInt(balance), + CodeHash: codeHash.Bytes(), + } +} + +// TestDeleteAccountRoundTrip verifies the basic delete path: create an +// account, read it back, delete it, confirm subsequent reads return nil. +// Regression test for the no-op DeleteAccount bug where the deletion was +// silently ignored and the old values remained in the trie. +func TestDeleteAccountRoundTrip(t *testing.T) { + tr := newEmptyTestTrie(t) + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + codeHash := common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") + + // Create: write account, verify round-trip. + acc := makeAccount(42, 1000, codeHash) + if err := tr.UpdateAccount(addr, acc, 0); err != nil { + t.Fatalf("UpdateAccount: %v", err) + } + got, err := tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount: %v", err) + } + if got == nil { + t.Fatal("GetAccount returned nil after UpdateAccount") + } + if got.Nonce != 42 { + t.Fatalf("Nonce: got %d, want 42", got.Nonce) + } + if got.Balance.Uint64() != 1000 { + t.Fatalf("Balance: got %s, want 1000", got.Balance) + } + if !bytes.Equal(got.CodeHash, codeHash[:]) { + t.Fatalf("CodeHash: got %x, want %x", got.CodeHash, codeHash) + } + + // Delete: verify GetAccount returns nil afterwards. + if err := tr.DeleteAccount(addr); err != nil { + t.Fatalf("DeleteAccount: %v", err) + } + got, err = tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount after delete: %v", err) + } + if got != nil { + t.Fatalf("GetAccount after delete: got %+v, want nil", got) + } +} + +// TestDeleteAccountOnMissingAccount verifies that deleting an account that +// was never created does not error and subsequent reads still return nil. +func TestDeleteAccountOnMissingAccount(t *testing.T) { + tr := newEmptyTestTrie(t) + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + + // Delete without any prior create. Should not panic or error on an + // empty root, and GetAccount should still return nil. + if err := tr.DeleteAccount(addr); err != nil { + t.Fatalf("DeleteAccount on empty trie: %v", err) + } + got, err := tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount after delete on empty trie: %v", err) + } + if got != nil { + t.Fatalf("GetAccount on deleted missing account: got %+v, want nil", got) + } +} + +// TestDeleteAccountPreservesOtherAccounts verifies that deleting one account +// does not affect accounts at different stems. +func TestDeleteAccountPreservesOtherAccounts(t *testing.T) { + tr := newEmptyTestTrie(t) + addrA := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + addrB := common.HexToAddress("0xabcdef1234567890abcdef1234567890abcdef12") + codeHashA := common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") + codeHashB := common.HexToHash("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff0102030405060708090a0b0c0d0e0f10") + + // Create two distinct accounts. + if err := tr.UpdateAccount(addrA, makeAccount(1, 100, codeHashA), 0); err != nil { + t.Fatalf("UpdateAccount(A): %v", err) + } + if err := tr.UpdateAccount(addrB, makeAccount(2, 200, codeHashB), 0); err != nil { + t.Fatalf("UpdateAccount(B): %v", err) + } + + // Delete A. + if err := tr.DeleteAccount(addrA); err != nil { + t.Fatalf("DeleteAccount(A): %v", err) + } + + // A should be gone. + if got, err := tr.GetAccount(addrA); err != nil { + t.Fatalf("GetAccount(A): %v", err) + } else if got != nil { + t.Fatalf("GetAccount(A) after delete: got %+v, want nil", got) + } + + // B should still be readable with its original values. + got, err := tr.GetAccount(addrB) + if err != nil { + t.Fatalf("GetAccount(B): %v", err) + } + if got == nil { + t.Fatal("GetAccount(B) returned nil after unrelated delete") + } + if got.Nonce != 2 { + t.Fatalf("Account B Nonce: got %d, want 2", got.Nonce) + } + if got.Balance.Uint64() != 200 { + t.Fatalf("Account B Balance: got %s, want 200", got.Balance) + } + if !bytes.Equal(got.CodeHash, codeHashB[:]) { + t.Fatalf("Account B CodeHash: got %x, want %x", got.CodeHash, codeHashB) + } +} + +// TestDeleteAccountThenRecreate verifies that an account can be deleted and +// then recreated with different values; the second read must return the new +// values, not the stale ones from before deletion. +func TestDeleteAccountThenRecreate(t *testing.T) { + tr := newEmptyTestTrie(t) + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + codeHash1 := common.HexToHash("1111111111111111111111111111111111111111111111111111111111111111") + codeHash2 := common.HexToHash("2222222222222222222222222222222222222222222222222222222222222222") + + // Create. + if err := tr.UpdateAccount(addr, makeAccount(1, 100, codeHash1), 0); err != nil { + t.Fatalf("UpdateAccount #1: %v", err) + } + // Delete. + if err := tr.DeleteAccount(addr); err != nil { + t.Fatalf("DeleteAccount: %v", err) + } + // Recreate with new values. + if err := tr.UpdateAccount(addr, makeAccount(7, 9999, codeHash2), 0); err != nil { + t.Fatalf("UpdateAccount #2: %v", err) + } + // Read: must observe the new values, not the originals. + got, err := tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount: %v", err) + } + if got == nil { + t.Fatal("GetAccount returned nil after recreate") + } + if got.Nonce != 7 { + t.Fatalf("Nonce: got %d, want 7", got.Nonce) + } + if got.Balance.Uint64() != 9999 { + t.Fatalf("Balance: got %s, want 9999", got.Balance) + } + if !bytes.Equal(got.CodeHash, codeHash2[:]) { + t.Fatalf("CodeHash: got %x, want %x", got.CodeHash, codeHash2) + } +} + +// TestDeleteAccountDoesNotAffectMainStorage verifies that DeleteAccount only +// clears the account's BasicData and CodeHash, leaving main storage slots +// untouched. Main storage slots live at different stems entirely (their +// keys route through the non-header branch in GetBinaryTreeKeyStorageSlot), +// so this test exercises the inter-stem isolation. Header-range storage +// slots share the same stem and are covered separately by +// TestDeleteAccountPreservesHeaderStorage. +// +// Wiping storage on self-destruct is a separate concern handled at the +// StateDB level. +func TestDeleteAccountDoesNotAffectMainStorage(t *testing.T) { + tr := newEmptyTestTrie(t) + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + codeHash := common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") + + // Create account. + if err := tr.UpdateAccount(addr, makeAccount(1, 100, codeHash), 0); err != nil { + t.Fatalf("UpdateAccount: %v", err) + } + // Write a main storage slot — i.e. key[31] >= 64 or key[:31] != 0 — so + // it lives at a different stem from the account header. + slot := common.HexToHash("0000000000000000000000000000000000000000000000000000000000000080") + value := common.TrimLeftZeroes(common.HexToHash("00000000000000000000000000000000000000000000000000000000deadbeef").Bytes()) + if err := tr.UpdateStorage(addr, slot[:], value); err != nil { + t.Fatalf("UpdateStorage: %v", err) + } + + // Delete the account. + if err := tr.DeleteAccount(addr); err != nil { + t.Fatalf("DeleteAccount: %v", err) + } + + // Account should be absent. + got, err := tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount after delete: %v", err) + } + if got != nil { + t.Fatalf("GetAccount after delete: got %+v, want nil", got) + } + + // Main storage slot should still be readable — DeleteAccount must not + // have touched it. + stored, err := tr.GetStorage(addr, slot[:]) + if err != nil { + t.Fatalf("GetStorage after DeleteAccount: %v", err) + } + if len(stored) == 0 { + t.Fatal("main storage slot was wiped by DeleteAccount, expected it to survive") + } + var expected [HashSize]byte + copy(expected[HashSize-len(value):], value) + if !bytes.Equal(stored, expected[:]) { + t.Fatalf("main storage slot: got %x, want %x", stored, expected) + } +} + +// TestDeleteAccountPreservesHeaderStorage verifies that DeleteAccount does +// not clobber header-range storage slots (key[31] < 64), which live at the +// SAME stem as BasicData/CodeHash but at offsets 64-127. The safety here +// relies on StemNode.InsertValuesAtStem treating nil entries in the values +// slice as "do not overwrite"; this test pins that invariant so a future +// change cannot silently corrupt slots 0-63 of any contract. +func TestDeleteAccountPreservesHeaderStorage(t *testing.T) { + tr := newEmptyTestTrie(t) + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + codeHash := common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") + + // Create account. + if err := tr.UpdateAccount(addr, makeAccount(1, 100, codeHash), 0); err != nil { + t.Fatalf("UpdateAccount: %v", err) + } + + // Create a second, unrelated account so the root promotes from StemNode + // to InternalNode. BinaryTrie.GetStorage walks via root.Get, which is + // only implemented on InternalNode/Empty — calling it with a StemNode + // root panics. The existing main-storage test gets away with this because + // the main-storage slot lands on a separate stem and forces the same + // promotion implicitly; here we want a same-stem header slot, so the + // promotion has to come from a second account. + other := common.HexToAddress("0xabcdef1234567890abcdef1234567890abcdef12") + if err := tr.UpdateAccount(other, makeAccount(0, 0, common.Hash{}), 0); err != nil { + t.Fatalf("UpdateAccount(other): %v", err) + } + + // Write a header-range storage slot — key[:31] == 0 and key[31] < 64 + // — which routes through the header branch in GetBinaryTreeKeyStorageSlot + // and lands on the same stem as BasicData/CodeHash. + var slot [HashSize]byte + slot[31] = 5 + value := []byte{0xde, 0xad, 0xbe, 0xef} + if err := tr.UpdateStorage(addr, slot[:], value); err != nil { + t.Fatalf("UpdateStorage: %v", err) + } + + // Delete the account. + if err := tr.DeleteAccount(addr); err != nil { + t.Fatalf("DeleteAccount: %v", err) + } + + // Account metadata should be gone. + got, err := tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount after delete: %v", err) + } + if got != nil { + t.Fatalf("GetAccount after delete: got %+v, want nil", got) + } + + // Header storage slot must survive — DeleteAccount only writes offsets + // BasicDataLeafKey, CodeHashLeafKey, and accountDeletedMarkerKey, leaving + // the header-storage offsets (64-127) untouched. + stored, err := tr.GetStorage(addr, slot[:]) + if err != nil { + t.Fatalf("GetStorage after DeleteAccount: %v", err) + } + if len(stored) == 0 { + t.Fatal("header storage slot was wiped by DeleteAccount, expected it to survive") + } + var expected [HashSize]byte + copy(expected[HashSize-len(value):], value) + if !bytes.Equal(stored, expected[:]) { + t.Fatalf("header storage slot: got %x, want %x", stored, expected) + } +} + +func TestDeleteAccountHashIsDeterministic(t *testing.T) { + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + codeHash := common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") + acc := makeAccount(42, 1000, codeHash) + + run := func() common.Hash { + tr := newEmptyTestTrie(t) + if err := tr.UpdateAccount(addr, acc, 0); err != nil { + t.Fatalf("UpdateAccount: %v", err) + } + if err := tr.DeleteAccount(addr); err != nil { + t.Fatalf("DeleteAccount: %v", err) + } + return tr.Hash() + } + + first := run() + second := run() + if first != second { + t.Fatalf("non-deterministic root after Update+Delete: first=%x second=%x", first, second) + } + + empty := newEmptyTestTrie(t).Hash() + if first == empty { + t.Fatalf("post-delete root unexpectedly equals empty-trie root %x", empty) + } +} + +func TestBinaryTrieWitness(t *testing.T) { + tracer := trie.NewPrevalueTracer() + + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: tracer, + } + if w := tr.Witness(); len(w) != 0 { + t.Fatal("expected empty witness for fresh trie") + } + + tracer.Put([]byte("path1"), []byte("blob1")) + tracer.Put([]byte("path2"), []byte("blob2")) + + witness := tr.Witness() + if len(witness) != 2 { + t.Fatalf("expected 2 witness entries, got %d", len(witness)) + } + if !bytes.Equal(witness[string([]byte("path1"))], []byte("blob1")) { + t.Fatal("unexpected witness value for path1") + } + if !bytes.Equal(witness[string([]byte("path2"))], []byte("blob2")) { + t.Fatal("unexpected witness value for path2") + } +} + +// testAccount is a helper that creates a BinaryTrie with a tracer and +// inserts a single account, returning the trie. +func testAccount(t *testing.T, addr common.Address, nonce uint64, balance uint64) *BinaryTrie { + t.Helper() + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + } + acc := &types.StateAccount{ + Nonce: nonce, + Balance: uint256.NewInt(balance), + CodeHash: types.EmptyCodeHash[:], + } + if err := tr.UpdateAccount(addr, acc, 0); err != nil { + t.Fatalf("UpdateAccount error: %v", err) + } + return tr +} + +// TestGetAccountNonMembershipStemRoot verifies that querying a non-existent +// address returns nil when the trie root is a StemNode (single-account trie). +// This is a regression test: previously the StemNode branch in GetAccount +// returned the root's values without verifying the stem. +func TestGetAccountNonMembershipStemRoot(t *testing.T) { + addr := common.HexToAddress("0x1111111111111111111111111111111111111111") + tr := testAccount(t, addr, 42, 100) + + // Verify root is a StemNode (single stem inserted). + if tr.store.root.Kind() != kindStem { + t.Fatalf("expected StemNode root, got kind %d", tr.store.root.Kind()) + } + + // Query a completely different address — must return nil. + other := common.HexToAddress("0x2222222222222222222222222222222222222222") + got, err := tr.GetAccount(other) + if err != nil { + t.Fatalf("GetAccount error: %v", err) + } + if got != nil { + t.Fatalf("expected nil for non-existent account, got nonce=%d balance=%s", got.Nonce, got.Balance) + } + + // Original account must still be retrievable. + got, err = tr.GetAccount(addr) + if err != nil { + t.Fatalf("GetAccount(original) error: %v", err) + } + if got == nil { + t.Fatal("expected original account, got nil") + } + if got.Nonce != 42 { + t.Fatalf("expected nonce=42, got %d", got.Nonce) + } +} + +// TestGetAccountNonMembershipInternalRoot verifies that querying a non-existent +// address returns nil when the trie root is an InternalNode (multi-account trie). +func TestGetAccountNonMembershipInternalRoot(t *testing.T) { + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + } + + // Insert two accounts whose binary tree keys have different first bits + // so the root splits into an InternalNode. + addr1 := common.HexToAddress("0x1111111111111111111111111111111111111111") + addr2 := common.HexToAddress("0x9999999999999999999999999999999999999999") + for _, addr := range []common.Address{addr1, addr2} { + acc := &types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(1), + CodeHash: types.EmptyCodeHash[:], + } + if err := tr.UpdateAccount(addr, acc, 0); err != nil { + t.Fatalf("UpdateAccount error: %v", err) + } + } + + // Verify root is an InternalNode. + if tr.store.root.Kind() != kindInternal { + t.Fatalf("expected InternalNode root, got kind %d", tr.store.root.Kind()) + } + + // Query a non-existent address — must return nil. + other := common.HexToAddress("0x5555555555555555555555555555555555555555") + got, err := tr.GetAccount(other) + if err != nil { + t.Fatalf("GetAccount error: %v", err) + } + if got != nil { + t.Fatalf("expected nil for non-existent account, got nonce=%d", got.Nonce) + } +} + +// TestGetStorageNonMembershipStemRoot verifies that querying storage for a +// non-existent address returns nil when the root is a StemNode. This is a +// regression test: previously StemNode.Get panicked unconditionally. +func TestGetStorageNonMembershipStemRoot(t *testing.T) { + addr := common.HexToAddress("0x1111111111111111111111111111111111111111") + tr := testAccount(t, addr, 1, 100) + + // Verify root is a StemNode. + if tr.store.root.Kind() != kindStem { + t.Fatalf("expected StemNode root, got kind %d", tr.store.root.Kind()) + } + + // Query storage for a different address — must return nil, not panic. + other := common.HexToAddress("0x2222222222222222222222222222222222222222") + slot := common.HexToHash("0x01") + got, err := tr.GetStorage(other, slot[:]) + if err != nil { + t.Fatalf("GetStorage error: %v", err) + } + if len(got) > 0 && !bytes.Equal(got, zero[:]) { + t.Fatalf("expected nil/zero for non-existent storage, got %x", got) + } +} + +// TestGetStorageNonMembershipInternalRoot verifies that querying storage for a +// non-existent address returns nil when the root is an InternalNode. +func TestGetStorageNonMembershipInternalRoot(t *testing.T) { + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + } + + addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + acc := &types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(1000), + CodeHash: types.EmptyCodeHash[:], + } + if err := tr.UpdateAccount(addr, acc, 0); err != nil { + t.Fatalf("UpdateAccount error: %v", err) + } + + // Add a storage slot so the root becomes an InternalNode (storage + // slots use a different stem than account data). + slot := common.HexToHash("0xFF") + val := common.TrimLeftZeroes(common.HexToHash("0xdeadbeef").Bytes()) + if err := tr.UpdateStorage(addr, slot[:], val); err != nil { + t.Fatalf("UpdateStorage error: %v", err) + } + + if tr.store.root.Kind() != kindInternal { + t.Fatalf("expected InternalNode root, got kind %d", tr.store.root.Kind()) + } + + // Query storage for a non-existent address — must return nil. + other := common.HexToAddress("0x9999999999999999999999999999999999999999") + got, err := tr.GetStorage(other, slot[:]) + if err != nil { + t.Fatalf("GetStorage error: %v", err) + } + if len(got) > 0 && !bytes.Equal(got, zero[:]) { + t.Fatalf("expected nil/zero for non-existent storage, got %x", got) + } +} + +// TestCommitSkipCleanSubtrees verifies that CollectNodes short-circuits on +// clean subtrees. First Commit flushes every resolved node; a follow-up +// Commit with no modifications flushes nothing; a single-leaf modification +// flushes only the root-to-leaf path. +func TestCommitSkipCleanSubtrees(t *testing.T) { + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + groupDepth: 1, + } + const n = 200 + key := func(i int) [HashSize]byte { + var k [HashSize]byte + binary.BigEndian.PutUint64(k[:8], uint64(i+1)*0x9e3779b97f4a7c15) + binary.BigEndian.PutUint64(k[8:16], uint64(i+1)*0xc2b2ae3d27d4eb4f) + binary.BigEndian.PutUint64(k[16:24], uint64(i+1)*0x165667b19e3779f9) + binary.BigEndian.PutUint64(k[24:32], uint64(i+1)*0x85ebca77c2b2ae63) + return k + } + for i := range n { + k := key(i) + var v [HashSize]byte + binary.BigEndian.PutUint64(v[24:], uint64(i+1)) + if err := tr.store.Insert(k[:], v[:], nil); err != nil { + t.Fatalf("Insert %d: %v", i, err) + } + } + + _, ns1 := tr.Commit(false) + if len(ns1.Nodes) == 0 { + t.Fatal("first Commit produced empty NodeSet") + } + + _, nsNoop := tr.Commit(false) + if len(nsNoop.Nodes) != 0 { + t.Fatalf("no-op Commit: expected empty NodeSet, got %d", len(nsNoop.Nodes)) + } + + // Modify a single leaf — only the root-to-leaf path should flush. + k := key(n / 2) + var newVal [HashSize]byte + newVal[0] = 0xff + if err := tr.store.Insert(k[:], newVal[:], nil); err != nil { + t.Fatalf("Insert (modify): %v", err) + } + _, ns2 := tr.Commit(false) + if len(ns2.Nodes) == 0 { + t.Fatal("modified Commit produced empty NodeSet") + } + if len(ns2.Nodes) > 32 { + t.Fatalf("modified Commit: expected ≤32 nodes (path+stem), got %d", len(ns2.Nodes)) + } + if len(ns2.Nodes) >= len(ns1.Nodes) { + t.Fatalf("expected second NodeSet (%d) to be smaller than first (%d)", len(ns2.Nodes), len(ns1.Nodes)) + } +} + +// BenchmarkCollectNodesSparseWrite measures Commit cost when one leaf +// changes per block — the common case for state updates. After warm-up +// (populate + initial Commit), each iteration modifies a single leaf and +// re-Commits. Matches the shape of the same-named benchmark on master so +// the two trees can be benchstat'd directly. +func BenchmarkCollectNodesSparseWrite(b *testing.B) { + const n = 10_000 + tr := &BinaryTrie{ + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + } + keys := make([][HashSize]byte, n) + for i := range n { + binary.BigEndian.PutUint64(keys[i][:8], uint64(i+1)*0x9e3779b97f4a7c15) + binary.BigEndian.PutUint64(keys[i][8:16], uint64(i+1)*0xc2b2ae3d27d4eb4f) + binary.BigEndian.PutUint64(keys[i][16:24], uint64(i+1)*0x165667b19e3779f9) + binary.BigEndian.PutUint64(keys[i][24:32], uint64(i+1)*0x85ebca77c2b2ae63) + var v [HashSize]byte + binary.BigEndian.PutUint64(v[24:], uint64(i+1)) + if err := tr.store.Insert(keys[i][:], v[:], nil); err != nil { + b.Fatalf("warmup Insert %d: %v", i, err) + } + } + _, _ = tr.Commit(false) // warmup flush + + var newVal [HashSize]byte + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + idx := i % n + binary.BigEndian.PutUint64(newVal[24:], uint64(i+1)) + if err := tr.store.Insert(keys[idx][:], newVal[:], nil); err != nil { + b.Fatalf("iter %d Insert: %v", i, err) + } + _, ns := tr.Commit(false) + if len(ns.Nodes) == 0 { + b.Fatalf("iter %d: empty NodeSet", i) + } + } +} diff --git a/trie/inspect.go b/trie/inspect.go new file mode 100644 index 000000000000..d7ca9ace63e7 --- /dev/null +++ b/trie/inspect.go @@ -0,0 +1,930 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package trie + +import ( + "bufio" + "bytes" + "cmp" + "container/heap" + "encoding/binary" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "slices" + "sort" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/internal/tablewriter" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/triedb/database" + "golang.org/x/sync/errgroup" + "golang.org/x/sync/semaphore" +) + +const ( + inspectDumpRecordSize = 32 + trieStatLevels*(3*4+8) + inspectDefaultTopN = 10 + inspectParallelism = int64(16) +) + +// inspector is used by the inner inspect function to coordinate across threads. +type inspector struct { + triedb database.NodeDatabase + root common.Hash + + config *InspectConfig + accountStat *LevelStats + + sem *semaphore.Weighted + + // Pass 1: dump file writer. + dumpMu sync.Mutex + dumpBuf *bufio.Writer + dumpFile *os.File + storageRecordsWritten atomic.Uint64 + + errMu sync.Mutex + err error +} + +// InspectConfig is a set of options to control inspection and format the output. +// TopN determines the maximum number of entries retained for each top-list. +// Path controls optional JSON output. DumpPath controls the pass-1 dump location. +type InspectConfig struct { + NoStorage bool + TopN int + Path string + DumpPath string +} + +// Inspect walks the trie with the given root and records the number and type of +// nodes at each depth. Storage trie stats are streamed to disk in fixed-size +// records, then summarized in a second pass. +func Inspect(triedb database.NodeDatabase, root common.Hash, config *InspectConfig) error { + trie, err := New(TrieID(root), triedb) + if err != nil { + return fmt.Errorf("fail to open trie %s: %w", root, err) + } + config = normalizeInspectConfig(config) + + dumpFile, err := os.OpenFile(config.DumpPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644) + if err != nil { + return fmt.Errorf("failed to create trie dump %s: %w", config.DumpPath, err) + } + in := inspector{ + triedb: triedb, + root: root, + config: config, + accountStat: NewLevelStats(), + sem: semaphore.NewWeighted(inspectParallelism), + dumpBuf: bufio.NewWriterSize(dumpFile, 1<<20), + dumpFile: dumpFile, + } + + // Start progress reporter + start := time.Now() + done := make(chan struct{}) + go func() { + ticker := time.NewTicker(8 * time.Second) + defer ticker.Stop() + for { + select { + case <-ticker.C: + accountNodes := in.accountStat.TotalNodes() + storageRecords := in.storageRecordsWritten.Load() + log.Info("Inspecting trie", + "accountNodes", accountNodes, + "storageRecords", storageRecords, + "elapsed", common.PrettyDuration(time.Since(start))) + case <-done: + return + } + } + }() + + in.recordRootSize(trie, root, in.accountStat) + in.inspect(trie, trie.root, 0, []byte{}, in.accountStat) + + // inspect is synchronous: it waits for all spawned goroutines in its + // subtree before returning, so no additional wait is needed here. + + // Persist account trie stats as the sentinel record. + in.writeDumpRecord(common.Hash{}, in.accountStat) + if err := in.closeDump(); err != nil { + in.setError(err) + } + + // Stop progress reporter + close(done) + + if err := in.getError(); err != nil { + return err + } + return Summarize(config.DumpPath, config) +} + +// InspectContract inspects the on-disk footprint of a single contract. +// It reports snapshot storage (slot count + size) and storage trie node +// statistics (node type breakdown and per-depth distribution). +func InspectContract(triedb database.NodeDatabase, db ethdb.Database, stateRoot common.Hash, address common.Address) error { + // Resolve account from the state trie. + accountHash := crypto.Keccak256Hash(address.Bytes()) + accountTrie, err := New(TrieID(stateRoot), triedb) + if err != nil { + return fmt.Errorf("failed to open account trie: %w", err) + } + accountRLP, err := accountTrie.Get(crypto.Keccak256(address.Bytes())) + if err != nil { + return fmt.Errorf("failed to read account: %w", err) + } + if accountRLP == nil { + return fmt.Errorf("account not found: %s", address) + } + var account types.StateAccount + if err := rlp.DecodeBytes(accountRLP, &account); err != nil { + return fmt.Errorf("failed to decode account: %w", err) + } + if account.Root == (common.Hash{}) || account.Root == types.EmptyRootHash { + return fmt.Errorf("account %s has no storage", address) + } + + // Look up account snapshot. + accountData := rawdb.ReadAccountSnapshot(db, accountHash) + + // Run trie walk + snap iteration in parallel. + var ( + snapSlots atomic.Uint64 + snapSize atomic.Uint64 + g errgroup.Group + start = time.Now() + ) + + // Goroutine 1: Snapshot storage iteration. + g.Go(func() error { + prefix := append(rawdb.SnapshotStoragePrefix, accountHash.Bytes()...) + it := db.NewIterator(prefix, nil) + defer it.Release() + + for it.Next() { + if !bytes.HasPrefix(it.Key(), prefix) { + break + } + snapSlots.Add(1) + snapSize.Add(uint64(len(it.Key()) + len(it.Value()))) + } + return it.Error() + }) + + // Goroutine 2: Storage trie walk using the existing inspector. + storageStat := NewLevelStats() + g.Go(func() error { + owner := accountHash + storage, err := New(StorageTrieID(stateRoot, owner, account.Root), triedb) + if err != nil { + return fmt.Errorf("failed to open storage trie: %w", err) + } + in := &inspector{ + triedb: triedb, + root: stateRoot, + config: &InspectConfig{NoStorage: true}, + accountStat: NewLevelStats(), // unused, but needed by inspector + sem: semaphore.NewWeighted(inspectParallelism), + dumpBuf: bufio.NewWriter(io.Discard), + } + + in.recordRootSize(storage, account.Root, storageStat) + in.inspect(storage, storage.root, 0, []byte{}, storageStat) + + if err := in.getError(); err != nil { + return err + } + return nil + }) + + // Progress reporter. + done := make(chan struct{}) + go func() { + ticker := time.NewTicker(8 * time.Second) + defer ticker.Stop() + for { + select { + case <-ticker.C: + log.Info("Inspecting contract", + "snapSlots", snapSlots.Load(), + "trieNodes", storageStat.TotalNodes(), + "elapsed", common.PrettyDuration(time.Since(start))) + case <-done: + return + } + } + }() + + if err := g.Wait(); err != nil { + close(done) + return err + } + close(done) + + // Display results. + fmt.Printf("\n=== Contract Inspection: %s ===\n", address) + fmt.Printf("Account hash: %s\n\n", accountHash) + + if len(accountData) == 0 { + fmt.Println("Account snapshot: not found") + } else { + fmt.Printf("Account snapshot: %s\n", common.StorageSize(len(accountData))) + } + + fmt.Printf("Snapshot storage: %d slots (%s)\n", + snapSlots.Load(), common.StorageSize(snapSize.Load())) + + // Compute trie totals from LevelStats. + var trieTotal, trieSize uint64 + for i := 0; i < trieStatLevels; i++ { + short, full, value, size := storageStat.level[i].load() + trieTotal += short + full + value + trieSize += size + } + fmt.Printf("Storage trie: %d nodes (%s)\n", trieTotal, common.StorageSize(trieSize)) + + // Depth distribution table with node type columns. + fmt.Println("\nStorage Trie Depth Distribution:") + b := new(strings.Builder) + table := tablewriter.NewWriter(b) + table.SetHeader([]string{"Depth", "Short", "Full", "Value", "Nodes", "Size"}) + for i := 0; i < trieStatLevels; i++ { + short, full, value, size := storageStat.level[i].load() + total := short + full + value + if total == 0 && size == 0 { + continue + } + table.AppendBulk([][]string{{ + fmt.Sprint(i), + fmt.Sprint(short), + fmt.Sprint(full), + fmt.Sprint(value), + fmt.Sprint(total), + common.StorageSize(size).String(), + }}) + } + table.Render() + fmt.Print(b.String()) + + return nil +} + +func normalizeInspectConfig(config *InspectConfig) *InspectConfig { + if config == nil { + config = &InspectConfig{} + } + if config.TopN <= 0 { + config.TopN = inspectDefaultTopN + } + if config.DumpPath == "" { + config.DumpPath = "trie-dump.bin" + } + return config +} + +func (in *inspector) recordRootSize(trie *Trie, root common.Hash, stat *LevelStats) { + if root == (common.Hash{}) || root == types.EmptyRootHash { + return + } + blob := trie.prevalueTracer.Get(nil) + if len(blob) == 0 { + resolved, err := trie.reader.Node(nil, root) + if err != nil { + log.Error("Failed to read trie root for size accounting", "trie", trie.Hash(), "root", root, "err", err) + return + } + blob = resolved + } + stat.addSize(0, uint64(len(blob))) +} + +func (in *inspector) closeDump() error { + var ret error + if in.dumpBuf != nil { + if err := in.dumpBuf.Flush(); err != nil { + ret = errors.Join(ret, fmt.Errorf("failed to flush trie dump %s: %w", in.config.DumpPath, err)) + } + } + if in.dumpFile != nil { + if err := in.dumpFile.Close(); err != nil { + ret = errors.Join(ret, fmt.Errorf("failed to close trie dump %s: %w", in.config.DumpPath, err)) + } + } + return ret +} + +func (in *inspector) setError(err error) { + if err == nil { + return + } + in.errMu.Lock() + defer in.errMu.Unlock() + in.err = errors.Join(in.err, err) +} + +func (in *inspector) getError() error { + in.errMu.Lock() + defer in.errMu.Unlock() + return in.err +} + +func (in *inspector) hasError() bool { + return in.getError() != nil +} + +// trySpawn attempts to run fn in a new goroutine, bounded by the semaphore. +// If a slot is available the goroutine is started and tracked via wg; the +// caller must call wg.Wait() before reading any state written by fn. +// Returns false (and does not start a goroutine) when no slot is available. +func (in *inspector) trySpawn(wg *sync.WaitGroup, fn func()) bool { + if !in.sem.TryAcquire(1) { + return false + } + wg.Add(1) + go func() { + defer in.sem.Release(1) + defer wg.Done() + fn() + }() + return true +} + +func (in *inspector) writeDumpRecord(owner common.Hash, s *LevelStats) { + if in.hasError() { + return + } + var buf [inspectDumpRecordSize]byte + copy(buf[:32], owner[:]) + + off := 32 + for i := 0; i < trieStatLevels; i++ { + binary.LittleEndian.PutUint32(buf[off:], uint32(s.level[i].short.Load())) + off += 4 + binary.LittleEndian.PutUint32(buf[off:], uint32(s.level[i].full.Load())) + off += 4 + binary.LittleEndian.PutUint32(buf[off:], uint32(s.level[i].value.Load())) + off += 4 + binary.LittleEndian.PutUint64(buf[off:], s.level[i].size.Load()) + off += 8 + } + in.dumpMu.Lock() + _, err := in.dumpBuf.Write(buf[:]) + in.dumpMu.Unlock() + if err != nil { + in.setError(fmt.Errorf("failed writing trie dump record: %w", err)) + } + + // Increment counter for storage tries only (not for account trie) + if owner != (common.Hash{}) { + in.storageRecordsWritten.Add(1) + } +} + +// inspect walks the trie rooted at n and records node statistics into stat. +// It may spawn goroutines for subtrees, but always waits for them before +// returning — the caller sees a fully-populated stat when inspect returns. +func (in *inspector) inspect(trie *Trie, n node, height uint32, path []byte, stat *LevelStats) { + if n == nil { + return + } + + // wg tracks goroutines spawned by this call so we can wait for them + // before returning. This guarantees stat is complete when we return, + // which is critical for storage tries that write their dump record + // immediately after inspect returns. + var wg sync.WaitGroup + + // Four types of nodes can be encountered: + // - short: extend path with key, inspect single value. + // - full: inspect all 17 children, spin up new threads when possible. + // - hash: need to resolve node from disk, retry inspect on result. + // - value: if account, begin inspecting storage trie. + switch n := (n).(type) { + case *shortNode: + nextPath := slices.Concat(path, n.Key) + in.inspect(trie, n.Val, height+1, nextPath, stat) + case *fullNode: + for idx, child := range n.Children { + if child == nil { + continue + } + childPath := slices.Concat(path, []byte{byte(idx)}) + childNode := child + if in.trySpawn(&wg, func() { + in.inspect(trie, childNode, height+1, childPath, stat) + }) { + continue + } + in.inspect(trie, childNode, height+1, childPath, stat) + } + case hashNode: + blob, err := trie.reader.Node(path, common.BytesToHash(n)) + if err != nil { + log.Error("Failed to resolve HashNode", "err", err, "trie", trie.Hash(), "height", height+1, "path", path) + return + } + stat.addSize(height, uint64(len(blob))) + resolved := mustDecodeNode(n, blob) + in.inspect(trie, resolved, height, path, stat) + + // Return early here so this level isn't recorded twice. + return + case valueNode: + if !hasTerm(path) { + break + } + var account types.StateAccount + if err := rlp.Decode(bytes.NewReader(n), &account); err != nil { + // Not an account value. + break + } + if account.Root == (common.Hash{}) || account.Root == types.EmptyRootHash { + // Account is empty, nothing further to inspect. + break + } + + if !in.config.NoStorage { + owner := common.BytesToHash(hexToCompact(path)) + storage, err := New(StorageTrieID(in.root, owner, account.Root), in.triedb) + if err != nil { + log.Error("Failed to open account storage trie", "node", n, "error", err, "height", height, "path", common.Bytes2Hex(path)) + break + } + storageStat := NewLevelStats() + run := func() { + in.recordRootSize(storage, account.Root, storageStat) + in.inspect(storage, storage.root, 0, []byte{}, storageStat) + in.writeDumpRecord(owner, storageStat) + } + if in.trySpawn(&wg, run) { + break + } + run() + } + default: + panic(fmt.Sprintf("%T: invalid node: %v", n, n)) + } + + // Wait for all goroutines spawned at this level before recording + // the current node. This ensures the entire subtree is counted + // before this call returns. + wg.Wait() + + // Record stats for current height. + stat.add(n, height) +} + +// Summarize performs pass 2 over a trie dump and reports account stats, +// aggregate storage statistics, and top-N rankings. +func Summarize(dumpPath string, config *InspectConfig) error { + config = normalizeInspectConfig(config) + if dumpPath == "" { + dumpPath = config.DumpPath + } + if dumpPath == "" { + return errors.New("missing dump path") + } + file, err := os.Open(dumpPath) + if err != nil { + return fmt.Errorf("failed to open trie dump %s: %w", dumpPath, err) + } + defer file.Close() + + if info, err := file.Stat(); err == nil { + if info.Size()%inspectDumpRecordSize != 0 { + return fmt.Errorf("invalid trie dump size %d (not a multiple of %d)", info.Size(), inspectDumpRecordSize) + } + } + + depthTop := newStorageStatsTopN(config.TopN, compareStorageStatsByDepth) + totalTop := newStorageStatsTopN(config.TopN, compareStorageStatsByTotal) + valueTop := newStorageStatsTopN(config.TopN, compareStorageStatsByValue) + + summary := &inspectSummary{} + reader := bufio.NewReaderSize(file, 1<<20) + var buf [inspectDumpRecordSize]byte + + for { + _, err := io.ReadFull(reader, buf[:]) + if errors.Is(err, io.EOF) { + break + } + if errors.Is(err, io.ErrUnexpectedEOF) { + return fmt.Errorf("truncated trie dump %s", dumpPath) + } + if err != nil { + return fmt.Errorf("failed reading trie dump %s: %w", dumpPath, err) + } + + record := decodeDumpRecord(buf[:]) + snapshot := newStorageStats(record.Owner, record.Levels) + if record.Owner == (common.Hash{}) { + summary.Account = snapshot + continue + } + summary.StorageCount++ + summary.DepthHistogram[snapshot.MaxDepth]++ + for i := 0; i < trieStatLevels; i++ { + summary.StorageLevels[i].Short += record.Levels[i].Short + summary.StorageLevels[i].Full += record.Levels[i].Full + summary.StorageLevels[i].Value += record.Levels[i].Value + summary.StorageLevels[i].Size += record.Levels[i].Size + } + + depthTop.TryInsert(snapshot) + totalTop.TryInsert(snapshot) + valueTop.TryInsert(snapshot) + } + if summary.Account == nil { + return fmt.Errorf("dump file %s does not contain the account trie sentinel record", dumpPath) + } + for i := 0; i < trieStatLevels; i++ { + summary.StorageTotals.Short += summary.StorageLevels[i].Short + summary.StorageTotals.Full += summary.StorageLevels[i].Full + summary.StorageTotals.Value += summary.StorageLevels[i].Value + summary.StorageTotals.Size += summary.StorageLevels[i].Size + } + summary.TopByDepth = depthTop.Sorted() + summary.TopByTotalNodes = totalTop.Sorted() + summary.TopByValueNodes = valueTop.Sorted() + + if config.Path != "" { + return summary.writeJSON(config.Path) + } + summary.display() + return nil +} + +type dumpRecord struct { + Owner common.Hash + Levels [trieStatLevels]jsonLevel +} + +func decodeDumpRecord(raw []byte) dumpRecord { + var ( + record dumpRecord + off = 32 + ) + copy(record.Owner[:], raw[:32]) + for i := 0; i < trieStatLevels; i++ { + record.Levels[i] = jsonLevel{ + Short: uint64(binary.LittleEndian.Uint32(raw[off:])), + Full: uint64(binary.LittleEndian.Uint32(raw[off+4:])), + Value: uint64(binary.LittleEndian.Uint32(raw[off+8:])), + Size: binary.LittleEndian.Uint64(raw[off+12:]), + } + off += 20 + } + return record +} + +type storageStats struct { + Owner common.Hash + Levels [trieStatLevels]jsonLevel + Summary jsonLevel + MaxDepth int + TotalNodes uint64 + TotalSize uint64 +} + +func newStorageStats(owner common.Hash, levels [trieStatLevels]jsonLevel) *storageStats { + snapshot := &storageStats{Owner: owner, Levels: levels} + for i := 0; i < trieStatLevels; i++ { + level := levels[i] + if level.Short != 0 || level.Full != 0 || level.Value != 0 { + snapshot.MaxDepth = i + } + snapshot.Summary.Short += level.Short + snapshot.Summary.Full += level.Full + snapshot.Summary.Value += level.Value + snapshot.Summary.Size += level.Size + } + snapshot.TotalNodes = snapshot.Summary.Short + snapshot.Summary.Full + snapshot.Summary.Value + snapshot.TotalSize = snapshot.Summary.Size + return snapshot +} + +func trimLevels(levels [trieStatLevels]jsonLevel) []jsonLevel { + n := len(levels) + for n > 0 && levels[n-1] == (jsonLevel{}) { + n-- + } + return levels[:n] +} + +func (s *storageStats) MarshalJSON() ([]byte, error) { + type jsonStorageSnapshot struct { + Owner common.Hash `json:"Owner"` + MaxDepth int `json:"MaxDepth"` + TotalNodes uint64 `json:"TotalNodes"` + TotalSize uint64 `json:"TotalSize"` + ValueNodes uint64 `json:"ValueNodes"` + Levels []jsonLevel `json:"Levels"` + Summary jsonLevel `json:"Summary"` + } + return json.Marshal(jsonStorageSnapshot{ + Owner: s.Owner, + MaxDepth: s.MaxDepth, + TotalNodes: s.TotalNodes, + TotalSize: s.TotalSize, + ValueNodes: s.Summary.Value, + Levels: trimLevels(s.Levels), + Summary: s.Summary, + }) +} + +func (s *storageStats) toLevelStats() *LevelStats { + stats := NewLevelStats() + for i := 0; i < trieStatLevels; i++ { + stats.level[i].short.Store(s.Levels[i].Short) + stats.level[i].full.Store(s.Levels[i].Full) + stats.level[i].value.Store(s.Levels[i].Value) + stats.level[i].size.Store(s.Levels[i].Size) + } + return stats +} + +type storageStatsCompare func(a, b *storageStats) int + +type storageStatsTopN struct { + limit int + cmp storageStatsCompare + heap storageStatsHeap +} + +type storageStatsHeap struct { + items []*storageStats + cmp storageStatsCompare +} + +func (h storageStatsHeap) Len() int { return len(h.items) } + +func (h storageStatsHeap) Less(i, j int) bool { + // Keep the weakest entry at the root (min-heap semantics). + return h.cmp(h.items[i], h.items[j]) < 0 +} + +func (h storageStatsHeap) Swap(i, j int) { h.items[i], h.items[j] = h.items[j], h.items[i] } + +func (h *storageStatsHeap) Push(x any) { + h.items = append(h.items, x.(*storageStats)) +} + +func (h *storageStatsHeap) Pop() any { + item := h.items[len(h.items)-1] + h.items = h.items[:len(h.items)-1] + return item +} + +func newStorageStatsTopN(limit int, cmp storageStatsCompare) *storageStatsTopN { + h := storageStatsHeap{cmp: cmp} + heap.Init(&h) + return &storageStatsTopN{limit: limit, cmp: cmp, heap: h} +} + +func (t *storageStatsTopN) TryInsert(item *storageStats) { + if t.limit <= 0 { + return + } + if t.heap.Len() < t.limit { + heap.Push(&t.heap, item) + return + } + if t.cmp(item, t.heap.items[0]) <= 0 { + return + } + heap.Pop(&t.heap) + heap.Push(&t.heap, item) +} + +func (t *storageStatsTopN) Sorted() []*storageStats { + out := append([]*storageStats(nil), t.heap.items...) + sort.Slice(out, func(i, j int) bool { return t.cmp(out[i], out[j]) > 0 }) + return out +} + +func compareStorageStatsByDepth(a, b *storageStats) int { + return cmp.Or( + cmp.Compare(a.MaxDepth, b.MaxDepth), + cmp.Compare(a.TotalNodes, b.TotalNodes), + cmp.Compare(a.Summary.Value, b.Summary.Value), + bytes.Compare(a.Owner[:], b.Owner[:]), + ) +} + +func compareStorageStatsByTotal(a, b *storageStats) int { + return cmp.Or( + cmp.Compare(a.TotalNodes, b.TotalNodes), + cmp.Compare(a.MaxDepth, b.MaxDepth), + cmp.Compare(a.Summary.Value, b.Summary.Value), + bytes.Compare(a.Owner[:], b.Owner[:]), + ) +} + +func compareStorageStatsByValue(a, b *storageStats) int { + return cmp.Or( + cmp.Compare(a.Summary.Value, b.Summary.Value), + cmp.Compare(a.MaxDepth, b.MaxDepth), + cmp.Compare(a.TotalNodes, b.TotalNodes), + bytes.Compare(a.Owner[:], b.Owner[:]), + ) +} + +type inspectSummary struct { + Account *storageStats + StorageCount uint64 + StorageTotals jsonLevel + StorageLevels [trieStatLevels]jsonLevel + DepthHistogram [trieStatLevels]uint64 + TopByDepth []*storageStats + TopByTotalNodes []*storageStats + TopByValueNodes []*storageStats +} + +func (s *inspectSummary) display() { + s.displayCombinedDepthTable() + s.Account.toLevelStats().display("Accounts trie") + fmt.Println("Storage trie aggregate summary") + fmt.Printf("Total storage tries: %d\n", s.StorageCount) + totalNodes := s.StorageTotals.Short + s.StorageTotals.Full + s.StorageTotals.Value + fmt.Printf("Total nodes: %d\n", totalNodes) + fmt.Printf("Total size: %s\n", common.StorageSize(s.StorageTotals.Size)) + fmt.Printf(" Short nodes: %d\n", s.StorageTotals.Short) + fmt.Printf(" Full nodes: %d\n", s.StorageTotals.Full) + fmt.Printf(" Value nodes: %d\n", s.StorageTotals.Value) + + b := new(strings.Builder) + table := tablewriter.NewWriter(b) + table.SetHeader([]string{"Max Depth", "Storage Tries"}) + for i, count := range s.DepthHistogram { + table.AppendBulk([][]string{{fmt.Sprint(i), fmt.Sprint(count)}}) + } + table.Render() + fmt.Print(b.String()) + fmt.Println() + + s.displayTop("Top storage tries by max depth", s.TopByDepth) + s.displayTop("Top storage tries by total node count", s.TopByTotalNodes) + s.displayTop("Top storage tries by value (slot) count", s.TopByValueNodes) +} + +func (s *inspectSummary) displayCombinedDepthTable() { + accountTotal := s.Account.Summary.Short + s.Account.Summary.Full + s.Account.Summary.Value + storageTotal := s.StorageTotals.Short + s.StorageTotals.Full + s.StorageTotals.Value + accountTotalSize := s.Account.Summary.Size + storageTotalSize := s.StorageTotals.Size + + fmt.Println("Trie Depth Distribution") + fmt.Printf("Account Trie: %d nodes (%s)\n", accountTotal, common.StorageSize(accountTotalSize)) + fmt.Printf("Storage Tries: %d nodes (%s) across %d tries\n", storageTotal, common.StorageSize(storageTotalSize), s.StorageCount) + + b := new(strings.Builder) + table := tablewriter.NewWriter(b) + table.SetHeader([]string{"Depth", "Account Nodes", "Account Size", "Storage Nodes", "Storage Size"}) + for i := 0; i < trieStatLevels; i++ { + accountNodes := s.Account.Levels[i].Short + s.Account.Levels[i].Full + s.Account.Levels[i].Value + accountSize := s.Account.Levels[i].Size + storageNodes := s.StorageLevels[i].Short + s.StorageLevels[i].Full + s.StorageLevels[i].Value + storageSize := s.StorageLevels[i].Size + if accountNodes == 0 && storageNodes == 0 { + continue + } + table.AppendBulk([][]string{{ + fmt.Sprint(i), + fmt.Sprint(accountNodes), + common.StorageSize(accountSize).String(), + fmt.Sprint(storageNodes), + common.StorageSize(storageSize).String(), + }}) + } + table.Render() + fmt.Print(b.String()) + fmt.Println() +} + +func (s *inspectSummary) displayTop(title string, list []*storageStats) { + fmt.Println(title) + if len(list) == 0 { + fmt.Println("No storage tries found") + fmt.Println() + return + } + for i, item := range list { + fmt.Printf("%d: %s\n", i+1, item.Owner) + item.toLevelStats().display("storage trie") + } +} + +func (s *inspectSummary) MarshalJSON() ([]byte, error) { + type jsonAccountTrie struct { + Name string `json:"Name"` + Levels []jsonLevel `json:"Levels"` + Summary jsonLevel `json:"Summary"` + } + type jsonStorageSummary struct { + TotalStorageTries uint64 `json:"TotalStorageTries"` + Totals jsonLevel `json:"Totals"` + Levels []jsonLevel `json:"Levels"` + DepthHistogram [trieStatLevels]uint64 `json:"DepthHistogram"` + } + type jsonInspectSummary struct { + AccountTrie jsonAccountTrie `json:"AccountTrie"` + StorageSummary jsonStorageSummary `json:"StorageSummary"` + TopByDepth []*storageStats `json:"TopByDepth"` + TopByTotalNodes []*storageStats `json:"TopByTotalNodes"` + TopByValueNodes []*storageStats `json:"TopByValueNodes"` + } + return json.Marshal(jsonInspectSummary{ + AccountTrie: jsonAccountTrie{ + Name: "account trie", + Levels: trimLevels(s.Account.Levels), + Summary: s.Account.Summary, + }, + StorageSummary: jsonStorageSummary{ + TotalStorageTries: s.StorageCount, + Totals: s.StorageTotals, + Levels: trimLevels(s.StorageLevels), + DepthHistogram: s.DepthHistogram, + }, + TopByDepth: s.TopByDepth, + TopByTotalNodes: s.TopByTotalNodes, + TopByValueNodes: s.TopByValueNodes, + }) +} + +func (s *inspectSummary) writeJSON(path string) error { + file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644) + if err != nil { + return err + } + defer file.Close() + + enc := json.NewEncoder(file) + enc.SetIndent("", " ") + return enc.Encode(s) +} + +// display will print a table displaying the trie's node statistics. +func (s *LevelStats) display(title string) { + // Shorten title if too long. + if len(title) > 32 { + title = title[0:8] + "..." + title[len(title)-8:] + } + + b := new(strings.Builder) + table := tablewriter.NewWriter(b) + table.SetHeader([]string{title, "Level", "Short Nodes", "Full Node", "Value Node"}) + + stat := &stat{} + for i := range s.level { + if s.level[i].empty() { + continue + } + short, full, value, _ := s.level[i].load() + table.AppendBulk([][]string{{"-", fmt.Sprint(i), fmt.Sprint(short), fmt.Sprint(full), fmt.Sprint(value)}}) + stat.add(&s.level[i]) + } + short, full, value, _ := stat.load() + table.SetFooter([]string{"Total", "", fmt.Sprint(short), fmt.Sprint(full), fmt.Sprint(value)}) + table.Render() + fmt.Print(b.String()) + fmt.Println("Max depth", s.MaxDepth()) + fmt.Println() +} + +type jsonLevel struct { + Short uint64 + Full uint64 + Value uint64 + Size uint64 +} diff --git a/trie/inspect_test.go b/trie/inspect_test.go new file mode 100644 index 000000000000..c07904c52d8b --- /dev/null +++ b/trie/inspect_test.go @@ -0,0 +1,256 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package trie + +import ( + "encoding/json" + "math/rand" + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie/trienode" + "github.com/holiman/uint256" +) + +// TestInspect inspects a randomly generated account trie. It's useful for +// quickly verifying changes to the results display. +func TestInspect(t *testing.T) { + db := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.HashScheme) + trie, err := NewStateTrie(TrieID(types.EmptyRootHash), db) + if err != nil { + t.Fatalf("failed to create state trie: %v", err) + } + // Create a realistic looking account trie with storage. + addresses, accounts := makeAccountsWithStorage(db, 11, true) + for i := 0; i < len(addresses); i++ { + trie.MustUpdate(crypto.Keccak256(addresses[i][:]), accounts[i]) + } + // Insert the accounts into the trie and hash it + root, nodes := trie.Commit(true) + db.Update(root, types.EmptyRootHash, trienode.NewWithNodeSet(nodes)) + db.Commit(root) + + tempDir := t.TempDir() + dumpPath := filepath.Join(tempDir, "trie-dump.bin") + if err := Inspect(db, root, &InspectConfig{ + TopN: 1, + DumpPath: dumpPath, + Path: filepath.Join(tempDir, "trie-summary.json"), + }); err != nil { + t.Fatalf("inspect failed: %v", err) + } + reanalysisPath := filepath.Join(tempDir, "trie-summary-reanalysis.json") + if err := Summarize(dumpPath, &InspectConfig{ + TopN: 1, + Path: reanalysisPath, + }); err != nil { + t.Fatalf("summarize failed: %v", err) + } + + inspectSummaryPath := filepath.Join(tempDir, "trie-summary.json") + inspectOut := loadInspectJSON(t, inspectSummaryPath) + reanalysisOut := loadInspectJSON(t, reanalysisPath) + + if len(inspectOut.StorageSummary.Levels) == 0 { + t.Fatal("expected StorageSummary.Levels to be populated") + } + if inspectOut.AccountTrie.Summary.Size == 0 { + t.Fatal("expected account trie size summary to be populated") + } + if inspectOut.StorageSummary.Totals.Size == 0 { + t.Fatal("expected storage trie size summary to be populated") + } + if !reflect.DeepEqual(inspectOut.AccountTrie, reanalysisOut.AccountTrie) { + t.Fatal("account trie summary mismatch between inspect and summarize") + } + if !reflect.DeepEqual(inspectOut.StorageSummary, reanalysisOut.StorageSummary) { + t.Fatal("storage summary mismatch between inspect and summarize") + } + + assertStorageTotalsMatchLevels(t, inspectOut) + assertStorageTotalsMatchLevels(t, reanalysisOut) + assertAccountTotalsMatchLevels(t, inspectOut.AccountTrie) + assertAccountTotalsMatchLevels(t, reanalysisOut.AccountTrie) + + var histogramTotal uint64 + for _, count := range inspectOut.StorageSummary.DepthHistogram { + histogramTotal += count + } + if histogramTotal != inspectOut.StorageSummary.TotalStorageTries { + t.Fatalf("depth histogram total %d does not match total storage tries %d", histogramTotal, inspectOut.StorageSummary.TotalStorageTries) + } +} + +type inspectJSONOutput struct { + // Reuse storageStats for AccountTrie JSON to avoid introducing a parallel + // account summary test type. AccountTrie JSON includes Levels+Summary, + // which map directly; other storageStats fields remain zero-values. + AccountTrie storageStats `json:"AccountTrie"` + + StorageSummary struct { + TotalStorageTries uint64 `json:"TotalStorageTries"` + Totals jsonLevel `json:"Totals"` + Levels []jsonLevel `json:"Levels"` + DepthHistogram [trieStatLevels]uint64 `json:"DepthHistogram"` + } `json:"StorageSummary"` +} + +func loadInspectJSON(t *testing.T, path string) inspectJSONOutput { + t.Helper() + raw, err := os.ReadFile(path) + if err != nil { + t.Fatalf("failed to read %s: %v", path, err) + } + var out inspectJSONOutput + if err := json.Unmarshal(raw, &out); err != nil { + t.Fatalf("failed to decode %s: %v", path, err) + } + return out +} + +func assertStorageTotalsMatchLevels(t *testing.T, out inspectJSONOutput) { + t.Helper() + var fromLevels jsonLevel + for _, level := range out.StorageSummary.Levels { + fromLevels.Short += level.Short + fromLevels.Full += level.Full + fromLevels.Value += level.Value + fromLevels.Size += level.Size + } + if fromLevels.Short != out.StorageSummary.Totals.Short || fromLevels.Full != out.StorageSummary.Totals.Full || fromLevels.Value != out.StorageSummary.Totals.Value || fromLevels.Size != out.StorageSummary.Totals.Size { + t.Fatalf("storage totals mismatch: levels=%+v totals=%+v", fromLevels, out.StorageSummary.Totals) + } +} + +func assertAccountTotalsMatchLevels(t *testing.T, account storageStats) { + t.Helper() + var fromLevels jsonLevel + for _, level := range account.Levels { + fromLevels.Short += level.Short + fromLevels.Full += level.Full + fromLevels.Value += level.Value + fromLevels.Size += level.Size + } + if fromLevels.Short != account.Summary.Short || fromLevels.Full != account.Summary.Full || fromLevels.Value != account.Summary.Value || fromLevels.Size != account.Summary.Size { + t.Fatalf("account totals mismatch: levels=%+v totals=%+v", fromLevels, account.Summary) + } +} + +// TestInspectContract tests the InspectContract function on a single account +// with storage and snapshot data. +func TestInspectContract(t *testing.T) { + diskdb := rawdb.NewMemoryDatabase() + db := newTestDatabase(diskdb, rawdb.HashScheme) + + // Create a contract address and its storage trie. + address := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") + accountHash := crypto.Keccak256Hash(address.Bytes()) + + // Build a storage trie with some entries. + storageTrie := NewEmpty(db) + storageSlots := make(map[common.Hash][]byte) + for i := 0; i < 10; i++ { + k := crypto.Keccak256Hash([]byte{byte(i)}) + v := []byte{byte(i + 1)} + storageTrie.MustUpdate(k.Bytes(), v) + storageSlots[k] = v + } + storageRoot, storageNodes := storageTrie.Commit(true) + db.Update(storageRoot, types.EmptyRootHash, trienode.NewWithNodeSet(storageNodes)) + db.Commit(storageRoot) + + // Build the account trie with the contract account. + account := types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(1000), + Root: storageRoot, + CodeHash: crypto.Keccak256(nil), + } + accountRLP, err := rlp.EncodeToBytes(&account) + if err != nil { + t.Fatalf("failed to encode account: %v", err) + } + + accountTrie := NewEmpty(db) + accountTrie.MustUpdate(crypto.Keccak256(address.Bytes()), accountRLP) + stateRoot, accountNodes := accountTrie.Commit(true) + db.Update(stateRoot, types.EmptyRootHash, trienode.NewWithNodeSet(accountNodes)) + db.Commit(stateRoot) + + // Write snapshot data for the account and its storage slots. + rawdb.WriteAccountSnapshot(diskdb, accountHash, accountRLP) + for k, v := range storageSlots { + rawdb.WriteStorageSnapshot(diskdb, accountHash, k, v) + } + + // InspectContract should succeed without error. + if err := InspectContract(db, diskdb, stateRoot, address); err != nil { + t.Fatalf("InspectContract failed: %v", err) + } +} + +func makeAccountsWithStorage(db *testDb, size int, storage bool) (addresses [][20]byte, accounts [][]byte) { + // Make the random benchmark deterministic + random := rand.New(rand.NewSource(0)) + + addresses = make([][20]byte, size) + for i := 0; i < len(addresses); i++ { + data := make([]byte, 20) + random.Read(data) + copy(addresses[i][:], data) + } + accounts = make([][]byte, len(addresses)) + for i := 0; i < len(accounts); i++ { + var ( + nonce = uint64(random.Int63()) + root = types.EmptyRootHash + code = crypto.Keccak256(nil) + ) + if storage { + trie := NewEmpty(db) + for range random.Uint32()%256 + 1 { // non-zero + k, v := make([]byte, 32), make([]byte, 32) + random.Read(k) + random.Read(v) + trie.MustUpdate(k, v) + } + var nodes *trienode.NodeSet + root, nodes = trie.Commit(true) + db.Update(root, types.EmptyRootHash, trienode.NewWithNodeSet(nodes)) + db.Commit(root) + } + numBytes := random.Uint32() % 33 // [0, 32] bytes + balanceBytes := make([]byte, numBytes) + random.Read(balanceBytes) + balance := new(uint256.Int).SetBytes(balanceBytes) + data, _ := rlp.EncodeToBytes(&types.StateAccount{ + Nonce: nonce, + Balance: balance, + Root: root, + CodeHash: code, + }) + accounts[i] = data + } + return addresses, accounts +} diff --git a/trie/levelstats.go b/trie/levelstats.go new file mode 100644 index 000000000000..c73d65214619 --- /dev/null +++ b/trie/levelstats.go @@ -0,0 +1,135 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package trie + +import ( + "fmt" + "sync/atomic" +) + +const trieStatLevels = 16 + +// LevelStats tracks the type and count of trie nodes at each level in a trie. +// +// Note: theoretically it is possible to have up to 64 trie levels, but +// LevelStats supports exactly 16 levels and panics on deeper paths. +type LevelStats struct { + level [trieStatLevels]stat +} + +// NewLevelStats creates an empty trie statistics collector. +func NewLevelStats() *LevelStats { + return &LevelStats{} +} + +// Copy returns a deep copy of the statistics. +func (s *LevelStats) Copy() *LevelStats { + cpy := NewLevelStats() + for i := range s.level { + cpy.level[i].short.Store(s.level[i].short.Load()) + cpy.level[i].full.Store(s.level[i].full.Load()) + cpy.level[i].value.Store(s.level[i].value.Load()) + cpy.level[i].size.Store(s.level[i].size.Load()) + } + return cpy +} + +// MaxDepth iterates each level and finds the deepest level with at least one +// trie node. +func (s *LevelStats) MaxDepth() int { + depth := 0 + for i := range s.level { + if s.level[i].short.Load() != 0 || s.level[i].full.Load() != 0 || s.level[i].value.Load() != 0 { + depth = i + } + } + return depth +} + +// TotalNodes returns the total number of nodes across all levels and types. +func (s *LevelStats) TotalNodes() uint64 { + var total uint64 + for i := range s.level { + total += s.level[i].short.Load() + s.level[i].full.Load() + s.level[i].value.Load() + } + return total +} + +// add increases the node count by one for the specified node type and depth. +func (s *LevelStats) add(n node, depth uint32) { + d := int(depth) + switch (n).(type) { + case *shortNode: + s.level[d].short.Add(1) + case *fullNode: + s.level[d].full.Add(1) + case valueNode: + s.level[d].value.Add(1) + default: + panic(fmt.Sprintf("%T: invalid node: %v", n, n)) + } +} + +// addSize increases the raw byte-size tally at the specified depth. +func (s *LevelStats) addSize(depth uint32, size uint64) { + s.level[depth].size.Add(size) +} + +// AddLeaf records a leaf depth. Witness collection reuses the value-node bucket +// for leaf accounting. It panics if the depth is outside [0, 15]. +func (s *LevelStats) AddLeaf(depth int) { + s.level[depth].value.Add(1) +} + +// LeafDepths returns leaf counts grouped by depth. +func (s *LevelStats) LeafDepths() [trieStatLevels]int64 { + var leaves [trieStatLevels]int64 + for i := range s.level { + leaves[i] = int64(s.level[i].value.Load()) + } + return leaves +} + +// stat is a specific level's count of each node type. +type stat struct { + short atomic.Uint64 + full atomic.Uint64 + value atomic.Uint64 + size atomic.Uint64 +} + +// empty is a helper that returns whether there are any trie nodes at the level. +func (s *stat) empty() bool { + if s.full.Load() == 0 && s.short.Load() == 0 && s.value.Load() == 0 && s.size.Load() == 0 { + return true + } + return false +} + +// load is a helper that loads each node type's value. +func (s *stat) load() (uint64, uint64, uint64, uint64) { + return s.short.Load(), s.full.Load(), s.value.Load(), s.size.Load() +} + +// add is a helper that adds two level's stats together. +func (s *stat) add(other *stat) *stat { + s.short.Add(other.short.Load()) + s.full.Add(other.full.Load()) + s.value.Add(other.value.Load()) + s.size.Add(other.size.Load()) + return s +} diff --git a/trie/levelstats_test.go b/trie/levelstats_test.go new file mode 100644 index 000000000000..90581eb1ab84 --- /dev/null +++ b/trie/levelstats_test.go @@ -0,0 +1,37 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package trie + +import "testing" + +func TestLevelStatsAddLeafDepthBounds(t *testing.T) { + stats := NewLevelStats() + stats.AddLeaf(15) + + if got := stats.LeafDepths()[15]; got != 1 { + t.Fatalf("leaf count at depth 15 = %d, want 1", got) + } +} + +func TestLevelStatsAddLeafPanicsOnDepth16(t *testing.T) { + defer func() { + if r := recover(); r == nil { + t.Fatal("expected panic for depth >= 16") + } + }() + NewLevelStats().AddLeaf(16) +} diff --git a/trie/node.go b/trie/node.go index 74fac4fd4ea6..70221160488b 100644 --- a/trie/node.go +++ b/trie/node.go @@ -17,6 +17,7 @@ package trie import ( + "bytes" "fmt" "io" "strings" @@ -160,11 +161,14 @@ func decodeNodeUnsafe(hash, buf []byte) (node, error) { if err != nil { return nil, fmt.Errorf("decode error: %v", err) } - switch c, _ := rlp.CountValues(elems); c { - case 2: + c, err := rlp.CountValues(elems) + switch { + case err != nil: + return nil, fmt.Errorf("invalid node list: %v", err) + case c == 2: n, err := decodeShort(hash, elems) return n, wrapError(err, "short") - case 17: + case c == 17: n, err := decodeFull(hash, elems) return n, wrapError(err, "full") default: @@ -224,7 +228,7 @@ func decodeRef(buf []byte) (node, []byte, error) { case kind == rlp.List: // 'embedded' node reference. The encoding must be smaller // than a hash in order to be valid. - if size := len(buf) - len(rest); size > hashLen { + if size := len(buf) - len(rest); size >= hashLen { err := fmt.Errorf("oversized embedded node (size is %d bytes, want size < %d)", size, hashLen) return nil, buf, err } @@ -242,6 +246,74 @@ func decodeRef(buf []byte) (node, []byte, error) { } } +// decodeNodeElements parses the RLP encoding of a trie node and returns all the +// elements in raw byte format. +// +// For full node, it returns a slice of 17 elements; +// For short node, it returns a slice of 2 elements; +func decodeNodeElements(buf []byte) ([][]byte, error) { + if len(buf) == 0 { + return nil, io.ErrUnexpectedEOF + } + return rlp.SplitListValues(buf) +} + +// encodeNodeElements encodes the provided node elements into a rlp list. +func encodeNodeElements(elements [][]byte) ([]byte, error) { + if len(elements) != 2 && len(elements) != 17 { + return nil, fmt.Errorf("invalid number of elements: %d", len(elements)) + } + return rlp.MergeListValues(elements) +} + +// NodeDifference accepts two RLP-encoding nodes and figures out the difference +// between them. +// +// An error is returned if any of the provided blob is nil, or the type of nodes +// are different. +func NodeDifference(oldvalue []byte, newvalue []byte) (int, []int, [][]byte, error) { + oldElems, err := decodeNodeElements(oldvalue) + if err != nil { + return 0, nil, nil, err + } + newElems, err := decodeNodeElements(newvalue) + if err != nil { + return 0, nil, nil, err + } + if len(oldElems) != len(newElems) { + return 0, nil, nil, fmt.Errorf("different node type, old elements: %d, new elements: %d", len(oldElems), len(newElems)) + } + var ( + indices = make([]int, 0, len(oldElems)) + diff = make([][]byte, 0, len(oldElems)) + ) + for i := 0; i < len(oldElems); i++ { + if !bytes.Equal(oldElems[i], newElems[i]) { + indices = append(indices, i) + diff = append(diff, oldElems[i]) + } + } + return len(oldElems), indices, diff, nil +} + +// ReassembleNode accepts a RLP-encoding node along with a set of mutations, +// applying the modification diffs according to the indices and re-assemble. +func ReassembleNode(blob []byte, mutations [][][]byte, indices [][]int) ([]byte, error) { + if len(mutations) == 0 && len(indices) == 0 { + return blob, nil + } + elements, err := decodeNodeElements(blob) + if err != nil { + return nil, err + } + for i := 0; i < len(mutations); i++ { + for j, pos := range indices[i] { + elements[pos] = mutations[i][j] + } + } + return encodeNodeElements(elements) +} + // wraps a decoding error with information about the path to the // invalid child node (for debugging encoding issues). type decodeError struct { diff --git a/trie/node_test.go b/trie/node_test.go index 9b8b33748fa7..b4f427ca7758 100644 --- a/trie/node_test.go +++ b/trie/node_test.go @@ -18,9 +18,13 @@ package trie import ( "bytes" + "math/rand" + "reflect" + "slices" "testing" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/internal/testrand" "github.com/ethereum/go-ethereum/rlp" ) @@ -94,6 +98,286 @@ func TestDecodeFullNode(t *testing.T) { } } +func makeTestLeafNode(small bool) []byte { + l := leafNodeEncoder{} + l.Key = hexToCompact(keybytesToHex(testrand.Bytes(10))) + if small { + l.Val = testrand.Bytes(10) + } else { + l.Val = testrand.Bytes(32) + } + buf := rlp.NewEncoderBuffer(nil) + l.encode(buf) + return buf.ToBytes() +} + +func makeTestFullNode(small bool) []byte { + n := fullnodeEncoder{} + for i := 0; i < 16; i++ { + switch rand.Intn(3) { + case 0: + // write nil + case 1: + // write hash + n.Children[i] = testrand.Bytes(32) + case 2: + // write embedded node + n.Children[i] = makeTestLeafNode(small) + } + } + n.Children[16] = testrand.Bytes(32) // value + buf := rlp.NewEncoderBuffer(nil) + n.encode(buf) + return buf.ToBytes() +} + +func TestEncodeDecodeNodeElements(t *testing.T) { + var nodes [][]byte + nodes = append(nodes, makeTestFullNode(true)) + nodes = append(nodes, makeTestFullNode(false)) + nodes = append(nodes, makeTestLeafNode(true)) + nodes = append(nodes, makeTestLeafNode(false)) + + for _, blob := range nodes { + elements, err := decodeNodeElements(blob) + if err != nil { + t.Fatalf("Failed to decode node elements: %v", err) + } + enc, err := encodeNodeElements(elements) + if err != nil { + t.Fatalf("Failed to encode node elements: %v", err) + } + if !bytes.Equal(enc, blob) { + t.Fatalf("Unexpected encoded node element, want: %v, got: %v", blob, enc) + } + } +} + +func makeTestLeafNodePair() ([]byte, []byte, [][]byte, []int) { + var ( + na = leafNodeEncoder{} + nb = leafNodeEncoder{} + ) + key := keybytesToHex(testrand.Bytes(10)) + na.Key = hexToCompact(key) + nb.Key = hexToCompact(key) + + valA := testrand.Bytes(32) + valB := testrand.Bytes(32) + na.Val = valA + nb.Val = valB + + bufa, bufb := rlp.NewEncoderBuffer(nil), rlp.NewEncoderBuffer(nil) + na.encode(bufa) + nb.encode(bufb) + diff, _ := rlp.EncodeToBytes(valA) + return bufa.ToBytes(), bufb.ToBytes(), [][]byte{diff}, []int{1} +} + +func makeTestFullNodePair() ([]byte, []byte, [][]byte, []int) { + var ( + na = fullnodeEncoder{} + nb = fullnodeEncoder{} + indices []int + values [][]byte + ) + for i := 0; i < 16; i++ { + switch rand.Intn(3) { + case 0: + // write nil + case 1: + // write same + var child []byte + if rand.Intn(2) == 0 { + child = testrand.Bytes(32) // hashnode + } else { + child = makeTestLeafNode(true) // embedded node + } + na.Children[i] = child + nb.Children[i] = child + case 2: + // write different + var ( + va []byte + diff []byte + ) + rnd := rand.Intn(3) + if rnd == 0 { + va = testrand.Bytes(32) // hashnode + diff, _ = rlp.EncodeToBytes(va) + } else if rnd == 1 { + va = makeTestLeafNode(true) // embedded node + diff = va + } else { + va = nil + diff = rlp.EmptyString + } + vb := testrand.Bytes(32) // hashnode + na.Children[i] = va + nb.Children[i] = vb + + indices = append(indices, i) + values = append(values, diff) + } + } + na.Children[16] = nil + nb.Children[16] = nil + + bufa, bufb := rlp.NewEncoderBuffer(nil), rlp.NewEncoderBuffer(nil) + na.encode(bufa) + nb.encode(bufb) + return bufa.ToBytes(), bufb.ToBytes(), values, indices +} + +func TestNodeDifference(t *testing.T) { + type testsuite struct { + old []byte + new []byte + expErr bool + expIndices []int + expValues [][]byte + } + var tests = []testsuite{ + // Invalid node data + { + old: nil, new: nil, expErr: true, + }, + { + old: testrand.Bytes(32), new: nil, expErr: true, + }, + { + old: nil, new: testrand.Bytes(32), expErr: true, + }, + { + old: bytes.Repeat([]byte{0x1}, 32), new: bytes.Repeat([]byte{0x2}, 32), expErr: true, + }, + // Different node type + { + old: makeTestLeafNode(true), new: makeTestFullNode(true), expErr: true, + }, + } + for range 10 { + va, vb, elements, indices := makeTestLeafNodePair() + tests = append(tests, testsuite{ + old: va, + new: vb, + expErr: false, + expIndices: indices, + expValues: elements, + }) + } + for range 10 { + va, vb, elements, indices := makeTestFullNodePair() + tests = append(tests, testsuite{ + old: va, + new: vb, + expErr: false, + expIndices: indices, + expValues: elements, + }) + } + + for i, test := range tests { + _, indices, values, err := NodeDifference(test.old, test.new) + if test.expErr && err == nil { + t.Fatalf("Expect error, got nil %d", i) + } + if !test.expErr && err != nil { + t.Fatalf("Unexpect error, %v", err) + } + if err == nil { + if !slices.Equal(indices, test.expIndices) { + t.Fatalf("Unexpected indices, want: %v, got: %v", test.expIndices, indices) + } + if !slices.EqualFunc(values, test.expValues, bytes.Equal) { + t.Fatalf("Unexpected values, want: %v, got: %v", test.expValues, values) + } + } + } +} + +func TestReassembleFullNode(t *testing.T) { + var fn fullnodeEncoder + for i := 0; i < 16; i++ { + if rand.Intn(2) == 0 { + fn.Children[i] = testrand.Bytes(32) + } + } + buf := rlp.NewEncoderBuffer(nil) + fn.encode(buf) + enc := buf.ToBytes() + + // Generate a list of diffs + var ( + values [][][]byte + indices [][]int + ) + for i := 0; i < 10; i++ { + var ( + pos = make(map[int]struct{}) + poslist []int + valuelist [][]byte + ) + for j := 0; j < 3; j++ { + p := rand.Intn(16) + if _, ok := pos[p]; ok { + continue + } + pos[p] = struct{}{} + + nh := testrand.Bytes(32) + diff, _ := rlp.EncodeToBytes(nh) + poslist = append(poslist, p) + valuelist = append(valuelist, diff) + fn.Children[p] = nh + } + values = append(values, valuelist) + indices = append(indices, poslist) + } + reassembled, err := ReassembleNode(enc, values, indices) + if err != nil { + t.Fatalf("Failed to re-assemble full node %v", err) + } + buf2 := rlp.NewEncoderBuffer(nil) + fn.encode(buf2) + enc2 := buf2.ToBytes() + if !reflect.DeepEqual(enc2, reassembled) { + t.Fatalf("Unexpeted reassembled node") + } +} + +func TestReassembleShortNode(t *testing.T) { + var ln leafNodeEncoder + ln.Key = hexToCompact(keybytesToHex(testrand.Bytes(10))) + ln.Val = testrand.Bytes(10) + buf := rlp.NewEncoderBuffer(nil) + ln.encode(buf) + enc := buf.ToBytes() + + // Generate a list of diffs + var ( + values [][][]byte + indices [][]int + ) + for i := 0; i < 10; i++ { + val := testrand.Bytes(10) + ln.Val = val + diff, _ := rlp.EncodeToBytes(val) + values = append(values, [][]byte{diff}) + indices = append(indices, []int{1}) + } + reassembled, err := ReassembleNode(enc, values, indices) + if err != nil { + t.Fatalf("Failed to re-assemble full node %v", err) + } + buf2 := rlp.NewEncoderBuffer(nil) + ln.encode(buf2) + enc2 := buf2.ToBytes() + if !reflect.DeepEqual(enc2, reassembled) { + t.Fatalf("Unexpeted reassembled node") + } +} + // goos: darwin // goarch: arm64 // pkg: github.com/ethereum/go-ethereum/trie diff --git a/trie/proof.go b/trie/proof.go index 1a06ed5d5e3b..58075daf9b11 100644 --- a/trie/proof.go +++ b/trie/proof.go @@ -454,7 +454,7 @@ func hasRightElement(node node, key []byte) bool { // // The firstKey is paired with firstProof, not necessarily the same as keys[0] // (unless firstProof is an existent proof). Similarly, lastKey and lastProof -// are paired. +// are paired. The firstKey should be less than or equal to all keys in the list. // // Expect the normal case, this function can also be used to verify the following // range proofs: @@ -520,9 +520,14 @@ func VerifyRangeProof(rootHash common.Hash, firstKey []byte, keys [][]byte, valu } return false, nil } - var lastKey = keys[len(keys)-1] + // Short circuit if the key of first element is greater than firstKey. + // A nil firstKey slice is equivalent to an empty slice. + if bytes.Compare(firstKey, keys[0]) > 0 { + return false, errors.New("unexpected key-value pairs preceding the requested range") + } // Special case, there is only one element and two edge keys are same. // In this case, we can't construct two edge paths. So handle it here. + var lastKey = keys[len(keys)-1] if len(keys) == 1 && bytes.Equal(firstKey, lastKey) { root, val, err := proofToPath(rootHash, nil, firstKey, proof, false) if err != nil { @@ -577,7 +582,9 @@ func VerifyRangeProof(rootHash common.Hash, firstKey []byte, keys [][]byte, valu tr.root = nil } for index, key := range keys { - tr.Update(key, values[index]) + if err := tr.Update(key, values[index]); err != nil { + return false, err + } } if tr.Hash() != rootHash { return false, fmt.Errorf("invalid proof, want hash %x, got %x", rootHash, tr.Hash()) diff --git a/trie/secure_trie.go b/trie/secure_trie.go index 7c7bd184bf84..4d03ca45f011 100644 --- a/trie/secure_trie.go +++ b/trie/secure_trie.go @@ -134,9 +134,9 @@ func (t *StateTrie) GetAccountByHash(addrHash common.Hash) (*types.StateAccount, // PrefetchAccount attempts to resolve specific accounts from the database // to accelerate subsequent trie operations. func (t *StateTrie) PrefetchAccount(addresses []common.Address) error { - var keys [][]byte - for _, addr := range addresses { - keys = append(keys, crypto.Keccak256(addr.Bytes())) + keys := make([][]byte, len(addresses)) + for i, addr := range addresses { + keys[i] = crypto.Keccak256(addr.Bytes()) } return t.trie.Prefetch(keys) } @@ -157,9 +157,9 @@ func (t *StateTrie) GetStorage(_ common.Address, key []byte) ([]byte, error) { // PrefetchStorage attempts to resolve specific storage slots from the database // to accelerate subsequent trie operations. func (t *StateTrie) PrefetchStorage(_ common.Address, keys [][]byte) error { - var keylist [][]byte - for _, key := range keys { - keylist = append(keylist, crypto.Keccak256(key)) + keylist := make([][]byte, len(keys)) + for i, key := range keys { + keylist[i] = crypto.Keccak256(key) } return t.trie.Prefetch(keylist) } @@ -324,6 +324,6 @@ func (t *StateTrie) MustNodeIterator(start []byte) NodeIterator { return t.trie.MustNodeIterator(start) } -func (t *StateTrie) IsVerkle() bool { +func (t *StateTrie) IsUBT() bool { return false } diff --git a/trie/transitiontrie/transition.go b/trie/transitiontrie/transition.go index 4c730220821f..3e5511be9ed2 100644 --- a/trie/transitiontrie/transition.go +++ b/trie/transitiontrie/transition.go @@ -202,8 +202,8 @@ func (t *TransitionTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error { panic("not implemented") // TODO: Implement } -// IsVerkle returns true if the trie is verkle-tree based -func (t *TransitionTrie) IsVerkle() bool { +// IsUBT returns true if the trie is verkle-tree based +func (t *TransitionTrie) IsUBT() bool { // For all intents and purposes, the calling code should treat this as a verkle trie return true } diff --git a/trie/trie_test.go b/trie/trie_test.go index b8b8edb33e85..3661933e2281 100644 --- a/trie/trie_test.go +++ b/trie/trie_test.go @@ -35,12 +35,12 @@ import ( "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/keccak" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/internal/testrand" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie/trienode" "github.com/holiman/uint256" - "golang.org/x/crypto/sha3" ) func init() { @@ -880,6 +880,7 @@ func (b *spongeBatch) ValueSize() int { return 100 } func (b *spongeBatch) Write() error { return nil } func (b *spongeBatch) Reset() {} func (b *spongeBatch) Replay(w ethdb.KeyValueWriter) error { return nil } +func (b *spongeBatch) Close() {} // TestCommitSequence tests that the trie.Commit operation writes the elements // of the trie in the expected order. @@ -968,7 +969,7 @@ func TestCommitSequenceStackTrie(t *testing.T) { prng := rand.New(rand.NewSource(int64(count))) // This spongeDb is used to check the sequence of disk-db-writes s := &spongeDb{ - sponge: sha3.NewLegacyKeccak256(), + sponge: keccak.NewLegacyKeccak256(), id: "a", values: make(map[string]string), } @@ -977,7 +978,7 @@ func TestCommitSequenceStackTrie(t *testing.T) { // Another sponge is used for the stacktrie commits stackTrieSponge := &spongeDb{ - sponge: sha3.NewLegacyKeccak256(), + sponge: keccak.NewLegacyKeccak256(), id: "b", values: make(map[string]string), } @@ -1040,7 +1041,7 @@ func TestCommitSequenceStackTrie(t *testing.T) { // not fit into 32 bytes, rlp-encoded. However, it's still the correct thing to do. func TestCommitSequenceSmallRoot(t *testing.T) { s := &spongeDb{ - sponge: sha3.NewLegacyKeccak256(), + sponge: keccak.NewLegacyKeccak256(), id: "a", values: make(map[string]string), } @@ -1049,7 +1050,7 @@ func TestCommitSequenceSmallRoot(t *testing.T) { // Another sponge is used for the stacktrie commits stackTrieSponge := &spongeDb{ - sponge: sha3.NewLegacyKeccak256(), + sponge: keccak.NewLegacyKeccak256(), id: "b", values: make(map[string]string), } diff --git a/trie/utils/verkle.go b/trie/utils/verkle.go deleted file mode 100644 index 2e42477b8d9e..000000000000 --- a/trie/utils/verkle.go +++ /dev/null @@ -1,413 +0,0 @@ -// Copyright 2023 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package utils - -import ( - "encoding/binary" - "sync" - - "github.com/crate-crypto/go-ipa/bandersnatch/fr" - "github.com/ethereum/go-ethereum/common/lru" - "github.com/ethereum/go-ethereum/metrics" - "github.com/ethereum/go-verkle" - "github.com/holiman/uint256" -) - -const ( - BasicDataLeafKey = 0 - CodeHashLeafKey = 1 - - BasicDataVersionOffset = 0 - BasicDataCodeSizeOffset = 5 - BasicDataNonceOffset = 8 - BasicDataBalanceOffset = 16 -) - -var ( - zero = uint256.NewInt(0) - verkleNodeWidthLog2 = 8 - headerStorageOffset = uint256.NewInt(64) - codeOffset = uint256.NewInt(128) - verkleNodeWidth = uint256.NewInt(256) - codeStorageDelta = uint256.NewInt(0).Sub(codeOffset, headerStorageOffset) - mainStorageOffsetLshVerkleNodeWidth = new(uint256.Int).Lsh(uint256.NewInt(1), 248-uint(verkleNodeWidthLog2)) - CodeOffset = uint256.NewInt(128) - VerkleNodeWidth = uint256.NewInt(256) - HeaderStorageOffset = uint256.NewInt(64) - VerkleNodeWidthLog2 = 8 - - index0Point *verkle.Point // pre-computed commitment of polynomial [2+256*64] - - // cacheHitGauge is the metric to track how many cache hit occurred. - cacheHitGauge = metrics.NewRegisteredGauge("trie/verkle/cache/hit", nil) - - // cacheMissGauge is the metric to track how many cache miss occurred. - cacheMissGauge = metrics.NewRegisteredGauge("trie/verkle/cache/miss", nil) -) - -func init() { - // The byte array is the Marshalled output of the point computed as such: - // - // var ( - // config = verkle.GetConfig() - // fr verkle.Fr - // ) - // verkle.FromLEBytes(&fr, []byte{2, 64}) - // point := config.CommitToPoly([]verkle.Fr{fr}, 1) - index0Point = new(verkle.Point) - err := index0Point.SetBytes([]byte{34, 25, 109, 242, 193, 5, 144, 224, 76, 52, 189, 92, 197, 126, 9, 145, 27, 152, 199, 130, 165, 3, 210, 27, 193, 131, 142, 28, 110, 26, 16, 191}) - if err != nil { - panic(err) - } -} - -// PointCache is the LRU cache for storing evaluated address commitment. -type PointCache struct { - lru lru.BasicLRU[string, *verkle.Point] - lock sync.RWMutex -} - -// NewPointCache returns the cache with specified size. -func NewPointCache(maxItems int) *PointCache { - return &PointCache{ - lru: lru.NewBasicLRU[string, *verkle.Point](maxItems), - } -} - -// Get returns the cached commitment for the specified address, or computing -// it on the flight. -func (c *PointCache) Get(addr []byte) *verkle.Point { - c.lock.Lock() - defer c.lock.Unlock() - - p, ok := c.lru.Get(string(addr)) - if ok { - cacheHitGauge.Inc(1) - return p - } - cacheMissGauge.Inc(1) - p = evaluateAddressPoint(addr) - c.lru.Add(string(addr), p) - return p -} - -// GetStem returns the first 31 bytes of the tree key as the tree stem. It only -// works for the account metadata whose treeIndex is 0. -func (c *PointCache) GetStem(addr []byte) []byte { - p := c.Get(addr) - return pointToHash(p, 0)[:31] -} - -// GetTreeKey performs both the work of the spec's get_tree_key function, and that -// of pedersen_hash: it builds the polynomial in pedersen_hash without having to -// create a mostly zero-filled buffer and "type cast" it to a 128-long 16-byte -// array. Since at most the first 5 coefficients of the polynomial will be non-zero, -// these 5 coefficients are created directly. -func GetTreeKey(address []byte, treeIndex *uint256.Int, subIndex byte) []byte { - if len(address) < 32 { - var aligned [32]byte - address = append(aligned[:32-len(address)], address...) - } - // poly = [2+256*64, address_le_low, address_le_high, tree_index_le_low, tree_index_le_high] - var poly [5]fr.Element - - // 32-byte address, interpreted as two little endian - // 16-byte numbers. - verkle.FromLEBytes(&poly[1], address[:16]) - verkle.FromLEBytes(&poly[2], address[16:]) - - // treeIndex must be interpreted as a 32-byte aligned little-endian integer. - // e.g: if treeIndex is 0xAABBCC, we need the byte representation to be 0xCCBBAA00...00. - // poly[3] = LE({CC,BB,AA,00...0}) (16 bytes), poly[4]=LE({00,00,...}) (16 bytes). - // - // To avoid unnecessary endianness conversions for go-ipa, we do some trick: - // - poly[3]'s byte representation is the same as the *top* 16 bytes (trieIndexBytes[16:]) of - // 32-byte aligned big-endian representation (BE({00,...,AA,BB,CC})). - // - poly[4]'s byte representation is the same as the *low* 16 bytes (trieIndexBytes[:16]) of - // the 32-byte aligned big-endian representation (BE({00,00,...}). - trieIndexBytes := treeIndex.Bytes32() - verkle.FromBytes(&poly[3], trieIndexBytes[16:]) - verkle.FromBytes(&poly[4], trieIndexBytes[:16]) - - cfg := verkle.GetConfig() - ret := cfg.CommitToPoly(poly[:], 0) - - // add a constant point corresponding to poly[0]=[2+256*64]. - ret.Add(ret, index0Point) - - return pointToHash(ret, subIndex) -} - -// GetTreeKeyWithEvaluatedAddress is basically identical to GetTreeKey, the only -// difference is a part of polynomial is already evaluated. -// -// Specifically, poly = [2+256*64, address_le_low, address_le_high] is already -// evaluated. -func GetTreeKeyWithEvaluatedAddress(evaluated *verkle.Point, treeIndex *uint256.Int, subIndex byte) []byte { - var poly [5]fr.Element - - // little-endian, 32-byte aligned treeIndex - var index [32]byte - for i := 0; i < len(treeIndex); i++ { - binary.LittleEndian.PutUint64(index[i*8:(i+1)*8], treeIndex[i]) - } - verkle.FromLEBytes(&poly[3], index[:16]) - verkle.FromLEBytes(&poly[4], index[16:]) - - cfg := verkle.GetConfig() - ret := cfg.CommitToPoly(poly[:], 0) - - // add the pre-evaluated address - ret.Add(ret, evaluated) - - return pointToHash(ret, subIndex) -} - -// BasicDataKey returns the verkle tree key of the basic data field for -// the specified account. -func BasicDataKey(address []byte) []byte { - return GetTreeKey(address, zero, BasicDataLeafKey) -} - -// CodeHashKey returns the verkle tree key of the code hash field for -// the specified account. -func CodeHashKey(address []byte) []byte { - return GetTreeKey(address, zero, CodeHashLeafKey) -} - -func codeChunkIndex(chunk *uint256.Int) (*uint256.Int, byte) { - var ( - chunkOffset = new(uint256.Int).Add(codeOffset, chunk) - treeIndex, subIndexMod = new(uint256.Int).DivMod(chunkOffset, verkleNodeWidth, new(uint256.Int)) - ) - return treeIndex, byte(subIndexMod.Uint64()) -} - -// CodeChunkKey returns the verkle tree key of the code chunk for the -// specified account. -func CodeChunkKey(address []byte, chunk *uint256.Int) []byte { - treeIndex, subIndex := codeChunkIndex(chunk) - return GetTreeKey(address, treeIndex, subIndex) -} - -func GetTreeKeyCodeChunkIndices(chunk *uint256.Int) (*uint256.Int, byte) { - chunkOffset := new(uint256.Int).Add(CodeOffset, chunk) - treeIndex := new(uint256.Int).Div(chunkOffset, VerkleNodeWidth) - subIndexMod := new(uint256.Int).Mod(chunkOffset, VerkleNodeWidth) - var subIndex byte - if len(subIndexMod) != 0 { - subIndex = byte(subIndexMod[0]) - } - return treeIndex, subIndex -} - -func GetTreeKeyCodeChunk(address []byte, chunk *uint256.Int) []byte { - treeIndex, subIndex := GetTreeKeyCodeChunkIndices(chunk) - return GetTreeKey(address, treeIndex, subIndex) -} - -func StorageIndex(storageKey []byte) (*uint256.Int, byte) { - // If the storage slot is in the header, we need to add the header offset. - var key uint256.Int - key.SetBytes(storageKey) - if key.Cmp(codeStorageDelta) < 0 { - // This addition is always safe; it can't ever overflow since pos. - -package utils - -import ( - "bytes" - "testing" - - "github.com/ethereum/go-verkle" - "github.com/holiman/uint256" -) - -func TestTreeKey(t *testing.T) { - var ( - address = []byte{0x01} - addressEval = evaluateAddressPoint(address) - smallIndex = uint256.NewInt(1) - largeIndex = uint256.NewInt(10000) - smallStorage = []byte{0x1} - largeStorage = bytes.Repeat([]byte{0xff}, 16) - ) - if !bytes.Equal(BasicDataKey(address), BasicDataKeyWithEvaluatedAddress(addressEval)) { - t.Fatal("Unmatched basic data key") - } - if !bytes.Equal(CodeHashKey(address), CodeHashKeyWithEvaluatedAddress(addressEval)) { - t.Fatal("Unmatched code hash key") - } - if !bytes.Equal(CodeChunkKey(address, smallIndex), CodeChunkKeyWithEvaluatedAddress(addressEval, smallIndex)) { - t.Fatal("Unmatched code chunk key") - } - if !bytes.Equal(CodeChunkKey(address, largeIndex), CodeChunkKeyWithEvaluatedAddress(addressEval, largeIndex)) { - t.Fatal("Unmatched code chunk key") - } - if !bytes.Equal(StorageSlotKey(address, smallStorage), StorageSlotKeyWithEvaluatedAddress(addressEval, smallStorage)) { - t.Fatal("Unmatched storage slot key") - } - if !bytes.Equal(StorageSlotKey(address, largeStorage), StorageSlotKeyWithEvaluatedAddress(addressEval, largeStorage)) { - t.Fatal("Unmatched storage slot key") - } -} - -// goos: darwin -// goarch: amd64 -// pkg: github.com/ethereum/go-ethereum/trie/utils -// cpu: VirtualApple @ 2.50GHz -// BenchmarkTreeKey -// BenchmarkTreeKey-8 398731 2961 ns/op 32 B/op 1 allocs/op -func BenchmarkTreeKey(b *testing.B) { - // Initialize the IPA settings which can be pretty expensive. - verkle.GetConfig() - - b.ReportAllocs() - b.ResetTimer() - - for i := 0; i < b.N; i++ { - BasicDataKey([]byte{0x01}) - } -} - -// goos: darwin -// goarch: amd64 -// pkg: github.com/ethereum/go-ethereum/trie/utils -// cpu: VirtualApple @ 2.50GHz -// BenchmarkTreeKeyWithEvaluation -// BenchmarkTreeKeyWithEvaluation-8 513855 2324 ns/op 32 B/op 1 allocs/op -func BenchmarkTreeKeyWithEvaluation(b *testing.B) { - // Initialize the IPA settings which can be pretty expensive. - verkle.GetConfig() - - addr := []byte{0x01} - eval := evaluateAddressPoint(addr) - - b.ReportAllocs() - b.ResetTimer() - for i := 0; i < b.N; i++ { - BasicDataKeyWithEvaluatedAddress(eval) - } -} - -// goos: darwin -// goarch: amd64 -// pkg: github.com/ethereum/go-ethereum/trie/utils -// cpu: VirtualApple @ 2.50GHz -// BenchmarkStorageKey -// BenchmarkStorageKey-8 230516 4584 ns/op 96 B/op 3 allocs/op -func BenchmarkStorageKey(b *testing.B) { - // Initialize the IPA settings which can be pretty expensive. - verkle.GetConfig() - - b.ReportAllocs() - b.ResetTimer() - - for i := 0; i < b.N; i++ { - StorageSlotKey([]byte{0x01}, bytes.Repeat([]byte{0xff}, 32)) - } -} - -// goos: darwin -// goarch: amd64 -// pkg: github.com/ethereum/go-ethereum/trie/utils -// cpu: VirtualApple @ 2.50GHz -// BenchmarkStorageKeyWithEvaluation -// BenchmarkStorageKeyWithEvaluation-8 320125 3753 ns/op 96 B/op 3 allocs/op -func BenchmarkStorageKeyWithEvaluation(b *testing.B) { - // Initialize the IPA settings which can be pretty expensive. - verkle.GetConfig() - - addr := []byte{0x01} - eval := evaluateAddressPoint(addr) - - b.ReportAllocs() - b.ResetTimer() - for i := 0; i < b.N; i++ { - StorageSlotKeyWithEvaluatedAddress(eval, bytes.Repeat([]byte{0xff}, 32)) - } -} diff --git a/trie/verkle.go b/trie/verkle.go deleted file mode 100644 index 70793330c534..000000000000 --- a/trie/verkle.go +++ /dev/null @@ -1,458 +0,0 @@ -// Copyright 2023 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package trie - -import ( - "bytes" - "encoding/binary" - "errors" - "fmt" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/trie/trienode" - "github.com/ethereum/go-ethereum/trie/utils" - "github.com/ethereum/go-ethereum/triedb/database" - "github.com/ethereum/go-verkle" - "github.com/holiman/uint256" -) - -var ( - errInvalidRootType = errors.New("invalid node type for root") -) - -// VerkleTrie is a wrapper around VerkleNode that implements the trie.Trie -// interface so that Verkle trees can be reused verbatim. -type VerkleTrie struct { - root verkle.VerkleNode - cache *utils.PointCache - reader *Reader - tracer *PrevalueTracer -} - -// NewVerkleTrie constructs a verkle tree based on the specified root hash. -func NewVerkleTrie(root common.Hash, db database.NodeDatabase, cache *utils.PointCache) (*VerkleTrie, error) { - reader, err := NewReader(root, common.Hash{}, db) - if err != nil { - return nil, err - } - t := &VerkleTrie{ - root: verkle.New(), - cache: cache, - reader: reader, - tracer: NewPrevalueTracer(), - } - // Parse the root verkle node if it's not empty. - if root != types.EmptyVerkleHash && root != types.EmptyRootHash { - blob, err := t.nodeResolver(nil) - if err != nil { - return nil, err - } - node, err := verkle.ParseNode(blob, 0) - if err != nil { - return nil, err - } - t.root = node - } - return t, nil -} - -// GetKey returns the sha3 preimage of a hashed key that was previously used -// to store a value. -func (t *VerkleTrie) GetKey(key []byte) []byte { - return key -} - -// GetAccount implements state.Trie, retrieving the account with the specified -// account address. If the specified account is not in the verkle tree, nil will -// be returned. If the tree is corrupted, an error will be returned. -func (t *VerkleTrie) GetAccount(addr common.Address) (*types.StateAccount, error) { - var ( - acc = &types.StateAccount{} - values [][]byte - err error - ) - switch n := t.root.(type) { - case *verkle.InternalNode: - values, err = n.GetValuesAtStem(t.cache.GetStem(addr[:]), t.nodeResolver) - if err != nil { - return nil, fmt.Errorf("GetAccount (%x) error: %v", addr, err) - } - default: - return nil, errInvalidRootType - } - if values == nil { - return nil, nil - } - basicData := values[utils.BasicDataLeafKey] - acc.Nonce = binary.BigEndian.Uint64(basicData[utils.BasicDataNonceOffset:]) - acc.Balance = new(uint256.Int).SetBytes(basicData[utils.BasicDataBalanceOffset : utils.BasicDataBalanceOffset+16]) - acc.CodeHash = values[utils.CodeHashLeafKey] - - // TODO account.Root is leave as empty. How should we handle the legacy account? - return acc, nil -} - -// PrefetchAccount attempts to resolve specific accounts from the database -// to accelerate subsequent trie operations. -func (t *VerkleTrie) PrefetchAccount(addresses []common.Address) error { - for _, addr := range addresses { - if _, err := t.GetAccount(addr); err != nil { - return err - } - } - return nil -} - -// GetStorage implements state.Trie, retrieving the storage slot with the specified -// account address and storage key. If the specified slot is not in the verkle tree, -// nil will be returned. If the tree is corrupted, an error will be returned. -func (t *VerkleTrie) GetStorage(addr common.Address, key []byte) ([]byte, error) { - k := utils.StorageSlotKeyWithEvaluatedAddress(t.cache.Get(addr.Bytes()), key) - val, err := t.root.Get(k, t.nodeResolver) - if err != nil { - return nil, err - } - return common.TrimLeftZeroes(val), nil -} - -// PrefetchStorage attempts to resolve specific storage slots from the database -// to accelerate subsequent trie operations. -func (t *VerkleTrie) PrefetchStorage(addr common.Address, keys [][]byte) error { - for _, key := range keys { - if _, err := t.GetStorage(addr, key); err != nil { - return err - } - } - return nil -} - -// UpdateAccount implements state.Trie, writing the provided account into the tree. -// If the tree is corrupted, an error will be returned. -func (t *VerkleTrie) UpdateAccount(addr common.Address, acc *types.StateAccount, codeLen int) error { - var ( - err error - basicData [32]byte - values = make([][]byte, verkle.NodeWidth) - stem = t.cache.GetStem(addr[:]) - ) - - // Code size is encoded in BasicData as a 3-byte big-endian integer. Spare bytes are present - // before the code size to support bigger integers in the future. PutUint32(...) requires - // 4 bytes, so we need to shift the offset 1 byte to the left. - binary.BigEndian.PutUint32(basicData[utils.BasicDataCodeSizeOffset-1:], uint32(codeLen)) - binary.BigEndian.PutUint64(basicData[utils.BasicDataNonceOffset:], acc.Nonce) - if acc.Balance.ByteLen() > 16 { - panic("balance too large") - } - acc.Balance.WriteToSlice(basicData[utils.BasicDataBalanceOffset : utils.BasicDataBalanceOffset+16]) - values[utils.BasicDataLeafKey] = basicData[:] - values[utils.CodeHashLeafKey] = acc.CodeHash[:] - - switch root := t.root.(type) { - case *verkle.InternalNode: - err = root.InsertValuesAtStem(stem, values, t.nodeResolver) - default: - return errInvalidRootType - } - if err != nil { - return fmt.Errorf("UpdateAccount (%x) error: %v", addr, err) - } - - return nil -} - -// UpdateStorage implements state.Trie, writing the provided storage slot into -// the tree. If the tree is corrupted, an error will be returned. -func (t *VerkleTrie) UpdateStorage(address common.Address, key, value []byte) error { - // Left padding the slot value to 32 bytes. - var v [32]byte - if len(value) >= 32 { - copy(v[:], value[:32]) - } else { - copy(v[32-len(value):], value[:]) - } - k := utils.StorageSlotKeyWithEvaluatedAddress(t.cache.Get(address.Bytes()), key) - return t.root.Insert(k, v[:], t.nodeResolver) -} - -// DeleteAccount leaves the account untouched, as no account deletion can happen -// in verkle. -// There is a special corner case, in which an account that is prefunded, CREATE2-d -// and then SELFDESTRUCT-d should see its funds drained. EIP161 says that account -// should be removed, but this is verboten by the verkle spec. This contains a -// workaround in which the method checks for this corner case, and if so, overwrites -// the balance with 0. This will be removed once the spec has been clarified. -func (t *VerkleTrie) DeleteAccount(addr common.Address) error { - k := utils.BasicDataKeyWithEvaluatedAddress(t.cache.Get(addr.Bytes())) - values, err := t.root.(*verkle.InternalNode).GetValuesAtStem(k, t.nodeResolver) - if err != nil { - return fmt.Errorf("Error getting data at %x in delete: %w", k, err) - } - var prefunded bool - for i, v := range values { - switch i { - case 0: - prefunded = len(v) == 32 - case 1: - prefunded = len(v) == 32 && bytes.Equal(v, types.EmptyCodeHash[:]) - default: - prefunded = v == nil - } - if !prefunded { - break - } - } - if prefunded { - t.root.Insert(k, common.Hash{}.Bytes(), t.nodeResolver) - } - return nil -} - -// RollBackAccount removes the account info + code from the tree, unlike DeleteAccount -// that will overwrite it with 0s. The first 64 storage slots are also removed. -func (t *VerkleTrie) RollBackAccount(addr common.Address) error { - var ( - evaluatedAddr = t.cache.Get(addr.Bytes()) - basicDataKey = utils.BasicDataKeyWithEvaluatedAddress(evaluatedAddr) - ) - basicDataBytes, err := t.root.Get(basicDataKey, t.nodeResolver) - if err != nil { - return fmt.Errorf("rollback: error finding code size: %w", err) - } - if len(basicDataBytes) == 0 { - return errors.New("rollback: basic data is not existent") - } - // The code size is encoded in BasicData as a 3-byte big-endian integer. Spare bytes are present - // before the code size to support bigger integers in the future. - // LittleEndian.Uint32(...) expects 4-bytes, so we need to shift the offset 1-byte to the left. - codeSize := binary.BigEndian.Uint32(basicDataBytes[utils.BasicDataCodeSizeOffset-1:]) - - // Delete the account header + first 64 slots + first 128 code chunks - _, err = t.root.(*verkle.InternalNode).DeleteAtStem(basicDataKey[:31], t.nodeResolver) - if err != nil { - return fmt.Errorf("error rolling back account header: %w", err) - } - - // Delete all further code - for i, chunknr := uint64(31*128), uint64(128); i < uint64(codeSize); i, chunknr = i+31*256, chunknr+256 { - // evaluate group key at the start of a new group - offset := uint256.NewInt(chunknr) - key := utils.CodeChunkKeyWithEvaluatedAddress(evaluatedAddr, offset) - - if _, err = t.root.(*verkle.InternalNode).DeleteAtStem(key[:], t.nodeResolver); err != nil { - return fmt.Errorf("error deleting code chunk stem (addr=%x, offset=%d) error: %w", addr[:], offset, err) - } - } - return nil -} - -// DeleteStorage implements state.Trie, deleting the specified storage slot from -// the trie. If the storage slot was not existent in the trie, no error will be -// returned. If the trie is corrupted, an error will be returned. -func (t *VerkleTrie) DeleteStorage(addr common.Address, key []byte) error { - var zero [32]byte - k := utils.StorageSlotKeyWithEvaluatedAddress(t.cache.Get(addr.Bytes()), key) - return t.root.Insert(k, zero[:], t.nodeResolver) -} - -// Hash returns the root hash of the tree. It does not write to the database and -// can be used even if the tree doesn't have one. -func (t *VerkleTrie) Hash() common.Hash { - return t.root.Commit().Bytes() -} - -// Commit writes all nodes to the tree's memory database. -func (t *VerkleTrie) Commit(_ bool) (common.Hash, *trienode.NodeSet) { - root := t.root.(*verkle.InternalNode) - nodes, err := root.BatchSerialize() - if err != nil { - // Error return from this function indicates error in the code logic - // of BatchSerialize, and we fail catastrophically if this is the case. - panic(fmt.Errorf("BatchSerialize failed: %v", err)) - } - nodeset := trienode.NewNodeSet(common.Hash{}) - for _, node := range nodes { - // Hash parameter is not used in pathdb - nodeset.AddNode(node.Path, trienode.NewNodeWithPrev(common.Hash{}, node.SerializedBytes, t.tracer.Get(node.Path))) - } - // Serialize root commitment form - return t.Hash(), nodeset -} - -// NodeIterator implements state.Trie, returning an iterator that returns -// nodes of the trie. Iteration starts at the key after the given start key. -// -// TODO(gballet, rjl493456442) implement it. -func (t *VerkleTrie) NodeIterator(startKey []byte) (NodeIterator, error) { - // TODO(@CPerezz): remove. - return nil, errors.New("not implemented") -} - -// Prove implements state.Trie, constructing a Merkle proof for key. The result -// contains all encoded nodes on the path to the value at key. The value itself -// is also included in the last node and can be retrieved by verifying the proof. -// -// If the trie does not contain a value for key, the returned proof contains all -// nodes of the longest existing prefix of the key (at least the root), ending -// with the node that proves the absence of the key. -// -// TODO(gballet, rjl493456442) implement it. -func (t *VerkleTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error { - panic("not implemented") -} - -// Copy returns a deep-copied verkle tree. -func (t *VerkleTrie) Copy() *VerkleTrie { - return &VerkleTrie{ - root: t.root.Copy(), - cache: t.cache, - reader: t.reader, - tracer: t.tracer.Copy(), - } -} - -// IsVerkle indicates if the trie is a Verkle trie. -func (t *VerkleTrie) IsVerkle() bool { - return true -} - -// Proof builds and returns the verkle multiproof for keys, built against -// the pre tree. The post tree is passed in order to add the post values -// to that proof. -func (t *VerkleTrie) Proof(posttrie *VerkleTrie, keys [][]byte) (*verkle.VerkleProof, verkle.StateDiff, error) { - var postroot verkle.VerkleNode - if posttrie != nil { - postroot = posttrie.root - } - proof, _, _, _, err := verkle.MakeVerkleMultiProof(t.root, postroot, keys, t.nodeResolver) - if err != nil { - return nil, nil, err - } - p, kvps, err := verkle.SerializeProof(proof) - if err != nil { - return nil, nil, err - } - return p, kvps, nil -} - -// ChunkedCode represents a sequence of 32-bytes chunks of code (31 bytes of which -// are actual code, and 1 byte is the pushdata offset). -type ChunkedCode []byte - -// Copy the values here so as to avoid an import cycle -const ( - PUSH1 = byte(0x60) - PUSH32 = byte(0x7f) -) - -// ChunkifyCode generates the chunked version of an array representing EVM bytecode -func ChunkifyCode(code []byte) ChunkedCode { - var ( - chunkOffset = 0 // offset in the chunk - chunkCount = len(code) / 31 - codeOffset = 0 // offset in the code - ) - if len(code)%31 != 0 { - chunkCount++ - } - chunks := make([]byte, chunkCount*32) - for i := 0; i < chunkCount; i++ { - // number of bytes to copy, 31 unless the end of the code has been reached. - end := 31 * (i + 1) - if len(code) < end { - end = len(code) - } - copy(chunks[i*32+1:], code[31*i:end]) // copy the code itself - - // chunk offset = taken from the last chunk. - if chunkOffset > 31 { - // skip offset calculation if push data covers the whole chunk - chunks[i*32] = 31 - chunkOffset = 1 - continue - } - chunks[32*i] = byte(chunkOffset) - chunkOffset = 0 - - // Check each instruction and update the offset it should be 0 unless - // a PUSH-N overflows. - for ; codeOffset < end; codeOffset++ { - if code[codeOffset] >= PUSH1 && code[codeOffset] <= PUSH32 { - codeOffset += int(code[codeOffset] - PUSH1 + 1) - if codeOffset+1 >= 31*(i+1) { - codeOffset++ - chunkOffset = codeOffset - 31*(i+1) - break - } - } - } - } - return chunks -} - -// UpdateContractCode implements state.Trie, writing the provided contract code -// into the trie. -// Note that the code-size *must* be already saved by a previous UpdateAccount call. -func (t *VerkleTrie) UpdateContractCode(addr common.Address, codeHash common.Hash, code []byte) error { - var ( - chunks = ChunkifyCode(code) - values [][]byte - key []byte - err error - ) - for i, chunknr := 0, uint64(0); i < len(chunks); i, chunknr = i+32, chunknr+1 { - groupOffset := (chunknr + 128) % 256 - if groupOffset == 0 /* start of new group */ || chunknr == 0 /* first chunk in header group */ { - values = make([][]byte, verkle.NodeWidth) - key = utils.CodeChunkKeyWithEvaluatedAddress(t.cache.Get(addr.Bytes()), uint256.NewInt(chunknr)) - } - values[groupOffset] = chunks[i : i+32] - - if groupOffset == 255 || len(chunks)-i <= 32 { - switch root := t.root.(type) { - case *verkle.InternalNode: - err = root.InsertValuesAtStem(key[:31], values, t.nodeResolver) - if err != nil { - return fmt.Errorf("UpdateContractCode (addr=%x) error: %w", addr[:], err) - } - default: - return errInvalidRootType - } - } - } - return nil -} - -func (t *VerkleTrie) ToDot() string { - return verkle.ToDot(t.root) -} - -func (t *VerkleTrie) nodeResolver(path []byte) ([]byte, error) { - blob, err := t.reader.Node(path, common.Hash{}) - if err != nil { - return nil, err - } - t.tracer.Put(path, blob) - return blob, nil -} - -// Witness returns a set containing all trie nodes that have been accessed. -func (t *VerkleTrie) Witness() map[string][]byte { - panic("not implemented") -} diff --git a/trie/verkle_test.go b/trie/verkle_test.go deleted file mode 100644 index 1832e3db1338..000000000000 --- a/trie/verkle_test.go +++ /dev/null @@ -1,173 +0,0 @@ -// Copyright 2023 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package trie - -import ( - "bytes" - "reflect" - "testing" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/rawdb" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/trie/utils" - "github.com/holiman/uint256" -) - -var ( - accounts = map[common.Address]*types.StateAccount{ - {1}: { - Nonce: 100, - Balance: uint256.NewInt(100), - CodeHash: common.Hash{0x1}.Bytes(), - }, - {2}: { - Nonce: 200, - Balance: uint256.NewInt(200), - CodeHash: common.Hash{0x2}.Bytes(), - }, - } - storages = map[common.Address]map[common.Hash][]byte{ - {1}: { - common.Hash{10}: []byte{10}, - common.Hash{11}: []byte{11}, - common.MaxHash: []byte{0xff}, - }, - {2}: { - common.Hash{20}: []byte{20}, - common.Hash{21}: []byte{21}, - common.MaxHash: []byte{0xff}, - }, - } -) - -func TestVerkleTreeReadWrite(t *testing.T) { - db := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.PathScheme) - tr, _ := NewVerkleTrie(types.EmptyVerkleHash, db, utils.NewPointCache(100)) - - for addr, acct := range accounts { - if err := tr.UpdateAccount(addr, acct, 0); err != nil { - t.Fatalf("Failed to update account, %v", err) - } - for key, val := range storages[addr] { - if err := tr.UpdateStorage(addr, key.Bytes(), val); err != nil { - t.Fatalf("Failed to update storage, %v", err) - } - } - } - - for addr, acct := range accounts { - stored, err := tr.GetAccount(addr) - if err != nil { - t.Fatalf("Failed to get account, %v", err) - } - if !reflect.DeepEqual(stored, acct) { - t.Fatal("account is not matched") - } - for key, val := range storages[addr] { - stored, err := tr.GetStorage(addr, key.Bytes()) - if err != nil { - t.Fatalf("Failed to get storage, %v", err) - } - if !bytes.Equal(stored, val) { - t.Fatal("storage is not matched") - } - } - } -} - -func TestVerkleRollBack(t *testing.T) { - db := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.PathScheme) - tr, _ := NewVerkleTrie(types.EmptyVerkleHash, db, utils.NewPointCache(100)) - - for addr, acct := range accounts { - // create more than 128 chunks of code - code := make([]byte, 129*32) - for i := 0; i < len(code); i += 2 { - code[i] = 0x60 - code[i+1] = byte(i % 256) - } - if err := tr.UpdateAccount(addr, acct, len(code)); err != nil { - t.Fatalf("Failed to update account, %v", err) - } - for key, val := range storages[addr] { - if err := tr.UpdateStorage(addr, key.Bytes(), val); err != nil { - t.Fatalf("Failed to update storage, %v", err) - } - } - hash := crypto.Keccak256Hash(code) - if err := tr.UpdateContractCode(addr, hash, code); err != nil { - t.Fatalf("Failed to update contract, %v", err) - } - } - - // Check that things were created - for addr, acct := range accounts { - stored, err := tr.GetAccount(addr) - if err != nil { - t.Fatalf("Failed to get account, %v", err) - } - if !reflect.DeepEqual(stored, acct) { - t.Fatal("account is not matched") - } - for key, val := range storages[addr] { - stored, err := tr.GetStorage(addr, key.Bytes()) - if err != nil { - t.Fatalf("Failed to get storage, %v", err) - } - if !bytes.Equal(stored, val) { - t.Fatal("storage is not matched") - } - } - } - - // ensure there is some code in the 2nd group of the 1st account - keyOf2ndGroup := utils.CodeChunkKeyWithEvaluatedAddress(tr.cache.Get(common.Address{1}.Bytes()), uint256.NewInt(128)) - chunk, err := tr.root.Get(keyOf2ndGroup, nil) - if err != nil { - t.Fatalf("Failed to get account, %v", err) - } - if len(chunk) == 0 { - t.Fatal("account was not created ") - } - - // Rollback first account and check that it is gone - addr1 := common.Address{1} - err = tr.RollBackAccount(addr1) - if err != nil { - t.Fatalf("error rolling back address 1: %v", err) - } - - // ensure the account is gone - stored, err := tr.GetAccount(addr1) - if err != nil { - t.Fatalf("Failed to get account, %v", err) - } - if stored != nil { - t.Fatal("account was not deleted") - } - - // ensure that the last code chunk is also gone from the tree - chunk, err = tr.root.Get(keyOf2ndGroup, nil) - if err != nil { - t.Fatalf("Failed to get account, %v", err) - } - if len(chunk) != 0 { - t.Fatal("account was not deleted") - } -} diff --git a/triedb/database.go b/triedb/database.go index d2637bd909a5..ef95169df1ae 100644 --- a/triedb/database.go +++ b/triedb/database.go @@ -31,26 +31,30 @@ import ( // Config defines all necessary options for database. type Config struct { - Preimages bool // Flag whether the preimage of node key is recorded - IsVerkle bool // Flag whether the db is holding a verkle tree - HashDB *hashdb.Config // Configs for hash-based scheme - PathDB *pathdb.Config // Configs for experimental path-based scheme + Preimages bool // Flag whether the preimage of node key is recorded + IsUBT bool // Flag whether the db is holding a unified binary tree + BinTrieGroupDepth int // Number of levels per serialized group in binary trie (1-8, default 8) + HashDB *hashdb.Config // Configs for hash-based scheme + PathDB *pathdb.Config // Configs for experimental path-based scheme } +const DefaultBinTrieGroupDepth = 5 + // HashDefaults represents a config for using hash-based scheme with // default settings. var HashDefaults = &Config{ Preimages: false, - IsVerkle: false, + IsUBT: false, HashDB: hashdb.Defaults, } -// VerkleDefaults represents a config for holding verkle trie data +// UBTDefaults represents a config for holding unified binary trie data // using path-based scheme with default settings. -var VerkleDefaults = &Config{ - Preimages: false, - IsVerkle: true, - PathDB: pathdb.Defaults, +var UBTDefaults = &Config{ + Preimages: false, + IsUBT: true, + BinTrieGroupDepth: DefaultBinTrieGroupDepth, + PathDB: pathdb.Defaults, } // backend defines the methods needed to access/update trie nodes in different @@ -109,7 +113,7 @@ func NewDatabase(diskdb ethdb.Database, config *Config) *Database { log.Crit("Both 'hash' and 'path' mode are configured") } if config.PathDB != nil { - db.backend = pathdb.New(diskdb, config.PathDB, config.IsVerkle) + db.backend = pathdb.New(diskdb, config.PathDB, config.IsUBT) } else { db.backend = hashdb.New(diskdb, config.HashDB) } @@ -129,8 +133,8 @@ func (db *Database) StateReader(blockRoot common.Hash) (database.StateReader, er return db.backend.StateReader(blockRoot) } -// HistoricReader constructs a reader for accessing the requested historic state. -func (db *Database) HistoricReader(root common.Hash) (*pathdb.HistoricalStateReader, error) { +// HistoricStateReader constructs a reader for accessing the requested historic state. +func (db *Database) HistoricStateReader(root common.Hash) (*pathdb.HistoricalStateReader, error) { pdb, ok := db.backend.(*pathdb.Database) if !ok { return nil, errors.New("not supported") @@ -138,6 +142,15 @@ func (db *Database) HistoricReader(root common.Hash) (*pathdb.HistoricalStateRea return pdb.HistoricReader(root) } +// HistoricNodeReader constructs a reader for accessing the historical trie node. +func (db *Database) HistoricNodeReader(root common.Hash) (*pathdb.HistoricalNodeReader, error) { + pdb, ok := db.backend.(*pathdb.Database) + if !ok { + return nil, errors.New("not supported") + } + return pdb.HistoricNodeReader(root) +} + // Update performs a state transition by committing dirty nodes contained in the // given set in order to update state from the specified parent to the specified // root. The held pre-images accumulated up to this point will be flushed in case @@ -314,6 +327,16 @@ func (db *Database) Enable(root common.Hash) error { return pdb.Enable(root) } +// AdoptSyncedState activates the database after a snap/2 sync and adopts the +// flat state populated during sync as-is, skipping regeneration. +func (db *Database) AdoptSyncedState(root common.Hash) error { + pdb, ok := db.backend.(*pathdb.Database) + if !ok { + return errors.New("not supported") + } + return pdb.AdoptSyncedState(root) +} + // Journal commits an entire diff hierarchy to disk into a single journal entry. // This is meant to be used during shutdown to persist the snapshot without // flattening everything down (bad for reorgs). It's only supported by path-based @@ -358,17 +381,17 @@ func (db *Database) StorageIterator(root common.Hash, account common.Hash, seek // IndexProgress returns the indexing progress made so far. It provides the // number of states that remain unindexed. -func (db *Database) IndexProgress() (uint64, error) { +func (db *Database) IndexProgress() (uint64, uint64, error) { pdb, ok := db.backend.(*pathdb.Database) if !ok { - return 0, errors.New("not supported") + return 0, 0, errors.New("not supported") } return pdb.IndexProgress() } -// IsVerkle returns the indicator if the database is holding a verkle tree. -func (db *Database) IsVerkle() bool { - return db.config.IsVerkle +// IsUBT returns the indicator if the database is holding a verkle tree. +func (db *Database) IsUBT() bool { + return db.config.IsUBT } // Disk returns the underlying disk database. @@ -384,3 +407,7 @@ func (db *Database) SnapshotCompleted() bool { } return pdb.SnapshotCompleted() } + +func (db *Database) BinTrieGroupDepth() int { + return db.config.BinTrieGroupDepth +} diff --git a/triedb/generate.go b/triedb/generate.go new file mode 100644 index 000000000000..259e139848ce --- /dev/null +++ b/triedb/generate.go @@ -0,0 +1,108 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package triedb + +import ( + "fmt" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/triedb/internal" +) + +// kvAccountIterator wraps an ethdb.Iterator to iterate over account snapshot +// entries in the database, implementing internal.AccountIterator. +type kvAccountIterator struct { + it ethdb.Iterator + hash common.Hash +} + +func newKVAccountIterator(db ethdb.Iteratee) *kvAccountIterator { + it := rawdb.NewKeyLengthIterator( + db.NewIterator(rawdb.SnapshotAccountPrefix, nil), + len(rawdb.SnapshotAccountPrefix)+common.HashLength, + ) + return &kvAccountIterator{it: it} +} + +func (it *kvAccountIterator) Next() bool { + if !it.it.Next() { + return false + } + key := it.it.Key() + copy(it.hash[:], key[len(rawdb.SnapshotAccountPrefix):]) + return true +} + +func (it *kvAccountIterator) Hash() common.Hash { return it.hash } +func (it *kvAccountIterator) Account() []byte { return it.it.Value() } +func (it *kvAccountIterator) Error() error { return it.it.Error() } +func (it *kvAccountIterator) Release() { it.it.Release() } + +// kvStorageIterator wraps an ethdb.Iterator to iterate over storage snapshot +// entries for a specific account, implementing internal.StorageIterator. +type kvStorageIterator struct { + it ethdb.Iterator + hash common.Hash +} + +func newKVStorageIterator(db ethdb.Iteratee, accountHash common.Hash) *kvStorageIterator { + it := rawdb.IterateStorageSnapshots(db, accountHash) + return &kvStorageIterator{it: it} +} + +func (it *kvStorageIterator) Next() bool { + if !it.it.Next() { + return false + } + key := it.it.Key() + copy(it.hash[:], key[len(rawdb.SnapshotStoragePrefix)+common.HashLength:]) + return true +} + +func (it *kvStorageIterator) Hash() common.Hash { return it.hash } +func (it *kvStorageIterator) Slot() []byte { return it.it.Value() } +func (it *kvStorageIterator) Error() error { return it.it.Error() } +func (it *kvStorageIterator) Release() { it.it.Release() } + +// GenerateTrie rebuilds all tries (storage + account) from flat snapshot data +// in the database. It reads account and storage snapshots from the KV store, +// builds tries using StackTrie with streaming node writes, and verifies the +// computed state root matches the expected root. +func GenerateTrie(db ethdb.Database, scheme string, root common.Hash) error { + acctIt := newKVAccountIterator(db) + defer acctIt.Release() + + got, err := internal.GenerateTrieRoot(db, scheme, acctIt, common.Hash{}, internal.StackTrieGenerate, func(dst ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *internal.GenerateStats) (common.Hash, error) { + storageIt := newKVStorageIterator(db, accountHash) + defer storageIt.Release() + + hash, err := internal.GenerateTrieRoot(dst, scheme, storageIt, accountHash, internal.StackTrieGenerate, nil, stat, false) + if err != nil { + return common.Hash{}, err + } + return hash, nil + }, internal.NewGenerateStats(), true) + if err != nil { + return err + } + if got != root { + return fmt.Errorf("state root mismatch: got %x, want %x", got, root) + } + return nil +} diff --git a/triedb/generate_test.go b/triedb/generate_test.go new file mode 100644 index 000000000000..42bccd9aa393 --- /dev/null +++ b/triedb/generate_test.go @@ -0,0 +1,178 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package triedb + +import ( + "bytes" + "sort" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" + "github.com/holiman/uint256" +) + +// testAccount is a helper for building test state with deterministic ordering. +type testAccount struct { + hash common.Hash + account types.StateAccount + storage []testSlot // must be sorted by hash +} + +type testSlot struct { + hash common.Hash + value []byte +} + +// buildExpectedRoot computes the state root from sorted test accounts using +// StackTrie (which requires sorted key insertion). +func buildExpectedRoot(t *testing.T, accounts []testAccount) common.Hash { + t.Helper() + // Sort accounts by hash + sort.Slice(accounts, func(i, j int) bool { + return bytes.Compare(accounts[i].hash[:], accounts[j].hash[:]) < 0 + }) + acctTrie := trie.NewStackTrie(nil) + for i := range accounts { + data, err := rlp.EncodeToBytes(&accounts[i].account) + if err != nil { + t.Fatal(err) + } + acctTrie.Update(accounts[i].hash[:], data) + } + return acctTrie.Hash() +} + +// computeStorageRoot computes the storage trie root from sorted slots. +func computeStorageRoot(slots []testSlot) common.Hash { + sort.Slice(slots, func(i, j int) bool { + return bytes.Compare(slots[i].hash[:], slots[j].hash[:]) < 0 + }) + st := trie.NewStackTrie(nil) + for _, s := range slots { + st.Update(s.hash[:], s.value) + } + return st.Hash() +} + +func TestGenerateTrieEmpty(t *testing.T) { + db := rawdb.NewMemoryDatabase() + if err := GenerateTrie(db, rawdb.HashScheme, types.EmptyRootHash); err != nil { + t.Fatalf("GenerateTrie on empty state failed: %v", err) + } +} + +func TestGenerateTrieAccountsOnly(t *testing.T) { + db := rawdb.NewMemoryDatabase() + + accounts := []testAccount{ + { + hash: common.HexToHash("0x01"), + account: types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(100), + Root: types.EmptyRootHash, + CodeHash: types.EmptyCodeHash.Bytes(), + }, + }, + { + hash: common.HexToHash("0x02"), + account: types.StateAccount{ + Nonce: 2, + Balance: uint256.NewInt(200), + Root: types.EmptyRootHash, + CodeHash: types.EmptyCodeHash.Bytes(), + }, + }, + } + for _, a := range accounts { + rawdb.WriteAccountSnapshot(db, a.hash, types.SlimAccountRLP(a.account)) + } + root := buildExpectedRoot(t, accounts) + + if err := GenerateTrie(db, rawdb.HashScheme, root); err != nil { + t.Fatalf("GenerateTrie failed: %v", err) + } +} + +func TestGenerateTrieWithStorage(t *testing.T) { + db := rawdb.NewMemoryDatabase() + + slots := []testSlot{ + {hash: common.HexToHash("0xaa"), value: []byte{0x01, 0x02, 0x03}}, + {hash: common.HexToHash("0xbb"), value: []byte{0x04, 0x05, 0x06}}, + } + storageRoot := computeStorageRoot(slots) + + accounts := []testAccount{ + { + hash: common.HexToHash("0x01"), + account: types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(100), + Root: storageRoot, + CodeHash: types.EmptyCodeHash.Bytes(), + }, + storage: slots, + }, + { + hash: common.HexToHash("0x02"), + account: types.StateAccount{ + Nonce: 0, + Balance: uint256.NewInt(50), + Root: types.EmptyRootHash, + CodeHash: types.EmptyCodeHash.Bytes(), + }, + }, + } + // Write account snapshots + for _, a := range accounts { + rawdb.WriteAccountSnapshot(db, a.hash, types.SlimAccountRLP(a.account)) + } + // Write storage snapshots + for _, a := range accounts { + for _, s := range a.storage { + rawdb.WriteStorageSnapshot(db, a.hash, s.hash, s.value) + } + } + root := buildExpectedRoot(t, accounts) + + if err := GenerateTrie(db, rawdb.HashScheme, root); err != nil { + t.Fatalf("GenerateTrie failed: %v", err) + } +} + +func TestGenerateTrieRootMismatch(t *testing.T) { + db := rawdb.NewMemoryDatabase() + + acct := types.StateAccount{ + Nonce: 1, + Balance: uint256.NewInt(100), + Root: types.EmptyRootHash, + CodeHash: types.EmptyCodeHash.Bytes(), + } + rawdb.WriteAccountSnapshot(db, common.HexToHash("0x01"), types.SlimAccountRLP(acct)) + + wrongRoot := common.HexToHash("0xdeadbeef") + err := GenerateTrie(db, rawdb.HashScheme, wrongRoot) + if err == nil { + t.Fatal("expected error for root mismatch, got nil") + } +} diff --git a/triedb/hashdb/database.go b/triedb/hashdb/database.go index 38392aa5199b..90d051429049 100644 --- a/triedb/hashdb/database.go +++ b/triedb/hashdb/database.go @@ -612,6 +612,9 @@ func (db *Database) Close() error { // NodeReader returns a reader for accessing trie nodes within the specified state. // An error will be returned if the specified state is not available. func (db *Database) NodeReader(root common.Hash) (database.NodeReader, error) { + if root == types.EmptyRootHash { + return &reader{db: db}, nil + } if _, err := db.node(root); err != nil { return nil, fmt.Errorf("state %#x is not available, %v", root, err) } diff --git a/triedb/internal/conversion.go b/triedb/internal/conversion.go new file mode 100644 index 000000000000..b331b63e2119 --- /dev/null +++ b/triedb/internal/conversion.go @@ -0,0 +1,363 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// Package internal contains shared trie generation utilities used by both +// triedb and triedb/pathdb. All code is ported from +// core/state/snapshot/conversion.go (with exported names) unless noted. +package internal + +import ( + "encoding/binary" + "fmt" + "math" + "runtime" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" +) + +// Iterator is an iterator to step over all the accounts or the specific +// storage in a snapshot which may or may not be composed of multiple layers. +type Iterator interface { + // Next steps the iterator forward one element, returning false if exhausted, + // or an error if iteration failed for some reason (e.g. root being iterated + // becomes stale and garbage collected). + Next() bool + + // Error returns any failure that occurred during iteration, which might have + // caused a premature iteration exit (e.g. snapshot stack becoming stale). + Error() error + + // Hash returns the hash of the account or storage slot the iterator is + // currently at. + Hash() common.Hash + + // Release releases associated resources. Release should always succeed and + // can be called multiple times without causing error. + Release() +} + +// AccountIterator is an iterator to step over all the accounts in a snapshot, +// which may or may not be composed of multiple layers. +type AccountIterator interface { + Iterator + + // Account returns the RLP encoded slim account the iterator is currently at. + // An error will be returned if the iterator becomes invalid + Account() []byte +} + +// StorageIterator is an iterator to step over the specific storage in a snapshot, +// which may or may not be composed of multiple layers. +type StorageIterator interface { + Iterator + + // Slot returns the storage slot the iterator is currently at. An error will + // be returned if the iterator becomes invalid + Slot() []byte +} + +// TrieKV represents a trie key-value pair. +type TrieKV struct { + Key common.Hash + Value []byte +} + +type ( + // TrieGeneratorFn is the interface of trie generation which can + // be implemented by different trie algorithm. + TrieGeneratorFn func(db ethdb.KeyValueWriter, scheme string, owner common.Hash, in chan (TrieKV), out chan (common.Hash)) + + // LeafCallbackFn is the callback invoked at the leaves of the trie, + // returns the subtrie root with the specified subtrie identifier. + LeafCallbackFn func(db ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *GenerateStats) (common.Hash, error) +) + +// GenerateStats is a collection of statistics gathered by the trie generator +// for logging purposes. +type GenerateStats struct { + head common.Hash + start time.Time + + accounts uint64 // Number of accounts done (including those being crawled) + slots uint64 // Number of storage slots done (including those being crawled) + + slotsStart map[common.Hash]time.Time // Start time for account slot crawling + slotsHead map[common.Hash]common.Hash // Slot head for accounts being crawled + + lock sync.RWMutex +} + +// NewGenerateStats creates a new generator stats. +func NewGenerateStats() *GenerateStats { + return &GenerateStats{ + slotsStart: make(map[common.Hash]time.Time), + slotsHead: make(map[common.Hash]common.Hash), + start: time.Now(), + } +} + +// ProgressAccounts updates the generator stats for the account range. +func (stat *GenerateStats) ProgressAccounts(account common.Hash, done uint64) { + stat.lock.Lock() + defer stat.lock.Unlock() + + stat.accounts += done + stat.head = account +} + +// FinishAccounts updates the generator stats for the finished account range. +func (stat *GenerateStats) FinishAccounts(done uint64) { + stat.lock.Lock() + defer stat.lock.Unlock() + + stat.accounts += done +} + +// ProgressContract updates the generator stats for a specific in-progress contract. +func (stat *GenerateStats) ProgressContract(account common.Hash, slot common.Hash, done uint64) { + stat.lock.Lock() + defer stat.lock.Unlock() + + stat.slots += done + stat.slotsHead[account] = slot + if _, ok := stat.slotsStart[account]; !ok { + stat.slotsStart[account] = time.Now() + } +} + +// FinishContract updates the generator stats for a specific just-finished contract. +func (stat *GenerateStats) FinishContract(account common.Hash, done uint64) { + stat.lock.Lock() + defer stat.lock.Unlock() + + stat.slots += done + delete(stat.slotsHead, account) + delete(stat.slotsStart, account) +} + +// Report prints the cumulative progress statistic smartly. +func (stat *GenerateStats) Report() { + stat.lock.RLock() + defer stat.lock.RUnlock() + + ctx := []interface{}{ + "accounts", stat.accounts, + "slots", stat.slots, + "elapsed", common.PrettyDuration(time.Since(stat.start)), + } + if stat.accounts > 0 { + if done := binary.BigEndian.Uint64(stat.head[:8]) / stat.accounts; done > 0 { + var ( + left = (math.MaxUint64 - binary.BigEndian.Uint64(stat.head[:8])) / stat.accounts + eta = common.CalculateETA(done, left, time.Since(stat.start)) + ) + // If there are large contract crawls in progress, estimate their finish time + for acc, head := range stat.slotsHead { + start := stat.slotsStart[acc] + if done := binary.BigEndian.Uint64(head[:8]); done > 0 { + left := math.MaxUint64 - binary.BigEndian.Uint64(head[:8]) + + // Override the ETA if larger than the largest until now + if slotETA := common.CalculateETA(done, left, time.Since(start)); eta < slotETA { + eta = slotETA + } + } + } + ctx = append(ctx, []interface{}{ + "eta", common.PrettyDuration(eta), + }...) + } + } + log.Info("Iterating state snapshot", ctx...) +} + +// ReportDone prints the last log when the whole generation is finished. +func (stat *GenerateStats) ReportDone() { + stat.lock.RLock() + defer stat.lock.RUnlock() + + var ctx []interface{} + ctx = append(ctx, []interface{}{"accounts", stat.accounts}...) + if stat.slots != 0 { + ctx = append(ctx, []interface{}{"slots", stat.slots}...) + } + ctx = append(ctx, []interface{}{"elapsed", common.PrettyDuration(time.Since(stat.start))}...) + log.Info("Iterated snapshot", ctx...) +} + +// RunReport periodically prints the progress information. +func RunReport(stats *GenerateStats, stop chan bool) { + timer := time.NewTimer(0) + defer timer.Stop() + + for { + select { + case <-timer.C: + stats.Report() + timer.Reset(time.Second * 8) + case success := <-stop: + if success { + stats.ReportDone() + } + return + } + } +} + +// GenerateTrieRoot generates the trie hash based on the snapshot iterator. +// It can be used for generating account trie, storage trie or even the +// whole state which connects the accounts and the corresponding storages. +func GenerateTrieRoot(db ethdb.KeyValueWriter, scheme string, it Iterator, account common.Hash, generatorFn TrieGeneratorFn, leafCallback LeafCallbackFn, stats *GenerateStats, report bool) (common.Hash, error) { + var ( + in = make(chan TrieKV) // chan to pass leaves + out = make(chan common.Hash, 1) // chan to collect result + stoplog = make(chan bool, 1) // 1-size buffer, works when logging is not enabled + wg sync.WaitGroup + ) + // Spin up a go-routine for trie hash re-generation + wg.Add(1) + go func() { + defer wg.Done() + generatorFn(db, scheme, account, in, out) + }() + // Spin up a go-routine for progress logging + if report && stats != nil { + wg.Add(1) + go func() { + defer wg.Done() + RunReport(stats, stoplog) + }() + } + // Create a semaphore to assign tasks and collect results through. We'll pre- + // fill it with nils, thus using the same channel for both limiting concurrent + // processing and gathering results. + threads := runtime.NumCPU() + results := make(chan error, threads) + for i := 0; i < threads; i++ { + results <- nil // fill the semaphore + } + // stop is a helper function to shutdown the background threads + // and return the re-generated trie hash. + stop := func(fail error) (common.Hash, error) { + close(in) + result := <-out + for i := 0; i < threads; i++ { + if err := <-results; err != nil && fail == nil { + fail = err + } + } + stoplog <- fail == nil + + wg.Wait() + return result, fail + } + var ( + logged = time.Now() + processed = uint64(0) + leaf TrieKV + ) + // Start to feed leaves + for it.Next() { + if account == (common.Hash{}) { + var ( + err error + fullData []byte + ) + if leafCallback == nil { + fullData, err = types.FullAccountRLP(it.(AccountIterator).Account()) + if err != nil { + return stop(err) + } + } else { + // Wait until the semaphore allows us to continue, aborting if + // a sub-task failed + if err := <-results; err != nil { + results <- nil // stop will drain the results, add a noop back for this error we just consumed + return stop(err) + } + // Fetch the next account and process it concurrently + account, err := types.FullAccount(it.(AccountIterator).Account()) + if err != nil { + return stop(err) + } + go func(hash common.Hash) { + subroot, err := leafCallback(db, hash, common.BytesToHash(account.CodeHash), stats) + if err != nil { + results <- err + return + } + if account.Root != subroot { + results <- fmt.Errorf("invalid subroot(path %x), want %x, have %x", hash, account.Root, subroot) + return + } + results <- nil + }(it.Hash()) + fullData, err = rlp.EncodeToBytes(account) + if err != nil { + return stop(err) + } + } + leaf = TrieKV{it.Hash(), fullData} + } else { + leaf = TrieKV{it.Hash(), common.CopyBytes(it.(StorageIterator).Slot())} + } + in <- leaf + + // Accumulate the generation statistic if it's required. + processed++ + if time.Since(logged) > 3*time.Second && stats != nil { + if account == (common.Hash{}) { + stats.ProgressAccounts(it.Hash(), processed) + } else { + stats.ProgressContract(account, it.Hash(), processed) + } + logged, processed = time.Now(), 0 + } + } + // Commit the last part statistic. + if processed > 0 && stats != nil { + if account == (common.Hash{}) { + stats.FinishAccounts(processed) + } else { + stats.FinishContract(account, processed) + } + } + return stop(nil) +} + +// StackTrieGenerate is the trie generation function that creates a StackTrie +// and persists nodes via rawdb.WriteTrieNode. +func StackTrieGenerate(db ethdb.KeyValueWriter, scheme string, owner common.Hash, in chan TrieKV, out chan common.Hash) { + var onTrieNode trie.OnTrieNode + if db != nil { + onTrieNode = func(path []byte, hash common.Hash, blob []byte) { + rawdb.WriteTrieNode(db, owner, path, hash, blob, scheme) + } + } + t := trie.NewStackTrie(onTrieNode) + for leaf := range in { + t.Update(leaf.Key[:], leaf.Value) + } + out <- t.Hash() +} diff --git a/triedb/pathdb/buffer.go b/triedb/pathdb/buffer.go index 138962110f08..5d3099285fea 100644 --- a/triedb/pathdb/buffer.go +++ b/triedb/pathdb/buffer.go @@ -132,7 +132,7 @@ func (b *buffer) size() uint64 { // flush persists the in-memory dirty trie node into the disk if the configured // memory threshold is reached. Note, all data must be written atomically. -func (b *buffer) flush(root common.Hash, db ethdb.KeyValueStore, freezer ethdb.AncientWriter, progress []byte, nodesCache, statesCache *fastcache.Cache, id uint64, postFlush func()) { +func (b *buffer) flush(root common.Hash, db ethdb.KeyValueStore, freezers []ethdb.AncientWriter, progress []byte, nodesCache, statesCache *fastcache.Cache, id uint64, postFlush func()) { if b.done != nil { panic("duplicated flush operation") } @@ -165,11 +165,9 @@ func (b *buffer) flush(root common.Hash, db ethdb.KeyValueStore, freezer ethdb.A // // This step is crucial to guarantee that the corresponding state history remains // available for state rollback. - if freezer != nil { - if err := freezer.SyncAncient(); err != nil { - b.flushErr = err - return - } + if err := syncHistory(freezers...); err != nil { + b.flushErr = err + return } nodes := b.nodes.write(batch, nodesCache) accounts, slots := b.states.write(batch, progress, statesCache) @@ -182,6 +180,8 @@ func (b *buffer) flush(root common.Hash, db ethdb.KeyValueStore, freezer ethdb.A b.flushErr = err return } + batch.Close() + commitBytesMeter.Mark(int64(size)) commitNodesMeter.Mark(int64(nodes)) commitAccountsMeter.Mark(int64(accounts)) diff --git a/triedb/pathdb/config.go b/triedb/pathdb/config.go index 3745a63eddd3..97ee1c23158d 100644 --- a/triedb/pathdb/config.go +++ b/triedb/pathdb/config.go @@ -43,6 +43,26 @@ const ( // Do not increase the buffer size arbitrarily, otherwise the system // pause time will increase when the database writes happen. defaultBufferSize = 64 * 1024 * 1024 + + // maxFullValueCheckpoint defines the maximum allowed encoding frequency (1/16) + // for storing nodes in full format. With this setting, a node may be written + // to the trienode history as a full value at the specified frequency. + // + // Note that the frequency is not strict: the actual decision is probabilistic. + // Only the overall long-term full-value encoding rate is enforced. + // + // Values beyond this limit are considered ineffective, as the trienode history + // is already well compressed. Increasing it further will only degrade read + // performance linearly. + maxFullValueCheckpoint = 16 + + // defaultFullValueCheckpoint defines the default full-value encoding frequency + // (1/8) for storing nodes in full format. With this setting, nodes may be + // written to the trienode history as full values at the specified rate. + // + // This strikes a balance between effective compression of the trienode history + // and acceptable read performance. + defaultFullValueCheckpoint = 8 ) var ( @@ -53,6 +73,8 @@ var ( // Defaults contains default settings for Ethereum mainnet. var Defaults = &Config{ StateHistory: params.FullImmutabilityThreshold, + TrienodeHistory: -1, + FullValueCheckpoint: defaultFullValueCheckpoint, EnableStateIndexing: false, TrieCleanSize: defaultTrieCleanSize, StateCleanSize: defaultStateCleanSize, @@ -61,25 +83,32 @@ var Defaults = &Config{ // ReadOnly is the config in order to open database in read only mode. var ReadOnly = &Config{ - ReadOnly: true, - TrieCleanSize: defaultTrieCleanSize, - StateCleanSize: defaultStateCleanSize, + ReadOnly: true, + TrienodeHistory: -1, + TrieCleanSize: defaultTrieCleanSize, + StateCleanSize: defaultStateCleanSize, + FullValueCheckpoint: defaultFullValueCheckpoint, } // Config contains the settings for database. type Config struct { + TrieCleanSize int // Maximum memory allowance (in bytes) for caching clean trie data + StateCleanSize int // Maximum memory allowance (in bytes) for caching clean state data + WriteBufferSize int // Maximum memory allowance (in bytes) for write buffer + ReadOnly bool // Flag whether the database is opened in read only mode + JournalDirectory string // Absolute path of journal directory (null means the journal data is persisted in key-value store) + + // Historical state configurations StateHistory uint64 // Number of recent blocks to maintain state history for, 0: full chain + TrienodeHistory int64 // Number of recent blocks to maintain trienode history for, 0: full chain, negative: disable EnableStateIndexing bool // Whether to enable state history indexing for external state access - TrieCleanSize int // Maximum memory allowance (in bytes) for caching clean trie data - StateCleanSize int // Maximum memory allowance (in bytes) for caching clean state data - WriteBufferSize int // Maximum memory allowance (in bytes) for write buffer - ReadOnly bool // Flag whether the database is opened in read only mode - JournalDirectory string // Absolute path of journal directory (null means the journal data is persisted in key-value store) + FullValueCheckpoint uint32 // The rate at which trie nodes are encoded in full-value format // Testing configurations - SnapshotNoBuild bool // Flag Whether the state generation is disabled - NoAsyncFlush bool // Flag whether the background buffer flushing is disabled - NoAsyncGeneration bool // Flag whether the background generation is disabled + SnapshotNoBuild bool // Flag Whether the state generation is disabled + NoAsyncFlush bool // Flag whether the background buffer flushing is disabled + NoAsyncGeneration bool // Flag whether the background generation is disabled + NoHistoryIndexDelay bool // Flag whether the history index delay is disabled } // sanitize checks the provided user configurations and changes anything that's @@ -90,6 +119,14 @@ func (c *Config) sanitize() *Config { log.Warn("Sanitizing invalid node buffer size", "provided", common.StorageSize(conf.WriteBufferSize), "updated", common.StorageSize(maxBufferSize)) conf.WriteBufferSize = maxBufferSize } + if conf.FullValueCheckpoint > maxFullValueCheckpoint { + log.Warn("Sanitizing trienode history full value checkpoint", "provided", conf.FullValueCheckpoint, "updated", maxFullValueCheckpoint) + conf.FullValueCheckpoint = maxFullValueCheckpoint + } + if conf.FullValueCheckpoint == 0 { + conf.FullValueCheckpoint = 1 + log.Info("Disabling diff mode trie node history encoding") + } return &conf } @@ -108,6 +145,13 @@ func (c *Config) fields() []interface{} { } else { list = append(list, "state-history", fmt.Sprintf("last %d blocks", c.StateHistory)) } + if c.TrienodeHistory >= 0 { + if c.TrienodeHistory == 0 { + list = append(list, "trie-history", "entire chain") + } else { + list = append(list, "trie-history", fmt.Sprintf("last %d blocks", c.TrienodeHistory)) + } + } if c.EnableStateIndexing { list = append(list, "index-history", true) } diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go index 131747978c34..e52949c93e87 100644 --- a/triedb/pathdb/database.go +++ b/triedb/pathdb/database.go @@ -45,7 +45,7 @@ type layer interface { // Note: // - the returned node is not a copy, please don't modify it. // - no error will be returned if the requested node is not found in database. - node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, *nodeLoc, error) + node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, nodeLoc, error) // account directly retrieves the account RLP associated with a particular // hash in the slim data format. An error will be returned if the read @@ -100,13 +100,9 @@ func merkleNodeHasher(blob []byte) (common.Hash, error) { // binaryNodeHasher computes the hash of the given verkle node. func binaryNodeHasher(blob []byte) (common.Hash, error) { if len(blob) == 0 { - return types.EmptyVerkleHash, nil + return types.EmptyBinaryHash, nil } - n, err := bintrie.DeserializeNode(blob, 0) - if err != nil { - return common.Hash{}, err - } - return n.Hash(), nil + return bintrie.DeserializeAndHash(blob, 0) } // Database is a multiple-layered structure for maintaining in-memory states @@ -127,7 +123,7 @@ type Database struct { // the shutdown to reject all following unexpected mutations. readOnly bool // Flag if database is opened in read only mode waitSync bool // Flag if database is deactivated due to initial state sync - isVerkle bool // Flag if database is used for verkle tree + isUBT bool // Flag if database is used for verkle tree hasher nodeHasher // Trie node hasher config *Config // Configuration for database @@ -137,13 +133,16 @@ type Database struct { stateFreezer ethdb.ResettableAncientStore // Freezer for storing state histories, nil possible in tests stateIndexer *historyIndexer // History indexer historical state data, nil possible + trienodeFreezer ethdb.ResettableAncientStore // Freezer for storing trienode histories, nil possible in tests + trienodeIndexer *historyIndexer // History indexer for historical trienode data + lock sync.RWMutex // Lock to prevent mutations from happening at the same time } // New attempts to load an already existing layer from a persistent key-value // store (with a number of memory layers from a journal). If the journal is not // matched with the base persistent layer, all the recorded diff layers are discarded. -func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { +func New(diskdb ethdb.Database, config *Config, isUBT bool) *Database { if config == nil { config = Defaults } @@ -151,7 +150,7 @@ func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { db := &Database{ readOnly: config.ReadOnly, - isVerkle: isVerkle, + isUBT: isUBT, config: config, diskdb: diskdb, hasher: merkleNodeHasher, @@ -161,7 +160,7 @@ func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { // important to note that the introduction of a prefix won't lead to // substantial storage overhead, as the underlying database will efficiently // compress the shared key prefix. - if isVerkle { + if isUBT { db.diskdb = rawdb.NewTable(diskdb, string(rawdb.VerklePrefix)) db.hasher = binaryNodeHasher } @@ -169,11 +168,14 @@ func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { // and in-memory layer journal. db.tree = newLayerTree(db.loadLayers()) - // Repair the state history, which might not be aligned with the state - // in the key-value store due to an unclean shutdown. - if err := db.repairHistory(); err != nil { - log.Crit("Failed to repair state history", "err", err) + // Repair the history, which might not be aligned with the persistent + // state in the key-value store due to an unclean shutdown. + states, trienodes, err := repairHistory(db.diskdb, isUBT, db.config.ReadOnly, db.tree.bottom().stateID(), db.config.TrienodeHistory >= 0) + if err != nil { + log.Crit("Failed to repair history", "err", err) } + db.stateFreezer, db.trienodeFreezer = states, trienodes + // Disable database in case node is still in the initial state sync stage. if rawdb.ReadSnapSyncStatusFlag(diskdb) == rawdb.StateSyncRunning && !db.readOnly { if err := db.Disable(); err != nil { @@ -187,72 +189,38 @@ func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { if err := db.setStateGenerator(); err != nil { log.Crit("Failed to setup the generator", "err", err) } - // TODO (rjl493456442) disable the background indexing in read-only mode - if db.stateFreezer != nil && db.config.EnableStateIndexing { - db.stateIndexer = newHistoryIndexer(db.diskdb, db.stateFreezer, db.tree.bottom().stateID(), typeStateHistory) - log.Info("Enabled state history indexing") - } + db.setHistoryIndexer() + fields := config.fields() - if db.isVerkle { + if db.isUBT { fields = append(fields, "verkle", true) } log.Info("Initialized path database", fields...) return db } -// repairHistory truncates leftover state history objects, which may occur due -// to an unclean shutdown or other unexpected reasons. -func (db *Database) repairHistory() error { - // Open the freezer for state history. This mechanism ensures that - // only one database instance can be opened at a time to prevent - // accidental mutation. - ancient, err := db.diskdb.AncientDatadir() - if err != nil { - // TODO error out if ancient store is disabled. A tons of unit tests - // disable the ancient store thus the error here will immediately fail - // all of them. Fix the tests first. - return nil - } - freezer, err := rawdb.NewStateFreezer(ancient, db.isVerkle, db.readOnly) - if err != nil { - log.Crit("Failed to open state history freezer", "err", err) +// setHistoryIndexer initializes the indexers for both state history and +// trienode history if available. Note that this function may be called while +// existing indexers are still running, so they must be closed beforehand. +func (db *Database) setHistoryIndexer() { + // TODO (rjl493456442) disable the background indexing in read-only mode + if !db.config.EnableStateIndexing { + return } - db.stateFreezer = freezer - - // Reset the entire state histories if the trie database is not initialized - // yet. This action is necessary because these state histories are not - // expected to exist without an initialized trie database. - id := db.tree.bottom().stateID() - if id == 0 { - frozen, err := db.stateFreezer.Ancients() - if err != nil { - log.Crit("Failed to retrieve head of state history", "err", err) - } - if frozen != 0 { - // Purge all state history indexing data first - batch := db.diskdb.NewBatch() - rawdb.DeleteStateHistoryIndexMetadata(batch) - rawdb.DeleteStateHistoryIndexes(batch) - if err := batch.Write(); err != nil { - log.Crit("Failed to purge state history index", "err", err) - } - if err := db.stateFreezer.Reset(); err != nil { - log.Crit("Failed to reset state histories", "err", err) - } - log.Info("Truncated extraneous state history") + if db.stateFreezer != nil { + if db.stateIndexer != nil { + db.stateIndexer.close() } - return nil - } - // Truncate the extra state histories above in freezer in case it's not - // aligned with the disk layer. It might happen after a unclean shutdown. - pruned, err := truncateFromHead(db.stateFreezer, typeStateHistory, id) - if err != nil { - log.Crit("Failed to truncate extra state histories", "err", err) + db.stateIndexer = newHistoryIndexer(db.diskdb, db.stateFreezer, db.tree.bottom().stateID(), typeStateHistory, db.config.NoHistoryIndexDelay) + log.Info("Enabled state history indexing") } - if pruned != 0 { - log.Warn("Truncated extra state histories", "number", pruned) + if db.trienodeFreezer != nil { + if db.trienodeIndexer != nil { + db.trienodeIndexer.close() + } + db.trienodeIndexer = newHistoryIndexer(db.diskdb, db.trienodeFreezer, db.tree.bottom().stateID(), typeTrienodeHistory, db.config.NoHistoryIndexDelay) + log.Info("Enabled trienode history indexing") } - return nil } // setStateGenerator loads the state generation progress marker and potentially @@ -293,7 +261,7 @@ func (db *Database) setStateGenerator() error { // - the database is opened in read only mode // - the snapshot build is explicitly disabled // - the database is opened in verkle tree mode - noBuild := db.readOnly || db.config.SnapshotNoBuild || db.isVerkle + noBuild := db.readOnly || db.config.SnapshotNoBuild || db.isUBT // Construct the generator and link it to the disk layer, ensuring that the // generation progress is resolved to prevent accessing uncovered states @@ -333,8 +301,13 @@ func (db *Database) Update(root common.Hash, parentRoot common.Hash, block uint6 if err := db.modifyAllowed(); err != nil { return err } - // TODO(rjl493456442) tracking the origins in the following PRs. - if err := db.tree.add(root, parentRoot, block, NewNodeSetWithOrigin(nodes.Nodes(), nil), states); err != nil { + var nodesWithOrigins *nodeSetWithOrigin + if db.config.TrienodeHistory >= 0 { + nodesWithOrigins = NewNodeSetWithOrigin(nodes.NodeAndOrigins()) + } else { + nodesWithOrigins = NewNodeSetWithOrigin(nodes.Nodes(), nil) + } + if err := db.tree.add(root, parentRoot, block, nodesWithOrigins, states); err != nil { return err } // Keep 128 diff layers in the memory, persistent layer is 129th. @@ -392,16 +365,9 @@ func (db *Database) Disable() error { return nil } -// Enable activates database and resets the state tree with the provided persistent -// state root once the state sync is finished. -func (db *Database) Enable(root common.Hash) error { - db.lock.Lock() - defer db.lock.Unlock() - - // Short circuit if the database is in read only mode. - if db.readOnly { - return errDatabaseReadOnly - } +// resetForReactivation performs the pathdb-side bookkeeping shared by both +// Enable and AdoptSyncedState. +func (db *Database) resetForReactivation(root common.Hash) error { // Ensure the provided state root matches the stored one. stored, err := db.hasher(rawdb.ReadAccountTrieNode(db.diskdb, nil)) if err != nil { @@ -410,51 +376,89 @@ func (db *Database) Enable(root common.Hash) error { if stored != root { return fmt.Errorf("state root mismatch: stored %x, synced %x", stored, root) } - // Drop the stale state journal in persistent database and - // reset the persistent state id back to zero. + // Drop the stale state journal marker and reset the persistent state id + // back to zero. batch := db.diskdb.NewBatch() rawdb.DeleteSnapshotRoot(batch) rawdb.WritePersistentStateID(batch, 0) if err := batch.Write(); err != nil { return err } - // Clean up all state histories in freezer. Theoretically - // all root->id mappings should be removed as well. Since - // mappings can be huge and might take a while to clear - // them, just leave them in disk and wait for overwriting. - if db.stateFreezer != nil { - // Purge all state history indexing data first - batch.Reset() - rawdb.DeleteStateHistoryIndexMetadata(batch) - rawdb.DeleteStateHistoryIndexes(batch) - if err := batch.Write(); err != nil { - return err - } - if err := db.stateFreezer.Reset(); err != nil { - return err - } - } - // Re-enable the database as the final step. + // Clean up all state histories in the freezer. Theoretically all root->id + // mappings should be removed as well; since those can be huge, leave them + // on disk and let them be overwritten. + purgeHistory(db.stateFreezer, db.diskdb, typeStateHistory) + purgeHistory(db.trienodeFreezer, db.diskdb, typeTrienodeHistory) + + // Re-enable the database as the final bookkeeping step. db.waitSync = false rawdb.WriteSnapSyncStatusFlag(db.diskdb, rawdb.StateSyncFinished) + return nil +} + +// Enable activates the database after a snap/1 sync and schedules background +// regeneration of the snapshot from the trie. +func (db *Database) Enable(root common.Hash) error { + db.lock.Lock() + defer db.lock.Unlock() - // Re-construct a new disk layer backed by persistent state - // and schedule the state snapshot generation if it's permitted. - db.tree.init(generateSnapshot(db, root, db.isVerkle || db.config.SnapshotNoBuild)) + if db.readOnly { + return errDatabaseReadOnly + } + if err := db.resetForReactivation(root); err != nil { + return err + } + // Re-construct a new disk layer backed by persistent state and schedule + // the state snapshot generation if it's permitted. + db.tree.init(generateSnapshot(db, root, db.isUBT || db.config.SnapshotNoBuild)) // After snap sync, the state of the database may have changed completely. // To ensure the history indexer always matches the current state, we must: // 1. Close any existing indexer // 2. Re-initialize the indexer so it starts indexing from the new state root. - if db.stateIndexer != nil && db.stateFreezer != nil && db.config.EnableStateIndexing { - db.stateIndexer.close() - db.stateIndexer = newHistoryIndexer(db.diskdb, db.stateFreezer, db.tree.bottom().stateID(), typeStateHistory) - log.Info("Re-enabled state history indexing") - } + db.setHistoryIndexer() + log.Info("Rebuilt trie database", "root", root) return nil } +// AdoptSyncedState reactivates the database after a snap/2 sync. The syncer +// already wrote a consistent flat state, so we take it as-is instead of +// rebuilding it from the trie. The new disk layer has no generator attached, +// and a "done" marker is written so future boots know the snapshot is +// already complete. +func (db *Database) AdoptSyncedState(root common.Hash) error { + db.lock.Lock() + defer db.lock.Unlock() + + if db.readOnly { + return errDatabaseReadOnly + } + if err := db.resetForReactivation(root); err != nil { + return err + } + + // Tell the snapshot subsystem the flat state is good by writing the new root + // and a "done" marker (nil journal) so the next boot doesn't try to rebuild it. + batch := db.diskdb.NewBatch() + rawdb.WriteSnapshotRoot(batch, root) + journalProgress(batch, nil, nil) + if err := batch.Write(); err != nil { + return err + } + + // New disk layer, no generator attached. Nothing to rebuild, and reads + // can serve the flat state right away without waiting on a generator to + // scan past every key. + dl := newDiskLayer(root, 0, db, nil, nil, newBuffer(db.config.WriteBufferSize, nil, nil, 0), nil) + db.tree.init(dl) + + db.setHistoryIndexer() + + log.Info("Adopted synced state", "root", root) + return nil +} + // Recover rollbacks the database to a specified historical point. // The state is supported as the rollback destination only if it's // canonical state and the corresponding trie histories are existent. @@ -506,6 +510,12 @@ func (db *Database) Recover(root common.Hash) error { if err != nil { return err } + if db.trienodeFreezer != nil { + _, err = truncateFromHead(db.trienodeFreezer, typeTrienodeHistory, dl.stateID()) + if err != nil { + return err + } + } log.Debug("Recovered state", "root", root, "elapsed", common.PrettyDuration(time.Since(start))) return nil } @@ -566,11 +576,21 @@ func (db *Database) Close() error { if db.stateIndexer != nil { db.stateIndexer.close() } + if db.trienodeIndexer != nil { + db.trienodeIndexer.close() + } // Close the attached state history freezer. - if db.stateFreezer == nil { - return nil + if db.stateFreezer != nil { + if err := db.stateFreezer.Close(); err != nil { + return err + } } - return db.stateFreezer.Close() + if db.trienodeFreezer != nil { + if err := db.trienodeFreezer.Close(); err != nil { + return err + } + } + return nil } // Size returns the current storage size of the memory cache in front of the @@ -605,7 +625,7 @@ func (db *Database) journalPath() string { return "" } var fname string - if db.isVerkle { + if db.isUBT { fname = fmt.Sprintf("verkle.journal") } else { fname = fmt.Sprintf("merkle.journal") @@ -645,11 +665,26 @@ func (db *Database) HistoryRange() (uint64, uint64, error) { // IndexProgress returns the indexing progress made so far. It provides the // number of states that remain unindexed. -func (db *Database) IndexProgress() (uint64, error) { - if db.stateIndexer == nil { - return 0, nil +func (db *Database) IndexProgress() (uint64, uint64, error) { + var ( + stateProgress uint64 + trieProgress uint64 + ) + if db.stateIndexer != nil { + prog, err := db.stateIndexer.progress() + if err != nil { + return 0, 0, err + } + stateProgress = prog + } + if db.trienodeIndexer != nil { + prog, err := db.trienodeIndexer.progress() + if err != nil { + return 0, 0, err + } + trieProgress = prog } - return db.stateIndexer.progress() + return stateProgress, trieProgress, nil } // AccountIterator creates a new account iterator for the specified root hash and diff --git a/triedb/pathdb/database_test.go b/triedb/pathdb/database_test.go index 8cca7b1b3ce4..41212dc9d079 100644 --- a/triedb/pathdb/database_test.go +++ b/triedb/pathdb/database_test.go @@ -143,7 +143,7 @@ type testerConfig struct { layers int // Number of state transitions to generate for enableIndex bool // Enable state history indexing or not journalDir string // Directory path for persisting journal files - isVerkle bool // Enables Verkle trie mode if true + isUBT bool // Enables Verkle trie mode if true writeBuffer *int // Optional, the size of memory allocated for write buffer trieCache *int // Optional, the size of memory allocated for trie cache @@ -182,7 +182,8 @@ func newTester(t *testing.T, config *testerConfig) *tester { WriteBufferSize: config.writeBufferSize(), NoAsyncFlush: true, JournalDirectory: config.journalDir, - }, config.isVerkle) + NoHistoryIndexDelay: true, + }, config.isUBT) obj = &tester{ db: db, @@ -747,6 +748,84 @@ func TestDisable(t *testing.T) { } } +// TestAdoptSyncedState verifies that AdoptSyncedState rejects a wrong root, +// writes the on-disk markers that say the snapshot is already complete, +// leaves a single fresh disk layer with no generator attached, and clears +// out stale state histories. +func TestAdoptSyncedState(t *testing.T) { + maxDiffLayers = 4 + defer func() { + maxDiffLayers = 128 + }() + + tester := newTester(t, &testerConfig{layers: 12}) + defer tester.release() + + // Push everything down to disk so the trie root is the persistent root. + if err := tester.db.Commit(tester.lastHash(), false); err != nil { + t.Fatalf("Failed to commit, err: %v", err) + } + stored := crypto.Keccak256Hash(rawdb.ReadAccountTrieNode(tester.db.diskdb, nil)) + + // Mimic the snap-syncing state. + if err := tester.db.Disable(); err != nil { + t.Fatalf("Failed to disable database: %v", err) + } + // Mismatched root must be rejected. + if err := tester.db.AdoptSyncedState(types.EmptyRootHash); err == nil { + t.Fatal("Mismatched root should be rejected") + } + if err := tester.db.AdoptSyncedState(stored); err != nil { + t.Fatalf("AdoptSyncedState failed: %v", err) + } + + // On-disk markers reflect a completed snapshot. + if got := rawdb.ReadSnapshotRoot(tester.db.diskdb); got != stored { + t.Fatalf("SnapshotRoot mismatch: got %x want %x", got, stored) + } + if blob := rawdb.ReadSnapshotGenerator(tester.db.diskdb); len(blob) == 0 { + t.Fatal("Generator journal not written") + } else { + var entry journalGenerator + if err := rlp.DecodeBytes(blob, &entry); err != nil { + t.Fatalf("Failed to decode generator journal: %v", err) + } + if !entry.Done { + t.Fatal("Generator journal should be marked Done") + } + // RLP turns a nil slice into an empty one on decode, so check length. + if len(entry.Marker) != 0 { + t.Fatalf("Generator marker should be empty, got %x", entry.Marker) + } + } + if rawdb.ReadSnapSyncStatusFlag(tester.db.diskdb) != rawdb.StateSyncFinished { + t.Fatal("Sync-status flag should be StateSyncFinished") + } + if tester.db.waitSync { + t.Fatal("waitSync should be false after adopt") + } + + // State histories are purged. + if n, err := tester.db.stateFreezer.Ancients(); err != nil || n != 0 { + t.Fatalf("State histories not purged: count=%d err=%v", n, err) + } + + // Layer tree has a single disk layer with no generator attached. + if got := tester.db.tree.len(); got != 1 { + t.Fatalf("Expected single layer, got %d", got) + } + dl := tester.db.tree.bottom() + if dl.rootHash() != stored { + t.Fatalf("Disk layer root mismatch: got %x want %x", dl.rootHash(), stored) + } + if dl.generator != nil { + t.Fatal("Disk layer should have no generator after adopt") + } + if dl.genMarker() != nil { + t.Fatal("genMarker should be nil after adopt") + } +} + func TestCommit(t *testing.T) { // Redefine the diff layer depth allowance for faster testing. maxDiffLayers = 4 @@ -950,7 +1029,7 @@ func TestDatabaseIndexRecovery(t *testing.T) { var ( dIndex int roots = env.roots - hr = newHistoryReader(env.db.diskdb, env.db.stateFreezer) + hr = newStateHistoryReader(env.db.diskdb, env.db.stateFreezer) ) for i, root := range roots { if root == dRoot { @@ -986,7 +1065,7 @@ func TestDatabaseIndexRecovery(t *testing.T) { t.Fatalf("Unexpected state history found, %d", i) } } - remain, err := env.db.IndexProgress() + remain, _, err := env.db.IndexProgress() if err != nil { t.Fatalf("Failed to obtain the progress, %v", err) } @@ -1000,7 +1079,7 @@ func TestDatabaseIndexRecovery(t *testing.T) { panic(fmt.Errorf("failed to update state changes, err: %w", err)) } } - remain, err = env.db.IndexProgress() + remain, _, err = env.db.IndexProgress() if err != nil { t.Fatalf("Failed to obtain the progress, %v", err) } @@ -1011,7 +1090,7 @@ func TestDatabaseIndexRecovery(t *testing.T) { // Ensure the truncated state histories become accessible bRoot = env.db.tree.bottom().rootHash() - hr = newHistoryReader(env.db.diskdb, env.db.stateFreezer) + hr = newStateHistoryReader(env.db.diskdb, env.db.stateFreezer) for i, root := range roots { if root == bRoot { break diff --git a/triedb/pathdb/difflayer.go b/triedb/pathdb/difflayer.go index ae523c979c62..8ca3a39cf34b 100644 --- a/triedb/pathdb/difflayer.go +++ b/triedb/pathdb/difflayer.go @@ -79,7 +79,7 @@ func (dl *diffLayer) parentLayer() layer { // node implements the layer interface, retrieving the trie node blob with the // provided node information. No error will be returned if the node is not found. -func (dl *diffLayer) node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, *nodeLoc, error) { +func (dl *diffLayer) node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, nodeLoc, error) { // Hold the lock, ensure the parent won't be changed during the // state accessing. dl.lock.RLock() @@ -91,7 +91,7 @@ func (dl *diffLayer) node(owner common.Hash, path []byte, depth int) ([]byte, co dirtyNodeHitMeter.Mark(1) dirtyNodeHitDepthHist.Update(int64(depth)) dirtyNodeReadMeter.Mark(int64(len(n.Blob))) - return n.Blob, n.Hash, &nodeLoc{loc: locDiffLayer, depth: depth}, nil + return n.Blob, n.Hash, nodeLoc{loc: locDiffLayer, depth: depth}, nil } // Trie node unknown to this layer, resolve from parent return dl.parent.node(owner, path, depth+1) diff --git a/triedb/pathdb/disklayer.go b/triedb/pathdb/disklayer.go index 76f3f5a46eaf..50c7279d0e38 100644 --- a/triedb/pathdb/disklayer.go +++ b/triedb/pathdb/disklayer.go @@ -26,6 +26,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" ) @@ -111,12 +112,12 @@ func (dl *diskLayer) markStale() { // node implements the layer interface, retrieving the trie node with the // provided node info. No error will be returned if the node is not found. -func (dl *diskLayer) node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, *nodeLoc, error) { +func (dl *diskLayer) node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, nodeLoc, error) { dl.lock.RLock() defer dl.lock.RUnlock() if dl.stale { - return nil, common.Hash{}, nil, errSnapshotStale + return nil, common.Hash{}, nodeLoc{}, errSnapshotStale } // Try to retrieve the trie node from the not-yet-written node buffer first // (both the live one and the frozen one). Note the buffer is lock free since @@ -128,7 +129,7 @@ func (dl *diskLayer) node(owner common.Hash, path []byte, depth int) ([]byte, co dirtyNodeHitMeter.Mark(1) dirtyNodeReadMeter.Mark(int64(len(n.Blob))) dirtyNodeHitDepthHist.Update(int64(depth)) - return n.Blob, n.Hash, &nodeLoc{loc: locDirtyCache, depth: depth}, nil + return n.Blob, n.Hash, nodeLoc{loc: locDirtyCache, depth: depth}, nil } } } @@ -140,7 +141,7 @@ func (dl *diskLayer) node(owner common.Hash, path []byte, depth int) ([]byte, co if blob := dl.nodes.Get(nil, key); len(blob) > 0 { cleanNodeHitMeter.Mark(1) cleanNodeReadMeter.Mark(int64(len(blob))) - return blob, crypto.Keccak256Hash(blob), &nodeLoc{loc: locCleanCache, depth: depth}, nil + return blob, crypto.Keccak256Hash(blob), nodeLoc{loc: locCleanCache, depth: depth}, nil } cleanNodeMissMeter.Mark(1) } @@ -160,7 +161,7 @@ func (dl *diskLayer) node(owner common.Hash, path []byte, depth int) ([]byte, co dl.nodes.Set(key, blob) cleanNodeWriteMeter.Mark(int64(len(blob))) } - return blob, crypto.Keccak256Hash(blob), &nodeLoc{loc: locDiskLayer, depth: depth}, nil + return blob, crypto.Keccak256Hash(blob), nodeLoc{loc: locDiskLayer, depth: depth}, nil } // account directly retrieves the account RLP associated with a particular @@ -275,7 +276,7 @@ func (dl *diskLayer) storage(accountHash, storageHash common.Hash, depth int) ([ // If the layer is being generated, ensure the requested storage slot // has already been covered by the generator. - key := append(accountHash[:], storageHash[:]...) + key := storageKeySlice(accountHash, storageHash) marker := dl.genMarker() if marker != nil && bytes.Compare(key, marker) > 0 { return nil, errNotCoveredYet @@ -323,36 +324,61 @@ func (dl *diskLayer) update(root common.Hash, id uint64, block uint64, nodes *no return newDiffLayer(dl, root, id, block, nodes, states) } -// writeStateHistory stores the state history and indexes if indexing is +// writeHistory stores the specified history and indexes if indexing is // permitted. // // What's more, this function also returns a flag indicating whether the // buffer flushing is required, ensuring the persistent state ID is always // greater than or equal to the first history ID. -func (dl *diskLayer) writeStateHistory(diff *diffLayer) (bool, error) { - // Short circuit if state history is not permitted - if dl.db.stateFreezer == nil { +func (dl *diskLayer) writeHistory(typ historyType, diff *diffLayer) (bool, error) { + var ( + limit uint64 + freezer ethdb.AncientStore + indexer *historyIndexer + writeFunc func(writer ethdb.AncientWriter, dl *diffLayer) error + ) + switch typ { + case typeStateHistory: + freezer = dl.db.stateFreezer + indexer = dl.db.stateIndexer + writeFunc = writeStateHistory + limit = dl.db.config.StateHistory + case typeTrienodeHistory: + freezer = dl.db.trienodeFreezer + indexer = dl.db.trienodeIndexer + writeFunc = func(writer ethdb.AncientWriter, diff *diffLayer) error { + return writeTrienodeHistory(writer, diff, dl.db.config.FullValueCheckpoint) + } + // Skip the history commit if the trienode history is not permitted + if dl.db.config.TrienodeHistory < 0 { + return false, nil + } + limit = uint64(dl.db.config.TrienodeHistory) + default: + panic(fmt.Sprintf("unknown history type: %v", typ)) + } + // Short circuit if the history freezer is nil + if freezer == nil { return false, nil } // Bail out with an error if writing the state history fails. // This can happen, for example, if the device is full. - err := writeStateHistory(dl.db.stateFreezer, diff) + err := writeFunc(freezer, diff) if err != nil { return false, err } - // Notify the state history indexer for newly created history - if dl.db.stateIndexer != nil { - if err := dl.db.stateIndexer.extend(diff.stateID()); err != nil { + // Notify the history indexer for newly created history + if indexer != nil { + if err := indexer.extend(diff.stateID()); err != nil { return false, err } } // Determine if the persisted history object has exceeded the // configured limitation. - limit := dl.db.config.StateHistory if limit == 0 { return false, nil } - tail, err := dl.db.stateFreezer.Tail() + tail, err := freezer.Tail() if err != nil { return false, err } // firstID = tail+1 @@ -375,14 +401,19 @@ func (dl *diskLayer) writeStateHistory(diff *diffLayer) (bool, error) { // These measures ensure the persisted state ID always remains greater // than or equal to the first history ID. if persistentID := rawdb.ReadPersistentStateID(dl.db.diskdb); persistentID < newFirst { - log.Debug("Skip tail truncation", "persistentID", persistentID, "tailID", tail+1, "headID", diff.stateID(), "limit", limit) + log.Debug("Skip tail truncation", "type", typ, "persistentID", persistentID, "tailID", tail+1, "headID", diff.stateID(), "limit", limit) return true, nil } - pruned, err := truncateFromTail(dl.db.stateFreezer, typeStateHistory, newFirst-1) + pruned, err := truncateFromTail(freezer, typ, newFirst-1) if err != nil { return false, err } - log.Debug("Pruned state history", "items", pruned, "tailid", newFirst) + // Notify the index pruner about the new tail so that stale index + // blocks referencing the pruned histories can be cleaned up. + if indexer != nil && pruned > 0 { + indexer.prune(newFirst) + } + log.Debug("Pruned history", "type", typ, "items", pruned, "tailid", newFirst) return false, nil } @@ -396,10 +427,22 @@ func (dl *diskLayer) commit(bottom *diffLayer, force bool) (*diskLayer, error) { // Construct and store the state history first. If crash happens after storing // the state history but without flushing the corresponding states(journal), // the stored state history will be truncated from head in the next restart. - flush, err := dl.writeStateHistory(bottom) + flushA, err := dl.writeHistory(typeStateHistory, bottom) + if err != nil { + return nil, err + } + // Construct and store the trienode history first. If crash happens after + // storing the trienode history but without flushing the corresponding + // states(journal), the stored trienode history will be truncated from head + // in the next restart. + flushB, err := dl.writeHistory(typeTrienodeHistory, bottom) if err != nil { return nil, err } + // Since the state history and trienode history may be configured with different + // lengths, the buffer will be flushed once either of them meets its threshold. + flush := flushA || flushB + // Mark the diskLayer as stale before applying any mutations on top. dl.stale = true @@ -448,7 +491,7 @@ func (dl *diskLayer) commit(bottom *diffLayer, force bool) (*diskLayer, error) { // Freeze the live buffer and schedule background flushing dl.frozen = combined - dl.frozen.flush(bottom.root, dl.db.diskdb, dl.db.stateFreezer, progress, dl.nodes, dl.states, bottom.stateID(), func() { + dl.frozen.flush(bottom.root, dl.db.diskdb, []ethdb.AncientWriter{dl.db.stateFreezer, dl.db.trienodeFreezer}, progress, dl.nodes, dl.states, bottom.stateID(), func() { // Resume the background generation if it's not completed yet. // The generator is assumed to be available if the progress is // not nil. @@ -504,12 +547,17 @@ func (dl *diskLayer) revert(h *stateHistory) (*diskLayer, error) { dl.stale = true - // Unindex the corresponding state history + // Unindex the corresponding history if dl.db.stateIndexer != nil { if err := dl.db.stateIndexer.shorten(dl.id); err != nil { return nil, err } } + if dl.db.trienodeIndexer != nil { + if err := dl.db.trienodeIndexer.shorten(dl.id); err != nil { + return nil, err + } + } // State change may be applied to node buffer, or the persistent // state, depends on if node buffer is empty or not. If the node // buffer is not empty, it means that the state transition that diff --git a/triedb/pathdb/flush.go b/triedb/pathdb/flush.go index 6563dbccff6e..4f816cf6a6d4 100644 --- a/triedb/pathdb/flush.go +++ b/triedb/pathdb/flush.go @@ -116,15 +116,16 @@ func writeStates(batch ethdb.Batch, genMarker []byte, accountData map[common.Has continue } slots += 1 + key := storageKeySlice(addrHash, storageHash) if len(blob) == 0 { rawdb.DeleteStorageSnapshot(batch, addrHash, storageHash) if clean != nil { - clean.Set(append(addrHash[:], storageHash[:]...), nil) + clean.Set(key, nil) } } else { rawdb.WriteStorageSnapshot(batch, addrHash, storageHash, blob) if clean != nil { - clean.Set(append(addrHash[:], storageHash[:]...), blob) + clean.Set(key, blob) } } } diff --git a/triedb/pathdb/generate.go b/triedb/pathdb/generate.go index 2efbbbb4e1ea..d3d26fff26f8 100644 --- a/triedb/pathdb/generate.go +++ b/triedb/pathdb/generate.go @@ -148,6 +148,7 @@ func (g *generator) stop() { g.abort <- ch <-ch g.running = false + log.Debug("Snapshot generation has been terminated") } // completed returns the flag indicating if the whole generation is done. diff --git a/triedb/pathdb/history.go b/triedb/pathdb/history.go index d78999f21835..7f5b0e35bac6 100644 --- a/triedb/pathdb/history.go +++ b/triedb/pathdb/history.go @@ -22,6 +22,7 @@ import ( "iter" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" ) @@ -121,6 +122,20 @@ func (ident stateIdent) String() string { return ident.addressHash.Hex() + ident.path } +func (ident stateIdent) bloomSize() int { + if ident.typ == typeAccount { + return 0 + } + if ident.typ == typeStorage { + return 0 + } + scheme := accountIndexScheme + if ident.addressHash != (common.Hash{}) { + scheme = storageIndexScheme + } + return scheme.getBitmapSize(len(ident.path)) +} + // newAccountIdent constructs a state identifier for an account. func newAccountIdent(addressHash common.Hash) stateIdent { return stateIdent{ @@ -180,17 +195,62 @@ func newStorageIdentQuery(address common.Address, addressHash common.Hash, stora } } -// newTrienodeIdentQuery constructs a state identifier for a trie node. -// the addressHash denotes the address hash of the associated account; -// the path denotes the path of the node within the trie; -// -// nolint:unused -func newTrienodeIdentQuery(addrHash common.Hash, path []byte) stateIdentQuery { - return stateIdentQuery{ - stateIdent: newTrienodeIdent(addrHash, string(path)), +// indexElem defines the element for indexing. +type indexElem interface { + key() stateIdent + ext() []uint16 +} + +type accountIndexElem struct { + addressHash common.Hash +} + +func (a accountIndexElem) key() stateIdent { + return stateIdent{ + typ: typeAccount, + addressHash: a.addressHash, } } +func (a accountIndexElem) ext() []uint16 { + return nil +} + +type storageIndexElem struct { + addressHash common.Hash + storageHash common.Hash +} + +func (a storageIndexElem) key() stateIdent { + return stateIdent{ + typ: typeStorage, + addressHash: a.addressHash, + storageHash: a.storageHash, + } +} + +func (a storageIndexElem) ext() []uint16 { + return nil +} + +type trienodeIndexElem struct { + owner common.Hash + path string + data []uint16 +} + +func (a trienodeIndexElem) key() stateIdent { + return stateIdent{ + typ: typeTrienode, + addressHash: a.owner, + path: a.path, + } +} + +func (a trienodeIndexElem) ext() []uint16 { + return a.data +} + // history defines the interface of historical data, shared by stateHistory // and trienodeHistory. type history interface { @@ -198,7 +258,7 @@ type history interface { typ() historyType // forEach returns an iterator to traverse the state entries in the history. - forEach() iter.Seq[stateIdent] + forEach() iter.Seq[indexElem] } var ( @@ -262,3 +322,139 @@ func truncateFromTail(store ethdb.AncientStore, typ historyType, ntail uint64) ( // Associated root->id mappings are left in the database. return int(ntail - otail), nil } + +// purgeHistory resets the history and also purges the associated index data. +func purgeHistory(store ethdb.ResettableAncientStore, disk ethdb.KeyValueStore, typ historyType) { + if store == nil { + return + } + frozen, err := store.Ancients() + if err != nil { + log.Crit("Failed to retrieve head of history", "type", typ, "err", err) + } + if frozen == 0 { + return + } + // Purge all state history indexing data first + batch := disk.NewBatch() + if typ == typeStateHistory { + rawdb.DeleteStateHistoryIndexMetadata(batch) + rawdb.DeleteStateHistoryIndexes(batch) + } else { + rawdb.DeleteTrienodeHistoryIndexMetadata(batch) + rawdb.DeleteTrienodeHistoryIndexes(batch) + } + if err := batch.Write(); err != nil { + log.Crit("Failed to purge history index", "type", typ, "err", err) + } + if err := store.Reset(); err != nil { + log.Crit("Failed to reset history", "type", typ, "err", err) + } + log.Info("Truncated extraneous history", "type", typ) +} + +// syncHistory explicitly sync the provided history stores. +func syncHistory(stores ...ethdb.AncientWriter) error { + for _, store := range stores { + if store == nil { + continue + } + if err := store.SyncAncient(); err != nil { + return err + } + } + return nil +} + +// repairHistory truncates any leftover history objects in either the state +// history or the trienode history, which may occur due to an unclean shutdown +// or other unexpected events. +// +// Additionally, this mechanism ensures that the state history and trienode +// history remain aligned. Since the trienode history is optional and not +// required by regular users, a gap between the trienode history and the +// persistent state may appear if the trienode history was disabled during the +// previous run. This process detects and resolves such gaps, preventing +// unexpected panics. +func repairHistory(db ethdb.Database, isUBT bool, readOnly bool, stateID uint64, enableTrienode bool) (ethdb.ResettableAncientStore, ethdb.ResettableAncientStore, error) { + ancient, err := db.AncientDatadir() + if err != nil { + // TODO error out if ancient store is disabled. A tons of unit tests + // disable the ancient store thus the error here will immediately fail + // all of them. Fix the tests first. + return nil, nil, nil + } + // State history is mandatory as it is the key component that ensures + // resilience to deep reorgs. + states, err := rawdb.NewStateFreezer(ancient, isUBT, readOnly) + if err != nil { + log.Crit("Failed to open state history freezer", "err", err) + } + + // Trienode history is optional and only required for building archive + // node with state proofs. + var trienodes ethdb.ResettableAncientStore + if enableTrienode { + trienodes, err = rawdb.NewTrienodeFreezer(ancient, isUBT, readOnly) + if err != nil { + log.Crit("Failed to open trienode history freezer", "err", err) + } + } + + // Reset the both histories if the trie database is not initialized yet. + // This action is necessary because these histories are not expected + // to exist without an initialized trie database. + if stateID == 0 { + purgeHistory(states, db, typeStateHistory) + purgeHistory(trienodes, db, typeTrienodeHistory) + return states, trienodes, nil + } + // Truncate excessive history entries in either the state history or + // the trienode history, ensuring both histories remain aligned with + // the state. + shead, err := states.Ancients() + if err != nil { + return nil, nil, err + } + if stateID > shead { // Gap is not permitted in the state history + return nil, nil, fmt.Errorf("gap between state [#%d] and state history [#%d]", stateID, shead) + } + truncTo := min(shead, stateID) + + if trienodes != nil { + thead, err := trienodes.Ancients() + if err != nil { + return nil, nil, err + } + if stateID <= thead { + truncTo = min(truncTo, thead) + } else { + if thead == 0 { + _, err = trienodes.TruncateTail(stateID) + if err != nil { + return nil, nil, err + } + log.Warn("Initialized trienode history") + } else { + return nil, nil, fmt.Errorf("gap between state [#%d] and trienode history [#%d]", stateID, thead) + } + } + } + // Truncate the extra history elements above in freezer in case it's not + // aligned with the state. It might happen after an unclean shutdown. + truncate := func(store ethdb.AncientStore, typ historyType, nhead uint64) { + if store == nil { + return + } + pruned, err := truncateFromHead(store, typ, nhead) + if err != nil { + log.Crit("Failed to truncate extra histories", "typ", typ, "err", err) + } + if pruned != 0 { + log.Warn("Truncated extra histories", "typ", typ, "number", pruned) + } + } + truncate(states, typeStateHistory, truncTo) + truncate(trienodes, typeTrienodeHistory, truncTo) + return states, trienodes, nil +} diff --git a/triedb/pathdb/history_index.go b/triedb/pathdb/history_index.go index 87b6e377afe2..eee4c1027313 100644 --- a/triedb/pathdb/history_index.go +++ b/triedb/pathdb/history_index.go @@ -25,22 +25,28 @@ import ( "github.com/ethereum/go-ethereum/ethdb" ) -// parseIndex parses the index data with the supplied byte stream. The index data -// is a list of fixed-sized metadata. Empty metadata is regarded as invalid. -func parseIndex(blob []byte) ([]*indexBlockDesc, error) { +// parseIndex parses the index data from the provided byte stream. The index data +// is a sequence of fixed-size metadata entries, and any empty metadata entry is +// considered invalid. +// +// Each metadata entry consists of two components: the indexBlockDesc and an +// optional extension bitmap. The bitmap length may vary across different categories, +// but must remain consistent within the same category. +func parseIndex(blob []byte, bitmapSize int) ([]*indexBlockDesc, error) { if len(blob) == 0 { return nil, errors.New("empty state history index") } - if len(blob)%indexBlockDescSize != 0 { - return nil, fmt.Errorf("corrupted state index, len: %d", len(blob)) + size := indexBlockDescSize + bitmapSize + if len(blob)%size != 0 { + return nil, fmt.Errorf("corrupted state index, len: %d, bitmap size: %d", len(blob), bitmapSize) } var ( lastID uint32 - descList []*indexBlockDesc + descList = make([]*indexBlockDesc, 0, len(blob)/size) ) - for i := 0; i < len(blob)/indexBlockDescSize; i++ { + for i := 0; i < len(blob)/size; i++ { var desc indexBlockDesc - desc.decode(blob[i*indexBlockDescSize : (i+1)*indexBlockDescSize]) + desc.decode(blob[i*size : (i+1)*size]) if desc.empty() { return nil, errors.New("empty state history index block") } @@ -69,33 +75,35 @@ func parseIndex(blob []byte) ([]*indexBlockDesc, error) { // indexReader is the structure to look up the state history index records // associated with the specific state element. type indexReader struct { - db ethdb.KeyValueReader - descList []*indexBlockDesc - readers map[uint32]*blockReader - state stateIdent + db ethdb.KeyValueReader + descList []*indexBlockDesc + readers map[uint32]*blockReader + state stateIdent + bitmapSize int } // loadIndexData loads the index data associated with the specified state. -func loadIndexData(db ethdb.KeyValueReader, state stateIdent) ([]*indexBlockDesc, error) { +func loadIndexData(db ethdb.KeyValueReader, state stateIdent, bitmapSize int) ([]*indexBlockDesc, error) { blob := readStateIndex(state, db) if len(blob) == 0 { return nil, nil } - return parseIndex(blob) + return parseIndex(blob, bitmapSize) } // newIndexReader constructs a index reader for the specified state. Reader with // empty data is allowed. -func newIndexReader(db ethdb.KeyValueReader, state stateIdent) (*indexReader, error) { - descList, err := loadIndexData(db, state) +func newIndexReader(db ethdb.KeyValueReader, state stateIdent, bitmapSize int) (*indexReader, error) { + descList, err := loadIndexData(db, state, bitmapSize) if err != nil { return nil, err } return &indexReader{ - descList: descList, - readers: make(map[uint32]*blockReader), - db: db, - state: state, + descList: descList, + readers: make(map[uint32]*blockReader), + db: db, + state: state, + bitmapSize: bitmapSize, }, nil } @@ -106,11 +114,9 @@ func (r *indexReader) refresh() error { // may have been modified by additional elements written to the disk. if len(r.descList) != 0 { last := r.descList[len(r.descList)-1] - if !last.full() { - delete(r.readers, last.id) - } + delete(r.readers, last.id) } - descList, err := loadIndexData(r.db, r.state) + descList, err := loadIndexData(r.db, r.state, r.bitmapSize) if err != nil { return err } @@ -118,26 +124,10 @@ func (r *indexReader) refresh() error { return nil } -// newIterator creates an iterator for traversing the index entries. -func (r *indexReader) newIterator() *indexIterator { - return newIndexIterator(r.descList, func(id uint32) (*blockReader, error) { - br, ok := r.readers[id] - if !ok { - var err error - br, err = newBlockReader(readStateIndexBlock(r.state, r.db, id)) - if err != nil { - return nil, err - } - r.readers[id] = br - } - return br, nil - }) -} - // readGreaterThan locates the first element that is greater than the specified // id. If no such element is found, MaxUint64 is returned. func (r *indexReader) readGreaterThan(id uint64) (uint64, error) { - it := r.newIterator() + it := r.newIterator(nil) found := it.SeekGT(id) if err := it.Error(); err != nil { return 0, err @@ -155,57 +145,75 @@ func (r *indexReader) readGreaterThan(id uint64) (uint64, error) { // history ids) is stored in these second-layer index blocks, which are size // limited. type indexWriter struct { - descList []*indexBlockDesc // The list of index block descriptions - bw *blockWriter // The live index block writer - frozen []*blockWriter // The finalized index block writers, waiting for flush - lastID uint64 // The ID of the latest tracked history - state stateIdent - db ethdb.KeyValueReader + descList []*indexBlockDesc // The list of index block descriptions + bw *blockWriter // The live index block writer + frozen []*blockWriter // The finalized index block writers, waiting for flush + lastID uint64 // The ID of the latest tracked history + state stateIdent // The identifier of the state being indexed + bitmapSize int // The size of optional extension bitmap + db ethdb.KeyValueReader } -// newIndexWriter constructs the index writer for the specified state. -func newIndexWriter(db ethdb.KeyValueReader, state stateIdent) (*indexWriter, error) { +// newIndexWriter constructs the index writer for the specified state. Additionally, +// it takes an integer as the limit and prunes all existing elements above that ID. +// It's essential as the recovery mechanism after unclean shutdown during the history +// indexing. +func newIndexWriter(db ethdb.KeyValueReader, state stateIdent, limit uint64, bitmapSize int) (*indexWriter, error) { blob := readStateIndex(state, db) if len(blob) == 0 { - desc := newIndexBlockDesc(0) - bw, _ := newBlockWriter(nil, desc) + desc := newIndexBlockDesc(0, bitmapSize) + bw, _ := newBlockWriter(nil, desc, 0 /* useless if the block is empty */, bitmapSize != 0) return &indexWriter{ - descList: []*indexBlockDesc{desc}, - bw: bw, - state: state, - db: db, + descList: []*indexBlockDesc{desc}, + bw: bw, + state: state, + db: db, + bitmapSize: bitmapSize, }, nil } - descList, err := parseIndex(blob) + descList, err := parseIndex(blob, bitmapSize) if err != nil { return nil, err } + // Trim trailing blocks whose elements all exceed the limit. + for i := len(descList) - 1; i > 0 && descList[i].max > limit; i-- { + // The previous block has the elements that exceed the limit, + // therefore the current block can be entirely dropped. + if descList[i-1].max >= limit { + descList = descList[:i] + } + } + // Take the last block for appending new elements lastDesc := descList[len(descList)-1] indexBlock := readStateIndexBlock(state, db, lastDesc.id) - bw, err := newBlockWriter(indexBlock, lastDesc) + + // Construct the writer for the last block. All elements in this block + // that exceed the limit will be truncated. + bw, err := newBlockWriter(indexBlock, lastDesc, limit, bitmapSize != 0) if err != nil { return nil, err } return &indexWriter{ - descList: descList, - lastID: lastDesc.max, - bw: bw, - state: state, - db: db, + descList: descList, + lastID: bw.last(), + bw: bw, + state: state, + db: db, + bitmapSize: bitmapSize, }, nil } // append adds the new element into the index writer. -func (w *indexWriter) append(id uint64) error { +func (w *indexWriter) append(id uint64, ext []uint16) error { if id <= w.lastID { return fmt.Errorf("append element out of order, last: %d, this: %d", w.lastID, id) } - if w.bw.full() { + if w.bw.estimateFull(ext) { if err := w.rotate(); err != nil { return err } } - if err := w.bw.append(id); err != nil { + if err := w.bw.append(id, ext); err != nil { return err } w.lastID = id @@ -218,10 +226,10 @@ func (w *indexWriter) append(id uint64) error { func (w *indexWriter) rotate() error { var ( err error - desc = newIndexBlockDesc(w.bw.desc.id + 1) + desc = newIndexBlockDesc(w.bw.desc.id+1, w.bitmapSize) ) w.frozen = append(w.frozen, w.bw) - w.bw, err = newBlockWriter(nil, desc) + w.bw, err = newBlockWriter(nil, desc, 0 /* useless if the block is empty */, w.bitmapSize != 0) if err != nil { return err } @@ -253,7 +261,8 @@ func (w *indexWriter) finish(batch ethdb.Batch) { } w.frozen = nil // release all the frozen writers - buf := make([]byte, 0, indexBlockDescSize*len(descList)) + size := indexBlockDescSize + w.bitmapSize + buf := make([]byte, 0, size*len(descList)) for _, desc := range descList { buf = append(buf, desc.encode()...) } @@ -262,49 +271,64 @@ func (w *indexWriter) finish(batch ethdb.Batch) { // indexDeleter is responsible for deleting index data for a specific state. type indexDeleter struct { - descList []*indexBlockDesc // The list of index block descriptions - bw *blockWriter // The live index block writer - dropped []uint32 // The list of index block id waiting for deleting - lastID uint64 // The ID of the latest tracked history - state stateIdent - db ethdb.KeyValueReader + descList []*indexBlockDesc // The list of index block descriptions + bw *blockWriter // The live index block writer + dropped []uint32 // The list of index block id waiting for deleting + lastID uint64 // The ID of the latest tracked history + state stateIdent // The identifier of the state being indexed + bitmapSize int // The size of optional extension bitmap + db ethdb.KeyValueReader } // newIndexDeleter constructs the index deleter for the specified state. -func newIndexDeleter(db ethdb.KeyValueReader, state stateIdent) (*indexDeleter, error) { +func newIndexDeleter(db ethdb.KeyValueReader, state stateIdent, limit uint64, bitmapSize int) (*indexDeleter, error) { blob := readStateIndex(state, db) if len(blob) == 0 { // TODO(rjl493456442) we can probably return an error here, // deleter with no data is meaningless. - desc := newIndexBlockDesc(0) - bw, _ := newBlockWriter(nil, desc) + desc := newIndexBlockDesc(0, bitmapSize) + bw, _ := newBlockWriter(nil, desc, 0 /* useless if the block is empty */, bitmapSize != 0) return &indexDeleter{ - descList: []*indexBlockDesc{desc}, - bw: bw, - state: state, - db: db, + descList: []*indexBlockDesc{desc}, + bw: bw, + state: state, + bitmapSize: bitmapSize, + db: db, }, nil } - descList, err := parseIndex(blob) + descList, err := parseIndex(blob, bitmapSize) if err != nil { return nil, err } + // Trim trailing blocks whose elements all exceed the limit. + for i := len(descList) - 1; i > 0 && descList[i].max > limit; i-- { + // The previous block has the elements that exceed the limit, + // therefore the current block can be entirely dropped. + if descList[i-1].max >= limit { + descList = descList[:i] + } + } + // Take the block for deleting element from lastDesc := descList[len(descList)-1] indexBlock := readStateIndexBlock(state, db, lastDesc.id) - bw, err := newBlockWriter(indexBlock, lastDesc) + + // Construct the writer for the last block. All elements in this block + // that exceed the limit will be truncated. + bw, err := newBlockWriter(indexBlock, lastDesc, limit, bitmapSize != 0) if err != nil { return nil, err } return &indexDeleter{ - descList: descList, - lastID: lastDesc.max, - bw: bw, - state: state, - db: db, + descList: descList, + lastID: bw.last(), + bw: bw, + state: state, + bitmapSize: bitmapSize, + db: db, }, nil } -// empty returns an flag indicating whether the state index is empty. +// empty returns whether the state index is empty. func (d *indexDeleter) empty() bool { return d.bw.empty() && len(d.descList) == 1 } @@ -337,7 +361,7 @@ func (d *indexDeleter) pop(id uint64) error { // Open the previous block writer for deleting lastDesc := d.descList[len(d.descList)-1] indexBlock := readStateIndexBlock(d.state, d.db, lastDesc.id) - bw, err := newBlockWriter(indexBlock, lastDesc) + bw, err := newBlockWriter(indexBlock, lastDesc, lastDesc.max, d.bitmapSize != 0) if err != nil { return err } @@ -363,7 +387,8 @@ func (d *indexDeleter) finish(batch ethdb.Batch) { if d.empty() { deleteStateIndex(d.state, batch) } else { - buf := make([]byte, 0, indexBlockDescSize*len(d.descList)) + size := indexBlockDescSize + d.bitmapSize + buf := make([]byte, 0, size*len(d.descList)) for _, desc := range d.descList { buf = append(buf, desc.encode()...) } diff --git a/triedb/pathdb/history_index_block.go b/triedb/pathdb/history_index_block.go index 7b59c8e88215..bb823bb13f79 100644 --- a/triedb/pathdb/history_index_block.go +++ b/triedb/pathdb/history_index_block.go @@ -17,30 +17,37 @@ package pathdb import ( + "bytes" "encoding/binary" "errors" "fmt" "math" + + "github.com/ethereum/go-ethereum/log" ) const ( - indexBlockDescSize = 14 // The size of index block descriptor - indexBlockEntriesCap = 4096 // The maximum number of entries can be grouped in a block - indexBlockRestartLen = 256 // The restart interval length of index block - historyIndexBatch = 512 * 1024 // The number of state history indexes for constructing or deleting as batch + indexBlockDescSize = 14 // The size of index block descriptor + indexBlockMaxSize = 4096 // The maximum size of a single index block + indexBlockRestartLen = 256 // The restart interval length of index block ) // indexBlockDesc represents a descriptor for an index block, which contains a // list of state mutation records associated with a specific state (either an // account or a storage slot). type indexBlockDesc struct { - max uint64 // The maximum state ID retained within the block - entries uint16 // The number of state mutation records retained within the block - id uint32 // The id of the index block + max uint64 // The maximum state ID retained within the block + entries uint16 // The number of state mutation records retained within the block + id uint32 // The id of the index block + extBitmap []byte // Optional fixed-size bitmap for the included extension elements } -func newIndexBlockDesc(id uint32) *indexBlockDesc { - return &indexBlockDesc{id: id} +func newIndexBlockDesc(id uint32, bitmapSize int) *indexBlockDesc { + var bitmap []byte + if bitmapSize > 0 { + bitmap = make([]byte, bitmapSize) + } + return &indexBlockDesc{id: id, extBitmap: bitmap} } // empty indicates whether the block is empty with no element retained. @@ -48,26 +55,33 @@ func (d *indexBlockDesc) empty() bool { return d.entries == 0 } -// full indicates whether the number of elements in the block exceeds the -// preconfigured limit. -func (d *indexBlockDesc) full() bool { - return d.entries >= indexBlockEntriesCap -} - // encode packs index block descriptor into byte stream. func (d *indexBlockDesc) encode() []byte { - var buf [indexBlockDescSize]byte + buf := make([]byte, indexBlockDescSize+len(d.extBitmap)) binary.BigEndian.PutUint64(buf[0:8], d.max) binary.BigEndian.PutUint16(buf[8:10], d.entries) binary.BigEndian.PutUint32(buf[10:14], d.id) + copy(buf[indexBlockDescSize:], d.extBitmap) return buf[:] } -// decode unpacks index block descriptor from byte stream. +// decode unpacks index block descriptor from byte stream. It's unsafe to mutate +// the provided byte stream after the function call. func (d *indexBlockDesc) decode(blob []byte) { d.max = binary.BigEndian.Uint64(blob[:8]) d.entries = binary.BigEndian.Uint16(blob[8:10]) d.id = binary.BigEndian.Uint32(blob[10:14]) + d.extBitmap = blob[indexBlockDescSize:] // no-deep copy! +} + +// copy returns a deep-copied object. +func (d *indexBlockDesc) copy() *indexBlockDesc { + return &indexBlockDesc{ + max: d.max, + entries: d.entries, + id: d.id, + extBitmap: bytes.Clone(d.extBitmap), + } } // parseIndexBlock parses the index block with the supplied byte stream. @@ -95,20 +109,38 @@ func (d *indexBlockDesc) decode(blob []byte) { // A uint16 can cover offsets in the range [0, 65536), which is more than enough // to store 4096 integers. // -// Each chunk begins with the full value of the first integer, followed by -// subsequent integers representing the differences between the current value -// and the preceding one. Integers are encoded with variable-size for best -// storage efficiency. Each chunk can be illustrated as below. +// Each chunk begins with a full integer value for the first element, followed +// by subsequent integers encoded as differences (deltas) from their preceding +// values. All integers use variable-length encoding for optimal space efficiency. +// +// In the updated format, each element in the chunk may optionally include an +// "extension" section. If an extension is present, it starts with a var-size +// integer indicating the length of the remaining extension payload, followed by +// that many bytes. If no extension is present, the element format is identical +// to the original version (i.e., only the integer or delta value is encoded). +// +// In the trienode history index, the extension field contains the list of +// trie node IDs that fall within this range. For the given state transition, +// these IDs represent the specific nodes in this range that were mutated. // -// Restart ---> +----------------+ -// | Full integer | -// +----------------+ -// | Diff with prev | -// +----------------+ -// | ... | -// +----------------+ -// | Diff with prev | -// +----------------+ +// Whether an element includes an extension is determined by the block reader +// based on the specification. Conceptually, a chunk is structured as: +// +// Restart ---> +----------------+ +// | Full integer | +// +----------------+ +// | (Extension?) | +// +----------------+ +// | Diff with prev | +// +----------------+ +// | (Extension?) | +// +----------------+ +// | ... | +// +----------------+ +// | Diff with prev | +// +----------------+ +// | (Extension?) | +// +----------------+ // // Empty index block is regarded as invalid. func parseIndexBlock(blob []byte) ([]uint16, []byte, error) { @@ -146,24 +178,26 @@ func parseIndexBlock(blob []byte) ([]uint16, []byte, error) { type blockReader struct { restarts []uint16 data []byte + hasExt bool } // newBlockReader constructs the block reader with the supplied block data. -func newBlockReader(blob []byte) (*blockReader, error) { +func newBlockReader(blob []byte, hasExt bool) (*blockReader, error) { restarts, data, err := parseIndexBlock(blob) if err != nil { return nil, err } return &blockReader{ restarts: restarts, - data: data, // safe to own the slice + data: data, // safe to own the slice + hasExt: hasExt, // flag whether extension should be resolved }, nil } // readGreaterThan locates the first element in the block that is greater than // the specified value. If no such element is found, MaxUint64 is returned. func (br *blockReader) readGreaterThan(id uint64) (uint64, error) { - it := newBlockIterator(br.data, br.restarts) + it := br.newIterator(nil) found := it.SeekGT(id) if err := it.Error(); err != nil { return 0, err @@ -178,29 +212,64 @@ type blockWriter struct { desc *indexBlockDesc // Descriptor of the block restarts []uint16 // Offsets into the data slice, marking the start of each section data []byte // Aggregated encoded data slice + hasExt bool // Flag whether the extension field for each element exists } -func newBlockWriter(blob []byte, desc *indexBlockDesc) (*blockWriter, error) { +// newBlockWriter constructs a block writer. In addition to the existing data +// and block description, it takes an element ID and prunes all existing elements +// above that ID. It's essential as the recovery mechanism after unclean shutdown +// during the history indexing. +func newBlockWriter(blob []byte, desc *indexBlockDesc, limit uint64, hasExt bool) (*blockWriter, error) { if len(blob) == 0 { return &blockWriter{ - desc: desc, - data: make([]byte, 0, 1024), + desc: desc, + data: make([]byte, 0, 1024), + hasExt: hasExt, }, nil } restarts, data, err := parseIndexBlock(blob) if err != nil { return nil, err } - return &blockWriter{ + writer := &blockWriter{ desc: desc, restarts: restarts, data: data, // safe to own the slice - }, nil + hasExt: hasExt, + } + var trimmed int + for !writer.empty() && writer.last() > limit { + if err := writer.pop(writer.last()); err != nil { + return nil, err + } + trimmed += 1 + } + if trimmed > 0 { + log.Debug("Truncated extraneous elements", "count", trimmed, "limit", limit) + } + return writer, nil +} + +// setBitmap applies the given extension elements into the bitmap. +func (b *blockWriter) setBitmap(ext []uint16) { + for _, n := range ext { + // Node ID zero is intentionally filtered out. Any element in this range + // can indicate that the sub-tree's root node was mutated, so storing zero + // is redundant and saves one byte for bitmap. + if n != 0 { + setBit(b.desc.extBitmap, int(n-1)) + } + } } // append adds a new element to the block. The new element must be greater than // the previous one. The provided ID is assumed to always be greater than 0. -func (b *blockWriter) append(id uint64) error { +// +// ext refers to the optional extension field attached to the appended element. +// This extension mechanism is used by trie-node history and represents a list of +// trie node IDs that fall within the range covered by the index element +// (typically corresponding to a sub-trie in trie-node history). +func (b *blockWriter) append(id uint64, ext []uint16) error { if id == 0 { return errors.New("invalid zero id") } @@ -227,13 +296,29 @@ func (b *blockWriter) append(id uint64) error { // element. b.data = binary.AppendUvarint(b.data, id-b.desc.max) } + // Extension validation + if (len(ext) == 0) != !b.hasExt { + if len(ext) == 0 { + return errors.New("missing extension") + } + return errors.New("unexpected extension") + } + // Append the extension if it is not nil. The extension is prefixed with a + // length indicator, and the block reader MUST understand this scheme and + // decode the extension accordingly. + if len(ext) > 0 { + b.setBitmap(ext) + enc := encodeIDs(ext) + b.data = binary.AppendUvarint(b.data, uint64(len(enc))) + b.data = append(b.data, enc...) + } b.desc.entries++ b.desc.max = id return nil } // scanSection traverses the specified section and terminates if fn returns true. -func (b *blockWriter) scanSection(section int, fn func(uint64, int) bool) { +func (b *blockWriter) scanSection(section int, fn func(uint64, int, []uint16) bool) error { var ( value uint64 start = int(b.restarts[section]) @@ -252,27 +337,47 @@ func (b *blockWriter) scanSection(section int, fn func(uint64, int) bool) { } else { value += x } - if fn(value, pos) { - return + // Resolve the extension if exists + var ( + err error + ext []uint16 + extLen int + ) + if b.hasExt { + l, ln := binary.Uvarint(b.data[pos+n:]) + extLen = ln + int(l) + ext, err = decodeIDs(b.data[pos+n+ln : pos+n+extLen]) + } + if err != nil { + return err } + if fn(value, pos, ext) { + return nil + } + // Shift to next position pos += n + pos += extLen } + return nil } // sectionLast returns the last element in the specified section. -func (b *blockWriter) sectionLast(section int) uint64 { +func (b *blockWriter) sectionLast(section int) (uint64, error) { var n uint64 - b.scanSection(section, func(v uint64, _ int) bool { + if err := b.scanSection(section, func(v uint64, _ int, _ []uint16) bool { n = v return false - }) - return n + }); err != nil { + return 0, err + } + return n, nil } // sectionSearch looks up the specified value in the given section, // the position and the preceding value will be returned if found. -func (b *blockWriter) sectionSearch(section int, n uint64) (found bool, prev uint64, pos int) { - b.scanSection(section, func(v uint64, p int) bool { +// It assumes that the preceding element exists in the section. +func (b *blockWriter) sectionSearch(section int, n uint64) (found bool, prev uint64, pos int, err error) { + if err := b.scanSection(section, func(v uint64, p int, _ []uint16) bool { if n == v { pos = p found = true @@ -280,8 +385,24 @@ func (b *blockWriter) sectionSearch(section int, n uint64) (found bool, prev uin } prev = v return false // continue iteration - }) - return found, prev, pos + }); err != nil { + return false, 0, 0, err + } + return found, prev, pos, nil +} + +// rebuildBitmap scans the entire block and rebuilds the bitmap. +func (b *blockWriter) rebuildBitmap() error { + clear(b.desc.extBitmap) + for i := 0; i < len(b.restarts); i++ { + if err := b.scanSection(i, func(v uint64, p int, ext []uint16) bool { + b.setBitmap(ext) + return false // continue iteration + }); err != nil { + return err + } + } + return nil } // pop removes the last element from the block. The assumption is held that block @@ -295,9 +416,9 @@ func (b *blockWriter) pop(id uint64) error { } // If there is only one entry left, the entire block should be reset if b.desc.entries == 1 { - //b.desc.min = 0 b.desc.max = 0 b.desc.entries = 0 + clear(b.desc.extBitmap) b.restarts = nil b.data = b.data[:0] return nil @@ -307,28 +428,45 @@ func (b *blockWriter) pop(id uint64) error { if b.desc.entries%indexBlockRestartLen == 1 { b.data = b.data[:b.restarts[len(b.restarts)-1]] b.restarts = b.restarts[:len(b.restarts)-1] - b.desc.max = b.sectionLast(len(b.restarts) - 1) + last, err := b.sectionLast(len(b.restarts) - 1) + if err != nil { + return err + } + b.desc.max = last b.desc.entries -= 1 - return nil + return b.rebuildBitmap() } // Look up the element preceding the one to be popped, in order to update // the maximum element in the block. - found, prev, pos := b.sectionSearch(len(b.restarts)-1, id) + found, prev, pos, err := b.sectionSearch(len(b.restarts)-1, id) + if err != nil { + return err + } if !found { return fmt.Errorf("pop element is not found, last: %d, this: %d", b.desc.max, id) } b.desc.max = prev b.data = b.data[:pos] b.desc.entries -= 1 - return nil + return b.rebuildBitmap() } func (b *blockWriter) empty() bool { return b.desc.empty() } -func (b *blockWriter) full() bool { - return b.desc.full() +func (b *blockWriter) estimateFull(ext []uint16) bool { + size := 8 + 2*len(ext) + return len(b.data)+size > indexBlockMaxSize +} + +// last returns the last element in the block. It should only be called when +// writer is not empty, otherwise the returned data is meaningless. +func (b *blockWriter) last() uint64 { + if b.empty() { + return 0 + } + return b.desc.max } // finish finalizes the index block encoding by appending the encoded restart points diff --git a/triedb/pathdb/history_index_block_test.go b/triedb/pathdb/history_index_block_test.go index c251cea2ecb9..923ae29348f7 100644 --- a/triedb/pathdb/history_index_block_test.go +++ b/triedb/pathdb/history_index_block_test.go @@ -17,6 +17,7 @@ package pathdb import ( + "bytes" "math" "math/rand" "slices" @@ -24,16 +25,36 @@ import ( "testing" ) +func randomExt(bitmapSize int, n int) []uint16 { + if bitmapSize == 0 { + return nil + } + var ( + limit = bitmapSize * 8 + extList []uint16 + ) + for i := 0; i < n; i++ { + extList = append(extList, uint16(rand.Intn(limit+1))) + } + return extList +} + func TestBlockReaderBasic(t *testing.T) { + testBlockReaderBasic(t, 0) + testBlockReaderBasic(t, 2) + testBlockReaderBasic(t, 34) +} + +func testBlockReaderBasic(t *testing.T, bitmapSize int) { elements := []uint64{ 1, 5, 10, 11, 20, } - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) for i := 0; i < len(elements); i++ { - bw.append(elements[i]) + bw.append(elements[i], randomExt(bitmapSize, 5)) } - br, err := newBlockReader(bw.finish()) + br, err := newBlockReader(bw.finish(), bitmapSize != 0) if err != nil { t.Fatalf("Failed to construct the block reader, %v", err) } @@ -60,18 +81,24 @@ func TestBlockReaderBasic(t *testing.T) { } func TestBlockReaderLarge(t *testing.T) { + testBlockReaderLarge(t, 0) + testBlockReaderLarge(t, 2) + testBlockReaderLarge(t, 34) +} + +func testBlockReaderLarge(t *testing.T, bitmapSize int) { var elements []uint64 for i := 0; i < 1000; i++ { elements = append(elements, rand.Uint64()) } slices.Sort(elements) - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) for i := 0; i < len(elements); i++ { - bw.append(elements[i]) + bw.append(elements[i], randomExt(bitmapSize, 5)) } - br, err := newBlockReader(bw.finish()) + br, err := newBlockReader(bw.finish(), bitmapSize != 0) if err != nil { t.Fatalf("Failed to construct the block reader, %v", err) } @@ -95,34 +122,91 @@ func TestBlockReaderLarge(t *testing.T) { } func TestBlockWriterBasic(t *testing.T) { - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + testBlockWriteBasic(t, 0) + testBlockWriteBasic(t, 2) + testBlockWriteBasic(t, 34) +} + +func testBlockWriteBasic(t *testing.T, bitmapSize int) { + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) if !bw.empty() { t.Fatal("expected empty block") } - bw.append(2) - if err := bw.append(1); err == nil { + bw.append(2, randomExt(bitmapSize, 5)) + if err := bw.append(1, randomExt(bitmapSize, 5)); err == nil { t.Fatal("out-of-order insertion is not expected") } + var maxElem uint64 for i := 0; i < 10; i++ { - bw.append(uint64(i + 3)) + bw.append(uint64(i+3), randomExt(bitmapSize, 5)) + maxElem = uint64(i + 3) } - bw, err := newBlockWriter(bw.finish(), newIndexBlockDesc(0)) + bw, err := newBlockWriter(bw.finish(), newIndexBlockDesc(0, bitmapSize), maxElem, bitmapSize != 0) if err != nil { t.Fatalf("Failed to construct the block writer, %v", err) } for i := 0; i < 10; i++ { - if err := bw.append(uint64(i + 100)); err != nil { + if err := bw.append(uint64(i+100), randomExt(bitmapSize, 5)); err != nil { t.Fatalf("Failed to append value %d: %v", i, err) } } bw.finish() } +func TestBlockWriterWithLimit(t *testing.T) { + testBlockWriterWithLimit(t, 0) + testBlockWriterWithLimit(t, 2) + testBlockWriterWithLimit(t, 34) +} + +func testBlockWriterWithLimit(t *testing.T, bitmapSize int) { + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) + + var bitmaps [][]byte + for i := 0; i < indexBlockRestartLen+2; i++ { + bw.append(uint64(i+1), randomExt(bitmapSize, 5)) + bitmaps = append(bitmaps, bytes.Clone(bw.desc.extBitmap)) + } + for i := 0; i < indexBlockRestartLen+2; i++ { + limit := uint64(i + 1) + + desc := bw.desc.copy() + block, err := newBlockWriter(bytes.Clone(bw.finish()), desc, limit, bitmapSize != 0) + if err != nil { + t.Fatalf("Failed to construct the block writer, %v", err) + } + if block.desc.max != limit { + t.Fatalf("Test %d, unexpected max value, got %d, want %d", i, block.desc.max, limit) + } + if !bytes.Equal(desc.extBitmap, bitmaps[i]) { + t.Fatalf("Test %d, unexpected bitmap, got: %v, want: %v", i, block.desc.extBitmap, bitmaps[i]) + } + + // Re-fill the elements + var maxElem uint64 + for elem := limit + 1; elem < indexBlockRestartLen+4; elem++ { + if err := block.append(elem, randomExt(bitmapSize, 5)); err != nil { + t.Fatalf("Failed to append value %d: %v", elem, err) + } + maxElem = elem + } + if block.desc.max != maxElem { + t.Fatalf("Test %d, unexpected max value, got %d, want %d", i, block.desc.max, maxElem) + } + } +} + func TestBlockWriterDelete(t *testing.T) { - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + testBlockWriterDelete(t, 0) + testBlockWriterDelete(t, 2) + testBlockWriterDelete(t, 34) +} + +func testBlockWriterDelete(t *testing.T, bitmapSize int) { + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) for i := 0; i < 10; i++ { - bw.append(uint64(i + 1)) + bw.append(uint64(i+1), randomExt(bitmapSize, 5)) } // Pop unknown id, the request should be rejected if err := bw.pop(100); err == nil { @@ -144,12 +228,18 @@ func TestBlockWriterDelete(t *testing.T) { } func TestBlcokWriterDeleteWithData(t *testing.T) { + testBlcokWriterDeleteWithData(t, 0) + testBlcokWriterDeleteWithData(t, 2) + testBlcokWriterDeleteWithData(t, 34) +} + +func testBlcokWriterDeleteWithData(t *testing.T, bitmapSize int) { elements := []uint64{ 1, 5, 10, 11, 20, } - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) for i := 0; i < len(elements); i++ { - bw.append(elements[i]) + bw.append(elements[i], randomExt(bitmapSize, 5)) } // Re-construct the block writer with data @@ -158,7 +248,10 @@ func TestBlcokWriterDeleteWithData(t *testing.T) { max: 20, entries: 5, } - bw, err := newBlockWriter(bw.finish(), desc) + if bitmapSize > 0 { + desc.extBitmap = make([]byte, bitmapSize) + } + bw, err := newBlockWriter(bw.finish(), desc, elements[len(elements)-1], bitmapSize != 0) if err != nil { t.Fatalf("Failed to construct block writer %v", err) } @@ -169,7 +262,7 @@ func TestBlcokWriterDeleteWithData(t *testing.T) { newTail := elements[i-1] // Ensure the element can still be queried with no issue - br, err := newBlockReader(bw.finish()) + br, err := newBlockReader(bw.finish(), bitmapSize != 0) if err != nil { t.Fatalf("Failed to construct the block reader, %v", err) } @@ -201,26 +294,60 @@ func TestBlcokWriterDeleteWithData(t *testing.T) { } func TestCorruptedIndexBlock(t *testing.T) { - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, 0), 0, false) + + var maxElem uint64 for i := 0; i < 10; i++ { - bw.append(uint64(i + 1)) + bw.append(uint64(i+1), nil) + maxElem = uint64(i + 1) } buf := bw.finish() // Mutate the buffer manually buf[len(buf)-1]++ - _, err := newBlockWriter(buf, newIndexBlockDesc(0)) + _, err := newBlockWriter(buf, newIndexBlockDesc(0, 0), maxElem, false) if err == nil { t.Fatal("Corrupted index block data is not detected") } } // BenchmarkParseIndexBlock benchmarks the performance of parseIndexBlock. +// +// goos: darwin +// goarch: arm64 +// pkg: github.com/ethereum/go-ethereum/triedb/pathdb +// cpu: Apple M1 Pro +// BenchmarkParseIndexBlock +// BenchmarkParseIndexBlock-8 35829495 34.16 ns/op func BenchmarkParseIndexBlock(b *testing.B) { // Generate a realistic index block blob - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, 0), 0, false) for i := 0; i < 4096; i++ { - bw.append(uint64(i * 2)) + bw.append(uint64(i*2), nil) + } + blob := bw.finish() + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, _, err := parseIndexBlock(blob) + if err != nil { + b.Fatalf("parseIndexBlock failed: %v", err) + } + } +} + +// goos: darwin +// goarch: arm64 +// pkg: github.com/ethereum/go-ethereum/triedb/pathdb +// cpu: Apple M1 Pro +// BenchmarkParseIndexBlockWithExt +// BenchmarkParseIndexBlockWithExt-8 35773242 33.72 ns/op +func BenchmarkParseIndexBlockWithExt(b *testing.B) { + // Generate a realistic index block blob + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, 34), 0, true) + for i := 0; i < 4096; i++ { + id, ext := uint64(i*2), randomExt(34, 3) + bw.append(id, ext) } blob := bw.finish() @@ -234,19 +361,58 @@ func BenchmarkParseIndexBlock(b *testing.B) { } // BenchmarkBlockWriterAppend benchmarks the performance of indexblock.writer +// +// goos: darwin +// goarch: arm64 +// pkg: github.com/ethereum/go-ethereum/triedb/pathdb +// cpu: Apple M1 Pro +// BenchmarkBlockWriterAppend +// BenchmarkBlockWriterAppend-8 293611083 4.113 ns/op 3 B/op 0 allocs/op func BenchmarkBlockWriterAppend(b *testing.B) { b.ReportAllocs() b.ResetTimer() - desc := newIndexBlockDesc(0) - writer, _ := newBlockWriter(nil, desc) + var blockID uint32 + desc := newIndexBlockDesc(blockID, 0) + writer, _ := newBlockWriter(nil, desc, 0, false) + + for i := 0; i < b.N; i++ { + if writer.estimateFull(nil) { + blockID += 1 + desc = newIndexBlockDesc(blockID, 0) + writer, _ = newBlockWriter(nil, desc, 0, false) + } + if err := writer.append(writer.desc.max+1, nil); err != nil { + b.Error(err) + } + } +} + +// goos: darwin +// goarch: arm64 +// pkg: github.com/ethereum/go-ethereum/triedb/pathdb +// cpu: Apple M1 Pro +// BenchmarkBlockWriterAppendWithExt +// BenchmarkBlockWriterAppendWithExt-8 11123844 103.6 ns/op 42 B/op 2 allocs/op +func BenchmarkBlockWriterAppendWithExt(b *testing.B) { + b.ReportAllocs() + b.ResetTimer() + + var ( + bitmapSize = 34 + blockID uint32 + ) + desc := newIndexBlockDesc(blockID, bitmapSize) + writer, _ := newBlockWriter(nil, desc, 0, true) for i := 0; i < b.N; i++ { - if writer.full() { - desc = newIndexBlockDesc(0) - writer, _ = newBlockWriter(nil, desc) + ext := randomExt(bitmapSize, 3) + if writer.estimateFull(ext) { + blockID += 1 + desc = newIndexBlockDesc(blockID, bitmapSize) + writer, _ = newBlockWriter(nil, desc, 0, true) } - if err := writer.append(writer.desc.max + 1); err != nil { + if err := writer.append(writer.desc.max+1, ext); err != nil { b.Error(err) } } diff --git a/triedb/pathdb/history_index_iterator.go b/triedb/pathdb/history_index_iterator.go index 1ccb39ad0970..e4aca24f5d56 100644 --- a/triedb/pathdb/history_index_iterator.go +++ b/triedb/pathdb/history_index_iterator.go @@ -40,31 +40,133 @@ type HistoryIndexIterator interface { Error() error } +// extFilter provides utilities for filtering index entries based on their +// extension field. +// +// It supports two primary operations: +// +// - determine whether a given target node ID or any of its descendants +// appears explicitly in the extension list. +// +// - determine whether a given target node ID or any of its descendants +// is marked in the extension bitmap. +// +// Together, these checks allow callers to efficiently filter out the irrelevant +// index entries during the lookup. +type extFilter uint16 + +// exists takes the entire extension field in the index block and determines +// whether the target ID or its descendants appears. Note, any of descendant +// can implicitly mean the presence of ancestor. +func (f extFilter) exists(ext []byte) (bool, error) { + fn := uint16(f) + list, err := decodeIDs(ext) + if err != nil { + return false, err + } + for _, elem := range list { + if elem == fn { + return true, nil + } + if isAncestor(fn, elem) { + return true, nil + } + } + return false, nil +} + +const ( + // bitmapBytesTwoLevels is the size of the bitmap for two levels of the + // 16-ary tree (16 nodes total, excluding the root). + bitmapBytesTwoLevels = 2 + + // bitmapBytesThreeLevels is the size of the bitmap for three levels of + // the 16-ary tree (272 nodes total, excluding the root). + bitmapBytesThreeLevels = 34 + + // bitmapElementThresholdTwoLevels is the total number of elements in the + // two levels of a 16-ary tree (16 nodes total, excluding the root). + bitmapElementThresholdTwoLevels = 16 + + // bitmapElementThresholdThreeLevels is the total number of elements in the + // two levels of a 16-ary tree (16 nodes total, excluding the root). + bitmapElementThresholdThreeLevels = bitmapElementThresholdTwoLevels + 16*16 +) + +// contains takes the bitmap from the block metadata and determines whether the +// target ID or its descendants is marked in the bitmap. Note, any of descendant +// can implicitly mean the presence of ancestor. +func (f extFilter) contains(bitmap []byte) (bool, error) { + id := int(f) + if id == 0 { + return true, nil + } + n := id - 1 // apply the position shift for excluding root node + + switch len(bitmap) { + case 0: + // Bitmap is not available, return "false positive" + return true, nil + case bitmapBytesTwoLevels: + // Bitmap for 2-level trie with at most 16 elements inside + if n >= bitmapElementThresholdTwoLevels { + return false, fmt.Errorf("invalid extension filter %d for 2 bytes bitmap", id) + } + return isBitSet(bitmap, n), nil + case bitmapBytesThreeLevels: + // Bitmap for 3-level trie with at most 16+16*16 elements inside + if n >= bitmapElementThresholdThreeLevels { + return false, fmt.Errorf("invalid extension filter %d for 34 bytes bitmap", id) + } else if n >= bitmapElementThresholdTwoLevels { + return isBitSet(bitmap, n), nil + } else { + // Check the element itself first + if isBitSet(bitmap, n) { + return true, nil + } + // Check descendants: the presence of any descendant implicitly + // represents a mutation of its ancestor. + return bitmap[2+2*n] != 0 || bitmap[3+2*n] != 0, nil + } + default: + return false, fmt.Errorf("unsupported bitmap size %d", len(bitmap)) + } +} + // blockIterator is the iterator to traverse the indices within a single block. type blockIterator struct { // immutable fields data []byte // Reference to the data segment within the block reader restarts []uint16 // Offsets pointing to the restart sections within the data + hasExt bool // Flag whether the extension is included in the data + + // Optional extension filter + filter *extFilter // Filters index entries based on the extension field. // mutable fields id uint64 // ID of the element at the iterators current position + ext []byte // Extension field of the element at the iterators current position dataPtr int // Current read position within the data slice restartPtr int // Index of the restart section where the iterator is currently positioned exhausted bool // Flag whether the iterator has been exhausted err error // Accumulated error during the traversal } -func newBlockIterator(data []byte, restarts []uint16) *blockIterator { +func (br *blockReader) newIterator(filter *extFilter) *blockIterator { it := &blockIterator{ - data: data, // hold the slice directly with no deep copy - restarts: restarts, // hold the slice directly with no deep copy + data: br.data, // hold the slice directly with no deep copy + restarts: br.restarts, // hold the slice directly with no deep copy + hasExt: br.hasExt, // flag whether the extension should be resolved + filter: filter, // optional extension filter } it.reset() return it } -func (it *blockIterator) set(dataPtr int, restartPtr int, id uint64) { +func (it *blockIterator) set(dataPtr int, restartPtr int, id uint64, ext []byte) { it.id = id + it.ext = ext + it.dataPtr = dataPtr it.restartPtr = restartPtr it.exhausted = dataPtr == len(it.data) @@ -79,6 +181,8 @@ func (it *blockIterator) setErr(err error) { func (it *blockIterator) reset() { it.id = 0 + it.ext = nil + it.dataPtr = -1 it.restartPtr = -1 it.exhausted = false @@ -90,12 +194,26 @@ func (it *blockIterator) reset() { } } -// SeekGT moves the iterator to the first element whose id is greater than the +func (it *blockIterator) resolveExt(pos int) ([]byte, int, error) { + if !it.hasExt { + return nil, 0, nil + } + length, n := binary.Uvarint(it.data[pos:]) + if n <= 0 { + return nil, 0, fmt.Errorf("too short for extension, pos: %d, datalen: %d", pos, len(it.data)) + } + if len(it.data[pos+n:]) < int(length) { + return nil, 0, fmt.Errorf("too short for extension, pos: %d, length: %d, datalen: %d", pos, length, len(it.data)) + } + return it.data[pos+n : pos+n+int(length)], n + int(length), nil +} + +// seekGT moves the iterator to the first element whose id is greater than the // given number. It returns whether such element exists. // // Note, this operation will unset the exhausted status and subsequent traversal // is allowed. -func (it *blockIterator) SeekGT(id uint64) bool { +func (it *blockIterator) seekGT(id uint64) bool { if it.err != nil { return false } @@ -112,11 +230,20 @@ func (it *blockIterator) SeekGT(id uint64) bool { return false } if index == 0 { - item, n := binary.Uvarint(it.data[it.restarts[0]:]) + pos := int(it.restarts[0]) + item, n := binary.Uvarint(it.data[pos:]) + if n <= 0 { + it.setErr(fmt.Errorf("failed to decode item at pos %d", it.restarts[0])) + return false + } + pos = pos + n - // If the restart size is 1, then the restart pointer shouldn't be 0. - // It's not practical and should be denied in the first place. - it.set(int(it.restarts[0])+n, 0, item) + ext, shift, err := it.resolveExt(pos) + if err != nil { + it.setErr(err) + return false + } + it.set(pos+shift, 0, item, ext) return true } var ( @@ -154,11 +281,18 @@ func (it *blockIterator) SeekGT(id uint64) bool { } pos += n + ext, shift, err := it.resolveExt(pos) + if err != nil { + it.setErr(err) + return false + } + pos += shift + if result > id { if pos == limit { - it.set(pos, restartIndex+1, result) + it.set(pos, restartIndex+1, result, ext) } else { - it.set(pos, restartIndex, result) + it.set(pos, restartIndex, result, ext) } return true } @@ -170,8 +304,45 @@ func (it *blockIterator) SeekGT(id uint64) bool { } // The element which is the first one greater than the specified id // is exactly the one located at the restart point. - item, n := binary.Uvarint(it.data[it.restarts[index]:]) - it.set(int(it.restarts[index])+n, index, item) + pos = int(it.restarts[index]) + item, n := binary.Uvarint(it.data[pos:]) + if n <= 0 { + it.setErr(fmt.Errorf("failed to decode item at pos %d", it.restarts[index])) + return false + } + pos = pos + n + + ext, shift, err := it.resolveExt(pos) + if err != nil { + it.setErr(err) + return false + } + it.set(pos+shift, index, item, ext) + return true +} + +// SeekGT implements HistoryIndexIterator, is the wrapper of the seekGT with +// optional extension filter logic applied. +func (it *blockIterator) SeekGT(id uint64) bool { + if !it.seekGT(id) { + return false + } + if it.filter == nil { + return true + } + for { + found, err := it.filter.exists(it.ext) + if err != nil { + it.setErr(err) + return false + } + if found { + break + } + if !it.next() { + return false + } + } return true } @@ -183,10 +354,9 @@ func (it *blockIterator) init() { it.restartPtr = 0 } -// Next implements the HistoryIndexIterator, moving the iterator to the next -// element. If the iterator has been exhausted, and boolean with false should -// be returned. -func (it *blockIterator) Next() bool { +// next moves the iterator to the next element. If the iterator has been exhausted, +// and boolean with false should be returned. +func (it *blockIterator) next() bool { if it.exhausted || it.err != nil { return false } @@ -198,7 +368,6 @@ func (it *blockIterator) Next() bool { it.setErr(fmt.Errorf("failed to decode item at pos %d", it.dataPtr)) return false } - var val uint64 if it.dataPtr == int(it.restarts[it.restartPtr]) { val = v @@ -206,13 +375,45 @@ func (it *blockIterator) Next() bool { val = it.id + v } + // Decode the extension field + ext, shift, err := it.resolveExt(it.dataPtr + n) + if err != nil { + it.setErr(err) + return false + } + // Move to the next restart section if the data pointer crosses the boundary nextRestartPtr := it.restartPtr - if it.restartPtr < len(it.restarts)-1 && it.dataPtr+n == int(it.restarts[it.restartPtr+1]) { + if it.restartPtr < len(it.restarts)-1 && it.dataPtr+n+shift == int(it.restarts[it.restartPtr+1]) { nextRestartPtr = it.restartPtr + 1 } - it.set(it.dataPtr+n, nextRestartPtr, val) + it.set(it.dataPtr+n+shift, nextRestartPtr, val, ext) + + return true +} +// Next implements the HistoryIndexIterator, moving the iterator to the next +// element. It's a wrapper of next with optional extension filter logic applied. +func (it *blockIterator) Next() bool { + if !it.next() { + return false + } + if it.filter == nil { + return true + } + for { + found, err := it.filter.exists(it.ext) + if err != nil { + it.setErr(err) + return false + } + if found { + break + } + if !it.next() { + return false + } + } return true } @@ -226,15 +427,15 @@ func (it *blockIterator) ID() uint64 { // Exhausting all the elements is not considered to be an error. func (it *blockIterator) Error() error { return it.err } -// blockLoader defines the method to retrieve the specific block for reading. -type blockLoader func(id uint32) (*blockReader, error) - // indexIterator is an iterator to traverse the history indices belonging to the // specific state entry. type indexIterator struct { // immutable fields descList []*indexBlockDesc - loader blockLoader + reader *indexReader + + // Optional extension filter + filter *extFilter // mutable fields blockIt *blockIterator @@ -243,10 +444,26 @@ type indexIterator struct { err error } -func newIndexIterator(descList []*indexBlockDesc, loader blockLoader) *indexIterator { +// newBlockIter initializes the block iterator with the specified block ID. +func (r *indexReader) newBlockIter(id uint32, filter *extFilter) (*blockIterator, error) { + br, ok := r.readers[id] + if !ok { + var err error + br, err = newBlockReader(readStateIndexBlock(r.state, r.db, id), r.bitmapSize != 0) + if err != nil { + return nil, err + } + r.readers[id] = br + } + return br.newIterator(filter), nil +} + +// newIterator initializes the index iterator with the specified extension filter. +func (r *indexReader) newIterator(filter *extFilter) *indexIterator { it := &indexIterator{ - descList: descList, - loader: loader, + descList: r.descList, + reader: r, + filter: filter, } it.reset() return it @@ -271,16 +488,32 @@ func (it *indexIterator) reset() { } func (it *indexIterator) open(blockPtr int) error { - id := it.descList[blockPtr].id - br, err := it.loader(id) + blockIt, err := it.reader.newBlockIter(it.descList[blockPtr].id, it.filter) if err != nil { return err } - it.blockIt = newBlockIterator(br.data, br.restarts) + it.blockIt = blockIt it.blockPtr = blockPtr return nil } +func (it *indexIterator) applyFilter(index int) (int, error) { + if it.filter == nil { + return index, nil + } + for index < len(it.descList) { + found, err := it.filter.contains(it.descList[index].extBitmap) + if err != nil { + return 0, err + } + if found { + break + } + index++ + } + return index, nil +} + // SeekGT moves the iterator to the first element whose id is greater than the // given number. It returns whether such element exists. // @@ -293,6 +526,11 @@ func (it *indexIterator) SeekGT(id uint64) bool { index := sort.Search(len(it.descList), func(i int) bool { return id < it.descList[i].max }) + index, err := it.applyFilter(index) + if err != nil { + it.setErr(err) + return false + } if index == len(it.descList) { return false } @@ -304,7 +542,13 @@ func (it *indexIterator) SeekGT(id uint64) bool { return false } } - return it.blockIt.SeekGT(id) + // Terminate if the element which is greater than the id can be found in the + // last block; otherwise move to the next block. It may happen that all the + // target elements in this block are all less than id. + if it.blockIt.SeekGT(id) { + return true + } + return it.Next() } func (it *indexIterator) init() error { @@ -325,15 +569,23 @@ func (it *indexIterator) Next() bool { it.setErr(err) return false } - if it.blockIt.Next() { return true } - if it.blockPtr == len(it.descList)-1 { + it.blockPtr++ + + index, err := it.applyFilter(it.blockPtr) + if err != nil { + it.setErr(err) + return false + } + it.blockPtr = index + + if it.blockPtr == len(it.descList) { it.exhausted = true return false } - if err := it.open(it.blockPtr + 1); err != nil { + if err := it.open(it.blockPtr); err != nil { it.setErr(err) return false } @@ -357,3 +609,48 @@ func (it *indexIterator) Error() error { func (it *indexIterator) ID() uint64 { return it.blockIt.ID() } + +// seqIter provides a simple iterator over a contiguous sequence of +// unsigned integers, ending at end (end is included). +type seqIter struct { + cur uint64 // current position + end uint64 // iteration stops at end-1 + done bool // true when iteration is exhausted +} + +func newSeqIter(last uint64) *seqIter { + return &seqIter{end: last + 1} +} + +// SeekGT positions the iterator at the smallest element > id. +// Returns false if no such element exists. +func (it *seqIter) SeekGT(id uint64) bool { + if id+1 >= it.end { + it.done = true + return false + } + it.cur = id + 1 + it.done = false + return true +} + +// Next advances the iterator. Returns false if exhausted. +func (it *seqIter) Next() bool { + if it.done { + return false + } + if it.cur+1 < it.end { + it.cur++ + return true + } + // this was the last element + it.done = true + return false +} + +// ID returns the id of the element where the iterator is positioned at. +func (it *seqIter) ID() uint64 { return it.cur } + +// Error returns any accumulated error. Exhausting all the elements is not +// considered to be an error. +func (it *seqIter) Error() error { return nil } diff --git a/triedb/pathdb/history_index_iterator_test.go b/triedb/pathdb/history_index_iterator_test.go index da60dc6e8f28..a11fd1766693 100644 --- a/triedb/pathdb/history_index_iterator_test.go +++ b/triedb/pathdb/history_index_iterator_test.go @@ -19,7 +19,9 @@ package pathdb import ( "errors" "fmt" + "maps" "math/rand" + "slices" "sort" "testing" @@ -28,12 +30,30 @@ import ( "github.com/ethereum/go-ethereum/ethdb" ) -func makeTestIndexBlock(count int) ([]byte, []uint64) { +func checkExt(f *extFilter, ext []uint16) bool { + if f == nil { + return true + } + fn := uint16(*f) + + for _, n := range ext { + if n == fn { + return true + } + if isAncestor(fn, n) { + return true + } + } + return false +} + +func makeTestIndexBlock(count int, bitmapSize int) ([]byte, []uint64, [][]uint16) { var ( marks = make(map[uint64]bool) - elements []uint64 + elements = make([]uint64, 0, count) + extList = make([][]uint16, 0, count) ) - bw, _ := newBlockWriter(nil, newIndexBlockDesc(0)) + bw, _ := newBlockWriter(nil, newIndexBlockDesc(0, bitmapSize), 0, bitmapSize != 0) for i := 0; i < count; i++ { n := uint64(rand.Uint32()) if marks[n] { @@ -45,17 +65,20 @@ func makeTestIndexBlock(count int) ([]byte, []uint64) { sort.Slice(elements, func(i, j int) bool { return elements[i] < elements[j] }) for i := 0; i < len(elements); i++ { - bw.append(elements[i]) + ext := randomExt(bitmapSize, 5) + extList = append(extList, ext) + bw.append(elements[i], ext) } data := bw.finish() - return data, elements + return data, elements, extList } -func makeTestIndexBlocks(db ethdb.KeyValueStore, stateIdent stateIdent, count int) []uint64 { +func makeTestIndexBlocks(db ethdb.KeyValueStore, stateIdent stateIdent, count int, bitmapSize int) ([]uint64, [][]uint16) { var ( marks = make(map[uint64]bool) elements []uint64 + extList [][]uint16 ) for i := 0; i < count; i++ { n := uint64(rand.Uint32()) @@ -67,15 +90,17 @@ func makeTestIndexBlocks(db ethdb.KeyValueStore, stateIdent stateIdent, count in } sort.Slice(elements, func(i, j int) bool { return elements[i] < elements[j] }) - iw, _ := newIndexWriter(db, stateIdent) + iw, _ := newIndexWriter(db, stateIdent, 0, bitmapSize) for i := 0; i < len(elements); i++ { - iw.append(elements[i]) + ext := randomExt(bitmapSize, 5) + extList = append(extList, ext) + iw.append(elements[i], ext) } batch := db.NewBatch() iw.finish(batch) batch.Write() - return elements + return elements, extList } func checkSeekGT(it HistoryIndexIterator, input uint64, exp bool, expVal uint64) error { @@ -113,43 +138,40 @@ func checkNext(it HistoryIndexIterator, values []uint64) error { return it.Error() } -func TestBlockIteratorSeekGT(t *testing.T) { - /* 0-size index block is not allowed - - data, elements := makeTestIndexBlock(0) - testBlockIterator(t, data, elements) - */ - - data, elements := makeTestIndexBlock(1) - testBlockIterator(t, data, elements) - - data, elements = makeTestIndexBlock(indexBlockRestartLen) - testBlockIterator(t, data, elements) - - data, elements = makeTestIndexBlock(3 * indexBlockRestartLen) - testBlockIterator(t, data, elements) - - data, elements = makeTestIndexBlock(indexBlockEntriesCap) - testBlockIterator(t, data, elements) -} - -func testBlockIterator(t *testing.T, data []byte, elements []uint64) { - br, err := newBlockReader(data) - if err != nil { - t.Fatalf("Failed to open the block for reading, %v", err) +func verifySeekGT(t *testing.T, elements []uint64, ext [][]uint16, newIter func(filter *extFilter) HistoryIndexIterator) { + set := make(map[extFilter]bool) + for _, extList := range ext { + for _, f := range extList { + set[extFilter(f)] = true + } } - it := newBlockIterator(br.data, br.restarts) + filters := slices.Collect(maps.Keys(set)) for i := 0; i < 128; i++ { + var filter *extFilter + if rand.Intn(2) == 0 && len(filters) > 0 { + filter = &filters[rand.Intn(len(filters))] + } else { + filter = nil + } + var input uint64 if rand.Intn(2) == 0 { input = elements[rand.Intn(len(elements))] } else { input = uint64(rand.Uint32()) } + index := sort.Search(len(elements), func(i int) bool { return elements[i] > input }) + for index < len(elements) { + if checkExt(filter, ext[index]) { + break + } + index++ + } + var ( exp bool expVal uint64 @@ -160,10 +182,17 @@ func testBlockIterator(t *testing.T, data []byte, elements []uint64) { } else { exp = true expVal = elements[index] - if index < len(elements) { - remains = elements[index+1:] + + index++ + for index < len(elements) { + if checkExt(filter, ext[index]) { + remains = append(remains, elements[index]) + } + index++ } } + + it := newIter(filter) if err := checkSeekGT(it, input, exp, expVal); err != nil { t.Fatal(err) } @@ -175,62 +204,71 @@ func testBlockIterator(t *testing.T, data []byte, elements []uint64) { } } -func TestIndexIteratorSeekGT(t *testing.T) { - ident := newAccountIdent(common.Hash{0x1}) - - dbA := rawdb.NewMemoryDatabase() - testIndexIterator(t, ident, dbA, makeTestIndexBlocks(dbA, ident, 1)) - - dbB := rawdb.NewMemoryDatabase() - testIndexIterator(t, ident, dbB, makeTestIndexBlocks(dbB, ident, 3*indexBlockEntriesCap)) - - dbC := rawdb.NewMemoryDatabase() - testIndexIterator(t, ident, dbC, makeTestIndexBlocks(dbC, ident, indexBlockEntriesCap-1)) - - dbD := rawdb.NewMemoryDatabase() - testIndexIterator(t, ident, dbD, makeTestIndexBlocks(dbD, ident, indexBlockEntriesCap+1)) -} - -func testIndexIterator(t *testing.T, stateIdent stateIdent, db ethdb.Database, elements []uint64) { - ir, err := newIndexReader(db, stateIdent) - if err != nil { - t.Fatalf("Failed to open the index reader, %v", err) +func verifyTraversal(t *testing.T, elements []uint64, ext [][]uint16, newIter func(filter *extFilter) HistoryIndexIterator) { + set := make(map[extFilter]bool) + for _, extList := range ext { + for _, f := range extList { + set[extFilter(f)] = true + } } - it := newIndexIterator(ir.descList, func(id uint32) (*blockReader, error) { - return newBlockReader(readStateIndexBlock(stateIdent, db, id)) - }) + filters := slices.Collect(maps.Keys(set)) - for i := 0; i < 128; i++ { - var input uint64 - if rand.Intn(2) == 0 { - input = elements[rand.Intn(len(elements))] + for i := 0; i < 16; i++ { + var filter *extFilter + if len(filters) > 0 { + filter = &filters[rand.Intn(len(filters))] } else { - input = uint64(rand.Uint32()) + filter = nil } - index := sort.Search(len(elements), func(i int) bool { - return elements[i] > input - }) + it := newIter(filter) + var ( - exp bool - expVal uint64 - remains []uint64 + pos int + exp []uint64 ) - if index == len(elements) { - exp = false - } else { - exp = true - expVal = elements[index] - if index < len(elements) { - remains = elements[index+1:] + for pos < len(elements) { + if checkExt(filter, ext[pos]) { + exp = append(exp, elements[pos]) } + pos++ } - if err := checkSeekGT(it, input, exp, expVal); err != nil { + if err := checkNext(it, exp); err != nil { t.Fatal(err) } - if exp { - if err := checkNext(it, remains); err != nil { - t.Fatal(err) - } + } +} + +func TestBlockIteratorSeekGT(t *testing.T) { + for _, size := range []int{0, 2, 34} { + for _, n := range []int{1, indexBlockRestartLen, 3 * indexBlockRestartLen} { + data, elements, ext := makeTestIndexBlock(n, size) + + verifySeekGT(t, elements, ext, func(filter *extFilter) HistoryIndexIterator { + br, err := newBlockReader(data, size != 0) + if err != nil { + t.Fatalf("Failed to open the block for reading, %v", err) + } + return br.newIterator(filter) + }) + } + } +} + +func TestIndexIteratorSeekGT(t *testing.T) { + ident := newAccountIdent(common.Hash{0x1}) + + for _, size := range []int{0, 2, 34} { + for _, n := range []int{1, 4096, 3 * 4096} { + db := rawdb.NewMemoryDatabase() + elements, ext := makeTestIndexBlocks(db, ident, n, size) + + verifySeekGT(t, elements, ext, func(filter *extFilter) HistoryIndexIterator { + ir, err := newIndexReader(db, ident, size) + if err != nil { + t.Fatalf("Failed to open the index reader, %v", err) + } + return ir.newIterator(filter) + }) } } } @@ -242,56 +280,82 @@ func TestBlockIteratorTraversal(t *testing.T) { testBlockIterator(t, data, elements) */ - data, elements := makeTestIndexBlock(1) - testBlockIteratorTraversal(t, data, elements) - - data, elements = makeTestIndexBlock(indexBlockRestartLen) - testBlockIteratorTraversal(t, data, elements) - - data, elements = makeTestIndexBlock(3 * indexBlockRestartLen) - testBlockIteratorTraversal(t, data, elements) - - data, elements = makeTestIndexBlock(indexBlockEntriesCap) - testBlockIteratorTraversal(t, data, elements) -} - -func testBlockIteratorTraversal(t *testing.T, data []byte, elements []uint64) { - br, err := newBlockReader(data) - if err != nil { - t.Fatalf("Failed to open the block for reading, %v", err) - } - it := newBlockIterator(br.data, br.restarts) - - if err := checkNext(it, elements); err != nil { - t.Fatal(err) + for _, size := range []int{0, 2, 34} { + for _, n := range []int{1, indexBlockRestartLen, 3 * indexBlockRestartLen} { + data, elements, ext := makeTestIndexBlock(n, size) + + verifyTraversal(t, elements, ext, func(filter *extFilter) HistoryIndexIterator { + br, err := newBlockReader(data, size != 0) + if err != nil { + t.Fatalf("Failed to open the block for reading, %v", err) + } + return br.newIterator(filter) + }) + } } } func TestIndexIteratorTraversal(t *testing.T) { ident := newAccountIdent(common.Hash{0x1}) - dbA := rawdb.NewMemoryDatabase() - testIndexIteratorTraversal(t, ident, dbA, makeTestIndexBlocks(dbA, ident, 1)) - - dbB := rawdb.NewMemoryDatabase() - testIndexIteratorTraversal(t, ident, dbB, makeTestIndexBlocks(dbB, ident, 3*indexBlockEntriesCap)) + for _, size := range []int{0, 2, 34} { + for _, n := range []int{1, 4096, 3 * 4096} { + db := rawdb.NewMemoryDatabase() + elements, ext := makeTestIndexBlocks(db, ident, n, size) + + verifyTraversal(t, elements, ext, func(filter *extFilter) HistoryIndexIterator { + ir, err := newIndexReader(db, ident, size) + if err != nil { + t.Fatalf("Failed to open the index reader, %v", err) + } + return ir.newIterator(filter) + }) + } + } +} - dbC := rawdb.NewMemoryDatabase() - testIndexIteratorTraversal(t, ident, dbC, makeTestIndexBlocks(dbC, ident, indexBlockEntriesCap-1)) +func TestSeqIterBasicIteration(t *testing.T) { + it := newSeqIter(5) // iterates over [1..5] + it.SeekGT(0) - dbD := rawdb.NewMemoryDatabase() - testIndexIteratorTraversal(t, ident, dbD, makeTestIndexBlocks(dbD, ident, indexBlockEntriesCap+1)) + var ( + got []uint64 + expected = []uint64{1, 2, 3, 4, 5} + ) + got = append(got, it.ID()) + for it.Next() { + got = append(got, it.ID()) + } + if len(got) != len(expected) { + t.Fatalf("iteration length mismatch: got %v, expected %v", got, expected) + } + for i := range expected { + if got[i] != expected[i] { + t.Fatalf("element mismatch at %d: got %d, expected %d", i, got[i], expected[i]) + } + } } -func testIndexIteratorTraversal(t *testing.T, stateIdent stateIdent, db ethdb.KeyValueReader, elements []uint64) { - ir, err := newIndexReader(db, stateIdent) - if err != nil { - t.Fatalf("Failed to open the index reader, %v", err) +func TestSeqIterSeekGT(t *testing.T) { + it := newSeqIter(5) + + tests := []struct { + input uint64 + ok bool + expected uint64 + }{ + {0, true, 1}, + {1, true, 2}, + {4, true, 5}, + {5, false, 0}, // 6 is out of range } - it := newIndexIterator(ir.descList, func(id uint32) (*blockReader, error) { - return newBlockReader(readStateIndexBlock(stateIdent, db, id)) - }) - if err := checkNext(it, elements); err != nil { - t.Fatal(err) + for _, tt := range tests { + ok := it.SeekGT(tt.input) + if ok != tt.ok { + t.Fatalf("SeekGT(%d) ok mismatch: got %v, expected %v", tt.input, ok, tt.ok) + } + if ok && it.ID() != tt.expected { + t.Fatalf("SeekGT(%d) positioned at %d, expected %d", tt.input, it.ID(), tt.expected) + } } } diff --git a/triedb/pathdb/history_index_pruner.go b/triedb/pathdb/history_index_pruner.go new file mode 100644 index 000000000000..c9be3618e822 --- /dev/null +++ b/triedb/pathdb/history_index_pruner.go @@ -0,0 +1,385 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package pathdb + +import ( + "encoding/binary" + "sync" + "sync/atomic" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" +) + +const ( + // indexPruningThreshold defines the number of pruned histories that must + // accumulate before triggering index pruning. This helps avoid scheduling + // index pruning too frequently. + indexPruningThreshold = 90000 + + // iteratorReopenInterval is how long the iterator is kept open before + // being released and re-opened. Long-lived iterators hold a read snapshot + // that blocks LSM compaction; periodically re-opening avoids stalling the + // compactor during a large scan. + iteratorReopenInterval = 30 * time.Second +) + +// indexPruner is responsible for pruning stale index data from the tail side +// when old history objects are removed. It runs as a background goroutine and +// processes pruning signals whenever the history tail advances. +// +// The pruning operates at the block level: for each state element's index +// metadata, leading index blocks whose maximum history ID falls below the +// new tail are removed entirely. This avoids the need to decode individual +// block contents and is efficient because index blocks store monotonically +// increasing history IDs. +type indexPruner struct { + disk ethdb.KeyValueStore + typ historyType + tail atomic.Uint64 // Tail below which index entries can be pruned + lastRun uint64 // The tail in the last pruning run + trigger chan struct{} // Non-blocking signal that tail has advanced + closed chan struct{} + wg sync.WaitGroup + log log.Logger + + pauseReq chan chan struct{} // Pause request; caller sends ack channel, pruner closes it when paused + resumeCh chan struct{} // Resume signal sent by caller after indexSingle/unindexSingle completes +} + +// newIndexPruner creates and starts a new index pruner for the given history type. +func newIndexPruner(disk ethdb.KeyValueStore, typ historyType) *indexPruner { + p := &indexPruner{ + disk: disk, + typ: typ, + trigger: make(chan struct{}, 1), + closed: make(chan struct{}), + log: log.New("type", typ.String()), + pauseReq: make(chan chan struct{}), + resumeCh: make(chan struct{}), + } + p.wg.Add(1) + go p.run() + return p +} + +// prune signals the pruner that the history tail has advanced to the given ID. +// All index entries referencing history IDs below newTail can be removed. +func (p *indexPruner) prune(newTail uint64) { + // Only update if the tail is actually advancing + for { + old := p.tail.Load() + if newTail <= old { + return + } + if p.tail.CompareAndSwap(old, newTail) { + break + } + } + // Non-blocking signal + select { + case p.trigger <- struct{}{}: + default: + } +} + +// pause requests the pruner to flush all pending writes and pause. It blocks +// until the pruner has acknowledged the pause. This must be paired with a +// subsequent call to resume. +func (p *indexPruner) pause() { + ack := make(chan struct{}) + select { + case p.pauseReq <- ack: + <-ack // wait for the pruner to flush and acknowledge + case <-p.closed: + } +} + +// resume unblocks a previously paused pruner, allowing it to continue +// processing. +func (p *indexPruner) resume() { + select { + case p.resumeCh <- struct{}{}: + case <-p.closed: + } +} + +// close shuts down the pruner and waits for it to finish. +func (p *indexPruner) close() { + select { + case <-p.closed: + return + default: + close(p.closed) + p.wg.Wait() + } +} + +// run is the main loop of the pruner. It waits for trigger signals and +// processes a small batch of entries on each trigger, advancing the cursor. +func (p *indexPruner) run() { + defer p.wg.Done() + + for { + select { + case <-p.trigger: + tail := p.tail.Load() + if tail < p.lastRun || tail-p.lastRun < indexPruningThreshold { + continue + } + if err := p.process(tail); err != nil { + p.log.Error("Failed to prune index", "tail", tail, "err", err) + } else { + p.lastRun = tail + } + + case ack := <-p.pauseReq: + // Pruner is idle, acknowledge immediately and wait for resume. + close(ack) + select { + case <-p.resumeCh: + case <-p.closed: + return + } + + case <-p.closed: + return + } + } +} + +// process iterates all index metadata entries for the history type and prunes +// leading blocks whose max history ID is below the given tail. +func (p *indexPruner) process(tail uint64) error { + var ( + err error + pruned int + start = time.Now() + ) + switch p.typ { + case typeStateHistory: + n, err := p.prunePrefix(rawdb.StateHistoryAccountMetadataPrefix, typeAccount, tail) + if err != nil { + return err + } + pruned += n + + n, err = p.prunePrefix(rawdb.StateHistoryStorageMetadataPrefix, typeStorage, tail) + if err != nil { + return err + } + pruned += n + statePruneHistoryIndexTimer.UpdateSince(start) + + case typeTrienodeHistory: + pruned, err = p.prunePrefix(rawdb.TrienodeHistoryMetadataPrefix, typeTrienode, tail) + if err != nil { + return err + } + trienodePruneHistoryIndexTimer.UpdateSince(start) + + default: + panic("unknown history type") + } + if pruned > 0 { + p.log.Info("Pruned stale index blocks", "pruned", pruned, "tail", tail, "elapsed", common.PrettyDuration(time.Since(start))) + } + return nil +} + +// prunePrefix scans all metadata entries under the given prefix and prunes +// leading index blocks below the tail. The iterator is periodically released +// and re-opened to avoid holding a read snapshot that blocks LSM compaction. +func (p *indexPruner) prunePrefix(prefix []byte, elemType elementType, tail uint64) (int, error) { + var ( + pruned int + opened = time.Now() + it = p.disk.NewIterator(prefix, nil) + batch = p.disk.NewBatchWithSize(ethdb.IdealBatchSize) + ) + for { + // Terminate if iterator is exhausted + if !it.Next() { + it.Release() + break + } + // Check termination or pause request + select { + case <-p.closed: + // Terminate the process if indexer is closed + it.Release() + if batch.ValueSize() > 0 { + return pruned, batch.Write() + } + return pruned, nil + + case ack := <-p.pauseReq: + // Save the current position so that after resume the + // iterator can be re-opened from where it left off. + start := common.CopyBytes(it.Key()[len(prefix):]) + it.Release() + + // Flush all pending writes before acknowledging the pause. + var flushErr error + if batch.ValueSize() > 0 { + if err := batch.Write(); err != nil { + flushErr = err + } + batch.Reset() + } + close(ack) + + // Block until resumed or closed. Always wait here even if + // the flush failed — returning early would cause resume() + // to deadlock since nobody would receive on resumeCh. + select { + case <-p.resumeCh: + if flushErr != nil { + return 0, flushErr + } + // Re-open the iterator from the saved position so the + // pruner sees the current database state (including any + // writes made by indexer during the pause). + it = p.disk.NewIterator(prefix, start) + opened = time.Now() + continue + case <-p.closed: + return pruned, flushErr + } + + default: + // Keep processing + } + + // Prune the index data block + key, value := it.Key(), it.Value() + ident, bsize := p.identFromKey(key, prefix, elemType) + n, err := p.pruneEntry(batch, ident, value, bsize, tail) + if err != nil { + p.log.Warn("Failed to prune index entry", "ident", ident, "err", err) + continue + } + pruned += n + + // Flush the batch if there are too many accumulated + if batch.ValueSize() >= ethdb.IdealBatchSize { + if err := batch.Write(); err != nil { + it.Release() + return 0, err + } + batch.Reset() + } + + // Periodically release the iterator so the LSM compactor + // is not blocked by the read snapshot we hold. + if time.Since(opened) >= iteratorReopenInterval { + opened = time.Now() + + start := common.CopyBytes(it.Key()[len(prefix):]) + it.Release() + it = p.disk.NewIterator(prefix, start) + } + } + if batch.ValueSize() > 0 { + if err := batch.Write(); err != nil { + return 0, err + } + } + return pruned, nil +} + +// identFromKey reconstructs the stateIdent and bitmapSize from a metadata key. +func (p *indexPruner) identFromKey(key []byte, prefix []byte, elemType elementType) (stateIdent, int) { + rest := key[len(prefix):] + + switch elemType { + case typeAccount: + // key = prefix + addressHash(32) + var addrHash common.Hash + copy(addrHash[:], rest[:32]) + return newAccountIdent(addrHash), 0 + + case typeStorage: + // key = prefix + addressHash(32) + storageHash(32) + var addrHash, storHash common.Hash + copy(addrHash[:], rest[:32]) + copy(storHash[:], rest[32:64]) + return newStorageIdent(addrHash, storHash), 0 + + case typeTrienode: + // key = prefix + addressHash(32) + path(variable) + var addrHash common.Hash + copy(addrHash[:], rest[:32]) + path := string(rest[32:]) + ident := newTrienodeIdent(addrHash, path) + return ident, ident.bloomSize() + + default: + panic("unknown element type") + } +} + +// pruneEntry checks a single metadata entry and removes leading index blocks +// whose max < tail. Returns the number of blocks pruned. +func (p *indexPruner) pruneEntry(batch ethdb.Batch, ident stateIdent, blob []byte, bsize int, tail uint64) (int, error) { + // Fast path: the first 8 bytes of the metadata encode the max history ID + // of the first index block (big-endian uint64). If it is >= tail, no + // blocks can be pruned and we skip the full parse entirely. + if len(blob) >= 8 && binary.BigEndian.Uint64(blob[:8]) >= tail { + return 0, nil + } + descList, err := parseIndex(blob, bsize) + if err != nil { + return 0, err + } + // Find the number of leading blocks that can be entirely pruned. + // A block can be pruned if its max history ID is strictly below + // the tail. + var count int + for _, desc := range descList { + if desc.max < tail { + count++ + } else { + break // blocks are ordered, no more to prune + } + } + if count == 0 { + return 0, nil + } + // Delete the pruned index blocks + for i := 0; i < count; i++ { + deleteStateIndexBlock(ident, batch, descList[i].id) + } + // Update or delete the metadata + remaining := descList[count:] + if len(remaining) == 0 { + // All blocks pruned, remove the metadata entry entirely + deleteStateIndex(ident, batch) + } else { + // Rewrite the metadata with the remaining blocks + size := indexBlockDescSize + bsize + buf := make([]byte, 0, size*len(remaining)) + for _, desc := range remaining { + buf = append(buf, desc.encode()...) + } + writeStateIndex(ident, batch, buf) + } + return count, nil +} diff --git a/triedb/pathdb/history_index_pruner_test.go b/triedb/pathdb/history_index_pruner_test.go new file mode 100644 index 000000000000..b3094de3e692 --- /dev/null +++ b/triedb/pathdb/history_index_pruner_test.go @@ -0,0 +1,355 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package pathdb + +import ( + "math" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" +) + +func writeMultiBlockIndex(t *testing.T, db ethdb.Database, ident stateIdent, bitmapSize int, startID uint64) []*indexBlockDesc { + t.Helper() + + if startID == 0 { + startID = 1 + } + iw, _ := newIndexWriter(db, ident, 0, bitmapSize) + + for i := 0; i < 10000; i++ { + if err := iw.append(startID+uint64(i), randomExt(bitmapSize, 5)); err != nil { + t.Fatalf("Failed to append element %d: %v", i, err) + } + } + batch := db.NewBatch() + iw.finish(batch) + if err := batch.Write(); err != nil { + t.Fatalf("Failed to write batch: %v", err) + } + + blob := readStateIndex(ident, db) + descList, err := parseIndex(blob, bitmapSize) + if err != nil { + t.Fatalf("Failed to parse index: %v", err) + } + return descList +} + +// TestPruneEntryBasic verifies that pruneEntry correctly removes leading index +// blocks whose max is below the given tail. +func TestPruneEntryBasic(t *testing.T) { + db := rawdb.NewMemoryDatabase() + ident := newAccountIdent(common.Hash{0xa}) + descList := writeMultiBlockIndex(t, db, ident, 0, 1) + + // Prune with a tail that is above the first block's max but below the second + firstBlockMax := descList[0].max + + pruner := newIndexPruner(db, typeStateHistory) + defer pruner.close() + + if err := pruner.process(firstBlockMax + 1); err != nil { + t.Fatalf("Failed to process pruning: %v", err) + } + + // Verify the first block was removed + blob := readStateIndex(ident, db) + if len(blob) == 0 { + t.Fatal("Index metadata should not be empty after partial prune") + } + remaining, err := parseIndex(blob, 0) + if err != nil { + t.Fatalf("Failed to parse index after prune: %v", err) + } + if len(remaining) != len(descList)-1 { + t.Fatalf("Expected %d blocks remaining, got %d", len(descList)-1, len(remaining)) + } + // The first remaining block should be what was previously the second block + if remaining[0].id != descList[1].id { + t.Fatalf("Expected first remaining block id %d, got %d", descList[1].id, remaining[0].id) + } + + // Verify the pruned block data is actually deleted + blockData := readStateIndexBlock(ident, db, descList[0].id) + if len(blockData) != 0 { + t.Fatal("Pruned block data should have been deleted") + } + + // Remaining blocks should still have their data + for _, desc := range remaining { + blockData = readStateIndexBlock(ident, db, desc.id) + if len(blockData) == 0 { + t.Fatalf("Block %d data should still exist", desc.id) + } + } +} + +// TestPruneEntryBasicTrienode is the same as TestPruneEntryBasic but for +// trienode index entries with a non-zero bitmapSize. +func TestPruneEntryBasicTrienode(t *testing.T) { + db := rawdb.NewMemoryDatabase() + addrHash := common.Hash{0xa} + path := string([]byte{0x0, 0x0, 0x0}) + ident := newTrienodeIdent(addrHash, path) + + descList := writeMultiBlockIndex(t, db, ident, ident.bloomSize(), 1) + firstBlockMax := descList[0].max + + pruner := newIndexPruner(db, typeTrienodeHistory) + defer pruner.close() + + if err := pruner.process(firstBlockMax + 1); err != nil { + t.Fatalf("Failed to process pruning: %v", err) + } + + blob := readStateIndex(ident, db) + remaining, err := parseIndex(blob, ident.bloomSize()) + if err != nil { + t.Fatalf("Failed to parse index after prune: %v", err) + } + if len(remaining) != len(descList)-1 { + t.Fatalf("Expected %d blocks remaining, got %d", len(descList)-1, len(remaining)) + } + if remaining[0].id != descList[1].id { + t.Fatalf("Expected first remaining block id %d, got %d", descList[1].id, remaining[0].id) + } + blockData := readStateIndexBlock(ident, db, descList[0].id) + if len(blockData) != 0 { + t.Fatal("Pruned block data should have been deleted") + } +} + +// TestPruneEntryComplete verifies that when all blocks are pruned, the metadata +// entry is also deleted. +func TestPruneEntryComplete(t *testing.T) { + db := rawdb.NewMemoryDatabase() + ident := newAccountIdent(common.Hash{0xb}) + iw, _ := newIndexWriter(db, ident, 0, 0) + + for i := 1; i <= 10; i++ { + if err := iw.append(uint64(i), nil); err != nil { + t.Fatalf("Failed to append: %v", err) + } + } + batch := db.NewBatch() + iw.finish(batch) + if err := batch.Write(); err != nil { + t.Fatalf("Failed to write: %v", err) + } + + pruner := newIndexPruner(db, typeStateHistory) + defer pruner.close() + + // Prune with tail above all elements + if err := pruner.process(11); err != nil { + t.Fatalf("Failed to process: %v", err) + } + + // Metadata entry should be deleted + blob := readStateIndex(ident, db) + if len(blob) != 0 { + t.Fatal("Index metadata should be empty after full prune") + } +} + +// TestPruneNoop verifies that pruning does nothing when the tail is below all +// block maximums. +func TestPruneNoop(t *testing.T) { + db := rawdb.NewMemoryDatabase() + ident := newAccountIdent(common.Hash{0xc}) + iw, _ := newIndexWriter(db, ident, 0, 0) + + for i := 100; i <= 200; i++ { + if err := iw.append(uint64(i), nil); err != nil { + t.Fatalf("Failed to append: %v", err) + } + } + batch := db.NewBatch() + iw.finish(batch) + if err := batch.Write(); err != nil { + t.Fatalf("Failed to write: %v", err) + } + + blob := readStateIndex(ident, db) + origLen := len(blob) + + pruner := newIndexPruner(db, typeStateHistory) + defer pruner.close() + + if err := pruner.process(50); err != nil { + t.Fatalf("Failed to process: %v", err) + } + + // Nothing should have changed + blob = readStateIndex(ident, db) + if len(blob) != origLen { + t.Fatalf("Expected no change, original len %d, got %d", origLen, len(blob)) + } +} + +// TestPrunePreservesReadability verifies that after pruning, the remaining +// index data is still readable and returns correct results. +func TestPrunePreservesReadability(t *testing.T) { + db := rawdb.NewMemoryDatabase() + ident := newAccountIdent(common.Hash{0xe}) + descList := writeMultiBlockIndex(t, db, ident, 0, 1) + firstBlockMax := descList[0].max + + pruner := newIndexPruner(db, typeStateHistory) + defer pruner.close() + + if err := pruner.process(firstBlockMax + 1); err != nil { + t.Fatalf("Failed to process: %v", err) + } + + // Read the remaining index and verify lookups still work + ir, err := newIndexReader(db, ident, 0) + if err != nil { + t.Fatalf("Failed to create reader: %v", err) + } + + // Looking for something greater than firstBlockMax should still work + result, err := ir.readGreaterThan(firstBlockMax) + if err != nil { + t.Fatalf("Failed to read: %v", err) + } + if result != firstBlockMax+1 { + t.Fatalf("Expected %d, got %d", firstBlockMax+1, result) + } + + // Looking for the last element should return MaxUint64 + result, err = ir.readGreaterThan(20000) + if err != nil { + t.Fatalf("Failed to read: %v", err) + } + if result != math.MaxUint64 { + t.Fatalf("Expected MaxUint64, got %d", result) + } +} + +// TestPrunePauseResume verifies the pause/resume mechanism: +// - The pruner pauses mid-iteration and flushes its batch +// - Data written while the pruner is paused (simulating indexSingle) is +// visible after resume via a fresh iterator +// - Pruning still completes correctly after resume +func TestPrunePauseResume(t *testing.T) { + db := rawdb.NewMemoryDatabase() + + // Create many accounts with multi-block indexes so the pruner is still + // iterating when the pause request arrives. + var firstBlockMax uint64 + for i := 0; i < 200; i++ { + hash := common.Hash{byte(i)} + ident := newAccountIdent(hash) + descList := writeMultiBlockIndex(t, db, ident, 0, 1) + if i == 0 { + firstBlockMax = descList[0].max + } + } + // Target account at the end of the key space — the pruner should not + // have visited it yet when the pause is acknowledged. + targetIdent := newAccountIdent(common.Hash{0xff}) + targetDescList := writeMultiBlockIndex(t, db, targetIdent, 0, 1) + + tail := firstBlockMax + 1 + + // Construct the pruner without starting run(). We call process() + // directly to exercise the mid-iteration pause path deterministically. + pruner := &indexPruner{ + disk: db, + typ: typeStateHistory, + log: log.New("type", "account"), + closed: make(chan struct{}), + pauseReq: make(chan chan struct{}, 1), // buffered so we can pre-deposit + resumeCh: make(chan struct{}), + } + + // Pre-deposit a pause request before process() starts. Because + // pauseReq is buffered, this succeeds immediately. When prunePrefix's + // select checks the channel on an early iteration, it will find the + // pending request and pause — no scheduling race is possible. + ack := make(chan struct{}) + pruner.pauseReq <- ack + + // Run process() in the background. + errCh := make(chan error, 1) + go func() { + errCh <- pruner.process(tail) + }() + + // Block until the pruner has flushed pending writes and acknowledged. + <-ack + + // While paused, append a new element to the target account's index, + // simulating what indexSingle would do during the pause window. + lastMax := targetDescList[len(targetDescList)-1].max + newID := lastMax + 10000 + iw, err := newIndexWriter(db, targetIdent, lastMax, 0) + if err != nil { + t.Fatalf("Failed to create index writer: %v", err) + } + if err := iw.append(newID, nil); err != nil { + t.Fatalf("Failed to append: %v", err) + } + batch := db.NewBatch() + iw.finish(batch) + if err := batch.Write(); err != nil { + t.Fatalf("Failed to write batch: %v", err) + } + + // Resume the pruner. + pruner.resume() + + // Wait for process() to complete. + if err := <-errCh; err != nil { + t.Fatalf("process() failed: %v", err) + } + + // Verify: the entry written during the pause must still be accessible. + // If the pruner used a stale iterator snapshot, it would overwrite the + // target's metadata and lose the new entry. + ir, err := newIndexReader(db, targetIdent, 0) + if err != nil { + t.Fatalf("Failed to create index reader: %v", err) + } + result, err := ir.readGreaterThan(newID - 1) + if err != nil { + t.Fatalf("Failed to read: %v", err) + } + if result != newID { + t.Fatalf("Entry written during pause was lost: want %d, got %d", newID, result) + } + + // Verify: pruning actually occurred on an early account. + earlyIdent := newAccountIdent(common.Hash{0x00}) + earlyBlob := readStateIndex(earlyIdent, db) + if len(earlyBlob) == 0 { + t.Fatal("Early account index should not be completely empty") + } + earlyRemaining, err := parseIndex(earlyBlob, 0) + if err != nil { + t.Fatalf("Failed to parse early account index: %v", err) + } + // The first block (id=0) should have been pruned. + if earlyRemaining[0].id == 0 { + t.Fatal("First block of early account should have been pruned") + } +} diff --git a/triedb/pathdb/history_index_test.go b/triedb/pathdb/history_index_test.go index be9b7c40491c..2644db46b595 100644 --- a/triedb/pathdb/history_index_test.go +++ b/triedb/pathdb/history_index_test.go @@ -29,19 +29,25 @@ import ( ) func TestIndexReaderBasic(t *testing.T) { + testIndexReaderBasic(t, 0) + testIndexReaderBasic(t, 2) + testIndexReaderBasic(t, 34) +} + +func testIndexReaderBasic(t *testing.T, bitmapSize int) { elements := []uint64{ 1, 5, 10, 11, 20, } db := rawdb.NewMemoryDatabase() - bw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa})) + bw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), 0, bitmapSize) for i := 0; i < len(elements); i++ { - bw.append(elements[i]) + bw.append(elements[i], randomExt(bitmapSize, 5)) } batch := db.NewBatch() bw.finish(batch) batch.Write() - br, err := newIndexReader(db, newAccountIdent(common.Hash{0xa})) + br, err := newIndexReader(db, newAccountIdent(common.Hash{0xa}), bitmapSize) if err != nil { t.Fatalf("Failed to construct the index reader, %v", err) } @@ -68,22 +74,28 @@ func TestIndexReaderBasic(t *testing.T) { } func TestIndexReaderLarge(t *testing.T) { + testIndexReaderLarge(t, 0) + testIndexReaderLarge(t, 2) + testIndexReaderLarge(t, 34) +} + +func testIndexReaderLarge(t *testing.T, bitmapSize int) { var elements []uint64 - for i := 0; i < 10*indexBlockEntriesCap; i++ { + for i := 0; i < 10*4096; i++ { elements = append(elements, rand.Uint64()) } slices.Sort(elements) db := rawdb.NewMemoryDatabase() - bw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa})) + bw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), 0, bitmapSize) for i := 0; i < len(elements); i++ { - bw.append(elements[i]) + bw.append(elements[i], randomExt(bitmapSize, 5)) } batch := db.NewBatch() bw.finish(batch) batch.Write() - br, err := newIndexReader(db, newAccountIdent(common.Hash{0xa})) + br, err := newIndexReader(db, newAccountIdent(common.Hash{0xa}), bitmapSize) if err != nil { t.Fatalf("Failed to construct the index reader, %v", err) } @@ -107,7 +119,7 @@ func TestIndexReaderLarge(t *testing.T) { } func TestEmptyIndexReader(t *testing.T) { - br, err := newIndexReader(rawdb.NewMemoryDatabase(), newAccountIdent(common.Hash{0xa})) + br, err := newIndexReader(rawdb.NewMemoryDatabase(), newAccountIdent(common.Hash{0xa}), 0) if err != nil { t.Fatalf("Failed to construct the index reader, %v", err) } @@ -121,57 +133,150 @@ func TestEmptyIndexReader(t *testing.T) { } func TestIndexWriterBasic(t *testing.T) { + testIndexWriterBasic(t, 0) + testIndexWriterBasic(t, 2) + testIndexWriterBasic(t, 34) +} + +func testIndexWriterBasic(t *testing.T, bitmapSize int) { db := rawdb.NewMemoryDatabase() - iw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa})) - iw.append(2) - if err := iw.append(1); err == nil { + iw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), 0, bitmapSize) + iw.append(2, randomExt(bitmapSize, 5)) + if err := iw.append(1, randomExt(bitmapSize, 5)); err == nil { t.Fatal("out-of-order insertion is not expected") } + var maxElem uint64 for i := 0; i < 10; i++ { - iw.append(uint64(i + 3)) + iw.append(uint64(i+3), randomExt(bitmapSize, 5)) + maxElem = uint64(i + 3) } batch := db.NewBatch() iw.finish(batch) batch.Write() - iw, err := newIndexWriter(db, newAccountIdent(common.Hash{0xa})) + iw, err := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), maxElem, bitmapSize) if err != nil { t.Fatalf("Failed to construct the block writer, %v", err) } for i := 0; i < 10; i++ { - if err := iw.append(uint64(i + 100)); err != nil { + if err := iw.append(uint64(i+100), randomExt(bitmapSize, 5)); err != nil { t.Fatalf("Failed to append item, %v", err) } } iw.finish(db.NewBatch()) } -func TestIndexWriterDelete(t *testing.T) { +func TestIndexWriterWithLimit(t *testing.T) { + testIndexWriterWithLimit(t, 0) + testIndexWriterWithLimit(t, 2) + testIndexWriterWithLimit(t, 34) +} + +func testIndexWriterWithLimit(t *testing.T, bitmapSize int) { db := rawdb.NewMemoryDatabase() - iw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa})) - for i := 0; i < indexBlockEntriesCap*4; i++ { - iw.append(uint64(i + 1)) + iw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), 0, bitmapSize) + + // 200 iterations (with around 50 bytes extension) is enough to cross + // the block boundary (4096 bytes) + for i := 0; i < 200; i++ { + iw.append(uint64(i+1), randomExt(bitmapSize, 50)) + } + batch := db.NewBatch() + iw.finish(batch) + batch.Write() + + for i := 0; i < 200; i++ { + limit := uint64(i + 1) + iw, err := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), limit, bitmapSize) + if err != nil { + t.Fatalf("Failed to construct the index writer, %v", err) + } + if iw.lastID != limit { + t.Fatalf("Test %d, unexpected max value, got %d, want %d", i, iw.lastID, limit) + } + // Re-fill the elements + var maxElem uint64 + for elem := limit + 1; elem < 500; elem++ { + if err := iw.append(elem, randomExt(bitmapSize, 5)); err != nil { + t.Fatalf("Failed to append value %d: %v", elem, err) + } + maxElem = elem + } + if iw.lastID != maxElem { + t.Fatalf("Test %d, unexpected max value, got %d, want %d", i, iw.lastID, maxElem) + } + } +} + +func TestIndexDeleterBasic(t *testing.T) { + testIndexDeleterBasic(t, 0) + testIndexDeleterBasic(t, 2) + testIndexDeleterBasic(t, 34) +} + +func testIndexDeleterBasic(t *testing.T, bitmapSize int) { + db := rawdb.NewMemoryDatabase() + iw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), 0, bitmapSize) + + // 200 iterations (with around 50 bytes extension) is enough to cross + // the block boundary (4096 bytes) + var maxElem uint64 + for i := 0; i < 200; i++ { + iw.append(uint64(i+1), randomExt(bitmapSize, 50)) + maxElem = uint64(i + 1) } batch := db.NewBatch() iw.finish(batch) batch.Write() // Delete unknown id, the request should be rejected - id, _ := newIndexDeleter(db, newAccountIdent(common.Hash{0xa})) - if err := id.pop(indexBlockEntriesCap * 5); err == nil { + id, _ := newIndexDeleter(db, newAccountIdent(common.Hash{0xa}), maxElem, bitmapSize) + if err := id.pop(500); err == nil { t.Fatal("Expect error to occur for unknown id") } - for i := indexBlockEntriesCap * 4; i >= 1; i-- { + for i := 200; i >= 1; i-- { if err := id.pop(uint64(i)); err != nil { t.Fatalf("Unexpected error for element popping, %v", err) } if id.lastID != uint64(i-1) { t.Fatalf("Unexpected lastID, want: %d, got: %d", uint64(i-1), iw.lastID) } - if rand.Intn(10) == 0 { - batch := db.NewBatch() - id.finish(batch) - batch.Write() + } +} + +func TestIndexDeleterWithLimit(t *testing.T) { + testIndexDeleterWithLimit(t, 0) + testIndexDeleterWithLimit(t, 2) + testIndexDeleterWithLimit(t, 34) +} + +func testIndexDeleterWithLimit(t *testing.T, bitmapSize int) { + db := rawdb.NewMemoryDatabase() + iw, _ := newIndexWriter(db, newAccountIdent(common.Hash{0xa}), 0, bitmapSize) + + // 200 iterations (with around 50 bytes extension) is enough to cross + // the block boundary (4096 bytes) + for i := 0; i < 200; i++ { + iw.append(uint64(i+1), randomExt(bitmapSize, 50)) + } + batch := db.NewBatch() + iw.finish(batch) + batch.Write() + + for i := 0; i < 200; i++ { + limit := uint64(i + 1) + id, err := newIndexDeleter(db, newAccountIdent(common.Hash{0xa}), limit, bitmapSize) + if err != nil { + t.Fatalf("Failed to construct the index writer, %v", err) + } + if id.lastID != limit { + t.Fatalf("Test %d, unexpected max value, got %d, want %d", i, iw.lastID, limit) + } + // Keep removing elements + for elem := id.lastID; elem > 0; elem-- { + if err := id.pop(elem); err != nil { + t.Fatalf("Failed to pop value %d: %v", elem, err) + } } } } @@ -212,7 +317,7 @@ func TestBatchIndexerWrite(t *testing.T) { } } for addrHash, indexes := range accounts { - ir, _ := newIndexReader(db, newAccountIdent(addrHash)) + ir, _ := newIndexReader(db, newAccountIdent(addrHash), 0) for i := 0; i < len(indexes)-1; i++ { n, err := ir.readGreaterThan(indexes[i]) if err != nil { @@ -232,7 +337,7 @@ func TestBatchIndexerWrite(t *testing.T) { } for addrHash, slots := range storages { for slotHash, indexes := range slots { - ir, _ := newIndexReader(db, newStorageIdent(addrHash, slotHash)) + ir, _ := newIndexReader(db, newStorageIdent(addrHash, slotHash), 0) for i := 0; i < len(indexes)-1; i++ { n, err := ir.readGreaterThan(indexes[i]) if err != nil { diff --git a/triedb/pathdb/history_indexer.go b/triedb/pathdb/history_indexer.go index 893ccd652368..9b215b917fae 100644 --- a/triedb/pathdb/history_indexer.go +++ b/triedb/pathdb/history_indexer.go @@ -34,17 +34,15 @@ import ( const ( // The batch size for reading state histories - historyReadBatch = 1000 + historyReadBatch = 1000 + historyIndexBatch = 8 * 1024 * 1024 // The number of state history indexes for constructing or deleting as batch stateHistoryIndexV0 = uint8(0) // initial version of state index structure stateHistoryIndexVersion = stateHistoryIndexV0 // the current state index version trienodeHistoryIndexV0 = uint8(0) // initial version of trienode index structure trienodeHistoryIndexVersion = trienodeHistoryIndexV0 // the current trienode index version - // estimations for calculating the batch size for atomic database commit - estimatedStateHistoryIndexSize = 3 // The average size of each state history index entry is approximately 2–3 bytes - estimatedTrienodeHistoryIndexSize = 3 // The average size of each trienode history index entry is approximately 2-3 bytes - estimatedIndexBatchSizeFactor = 32 // The factor counts for the write amplification for each entry + indexerProcessBatchInSync = 100000 // threshold for history batch indexing when node is in sync stage. ) // indexVersion returns the latest index version for the given history type. @@ -125,18 +123,20 @@ func deleteIndexMetadata(db ethdb.KeyValueWriter, typ historyType) { // batchIndexer is responsible for performing batch indexing or unindexing // of historical data (e.g., state or trie node changes) atomically. type batchIndexer struct { - index map[stateIdent][]uint64 // List of history IDs for tracked state entry - pending int // Number of entries processed in the current batch. - delete bool // Operation mode: true for unindex, false for index. - lastID uint64 // ID of the most recently processed history. - typ historyType // Type of history being processed (e.g., state or trienode). - db ethdb.KeyValueStore // Key-value database used to store or delete index data. + index map[stateIdent][]uint64 // List of history IDs for tracked state entry + ext map[stateIdent][][]uint16 // List of extension for each state element + pending int // Number of entries processed in the current batch. + delete bool // Operation mode: true for unindex, false for index. + lastID uint64 // ID of the most recently processed history. + typ historyType // Type of history being processed (e.g., state or trienode). + db ethdb.KeyValueStore // Key-value database used to store or delete index data. } // newBatchIndexer constructs the batch indexer with the supplied mode. func newBatchIndexer(db ethdb.KeyValueStore, delete bool, typ historyType) *batchIndexer { return &batchIndexer{ index: make(map[stateIdent][]uint64), + ext: make(map[stateIdent][][]uint16), delete: delete, typ: typ, db: db, @@ -146,8 +146,10 @@ func newBatchIndexer(db ethdb.KeyValueStore, delete bool, typ historyType) *batc // process traverses the state entries within the provided history and tracks the mutation // records for them. func (b *batchIndexer) process(h history, id uint64) error { - for ident := range h.forEach() { - b.index[ident] = append(b.index[ident], id) + for elem := range h.forEach() { + key := elem.key() + b.index[key] = append(b.index[key], id) + b.ext[key] = append(b.ext[key], elem.ext()) b.pending++ } b.lastID = id @@ -155,22 +157,6 @@ func (b *batchIndexer) process(h history, id uint64) error { return b.finish(false) } -// makeBatch constructs a database batch based on the number of pending entries. -// The batch size is roughly estimated to minimize repeated resizing rounds, -// as accurately predicting the exact size is technically challenging. -func (b *batchIndexer) makeBatch() ethdb.Batch { - var size int - switch b.typ { - case typeStateHistory: - size = estimatedStateHistoryIndexSize - case typeTrienodeHistory: - size = estimatedTrienodeHistoryIndexSize - default: - panic(fmt.Sprintf("unknown history type %d", b.typ)) - } - return b.db.NewBatchWithSize(size * estimatedIndexBatchSizeFactor * b.pending) -} - // finish writes the accumulated state indexes into the disk if either the // memory limitation is reached or it's requested forcibly. func (b *batchIndexer) finish(force bool) error { @@ -181,30 +167,52 @@ func (b *batchIndexer) finish(force bool) error { return nil } var ( - batch = b.makeBatch() - batchMu sync.RWMutex - start = time.Now() - eg errgroup.Group + start = time.Now() + eg errgroup.Group + + batch = b.db.NewBatchWithSize(ethdb.IdealBatchSize) + batchSize int + batchMu sync.RWMutex + + writeBatch = func(fn func(batch ethdb.Batch)) error { + batchMu.Lock() + defer batchMu.Unlock() + + fn(batch) + if batch.ValueSize() >= ethdb.IdealBatchSize { + batchSize += batch.ValueSize() + if err := batch.Write(); err != nil { + return err + } + batch.Reset() + } + return nil + } ) eg.SetLimit(runtime.NumCPU()) + var indexed uint64 + if metadata := loadIndexMetadata(b.db, b.typ); metadata != nil { + indexed = metadata.Last + } for ident, list := range b.index { + ext := b.ext[ident] eg.Go(func() error { if !b.delete { - iw, err := newIndexWriter(b.db, ident) + iw, err := newIndexWriter(b.db, ident, indexed, ident.bloomSize()) if err != nil { return err } - for _, n := range list { - if err := iw.append(n); err != nil { + for i, n := range list { + if err := iw.append(n, ext[i]); err != nil { return err } } - batchMu.Lock() - iw.finish(batch) - batchMu.Unlock() + return writeBatch(func(batch ethdb.Batch) { + iw.finish(batch) + }) } else { - id, err := newIndexDeleter(b.db, ident) + id, err := newIndexDeleter(b.db, ident, indexed, ident.bloomSize()) if err != nil { return err } @@ -213,11 +221,10 @@ func (b *batchIndexer) finish(force bool) error { return err } } - batchMu.Lock() - id.finish(batch) - batchMu.Unlock() + return writeBatch(func(batch ethdb.Batch) { + id.finish(batch) + }) } - return nil }) } if err := eg.Wait(); err != nil { @@ -233,12 +240,16 @@ func (b *batchIndexer) finish(force bool) error { storeIndexMetadata(batch, b.typ, b.lastID-1) } } + batchSize += batch.ValueSize() + if err := batch.Write(); err != nil { return err } - log.Debug("Committed batch indexer", "type", b.typ, "entries", len(b.index), "records", b.pending, "elapsed", common.PrettyDuration(time.Since(start))) + log.Debug("Committed batch indexer", "type", b.typ, "entries", len(b.index), "records", b.pending, "size", common.StorageSize(batchSize), "elapsed", common.PrettyDuration(time.Since(start))) + b.pending = 0 - b.index = make(map[stateIdent][]uint64) + clear(b.index) + clear(b.ext) return nil } @@ -340,7 +351,8 @@ type interruptSignal struct { // If a state history is removed due to a rollback, the associated indexes should // be unmarked accordingly. type indexIniter struct { - disk ethdb.KeyValueStore + state *initerState + disk ethdb.Database freezer ethdb.AncientStore interrupt chan *interruptSignal done chan struct{} @@ -355,8 +367,9 @@ type indexIniter struct { wg sync.WaitGroup } -func newIndexIniter(disk ethdb.KeyValueStore, freezer ethdb.AncientStore, typ historyType, lastID uint64) *indexIniter { +func newIndexIniter(disk ethdb.Database, freezer ethdb.AncientStore, typ historyType, lastID uint64, noWait bool) *indexIniter { initer := &indexIniter{ + state: newIniterState(disk, noWait), disk: disk, freezer: freezer, interrupt: make(chan *interruptSignal), @@ -376,12 +389,7 @@ func newIndexIniter(disk ethdb.KeyValueStore, freezer ethdb.AncientStore, typ hi // Launch background indexer initer.wg.Add(1) - if recover { - log.Info("History indexer is recovering", "history", lastID, "indexed", metadata.Last) - go initer.recover(lastID) - } else { - go initer.run(lastID) - } + go initer.run(recover) return initer } @@ -391,6 +399,7 @@ func (i *indexIniter) close() { return default: close(i.closed) + i.state.close() i.wg.Wait() } } @@ -422,85 +431,109 @@ func (i *indexIniter) remain() uint64 { } } -func (i *indexIniter) run(lastID uint64) { +func (i *indexIniter) run(recover bool) { defer i.wg.Done() // Launch background indexing thread var ( - done = make(chan struct{}) - interrupt = new(atomic.Int32) + done chan struct{} + interrupt *atomic.Int32 - // checkDone indicates whether all requested state histories - // have been fully indexed. + // checkDone reports whether indexing has completed for all histories. checkDone = func() bool { metadata := loadIndexMetadata(i.disk, i.typ) - return metadata != nil && metadata.Last == lastID + return metadata != nil && metadata.Last == i.last.Load() + } + // canExit reports whether the initial indexing phase has completed. + canExit = func() bool { + return !i.state.is(stateSyncing) && checkDone() } + heartBeat = time.NewTimer(0) ) - go i.index(done, interrupt, lastID) + defer heartBeat.Stop() + if recover { + if aborted := i.recover(); aborted { + return + } + } for { select { case signal := <-i.interrupt: - // The indexing limit can only be extended or shortened continuously. newLastID := signal.newLastID - if newLastID != lastID+1 && newLastID != lastID-1 { - signal.result <- fmt.Errorf("invalid history id, last: %d, got: %d", lastID, newLastID) + oldLastID := i.last.Load() + + // The indexing limit can only be extended or shortened continuously. + if newLastID != oldLastID+1 && newLastID != oldLastID-1 { + signal.result <- fmt.Errorf("invalid history id, last: %d, got: %d", oldLastID, newLastID) continue } i.last.Store(newLastID) // update indexing range // The index limit is extended by one, update the limit without // interrupting the current background process. - if newLastID == lastID+1 { - lastID = newLastID + if newLastID == oldLastID+1 { signal.result <- nil - i.log.Debug("Extended history range", "last", lastID) + i.log.Debug("Extended history range", "last", newLastID) continue } - // The index limit is shortened by one, interrupt the current background - // process and relaunch with new target. - interrupt.Store(1) - <-done - + // The index limit is shortened, interrupt the current background + // process if it's active and update the target. + if done != nil { + interrupt.Store(1) + <-done + done, interrupt = nil, nil + } // If all state histories, including the one to be reverted, have // been fully indexed, unindex it here and shut down the initializer. if checkDone() { - i.log.Info("Truncate the extra history", "id", lastID) - if err := unindexSingle(lastID, i.disk, i.freezer, i.typ); err != nil { + i.log.Info("Truncate the extra history", "id", oldLastID) + if err := unindexSingle(oldLastID, i.disk, i.freezer, i.typ); err != nil { signal.result <- err return } close(i.done) signal.result <- nil - i.log.Info("Histories have been fully indexed", "last", lastID-1) + i.log.Info("Histories have been fully indexed", "last", i.last.Load()) return } - // Adjust the indexing target and relaunch the process - lastID = newLastID + // Adjust the indexing target signal.result <- nil - - done, interrupt = make(chan struct{}), new(atomic.Int32) - go i.index(done, interrupt, lastID) - i.log.Debug("Shortened history range", "last", lastID) + i.log.Debug("Shortened history range", "last", newLastID) case <-done: - if checkDone() { + done, interrupt = nil, nil + + if canExit() { close(i.done) - i.log.Info("Histories have been fully indexed", "last", lastID) return } - // Relaunch the background runner if some tasks are left - done, interrupt = make(chan struct{}), new(atomic.Int32) - go i.index(done, interrupt, lastID) - case <-i.closed: - interrupt.Store(1) - i.log.Info("Waiting background history index initer to exit") - <-done + case <-heartBeat.C: + heartBeat.Reset(time.Second * 15) - if checkDone() { + // Short circuit if the indexer is still busy + if done != nil { + continue + } + if canExit() { close(i.done) + return + } + // The local chain is still in the syncing phase. Only start the indexing + // when a sufficient amount of histories has accumulated. Batch indexing + // is more efficient than processing items individually. + if i.state.is(stateSyncing) && i.last.Load()-i.indexed.Load() < indexerProcessBatchInSync { + continue + } + done, interrupt = make(chan struct{}), new(atomic.Int32) + go i.index(done, interrupt, i.last.Load()) + + case <-i.closed: + if done != nil { + interrupt.Store(1) + i.log.Info("Waiting background history index initer to exit") + <-done } return } @@ -562,7 +595,7 @@ func (i *indexIniter) index(done chan struct{}, interrupt *atomic.Int32, lastID } return } - i.log.Info("Start history indexing", "beginID", beginID, "lastID", lastID) + i.log.Debug("Start history indexing", "beginID", beginID, "lastID", lastID) var ( current = beginID @@ -609,7 +642,7 @@ func (i *indexIniter) index(done chan struct{}, interrupt *atomic.Int32, lastID done = current - beginID ) eta := common.CalculateETA(done, left, time.Since(start)) - i.log.Info("Indexing history", "processed", done, "left", left, "elapsed", common.PrettyDuration(time.Since(start)), "eta", common.PrettyDuration(eta)) + i.log.Debug("Indexing history", "processed", done, "left", left, "elapsed", common.PrettyDuration(time.Since(start)), "eta", common.PrettyDuration(eta)) } } i.indexed.Store(current - 1) // update indexing progress @@ -620,7 +653,7 @@ func (i *indexIniter) index(done chan struct{}, interrupt *atomic.Int32, lastID if err := batch.finish(true); err != nil { i.log.Error("Failed to flush index", "err", err) } - log.Info("State indexing interrupted") + log.Debug("State indexing interrupted") return } } @@ -628,7 +661,7 @@ func (i *indexIniter) index(done chan struct{}, interrupt *atomic.Int32, lastID if err := batch.finish(true); err != nil { i.log.Error("Failed to flush index", "err", err) } - i.log.Info("Indexed history", "from", beginID, "to", lastID, "elapsed", common.PrettyDuration(time.Since(start))) + i.log.Debug("Indexed history", "from", beginID, "to", lastID, "elapsed", common.PrettyDuration(time.Since(start))) } // recover handles unclean shutdown recovery. After an unclean shutdown, any @@ -641,35 +674,35 @@ func (i *indexIniter) index(done chan struct{}, interrupt *atomic.Int32, lastID // by chain recovery, under the assumption that the recovered histories will be // identical to the lost ones. Fork-awareness should be added in the future to // correctly handle histories affected by reorgs. -func (i *indexIniter) recover(lastID uint64) { - defer i.wg.Done() +func (i *indexIniter) recover() bool { + log.Info("History indexer is recovering", "last", i.last.Load(), "indexed", i.indexed.Load()) for { select { case signal := <-i.interrupt: newLastID := signal.newLastID - if newLastID != lastID+1 && newLastID != lastID-1 { - signal.result <- fmt.Errorf("invalid history id, last: %d, got: %d", lastID, newLastID) + oldLastID := i.last.Load() + + // The indexing limit can only be extended or shortened continuously. + if newLastID != oldLastID+1 && newLastID != oldLastID-1 { + signal.result <- fmt.Errorf("invalid history id, last: %d, got: %d", oldLastID, newLastID) continue } - // Update the last indexed flag - lastID = newLastID signal.result <- nil i.last.Store(newLastID) - i.log.Debug("Updated history index flag", "last", lastID) + i.log.Debug("Updated history index flag", "last", newLastID) // Terminate the recovery routine once the histories are fully aligned // with the index data, indicating that index initialization is complete. metadata := loadIndexMetadata(i.disk, i.typ) - if metadata != nil && metadata.Last == lastID { - close(i.done) - i.log.Info("History indexer is recovered", "last", lastID) - return + if metadata != nil && metadata.Last == newLastID { + i.log.Info("History indexer is recovered", "last", newLastID) + return false } case <-i.closed: - return + return true } } } @@ -686,6 +719,7 @@ func (i *indexIniter) recover(lastID uint64) { // state history. type historyIndexer struct { initer *indexIniter + pruner *indexPruner typ historyType disk ethdb.KeyValueStore freezer ethdb.AncientStore @@ -737,10 +771,11 @@ func checkVersion(disk ethdb.KeyValueStore, typ historyType) { // newHistoryIndexer constructs the history indexer and launches the background // initer to complete the indexing of any remaining state histories. -func newHistoryIndexer(disk ethdb.KeyValueStore, freezer ethdb.AncientStore, lastHistoryID uint64, typ historyType) *historyIndexer { +func newHistoryIndexer(disk ethdb.Database, freezer ethdb.AncientStore, lastHistoryID uint64, typ historyType, noWait bool) *historyIndexer { checkVersion(disk, typ) return &historyIndexer{ - initer: newIndexIniter(disk, freezer, typ, lastHistoryID), + initer: newIndexIniter(disk, freezer, typ, lastHistoryID, noWait), + pruner: newIndexPruner(disk, typ), typ: typ, disk: disk, freezer: freezer, @@ -749,6 +784,7 @@ func newHistoryIndexer(disk ethdb.KeyValueStore, freezer ethdb.AncientStore, las func (i *historyIndexer) close() { i.initer.close() + i.pruner.close() } // inited returns a flag indicating whether the existing state histories @@ -769,6 +805,8 @@ func (i *historyIndexer) extend(historyID uint64) error { case <-i.initer.closed: return errors.New("indexer is closed") case <-i.initer.done: + i.pruner.pause() + defer i.pruner.resume() return indexSingle(historyID, i.disk, i.freezer, i.typ) case i.initer.interrupt <- signal: return <-signal.result @@ -786,12 +824,27 @@ func (i *historyIndexer) shorten(historyID uint64) error { case <-i.initer.closed: return errors.New("indexer is closed") case <-i.initer.done: + i.pruner.pause() + defer i.pruner.resume() return unindexSingle(historyID, i.disk, i.freezer, i.typ) case i.initer.interrupt <- signal: return <-signal.result } } +// prune signals the pruner that the history tail has advanced to the given ID, +// so that stale index blocks referencing pruned histories can be removed. +func (i *historyIndexer) prune(newTail uint64) { + select { + case <-i.initer.closed: + log.Debug("Ignored the pruning signal", "reason", "closed") + case <-i.initer.done: + i.pruner.prune(newTail) + default: + log.Debug("Ignored the pruning signal", "reason", "busy") + } +} + // progress returns the indexing progress made so far. It provides the number // of states that remain unindexed. func (i *historyIndexer) progress() (uint64, error) { diff --git a/triedb/pathdb/history_indexer_state.go b/triedb/pathdb/history_indexer_state.go new file mode 100644 index 000000000000..27460832979a --- /dev/null +++ b/triedb/pathdb/history_indexer_state.go @@ -0,0 +1,183 @@ +// Copyright 2026 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package pathdb + +import ( + "bytes" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" +) + +// state represents the syncing status of the node. +type state int + +const ( + // stateSynced indicates that the local chain head is sufficiently close to the + // network chain head, and the majority of the data has been fully synchronized. + stateSynced state = iota + + // stateSyncing indicates that the sync process is still in progress. Local node + // is actively catching up with the network chain head. + stateSyncing + + // stateStalled indicates that sync progress has stopped for a while + // with no progress. This may be caused by network instability (e.g., no peers), + // manual operation such as syncing the local chain to a specific block. + stateStalled +) + +const ( + // syncStateTimeWindow defines the maximum allowed lag behind the network + // chain head. + // + // If the local chain head falls within this threshold, the node is considered + // close to the tip and will be marked as stateSynced. + syncStateTimeWindow = 6 * time.Hour + + // syncStalledTimeout defines the maximum duration during which no sync + // progress is observed. If this timeout is exceeded, the node's status + // will be considered stalled. + syncStalledTimeout = 5 * time.Minute +) + +type initerState struct { + state state + stateLock sync.Mutex + disk ethdb.Database + term chan struct{} +} + +func newIniterState(disk ethdb.Database, noWait bool) *initerState { + s := &initerState{ + state: stateSyncing, + disk: disk, + term: make(chan struct{}), + } + go s.update(noWait) + return s +} + +func (s *initerState) get() state { + s.stateLock.Lock() + defer s.stateLock.Unlock() + + return s.state +} + +func (s *initerState) is(state state) bool { + return s.get() == state +} + +func (s *initerState) set(state state) { + s.stateLock.Lock() + defer s.stateLock.Unlock() + + s.state = state +} + +func (s *initerState) update(noWait bool) { + ticker := time.NewTicker(time.Minute) + defer ticker.Stop() + + headBlock := s.readLastBlock() + if headBlock != nil && time.Since(time.Unix(int64(headBlock.Time), 0)) < syncStateTimeWindow { + s.set(stateSynced) + log.Info("Marked indexing initer as synced") + } else if noWait { + s.set(stateSynced) + log.Info("Marked indexing initer as synced forcibly") + } else { + s.set(stateSyncing) + } + + var ( + hhash = rawdb.ReadHeadHeaderHash(s.disk) + fhash = rawdb.ReadHeadFastBlockHash(s.disk) + bhash = rawdb.ReadHeadBlockHash(s.disk) + skeleton = rawdb.ReadSkeletonSyncStatus(s.disk) + lastProgress = time.Now() + ) + for { + select { + case <-ticker.C: + state := s.get() + if state == stateSynced || state == stateStalled { + continue + } + headBlock := s.readLastBlock() + if headBlock == nil { + continue + } + // State machine: stateSyncing => stateSynced + if time.Since(time.Unix(int64(headBlock.Time), 0)) < syncStateTimeWindow { + s.set(stateSynced) + log.Info("Marked indexing initer as synced") + continue + } + // State machine: stateSyncing => stateStalled + newhhash := rawdb.ReadHeadHeaderHash(s.disk) + newfhash := rawdb.ReadHeadFastBlockHash(s.disk) + newbhash := rawdb.ReadHeadBlockHash(s.disk) + newskeleton := rawdb.ReadSkeletonSyncStatus(s.disk) + hasProgress := newhhash.Cmp(hhash) != 0 || newfhash.Cmp(fhash) != 0 || newbhash.Cmp(bhash) != 0 || !bytes.Equal(newskeleton, skeleton) + + if !hasProgress && time.Since(lastProgress) > syncStalledTimeout { + s.set(stateStalled) + log.Info("Marked indexing initer as stalled") + continue + } + if hasProgress { + hhash = newhhash + fhash = newfhash + bhash = newbhash + skeleton = newskeleton + lastProgress = time.Now() + } + + case <-s.term: + return + } + } +} + +func (s *initerState) close() { + select { + case <-s.term: + default: + close(s.term) + } + return +} + +// readLastBlock returns the local chain head. +func (s *initerState) readLastBlock() *types.Header { + hash := rawdb.ReadHeadBlockHash(s.disk) + if hash == (common.Hash{}) { + return nil + } + number, exists := rawdb.ReadHeaderNumber(s.disk, hash) + if !exists { + return nil + } + return rawdb.ReadHeader(s.disk, hash, number) +} diff --git a/triedb/pathdb/history_indexer_test.go b/triedb/pathdb/history_indexer_test.go index f333d18d8b53..8bb1db42da9c 100644 --- a/triedb/pathdb/history_indexer_test.go +++ b/triedb/pathdb/history_indexer_test.go @@ -27,7 +27,7 @@ import ( // deadlock when the indexer is active. This specifically targets the case where // signal.result must be sent to unblock the caller. func TestHistoryIndexerShortenDeadlock(t *testing.T) { - //log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelInfo, true))) + // log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelDebug, true))) db := rawdb.NewMemoryDatabase() freezer, _ := rawdb.NewStateFreezer(t.TempDir(), false, false) defer freezer.Close() @@ -38,7 +38,7 @@ func TestHistoryIndexerShortenDeadlock(t *testing.T) { rawdb.WriteStateHistory(freezer, uint64(i+1), h.meta.encode(), accountIndex, storageIndex, accountData, storageData) } // As a workaround, assign a future block to keep the initer running indefinitely - indexer := newHistoryIndexer(db, freezer, 200, typeStateHistory) + indexer := newHistoryIndexer(db, freezer, 200, typeStateHistory, true) defer indexer.close() done := make(chan error, 1) diff --git a/triedb/pathdb/history_reader.go b/triedb/pathdb/history_reader.go index 1bf4cf648d61..4ae1fb36cbec 100644 --- a/triedb/pathdb/history_reader.go +++ b/triedb/pathdb/history_reader.go @@ -22,11 +22,17 @@ import ( "errors" "fmt" "math" + "slices" "sort" + "sync" + "sync/atomic" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" + "golang.org/x/sync/errgroup" ) // indexReaderWithLimitTag is a wrapper around indexReader that includes an @@ -40,8 +46,8 @@ type indexReaderWithLimitTag struct { } // newIndexReaderWithLimitTag constructs a index reader with indexing position. -func newIndexReaderWithLimitTag(db ethdb.KeyValueReader, state stateIdent, limit uint64) (*indexReaderWithLimitTag, error) { - r, err := newIndexReader(db, state) +func newIndexReaderWithLimitTag(db ethdb.KeyValueReader, state stateIdent, limit uint64, bitmapSize int) (*indexReaderWithLimitTag, error) { + r, err := newIndexReader(db, state, bitmapSize) if err != nil { return nil, err } @@ -99,16 +105,17 @@ func (r *indexReaderWithLimitTag) readGreaterThan(id uint64, lastID uint64) (uin return r.reader.readGreaterThan(id) } -// historyReader is the structure to access historic state data. -type historyReader struct { +// stateHistoryReader is the structure to access historic state data. +type stateHistoryReader struct { disk ethdb.KeyValueReader freezer ethdb.AncientReader readers map[string]*indexReaderWithLimitTag } -// newHistoryReader constructs the history reader with the supplied db. -func newHistoryReader(disk ethdb.KeyValueReader, freezer ethdb.AncientReader) *historyReader { - return &historyReader{ +// newStateHistoryReader constructs the history reader with the supplied db +// for accessing historical states. +func newStateHistoryReader(disk ethdb.KeyValueReader, freezer ethdb.AncientReader) *stateHistoryReader { + return &stateHistoryReader{ disk: disk, freezer: freezer, readers: make(map[string]*indexReaderWithLimitTag), @@ -117,7 +124,7 @@ func newHistoryReader(disk ethdb.KeyValueReader, freezer ethdb.AncientReader) *h // readAccountMetadata resolves the account metadata within the specified // state history. -func (r *historyReader) readAccountMetadata(address common.Address, historyID uint64) ([]byte, error) { +func (r *stateHistoryReader) readAccountMetadata(address common.Address, historyID uint64) ([]byte, error) { blob := rawdb.ReadStateAccountIndex(r.freezer, historyID) if len(blob) == 0 { return nil, fmt.Errorf("account index is truncated, historyID: %d", historyID) @@ -143,7 +150,7 @@ func (r *historyReader) readAccountMetadata(address common.Address, historyID ui // readStorageMetadata resolves the storage slot metadata within the specified // state history. -func (r *historyReader) readStorageMetadata(storageKey common.Hash, storageHash common.Hash, historyID uint64, slotOffset, slotNumber int) ([]byte, error) { +func (r *stateHistoryReader) readStorageMetadata(storageKey common.Hash, storageHash common.Hash, historyID uint64, slotOffset, slotNumber int) ([]byte, error) { data, err := rawdb.ReadStateStorageIndex(r.freezer, historyID, slotIndexSize*slotOffset, slotIndexSize*slotNumber) if err != nil { msg := fmt.Sprintf("id: %d, slot-offset: %d, slot-length: %d", historyID, slotOffset, slotNumber) @@ -178,7 +185,7 @@ func (r *historyReader) readStorageMetadata(storageKey common.Hash, storageHash } // readAccount retrieves the account data from the specified state history. -func (r *historyReader) readAccount(address common.Address, historyID uint64) ([]byte, error) { +func (r *stateHistoryReader) readAccount(address common.Address, historyID uint64) ([]byte, error) { metadata, err := r.readAccountMetadata(address, historyID) if err != nil { return nil, err @@ -194,7 +201,7 @@ func (r *historyReader) readAccount(address common.Address, historyID uint64) ([ } // readStorage retrieves the storage slot data from the specified state history. -func (r *historyReader) readStorage(address common.Address, storageKey common.Hash, storageHash common.Hash, historyID uint64) ([]byte, error) { +func (r *stateHistoryReader) readStorage(address common.Address, storageKey common.Hash, storageHash common.Hash, historyID uint64) ([]byte, error) { metadata, err := r.readAccountMetadata(address, historyID) if err != nil { return nil, err @@ -224,35 +231,16 @@ func (r *historyReader) readStorage(address common.Address, storageKey common.Ha // stateID: represents the ID of the state of the specified version; // lastID: represents the ID of the latest/newest state history; // latestValue: represents the state value at the current disk layer with ID == lastID; -func (r *historyReader) read(state stateIdentQuery, stateID uint64, lastID uint64, latestValue []byte) ([]byte, error) { - tail, err := r.freezer.Tail() +func (r *stateHistoryReader) read(state stateIdentQuery, stateID uint64, lastID uint64, latestValue []byte) ([]byte, error) { + lastIndexed, err := checkStateAvail(state.stateIdent, typeStateHistory, r.freezer, stateID, lastID, r.disk) if err != nil { return nil, err - } // firstID = tail+1 - - // stateID+1 == firstID is allowed, as all the subsequent state histories - // are present with no gap inside. - if stateID < tail { - return nil, fmt.Errorf("historical state has been pruned, first: %d, state: %d", tail+1, stateID) } - - // To serve the request, all state histories from stateID+1 to lastID - // must be indexed. It's not supposed to happen unless system is very - // wrong. - metadata := loadIndexMetadata(r.disk, toHistoryType(state.typ)) - if metadata == nil || metadata.Last < lastID { - indexed := "null" - if metadata != nil { - indexed = fmt.Sprintf("%d", metadata.Last) - } - return nil, fmt.Errorf("state history is not fully indexed, requested: %d, indexed: %s", stateID, indexed) - } - // Construct the index reader to locate the corresponding history for // state retrieval ir, ok := r.readers[state.String()] if !ok { - ir, err = newIndexReaderWithLimitTag(r.disk, state.stateIdent, metadata.Last) + ir, err = newIndexReaderWithLimitTag(r.disk, state.stateIdent, lastIndexed, 0) if err != nil { return nil, err } @@ -277,3 +265,230 @@ func (r *historyReader) read(state stateIdentQuery, stateID uint64, lastID uint6 } return r.readStorage(state.address, state.storageKey, state.storageHash, historyID) } + +// trienodeReader is the structure to access historical trienode data. +type trienodeReader struct { + disk ethdb.KeyValueReader + freezer ethdb.AncientReader + readConcurrency int // The concurrency used to load trie node data from history +} + +// newTrienodeReader constructs the history reader with the supplied db +// for accessing historical trie nodes. +func newTrienodeReader(disk ethdb.KeyValueReader, freezer ethdb.AncientReader, readConcurrency int) *trienodeReader { + return &trienodeReader{ + disk: disk, + freezer: freezer, + readConcurrency: readConcurrency, + } +} + +// readTrienode retrieves the trienode data from the specified trienode history. +func (r *trienodeReader) readTrienode(addrHash common.Hash, path string, historyID uint64) ([]byte, bool, error) { + tr := newTrienodeHistoryReader(historyID, r.freezer) + return tr.read(addrHash, path) +} + +// assembleNode takes a complete node value as the base and applies a list of +// mutation records to assemble the final node value accordingly. +func assembleNode(blob []byte, elements [][][]byte, indices [][]int) ([]byte, error) { + if len(elements) == 0 && len(indices) == 0 { + return blob, nil + } + children, err := rlp.SplitListValues(blob) + if err != nil { + return nil, err + } + for i := 0; i < len(elements); i++ { + for j, pos := range indices[i] { + children[pos] = elements[i][j] + } + } + return rlp.MergeListValues(children) +} + +type resultQueue struct { + data [][]byte + lock sync.Mutex +} + +func newResultQueue(size int) *resultQueue { + return &resultQueue{ + data: make([][]byte, size, size*2), + } +} + +func (q *resultQueue) set(data []byte, pos int) { + q.lock.Lock() + defer q.lock.Unlock() + + if pos >= len(q.data) { + newSize := pos + 1 + if cap(q.data) < newSize { + newData := make([][]byte, newSize, newSize*2) + copy(newData, q.data) + q.data = newData + } + q.data = q.data[:newSize] + } + q.data[pos] = data +} + +func (r *trienodeReader) readOptimized(state stateIdent, it HistoryIndexIterator, latestValue []byte) ([]byte, error) { + var ( + elements [][][]byte + indices [][]int + blob = latestValue + + eg errgroup.Group + seq int + term atomic.Bool + queue = newResultQueue(r.readConcurrency * 2) + ) + eg.SetLimit(r.readConcurrency) + + for { + id, pos := it.ID(), seq + seq += 1 + + eg.Go(func() error { + data, found, err := r.readTrienode(state.addressHash, state.path, id) + if err != nil { + term.Store(true) + return err + } + // In optimistic readahead mode, it is theoretically possible to encounter a + // NotFound error, where the trie node does not actually exist and the iterator + // reports a false-positive mutation record. Terminate the iterator if so, as + // all the necessary data (checkpoints and all diffs) required has already been + // fetching. + if !found { + term.Store(true) + log.Debug("Failed to read the trienode") + return nil + } + full, _, err := decodeNodeFull(data) + if err != nil { + term.Store(true) + return err + } + if full { + term.Store(true) + } + queue.set(data, pos) + return nil + }) + if term.Load() || !it.Next() { + break + } + } + if err := eg.Wait(); err != nil { + return nil, err + } + if err := it.Error(); err != nil { + return nil, err + } + for i := 0; i < seq; i++ { + isComplete, fullBlob, err := decodeNodeFull(queue.data[i]) + if err != nil { + return nil, err + } + // Terminate the loop is the node with full value has been found + if isComplete { + blob = fullBlob + break + } + // Decode the partial encoded node and keep iterating the node history + // until the node with full value being reached. + element, index, err := decodeNodeCompressed(queue.data[i]) + if err != nil { + return nil, err + } + elements, indices = append(elements, element), append(indices, index) + } + slices.Reverse(elements) + slices.Reverse(indices) + return assembleNode(blob, elements, indices) +} + +// read retrieves the trie node data associated with the stateID. +// stateID: represents the ID of the state of the specified version; +// lastID: represents the ID of the latest/newest trie node history; +// latestValue: represents the trie node value at the current disk layer with ID == lastID; +func (r *trienodeReader) read(state stateIdent, stateID uint64, lastID uint64, latestValue []byte) ([]byte, error) { + _, err := checkStateAvail(state, typeTrienodeHistory, r.freezer, stateID, lastID, r.disk) + if err != nil { + return nil, err + } + // Construct the index iterator to traverse the trienode history + var ( + scheme *indexScheme + it HistoryIndexIterator + ) + if state.addressHash == (common.Hash{}) { + scheme = accountIndexScheme + } else { + scheme = storageIndexScheme + } + if state.addressHash == (common.Hash{}) && state.path == "" { + it = newSeqIter(lastID) + } else { + chunkID, nodeID := scheme.splitPathLast(state.path) + + queryIdent := state + queryIdent.path = chunkID + ir, err := newIndexReader(r.disk, queryIdent, scheme.getBitmapSize(len(chunkID))) + if err != nil { + return nil, err + } + filter := extFilter(nodeID) + it = ir.newIterator(&filter) + } + // Move the iterator to the first element whose id is greater than + // the given number. + found := it.SeekGT(stateID) + if err := it.Error(); err != nil { + return nil, err + } + // The state was not found in the trie node histories, as it has not been + // modified since stateID. Use the data from the associated disk layer + // instead (full value node as always) + if !found { + return latestValue, nil + } + return r.readOptimized(state, it, latestValue) +} + +// checkStateAvail determines whether the requested historical state is available +// for accessing. What's more, it also returns the ID of the latest indexed history +// entry for subsequent usage. +// +// TODO(rjl493456442) it's really expensive to perform the check for every state +// retrieval, please rework this later. +func checkStateAvail(state stateIdent, exptyp historyType, freezer ethdb.AncientReader, stateID uint64, lastID uint64, db ethdb.KeyValueReader) (uint64, error) { + if toHistoryType(state.typ) != exptyp { + return 0, fmt.Errorf("unsupported history type: %d, want: %v", toHistoryType(state.typ), exptyp) + } + // firstID = tail+1 + tail, err := freezer.Tail() + if err != nil { + return 0, err + } + // stateID+1 == firstID is allowed, as all the subsequent history entries + // are present with no gap inside. + if stateID < tail { + return 0, fmt.Errorf("historical state has been pruned, first: %d, state: %d", tail+1, stateID) + } + // To serve the request, all history entries from stateID+1 to lastID + // must be indexed. It's not supposed to happen unless system is very + // wrong. + metadata := loadIndexMetadata(db, exptyp) + if metadata == nil || metadata.Last < lastID { + indexed := "null" + if metadata != nil { + indexed = fmt.Sprintf("%d", metadata.Last) + } + return 0, fmt.Errorf("history is not fully indexed, requested: %d, indexed: %s", stateID, indexed) + } + return metadata.Last, nil +} diff --git a/triedb/pathdb/history_reader_test.go b/triedb/pathdb/history_reader_test.go index 3e1a545ff324..b69fba68cb4c 100644 --- a/triedb/pathdb/history_reader_test.go +++ b/triedb/pathdb/history_reader_test.go @@ -50,7 +50,7 @@ func stateAvail(id uint64, env *tester) bool { return id+1 >= firstID } -func checkHistoricalState(env *tester, root common.Hash, id uint64, hr *historyReader) error { +func checkHistoricalState(env *tester, root common.Hash, id uint64, hr *stateHistoryReader) error { if !stateAvail(id, env) { return nil } @@ -157,7 +157,7 @@ func testHistoryReader(t *testing.T, historyLimit uint64) { var ( roots = env.roots dl = env.db.tree.bottom() - hr = newHistoryReader(env.db.diskdb, env.db.stateFreezer) + hr = newStateHistoryReader(env.db.diskdb, env.db.stateFreezer) ) for i, root := range roots { if root == dl.rootHash() { diff --git a/triedb/pathdb/history_state.go b/triedb/pathdb/history_state.go index bc21915dbaa8..23428b1a5459 100644 --- a/triedb/pathdb/history_state.go +++ b/triedb/pathdb/history_state.go @@ -283,11 +283,11 @@ func (h *stateHistory) typ() historyType { // forEach implements the history interface, returning an iterator to traverse the // state entries in the history. -func (h *stateHistory) forEach() iter.Seq[stateIdent] { - return func(yield func(stateIdent) bool) { +func (h *stateHistory) forEach() iter.Seq[indexElem] { + return func(yield func(indexElem) bool) { for _, addr := range h.accountList { addrHash := crypto.Keccak256Hash(addr.Bytes()) - if !yield(newAccountIdent(addrHash)) { + if !yield(accountIndexElem{addrHash}) { return } for _, slotKey := range h.storageList[addr] { @@ -298,7 +298,7 @@ func (h *stateHistory) forEach() iter.Seq[stateIdent] { if h.meta.version != stateHistoryV0 { slotHash = crypto.Keccak256Hash(slotKey.Bytes()) } - if !yield(newStorageIdent(addrHash, slotHash)) { + if !yield(storageIndexElem{addrHash, slotHash}) { return } } diff --git a/triedb/pathdb/history_trienode.go b/triedb/pathdb/history_trienode.go index 1004106af9c1..11d6112806a0 100644 --- a/triedb/pathdb/history_trienode.go +++ b/triedb/pathdb/history_trienode.go @@ -46,7 +46,10 @@ import ( // - block number (8 bytes) // // - a lexicographically sorted list of trie IDs -// - the corresponding offsets into the key and value sections for each trie data chunk +// - the corresponding offsets into the key and value sections for each trie +// data chunk. The offsets refer to the end position of each chunk, with +// the assumption that the key and value sections for the first data chunk +// start at offset 0. // // Although some fields (e.g., parent state root, block number) are duplicated // between the state history and the trienode history, these two histories @@ -55,19 +58,16 @@ import ( // // # Key section // The key section stores trie node keys (paths) in a compressed format. -// It also contains relative offsets into the value section for resolving -// the corresponding trie node data. Note that these offsets are relative -// to the data chunk for the trie; the chunk offset must be added to obtain -// the absolute position. +// It also contains relative offsets into the value section for locating +// the corresponding trie node data. These offsets are relative to the +// beginning of the trie data chunk, the chunk's base offset must be added +// to obtain the absolute position in the value section. // // # Value section // The value section is a concatenated byte stream of all trie node data. // Each trie node can be retrieved using the offset and length specified // by its index entry. // -// The header and key sections are sufficient for locating a trie node, -// while a partial read of the value section is enough to retrieve its data. - // Header section: // // +----------+------------------+---------------------+---------------------+-------+------------------+---------------------+---------------------| @@ -89,9 +89,9 @@ import ( // // +---- key len ----+ // / \ -// +-------+---------+-----------+---------+-----------------------+-----------------+ -// | shared (varint) | not shared (varint) | value length (varlen) | key (varlen) | -// +-----------------+---------------------+-----------------------+-----------------+ +// +-------+---------+-----------+---------+-----------------------+-----------------------+ +// | shared (varint) | not shared (varint) | value length (varlen) | unshared key (varlen) | +// +-----------------+---------------------+-----------------------+-----------------------+ // // trailer: // @@ -101,9 +101,9 @@ import ( // | restart_1 key offset | restart_1 value offset | ... | restart number (4-bytes) | // +----------------------+------------------------+-----+--------------------------+ // -// Note: Both the key offset and the value offset are relative to the start of -// the trie data chunk. To obtain the absolute offset, add the offset of the -// trie data chunk itself. +// Note: Both the key offset and the value offset are relative to the beginning +// of the trie data chunk. The chunk's base offset must be added to obtain the +// absolute position in the value section. // // Value section: // @@ -140,9 +140,12 @@ type trienodeHistory struct { // newTrienodeHistory constructs a trienode history with the provided trie nodes. func newTrienodeHistory(root common.Hash, parent common.Hash, block uint64, nodes map[common.Hash]map[string][]byte) *trienodeHistory { - nodeList := make(map[common.Hash][]string) + nodeList := make(map[common.Hash][]string, len(nodes)) for owner, subset := range nodes { - keys := sort.StringSlice(slices.Collect(maps.Keys(subset))) + keys := make(sort.StringSlice, 0, len(subset)) + for k := range subset { + keys = append(keys, k) + } keys.Sort() nodeList[owner] = keys } @@ -159,17 +162,6 @@ func newTrienodeHistory(root common.Hash, parent common.Hash, block uint64, node } } -// sharedLen returns the length of the common prefix shared by a and b. -func sharedLen(a, b []byte) int { - n := min(len(a), len(b)) - for i := range n { - if a[i] != b[i] { - return i - } - } - return n -} - // typ implements the history interface, returning the historical data type held. func (h *trienodeHistory) typ() historyType { return typeTrienodeHistory @@ -177,11 +169,35 @@ func (h *trienodeHistory) typ() historyType { // forEach implements the history interface, returning an iterator to traverse the // state entries in the history. -func (h *trienodeHistory) forEach() iter.Seq[stateIdent] { - return func(yield func(stateIdent) bool) { +func (h *trienodeHistory) forEach() iter.Seq[indexElem] { + return func(yield func(indexElem) bool) { for _, owner := range h.owners { - for _, path := range h.nodeList[owner] { - if !yield(newTrienodeIdent(owner, path)) { + var ( + scheme *indexScheme + paths = h.nodeList[owner] + indexes = make(map[string]map[uint16]struct{}) + ) + if owner == (common.Hash{}) { + scheme = accountIndexScheme + } else { + scheme = storageIndexScheme + } + for _, leaf := range findLeafPaths(paths) { + chunks, ids := scheme.splitPath(leaf) + for i := 0; i < len(chunks); i++ { + if _, exists := indexes[chunks[i]]; !exists { + indexes[chunks[i]] = make(map[uint16]struct{}) + } + indexes[chunks[i]][ids[i]] = struct{}{} + } + } + for chunk, ids := range indexes { + elem := trienodeIndexElem{ + owner: owner, + path: chunk, + data: slices.Collect(maps.Keys(ids)), + } + if !yield(elem) { return } } @@ -209,17 +225,22 @@ func (h *trienodeHistory) encode() ([]byte, []byte, []byte, error) { restarts []uint32 prefixLen int - internalKeyOffset uint32 // key offset for the trie internally - internalValOffset uint32 // value offset for the trie internally + internalKeyOffset uint32 // key offset within the trie data internally + internalValOffset uint32 // value offset within the trie data internally ) for i, path := range h.nodeList[owner] { key := []byte(path) + + // Track the internal key and value offsets at the beginning of the + // restart section. The absolute offsets within the key and value + // sections should first include the offset of the trie chunk itself + // stored in the header section. if i%trienodeDataBlockRestartLen == 0 { restarts = append(restarts, internalKeyOffset) restarts = append(restarts, internalValOffset) prefixLen = 0 } else { - prefixLen = sharedLen(prevKey, key) + prefixLen = commonPrefixLen(prevKey, key) } value := h.nodes[owner][path] @@ -258,18 +279,13 @@ func (h *trienodeHistory) encode() ([]byte, []byte, []byte, error) { } // Fill the header section with the offsets of the key and value sections. - // Note that the key/value offsets are intentionally tracked *after* encoding - // them into their respective sections, ensuring each offset refers to the end - // position. For n trie chunks, n offset pairs are sufficient to uniquely locate - // the corresponding data. - headerSection.Write(owner.Bytes()) // 32 bytes - binary.Write(&headerSection, binary.BigEndian, uint32(keySection.Len())) // 4 bytes - - // The offset to the value section is theoretically unnecessary, since the - // individual value offset is already tracked in the key section. However, - // we still keep it here for two reasons: - // - It's cheap to store (only 4 bytes for each trie). - // - It can be useful for decoding the trie data when key is not required (e.g., in hash mode). + // Note that key/value offsets are intentionally recorded *after* encoding + // into their respective sections, so each offset refers to an end position. + // For n trie chunks, n offset pairs are sufficient to uniquely locate each + // chunk's data. For example, [0, offset_0] defines the range of trie chunk 0, + // while [offset_{n-2}, offset_{n-1}] defines the range of trie chunk n-1. + headerSection.Write(owner.Bytes()) // 32 bytes + binary.Write(&headerSection, binary.BigEndian, uint32(keySection.Len())) // 4 bytes binary.Write(&headerSection, binary.BigEndian, uint32(valueSection.Len())) // 4 bytes } return headerSection.Bytes(), keySection.Bytes(), valueSection.Bytes(), nil @@ -332,32 +348,68 @@ func decodeHeader(data []byte) (*trienodeMetadata, []common.Hash, []uint32, []ui }, owners, keyOffsets, valOffsets, nil } -func decodeSingle(keySection []byte, onValue func([]byte, int, int) error) ([]string, error) { - var ( - prevKey []byte - items int - keyOffsets []uint32 - valOffsets []uint32 +// decodeKeyEntry resolves a single entry from the key section starting from +// the specified offset. +func decodeKeyEntry(keySection []byte, offset int) (uint64, uint64, []byte, int, error) { + var byteRead int - keyOff int // the key offset within the single trie data - valOff int // the value offset within the single trie data + // Resolve the length of shared key + nShared, nn := binary.Uvarint(keySection[offset:]) // key length shared (varint) + if nn <= 0 { + return 0, 0, nil, 0, fmt.Errorf("corrupted varint encoding for nShared at offset %d", offset) + } + byteRead += nn - keys []string - ) + // Resolve the length of unshared key + nUnshared, nn := binary.Uvarint(keySection[offset+byteRead:]) // key length not shared (varint) + if nn <= 0 { + return 0, 0, nil, 0, fmt.Errorf("corrupted varint encoding for nUnshared at offset %d", offset+byteRead) + } + byteRead += nn + + // Resolve the length of value + nValue, nn := binary.Uvarint(keySection[offset+byteRead:]) // value length (varint) + if nn <= 0 { + return 0, 0, nil, 0, fmt.Errorf("corrupted varint encoding for nValue at offset %d", offset+byteRead) + } + byteRead += nn + + // Validate that the values can fit in an int to prevent overflow on 32-bit systems + if nShared > uint64(math.MaxUint32) || nUnshared > uint64(math.MaxUint32) || nValue > uint64(math.MaxUint32) { + return 0, 0, nil, 0, errors.New("key/value size too large") + } + + // Resolve the unshared key + if offset+byteRead+int(nUnshared) > len(keySection) { + return 0, 0, nil, 0, fmt.Errorf("key length too long, unshared key length: %d, off: %d, section size: %d", nUnshared, offset+byteRead, len(keySection)) + } + unsharedKey := keySection[offset+byteRead : offset+byteRead+int(nUnshared)] + byteRead += int(nUnshared) + + return nShared, nValue, unsharedKey, byteRead, nil +} + +// decodeRestartTrailer resolves all the offsets recorded at the trailer. +func decodeRestartTrailer(keySection []byte) ([]uint32, []uint32, int, error) { // Decode the number of restart section if len(keySection) < 4 { - return nil, fmt.Errorf("key section too short, size: %d", len(keySection)) + return nil, nil, 0, fmt.Errorf("key section too short, size: %d", len(keySection)) } nRestarts := binary.BigEndian.Uint32(keySection[len(keySection)-4:]) + // Decode the trailer + var ( + keyOffsets = make([]uint32, 0, int(nRestarts)) + valOffsets = make([]uint32, 0, int(nRestarts)) + ) if len(keySection) < int(8*nRestarts)+4 { - return nil, fmt.Errorf("key section too short, restarts: %d, size: %d", nRestarts, len(keySection)) + return nil, nil, 0, fmt.Errorf("key section too short, restarts: %d, size: %d", nRestarts, len(keySection)) } for i := range int(nRestarts) { o := len(keySection) - 4 - (int(nRestarts)-i)*8 keyOffset := binary.BigEndian.Uint32(keySection[o : o+4]) if i != 0 && keyOffset <= keyOffsets[i-1] { - return nil, fmt.Errorf("key offset is out of order, prev: %v, cur: %v", keyOffsets[i-1], keyOffset) + return nil, nil, 0, fmt.Errorf("key offset is out of order, prev: %v, cur: %v", keyOffsets[i-1], keyOffset) } keyOffsets = append(keyOffsets, keyOffset) @@ -365,98 +417,118 @@ func decodeSingle(keySection []byte, onValue func([]byte, int, int) error) ([]st // section have zero-size value. valOffset := binary.BigEndian.Uint32(keySection[o+4 : o+8]) if i != 0 && valOffset < valOffsets[i-1] { - return nil, fmt.Errorf("value offset is out of order, prev: %v, cur: %v", valOffsets[i-1], valOffset) + return nil, nil, 0, fmt.Errorf("value offset is out of order, prev: %v, cur: %v", valOffsets[i-1], valOffset) } valOffsets = append(valOffsets, valOffset) } - keyLimit := len(keySection) - 4 - int(nRestarts)*8 + keyLimit := len(keySection) - 4 - int(nRestarts)*8 // End of key data + return keyOffsets, valOffsets, keyLimit, nil +} +// decodeRestartSection resolves all entries in a restart section. The keyData +// contains the encoded keys for the section. +// +// onValue is the callback function being invoked for each resolved entry. The +// start and limit are the offsets within the restart section, the base value +// offset of the restart section itself should be added by the caller itself. +// What's more, this function should return `aborted == true` if the entry +// resolution should be terminated. +func decodeRestartSection(keyData []byte, onValue func(key []byte, start int, limit int) (bool, error)) error { + var ( + prevKey []byte + items int + + keyOff int // the key offset within the single trie data + valOff int // the value offset within the single trie data + ) // Decode data - for keyOff < keyLimit { - // Validate the key and value offsets within the single trie data chunk - if items%trienodeDataBlockRestartLen == 0 { - restartIndex := items / trienodeDataBlockRestartLen - if restartIndex >= len(keyOffsets) { - return nil, fmt.Errorf("restart index out of range: %d, available restarts: %d", restartIndex, len(keyOffsets)) - } - if keyOff != int(keyOffsets[restartIndex]) { - return nil, fmt.Errorf("key offset is not matched, recorded: %d, want: %d", keyOffsets[restartIndex], keyOff) - } - if valOff != int(valOffsets[restartIndex]) { - return nil, fmt.Errorf("value offset is not matched, recorded: %d, want: %d", valOffsets[restartIndex], valOff) - } - } - // Resolve the entry from key section - nShared, nn := binary.Uvarint(keySection[keyOff:]) // key length shared (varint) - if nn <= 0 { - return nil, fmt.Errorf("corrupted varint encoding for nShared at offset %d", keyOff) - } - keyOff += nn - nUnshared, nn := binary.Uvarint(keySection[keyOff:]) // key length not shared (varint) - if nn <= 0 { - return nil, fmt.Errorf("corrupted varint encoding for nUnshared at offset %d", keyOff) - } - keyOff += nn - nValue, nn := binary.Uvarint(keySection[keyOff:]) // value length (varint) - if nn <= 0 { - return nil, fmt.Errorf("corrupted varint encoding for nValue at offset %d", keyOff) + for keyOff < len(keyData) { + nShared, nValue, unsharedKey, nn, err := decodeKeyEntry(keyData, keyOff) + if err != nil { + return err } keyOff += nn - // Validate that the values can fit in an int to prevent overflow on 32-bit systems - if nShared > uint64(math.MaxUint32) || nUnshared > uint64(math.MaxUint32) || nValue > uint64(math.MaxUint32) { - return nil, errors.New("key size too large") - } - - // Resolve unshared key - if keyOff+int(nUnshared) > len(keySection) { - return nil, fmt.Errorf("key length too long, unshared key length: %d, off: %d, section size: %d", nUnshared, keyOff, len(keySection)) - } - unsharedKey := keySection[keyOff : keyOff+int(nUnshared)] - keyOff += int(nUnshared) - // Assemble the full key var key []byte if items%trienodeDataBlockRestartLen == 0 { if nShared != 0 { - return nil, fmt.Errorf("unexpected non-zero shared key prefix: %d", nShared) + return fmt.Errorf("unexpected non-zero shared key prefix: %d", nShared) } key = unsharedKey } else { if int(nShared) > len(prevKey) { - return nil, fmt.Errorf("unexpected shared key prefix: %d, prefix key length: %d", nShared, len(prevKey)) + return fmt.Errorf("unexpected shared key prefix: %d, prefix key length: %d", nShared, len(prevKey)) } - key = append([]byte{}, prevKey[:nShared]...) - key = append(key, unsharedKey...) + key = make([]byte, int(nShared)+len(unsharedKey)) + copy(key[:nShared], prevKey[:nShared]) + copy(key[nShared:], unsharedKey) } if items != 0 && bytes.Compare(prevKey, key) >= 0 { - return nil, fmt.Errorf("trienode paths are out of order, prev: %v, cur: %v", prevKey, key) + return fmt.Errorf("trienode paths are out of order, prev: %v, cur: %v", prevKey, key) } prevKey = key - // Resolve value - if onValue != nil { - if err := onValue(key, valOff, valOff+int(nValue)); err != nil { - return nil, err - } + valEnd := valOff + int(nValue) + abort, err := onValue(key, valOff, valEnd) + if err != nil { + return err } - valOff += int(nValue) - + if abort { + return nil + } + valOff = valEnd items++ - keys = append(keys, string(key)) } - if keyOff != keyLimit { - return nil, fmt.Errorf("excessive key data after decoding, offset: %d, size: %d", keyOff, keyLimit) + if keyOff != len(keyData) { + return fmt.Errorf("excessive key data after decoding, offset: %d, size: %d", keyOff, len(keyData)) } - return keys, nil + return nil +} + +// onValue is the callback function being invoked for each resolved entry. The +// start and limit are the offsets within this trie chunk, the base value +// offset of the trie chunk itself should be added by the caller itself. +func decodeSingle(keySection []byte, onValue func([]byte, int, int) error) error { + keyOffsets, valOffsets, keyLimit, err := decodeRestartTrailer(keySection) + if err != nil { + return err + } + for i := 0; i < len(keyOffsets); i++ { + var keyData []byte + if i == len(keyOffsets)-1 { + keyData = keySection[keyOffsets[i]:keyLimit] + } else { + keyData = keySection[keyOffsets[i]:keyOffsets[i+1]] + } + err := decodeRestartSection(keyData, func(key []byte, start int, limit int) (bool, error) { + valStart := int(valOffsets[i]) + start + valLimit := int(valOffsets[i]) + limit + + // Possible in tests + if onValue == nil { + return false, nil + } + if err := onValue(key, valStart, valLimit); err != nil { + return false, err + } + return false, nil // abort=false + }) + if err != nil { + return err + } + } + return nil } func decodeSingleWithValue(keySection []byte, valueSection []byte) ([]string, map[string][]byte, error) { var ( - offset int - nodes = make(map[string][]byte) + offset int + estimated = len(keySection) / 8 + nodes = make(map[string][]byte, estimated) + paths = make([]string, 0, estimated) ) - paths, err := decodeSingle(keySection, func(key []byte, start int, limit int) error { + err := decodeSingle(keySection, func(key []byte, start int, limit int) error { if start != offset { return fmt.Errorf("gapped value section offset: %d, want: %d", start, offset) } @@ -467,7 +539,9 @@ func decodeSingleWithValue(keySection []byte, valueSection []byte) ([]string, ma if start > len(valueSection) || limit > len(valueSection) { return fmt.Errorf("value section out of range: start: %d, limit: %d, size: %d", start, limit, len(valueSection)) } - nodes[string(key)] = valueSection[start:limit] + strkey := string(key) + paths = append(paths, strkey) + nodes[strkey] = valueSection[start:limit] offset = limit return nil @@ -493,7 +567,8 @@ func (h *trienodeHistory) decode(header []byte, keySection []byte, valueSection h.nodes = make(map[common.Hash]map[string][]byte) for i := range len(owners) { - // Resolve the boundary of key section + // Resolve the boundary of the key section, each offset referring + // to the end position of this trie chunk. var keyStart, keyLimit uint32 if i != 0 { keyStart = keyOffsets[i-1] @@ -503,7 +578,8 @@ func (h *trienodeHistory) decode(header []byte, keySection []byte, valueSection return fmt.Errorf("invalid key offsets: keyStart: %d, keyLimit: %d, size: %d", keyStart, keyLimit, len(keySection)) } - // Resolve the boundary of value section + // Resolve the boundary of the value section, each offset referring + // to the end position of this trie chunk. var valStart, valLimit uint32 if i != 0 { valStart = valueOffsets[i-1] @@ -533,14 +609,11 @@ func (ir iRange) len() uint32 { return ir.limit - ir.start } -// singleTrienodeHistoryReader provides read access to a single trie within the -// trienode history. It stores an offset to the trie's position in the history, -// along with a set of per-node offsets that can be resolved on demand. type singleTrienodeHistoryReader struct { - id uint64 - reader ethdb.AncientReader - valueRange iRange // value range within the global value section - valueInternalOffsets map[string]iRange // value offset within the single trie data + id uint64 + reader ethdb.AncientReader + keyData []byte + valueRange iRange } func newSingleTrienodeHistoryReader(id uint64, reader ethdb.AncientReader, keyRange iRange, valueRange iRange) (*singleTrienodeHistoryReader, error) { @@ -548,121 +621,173 @@ func newSingleTrienodeHistoryReader(id uint64, reader ethdb.AncientReader, keyRa if err != nil { return nil, err } - valueOffsets := make(map[string]iRange) - _, err = decodeSingle(keyData, func(key []byte, start int, limit int) error { - valueOffsets[string(key)] = iRange{ - start: uint32(start), - limit: uint32(limit), - } - return nil + return &singleTrienodeHistoryReader{ + id: id, + reader: reader, + keyData: keyData, + valueRange: valueRange, + }, nil +} + +// searchSingle searches for a specific trie node identified by the provided +// key within a single trie node chunk. +// +// It returns the node value's offset range (start and limit) within the +// trie node data. An error is returned if the node cannot be found. +func (sr *singleTrienodeHistoryReader) searchSingle(key []byte) (int, int, bool, error) { + keyOffsets, valOffsets, keyLimit, err := decodeRestartTrailer(sr.keyData) + if err != nil { + return 0, 0, false, err + } + // Binary search against the boundary keys for each restart section + var ( + boundFind bool + boundValueLen uint64 + ) + pos := sort.Search(len(keyOffsets), func(i int) bool { + _, nValue, dkey, _, derr := decodeKeyEntry(sr.keyData[keyOffsets[i]:], 0) + if derr != nil { + err = derr + return false + } + n := bytes.Compare(key, dkey) + if n == 0 { + boundFind = true + boundValueLen = nValue + } + return n <= 0 }) if err != nil { - return nil, err + return 0, 0, false, err } - return &singleTrienodeHistoryReader{ - id: id, - reader: reader, - valueRange: valueRange, - valueInternalOffsets: valueOffsets, - }, nil + // The node is found as the boundary of restart section + if boundFind { + start := valOffsets[pos] + limit := valOffsets[pos] + uint32(boundValueLen) + return int(start), int(limit), true, nil + } + // The node is not found as all others have larger key than the target + if pos == 0 { + return 0, 0, false, nil + } + // Search the target node within the restart section + var keyData []byte + if pos == len(keyOffsets) { + keyData = sr.keyData[keyOffsets[pos-1]:keyLimit] // last section + } else { + keyData = sr.keyData[keyOffsets[pos-1]:keyOffsets[pos]] // non-last section + } + var ( + nStart int + nLimit int + found bool + ) + err = decodeRestartSection(keyData, func(ikey []byte, start, limit int) (bool, error) { + if bytes.Equal(key, ikey) { + nStart = int(valOffsets[pos-1]) + start + nLimit = int(valOffsets[pos-1]) + limit + found = true + return true, nil // abort = true + } + return false, nil // abort = false + }) + if err != nil { + return 0, 0, false, err + } + if !found { + return 0, 0, false, nil + } + return nStart, nLimit, true, nil } // read retrieves the trie node data with the provided node path. -func (sr *singleTrienodeHistoryReader) read(path string) ([]byte, error) { - offset, exists := sr.valueInternalOffsets[path] - if !exists { - return nil, fmt.Errorf("trienode %v not found", []byte(path)) +func (sr *singleTrienodeHistoryReader) read(key []byte) ([]byte, bool, error) { + start, limit, found, err := sr.searchSingle(key) + if err != nil { + return nil, false, err + } + if !found { + return nil, false, nil + } + valStart := uint64(start) + uint64(sr.valueRange.start) + valLen := uint64(limit - start) + value, err := rawdb.ReadTrienodeHistoryValueSection(sr.reader, sr.id, valStart, valLen) + if err != nil { + return nil, false, err } - return rawdb.ReadTrienodeHistoryValueSection(sr.reader, sr.id, uint64(sr.valueRange.start+offset.start), uint64(offset.len())) + return value, true, nil } // trienodeHistoryReader provides read access to node data in the trie node history. // It resolves data from the underlying ancient store only when needed, minimizing // I/O overhead. type trienodeHistoryReader struct { - id uint64 // ID of the associated trienode history - reader ethdb.AncientReader // Database reader of ancient store - keyRanges map[common.Hash]iRange // Key ranges identifying trie chunks - valRanges map[common.Hash]iRange // Value ranges identifying trie chunks - iReaders map[common.Hash]*singleTrienodeHistoryReader // readers for each individual trie chunk + id uint64 // ID of the associated trienode history + reader ethdb.AncientReader // Database reader of ancient store } // newTrienodeHistoryReader constructs the reader for specific trienode history. -func newTrienodeHistoryReader(id uint64, reader ethdb.AncientReader) (*trienodeHistoryReader, error) { - r := &trienodeHistoryReader{ - id: id, - reader: reader, - keyRanges: make(map[common.Hash]iRange), - valRanges: make(map[common.Hash]iRange), - iReaders: make(map[common.Hash]*singleTrienodeHistoryReader), - } - if err := r.decodeHeader(); err != nil { - return nil, err +func newTrienodeHistoryReader(id uint64, reader ethdb.AncientReader) *trienodeHistoryReader { + return &trienodeHistoryReader{ + id: id, + reader: reader, } - return r, nil } // decodeHeader decodes the header section of trienode history. -func (r *trienodeHistoryReader) decodeHeader() error { +func (r *trienodeHistoryReader) decodeHeader(owner common.Hash) (iRange, iRange, bool, error) { header, err := rawdb.ReadTrienodeHistoryHeader(r.reader, r.id) if err != nil { - return err + return iRange{}, iRange{}, false, err } _, owners, keyOffsets, valOffsets, err := decodeHeader(header) if err != nil { - return err + return iRange{}, iRange{}, false, err } - for i, owner := range owners { - // Decode the key range for this trie chunk - var keyStart uint32 - if i != 0 { - keyStart = keyOffsets[i-1] - } - r.keyRanges[owner] = iRange{ - start: keyStart, - limit: keyOffsets[i], - } + pos := sort.Search(len(owners), func(i int) bool { + return owner.Cmp(owners[i]) <= 0 + }) + if pos == len(owners) || owners[pos] != owner { + return iRange{}, iRange{}, false, nil + } + var keyRange iRange + if pos != 0 { + keyRange.start = keyOffsets[pos-1] + } + keyRange.limit = keyOffsets[pos] - // Decode the value range for this trie chunk - var valStart uint32 - if i != 0 { - valStart = valOffsets[i-1] - } - r.valRanges[owner] = iRange{ - start: valStart, - limit: valOffsets[i], - } + var valRange iRange + if pos != 0 { + valRange.start = valOffsets[pos-1] } - return nil + valRange.limit = valOffsets[pos] + return keyRange, valRange, true, nil } // read retrieves the trie node data with the provided TrieID and node path. -func (r *trienodeHistoryReader) read(owner common.Hash, path string) ([]byte, error) { - ir, ok := r.iReaders[owner] - if !ok { - keyRange, exists := r.keyRanges[owner] - if !exists { - return nil, fmt.Errorf("trie %x is unknown", owner) - } - valRange, exists := r.valRanges[owner] - if !exists { - return nil, fmt.Errorf("trie %x is unknown", owner) - } - var err error - ir, err = newSingleTrienodeHistoryReader(r.id, r.reader, keyRange, valRange) - if err != nil { - return nil, err - } - r.iReaders[owner] = ir +func (r *trienodeHistoryReader) read(owner common.Hash, path string) ([]byte, bool, error) { + keyRange, valRange, found, err := r.decodeHeader(owner) + if err != nil { + return nil, false, err + } + if !found { + return nil, false, nil + } + ir, err := newSingleTrienodeHistoryReader(r.id, r.reader, keyRange, valRange) + if err != nil { + return nil, false, err } - return ir.read(path) + return ir.read([]byte(path)) } // writeTrienodeHistory persists the trienode history associated with the given diff layer. -// nolint:unused -func writeTrienodeHistory(writer ethdb.AncientWriter, dl *diffLayer) error { +func writeTrienodeHistory(writer ethdb.AncientWriter, dl *diffLayer, rate uint32) error { start := time.Now() - h := newTrienodeHistory(dl.rootHash(), dl.parent.rootHash(), dl.block, dl.nodes.nodeOrigin) + nodes, err := dl.nodes.encodeNodeHistory(dl.root, rate) + if err != nil { + return err + } + h := newTrienodeHistory(dl.rootHash(), dl.parent.rootHash(), dl.block, nodes) header, keySection, valueSection, err := h.encode() if err != nil { return err @@ -686,7 +811,6 @@ func writeTrienodeHistory(writer ethdb.AncientWriter, dl *diffLayer) error { } // readTrienodeMetadata resolves the metadata of the specified trienode history. -// nolint:unused func readTrienodeMetadata(reader ethdb.AncientReader, id uint64) (*trienodeMetadata, error) { header, err := rawdb.ReadTrienodeHistoryHeader(reader, id) if err != nil { diff --git a/triedb/pathdb/history_trienode_test.go b/triedb/pathdb/history_trienode_test.go index be4740a90457..05278c30b1a0 100644 --- a/triedb/pathdb/history_trienode_test.go +++ b/triedb/pathdb/history_trienode_test.go @@ -19,6 +19,7 @@ package pathdb import ( "bytes" "encoding/binary" + "fmt" "math/rand" "reflect" "testing" @@ -137,14 +138,11 @@ func TestTrienodeHistoryReader(t *testing.T) { } } for i, h := range hs { - tr, err := newTrienodeHistoryReader(uint64(i+1), freezer) - if err != nil { - t.Fatalf("Failed to construct the history reader: %v", err) - } + tr := newTrienodeHistoryReader(uint64(i+1), freezer) for _, owner := range h.owners { nodes := h.nodes[owner] for key, value := range nodes { - blob, err := tr.read(owner, key) + blob, _, err := tr.read(owner, key) if err != nil { t.Fatalf("Failed to read trienode history: %v", err) } @@ -417,23 +415,23 @@ func TestTrienodeHistoryReaderNonExistentPath(t *testing.T) { if err := rawdb.WriteTrienodeHistory(freezer, 1, header, keySection, valueSection); err != nil { t.Fatalf("Failed to write trienode history: %v", err) } - - tr, err := newTrienodeHistoryReader(1, freezer) - if err != nil { - t.Fatalf("Failed to construct history reader: %v", err) - } + tr := newTrienodeHistoryReader(1, freezer) // Try to read a non-existent path - _, err = tr.read(testrand.Hash(), "nonexistent") - if err == nil { - t.Fatal("Expected error for non-existent trie owner") + var ( + err error + found bool + ) + _, found, err = tr.read(testrand.Hash(), "nonexistent") + if found || err != nil { + t.Fatal("Expected not found for non-existent trie owner") } // Try to read from existing owner but non-existent path owner := h.owners[0] - _, err = tr.read(owner, "nonexistent-path") - if err == nil { - t.Fatal("Expected error for non-existent path") + _, found, err = tr.read(owner, "nonexistent-path") + if found || err != nil { + t.Fatal("Expected not found for non-existent path") } } @@ -457,23 +455,19 @@ func TestTrienodeHistoryReaderNilValues(t *testing.T) { if err := rawdb.WriteTrienodeHistory(freezer, 1, header, keySection, valueSection); err != nil { t.Fatalf("Failed to write trienode history: %v", err) } - - tr, err := newTrienodeHistoryReader(1, freezer) - if err != nil { - t.Fatalf("Failed to construct history reader: %v", err) - } + tr := newTrienodeHistoryReader(1, freezer) // Test reading nil values - data1, err := tr.read(owner, "nil1") - if err != nil { + data1, found, err := tr.read(owner, "nil1") + if err != nil || !found { t.Fatalf("Failed to read nil value: %v", err) } if len(data1) != 0 { t.Fatal("Expected nil data for nil value") } - data2, err := tr.read(owner, "nil2") - if err != nil { + data2, found, err := tr.read(owner, "nil2") + if err != nil || !found { t.Fatalf("Failed to read nil value: %v", err) } if len(data2) != 0 { @@ -481,8 +475,8 @@ func TestTrienodeHistoryReaderNilValues(t *testing.T) { } // Test reading non-nil value - data3, err := tr.read(owner, "data1") - if err != nil { + data3, found, err := tr.read(owner, "data1") + if err != nil || !found { t.Fatalf("Failed to read non-nil value: %v", err) } if !bytes.Equal(data3, []byte("some data")) { @@ -498,7 +492,7 @@ func TestTrienodeHistoryReaderNilKey(t *testing.T) { // Add some nil values nodes[owner][""] = []byte("some data") - nodes[owner]["data1"] = []byte("some data") + nodes[owner]["data1"] = []byte("some data1") h := newTrienodeHistory(common.Hash{}, common.Hash{}, 1, nodes) @@ -509,14 +503,10 @@ func TestTrienodeHistoryReaderNilKey(t *testing.T) { if err := rawdb.WriteTrienodeHistory(freezer, 1, header, keySection, valueSection); err != nil { t.Fatalf("Failed to write trienode history: %v", err) } - - tr, err := newTrienodeHistoryReader(1, freezer) - if err != nil { - t.Fatalf("Failed to construct history reader: %v", err) - } + tr := newTrienodeHistoryReader(1, freezer) // Test reading nil values - data1, err := tr.read(owner, "") + data1, _, err := tr.read(owner, "") if err != nil { t.Fatalf("Failed to read nil value: %v", err) } @@ -525,63 +515,17 @@ func TestTrienodeHistoryReaderNilKey(t *testing.T) { } // Test reading non-nil value - data2, err := tr.read(owner, "data1") + data2, _, err := tr.read(owner, "data1") if err != nil { t.Fatalf("Failed to read non-nil value: %v", err) } - if !bytes.Equal(data2, []byte("some data")) { + if !bytes.Equal(data2, []byte("some data1")) { t.Fatal("Data mismatch for non-nil key") } } -// TestTrienodeHistoryReaderIterator tests the iterator functionality -func TestTrienodeHistoryReaderIterator(t *testing.T) { - h := makeTrienodeHistory() - - // Count expected entries - expectedCount := 0 - expectedNodes := make(map[stateIdent]bool) - for owner, nodeList := range h.nodeList { - expectedCount += len(nodeList) - for _, node := range nodeList { - expectedNodes[stateIdent{ - typ: typeTrienode, - addressHash: owner, - path: node, - }] = true - } - } - - // Test the iterator - actualCount := 0 - for x := range h.forEach() { - _ = x - actualCount++ - } - if actualCount != expectedCount { - t.Fatalf("Iterator count mismatch: expected %d, got %d", expectedCount, actualCount) - } - - // Test that iterator yields expected state identifiers - seen := make(map[stateIdent]bool) - for ident := range h.forEach() { - if ident.typ != typeTrienode { - t.Fatal("Iterator should only yield trienode history identifiers") - } - key := stateIdent{typ: ident.typ, addressHash: ident.addressHash, path: ident.path} - if seen[key] { - t.Fatal("Iterator yielded duplicate identifier") - } - seen[key] = true - - if !expectedNodes[key] { - t.Fatalf("Unexpected yielded identifier %v", key) - } - } -} - -// TestSharedLen tests the sharedLen helper function -func TestSharedLen(t *testing.T) { +// TestCommonPrefixLen tests the commonPrefixLen helper function +func TestCommonPrefixLen(t *testing.T) { tests := []struct { a, b []byte expected int @@ -610,13 +554,13 @@ func TestSharedLen(t *testing.T) { } for i, test := range tests { - result := sharedLen(test.a, test.b) + result := commonPrefixLen(test.a, test.b) if result != test.expected { t.Errorf("Test %d: sharedLen(%q, %q) = %d, expected %d", i, test.a, test.b, result, test.expected) } // Test commutativity - resultReverse := sharedLen(test.b, test.a) + resultReverse := commonPrefixLen(test.b, test.a) if result != resultReverse { t.Errorf("Test %d: sharedLen is not commutative: sharedLen(a,b)=%d, sharedLen(b,a)=%d", i, result, resultReverse) @@ -678,14 +622,14 @@ func TestDecodeSingleCorruptedData(t *testing.T) { _, keySection, _, _ := h.encode() // Test with empty key section - _, err := decodeSingle([]byte{}, nil) + err := decodeSingle([]byte{}, nil) if err == nil { t.Fatal("Expected error for empty key section") } // Test with key section too small for trailer if len(keySection) > 0 { - _, err := decodeSingle(keySection[:3], nil) // Less than 4 bytes for trailer + err := decodeSingle(keySection[:3], nil) // Less than 4 bytes for trailer if err == nil { t.Fatal("Expected error for key section too small for trailer") } @@ -698,7 +642,7 @@ func TestDecodeSingleCorruptedData(t *testing.T) { for i := range 10 { corrupted[i] = 0xFF } - _, err = decodeSingle(corrupted, nil) + err = decodeSingle(corrupted, nil) if err == nil { t.Fatal("Expected error for corrupted varint") } @@ -708,7 +652,7 @@ func TestDecodeSingleCorruptedData(t *testing.T) { copy(corrupted, keySection) // Set restart count to something too large binary.BigEndian.PutUint32(corrupted[len(corrupted)-4:], 10000) - _, err = decodeSingle(corrupted, nil) + err = decodeSingle(corrupted, nil) if err == nil { t.Fatal("Expected error for invalid restart count") } @@ -737,3 +681,57 @@ func testEncodeDecode(t *testing.T, h *trienodeHistory) { t.Fatal("Trienode content mismatch") } } + +func TestSearchSingle(t *testing.T) { + nodes := make(map[common.Hash]map[string][]byte) + ownerA, ownerB := testrand.Hash(), testrand.Hash() + nodes[ownerA] = make(map[string][]byte) + nodes[ownerB] = make(map[string][]byte) + + for i := 0; i < trienodeDataBlockRestartLen*2; i++ { + nodes[ownerA][fmt.Sprintf("%d", 2*i+1)] = testrand.Bytes(rand.Intn(5)) + nodes[ownerB][fmt.Sprintf("%d", 2*i+1)] = testrand.Bytes(rand.Intn(5)) + } + h := newTrienodeHistory(common.Hash{}, common.Hash{}, 1, nodes) + + var freezer, _ = rawdb.NewTrienodeFreezer(t.TempDir(), false, false) + defer freezer.Close() + + header, keySection, valueSection, _ := h.encode() + if err := rawdb.WriteTrienodeHistory(freezer, 1, header, keySection, valueSection); err != nil { + t.Fatalf("Failed to write trienode history: %v", err) + } + tr := newTrienodeHistoryReader(1, freezer) + + // Test reading non-existent entry + keys := []string{ + "0", + "2", + "30", + "32", + "64", + "1000", + } + for _, key := range keys { + _, found, err := tr.read(ownerA, key) + if err != nil || found { + t.Fatalf("Expected non-existent entry %v", err) + } + _, found, err = tr.read(ownerB, key) + if err != nil || found { + t.Fatalf("Expected non-existent entry %v", err) + } + } + + for owner, subnodes := range nodes { + for key, value := range subnodes { + got, found, err := tr.read(owner, key) + if err != nil || !found { + t.Fatal("Failed to read trienode") + } + if bytes.Compare(got, value) != 0 { + t.Fatalf("Unexpected value for key %v, got %v, expected %v", []byte(key), got, value) + } + } + } +} diff --git a/triedb/pathdb/history_trienode_utils.go b/triedb/pathdb/history_trienode_utils.go new file mode 100644 index 000000000000..11107494bb15 --- /dev/null +++ b/triedb/pathdb/history_trienode_utils.go @@ -0,0 +1,344 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package pathdb + +import ( + "encoding/binary" + "fmt" + "math/bits" + "slices" + "strings" +) + +// commonPrefixLen returns the length of the common prefix shared by a and b. +func commonPrefixLen(a, b []byte) int { + n := min(len(a), len(b)) + for i := range n { + if a[i] != b[i] { + return i + } + } + return n +} + +// findLeafPaths scans a lexicographically sorted list of paths and returns +// the subset of paths that represent leaves. +// +// A path is considered a leaf if: +// - it is the last element in the list, or +// - the next path does not have the current path as its prefix. +// +// In other words, a leaf is a path that has no children extending it. +// +// Example: +// +// Input: ["a", "ab", "abc", "b", "ba"] +// Output: ["abc", "ba"] +// +// The input must be sorted; otherwise the result is undefined. +func findLeafPaths(paths []string) []string { + var leaves []string + for i := 0; i < len(paths); i++ { + if i == len(paths)-1 || !strings.HasPrefix(paths[i+1], paths[i]) { + leaves = append(leaves, paths[i]) + } + } + return leaves +} + +// hexPathNodeID computes a numeric node ID from the given path. The path is +// interpreted as a sequence of base-16 digits, where each byte of the input +// is treated as one hexadecimal digit in a big-endian number. +// +// The resulting node ID is constructed as: +// +// ID = 1 + 16 + 16^2 + ... + 16^(n-1) + value +// +// where n is the number of bytes in the path, and `value` is the base-16 +// interpretation of the byte sequence. +// +// The offset (1 + 16 + 16^2 + ... + 16^(n-1)) ensures that all IDs of shorter +// paths occupy a lower numeric range, preserving lexicographic ordering between +// differently-length paths. +// +// The numeric node ID is represented by the uint16 with the assumption the length +// of path won't be greater than 3. +func hexPathNodeID(path string) uint16 { + var ( + offset = uint16(0) + pow = uint16(1) + value = uint16(0) + bytes = []byte(path) + ) + for i := 0; i < len(bytes); i++ { + offset += pow + pow *= 16 + } + for i := 0; i < len(bytes); i++ { + value = value*16 + uint16(bytes[i]) + } + return offset + value +} + +// bitmapSize computes the number of bytes required for the marker bitmap +// corresponding to the remaining portion of a path after a cut point. +// The marker is a bitmap where each bit represents the presence of a +// possible element in the remaining path segment. +func bitmapSize(levels int) int { + // Compute: total = 1 + 16 + 16^2 + ... + 16^(segLen-1) + var ( + bits = 0 + pow = 1 + ) + for i := 0; i < levels; i++ { + bits += pow + pow *= 16 + } + // A small adjustment is applied to exclude the root element of this path + // segment, since any existing element would already imply the mutation of + // the root element. This trick can save us 1 byte for each bitmap which is + // non-trivial. + bits -= 1 + return bits / 8 +} + +// indexScheme defines how trie nodes are split into chunks and index them +// at chunk level. +// +// skipRoot indicates whether the root node should be excluded from indexing. +// cutPoints specifies the key length of chunks (in nibbles) extracted from +// each path. +type indexScheme struct { + // skipRoot indicates whether the root node should be excluded from indexing. + // In the account trie, the root is mutated on every state transition, so + // indexing it provides no value. + skipRoot bool + + // cutPoints defines the key lengths of chunks at different positions. + // A single trie node path may span multiple chunks vertically. + cutPoints []int + + // bitmaps specifies the required bitmap size for each chunk. The key is the + // chunk key length, and the value is the corresponding bitmap size. + bitmaps map[int]int +} + +var ( + // Account trie is split into chunks like this: + // + // - root node is excluded from indexing + // - nodes at level1 to level2 are grouped as 16 chunks + // - all other nodes are grouped 3 levels per chunk + // + // Level1 [0] ... [f] 16 chunks + // Level3 [000] ... [fff] 4096 chunks + // Level6 [000000] ... [fffffff] 16777216 chunks + // + // For the chunks at level1, there are 17 nodes per chunk. + // + // chunk-level 0 [ 0 ] 1 node + // chunk-level 1 [ 1 ] … [ 16 ] 16 nodes + // + // For the non-level1 chunks, there are 273 nodes per chunk, + // regardless of the chunk's depth in the trie. + // + // chunk-level 0 [ 0 ] 1 node + // chunk-level 1 [ 1 ] … [ 16 ] 16 nodes + // chunk-level 2 [ 17 ] … … [ 272 ] 256 nodes + accountIndexScheme = newIndexScheme(true) + + // Storage trie is split into chunks like this: (3 levels per chunk) + // + // Level0 [ ROOT ] 1 chunk + // Level3 [000] ... [fff] 4096 chunks + // Level6 [000000] ... [fffffff] 16777216 chunks + // + // Within each chunk, there are 273 nodes in total, regardless of + // the chunk's depth in the trie. + // + // chunk-level 0 [ 0 ] 1 node + // chunk-level 1 [ 1 ] … [ 16 ] 16 nodes + // chunk-level 2 [ 17 ] … … [ 272 ] 256 nodes + storageIndexScheme = newIndexScheme(false) +) + +// newIndexScheme initializes the index scheme. +func newIndexScheme(skipRoot bool) *indexScheme { + var ( + cuts []int + bitmaps = make(map[int]int) + ) + for v := 0; v <= 64; v += 3 { + var ( + levels int + length int + ) + if v == 0 && skipRoot { + length = 1 + levels = 2 + } else { + length = v + levels = 3 + } + cuts = append(cuts, length) + bitmaps[length] = bitmapSize(levels) + } + return &indexScheme{ + skipRoot: skipRoot, + cutPoints: cuts, + bitmaps: bitmaps, + } +} + +// getBitmapSize returns the required bytes for bitmap with chunk's position. +func (s *indexScheme) getBitmapSize(pathLen int) int { + return s.bitmaps[pathLen] +} + +// chunkSpan returns how many chunks should be spanned with the given path. +func (s *indexScheme) chunkSpan(length int) int { + var n int + for _, cut := range s.cutPoints { + if length >= cut { + n++ + continue + } + } + return n +} + +// splitPath applies the indexScheme to the given path and returns two lists: +// +// - chunkIDs: the progressive chunk IDs cuts defined by the scheme +// - innerIDs: the computed node ID for the path segment following each cut +// +// The scheme defines a set of cut points that partition the path. For each cut: +// +// - chunkIDs[i] is path[:cutPoints[i]] +// - innerIDs[i] is the node ID of the segment path[cutPoints[i] : nextCut-1] +func (s *indexScheme) splitPath(path string) ([]string, []uint16) { + // Special case: the root node of the account trie is mutated in every + // state transition, so its mutation records can be ignored. + n := len(path) + if n == 0 && s.skipRoot { + return nil, nil + } + var ( + // Determine how many chunks are spanned by the path + chunks = s.chunkSpan(n) + chunkIDs = make([]string, 0, chunks) + nodeIDs = make([]uint16, 0, chunks) + ) + for i := 0; i < chunks; i++ { + position := s.cutPoints[i] + chunkIDs = append(chunkIDs, path[:position]) + + var limit int + if i != chunks-1 { + limit = s.cutPoints[i+1] - 1 + } else { + limit = len(path) + } + nodeIDs = append(nodeIDs, hexPathNodeID(path[position:limit])) + } + return chunkIDs, nodeIDs +} + +// splitPathLast returns the path prefix of the deepest chunk spanned by the +// given path, along with its corresponding internal node ID. If the path +// spans no chunks, it returns an empty prefix and 0. +// +// nolint:unused +func (s *indexScheme) splitPathLast(path string) (string, uint16) { + chunkIDs, nodeIDs := s.splitPath(path) + if len(chunkIDs) == 0 { + return "", 0 + } + n := len(chunkIDs) + return chunkIDs[n-1], nodeIDs[n-1] +} + +// encodeIDs sorts the given list of uint16 IDs and encodes them into a +// compact byte slice using variable-length unsigned integer encoding. +func encodeIDs(ids []uint16) []byte { + slices.Sort(ids) + buf := make([]byte, 0, len(ids)) + for _, id := range ids { + buf = binary.AppendUvarint(buf, uint64(id)) + } + return buf +} + +// decodeIDs decodes a sequence of variable-length encoded uint16 IDs from the +// given byte slice and returns them as a set. +// +// Returns an error if the input buffer does not contain a complete Uvarint value. +func decodeIDs(buf []byte) ([]uint16, error) { + var res []uint16 + for len(buf) > 0 { + id, n := binary.Uvarint(buf) + if n <= 0 { + return nil, fmt.Errorf("too short for decoding node id, %v", buf) + } + buf = buf[n:] + res = append(res, uint16(id)) + } + return res, nil +} + +// isAncestor reports whether node x is the ancestor of node y. +func isAncestor(x, y uint16) bool { + for y > x { + y = (y - 1) / 16 // parentID(y) = (y - 1) / 16 + if y == x { + return true + } + } + return false +} + +// isBitSet reports whether the bit at `index` in the byte slice `b` is set. +func isBitSet(b []byte, index int) bool { + return b[index/8]&(1<<(7-index%8)) != 0 +} + +// setBit sets the bit at `index` in the byte slice `b` to 1. +func setBit(b []byte, index int) { + b[index/8] |= 1 << (7 - index%8) +} + +// bitPosTwoBytes returns the positions of set bits in a 2-byte bitmap. +// +// The bitmap is interpreted as a big-endian uint16. Bit positions are +// numbered from 0 to 15, where position 0 corresponds to the most +// significant bit of b[0], and position 15 corresponds to the least +// significant bit of b[1]. +func bitPosTwoBytes(b []byte) []int { + if len(b) != 2 { + panic("expect 2 bytes") + } + var ( + pos []int + mask = binary.BigEndian.Uint16(b) + ) + for mask != 0 { + p := bits.LeadingZeros16(mask) + pos = append(pos, p) + mask &^= 1 << (15 - p) + } + return pos +} diff --git a/triedb/pathdb/history_trienode_utils_test.go b/triedb/pathdb/history_trienode_utils_test.go new file mode 100644 index 000000000000..32bd91166d04 --- /dev/null +++ b/triedb/pathdb/history_trienode_utils_test.go @@ -0,0 +1,584 @@ +// Copyright 2025 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package pathdb + +import ( + "bytes" + "reflect" + "testing" +) + +func TestHexPathNodeID(t *testing.T) { + t.Parallel() + + var suites = []struct { + input string + exp uint16 + }{ + { + input: "", + exp: 0, + }, + { + input: string([]byte{0x0}), + exp: 1, + }, + { + input: string([]byte{0xf}), + exp: 16, + }, + { + input: string([]byte{0x0, 0x0}), + exp: 17, + }, + { + input: string([]byte{0x0, 0xf}), + exp: 32, + }, + { + input: string([]byte{0x1, 0x0}), + exp: 33, + }, + { + input: string([]byte{0x1, 0xf}), + exp: 48, + }, + { + input: string([]byte{0xf, 0xf}), + exp: 272, + }, + { + input: string([]byte{0xf, 0xf, 0xf}), + exp: 4368, + }, + } + for _, suite := range suites { + got := hexPathNodeID(suite.input) + if got != suite.exp { + t.Fatalf("Unexpected node ID for %v: got %d, want %d", suite.input, got, suite.exp) + } + } +} + +func TestFindLeafPaths(t *testing.T) { + t.Parallel() + + tests := []struct { + input []string + expect []string + }{ + { + input: nil, + expect: nil, + }, + { + input: []string{"a"}, + expect: []string{"a"}, + }, + { + input: []string{"", "0", "00", "01", "1"}, + expect: []string{ + "00", + "01", + "1", + }, + }, + { + input: []string{"10", "100", "11", "2"}, + expect: []string{ + "100", + "11", + "2", + }, + }, + { + input: []string{"10", "100000000", "11", "111111111", "2"}, + expect: []string{ + "100000000", + "111111111", + "2", + }, + }, + } + for _, test := range tests { + res := findLeafPaths(test.input) + if !reflect.DeepEqual(res, test.expect) { + t.Fatalf("Unexpected result: %v, expected %v", res, test.expect) + } + } +} + +func TestSplitAccountPath(t *testing.T) { + t.Parallel() + + var suites = []struct { + input string + expPrefix []string + expID []uint16 + }{ + // Length = 0 + { + "", nil, nil, + }, + // Length = 1 + { + string([]byte{0x0}), + []string{ + string([]byte{0x0}), + }, + []uint16{ + 0, + }, + }, + { + string([]byte{0x1}), + []string{ + string([]byte{0x1}), + }, + []uint16{ + 0, + }, + }, + { + string([]byte{0xf}), + []string{ + string([]byte{0xf}), + }, + []uint16{ + 0, + }, + }, + // Length = 2 + { + string([]byte{0x0, 0x0}), + []string{ + string([]byte{0x0}), + }, + []uint16{ + 1, + }, + }, + { + string([]byte{0x0, 0x1}), + []string{ + string([]byte{0x0}), + }, + []uint16{ + 2, + }, + }, + { + string([]byte{0x0, 0xf}), + []string{ + string([]byte{0x0}), + }, + []uint16{ + 16, + }, + }, + { + string([]byte{0xf, 0xf}), + []string{ + string([]byte{0xf}), + }, + []uint16{ + 16, + }, + }, + // Length = 3 + { + string([]byte{0x0, 0x0, 0x0}), + []string{ + string([]byte{0x0}), + string([]byte{0x0, 0x0, 0x0}), + }, + []uint16{ + 1, 0, + }, + }, + // Length = 3 + { + string([]byte{0xf, 0xf, 0xf}), + []string{ + string([]byte{0xf}), + string([]byte{0xf, 0xf, 0xf}), + }, + []uint16{ + 16, 0, + }, + }, + // Length = 4 + { + string([]byte{0x0, 0x0, 0x0, 0x0}), + []string{ + string([]byte{0x0}), + string([]byte{0x0, 0x0, 0x0}), + }, + []uint16{ + 1, 1, + }, + }, + { + string([]byte{0xf, 0xf, 0xf, 0xf}), + []string{ + string([]byte{0xf}), + string([]byte{0xf, 0xf, 0xf}), + }, + []uint16{ + 16, 16, + }, + }, + // Length = 5 + { + string([]byte{0x0, 0x0, 0x0, 0x0, 0x0}), + []string{ + string([]byte{0x0}), + string([]byte{0x0, 0x0, 0x0}), + }, + []uint16{ + 1, 17, + }, + }, + { + string([]byte{0xf, 0xf, 0xf, 0xf, 0xf}), + []string{ + string([]byte{0xf}), + string([]byte{0xf, 0xf, 0xf}), + }, + []uint16{ + 16, 272, + }, + }, + // Length = 6 + { + string([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0}), + []string{ + string([]byte{0x0}), + string([]byte{0x0, 0x0, 0x0}), + string([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0}), + }, + []uint16{ + 1, 17, 0, + }, + }, + { + string([]byte{0xf, 0xf, 0xf, 0xf, 0xf, 0xf}), + []string{ + string([]byte{0xf}), + string([]byte{0xf, 0xf, 0xf}), + string([]byte{0xf, 0xf, 0xf, 0xf, 0xf, 0xf}), + }, + []uint16{ + 16, 272, 0, + }, + }, + } + for _, suite := range suites { + prefix, id := accountIndexScheme.splitPath(suite.input) + if !reflect.DeepEqual(prefix, suite.expPrefix) { + t.Fatalf("Unexpected prefix for %v: got %v, want %v", suite.input, prefix, suite.expPrefix) + } + if !reflect.DeepEqual(id, suite.expID) { + t.Fatalf("Unexpected ID for %v: got %v, want %v", suite.input, id, suite.expID) + } + } +} + +func TestSplitStoragePath(t *testing.T) { + t.Parallel() + + var suites = []struct { + input string + expPrefix []string + expID []uint16 + }{ + // Length = 0 + { + "", + []string{ + string([]byte{}), + }, + []uint16{ + 0, + }, + }, + // Length = 1 + { + string([]byte{0x0}), + []string{ + string([]byte{}), + }, + []uint16{ + 1, + }, + }, + { + string([]byte{0x1}), + []string{ + string([]byte{}), + }, + []uint16{ + 2, + }, + }, + { + string([]byte{0xf}), + []string{ + string([]byte{}), + }, + []uint16{ + 16, + }, + }, + // Length = 2 + { + string([]byte{0x0, 0x0}), + []string{ + string([]byte{}), + }, + []uint16{ + 17, + }, + }, + { + string([]byte{0x0, 0x1}), + []string{ + string([]byte{}), + }, + []uint16{ + 18, + }, + }, + { + string([]byte{0x0, 0xf}), + []string{ + string([]byte{}), + }, + []uint16{ + 32, + }, + }, + { + string([]byte{0xf, 0xf}), + []string{ + string([]byte{}), + }, + []uint16{ + 272, + }, + }, + // Length = 3 + { + string([]byte{0x0, 0x0, 0x0}), + []string{ + string([]byte{}), + string([]byte{0x0, 0x0, 0x0}), + }, + []uint16{ + 17, 0, + }, + }, + // Length = 3 + { + string([]byte{0xf, 0xf, 0xf}), + []string{ + string([]byte{}), + string([]byte{0xf, 0xf, 0xf}), + }, + []uint16{ + 272, 0, + }, + }, + // Length = 4 + { + string([]byte{0x0, 0x0, 0x0, 0x0}), + []string{ + string([]byte{}), + string([]byte{0x0, 0x0, 0x0}), + }, + []uint16{ + 17, 1, + }, + }, + { + string([]byte{0xf, 0xf, 0xf, 0xf}), + []string{ + string([]byte{}), + string([]byte{0xf, 0xf, 0xf}), + }, + []uint16{ + 272, 16, + }, + }, + // Length = 5 + { + string([]byte{0x0, 0x0, 0x0, 0x0, 0x0}), + []string{ + string([]byte{}), + string([]byte{0x0, 0x0, 0x0}), + }, + []uint16{ + 17, 17, + }, + }, + { + string([]byte{0xf, 0xf, 0xf, 0xf, 0xf}), + []string{ + string([]byte{}), + string([]byte{0xf, 0xf, 0xf}), + }, + []uint16{ + 272, 272, + }, + }, + // Length = 6 + { + string([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0}), + []string{ + string([]byte{}), + string([]byte{0x0, 0x0, 0x0}), + string([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0}), + }, + []uint16{ + 17, 17, 0, + }, + }, + { + string([]byte{0xf, 0xf, 0xf, 0xf, 0xf, 0xf}), + []string{ + string([]byte{}), + string([]byte{0xf, 0xf, 0xf}), + string([]byte{0xf, 0xf, 0xf, 0xf, 0xf, 0xf}), + }, + []uint16{ + 272, 272, 0, + }, + }, + } + for i, suite := range suites { + prefix, id := storageIndexScheme.splitPath(suite.input) + if !reflect.DeepEqual(prefix, suite.expPrefix) { + t.Fatalf("Test %d, unexpected prefix for %v: got %v, want %v", i, suite.input, prefix, suite.expPrefix) + } + if !reflect.DeepEqual(id, suite.expID) { + t.Fatalf("Test %d, unexpected ID for %v: got %v, want %v", i, suite.input, id, suite.expID) + } + } +} + +func TestIsAncestor(t *testing.T) { + suites := []struct { + x, y uint16 + want bool + }{ + {0, 1, true}, + {0, 16, true}, + {0, 17, true}, + {0, 272, true}, + + {1, 0, false}, + {1, 2, false}, + {1, 17, true}, + {1, 18, true}, + {17, 273, true}, + {1, 1, false}, + } + for _, tc := range suites { + result := isAncestor(tc.x, tc.y) + if result != tc.want { + t.Fatalf("isAncestor(%d, %d) = %v, want %v", tc.x, tc.y, result, tc.want) + } + } +} + +func TestBitmapSet(t *testing.T) { + suites := []struct { + index int + expect []byte + }{ + { + 0, []byte{0b10000000, 0x0}, + }, + { + 1, []byte{0b01000000, 0x0}, + }, + { + 7, []byte{0b00000001, 0x0}, + }, + { + 8, []byte{0b00000000, 0b10000000}, + }, + { + 15, []byte{0b00000000, 0b00000001}, + }, + } + for _, tc := range suites { + var buf [2]byte + setBit(buf[:], tc.index) + + if !bytes.Equal(buf[:], tc.expect) { + t.Fatalf("bitmap = %v, want %v", buf, tc.expect) + } + if !isBitSet(buf[:], tc.index) { + t.Fatal("bit is not set") + } + } +} + +func TestBitPositions(t *testing.T) { + suites := []struct { + input []byte + expect []int + }{ + { + []byte{0b10000000, 0x0}, []int{0}, + }, + { + []byte{0b01000000, 0x0}, []int{1}, + }, + { + []byte{0b00000001, 0x0}, []int{7}, + }, + { + []byte{0b00000000, 0b10000000}, []int{8}, + }, + { + []byte{0b00000000, 0b00000001}, []int{15}, + }, + { + []byte{0b10000000, 0b00000001}, []int{0, 15}, + }, + { + []byte{0b10000001, 0b00000001}, []int{0, 7, 15}, + }, + { + []byte{0b10000001, 0b10000001}, []int{0, 7, 8, 15}, + }, + { + []byte{0b11111111, 0b11111111}, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, + }, + { + []byte{0x0, 0x0}, nil, + }, + } + for _, tc := range suites { + got := bitPosTwoBytes(tc.input) + if !reflect.DeepEqual(got, tc.expect) { + t.Fatalf("Unexpected position set, want: %v, got: %v", tc.expect, got) + } + } +} diff --git a/triedb/pathdb/iterator.go b/triedb/pathdb/iterator.go index 8ca824720663..2d333dfa1b01 100644 --- a/triedb/pathdb/iterator.go +++ b/triedb/pathdb/iterator.go @@ -24,48 +24,15 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/triedb/internal" ) -// Iterator is an iterator to step over all the accounts or the specific -// storage in a snapshot which may or may not be composed of multiple layers. -type Iterator interface { - // Next steps the iterator forward one element, returning false if exhausted, - // or an error if iteration failed for some reason (e.g. root being iterated - // becomes stale and garbage collected). - Next() bool - - // Error returns any failure that occurred during iteration, which might have - // caused a premature iteration exit (e.g. layer stack becoming stale). - Error() error - - // Hash returns the hash of the account or storage slot the iterator is - // currently at. - Hash() common.Hash - - // Release releases associated resources. Release should always succeed and - // can be called multiple times without causing error. - Release() -} - -// AccountIterator is an iterator to step over all the accounts in a snapshot, -// which may or may not be composed of multiple layers. -type AccountIterator interface { - Iterator - - // Account returns the RLP encoded slim account the iterator is currently at. - // An error will be returned if the iterator becomes invalid - Account() []byte -} - -// StorageIterator is an iterator to step over the specific storage in a snapshot, -// which may or may not be composed of multiple layers. -type StorageIterator interface { - Iterator - - // Slot returns the storage slot the iterator is currently at. An error will - // be returned if the iterator becomes invalid - Slot() []byte -} +// Type aliases for the iterator interfaces defined in triedb/internal. +type ( + Iterator = internal.Iterator + AccountIterator = internal.AccountIterator + StorageIterator = internal.StorageIterator +) type ( // loadAccount is the function to retrieve the account from the associated diff --git a/triedb/pathdb/iterator_test.go b/triedb/pathdb/iterator_test.go index adb534f47d16..191c2fadf593 100644 --- a/triedb/pathdb/iterator_test.go +++ b/triedb/pathdb/iterator_test.go @@ -369,7 +369,7 @@ func TestAccountIteratorTraversalValues(t *testing.T) { if i%8 == 0 { e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i) } - if i > 50 || i < 85 { + if i > 50 && i < 85 { f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i) } if i%64 == 0 { @@ -489,7 +489,7 @@ func TestStorageIteratorTraversalValues(t *testing.T) { if i%8 == 0 { e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i) } - if i > 50 || i < 85 { + if i > 50 && i < 85 { f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i) } if i%64 == 0 { diff --git a/triedb/pathdb/journal.go b/triedb/pathdb/journal.go index 02bdef5d34fa..657fbbff2734 100644 --- a/triedb/pathdb/journal.go +++ b/triedb/pathdb/journal.go @@ -161,7 +161,19 @@ func loadGenerator(db ethdb.KeyValueReader, hash nodeHasher) (*journalGenerator, // loadLayers loads a pre-existing state layer backed by a key-value store. func (db *Database) loadLayers() layer { // Retrieve the root node of persistent state. - root, err := db.hasher(rawdb.ReadAccountTrieNode(db.diskdb, nil)) + var ( + root common.Hash + err error + ) + if db.isUBT { + root = rawdb.ReadSnapshotRoot(db.diskdb) + if root == (common.Hash{}) { + root = types.EmptyBinaryHash + } + } else { + blob := rawdb.ReadAccountTrieNode(db.diskdb, nil) + root, err = db.hasher(blob) + } if err != nil { log.Crit("Failed to compute node hash", "err", err) } @@ -338,10 +350,8 @@ func (db *Database) Journal(root common.Hash) error { // but the ancient store is not properly closed, resulting in recent writes // being lost. After a restart, the ancient store would then be misaligned // with the disk layer, causing data corruption. - if db.stateFreezer != nil { - if err := db.stateFreezer.SyncAncient(); err != nil { - return err - } + if err := syncHistory(db.stateFreezer, db.trienodeFreezer); err != nil { + return err } // Store the journal into the database and return var ( diff --git a/triedb/pathdb/layertree.go b/triedb/pathdb/layertree.go index ec45257db56c..b20e40bd0516 100644 --- a/triedb/pathdb/layertree.go +++ b/triedb/pathdb/layertree.go @@ -151,6 +151,15 @@ func (tree *layerTree) add(root common.Hash, parentRoot common.Hash, block uint6 if root == parentRoot { return errors.New("layer cycle") } + // If a layer with this root already exists, skip the insertion. Fork blocks + // can produce the same state root as the canonical block (same parent, same + // coinbase, zero txs); overwriting tree.layers[root] would corrupt the parent + // chain for any child layers already built on top of the existing one, and + // appending a duplicate root to the lookup indices causes accountTip/storageTip + // to resolve the wrong layer. + if tree.get(root) != nil { + return nil + } parent := tree.get(parentRoot) if parent == nil { return fmt.Errorf("triedb parent [%#x] layer missing", parentRoot) @@ -310,8 +319,8 @@ func (tree *layerTree) lookupAccount(accountHash common.Hash, state common.Hash) tree.lock.RLock() defer tree.lock.RUnlock() - tip := tree.lookup.accountTip(accountHash, state, tree.base.root) - if tip == (common.Hash{}) { + tip, ok := tree.lookup.accountTip(accountHash, state, tree.base.root) + if !ok { return nil, fmt.Errorf("[%#x] %w", state, errSnapshotStale) } l := tree.layers[tip] @@ -328,8 +337,8 @@ func (tree *layerTree) lookupStorage(accountHash common.Hash, slotHash common.Ha tree.lock.RLock() defer tree.lock.RUnlock() - tip := tree.lookup.storageTip(accountHash, slotHash, state, tree.base.root) - if tip == (common.Hash{}) { + tip, ok := tree.lookup.storageTip(accountHash, slotHash, state, tree.base.root) + if !ok { return nil, fmt.Errorf("[%#x] %w", state, errSnapshotStale) } l := tree.layers[tip] diff --git a/triedb/pathdb/layertree_test.go b/triedb/pathdb/layertree_test.go index a74c6eb045f6..0dcfd7aae8d2 100644 --- a/triedb/pathdb/layertree_test.go +++ b/triedb/pathdb/layertree_test.go @@ -55,9 +55,9 @@ func TestLayerCap(t *testing.T) { layers: 2, base: common.Hash{0x2}, snapshot: map[common.Hash]struct{}{ - common.Hash{0x2}: {}, - common.Hash{0x3}: {}, - common.Hash{0x4}: {}, + {0x2}: {}, + {0x3}: {}, + {0x4}: {}, }, }, { @@ -76,8 +76,8 @@ func TestLayerCap(t *testing.T) { layers: 1, base: common.Hash{0x3}, snapshot: map[common.Hash]struct{}{ - common.Hash{0x3}: {}, - common.Hash{0x4}: {}, + {0x3}: {}, + {0x4}: {}, }, }, { @@ -96,7 +96,7 @@ func TestLayerCap(t *testing.T) { layers: 0, base: common.Hash{0x4}, snapshot: map[common.Hash]struct{}{ - common.Hash{0x4}: {}, + {0x4}: {}, }, }, { @@ -119,9 +119,9 @@ func TestLayerCap(t *testing.T) { layers: 2, base: common.Hash{0x2a}, snapshot: map[common.Hash]struct{}{ - common.Hash{0x4a}: {}, - common.Hash{0x3a}: {}, - common.Hash{0x2a}: {}, + {0x4a}: {}, + {0x3a}: {}, + {0x2a}: {}, }, }, { @@ -144,8 +144,8 @@ func TestLayerCap(t *testing.T) { layers: 1, base: common.Hash{0x3a}, snapshot: map[common.Hash]struct{}{ - common.Hash{0x4a}: {}, - common.Hash{0x3a}: {}, + {0x4a}: {}, + {0x3a}: {}, }, }, { @@ -168,11 +168,11 @@ func TestLayerCap(t *testing.T) { layers: 2, base: common.Hash{0x2}, snapshot: map[common.Hash]struct{}{ - common.Hash{0x4a}: {}, - common.Hash{0x3a}: {}, - common.Hash{0x4b}: {}, - common.Hash{0x3b}: {}, - common.Hash{0x2}: {}, + {0x4a}: {}, + {0x3a}: {}, + {0x4b}: {}, + {0x3b}: {}, + {0x2}: {}, }, }, } @@ -261,7 +261,7 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2}: {}, }, }, @@ -271,11 +271,11 @@ func TestDescendant(t *testing.T) { tr.add(common.Hash{0x3}, common.Hash{0x2}, 2, NewNodeSetWithOrigin(nil, nil), NewStateSetWithOrigin(nil, nil, nil, nil, false)) }, snapshotB: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2}: {}, common.Hash{0x3}: {}, }, - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3}: {}, }, }, @@ -291,16 +291,16 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2}: {}, common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x3}: { + {0x3}: { common.Hash{0x4}: {}, }, }, @@ -310,11 +310,11 @@ func TestDescendant(t *testing.T) { tr.cap(common.Hash{0x4}, 2) }, snapshotB: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x3}: { + {0x3}: { common.Hash{0x4}: {}, }, }, @@ -330,16 +330,16 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2}: {}, common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x3}: { + {0x3}: { common.Hash{0x4}: {}, }, }, @@ -349,7 +349,7 @@ func TestDescendant(t *testing.T) { tr.cap(common.Hash{0x4}, 1) }, snapshotB: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x3}: { + {0x3}: { common.Hash{0x4}: {}, }, }, @@ -365,16 +365,16 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2}: {}, common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3}: {}, common.Hash{0x4}: {}, }, - common.Hash{0x3}: { + {0x3}: { common.Hash{0x4}: {}, }, }, @@ -400,7 +400,7 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2a}: {}, common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, @@ -408,18 +408,18 @@ func TestDescendant(t *testing.T) { common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x2a}: { + {0x2a}: { common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, }, - common.Hash{0x3a}: { + {0x3a}: { common.Hash{0x4a}: {}, }, - common.Hash{0x2b}: { + {0x2b}: { common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x3b}: { + {0x3b}: { common.Hash{0x4b}: {}, }, }, @@ -429,11 +429,11 @@ func TestDescendant(t *testing.T) { tr.cap(common.Hash{0x4a}, 2) }, snapshotB: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x2a}: { + {0x2a}: { common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, }, - common.Hash{0x3a}: { + {0x3a}: { common.Hash{0x4a}: {}, }, }, @@ -453,7 +453,7 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2a}: {}, common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, @@ -461,18 +461,18 @@ func TestDescendant(t *testing.T) { common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x2a}: { + {0x2a}: { common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, }, - common.Hash{0x3a}: { + {0x3a}: { common.Hash{0x4a}: {}, }, - common.Hash{0x2b}: { + {0x2b}: { common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x3b}: { + {0x3b}: { common.Hash{0x4b}: {}, }, }, @@ -482,7 +482,7 @@ func TestDescendant(t *testing.T) { tr.cap(common.Hash{0x4a}, 1) }, snapshotB: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x3a}: { + {0x3a}: { common.Hash{0x4a}: {}, }, }, @@ -501,23 +501,23 @@ func TestDescendant(t *testing.T) { return tr }, snapshotA: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x1}: { + {0x1}: { common.Hash{0x2}: {}, common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x3a}: { + {0x3a}: { common.Hash{0x4a}: {}, }, - common.Hash{0x3b}: { + {0x3b}: { common.Hash{0x4b}: {}, }, }, @@ -528,16 +528,16 @@ func TestDescendant(t *testing.T) { tr.cap(common.Hash{0x4a}, 2) }, snapshotB: map[common.Hash]map[common.Hash]struct{}{ - common.Hash{0x2}: { + {0x2}: { common.Hash{0x3a}: {}, common.Hash{0x4a}: {}, common.Hash{0x3b}: {}, common.Hash{0x4b}: {}, }, - common.Hash{0x3a}: { + {0x3a}: { common.Hash{0x4a}: {}, }, - common.Hash{0x3b}: { + {0x3b}: { common.Hash{0x4b}: {}, }, }, @@ -575,6 +575,40 @@ func TestDescendant(t *testing.T) { } } +func TestDuplicateRootLookup(t *testing.T) { + // Chain: + // C1->C2->C3 (HEAD) + tr := newTestLayerTree() // base = 0x1 + tr.add(common.Hash{0x2}, common.Hash{0x1}, 1, NewNodeSetWithOrigin(nil, nil), + NewStateSetWithOrigin(randomAccountSet("0xa"), randomStorageSet([]string{"0xa"}, [][]string{{"0x1"}}, nil), nil, nil, false)) + tr.add(common.Hash{0x3}, common.Hash{0x2}, 2, NewNodeSetWithOrigin(nil, nil), + NewStateSetWithOrigin(randomAccountSet("0xa"), randomStorageSet([]string{"0xa"}, [][]string{{"0x1"}}, nil), nil, nil, false)) + + // A fork block with the same state root as C2; inserting it must not + // pollute the lookup history for the canonical descendant C3. + tr.add(common.Hash{0x2}, common.Hash{0x1}, 1, NewNodeSetWithOrigin(nil, nil), + NewStateSetWithOrigin(randomAccountSet("0xa"), randomStorageSet([]string{"0xa"}, [][]string{{"0x1"}}, nil), nil, nil, false)) + if n := tr.len(); n != 3 { + t.Fatalf("duplicate root insert changed layer count, got %d, want 3", n) + } + + l, err := tr.lookupAccount(common.HexToHash("0xa"), common.Hash{0x3}) + if err != nil { + t.Fatalf("account lookup failed: %v", err) + } + if l.rootHash() != (common.Hash{0x3}) { + t.Errorf("unexpected account tip, want %x, got %x", common.Hash{0x3}, l.rootHash()) + } + + l, err = tr.lookupStorage(common.HexToHash("0xa"), common.HexToHash("0x1"), common.Hash{0x3}) + if err != nil { + t.Fatalf("storage lookup failed: %v", err) + } + if l.rootHash() != (common.Hash{0x3}) { + t.Errorf("unexpected storage tip, want %x, got %x", common.Hash{0x3}, l.rootHash()) + } +} + func TestAccountLookup(t *testing.T) { // Chain: // C1->C2->C3->C4 (HEAD) @@ -882,3 +916,118 @@ func TestStorageLookup(t *testing.T) { } } } + +// TestLookupZeroBaseRootFallback is a regression test for a sentinel +// collision in accountTip/storageTip: before the fix they returned +// common.Hash{} as both the "stale" marker and the disk-layer fallback +// when the disk root itself happened to be zero. lookupAccount/Storage +// then misreported a legitimate fallback as errSnapshotStale. +// +// On the merkle path the collision was invisible because the empty +// merkle trie hashes to types.EmptyRootHash (a concrete non-zero +// keccak), so the disk layer's root was never the zero hash in +// practice. The bug only surfaces once the disk layer root can +// legitimately be zero (for example a fresh verkle/bintrie database +// where the empty binary trie hashes to EmptyVerkleHash == +// common.Hash{}). +// +// The test constructs a layer tree whose base layer's root IS the zero +// hash, stacks diff layers on top, and exercises four cases: +// +// 1. Look up an account NEVER written → should fall through to the +// disk layer and return (diskLayer, nil). Before the fix this +// returned errSnapshotStale because the fallback hash collided +// with the sentinel. +// 2. Symmetric case for lookupStorage. +// 3. Look up an account written in a diff layer → should return that +// diff layer (the normal happy path is unaffected by the fix). +// 4. Look up any key at a state root that isn't part of the tree +// (neither the disk root nor a descendant of it) → MUST still +// return errSnapshotStale. This pins the "other half" of the +// contract so a future refactor that always returns ok=true would +// fail here. +func TestLookupZeroBaseRootFallback(t *testing.T) { + // Build a layer tree whose disk-layer root is common.Hash{} — + // mirrors the bintrie/verkle configuration where the empty trie + // hashes to EmptyVerkleHash. newTestLayerTree can't be reused + // because it hard-codes common.Hash{0x1}. + db := New(rawdb.NewMemoryDatabase(), nil, false) + base := newDiskLayer(common.Hash{}, 0, db, nil, nil, newBuffer(0, nil, nil, 0), nil) + tr := newLayerTree(base) + + // Stack two diff layers on the zero-rooted disk layer, each + // touching a known account and slot so we have something for the + // happy-path lookups to find later. + if err := tr.add( + common.Hash{0x2}, common.Hash{}, + 1, + NewNodeSetWithOrigin(nil, nil), + NewStateSetWithOrigin( + randomAccountSet("0xa"), + randomStorageSet([]string{"0xa"}, [][]string{{"0x1"}}, nil), + nil, nil, false), + ); err != nil { + t.Fatalf("add first diff layer: %v", err) + } + if err := tr.add( + common.Hash{0x3}, common.Hash{0x2}, + 2, + NewNodeSetWithOrigin(nil, nil), + NewStateSetWithOrigin( + randomAccountSet("0xb"), + nil, nil, nil, false), + ); err != nil { + t.Fatalf("add second diff layer: %v", err) + } + + // Case 1: unknown account queried at the head. The lookup must + // fall through the diff layers, hit the disk-layer fallback at + // base=common.Hash{}, and return the disk layer with no error — + // NOT errSnapshotStale. + l, err := tr.lookupAccount(common.HexToHash("0xdead"), common.Hash{0x3}) + if err != nil { + t.Fatalf("lookupAccount on zero-base disk layer: unexpected error %v", err) + } + if l.rootHash() != (common.Hash{}) { + t.Errorf("expected fall-through to disk layer (root=0), got %x", l.rootHash()) + } + + // Case 2: symmetric check for storage. Slot 0x99 was never written, + // so the lookup must fall through to the disk layer just like + // Case 1. + l, err = tr.lookupStorage( + common.HexToHash("0xdead"), common.HexToHash("0x99"), common.Hash{0x3}) + if err != nil { + t.Fatalf("lookupStorage on zero-base disk layer: unexpected error %v", err) + } + if l.rootHash() != (common.Hash{}) { + t.Errorf("expected fall-through to disk layer (root=0), got %x", l.rootHash()) + } + + // Case 3: happy path. Account 0xa was written at diff layer 0x2. + // The lookup must return that layer, proving the fix didn't break + // the normal resolution path. + l, err = tr.lookupAccount(common.HexToHash("0xa"), common.Hash{0x3}) + if err != nil { + t.Fatalf("lookupAccount(known): %v", err) + } + if l.rootHash() != (common.Hash{0x2}) { + t.Errorf("known account tip: want %x, got %x", + common.Hash{0x2}, l.rootHash()) + } + + // Case 4: truly stale state root. This pins the other half of the + // contract — the boolean must actually signal not-found for an + // unknown state, otherwise a refactor that always returned + // ok=true would still pass cases 1–3. + _, err = tr.lookupAccount(common.HexToHash("0xa"), common.HexToHash("0xdeadbeef")) + if !errors.Is(err, errSnapshotStale) { + t.Errorf("lookupAccount(stale state): want errSnapshotStale, got %v", err) + } + _, err = tr.lookupStorage( + common.HexToHash("0xa"), common.HexToHash("0x1"), + common.HexToHash("0xdeadbeef")) + if !errors.Is(err, errSnapshotStale) { + t.Errorf("lookupStorage(stale state): want errSnapshotStale, got %v", err) + } +} diff --git a/triedb/pathdb/lookup.go b/triedb/pathdb/lookup.go index 8b092730f8fc..9b300ec87152 100644 --- a/triedb/pathdb/lookup.go +++ b/triedb/pathdb/lookup.go @@ -33,6 +33,13 @@ func storageKey(accountHash common.Hash, slotHash common.Hash) [64]byte { return key } +// storageKeySlice returns a key for uniquely identifying the storage slot in +// the slice format. +func storageKeySlice(accountHash common.Hash, slotHash common.Hash) []byte { + key := storageKey(accountHash, slotHash) + return key[:] +} + // lookup is an internal structure used to efficiently determine the layer in // which a state entry resides. type lookup struct { @@ -85,12 +92,16 @@ func newLookup(head layer, descendant func(state common.Hash, ancestor common.Ha // stateID or is a descendant of it. // // If found, the account data corresponding to the supplied stateID resides -// in that layer. Otherwise, two scenarios are possible: +// in the layer identified by the returned hash (ok=true). Otherwise, +// (common.Hash{}, false) is returned to signal that the supplied stateID is +// stale. // -// (a) the account remains unmodified from the current disk layer up to the state -// layer specified by the stateID: fallback to the disk layer for data retrieval, -// (b) or the layer specified by the stateID is stale: reject the data retrieval. -func (l *lookup) accountTip(accountHash common.Hash, stateID common.Hash, base common.Hash) common.Hash { +// Note the returned hash may itself be common.Hash{} when the disk layer's +// root is zero — as is the case for a fresh verkle/bintrie database whose +// empty trie hashes to EmptyVerkleHash. Callers must therefore consult the +// boolean rather than comparing the returned hash against common.Hash{} +// directly. +func (l *lookup) accountTip(accountHash common.Hash, stateID common.Hash, base common.Hash) (common.Hash, bool) { // Traverse the mutation history from latest to oldest one. Several // scenarios are possible: // @@ -116,31 +127,26 @@ func (l *lookup) accountTip(accountHash common.Hash, stateID common.Hash, base c // containing the modified data. Otherwise, the current state may be ahead // of the requested one or belong to a different branch. if list[i] == stateID || l.descendant(stateID, list[i]) { - return list[i] + return list[i], true } } // No layer matching the stateID or its descendants was found. Use the // current disk layer as a fallback. if base == stateID || l.descendant(stateID, base) { - return base + return base, true } // The layer associated with 'stateID' is not the descendant of the current // disk layer, it's already stale, return nothing. - return common.Hash{} + return common.Hash{}, false } // storageTip traverses the layer list associated with the given account and // slot hash in reverse order to locate the first entry that either matches // the specified stateID or is a descendant of it. // -// If found, the storage data corresponding to the supplied stateID resides -// in that layer. Otherwise, two scenarios are possible: -// -// (a) the storage slot remains unmodified from the current disk layer up to -// the state layer specified by the stateID: fallback to the disk layer for -// data retrieval, (b) or the layer specified by the stateID is stale: reject -// the data retrieval. -func (l *lookup) storageTip(accountHash common.Hash, slotHash common.Hash, stateID common.Hash, base common.Hash) common.Hash { +// See accountTip for the returned-hash / ok convention — the same +// bintrie-zero-root caveat applies here. +func (l *lookup) storageTip(accountHash common.Hash, slotHash common.Hash, stateID common.Hash, base common.Hash) (common.Hash, bool) { list := l.storages[storageKey(accountHash, slotHash)] for i := len(list) - 1; i >= 0; i-- { // If the current state matches the stateID, or the requested state is a @@ -148,17 +154,17 @@ func (l *lookup) storageTip(accountHash common.Hash, slotHash common.Hash, state // containing the modified data. Otherwise, the current state may be ahead // of the requested one or belong to a different branch. if list[i] == stateID || l.descendant(stateID, list[i]) { - return list[i] + return list[i], true } } // No layer matching the stateID or its descendants was found. Use the // current disk layer as a fallback. if base == stateID || l.descendant(stateID, base) { - return base + return base, true } // The layer associated with 'stateID' is not the descendant of the current // disk layer, it's already stale, return nothing. - return common.Hash{} + return common.Hash{}, false } // addLayer traverses the state data retained in the specified diff layer and diff --git a/triedb/pathdb/metrics.go b/triedb/pathdb/metrics.go index 31c40053fc26..e01dfdfb861e 100644 --- a/triedb/pathdb/metrics.go +++ b/triedb/pathdb/metrics.go @@ -73,23 +73,23 @@ var ( stateHistoryDataBytesMeter = metrics.NewRegisteredMeter("pathdb/history/state/bytes/data", nil) stateHistoryIndexBytesMeter = metrics.NewRegisteredMeter("pathdb/history/state/bytes/index", nil) - //nolint:unused - trienodeHistoryBuildTimeMeter = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/time", nil) - //nolint:unused - trienodeHistoryDataBytesMeter = metrics.NewRegisteredMeter("pathdb/history/trienode/bytes/data", nil) - //nolint:unused + trienodeHistoryBuildTimeMeter = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/time", nil) + trienodeHistoryDataBytesMeter = metrics.NewRegisteredMeter("pathdb/history/trienode/bytes/data", nil) trienodeHistoryIndexBytesMeter = metrics.NewRegisteredMeter("pathdb/history/trienode/bytes/index", nil) - stateIndexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/state/index/time", nil) - stateUnindexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/state/unindex/time", nil) - trienodeIndexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/index/time", nil) - trienodeUnindexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/unindex/time", nil) + stateIndexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/state/index/time", nil) + stateUnindexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/state/unindex/time", nil) + statePruneHistoryIndexTimer = metrics.NewRegisteredResettingTimer("pathdb/history/state/prune/time", nil) + trienodeIndexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/index/time", nil) + trienodeUnindexHistoryTimer = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/unindex/time", nil) + trienodePruneHistoryIndexTimer = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/prune/time", nil) lookupAddLayerTimer = metrics.NewRegisteredResettingTimer("pathdb/lookup/add/time", nil) lookupRemoveLayerTimer = metrics.NewRegisteredResettingTimer("pathdb/lookup/remove/time", nil) - historicalAccountReadTimer = metrics.NewRegisteredResettingTimer("pathdb/history/account/reads", nil) - historicalStorageReadTimer = metrics.NewRegisteredResettingTimer("pathdb/history/storage/reads", nil) + historicalAccountReadTimer = metrics.NewRegisteredResettingTimer("pathdb/history/account/reads", nil) + historicalStorageReadTimer = metrics.NewRegisteredResettingTimer("pathdb/history/storage/reads", nil) + historicalTrienodeReadTimer = metrics.NewRegisteredResettingTimer("pathdb/history/trienode/reads", nil) ) // Metrics in generation diff --git a/triedb/pathdb/nodes.go b/triedb/pathdb/nodes.go index c6f9e7aece35..62c72c1953ac 100644 --- a/triedb/pathdb/nodes.go +++ b/triedb/pathdb/nodes.go @@ -14,12 +14,14 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . +// nolint:unused package pathdb import ( "bytes" "errors" "fmt" + "hash/fnv" "io" "maps" @@ -30,6 +32,7 @@ import ( "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/trie" "github.com/ethereum/go-ethereum/trie/trienode" ) @@ -424,3 +427,265 @@ func (s *nodeSetWithOrigin) decode(r *rlp.Stream) error { s.computeSize() return nil } + +// encodeNodeCompressed encodes the trie node differences between two consecutive +// versions into byte stream. The format is as below: +// +// - metadata byte layout (1 byte): +// +// ┌──── Bits (from MSB to LSB) ───┐ +// │ 7 │ 6 │ 5 │ 4 │ 3 │ 2 │ 1 │ 0 │ +// └───────────────────────────────┘ +// │ │ │ │ │ │ │ └─ FlagA: set if value is encoded in compressed format +// │ │ │ │ │ │ └───── FlagB: set if no extended bitmap is present after the metadata byte +// │ │ │ │ │ └───────── FlagC: bitmap for node (only used when flagB == 1) +// │ │ │ │ └───────────── FlagD: bitmap for node (only used when flagB == 1) +// │ │ │ └───────────────── FlagE: reserved (marks the presence of the 16th child in a full node) +// │ │ └───────────────────── FlagF: reserved +// │ └───────────────────────── FlagG: reserved +// └───────────────────────────── FlagH: reserved +// +// Note: +// - If flagB is 1, the node refers to a shortNode; +// - flagC indicates whether the key of the shortNode is recorded. +// - flagD indicates whether the value of the shortNode is recorded. +// +// - If flagB is 0, the node refers to a fullNode; +// - each bit in extended bitmap indicates whether the corresponding +// child have been modified. +// +// Example: +// +// 0b_0000_1011 +// +// Bit0=1, Bit1=1 -> node in compressed format, no extended bitmap +// Bit2=0, Bit3=1 -> the key of a short node is not stored; its value is stored. +// +// - 2 bytes extended bitmap (only if the flagB in metadata is 0), each bit +// represents a corresponding child; +// +// - concatenation of original value of modified children along with its size; +func encodeNodeCompressed(addExtension bool, elements [][]byte, indices []int) []byte { + var ( + enc []byte + flag = byte(1) // The compression format indicator + ) + // Pre-allocate the byte slice for the node encoder + size := 1 + if addExtension { + size += 2 + } + for _, element := range elements { + size += len(element) + 1 + } + enc = make([]byte, 0, size) + + if !addExtension { + flag |= 2 // The embedded bitmap indicator + + // Embedded bitmap + for _, pos := range indices { + flag |= 1 << (pos + 2) + } + enc = append(enc, flag) + } else { + // Extended bitmap + bitmap := make([]byte, 2) // bitmaps for at most 16 children + for _, pos := range indices { + // Children[16] is only theoretically possible in the Merkle-Patricia-trie, + // in practice this field is never used in the Ethereum case. If it occurs, + // use the FlagE for marking the presence. + if pos >= 16 { + log.Warn("Unexpected 16th child encountered in a full node") + flag |= 1 << 4 // Use the reserved flagE + continue + } + setBit(bitmap, pos) + } + enc = append(enc, flag) + enc = append(enc, bitmap...) + } + for _, element := range elements { + enc = append(enc, byte(len(element))) // 1 byte is sufficient for element size + enc = append(enc, element...) + } + return enc +} + +// encodeNodeFull encodes the full trie node value into byte stream. The format is +// as below: +// +// - metadata byte layout (1 byte): 0b0 +// - node value +// +// TODO(rjl493456442) it's not allocation efficient, please improve it. +func encodeNodeFull(value []byte) []byte { + enc := make([]byte, len(value)+1) + copy(enc[1:], value) + return enc +} + +// decodeNodeCompressed decodes the byte stream of compressed trie node +// back to the original elements and their indices. +// +// It assumes the byte stream contains a compressed format node. +func decodeNodeCompressed(data []byte) ([][]byte, []int, error) { + if len(data) < 1 { + return nil, nil, errors.New("invalid data: too short") + } + flag := data[0] + if flag&byte(1) == 0 { + return nil, nil, errors.New("invalid data: full node value") + } + noExtend := flag&byte(2) != 0 + + // Reconstruct indices from bitmap + var indices []int + if noExtend { + if flag&byte(4) != 0 { // flagC + indices = append(indices, 0) + } + if flag&byte(8) != 0 { // flagD + indices = append(indices, 1) + } + data = data[1:] + } else { + if len(data) < 3 { + return nil, nil, errors.New("invalid data: too short") + } + bitmap := data[1:3] + indices = bitPosTwoBytes(bitmap) + if flag&byte(16) != 0 { // flagE + indices = append(indices, 16) + log.Info("Unexpected 16th child encountered in a full node") + } + data = data[3:] + } + // Reconstruct elements + elements := make([][]byte, 0, len(indices)) + for i := 0; i < len(indices); i++ { + if len(data) == 0 { + return nil, nil, errors.New("invalid data: missing size byte") + } + // Read element size + size := int(data[0]) + data = data[1:] + + // Check if we have enough data for the element + if len(data) < size { + return nil, nil, fmt.Errorf("invalid data: expected %d bytes, got %d", size, len(data)) + } + // Extract element + if size == 0 { + elements = append(elements, nil) + + // The zero-size element is practically unexpected, for node deletion + // the rlp.EmptyString is still expected. Log loudly for the potential + // programming error. + log.Error("Empty element from compressed node, please open an issue", "raw", data) + } else { + element := make([]byte, size) + copy(element, data[:size]) + data = data[size:] + elements = append(elements, element) + } + } + // Check if all data is consumed + if len(data) != 0 { + return nil, nil, errors.New("invalid data: trailing bytes") + } + return elements, indices, nil +} + +// decodeNodeFull decodes the byte stream of full value trie node. +func decodeNodeFull(data []byte) (bool, []byte, error) { + if len(data) < 1 { + return false, nil, errors.New("invalid data: too short") + } + flag := data[0] + if flag != byte(0) { + return false, nil, nil + } + return true, data[1:], nil +} + +// encodeNodeHistory encodes the history of a node. Typically, the original values +// of dirty nodes serve as the history, but this can lead to significant storage +// overhead. +// +// For full nodes, which often see only a few modified children during state +// transitions, recording the entire child set (up to 16 children at 32 bytes +// each) is inefficient. For short nodes, which often see only the value is +// modified during the state transition, recording the key part is also unnecessary. +// To compress size, we instead record the diff of the node, rather than the +// full value. It's vital to compress the overall trienode history. +// +// However, recovering a node from a series of diffs requires applying multiple +// history records, which is computationally and IO intensive. To mitigate this, we +// periodically record the full value of a node as a checkpoint. The frequency of +// these checkpoints is a tradeoff between the compression rate and read overhead. +func (s *nodeSetWithOrigin) encodeNodeHistory(root common.Hash, rate uint32) (map[common.Hash]map[string][]byte, error) { + var ( + // the set of all encoded node history elements + nodes = make(map[common.Hash]map[string][]byte) + + // encodeFullValue determines whether a node should be encoded + // in full format with a pseudo-random probabilistic algorithm. + encodeFullValue = func(owner common.Hash, path string) bool { + // For trie nodes at the first two levels of the account trie, it is very + // likely that all children are modified within a single state transition. + // In such cases, do not use diff mode. + if owner == (common.Hash{}) && len(path) < 2 { + return true + } + h := fnv.New32a() + h.Write(root.Bytes()) + h.Write(owner.Bytes()) + h.Write([]byte(path)) + return h.Sum32()%rate == 0 + } + ) + for owner, origins := range s.nodeOrigin { + var posts map[string]*trienode.Node + if owner == (common.Hash{}) { + posts = s.nodeSet.accountNodes + } else { + posts = s.nodeSet.storageNodes[owner] + } + nodes[owner] = make(map[string][]byte) + + for path, oldvalue := range origins { + n, exists := posts[path] + if !exists { + // something not expected + return nil, fmt.Errorf("node with origin is not found, %x-%v", owner, []byte(path)) + } + encodeFull := encodeFullValue(owner, path) + if !encodeFull { + // TODO(rjl493456442) the diff-mode reencoding can take non-trivial + // time, like 1-2ms per block, is there any way to mitigate the overhead? + + // Partial encoding is required, try to find the node diffs and + // fallback to the full-value encoding if fails. + // + // The partial encoding will be failed in these certain cases: + // - the node is deleted or was not-existent; + // - the node type has been changed (e.g, from short to full) + nElem, indices, diffs, err := trie.NodeDifference(oldvalue, n.Blob) + if err != nil { + encodeFull = true // fallback to the full node encoding + } else { + // Encode the node difference as the history element + addExt := nElem != 2 // fullNode + blob := encodeNodeCompressed(addExt, diffs, indices) + nodes[owner][path] = blob + } + } + if encodeFull { + // Encode the entire original value as the history element + nodes[owner][path] = encodeNodeFull(oldvalue) + } + } + } + return nodes, nil +} diff --git a/triedb/pathdb/nodes_test.go b/triedb/pathdb/nodes_test.go index 483dc4b1a612..131d0ab01253 100644 --- a/triedb/pathdb/nodes_test.go +++ b/triedb/pathdb/nodes_test.go @@ -18,11 +18,13 @@ package pathdb import ( "bytes" + "math/rand" "reflect" "testing" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/internal/testrand" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie/trienode" ) @@ -126,3 +128,49 @@ func TestNodeSetWithOriginEncode(t *testing.T) { t.Fatalf("Unexpected data size, got: %d, want: %d", dec2.size, s.size) } } + +func TestEncodeFullNodeCompressed(t *testing.T) { + var ( + elements [][]byte + indices []int + ) + for i := 0; i <= 16; i++ { + if rand.Intn(2) == 0 { + elements = append(elements, testrand.Bytes(20)) + indices = append(indices, i) + } + } + enc := encodeNodeCompressed(true, elements, indices) + decElements, decIndices, err := decodeNodeCompressed(enc) + if err != nil { + t.Fatalf("Failed to decode node compressed, %v", err) + } + if !reflect.DeepEqual(elements, decElements) { + t.Fatalf("Elements are not matched") + } + if !reflect.DeepEqual(indices, decIndices) { + t.Fatalf("Indices are not matched") + } +} + +func TestEncodeShortNodeCompressed(t *testing.T) { + var ( + elements [][]byte + indices []int + ) + for i := 0; i < 2; i++ { + elements = append(elements, testrand.Bytes(20)) + indices = append(indices, i) + } + enc := encodeNodeCompressed(false, elements, indices) + decElements, decIndices, err := decodeNodeCompressed(enc) + if err != nil { + t.Fatalf("Failed to decode node compressed, %v", err) + } + if !reflect.DeepEqual(elements, decElements) { + t.Fatalf("Elements are not matched") + } + if !reflect.DeepEqual(indices, decIndices) { + t.Fatalf("Indices are not matched") + } +} diff --git a/triedb/pathdb/reader.go b/triedb/pathdb/reader.go index 842ac0972e38..e087ef26edbd 100644 --- a/triedb/pathdb/reader.go +++ b/triedb/pathdb/reader.go @@ -47,7 +47,7 @@ type nodeLoc struct { } // string returns the string representation of node location. -func (loc *nodeLoc) string() string { +func (loc nodeLoc) string() string { return fmt.Sprintf("loc: %s, depth: %d", loc.loc, loc.depth) } @@ -177,7 +177,7 @@ func (db *Database) NodeReader(root common.Hash) (database.NodeReader, error) { return &reader{ db: db, state: root, - noHashCheck: db.isVerkle, + noHashCheck: db.isUBT, layer: layer, }, nil } @@ -200,7 +200,7 @@ func (db *Database) StateReader(root common.Hash) (database.StateReader, error) // historical state. type HistoricalStateReader struct { db *Database - reader *historyReader + reader *stateHistoryReader id uint64 } @@ -229,12 +229,12 @@ func (db *Database) HistoricReader(root common.Hash) (*HistoricalStateReader, er return nil, err // e.g., the referred state history has been pruned } if meta.parent != root { - return nil, fmt.Errorf("state %#x is not canonincal", root) + return nil, fmt.Errorf("state %#x is not canonical", root) } return &HistoricalStateReader{ id: *id, db: db, - reader: newHistoryReader(db.diskdb, db.stateFreezer), + reader: newStateHistoryReader(db.diskdb, db.stateFreezer), }, nil } @@ -318,3 +318,90 @@ func (r *HistoricalStateReader) Storage(address common.Address, key common.Hash) } return r.reader.read(newStorageIdentQuery(address, addrHash, key, keyHash), r.id, dl.stateID(), latest) } + +// HistoricalNodeReader is a wrapper over history reader, providing access to +// historical trie node data. +type HistoricalNodeReader struct { + db *Database + reader *trienodeReader + id uint64 +} + +// HistoricNodeReader constructs a reader for accessing the requested historic state. +func (db *Database) HistoricNodeReader(root common.Hash) (*HistoricalNodeReader, error) { + // Bail out if the state history hasn't been fully indexed + if db.trienodeIndexer == nil || db.trienodeFreezer == nil { + return nil, fmt.Errorf("historical state %x is not available", root) + } + if !db.trienodeIndexer.inited() { + return nil, errors.New("trienode histories haven't been fully indexed yet") + } + // - States at the current disk layer or above are directly accessible + // via `db.NodeReader`. + // + // - States older than the current disk layer (including the disk layer + // itself) are available via `db.HistoricalNodeReader`. + id := rawdb.ReadStateID(db.diskdb, root) + if id == nil { + return nil, fmt.Errorf("state %#x is not available", root) + } + // Ensure the requested trienode history is canonical, states on side chain + // are not accessible. + meta, err := readTrienodeMetadata(db.trienodeFreezer, *id+1) + if err != nil { + return nil, fmt.Errorf("state %#x is not available", root) // e.g., the referred trienode history has been pruned + } + if meta.parent != root { + return nil, fmt.Errorf("state %#x is not canonical", root) + } + return &HistoricalNodeReader{ + id: *id, + db: db, + reader: newTrienodeReader(db.diskdb, db.trienodeFreezer, int(db.config.FullValueCheckpoint)), + }, nil +} + +// Node directly retrieves the trie node data associated with a particular path, +// within a particular account. An error will be returned if the read operation +// exits abnormally. Specifically, if the layer is already stale. +// +// Note: +// - the returned trie node data is not a copy, please don't modify it. +// - an error will be returned if the requested trie node is not found in database. +func (r *HistoricalNodeReader) Node(owner common.Hash, path []byte, hash common.Hash) ([]byte, error) { + defer func(start time.Time) { + historicalTrienodeReadTimer.UpdateSince(start) + }(time.Now()) + + // TODO(rjl493456442): Theoretically, the obtained disk layer could become stale + // within a very short time window. + // + // While reading the account data while holding `db.tree.lock` can resolve + // this issue, but it will introduce a heavy contention over the lock. + // + // Let's optimistically assume the situation is very unlikely to happen, + // and try to define a low granularity lock if the current approach doesn't + // work later. + dl := r.db.tree.bottom() + latest, h, _, err := dl.node(owner, path, 0) + if err != nil { + return nil, err + } + if h == hash { + return latest, nil + } + blob, err := r.reader.read(newTrienodeIdent(owner, string(path)), r.id, dl.stateID(), latest) + if err != nil { + return nil, err + } + // Error out if the local one is inconsistent with the target. + if crypto.Keccak256Hash(blob) != hash { + blobHex := "nil" + if len(blob) > 0 { + blobHex = hexutil.Encode(blob) + } + log.Error("Unexpected historical trie node", "owner", owner.Hex(), "path", path, "blob", blobHex) + return nil, fmt.Errorf("unexpected historical trie node: (%x %v), blob: %s", owner, path, blobHex) + } + return blob, nil +} diff --git a/triedb/pathdb/states.go b/triedb/pathdb/states.go index dc737c3b53ee..27a6c1d422df 100644 --- a/triedb/pathdb/states.go +++ b/triedb/pathdb/states.go @@ -170,12 +170,13 @@ func (s *stateSet) accountList() []common.Hash { if list != nil { return list } - // No old sorted account list exists, generate a new one. It's possible that - // multiple threads waiting for the write lock may regenerate the list - // multiple times, which is acceptable. s.listLock.Lock() defer s.listLock.Unlock() + // Double check after acquiring the write lock + if list = s.accountListSorted; list != nil { + return list + } list = slices.SortedFunc(maps.Keys(s.accountData), common.Hash.Cmp) s.accountListSorted = list return list @@ -200,12 +201,13 @@ func (s *stateSet) storageList(accountHash common.Hash) []common.Hash { } s.listLock.RUnlock() - // No old sorted account list exists, generate a new one. It's possible that - // multiple threads waiting for the write lock may regenerate the list - // multiple times, which is acceptable. s.listLock.Lock() defer s.listLock.Unlock() + // Double check after acquiring the write lock + if list := s.storageListSorted[accountHash]; list != nil { + return list + } list := slices.SortedFunc(maps.Keys(s.storageData[accountHash]), common.Hash.Cmp) s.storageListSorted[accountHash] = list return list @@ -340,7 +342,10 @@ func (s *stateSet) encode(w io.Writer) error { AddrHashes []common.Hash Accounts [][]byte } - var enc accounts + enc := accounts{ + AddrHashes: make([]common.Hash, 0, len(s.accountData)), + Accounts: make([][]byte, 0, len(s.accountData)), + } for addrHash, blob := range s.accountData { enc.AddrHashes = append(enc.AddrHashes, addrHash) enc.Accounts = append(enc.Accounts, blob) @@ -503,7 +508,10 @@ func (s *StateSetWithOrigin) encode(w io.Writer) error { Addresses []common.Address Accounts [][]byte } - var accounts Accounts + accounts := Accounts{ + Addresses: make([]common.Address, 0, len(s.accountOrigin)), + Accounts: make([][]byte, 0, len(s.accountOrigin)), + } for address, blob := range s.accountOrigin { accounts.Addresses = append(accounts.Addresses, address) accounts.Accounts = append(accounts.Accounts, blob) @@ -575,6 +583,18 @@ func (s *StateSetWithOrigin) decode(r *rlp.Stream) error { } } s.storageOrigin = storageSet + + // Compute the size of origin data, keeping consistent with NewStateSetWithOrigin + var size int + for _, data := range s.accountOrigin { + size += common.HashLength + len(data) + } + for _, slots := range s.storageOrigin { + for _, data := range slots { + size += 2*common.HashLength + len(data) + } + } + s.size = s.stateSet.size + uint64(size) return nil } diff --git a/triedb/pathdb/verifier.go b/triedb/pathdb/verifier.go index a69b10f4f304..c53590f2fd63 100644 --- a/triedb/pathdb/verifier.go +++ b/triedb/pathdb/verifier.go @@ -17,36 +17,15 @@ package pathdb import ( - "encoding/binary" "errors" "fmt" - "math" - "runtime" - "sync" - "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/trie" -) - -// trieKV represents a trie key-value pair -type trieKV struct { - key common.Hash - value []byte -} - -type ( - // trieHasherFn is the interface of trie hasher which can be implemented - // by different trie algorithm. - trieHasherFn func(in chan trieKV, out chan common.Hash) - - // leafCallbackFn is the callback invoked at the leaves of the trie, - // returns the subtrie root with the specified subtrie identifier. - leafCallbackFn func(accountHash, codeHash common.Hash, stat *generateStats) (common.Hash, error) + "github.com/ethereum/go-ethereum/triedb/internal" ) // VerifyState traverses the flat states specified by the given state root and @@ -58,7 +37,7 @@ func (db *Database) VerifyState(root common.Hash) error { } defer acctIt.Release() - got, err := generateTrieRoot(acctIt, common.Hash{}, stackTrieHasher, func(accountHash, codeHash common.Hash, stat *generateStats) (common.Hash, error) { + got, err := internal.GenerateTrieRoot(nil, "", acctIt, common.Hash{}, stackTrieHasher, func(_ ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *internal.GenerateStats) (common.Hash, error) { // Migrate the code first, commit the contract code into the tmp db. if codeHash != types.EmptyCodeHash { code := rawdb.ReadCode(db.diskdb, codeHash) @@ -73,12 +52,12 @@ func (db *Database) VerifyState(root common.Hash) error { } defer storageIt.Release() - hash, err := generateTrieRoot(storageIt, accountHash, stackTrieHasher, nil, stat, false) + hash, err := internal.GenerateTrieRoot(nil, "", storageIt, accountHash, stackTrieHasher, nil, stat, false) if err != nil { return common.Hash{}, err } return hash, nil - }, newGenerateStats(), true) + }, internal.NewGenerateStats(), true) if err != nil { return err @@ -89,264 +68,10 @@ func (db *Database) VerifyState(root common.Hash) error { return nil } -// generateStats is a collection of statistics gathered by the trie generator -// for logging purposes. -type generateStats struct { - head common.Hash - start time.Time - - accounts uint64 // Number of accounts done (including those being crawled) - slots uint64 // Number of storage slots done (including those being crawled) - - slotsStart map[common.Hash]time.Time // Start time for account slot crawling - slotsHead map[common.Hash]common.Hash // Slot head for accounts being crawled - - lock sync.RWMutex -} - -// newGenerateStats creates a new generator stats. -func newGenerateStats() *generateStats { - return &generateStats{ - slotsStart: make(map[common.Hash]time.Time), - slotsHead: make(map[common.Hash]common.Hash), - start: time.Now(), - } -} - -// progressAccounts updates the generator stats for the account range. -func (stat *generateStats) progressAccounts(account common.Hash, done uint64) { - stat.lock.Lock() - defer stat.lock.Unlock() - - stat.accounts += done - stat.head = account -} - -// finishAccounts updates the generator stats for the finished account range. -func (stat *generateStats) finishAccounts(done uint64) { - stat.lock.Lock() - defer stat.lock.Unlock() - - stat.accounts += done -} - -// progressContract updates the generator stats for a specific in-progress contract. -func (stat *generateStats) progressContract(account common.Hash, slot common.Hash, done uint64) { - stat.lock.Lock() - defer stat.lock.Unlock() - - stat.slots += done - stat.slotsHead[account] = slot - if _, ok := stat.slotsStart[account]; !ok { - stat.slotsStart[account] = time.Now() - } -} - -// finishContract updates the generator stats for a specific just-finished contract. -func (stat *generateStats) finishContract(account common.Hash, done uint64) { - stat.lock.Lock() - defer stat.lock.Unlock() - - stat.slots += done - delete(stat.slotsHead, account) - delete(stat.slotsStart, account) -} - -// report prints the cumulative progress statistic smartly. -func (stat *generateStats) report() { - stat.lock.RLock() - defer stat.lock.RUnlock() - - ctx := []interface{}{ - "accounts", stat.accounts, - "slots", stat.slots, - "elapsed", common.PrettyDuration(time.Since(stat.start)), - } - if stat.accounts > 0 { - // If there's progress on the account trie, estimate the time to finish crawling it - if done := binary.BigEndian.Uint64(stat.head[:8]) / stat.accounts; done > 0 { - var ( - left = (math.MaxUint64 - binary.BigEndian.Uint64(stat.head[:8])) / stat.accounts - eta = common.CalculateETA(done, left, time.Since(stat.start)) - ) - // If there are large contract crawls in progress, estimate their finish time - for acc, head := range stat.slotsHead { - start := stat.slotsStart[acc] - if done := binary.BigEndian.Uint64(head[:8]); done > 0 { - left := math.MaxUint64 - binary.BigEndian.Uint64(head[:8]) - - // Override the ETA if larger than the largest until now - if slotETA := common.CalculateETA(done, left, time.Since(start)); eta < slotETA { - eta = slotETA - } - } - } - ctx = append(ctx, []interface{}{ - "eta", common.PrettyDuration(eta), - }...) - } - } - log.Info("Iterating state snapshot", ctx...) -} - -// reportDone prints the last log when the whole generation is finished. -func (stat *generateStats) reportDone() { - stat.lock.RLock() - defer stat.lock.RUnlock() - - var ctx []interface{} - ctx = append(ctx, []interface{}{"accounts", stat.accounts}...) - if stat.slots != 0 { - ctx = append(ctx, []interface{}{"slots", stat.slots}...) - } - ctx = append(ctx, []interface{}{"elapsed", common.PrettyDuration(time.Since(stat.start))}...) - log.Info("Iterated snapshot", ctx...) -} - -// runReport periodically prints the progress information. -func runReport(stats *generateStats, stop chan bool) { - timer := time.NewTimer(0) - defer timer.Stop() - - for { - select { - case <-timer.C: - stats.report() - timer.Reset(time.Second * 8) - case success := <-stop: - if success { - stats.reportDone() - } - return - } - } -} - -// generateTrieRoot generates the trie hash based on the snapshot iterator. -// It can be used for generating account trie, storage trie or even the -// whole state which connects the accounts and the corresponding storages. -func generateTrieRoot(it Iterator, account common.Hash, generatorFn trieHasherFn, leafCallback leafCallbackFn, stats *generateStats, report bool) (common.Hash, error) { - var ( - in = make(chan trieKV) // chan to pass leaves - out = make(chan common.Hash, 1) // chan to collect result - stoplog = make(chan bool, 1) // 1-size buffer, works when logging is not enabled - wg sync.WaitGroup - ) - // Spin up a go-routine for trie hash re-generation - wg.Add(1) - go func() { - defer wg.Done() - generatorFn(in, out) - }() - // Spin up a go-routine for progress logging - if report && stats != nil { - wg.Add(1) - go func() { - defer wg.Done() - runReport(stats, stoplog) - }() - } - // Create a semaphore to assign tasks and collect results through. We'll pre- - // fill it with nils, thus using the same channel for both limiting concurrent - // processing and gathering results. - threads := runtime.NumCPU() - results := make(chan error, threads) - for i := 0; i < threads; i++ { - results <- nil // fill the semaphore - } - // stop is a helper function to shutdown the background threads - // and return the re-generated trie hash. - stop := func(fail error) (common.Hash, error) { - close(in) - result := <-out - for i := 0; i < threads; i++ { - if err := <-results; err != nil && fail == nil { - fail = err - } - } - stoplog <- fail == nil - - wg.Wait() - return result, fail - } - var ( - logged = time.Now() - processed = uint64(0) - leaf trieKV - ) - // Start to feed leaves - for it.Next() { - if account == (common.Hash{}) { - var ( - err error - fullData []byte - ) - if leafCallback == nil { - fullData, err = types.FullAccountRLP(it.(AccountIterator).Account()) - if err != nil { - return stop(err) - } - } else { - // Wait until the semaphore allows us to continue, aborting if - // a sub-task failed - if err := <-results; err != nil { - results <- nil // stop will drain the results, add a noop back for this error we just consumed - return stop(err) - } - // Fetch the next account and process it concurrently - account, err := types.FullAccount(it.(AccountIterator).Account()) - if err != nil { - return stop(err) - } - go func(hash common.Hash) { - subroot, err := leafCallback(hash, common.BytesToHash(account.CodeHash), stats) - if err != nil { - results <- err - return - } - if account.Root != subroot { - results <- fmt.Errorf("invalid subroot(path %x), want %x, have %x", hash, account.Root, subroot) - return - } - results <- nil - }(it.Hash()) - fullData, err = rlp.EncodeToBytes(account) - if err != nil { - return stop(err) - } - } - leaf = trieKV{it.Hash(), fullData} - } else { - leaf = trieKV{it.Hash(), common.CopyBytes(it.(StorageIterator).Slot())} - } - in <- leaf - - // Accumulate the generation statistic if it's required. - processed++ - if time.Since(logged) > 3*time.Second && stats != nil { - if account == (common.Hash{}) { - stats.progressAccounts(it.Hash(), processed) - } else { - stats.progressContract(account, it.Hash(), processed) - } - logged, processed = time.Now(), 0 - } - } - // Commit the last part statistic. - if processed > 0 && stats != nil { - if account == (common.Hash{}) { - stats.finishAccounts(processed) - } else { - stats.finishContract(account, processed) - } - } - return stop(nil) -} - -func stackTrieHasher(in chan trieKV, out chan common.Hash) { +func stackTrieHasher(_ ethdb.KeyValueWriter, _ string, _ common.Hash, in chan internal.TrieKV, out chan common.Hash) { t := trie.NewStackTrie(nil) for leaf := range in { - t.Update(leaf.key[:], leaf.value) + t.Update(leaf.Key[:], leaf.Value) } out <- t.Hash() } diff --git a/version/version.go b/version/version.go index a3aad5d39898..5d402f3009b2 100644 --- a/version/version.go +++ b/version/version.go @@ -18,7 +18,7 @@ package version const ( Major = 1 // Major version component of the current release - Minor = 16 // Minor version component of the current release - Patch = 8 // Patch version component of the current release + Minor = 17 // Minor version component of the current release + Patch = 4 // Patch version component of the current release Meta = "unstable" // Version metadata to append to the version string )