From b6115e9a304cb771a3ad8383da3c61a61c6ce6cf Mon Sep 17 00:00:00 2001 From: Mayveskii Date: Wed, 18 Mar 2026 10:43:24 +0300 Subject: [PATCH 001/183] core: fix txLookupLock mutex leak on error returns in reorg() (#34039) --- core/blockchain.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/core/blockchain.go b/core/blockchain.go index 8df2365072..42a8405ec9 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -2628,6 +2628,7 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error // 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 @@ -2730,9 +2731,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 } From 6138a11c39aa162dd723518d6edba57cd538a867 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Wed, 18 Mar 2026 13:54:23 +0100 Subject: [PATCH 002/183] trie/bintrie: parallelize InternalNode.Hash at shallow tree depths (#34032) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary At tree depths below `log2(NumCPU)` (clamped to [2, 8]), hash the left subtree in a goroutine while hashing the right subtree inline. This exploits available CPU cores for the top levels of the tree where subtree hashing is most expensive. On single-core machines, the parallel path is disabled entirely. Deeper nodes use sequential hashing with the existing `sync.Pool` hasher where goroutine overhead would exceed the hash computation cost. The parallel path uses `sha256.Sum256` with a stack-allocated buffer to avoid pool contention across goroutines. **Safety:** - Left/right subtrees are disjoint — no shared mutable state - `sync.WaitGroup` provides happens-before guarantee for the result - `defer wg.Done()` + `recover()` prevents goroutine panics from crashing the process - `!bt.mustRecompute` early return means clean nodes never enter the parallel path - Hash results are deterministic regardless of computation order — no consensus risk ## Benchmark (AMD EPYC 48-core, 500K entries, `--benchtime=10s --count=3`, post-H01 baseline) | Metric | Baseline | Parallel | Delta | |--------|----------|----------|-------| | Approve (Mgas/s) | 224.5 ± 7.1 | **259.6 ± 2.4** | **+15.6%** | | BalanceOf (Mgas/s) | 982.9 ± 5.1 | 954.3 ± 10.8 | -2.9% (noise, clean nodes skip parallel path) | | Allocs/op (approve) | ~810K | ~700K | -13.6% | --- trie/bintrie/internal_node.go | 44 +++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/trie/bintrie/internal_node.go b/trie/bintrie/internal_node.go index 7ad76aa9db..946203bcfb 100644 --- a/trie/bintrie/internal_node.go +++ b/trie/bintrie/internal_node.go @@ -17,12 +17,33 @@ package bintrie import ( + "crypto/sha256" "errors" "fmt" + "math/bits" + "runtime" + "sync" "github.com/ethereum/go-ethereum/common" ) +// parallelDepth returns the tree depth below which Hash() spawns goroutines. +func parallelDepth() int { + return min(bits.Len(uint(runtime.NumCPU())), 8) +} + +// isDirty reports whether a BinaryNode child needs rehashing. +func isDirty(n BinaryNode) bool { + switch v := n.(type) { + case *InternalNode: + return v.mustRecompute + case *StemNode: + return v.mustRecompute + default: + return false + } +} + func keyToPath(depth int, key []byte) ([]byte, error) { if depth > 31*8 { return nil, errors.New("node too deep") @@ -124,6 +145,29 @@ func (bt *InternalNode) Hash() common.Hash { return bt.hash } + // At shallow depths, parallelize when both children need rehashing: + // hash left subtree in a goroutine, right subtree inline, then combine. + // Skip goroutine overhead when only one child is dirty (common case + // for narrow state updates that touch a single path through the trie). + if bt.depth < parallelDepth() && isDirty(bt.left) && isDirty(bt.right) { + var input [64]byte + var lh common.Hash + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer wg.Done() + lh = bt.left.Hash() + }() + rh := bt.right.Hash() + copy(input[32:], rh[:]) + wg.Wait() + copy(input[:32], lh[:]) + bt.hash = sha256.Sum256(input[:]) + bt.mustRecompute = false + return bt.hash + } + + // Deeper nodes: sequential using pooled hasher (goroutine overhead > hash cost) h := newSha256() defer returnSha256(h) if bt.left != nil { From 6ae3f9fa562f28e805e6a5c20f0e42c1efc7d729 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Wed, 18 Mar 2026 13:54:29 +0100 Subject: [PATCH 003/183] core/history: refactor pruning configuration (#34036) This PR introduces a new type HistoryPolicy which captures user intent as opposed to pruning point stored in the blockchain which persists the actual tail of data in the database. It is in preparation for the rolling history expiry feature. It comes with a semantic change: if database was pruned and geth is running without a history mode flag (or explicit keep all flag) geth will emit a warning but continue running as opposed to stopping the world. --- cmd/geth/chaincmd.go | 11 +-- cmd/workload/testsuite.go | 8 ++- core/blockchain.go | 113 ++++++++++--------------------- core/blockchain_test.go | 16 +---- core/history/historymode.go | 81 +++++++++++----------- core/history/historymode_test.go | 58 ++++++++++++++++ eth/backend.go | 9 ++- 7 files changed, 159 insertions(+), 137 deletions(-) create mode 100644 core/history/historymode_test.go diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go index 7e14ec1c60..1084100f39 100644 --- a/cmd/geth/chaincmd.go +++ b/cmd/geth/chaincmd.go @@ -731,13 +731,16 @@ func pruneHistory(ctx *cli.Context) error { // Determine the prune point based on the history mode. genesisHash := chain.Genesis().Hash() - prunePoint := history.GetPrunePoint(genesisHash, mode) - if prunePoint == nil { + 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 ( - targetBlock = prunePoint.BlockNumber - targetBlockHash = prunePoint.BlockHash + targetBlock = policy.Target.BlockNumber + targetBlockHash = policy.Target.BlockHash ) // Check the current freezer tail to see if pruning is needed/possible. diff --git a/cmd/workload/testsuite.go b/cmd/workload/testsuite.go index 80cbd15352..4e33522f1b 100644 --- a/cmd/workload/testsuite.go +++ b/cmd/workload/testsuite.go @@ -155,7 +155,9 @@ func testConfigFromCLI(ctx *cli.Context) (cfg testConfig) { } 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) { @@ -180,7 +182,9 @@ func testConfigFromCLI(ctx *cli.Context) (cfg testConfig) { } 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) diff --git a/core/blockchain.go b/core/blockchain.go index 42a8405ec9..1b45a5ac39 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -194,9 +194,8 @@ type BlockChainConfig struct { 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 @@ -227,13 +226,13 @@ type BlockChainConfig struct { // 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, @@ -715,82 +714,44 @@ func (bc *BlockChain) loadLastState() error { // initializeHistoryPruning sets bc.historyPrunePoint. func (bc *BlockChain) initializeHistoryPruning(latest uint64) error { - var ( - freezerTail, _ = bc.db.Tail() - genesisHash = bc.genesisBlock.Hash() - mergePoint = history.MergePrunePoints[genesisHash] - praguePoint = history.PraguePrunePoints[genesisHash] - ) - switch bc.cfg.ChainHistoryMode { - 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. - if mergePoint != nil && freezerTail == mergePoint.BlockNumber { - bc.historyPrunePoint.Store(mergePoint) - return nil - } - if praguePoint != nil && freezerTail == praguePoint.BlockNumber { - bc.historyPrunePoint.Store(praguePoint) - return nil - } - log.Error("Chain history database is pruned with unknown configuration", "tail", freezerTail) - return errors.New("unexpected database tail") + freezerTail, _ := bc.db.Tail() + policy := bc.cfg.HistoryPolicy - case history.KeepPostMerge: - if mergePoint == nil { - return errors.New("history pruning requested for unknown network") + switch policy.Mode { + case history.KeepAll: + 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), + }) } - if freezerTail == 0 && latest != 0 { - log.Error(fmt.Sprintf("Chain history mode is configured as %q, but database is not pruned.", bc.cfg.ChainHistoryMode.String())) - log.Error("Run 'geth prune-history --history.chain postmerge' to prune pre-merge history.") - return errors.New("history pruning requested via configuration") - } - // Check if DB is pruned further than requested (to Prague). - if praguePoint != nil && freezerTail == praguePoint.BlockNumber { - log.Error("Chain history database is pruned to Prague block, but postmerge mode was requested.") - log.Error("History cannot be unpruned. To restore history, use 'geth import-history'.") - log.Error("If you intended to keep post-Prague history, use '--history.chain postprague' instead.") - return errors.New("database pruned beyond requested history mode") - } - if freezerTail > 0 && freezerTail != mergePoint.BlockNumber { - return errors.New("chain history database pruned to unknown block") - } - bc.historyPrunePoint.Store(mergePoint) return nil - case history.KeepPostPrague: - if praguePoint == nil { - return errors.New("history pruning requested for unknown network") - } - // Check if already at the prague prune point. - if freezerTail == praguePoint.BlockNumber { - bc.historyPrunePoint.Store(praguePoint) + case history.KeepPostMerge, history.KeepPostPrague: + target := policy.Target + // Already at the target. + if freezerTail == target.BlockNumber { + bc.historyPrunePoint.Store(target) return nil } - // Check if database needs pruning. - if latest != 0 { - if freezerTail == 0 { - log.Error(fmt.Sprintf("Chain history mode is configured as %q, but database is not pruned.", bc.cfg.ChainHistoryMode.String())) - log.Error("Run 'geth prune-history --history.chain postprague' to prune pre-Prague history.") - return errors.New("history pruning requested via configuration") - } - if mergePoint != nil && freezerTail == mergePoint.BlockNumber { - log.Error(fmt.Sprintf("Chain history mode is configured as %q, but database is only pruned to merge block.", bc.cfg.ChainHistoryMode.String())) - log.Error("Run 'geth prune-history --history.chain postprague' to prune pre-Prague history.") - return errors.New("history pruning requested via configuration") - } - log.Error("Chain history database is pruned to unknown block", "tail", freezerTail) - return errors.New("unexpected database tail") + // 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) } - // Fresh database (latest == 0), will sync from prague point. - bc.historyPrunePoint.Store(praguePoint) + // 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) } } diff --git a/core/blockchain_test.go b/core/blockchain_test.go index ce592f0267..d3ca21b2b3 100644 --- a/core/blockchain_test.go +++ b/core/blockchain_test.go @@ -36,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" @@ -4337,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 ( diff --git a/core/history/historymode.go b/core/history/historymode.go index bdaf07826d..1adfe014b2 100644 --- a/core/history/historymode.go +++ b/core/history/historymode.go @@ -77,57 +77,62 @@ func (m *HistoryMode) UnmarshalText(text []byte) error { return nil } +// PrunePoint identifies a specific block for history pruning. type PrunePoint struct { BlockNumber uint64 BlockHash common.Hash } -// MergePrunePoints contains 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 -// the given block. -var MergePrunePoints = 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"), + }, }, } -// PraguePrunePoints contains the pre-defined history pruning cutoff blocks for the Prague -// (Pectra) upgrade. They point to the first post-Prague block. Any pruning should truncate -// *up to* but excluding the given block. -var PraguePrunePoints = map[common.Hash]*PrunePoint{ - // mainnet - first Prague block (May 7, 2025) - params.MainnetGenesisHash: { - BlockNumber: 22431084, - BlockHash: common.HexToHash("0x50c8cab760b2948349c590461b166773c45d8f4858cccf5a43025ab2960152e8"), - }, - // sepolia - first Prague block (March 5, 2025) - params.SepoliaGenesisHash: { - BlockNumber: 7836331, - BlockHash: common.HexToHash("0xe6571beb68bf24dbd8a6ba354518996920c55a3f8d8fdca423e391b8ad071f22"), - }, +// 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 } -// PrunePoints is an alias for MergePrunePoints for backward compatibility. -// Deprecated: Use GetPrunePoint or MergePrunePoints directly. -var PrunePoints = MergePrunePoints - -// GetPrunePoint returns the prune point for the given genesis hash and history mode. -// Returns nil if no prune point is defined for the given combination. -func GetPrunePoint(genesisHash common.Hash, mode HistoryMode) *PrunePoint { +// NewPolicy constructs a HistoryPolicy from the given mode and genesis hash. +func NewPolicy(mode HistoryMode, genesisHash common.Hash) (HistoryPolicy, error) { switch mode { - case KeepPostMerge: - return MergePrunePoints[genesisHash] - case KeepPostPrague: - return PraguePrunePoints[genesisHash] + 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 nil + return HistoryPolicy{}, fmt.Errorf("invalid history mode: %d", mode) } } diff --git a/core/history/historymode_test.go b/core/history/historymode_test.go new file mode 100644 index 0000000000..87eae188dd --- /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/eth/backend.go b/eth/backend.go index 72228614f0..e9bea59734 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" @@ -175,7 +176,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 } @@ -220,6 +221,10 @@ 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, @@ -233,7 +238,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { TrienodeHistory: config.TrienodeHistory, NodeFullValueCheckpoint: config.NodeFullValueCheckpoint, StateScheme: scheme, - ChainHistoryMode: config.HistoryMode, + HistoryPolicy: histPolicy, TxLookupLimit: int64(min(config.TransactionHistory, math.MaxInt64)), VmConfig: vm.Config{ EnablePreimageRecording: config.EnablePreimageRecording, From b35645bdf7dfb2f0a22f14e8d278b9ec3cb1d48b Mon Sep 17 00:00:00 2001 From: haoyu-haoyu <85037553+haoyu-haoyu@users.noreply.github.com> Date: Wed, 18 Mar 2026 12:56:26 +0000 Subject: [PATCH 004/183] build: fix missing '!' in shebang of generated oss-fuzz scripts (#34044) \`oss-fuzz.sh\` line 38 writes \`#/bin/sh\` instead of \`#!/bin/sh\` as the shebang of generated fuzz test runner scripts. \`\`\`diff -#/bin/sh +#!/bin/sh \`\`\` Without the \`!\`, the kernel does not recognize the interpreter directive. Co-authored-by: Claude Opus 4.6 --- oss-fuzz.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/oss-fuzz.sh b/oss-fuzz.sh index bd87665125..73209fd8c8 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 From 3341d8ace0dd85cb5aa90548269e307439ef8b35 Mon Sep 17 00:00:00 2001 From: vickkkkkyy Date: Thu, 19 Mar 2026 06:31:40 +0800 Subject: [PATCH 005/183] eth/filters: rangeLogs should error on invalid block range (#33763) Fixes log filter to reject out of order block ranges. --- eth/filters/filter.go | 2 +- eth/filters/filter_test.go | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/eth/filters/filter.go b/eth/filters/filter.go index 9915f28128..04e11f0475 100644 --- a/eth/filters/filter.go +++ b/eth/filters/filter.go @@ -390,7 +390,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() diff --git a/eth/filters/filter_test.go b/eth/filters/filter_test.go index 63727200f7..e7b1b08046 100644 --- a/eth/filters/filter_test.go +++ b/eth/filters/filter_test.go @@ -357,7 +357,8 @@ func testFilters(t *testing.T, history uint64, noHistory bool) { 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, 0), + 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, 0), From 4faadf17fbc29d7890089acc660d553be454067a Mon Sep 17 00:00:00 2001 From: Bosul Mun Date: Thu, 19 Mar 2026 17:51:03 +0900 Subject: [PATCH 006/183] rlp: add AppendList method to RawList (#34048) This the AppendList method to merge two RawList instances by appending the raw content. --- rlp/raw.go | 12 ++++++++++++ rlp/raw_test.go | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/rlp/raw.go b/rlp/raw.go index 08ec667158..5f41cad5c4 100644 --- a/rlp/raw.go +++ b/rlp/raw.go @@ -168,6 +168,18 @@ func (r *RawList[T]) AppendRaw(b []byte) error { 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 { diff --git a/rlp/raw_test.go b/rlp/raw_test.go index 112c5d7897..ed7d3524c2 100644 --- a/rlp/raw_test.go +++ b/rlp/raw_test.go @@ -246,6 +246,54 @@ func TestRawListAppendRaw(t *testing.T) { 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 { From a3083ff5d0fdc8dec370a421ca4a7ad876e4fe08 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Thu, 19 Mar 2026 16:52:10 +0800 Subject: [PATCH 007/183] cmd: add support for enumerating a single storage trie (#34051) --- cmd/geth/snapshot.go | 239 +++++++++++++++++++++++++++++++------------ cmd/utils/flags.go | 4 + 2 files changed, 179 insertions(+), 64 deletions(-) diff --git a/cmd/geth/snapshot.go b/cmd/geth/snapshot.go index fc0658a59c..c177fb5ea2 100644 --- a/cmd/geth/snapshot.go +++ b/cmd/geth/snapshot.go @@ -36,6 +36,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 +106,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 +116,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 +125,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 +136,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. `, }, { @@ -272,6 +281,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 +432,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 +482,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 +545,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 +624,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)) { diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 792e0e55ab..3a0bcc6b05 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -218,6 +218,10 @@ 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", From fd859638bd76d15b15468c9b2dea601035779769 Mon Sep 17 00:00:00 2001 From: jwasinger Date: Thu, 19 Mar 2026 12:02:49 -0400 Subject: [PATCH 008/183] core/vm: rework gas measurement for call variants (#33648) EIP-7928 brings state reads into consensus by recording accounts and storage accessed during execution in the block access list. As part of the spec, we need to check that there is enough gas available to cover the cost component which doesn't depend on looking up state. If this component can't be covered by the available gas, we exit immediately. The portion of the call dynamic cost which doesn't depend on state look ups: - EIP2929 call costs - value transfer cost - memory expansion cost This PR: - breaks up the "inner" gas calculation for each call variant into a pair of stateless/stateful cost methods - modifies the gas calculation logic of calls to check stateless cost component first, and go out of gas immediately if it is not covered. --------- Co-authored-by: Gary Rong --- core/vm/gas.go | 1 - core/vm/gas_table.go | 106 ++++++++++++++++++-------------------- core/vm/operations_acl.go | 91 ++++++++++++++++++++------------ 3 files changed, 108 insertions(+), 90 deletions(-) diff --git a/core/vm/gas.go b/core/vm/gas.go index 5fe589bce6..dcb20893c5 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 aa1ad918bb..f075a99468 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -373,7 +373,32 @@ func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor return 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) (uint64, error) { + intrinsic, err := intrinsicFunc(evm, contract, stack, mem, memorySize) + if err != nil { + return 0, err + } + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, intrinsic, stack.Back(0)) + if err != nil { + return 0, err + } + gas, overflow := math.SafeAdd(intrinsic, evm.callGasTemp) + if overflow { + return 0, ErrGasUintOverflow + } + return gas, nil + } +} + +func gasCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { var ( gas uint64 transfersValue = !stack.Back(2).IsZero() @@ -382,38 +407,40 @@ func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize if evm.readOnly && transfersValue { return 0, ErrWriteProtection } - - 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 - } + // Stateless check memoryGas, err := memoryGasCost(mem, memorySize) if err != nil { return 0, err } + var transferGas uint64 + if transfersValue && !evm.chainRules.IsEIP4762 { + transferGas = params.CallValueTransferGas + } var overflow bool - if gas, overflow = math.SafeAdd(gas, memoryGas); overflow { + if gas, overflow = math.SafeAdd(memoryGas, transferGas); overflow { return 0, 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 < gas { + return 0, ErrOutOfGas } - if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow { + // 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 + } + if gas, overflow = math.SafeAdd(gas, stateGas); overflow { return 0, ErrGasUintOverflow } - return 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) (uint64, error) { memoryGas, err := memoryGasCost(mem, memorySize) if err != nil { return 0, err @@ -428,46 +455,15 @@ func gasCallCode(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memory if gas, overflow = math.SafeAdd(gas, memoryGas); overflow { return 0, 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 } -func gasDelegateCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, 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 gas, nil +func gasDelegateCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + return memoryGasCost(mem, memorySize) } -func gasStaticCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, 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 gas, nil +func gasStaticCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + return memoryGasCost(mem, memorySize) } func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { diff --git a/core/vm/operations_acl.go b/core/vm/operations_acl.go index ce394d9384..addd2b162f 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -256,10 +256,10 @@ func makeSelfdestructGasFn(refundsEnabled bool) gasFunc { } var ( - innerGasCallEIP7702 = makeCallVariantGasCallEIP7702(gasCall) - gasDelegateCallEIP7702 = makeCallVariantGasCallEIP7702(gasDelegateCall) - gasStaticCallEIP7702 = makeCallVariantGasCallEIP7702(gasStaticCall) - gasCallCodeEIP7702 = makeCallVariantGasCallEIP7702(gasCallCode) + innerGasCallEIP7702 = makeCallVariantGasCallEIP7702(gasCallIntrinsic) + gasDelegateCallEIP7702 = makeCallVariantGasCallEIP7702(gasDelegateCallIntrinsic) + gasStaticCallEIP7702 = makeCallVariantGasCallEIP7702(gasStaticCallIntrinsic) + gasCallCodeEIP7702 = makeCallVariantGasCallEIP7702(gasCallCodeIntrinsic) ) func gasCallEIP7702(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { @@ -274,62 +274,85 @@ func gasCallEIP7702(evm *EVM, contract *Contract, stack *Stack, mem *Memory, mem return innerGasCallEIP7702(evm, contract, stack, mem, memorySize) } -func makeCallVariantGasCallEIP7702(oldCalculator gasFunc) gasFunc { +func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, 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) { + + // 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(eip2929Cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { return 0, 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 0, 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 < intrinsicCost { + return 0, 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) { + if !contract.UseGas(eip7702Cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { return 0, 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, intrinsicCost, stack.Back(0)) if err != nil { - return old, err + return 0, 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 += eip2929Cost + eip7702Cost - var overflow bool - if total, overflow = math.SafeAdd(old, total); overflow { + // 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 0, ErrGasUintOverflow } - return total, nil + if totalCost, overflow = math.SafeAdd(totalCost, intrinsicCost); overflow { + return 0, ErrGasUintOverflow + } + if totalCost, overflow = math.SafeAdd(totalCost, evm.callGasTemp); overflow { + return 0, ErrGasUintOverflow + } + return totalCost, nil } } From 35b91092c5b75399b15354da23f9433c574ce3bc Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Thu, 19 Mar 2026 18:26:00 +0100 Subject: [PATCH 009/183] rlp: add Size method to EncoderBuffer (#34052) The new method returns the size of the written data, excluding any unfinished list structure. --- rlp/encbuffer.go | 10 ++++++++++ rlp/encode_test.go | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/rlp/encbuffer.go b/rlp/encbuffer.go index 61d8bd059c..ca0aa290fe 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_test.go b/rlp/encode_test.go index e63ea319b4..8dc9fdaf1f 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) { From 59ce2cb6a14db04432857b2ae76b1889841bc4e6 Mon Sep 17 00:00:00 2001 From: jvn Date: Fri, 20 Mar 2026 10:22:15 +0530 Subject: [PATCH 010/183] p2p: track in-progress inbound node IDs (#33198) Avoid dialing a node while we have an inbound connection request from them in progress. Closes #33197 --- p2p/dial.go | 67 ++++++++++++++++++++++++++++++++---------- p2p/dial_test.go | 76 ++++++++++++++++++++++++++++++++++++++++++++++++ p2p/server.go | 12 ++++++-- 3 files changed, 137 insertions(+), 18 deletions(-) diff --git a/p2p/dial.go b/p2p/dial.go index 225709427c..f9463d6d89 100644 --- a/p2p/dial.go +++ b/p2p/dial.go @@ -76,6 +76,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 +105,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 +167,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 +230,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 +299,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 +422,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 f18dacce2a..9684aa6e91 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/server.go b/p2p/server.go index 10c855f1c4..6d2323f9ce 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 { From 77779d1098c86d478768d8f2d0b6982ff2364d44 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Fri, 20 Mar 2026 15:40:04 +0100 Subject: [PATCH 011/183] core/state: bypass per-account updateTrie in IntermediateRoot for binary trie (#34022) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary In binary trie mode, `IntermediateRoot` calls `updateTrie()` once per dirty account. But with the binary trie there is only one unified trie (`OpenStorageTrie` returns `self`), so each call redundantly does per-account trie setup: `getPrefetchedTrie`, `getTrie`, slice allocations for deletions/used, and `prefetcher.used` — all for the same trie pointer. This PR replaces the per-account `updateTrie()` calls with a single flat loop that applies all storage updates directly to `s.trie`. The MPT path is unchanged. The prefetcher trie replacement is guarded to avoid overwriting the binary trie that received updates. This is the phase-1 counterpart to #34021 (H01). H01 fixes the commit phase (`trie.Commit()` called N+1 times). This PR fixes the update phase (`updateTrie()` called N times with redundant setup). Same root cause — unified binary trie operated on per-account — different phases. ## Benchmark (Apple M4 Pro, 500K entries, `--benchtime=10s --count=3`, on top of #34021) | Metric | H01 baseline | H01 + this PR | Delta | |--------|:------------:|:-------------:|:-----:| | Approve (Mgas/s) | 368 | **414** | **+12.5%** | | BalanceOf (Mgas/s) | 870 | 875 | +0.6% | Should be rebased after #34021 is merged. --- core/state/statedb.go | 71 +++++++++++++++++++++++++++++++------------ 1 file changed, 52 insertions(+), 19 deletions(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index 2477242eb5..02622f0bd6 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -824,22 +824,55 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { 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 + // 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) + } + } else { + if err := s.trie.DeleteStorage(addr, key[:]); err != nil { + s.setError(err) + } + } + } } - 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, @@ -847,9 +880,9 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { if s.witness != nil && obj.trie != nil { s.witness.AddState(obj.trie.Witness()) } - } - 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 @@ -911,7 +944,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.TrieDB().IsVerkle() { if trie := s.prefetcher.trie(common.Hash{}, s.originalRoot); trie == nil { log.Error("Failed to retrieve account pre-fetcher trie") } else { From 305cd7b9eb1c2b2f9e555309bce8a389633ca923 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Fri, 20 Mar 2026 18:53:14 +0100 Subject: [PATCH 012/183] trie/bintrie: fix NodeIterator Empty node handling and expose tree accessors (#34056) Fix three issues in the binary trie NodeIterator: 1. Empty nodes now properly backtrack to parent and continue iteration instead of terminating the entire walk early. 2. `HashedNode` resolver handles `nil` data (all-zeros hash) gracefully by treating it as Empty rather than panicking. 3. Parent update after node resolution guards against stack underflow when resolving the root node itself. --------- Co-authored-by: tellabg <249254436+tellabg@users.noreply.github.com> --- trie/bintrie/iterator.go | 32 +++-- trie/bintrie/iterator_test.go | 239 ++++++++++++++++++++++++++++++++++ 2 files changed, 263 insertions(+), 8 deletions(-) create mode 100644 trie/bintrie/iterator_test.go diff --git a/trie/bintrie/iterator.go b/trie/bintrie/iterator.go index 917f82efc9..048d37f766 100644 --- a/trie/bintrie/iterator.go +++ b/trie/bintrie/iterator.go @@ -119,10 +119,17 @@ func (it *binaryNodeIterator) Next(descend bool) bool { return it.Next(descend) case HashedNode: // resolve the node - data, err := it.trie.nodeResolver(it.Path(), common.Hash(node)) + resolverPath := it.Path() + data, err := it.trie.nodeResolver(resolverPath, common.Hash(node)) if err != nil { panic(err) } + if data == nil { + // Empty/nil node — treat as Empty, backtrack + it.current = Empty{} + it.stack[len(it.stack)-1].Node = it.current + return it.Next(descend) + } it.current, err = DeserializeNodeWithHash(data, len(it.stack)-1, common.Hash(node)) if err != nil { panic(err) @@ -130,16 +137,25 @@ func (it *binaryNodeIterator) Next(descend bool) bool { // update the stack and parent with the resolved node it.stack[len(it.stack)-1].Node = it.current - parent := &it.stack[len(it.stack)-2] - if parent.Index == 0 { - parent.Node.(*InternalNode).left = it.current - } else { - parent.Node.(*InternalNode).right = it.current + if len(it.stack) >= 2 { + parent := &it.stack[len(it.stack)-2] + if parent.Index == 0 { + parent.Node.(*InternalNode).left = it.current + } else { + parent.Node.(*InternalNode).right = it.current + } } return it.Next(descend) case Empty: - // do nothing - return false + // Empty node - go back to parent and continue + 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(descend) default: panic("invalid node type") } diff --git a/trie/bintrie/iterator_test.go b/trie/bintrie/iterator_test.go new file mode 100644 index 0000000000..3e717c07ba --- /dev/null +++ b/trie/bintrie/iterator_test.go @@ -0,0 +1,239 @@ +// 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() + tr := &BinaryTrie{ + root: NewBinaryNode(), + tracer: trie.NewPrevalueTracer(), + } + for _, kv := range entries { + var err error + tr.root, err = tr.root.Insert(kv[0][:], kv[1][:], nil, 0) + if 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{ + root: Empty{}, + 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 _, ok := tr.root.(*InternalNode); !ok { + t.Fatalf("expected InternalNode root, got %T", tr.root) + } + 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, ok := tr.root.(*InternalNode) + if !ok { + t.Fatalf("expected InternalNode root, got %T", tr.root) + } + + // 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. + root.right = HashedNode(common.Hash{}) + + // Should not panic; the zero-hash right child should be treated as Empty. + if leaves := countLeaves(t, tr); 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) + } +} From e23b0cbc2254b0af4a5d38e6295621de52689bc0 Mon Sep 17 00:00:00 2001 From: Lessa <230214854+adblesss@users.noreply.github.com> Date: Mon, 23 Mar 2026 09:54:30 -0400 Subject: [PATCH 013/183] core/rawdb: fix key length check for num -- hash in db inspect (#34074) Fix incorrect key length calculation for `numHashPairings` in `InspectDatabase`, introduced in #34000. The `headerHashKey` format is `headerPrefix + num + headerHashSuffix` (10 bytes), but the check incorrectly included `common.HashLength`, expecting 42 bytes. This caused all number -- hash entries to be misclassified as unaccounted data. --- core/rawdb/database.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/rawdb/database.go b/core/rawdb/database.go index a13afb9c0e..945fd9097d 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -480,7 +480,7 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { receipts.add(size) 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) && len(key) == (len(headerPrefix)+8+common.HashLength+len(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) From a61e5ccb1e343d9c28b85ba6851e7829517b98b1 Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Mon, 23 Mar 2026 22:10:32 +0800 Subject: [PATCH 014/183] core, internal/ethapi: fix incorrect max-initcode RPC error mapping (#34067) Problem: The max-initcode sentinel moved from core to vm, but RPC pre-check mapping still depended on core.ErrMaxInitCodeSizeExceeded. This mismatch could surface inconsistent error mapping when oversized initcode is submitted through JSON-RPC. Solution: - Remove core.ErrMaxInitCodeSizeExceeded from the core pre-check error set. - Map max-initcode validation errors in RPC from vm.ErrMaxInitCodeSizeExceeded. - Keep the RPC error code mapping unchanged (-38025). Impact: - Restores consistent max-initcode error mapping after the sentinel move. - Preserves existing JSON-RPC client expectations for error code -38025. - No consensus, state, or protocol behavior changes. --- core/error.go | 4 ---- internal/ethapi/errors.go | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/core/error.go b/core/error.go index 4610842cee..7dd5b8a432 100644 --- a/core/error.go +++ b/core/error.go @@ -66,10 +66,6 @@ var ( // 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/internal/ethapi/errors.go b/internal/ethapi/errors.go index e406c36d6c..cc79af6f3c 100644 --- a/internal/ethapi/errors.go +++ b/internal/ethapi/errors.go @@ -141,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{ From b87340a856573ab5f15577acc1dc563702e4fe14 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felf=C3=B6ldi=20Zsolt?= Date: Mon, 23 Mar 2026 15:29:53 +0100 Subject: [PATCH 015/183] core, core/vm: implement EIP-7708 (#33645) This PR implements EIP-7708 according to the latest "rough consensus": https://github.com/ethereum/EIPs/pull/9003 https://github.com/etan-status/EIPs/blob/fl-ethlogs/EIPS/eip-7708.md --------- Co-authored-by: Jared Wasinger Co-authored-by: raxhvl Co-authored-by: Gary Rong --- core/eth_transfer_logs_test.go | 169 +++++++++++++++++++++++++++++++++ core/evm.go | 6 +- core/state/statedb.go | 35 +++++++ core/state/statedb_hooked.go | 4 + core/state_transition.go | 3 + core/types/log.go | 31 ++++++ core/vm/evm.go | 7 +- core/vm/gas_table_test.go | 4 +- core/vm/instructions.go | 10 +- core/vm/interface.go | 1 + core/vm/interpreter_test.go | 2 +- params/protocol_params.go | 8 ++ 12 files changed, 270 insertions(+), 10 deletions(-) create mode 100644 core/eth_transfer_logs_test.go diff --git a/core/eth_transfer_logs_test.go b/core/eth_transfer_logs_test.go new file mode 100644 index 0000000000..815b56b588 --- /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/evm.go b/core/evm.go index 7430c0e21f..818b23bee5 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" ) @@ -138,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/state/statedb.go b/core/state/statedb.go index 02622f0bd6..59ad3cdfef 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -743,6 +743,41 @@ func (s *StateDB) GetRefund() uint64 { return s.refund } +type removedAccountWithBalance struct { + address common.Address + balance *uint256.Int +} + +// EmitLogsForBurnAccounts emits 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) EmitLogsForBurnAccounts() { + var list []removedAccountWithBalance + for addr := range s.journal.dirties { + 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 { + sort.Slice(list, func(i, j int) bool { + return list[i].address.Cmp(list[j].address) < 0 + }) + } + for _, acct := range list { + s.AddLog(types.EthBurnLog(acct.address, acct.balance)) + } +} + // 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. diff --git a/core/state/statedb_hooked.go b/core/state/statedb_hooked.go index 48794a3f41..8c217fba48 100644 --- a/core/state/statedb_hooked.go +++ b/core/state/statedb_hooked.go @@ -229,6 +229,10 @@ func (s *hookedStateDB) AddLog(log *types.Log) { } } +func (s *hookedStateDB) EmitLogsForBurnAccounts() { + s.inner.EmitLogsForBurnAccounts() +} + func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) { 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. diff --git a/core/state_transition.go b/core/state_transition.go index 6a40b4f7ab..52375bedaa 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -583,6 +583,9 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { st.evm.AccessEvents.AddAccount(st.evm.Context.Coinbase, true, math.MaxUint64) } } + if rules.IsAmsterdam { + st.evm.StateDB.EmitLogsForBurnAccounts() + } return &ExecutionResult{ UsedGas: st.gasUsed(), MaxUsedGas: peakGasUsed, diff --git a/core/types/log.go b/core/types/log.go index f0e6a3a745..487ca57b5a 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/vm/evm.go b/core/vm/evm.go index 5897dbd265..36494de2a8 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 @@ -283,8 +283,9 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g // 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.Context.Transfer(evm.StateDB, caller, addr, value, &evm.chainRules) } + if isPrecompile { var stateDB StateDB if evm.chainRules.IsAmsterdam { @@ -567,7 +568,7 @@ func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *ui } 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. diff --git a/core/vm/gas_table_test.go b/core/vm/gas_table_test.go index 436cc47f2e..e9e56038dd 100644 --- a/core/vm/gas_table_test.go +++ b/core/vm/gas_table_test.go @@ -94,7 +94,7 @@ 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}}) @@ -144,7 +144,7 @@ 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{} diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 4e4a33acda..a5fa11e307 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -934,6 +934,13 @@ func opSelfdestruct6780(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, erro 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 { @@ -1086,9 +1093,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 diff --git a/core/vm/interface.go b/core/vm/interface.go index e285b18b0f..6a93846ac5 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -87,6 +87,7 @@ type StateDB interface { Snapshot() int AddLog(*types.Log) + EmitLogsForBurnAccounts() AddPreimage(common.Hash, []byte) Witness() *stateless.Witness diff --git a/core/vm/interpreter_test.go b/core/vm/interpreter_test.go index 79531f78d2..28df8546b5 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 { diff --git a/params/protocol_params.go b/params/protocol_params.go index cebf5008c8..652574287c 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -222,3 +222,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)') + +) From 745b0a8c09ad9d0866da67403ffa99d11ba70ec3 Mon Sep 17 00:00:00 2001 From: vickkkkkyy Date: Tue, 24 Mar 2026 01:14:28 +0800 Subject: [PATCH 016/183] cmd/utils: guard SampleRatio flag with IsSet check (#34062) In `setOpenTelemetry`, all other fields (Enabled, Endpoint, AuthUser, AuthPassword, InstanceID, Tags) are guarded by `ctx.IsSet()` checks, so they only override the config file when explicitly set via CLI flags. `SampleRatio` was the only field missing this guard, causing the flag default (`1.0`) to always overwrite whatever was loaded from the config file. - Fix OpenTelemetry `SampleRatio` being unconditionally overwritten by the CLI flag default value (`1.0`), even when the user did not pass `--rpc.telemetry.sample-ratio` - This caused config file values for `SampleRatio` to be silently ignored --- cmd/utils/flags.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 3a0bcc6b05..c1284044eb 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -1584,7 +1584,9 @@ func setOpenTelemetry(ctx *cli.Context, cfg *node.Config) { if ctx.IsSet(RPCTelemetryTagsFlag.Name) { tcfg.Tags = ctx.String(RPCTelemetryTagsFlag.Name) } - tcfg.SampleRatio = ctx.Float64(RPCTelemetrySampleRatioFlag.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)) From e951bcbff729b0eae1e1743c2bbb27064bbaf165 Mon Sep 17 00:00:00 2001 From: Csaba Kiraly Date: Tue, 24 Mar 2026 14:57:11 +0100 Subject: [PATCH 017/183] cmd/devp2p: fix discv5 PingMultiIP test session key mismatch (#34031) conn.read() used the actual UDP packet source address for codec.Decode(), but conn.write() always used tc.remoteAddr. When the remote node is reachable via multiple Docker networks, the packet source IP differs from tc.remoteAddr, causing a session key lookup failure in the codec. Use tc.remoteAddr.String() consistently in conn.read() so the session cache key matches what was used during Encode. --- cmd/devp2p/internal/v5test/framework.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/cmd/devp2p/internal/v5test/framework.go b/cmd/devp2p/internal/v5test/framework.go index 92a5048150..acab1eef79 100644 --- a/cmd/devp2p/internal/v5test/framework.go +++ b/cmd/devp2p/internal/v5test/framework.go @@ -218,11 +218,15 @@ func (tc *conn) read(c net.PacketConn) v5wire.Packet { if err := c.SetReadDeadline(time.Now().Add(waitTime)); err != nil { return &readError{err} } - n, fromAddr, err := c.ReadFrom(buf) + n, _, err := c.ReadFrom(buf) if err != nil { return &readError{err} } - _, _, p, err := tc.codec.Decode(buf[:n], fromAddr.String()) + // Always use tc.remoteAddr for session lookup. The actual source address of + // the packet may differ from tc.remoteAddr when the remote node is reachable + // via multiple networks (e.g. Docker bridge vs. overlay), but the codec's + // session cache is keyed by the address used during Encode. + _, _, p, err := tc.codec.Decode(buf[:n], tc.remoteAddr.String()) if err != nil { return &readError{err} } From 8f9061f937e8fe0cbd45f7416073fb03bd321667 Mon Sep 17 00:00:00 2001 From: Andrew Davis <1709934+Savid@users.noreply.github.com> Date: Wed, 25 Mar 2026 06:47:18 +1000 Subject: [PATCH 018/183] cmd/utils: optimize history import with batched insertion (#33894) Improve speed of import-history command by two orders of magnitude. Rework ImportHistory to collect up to 2500 blocks per flush instead of flushing after each block, reducing database commit overhead. --------- Co-authored-by: Sina Mahmoodi --- cmd/utils/cmd.go | 61 ++++++++++++++++++++++++++++++++---------------- 1 file changed, 41 insertions(+), 20 deletions(-) diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 995724e6fc..e490f613b3 100644 --- a/cmd/utils/cmd.go +++ b/cmd/utils/cmd.go @@ -274,40 +274,66 @@ func ImportHistory(chain *core.BlockChain, dir string, network string, from func reported = time.Now() imported = 0 h = sha256.New() - scratch = bytes.NewBuffer(nil) + buf = bytes.NewBuffer(nil) ) for i, file := range entries { err := func() error { path := filepath.Join(dir, file) - // validate against checksum file in directory + // Validate against checksum file in directory. f, err := os.Open(path) if err != nil { return fmt.Errorf("open %s: %w", path, err) } defer f.Close() + if _, err := io.Copy(h, f); err != nil { return fmt.Errorf("checksum %s: %w", path, err) } - got := common.BytesToHash(h.Sum(scratch.Bytes()[:])).Hex() - want := checksums[i] + got := common.BytesToHash(h.Sum(buf.Bytes()[:])).Hex() h.Reset() - scratch.Reset() - - if got != want { - return fmt.Errorf("%s checksum mismatch: have %s want %s", file, got, want) + 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 := from(f) if err != nil { return fmt.Errorf("error opening era: %w", err) } + defer e.Close() + it, err := e.Iterator() if err != nil { 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 { @@ -320,23 +346,18 @@ func ImportHistory(chain *core.BlockChain, dir string, network string, from func if err != nil { return fmt.Errorf("error reading receipts %d: %w", it.Number(), err) } - enc := types.EncodeBlockReceiptLists([]types.Receipts{receipts}) - if _, err := chain.InsertReceiptChain([]*types.Block{block}, enc, math.MaxUint64); err != nil { - return fmt.Errorf("error inserting body %d: %w", it.Number(), err) - } - imported++ - - 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 + } } } if err := it.Error(); err != nil { return err } - return nil + return flush() }() if err != nil { return err From 5d0e18f7757d811db2cae9dac7ac41d02bc59ef8 Mon Sep 17 00:00:00 2001 From: bigbear <155267841+aso20455@users.noreply.github.com> Date: Wed, 25 Mar 2026 09:16:09 +0100 Subject: [PATCH 019/183] core/tracing: fix NonceChangeAuthorization comment (#34085) Comment referenced NonceChangeTransaction which doesn't exist, should be NonceChangeAuthorization. --- core/tracing/hooks.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/tracing/hooks.go b/core/tracing/hooks.go index 6d0131ce70..de63689bc5 100644 --- a/core/tracing/hooks.go +++ b/core/tracing/hooks.go @@ -426,7 +426,7 @@ 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. From 8a3a309fa97bff7252da3e7e8cac47d024d2e281 Mon Sep 17 00:00:00 2001 From: Lessa <230214854+adblesss@users.noreply.github.com> Date: Thu, 26 Mar 2026 09:02:31 -0400 Subject: [PATCH 020/183] core/txpool/legacypool: remove redundant nil check in Get (#34092) Leftover from d40a255 when return type changed from *txpool.Transaction to *types.Transaction. --- core/txpool/legacypool/legacypool.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index 25c4b13166..d29b71ebc2 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -998,11 +998,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. From 1b3b028d1da4aedcb480693e58910712abe20009 Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Fri, 27 Mar 2026 09:41:56 +0800 Subject: [PATCH 021/183] miner: fix txFitsSize comment (#34100) Rename the comment so it matches the helper name. --- miner/worker.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/miner/worker.go b/miner/worker.go index e82f5f6e55..1260662fe7 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -75,7 +75,7 @@ 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 } From acdd13971705c767330bdfbd4511b4d1e53580fd Mon Sep 17 00:00:00 2001 From: jwasinger Date: Thu, 26 Mar 2026 21:45:49 -0400 Subject: [PATCH 022/183] miner: set slot number when building test payload (#34094) --- miner/payload_building.go | 1 + 1 file changed, 1 insertion(+) diff --git a/miner/payload_building.go b/miner/payload_building.go index 97b4d0c509..ccaabec373 100644 --- a/miner/payload_building.go +++ b/miner/payload_building.go @@ -350,6 +350,7 @@ func (miner *Miner) BuildTestingPayload(args *BuildPayloadArgs, transactions []* random: args.Random, withdrawals: args.Withdrawals, beaconRoot: args.BeaconRoot, + slotNum: args.SlotNum, noTxs: empty, forceOverrides: true, overrideExtraData: extraData, From c3467dd8b5e2cf151744b04b62888649ee21f52d Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Sat, 28 Mar 2026 00:06:46 +0800 Subject: [PATCH 023/183] core, miner, trie: relocate witness stats (#34106) This PR relocates the witness statistics into the witness itself, making it more self-contained. --- core/blockchain.go | 16 +++++----------- core/state/statedb.go | 38 ++++++++------------------------------ core/stateless/stats.go | 7 +++++++ core/stateless/witness.go | 36 +++++++++++++++++++++++++++++------- miner/worker.go | 4 ++-- trie/levelstats.go | 12 ++++++++++++ 6 files changed, 63 insertions(+), 50 deletions(-) diff --git a/core/blockchain.go b/core/blockchain.go index 1b45a5ac39..35b2d35dc7 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -2170,24 +2170,18 @@ func (bc *BlockChain) ProcessBlock(ctx context.Context, parentRoot common.Hash, // 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 config.StatelessSelfValidation || config.MakeWitness { - witness, err = stateless.NewWitness(block.Header(), bc) + witness, err = stateless.NewWitness(block.Header(), bc, config.EnableWitnessStats) if err != nil { return nil, err } - if config.EnableWitnessStats { - witnessStats = stateless.NewWitnessStats() - } } - statedb.StartPrefetcher("chain", witness, witnessStats) + statedb.StartPrefetcher("chain", witness) defer statedb.StopPrefetcher() } @@ -2306,8 +2300,8 @@ func (bc *BlockChain) ProcessBlock(ctx context.Context, parentRoot common.Hash, 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()) } elapsed := time.Since(startTime) + 1 // prevent zero division stats.TotalTime = elapsed diff --git a/core/state/statedb.go b/core/state/statedb.go index 59ad3cdfef..93dd7d6488 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -135,8 +135,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 @@ -201,13 +200,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 @@ -913,7 +911,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { // 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 }) @@ -930,17 +928,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 @@ -954,17 +944,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()) } } } @@ -1037,11 +1019,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 } diff --git a/core/stateless/stats.go b/core/stateless/stats.go index 7f4473a67c..8c05b23d37 100644 --- a/core/stateless/stats.go +++ b/core/stateless/stats.go @@ -54,6 +54,13 @@ func NewWitnessStats() *WitnessStats { } } +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() diff --git a/core/stateless/witness.go b/core/stateless/witness.go index 588c895a2f..f1321699c1 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/miner/worker.go b/miner/worker.go index 1260662fe7..39a61de318 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -330,12 +330,12 @@ func (miner *Miner) makeEnv(parent *types.Header, header *types.Header, coinbase } 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), diff --git a/trie/levelstats.go b/trie/levelstats.go index 9168e3fbaf..c73d652146 100644 --- a/trie/levelstats.go +++ b/trie/levelstats.go @@ -36,6 +36,18 @@ 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 { From a2496852e98876530130c93ca540860a31a0d18a Mon Sep 17 00:00:00 2001 From: Charles Dusek <38732970+cgdusek@users.noreply.github.com> Date: Sat, 28 Mar 2026 05:37:39 -0500 Subject: [PATCH 024/183] p2p/discover: resolve DNS hostnames for bootstrap nodes (#34101) Fixes #31208 --- p2p/discover/table.go | 45 ++++++++++++++++++++++++++++ p2p/discover/table_test.go | 60 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 105 insertions(+) diff --git a/p2p/discover/table.go b/p2p/discover/table.go index e5b2c7c8c5..721cd7b589 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 { diff --git a/p2p/discover/table_test.go b/p2p/discover/table_test.go index 8cc4ae33b2..c3b71ea5a6 100644 --- a/p2p/discover/table_test.go +++ b/p2p/discover/table_test.go @@ -490,6 +490,66 @@ 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()) +} + func newkey() *ecdsa.PrivateKey { key, err := crypto.GenerateKey() if err != nil { From bd3c8431d9f7282e840670ef72c9a7c8f67e3271 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Sat, 28 Mar 2026 11:39:44 +0100 Subject: [PATCH 025/183] build, cmd/keeper: add "womir" target (#34079) This PR enables the block validation of keeper in the womir/openvm zkvm. It also fixes some issues related to building the executables in CI. Namely, it activates the build which was actually disabled, and also resolves some resulting build conflicts by fixing the tags. Co-authored-by: Leo --- build/ci.go | 20 +++++++------ cmd/keeper/getpayload_example.go | 1 + cmd/keeper/getpayload_wasm.go | 4 +-- cmd/keeper/getpayload_womir.go | 49 ++++++++++++++++++++++++++++++++ cmd/keeper/stubs.go | 4 +-- 5 files changed, 66 insertions(+), 12 deletions(-) create mode 100644 cmd/keeper/getpayload_womir.go diff --git a/build/ci.go b/build/ci.go index dce01f01a8..173288bcdc 100644 --- a/build/ci.go +++ b/build/ci.go @@ -107,17 +107,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,11 +167,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 + "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. @@ -305,7 +309,7 @@ func doInstallKeeper(cmdline []string) { args := slices.Clone(gobuild.Args) args = append(args, "-o", executablePath(outputName)) 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}) } } diff --git a/cmd/keeper/getpayload_example.go b/cmd/keeper/getpayload_example.go index 683cc79248..8f40a7bd11 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 index b912678825..5024ac7d49 100644 --- a/cmd/keeper/getpayload_wasm.go +++ b/cmd/keeper/getpayload_wasm.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 wasm -// +build wasm +//go:build wasm && !womir +// +build wasm,!womir package main diff --git a/cmd/keeper/getpayload_womir.go b/cmd/keeper/getpayload_womir.go new file mode 100644 index 0000000000..8645dc7c26 --- /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/stubs.go b/cmd/keeper/stubs.go index 407a21a145..de7ee64353 100644 --- a/cmd/keeper/stubs.go +++ b/cmd/keeper/stubs.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 !example && !ziren && !wasm -// +build !example,!ziren,!wasm +//go:build !example && !ziren && !wasm && !womir +// +build !example,!ziren,!wasm,!womir package main From d1369b69f5d8b86741299a6b3c171ac58ed296bf Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Sat, 28 Mar 2026 18:46:09 +0800 Subject: [PATCH 026/183] core/txpool/legacypool: use types.Sender instead of signer.Sender (#34059) `pool.signer.Sender(tx)` bypasses the sender cache used by types.Sender, which can force an extra signature recovery for every promotable tx (promotion runs frequently). Use `types.Sender(pool.signer, tx)` here to keep sender derivation cached and consistent. --- core/txpool/legacypool/legacypool.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index d29b71ebc2..93b3cb5be2 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -1404,7 +1404,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) } From e585ad3b42994ca7e77a34c0f5bcf808d9987e48 Mon Sep 17 00:00:00 2001 From: Charles Dusek <38732970+cgdusek@users.noreply.github.com> Date: Mon, 30 Mar 2026 02:34:23 -0500 Subject: [PATCH 027/183] core/rawdb: fix freezer dir.Sync() failure on Windows (#34115) --- core/rawdb/freezer_utils.go | 8 +---- core/rawdb/freezer_utils_unix.go | 49 +++++++++++++++++++++++++++++ core/rawdb/freezer_utils_windows.go | 26 +++++++++++++++ 3 files changed, 76 insertions(+), 7 deletions(-) create mode 100644 core/rawdb/freezer_utils_unix.go create mode 100644 core/rawdb/freezer_utils_windows.go diff --git a/core/rawdb/freezer_utils.go b/core/rawdb/freezer_utils.go index 7786b7a990..7f1a978b63 100644 --- a/core/rawdb/freezer_utils.go +++ b/core/rawdb/freezer_utils.go @@ -26,13 +26,7 @@ func atomicRename(src, dest string) error { if err := os.Rename(src, dest); err != nil { return err } - dir, err := os.Open(filepath.Dir(src)) - if err != nil { - return err - } - defer dir.Close() - - return dir.Sync() + return syncDir(filepath.Dir(src)) } // copyFrom copies data from 'srcPath' at offset 'offset' into 'destPath'. diff --git a/core/rawdb/freezer_utils_unix.go b/core/rawdb/freezer_utils_unix.go new file mode 100644 index 0000000000..1d26490cab --- /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/core/rawdb/freezer_utils_windows.go b/core/rawdb/freezer_utils_windows.go new file mode 100644 index 0000000000..7b652f7ab5 --- /dev/null +++ b/core/rawdb/freezer_utils_windows.go @@ -0,0 +1,26 @@ +// 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 + +// 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 +} From ceabc39304ec298d891d3cde51b8cfddc6842197 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Mon, 30 Mar 2026 10:01:12 +0200 Subject: [PATCH 028/183] internal/ethapi: limit number of calls to eth_simulateV1 (#34616) Later on we can consider making these limits configurable if the use-case arose. --- internal/ethapi/api.go | 10 ++++++++++ internal/ethapi/simulate.go | 8 ++++++++ 2 files changed, 18 insertions(+) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index bb0dd042ab..a62328e201 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -841,6 +841,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 diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index aa7609ff93..eacb296132 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -44,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 ) From 95705e8b7b6e021b3312c4dc9c817b7646bf67af Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Mon, 30 Mar 2026 10:01:30 +0200 Subject: [PATCH 029/183] internal/ethapi: limit number of getProofs keys (#34617) We can consider making this limit configurable if ever the need arose. --- internal/ethapi/api.go | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index a62328e201..4f217d0578 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -57,6 +57,10 @@ const estimateGasErrorRatio = 0.015 // 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") @@ -362,6 +366,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)) @@ -393,6 +400,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 From be4dc0c4be2fe316dbdd0a73e48421f64978232f Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 30 Mar 2026 18:42:40 +0800 Subject: [PATCH 030/183] version: release go-ethereum v1.17.2 stable (#34618) --- version/version.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/version/version.go b/version/version.go index b9bc87c866..a0e2fe3065 100644 --- a/version/version.go +++ b/version/version.go @@ -17,8 +17,8 @@ package version const ( - Major = 1 // Major version component of the current release - Minor = 17 // Minor version component of the current release - Patch = 2 // Patch version component of the current release - Meta = "unstable" // Version metadata to append to the version string + Major = 1 // Major version component of the current release + Minor = 17 // Minor version component of the current release + Patch = 2 // Patch version component of the current release + Meta = "stable" // Version metadata to append to the version string ) From fe47c399039e513d7b9bae35a66ad153b060842c Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 30 Mar 2026 21:01:29 +0800 Subject: [PATCH 031/183] version: start v1.17.3 release cycle (#34619) --- version/version.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/version/version.go b/version/version.go index a0e2fe3065..ea1f5fc632 100644 --- a/version/version.go +++ b/version/version.go @@ -17,8 +17,8 @@ package version const ( - Major = 1 // Major version component of the current release - Minor = 17 // Minor version component of the current release - Patch = 2 // Patch version component of the current release - Meta = "stable" // Version metadata to append to the version string + Major = 1 // Major version component of the current release + Minor = 17 // Minor version component of the current release + Patch = 3 // Patch version component of the current release + Meta = "unstable" // Version metadata to append to the version string ) From 965bd6b6a0a8a7956c341b2f9adf823afc916b32 Mon Sep 17 00:00:00 2001 From: Bosul Mun Date: Mon, 30 Mar 2026 22:17:37 +0900 Subject: [PATCH 032/183] eth: implement EIP-7975 (eth/70 - partial block receipt lists) (#33153) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In this PR, we add support for protocol version eth/70, defined by EIP-7975. Overall changes: - Each response is buffered in the peer’s receipt buffer when the `lastBlockIncomplete` field is true. - Continued request uses the same request id of its original request(`RequestPartialReceipts`). - Partial responses are verified in `validateLastBlockReceipt`. - Even if all receipts for partial blocks of the request are collected, those partial results are not sinked to the downloader, to avoid complexity. This assumes that partial response and buffering occur only in exceptional cases. --------- Co-authored-by: Gary Rong Co-authored-by: Felix Lange --- cmd/devp2p/internal/ethtest/chain.go | 14 + cmd/devp2p/internal/ethtest/conn.go | 11 +- cmd/devp2p/internal/ethtest/snap.go | 32 +- cmd/devp2p/internal/ethtest/suite.go | 129 +- .../internal/ethtest/testdata/chain.rlp | Bin 451888 -> 457980 bytes .../internal/ethtest/testdata/genesis.json | 6 +- .../internal/ethtest/testdata/headblock.json | 16 +- .../internal/ethtest/testdata/headfcu.json | 6 +- .../internal/ethtest/testdata/headstate.json | 4210 +++---- .../internal/ethtest/testdata/newpayload.json | 10313 ++++++++-------- .../internal/ethtest/testdata/txinfo.json | 2943 ++--- eth/downloader/downloader_test.go | 4 +- .../fetchers_concurrent_receipts.go | 10 +- eth/downloader/peer.go | 2 +- eth/downloader/skeleton_test.go | 2 +- eth/handler_eth_test.go | 24 +- eth/handler_test.go | 2 +- eth/protocols/eth/dispatcher.go | 12 +- eth/protocols/eth/handler.go | 31 +- eth/protocols/eth/handler_test.go | 105 +- eth/protocols/eth/handlers.go | 135 +- eth/protocols/eth/handshake_test.go | 2 +- eth/protocols/eth/peer.go | 257 +- eth/protocols/eth/peer_test.go | 2 +- eth/protocols/eth/protocol.go | 27 +- eth/protocols/eth/protocol_test.go | 11 +- eth/protocols/eth/receipt.go | 75 +- eth/protocols/eth/receipt_test.go | 5 +- eth/sync_test.go | 4 +- rlp/rlpgen/testdata/pkgclash.in.txt | 2 +- rlp/rlpgen/testdata/pkgclash.out.txt | 2 +- 31 files changed, 9535 insertions(+), 8859 deletions(-) diff --git a/cmd/devp2p/internal/ethtest/chain.go b/cmd/devp2p/internal/ethtest/chain.go index 689667a56b..b44e6aa36a 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 98baba81a4..02579f8b55 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 } @@ -335,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 { diff --git a/cmd/devp2p/internal/ethtest/snap.go b/cmd/devp2p/internal/ethtest/snap.go index 7c1ca70cc0..07c75f6ced 100644 --- a/cmd/devp2p/internal/ethtest/snap.go +++ b/cmd/devp2p/internal/ethtest/snap.go @@ -87,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.", }, { @@ -97,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.", }, { @@ -107,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.", }, { @@ -178,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.`, }, @@ -189,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.`, }, @@ -227,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.`, }, @@ -658,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, @@ -679,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"), }, }, diff --git a/cmd/devp2p/internal/ethtest/suite.go b/cmd/devp2p/internal/ethtest/suite.go index 7560c13137..d710f98428 100644 --- a/cmd/devp2p/internal/ethtest/suite.go +++ b/cmd/devp2p/internal/ethtest/suite.go @@ -35,6 +35,7 @@ import ( "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" ) @@ -83,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}, @@ -429,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()) @@ -437,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 receipts 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) - 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 } - if resp.List.Len() != len(req.GetReceiptsRequest) { - t.Fatalf("wrong receipts in response: expected %d receipts, got %d", len(req.GetReceiptsRequest), resp.List.Len()) + + hasher := trie.NewStackTrie(nil) + hashes := make([]common.Hash, len(receipts)) + for i := range receipts { + hashes[i] = types.DeriveSha(receipts[i].Derivable(), hasher) + } + + for i, hash := range hashes { + if receiptHashes[i] != hash { + t.Fatalf("wrong receipt root: want %x, got %x", receiptHashes[i], hash) + } } } diff --git a/cmd/devp2p/internal/ethtest/testdata/chain.rlp b/cmd/devp2p/internal/ethtest/testdata/chain.rlp index 7d4f4b3efe5d204312966e56040e759ce53b6600..d5209ab0413ab9977afa596152879ae8d95ae556 100644 GIT binary patch delta 157748 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 IJ&sKIe{Ps05dZ)H delta 152997 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ⅅ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 diff --git a/cmd/devp2p/internal/ethtest/testdata/genesis.json b/cmd/devp2p/internal/ethtest/testdata/genesis.json index c8ed44b885..a8963b30ea 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 bb5244be18..da18081d34 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 9ab3a4de1a..eeb2ea5829 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 72c7ebd509..982015d0a5 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,190 +1833,187 @@ "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": "0x2bf43f06b9f27c71498ec5b782da1259b2a6eb02fe7f9136c3d0b2858c0f6e09", + "code": "0x20d186469448ced763a24def3f3468c9b40577d59eac422c275a9576c439d86547d8af78512b204f644d8f13cc57c25ffeeb27f5044fd719cb9725d000fe6aac4851de8a4df83c855557329789c7e5ef967a3a084e4ae3784f2778aeb8b86084e46a11c5890976e15441eaf10504a1b4f452c682aba2316cc50045a1455c86e09a2621996aa68bc125b1cf3679db117591d94cbb32bed7853d075ac666de26906f4dd0040cdabb3e17c91cda6a1798a305913c9e276fa80b450a4dac0e46d04e056520d4601757791117f936edc6e5228e597c55498227034e003251987fdb0f6a7e37735eea420ba517b5284cd84328feb0209a3069f0ddbf84e94193c44f37", + "address": "0x017aae1940b253e7afad292098eb59e6c64e9bee", + "key": "0x08440b5468b3c640fa97a13fdaabbe5bf5fa0d0035a457b43aeba20442a9335d" + }, + "0x03B745d7f28eCfd7903f746B9d3d36f56E004C73": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0175c17de53473bbf136e6af7086b8700b43cf38", - "key": "0xf045ac5237b17e93661fe75054f95cc76df4c3b668f0e4a1d8f5daebc12a85c5" + "address": "0x03b745d7f28ecfd7903f746b9d3d36f56e004c73", + "key": "0x0af10a79f7cad0388da160fbb23ba70ad0093166ea4b5cfb620dd59bc84357f7" }, - "0x022916D4E98bF4d48884Ad1cB9c4aA58CbfDc970": { + "0x04361123c6CBFc38F6Ee7B0202ecEFdaE36efEB4": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x022916d4e98bf4d48884ad1cb9c4aa58cbfdc970", - "key": "0xf80cab3980ad7df8c2fc9d0f457c7fa62e4a5a2e0e0057ad96302ecc3d1e6cd3" - }, - "0x0242186831F57A6FC1177d96F18B31E8bF67E7AE": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0242186831f57a6fc1177d96f18b31e8bf67e7ae", - "key": "0x022c043e6e7e719985ea4071080e6532d25dc102f3fffa2d96db43eeae4e8dc6" - }, - "0x0300100F529a704d19736A8714837adbc934db7F": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x730f4b9a001161056466356bac602cec9aea791a93eee35887c5b445c1ba84d2", - "code": "0xa3460b9064575a01ae448ac16880d3d6297c3b1b3ed6401e5e55576437da869cb8268a6811e35185c888408dbd03c24dd26f48c3ed147cffb085165a9b915e99d9c7c9af5ae3bd9d3c51ae123d91d0a46beaa95906b5f109f17d5f466c68dbf5e7484af6bbc8157ed372968cb5ffae804c38bcbc5773bb07433d44bbcc6ebbf0599ef2d67d4a71e24d4f29210ed925ef54d64da410ce44512c56a7a472cfb0df80db63b10209d83bee8914a5717573d21b5817ca696e60bfa859102ac5a737f7e23d3626096a70b8a02737a3c2f960e5732ebae39d6a014de867a32a96f9bd4df5d6daae740c69c53563f540b21d345f00222698cc33e6e7a4196bed610744c1", - "address": "0x0300100f529a704d19736a8714837adbc934db7f", - "key": "0x97b25febb46f44607c87a3498088c605086df207c7ddcd8ee718836a516a9153" - }, - "0x075dB7AB5778cd5491d3ED7Ab64c1Ec0818148F3": { - "balance": "0", - "nonce": 1, - "root": "0xd3f27d2eba503b1af71052fe41fe4073a680ebe483f428d3caf50e94dfff12ab", + "root": "0x34af31de538687879648eb811e76794299920242a507de08c946638fe1def18d", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000019f": "019f", - "0x00000000000000000000000000000000000000000000000000000000000001a0": "01a0", - "0x00000000000000000000000000000000000000000000000000000000000001a1": "01a1" + "0x0000000000000000000000000000000000000000000000000000000000000035": "35", + "0x0000000000000000000000000000000000000000000000000000000000000036": "36", + "0x0000000000000000000000000000000000000000000000000000000000000037": "37" }, - "address": "0x075db7ab5778cd5491d3ed7ab64c1ec0818148f3", - "key": "0xf84223f460140ad56af9836cfa6c1c58c1397abf599c214689bc881066020ff7" + "address": "0x04361123c6cbfc38f6ee7b0202ecefdae36efeb4", + "key": "0x3960cb77ee8ce76e0a84773c1d222795fba838aa28edcca2045779467ef3fa27" }, - "0x0767637af7aeA66d876BAC94769Da962Bb4D93F6": { + "0x08D3B23DbFE8EF7965A8b5e4d9c21feDdBc11491": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x0767637af7aea66d876bac94769da962bb4d93f6", - "key": "0x500b6c47c37153a6d5f95cb6503d4d6677f1b875ab80b7d12a3e15db75573930" + "address": "0x08d3b23dbfe8ef7965a8b5e4d9c21feddbc11491", + "key": "0x792cc9f20a61c16646d5b6136693e7789549adb7d8e35503d0004130ea6528b0" }, - "0x08B229256Ba635C4500B5bCd23C8df2E06FD2666": { + "0x0Aa79FD7C1C0e7E00c4ba9feE89F49D7daa0B61B": { "balance": "0", "nonce": 1, - "root": "0x533722a718cdf4f4cd17633807044d1e14f967b005430f7aee50ae9a4844c16d", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x0aa79fd7c1c0e7e00c4ba9fee89f49d7daa0b61b", + "key": "0x5d09cbe91ea3932998d10a7c8106f1f4fca78689ff14cc078317a695f449ce14" + }, + "0x0EF32DeC5f88A96C2EB042126e8AB982406e0267": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x5fbc8fe8138fab7ad184ea266f527d1893aab90dda28f7d24be94b959c96ebdc", + "code": "0x8a1b5c8cd5b7bd4a981a9c76dd66b7aa945dc8c3e0d495c4302436789fc22deb28c3ddba77ef852302eb67f6ce73e9c25e4571d861f77ad858cbfc3a8b54fb6f354d8a99986db445a0165d66c40c5165c1279120b31bd4c3c2f2481f7db470b9b2da59e7d1f8c6f5b402f26d36ed8613aa166b0402cb67bf66827eb445a0425c4b1129d94a51518e06a7990c71f442b0b66889854dcec1ddafaf1a71b43c7d0d973d75199dd705c0c68e8de5860d9d79de36c934e6e853a20e564b4cb3df71d70f7c04ea896bef7c7bf375a13ee362225e123d9012b8c6b13304e824fcd38751e836b707360d6a982410a47a44158b01d3eed14352c6353955a96cff8a983bb2", + "address": "0x0ef32dec5f88a96c2eb042126e8ab982406e0267", + "key": "0x181abdd5e212171007e085fdc284a84d42d5bfc160960d881ccb6a10005ff089" + }, + "0x0F228c3Ba41142e702Ee7306859026C99d3D2df5": { + "balance": "0", + "nonce": 1, + "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", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x112e887c13720ea0ea8ab3c2ee9639155ff06e50", - "key": "0x171124648329d6a061328d1189b14f64e3da43648255489dbc67168331936bc6" - }, - "0x1218Cf397301c287Cfd4a2Bdbd922A3432457388": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x097d31b10fc018fa01b350d82033872d007057b464560cdc1afd34fcddb14501", - "code": "0x3568ac4853d98daec689c5f2aa7d3141dd0256607e02057f4de3da3f333907ff9b41fe675cf46e85813b95622c1329ddda8c317b528ee44b3cbf5c27b8b8f7e5759c070bd3698aa0ecb5628e2a94ee9c0fc87c120f625d01a781262556e517bada8419d7f831676b15592f36811aed673124b0b8123e5c73e1ea68245a6ccf6457969cb441519f4b2cd9b0a57d7e95a7eb2c5e3f719cad38e8c60697bef8a3c2e153613a7c973b978a2b720f5225dbf4b83bda7128b3fd13e56307208ddfe0c77c2ebe6bc91f70109fbacaade46e1cb5258e806c9970c9d5085c13d5e23751de34ee70246abe44a6ef3f9dc451e68ce7669b7393fc4538f9fc58aec8dbf5b825", - "address": "0x1218cf397301c287cfd4a2bdbd922a3432457388", - "key": "0x887e6e4c23e7a93a0c66f56b8ac9b5399d205063604ff2f093c5b2d30af481e3" - }, - "0x132432ce1CE64304f1D145eBa1772F6edd6Cdd17": { - "balance": "0", - "nonce": 1, - "root": "0xa8cbc3846808271a2bf0580ee9da43b36853292ce79dbe0bc785c62337eaec86", + "root": "0x02c382fe4494fbb1df7e05021bd783c68ee4d3d0c82baad3d7a91cd910f3dac2", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000006b": "6b", - "0x000000000000000000000000000000000000000000000000000000000000006c": "6c", - "0x000000000000000000000000000000000000000000000000000000000000006d": "6d" + "0x0000000000000000000000000000000000000000000000000000000000000148": "0148", + "0x0000000000000000000000000000000000000000000000000000000000000149": "0149", + "0x000000000000000000000000000000000000000000000000000000000000014a": "014a" }, - "address": "0x132432ce1ce64304f1d145eba1772f6edd6cdd17", - "key": "0x729953a43ed6c913df957172680a17e5735143ad767bda8f58ac84ec62fbec5e" + "address": "0x0ef96a52f4510f82b049ba991c401a8f5eb823e5", + "key": "0x59312f89c13e9e24c1cb8b103aa39a9b2800348d97a92c2c9e2a78fa02b70025" }, - "0x13f3F31335881a7402955Dc3Bf0b4A62936b44aa": { + "0x10FA59f55E0876fd0742a892CdC28522a44d0Ac4": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x13f3f31335881a7402955dc3bf0b4a62936b44aa", - "key": "0x6742b9f65e686fd1b9da73a3a29541cbb07afaaf51b5b5be682b462131709388" + "address": "0x10fa59f55e0876fd0742a892cdc28522a44d0ac4", + "key": "0xf1030dcbd8e148d0bb4baa102b98525fdff7fb308c789a245aa66a8402d2344e" + }, + "0x123B4998651f811E46D2441aeFECfd2FacD29b36": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x123b4998651f811e46d2441aefecfd2facd29b36", + "key": "0x9024e9b7859e438367088a1d007cfd7ede3ee942414862a496b8f63601d6e615" + }, + "0x12a0aB4dF31cfDf42713Dc3cEebFc710FE675b3d": { + "balance": "0", + "nonce": 1, + "root": "0xe2a164e2c30cf30391c88ff32a0e202194b08f2a61a9cd2927ea5ed6dfbf1056", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "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" }, + "0x17b917F9D79d922b33E41582984712e32b3AD366": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x17b917f9d79d922b33e41582984712e32b3ad366", + "key": "0x13cfc46f6bdb7a1c30448d41880d061c3b8d36c55a29f1c0c8d95a8e882b8c25" + }, "0x17e7EedCe4Ac02ef114a7eD9fE6E2F33Feba1667": { "balance": "0", "nonce": 1, @@ -2026,82 +2023,17 @@ "address": "0x17e7eedce4ac02ef114a7ed9fe6e2f33feba1667", "key": "0x69bf6d72df9e6b88306eb4e4624996e919f0433ba63520aa9a1d3f9888e09b1f" }, - "0x18291b5F568E45eF0f16709B20c810E08750791f": { + "0x19Ee2Fd8a16B0d5348CC43634E3015f5c4eC281d": { "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": { - "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" - }, - "0x1E8CE8258Fb47F55Bf2C1473aCb89a10074B9D0E": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd5daa3aec1f142e2b2059b675d676ccb42129d27d96f8e901df2dac6104b38e2", - "code": "0xf548adfdedfd2f8b2416994318306c690dadb026395430e32e9a141187933c8602d9f8353bca53bc9b195aa186ab6d98b49a9120c00257ee2c7d860c26f864ea7352bc45c8aa6995480780fe15a07c4daa795263b5e7a9d04d9ed979c93ca85e57023ef7fe58b878582140ea36f22723905ad724896eaf74090fba76c229bd2269bc8c08a6b955aec2072ca430bac7123bc3539264a736d1a23621b0f0c62f3166eeecffab615cf4c69d47d3aa51576e95b697767264fa754ea36f4e363ea19359149054a4189e9e52234a041160d0a984f6bcb43e7a9da69cfb168d147633650425d4cac564eade3739b18cff91bb2bc855f9c26bed98f6e089d895e00c3d5f", - "address": "0x1e8ce8258fb47f55bf2c1473acb89a10074b9d0e", - "key": "0xfb2ab315988de92dcf6ba848e756676265b56e4b84778a2c955fb2b3c848c51c" - }, - "0x1F12d422bFb4444EdA416C805B0eBC9C9C5219b9": { - "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": { + "0x1bE75a06c0277c0ad20d2a7B537A4E3262ae544A": { "balance": "0", "nonce": 1, - "root": "0x2ac8ab8e205b5f066caaf29772e71b8acc033fb2dd00aef81d58d5c6cf41393f", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x721a89c9ec88bf5d831f58a8fc24ee302af110b17d80413835d06f29e56c24cb", + "code": "0x977b44b92ba69610c99ea306058ffef6449dfef2a9111a242e2487f3b67bd884e1c7dc25d93c8ca94ab03df899ffd8369f903d70f89208ea0f9216c56c311f65a7ab9585d176f7553243ab24f6ba2b1d026cba57011704693e8f7e688fc6c10272f499da03a12e0d69bedeb8af54720422e6a93707efd07a19d40b1693edd7746269a42f8721783686df7e2d53dfc3e449c24381e01837fc0db59bddaf4da17fe35f100537fc5a81611a171b65ec62698d902d6c24f0dca36213fbd791d816cad51254392213b26261c76c6dc24d6f095073d42a479d10d1abaf6cbc5679bb519651205dc817afac4f6b337402a37ee248db015896cb81056928573c24869cff", + "address": "0x1be75a06c0277c0ad20d2a7b537a4e3262ae544a", + "key": "0xc02a1a280bf5e9f8aee1a855dad87a7d58ba42d4d58909c683dd62e220cb917f" + }, + "0x20bcaA573F9D21A04b8434F31f23b146F3178cf7": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x3a53ca9ebc623f96f3c01edfc2cfea906df6afcdb46fd4cd0c5ef231dcb247b3", + "code": "0xa0154eb5d4f58d1845cc59d98da9dc0526a385100cab80e881cf68c5ddd774d6c83df05b39f04b0e32a580fb2457e5a805b04291544a17fa7d0673ae46aa593e16cf53eb5237943918e4520255055c6e4c38e4c0d88373b478ac80453df3aab44a5bde82e5995b6780e708038ec38d21cac5aa8ea437e42bbb7a345c96e77afef5e826823d1b521a059a638208df20ec7a83c69ba78f1fe2089269842362b6d9f6a2fe1e948cbfc587c2c82d46a9aef3b8bf6d2ef795f19d1a32a7aa457123ebb5875b78058b3879b3385f1925ff16e04250b3cad255a1746f02b5fd66a379ca2c0fb383035f53c87dbc233aba2b5c9852b97d153d9a9e79119bdea4a5918250", + "address": "0x20bcaa573f9d21a04b8434f31f23b146f3178cf7", + "key": "0xefe19584458047edddb6b4c43bb36ef63fb1d5b8d3c630c09a27580302790e80" + }, + "0x21171D0AfFf7169E5692bf7bd5ADb43AF0f5F59E": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x21171d0afff7169e5692bf7bd5adb43af0f5f59e", + "key": "0x2d425481284fbb1874a2c55d81564f371543b3b8f7450e860bc5381ba47b465f" + }, + "0x2AEB07Bf550A17EB782474376C0c1b6d1164d623": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x59ea8e8394dd6ada740962707b3d7323a33209aa01c521f7633914c990dc4e72", + "code": "0x5d4702183e4406aa0103cf4e1193f621dd93a4fef034dfbf6d5fe2604aabfac75a13f6356acb2f32ad5f7b35e3b5cce60828c11d4777e62d521196ece8fb340983e3008e3af31fcc69e293b6825b3fef522aa83473e56e69122349586a735e2046df1ba032f7273adfb50869ef5a17a8fffe76f90e9f8294290a3c9b9484add5b21769473a98c1ba3e6d2bc72b8bbb799cd2c30a9cff3f1428f7037f772e03eda237ad7935dea2dae206a9f954a0b3f021aba3d29281f5d8e9d20fec92bc90bdf9909f4b035d96087c3a4a8df382d8d87641eb9e01c03c2f87643b292928b907b62e1dce1317f4e156490b590e91d0e333ceb760dac2ddef3bd251cf89fa8776", + "address": "0x2aeb07bf550a17eb782474376c0c1b6d1164d623", + "key": "0x81eb53bd3cdb01b239029a40c5362aa81a9017921981d1f188c2b7df594203c2" + }, + "0x2B0c6fDcbEc5dc0e3a89e2Dc1f4f3E8e381E200f": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x2b0c6fdcbec5dc0e3a89e2dc1f4f3e8e381e200f", + "key": "0x92e7a2e08d0b020127e08b5d531e73506805651f6cab173d836f43566dfffe0c" + }, + "0x2BD85770Ed2Cc8d09f91a3C1b0F7197dfd8A8850": { + "balance": "0", + "nonce": 1, + "root": "0xcbf1eba0bbd55dc6bf80b04aee815e20cb66ffea5a015c3fbd8ba5df2ccae82b", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000a2": "a2", - "0x00000000000000000000000000000000000000000000000000000000000000a3": "a3", - "0x00000000000000000000000000000000000000000000000000000000000000a4": "a4" + "0x00000000000000000000000000000000000000000000000000000000000001b6": "01b6", + "0x00000000000000000000000000000000000000000000000000000000000001b7": "01b7", + "0x00000000000000000000000000000000000000000000000000000000000001b8": "01b8" }, - "address": "0x1f94c5d92a7cda91e46258db39cd2080934cf401", - "key": "0xade3931ebf0e80c7ff1ef57f79e1a3bee133066fbc2f65c98bde9b9751c59fd5" - }, - "0x1aE59138Ad95812304b117eE7B0d502bCB885af5": { - "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" - }, - "0x23946FCc6A6FC157F5fA71766920C05B3ca332A9": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x9b8e6ae27d3f687d8da6c6cd00910988ee2f132e69a9039495349f53e5d420d4", - "code": "0x2200b384d5b1adb897ca35499aac189a6bc95554ae7cd569cff630ab95ab2408ec2ece864d596b2df3fda60d8ff3647904c8787bbcdca061ac2c3ced7ec882414e891f8214eefddacb67949285b4d8381359bda85deba8c8d1cd531fac277446250aa56d419d6944c75ef323c37456f10c8deae91a088f5266af04395bfb6f9f1d83040a41828888b050efc081f5d66c96d76f2436e80f14429fe3ba7679228b5d30ee1cebf81682922812857932b35925ce3b0005995d8dcc5cdc3ade024209b45d823cb873a82c40322caac58ec73ecb33fe985c8d73b5edc8c5bd10a32dacbd709dd7349a1e346060645a803266120e2ad65cd1489f355739a06ccb96006a", - "address": "0x23946fcc6a6fc157f5fa71766920c05b3ca332a9", - "key": "0xfb1f3c0b3adbfacce7162c4512f5e01da2e45f783d1d098d59478ba98579a943" - }, - "0x23E7eCFEbfe3a69F17F90fE6AFF700c395C502A4": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x23e7ecfebfe3a69f17f90fe6aff700c395c502a4", - "key": "0xed63eed77538b7d6aec65f20d6538407bb521bcc2049f5227f0ba7125f7e5246" - }, - "0x23b17315554BD2928C1f86dD526F7ee065a9607d": { - "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" - }, - "0x26e92A8D6eDBD0b9cED1dd80a920Ad0b796fCf93": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x26e92a8d6edbd0b9ced1dd80a920ad0b796fcf93", - "key": "0xa28e6adde4090652685168a269cb1141e28b0849487175237b9b32064788c2f9" - }, - "0x2C0cd3C60f41d56ED7664dbce39630395614Bf4b": { - "balance": "0", - "nonce": 1, - "root": "0xa3e3987c498c56b398b12cf368a76f2d184dd1d77b4896f4626909e35a7536d2", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000c3": "c3", - "0x00000000000000000000000000000000000000000000000000000000000000c4": "c4", - "0x00000000000000000000000000000000000000000000000000000000000000c5": "c5" - }, - "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" - }, - "0x2be6F9Ec5d4a0E79953570f06554FbFf9473B11E": { - "balance": "0", - "nonce": 1, - "root": "0x9e2e9c13c28b856f12884ebd17a330603ac2294d472aa7b0caab80761af0ae9d", + "root": "0x1d5b0045e4bbf5ac05684b7f97ad373b57bfa9fc07e8c214c28624f7ce9a47a5", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000076": "76", - "0x0000000000000000000000000000000000000000000000000000000000000077": "77", - "0x0000000000000000000000000000000000000000000000000000000000000078": "78" + "0x000000000000000000000000000000000000000000000000000000000000002a": "2a", + "0x000000000000000000000000000000000000000000000000000000000000002b": "2b", + "0x000000000000000000000000000000000000000000000000000000000000002c": "2c" }, - "address": "0x2be6f9ec5d4a0e79953570f06554fbff9473b11e", - "key": "0xc5a247c452045b83598d9bdb0bfc185eadffbc577e2f8bbafaa5339d2adac545" + "address": "0x2eb6db4e06119ab31a3acf4f406ccbaa85e39c66", + "key": "0xaeaf19d38b69be4fb41cc89e4888708daa6b9b1c3f519fa28fe9a0da70cd8697" + }, + "0x2Eba46D62F0C7DFCdc435769A2d5Bc73FC311ee9": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x2eba46d62f0c7dfcdc435769a2d5bc73fc311ee9", + "key": "0xf132caa2fde1cb1d7854da7631c474d928ae153b5ebedf16d262d5bd28a4ab48" }, "0x2c1287779024c3a2F0924b54816D79b7e378907d": { "balance": "0", @@ -2268,98 +2151,91 @@ "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" + "codeHash": "0xad3bcddc933488cbc5a30cf7295a338d57ecdbce88acef961e28fc0267fafee4", + "code": "0xb84e4298f3a6292774b798b43a202ce92291460f19fe80ed2d2d7e8e4674dcba31ff9da46623ded696608610c3749320b1cb2c2dfd644b1139da5367a8e616cf82fb8bdd0a53542a1f59046c16f7a1350c43d22db36425bb53f551e7c6a091814ba0d371c59a4c8176901cb7799ecdd8b41b974be3a1349b5d0a9ff9aaa230d9547911337f50119fe7598b1be3fa84d3d0506ffe5c730db17c43bc74040bbfce348e8fe0716b12afdd2e814ae0b8b1bb9b5c7a197ef418c73b8bdd93bee14de5c695a062ea1c0f75fd266ccc34c407f7d5229534fc96b1932c122008903fa35369a4526ee6c6fed706e20afa2cce030b28dbcbab5e4e2d1918c6e71839728400", + "address": "0x32c417b98c3d9bdd37550c0070310526347b4648", + "key": "0x80cd4a7b601d4ba0cb09e527a246c2b5dd25b6dbf862ac4e87c6b189bfce82d7" }, - "0x38D0Bd409aBe8d78F9F0E0a03671e44e81c41C27": { + "0x3632D1763078069cA77B90E27061147a3b17Ddc3": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x38d0bd409abe8d78f9f0e0a03671e44e81c41c27", - "key": "0xb58e67c536550fdf7140c8333ca62128df469a7270b16d528bc778909e0ac9a5" - }, - "0x3A2C11526F95C05A5de3614E9c40666798C5F9b9": { - "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" - }, - "0x3C48a562A0361236F28a17AAC65B9130a0316B71": { - "balance": "0", - "nonce": 1, - "root": "0xd8419536b78c13ef996838648ee38f89388fe1ffdca0b92bbbd78187a54c3f49", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000034": "34", - "0x0000000000000000000000000000000000000000000000000000000000000035": "35", - "0x0000000000000000000000000000000000000000000000000000000000000036": "36" - }, - "address": "0x3c48a562a0361236f28a17aac65b9130a0316b71", - "key": "0x8ff8a4884137e983c0298ad24228193292b5f523869dc16eeb916cae8b09239c" - }, - "0x3Ee253436Fc50e5a136eE01489a318afe2bbD572": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x3ee253436fc50e5a136ee01489a318afe2bbd572", - "key": "0xaf7c37d08a73483eff9ef5054477fb5d836a184aa07c3edb4409b9eb22dd56ca" - }, - "0x3aDfbF5A4B4493AB10b6d695E5a6f7f91F768098": { - "balance": "0", - "nonce": 1, - "root": "0x98d78678d41a3fbfda98fdf2709727e38bb15bf11287e7204299ef5a125acf8f", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000022e": "022e", - "0x000000000000000000000000000000000000000000000000000000000000022f": "022f", - "0x0000000000000000000000000000000000000000000000000000000000000230": "0230" - }, - "address": "0x3adfbf5a4b4493ab10b6d695e5a6f7f91f768098", - "key": "0x83d7634225a59c664f323c88bcfaff1cf73421ed036ccd2dbe44571312128db7" + "address": "0x3632d1763078069ca77b90e27061147a3b17ddc3", + "key": "0x0463e52cda557221b0b66bd7285b043071df4c2ab146260f4e010970f3a0cccf" }, "0x3aE75c08b4c907EB63a8960c45B86E1e9ab6123c": { - "balance": "1000000000000000000000000100000000012", + "balance": "1000000000000000000000000400000000011", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", "key": "0x878040f46b1b4a065e6b82abd35421eb69eededc0c9598b82e3587ae47c8a651" }, + "0x3c204CcddfEBaE334988367B5cf372387dC49EBd": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x3c204ccddfebae334988367b5cf372387dc49ebd", + "key": "0x5ec55391e89ac4c3cf9e61801cd13609e8757ab6ed08687237b789f666ea781b" + }, + "0x3fBa9AE304c21d19f50c23dB133073f4f9665FC1": { + "balance": "0", + "nonce": 1, + "root": "0xecba188c60d6fd06bba6dfad2fc6162c590d588ec0db0953b033ece234571816", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000040": "40", + "0x0000000000000000000000000000000000000000000000000000000000000041": "41", + "0x0000000000000000000000000000000000000000000000000000000000000042": "42" + }, + "address": "0x3fba9ae304c21d19f50c23db133073f4f9665fc1", + "key": "0x0b564e4a0203cbcec8301709a7449e2e7371910778df64c89f48507390f2d129" + }, + "0x402F57de890877dEf439A753FCc0c37ac7808eF5": { + "balance": "0", + "nonce": 1, + "root": "0x1255f3a2840f807a7966373c9961a98cb3257bcd1b5932ed04b5708ddb80f81a", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000106": "0106", + "0x0000000000000000000000000000000000000000000000000000000000000107": "0107", + "0x0000000000000000000000000000000000000000000000000000000000000108": "0108" + }, + "address": "0x402f57de890877def439a753fcc0c37ac7808ef5", + "key": "0x5c20f6ee05edbb60beeab752d87412b2f6e12c8feefa2079e6bd989f814ed4da" + }, "0x4055CAe5c7d838cda10D40f9d07106C7f5f3be1c": { "balance": "0", "nonce": 1, @@ -2373,731 +2249,809 @@ "address": "0x4055cae5c7d838cda10d40f9d07106c7f5f3be1c", "key": "0x6b9ff41fb13fc66c4e1c4f85d59c52608698715472b7cce609bdbf75976a438b" }, - "0x417fE11f58B6A2d089826B60722fBeD1D2Db96dD": { + "0x410EaCE40803A705AdF026fE52367EAfb8845639": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x35e6505af3b8e9a18eefffd4dafa37f401469b1932fa2011ce72a78ea72721ab", - "code": "0x36156009575f355f555b305f525f5460205260405ff3", - "address": "0x417fe11f58b6a2d089826b60722fbed1d2db96dd", - "key": "0xd5e252ab2fba10107258010f154445cf7dffc42b7d8c5476de9a7adb533d73f1" - }, - "0x426Fcdc383c8bEcb38926EC0569Ec4a810105faB": { - "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" }, - "0x47e37FB6Ade990175D502C02DA3Dc3607b9D0080": { + "0x4DC5e971f8B11aCe4F21D40B0EdE74a07940F356": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x30cddb925e3f4db7ec9bb0259a1726f79627a71b97dfdbf8827cce2ff258fc64", - "code": "0xd6866844f1a8c30f9968e80fa46697288da4b41c675b67a51469639e5afc24352ad561dc52a39ba65c35d8ffc50780b2be420e6593582aa43068d94afe08aa0ba82effcee24f9d07d1b8ac005bd5c8627d3d8c14e389a86d3b62ee3d5f63ab8910f3a17841c6d818ccbb16e4596978865bb77ba586b583c9de26b166e55de864aaded8c7cb956d25d285cba29213c176ec5fc32f3996cb04804f6c9dc496ea728ec4d803bc2cd2bec8ceaf2e5a0dec14ca32ca78fa74656eb25549e85d5772b1a241f58d1f790a3686289a7a511e6884e534f73cfe21a83706dadf334c70edd8a42755a2e6766ad8a3c8e0dc6925c5b384a166afae805bfb4a3c3233012e5345", - "address": "0x47e37fb6ade990175d502c02da3dc3607b9d0080", - "key": "0x7842c57cd7a74b4a6b925c5db7c5953f7c65969fedc3f81c087d6ddf9322e6de" + "codeHash": "0x35e6505af3b8e9a18eefffd4dafa37f401469b1932fa2011ce72a78ea72721ab", + "code": "0x36156009575f355f555b305f525f5460205260405ff3", + "address": "0x4dc5e971f8b11ace4f21d40b0ede74a07940f356", + "key": "0x010c21d7a511db44071d870baf13ba54cbfc4937cae61371a71bcd5767e92822" }, - "0x4816Ce9Dd68c07aB1e12b5dDC4dBEF38792751C5": { + "0x4FFFb6FbD0372228CB5E4D1f033a29f30CB668C8": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x68fe999031d902f2cc91d087a2598dbc4461ac613484a5e190363612bbb7b26a", - "code": "0xfcb16150feea765524e9631cb7d1c8fad9ef75bffc2b9555ecc778186e5f140839772aaac033ecb199d13e70c3b4f8460b29cb5c3706d73d2ca45ca99b4ca34eff4638b33a6cbf8dc1ce4956e292e68da624d971bbf286cb7b35f308cea1c92b25449fa2e7137906e514f13986232d0f39f369be718e81f160ca187154669ae03a9dbf973d57393fa007fb8bd8b707e68131e5350075a7173b126035e7d5ef0800865105d845ec42a1bb319d16dde04301a355a4a41c6bd516f7937fbef9e4a44afe6e90eec383b191ec32dadb5b4f777a12a1e05ead60984ca62aa5eb8c24a5cf02837130190a95dcc836111e3f8751322ffcf187e84483660b9878a189eb2f", - "address": "0x4816ce9dd68c07ab1e12b5ddc4dbef38792751c5", - "key": "0x93843d6fa1fe5709a3035573f61cc06832f0377544d16d3a0725e78a0fa0267c" - }, - "0x49790702079905E7fF97976DB38b586cbC8d8f8F": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x9231a45606b88ef38e96170f698ef8b8598e49b17187c2e70bc225e6a310cc36", - "code": "0xe5f0063c1029cda3916753b401644c6cf5a2638073f3d047231d47d090ece5034da2fdba370917407bf27824b5e855154d59c9cf9fb85539d72027a97766a6847cddfe6ee35b633c2515d8bb92b0535385c25ce39e902fe4b910ed87a58a3b60cd3081b24d2bafaebfca188b94ec88c4e89cff1900493426655481a8976b4844bcc8f9a3b8acb6eaeffd4381f3d6cf8b3246ec37986171ade75dabece51a6f930482edbcb3ac47f314e74e8a59cbb23c7d36fd54f30d440cd1e2368bac348c0234d70136299f76a744ea8afda8ebddfe1632bb03a70f19f9a17b6d3d3ba5575326dae0c1fa21b43457f9f70b55c25fa5dbad768871d3a55b8d7fdbbe10bdd96f", - "address": "0x49790702079905e7ff97976db38b586cbc8d8f8f", - "key": "0x13fb7f6b6fcbfc3892b99fb37dfd04ecf3c8d56f2d14add9517b76ea9555c1a3" - }, - "0x4A5F072863f868E00D0039807EE1d00F783335A0": { - "balance": "0", - "nonce": 1, - "root": "0x4ba055b3d6ea2c0c46b8cb5ee08f6999487ff7d49e3e4fe566ae049608f647aa", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001aa": "01aa", - "0x00000000000000000000000000000000000000000000000000000000000001ab": "01ab", - "0x00000000000000000000000000000000000000000000000000000000000001ac": "01ac" - }, - "address": "0x4a5f072863f868e00d0039807ee1d00f783335a0", - "key": "0x8fa1ad571a8b9c6e679630b6e0d38d678311338dc0362f9303d10585aaf26d88" - }, - "0x4BE1C90eB0389A67A16a0d3027AFbE68eB26Fa40": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1cb937eefd555a5cd91fcc756cc135b04866df6c4e79b7fadf8ee10c0e8c45a3", - "code": "0x6bf91e8d24ef545af6a807b0be29a4dd23c0aa47cf86b2cc206ca5ea23e055b2508079f55449251bb3bbdddb22a48768402fe704ba650632035ff2d1f076fe8ed4dd338702652a43f9ac2b2bb0a6113f819db6a79f2161642d6d00325b6004b409c221adb84d5771ff4acef6600bf4bcaae01c6e3b391a7a61d09dd98b033b4d5a720867e9fea2afb6fbd35e6fcef36c6937fcecdcc9d43dcf109be0eaf9b0f76f25c0a5b9213781766d43fd87d9b3c49063e227d41ca646f0041bc234e3f0b821cc2999d14cb884f78fd8d378149fefb96229f402ad786759cb00743d06a86d4128452ee0fadc2e40ee2c2df6066f44872006f24784df32eee9df0d59afcb65", - "address": "0x4be1c90eb0389a67a16a0d3027afbe68eb26fa40", - "key": "0xccf7b06a67d8943c3e6f1af42977144fdcd4e35c5935804dccfab975d22fafbb" - }, - "0x4Ba8273797F206A13B4d13239A9C7692951Ba5Dd": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x6bd773abf6bc040838521c9de345cfedbce33617c4c7dc7e28ff79ee67576911", - "code": "0x7c263fa0a5ccb147804e1651fd02a4a91952936ded9df2b9563f58d3237deb6a2d4d9a6ec39bf84ae0d7d0d9e45117cf3fa3d0fbb6e82c52a370dde3249feff83cde3efd24a4795570409a9e1b6dbf5422dfd717e5210b527266f77c827cdf45d903a9ee0bc20272238d57d8e5255e7e6042b6f02f15379507de7f4fd2d73e2efb5e2c639adf6f19556e762eea9953bf8c1f92c6a39651186429f581ab8068491845cf6ae7e4ea2bf7813e2b8bc2c114d32bd93817b2f113543c4e0ebc1f38d29c098d85f6b83561069bae1c5511a0bbd59215ff2718b423e828420534b07ce255f7fb2960e0b7d7b8eaaaeb07b847a0fcd209d4e050e30df0ea578f57d3dabd", - "address": "0x4ba8273797f206a13b4d13239a9c7692951ba5dd", - "key": "0x48c2282032e9f2a065de95c075888d04a8dede9499b3c4837179b81d6992c572" - }, - "0x4FdE47c424dddFb38606FEdaE5b6522D8aC6C3e3": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x314204915e2b98401a3ade8178f328eb28e28be295588c447b09b5ac4a782140", - "code": "0x825cb36b0f2510a04cf6a63d38fd27bab6d05658e3c7b75a8e0bc0433c0ad1d83254a08c6b1f2452e29dd01c1d0c85218d57ed34adaa4d9e3b5080f944b9bd85a0b82392ca930f909da3e8f1e1b75001281d70a8e3841b3b4dbad931d5554bd4fbca97ca5841cc7bc1e64c05a3e88ed0241af42ee1c0e65d806d2bfb6bb7fcde939a97a2cdf42f5b2accc7a97b393a7e41066fe584741a52b411280ec3e57603acafcf2c60bf92bccb8c65f5ccffb377b9ab5ab1e8283e2807c12a0c2ffc1ebeb63423a192f69a0ae0d422d5ecafd6a0773a3869d94cfcc860a907e75f293a84a569f999e0f44f33e77ec9059a51b9940e65c0f955f48a7dfe61f7c752a08a8e", - "address": "0x4fde47c424dddfb38606fedae5b6522d8ac6c3e3", - "key": "0xfb620e9421928a795a331d223b11ab476c45372f2c7c3dffc9b13f0e1812b05c" + "address": "0x4fffb6fbd0372228cb5e4d1f033a29f30cb668c8", + "key": "0xf19ee923ed66b7b9264c2644aa20e5268a251b4914ca81b1dffee96ecb074cb1" }, "0x4a0f1452281bCec5bd90c3dce6162a5995bfe9df": { - "balance": "1000000000000000000000000200000000010", + "balance": "1000000000000000000000000100000000008", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", "key": "0x5c1d92594d6377fe6423257781b382f94dffcde4fadbf571aa328f6eb18f8fcd" }, - "0x4bA91E785d2361ddB198Bcd71D6038305021A9b8": { + "0x4ad186EC10047a207268c921FE2dD72A47747A73": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd65f73004752376a8f043ec68c2c964e98926865f14775678b2aa84947a74e7b", - "code": "0x84420f67222b5641972786145b747b9f6b269166fdbd701129dc55eaa77148fe96259bc7ece823714bb3a8cdbaf7f384e05c267f2e16021d51fba05ac06151898b94fcf86dae9dd6026b2b824fa932e75c4b81a1e20209dc376bd215d0be1a551346e0df37ec385cdcfef5b73b13f4fa1b55be0c86f81fb5b3701ef64fc4df00f5349d815f3ca9782afe723f3eacee30c3464fc05e12638977843bb2183a16ade78ea91a221fb67f10aba14ba22dc39f780130b5cf7d2295f57a7414e295968ba005de1f4b235134f6a66019013c8498d7fe5d9c4a258bb57fe1485c0d4f3e3abd13a6863b607a386edab49cda39c0a4d9199a0f276cecc8aaa8f8c5a83f8170", - "address": "0x4ba91e785d2361ddb198bcd71d6038305021a9b8", - "key": "0x99ce1680f73f2adfa8e6bed135baa3360e3d17f185521918f9341fc236526321" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x4ad186ec10047a207268c921fe2dd72a47747a73", + "key": "0xa4f5c77c9bb083c10bb92b2824a1bee39bba3df29e8923cdec19e7c4804768c2" }, "0x4ddE844b71bcdf95512Fb4Dc94e84FB67b512eD8": { - "balance": "1000000000000000000000000000000000011", + "balance": "1000000000000000000000000300000000005", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", "key": "0x5602444769b5fd1ddfca48e3c38f2ecad326fe2433f22b90f6566a38496bd426" }, - "0x514772fb7F9ED5E54Ea9fdC34aA4dfC7bE594494": { + "0x4f04694790aFe884d18dD822B979EC2C4aF9b3BB": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x899281cb5d4cbae8408193bbbaa6701ab3d6dc4c07df2c4212f3f64b31f00416", - "code": "0x6654c25418c9c9cdb53e9c7e15d751e46e03faf5fe299ca4ef6817467fb3bbbb02f99646d718504e95233737033d5f11cacb283e1a9b2d1ad1d2dcef08c6a40afbe158bb61721b4374c6cbf06c87d78138667de83e1f69f30893bb437dff0373ddcda9846e422308a606a70526455845f80d0b22327f98d8eaafcc7c9b60f26b3d112fe2cfc19c13b28ff9f53ecf385f288fca3c9a800e2826903f86442b3c692e2d51fab4d9c1610962d39452e3dbc097fb8114b50951fac0449fa7df26914402f56c3256756e82795f0244ca0a1b4c6ee21854c0a86342ad6bb8f8a2eb8a4067bc00cb24423cdb75e37549e0e845bf4e9d27038e3fbbeb29e8e99a1aa5c461", - "address": "0x514772fb7f9ed5e54ea9fdc34aa4dfc7be594494", - "key": "0xf02f9c16ca8e4ca4daf37afe833d6f9b50b934fcb50954792900ce943d6b5fc8" + "codeHash": "0x27222c12233093361570e05aefa71218f7dbc80fed9fcd3e5e354c03ca17de57", + "code": "0xd976efa78ad29ed9a36b7b646a8316d94e2c0992fc889454e231f704190e7a66ba83dad61dd09c4add2a92c161b549d6c2b3eb3bec381c11b2bb2115ce510dc42429aa244130f07134860db48fc78040f9f98eede7613d21acc0b07977d62e0b559614b4d580ed63d8a55cd6b8faddba8339f014c3d1f205f17c8d91908d9837bcd24d8c047e5063867d3e8b2ed6abca2a71b23ce541fb0a23b900d8552c1f0f363d3eca645461a89868e2d177d079dfa222f93ac92576c6a53e4dda614a7188c0220d7114abf7ccce953eee6e1de8cad09c9ecf565e0deb6789b009431ce7760cb142a4b2e6afdc2587853f87ce63d7e7240df143c620b87bc6ee166d70c5b8", + "address": "0x4f04694790afe884d18dd822b979ec2c4af9b3bb", + "key": "0x886873063fad8b6ba257121f5b9972a94b3edda692659880083b9bc85c75a929" }, - "0x5259FD366E381590eD3d01cF2181726498eFdaA2": { + "0x4f85d16FF1523308530cDB76384f9eD09a143470": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x5259fd366e381590ed3d01cf2181726498efdaa2", - "key": "0xb4ac940399ad74961d86385549af09654ff2fd37b19860ac2197cf0ede38fcbc" - }, - "0x52859c77dc11a2983F1eD3F9284f215c94FF354C": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x38ec67839d530b6a89731615d891c92067632d4439c68e5ac4a823d0a6e4f567", - "code": "0x117de450db9ef19cde82383de3b55cb0a7965580517c7121000ae2f172c97cbc9e45afa898d1218177bd2c70d157dabd7c7e29f662fd9efaedfcbb325862d874ac7511a01df823fb51359303411b7e2f723cd4e10f128e3084b8ebbea214c26304bb3b4207ce82295d38e8bff9678c7ffab2d11ac7c8ae0afa11bb2d6b2ff7fc6a4cd983fbfa662ee9a9fcdd19aa030fb27b315fada4a7adf24555d0223dc4871c8533394fc1a3f2824e39d8ef04b7ac42ed1afab3eb82c41e5654726710177000cc4898feff114e317ec8cc5776eedd027135f826cc0a15a25d1f713a60e56f0d1052827618a31385863032e24ca36ed2081d363c7d531b6429ccd7f7fafb7b", - "address": "0x52859c77dc11a2983f1ed3f9284f215c94ff354c", - "key": "0xb8da07edfd4449f2c95df40fc5095b3e75a702fcbaac7b5f9dce232800cfac3e" - }, - "0x549ABF1AE8db6dE0D131A7B2b094C813EC1c6731": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x549abf1ae8db6de0d131a7b2b094c813ec1c6731", - "key": "0x910fb8b22867289cb57531ad39070ef8dbdbbe7aee941886a0e9f572b63ae9ee" - }, - "0x591317752B32E45c9d44D925a4bCb4898f6b51Fb": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x591317752b32e45c9d44d925a4bcb4898f6b51fb", - "key": "0x88a5635dabc83e4e021167be484b62cbed0ecdaa9ac282dab2cd9405e97ed602" - }, - "0x5C04401B6F6a5e318c7B6f3106A6217d20008427": { - "balance": "0", - "nonce": 1, - "root": "0xfa8419ae99f4a7adefcfee0f90051b152ab94b0f2c5e8f40afa685eaedd48d0e", + "root": "0xf4ddbfed83012b2b1bdfc64f088f12d9b9cd9b6b31e018c96afb602d15bf2794", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000017f": "017f", + "0x0000000000000000000000000000000000000000000000000000000000000180": "0180", + "0x0000000000000000000000000000000000000000000000000000000000000181": "0181" + }, + "address": "0x4f85d16ff1523308530cdb76384f9ed09a143470", + "key": "0xe88893cfac9ee1250741f923dc7a2b2471fdca54afdf6272b3424a67b126b1d8" + }, + "0x534Df862ed8fD56F9e9F7A50451B81Ac308Fba3a": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x534df862ed8fd56f9e9f7a50451b81ac308fba3a", + "key": "0x2cff8455579bc93ffe8b215568080eb6b15a62dc94b6465ed6eeda919eb9ec75" + }, + "0x565f012918C969574b4DD7aB1438078360FEDbAc": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x65c9fd8e4f80c595224432b2e8c5c5daa9938c20f3303d0b0b576f930c6e400c", + "code": "0x036d965cb9d0e83de4c353f95caf4ecf8ee07c3b7815487583c2320e4410a14a974020aad38fd296c46604163b1d9ac2824887d4512f177363b73ec3c7aa5acec108ef12f26b4ade44fe5ed2f32b5ef7630c67d90a9897364bf8e724599e3cc46826f3b2dc85a23ac29ae589df3f1bd4b838fb58b1fba29fe7bbe6ff9d23dac1785099b1161b577a98586b6a1e4f4377ee16e922ae82fe8e16636298a173aea19a5bffddecd82ad75cb64b02d7705d37a866810905387dcfac43b76b6b52dbf188f578fea244f4e9da815349e19db14e2fab4bbc9bb5a29958ac2714022c21ab0f3692613da04ee297f5ae7520d29a65c5bb0c654c692374a729420b0423c80f", + "address": "0x565f012918c969574b4dd7ab1438078360fedbac", + "key": "0xb890172948a324f9b9a7b7733028129f7303744d7abad5f78719f3e474c3d91b" + }, + "0x56abfD748156bc91D9A8E14F4AF42dbe3968F22a": { + "balance": "0", + "nonce": 1, + "root": "0xb153956e166789ae49df7e053c4453e66ffa032f0ceb753fff0b86796f250913", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000195": "0195", + "0x0000000000000000000000000000000000000000000000000000000000000196": "0196", + "0x0000000000000000000000000000000000000000000000000000000000000197": "0197" + }, + "address": "0x56abfd748156bc91d9a8e14f4af42dbe3968f22a", + "key": "0x9961ac161049db66cea081d22a1b4aa9ce2c2cc8cc45f29f2d912d917ac6bb9a" + }, + "0x5820871100e656b0D84b950F0A557e37419bF17D": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xbfd53712aaf28ce81b4ca4ab65774f50a244cab646979adb59df00e1943deb55", + "code": "0x6cec44c34efdba490f3ab1336603140e8c0c28cdc34b65964a9ac1f0bfec07dd6d7892ce866bb2c3e65cb18b34b9a11788bcb55274efbc45622aad07c7f85a36f4d6b0967b42b86b19b12197339035f1db3d03253fe3615cd3e99d15d3921db0fa137d319445e5cab57eeed640ea68859c23a54e370f0c92b86e7378db9f6717f7b22d72bb41f50e7619fe6009e692899723f40bdbefb4ae417e7031ff0bccd5446b3a55c06c80b51690681e337aa42dc6d1eaa19031355aa6f894fc549746131c96c8fe65efc95b3b88cf5d783a40ba92aaab0d52edbfcf0abf2b8c2c9cfb8068b17a0ae68dfa3f84a81023be55645133434b92210d7c095b98954ca0e3e37f", + "address": "0x5820871100e656b0d84b950f0a557e37419bf17d", + "key": "0x4615e5f5df5b25349a00ad313c6cd0436b6c08ee5826e33a018661997f85ebaa" + }, + "0x58d77a134C11f45f9573D5c105FA6c8AE9b4237a": { + "balance": "0", + "nonce": 1, + "root": "0xa1b975fea88bcc79f5f339e687406fb39306b49b2efd0728846bbd04058ab607", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000082": "82", + "0x0000000000000000000000000000000000000000000000000000000000000083": "83", + "0x0000000000000000000000000000000000000000000000000000000000000084": "84" + }, + "address": "0x58d77a134c11f45f9573d5c105fa6c8ae9b4237a", + "key": "0xd9f987fec216556304eba05bcdae47bb736eea5a4183eb3e2c3a5045734ae8c7" + }, + "0x58f8fe237b593C19546e1e758a2544561d04bfe0": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x58f8fe237b593c19546e1e758a2544561d04bfe0", + "key": "0xedabf9f506b5170888ca458df9dab111fa2c708b88cc706659db520718be9d60" + }, + "0x59Af84F3e7C82fce2814D0d6a548A6511b78d2E5": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc158240d4f9b25991d0863ec1afcfff897c6aa11de437ff428198163f7ed1544", + "code": "0xf9cab2ea5fc2898ca670240c87501f552f715e74f50142c35920c55eb3c0ea1ace08be9c0c4b619a77d9aae0c356635893985acdb56f3ab9f0887a6e839e7b153e04681523725281e5522c3930409045daace340ba5584d6ce46fad8ff0ee17c3429d6fa9db26e5631128d8185584d24f10323af033be7ff252ec8822b07bae1d21de5f10f7da2cc11d7285aa1870cc63fc64f1607ff0e823e4786ac9df506e1df77777c28427b65a9d9118284c3b1167eb43cc55aaa62b9f7d4ced77b911b0fe88c6d20e10af62aabb42c56ecad3aa0e9a8ce42bb84e4e634e80a0ca98bd48c5d7fa289fe0cce3684f388c19bfa7a0aaa2c98a5c74839d3148ac362bccbc70b", + "address": "0x59af84f3e7c82fce2814d0d6a548a6511b78d2e5", + "key": "0xd0873c9513c278a9dcb764072f7e2477235e814ca74f2ee4ab76c246f5ad239f" + }, + "0x59Fad703B903b1EC41FC5AbD42D277d69edd066f": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x72921c8e5b6ae768ecfcac7b214adcb6d129b1a27f01e3e53d5983b7172e3d99", + "code": "0xb0dd6ab64c91b13c13faf41aed0cf4d2ab8c259821710faa2ebcf849f80109e200f505a85dbdbde1426fd0a2214b8259b1ae4fcb9e18d53f06ec1b77e152797df7876b98fed9c448027081aa9a3e3a7d7052d18b7eea057b4def36c2fa47a12b0c5c7680cb1c40d05734a81289808b02f7180a420c18852dda2d5494a7f1afad66a8b3e51c9ef3016ee1d800e0aeb1de0aabe53158ecbd316dff51dbffe933a22944b9af8d962e2b5d171cd2b530c03b245945580d9e2a1c9efc472e2e5ec88bb5bc34a01e38ddc423f2e350462018e1f467d9168b2bb3690f0907c153557fceddf531d3aca5e6896fb90b841c9479873f9c1669c2ca84e3acb343f9c4daec0c", + "address": "0x59fad703b903b1ec41fc5abd42d277d69edd066f", + "key": "0x7c1d28615d0c377de4275a33b4f0ab75cbd2c397da5620caf1509a63564a806f" + }, + "0x5Cb874efC014fA0F7FB7331F29cc0b59973C6595": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x7864bc18a660d9d01fbc0e4c106e46acb7845d67a68538a1169a2255af2498df", + "code": "0x6d8e62e97e5129d5cef2e9dc5714a6fa7cfd8bb0b2a30fbcd3bc76f51251d708c9c9d362b631fd1cf2a811476392bf4340a481940250c78d4e1a8ba601af1c0ca42a541cdcfe5eae324446eb151010137f37bbef104de95f2a946c2404849477f4a235ccdb54c513989f886387aec23f9bf80ade6bf8f128a86992a7069f7985be89b2b9c21da99020673067731702f61a06f1657a7bc439452ab88ee45c8f3d12375e8dbec105fbd47c977d99a60ca0d2bf8a8ad37fe84ac7d8350cdcc77770b140c83f89450527e0d9bfdbe42b2fde284574f0f05c92031f07f3f4d420a7925a41508a056f33ebc54916028c311d205604728c0f8fe1666ec11122b917bee3", + "address": "0x5cb874efc014fa0f7fb7331f29cc0b59973c6595", + "key": "0x4402ea95dba35ab4b25f25e5dd1da45f79ebd51cdbdcbcd437fd8b204afa0e15" + }, + "0x5E5F35d83E5485AA1006F6Ca478eC7507d0efad4": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x5e5f35d83e5485aa1006f6ca478ec7507d0efad4", + "key": "0x53ed76a58ca2fe13ebac69b866c007878047e8c418866ece50f947ddafc36321" + }, + "0x5b35D3e1Ac7A2C61d247046D38773DeCF4f2839a": { + "balance": "0", + "nonce": 1, + "root": "0xcc48f8d1c0dd6ec8ab7bbd792d94f6a74c8876b41bc859cee2228e8dad8207a4", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000ad": "ad", "0x00000000000000000000000000000000000000000000000000000000000000ae": "ae", - "0x00000000000000000000000000000000000000000000000000000000000000af": "af" + "0x00000000000000000000000000000000000000000000000000000000000000af": "af", + "0x00000000000000000000000000000000000000000000000000000000000000b0": "b0" }, - "address": "0x5c04401b6f6a5e318c7b6f3106a6217d20008427", - "key": "0x6c37093a34016ae687da7aabb18e42009b71edff70a94733c904aea51a4853c1" + "address": "0x5b35d3e1ac7a2c61d247046d38773decf4f2839a", + "key": "0x55cab9586acb40e66f66147ff3a059cfcbbad785dddd5c0cc31cb43edf98a5d5" }, - "0x5c019738b38feAE2a8944BD644f7AcD5E6f40e5c": { + "0x5c272D741b74a8FEF2749FaE559C3900052ABBac": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x5c019738b38feae2a8944bd644f7acd5e6f40e5c", - "key": "0xbccd85b63dba6300f84c561c5f52ce08a240564421e382e6f550ce0c12f2f632" - }, - "0x5ddf897368f755b65a47c325558C5D1B6101D6AE": { - "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": { + "0x6057FE92F331FDb8f9728160E857B920d7824ff6": { + "balance": "0", + "nonce": 1, + "root": "0x0dd7fa1a6c3ee15039f57211a40021e727617dcf3396ad739b3a6bc0547039b8", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001d7": "01d7", + "0x00000000000000000000000000000000000000000000000000000000000001d8": "01d8", + "0x00000000000000000000000000000000000000000000000000000000000001d9": "01d9" + }, + "address": "0x6057fe92f331fdb8f9728160e857b920d7824ff6", + "key": "0x6aa85d4b187111f2c5ecf219bd89f549601ff55f5d81290f81a564ade80db911" + }, + "0x6269E930EEe66e89863DB1FF8e4744d65E1Fb6bf": { + "balance": "0", + "nonce": 1, + "root": "0x75a2a5a81b84c4f6290edf5328f743c609fec3724db2187fa84fe11999b936c1", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000c4": "c4", + "0x00000000000000000000000000000000000000000000000000000000000000c5": "c5", + "0x00000000000000000000000000000000000000000000000000000000000000c6": "c6" + }, + "address": "0x6269e930eee66e89863db1ff8e4744d65e1fb6bf", + "key": "0x419809ad1512ed1ab3fb570f98ceb2f1d1b5dea39578583cd2b03e9378bbe418" + }, + "0x64259510073C9E180Db9a7D4A6e6752a52fEcFAD": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1cdd99d5886db6ad2fa95eae0e3dbbe46bfd4d76dd9fc071924bfbdfb5092df1", - "code": "0x5ebf747c75d0738c34413ae2d381abbe56223451ec9a8182acbb3c1b4cd303c36b426b81e25bfdca83dacfd6d1498cc9b779efa0e16c484b0a45c63e2a8ac0eb41338e7384edaf5f4b58e81789655568fca10ff473e1ae582e94707ba3b4af90ef1ae8d7b697e2fe5c14ab2301c3ae5fc2eb455e13fec873d608e25c13013abe76d086a43441006cc18880195fbac37baa9f0b926a479db4db18e84f5b93b3bdc27bef70534a73a3458fa13111419bdb863ccef9e14b21600ede3c5d6199ba547b426c558c84faa8521ed0fec4740eb270d0d68f28ebd25a3f457810c19e5e1d6c8fbe6ccd59976251666e62bf63684699437b1318f66f299d463a2a35e6cafc", - "address": "0x6122a0f0099cf6829a1a798c7d8194f3f1c767c6", - "key": "0x0e733ffe8353481b1a9ff5640302b8aea65c7d1863b432df95ccb2be96afa76b" + "codeHash": "0xae2556f6467404d4960c0e82cb0549aa24b1b86d63e8916f4991b4aad90797c2", + "code": "0x7308fca2a3bc677778472f81a566eb92fd5c90e7fecfd7cfaccab39916d3dcf0f531e5b3d77d17a0ec1ff2986b8bc33d0c3e72c0453b9046ab0041949852d1fe279a12b9e4525aa676a2558adc8dde630f6552ec594fcfc6faed4dc25a43b154874e0e82c737fcd276046addf49cabb96bdde8128c11ad519f9fe60006c3a47a9febe27a7cca7c12f1344dd0fe9b564e4efcfd2da37f2bb9004affb93ba10be62403cb0c79227a6b79d68d83cc4f30f951ae106ed6e674d9b7492bcf06603be70464f185bbc7db7df2ca680828dc05691ca64c1fdd3c16ed64141e4ee71f7991f1719981d146cbcc1630a3b12228b0581a3cc54c736724b85bd467e0a7082217", + "address": "0x64259510073c9e180db9a7d4a6e6752a52fecfad", + "key": "0x68ccf188baffd6aea3b31029f80ea18836c629ac53500a7137268ce1512529bf" }, - "0x61774970e93c00A3E206a26c64707D3E33F89972": { + "0x64c725A9fC63B8e7C45985387094C9C7c6bca3dA": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x61774970e93c00a3e206a26c64707d3e33f89972", - "key": "0x07b49045c401bcc408f983d91a199c908cdf0d646049b5b83629a70b0117e295" - }, - "0x62b519210D1152d05522eCD2786a0894Ef96711a": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x53e60f54205478067bd7871cc267787db82640762b903ae292cc4f7b1e034b2f", - "code": "0xd9dfa62431de8be2dbd2a3e48181600f1d9a369e648c27560dba1fbb3ad2b73f114d5534ea633c2a4fc65ce2157734e1ac5b006861db9b2fb713da83945f9b1644e6cc9ec0025107fead21d06dc3a721589436afc2b981a277584ae87017150697b8d5f3ffb17ab53746c00a9a5934cdc979817ec37b75a47e7116ebc0dc98bb39e54ab7b21fcfb47de39aee65760cb929603027794f0bcd7af8e3aad7c10b9511a5f8a2a2bf42740ed0a334377de2c3084e93c4f4d0a6c75576781b77d09917724e042275b7684cb97d5450ac014448187dcc8ad8eca739641820e932cead43c37c803fa400daf840edddd3bfd7134b4feb4e68c807934df6e79be380372de7", - "address": "0x62b519210d1152d05522ecd2786a0894ef96711a", - "key": "0x2439cfa77d7473700a4a2e1f646172781c057ed8562f05dd5d4262b33fd7861a" - }, - "0x6325c46e45d96F775754B39A17D733C4920d0038": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x005277275713c3dca04ab6c7e47c80280f192d40dbc42d4798ae13efafb012aa", - "code": "0x66ce4e8e12a5403828e3fb3176b429cb926ef9dc29fd04c1b3c13ed2787d98d63eae4e449535fef8fff684d6f73d890e306ee348ada8a418981c28d496bb7be350dfc491ab5c757ee78cfa27228f3a47882447741e862da671b4cb5afd51d95370d52b43b3e1f9a31ab6163a901e55133bd37da50c470c7ad07e6be9a4e139f4309f8175bdcf9b0c39a91eee31067537b925ed2b384eabdf80116866cc3ab80ddb57df9c1c4f68e2fa98244b87e0d27e04c99093c63e7983b367307c46863d3f3fc3eafd6666b4115f284754aee9ae5ecd0e309cfccdd979fc5507fff0213446ac2be92b45f4e420d0da2f410ca74328fa136fa304300cb98f3bfe380f244449", - "address": "0x6325c46e45d96f775754b39a17d733c4920d0038", - "key": "0x7c463797c90e9ba42b45ae061ffaa6bbd0dad48bb4998f761e81859f2a904a49" - }, - "0x63EB2d6EC7c526Fd386631f71824baD098f39813": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1168db50d8c2d04754fa4490bbedbb9da7d8abaee13dbb166226184e43a2c230", - "code": "0x50f395cf935269ec6c0da54860a5c40e4a834461db1470816d90e1e42a72199933adcd84fdc27d3e867d7b3e99f37edf5e90974dafbd1ff1ab87448df87b1e8832c9847d10682bcdcec3f220294c4be920f5b07e4c9bd319b015ed2172b56db476f70a4b50e1ae7567d0cc5ac047a75e39b034ce3beb11fbcef92f4b009d5ac5d98acec5291ba9332e4780f7cbe1ffb2dd12ac35ed0a419e68c5bb25a3f36736406423470b595ffad93ccf38676da45f48a17fcf63343e5bfb15c88f71795d1135c961d63bca6edaaef30eb43d3e98ae2b23003091278d643f0b7d548887f0c1bbb0e6314a05b0c3773a37fe72e4dab42b2fabbc8cab6968d2bbb4760eccbeb9", - "address": "0x63eb2d6ec7c526fd386631f71824bad098f39813", - "key": "0xfdaf2549ea901a469b3e91cd1c4290fab376ef687547046751e10b7b461ff297" + "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": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xb7c056307dcfe4d5bf2de7d5ad1bde4bfcd7aaa0b8f809a5f281bf5c0ffc5ef3", - "code": "0x8287407dd86f9cd15823a62f56cae15d1cdb1d9dd2cfac15669fd1037cbd633fba04c9fd01e5135b6259852aa7338be61049b7b5f6b9bf8cbd858ccf50532c262f2120a9890bd4e58b07c28e03ff53234c375f6e9b60ef12bd3dd7fb6234e9bc2b664fbfedceaa9e368d36426d56ced624f761197dd7b96937cddcd7d4a8ca8d775b7a133f8641b4824710333c2c435f2413ef48954449113b6ed0576502adb9825fb6258ed58db931ef4a50b617f3b78cc886f5d1e09c7deb5b845bffeed38bb03cda5378747d2b3f6b4d23edbf03f046cbf5e0ec8cf1df19f2b28601c8cd810b1b62f1989f657b839db886f8749798d4c830427984730946a0d3525032d7c6", - "address": "0x667bb3a03733d43ec28d2178c39dc8d8d62e48c2", - "key": "0x184b9df2b6cae0dae7687488d9f738d1038720fb1c84aa74b880cea89d89ccdf" - }, - "0x670DC376eCcA46823e13bAb90acAB2004fB1706C": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x670dc376ecca46823e13bab90acab2004fb1706c", - "key": "0xdcda5b5203c2257997a574bdf85b2bea6d04829e8d7e048a709badc0fb99288c" - }, - "0x6741149452787eB4384ebbD8456643F246217034": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xa0750f0af31158ef75bf1585ac49a9f036c3d1c824bc9cf85348eea1cd44c4e7", - "code": "0x2bdf3b387a25238ca107528ef613f0cda5e5fdc55d2a862a6772bc33c52e9bfa806416b7717fcc15b81108defcfbf29e72f55b2197fecde6e539ebee057989a401c50f6fac5dab042d56d6672b634cb37b505c5aae3d7ba4611136701b0571deb7b30a37f76c4fb5cd36b8aa4d39c72a853a8d4c2fa5b557a49cb235c2e1dafff37f59c4a66e94d1fca74ea62b6b8408510c029e65fdcd1df49d986c1b36dc7926564a9842445dc74d9f07ed82bf6b114b8b1d9caab12e4ffe452622666b49365b356955612a215e910dad02f366f8b9b52d08b78752c97e0f89f9efd40bcbdd49d68b6163ca37cddbba727f9683532a5f96ca0a6046c4d911e9c07656aba166", - "address": "0x6741149452787eb4384ebbd8456643f246217034", - "key": "0x37e51740ad994839549a56ef8606d71ace79adc5f55c988958d1c450eea5ac2d" - }, - "0x67b7C7F0A33D823099897812498d27F02641211C": { - "balance": "0", - "nonce": 1, - "root": "0xa76e1579c7dc21902a22df113429d0ce1741c95e74724cb3380542329025d9f5", + "root": "0x2931f633d50c1479ed6fc7e6694773cc891359a82498d36c3a1ff6183e393f96", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000152": "0152", - "0x0000000000000000000000000000000000000000000000000000000000000153": "0153", - "0x0000000000000000000000000000000000000000000000000000000000000154": "0154" + "0x00000000000000000000000000000000000000000000000000000000000001ab": "01ab", + "0x00000000000000000000000000000000000000000000000000000000000001ac": "01ac", + "0x00000000000000000000000000000000000000000000000000000000000001ad": "01ad" }, - "address": "0x67b7c7f0a33d823099897812498d27f02641211c", - "key": "0x32e29e5de456ade7b4d54018ccdb635ed75ef0f69d5012a5bc7940db8ad41c5a" + "address": "0x67a61a385416d9c31e4faa3119a425d9cf1616a5", + "key": "0x5a3e8a1207bb1a9c2d1265bed157f2af2b6a72714c6fbd2d88e54ac286edd612" }, - "0x6e538D4e5B09ef72527C5f360A9eed7BdC78c013": { + "0x684bC6825e462FDB916de100633e6B6E7F24889E": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x6e538d4e5b09ef72527c5f360a9eed7bdc78c013", - "key": "0x8a9059b202d794382c3d775abd293c1e8a931a9e452cd405bce318655011be46" + "address": "0x684bc6825e462fdb916de100633e6b6e7f24889e", + "key": "0x4d21debd0e9f83b4968ba732fc45af8c777c93e880de876458fecec6ad7a1785" + }, + "0x6D8B8F27857e10B21C0FF227110d7533CEA03d0E": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x6d8b8f27857e10b21c0ff227110d7533cea03d0e", + "key": "0xfdbb8ddca8cecfe275da1ea1c36e494536f581d64ddf0c4f2e6dae9c7d891427" + }, + "0x6E61C1930047f977205cc445234d627eaA0b6CEa": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x6e61c1930047f977205cc445234d627eaa0b6cea", + "key": "0xfc648c6bfa55dfd6dd1b2322a6c768637f88704e48325686ef2589f8e3b06a73" + }, + "0x6F372e56E94825B6542Df4459Df1dA3aA52cf093": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x6f372e56e94825b6542df4459df1da3aa52cf093", + "key": "0xb898e426a8614ef715b2e6ae0d473ccb71e1b40053fc0637134ebecc90c089a0" + }, + "0x6F80f6A318Ea88BF0115D693F564139a5fb488f6": { + "balance": "0", + "nonce": 1, + "root": "0xbbb0506aae3a78c8ba163d88e1c7424c7af27bea7b2678235dadb60746261d37", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000132": "0132", + "0x0000000000000000000000000000000000000000000000000000000000000133": "0133", + "0x0000000000000000000000000000000000000000000000000000000000000134": "0134" + }, + "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" + }, + "0x7029b7A1e1a0e17a08Ae0F5f58d06620fC0e22f7": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "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" - }, - "0x73AACD67E1d72534a3D83D38b88026bE46ff2928": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1e68027de7f5bb2a9c63f83cc6107bfe71694dc9d086d845e1e3b1e97dacf2c5", - "code": "0xa81c3a5a553fab8c561679d85bb19e6a7eb0218b4839501a326c84cd4158b2d51161d849492e842dca32edceeb2630bc6d621f9dea3fdc78ca65f82bb844f4b139366d2e14b42d797be5fb2272e93ead41cec826548512dfa09eaadf5ba4c2a4a171e6dff2e291b2403638b36fa1900bfb6d28056b9cc28339adf04ff3e24b88f13a4de10a82cea8926787ad7534bdd0eeb85aaf1d4813cb0c9cf7e399b7ef0bc1e4ab78a93992ee6fa5897690163464c8f8afa9af264f2d83bf6e5bb209a73a84ff3eb04bac0a2190b4fb9ac6d0dbbdf1bb431847b8b7ccd4a0ae0968e179db7130ab3fdec6ebe33fbecf2e3fe7b06f5b02e4c74c7e44e42655d673012f1254", - "address": "0x73aacd67e1d72534a3d83d38b88026be46ff2928", - "key": "0x9dcac55a8e43a847f19e26fedaddad4c4b70f05633da984b95bc232a1289470b" - }, - "0x7419f9024b102E628c6d8Ae2178fc11edA4091cA": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x7419f9024b102e628c6d8ae2178fc11eda4091ca", - "key": "0xedad8de5342a46c07726160a648709be199da56fdbc92ea23f5bc51a32abd680" + "codeHash": "0x017dac995561f4ad38ea01f7cd0d0a599ad4fd54610ec4bbb0a022c6c25b0102", + "code": "0x3884095ca26754c19839d1d65ed3564b4558896672ae6763c55fd1245d56ef7b51c44284d952b00f7c584661b05f3b5ef462e7e5fa5fd8ff860e55075b3c69e100b80c4ff21059bea8fc1d75692dc11a282117d4df95e89684ca76663735d95b308b08755ec965f49e4d58d22ebbf80dc425791b553f8567a173e85e1abb76c3d59d36d9a2de213c9d9eb0f9211f3a0af11fcfbb0f65cfc9f3c7b45309667e2e354f9940ed6a1b290b3c1c5b50e9b42ff556724d10fadf83a38bec6611feca7d587d806a8d61a216518ddc9bce228cccdd621174b77f4d8d747c1064e65d14c8dd19496508bc227dc9b9d757c38132fb6956c14e9e9fa87b6fa13663f26722cf", + "address": "0x7212449475dcc75d408ad62a9acc121d94288f6d", + "key": "0xe333845edc60ed469a894c43ed8c06ec807dafd079b3c948077da56e18436290" }, "0x7435ed30A8b4AEb0877CEf0c6E8cFFe834eb865f": { - "balance": "999999999999999999999504116057851184", - "nonce": 548, + "balance": "999999999999999999978502856567391250", + "nonce": 603, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "key": "0x4363d332a0d4df8582a84932729892387c623fe1ec42e2cfcbe85c183ed98e0e" }, - "0x75F2A26625f08390f5b66C5238571de790b4D7cD": { - "balance": "0", - "nonce": 1, - "root": "0xe0a82b671528878859d9895420b108b58cd0a4b529f64b68aba04b144fd8391c", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000223": "0223", - "0x0000000000000000000000000000000000000000000000000000000000000224": "0224", - "0x0000000000000000000000000000000000000000000000000000000000000225": "0225" - }, - "address": "0x75f2a26625f08390f5b66c5238571de790b4d7cd", - "key": "0x0530f0a872be8e03883d9dcdf34c6243c8b077f5e1454dcba0b00ac41b1c4007" - }, - "0x75b9236DFE7D0E12Eb21B6d175276A7c5D4e851D": { - "balance": "0", - "nonce": 1, - "root": "0xb3f69d1bc520e1e6cb0c45736136f623265d1c97a183709d9171fb81e888d0b2", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000055": "55", - "0x0000000000000000000000000000000000000000000000000000000000000056": "56", - "0x0000000000000000000000000000000000000000000000000000000000000057": "57" - }, - "address": "0x75b9236dfe7d0e12eb21b6d175276a7c5d4e851d", - "key": "0xc54ffffcbaa5b566a7cf37386c4ce5a338d558612343caaa99788343d516aa5f" - }, - "0x77EA772798792AE8A7A5Db1444c5a08422E61D70": { + "0x746a4A19f37986b4bDF4Aa856C13876Ba5d00885": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1d0c729cea26d0141bd5dbd789a82c2bf58858a1b7dd4afc84996e5664a9a4d6", - "code": "0xa29f2962b8badecbf4d3036e28fcd7dcf22db126f130193790f7698ee4d3dd84c8d233a0ebef7c9a17d2b0b17eea62cca39002a128ccf419119b4a1a1f1e7428a4e0f4432e44d027a7b3f953940f096bca7a9bd910297cad2ba7c703c2b799d3fc111d09a6e2f0958402cbe16a5aef32c9d8ddb9a4df7271140de57bfed6525aac375bcb880242328180c23d4a918023a12a7caf7cf12b8c4074e4a3f39900a0b4e18992ad424cdedc46668609f2bafcf665a8d99577618d5923c69264d9cf5f84a4048ee77615560f9afb39551a46e123dd0dd6c928af241dc565271d0325697fecc9f0b925868a8c62ee842da0498074146a036d84a1041d9b5286786bbbf3", - "address": "0x77ea772798792ae8a7a5db1444c5a08422e61d70", - "key": "0xea65665779db5aff91565df8d1183c21fef505ef0568218063195936d02da2dd" + "codeHash": "0xc6f019710802c277f20eebef107a03c7716f7cceb4e71e88a6362ea01d91b71e", + "code": "0xe6cf798baf210a542efc04b9a1d35b51bbf5e410ca16e05b2438d8aa878eb4cbfe979cac28aae02591b1e9a75c257b8ef0ce5a9b169c4326754f1a4cb4d5218def8ddbc0ff0e6cbcbe485109d3c044e9d7ecef5b93900570208a0441ce95e47f957c7b755145fcfcc61091a48f9327db65a575704887cd0deb33ea7d7c39a27ee818def27d07091d58213bf54017c19392db186502c3606e7f6f2cb35e780e920072714fb5796f380bf3a3e1f2a0bef653a1c86c2fdc99fb3e1ba6475976d081a30c04976f511ea0ed4105f3959ef4bfbac33edc0897e2ca235ed8ed37aaea85c6ea3000385ba405ac4a152ff53937c2fdc832eefb152314b376e57ba9bff1e7", + "address": "0x746a4a19f37986b4bdf4aa856c13876ba5d00885", + "key": "0xdf769ae3989fee7f1bf6e8ac9dd3569178d4099af14dad7fdf015ee0e4730f9a" }, - "0x789f8Bd19f7Dd88DE4C94662B7680AB685553728": { + "0x75BE2E16aB7d49356F016A57f5a389B18e361FdC": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x306dded1de1f616ce99dc5c63dc6ff249af675ecd11cfa7704e3a1b1a20f0be4", + "code": "0xd66e2ad9c622d8fba62695dddfb1dae629a4779e0b6cb52d0a48eef9e5021d6f391130299419caa48b4a7a49a2cba7c0a42b146ec50747d93cfc4f54371597af93e1a7869b67d2b4edac36ff5bc7eeba517ff228f0aa77f525822d8334b69637a23430173c031a9aa170221f1b31469dc7fa6938a8b13413c9b8fd8421cf5e2c6eac71626d09a1fa3110436e2c6ede46c11ad87705148403bfee1ba7383277ff545737c28018ecb87363e183c16876d68b107616b0e56037a60eef9a6d6ae89dd77d6d8eeae66a03ce8ecdba82c6a0ce9cff76f7a4a6bc2bdc670680d37142738417624c20328f41fe28003645cb6736b72c1c0f9d860d2b376428c0d43492a0", + "address": "0x75be2e16ab7d49356f016a57f5a389b18e361fdc", + "key": "0x4527ec446456c7a0bb1da8a13c16defca121665a737b6158c7bfc933e95a1e3e" + }, + "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": "0x789f8bd19f7dd88de4c94662b7680ab685553728", - "key": "0xeb4aae143f2a12481bedc1d5283378b5cdb0d04e0726fdb5735008d766a0a726" + "address": "0x7a9fe86beaf9c94121dfa31144ca12ca061709f8", + "key": "0xebdbbe3cfd9cc04fae47b7655833c19f42ada5e8ed76371e9ebe43cad66684c4" }, - "0x7A19252e8C9b457Eb07f52D0dDBe16820B5b7830": { + "0x7C28716a0503bC00725b3aef3D4eD4741555fB95": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd9733b05a801246c9a6b8f04fb365284d2e15776e63ec367591211b31bac3d12", - "code": "0xff91e8593b941cc006a9af6dd29cf00c1d93d745cd30e13d28db6ad34229c727c0f9ae4ecbfaa81a3f2a4c9bb264c28cac2ae8853111c19109e83d6c1292e7a5db185bc3aea90f5e30861a799d320e0bb6de11723a5674bbbfb6409c8f47b8822023c3bd05b942cf6cbd5cd645de4d3fea19926fd4838b16303d2ed62750847284ea7badd9e8d390707dc2872182ac68c8c7a984bb7d1aac16736628a499083edb0e2bdd19b7b49c93d2d0d8a27fc83f2071eeb7608d02782d79ee059eccc097f09b457c15826396efb730bf67656e5debac76c904fafa6861ed5765cea4df444069a8200c657d770aa801936fc60d04a47893a564a93a09e064b483165beec1", - "address": "0x7a19252e8c9b457eb07f52d0ddbe16820b5b7830", - "key": "0xab7bdc41a80ae9c8fcb9426ba716d8d47e523f94ffb4b9823512d259c9eca8cd" - }, - "0x7BBcF9B49875acdBaa5857fD596CAF6dF405939c": { - "balance": "0", - "nonce": 1, - "root": "0x8dd6737b0207a31db75fbbc29063d72290aafa75f4164d85f3f4b6fbbba2fc74", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000024f": "024f", - "0x0000000000000000000000000000000000000000000000000000000000000250": "0250", - "0x0000000000000000000000000000000000000000000000000000000000000251": "0251" - }, - "address": "0x7bbcf9b49875acdbaa5857fd596caf6df405939c", - "key": "0xd82835359d9c4b09cad79be31a60ead5e421589b8cb2bfdd6e173d680176bf7e" - }, - "0x7DB168B2537EcaAc90f67C14401fa36fD8980252": { - "balance": "0", - "nonce": 1, - "root": "0xc5913c221e08d61a0acf3d91886ae1dd3d00f640857b9abba5bb23639b95c015", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000218": "0218", - "0x0000000000000000000000000000000000000000000000000000000000000219": "0219", - "0x000000000000000000000000000000000000000000000000000000000000021a": "021a" - }, - "address": "0x7db168b2537ecaac90f67c14401fa36fd8980252", - "key": "0x33f31989117f50a30bbd8bde69d2efcc6ea606102f7b3841a65a69fdb909f041" + "codeHash": "0xeffe888f927bccce1cf9281bd54ff035d06523b2f8519818e29f6d05f4851d98", + "code": "0x7e5820c0761b14115fe6ea18abae67e05d6099871305166211e1f3758c4ff0a7655e312cedbc024eac269caedb1f8f41f06c7f8f0177eb4f3554a658d1589a9d4826094ebf8431e0f0afae13d5b994ffdf50eb0cc63e327bf379974c92f50c6df5647cf2573625ccbe9a0b30aa78a110d0e7ac736f8a0e5ccc4022496f1a33b36b6941afb4be291eddac0e5c0dbb129591aa625d268e37dd1c2f9e5df9c0ecb65f503c75b1697635d4fc43250a4d9729a209a9ef27041f1535e5fb1d180ab5bda1ac5b3292d22071387cd970203935d354b23b6bc6a826028cfb02fb0167851e847e2cd21f9334520ad3e61ef154438d3083f3cd0fbfe02ee2ecc3dba7f46ef4", + "address": "0x7c28716a0503bc00725b3aef3d4ed4741555fb95", + "key": "0x549db5d8918de0246040398fa51124081d010de247f37f06ed212bddc1b9984f" }, "0x7Dcd17433742F4c0Ca53122aB541D0Ba67fC27Df": { "balance": "486", "nonce": 0, - "root": "0x735b3acfeefa3610e61d87c6927b5d712cedaa9fd722002c537b13d8619fe39c", + "root": "0x825a39b4466a4068d4dc731403a7a9631f29b4dd1b3bd1c609faf64305e0d55f", "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", + "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", - "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", + "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": "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", + "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": "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" + "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" }, - "0x830544a6A94aa496947fB7e0182d64FC90192AFc": { + "0x7FA65F7792d36FD0282DFd7398347317045DaD39": { + "balance": "0", + "nonce": 1, + "root": "0x2084e24f0110a0fd1c5b1283ba04925cf5bbfcba34c26c8f2ed36d80649fa105", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000a3": "a3", + "0x00000000000000000000000000000000000000000000000000000000000000a4": "a4", + "0x00000000000000000000000000000000000000000000000000000000000000a5": "a5" + }, + "address": "0x7fa65f7792d36fd0282dfd7398347317045dad39", + "key": "0xf7c5aded54c81097690f975dcb3cbfb114a997c0f5ce75d2e6acda54986b88b7" + }, + "0x7d53f4E89992aBf93C95467Cb2e0E1Be141eF844": { + "balance": "0", + "nonce": 1, + "root": "0x22330f48a508599789a782a57c07ba7f7fc9b9ca9ce9e3331ea36127d1a283cd", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000169": "0169", + "0x000000000000000000000000000000000000000000000000000000000000016a": "016a", + "0x000000000000000000000000000000000000000000000000000000000000016b": "016b" + }, + "address": "0x7d53f4e89992abf93c95467cb2e0e1be141ef844", + "key": "0xc57a0482220d36c87a41479e62e55decd08ec51a10116b3284b90bbf5b2bcc2a" + }, + "0x7e42Fed5f877BF877BfF6A6a5aa02f1dFf69a9d0": { + "balance": "0", + "nonce": 1, + "root": "0xbaebe83bb6a87dca34a07a0ee1da5c038e50ea59754f4c3027cda3ef209dc9fb", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001cc": "01cc", + "0x00000000000000000000000000000000000000000000000000000000000001cd": "01cd", + "0x00000000000000000000000000000000000000000000000000000000000001ce": "01ce" + }, + "address": "0x7e42fed5f877bf877bff6a6a5aa02f1dff69a9d0", + "key": "0xbec5e51999dfacb259afcce7ae4a1d085bb27277793cda96a079bda642d15441" + }, + "0x81bda6e29Da8c3e4806B64Dfa1cd32cd9C8Fa70e": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xfcc60211b6d08e046c0587a81331df89a1fbab58efa0b6acf075c2ded4ea62d9", + "code": "0xf5f4f145f249ec8fd417deb07ebba6ad75c6c8d3b9078a26ec16edbc5b4cb13241a2d376d1cc7cfee6058e74f6bf0c848c6567d84037dbd084e5b28dcf7825c22f13198cc353a2bcdeea8950fb4fa16e1bfa845cff6c4dacc918c492308fe106404cbace760d55701d2fa2fc1576ec2fb0de43f2334f9dcaf513296946815da2bc7fc19ff06ab7008e625df9a00cd9ca64bd66c2f214458996515c1bec5bd2dfbfda5199faa78deb0e4a0aea26d0cd85d6b8a20455bdf7dcc586341fa10c60391c2768f4ba3e934fd0e312a0beedb01d78534b2c4064bfbf23f299e3773d9eee9b46cd7f09bcd8d210c8707cabc088fc81dbe986970bb1ba06a73ce0520c5465", + "address": "0x81bda6e29da8c3e4806b64dfa1cd32cd9c8fa70e", + "key": "0xd5e5e7be8a61bb5bfa271dfc265aa9744dea85de957b6cffff0ecb403f9697db" + }, + "0x828a91Cb304a669DeFF703BB8506a19EbA28e250": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x830544a6a94aa496947fb7e0182d64fc90192afc", - "key": "0xf1b58012b0f270cdd9c1add82f593179cef3f8360950aa5d1fe5de28677e73a2" + "address": "0x828a91cb304a669deff703bb8506a19eba28e250", + "key": "0xea810ea64a420acfa917346a4a02580a50483890cba1d8d1d158d11f1c59ed02" }, - "0x838CD8572D61ec23308cfb4f1f243B796a7f310B": { + "0x82C291Ed50c5F02D7E15E655C6353C9278E1bbec": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x30bfd822c5b2b88f07fc3988e7e78f96e22799091c6d1ba6e7cd6664669dddbd", - "code": "0xdbacf0626d1d814fd5d504189e5d5800cfd88bcf349ba6ba602b922e791aad56ccfe5d2425df2e3cbe8d7f0532b0a6b9f9be4a330be5d04c4d5f0c47290ef43ed67c34e8612c0557ad77818f63b0e965e2a918f477c43c5c407335625c16a68dfc647ae7caefab63c0c1f704d0ea4ba636fcfdf39fd0af454789b76cbc52f42e66b0a0b12995e6441f9cb2914565120c2e684eba0fba8b96acd03665e0cd074866e8088a238d9e0c32ad5efd7ee9df89e732a9c593a90146e4811d165f76da25de0705a5a4491cc4250dfb52b96473113e661025e4c03285e60a4cabadf93d8d256808232eb07d2271c0909d50bea3c5ea7ccbf9eef8f2443bdaee0dcef83c94", - "address": "0x838cd8572d61ec23308cfb4f1f243b796a7f310b", - "key": "0xd6167bc4042666c07f4e56f51aabd2c4362fa4f6c83ca79a912bdf0a8e779475" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x82c291ed50c5f02d7e15e655c6353c9278e1bbec", + "key": "0xa9970b3744a0e46b248aaf080a001441d24175b5534ad80755661d271b976d67" + }, + "0x82EF715853ef1959f9e4628C253F5582d5e8CbE6": { + "balance": "0", + "nonce": 1, + "root": "0x8291966c55b7b20309783e4ee760f8ec2e4082e14fb79435a395c4601f16cd6c", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000fb": "fb", + "0x00000000000000000000000000000000000000000000000000000000000000fc": "fc", + "0x00000000000000000000000000000000000000000000000000000000000000fd": "fd" + }, + "address": "0x82ef715853ef1959f9e4628c253f5582d5e8cbe6", + "key": "0xcee41784a4f2beac87ec4f132d240d8147ab4f075e723ca30b11c150bec2b94b" }, "0x83C7e323d189f18725ac510004fdC2941F8C4A78": { - "balance": "1000000000000000000000000100000000008", + "balance": "1000000000000000000000000100000000006", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", @@ -3105,13 +3059,47 @@ "key": "0xb17ea61d092bd5d77edd9d5214e9483607689cdcc35a30f7ea49071b3be88c64" }, "0x84E75c28348fB86AceA1A93a39426d7D60f4CC46": { - "balance": "1000000000000000000000000300000000009", + "balance": "1000000000000000000000000400000000009", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", "key": "0x5162f18d40405c59ef279ad71d87fbec2bbfedc57139d56986fbf47daf8bcbf2" }, + "0x863AcCE24e84A75b149e91470591225488Aa202B": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x5fc20dd0c1702289c1ebac32a00d38d5f3ab099aa4a62f756fc6740009dee488", + "code": "0xa00efdb534f3a036f288f1ed093d8ee3c505b1830f5e7bdcfba3bc6cef961d6725c7e231d8fa316d46e8b9b45ae34c96362447a0121688b5fc8977a621c28ef207353636cb00f21a886a8dbc179f462dc0eba7e397de30c4590b03532e23d3afc7e9ee3fcc756aafa61501a80648b24edd970a6d68f0424eebc857c57773f53e69a50b34f46ecf75aea648265eec0fff27688b0100a4a90d38989180db6ad3816b588810da3f66df779850de767250d6b354379a4ea55b612520748b864937ea6a37856c397693f1de1578faa1274997837d54cde3a4c322a3787c67642a2544338702c004713ec1a08e6b92548f894b51c234cd2945f4ef5e08199c618d1034", + "address": "0x863acce24e84a75b149e91470591225488aa202b", + "key": "0x5788e3a5115bdb419afcc4cc415404c53d8e15aa647bb459e6f01bbcbe80ee3e" + }, + "0x8642821710100A9a3Ab10cd4223278A713318096": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xb05730ba4681896d76c307f28a0744f22990f47580134eb2175db1f80bbabfa9", + "code": "0x5a13bb8468ff08ea1be5434a63d147aa9a75598c1472c6c3689ce0cc412fb137e2497937f87a756db742358161519471672c61e08459ad8650f94ad10a7dd95e33404a00df2797ca129732dcec6569f4fb1a987d4ec0b4118a6130ffa089264f2365e0ce0defc8344c79251e10c13bda9f60f98c7b76a120b28b1a0e8fcfc3610b452314837379af560040da1e59ab48282b9d8f6b5a9755a333ca81fef097517409e4ab0136215a31862fc94b13e16094495561fa1aa10a04fdf23371b35b72bf66e9c8a6f2fac97b772c6cb459729a5fda5bde7ee9c2761261bd7c12b4bf4018560b1f83759e5d4d88e0ae0bb6a6669899a83188652f373acd98f90e0e46a8", + "address": "0x8642821710100a9a3ab10cd4223278a713318096", + "key": "0x4fbc5fc8df4f0a578c3be3549f1cb3ef135cbcdf75f620c7a1d412462e9b3b94" + }, + "0x86b59E8a12C2BB58142FE270c534eA0AB3aFEe2d": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x86b59e8a12c2bb58142fe270c534ea0ab3afee2d", + "key": "0x76f24004f2230993f7843ed74840da1c520917d1f6a2e19d74ba58e52bd60a26" + }, + "0x87610688d55c08238eAcF52864B5a5920a00B764": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x87610688d55c08238eacf52864b5a5920a00b764", + "key": "0x80a2c1f38f8e2721079a0de39f187adedcb81b2ab5ae718ec1b8d64e4aa6930e" + }, "0x882e7e5d12617C267a72948e716f231Fa79e6d51": { "balance": "0", "nonce": 1, @@ -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" + "address": "0x891baaf101b07222bbcf62e7dc519199d09255b0", + "key": "0x1f45298df4f084a080ff705ba3b4b42ed8583bc310131bb496b4d2150c732e1e" }, - "0x89755Db2D43ED07322030C44268CFa774A05213F": { + "0x8A7EA0e207F38aFCE6C3b2A1D42AA55af13edFE1": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x8bea63d78653a516d0f413b043e750eeb449d8f5945d8b4c99a31a180ebdbd92", - "code": "0x3cf37595cd499be52965dd5cca4dc7fd8080976ba95b4d20907743b4d3ecf9ffd77d0f489ce296cd5f8054a5bea29f38d5248debcffc93c173d3e97af0f5880eb9106f1081d00798476dd8912565c23630e501584be091d1b1a61107e4b43f0c7f6764beb2e7bda5d37196dccaaf19eedcfd75069c8ae61ff739b58f0245c006f6e0480bfd242c1f13584a18b56f00f714e95b7578def5b6fe8aa6fe2c7565cb880cf1e5ea91773c5662a51b8b5d0bcb364561c2a7d5f3dd16bb1e539e17a963c6bed01c788e26af9ba38008dbb606bf52075609b11bbf1ff2f92d9630a74dad5f42225f39926a4b2bfb3ebbfb8ad78d7118cb50f042eeb7c25d212650a9a4af", - "address": "0x89755db2d43ed07322030c44268cfa774a05213f", - "key": "0xaa0ee8e4dced0932f418b0f072a87b286e6fbff9a0fa8b8914bb99c64cf7f019" - }, - "0x89b589f62abaEEC1C5BeBB68E788Dfae838470A2": { - "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" }, - "0x8cea358A7a343ac1142AAab4690DEE0572d28bc1": { + "0x8dcd17433742f4c0cA53122AB541d0BA67FC27ff": { + "balance": "0", + "nonce": 0, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x8ce72a0ce7ef4a4ae413b96a758180236e818fbd3e65950a11efa82cdede9074", + "code": "0x6202e6306000a0", + "address": "0x8dcd17433742f4c0ca53122ab541d0ba67fc27ff", + "key": "0x5014f5ee2c5966afd3f28ea3e96073eb0f4213dedf42d4214aebdf1f179fb9bd" + }, + "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" }, - "0x9025d2F24A1a23CB2B093823e52e1f90DAC60a95": { + "0x9103C21ffb25BB86EA67E2A55a82a3cee45F5882": { "balance": "0", "nonce": 1, - "root": "0x5a937f34e712fd3198d9708e641383e8e45367b8fd1732b5d8a9f88835045af2", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x5f648f090749c4f185cdfd503f551f6a139518ef3b43034af7a2b6ea5151e0d4", + "code": "0xfa180208e416b80964438d3c35d1cc392fa2306729e8d162378339e15452ec247ea39c3a1b472adb1a46b82f40de40bb7a9fa5ad3dbeac7da36175e48293187d80ab0009a43379585ef3a79a25eb8b1572a96a1872c34834f703ae9e75aa75615b8b05a5871be0d722857bea97754d7edb37140ff7f5ffaf755616aae77f9ee7ff5af8c6d0a01a7e08a3fc6755b1e203b13b017a37f29ba48e9d20c987ab01a447c79cba3f4a4cb401a74b9326948647c38eaca90838d64c42fe591a3970e60281cd6fd31e0e2075b20489038375b1268e8cc49cebd55fbf190199521e0b9268af8c5873f91d3f43478f15fdd9584a5f9afdb530ee1cc5e23e8ed7c5c37842b5", + "address": "0x9103c21ffb25bb86ea67e2a55a82a3cee45f5882", + "key": "0x0ddecb41d3585905401dec1427b10fddf452737202507201d54b12b41e58e1cf" + }, + "0x9167Bee148a782A1Ff58D1e87E2ba20F5171580B": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x9167bee148a782a1ff58d1e87e2ba20f5171580b", + "key": "0xb19edf94146a2973ecb69c4fcbec11b328d0827e2492aca625601728aec20a76" + }, + "0x923F800Cf288500F8E53f04e4698c9B885DcF030": { + "balance": "0", + "nonce": 1, + "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", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9379ed0f7e4f0da2814dc50bbf895f239be0e367", - "key": "0x89cbf9be493866f796305912943ca6b0991e8ad18a2f5b4a2847c72aaa021fff" - }, - "0x9380b994c5738F68312f0E517902da81f63cDCfa": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9380b994c5738f68312f0e517902da81f63cdcfa", - "key": "0x50d83ef5194d06752cd5594b57e809b135f24eedd124a51137feaaf049bc2efd" - }, - "0x9539d142fbbdEa1A80522fEdfA5A8619b4fa1861": { - "balance": "0", - "nonce": 1, - "root": "0x9eda8eb6ca03d7c4afe47279acc90a45d1b2ca6a11afd95206f8868d20520d06", + "root": "0xb9e281bd4eeb831410eb18e4fd03a36f0e5977e0c76074b27d202f879f924c87", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x000000000000000000000000000000000000000000000000000000000000001e": "1e", - "0x000000000000000000000000000000000000000000000000000000000000001f": "1f", - "0x0000000000000000000000000000000000000000000000000000000000000020": "20" - }, - "address": "0x9539d142fbbdea1a80522fedfa5a8619b4fa1861", - "key": "0x9a57b0a587fc060d23e9d43445f3f75c10c91121e850e44ef1fd11e47afd5ba7" - }, - "0x98618Af6804CBB0B95A2625850bdC390f3Df5792": { - "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" - }, - "0x99D40A710cb552EAaee1599d4040055859b1610d": { - "balance": "0", - "nonce": 1, - "root": "0x9b3243375d54294b7f3e11b027fdfb57c63136fe58b679c0a227e2f55ad7c072", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000147": "0147", - "0x0000000000000000000000000000000000000000000000000000000000000148": "0148", - "0x0000000000000000000000000000000000000000000000000000000000000149": "0149" - }, - "address": "0x99d40a710cb552eaaee1599d4040055859b1610d", - "key": "0x946bfb429d90f1b39bb47ada75376a8d90a5778068027d4b8b8514ac13f53eca" - }, - "0x9DDDb8668AF4D3DC4746b64973d7961Cb7Ca83Fd": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9dddb8668af4d3dc4746b64973d7961cb7ca83fd", - "key": "0xf251e6fdb71031f2b1cfc0e2189460c6b88783c30f5d8e84aa0bf5262b7064a5" - }, - "0x9Ef0201350e14E23DEFbace3Df6C0582F1B7eAA0": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0x9ef0201350e14e23defbace3df6c0582f1b7eaa0", - "key": "0x136a96313f35a3d9f3439a676c0780ca086c2638a6b92272afcc6e296b89935e" - }, - "0x9b3cf956056937Dfb6F9E3dc02e3979A4E421c0A": { - "balance": "0", - "nonce": 1, - "root": "0xce2f545355cdd2106ac32f9929d2a421f2b50fa224d450fdbd6ce592eeec1222", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000003f": "3f", - "0x0000000000000000000000000000000000000000000000000000000000000040": "40", - "0x0000000000000000000000000000000000000000000000000000000000000041": "41" - }, - "address": "0x9b3cf956056937dfb6f9e3dc02e3979a4e421c0a", - "key": "0xb1b2c1c59637202bb0e0d21255e44e0df719fe990be05f213b1b813e3d8179d7" - }, - "0x9bB981F592bC1f9c31dB67F30Bbf1FF44b649886": { - "balance": "0", - "nonce": 1, - "root": "0xd60ee4ad5abbe759622fca5c536109b11e85aa2b48c0be2aebf01df597e74dba", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000015d": "015d", - "0x000000000000000000000000000000000000000000000000000000000000015e": "015e", - "0x000000000000000000000000000000000000000000000000000000000000015f": "015f" - }, - "address": "0x9bb981f592bc1f9c31db67f30bbf1ff44b649886", - "key": "0x1ee7e0292fba90d9733f619f976a2655c484adb30135ef0c5153b5a2f32169df" - }, - "0x9c06979A58c4E331F355883d1e893D13e3b7F341": { - "balance": "0", - "nonce": 1, - "root": "0x209641d47d9d587d8c732197fc36a51c1d24948f632742d213d0cb8763c7edf7", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001ec": "01ec", - "0x00000000000000000000000000000000000000000000000000000000000001ed": "01ed", - "0x00000000000000000000000000000000000000000000000000000000000001ee": "01ee" - }, - "address": "0x9c06979a58c4e331f355883d1e893d13e3b7f341", - "key": "0xa619a597342a62e6b3fbe3ab3d7933a82020342dd0f1520abfa4623d9bbbbb90" - }, - "0x9e59004e909fF011E5882332E421b6772E68ED10": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x2f69e37f59a31ef79d90459fccee2d365e354ad304c05e646cbf6b4a9f085eab", - "code": "0xb4c4e2b6245313ebc2e84fd30cd4004aef84bd2a40151a93462f49c26e7506fb2d24f5b2a624144cca8966ee8ebaaedd1ac3debcaece0f685b099077dfb2d70a0e75755c41adbb4f27053405d1410dcc6f39998c05961a8623aa6cb33b0be66f8195e934be8e1e1e67e36670679242f3eb3fe013d19203686902c1dc42dff3e49866e7eef0c92f888b29f2bed58ab872a91939249d76586c0b7412b6b577479e1d87c3377c62b76e969d2b0db015e24647df9fee4d414b11c6817618df8537f3098e5c8946c3f55aae04af8fe9c4589802eae2b11667f4dfa6883e23815c01edd65ecf137cd4f3b2d832c2d1201b08f864662ac72ecf52eb255eb7d0df1a1db6", - "address": "0x9e59004e909ff011e5882332e421b6772e68ed10", - "key": "0x3897cb9b6f68765022f3c74f84a9f2833132858f661f4bc91ccd7a98f4e5b1ee" - }, - "0xA355a21C36De6b7218d21e119b60676b176704fc": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x733cb31bbb18e7b961481250f0ba1360594dc64d3e718fe7de2ec90d34c6098e", - "code": "0x1e294673971cfca694eb2b530effc46ed1a0e6951dc278025e8cc33a1b7920173741728d05b0ba6fc6794269449728dd17f14bc1b31e69610ecc42912ff0f4d20e2fb4e3c2ec2260f93ea3216765fbac4298665bf7377032a021f529b2e2d5222a16a5eea9d64b50e6e0c5b94e99bd7223c40366b3c0a4ea4fe6ffa3e3a0e6e1ed85464681cf13f1b75d78e7f27dcf6f81bcb07a6f89e5530327fe310424559eaa4c866d26f9e82356895b445c2e5df46dc3b43ac6c8b2c240632dc8221f3a766c72695df125cf92f136bb13fddea02c359a434c7ac841202aefd428779c63f889b65a10a48c13fa4f1a7fd615279159853638195bb5622212415f85f7b734e0", - "address": "0xa355a21c36de6b7218d21e119b60676b176704fc", - "key": "0x958facc25352ac71b19beae99e016548fa24d959f5e766b4f9348cd15b65d565" - }, - "0xA6a54695341F038ad15e9e32f1096f5201236512": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xa6a54695341f038ad15e9e32f1096f5201236512", - "key": "0xa87387b50b481431c6ccdb9ae99a54d4dcdd4a3eff75d7b17b4818f7bbfc21e9" - }, - "0xAE6883d7bEE5Ac3a2B1B2687C64309d3a168fBE9": { - "balance": "0", - "nonce": 1, - "root": "0xaff437d2f3b4a919f175d26053aae80fd53ae4901a9007925d621faa5d3024e8", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000202": "0202", - "0x0000000000000000000000000000000000000000000000000000000000000203": "0203", - "0x0000000000000000000000000000000000000000000000000000000000000204": "0204" - }, - "address": "0xae6883d7bee5ac3a2b1b2687c64309d3a168fbe9", - "key": "0x0e85ef0d4474e7938384fefcd97e2f3603fb0fa1d3efb98eddfa5ffff6679cc4" - }, - "0xB565fF21AF37E44a5E8BC217D6B43C86419CF0F9": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xb565ff21af37e44a5e8bc217d6b43c86419cf0f9", - "key": "0x66192e4c757fba1cdc776e6737008f42d50370d3cd801db3624274283bf7cd63" - }, - "0xBAC9D93678C9B032c393a23e4c013E37641AD850": { - "balance": "0", - "nonce": 1, - "root": "0xfb79021e7fa54b9bd2df64f6db57897d52ae85f7c195af518de48200a1325e2c", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000000ef": "ef", "0x00000000000000000000000000000000000000000000000000000000000000f0": "f0", - "0x00000000000000000000000000000000000000000000000000000000000000f1": "f1" + "0x00000000000000000000000000000000000000000000000000000000000000f1": "f1", + "0x00000000000000000000000000000000000000000000000000000000000000f2": "f2" }, - "address": "0xbac9d93678c9b032c393a23e4c013e37641ad850", - "key": "0x8a8266874b43f78d4097f27b2842132faed7e7e430469eec7354541eb97c3ea0" + "address": "0x93747f73c18356c6b202f527f552436a0e06116a", + "key": "0x73cd1b7cd355f3f77c570a01100a616757408bb7abb78fe9ee1262b99688fcc4" }, - "0xBd079b0337A29cCCD2EC95b395Ef5c01E992b6a5": { + "0x96D9eB44cA2670Feee25Ddb1359B6d36e6fFBaf5": { "balance": "0", "nonce": 1, - "root": "0xe478b9c7df7d530ab039ef863b6ee52df4c726c17ac895122343b51c45d5f18e", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0x96d9eb44ca2670feee25ddb1359b6d36e6ffbaf5", + "key": "0x54f5ae26f0a76f1cb1f3f6d1677c1483d53e13f47e520a1583b31a61422c02c2" + }, + "0x98689EC73E856AA045d939b320765303666Df0B4": { + "balance": "0", + "nonce": 1, + "root": "0x52d6d2913ae44bca11b5a116021db97c91a13e385ed48ba06628e74201231dba", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000029": "29", - "0x000000000000000000000000000000000000000000000000000000000000002a": "2a", - "0x000000000000000000000000000000000000000000000000000000000000002b": "2b" + "0x00000000000000000000000000000000000000000000000000000000000001c1": "01c1", + "0x00000000000000000000000000000000000000000000000000000000000001c2": "01c2", + "0x00000000000000000000000000000000000000000000000000000000000001c3": "01c3" }, - "address": "0xbd079b0337a29cccd2ec95b395ef5c01e992b6a5", - "key": "0xf0877d51b7712e08f2a3c96cddf50ff61b8b90f80b8b9817ea613a8a157b0c45" + "address": "0x98689ec73e856aa045d939b320765303666df0b4", + "key": "0xd5c9aa063e60e4cb577a1d645d09643c9074af8fa8677c78bd1240cac7b6749e" + }, + "0x9BA269ed634782aE1fd4508A841B697DEAd12744": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x5b8c99577256a15d06a28136692317076372b213abc4dff772cc8036c96d1084", + "code": "0x00caca6c725b2071171ea44f3346bf78f8d0b5597a2a408f011fa08aeebfdf2ab4b879bb3f11edf50695b610ae1ee979639a7ba524b1c699e0f89b9b31353fec6fb82ae3a889cf4e8d2c22a8349342b87eb518f9f05e15ad60fe6991d6c420cffd78ff3ecb67ba1b488f00413974097aa64512e6c708a2a6b96680df32343bb8cc5c8c706f8389f8e638c815d14b44781c79c9bd4b5aed387262c62c4249401d53be41676d5cc1f0a9d657b80dda9f476346bae3ba32459c3c42ff07ead14c2951409a2286f645e1dcaad586703c168893dccc02a1a9aad36a0076045dccedfc994a8886cc0e1ee9de6e5b5661a7c83f7243c5f0ad8c0d5c6016c5fbb8882983", + "address": "0x9ba269ed634782ae1fd4508a841b697dead12744", + "key": "0x3a8a079f2f9b3eb93f242e2d3e7158f0f6850302944c8752ac210c93463ff6ef" + }, + "0x9F50EC6C8a595869d71cE8C3B1C17C02599A5CC3": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x67d7afc302b0d54eb18853411f46998d05c8eaf4da3f2b77af1fb618626f2bdc", + "code": "0x3f1579c5434b902977fc1e0703af241fe080512fbb19dc21b0d08faa73050669a4eaa4181d8aa57552f668c2ff97a093341c3d011221f34a7505ed786b4bf2a7d6f9868dfb52c402e1d59c73c3f2f623c40a3db8774902d63940b3f50d6ef3848335fd41503dd7bc5aa80d8d618041fa501eb79009bbbf336978ac474a44ddf02e4f5055f95dbb749a90019f6e44beb69dd0487d79367dae3c2cb00571405a3eedf063063c2432b0daf4344815598e8dac7a678a6019d0efceef7dc21aa986ed588f4bad177fcafeb86bed8dfc1d9acf702e643163d5b6736d7bf35d937d255f86ceeafcdeafbc5fee426ab68fb25b6d7278bea8cc7dc7c6d8b22351c2a13639", + "address": "0x9f50ec6c8a595869d71ce8c3b1c17c02599a5cc3", + "key": "0x2705244734f69af78e16c74784e1dc921cb8b6a98fe76f577cc441c831e973bf" + }, + "0x9c6e13AE62C45c5af66061ae7d5bd7777bd73Fb3": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x920edc96a12889225908eaac095bcde16b6e5c8c252b15db65db90e1974251b6", + "code": "0xd6d11e3863c3c5c135c900a7a1f2145ef8955827c13fba8bb96e8ba136267217fa958e1be2d3d8d37da34f1c291dcec750fb1828e4bcff2846e36aa189960a9f00bc01de787f9aae8d65e5871bde106f5c7828b32fd415624a3d18da543a148d9c68d7404ea71965a39260214a95ed0602bd38a9bb003aaff75f9fef6859368a7a994dc0d23dbd6a674e00a2fecd717ed14fc668e1d60c12dd72df674ba0055d8dd1cc0c68bc6b297f58d399ad869ae785ae1f5878bb7c943cd5d51ef157568375a356d8f1fe1b56859f3da848bc73e306897a977d2988371232bbf4bf1e3f5ae5fc80b2bb06155477ca775440f681635a2010925a774478b3685b59b1c5d864", + "address": "0x9c6e13ae62c45c5af66061ae7d5bd7777bd73fb3", + "key": "0x255d91ddd310cc85afd19e6dae09c70558cca5fb7f1bb7a8ff074fc7e99cba61" + }, + "0x9f5CC913d1bB637b0cA3510A49BFAA0051deCC75": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x851cb461ed63af978778812e29b8438ce3f16aa94563d2da59fa0be03ac953e6", + "code": "0x42e4f963a3fa39ab69d625e264d630b7b8d02724b6965c3e5947a27d0128f6464e121f71c7387e782159a5ba74f560edf5f0a75236c9955a45a634893ccae10d5a6abfa0b523f1fbb68d45b199c8a459119750121cfa7e46c7afd4a8f9bb9b99ee067c1090ecd738876f3df0e706ba52760fc8dff34c0a82ab024434431f51deafdf7aaebcce7888b84b30340b3fd0b42f1628596c1a7bdf530b00a0e826bd8a0c8c25983c5dec62ddcff7ef6a7b6a0125a8e67abeacf43feb9033b61ef373d797d00f5e9af51f367376d3b4e378fe4451a9a7f795a2a7bab9aaea91f6031d6c83754adcbc6e45a35e984f70507c095d41bbef00afae3cb78028e9ccf3b0736b", + "address": "0x9f5cc913d1bb637b0ca3510a49bfaa0051decc75", + "key": "0xeceecfebcecb0c7cc1178556acca97a647ac263a51908fa44bfd209d82387baa" + }, + "0x9ffACcB3fF3D37762a5a37C4255e47f524E2C975": { + "balance": "0", + "nonce": 1, + "root": "0xb856a374cf6edfda9a89ee543cc835161764cf5dba40a87c2748d5bd14a5dbe4", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000245": "0245", + "0x0000000000000000000000000000000000000000000000000000000000000246": "0246", + "0x0000000000000000000000000000000000000000000000000000000000000247": "0247" + }, + "address": "0x9ffaccb3ff3d37762a5a37c4255e47f524e2c975", + "key": "0x93dd6c4b1d18f757fc687bfe44d81ee7eb4fb269120f91e7bc6fe3f596be47f5" + }, + "0xA1164E71D16e9eEec97392A83B253438FB36C108": { + "balance": "0", + "nonce": 1, + "root": "0xda3f636d9768b5cc17d188469438245b9115ab2c12280c4185c3aa039792b3be", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000013d": "013d", + "0x000000000000000000000000000000000000000000000000000000000000013e": "013e", + "0x000000000000000000000000000000000000000000000000000000000000013f": "013f" + }, + "address": "0xa1164e71d16e9eeec97392a83b253438fb36c108", + "key": "0x3c14ed4cc1c3cdeeb405fa351cfd8e2cabbbee07b9fe38828a2abd2eb9842cfa" + }, + "0xA90169ae859913CC39E0c24ADdAD3E74788276a3": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xa90169ae859913cc39e0c24addad3e74788276a3", + "key": "0x8c1e1a5ebeff0db0b6358fae0f6947ca7e092a3c6675d35381f2358a170eb0b3" + }, + "0xA961fF20323997A869Eb4D18E8a7Fb921690E793": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x672ac0692d0cc664ef0f82004a74014b2304cd08526c32826d91d6ca2e895070", + "code": "0xb2e2b84e9c287c35516c8c03da30b8438afb348d4d79934a428878aa29874ca0ad6f0c78bdaf95ef24d97b54420f40d55858cdd1fb13209f0d32e335a0c9e2bd7ec3c2f200843fc90126ba954586fc6de68c1a3d419d6f0667702fd695602f052f84c972fe68fabc45c457b4ff540e42699a4370cab6e165c8aa3ee904308975acaad697e97d6029fe86d542dad1d34ad3d6952dc1e276bca67b4305f914f2e385f617656293cf345cffb629940096100b80c9fbd7417ab664df65fbc8ab4ae3c3a4f9c0cd86a77a5f703bc4c9de9055aca230e85714684c3c974483c02b2238015395b57ebda58dc99e6864a8c8ae71ba95fcfb915d35ab1c5375564a181e19", + "address": "0xa961ff20323997a869eb4d18e8a7fb921690e793", + "key": "0x45a2591a446e24dacceeaa3302901481268f67a0c7a3f5e282dc54132ef54fee" + }, + "0xAB557835aB3e5c43bF34Ac9b2ab730c5E0Bc9967": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x9716c463c09b065800e539fb1d0cec27d8237686c32b94b7c0da4e49e41c02a4", + "code": "0x30cd5015e58b9c24eb2595e46f57007c5ed8a4ec876a16d456573afa20d3e9f577ebf6665d47f78de8fd49ef0f2b9e56505597ecaabf21c3af83dd603fdf48673b77fbda46b9ec81be06aaa750123ed7df8486d593acd5a63efe1ee068667c8d95bece5f6b20131d5e81b5b1776a1207bfb0e442012d2877df319d49ae267d7d37cbb42e77be277901f199d496ec2cbd5a4a969935694ab27df77ec42914a258f282e2888c324df7cb75156822c2e77eb209598344e61a2f9e26eac48e8a1c0deaa54584ad2f8e3adb41715141f532d0309f2407f7fec73992b958422fb316a3fcc52bc06864b9e3d1f7f3445c632ab994c7b676fff2b07ce1895e6627a5e6bc", + "address": "0xab557835ab3e5c43bf34ac9b2ab730c5e0bc9967", + "key": "0xc9ea69dc9e84712b1349c9b271956cc0cb9473106be92d7a937b29e78e7e970e" + }, + "0xAB9025D4a9F93c65cD4Fe978D38526860aF0aa62": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xab9025d4a9f93c65cd4fe978d38526860af0aa62", + "key": "0x17350c7adae7f08d7bbb8befcc97234462831638443cd6dfea186cbf5a08b7c7" + }, + "0xABe2b033C497E091c1E494C98c178E8aA06Bcb00": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x95e57877cb77e5808a2bcdbd9a45d097c0b3dc68abb1f465ea48b008a3148556", + "code": "0x1120594d593e46ec980fa0e64ae4f1623f0418421709dc7d6fad68015af55d1d620578150f00fe0405f3d5666527df1cd988c5f1cb8f0c21d438b7905f0afa7e378a1747347d49ceae36de53193d9d8491e80e3a2fb11519a36bfcfac52a0538f66305a61ddb824256acb564f9115b8a40970c3a191cb25bf2239e3351c867ad7689a99680307812a025bfe2515f32064fcc60dd1f88561facecb27800c6e7d8d06a3dc40d36e90357739e5267c8f470c6aa505d386b9fbc86dd03bb7df3aac74e667e8bad4edde6f56bcaa3e55b50d51f169d5647b8943e923ba4e5d9251b30c0a91aeab3466ec13dc835dabc920debb7b08929ed570a9253107510cdb18f73", + "address": "0xabe2b033c497e091c1e494c98c178e8aa06bcb00", + "key": "0x2374954008440ca3d17b1472d34cc52a6493a94fb490d5fb427184d7d5fd1cbf" + }, + "0xAC4D51af4Cb7BAb4743Fa57Bc80B144d7a091268": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xac4d51af4cb7bab4743fa57bc80b144d7a091268", + "key": "0xe42a85d04a1d0d9fe0703020ef98fa89ecdeb241a48de2db73f2feeaa2e49b0f" + }, + "0xB0eE91BA61E8a3914A7eAB120786e9E61bFe4fAF": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xb0ee91ba61e8a3914a7eab120786e9e61bfe4faf", + "key": "0x4bd8ef9873a5e85d4805dbcb0dbf6810e558ea175167549ef80545a9cafbb0e1" + }, + "0xB39590ED5AFc0053c8546F42aDCA5103127101d0": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xb39590ed5afc0053c8546f42adca5103127101d0", + "key": "0xbd016cd87ac43eda3340965f21b4c4468864a7f5bd4924913e1f872c3043752b" + }, + "0xBDda53a9729794D60e7555A0A9066b3aBCFc15a1": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xbdda53a9729794d60e7555a0a9066b3abcfc15a1", + "key": "0x8b016cf0507d02b670f348014bfbbac4ddc6c327f162ad478a4d4658a11ed051" + }, + "0xC019b892751D14Fdaa6cF0435E7f52C957E9F11A": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x1d6fd9c82f1c83e2e756f73641224957124560dcc9047ba881d7c4f08bcd3866", + "code": "0x5bbfe49fc46bd3c0efd63509af9eb2a12636d52d97f4d1cf52bf53227ef389c271b77ca6c28942a6a5831a75c27e59515f05848f3eb905d816d90fe6792b6da75759ed2ce2b5d312af3edff82a4df858741988b1bddfcca1f32b72a28d1d70f0f787d5ff306ee7ea1d7b35b5cacd5a837646921c113945dbc3a3b6329ce400332b634da6ab875d88498f503820d9b51f6eb10d3d2f378c32aef2289b509f3def68ec43d1fa25ecab18a22465ce1f8255926468a3d494eb646e020d9745efacba95205ee1597333a2b36cc31b0a8c074c0c1fa2918672c4e3dde98e6eb3460fe407979f83feb91e6e71e734e272c56671bf06f2c8bf8067684cbe31f663fccc52", + "address": "0xc019b892751d14fdaa6cf0435e7f52c957e9f11a", + "key": "0xae30ad28b2c8aab0d3c983610429e60fc0073255d1c69e538d6ae7b5d9562b4f" + }, + "0xC798205CF296141b777279868c635Cf7bb515510": { + "balance": "0", + "nonce": 1, + "root": "0x1bdb6449de127c6efa6829eef0c6b2188a66f104b5d1091f7dd3f419db0a8da6", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000224": "0224", + "0x0000000000000000000000000000000000000000000000000000000000000225": "0225", + "0x0000000000000000000000000000000000000000000000000000000000000226": "0226" + }, + "address": "0xc798205cf296141b777279868c635cf7bb515510", + "key": "0xdf474a26cbbb578c227ea61f57b81c27ce1e9d917d32a818f4e13a84591d8af2" }, "0xC7B99a164Efd027a93f147376Cc7DA7C67c6bbE0": { - "balance": "1000000000000000000000000500000000007", + "balance": "1000000000000000000000000200000000009", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", "key": "0x8e11480987056c309d7064ebbd887f086d815353cdbaadb796891ed25f8dcf61" }, - "0xD089C853b406be547d8e331D31CbD5C4D472A349": { + "0xCaE62C8E777eA0541A55B5Af15D59eECc71cE2ac": { "balance": "0", "nonce": 1, - "root": "0xa33259a022cf713371b64cf9305a032e8bf31d4245fe00f5dca4aaa19967abb4", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xb18b045e361de70704dd8b0b76210e158bcf3cb17d01d32af071fdcc6f599b95", + "code": "0xf3261457f4fd0b7c00a1511877ab27b74183ac470be8db3a7ecdc64335f6f979dd2cb9885bc4a6b7d63bce617b9a4981fb4dfc6d1957489e794070560e4e930da145dac0d5853e9e18103395cfe86de32038064edbc272862280672e49bb93357b2f1db823434eb2c3257b921622f3b73c33ed78ab6344072b7d0d89829cce01e9e3d0af61c0577149d8fdf930c9e5cbb4ff7a5481b41229c7576f61f8f2ec08c6d78b22ca7ce0ed62fd1a46e03059e749d11a0ae0882853a9c6848594bb8508c612924e9d43860c38e1b79881d3d6b2fbf66e000a9d5170db882dc3f048dd6fbb59cc25b8b8d576949767a0b63e0aa0df84d25f2821a2ea8cbdfce970777b41", + "address": "0xcae62c8e777ea0541a55b5af15d59eecc71ce2ac", + "key": "0x3f6c9bea2a94e47b2694dda7576291a475e5e70977c0a71fedf363ea2cb652e9" + }, + "0xD1FFA9fF507492844818d0d91Bf35B93a7c95E4a": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xde7b1b0e50a7d7bfc2941895dea4aa00ef5020617339bf6862b65a44fb9e3e7d", + "code": "0x5ee7521a899a1bbd499ad817e1d673d594eb84ef5130440e43abd9ab1110486735b47ec3f55b71d6589203440915d2ef7280ff31d26085f81a04730b0655d961b2c0f7f2035a27e69c9e7dbc21354039da07b465d84ab3b1eba23eace489d13e7bfa808024a5334b0a1e191d8e95f6724ea40d1a03d1286b6934e670f8c6924b6a1b1ef94f6deb640ab38caedbf44252d256d60e00dbeb774c18a4a570e050fc0e4439da0f5e13593fa65268ba122e984104c23e93195f67ae3ccd394337e11d8725003c645a213b2583d67f9bdc3f05a16873ac6edf6234e388904a6f2b0dde4a6beb59a7cd08dcb4592438190f4a5c641daeac5ab9b96006d018a6e01e04ee", + "address": "0xd1ffa9ff507492844818d0d91bf35b93a7c95e4a", + "key": "0x4885a02db06138818497f56f6ef6f9611b1fe93d81f6d4a03dd83ee80a119ed6" + }, + "0xD592d2BCa2E78Bf7f3Ef341A2f6B8F0BF96343c9": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xd592d2bca2e78bf7f3ef341a2f6b8f0bf96343c9", + "key": "0x07891c3045a0c538a419a3c93f75a612f61a0d8be29aa478f990555ede27620d" + }, + "0xD7678E32ceAc078dc261D151aeC9b898159E913b": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xb4930a125627ac818615f09e52738e8bd19f268bdfddc69da23bd7b4fb356d06", + "code": "0xf078381c098d7f56dca8447e60d28e39dabf16c4904f8d5980026cc19a6afa0bc7c87573e3262dc947d048fbb918b7a15536786731da04effd045b5a3482a16f9440d37190611706c0e4201f46f8693282307e769f69845197a9beef60e5f566af4553fd35816720fe0f3fda7c1e71383dbf00831aabef83faf4be5b7112ed159eae233279988a43ad0a99b0d0230f245ba8453a0accc9af91185b1ecd1a7116f29da813564266cccd5dc5a3c1b701abfaf5ac71f45fde4e18fcf60d7c41d5846ad5557a6f35d40337b6890f3b6f15a1e64adcfbc425b4bcb28ee67b2b920da212520cb5bf4d324fac63d20e3230854765e952834555d0e102dd85ff0e57cade", + "address": "0xd7678e32ceac078dc261d151aec9b898159e913b", + "key": "0x9fb96451e98ab7803d6bff5c91f131133a99711978a9a2b3bd5af43252869882" + }, + "0xD9c364A44CEF789017B5bAD4F17e197D079c76aE": { + "balance": "0", + "nonce": 1, + "root": "0xd91acf305934a60c960a93fb00f927ec79308b8a919d2449faede722c2324cb3", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000097": "97", - "0x0000000000000000000000000000000000000000000000000000000000000098": "98", - "0x0000000000000000000000000000000000000000000000000000000000000099": "99" + "0x0000000000000000000000000000000000000000000000000000000000000153": "0153", + "0x0000000000000000000000000000000000000000000000000000000000000154": "0154", + "0x0000000000000000000000000000000000000000000000000000000000000155": "0155" }, - "address": "0xd089c853b406be547d8e331d31cbd5c4d472a349", - "key": "0x389093badcaa24c3a8cbb4461f262fba44c4f178a162664087924e85f3d55710" + "address": "0xd9c364a44cef789017b5bad4f17e197d079c76ae", + "key": "0x51c07e7aa8b36d37d8094e2bb6a81f3f8f275acdf7620f893f933a9ffb7d6377" }, - "0xD68D1A62f58c6B8cceF66B50228Bb9163784F355": { + "0xE3A8b633a20D3Bc82CFD6d6cB315dD9784b3EA41": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xd68d1a62f58c6b8ccef66b50228bb9163784f355", - "key": "0xf7eaa0ae3d9e339e65e019d913513f53f3175e0b35c21f171cc04e6bb06e8c13" + "codeHash": "0x6a95d1532ea10e01c45c3852bd1dc75cde391adb68e4c49179dcf4594b7750bc", + "code": "0x252b89bf90b319923f6559e774e32f611a27a81d0f532f5b807532a98a9da5dff6346df2f890680af66f02884a3534996812dc8641475d151d43319ca32915acdfb3923e257006c00eb45b8fd73a3468e2d76d01d6f08434ec78404b1eb39275fd55fc2e9ef63e16e696580fa41a16b1359de042d9d894f9176ffec1c194a98623daade2992486e297dc206712cf2981a43df9a70de4d5f3b59dea984dc1135be8aa0c96d7827d7f81d506691cca1eef157279cd2b906ec7a6ae523f2e4aacf9fd0f0a9f6943052f202072825110d2e71fe4569f7a80872d4befddcab68faab64571c490b675f7c0c08a6af51968eed01a2a796f37061d16506458d1631c4af8", + "address": "0xe3a8b633a20d3bc82cfd6d6cb315dd9784b3ea41", + "key": "0xa3f8196fd37c836d7a5bfcdd9807147e8d74957f5125bed4c6fe6da4e348dcad" }, - "0xD917458e88a37B9aE35F72d4CC315ef2020b2418": { + "0xE4f62e66DfCeD3f18080ed3080b276edaEF0E1C6": { "balance": "0", "nonce": 1, - "root": "0x1b9e47810d5392418d38571a39fa5984e48e0f03b932d8b98f6aa771ccad65f2", + "root": "0xfe629ea231aa00b09ac842cd51a4c63ced36a60cbbc2fd49c2891b67b38cfe9f", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000131": "0131", - "0x0000000000000000000000000000000000000000000000000000000000000132": "0132", - "0x0000000000000000000000000000000000000000000000000000000000000133": "0133" + "0x0000000000000000000000000000000000000000000000000000000000000061": "61", + "0x0000000000000000000000000000000000000000000000000000000000000062": "62", + "0x0000000000000000000000000000000000000000000000000000000000000063": "63" }, - "address": "0xd917458e88a37b9ae35f72d4cc315ef2020b2418", - "key": "0x4c2765139cace1d217e238cc7ccfbb751ef200e0eae7ec244e77f37e92dfaee5" - }, - "0xD9D4095509b1ea9aDde0E42D4eed8A4bC01ce4F9": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xbbcdc1260a8c1207ed4df8f6aa53d86b13407470023e3d529bb2d34ee71739ef", - "code": "0x505a94e92091157a2b6c32cdb529e4e0fff70a56f15fdc98e76e3995f7d83843d5db31e9e7c32143fe3af51e3315d4786b187de82f0dfa39162c39200bde0914635ba9e622461ba1e5f620ca05d0e3903d2be7dd66af8da9796c6b26acd3b499fe480de640588828f4a109d5f0bce8c49ea257ed6d39a78cefb2cb82699ced8d0b68115d5c2b6ccaf79db212002dcc3d52944fdf04f672a09f6629e434f2646687ab7a5a3e42e9ce80c9bfd4beffdff114c758e71396b4ddbbdcc38c72c3a00cbf662de3bbc8b6d7b5786261d3e6f5e282baa7fdbd39fa16fa0c27c43972cc6e10e1d521b80b6a244f273da5d76441c35c86907c122c4d9bb88ab0ae851ea3f4", - "address": "0xd9d4095509b1ea9adde0e42d4eed8a4bc01ce4f9", - "key": "0x38978834c603c45c873fa267fe1b541694e9e55e9c59abd0c22489cd9eaef823" - }, - "0xDB25388D92FA7D824178bc472C0a5FD84A69d18D": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xdb25388d92fa7d824178bc472c0a5fd84a69d18d", - "key": "0x9a36e49d6fa789abc112272965ccb529476471bc9584caf51bbf38cf818ecf57" - }, - "0xDD9ee108e8d5D2E8937E9FD029eC3A6640708af0": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xdd9ee108e8d5d2e8937e9fd029ec3a6640708af0", - "key": "0x2a39afbe88f572c23c90da2d059af3de125f1da5c3753c530dc5619a4857119f" - }, - "0xDE1c2fC2e4Ee50F61a0Ee3758Bb67Bc468467F03": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x6ce8bcf63e7a26264045680ee93464c00c1029a197aacc749391b7a840cc8697", - "code": "0x24259e866b89e445290f514548cfa7341e867e1c75b75575d8008246d6bf88796e0cbff4014bd643fbb0707f5e2c1ad686153dae9f96a33de90a5cb2c73f01934107dbec03e25a3a7041ae16c199ebe0c15cdfc958612c5bc8a87d743449bee7e7b26963c6a46bc669ee69f5ec3ddaa2b4dba8fb6c66bbf247f3096d559f5641849d57e96537ad7e37a5709b12dd8ea54383e2864ba1d0d83e2ffbde7f8a5fb5f6ddcb15ef525982aac03ef65faf2cb3fcdd8eb6b2a2b58c6bc2acd57989ebb44362cdde8131eaf20d98617619b09146ce4f5f53fe563db99ef97b050183da81c5072f4eee335da8bb992dd71959a7534cd43bcc582c57ed9631abb2f4d7bcc4", - "address": "0xde1c2fc2e4ee50f61a0ee3758bb67bc468467f03", - "key": "0x0243011ec33679195dffcf94a02eed0e26b589f14af470e55e798647b537c46f" - }, - "0xDeF9100B4510C563B2532EDDfC5dCDc82bb541f2": { - "balance": "0", - "nonce": 1, - "root": "0xd45ccd3dd6bb0efbcc59566edbba5873ffadaa694d76582ad5b876b88f39b461", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000008c": "8c", - "0x000000000000000000000000000000000000000000000000000000000000008d": "8d", - "0x000000000000000000000000000000000000000000000000000000000000008e": "8e" - }, - "address": "0xdef9100b4510c563b2532eddfc5dcdc82bb541f2", - "key": "0x9b6e7bfcd9347b45c94947acb6ddd3df4d228807ea09100b7a60b8c1b2aede5a" - }, - "0xE06751015cf69396708198F9Fd3fAC98367847ae": { - "balance": "0", - "nonce": 1, - "root": "0xd39ad83d4fc3df3ce208b6c0779e4d1c0138867bdd0a6ba4e49ccb45419e540d", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000013c": "013c", - "0x000000000000000000000000000000000000000000000000000000000000013d": "013d", - "0x000000000000000000000000000000000000000000000000000000000000013e": "013e" - }, - "address": "0xe06751015cf69396708198f9fd3fac98367847ae", - "key": "0x0610ba7a05912ec56deae88974bcc177dbce70b079adc9db6212f83a093a91c2" - }, - "0xE153E75b139632f5d13F19d5C66579D5d6813259": { - "balance": "0", - "nonce": 1, - "root": "0xff687feaf8718db6ab0fc7f8d1e2cfd9ef45928488fc3d578477cdfdcc51dd09", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001f7": "01f7", - "0x00000000000000000000000000000000000000000000000000000000000001f8": "01f8", - "0x00000000000000000000000000000000000000000000000000000000000001f9": "01f9" - }, - "address": "0xe153e75b139632f5d13f19d5c66579d5d6813259", - "key": "0x59aef4df4fe449a1f7048fe2bcb680f4591eae75f45efe3dfca5febfe54d38d8" - }, - "0xE3A71B4CAf54dF7d2480743C5A6770A1a5a9BcDa": { - "balance": "0", - "nonce": 1, - "root": "0xd9302d64a423861c7b3ffa4e25dd32c407f472bda0e75c4da719b77a4c9d7424", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x000000000000000000000000000000000000000000000000000000000000011b": "011b", - "0x000000000000000000000000000000000000000000000000000000000000011c": "011c", - "0x000000000000000000000000000000000000000000000000000000000000011d": "011d" - }, - "address": "0xe3a71b4caf54df7d2480743c5a6770a1a5a9bcda", - "key": "0xe4d9c31cc9b4a9050bbbf77cc08ac26d134253dcb6fd994275c5c3468f5b7810" - }, - "0xE43cE33cdB88A2EFE8A3d652bfB252fd91A950a7": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x037e70d89f4b730aac959986dbbfe0af1a286ddb31e1de05bcee64135e5c17cb", - "code": "0xeef53c6ca945792f947138460881b8ce441c90705cebd2ac63082b1a9dbb6d1ef15659e3492137bbe7b2a548a5ff636574ffc69b4cd7e9919fa8f0121846b7587f8a4e01196c8d8e8d7fab5763f17afdd953e7fd375125594fe15f4147baa966b31f12b3ea8a692474f7a878f34a0093e7342405a33cd6974e35402ae55fdcccdf0fed250aa631da36a99e614c87fd768ef2946f5a4a62890303785aab8ccc70c9aadf72d8055a8681a6e3890308b25746e822fb40031daa81d0d225a722d0fbb0a0135deb29f445269723c8cde0b5434bcd83acff45693494d6a48dfe22d505d01e0763a645edda4d609886f87b822dc86d428442ef174eb0085b4a201be63d", - "address": "0xe43ce33cdb88a2efe8a3d652bfb252fd91a950a7", - "key": "0xc157e0d637d64b90e2c59bc8bed2acd75696ea1ac6b633661c12ce8f2bce0d62" - }, - "0xE52C0F008957444c48Eba77467eaf2b7C127e3C5": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1973f7c92cddb2e8e1b1a679e0ccc4228c832fa0881e126e99d8c153768fe417", - "code": "0x23aec33011cec136936404546e8d71610b1ea813717b1b6bf3b77b689326a34bff8631e720139e221f6f7436289600a293ec800074eefb6074c9c4d3d71451d44f3b95b4e5f87ebaefd8697e1beeac39c49315154dac40afc4471c173e106006158cf96e390593ec3d9db70f55562909ef65f4603e50b9bf4a3df75ee2795f3069934b3c578097dd99f0cb0d2c04136fd8095c48557144cc40a978589e45b612072a01774dff6b43d7101e6ad7d329fe9af3407ec1356a898458310d3114a95c20874b0c906c478f1952ec7ffbf9ccb55019a08fb7b7fe98adcb0bbcfe4c582b3173396d1c155446a89455c4997640738bf81f11b8e7aa00d59a627e170c021f", - "address": "0xe52c0f008957444c48eba77467eaf2b7c127e3c5", - "key": "0xb888c9946a84be90a9e77539b5ac68a3c459761950a460f3e671b708bb39c41f" + "address": "0xe4f62e66dfced3f18080ed3080b276edaef0e1c6", + "key": "0x4dee48db6b3b08cbac1e06a9a3ad1d0100541ec9eafa2a1fc82e5d47ab763aa4" }, "0xE7d13f7Aa2A838D24c59b40186a0aCa1e21CffCC": { - "balance": "1000000000000000000000000300000000004", + "balance": "1000000000000000000000000300000000005", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", "key": "0xec3e92967d10ac66eff64a5697258b8acf87e661962b2938a0edcd78788f360d" }, - "0xED61c537F1B4f454c46B2352069Fa6b42623C110": { + "0xE8ab29bE268a4a4447e4f7bF0B5DA4AA4734AC1A": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xed61c537f1b4f454c46b2352069fa6b42623c110", - "key": "0xfbf3a1231e6625c304d124d07affe93eb8815d22b5fd75d546c09dc1cfda9e67" - }, - "0xF9062429a0c38F2886bbc72EC59Eb41041caE478": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xf9062429a0c38f2886bbc72ec59eb41041cae478", - "key": "0x3de2ace05e9ea0f0318554327d9809e6706eadd51f104b1235f40712070503e5" - }, - "0xFb7b49bc3178263F3a205349c0E8060F44584500": { - "balance": "0", - "nonce": 1, - "root": "0x5b8cce34b1c8ca497abd9d4baa011f924fabb467a2d6617c9cfd83a2c32a1aee", + "root": "0x9a976e308ba6adecbca552a318a503b3ad99fbe0ba03c079bfb6244d3cd0e86e", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000189": "0189", - "0x000000000000000000000000000000000000000000000000000000000000018a": "018a", - "0x000000000000000000000000000000000000000000000000000000000000018b": "018b" + "0x000000000000000000000000000000000000000000000000000000000000022f": "022f", + "0x0000000000000000000000000000000000000000000000000000000000000230": "0230", + "0x0000000000000000000000000000000000000000000000000000000000000231": "0231" }, - "address": "0xfb7b49bc3178263f3a205349c0e8060f44584500", - "key": "0xa03fe040e4264070290e95ffe06bf9da0006556091f17c5df5abaa041de0c2f7" + "address": "0xe8ab29be268a4a4447e4f7bf0b5da4aa4734ac1a", + "key": "0x2f3f84580f03d8a347fdaafc9b6f755f314030839efe0886fc804c610cb37933" }, - "0xa6515a495Ec7723416665EBb54fC002BF1e9A873": { + "0xE98D9997c3d04ed1538a05615C00A93cdbBD3b53": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x4a027c1ef8411fa885c9fe4e5a504ec57076b475c72c4b0d150b8d97906de706", - "code": "0x91d04e206f89145185d7c0a82618aa78fe710bc8a1b4b414b377926cf5e3a66be28502ad67d33d7274b03e765dd18f1a1ab4ba1c827c6d3e7a0d3ca492e6b46315531e88bae16d971c335931052549d408d7d05a38b4dacc091f6db9dbbb6ddc38d21990164d4d7df1f1c3adadd435da81121ed3ccf04d07098021ef81b4663045d505cb6581b7f15e33d93b5bbad62cb60fb8a720b633d8cb1906954b0943f218fe2baba04b04b843cd138489dc125d2854aec75ebb8a449c914ba035cd57fe923334cd90d34656991c6938c9e0b8aa7a8fca68f889521f05af1a847e16ec0dd52427a773bf62425ab36cd77fb888038dcf97aeef30aa680c9fcd289221ae32", - "address": "0xa6515a495ec7723416665ebb54fc002bf1e9a873", - "key": "0xbbdc59572cc62c338fb6e027ab00c57cdeed233c8732680a56a5747141d20c7c" + "codeHash": "0x2d5da89dbc1dd4a72b762b0f02be2b019621e4eff4ae05cde7765f59fa027625", + "code": "0x59177b3ac362dfed2f5f2a6bdf40ad57c106ed436858a6006d6ca83c5f346676a29a965f7460be4b61c6850bfc18ee18bf45c79a5c6dbb1c0c895fc557ef5cb4cb1732e48e4275b8843ef6d2c0a17588ad394b156ef59f4f2f771abe2307b3f752b9e2a36c35aa2b44ce6c4b89f2a7aaf2f3fa2a112b48803d5b977a94749881440ceb88230bf2fc4edf65d2bb9a74d227c8a62abedec268e550d793dd5334e8ccd6890ea7087c2546c4c3d5264f04f94346973886db02cfa8794a31b759885d34861d98f8dcef653538193bb0f515950c5a7c054bd7a960894da70594bb33c5e71ff1efb43d93f85854e953bee84c0621efb6a50c7756c8f9231166a4df67f7", + "address": "0xe98d9997c3d04ed1538a05615c00a93cdbbd3b53", + "key": "0xd806336c4f3fbb4aac21b0058a7a4fbe4470832dd35ea3d5ee8a52a3fa870fe0" }, - "0xa956ca63bf28E7dA621475D6b077dA1AB9812b3A": { + "0xE9B17e54DBa3344a23160Cb2b64F88024648c53E": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xa956ca63bf28e7da621475d6b077da1ab9812b3a", - "key": "0xaad7b91d085a94c11a2f7e77dc95cfcfc5daf4f509ca4e0c0e493b86c6cbff78" - }, - "0xaD9Dad8a45e691B45a09e2CE5a88594A08f4744A": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xad9dad8a45e691b45a09e2ce5a88594a08f4744a", - "key": "0x90c9be68ba7502086f74ff43be0a2f2dff9baa9073fbccf73690addc0d93ee20" - }, - "0xaF17b30f5Ab8e6a4D7A563bDB0194F3E0bD50209": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xaf17b30f5ab8e6a4d7a563bdb0194f3e0bd50209", - "key": "0x26ce7d83dfb0ab0e7f15c42aeb9e8c0c5dba538b07c8e64b35fb64a37267dd96" - }, - "0xaa53Ff4bb2334Faf9f4447197ef69c39c0BB1379": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xaa53ff4bb2334faf9f4447197ef69c39c0bb1379", - "key": "0xed263a22f0e8be37bcc1873e589c54fe37fdde92902dc75d656997a7158a9d8c" - }, - "0xaaAF6A159065e1df8848bAD2123ce201f914651f": { - "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" - }, - "0xb5435eFdaf27d2d95A4074d8a202Fe8605e93bc6": { - "balance": "0", - "nonce": 1, - "root": "0x50c6f81d76e16573b6164ad984d3383e480986fb380b3b49aeb5ded831297fe2", + "root": "0xb1d2896c079496c392d81871dc5e4a7e8a1c80c3e19d90b9ce2a74982e45ee5c", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000060": "60", - "0x0000000000000000000000000000000000000000000000000000000000000061": "61", - "0x0000000000000000000000000000000000000000000000000000000000000062": "62" + "0x0000000000000000000000000000000000000000000000000000000000000174": "0174", + "0x0000000000000000000000000000000000000000000000000000000000000175": "0175", + "0x0000000000000000000000000000000000000000000000000000000000000176": "0176" }, - "address": "0xb5435efdaf27d2d95a4074d8a202fe8605e93bc6", - "key": "0x7d3eeccfd59fb913b7c1da576a38811506589cb0c082898306ac97727104a41d" + "address": "0xe9b17e54dba3344a23160cb2b64f88024648c53e", + "key": "0xb4f179efc346197df9c3a1cb3e95ea743ddde97c27b31ad472d352dba09ee1f5" }, - "0xb609BC528052Bd9669595a35f6eB6A4d7A30AC3D": { + "0xF0A279D2276DE583Ebcd7F69a6532f13349Ad656": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1df52e345118c81b3e417faae2407169b7143b97665088704492ebe68918af5b", - "code": "0xb6c77d91e1853c9460797543e6950962a973fa1ff748bd1983124d001970f0fe86752f6f10cf905e418968184a6649df48e5bb4b03fe0c6c30d4a92846800ae5120d6850bf2577eddbd2ee4d37824e28eb8583bd541f524a671400c5a7a4d0d343101321f77bc643f5acb4f9e125b12553e936073cee8dc5591c518fbdd9b31bfd12ab6661c66aa507572bb762941842d549de49dae1e273c6eff4353793382663751fa9514f6f7fc44151fc96fb391df328691d6b6a3752c0e99a8013ceca8537ce7393bde93f10df15acd9635be2b3c297dc27a2b26e7c8a093e1e7b56ff6c46d267957117ed5d4464f4be9f8d0298d446fb30aa03ae79a281755983f162ef", - "address": "0xb609bc528052bd9669595a35f6eb6a4d7a30ac3d", - "key": "0xe6388bfcbbd6000e90a10633c72c43b0b0fed7cf38eab785a71e6f0c5b80a26a" + "codeHash": "0xfc7ac100da7ec6df53d378321dc20b34177cca47f5ce7d6f640a7d377dba751b", + "code": "0xbed52935ceac91f9e56488c9c56a4ef4668325f0a4b3c9d4f59d0ca1f55873d4bbe9cd6f2ec3bfaf65e3dedea335e6580be1b90f02a28ba4334c14331d83537d461fa69d479e93c39ece03263cf3188143876d720ddc370708f917dd5a84899be033ac067c55ffa15276c1e7e852433fbe5b06aff21c9e12052d01007cfb4f63bbdfb9fbd5a250e303de7582d54b86c5073c3b3f8b2a52103e1be92f6afa665fda42636e2a248443cf028fedd444727b22ed1346bb793d0c53ce70ab162113cab28fc5200528140e039cbf5bb18ca2a92163357f6f90819a1a81c4fb0b7930fdda11920abf8ace283badaa3b53848cae08e30f173a07c3429625c5529361fb05", + "address": "0xf0a279d2276de583ebcd7f69a6532f13349ad656", + "key": "0x11eb0304c1baa92e67239f6947cb93e485a7db05e2b477e1167a8960458fa8cc" }, - "0xb911ABEEaD298d03C21c6C5fF397Cd80EB375D73": { + "0xF2C93BECbB050bA17dc9a2811A4d0DB97d0B1295": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xb911abeead298d03c21c6c5ff397cd80eb375d73", - "key": "0x873429def7829ff8227e4ef554591291907892fc8f3a1a0667dada3dc2a3eb84" - }, - "0xbA015A43CbAD870109287840657E509A8341430a": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x1d14dc1aad6545eccef12200b1d83eeccb7348e9efd37e3746547dc73319afcf", - "code": "0x6e114c97b74d78d3fc0453a7d40bb97c3b4da8bb89f0980f5e4234e1f334ec84d4fbf7701c97d78140335cb7a734885ddc620514a15e05dbfac5539c2e57005b4b399fdd2bd107baa82b219995c39b6fc0ea647f084bf576820030b40ec5eb1cc5a384a96c46160234a4c0a6841ffd094db428a8c4daf7fd60b8b3a2ec664beb2e4a5db9f6476a273a6466f6797062bb465d865a212e1a73b871f554b9505f849b837c8b3dd4ff54aa4bc7a8e72175cdf3090b5f77b8bbf2a981c389876ba34efc97c68684fd6376bbc41389aefdca942921a4974c57e664af0fefd08944deed5a7db4128d556fcc54111e0c2d693821e2cc01fc3dcce8e3a8e72c6393e2e68c", - "address": "0xba015a43cbad870109287840657e509a8341430a", - "key": "0xe49c3e4a107c2ab2bb5eb9f7830765501c0d2ba62d3bbdd3893ad2c6c7988e1a" - }, - "0xbA28562EAec75C2a24AddcdcB48b652a1D3d796a": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xba28562eaec75c2a24addcdcb48b652a1d3d796a", - "key": "0xf4f027863d66e0e04cac2d1b0bab3ce723d96b75cba02adfd94ec1aaac5f2e4f" - }, - "0xbE2b071590A1AEdbAe740BdA19589961eA8b90cb": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xbe2b071590a1aedbae740bda19589961ea8b90cb", - "key": "0x913a945d006f413415a63ff0e57fd2fad9ffbfe8857259722a0151b119f95e8e" - }, - "0xc672A4A5736BF99939A58C779E8574426ec2cb51": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x75de76446047b5ca099fe7a60a63ca86f78a280755e4b047d9e0f6ab5a3c8768", - "code": "0x03a2399dbeda27cb7b00f2bfdc46f625dc0d6ae1d1ae296eec64981420d7379f0f3712e63236af36733b72c796625945c9773de445465c4fc67079d0b2e58274ef975306a7f41285be2b1dbd58511cc28e1ba38da8aa9340702e3ef450eb792d74a58ce557b85901a0b85724f38fce3ea8b9f9a3989c57d19c477401a276956ceab7b9199383d8854ef3a3f8fee3f1e19d8bfc85e865c3273d04fc662b1ce3bdc3aa7b16422e3d10217b011900f49bacef88cb7c2a404a290e330e33c4bcfaeea29fc3afaacd35a28d15a491bc01bca5199d6323fa7cbb82b966837ee0fcb0c3a879e17a65faef645fad8f5e188dd2ff408303922ad6e8d1183345917dabbe25", - "address": "0xc672a4a5736bf99939a58c779e8574426ec2cb51", - "key": "0xb7ff380fe56a4b74a8253a904b912204c0421a68d57b0c2251eac54ee7d1edf3" - }, - "0xcCF0b963A645abe7b67Aa6E95AEA73FF9E0576CC": { - "balance": "0", - "nonce": 1, - "root": "0x54d96c4ece0ea7b8fb4020944003566809100c43a61883d7edaf155e10e9c7cc", + "root": "0x2fd7b839f5613c91ae241ba33e03e781c11b821250bae1aa3017b2fe75bac3fa", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000203": "0203", + "0x0000000000000000000000000000000000000000000000000000000000000204": "0204", + "0x0000000000000000000000000000000000000000000000000000000000000205": "0205" + }, + "address": "0xf2c93becbb050ba17dc9a2811a4d0db97d0b1295", + "key": "0xe3c90ccc988cd8abee77974903c16cf47988812f0f862dac3a11f06ae963d388" + }, + "0xF687d9CA2aCAA4DEe5f4BA6C1eF0c0B89205B92E": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xe5e61fa1465f3b1eb6e74632116b3766e24c61087fef3dc7af43dbe4fb3189b0", + "code": "0x4115ab6dee63da78950ac0a3ed6bebb017d9a5fc2e00608c82a3571125cfc38f12ee62be373328a28b316ed050591a9eac96ceb924246f86a1c0bc4f37d75b72a6bae38b5fd06c5ea81391e321be657722acd828b3352148b27a1ee3ea751aff6afc6c4beef433610998248245abb3600b2c2559a49a1cc2f3bf575b0d7b342613010f2857e6ee9389ef1e3b0d0d0b88a9cfb6ae9c58a9247e15c7e9334961e1888ab0db3616b32b3d0f09c88e675f52fafb0e7bbc38c0163460269ae83e6703d5e2e4e2abf6a871a9749909d2e6d5bb201405296004cedafbe5629981c69e1bfdc92b9060d7f6c40c01ce432c46d932dfb344659169a47bb9778e9ac38134ea", + "address": "0xf687d9ca2acaa4dee5f4ba6c1ef0c0b89205b92e", + "key": "0xddfb897c68a043e82b8d4d7751e6dd639066efea80cd177409faa10ae576676e" + }, + "0xF75b18c1a92C6C6659b3211D45Ee8E1BEFBD3a6C": { + "balance": "0", + "nonce": 1, + "root": "0x818eaf5adb56c6728889ba66b6980cd66b41199f0007cdd905ae739405e3c630", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000077": "77", + "0x0000000000000000000000000000000000000000000000000000000000000078": "78", + "0x0000000000000000000000000000000000000000000000000000000000000079": "79" + }, + "address": "0xf75b18c1a92c6c6659b3211d45ee8e1befbd3a6c", + "key": "0x6da4870a3dd2d5ee0dd0f235e6c07caaeea1e6fecf182b68a908462d1dae3edf" + }, + "0xF89374e8646084BE4525B8Da2E64aF316b570458": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xdc443b3e953eaa80fc5b5ae5ed28a3771bb30b13eed51dcc72ca2b3ee6f12441", + "code": "0x1cb7ce0668e72b96f704af9e1445a9dc6f6ac599eec355bfcfe4d3befbb001be40165e7164257b249280bf839a50283d248062ed7b0e6d8820cb6c506bfcf7d3c0c7c7c9a2a6655862feea3cc7ff13629582293fcfe0e1094efb20897bb02a656a2b6bffaca788160f671fa62d34758b717f75a90ad5a468757c50d61f33c4437f6fa3f34639ea1891363ca773619dbd5f652d7ab50411111dde2f57e3ae13add1ccbf1f9f869f51cd81e6f099f905636b057f682c706fe990614b1120516928ee4750d043edce57577a49a1f0c4b389e3b8c38c27dc693bc6b7154c07280771f2e2385bc2a5be32198cd1e425186910eb1a233b2b2a22be149cee4dc72d0162", + "address": "0xf89374e8646084be4525b8da2e64af316b570458", + "key": "0x8a501498b71c00ef30dfb420ca71d286546a057bb13d56eb0e175c0e42c2f3a6" + }, + "0xa12B147dD542518f44f821a4d436066C64932b0d": { + "balance": "0", + "nonce": 1, + "root": "0x0fd8e99b1b4ab4eb8c6c2218221ae6978cc67433341ed8a1ad6185d34fa82c61", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000014": "14", + "0x0000000000000000000000000000000000000000000000000000000000000015": "15", + "0x0000000000000000000000000000000000000000000000000000000000000016": "16" + }, + "address": "0xa12b147dd542518f44f821a4d436066c64932b0d", + "key": "0xae88076d02b19c4d09cb13fca14303687417b632444f3e30fc4880c225867be3" + }, + "0xa474Ce23d592a232C3869513A64834b2e723Ccf9": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xf0477d2d7456a060329028971c32a1049d112839ad6b9a8e0d41444144926912", + "code": "0x994debe1129ece54bc3e58d0080c657e4b57b49bd13c22d7c016ed5f3a59f29b4a8f2534811696fb7ed42c0b67bc755be8c4b58555c78db94a4c7b3764768107e7be31a9c65c0ddf13f554a0804c3b81ee1c5361cd94c5b1b0d3d4b42f09361c9a5f52b0aa8b858876d6b4ca6afd4df27bc0b2c0203007b759c631d3cfff3fc13fd38f8530aa5fa5e7a7e3bbcbf778be060fcd7938f51ba61c29cfa2d7317a0ae7931a793ebad246669683fe0c2c3600ca9cee55528b0b323e7c261585a013906a6a5810011038c63a76db6bb2409835d8bbd31c9732bb760cbdfa75d621b09a5534f9be7d15052a6dc35949bed0cb4fd90ba01e43563e9b5123d82176259e2d", + "address": "0xa474ce23d592a232c3869513a64834b2e723ccf9", + "key": "0x83bdc30d3ea7e078f2d487a9110f41e0f3fe3a9f7eaf48b9b2284b23993b0d70" + }, + "0xae3b97067d3F027E8011DfCF496dcD1079dd12d5": { + "balance": "0", + "nonce": 1, + "root": "0x9ed156eb2e3d2c3ecdc5fc9e4f54a5ba305d7d1e475ebd55d1f0bf64cffe5c15", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000023a": "023a", + "0x000000000000000000000000000000000000000000000000000000000000023b": "023b", + "0x000000000000000000000000000000000000000000000000000000000000023c": "023c" + }, + "address": "0xae3b97067d3f027e8011dfcf496dcd1079dd12d5", + "key": "0xa5bc78ba16936293e296c3d3e919d76eb953b28dc00c9852ca4987ba0c82c761" + }, + "0xb787c848479278cfdB56950Cda545Cd45881722D": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x58571002dc11e8a8698ab7f378670c332e6832b49dd44a7de317c87969aaca99", + "code": "0xa46c9a5e42ee711d67cec634bfb278f07133f8b3c236b826c53d763ec9766625f1c66cd5ac352bee1084e866f7ef3ef0a14c943b098d4776ee3af92a090e1db21f3740a279cf2d77f66bcbcd8ca9363a902fba240cc78bdb7fdc53f368015d5a533822937425fd8b485f29fe6819cabe96466337e03c8bcb1508e67c7a9c0675040df0cfdbe2439420993d589140042c9218e6e20c99578d1a137f827725261d5e9d47962747e01107e18234d09097958f3f7626c12966c952111c0776febce91bc34baf0bdc39cb35028662cf837c92de8adfcc490dc213b82c0a99a2de03013191183bb78cf07513f1832ebb64acd65d49101ab3bce7606c66025fac20ea90", + "address": "0xb787c848479278cfdb56950cda545cd45881722d", + "key": "0x1098f06082dc467088ecedb143f9464ebb02f19dc10bd7491b03ba68d751ce45" + }, + "0xb917B7f3D49770D3d2F0aD2F497E5bfe0f25Dc5F": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xb917b7f3d49770d3d2f0ad2f497e5bfe0f25dc5f", + "key": "0x65e6b6521e4f1f97e80710581f42063392c9b33e0aeea4081a102a32238992ea" + }, + "0xb9B85616Fc8ED95979a5e31b8968847e7518B165": { + "balance": "0", + "nonce": 1, + "root": "0x89bde89df7f2d83344a503944bb347b847f208df837228bb2cdfd6c3228ca3df", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x000000000000000000000000000000000000000000000000000000000000011c": "011c", + "0x000000000000000000000000000000000000000000000000000000000000011d": "011d", + "0x000000000000000000000000000000000000000000000000000000000000011e": "011e" + }, + "address": "0xb9b85616fc8ed95979a5e31b8968847e7518b165", + "key": "0x6a5e43139d88da6cfba857e458ae0b5359c3fde36e362b6e5f782a90ce351f14" + }, + "0xbce2408DA01DC215E427B012d1a68546F5ffcDFB": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xbce2408da01dc215e427b012d1a68546f5ffcdfb", + "key": "0x4db0b9725504eefe9b12857cf35dca9d90d6d07bb09bdc03b7ec1974de752403" + }, + "0xc147eCDF75298b9970440371EC57161bc3B8309E": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x882d5843dd5d7da734663209498b3277b9f3847fc5cae00f2f18f8265805c347", + "code": "0xae64a54e96e21d5e6e871f7870e8711620e9d630d04b7524844b2de5b466d08aa739a51387ece9d9b8e11b8bf7e5909dc8f9657225a2c6da44cad2fed408c2dd2b68a083e1b3a60cb87c92e2ce191ad4d75579ade9934fe0d4304f1604243b84b01818f3e9f0631d183410281d3672cfa0e4d82ad4d20b2f4def7db9466081919cbbcd6da79a96e2c00832bdfed8cb53fa1ef801d1db5928e9d3c2c3cbd15933362c6fb4abf103d18f0c520f9fe75352cd942e2ab332d796e53c82787d53ca68a701929b14ac2d3f52993bf388c7bd2787e5382631ced5ceb068ae34d2902a7cee0b9e9b585169fdbe97147eee724f92c9ea9274b51e7026b85feb6d32aa4a96", + "address": "0xc147ecdf75298b9970440371ec57161bc3b8309e", + "key": "0x5bf8b42134cc2ee0654bfb8cd3f7fb4c1bf368ca51f2cd923af8eb1d7c41598e" + }, + "0xc36e899Bc3c312869B146c3B2B28a0814FfAbad8": { + "balance": "0", + "nonce": 1, + "root": "0xc784c4978b7142c2f59d78be0ea1f14a39ffec9c512f9bbe75703ef7590970cc", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001e1": "01e1", "0x00000000000000000000000000000000000000000000000000000000000001e2": "01e2", - "0x00000000000000000000000000000000000000000000000000000000000001e3": "01e3" + "0x00000000000000000000000000000000000000000000000000000000000001e3": "01e3", + "0x00000000000000000000000000000000000000000000000000000000000001e4": "01e4" }, - "address": "0xccf0b963a645abe7b67aa6e95aea73ff9e0576cc", - "key": "0x2c5f586f46056bc6b891f7ed71cbe787e6f4839646e44d67e5c0bd737ff7154b" + "address": "0xc36e899bc3c312869b146c3b2b28a0814ffabad8", + "key": "0x01e4f3a112f7034fdcb78c6ab534de5391d2c0c3772d641f69d1465e7a0bfa1f" }, - "0xd48171b7166F5E467AbCbA12698dF579328e637D": { + "0xc48c3d6FA1afa2c203EBCe7d58f46CEE0c74AE2A": { "balance": "0", "nonce": 1, - "root": "0x944f095afbd1383e5d0f91ef02895d398f4f76fdb6d86adf4765f25bdc304f5f", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000081": "81", - "0x0000000000000000000000000000000000000000000000000000000000000082": "82", - "0x0000000000000000000000000000000000000000000000000000000000000083": "83" - }, - "address": "0xd48171b7166f5e467abcba12698df579328e637d", - "key": "0x188111c233bf6516bb9da8b5c4c31809a42e8604cd0158d933435cfd8e06e413" + "address": "0xc48c3d6fa1afa2c203ebce7d58f46cee0c74ae2a", + "key": "0xadc8fbbe07e1a1609c3b54342d036f018af4d93ae59dd4425f6244f5949cedc2" }, - "0xd778467Da3D250d74009a0b24A77ec73fE459164": { + "0xc7a0a19EA8Fc63cC6021Af2E11AC0584D75C97B7": { "balance": "0", "nonce": 1, - "root": "0xf120c3cc3618eef211a028a99d9f010cc498a79097042dff780391ec3563ad51", + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xc7a0a19ea8fc63cc6021af2e11ac0584d75c97b7", + "key": "0x86d03d0f6bed220d046a4712ec4f451583b276df1aed33f96495d22569dc3485" + }, + "0xc9823569b2E62F92B406e70522aDEEe24E23a827": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x84605622999eb7f957084085b52f1c7b7409059ca2e8b3560e3d02be973114d3", + "code": "0x538474d0f64483776ed44915f71ae7f0bb8a622d35cec6d7f58631c690c1e43e334c7786e3bf81676e3a0d3736526c15df34c509bc9c3d422872d2fcec03bb4c0ee5eb80d8d139aa8aaeff0e93c5d082f8a95ab74e45ba383f83aa303ed7b715851c0a6dcea6d9c0b20e1d693e72bc7e402b6eed6a9bc52d715e1495b07edd2e4ecaefe56730f3d4c9899e811fe6b6866094124a9e94dd77caa81d8bd4d8c1ad53e6bfe60438140020269ed9fe5e9e4479f1629f851a14a4608433a904faf5c8171873f192ebc553c77ac3d91f610d9b3b5d968c33b2894a4af1d74d93346ae36c531230b5ec6213920791b4b9121f927f751c23cec4b3ac966fd3d1d6d970fb", + "address": "0xc9823569b2e62f92b406e70522adeee24e23a827", + "key": "0x683b6c03cc32afe5db8cb96050f711fdaff8f8ff44c7587a9a848f921d02815e" + }, + "0xcC29d71a7dE378E9Cc11541B48a5F4E79157673A": { + "balance": "0", + "nonce": 1, + "root": "0xf82bf2c4bf4eabb1dc579d5ba1f80bceb690e6d41bec710f78acffe87543f186", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001d6": "01d6", - "0x00000000000000000000000000000000000000000000000000000000000001d7": "01d7", - "0x00000000000000000000000000000000000000000000000000000000000001d8": "01d8" + "0x00000000000000000000000000000000000000000000000000000000000001a0": "01a0", + "0x00000000000000000000000000000000000000000000000000000000000001a1": "01a1", + "0x00000000000000000000000000000000000000000000000000000000000001a2": "01a2" }, - "address": "0xd778467da3d250d74009a0b24a77ec73fe459164", - "key": "0x6862961bf74f98147405d296a8f9d9147a02013a4bebb049a171715de1a58963" + "address": "0xcc29d71a7de378e9cc11541b48a5f4e79157673a", + "key": "0xb545359603802ec567ddb83b02a16e420860ab3daea52f2530a94b02d9129bba" + }, + "0xcF26B3672851128B3d41e65C7c8563CA54837Ae1": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0x8d694036b187e12b604aeaafd52aa967e7f7d184df20fcb1c8c234eea6631a69", + "code": "0xa3782a2fe6ea312a811ac4c42fe7783faf92d4cb89cfcb3782e3fa260888489023903e96f7ccc3c321ee90eaffc37f489d842d55a6c8ffa1ddb161af2d3fb72fda50f95f737dd96a2ff448425767f58b49e6bc691060be2dd7aee3b8374d3aa362d3caefc27072d8a29831635245f4b528ba9b3356b77b4a38e93725f0197aa02fb2ea1f5bff21afae24d3f3e60076cb2c3b5b5ab20a71202cf9d49fa1606d4a701b5d687eb62af0eb18eb02d71426f2205884f5e7acc1bcd7b47c1b498ea8c95ec353220bc9ea0f081d44c7fbe1f97d75f2b74a0c416d06ce7cc6ebc553754a26382593f450ee34359d1d633b07dd27a5a9c2d9d495db1f1762692243a2641d", + "address": "0xcf26b3672851128b3d41e65c7c8563ca54837ae1", + "key": "0xdaceea0041b683170f8d205a0ccd2c5e01ebe604b5731f89bb6c8b8a0f9ea776" + }, + "0xd15ec528baFC44EbbA397415Ca5340a5C2B4f417": { + "balance": "0", + "nonce": 1, + "root": "0xef3164f6238d01061c0559193be70618658b742eec056b27996308eef51b95a6", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000001ed": "01ed", + "0x00000000000000000000000000000000000000000000000000000000000001ee": "01ee", + "0x00000000000000000000000000000000000000000000000000000000000001ef": "01ef" + }, + "address": "0xd15ec528bafc44ebba397415ca5340a5c2b4f417", + "key": "0xcde608490277d1ddfe34418396fab0c8a7bd0bf5a1bbe962ae0f5f13453c6213" + }, + "0xd24EF00a6c137ecA8067377de36F76836B8c7EeE": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xd24ef00a6c137eca8067377de36f76836b8c7eee", + "key": "0xa3b7b9153d8f3262ef97bbfceab8bf6e2ee4e2a8d35a6042f6a5cee83415c53a" }, "0xd803681E487E6AC18053aFc5a6cD813c86Ec3E4D": { - "balance": "1000000000000000000000000500000000007", + "balance": "1000000000000000000000000200000000009", "nonce": 0, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", "key": "0xe5302e42ca6111d3515cbbb2225265077da41d997f069a6c492fa3fcb0fdf284" }, - "0xd9c035E32F69DaB32F382F4ECA08ac316CB4fa4d": { + "0xdA3802907F850f9b6672fc38512ae47A5778d8F9": { "balance": "0", "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x91490c55fe9d257ab92ee7c14d7614e4ce7bac6f9bb136427a3c67df010b8761", - "code": "0x941a419570a1ac7361c777110e70919980aa20af68c061451b272502d1c7bf877d3fa8f5cca21f050296be6b1a18825e0663c16cf7abb5263fd97a7042f1a7019aead984481533ddc3e1804cd415af4859e5a9209b3e78027e9504b13edc4bf9726c0239d8143fcc34d30ac6ef3f6e3a51e31b0bb7a03ff559c40434071fd48d080207eb7481f12bdcb87a64d5eef86a69742a6e85ca5bc6cbd6493c6f955c00563116b304f60034ae594a61486cd49541585ff56c84c5873e3fccb3f79c188f93526f8eb108615ff025803e1a91a242013880017345c667ca5624ba4a4111579881b6eeebb8651e1bf8e3463186d9b28eb3683206809622f3c6655c5386ebe1", - "address": "0xd9c035e32f69dab32f382f4eca08ac316cb4fa4d", - "key": "0x52ee830cbf07cbdfef612efc7475e16c6988d86442e32f31308d7c52d509a394" - }, - "0xdeD53dD3E21f2A1F750807aFeF8c31053485bb28": { - "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": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xd4b553aed9df4bb81dfec99c249dbb99fb7beaef39f870cded5fe5719a809f7a", - "code": "0x0dda8da39b09c5d12be3408433542bcb85e79c16e9fa698274be0a5f5c0de0fb9155f2118833bf042b9dc03ff0b395208526fb6aae0ce96bd5b48743c48f179e14f494c65b48b2269e6f5785daed2174329ff45233af29f1ab57a83ec298b66135158e6a4d60ba7fad6584323785917414cc012686456fc0f2439c277bd05cfc9c989adbdafe30987e6fdc03d7338cb0c4591d695fc239ac5a81ff2f8e808e27ae2e9d1466e10fd686cfb1a2f8b60d75f9fd753466b824829dac49112d9496996c44c6278aa5f1fb3b169e5ac7fc49bdcfc3e1806375d1855254212e157be3bf1325408048277dccf4ad3c883277c32a60bc62de3dc708503358ea4b20f98206", - "address": "0xe2ff4e7e4a28d327b030800bb65149d843d82d2d", - "key": "0x911077c76a4a16f33df9c81d27b2ca80256a7141e83339fc2f18948313012e2f" - }, - "0xe7B2CEB8674516c4aEb43979808b237656aB3B6B": { + "0xdC60D4434411B2608150f68c4c1b818B6208AcC2": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xe7b2ceb8674516c4aeb43979808b237656ab3b6b", - "key": "0x75d231f57a1a9751f58769d5691f4807ab31ac0e802b1a1f6bfc77f5dff0adbf" + "address": "0xdc60d4434411b2608150f68c4c1b818b6208acc2", + "key": "0x8510660ad5e3d35a30d4fb7c2615c040f9f698faae2ac48022e366deaeecbe77" }, - "0xe920AB4e34595482e98B2C0d16Be164c49190546": { + "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": "0xf91b587fa3d345550ae9b246a788e2f668bf8df9071d8b4e3f07594a52791925", - "code": "0xddf72b2f62b0846ca7da60f0df0f94cdb28e603ef5291f65615841a7468c44c0710244b60ba7c1bd35ceda568c1c62624e99f11696da5612c84c7901031a9ece682e02e2fdab880917c319130d538d88dd4ea8d4b55431d219c9fc1fda9de93cc441712b999ae1b5f312a9513edfd8374c171ed2e13f457312b48a6118e30c586c90643f346afd56f022a6ddf0199dca4d55558c4e0c6b438b89dc77236b62238e8fc62d2064391f7b9dfc498260918dda58b2fadba062c23c105952e10f766b5a9adcc69eddff3413d21062a8f00e1b55efcbb4b88e08038f348ea9bf741c6d8060c339d013a28259483a9bbf8245b3f2c21722b238902c8756e3fa46291ecb", - "address": "0xe920ab4e34595482e98b2c0d16be164c49190546", - "key": "0xd623b1845175b206c127c08046281c013e4a3316402a771f1b3b77a9831143f5" + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "address": "0xe57ef4a8da86f1ccd38ce12e3fabe819faa0a95b", + "key": "0xe69a86b4c8c8a9836fdd2617fbce1d746e4bd63be4f1a1d5cc5ba1f0f409e780" + }, + "0xe6dDdBFFDE545e58030d4B8ca9e00cFb68975B5D": { + "balance": "0", + "nonce": 1, + "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "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", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xf11da605c7ce2bb45fdd1117c7a7744f505efea4", - "key": "0x4490d5539df3636dbe295411ff92b662bb12ea3656f46fedbf5625af73882277" - }, - "0xf820E25fAA00515571CFFa390f2fa3E96B0b5c6a": { - "balance": "0", - "nonce": 1, - "root": "0xc7839c3366ccfac78f919d8471358021b5b7d493e6532c52efe048ff2da0af0c", + "root": "0x5a82aff126ffebff76002b1e4de03c40ba494b81cb3fbc528f23e4be35a9afe6", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x00000000000000000000000000000000000000000000000000000000000001c0": "01c0", - "0x00000000000000000000000000000000000000000000000000000000000001c1": "01c1", - "0x00000000000000000000000000000000000000000000000000000000000001c2": "01c2" + "0x000000000000000000000000000000000000000000000000000000000000004b": "4b", + "0x000000000000000000000000000000000000000000000000000000000000004c": "4c", + "0x000000000000000000000000000000000000000000000000000000000000004d": "4d" }, - "address": "0xf820e25faa00515571cffa390f2fa3e96b0b5c6a", - "key": "0x7e1eec4a63dcc09bf241883e29bb53e7c377c1c0891a1b0189bcd411b20c0738" + "address": "0xf41f36c9d43ad24ee6de564215c047b66db1d391", + "key": "0xfffae3923d4ffa22ca4150e83647a3f7a442233f4f4f6d742028c3f62016da7d" }, - "0xfAbE26BC448a25eC56FF9360b19B66d56BaDFf51": { + "0xf60c9dEeF62A32528b0b4652093b8B260a208827": { + "balance": "0", + "nonce": 1, + "root": "0xb7ba1d0a5343f51a519e9545efa1a5368a6d3c59a7e4463e3744c30ff35bea20", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000111": "0111", + "0x0000000000000000000000000000000000000000000000000000000000000112": "0112", + "0x0000000000000000000000000000000000000000000000000000000000000113": "0113" + }, + "address": "0xf60c9deef62a32528b0b4652093b8b260a208827", + "key": "0xd0fb2f31b364fd56c16154fe421ea6f768a5fb87c7f0e20b4d689b6816c4d8d7" + }, + "0xf61ac2A10B7981a12822e3E48671EbD969bCe9C2": { + "balance": "0", + "nonce": 1, + "root": "0x15590989a348b65eb16aa3f8d2584fb877e412a1385225f36c247b6399764c90", + "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", + "storage": { + "0x00000000000000000000000000000000000000000000000000000000000000da": "da", + "0x00000000000000000000000000000000000000000000000000000000000000db": "db", + "0x00000000000000000000000000000000000000000000000000000000000000dc": "dc" + }, + "address": "0xf61ac2a10b7981a12822e3e48671ebd969bce9c2", + "key": "0xbfe5dee42bddd2860a8ebbcdd09f9c52a588ba38659cf5e74b07d20f396e04d4" + }, + "0xf8C11c750ab2B0276A272F875857cf535aBa2Fd7": { "balance": "0", "nonce": 1, "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x605a56872757b687e70b0a8c3c3bab8566722172023e2c89b8be7ca0601ddf87", - "code": "0xc189f84ce68d330a8fdf55d40ed2705c7b14e02dd92ac2ee8966971c2fb56ec7ead8f6c0653ac108e89227cbe7425f3b89d61d55b92d8aa75cefaf308a8fbf7e8622f55c65610f385e1d95c8f07ca152f97aa824081a0afcd103f33f6b8ca72a33871796b7313fc5499b1f5322d50f5058acefe7776b255179bf9ae1e55602027173dcd6a2b7fe9242f4c2bd4b2c88cf749fb25984608228bc83697bfa7eb5b471185a1ea5a896559cd0665d0979f85c835265f180e74502f783bd7a192bf63fece6665d217127474d08619b555ba7cf850c9566e44f26045fd57ee3fafe0590e674d6359c3bd263fc88d21d87228700bd819a703993ffdb575906e5517cd01d", - "address": "0xfabe26bc448a25ec56ff9360b19b66d56badff51", - "key": "0x7b5d2a2cc2dee3a5ba257d9324d8772b209ed8ebc559c73dadd32af002df621e" + "codeHash": "0x909e99eac3d2f939aa3734152690a23ff48fe70e0bed64695466cd46b583c4e2", + "code": "0x5a2ec50db2ca06446b795168e7be7507522174c31903d424779360a3b6f0ff978162d6cc32dc75b44adf81a1e9dc0ac7f7be79fef38219137739c8af5157a313b64fbcd928f024c431e809fae07258ca41432c098236d3d43c3c8e52253217b6eca4505ea32ae1a4ee824c5255e38a00422c023b789b59b6ce92c6731bc698919de437229a9a5b71b813b2ca574feb648a19bad8f1978fc540dba421c3042f6c68eb1985abb1bca8cc77a9e3c4ceb1ed4b4c857374b7d6d3773b5c340a823c929ed76419063e05b6bd3c4b2b3da7ac5fb72330fe54743c0f00a9c1ac8afb46aed84e31a70eda71f01446d3305fdb4ca4341833b4481c4ad865d2e6179edbb744", + "address": "0xf8c11c750ab2b0276a272f875857cf535aba2fd7", + "key": "0x603aef023d668fbda50a2b26e37969e2ee93b68d0e6f8abbdf7b6f6183a9c09d" }, - "0xfCE0CADC18035c4a6FE8279165277788826591fB": { + "0xf935652dc257EF89c33B2488BB18E2d068Bd35f6": { "balance": "0", "nonce": 1, - "root": "0x14f9f4b9445c7547d5a4671a38b0b12bbc0e7198c3b2934b82b695c8630d4972", + "root": "0x6d9d3f86b1f8f8e94248f307137ef85b10a1d57a5ac60aaf227e8cbfa2224db0", "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "storage": { - "0x0000000000000000000000000000000000000000000000000000000000000126": "0126", "0x0000000000000000000000000000000000000000000000000000000000000127": "0127", - "0x0000000000000000000000000000000000000000000000000000000000000128": "0128" + "0x0000000000000000000000000000000000000000000000000000000000000128": "0128", + "0x0000000000000000000000000000000000000000000000000000000000000129": "0129" }, - "address": "0xfce0cadc18035c4a6fe8279165277788826591fb", - "key": "0x68bda3bd48de9803b2a21ffd518bc8aa99a56d7eb40cc8db1a6bf803b8693be5" - }, - "0xfcb2A3a61D3De12F554db60494f13e9477F31a2f": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0x302c2cdce1f556b5053afca77878c358d2492d7745f5cbbf9db5761df20db001", - "code": "0x50ba73278bbf571a271f39357d381d2f5f97b7d5b6a23b684b7751eddba38718b712f55a8405e8766b7610a3b707f0ea903b826c8623fa2624da135a56a422ebb8b9c4837d54a5d26c8f7e03d3b9cd37367cb9ba2a74a2e4e571a0b453433473fcbc0922eb3255790a824facc22abbf7bf018597c0700c13a6df4a019b75b3ae9ffad69f84083f437fc88821853a0555fc46dd72c6c7dcb209f949f252909fdcefff4d220e7779831f23f8b0cb0449a9525f4c42705a5e35acfb5cc1016cf81b8e7bd63088de20dd86bdf2b9ba56bd140f59161a5d05abb70bf55a82cda068e494152e7cadd4eba05f59e9c2118d2ed4e1d9e020bb8d2b37c15f90576f810742", - "address": "0xfcb2a3a61d3de12f554db60494f13e9477f31a2f", - "key": "0x678bb0d1fd0696bae4b7e06994861242bfbfe332bc030c15ab9d33c26eeab13c" - }, - "0xfdB19A177ED1B386d141e392B7A27467469fAbB2": { - "balance": "0", - "nonce": 1, - "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", - "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", - "address": "0xfdb19a177ed1b386d141e392b7a27467469fabb2", - "key": "0x7cf2a82cb777b7aa435dcddab99299165f8e46c83c1f9bd50206e428074143be" + "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 0e18cd8525..b5327ae816 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", + "baseFeePerGas": "0xdbad13f", + "blockHash": "0xc2edbf6987d529aeb53f0446650f0c76fd4aac53d87319bd3906700461531e28", "transactions": [ - "0x02f86d870c72dd9d5e883e0a01840dcb6246825208943ae75c08b4c907eb63a8960c45b86e1e9ab6123c0180c080a084acd22563552cb084358e49c7d881c7fd44d2bb47becbf7d45db91a89d256a0a0693e415095b70f8b616169aba614e663b0dcbad5b55b427407c8e11a70b4dc85" + "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", + "gasLimit": "0x11e1a300", + "gasUsed": "0x5208", "timestamp": "0x5c8", "extraData": "0x", "baseFeePerGas": "0x8", - "blockHash": "0xb3a80dd6748adaba8d2598da58441cc645b165d96de91b605122e82caff076d8", - "transactions": [], - "withdrawals": [ - { - "index": "0xc", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } + "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 254b59d346..4cbecc1bc7 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,441 +29,7 @@ "logtopic1": "0x3569f740e521d8bb11c5b72660dc96272ad66bfd811ed918c3a9e02acd4ade8f" }, { - "txhash": "0xd463f0b9ea6530b1d24d8b8b7021979d48dac8452ed957fb722263a5a1b5ed08", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xcb55d89f2ee070d017b426876d6072d91c2a7311ade9a1bed2f8200127ec380e" - }, - { - "txhash": "0xe131203a45328fe320b0820698177e8ad2f3b3ee8c552787ddb1db725a2c4484", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x73286395f2a86bb5537d9b45ca7c681044645f31475a11d49285d6a0f028b8f0" - }, - { - "txhash": "0x4cee3118350175e8ddab6edac9672440c672baea4c9eecd53e4dd411a978a990", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2a", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x35f96bc70aa62a539fa99d9153b0f8aaa4594abf70cc8a8d9018e04e39a17982" - }, - { - "txhash": "0x0cdaf3e63a21eacdaf83b844b5ee98f7ea540667d68f6c527af01a8724bd23b1", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x35", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xefcb86facadbec33b8779888975eacca8f44a9073a845521617f1fb30e1ac818" - }, - { - "txhash": "0xd2a4dda75edef4c514a21ca9167f310fe3d296497ab78e66a2861d07dbe38585", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x40", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x905cfe802dc4c667312ea08fdbe97798b88cfb11049ade2b18ad9001e8b6dd7c" - }, - { - "txhash": "0xfeb2fe04b5241685c79ee42b624b2144a8c6e2871e12d2da75d39b03a9b9a950", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4b", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x0d968817f6ab6815faa1501ac1eafc810f4bc9b7423abc4f1bd5e65e791b4e0b" - }, - { - "txhash": "0x3d08d1fdf8a7b74fe2af54dcff575b87ff4c0203810df3647ba2a02793710b5e", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x56", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xa0634d80c0a702c2b06dfe60ace0d8f788b99406f1d2ac44ad3a26faa3fc1464" - }, - { - "txhash": "0x8be5109fe8dddab4ee47ee4ea8e5c1973eeedcf13749be4e4fca93d9c0550a6e", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x61", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x50495437ee69f7b12c5d6eb55cdcd8f5ce12a2eac21a2a42a7549e9f5289b1fb" - }, - { - "txhash": "0x37d1d547768ea14ceef7274f5f24c8bfeabe795faf8626556a6688a4b72485a3", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x6c", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x59b1019e8b01471b1dd478e65c30667d2d1780ed0c8bf5fc784b1413789b2f82" - }, - { - "txhash": "0xf2fc33ca3b9e09c698e75ddef6db493d606edc4d36803966341cc0937be3dcb1", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x77", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x47cd31a1b89686fa610642222d2da6119e54ee8ca761bd01a649e3759e47746c" - }, - { - "txhash": "0xe6cd7289688ee233a5cc20add1ce439e3faee022bb954c80b84b4ce3c84690d4", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x82", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x562f817652b4478bc1e434240cd21e00774a5a1210833cbf0225273e2b98bae2" - }, - { - "txhash": "0xda6e57b6ed17f0591bb5313cc927800303bae5fcb20507a1eae0d5c24b4da809", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x8d", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb9f03edd278ccfc90e45785c1fea3f972618a32899f836dd4fe0e63eaf8c7c40" - }, - { - "txhash": "0x3e01b65976317255bd0ebd2ed6e506c7c44671e5786302052367a9d9c5fe1b70", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x98", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x72be914df22404e1ed45a8224b52201a77605d52065746a00af5f60980fa4c99" - }, - { - "txhash": "0xfc6bafe4ad86d5d2343cdcaa2d695050931b1d2a49a63e5be4deccd97b84bcaf", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa3", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xff5c526fc525d03cecce39f4ec167af09f80525e2d44e60ee4df33a357b24ed2" - }, - { - "txhash": "0x687bb7707e54385064c6b22425f9ad06fa0377ee68b8bab7ffe34f592c79b8d5", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xae", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x87fc0239418406958902bcd8e059f9ddc08fb2683a4be0cfd47b1eb97418be1e" - }, - { - "txhash": "0x20add83f7f234cace1af3d3bfc50e28ad885767711f4a143f397b09359999353", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb9", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x85c0042b81b23b846d1e4881b0131b4bbff774dd9bdece2e74fa92ebdb053c34" - }, - { - "txhash": "0x5133df1193a2f8e63c0eee29b4cf93edad7b35ec68e5bdd214d959096b330aa2", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc4", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x32984cfbb954e0815427570f4ceaef21a3691026950e5ad80401232f687620e7" - }, - { - "txhash": "0xa2c5369f2abed72c2a9826e79228b372e4b1a387e5832965af5d0d874df68576", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xcf", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd34d30c2584168001b907965762f784cb4337381aa8090ae36bc66bd515849b5" - }, - { - "txhash": "0x82abb81ce6873ac4e3dda7b2276c80923283f8a43671eed167b41720f6bdbb27", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xda", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3982f6a73961b17f67a84959ebc42a5a3ebdd1faa925399f3f276cc2de65f2fb" - }, - { - "txhash": "0x302d4582613dfd96d4c9e18bfecb1017f40a8d8313ef13356e1885575d21622f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe5", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x782a285a3a645a32202a71e713e4a813bbaef9f50ce10e4caa0122c110d86bf6" - }, - { - "txhash": "0xaab104ba3538ee8a11349279ac0ba9374cff8b325fbbadab6bac24828f297a49", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf0", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x44dc9099d91b074b843002013672df4de9f691cf60546fa74eccafa9044a75a2" - }, - { - "txhash": "0xc6c2d288432ce16555d12b522398b07beb749eb44f6162c4d71c90670b59df79", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xfb", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1bf804b21bbd284f3f59e4862747fabb1d91cd202d99df811fbcd650c8916ef1" - }, - { - "txhash": "0x205e93a639805b8104b073a1aac798821403d8deeac62a463f934df64907808f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x106", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x628887ea9304aeb7f3934543b9d14ab4e7e5cd422ba572d39d6ee10c33045345" - }, - { - "txhash": "0x64e12e4bcceab36795d18fa5758676bd96d4f6ae943c206bba9782dc96c3ef6b", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x111", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xee181b97fd68754f6245c655a0a0686e8d12aa4eac5f1d059e7e3b8d6a924073" - }, - { - "txhash": "0xfce43c4ea272fb22e6443782eee4d50c567c17e7e9def4573569778f0ac8558a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x11c", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xf0ca8a88096a033508993a424f4e40ee1d800f62390dfe4ed5dd74a0f6785e25" - }, - { - "txhash": "0x92457c1dd22ebbf0c6b477646b4efa376d5f5c4a55b8cc267e84304b61ca2449", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x127", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xd2dcfcdea157f70f8422558eb02bdc6a503cf24126f8f2dc2b52a644f5f02271" - }, - { - "txhash": "0x99a7fc49256d1f8092db5990270645ab9a4d96b49fb9224bafe6fddb7f6f86f0", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x132", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4d4855c520c09f3435e2cb46ceb4d2a12df59c127a1f2e871e7e9e8203fd6ce1" - }, - { - "txhash": "0xcf272615d5e4bf4555cf867154234f5df2e230442c1c87508c051e407e2811d7", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x13d", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x8a76d1e2fd58cc0018aa306e83990d74d16ba9aeab4794595fc72551f0465476" - }, - { - "txhash": "0x26501c0425d7865224b5b38b85ec90d07881f213813c81f85aa863c94109bd64", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x148", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7a63090121e41c76eee07564883abe3bd839fb20a0d2513bc9bc524f6c16f88a" - }, - { - "txhash": "0x49249dfc575b61369ae47f58f81cd66315038672a912cb900babfa535e52ed9f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x153", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc4f8d20ccba0b50d46d9c87f28cebf8c165fced694a2b34412a4b6153b987a17" - }, - { - "txhash": "0x0f88d2f5193f44c1595c53019d68fce6fe715e2f9aa8fa4edd751546cbc21475", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x15e", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x4b916e15bdb0f5b4bccaa3447694db53cc34095b5bc26299c14a9f573bd6c758" - }, - { - "txhash": "0xa164fc90c20e70842b76427eaca6ef266fa3ba71e933c5ce9df68d2e817f6197", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x169", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7975cc1088361453b019ff19e2177b264cfea56f4c09b1a8a086f6c405dd516c" - }, - { - "txhash": "0x25b5c50473f34a2940ccccf2080dbd466a264e936c2a38ee6b1410ee4d5798e5", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x174", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x5423899586eb1d932cb9da03e478e1dd5d4cbbcb66d24262c7d67e543185c2ef" - }, - { - "txhash": "0x14f08427a199620151f7cbe9d4d4a6a6b087e41e294e80ac23d7bb89e9100378", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x17f", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x187c8bbc8cd3f478b5688bc03cf5eda82ee75aa605e946b39ed1898f0cc0e00f" - }, - { - "txhash": "0x5b5626eb904ccbd5e3f96a12ae819a7997238d6950a6eead7e55171e9c8aab3f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18a", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x1bf8eef1506aea16c94dd534ab271dfdae26648de569b3bf6fc8bf4c76bd1a99" - }, - { - "txhash": "0xece63f7c604356e632fdd80e92222629c86f470612feabf2e7059fdb7d09a11d", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x195", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x434e2bcc5f4148668dd618144aac33ef5d463b292b3baad302a60aeb6be03b86" - }, - { - "txhash": "0x5b8bef43f888a81d06bb9757ebfbc240f379bcdfef6efbefd76c6974a2b844be", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a0", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7b95105ef96b105a85277c69993f6f56602d912fe712ddf6156cdfcd8c490607" - }, - { - "txhash": "0x1e0ee081c4d5b43e12ed4eb80f14a1519f6e47f1d2ed7d88eea2097b1f2fa0db", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ab", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x2ecc9be98f9a8adac6e6acc5f160b0d15439b3856f0dee2a3005db79076252a1" - }, - { - "txhash": "0x4a2c9d2193f39a13e47237e14bd645267a17d3f096fd7ee6646ec0f4b71ea82e", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1b6", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc452b6d808f45af81c3310dcf94a1704359eafc34709c45b0c7b95adf4cd02af" - }, - { - "txhash": "0x5d0a088f57e56aeaaff5958232ae8a0e4846cee85333b465d43c4462714558d0", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c1", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x7eae9da1da48fe866f64de7ac5c70c8e43644867b917aa8461f84915396d3598" - }, - { - "txhash": "0x169f28d6c3062de156f293def5ccad7deff2211443ffd2a44e3e1a711df25478", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1cc", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x492ae6c575840126917090c30d003aec0892cd6250f877b99f33b72133b94f23" - }, - { - "txhash": "0xa1deb6e1a31c1eefc0b4348baddcd41b9671fa0189eb32643fde34dfd21a1774", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d7", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc8bbb420578d2d80897ca392a55fce5e4834f1d641472c0fd6a9698b7a8e7866" - }, - { - "txhash": "0x383b1359ef9168e0c519618b865a0b2bd246f40574f854c56b3dfab642a4c5bd", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e2", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x3a970a6d07c991261dcb566f26d21a76c578d05d1565c47dbc1fc071934c8c43" - }, - { - "txhash": "0x17551b7e94b2b97a41b94ac50c71106bfa09ea50ea92512fb63057557c05a644", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ed", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x51524a498a88953303410a83d67c2b8c69ddafeb99b570accaaed774fbc8583e" - }, - { - "txhash": "0xd2d67b7bee59a1bc320887f03e4c39e9c771af365a2949b53621402857985a7a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f8", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x96c0d209b0a5b8b06947cc4c7ca723df55c5b972711b6c08ec7b9c393fa6e8ea" - }, - { - "txhash": "0xb826afbbbb480140ac552e49ffb3985f7d3dfe9f37dcb3271ec5c35d71c9c844", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x203", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x39410f5a8f450e0b7fe63aa93e214a7c5cbe78786c815ebc926f1e8a2a14f4bb" - }, - { - "txhash": "0x5be0a9f1701d01528926726a6a63fda07641d87172d1138b3a76c15af80cf396", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x20e", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x075a739ccce514f063220aa4bb66f08a7966189b0f24a2c5ad4692133d7aa6cb" - }, - { - "txhash": "0xdf443c6601c8656a7bffdfb38d9cc4ec15c324ed50e099546f2a548d1fd6bf6a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x219", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x9f5941a130f6c2ff98ec21bb2517998dc5c8512230dcb37ede3cb8a4694175ab" - }, - { - "txhash": "0x5c94f25cebcaeaea9dce953b49dafa01f5ebab6bab84ac85257a4df50d216ff5", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x224", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x30335bc132be5a5f3bf464e0eed03a3c74f180cb9906552e187e4c04f024b804" - }, - { - "txhash": "0xd7ea9612e78bfd71cd959c1bb7b860fb96010f6132326724dd4fe1cd89262928", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x22f", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xc668aa05d66c2f88a95db12354386f3b6a1722a98aade506e117201f2fd0511f" - }, - { - "txhash": "0x71f54b7f3f4acfdb51b3bc5e822e3a491a6a892b9ef7dee7493d38f135d69df5", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23a", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xfc6dfdea8f35e8af49faf38c0164a3deacd65c3927eeece6023868f32fd382a7" - }, - { - "txhash": "0x34c7189ae7c5894d908d9df8038d9f15d46bf8fef3b44c179f4bf5c194a49963", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x245", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x14ec3dfb63100132cf23ef71b80689146033fc6ceb9f8c0f0a65ef93cd18c2c7" - }, - { - "txhash": "0x801afe1e8d16b2fa9dca00d4ce5aca48efe8cfb7fedaa9ca4e60e3ec5ba7e9ce", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x250", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x5571137d48f7d081e62051a6bbca9d1e25c93ac6f84b7a3bc146f126ac80928d" - } - ], - "tx-emit-eip2930": [ - { - "txhash": "0xc9303fcbe3f18d9b5f259e62f7b59d8fe7ef6545b301a3022610c8cc32e3d12a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x8", - "indexInBlock": 0, - "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a7" - }, - { - "txhash": "0xe7ec4729b421badeb6aeae0214ad958c9b51516d617f089dc8fbd514380630de", + "txhash": "0x62da81199d8ac0d4231dec90c6085f1153a58eba6bbac04f71da4d5076c9b7c1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x15", "indexInBlock": 0, @@ -471,7 +37,7 @@ "logtopic1": "0xf77c749ecb156f605e2334b14caea388100bed09b4c16579c952a96e90355629" }, { - "txhash": "0x06e43cd84b25d35ea82b3b04c4778d565b7370b2551b36382bb0e971d27961fb", + "txhash": "0x7a8c4456e604a0b6210f29c6e68405d2ca5425fdce16bfcc6dfa3d3904b32740", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x20", "indexInBlock": 0, @@ -479,7 +45,7 @@ "logtopic1": "0x415feb809041baabc4d9246223e40f1083963cbe1ef6dedb8b153e49d02ee7ce" }, { - "txhash": "0x414663e2a0b7c8300c9e4f7f6836ff392e626ac8442023e81f479028e0bef79b", + "txhash": "0xd1ec37a2bc2841c4dc61de447dbe772a92284714f03752bc4056eafdac74dc21", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x2b", "indexInBlock": 0, @@ -487,7 +53,7 @@ "logtopic1": "0x89c17d9392b73a55738ba19aae192f2f9c5612dc8bd803ca23b9c2fb9c309e56" }, { - "txhash": "0xc6fa80c16effc705553d70ec5776c402eaaceee2ecb41dc444da158ed0166d8a", + "txhash": "0xa2b3275339e1237e6918726e0f0906f7f6a70a069cfefd3d9b5380e67c2d1305", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x36", "indexInBlock": 0, @@ -495,7 +61,7 @@ "logtopic1": "0x9038344c39b01167bfa8e99a6425d34bca24c27ceb191e8eba70ab5a8f719ce5" }, { - "txhash": "0x84efb3f3887121d539cadf5e973689d70d91389fc03435e4f51ad361d089ce19", + "txhash": "0xc488c5aac30312fe8365ed78fc6cc12b531f9cfc315e6ec5ddb610eac4a48976", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x41", "indexInBlock": 0, @@ -503,7 +69,7 @@ "logtopic1": "0x4b3120af8064823e074758c51cd6cd0954587c0d94b5b37b336261fc7aa2ddb3" }, { - "txhash": "0x9fad4904eed2887e05f4f5d2152f2c89a36d9d936c29c50a7ce7601effd8b19c", + "txhash": "0x7b43a1b8ddf97ab6ccb6dcab385184d1a1165e3c221013b34448223af45fc832", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x4c", "indexInBlock": 0, @@ -511,7 +77,7 @@ "logtopic1": "0x41565ae6f06f2555139f444c467d6b709b45180aa0c6b15bb5b1388d55ef952c" }, { - "txhash": "0xeb53887ad3621080290ea5f1ea0adf1f8085bec14df74c5b81b3c7efe4b7efde", + "txhash": "0x8954b9d95e7b0d5a726847449419e1cf77a624199e1fa89f311150dcac94b361", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x57", "indexInBlock": 0, @@ -519,7 +85,7 @@ "logtopic1": "0x00f7ca033c24d91f8fc39cbf0edc8a43192507f93d7316f311b05eeb85921eed" }, { - "txhash": "0xbc3f4e9e137c2e0c8973401ad6f64795c04b7d47ac215feb6011aa9a7ed03c7d", + "txhash": "0xb2749d3a5d1b062f85a4717ee5c3a7a686a31b03ecb2e29394bce32e15bc3e08", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x62", "indexInBlock": 0, @@ -527,7 +93,7 @@ "logtopic1": "0x761bf5fb1730fee0e499bb1806b9ae14394e673ab9c1dc12e95b9d3f1647cecd" }, { - "txhash": "0x86c2c4e5a08428efde69db7036025b1349438f22d85c2bbc9714544473f984d0", + "txhash": "0xbf2b014779d3872e5b8ae89c65d8c5912e60c459698f44f7281b9f14e03e6baf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x6d", "indexInBlock": 0, @@ -535,7 +101,7 @@ "logtopic1": "0x468eae0ffdb87a4dc081a86c494969801637f690e1e1da15fb4a9d2c78272da8" }, { - "txhash": "0x90439c435817e3a77f33a7746c3f79961ecd321fab300519708d661fc7ec65eb", + "txhash": "0x1d27789de7fbb33eed6c51da18ee5e7cef7b242046842d42141cfb7f4893b624", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x78", "indexInBlock": 0, @@ -543,7 +109,7 @@ "logtopic1": "0xdbc7a073eb54d33d8e6dec5b0b635a874204bda1c23234ff0cca057ff8ed77f5" }, { - "txhash": "0x88792d2ea77fce18827a27f02f6aaf54824e5bd6e60215e26e69fe73d00de657", + "txhash": "0x48369062975939c17e4695b1368d7a1e0b60d145662ef9ba0b7a61b39c3f2cd4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x83", "indexInBlock": 0, @@ -551,7 +117,7 @@ "logtopic1": "0x7a9cae3647128ba14914f547c5f27444cd7325bbc37e5038abc31eea45003034" }, { - "txhash": "0x1492acea121d6e2e74507e43a99ed8146c57ed80720f2d108cf9c31a22cb5951", + "txhash": "0x7fbb4a27af5e59af9219a6b3a63b8cedf03d7f4601f1cdb83d12ccb85f50d315", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x8e", "indexInBlock": 0, @@ -559,7 +125,7 @@ "logtopic1": "0x2df4cc92987ab73b08a3474750456382a0add51fa25f928480762f3d993f2984" }, { - "txhash": "0x36c80351a5e5b1af63afa0bcf9b3ba0cbda0ec541b3744977b7f049654c54eef", + "txhash": "0xcaf24c0839480fea158a7ab6ef75a23ef77474cfd9ab3c8ac081a945aab21c4e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x99", "indexInBlock": 0, @@ -567,7 +133,7 @@ "logtopic1": "0xf8b0a158a81e46d2f46d268e7726acaf7c33fc321c36f6157f07abbf7fa49e5b" }, { - "txhash": "0x15417bc19302807aa8dfa6e7f27d558b7bc3cc63fe1e420ed02cb33d0b7098ab", + "txhash": "0xdae00232b88d3b90d09205f957ad48386379d37ac2d5540d8af9fe9d553fdbda", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xa4", "indexInBlock": 0, @@ -575,7 +141,7 @@ "logtopic1": "0x85ca3ddf1ae9fb0aeadecd8109961dc5d5eaff16ef7adc672149a7826c69da97" }, { - "txhash": "0x02ffd0bf00551df3bdba55994ac9ace84b08169515ca7ad46018caf13cfcfe15", + "txhash": "0xa10cd97b8629e989007f80e56895aefd1c1e989dbf217ea151b283f86acb2a06", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xaf", "indexInBlock": 0, @@ -583,7 +149,7 @@ "logtopic1": "0x73b2b230124967b31546c7e2fedbc5ab108a537ef6d645621fe74fcdc0644b28" }, { - "txhash": "0x322d17f7800f157cab844c56b8997f73a4af682c2b9d1896e7febd234f5e3055", + "txhash": "0xaea435d689fd6296e3cce8d5804b780ce50074f43d6fe6181de0342698eab582", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xba", "indexInBlock": 0, @@ -591,7 +157,7 @@ "logtopic1": "0x46765aab85a7ee88496ecde24f93cd5ce361b5a9fb43a2641d77bfbc97928010" }, { - "txhash": "0x58e2dd04291740326a8f8fe3475781d8c1dee08176a2ae44eadac4c7518c6bcc", + "txhash": "0x97ed8f06347509fcd1ad5b8e81c69d3aa2b17f614923eeb028932a7cd68be7a4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xc5", "indexInBlock": 0, @@ -599,7 +165,7 @@ "logtopic1": "0xd0e6005ee39e02d654cc2db358df9659d8265e24d7362df88a7df9200438f6ba" }, { - "txhash": "0x095eb45d2c81cff8a691af38b0b7e3bbf69a77a740a8362f8ad4d7e710de08de", + "txhash": "0x85bdef644e1d4dd68f8d748f29ff0047b55ec15731f700b2c9a7aec250a70031", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xd0", "indexInBlock": 0, @@ -607,7 +173,7 @@ "logtopic1": "0x4323bceecd4ef7216d5b57b9dd12ecf03842ed56d87fe43d0959436f408f44c4" }, { - "txhash": "0xf69b4d268ccdd64739eb9f74d76e06b6d7ed43e1e86d0d6e7deef093826718f5", + "txhash": "0x81eed80ddf014a4ca8e043b52302f20d4f0ccb6a9ff9b595abcb3ee027977be0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xdb", "indexInBlock": 0, @@ -615,7 +181,7 @@ "logtopic1": "0x81607ef8d6fd479d2d0f55ec50762ee5fc35883ee5600525ce1e9ef3398d5aa5" }, { - "txhash": "0x8e430bb7a64d7757860a881f31b721c8457b80b69332dd67668be803f48e5d35", + "txhash": "0x7ad3bf852c70e27efab2e2dcb39dead02b88818efbbd12b7aa0633541f7b3f38", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xe6", "indexInBlock": 0, @@ -623,7 +189,7 @@ "logtopic1": "0xb36949b816cb2ec4ab90f345d0bed84f55b8fcbeffd22198724c45d8a30b20a6" }, { - "txhash": "0x61f149d4cfff2ec32410a4684600ef4dff10be09284ae170d4693b9590642e14", + "txhash": "0x4aef6e5f54a5115cffe06cf73a588815fa873ef550c94e89713678889585c6e0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xf1", "indexInBlock": 0, @@ -631,7 +197,7 @@ "logtopic1": "0x40c619388e6393f420e805451bd48b10c670de7d51e916a3ffe5ac3c96b81938" }, { - "txhash": "0x7ca86b15d7e14a9bbe4a012edf616f8341625a032c2bfb16b0361742165b6033", + "txhash": "0xee20ead2bc204a4049915c4996e332b148ff187fc4653058dbf0df9e73b451c2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xfc", "indexInBlock": 0, @@ -639,7 +205,7 @@ "logtopic1": "0xa22721490cd06a0e77bc2b085bb4d57e7e5e0b459a2afc65ec4697d51926e1b8" }, { - "txhash": "0xd9fca30f3482e9d19271c9f1223ced48fd7e315ca4d0ea28c038afa16ba17d3f", + "txhash": "0xc46b84e641877cab5374c169a802c50ed4bbb63a4be91a2d2e9ea62cc3bed0d7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x107", "indexInBlock": 0, @@ -647,7 +213,7 @@ "logtopic1": "0xac748acc1af284e25d06434a8c1bbbf75bb8154a06f53f75d4f36edb656a49ba" }, { - "txhash": "0xb5bd2b2a1e89dbfc78b28316727a351716033e8968a5832f0fc6f5fad06061a3", + "txhash": "0x38e848949e94f3d41ba77dd36fda8159401263178046316cf1d2321999101cd9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x112", "indexInBlock": 0, @@ -655,7 +221,7 @@ "logtopic1": "0x4edb05f465bc71ee02c59ac9b5b50ddd974960ea2bd7e8cf7ae91c38c0b5789c" }, { - "txhash": "0xa620915661e953c73734bc32bb5d340ff2616906dd600a08a777c02f01a752cd", + "txhash": "0xe1bbc32cee7b6f6ff8477171315df665b211dac38a64c519aa32402dea5cb675", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x11d", "indexInBlock": 0, @@ -663,7 +229,7 @@ "logtopic1": "0x0678ff21f84e5213aa8d1d173b3517f8e6c3d1523959c101c75a31daa70ab942" }, { - "txhash": "0x792c9815f48f974bb737f43e351015f573dde750d3c5bc2ecf78524381addc46", + "txhash": "0x9615de1a110d38ec38ef96054453067bec5e39472ce177d0fbc8523b503edfef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x128", "indexInBlock": 0, @@ -671,7 +237,7 @@ "logtopic1": "0xb3750ecb88b6e11e5f686cbacb3d24e61396cef4a1525b30d5a30edc4b3fdec0" }, { - "txhash": "0x66f4a947f820d53549e32402217beb1fa688d0a3a9df01393883b43add1af7ba", + "txhash": "0x9393ec29fb5a5d71fceec3dc7301afa92a3792d77a2c1be6a29be162cd822e26", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x133", "indexInBlock": 0, @@ -679,7 +245,7 @@ "logtopic1": "0x38570ba11cfca6a25bea615c7ec09ae671516245a92a5f8fc61d2e82529454e8" }, { - "txhash": "0xd62159aaeae3823a577e60ec54af48a461c39a2a8d84db012ba6cf9f9716e65a", + "txhash": "0x3f51ad5645ecb1d7229406838378a0f949a2703afba50a615d7efe57a90cf669", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x13e", "indexInBlock": 0, @@ -687,7 +253,7 @@ "logtopic1": "0xd5eb8e9a486b23e10cf0092ca8690e7bd6d6c90932960cdfa5da36d1e1f20423" }, { - "txhash": "0xa5c399b1c83feee457bd10e9cb5443f4184e28f49d44aa75432061e3b379934b", + "txhash": "0x038b847a33bab554aa0ff0219acb7475ab1c51415337790b78a2a41664194361", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x149", "indexInBlock": 0, @@ -695,7 +261,7 @@ "logtopic1": "0xb5e95d5da3e73f937bfbc9b4990bfdbd865c6d3a3b50478657e20b507fac7541" }, { - "txhash": "0xdf6e0917de58a976925e579a3bf7be58bc52009f6307ca89aea3564ea78059dc", + "txhash": "0xbbff97fbb8a0fd1716b8f33e0f5b56017a9657eac41585f95559845293a34e8f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x154", "indexInBlock": 0, @@ -703,7 +269,7 @@ "logtopic1": "0xa3e65c2aeaf352e79173be13e572f691d8d75ea1064610b8418246d95bcc421c" }, { - "txhash": "0xec034419430d4e6672f6e20c2145c4fadf17f3e06a3e821e9ca6a786c9b45515", + "txhash": "0x72c15fd124c1097b19c923848c9b14fd73511db3416327885c156ad62252efdb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x15f", "indexInBlock": 0, @@ -711,7 +277,7 @@ "logtopic1": "0xcd78e90ed1705eeff092f3df07b16a382082e9c388030ec3188daefa57a731dd" }, { - "txhash": "0xd1b8042da59f6d7a3f740c84f28c46cba7706397e581b7b9c5b2cc80f17586f4", + "txhash": "0xc7baf1ea1dd369c9955b15edc0e2644083c227cfdd165f83ef6025ed6b02c344", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x16a", "indexInBlock": 0, @@ -719,7 +285,7 @@ "logtopic1": "0x490b9d550a200295b38f2456a42525d3a43c345d2fa1431e770fea9656b26723" }, { - "txhash": "0x96566916710216635e35febde8ce995b9c109a38e5870706cf77279f609ddb98", + "txhash": "0x2e221c13d1a9566863bbf42cc0cbefe015613bbd7e9e19b46a2484f4fc81fcac", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x175", "indexInBlock": 0, @@ -727,7 +293,7 @@ "logtopic1": "0xcb35fbd0ebf79655e6882326c19855ff90befcd2e589418566ec2e3a1efd65d8" }, { - "txhash": "0x3d5e920028d1218989019830525bff1e6f08eb79953470d4f2692476849db51f", + "txhash": "0xa1af8ade321526f139ceb3e76fa12522a5d5cdac78deb81c0f49cbb5b4a9e93e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x180", "indexInBlock": 0, @@ -735,7 +301,7 @@ "logtopic1": "0xafc44d58dec637206e79248a528189c68365e20afc23410475deb5e5dc69c82a" }, { - "txhash": "0x4c04efa9772f455ce5d77eac6037dcf8f8a904d7849dcc139f1c98b9d90d0471", + "txhash": "0xab12c172b674032a76a6bfdf79ecc0846d337953d23523fcb709c119cded3f4c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x18b", "indexInBlock": 0, @@ -743,7 +309,7 @@ "logtopic1": "0x1f1860251182573015d583a718463a52050e45d795ec0f94d112206c3fd62e45" }, { - "txhash": "0x0ee54e10b675053fa6e447175e8a0e64af66d0f3c4938f5a545e392c329e1e73", + "txhash": "0xb5062802b3ebe1a560d0a84ae7405ace74a3bc1b04cbdc0f88a0e894b7cfc90c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x196", "indexInBlock": 0, @@ -751,7 +317,7 @@ "logtopic1": "0x19fbac480a243f8c051e10225cec11bcb7fb274fac8792ca7e36bab8e39d312c" }, { - "txhash": "0x6bd480320bb019a63d45deeac7ed513db679147d411f6e8c7a884430d5e9f684", + "txhash": "0x9e3599809a88b599b80114ddf4d2f7c38be757f998b0914954553abc81206fa7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1a1", "indexInBlock": 0, @@ -759,7 +325,7 @@ "logtopic1": "0xfb2772a3127ac292efa3da20fad64d950bf973fb209892fdf834766aa8cdc3ba" }, { - "txhash": "0x27cdbcc53409169cfaf19ca3c19a424308dd879a53bfb34f0cb622e98341e09c", + "txhash": "0x4a2eb0bf09b80def14f483a6175281c4067fd2eb220cc47707130d3b14f0fb8c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1ac", "indexInBlock": 0, @@ -767,7 +333,7 @@ "logtopic1": "0xa90642da2f095eb8128f01811cb553162395cfcecbe5b077f12c62a1effa7c82" }, { - "txhash": "0x691d488d31d23773b488470cbd25e0036b2bfa466ba08e951eea23b856f3f908", + "txhash": "0x6cc89bb432f442a20c17b618b075e052f9eebcecc39b21776af49a4cff501bfa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1b7", "indexInBlock": 0, @@ -775,7 +341,7 @@ "logtopic1": "0x75eb384e56c3a3a30a408622e6f0595d30705efaff129c133effc43c3b946de0" }, { - "txhash": "0x8878d98141b90199635b3989109699d477c828c5faedf356781f6eb587c4344b", + "txhash": "0x509133ac59b43f8954559fc0234228110b81c7272b9db1112828ee03d407030a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1c2", "indexInBlock": 0, @@ -783,7 +349,7 @@ "logtopic1": "0x2aee290f6f3f6c60a6985d0150eab487f9de1c47962a779be7343cc0cff270f9" }, { - "txhash": "0xf59da47c6804c63a8634cc67a08092994451fdd5fa56b7225c40a67edc23e635", + "txhash": "0x900a3e1ca48e9a476a45fe3d0f88a8b40134ca59f902719ff75db2b7a361a06b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1cd", "indexInBlock": 0, @@ -791,7 +357,7 @@ "logtopic1": "0x41b546f355dc0dd009ac5da8bfd17c8e197595c1c1f21aabbb1f3b18343a0718" }, { - "txhash": "0xeab623e58b8f2d54649a24878731423ef914b23194a1ffed91b143b877fd69f8", + "txhash": "0x7dfe4a0c877a5193b0f3180e2d8465ee5f042e420f740edd72139dcbdbb46d56", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1d8", "indexInBlock": 0, @@ -799,7 +365,7 @@ "logtopic1": "0xca27d6fc8e6016df20a295f26b57b2f6ac7a8cec98224571f416ea88c0ee7b97" }, { - "txhash": "0x0f68375d9c8575badff105441ec3f3fa0227c2fd5015fd3fb288cab15a0dc269", + "txhash": "0xe67e670bef823b90351ae0811db0c4b167a6549543345128309c0281ef8365d8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1e3", "indexInBlock": 0, @@ -807,7 +373,7 @@ "logtopic1": "0xd1a0570d06c0cc4198b4475cb892ec41ca3239ff670666bcd97faeb62c1db6bb" }, { - "txhash": "0x5e1845a8cd15ad7e127cdede8899eb6a473e59045ad5cac8cbceac140b6ae52b", + "txhash": "0x8f376b2834fec36a91e856fb0e7b85db94d2d764b6131f064cbb9d796bfb2a19", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1ee", "indexInBlock": 0, @@ -815,7 +381,7 @@ "logtopic1": "0xa6602e59691514abf1ee46e71c1f4c7411eddb76e687f8f4aaa1ebf305b97f6c" }, { - "txhash": "0xa56dc267f90bde33765a9acdb6853250ea8405b0819e0884ddb2cd26af1ed262", + "txhash": "0x66485193e1246cf388f2f6702307d7ddb4dc665b6d98a61b1e603a667b62254f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1f9", "indexInBlock": 0, @@ -823,7 +389,7 @@ "logtopic1": "0x0a5a37a1db2e0068ee9791dbe377a74c4f7bc36bc27af57ca7e49059127e8eb0" }, { - "txhash": "0xc97c6242194520c2185b98119eb572ff29243d6b86afe9e78209c2c0633f8e43", + "txhash": "0x487fb2870d14ac9e4df7b20b32afc3b499e69233aacdd983714ca9a879a690ad", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x204", "indexInBlock": 0, @@ -831,7 +397,7 @@ "logtopic1": "0xb50dcc47e811f76cc69369cb397936a5c70520a51f33b84f1b54591da145e823" }, { - "txhash": "0x102f1c2680bb4bbde8b42b0ed2b27d0f53b0741f6bfafce3326300f0ba02d461", + "txhash": "0xb4226c093edab69c51ae8c63ae4572b7a5084fb3943e11d192b0587480f61827", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x20f", "indexInBlock": 0, @@ -839,7 +405,7 @@ "logtopic1": "0xc6bea923a54f8cf570edfddbda896a2ebf7b53d33b1dac8914ed024ff0621f18" }, { - "txhash": "0xf312429462bdb087f27b05d3485452aad3177090d1c834c4c3b1febae3ebdeb3", + "txhash": "0x4d1eb4c4f40faf9774d150502f66f0c95cea371c61340d48fdbda852d459716b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x21a", "indexInBlock": 0, @@ -847,7 +413,7 @@ "logtopic1": "0xb296a1364260e1c8d47bcf2239f26b6b909a0a7687250af4af545eff0ea95ed7" }, { - "txhash": "0x6b99996554a4f85b731230f246e924a1d5c455311909d76074a378e2ad0dc344", + "txhash": "0x6adc552ebbb9b37ef662251ae9625857551100f6560033b09f70b7f3be3e673c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x225", "indexInBlock": 0, @@ -855,7 +421,7 @@ "logtopic1": "0x142951613bf93db71eba96bb48c57a42168fcfded6491e1229ea2b8570f77e7f" }, { - "txhash": "0xe0909f2b9a4d6b4064c61ed92c0914edf5bdc08ea9454cad75409f8edc2b99fc", + "txhash": "0x65adf12f5b8c2e24801a6845adbc615d2b58294f8019572e9ad56921f34507d2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x230", "indexInBlock": 0, @@ -863,7 +429,7 @@ "logtopic1": "0xa99b8fb9a23a3a24ef3330a371d081c4158ea1b75c9af3c2bda5440857bc8237" }, { - "txhash": "0xec379187efb4e736e8274e899cc4bc4b8c1f94596e67999d57ad1950a9e12e91", + "txhash": "0xf58d4acaa927394b8be4a4a5c2f8594cdd47d6b994f86b40190628fac65891d0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x23b", "indexInBlock": 0, @@ -871,7 +437,7 @@ "logtopic1": "0xb9a419e057752857f289694284890ff1fcbfbe5d736b5e52bb8568e077f49883" }, { - "txhash": "0xeb7451aba7fe97573c34ea34bdf06b8782335c6de5ba4507aa55c799b1446032", + "txhash": "0x61d683cbcc73112161fba6dfd3ec9c70339854e7986be731313162e6a571c9a4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x246", "indexInBlock": 0, @@ -879,7 +445,7 @@ "logtopic1": "0xe0fa1a4e967a01f4a84aa6715b0977cc111d3cc0834c5d04f0f1d87e0d561a71" }, { - "txhash": "0x73bb7b0c0bfe122b47a7242c5cb85473bfb1b6ab532968acb36e2e95d28abd80", + "txhash": "0x9ccd92d4101101b304db4ed5b25e14444900774ba9a8659f01846da9b8f95660", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x251", "indexInBlock": 0, @@ -887,17 +453,17 @@ "logtopic1": "0x701960547b78067b00883157f5e9fca3bbea742385129f0db7e1e69ce445dfef" } ], - "tx-emit-eip4844": [ + "tx-emit-eip2930": [ { - "txhash": "0xf420e289a5ee4f9f9741ede7f240216b93ddb6e9b6e54859db1d33e57edfb174", + "txhash": "0x76f2917dfdad8c636c493258e672938661a2044a05338bbad7d14d446fae4d45", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9", + "block": "0x8", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0x63cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f" + "logtopic1": "0x881a8434f98b103a2ee48727304618ca54234f1474c44bef70c21accc4dbc0a7" }, { - "txhash": "0xd5b23faaf6a0054ef645601b6a3882ff63368c518afc2f6555408d35f41adab6", + "txhash": "0x30fc0bab35d4325db37b953f5cf26e05f2c18593adcc4c14c8fb04b28501c2c5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x16", "indexInBlock": 0, @@ -905,7 +471,7 @@ "logtopic1": "0xa41cb4f2ab2731a8889754ae1a340c666cb8107b497b922073df80a9b255e31b" }, { - "txhash": "0xddcf88da9d1942ff808a887b92501dcd74b01cfb8031324b684a4ee29fb63c1b", + "txhash": "0x07032ce65db029864ffcc0c3b00ed01bf8fa90da0efc781ecf517920ed762304", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x21", "indexInBlock": 0, @@ -913,7 +479,7 @@ "logtopic1": "0xb2416e7ca12669406e6cd5154ad5177841b7d0cddeb2760249c28e1aa151f970" }, { - "txhash": "0x45a0afbc813c5795a8a3f22ff93dfe6810a1557a96e1fb87c90e68d6e834bf6b", + "txhash": "0x61a1ed16c11ef4e4c8036233b87753a761be8c9702514ea87fe3bc82345bbbba", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x2c", "indexInBlock": 0, @@ -921,7 +487,7 @@ "logtopic1": "0x11f0a8ac2adda075c95bbf6be534e3254dafa759f62cbcf0e91bc6f0335e70aa" }, { - "txhash": "0x39bec15647bf657b5d91d4571f2e68e7c86705d521d48c09c35c2bd40eed7c0e", + "txhash": "0x24a0922096c6a6b34668d0b06c4724db961e3b4c462c6fa645517e19293ec37d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x37", "indexInBlock": 0, @@ -929,7 +495,7 @@ "logtopic1": "0x8460e232c64e6cd9f816c02d855c892755984ebbb91592e683cda80aaba4ba22" }, { - "txhash": "0x64505ad9b89241532e82029f9eae4c180ac6c32b09a29b1f452c92da1af320a9", + "txhash": "0xdce27eb7c2b44d61022e4923329a9b18f0dd26093a88dd5efa772fb1e52273eb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x42", "indexInBlock": 0, @@ -937,7 +503,7 @@ "logtopic1": "0xe7d55978188f31ab090b1f10d8d401a66356b11ca8c296384a0a51e36e6ec11f" }, { - "txhash": "0x7191d4d64827164b565c87480409d22354811d609572d1c2a314c86560fa4302", + "txhash": "0xdb7b8df9ad36fc8838cfedc2f272cb205f7ad2860cd1f5ac5e739ed1a2973784", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x4d", "indexInBlock": 0, @@ -945,7 +511,7 @@ "logtopic1": "0x24a4daf5b3cac3bf3066902cda09da0fc862e0a6723c47981ed601782ad69079" }, { - "txhash": "0xe94af7e94ff9b3cc7ec58666ef5333ffdd8cec10340e270f519ac5a95277eddf", + "txhash": "0xccf0da8511e51af458ef4ea7734531fdb77b8bb48191efd8257cf6ac16daf3f6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x58", "indexInBlock": 0, @@ -953,7 +519,7 @@ "logtopic1": "0x7c24a68c92e3b68daa153ae82eff9be1ebbab973384e0f4b256f158f93c5d525" }, { - "txhash": "0xade7523b78f2e5f6c67cd47e6d7e2f8011534e6ed32552d5bf8d8e5bc3a56d1c", + "txhash": "0xe78dac2c962f7fc240909233c4b8bbf47a6ab4b9b3b4376ecb92a4eff4e147e3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x63", "indexInBlock": 0, @@ -961,7 +527,7 @@ "logtopic1": "0x02bd9d62880450596e11c3417f2644a81f7cc233a05394bbbfb58428ed53f413" }, { - "txhash": "0x3292412496ffb7d9778bfb58cb3831b7faad4fd66db3d0eb781fc42acfff63cb", + "txhash": "0x2e5f23d99b09fd9f81f2fc7013c3a3bd8fea88bd6df07e2b236addad4e9e94e3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x6e", "indexInBlock": 0, @@ -969,7 +535,7 @@ "logtopic1": "0x0dcf6219856f226889a2440b388d8e15f5df0eb64a7b443f3a7a5dca7b87b0f2" }, { - "txhash": "0x647ebc00e9b4f1745b906d55709623d4565c4ee37cc43cce3294e86fbb06af9c", + "txhash": "0x37010507fe716034116f8d945ce2bc35d3718e7c10b78ba34e4ddf780c6063b7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x79", "indexInBlock": 0, @@ -977,7 +543,7 @@ "logtopic1": "0x0f624930606bfcd2386d583abca6ab10227d71fc1633fea53f94bd146c152b8f" }, { - "txhash": "0xb19cf34f280a82abe8279d9037a23cff23592f19805be3d08683929a618523ae", + "txhash": "0xb53c6450c32830cf3be18b73370a0a290a12acbf4d734e8ad8785d4742e8035b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x84", "indexInBlock": 0, @@ -985,7 +551,7 @@ "logtopic1": "0x2daaea9286d7edb7568e0803a61bfdb1e1506156d27e93bdf1942564850646c6" }, { - "txhash": "0x36f1fabea1bdec555c4febcf4c87ea5bcdf9ae5a1bd9a10726287649704d94c2", + "txhash": "0xb7b48df8d1f44601669025fe789c2a5aa05771ac35ea90bd5bef536ecdc4f92e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x8f", "indexInBlock": 0, @@ -993,7 +559,7 @@ "logtopic1": "0xfaca663a6ed04f52c0e7a8981cb438545f614a2cf84f9077659d0fce0045cda7" }, { - "txhash": "0x4b518ca4f87136c909ff5c85233c42466d29a1a07991ad4e5a757d81c2b4c9f9", + "txhash": "0x938a5fc80f6fbdf6d5c8838458e4695f0b8fca8db7fc49ead340ed4f0ca2b3d3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x9a", "indexInBlock": 0, @@ -1001,7 +567,7 @@ "logtopic1": "0xe6a5227fabefc934ddc0a3142a50747ad1157ad0829ec0bbc389d5e22e3282c2" }, { - "txhash": "0xfb9370f7667bbfae1f6223e3abff4af8464d2ae0639e915d7f33e0b8fd9db0b5", + "txhash": "0xe3d00022dd63b6705c7eab12a15ad5f279b99eeff670bf4316d4ccda0045f324", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xa5", "indexInBlock": 0, @@ -1009,7 +575,7 @@ "logtopic1": "0x6a99e5276c6ea0c0894cfaf376fbbfdc736b359e1560a77365c14fcdf6cbbf53" }, { - "txhash": "0x3673b0487371e7e696dafa1a8e4564fb345c950362dac3641d570b2f37018940", + "txhash": "0xc0f5f7053ddfd90bf909cba8f2d0ba8ec3f5ac2f9efdf7d44f6e632d02d77d51", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xb0", "indexInBlock": 0, @@ -1017,7 +583,7 @@ "logtopic1": "0xbdfd2b337ff30e9e15c09313bf796d3c75177943e0aa0445f479fbd2dd5c1d6e" }, { - "txhash": "0x1117f306b532c07bc696dd2b53a66fc8ea8c7be319c8db8149b13a564d9964eb", + "txhash": "0x06b8f91efd631d83bbc3cabc57e6e4dd311e638f32c0bcd0e2bde98454cde233", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xbb", "indexInBlock": 0, @@ -1025,7 +591,7 @@ "logtopic1": "0x23c2e06f633f91e89e0d95cf87dce47fe1cb2b95434ff45773f1fd560ad2dcf6" }, { - "txhash": "0xd589b01ccc4b4c2004a2bd5b3f83fe8749ecce32dc8d96b3a5ee0be0b452374d", + "txhash": "0x9dbd1ff97745b8fd334b4a2bc75ccaa32ded0c9bfb954baba7f5d9bb7280e6e7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xc6", "indexInBlock": 0, @@ -1033,7 +599,7 @@ "logtopic1": "0x3c8110e03f1b54de6085ff899d0dccd87806b788d1ef3fddbca1de4c356266e7" }, { - "txhash": "0x2ae3fdf2e8671f02c712cc2f0ed0a64464e2b3eb69324b4b3291adc850eafb4c", + "txhash": "0xa214e938f072e94479207b9fb4c2c5a247acdd9d6ae0af03d31783495bd82219", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xd1", "indexInBlock": 0, @@ -1041,7 +607,7 @@ "logtopic1": "0x5d7c0426d6595c1819b962730e5d2a44644703ebd960ec3ac51297ad937692f4" }, { - "txhash": "0x3896b74ebf76ff849f44241bec1e1f649653376971e657ad787801cf89bc002e", + "txhash": "0x24f06cd0fe391480eb99730d94c35fbba76cf55fc51c58a6afb25a1629e86964", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xdc", "indexInBlock": 0, @@ -1049,7 +615,7 @@ "logtopic1": "0xe207f028cce1624a1fc76c56f1794c2704a692c1f214685291d618e40733ff1b" }, { - "txhash": "0xa0416d5370e59e86c33919e17cbef2ddc5aec738068d627a5158b46513115470", + "txhash": "0x5a93049aaace1c9fdcfa440ede274acc58613f8476bfd80d17cc67a289481551", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xe7", "indexInBlock": 0, @@ -1057,7 +623,7 @@ "logtopic1": "0x18fbf0ae0e2133584c461cbd43169854c7c7e818e8b5779892da244f24d27b56" }, { - "txhash": "0x36e00ad068d4b0aeec3c2d5a7a196da7feb1ae69b19289156477b7b5a025a908", + "txhash": "0xbab062324e2bd4efa01fba78c887d8893e40aa9cfb2af72a115877cdbba7efc1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xf2", "indexInBlock": 0, @@ -1065,7 +631,7 @@ "logtopic1": "0xe8a78860d5ffde377f4eb0849fe59ed491d4a12fd51edebc2bceab3549d83463" }, { - "txhash": "0x8ae68021325ec15d383dac77654f45002c2540c113c8069496b4c7b7ae847f42", + "txhash": "0x88411eed62ba108205b74c16cb97c78eb5e670c73a462c81892decf6caf83b48", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xfd", "indexInBlock": 0, @@ -1073,7 +639,7 @@ "logtopic1": "0x9138868b39f601dde19efa6e9a154230a51805e9a6cabaf28fed5163aea58328" }, { - "txhash": "0xa0521c7d9e65b85ce70e1047a30fc0f40716c958e5d26ed1b892dbb58c631623", + "txhash": "0x79f84618f37ce72b674e601cb0a4305f2995911efc8cc403de6fee482f34acc3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x108", "indexInBlock": 0, @@ -1081,7 +647,7 @@ "logtopic1": "0x4348597bdcdee80c8e110d94f771eb7edce9c8691b2f90b71c0d11f729f086c9" }, { - "txhash": "0xd08c91a1bd8cedb22608d15dcc429cd8fe2785c0e28f8aff323d8a47957b22d2", + "txhash": "0xe46b05ec347dd18d056a9318a43b3d196e0c493c56cda202b97ee26f9b132af1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x113", "indexInBlock": 0, @@ -1089,7 +655,7 @@ "logtopic1": "0xaf1c2654b2e98e9ffbb02f14d88617a245a9a1679162be29776a4836185dc2fa" }, { - "txhash": "0x50266b81dee4437511591aaa60df86717642524cab47d508be3cfe16248574a9", + "txhash": "0xf67bb9d97909efffb323cd48f9547bf08c5051bf1bb9ea58c2e7e9929e9b5a0b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x11e", "indexInBlock": 0, @@ -1097,7 +663,7 @@ "logtopic1": "0x81260b78e72018d5773b6ba1df006b09a387fd733e59ad152c119d9848ecf1f9" }, { - "txhash": "0x0dab5929cbcf54b4b6742c4e7ea56774f9f07c5ee046151312accbad330ab7d1", + "txhash": "0x49a00cf1ab0cac049709ad4d7d7a18c5622fa59abc25e0f33f3319c154f27a69", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x129", "indexInBlock": 0, @@ -1105,7 +671,7 @@ "logtopic1": "0xf9b648439e7b876f9aa1b178fc6381f44bcaee23754d8da33b2d44e78cf47bb1" }, { - "txhash": "0xd72795a9627079d42e1f65998602783c0e1152b1a6ee62b5f399955aaf1a3808", + "txhash": "0x5490dad7b381c41f8492dac1d97b40465a0291c0a9ad625c4a53d5ef74ba78e7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x134", "indexInBlock": 0, @@ -1113,7 +679,7 @@ "logtopic1": "0xbefb4ff6aefe6c4d85158d11057517eb9cb1e1cae3e9d2d9c90ff40b2cceb546" }, { - "txhash": "0x1f049fea47d8615029fae54748b820cca1369ac4fb2bd01e570a5bd2478c683e", + "txhash": "0x2f02d65eb6718a9fb37ad3ac3b7811d45a161b9e07681b8b17892929212caa94", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x13f", "indexInBlock": 0, @@ -1121,7 +687,7 @@ "logtopic1": "0x9575996f3ad6e9709d7122224335451a59395327d297fd7967004e8dc1391308" }, { - "txhash": "0xa507e1f9dc79761107510d4f931dbcc1d2d846bb2c2007faae7198c926431d61", + "txhash": "0x3e1aacd5bbb49d73201c1b91c53abf7a7dc9633d7e4a9eeb1acb248cfd6299bb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x14a", "indexInBlock": 0, @@ -1129,7 +695,7 @@ "logtopic1": "0xa791ce367786fdc4c5216c8b94dfe1076746e058166dabda25b5e6a3266ce857" }, { - "txhash": "0xdc4ebad42a33cedb2c56f2963b7f665b806c7e76a95b3527e03dcee1e8d3aac0", + "txhash": "0x9eefff22b8fc296d66b4c0892dd021090efc184974347ba86750265ee81f4967", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x155", "indexInBlock": 0, @@ -1137,7 +703,7 @@ "logtopic1": "0x6df5983ddc40ef2c7ffa2c79bf9402568f2ee0ec7b675ca15aaa20b536d2a5f2" }, { - "txhash": "0xc1631f848ee48f93986a0d7f3a3856229d6d7f2ab448da79299ae65ef5c9c72d", + "txhash": "0x1c330cf34399c5116a1f0040282be248753e2b3deadf05ad719684e06ff62a75", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x160", "indexInBlock": 0, @@ -1145,7 +711,7 @@ "logtopic1": "0x40325cfcd159fa7bf89d8c252b6ff47cbc17aafff5e7feb92014d00285484cfd" }, { - "txhash": "0xa8b3e0feee69ef4ad9f164709f9d8c93cb0cef54b547d6df3d3bd60d9373ac61", + "txhash": "0x97e229b0d274161ce5acfe05d2770f44e1dc5f5c2390e0b001d227f01e1d56a4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x16b", "indexInBlock": 0, @@ -1153,7 +719,7 @@ "logtopic1": "0x039a54e14fa9769f840074356dec3dbd47c3588fe71fe942fb7aec5edfd0a096" }, { - "txhash": "0x59a87b6c242eee2b5bfb727160765d68198245907faeabf342d28663f9695bc0", + "txhash": "0x68e4f0d419f3f18f2f448f2a2a85eb33cedb8eb9baaae0c41052b3e5c5ab783a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x176", "indexInBlock": 0, @@ -1161,7 +727,7 @@ "logtopic1": "0x927e4ce70caf344a9e108ea8803cd49216852109c3e4922dfed2680e9f24361d" }, { - "txhash": "0xb6e6ee58c5cdab20b7a2ab2593716985f53644bdab28c89f5cf05c4704b9a43a", + "txhash": "0x4d02d96d7dff2017f1b95c045a61000ad1c2644f342fbdfe39eccc70f3feec7d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x181", "indexInBlock": 0, @@ -1169,7 +735,7 @@ "logtopic1": "0xe2a0b166c03b200234eacf5eaf9ea11746c9bfd00e72f55d8cab76e0eca7195a" }, { - "txhash": "0xf8b2538634ae7c9012e0298b5658de6faf19edbcc7a6ad8ad9409c3e876ca311", + "txhash": "0x731cb5ada167fa9cdb4b85e62eef892890f5f4310f548a6928a0aec9cfb361dc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x18c", "indexInBlock": 0, @@ -1177,7 +743,7 @@ "logtopic1": "0x92da59b68bfd8a9c1cb1ca6a302ee966f829f2727a36823b0dc7fddf7790a108" }, { - "txhash": "0x3a93ba0531ec222285241aa65a45f44ab14900e4d9c5389f0713456436881b60", + "txhash": "0x6acbb0bc12e52870c6fb5240ffb771f703d91f3d933ecb4a228693174787552a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x197", "indexInBlock": 0, @@ -1185,7 +751,7 @@ "logtopic1": "0x677a6b432bd3361f469c2e051c8e09ea92ed0d049eb563118ff8c680fc93a2a7" }, { - "txhash": "0x1e7d6ae181604098663d2a7b69f2d6a5ef30fe23e953ef480595751a24b63899", + "txhash": "0xd76726d4614e485b18408bc45046136e9cdd2d897485fe4e4dad69c9e849c3c1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1a2", "indexInBlock": 0, @@ -1193,7 +759,7 @@ "logtopic1": "0x250ca62bfd18dde43e70bab089d01d591ce6ab28978434258ae1017c72f12b0a" }, { - "txhash": "0x80223c925ca21ffa9b819dbdb802b1483b8828f209a1e44a6b66e777aeecfd5f", + "txhash": "0x238bb24148c083d631203d405f31779bf2f8cb674683d7cfaae0a45f33c6be8a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1ad", "indexInBlock": 0, @@ -1201,7 +767,7 @@ "logtopic1": "0xcea8a961664f986542ebbc496878d052736682831cd7847bc769ae16e9eefb65" }, { - "txhash": "0x05f3165887c2a6fe74c26b7a5561c22124331bb248a8c83400f9e84254a0a656", + "txhash": "0x29d488a18542c3622726b62f9e223c8b43a885c568d726aee959288cfdf7b3ad", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1b8", "indexInBlock": 0, @@ -1209,7 +775,7 @@ "logtopic1": "0xe5f4774cc356a99594f072de9e8113739c65fb51b5d0fef3f40627cac02dd963" }, { - "txhash": "0x9bdf145cf420be4935f61d48d278854fbb146c5dce686a81f586a6b72e2f1697", + "txhash": "0x1fe0e80aaeb234d31d5c78f52564efda7ffcd74817e6231c4598eadab68b8dc6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1c3", "indexInBlock": 0, @@ -1217,7 +783,7 @@ "logtopic1": "0x6f9ff000b2dc3a554bbbb882ebc7726b700eb7afea141ab16e00a057f314d0db" }, { - "txhash": "0xb1c7a90ffebb5658771131f7286426643259c1d9d3c6581d97a2faccacd3f2b3", + "txhash": "0x05e939d864b0384a980615b891a60e3c7fd6fdd4f123a03a506c3deb1cd10bef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1ce", "indexInBlock": 0, @@ -1225,7 +791,7 @@ "logtopic1": "0xfd6fc192aa03eedb6505372aa1dcda93dd186fb3eded0bcafdaa4f2829fe43b5" }, { - "txhash": "0x837101affb0ad970b9101a914f733b437fa042e2550b3d781f6775285fc8cb99", + "txhash": "0xfafb4b8d000ff550dbf4a1e3cc6b1f06ee2973d10dcddfedf7587ea72feefd5f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1d9", "indexInBlock": 0, @@ -1233,7 +799,7 @@ "logtopic1": "0x506c0723b5e537632209d4a824a6073d5eccadb36b9b8717b2ecc9e2d5cacda2" }, { - "txhash": "0x4a5060608b481087ac139068f55d76edcd8a4fa189abca438bf0b18d25450638", + "txhash": "0xcd68404c240e22562bac6dbd9ac85f0807cd263e8b9b30ae67a0d515cae30cc0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1e4", "indexInBlock": 0, @@ -1241,7 +807,7 @@ "logtopic1": "0x27edda711baed4a613c44d8ac8678531c9938eea106e7c5649e438f3d24b8fe3" }, { - "txhash": "0x7bf955bd6b528d2435096d3d88b3b39deaee5f7702b206c6e0e9cadf739b2aab", + "txhash": "0xf12ae2e38e424be45a18c6b0977c009de69f6f3993c34bfbd4ed40f0501def7f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1ef", "indexInBlock": 0, @@ -1249,7 +815,7 @@ "logtopic1": "0xbae4f13d358194452066fc1305964decaafbc9c56a2fd16936d25d9521a57a19" }, { - "txhash": "0x20ffe88022aa6e1b6a9ff7f2a6465a3db959aad55dd70dc3380d63087e7ee390", + "txhash": "0xe8a619cde23c8746d4847eead4dbe79500af69f978bf0d7b8470432eef4a5a31", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1fa", "indexInBlock": 0, @@ -1257,7 +823,7 @@ "logtopic1": "0x989e02934facff928d8e788f174ab7d48838c62b07d420a8527cb7eaabdbe91b" }, { - "txhash": "0x4b5bb822f7a362c9e204624b436f342b3abded4c548e19e9a01d36d3493c8a32", + "txhash": "0x2313cd696ec9c6a7b5ad21e9daa106264d9c382c0e3a067529a56d81a4511c96", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x205", "indexInBlock": 0, @@ -1265,7 +831,7 @@ "logtopic1": "0xe891146f52235abb9f53919fc0e41a678d5a8a807a2247177d67539a2bcc3d1a" }, { - "txhash": "0x4a8d2ceec1465c2db3990dabd36c0027303110f516a7b591c01a733ef7e7cbed", + "txhash": "0x602659a646a466a7044b066ece12a8ff17e34c2e6a4ca667bb794933f874e561", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x210", "indexInBlock": 0, @@ -1273,7 +839,7 @@ "logtopic1": "0xab15322a52f3de5dda0553d7abbf171524cabb9c97dacea8806c750361d472df" }, { - "txhash": "0x56a530e9c72cfcf61a6b0d1fe735f3df56792dd25f942baec63e0ccbb2a41a8a", + "txhash": "0xfc39bd0e3451001fe930e70883bb945d8373dd99baa6964973d8aa3ac74a3d34", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x21b", "indexInBlock": 0, @@ -1281,7 +847,7 @@ "logtopic1": "0x6c172610999b0729fbb6bb1ba27e7a0009f1b584ad6f8307d3dcc7d24a180874" }, { - "txhash": "0x4233ea782ca4eb51f939a929af9257a374af873d136c50fac14d2df85564e5d3", + "txhash": "0xb1d7b6a1f9fc6af8bc3fd36d72e4d8682167af0c52dad7c1d63e755ace3afc3d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x226", "indexInBlock": 0, @@ -1289,7 +855,7 @@ "logtopic1": "0xa344ff63ecb6c6cbbd711b06a84844147910ef79a57679958664abf4af9938d3" }, { - "txhash": "0x9f26d7fa9f6598f111b1ff50e143b2579520afa7fd5013544762b1378d2ab4ec", + "txhash": "0x7f1eea64084e269d16f948a767155c7c0111865f58b9e91c3f7cbe30cec180e6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x231", "indexInBlock": 0, @@ -1297,7 +863,7 @@ "logtopic1": "0x88edc52ba848622b1d92e73d2c311c1c83420986c621546fbadac23c3428c570" }, { - "txhash": "0xfb7f1b4cae168e0c7c37155044d0f8907514472726a682ad14dc562cb86ef124", + "txhash": "0xde6513995c2989b0a314800a65da7a5aa3d3bb50215909aafcabce6063ebb69b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x23c", "indexInBlock": 0, @@ -1305,7 +871,7 @@ "logtopic1": "0x7a536b71187079aaf5462b7d483063e3d25cea8e3a6790ebdbb284666fe81068" }, { - "txhash": "0xda8372595a6f7b652d57a878d3de4a14ed4f4ec71a0c465e01ba8bc29c542cd4", + "txhash": "0x1669770dfc06f40ec72b287e27938ff69b1e3055d68ec6e33633da92108ddda0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x247", "indexInBlock": 0, @@ -1313,7 +879,7 @@ "logtopic1": "0xa0c2e429d47e77e9b7c98c1aa4aefb731206f41b64a6587678905a86d14a7d75" }, { - "txhash": "0xdec9676345f2218dcc1eb83512845910541be142c407b8ec119aab5323132dfc", + "txhash": "0x50277d3afe5e049a21cb992cd83e0c069dcc5e5bb97963693fe480cdf48c204e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x252", "indexInBlock": 0, @@ -1321,17 +887,17 @@ "logtopic1": "0x48ca1081e747a7f831228b894dd5fc401d64c6496a2b9e578dd3c59b8f0df2cc" } ], - "tx-emit-legacy": [ + "tx-emit-eip4844": [ { - "txhash": "0x93b1dc3b8982a6c8bd8cecb7d5cf45af27ee28b41daf9c801e51065eb7dc60d4", + "txhash": "0x87630fa02828dad0c04ea8ffa7c5d742bf6aac72b8b0a7e72a28b7d2c0d9fdcb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa", + "block": "0x9", "indexInBlock": 0, "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", - "logtopic1": "0xb8d28e7b703baf999848ecbba44026cb6479b3f0466037bcf2221ffc3f8549f9" + "logtopic1": "0x63cde520fb894276a981d2c9099bef9beb949121c1be98f3abe1b721d880899f" }, { - "txhash": "0x56d2f9f1862cf585c2419e181e919504b73608b705237dde572bd616f1d650a3", + "txhash": "0x75118b029d56f192f458f1a2a38238237f19c11f88eb97e0483ad26e021ae15c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x17", "indexInBlock": 0, @@ -1339,7 +905,7 @@ "logtopic1": "0xa6d01173df2aa437fb0118d181e64a8f8e05713fc01c42fbfd2250516639ae95" }, { - "txhash": "0x86073ac16f561025c7719c0cea52c04a136770717a5d0a9f70e3dcd87efb4e5c", + "txhash": "0x99ba6434209d91a5fc015f2c409877d1d5567287b64c46f984a64d631efa866d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x22", "indexInBlock": 0, @@ -1347,7 +913,7 @@ "logtopic1": "0xe94d0b2545ec05c3ce3431c4d45c3b62fcab156563e8308fae1ebd27a2810c1a" }, { - "txhash": "0xb19203054582d226c20a830e5ae3337d13af37db285d2936f7949eee221dd332", + "txhash": "0x17eced62882b234b280f2382a0225cf218e59de7124bd3d7214fa2da8b766188", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x2d", "indexInBlock": 0, @@ -1355,7 +921,7 @@ "logtopic1": "0x6551251b96ca27f3af8a2c500d6dd1ea5b9ab7002b3d923b66db0493f4a7123e" }, { - "txhash": "0x794c81d1b630164f8bd2b0abb4ff9606598f03e56e5475526b6736b449feee46", + "txhash": "0x7cb0ae261889695ae99b64ea9f6468a493f87b90fccf073761daf15ed4868551", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x38", "indexInBlock": 0, @@ -1363,7 +929,7 @@ "logtopic1": "0xfa29cff134420b6526f434ab690a9c3a140aa27b8479ae3d8d83b6c799acbc23" }, { - "txhash": "0x0fcdbb8b331a37eae304599f5e40496965eba8649cdd28319abe9a5184186285", + "txhash": "0x0e6a717775a24331736f5062466715bdf7a4330466d235a6ffdd746bffdcaf22", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x43", "indexInBlock": 0, @@ -1371,7 +937,7 @@ "logtopic1": "0x412379b7f583981ea6e84408cba75ced69039e07ce9cdaa32a8a9dac997aaafb" }, { - "txhash": "0x6bf0e75233c60170a92dcff17d3906533daf2aecc20a427a3cb6260717103396", + "txhash": "0x153401e45e9053f121b36d88763bec1515553e3762cf5f46f4d125b0700435aa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x4e", "indexInBlock": 0, @@ -1379,7 +945,7 @@ "logtopic1": "0x87dfa85154edde1626e3a09196eab4b60f71887ec7b50ccbbe7ec76c0be6bdff" }, { - "txhash": "0x95a5b38bf61dedf258cbaec502c5e0c09e1e19e90c504dd48af18f9412ea487c", + "txhash": "0x559f888f55e908ab3f4ad9d0d693b4d572ff9ab00058df6465cfe43722b45c6b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x59", "indexInBlock": 0, @@ -1387,7 +953,7 @@ "logtopic1": "0x6e2466f20ef20cb42d216dbf4a0d934199213e9b8d75bedc9c2d3e038a587474" }, { - "txhash": "0x4e6eaacb23cdbedac1a0468927c2b1cdeec1448cbf57936620ccfdd0f75ae91a", + "txhash": "0x154de45bd8bde35c256318cb983131890d97b99689ec175d686cf88742e82fc9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x64", "indexInBlock": 0, @@ -1395,7 +961,7 @@ "logtopic1": "0xd75c9abb1414054ca164bba2f8c09917fb90c24789feaa311ee34a0b3f4a82f0" }, { - "txhash": "0xb83984637e9c41986b59bfc847b7c922363add3a6412024a73357549f27bf4dc", + "txhash": "0x67de1da7ebd65a1f384814112a0ef54c3907e09e18c8a0ddb5630a6883a3c8c5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x6f", "indexInBlock": 0, @@ -1403,7 +969,7 @@ "logtopic1": "0x165e0e0cc13ca53c5af4860637550364c5c90a512906490ace14efb534873741" }, { - "txhash": "0x4f70c780915a9595d214c9c9fc4d96eb7bda3776cd2301f89f831421c13ea768", + "txhash": "0x478293db9f43eec14e4a54b90cb07d6e85e72095f3729d3f80c7e8c33f4b0f19", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x7a", "indexInBlock": 0, @@ -1411,7 +977,7 @@ "logtopic1": "0x16bee816935475cd45501fc5fd01bf913f8ef54330a43d80ef73101a4c728b34" }, { - "txhash": "0x37967eef8dec21d44420c96212a7723608eae9c9df5587b70e3f324a09e0c1bd", + "txhash": "0xd229b870b66a6c5452c88260ef6cc32ffa71363ddbd09340ccda6173af447fc8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x85", "indexInBlock": 0, @@ -1419,7 +985,7 @@ "logtopic1": "0xaf1f0d50933e49dd24b61a24c670809a5b875e3b746862636288dead8579dc4e" }, { - "txhash": "0x15880426a7d1d3df1aa32e7693cb507f8fc69ab9d90e5559eddd9424cdb4f80d", + "txhash": "0xf70f764ffe1e6c2e2770eab2bf0137ece8563607cc3578c8b0e76709105553fd", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x90", "indexInBlock": 0, @@ -1427,7 +993,7 @@ "logtopic1": "0x5b300d53be5798f53b472dadb8966674169ff3e8d08eccb3f065bd827abd7b77" }, { - "txhash": "0xf1aae9cd76d3f95b8796faf9b2d46303421eb3f8bf370b2367a72817d2600eb8", + "txhash": "0xdf9bcc5831652ac45ba42e4128e057379f8c3b6fb6aa602ff2c1e490ede09321", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x9b", "indexInBlock": 0, @@ -1435,7 +1001,7 @@ "logtopic1": "0x970a64830f255bfc38886621b37a7f1a7284bad6c4a04b6a2442ad212e19a6a2" }, { - "txhash": "0x43c353bb6e0361414d7df069730164f8049957afc9376e24fbce3cf8659b8085", + "txhash": "0xadfcdf36179a98c790d47379913a53dd22487dbd7cb1110da530a0b93247d6fc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xa6", "indexInBlock": 0, @@ -1443,7 +1009,7 @@ "logtopic1": "0x611f5b5e5ee263412fed40f169d0727f4e6e1a2bc94caf668d2bcf22cddca8c1" }, { - "txhash": "0xe70aa05480e8ec451e6063031138f83fd569c1b9ec1edd2ce6e5256e7e92965e", + "txhash": "0x89a19e25a99d212f59b3f9aa2767bc896e05ce9d1117fc048ae4fcbcdc83b8d6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xb1", "indexInBlock": 0, @@ -1451,7 +1017,7 @@ "logtopic1": "0x4632fe8e9579f33e2e42e68811d49a09ad1af1f01a68e7ae742f765e8e797ff8" }, { - "txhash": "0x5b7c43d070aea7cb7e9c8daa027e319ebf8662e56701abbedfe2bef07daa9eb1", + "txhash": "0xd20b4075e81e20237b969c5e1859b24ed57dd08e7995dc33ddfaf3d13a5077a3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xbc", "indexInBlock": 0, @@ -1459,7 +1025,7 @@ "logtopic1": "0x205bcc2489f954a3af7a16da4d6042a75fcd6eb69b848c52b3448acb24b23580" }, { - "txhash": "0x6fafd835f52299368f36bcc17c548df55adfa18f26e56847114893b7ce9de699", + "txhash": "0x5836c415ab49b17a68c21b26c484e9a2a7d6ed3ae02d915be819657b2f0d87b5", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xc7", "indexInBlock": 0, @@ -1467,7 +1033,7 @@ "logtopic1": "0x0a2bc3fd72bd3f8bb7f1de9a7dc9e928a7c6a831237124e65c60c25f8348af19" }, { - "txhash": "0xa53506fce1b528bd18d18154b72025ebf9c8297ccd17cc52a94c2bcc03a504c1", + "txhash": "0x002ad9234cb0fe05d594ff3261c0c0aa9834e884b9554dd2e50796bfb43d2115", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xd2", "indexInBlock": 0, @@ -1475,7 +1041,7 @@ "logtopic1": "0x4c3dffb6198347c61671fa1fafd5d80f384ab67a494f5c7bc7428bcb6ca5a445" }, { - "txhash": "0xd21d210873d8178c9ca4b9fd98e3d90e4f6fb00f81d82eb44d6f0c5c2d3b69ac", + "txhash": "0xf31826ea55e1dfd9a0ef79e69c038c18ce2613ab7521dd40278a57f5abe6597c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xdd", "indexInBlock": 0, @@ -1483,7 +1049,7 @@ "logtopic1": "0x8a38792846734575025e5114061b62006064b0636caf6733294eb26895bda2ac" }, { - "txhash": "0x00fe86870f7e16b7b184caef8aafe35112faa784d316c71a1932d2e0eca799fb", + "txhash": "0x8d92d60cb82c87fa52373745142a7aef3a4e61c4ef8263143b72921ded517926", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xe8", "indexInBlock": 0, @@ -1491,7 +1057,7 @@ "logtopic1": "0xe70ed54757ba10a0b95454f6483d3d2e11613828f13d57d50b8a3a98e2c8df1c" }, { - "txhash": "0x182de5a2fa9261eb867b7c233750ec22f6456a9902af2677476fef9747af3d65", + "txhash": "0x8f92d8ff45acea30275dfe8b0db8275ef2788dc98e2e463f95b611c06e42605c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xf3", "indexInBlock": 0, @@ -1499,7 +1065,7 @@ "logtopic1": "0x427b8ffdff6454ea85c8251407144400ed4e693ffb6a74f319e0238c0e72afad" }, { - "txhash": "0x5e8121133745699e0ffdd3cdf62fcce14ad16005c7ec53225df1aac03fc067a7", + "txhash": "0xca302bad2ca8f5faf8b03738527fc4336d676426582ca7325fc8d056223d0800", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xfe", "indexInBlock": 0, @@ -1507,7 +1073,7 @@ "logtopic1": "0x2dd51e8325001014c6845bc5ad51b134ab237f95ab18da55cabc4275b029bf3f" }, { - "txhash": "0x06cf9afd2a64d19c462dff4acb3c32bf9603478d308a5107ae197acf716be505", + "txhash": "0xa96c411f76d0a78fd803b9e54451f18c325516bf7f2425dc13a186087c7cdd6f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x109", "indexInBlock": 0, @@ -1515,7 +1081,7 @@ "logtopic1": "0x321c62425869f150c2cb7f489691c3e5cd49f7cd62d07ecbb7477c4148aaaa0b" }, { - "txhash": "0x0390a326d5615bea72add73e2398cda64b160a4f7980038997006feeb1721d62", + "txhash": "0x5453ca1ac0d4597813a0719201d71fbaf656645760f2e9552963e5ee7bac2713", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x114", "indexInBlock": 0, @@ -1523,7 +1089,7 @@ "logtopic1": "0x1f6ebf3e4d9c96ec86b866137bbec9bbb56d188e7126babfccc6394fdcc6a3d4" }, { - "txhash": "0xaa9089bc7bf3a9fff0ac8c3d8974ebcbbdf24c494c6be9f6dc330700e0c511ac", + "txhash": "0x6865e9e71c92547c91d69f78d48b135cf41025bcb5aed177989683f6b747e660", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x11f", "indexInBlock": 0, @@ -1531,7 +1097,7 @@ "logtopic1": "0x9ebbf91a66183d0d37b03faf46daf8fe238c1aa2b24e6663dc14e50557d432c7" }, { - "txhash": "0xc4740d2ec8cc977d641f18f97c1d789b0a761e0a8057105437acaf8f7e5f33cb", + "txhash": "0xdaf6cde4356d00a862a0c1c651703008413f3ccc4d00f9046fc83c09ecb1ec7c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x12a", "indexInBlock": 0, @@ -1539,7 +1105,7 @@ "logtopic1": "0x94605c950838b2b0b1ce76f58acfb91a94c2aba787d02add7187360989745a4e" }, { - "txhash": "0xaab8e9062dcf651d0bd5fff9cb086ee779f3f91bce1c9a090baba71e0500d696", + "txhash": "0xe72dff0e31241074f1696cfb82a60f4ce97103508edfd854fe2e8e61a694bfa6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x135", "indexInBlock": 0, @@ -1547,7 +1113,7 @@ "logtopic1": "0x3eb32abcff52bfdf0887e9aebaeeaee4a61b76f2fbc9a183c2afc8552d46c3f6" }, { - "txhash": "0xe1fb51da4cd5656875be51625ad129bbaef0a28066ccf1729dc8d4809f636240", + "txhash": "0x140b3630a28806c4e07ade0b9ef16d6c46fb643dfefd197f8732ab6fd1a146ed", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x140", "indexInBlock": 0, @@ -1555,7 +1121,7 @@ "logtopic1": "0xd314fafd686fcd729a24ff511ae5e19248bd6ac6de8c28c79918df72de20e63e" }, { - "txhash": "0xed9806dd032752f6fdd4234b61a6aa6941af207de555aaaac5610b04f4be967f", + "txhash": "0xdb0d10d5fb34e5ccf5b1e3bb0eb7107a0772bbc160430c02c8f9de9f1b58bde2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x14b", "indexInBlock": 0, @@ -1563,7 +1129,7 @@ "logtopic1": "0x951b3b37c2a87b5a67918e750832a50c5565298a35390bad3ffffadb2f7b4afe" }, { - "txhash": "0x66cbbe01979712ff30beed89a5088350249b13ea9d1c162b3d770c4ae98387c0", + "txhash": "0xd7268bce9c920c807d1c5a4bdd9ad35e6229feba835b3a0ffdf1226bd47e4f40", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x156", "indexInBlock": 0, @@ -1571,7 +1137,7 @@ "logtopic1": "0xe067f85eba81feba79bf640415c11ab4448d5cc4a41652fc0a200be4d2661786" }, { - "txhash": "0xfca2d9cd7cf664cc092bc71e1ff0e6ebefb991bd0a83d1a42d2ebb0fd6b5a50f", + "txhash": "0x94018987b14bf2d6796924a52406f3659776f92832953fdd62d44673dd7e817d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x161", "indexInBlock": 0, @@ -1579,7 +1145,7 @@ "logtopic1": "0xd73688caabee79f6ecf3a0b092d26e639b7e486e45c00031db80d3d7abe8c683" }, { - "txhash": "0x576ac317e0aa5ce1268c528945bc17fddb69b3391b22df0db5ef6ac7d3d9eced", + "txhash": "0xe9d9cd83cb08f1dce82791973d9cda526004b154ab7c41c2115af0db4f9c3494", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x16c", "indexInBlock": 0, @@ -1587,7 +1153,7 @@ "logtopic1": "0x945c01f307d13fcdab0a2a3a4c4bd5ebb69a00c3dd59896a959664e01ce10695" }, { - "txhash": "0xed8db5d85b8d9618a7c012715866440ab390b23bacb24885a9638b9d48028faa", + "txhash": "0x9412fef1c0313b43d6bcee24f8fedf864ff075a158b254e1f47250347459935f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x177", "indexInBlock": 0, @@ -1595,7 +1161,7 @@ "logtopic1": "0x3f410a22d042d915c50f9269337a2bc7155f86d79bbff1721d83f44153635ac2" }, { - "txhash": "0x90dd94f9997d05a851a81789518079ba4251ca0c3485083dea817e32df80a2b0", + "txhash": "0xe26d038ae4f3490bd88bffc6dd8c673cec148d00d1332958a94e0155146bd688", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x182", "indexInBlock": 0, @@ -1603,7 +1169,7 @@ "logtopic1": "0x4b85d3d5e4e06787a4e7e6d00f4e2f6d7e0358d9e511177ab584553d4ca06038" }, { - "txhash": "0x019dd8e438d6818397398da44bf836cc9eab53e49fe604be0048bd72d06f7ecf", + "txhash": "0x50f46bf3575161f98d3e823b1e8708627ef2c2705e9fba8b43de84032d791306", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x18d", "indexInBlock": 0, @@ -1611,7 +1177,7 @@ "logtopic1": "0x0c8e91bcf03d65aedba99f4f76d3ff8cd007668948ce12daf4dded4761c7b19d" }, { - "txhash": "0x694c644dd4e60de18a392c912e6c883a9fe177f6995d3ac4b1d0e121ed0b7b2b", + "txhash": "0xbaee8142b7fd3fa6fa047a67ea1d12b9e366bcde62535d93534f32386fda0222", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x198", "indexInBlock": 0, @@ -1619,7 +1185,7 @@ "logtopic1": "0x82a4bb68f7522b711c9f22b00f9c5e050f52cb2bc5f0f50eadcb12a5f1c30839" }, { - "txhash": "0x48578438fdd693c25ed25e30c141ed5db0743f49c55a4d355c774f5da6ba0a12", + "txhash": "0x168c04757e530b0f6a19b88bb769693adc15ac857c48a2aa3fa67dceab97a484", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1a3", "indexInBlock": 0, @@ -1627,7 +1193,7 @@ "logtopic1": "0xce87527a0ad3ddb4d0d57d8077e84d48a6f3810f2a5672143d3b6969b0f86d6e" }, { - "txhash": "0x6daaa691e14a7a4c586ce5f411c60671c793c2ac01710ceae2e36b2cc2631822", + "txhash": "0x95e1fd4c38074c94083bed06f882b6b2f88364de3413f7ab8fd47a57cfe239e3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1ae", "indexInBlock": 0, @@ -1635,7 +1201,7 @@ "logtopic1": "0xe3cb3b98042d005e52e8bbbf49b25e11be63ec7c63ae5a5043e44c545fce633e" }, { - "txhash": "0x7e1ef2e07a223c6ad828353b5052bba8a87b5c5115ba507f4bd22f9e842a499b", + "txhash": "0x59b762afe595324d884387df2e79ac368fe6e8f5a8985c913b7f447459c91b79", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1b9", "indexInBlock": 0, @@ -1643,7 +1209,7 @@ "logtopic1": "0x1fac03facd67f44699ff86330a7f959ed3745add76d323f4832bc17c35be45c9" }, { - "txhash": "0xfee141740da30da512d76b3db294ba34e78a108433fc76054c9d93a6222023d8", + "txhash": "0x1a11fc2d6215e58d2d50ccb49c641e0ff870d7eeb54d7315b4151031bf9cde4f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1c4", "indexInBlock": 0, @@ -1651,7 +1217,7 @@ "logtopic1": "0xe4c7ff156c2f31d046217715d0f193c8a6b3a7af6341d6abe0e28c49d1210638" }, { - "txhash": "0x41f54d93a2f08e78459286b2502954cfa13dc70a18ca7ec73dc1905905544aca", + "txhash": "0xdb923b2884944f8adbf8a4e771e4001de4b8da897191c7aa9a9153338e6d0a78", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1cf", "indexInBlock": 0, @@ -1659,7 +1225,7 @@ "logtopic1": "0x9225354562a563158ba2ce0e86cfeed7fde0ed27c77342aaea09551b9c00ea19" }, { - "txhash": "0x63dfd5f89048de40697cf44e045668ed559be531969a8a1e70d0276e5379335d", + "txhash": "0xf9d3b87c7fc9b4c13eeec16198e8af4ed75c954de57fc5d9a9faf23a6607642b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1da", "indexInBlock": 0, @@ -1667,7 +1233,7 @@ "logtopic1": "0x231eb803c34ec183e74b466c105b5518b554ce215bbc31bfa52c384138b8479a" }, { - "txhash": "0x7244fa2b6a90be34eb69c9c848da7784cff392463f1b4c52307df75bffcf36c8", + "txhash": "0xbc52633dc609189d4ff57b01d62bdb08f9d72ffc41b56948bf14cf6e6d4155f6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1e5", "indexInBlock": 0, @@ -1675,7 +1241,7 @@ "logtopic1": "0x17f29f600f5128013ce183ac10efc609231aff556df37c8f5d6802c1240c22f4" }, { - "txhash": "0x8f31383336ceaa850f701b920f47617acca17664ca5f4c971df87ddd0650ebbd", + "txhash": "0x7faacc820e63e7d98aa1bbf4f06e6b834ea0c09f92cf7f0215b9a362e626dee8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1f0", "indexInBlock": 0, @@ -1683,7 +1249,7 @@ "logtopic1": "0x8405cb4703a08e5160e343c37d42df5f045091f6b22664b0ec3f587df18d2d82" }, { - "txhash": "0xf08771ff65480e0a952226da4d9f994451e971e3acf08185b9442a106ab9c586", + "txhash": "0x44982cdb60b916247d171d4601a276d35fdf2b4609b8f284c9c1a370d8b83f9f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1fb", "indexInBlock": 0, @@ -1691,7 +1257,7 @@ "logtopic1": "0xe865c3418b47b88e94c28956b326a799298fb44c62a7a6bb55fd991f7c0442ca" }, { - "txhash": "0xebec9c429aacd0d3b9a9b0650e3136763b70799015d78d0718a37a56bb840130", + "txhash": "0x98977c7f5978be5e730e77d48d8c6a424d8fc5e2dac8054091fb267d39c7f283", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x206", "indexInBlock": 0, @@ -1699,7 +1265,7 @@ "logtopic1": "0xec200bf1cc6a2c5d58960dc3476cc4794ba1a9fca2ac3d09b63e7811b7299c3d" }, { - "txhash": "0x52edf7a236dd4d81f928a63f9249a8b3d60e09ae1e44801ace03c2f806cf539c", + "txhash": "0x571efdba0d0d1d75f25fee27437772f66e3b5eae7b7360d46cfd10f543a48714", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x211", "indexInBlock": 0, @@ -1707,7 +1273,7 @@ "logtopic1": "0x09b79212fdf6dfcd322d6aabd5ba752b962d7e575cf299112bead28ab955f4c8" }, { - "txhash": "0x08a32aa63fce9746806dc432b63c5059c988cae94575471a64e898dda449209b", + "txhash": "0xb762b9e7af89f7a7798ade8f2bc6445262220ac9938dfcc16a6a6594d1e0db89", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x21c", "indexInBlock": 0, @@ -1715,7 +1281,7 @@ "logtopic1": "0xce285eb20810f2d026bc0b62faf3735df2193835ffd85df244ecc2df24f43b00" }, { - "txhash": "0x160b312c6247f5629ef3557427776e40b11c6da95495086f92bd3e68796ead01", + "txhash": "0xd6145f9061be63bed4d88f14de088ca1ad8e4b928cea570fb529d3ea6321b6e6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x227", "indexInBlock": 0, @@ -1723,7 +1289,7 @@ "logtopic1": "0xf26b2f780c4b92b3f15f1d6e90f7d5a176b58eefea6f0d9cf2f8a0d1f86a139f" }, { - "txhash": "0x112b594c142d35c4888d2ea319c3d2128fa6d485fd127abca1c1fca07c10ad23", + "txhash": "0xbaf1e1bc18bad6d7788791cbc1ae5bb91e2dd4a09c50c999385a8c1835414e35", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x232", "indexInBlock": 0, @@ -1731,7 +1297,7 @@ "logtopic1": "0xab5140d25dce39c42d511dba633cde87b45465d48aa4ec211b27de998abbadfc" }, { - "txhash": "0xcbb68fb40512406853eae3d8378920825b17ba9ed6849ebfb115f21e07803425", + "txhash": "0xcef14bcb034bec993d8d12107db4dbdcf23f730dcf5d42091ce3a1ea6f7ac13c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x23d", "indexInBlock": 0, @@ -1739,7 +1305,7 @@ "logtopic1": "0xc558392238c2d11cdd04a6ae37065f3541a22140500f92c0d8006ff95e8df595" }, { - "txhash": "0x4aa773330bd4bbf6ff2b0754b34ec922c9cc1466702f07aae225637e0bf812b9", + "txhash": "0x3c84318e56935f73527aca010331231b010ad0903bfe8939994ad9680f6d3d25", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x248", "indexInBlock": 0, @@ -1747,7 +1313,7 @@ "logtopic1": "0x69626497767f58c222726a6a3c65050bcfdbb9346f9e5d146ef02bf59275b3d2" }, { - "txhash": "0xe5af8b4f6d6aa91fe8d453312890cf607a28bd49e3f6aa4fa032dd3d8606498b", + "txhash": "0xf654d5f9c472097f745521cdecdd9854b4c4f1e23c7c027121724d67be42cc42", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x253", "indexInBlock": 0, @@ -1755,1300 +1321,1735 @@ "logtopic1": "0xee0b894f33a9643c94e4e2237077260f4191c5bf6bb3c17a2212b86af6f67df4" } ], + "tx-emit-legacy": [ + { + "txhash": "0xc9e729de373f2fcab9ddd36402c047cb117522ef48b25435bd415b9bcf794bb9", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xa", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xb8d28e7b703baf999848ecbba44026cb6479b3f0466037bcf2221ffc3f8549f9" + }, + { + "txhash": "0xfe4c001ff9cbf3338dd712296b718a6467ab734617ca225ce7ce4e3a9547be41", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x18", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x95104e47e1982aba633477f377b1511396c3fe83600224bcb0c78949be705b33" + }, + { + "txhash": "0xffde4e2fd1cd2f5e51e564b08216b9ef80978c586098221cd19f1ee742db1c03", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x23", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x2acfc92a1cc51397c95e434631e449d83a81de91964ed735a8c8b71b35e1a626" + }, + { + "txhash": "0x965195498584dd1a4ee5ae7d60e5bb4dae1254b2ec61023f7b86678d75643201", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x2e", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x5b6618f0def0d634d51118d232eadc26ecbc8d54a7efaa225afc472f0a611c69" + }, + { + "txhash": "0x209a012091e6c869a96f21aee8de7ca44490a593d0f619793b961b2ba4a777b2", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x39", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x349c26db328204bd2527eb45003b0039d5a636f76c8849bca0b34e8fb134f505" + }, + { + "txhash": "0xff76c1915b804a9f4abe17f6564b278ece6cbc1ceca0604856e7f440cbd6d9c8", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x44", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xb66fab7dddd4d16174b227a6f958d7ba2ae8ebc52d763b02c1ff944362755e6e" + }, + { + "txhash": "0x39c37d8cff047f5047fce694f7703b57b08cf414710cd94fc3daea5902330559", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x4f", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x780fa5a814a83baf682b2f170be956308be6ce1bf84ce68ca5f3c59cc41c7c28" + }, + { + "txhash": "0xbac05861c5a87e48448ca240659aca18658a08c7d0b6318690809b0c227470db", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x5a", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x9739ae7192ad23a41778719941582886701a0830589c7ebfc5db094037635d82" + }, + { + "txhash": "0xf24d6d5bd0136dc7a2cf4ce1e2daf6191b415af43dcaf6bf1d43ae69ef2a306c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x65", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xf5acd98a17a3425f113b869e0dd03f82ee696401d2e7f59e8902610150a95a20" + }, + { + "txhash": "0xaf83fcaed15f46e777c9cb54fd6465f00dd6d929c556bd5644ea39fce51be74a", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x70", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x5cd04d660080fb51a0cc8df0d716e1bff4eff98c887cf3274aabe7ec53dc3615" + }, + { + "txhash": "0x7382ad28a6589fcf07195874a36eee8f4c5fa22f3288a1979b374d80e7c6fb88", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x7b", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xf199b2d65bb711d578312320d210574bcc79d63c841d7dcf96ee3604140a7353" + }, + { + "txhash": "0x730f124954d2b20c9ebfdf6715da7192a570450b485ae60c12a102fecd80d21d", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x86", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xe9bc0af4e1917255f83262d4d61622be8b86fcb24a5810c7b592dd6da6861d56" + }, + { + "txhash": "0x69e193cbcc3231501957748043aa48e52b141d0fa38dc6f5027e06790e3088fe", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x91", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x74871a06c400033dfb8aee09db8282719447dc850ca097c5e240f67a2fd7fec2" + }, + { + "txhash": "0x375b37a5a1fc955be827b5782601616fe2c2f420728237644f93f6ba41aa925f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x9c", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x32eac35ea119adcf265e25a03e27234688fd743982f4ea87940a85b601b4243f" + }, + { + "txhash": "0xbec707c5af50adffd736ffad61ec142954a1a0c79b64b7bc7d826417ef746b1d", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xa7", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x6d8f3f1992b15fdc2a757b2b99a8a3721589fc2e31188ab7620ca2884102ece5" + }, + { + "txhash": "0xdea7d229c8331223fc55f26e6db29436721e1d94181fa4aa35ebea2f52250058", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xb2", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x10ed5dd66ac107d9c27405dd97b947d333696bb8749b7a6b0890b449d3bf2238" + }, + { + "txhash": "0x84ac82e58add797c823abd8d3b4f4a20665dc4068f300be3a9459bf2ef456ef7", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xbd", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x8348faa37f759999e3e7d161ca60aeee74b5c55075e626534a26da3aa8962a71" + }, + { + "txhash": "0xe0ca84624d60f1953d23b326950059ef3223e3330bdcea93fac344ec82abc168", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xc8", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x228c9eabdaf185c57233f73fb31db8870dd1d46eef92c3d4c5a5eba1b8f73f00" + }, + { + "txhash": "0x099cb6b36a37892bbb3d51706996a094a1415a6f33212f243865b875b72e2b8e", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xd3", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xee9be26249f0e23118ea14c2c58ab3fc7e42e888edb4b1de6de4a03e0b793b00" + }, + { + "txhash": "0xc2e05a39699ee47ddbce4e95a5340c269f1ee97e5a7548459d31ad6799c0890f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xde", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x18c688de10e38d70bcc478405df715df76bef7c2783e310b391dc958ab5b0901" + }, + { + "txhash": "0x40f57b0347ea5eeea424e89e020452901299918adbba53ac7638f90ff17ca735", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xe9", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x656fd2851f3badaee7500720d14437294b0fcb76990f68895b487132860e635a" + }, + { + "txhash": "0x96a0fe2e43927cf872963c776aa100c66f2113175962fc6086791c32ae2733cb", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xf4", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x70fe2e29e879b5adeef12bf7a782c3fd7815b6fcd3defad6eea94b8fac090e8d" + }, + { + "txhash": "0x74a0161cfd87a7d05de5e037daf133ba5ae70b2a16762e851241223c57747d7b", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xff", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x95eac6698d094a89aa0fbdbe4dfa56a92b928657bfd2a6374fdd5ffadfd8ebe5" + }, + { + "txhash": "0x5ae569d9a62af8934e450e18e1f228f47122ecee5a989786ea8d5026924bb1a5", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x10a", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x24562ede5125f88e7d44659502457e8632f0cd29dd768d7ce337e567830c6b90" + }, + { + "txhash": "0x6ec782b355abd516c6fd977888a21cb7aa40bd801f5fa617d24125c2a64b869d", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x115", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xecb9f805cd314a9aef8cf2c51ccee54704c5cdcb0cf745bd3411c0cfd1bb2381" + }, + { + "txhash": "0x7adbe701b69f8e23d502a523be257949189f1c64796dcb2a196b1a38e0bb9fc0", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x120", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x0e207a83fb16f4e1d86cdb18c78df10f272b8c9dfc773d8c636bf763e5d86ede" + }, + { + "txhash": "0xb906b20d68d3e9eab03429a2138b01a70b3849e38daeffa372bbb2691a65d4da", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x12b", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x1098fa447b36d691c6d8801147ed65b27ab8c9667e089b59f1a1cdbe54cddecb" + }, + { + "txhash": "0xedb1504025eb7f6b7726435ebd218617ad192c7b1c1d91f5fa391e2282fdd888", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x136", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xfef2849e52369d74814504a0592be1651fc3581e54b57283fd34053344624f83" + }, + { + "txhash": "0x18ab4d8f2762ba37f4386d2b2ccb442460fe99bd12bc1e64979008300b1b3524", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x141", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x304f1607803b1445143f85e860e6837543043e4a7ce83fb6c4b98a2b57a5be44" + }, + { + "txhash": "0xeb189808d46e050503dffeb59abb4f6971a926b2ce701d7a6fc2858a62f9d656", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x14c", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x6b5eaf5499e02713812d712b5b5d3ee95e185212f6a71cc9a583a971cd861a4f" + }, + { + "txhash": "0x644010d9403c3e434feae06db0943ee0e382a7a16b3534738ec34608134463c3", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x157", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xf4770d7a56ee02b105688173dbb647939e9168262a4d14b9f6a6efe19b647388" + }, + { + "txhash": "0xf75f7d6ca00fda8215c4f48052b84f6a083b5698d13a627f910e93eeb6dc9bd5", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x162", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xf4c5c0fe94f1f62a752dc2b883078110c5753ac15ab5fe6f425821fb61963118" + }, + { + "txhash": "0xd989970efb8d750e0d5bd61ff5cfbf84aa5fef070d6bcc6f71258471207bb046", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x16d", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x8d866e9225b61c55bb3e8d27f9eed41faec221f3eb1ea322661ce1956885d021" + }, + { + "txhash": "0x16622bce94aaa8e9dfd14e1a3889aee0bf65769454b7c781a2c822bdc2811336", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x178", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x7fffa2c61f6cad00c700b65e33937fcbab57dff84b2e792d81126626970905f1" + }, + { + "txhash": "0xe1c47b77b2b7c5ce5f4d5984ab1279abd3f976603e5d1996b454500bab1e4865", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x183", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x9f569f15edd7832cd57a6cff95e09ab162c23f3dda7e729a74b2f41624294998" + }, + { + "txhash": "0x3a1237cd02dcd1e6e8974ed68da1077dfd2dee6725e8287254e29ad19766d649", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x18e", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x22bc306256606a63c7e6adbfdb53ac8a2579216b16bcdc452de151e042d02124" + }, + { + "txhash": "0xb9d6436537e309c4ba46c1c33a099f7f4f0cbf408d39a8815b343972d104822c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x199", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xef03c0a4bb7099df0152e975b6c3172e7f47225648d2754efc7e81f2d1ed71c4" + }, + { + "txhash": "0x54713a1d1c77ea2e204d386c140d54cf409d8a7290be65251399b02bfc1b6718", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1a4", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x6542b8fc06728a624d10d21d45cb3fc58b811a380547cab3d5bf9e8af0de6951" + }, + { + "txhash": "0x9b50b6ff2a9fdd1fa9b5a016c500bacfcd6472817c916582d1c7f908a792bf42", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1af", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x6760889404c1143da18e9f066f1d68de75c9a16a9d10a280d41864fd7580456f" + }, + { + "txhash": "0x36d9fc6535adfa5bd43b983dbb71f27fe4e224f38ffd753351241951f147cba0", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1ba", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xef429d45b992d9e888f08c3038963cbf4aa2b1e5b209fff23a8299c595430277" + }, + { + "txhash": "0x1f137085055e119cca83f54e757c0db8f19a6781305a2c9348b5fdc2be9668c0", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1c5", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x9a9b2b0f17eb8c44f3d00dc6cd8475e9783cc715b3779af9170ddeed0221bcf2" + }, + { + "txhash": "0xc656c9855aca6fa4ccedde00cd56b2a340391315abee1c18228dcc4e6d482b56", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1d0", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x04050d53dc4e38076a46f473ca2ccad11c6f0357bccc0d1fc7a16e0523892956" + }, + { + "txhash": "0x77a65636b0191f4f3eedd30f15a98a3e6a0132c0496ea87a85932d35971c48bb", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1db", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xbb8f646a16b72f34169bcd82f0c023b582d2ae9f395fb59f9e022e6caacd83a0" + }, + { + "txhash": "0x893aaf0147a55c11d2f3a7316abe881fd6176b170f434d5a8786bae3ccc7b4d1", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1e6", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x304daa529f8e4e88c6c20e572fd04f196d6a32a5a47361118b7f42b4602c44d0" + }, + { + "txhash": "0x3040182f2f5da3ce5e34f51eadeff0200754f66f65e2993047ec7970300f2369", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1f1", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x7e93ec1b055e40d91bd222d7a3d4b0e85d09dfd561b0cd47d09a25fe183a06da" + }, + { + "txhash": "0x98381ec459f4b3df5573e50dbb902bac9822ce2ffb9f5382ee3d46485a6e0700", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1fc", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xbdfccf10ce95236042860c90f84756794940d0d15da20833f8bdc1b921be3efa" + }, + { + "txhash": "0x50f1f26fbf8dad7abcc19a5330645c94410ba61993f68b00d992195a4f9c0d69", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x207", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xd407a81a8c9c2573926ab54ecd5ee3eb6f1853de6b11142313df08897b6842e2" + }, + { + "txhash": "0x8e9a160d98ae1ef12734744cfc7d76fe8c7c9913612ea670cfdf33ecad642fb3", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x212", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x005c4510db462e3bc91da9b8d22c23873a9f44acfaa4c50c91af1d92652e2e34" + }, + { + "txhash": "0xbbbc951661c3d4f863d5e05b77682ee5f2640fd3a33d499ab644c02d677581f0", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x21d", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x2724a489616bca201e7565382948f9832cbb927d030b1d2439c28ba1910c9bc6" + }, + { + "txhash": "0x4b8f8616a8e4c15a532d546db4d61a3cd2f6d850b9f23f87ad6145746c2c660f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x228", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x474ee39f920d2819e9ccf6080e9b95c49fc2dfc9841cb795583b81b7497c0425" + }, + { + "txhash": "0x9c178718bacc5a61736d5659e6130cf16b96a69f0a0d2b1684d70179d4d0eb2d", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x233", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0x67f77810c4968b55b6ae34b927b213ced7c266fba0cf752957a861450bb43a7a" + }, + { + "txhash": "0xf83ffa5e5321a459515c73c3a553c595ecc4cc1048d22391609427debd3f9079", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x23e", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xfc4b6ee72c1b0e13d4d0c218aa48c6233d313507fb55d142e7a2951f0b7c07d5" + }, + { + "txhash": "0xd52afab5788002f90601ef20ee8254a41dadf76832c70da4bb0ee4e6c3cd9e5f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x249", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xff442992eff2fa28cd13c50239c9e15f907488f574ade0e75cdba2cfdb26c480" + }, + { + "txhash": "0x96a373f0a6b2f247ba998c24f9f606e8dc65a39e9fbfd5f9034b4caf0e7dbd69", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x254", + "indexInBlock": 0, + "logtopic0": "0x00000000000000000000000000000000000000000000000000000000656d6974", + "logtopic1": "0xfb0e917bcfc6a3ba3c079d0f19d7f2ede25ac596e725d016e0c31dbc8b390508" + } + ], + "tx-largereceipt": 11, "tx-request-eip7002": { - "txhash": "0x45d9e01d8dc308a89f2911954f518bc0721d7975d5692f6969217a05bc0e23a0", + "txhash": "0x27d8ca12587f28aa0184966fabcbeb321b438a6495d5e8294dc9c62525f41b8c", "block": "0xd" }, "tx-transfer-eip1559": [ { - "txhash": "0xbc83f75c374dc1b4418ef18bf183ed000b3f7c1fca3da045c0f5253eb0177939", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb", - "indexInBlock": 0 - }, - { - "txhash": "0x374ca7fe3bceee86e9b9d9ecb31858eeec3ac7ea7a632e56be943bba4e587fd4", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18", - "indexInBlock": 0 - }, - { - "txhash": "0x9ff78644fb64277ebe7838620b5817a0dbfbaf6b45713b80698628246492cc83", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23", - "indexInBlock": 0 - }, - { - "txhash": "0x7f7b81c472c91ca8c511f29cab406ac201c770fad32270459a79f54d86c52614", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x2e", - "indexInBlock": 0 - }, - { - "txhash": "0x2ab6b266e3072e1ecbb21ae3111da1face60d84b41191287fa0f95971944e888", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x39", - "indexInBlock": 0 - }, - { - "txhash": "0x25b39f052f73a5bac64ba238ce4ffb9770a35dbd835136cb9ac66f4c3ac936de", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x44", - "indexInBlock": 0 - }, - { - "txhash": "0x9de0b20d432dbbe839b178aa91cfa5381bcd84af3603bf48c4494042f716d507", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x4f", - "indexInBlock": 0 - }, - { - "txhash": "0x610925d303403f4e3aca2495a12e5dc1688839b4f256f80dca33dba22ed45e63", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x5a", - "indexInBlock": 0 - }, - { - "txhash": "0x4abe64b41866828e0be88788bae36cb03dcbf85d070807670ccf27160e5a9a4d", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x65", - "indexInBlock": 0 - }, - { - "txhash": "0x39f187a146d61009a03fecd06cb2f4c4b38cd26765905c3362fde02c046c0c85", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x70", - "indexInBlock": 0 - }, - { - "txhash": "0x2f0d711bdc3d0b2f8efecc78a50bef10cad8dbe36a636685df0ce5e77ff2f470", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x7b", - "indexInBlock": 0 - }, - { - "txhash": "0x0131d1b2950a637e2709deaffd487fd6b395485df174fd33dda6650bcf6fd42a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x86", - "indexInBlock": 0 - }, - { - "txhash": "0x7a1a947af6d0713ec475e0e401ac0c30502f9d23a3eec761f40116bd1dc9f0c9", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x91", - "indexInBlock": 0 - }, - { - "txhash": "0xc991b6e9ea27ca67d7b00afb5c3dcb0d9de6d2890d5ce4e3f032d9e7b2cb44ed", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x9c", - "indexInBlock": 0 - }, - { - "txhash": "0xd190fa45214c261223635b2a8c2659b2a142d8f213a470917075ebf2482e0d28", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xa7", - "indexInBlock": 0 - }, - { - "txhash": "0xb4ae0934d6d6775fa216a6f14f638ff0d394bcbfbc97108863a64cf239e0eaab", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xb2", - "indexInBlock": 0 - }, - { - "txhash": "0xe41f1f5bb0c5f4328c608347f2b347ba249793f47395aa57f735d45fbe564463", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xbd", - "indexInBlock": 0 - }, - { - "txhash": "0xff3473cad2636d1688009c27d790172c3f359a12b2c46fae71932cfdd62982c4", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xc8", - "indexInBlock": 0 - }, - { - "txhash": "0xf3892f186643cfa58ecc5a2770c3c06dcdfa06a7701e08e42a8817d7af24093b", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xd3", - "indexInBlock": 0 - }, - { - "txhash": "0x258d7184e3022ec70cef833ae3a66dce9a36e42a7d2dd0d9e5cc14ed1fb5eedf", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xde", - "indexInBlock": 0 - }, - { - "txhash": "0x07fa584efe43c50c1ee8bdca6369841ffa7121576750cb7c08bc251356e80a15", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xe9", - "indexInBlock": 0 - }, - { - "txhash": "0x092365255715c991b48ab31b184ae51f2758c17b2ac1aaf7d1036f105bb333a9", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xf4", - "indexInBlock": 0 - }, - { - "txhash": "0x8034b5908a0204004211f252b06d2f4efd19d276adf6aafbed3de97e5435499f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0xff", - "indexInBlock": 0 - }, - { - "txhash": "0xcb89f9e7e062c3d72798c6cc38f7c4ec26a5fa6d8cf86b33b9859657264d32f7", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x10a", - "indexInBlock": 0 - }, - { - "txhash": "0xd37c021b3d8923723a80a78eaf9840a72f4d89aaccc63c80af112d52434fe886", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x115", - "indexInBlock": 0 - }, - { - "txhash": "0x653da2892fc5b19e542ee54ea44cec8b98c7a6a778a6e15cb4007db8b76ed34d", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x120", - "indexInBlock": 0 - }, - { - "txhash": "0xf0721ceefdbd4ad6518652cb402c0611180101bc655545c973018120484c8d7c", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x12b", - "indexInBlock": 0 - }, - { - "txhash": "0xb79eab5bad9b2b9c51873f53ee7820e99446c6530ac407be032d0bda6cd601a5", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x136", - "indexInBlock": 0 - }, - { - "txhash": "0xb000e7ae9e2b767464fc90d633aff286a663f6aa4c33b27b8649867f403b8848", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x141", - "indexInBlock": 0 - }, - { - "txhash": "0xa79af0ce0ef3d6c97f08ad0519ee84eb102a8611ff9bbfdb513b737582c66a71", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x14c", - "indexInBlock": 0 - }, - { - "txhash": "0xf3b4d8172c990c289f658b6c3ecf980ce627bfe540ea7a9a11cc4708a38d1e0a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x157", - "indexInBlock": 0 - }, - { - "txhash": "0x385cb2c14d85546645d1cbefa13c01bd6b2eb7f848fc132dd33631b3693d0234", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x162", - "indexInBlock": 0 - }, - { - "txhash": "0x2cfecb05aa5dff4016e567291331de567995aef33595892dcc8da9e8626c5e29", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x16d", - "indexInBlock": 0 - }, - { - "txhash": "0x3c551a5bcb06c70c5ed8a024b9c3092d145806ec47c79711e728b776581ba933", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x178", - "indexInBlock": 0 - }, - { - "txhash": "0xf212343a00e92eecaa2882a9028a974cdb53427925ca5e8e514686429783b660", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x183", - "indexInBlock": 0 - }, - { - "txhash": "0x1690ab67922c40b4feba88cb3dadb633142ee6f8e394b61d5ce74efe81aaa7a3", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x18e", - "indexInBlock": 0 - }, - { - "txhash": "0x5051062bb54302b19e2f01987ce412c4026a6eccd8b1224adf89638a893d2ce6", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x199", - "indexInBlock": 0 - }, - { - "txhash": "0x45b3d0b9de23a95ed6af569805c29bbb67e6a70bfa5f5af994b4d134f68b9fbd", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1a4", - "indexInBlock": 0 - }, - { - "txhash": "0xb3446d893246dd626944b802651f051f7e1f52827b8c1b1a1e1b4ab597286726", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1af", - "indexInBlock": 0 - }, - { - "txhash": "0x99d235917c941efc6dc2799623a2b36fc4f5eb2a975952e0a402cd368b2c5c3e", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1ba", - "indexInBlock": 0 - }, - { - "txhash": "0x1841d6e9976ab0bcbc4b00cd67922c026eedd7663122d8f97ad4108f47d70813", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1c5", - "indexInBlock": 0 - }, - { - "txhash": "0x22c29f259f4f88ba7758679ceba786815af37b386f899e91fe0196729acee24d", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1d0", - "indexInBlock": 0 - }, - { - "txhash": "0xa157bad573954d4fab243dbb5fc73435233bd00ce8be8dbcd9f7be80b1d17a49", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1db", - "indexInBlock": 0 - }, - { - "txhash": "0xe0f9de399946816e8a2db32d0738e41d22cce9f444f60824128e5b76ba0e813b", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1e6", - "indexInBlock": 0 - }, - { - "txhash": "0xf78a2067ea28bab199b8d21a42e09553c1bb8e5df791c76f3ebf77f9162e0da3", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1f1", - "indexInBlock": 0 - }, - { - "txhash": "0x754486a577ea77ec5e00664bf0451166b2d5dd9fe42e3b55b9824f78aa628d49", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x1fc", - "indexInBlock": 0 - }, - { - "txhash": "0x5eee12b1b419ef402143847e1940476be871883c16c3a0a7229b817123c2a408", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x207", - "indexInBlock": 0 - }, - { - "txhash": "0x5970e58e6ed36d823ef504f70b1a28acc9433b76284ddf1a3814b3beba37146d", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x212", - "indexInBlock": 0 - }, - { - "txhash": "0xf5166d4fec3e9457916b4079e7526672cf797bcf7824b69a54867aa78e2f2691", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x21d", - "indexInBlock": 0 - }, - { - "txhash": "0x9a1c5ba87f390597ebd00d8ad572fd3c8b95c68910e62644cb055a0ef06e8eeb", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x228", - "indexInBlock": 0 - }, - { - "txhash": "0xef08e643ee3fc351e62c29536758cddb55b8978a71e0fd3ef60fc347d5e6965a", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x233", - "indexInBlock": 0 - }, - { - "txhash": "0x5ffa342f7f5240c5fe829b8e171f0e206b71626337c84e091f08fbc38a64a04f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x23e", - "indexInBlock": 0 - }, - { - "txhash": "0x93c697d79b649351a04237604f19f399b797ca5756ec56c83657f06ceda7f06f", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x249", - "indexInBlock": 0 - }, - { - "txhash": "0xd8d2d00485bb8b861ebfe6cf40ff7244593d92fa9d30f8200542527ced99e37d", - "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "block": "0x254", - "indexInBlock": 0 - } - ], - "tx-transfer-eip2930": [ - { - "txhash": "0xe0b7691cf34a37b87a56a79d2887ebb9e1f132d58b0e34c93e51ac80ae361965", + "txhash": "0x4feb87725c3d45aef205359d7d200f523004b2961282c47736c49e3a453a3ab8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xe", "indexInBlock": 0 }, { - "txhash": "0xe404d773d3dd0560096e006eca641ba5345090871591f3fe7e375e7a430c98c7", + "txhash": "0xf282b242af9a863a650850cd7390dc3b3b485845e6290ee171edffab96a7c6dc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x19", "indexInBlock": 0 }, { - "txhash": "0x0714cd906571480a922fe8d78c1f1061fc40db2cd1ed8cbb4369fda866626a0e", + "txhash": "0xebf2517adcc7342a874af927a17590156aa85059fc903ab1b09f97c34c8b8b4e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x24", "indexInBlock": 0 }, { - "txhash": "0xfe336bb145af0acfb0aaccafd4318827ed629b8dd51c3e9acd799bb8831bc5f7", + "txhash": "0x926f6bb97f760b2ac6c523e975d2697276ee3d881dd8348a4e7b7f2c846da188", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x2f", "indexInBlock": 0 }, { - "txhash": "0x996f4a409ebc40722579170f38948bc8df1aaceddd57fe43799895e989e9037b", + "txhash": "0xef9dea375d62f1406d8777e70192ba24af24044c356da063eb71712eb7499356", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x3a", "indexInBlock": 0 }, { - "txhash": "0x3723f923685f12cc032c922ea5b3bb33c3801e3501fd5c33efe367036068e209", + "txhash": "0x0816a60a0e6fd2afe45e7db877e33d055c3e4549037eb1e5209a21c4018250bb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x45", "indexInBlock": 0 }, { - "txhash": "0x0920572b6c461143bad4fb1c8fce1172555e1e7def25fa332aa4f925b257372e", + "txhash": "0x9720170ff561812f8bc717c251fbc942af99eefb8b5be1296c0dc3b331da7b33", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x50", "indexInBlock": 0 }, { - "txhash": "0x14976ca88889d8e531c3e6e857777514216db60edbc5275e54e07bc1bca12f9d", + "txhash": "0xceda26628e2eecad063f6a4341ea4043fcce307a748b5a41c2a3d0e45721bb0f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x5b", "indexInBlock": 0 }, { - "txhash": "0x27bbf3f736afb8fcaecb7ac3ccc9c213884eeb5fc7eb657954e148231ff3bcb0", + "txhash": "0x0d8c55478b560a6305ea886fbbfcb36441767c65270c9618ceb33b22f2ee4eef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x66", "indexInBlock": 0 }, { - "txhash": "0x9acc4d59b8d8c2266714935b4a6f240f58816db5d957883864be194491038cf0", + "txhash": "0x12b7508b1d9a5f9afb9de821961aca87f93d97849b8a1b5065a0e50cfc2e8a5e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x71", "indexInBlock": 0 }, { - "txhash": "0xe6aa517bcd4b76ad664af114669499b69d4cd4fa9482e12ac17b519d35d040e1", + "txhash": "0xebe88d489dad8695b60b9e8370ce0e389e7cb9e49670980919aac829e2abb83b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x7c", "indexInBlock": 0 }, { - "txhash": "0xc282a609762a7ddd8fbf2202f132e7c6e94c63f05ae94a26833cedeb55f3e7ec", + "txhash": "0xdd63b0ac29f1b5b9911a159e704a148fa190ae321158a23e2910b52b69f810ce", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x87", "indexInBlock": 0 }, { - "txhash": "0xbba59f4b08448ce6e94e457da75e10871594f2fb719b47a94d01354b06db8b4b", + "txhash": "0x9352e3fdb1640ce153b9580ddf310002221ec5bc20d4ae4f9148cb7e2d7d15bc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x92", "indexInBlock": 0 }, { - "txhash": "0x26e0ad605b9338c5f9396bd4da0857e4711b6e67303ab777d2f3e304eeb0198b", + "txhash": "0xff6132e2fb07b0e93bcc88a2eeb025b8e6a24ee6b2b78acb09e8738b3b902c97", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x9d", "indexInBlock": 0 }, { - "txhash": "0x9c2232aba0d6cea846a96d85fff3444cc9a9c2b4063232d1ebbb3b00a5bacda3", + "txhash": "0x8e732995f21ca7456d4e2f2c988990ddbfeb2d0ae968024b1940ee9814b06d2e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xa8", "indexInBlock": 0 }, { - "txhash": "0x1eacd4527bb933ad6054547d9f245ac44e26dbfa11610ed6e835772c6ac8ae48", + "txhash": "0x6bd76373cd2baa3e2f13ff199293fa5cab2b5e3bd7979769b1d79c3612f393bf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xb3", "indexInBlock": 0 }, { - "txhash": "0x38647f25a7e7a05902d512884a52a2733603be1e5f20fe9eeda0e2f2dc6fb89e", + "txhash": "0x33895d27bd9d17d08165eebb010d0c01e87503624147a93f05fcc7f6b39cbc00", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xbe", "indexInBlock": 0 }, { - "txhash": "0x35ba3e88129db4e62c1806e016e731c72b4d202c2ed1664af0d751558e0b2f5f", + "txhash": "0xc48a8664d8ad6a7fce451d9414cdbe341466c42f9c9edcd3c7dbcf3b8afe4fdd", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xc9", "indexInBlock": 0 }, { - "txhash": "0x714288a3625459cfae682e2e053fb9a6366dd0e37e655da8ac8a603b0c2c879b", + "txhash": "0x8e28590eac2c10ac2a12b28d30f1085ee506c4bed98ec70a9866d99051b38f4b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xd4", "indexInBlock": 0 }, { - "txhash": "0x638d97e8a1034faf96ade4fb9ca6abacf25c66ccdfe5824a999cde11eaa3b8ed", + "txhash": "0x22245d80eb9eff7ae730c21743cc4654ca641a3294d1891daafd80aaded914b8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xdf", "indexInBlock": 0 }, { - "txhash": "0xc1382a6685aa78c36e5ed96410da6fdb90549678bd5017ed89412a19ed199f81", + "txhash": "0x8c8365b97fbaac8e4518c70c04dd29512d1b1a036584ebe908ce79d9f18de9cc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xea", "indexInBlock": 0 }, { - "txhash": "0xb446f8fe040ee764827538219e03981d204c329070db7c0a48cd44adeb24db8f", + "txhash": "0x55ffd4fc5e14677b4a26018d48c5a99c8df4e7b797073ada522ada9ca7b30ceb", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xf5", "indexInBlock": 0 }, { - "txhash": "0xa358a78375426e23e7c6662acd42da119b8f87f2e2888adc163a170cd5e826c7", + "txhash": "0x9bc9ad750a0a4365323da3dbacb65c3723ae8564f7a1654a113a527d810ef8e0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x100", "indexInBlock": 0 }, { - "txhash": "0x7a7611969dfd1bde5325f206a97e22c2bc462ff5d2081e71ff89d28777f31c06", + "txhash": "0x1e0effb8659f8e43b7a49a6a926d0b76a352d0a45e86e267b8fbc651ff06a7ac", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x10b", "indexInBlock": 0 }, { - "txhash": "0x457a238e8a1daf3960fc558f8f84033fd33f59fb988b9a9adae36f873ff3c3b4", + "txhash": "0x42faedb8e5b8d6f1433c5d14438cd28eee2080fd7dd375cd574561234aa6ada1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x116", "indexInBlock": 0 }, { - "txhash": "0x4c2d91cbcb732caa6abcbd4140976d0645f6c22d108e477617ee2db2d8129e67", + "txhash": "0xdf64ad606a0975e92909f66625d6a00019e6664a18c67c84ef61ddded0bf0cc3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x121", "indexInBlock": 0 }, { - "txhash": "0x8c9d1f3bb047963383dadc9ff7cb858b97773169532212e283a5695eea9e033f", + "txhash": "0x92219dc27a8c0fb0337c093c2e548a135bc5022a85fc6ccb0e7b2257e8bd2e86", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x12c", "indexInBlock": 0 }, { - "txhash": "0x4c09711bf3edf86842c892fcb260674ec524f014ef5c90f9f3bb23794a8b3956", + "txhash": "0x1242e0eacb6a87f1066df63a9046b9d920b27f2e2d5f808599a4029a36a41e0a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x137", "indexInBlock": 0 }, { - "txhash": "0x31992687ad2485da5c31dfda4dbeeec248a65f5ed003563af394e704dfacfc88", + "txhash": "0xf27431f9cfd98c4b376684550e44b0b8e7c71dc997630f85680e1bc5c18cf3c3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x142", "indexInBlock": 0 }, { - "txhash": "0x661dde8fed4e46c464a33c0f20ee5403250ff3f3c3f99fa55d4307d911b874de", + "txhash": "0xe32fb93c2365ef4db9f3123a474af1fd4837c7bf0e4e0271c166c260b122aa45", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x14d", "indexInBlock": 0 }, { - "txhash": "0x923cb21db498ee179399dfdb8ebca0e0d9822bca94b1127bcd1f11489845e381", + "txhash": "0xa76927c677654a060e2d90cbe4b326fa5eee76d797f54604786849c23879bdee", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x158", "indexInBlock": 0 }, { - "txhash": "0xb72ca20dc96db26fec00f01efa1b251f29bb12a1ceb311bfe8bf39431769221b", + "txhash": "0x35d8f92489a6e1e20f1942193c470e18f4facd5e92b17db55fa311a397aff249", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x163", "indexInBlock": 0 }, { - "txhash": "0xd156edd6076ac206519a5851bdb1ec90a88452c2948ae3fba2be79f1e91dbfe3", + "txhash": "0x3698d4bd1112c7eceb64425a6b7b6a4b142d32c77bce800bd6767ecd10ca80bf", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x16e", "indexInBlock": 0 }, { - "txhash": "0xf1743d554afb4af9f068901f7ad89b3b432d1bd7a88cbfaeab307a020f14e1de", + "txhash": "0xfc7bad28f0e8df37d6a65b3919d9854d2136e247fa4d2d434ae13f47cee60c81", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x179", "indexInBlock": 0 }, { - "txhash": "0x642dd19ff447e4f83c81c529faeaaf07c811215f9fab8967018ec9ff4c9570ef", + "txhash": "0xde78807bcae67a3590b05f888d9d0a80ddea3c2d30bb2ebcc7a7b84de7943543", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x184", "indexInBlock": 0 }, { - "txhash": "0x259e0e9918735fd7786872176cec8a4669e0bfcae37a6ce496023d871407d395", + "txhash": "0x369b86a5664091d43b8bc3bbe4976da5a793a47583ffcca617267817e3ae445b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x18f", "indexInBlock": 0 }, { - "txhash": "0x34fe95d74f6232b0273cdac075cba7ab6438ae662e89aa71e8b99206bfc57153", + "txhash": "0x8eac800c7781a5ada09bfabee12ffdcecf65d517d164f42d1629a9d1eeb9995f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x19a", "indexInBlock": 0 }, { - "txhash": "0xcf826d5d3ccfe1773b5b83a3ec29de8826c92566e310cabf8940733d71ad1cba", + "txhash": "0x7232f8a35c4fc601bde57e96dbd338e6898ae0733b4feefe74610bb44705577e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1a5", "indexInBlock": 0 }, { - "txhash": "0x5a88d1e506f286c57a7a3a6f68cab3b18e9f3ef279b574e6910cca83bdaf7daf", + "txhash": "0x5b9b04078f27faa47f01cb52179b174c5aaa67b1b3ca6776a2872fbe64be4dac", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1b0", "indexInBlock": 0 }, { - "txhash": "0xe383a01e0ad60a5f35cadbe8938a1459a679b7717166a9373512c1a832f24423", + "txhash": "0x25a2cb528f8f5373d2e472d7e28df6b9b18c6d14a5405433aab7333c6d19fe6b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1bb", "indexInBlock": 0 }, { - "txhash": "0x65efb74528143a9b3fcedcb4e94892d25661480613c1485fccc00691c7488c8d", + "txhash": "0x64b5195035210f1570783ab55464becc3bc8f3944f854b1432aa9bf4e5f442e2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1c6", "indexInBlock": 0 }, { - "txhash": "0x54dcbac0ede42273e9b00e78dbc44bd30122cd3b5b17fbf7b8b761bee5de60f7", + "txhash": "0xe898405f30c0ceffd19eb618b30e670cd4f75c3ed6cc3fd7700b40e050d6090f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1d1", "indexInBlock": 0 }, { - "txhash": "0x725e6fdd298ee6d7a0c85da4b86338b179d0e1e2412042302e14e2d1f80fc7c2", + "txhash": "0x1fe3a558cad7acef03cfe28ad0517af33fe5f1bf5d2497e8b9fc1ddf49f6666a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1dc", "indexInBlock": 0 }, { - "txhash": "0x9b4e47130328936b6c1c0b1eba493d17c314f973dfe7e75b42a3db206e504a23", + "txhash": "0x1b1a72cfc78eb9ac22b033028c35bdec7347c40f3120ed9527fbde2966b78c35", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1e7", "indexInBlock": 0 }, { - "txhash": "0xece1d40c8ee54ccb4e80533dc30cc365e44f97f62b66173819bf3d8629b69381", + "txhash": "0x0c41e800e62b889789d63028503a2afdc7b48dfa75f8fac0c8b9dccd73726858", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1f2", "indexInBlock": 0 }, { - "txhash": "0x76a2d9684d03b8e18b262d1d27a0d6b21753b93efd510b3913ce0ebe1767945c", + "txhash": "0x7a7ad517c21c75ebca258a25c35b110f414004f87ecfe2aa29283a8b3815f2d8", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1fd", "indexInBlock": 0 }, { - "txhash": "0x46351b527c01acf613175fc763cd5a2a70e35c38c7c76ee0b6555f787d86c6e2", + "txhash": "0x995502755fff45ae2074c787012c900fdd6dc6264910712bf6b3cb0e25539c66", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x208", "indexInBlock": 0 }, { - "txhash": "0xc954c8d329f749ec212c19a85f38482b2a3970da384441ca205ba09a792ea1f7", + "txhash": "0xe19b59781cfb6a730a22b24f96f6b8a9fcd567a0ea4238b2916affe2a1a131f4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x213", "indexInBlock": 0 }, { - "txhash": "0x96ee75e8ef38f2fdaef65165ea3b03d125558e45a74568479ef47db03aa6c5fc", + "txhash": "0xfdb1b2cb3fcf7c849c5376e1d5765e91cbaeeee0aea7877e1d379522436629c3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x21e", "indexInBlock": 0 }, { - "txhash": "0x2a843d73fc5567275043097afb99799acc38822f63b279d4b1a027fda110968b", + "txhash": "0x8510955c5bc445ab6272fd2e9cb7ecf10bb529d4edf5cb03eed14a86c34ab7e4", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x229", "indexInBlock": 0 }, { - "txhash": "0x32858610393c1bbc5506b9126e2c6be2030c82c93d298fba9c14cc0ada2513d2", + "txhash": "0xd1c580b4cd75f21af59dc7312726122ca905d363982dd6bdc9b16ab459c4f351", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x234", "indexInBlock": 0 }, { - "txhash": "0xccc59651e1e4c4b64d645f6110eb5433ce8848b4bcdd5bd7d628eed653a9b32b", + "txhash": "0x95826c39ecf731f43925e7be0c36d389cd6dd7cba81911a92e33c60c07a1e54f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x23f", "indexInBlock": 0 }, { - "txhash": "0x0f6365dd89c14374995007394ad902ef1b4076160ca7c469a2f40db5143e40fb", + "txhash": "0xa25c1a0867649aca89addff35c96b8beb149f68606e08621b9a391ccef9df0db", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x24a", "indexInBlock": 0 }, { - "txhash": "0x2bdf049c6e42fb2882aa350ae0b1ea17e1cc696505a755f97710a13ab5dd2100", + "txhash": "0x87fb42acce30f67650d3917485de95788ba5002054907b67996498c23e03137c", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x255", "indexInBlock": 0 } ], - "tx-transfer-legacy": [ + "tx-transfer-eip2930": [ { - "txhash": "0xf5d6671f1963c4b2803a03776a06fe6fcc7ebae6fcc714f2ba9abaa6b9c4331c", + "txhash": "0xf278a97c1c92c517531ae9f24179862518cf6397cd3615deebe37049d5a6c695", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xf", "indexInBlock": 0 }, { - "txhash": "0x2c4880155cc7084393750b60732e44dfcc36b5da126d7dafd2e3e679d1fe1456", + "txhash": "0xc33009465ef1eb2ff62d02d50cbaaf73fee9dff8be51f71ac7976367ddfc4541", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1a", "indexInBlock": 0 }, { - "txhash": "0x836d8aef2c4549477e76f9d2250a7818d2659551d4e46d979b3a9c0695824fd5", + "txhash": "0xa6598b072ed0598260358ed568e3c907d36e422b14e35ab459e9e24ae98251ef", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x25", "indexInBlock": 0 }, { - "txhash": "0x4142c689b6edab80bd472c19730a883236279ffa68be403a4e0062d34b095cde", + "txhash": "0x61aa0de65eb4a0db81573b043c35a4de3dcfabf37117a3e67905c7d3038dad23", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x30", "indexInBlock": 0 }, { - "txhash": "0x3d15ef5c40d1abe4006d81bc88a3d7918853099afa1d6ce499747ae49181deb8", + "txhash": "0xdcf01b9729cddeefec7be5348f0d364ee1295831f999c0f5a49b047c9694e970", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x3b", "indexInBlock": 0 }, { - "txhash": "0x36b77745eacf696b87e1cefa6eb7308299c022fd04ca579f67bbf9f88a769670", + "txhash": "0x7867b39e0b2f176fbd61364bce00443bd3f2ca5d743d3ab95104cb13a5cf5208", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x46", "indexInBlock": 0 }, { - "txhash": "0x7bd16c7de942d1dfd8a330d3b4f4388897b88c1e55e29950aaa67ab5d340d63b", + "txhash": "0x2ba84167cbba25e83e98cbca146d39a4a36d29dc2c9d971b41bf5ea1b9c9425a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x51", "indexInBlock": 0 }, { - "txhash": "0x70aa1c05d32af66dadf90df365318ff39bb29204c01e52e7687c2fa03bcd7792", + "txhash": "0x203b1d7997f674fd45fe2eb6af5f0a88b59eaa8598b86f408ca44763e034bd36", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x5c", "indexInBlock": 0 }, { - "txhash": "0x53fb233255b5c3a627afe4bb562c30bcff7c001bbd84118daf5bf7dab3f6b741", + "txhash": "0x8fd08a67b065db1005917aea2934104c6132cad339c2fe07f51e7717bbe4ffe7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x67", "indexInBlock": 0 }, { - "txhash": "0xfd5f8f34059ec5a386048f048022aebe3977b326babac83b34d43f1810aea93c", + "txhash": "0xf0a9ae994a7741fcbe854f2d4a684f5fd434d40badc2ae36611f5764aaeb08b3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x72", "indexInBlock": 0 }, { - "txhash": "0x98e0d4060dbb4451b13a56dfee901f55d212981e156ad9672cb4bc32e95f7744", + "txhash": "0x090fcb3259cccab1bad9dd572493e4ee05df3f53137ca16b4e7ea2f5b5c1d7d3", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x7d", "indexInBlock": 0 }, { - "txhash": "0xdf35c584e51084b3e1ce88e6927f8dfe4b338538026e0119ed44a8a06ee8680f", + "txhash": "0xe79b88caea408e8be7e3ac3269889b8f59fd4c1ca612213b9a7999ffe5b72e52", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x88", "indexInBlock": 0 }, { - "txhash": "0xdd0cdb19583b486fe64aea158301d580605ce93f722e5ed76b6d091ef33cb36b", + "txhash": "0x1bfa25e0530d084489db9ab1b6afa7d9f1c3b39f863adf5e2832768927644daa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x93", "indexInBlock": 0 }, { - "txhash": "0x5fbf81465a08a6fd6c858ba525a6449759ad4dd9772e88aefa7d70b40f59fe94", + "txhash": "0xde483617d2d66c2ad07033b75a73e0c3d9be8e57b614a2aee96eba35f414629d", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x9e", "indexInBlock": 0 }, { - "txhash": "0x0707d1ec61cbc124e3cc6dd2b3617df6d15c247b4513776fbc64d6749e212564", + "txhash": "0x29aeef1bb9f0555427576d10a93920d4cbb848b4df7a11708e1d15877dc1b2e0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xa9", "indexInBlock": 0 }, { - "txhash": "0x15ce9de77512ff529b9493f36c4faa3b287e2f48634f444ebf33db2bb26f019a", + "txhash": "0x00986df4dd53f3e79bfb60d0d6532963c32d14082b90a5e0f781a90521c39926", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xb4", "indexInBlock": 0 }, { - "txhash": "0x81109d5ba61fc6be29b6825aaa3de407d2691364584ec4465853891a1f9a9092", + "txhash": "0x1041875f7d50a26da74163d4e54a7f9c93d314c299725aa85cbfc7a3ecc35297", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xbf", "indexInBlock": 0 }, { - "txhash": "0x741a9b3cb46fb639934e6705950e754a35be54cde90edaa7dc7a7367b964ec1c", + "txhash": "0x79628bf904cf51c4a9746ca13c3f6f55c8cdae638fb2b3166a66d516c4eb5003", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xca", "indexInBlock": 0 }, { - "txhash": "0xc74ac6c61b5fa34bd613863335dc814d646c9670319c6b78c5ff78edd303a148", + "txhash": "0x40094566e6f9bb849004d5f9593bc361c8572fdda9d56f17dae2cda65c6c1e75", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xd5", "indexInBlock": 0 }, { - "txhash": "0x4cb8d6ad80fb3d560e3c99f89a1e6e949706ee34ac60dfee6d3bac5742defeea", + "txhash": "0x36bcaa05763afdbab9ba004c67cfa38fdd5f0fd87164d8ff388720a54ba4a8a1", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xe0", "indexInBlock": 0 }, { - "txhash": "0x43e55b80d307da89ba157e2404b4f74486379b82442d2c439b796d05f0b0cc48", + "txhash": "0xb624d30fb3f252245883434de2ed770b795e907a619ac88992d6b7699b48cfa7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xeb", "indexInBlock": 0 }, { - "txhash": "0x2d78dabdfdf32911d516e48b7630ef0c38d1f23e824a0d206126076ab27ea9de", + "txhash": "0xbd3087ce9745fe988d07ea8ba090b4cb8d1a86e57c50fdcdbb30ecb908dc9e6b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0xf6", "indexInBlock": 0 }, { - "txhash": "0x1b87238c602d7af7240cc63513ffa0ded2851e43587ed3b6a4a9278ebd666f7c", + "txhash": "0xafa45cc36b48bc966aa8aa30e408db455e4f9c1add0587a89ba40a94866d1e03", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x101", "indexInBlock": 0 }, { - "txhash": "0x07796620f21dbc0f24cc465703dec79d4d1ede06e4203229a98ce5a1e3838f97", + "txhash": "0xac35c9970d8166e66a131b1b3dc2f863e7ae36292e6a49bbfcb83f3cdd2ff2d2", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x10c", "indexInBlock": 0 }, { - "txhash": "0xe42627e627add33a75bac9aa36bbafd70ce5c225805c6c38e1cfe4d172d5115c", + "txhash": "0x9b7e08f4c8fa53992950abce073f5eb02f380f451780d0d42de4c69e3a69af23", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x117", "indexInBlock": 0 }, { - "txhash": "0x63a4e7940479d26fe0540ec179765a76ad718016c46f50b091700bc445e94090", + "txhash": "0x3e31801a2a6ea466f490a9b604a116f390794eb63c7ab4721017a5fdf966e166", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x122", "indexInBlock": 0 }, { - "txhash": "0x7069110601d62a25c9f53b0d8014a7a350ef57c49e6f4f065db8dcf2d3df424a", + "txhash": "0x51c1f4e597a9f557a71e97975c0ee80b3036775d922acb96fdcab674023790c7", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x12d", "indexInBlock": 0 }, { - "txhash": "0x908826470714e97daa2f45cca9b77e61fe6187cfd2382cc6855851c3ab6777e6", + "txhash": "0x4e0eec0f6504ef995e5dbf52b0db7c0d4a637b8d4107fd9bb7b9cba124d4e6af", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x138", "indexInBlock": 0 }, { - "txhash": "0xe5e41eee4792cc57e81231553406f05ee5f5d0b1064e93eb113b22a5c67120e1", + "txhash": "0x3dcc58d773206b067dbd8dbc241e12c6cbc22beb64def944ced03490d10c504e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x143", "indexInBlock": 0 }, { - "txhash": "0x502f2197f9a78a84978ad877be0fe29c5c3277895337c7fba7dd2723644763de", + "txhash": "0xbcd88536b680f217c8ba593327153a9a87850c293c7ab51d28e11161a8c114e6", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x14e", "indexInBlock": 0 }, { - "txhash": "0xba56db6e61a61cd1a3aaade35a19f85c614ff0e7afbb7156986118a0dee9af6b", + "txhash": "0xfb4a89e5ad56f40bbd99694669c41784f0dc7b25ec485b07c29d9b8764f6370e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x159", "indexInBlock": 0 }, { - "txhash": "0xc68be8d777be9b31eeffc3daf17761f3a5075875655fe029e82e18cf884b0102", + "txhash": "0x403aa6d501d04dc47e052d9e8e35309047e0e6352bcababbb47d8c3095f2478f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x164", "indexInBlock": 0 }, { - "txhash": "0xcd438fbb83757586be3d83f4d004024f8cbf464f6bf1662671ba4e97177e86b1", + "txhash": "0x2d80b71c714bc3f7fd0c5abce861e0499bf11ab1ac915a4ac399d6046b5341de", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x16f", "indexInBlock": 0 }, { - "txhash": "0x90a4b393275d8a4e40764b90b1820365ae3b0ebd92c14593789618e08fb44b29", + "txhash": "0x8e59e25432ee45eb91663edb66f23e30f8988a94d363bd4211ec8106bc7bdc7a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x17a", "indexInBlock": 0 }, { - "txhash": "0xa82459bb400a4fa392738753dc867627d2ee8436d95e143119505120808bb756", + "txhash": "0x3b17e71cc75e8af270a71446cb1f55dcd2c3c8c638ba7ca3b156713d5c5bc740", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x185", "indexInBlock": 0 }, { - "txhash": "0xba5383efd6209b60452c61ff20f5faf687ddcbb5426b3d202717a3a0f09cc655", + "txhash": "0x62b840b93964bf5ef9f3b308f6cdad7793796a94d6810edd7db64d2d41801b0a", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x190", "indexInBlock": 0 }, { - "txhash": "0xb99807ee84bbedc5e0f04e8bf82400919ffac94c7daa74ce717a9dfcd692dedb", + "txhash": "0xf1c711c41fc04a59b26b14994f625576a7c708302044d5dbe3926bde93505459", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x19b", "indexInBlock": 0 }, { - "txhash": "0x1b50a9075eea2053d04b1149a22ceb5982115642e42a46f8773b1e75132ba334", + "txhash": "0x7f8d63774d886b4d1e8ad70daf38208d3037fbdf875c1180904240308cb290bd", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1a6", "indexInBlock": 0 }, { - "txhash": "0x607ef258fe227a1f5fb6a5bfaa714df94bc22567731591ebf3d2be6435735c85", + "txhash": "0xc2e3e4e30aa8973c6fa6a8ca0fc9d2c77e4e720d72ed0311132c5a9d33dbad49", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1b1", "indexInBlock": 0 }, { - "txhash": "0x6337272ab1f627a38c734a263da2debe7958c2154f6607f880d2d9c76cc70c88", + "txhash": "0x0a92968be399bb163ed87a9e950f87301d1bee7faddd5ee58a966629eccd4d99", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1bc", "indexInBlock": 0 }, { - "txhash": "0xd41f6909931b295eea7c3463a11c979d7174df197110ab3aeb77c16075b0e5be", + "txhash": "0x7f087aea555e2f441682d04c022a63c60dd38129da8196be244618d539b1d899", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1c7", "indexInBlock": 0 }, { - "txhash": "0x5dbc467c60a1655ffc50b47ae6250331a9cdc7818deca6a630e3f00be2fdd419", + "txhash": "0xfcbee8bc75ade3572115835825b2babe4de4e1e3b776323334e4a6e66c4746ae", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1d2", "indexInBlock": 0 }, { - "txhash": "0xad3cdc85f95156f0e6b5cba9228e01db5f4cadea36238ace690321e8150780b7", + "txhash": "0xf50c7c278b5e2bf2a15b523f4a714ab4c3aa2de23e1b45b20fe7df6dfc0d3d1b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1dd", "indexInBlock": 0 }, { - "txhash": "0x0c35c17ae34707eb557bd7e3d6d56a0e3f39841365b4ef46b586131ffd80d93e", + "txhash": "0xca67efa5a92421ffc387fcb06b4f53a14148c1da50f0cc514814587f5f1a63aa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1e8", "indexInBlock": 0 }, { - "txhash": "0x2660c57fca0ca07684524e301982e6ce557d2eef665d60a92c1bbac586b1daa3", + "txhash": "0x2d35008bda6dad6c13a68788a1b0b4b671d82ba03ce007d8026124bc2f78ad4e", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1f3", "indexInBlock": 0 }, { - "txhash": "0x57c142cf1c0eb125de13729a590e4e44dc4b65936068286e4fafa1d144c8548c", + "txhash": "0x6e4b127cec980eaebed4039019171993d63ccf3d8f50792b3b651381391d6a3f", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x1fe", "indexInBlock": 0 }, { - "txhash": "0x4ec028beafac0f493add6acd0e5389d4767f6e756cfbebed4c907312bd990a7b", + "txhash": "0xab711b291a1efce49e0ff8f0aebe8acdc84eae9405b2d70cb4a886854160a1be", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x209", "indexInBlock": 0 }, { - "txhash": "0x92da32c91120e188fd7a7945c1f9632faa33b85b1c2d63e71da6c5e65d2597ef", + "txhash": "0x996878da21de571313c57f2f0dac52d8fc906c4e038bbaa0e5171a46c08dabf9", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x214", "indexInBlock": 0 }, { - "txhash": "0xb31ea80795c9bba23c7509df3148f04d0b6545e29d463e47ebbb59eb19bfc09d", + "txhash": "0xd9743a7901761dce46c57ff8df4d3cdf874e108891ff5661ed7d2a4eaf50b54b", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x21f", "indexInBlock": 0 }, { - "txhash": "0x84ce5e0adc7ecf6da455c89cbb2fb88b19a6530fe3908dc78a3f48e053304bb2", + "txhash": "0x388c9d3c3c9ba4afb738e3a0778166e39f685adcfea23175196f0eee64d173bc", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x22a", "indexInBlock": 0 }, { - "txhash": "0x2660f8cda902bad9c28fe68cc88cd1c8e168ed676b721a1d62ece206520f3ed9", + "txhash": "0xf5df907bbe60656be433813c67a612166b23245e7d83078ae8975835f410d492", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x235", "indexInBlock": 0 }, { - "txhash": "0x9bfb5a154892c511155e70f2897ec9191acc3826d3d94b7f59e14c393f9b82cf", + "txhash": "0xe75a50ed07ea70f57dab38daaa3bfa7e763a4fd4503eb13a77518a10648f7caa", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x240", "indexInBlock": 0 }, { - "txhash": "0x0fbd5dc542001c414af0d21f05c33a425491f56488994d16505c09782cf67076", + "txhash": "0xb01424eaa3df62924ba4d4e52117b89c7ed24a7556c2d46367f908ad41784db0", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x24b", "indexInBlock": 0 }, { - "txhash": "0xbf6d4db691b6c5c6810508476aea4812982794ed5a399fc00c0290dc85901c3f", + "txhash": "0x05fe8649c80459cd462cea4676d39d5be523f672f2a1e5fc210b5b6571b59450", "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", "block": "0x256", "indexInBlock": 0 } ], + "tx-transfer-legacy": [ + { + "txhash": "0x4845dfdee733cb11e204253aa9b2e0a9597c9b7f700642d084fd5aad365dbeff", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x10", + "indexInBlock": 0 + }, + { + "txhash": "0xe4ba4ed6784f2f452274186824174874661f76c1961d34fee86371da194a428f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1b", + "indexInBlock": 0 + }, + { + "txhash": "0xe30c98691cc89f2db31aec5c2b3cdfd720015210fce4b48a8ce561d7f179af8b", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x26", + "indexInBlock": 0 + }, + { + "txhash": "0x7538bb702539b67fbb8d44d2e946d1d241ddc4c2943e48ecb3107c8868184775", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x31", + "indexInBlock": 0 + }, + { + "txhash": "0x88edfa85d3e3bab608081a9421e0eab5fbd09ad10db58c07c178c6ac74617233", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x3c", + "indexInBlock": 0 + }, + { + "txhash": "0x41aec073b267edc44e28b0c33f8c20e7619687ca5d7f09faa30e49621cdd3e70", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x47", + "indexInBlock": 0 + }, + { + "txhash": "0xe0854da80105ea343c29cb7a8db30413b59f5b62a1f42793ce635be4e7536cc9", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x52", + "indexInBlock": 0 + }, + { + "txhash": "0x0cf942350189ee11294379c2a16c9744bc7502f127f4f71ac95cf0a2f681aa3a", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x5d", + "indexInBlock": 0 + }, + { + "txhash": "0xd521a3fccc17113eac1a50bd0a34a3ca87ee5234c51fe41ba8eb8c26ad142363", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x68", + "indexInBlock": 0 + }, + { + "txhash": "0x1bcb6ff54f0f244c3b7390b488e76c3d1d95ff7f340adb81f785820930edc010", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x73", + "indexInBlock": 0 + }, + { + "txhash": "0x7571a5b0881a76054142ad7af3924bd225a67a4705479f4f87e6a68388a5f0aa", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x7e", + "indexInBlock": 0 + }, + { + "txhash": "0x999f17b911d92aaed0c83e37a545cf44f1effaf1245bddc7c63aae3c092e8200", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x89", + "indexInBlock": 0 + }, + { + "txhash": "0xb72b3670cd73b79b8083e590a96c942c0e387c4f0df39eadee69bf0d23c12f8f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x94", + "indexInBlock": 0 + }, + { + "txhash": "0x71d5d38bd1d2af22f3a2bbc6b657b2d1c081a5f7a8345e1aa0c9f7bacfe884a0", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x9f", + "indexInBlock": 0 + }, + { + "txhash": "0x6acdc778a4e9df4318ee1f01bd3dbdad1539cdb53ff865d28827ce21ac9ab9d6", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xaa", + "indexInBlock": 0 + }, + { + "txhash": "0x0303678ee1fa8a6b080ed12b5a752d255008709a9b76e439f48357627d4d8dfe", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xb5", + "indexInBlock": 0 + }, + { + "txhash": "0x2230bdceb24246aee1c7d17a98eccbfefba3079719c6c1e32e8b7d4fc789761d", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xc0", + "indexInBlock": 0 + }, + { + "txhash": "0xab1ad5a65facf07d9687759b529fb8e8a1cb29ac4a5bc8178b58218a11b8b611", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xcb", + "indexInBlock": 0 + }, + { + "txhash": "0xf8d85b2cf1d77a5f513b3158fd49c5fb2b0a11fddad23ddeccfeccfadb3c9e89", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xd6", + "indexInBlock": 0 + }, + { + "txhash": "0xc076e024e047c92e61148b6a6312f704fd3d969febd46f9b41e0106f4bdce366", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xe1", + "indexInBlock": 0 + }, + { + "txhash": "0xfc956eea160fcbbd4a13f4f56f984f245ff189f73512b4807b37e47b0f14096a", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xec", + "indexInBlock": 0 + }, + { + "txhash": "0x37f2c2e41705384ecf88d1bd58520a91614cbcc3a01ee2a9866482c669154d6c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0xf7", + "indexInBlock": 0 + }, + { + "txhash": "0xf13d8d224ceb88804b6f61adbf0067c9f67e8247b2748db8339b597cfdeffaef", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x102", + "indexInBlock": 0 + }, + { + "txhash": "0x370d01c7b49b48f7eaae30826df1b5f702721dab17da55f509e850665671cf3c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x10d", + "indexInBlock": 0 + }, + { + "txhash": "0x3f5065a0ca467127e296ad2d27dc690eaf04d36490c7e7b34231c280fddf1797", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x118", + "indexInBlock": 0 + }, + { + "txhash": "0xc9edbf3ceeb867c3c6d22a70356139fdf595ef3f98ca4c41415e30a374d2da5a", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x123", + "indexInBlock": 0 + }, + { + "txhash": "0x3828637a29c6b96eedc2900ea419f059dde3f8d3399db36cadf89870a2784c0c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x12e", + "indexInBlock": 0 + }, + { + "txhash": "0x477443f1609dd34747aff99d568b3752cd8478f75465c2c09717e69f0cbf089b", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x139", + "indexInBlock": 0 + }, + { + "txhash": "0x5d3c2eb824b0e5fa14dc29635d3b0b17f070ddbbf9c8ce07dd62c212f4af61f6", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x144", + "indexInBlock": 0 + }, + { + "txhash": "0xdbaed77ef32f3a0149d3a220bd0c2c49b6da1b7ef56637442f1b91c916064b0d", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x14f", + "indexInBlock": 0 + }, + { + "txhash": "0xd02a9a5522a418abb75b1330b317c98812c033f7ae8c177355c3836a8a28dc95", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x15a", + "indexInBlock": 0 + }, + { + "txhash": "0x4bca9b38d6eb5008866383961fd1313869a8476fabb260d9b93a5b2dc8986905", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x165", + "indexInBlock": 0 + }, + { + "txhash": "0xeaafeaf48129a32da8973a6190ce0c19b1f3729cc39d3eb55321bd45d3cafacf", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x170", + "indexInBlock": 0 + }, + { + "txhash": "0x85e50638e9e342829033b7f51913edfe86cc1d7691f98ee4f1b725ba20e2a2d2", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x17b", + "indexInBlock": 0 + }, + { + "txhash": "0x7d87678bc9f09d640f401783a67768450e7d19d54ce2deb5fc157fc224be2692", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x186", + "indexInBlock": 0 + }, + { + "txhash": "0x97c821ea0562ce8a74d88a738e7d104f82025952d07e855dca65cd0b46c2d3d5", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x191", + "indexInBlock": 0 + }, + { + "txhash": "0xb6eb23273ff663427676741b12392ee848576225b18baefc308543f209500ca9", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x19c", + "indexInBlock": 0 + }, + { + "txhash": "0x55dbcf25403390d76fab637c2ca501447a93aa371ff36d1316ea2858efbf1aad", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1a7", + "indexInBlock": 0 + }, + { + "txhash": "0xb163de0bcd66c79501165e608cde61312fcfd73d39c2b1970c4d6db2f8ee9595", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1b2", + "indexInBlock": 0 + }, + { + "txhash": "0xf6c6d5abdbb9489d60d66a0a1bf8cbfcd3d06c89cd1bb1aaca5fb0994a5c0e1c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1bd", + "indexInBlock": 0 + }, + { + "txhash": "0xdca0b4a5f20554780d9b2510913cf39498ba3dd98253eddeb292aaab06cb76d1", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1c8", + "indexInBlock": 0 + }, + { + "txhash": "0x198387dacde38e90275dc46370055c1180b6fa458930a20c09b900249ac93417", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1d3", + "indexInBlock": 0 + }, + { + "txhash": "0x39d1f89c9b97905bb44a191b1df7364bbba74cd22634e74faac369419b4f409f", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1de", + "indexInBlock": 0 + }, + { + "txhash": "0xc7aefb93eb98c60bb8badb08df91beb8ba154ef4c076c2b2fb3e68b1668fbb77", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1e9", + "indexInBlock": 0 + }, + { + "txhash": "0xf9b76794a6143a25ee62c9d9e847d7068646dc954357bd4be1872148bd91923b", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1f4", + "indexInBlock": 0 + }, + { + "txhash": "0x3590ade203eb06fa0e509948eecdf53ef176c4792d90d50df070b1d1ca4931dc", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x1ff", + "indexInBlock": 0 + }, + { + "txhash": "0x267c879d60a9e2d6b86e57c6b50933288e1e50299f3cef26379a536a4703577c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x20a", + "indexInBlock": 0 + }, + { + "txhash": "0x6c64b842af6cf82d41bda0f6181369b98d01b096e897299e46a08bddec540f93", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x215", + "indexInBlock": 0 + }, + { + "txhash": "0xd64c4fdda714ae62c0ba6139a59dbfdd8d7a9d1bdd9ffd9ed6bb6fcfa618aaf5", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x220", + "indexInBlock": 0 + }, + { + "txhash": "0x90faef9e382ce09403e51eee1af464cea2c363a5fe3458f03b123b0bf4c69914", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x22b", + "indexInBlock": 0 + }, + { + "txhash": "0x5cdd6add765fbd5afc12c77be220da2d4a81fdbc4f6572977f710d5eadca35ea", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x236", + "indexInBlock": 0 + }, + { + "txhash": "0x0c961395a8d267e7ce4919a810865266d9286f4272bd3504bc7eabeff7562c7c", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x241", + "indexInBlock": 0 + }, + { + "txhash": "0x2bdbc6ce98d07e93505ceb1f524dbc95f1ced213453e35f1b772e8919729f411", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "block": "0x24c", + "indexInBlock": 0 + }, + { + "txhash": "0xf0092cb03bbed01544bfef80adfc92f2842a2be9e89a4f0029c50e9511d704e1", + "sender": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "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", - "amount": "0x64" - } - ] - }, - "159": { - "withdrawals": [ - { - "index": "0xd", - "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", - "amount": "0x64" - } - ] - }, - "16": { - "withdrawals": [ - { - "index": "0x0", - "validatorIndex": "0x5", - "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", - "amount": "0x64" - } - ] - }, - "170": { - "withdrawals": [ - { - "index": "0xe", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } - ] - }, - "181": { - "withdrawals": [ - { - "index": "0xf", - "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", - "amount": "0x64" - } - ] - }, - "192": { - "withdrawals": [ - { - "index": "0x10", - "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", - "amount": "0x64" - } - ] - }, - "203": { - "withdrawals": [ - { - "index": "0x11", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } - ] - }, - "214": { - "withdrawals": [ - { - "index": "0x12", - "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "amount": "0x64" - } - ] - }, - "225": { - "withdrawals": [ - { - "index": "0x13", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } - ] - }, - "236": { - "withdrawals": [ - { - "index": "0x14", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } - ] - }, - "247": { - "withdrawals": [ - { - "index": "0x15", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } - ] - }, - "258": { - "withdrawals": [ - { - "index": "0x16", - "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "amount": "0x64" - } - ] - }, - "269": { - "withdrawals": [ - { - "index": "0x17", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } - ] - }, - "27": { - "withdrawals": [ - { - "index": "0x1", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } - ] - }, - "280": { - "withdrawals": [ - { - "index": "0x18", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } - ] - }, - "291": { - "withdrawals": [ - { - "index": "0x19", - "validatorIndex": "0x5", - "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", - "amount": "0x64" - } - ] - }, - "302": { - "withdrawals": [ - { - "index": "0x1a", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } - ] - }, - "313": { - "withdrawals": [ - { - "index": "0x1b", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } - ] - }, - "324": { - "withdrawals": [ - { - "index": "0x1c", - "validatorIndex": "0x5", - "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", - "amount": "0x64" - } - ] - }, - "335": { - "withdrawals": [ - { - "index": "0x1d", - "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", - "amount": "0x64" - } - ] - }, - "346": { - "withdrawals": [ - { - "index": "0x1e", - "validatorIndex": "0x5", - "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", - "amount": "0x64" - } - ] - }, - "357": { - "withdrawals": [ - { - "index": "0x1f", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } - ] - }, - "368": { - "withdrawals": [ - { - "index": "0x20", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } - ] - }, - "379": { - "withdrawals": [ - { - "index": "0x21", - "validatorIndex": "0x5", "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", "amount": "0x64" } ] }, - "38": { + "160": { "withdrawals": [ { - "index": "0x2", - "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", - "amount": "0x64" - } - ] - }, - "390": { - "withdrawals": [ - { - "index": "0x22", - "validatorIndex": "0x5", - "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", - "amount": "0x64" - } - ] - }, - "401": { - "withdrawals": [ - { - "index": "0x23", + "index": "0xd", "validatorIndex": "0x5", "address": "0x0c2c51a0990aee1d73c1228de158688341557508", "amount": "0x64" } ] }, - "412": { + "17": { + "withdrawals": [ + { + "index": "0x0", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } + ] + }, + "171": { + "withdrawals": [ + { + "index": "0xe", + "validatorIndex": "0x5", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "amount": "0x64" + } + ] + }, + "182": { + "withdrawals": [ + { + "index": "0xf", + "validatorIndex": "0x5", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "amount": "0x64" + } + ] + }, + "193": { + "withdrawals": [ + { + "index": "0x10", + "validatorIndex": "0x5", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "amount": "0x64" + } + ] + }, + "204": { + "withdrawals": [ + { + "index": "0x11", + "validatorIndex": "0x5", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "amount": "0x64" + } + ] + }, + "215": { + "withdrawals": [ + { + "index": "0x12", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } + ] + }, + "226": { + "withdrawals": [ + { + "index": "0x13", + "validatorIndex": "0x5", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", + "amount": "0x64" + } + ] + }, + "237": { + "withdrawals": [ + { + "index": "0x14", + "validatorIndex": "0x5", + "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", + "amount": "0x64" + } + ] + }, + "248": { + "withdrawals": [ + { + "index": "0x15", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } + ] + }, + "259": { + "withdrawals": [ + { + "index": "0x16", + "validatorIndex": "0x5", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "amount": "0x64" + } + ] + }, + "270": { + "withdrawals": [ + { + "index": "0x17", + "validatorIndex": "0x5", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", + "amount": "0x64" + } + ] + }, + "28": { + "withdrawals": [ + { + "index": "0x1", + "validatorIndex": "0x5", + "address": "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c", + "amount": "0x64" + } + ] + }, + "281": { + "withdrawals": [ + { + "index": "0x18", + "validatorIndex": "0x5", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "amount": "0x64" + } + ] + }, + "292": { + "withdrawals": [ + { + "index": "0x19", + "validatorIndex": "0x5", + "address": "0x2d389075be5be9f2246ad654ce152cf05990b209", + "amount": "0x64" + } + ] + }, + "303": { + "withdrawals": [ + { + "index": "0x1a", + "validatorIndex": "0x5", + "address": "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8", + "amount": "0x64" + } + ] + }, + "314": { + "withdrawals": [ + { + "index": "0x1b", + "validatorIndex": "0x5", + "address": "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2", + "amount": "0x64" + } + ] + }, + "325": { + "withdrawals": [ + { + "index": "0x1c", + "validatorIndex": "0x5", + "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", + "amount": "0x64" + } + ] + }, + "336": { + "withdrawals": [ + { + "index": "0x1d", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } + ] + }, + "347": { + "withdrawals": [ + { + "index": "0x1e", + "validatorIndex": "0x5", + "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", + "amount": "0x64" + } + ] + }, + "358": { + "withdrawals": [ + { + "index": "0x1f", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } + ] + }, + "369": { + "withdrawals": [ + { + "index": "0x20", + "validatorIndex": "0x5", + "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", + "amount": "0x64" + } + ] + }, + "380": { + "withdrawals": [ + { + "index": "0x21", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } + ] + }, + "39": { + "withdrawals": [ + { + "index": "0x2", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } + ] + }, + "391": { + "withdrawals": [ + { + "index": "0x22", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } + ] + }, + "402": { + "withdrawals": [ + { + "index": "0x23", + "validatorIndex": "0x5", + "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "amount": "0x64" + } + ] + }, + "413": { "withdrawals": [ { "index": "0x24", @@ -3058,167 +3059,167 @@ } ] }, - "423": { + "424": { "withdrawals": [ { "index": "0x25", "validatorIndex": "0x5", - "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", - "amount": "0x64" - } - ] - }, - "434": { - "withdrawals": [ - { - "index": "0x26", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } - ] - }, - "445": { - "withdrawals": [ - { - "index": "0x27", - "validatorIndex": "0x5", - "address": "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf", - "amount": "0x64" - } - ] - }, - "456": { - "withdrawals": [ - { - "index": "0x28", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } - ] - }, - "467": { - "withdrawals": [ - { - "index": "0x29", - "validatorIndex": "0x5", - "address": "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df", - "amount": "0x64" - } - ] - }, - "478": { - "withdrawals": [ - { - "index": "0x2a", - "validatorIndex": "0x5", - "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", - "amount": "0x64" - } - ] - }, - "489": { - "withdrawals": [ - { - "index": "0x2b", - "validatorIndex": "0x5", - "address": "0x83c7e323d189f18725ac510004fdc2941f8c4a78", - "amount": "0x64" - } - ] - }, - "49": { - "withdrawals": [ - { - "index": "0x3", - "validatorIndex": "0x5", - "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", - "amount": "0x64" - } - ] - }, - "500": { - "withdrawals": [ - { - "index": "0x2c", - "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", - "amount": "0x64" - } - ] - }, - "511": { - "withdrawals": [ - { - "index": "0x2d", - "validatorIndex": "0x5", - "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", - "amount": "0x64" - } - ] - }, - "522": { - "withdrawals": [ - { - "index": "0x2e", - "validatorIndex": "0x5", - "address": "0x0c2c51a0990aee1d73c1228de158688341557508", - "amount": "0x64" - } - ] - }, - "533": { - "withdrawals": [ - { - "index": "0x2f", - "validatorIndex": "0x5", - "address": "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0", - "amount": "0x64" - } - ] - }, - "544": { - "withdrawals": [ - { - "index": "0x30", - "validatorIndex": "0x5", - "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", - "amount": "0x64" - } - ] - }, - "555": { - "withdrawals": [ - { - "index": "0x31", - "validatorIndex": "0x5", "address": "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0", "amount": "0x64" } ] }, - "566": { + "435": { + "withdrawals": [ + { + "index": "0x26", + "validatorIndex": "0x5", + "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "amount": "0x64" + } + ] + }, + "446": { + "withdrawals": [ + { + "index": "0x27", + "validatorIndex": "0x5", + "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", + "amount": "0x64" + } + ] + }, + "457": { + "withdrawals": [ + { + "index": "0x28", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } + ] + }, + "468": { + "withdrawals": [ + { + "index": "0x29", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } + ] + }, + "479": { + "withdrawals": [ + { + "index": "0x2a", + "validatorIndex": "0x5", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "amount": "0x64" + } + ] + }, + "490": { + "withdrawals": [ + { + "index": "0x2b", + "validatorIndex": "0x5", + "address": "0xeda8645ba6948855e3b3cd596bbb07596d59c603", + "amount": "0x64" + } + ] + }, + "50": { + "withdrawals": [ + { + "index": "0x3", + "validatorIndex": "0x5", + "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "amount": "0x64" + } + ] + }, + "501": { + "withdrawals": [ + { + "index": "0x2c", + "validatorIndex": "0x5", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", + "amount": "0x64" + } + ] + }, + "512": { + "withdrawals": [ + { + "index": "0x2d", + "validatorIndex": "0x5", + "address": "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d", + "amount": "0x64" + } + ] + }, + "523": { + "withdrawals": [ + { + "index": "0x2e", + "validatorIndex": "0x5", + "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", + "amount": "0x64" + } + ] + }, + "534": { + "withdrawals": [ + { + "index": "0x2f", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } + ] + }, + "545": { + "withdrawals": [ + { + "index": "0x30", + "validatorIndex": "0x5", + "address": "0x4340ee1b812acb40a1eb561c019c327b243b92df", + "amount": "0x64" + } + ] + }, + "556": { + "withdrawals": [ + { + "index": "0x31", + "validatorIndex": "0x5", + "address": "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c", + "amount": "0x64" + } + ] + }, + "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", - "amount": "0x64" - } - ] - }, - "60": { - "withdrawals": [ - { - "index": "0x4", - "validatorIndex": "0x5", - "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", - "amount": "0x64" - } - ] - }, - "71": { - "withdrawals": [ - { - "index": "0x5", - "validatorIndex": "0x5", - "address": "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e", - "amount": "0x64" - } - ] - }, - "82": { - "withdrawals": [ - { - "index": "0x6", - "validatorIndex": "0x5", "address": "0x717f8aa2b982bee0e29f573d31df288663e1ce16", "amount": "0x64" } ] }, - "93": { + "61": { + "withdrawals": [ + { + "index": "0x4", + "validatorIndex": "0x5", + "address": "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759", + "amount": "0x64" + } + ] + }, + "72": { + "withdrawals": [ + { + "index": "0x5", + "validatorIndex": "0x5", + "address": "0x0c2c51a0990aee1d73c1228de158688341557508", + "amount": "0x64" + } + ] + }, + "83": { + "withdrawals": [ + { + "index": "0x6", + "validatorIndex": "0x5", + "address": "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc", + "amount": "0x64" + } + ] + }, + "94": { "withdrawals": [ { "index": "0x7", "validatorIndex": "0x5", - "address": "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f", + "address": "0x84e75c28348fb86acea1a93a39426d7d60f4cc46", "amount": "0x64" } ] diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go index f113cf3e9f..01a994dbfd 100644 --- a/eth/downloader/downloader_test.go +++ b/eth/downloader/downloader_test.go @@ -259,8 +259,8 @@ 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.ServiceGetReceiptsQuery(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()) // compute hashes diff --git a/eth/downloader/fetchers_concurrent_receipts.go b/eth/downloader/fetchers_concurrent_receipts.go index dbea30e881..74dbc67af3 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 0848e92a26..d20bda69e9 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/skeleton_test.go b/eth/downloader/skeleton_test.go index 8c38e9d0c5..b9e7dba6ee 100644 --- a/eth/downloader/skeleton_test.go +++ b/eth/downloader/skeleton_test.go @@ -208,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") } diff --git a/eth/handler_eth_test.go b/eth/handler_eth_test.go index 68e91fa897..4f74f7672f 100644 --- a/eth/handler_eth_test.go +++ b/eth/handler_eth_test.go @@ -137,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() @@ -168,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() @@ -199,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() @@ -249,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() @@ -305,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() @@ -380,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 fee6bae138..9cd955d29d 100644 --- a/eth/handler_test.go +++ b/eth/handler_test.go @@ -317,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 3f78fb4646..5a01ab32e0 100644 --- a/eth/protocols/eth/dispatcher.go +++ b/eth/protocols/eth/dispatcher.go @@ -214,7 +214,10 @@ loop: continue loop } - pending[req.id] = req + // 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: @@ -227,6 +230,13 @@ loop: } // 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: diff --git a/eth/protocols/eth/handler.go b/eth/protocols/eth/handler.go index aa1c7d45bc..59512f5be7 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 { @@ -173,8 +177,22 @@ var eth69 = map[uint64]msgHandler{ BlockHeadersMsg: handleBlockHeaders, GetBlockBodiesMsg: handleGetBlockBodies, BlockBodiesMsg: handleBlockBodies, - GetReceiptsMsg: handleGetReceipts, - ReceiptsMsg: handleReceipts, + GetReceiptsMsg: handleGetReceipts69, + ReceiptsMsg: handleReceipts69, + GetPooledTransactionsMsg: handleGetPooledTransactions, + PooledTransactionsMsg: handlePooledTransactions, + BlockRangeUpdateMsg: handleBlockRangeUpdate, +} + +var eth70 = map[uint64]msgHandler{ + TransactionsMsg: handleTransactions, + NewPooledTransactionHashesMsg: handleNewPooledTransactionHashes, + GetBlockHeadersMsg: handleGetBlockHeaders, + BlockHeadersMsg: handleBlockHeaders, + GetBlockBodiesMsg: handleGetBlockBodies, + BlockBodiesMsg: handleBlockBodies, + GetReceiptsMsg: handleGetReceipts70, + ReceiptsMsg: handleReceipts70, GetPooledTransactionsMsg: handleGetPooledTransactions, PooledTransactionsMsg: handlePooledTransactions, BlockRangeUpdateMsg: handleBlockRangeUpdate, @@ -194,9 +212,12 @@ func handleMessage(backend Backend, peer *Peer) error { defer msg.Discard() var handlers map[uint64]msgHandler - 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 2e0ce0408b..a45abc90eb 100644 --- a/eth/protocols/eth/handler_test.go +++ b/eth/protocols/eth/handler_test.go @@ -596,11 +596,11 @@ func testGetBlockReceipts(t *testing.T, protocol uint) { } // 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{ + if err := p2p.ExpectMsg(peer.app, ReceiptsMsg, &ReceiptsPacket69{ RequestId: 123, List: receipts, }); err != nil { @@ -608,6 +608,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 } @@ -670,10 +767,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 } diff --git a/eth/protocols/eth/handlers.go b/eth/protocols/eth/handlers.go index 90717472f9..7556df9af2 100644 --- a/eth/protocols/eth/handlers.go +++ b/eth/protocols/eth/handlers.go @@ -246,47 +246,51 @@ func ServiceGetBlockBodiesQuery(chain *core.BlockChain, query GetBlockBodiesRequ return bodies } -func handleGetReceipts(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 := ServiceGetReceiptsQuery(backend.Chain(), query.GetReceiptsRequest) - return peer.ReplyReceiptsRLP(query.RequestId, response) + response := ServiceGetReceiptsQuery69(backend.Chain(), query.GetReceiptsRequest) + return peer.ReplyReceiptsRLP69(query.RequestId, response) } -// ServiceGetReceiptsQuery assembles the response to a receipt query. +func handleGetReceipts70(backend Backend, msg Decoder, peer *Peer) error { + var query GetReceiptsPacket70 + if err := msg.Decode(&query); err != nil { + return err + } + response, lastBlockIncomplete := serviceGetReceiptsQuery70(backend.Chain(), query.GetReceiptsRequest, query.FirstBlockReceiptIndex) + return peer.ReplyReceiptsRLP70(query.RequestId, response, lastBlockIncomplete) +} + +// 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 ServiceGetReceiptsQuery(chain *core.BlockChain, query GetReceiptsRequest) rlp.RawList[*ReceiptList] { - // Gather state data until the fetch or network limits is reached +func ServiceGetReceiptsQuery69(chain *core.BlockChain, query GetReceiptsRequest) rlp.RawList[*ReceiptList] { var ( bytes int receipts rlp.RawList[*ReceiptList] ) for lookups, hash := range query { - if bytes >= softResponseLimit || receipts.Len() >= 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 = blockReceiptsToNetwork(results, body) - if err != nil { - log.Error("Error in block receipts conversion", "hash", hash, "err", err) - continue - } + continue // Can't retrieve the receipts, so we just skip this block. + } + body := chain.GetBodyRLP(hash) + if body == nil { + continue // The block body is missing, we also have to skip. + } + results, _, err := blockReceiptsToNetwork(results, body, receiptQueryParams{}) + if err != nil { + log.Error("Error in block receipts conversion", "hash", hash, "err", err) + continue } receipts.AppendRaw(results) bytes += len(results) @@ -294,6 +298,50 @@ func ServiceGetReceiptsQuery(chain *core.BlockChain, query GetReceiptsRequest) r return receipts } +// 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.RawList[*ReceiptList] + ) + for i, hash := range query { + if bytes >= softResponseLimit || receipts.Len() >= maxReceiptsServe { + break + } + results := chain.GetReceiptsRLP(hash) + if results == nil { + continue // Can't retrieve the receipts, so we just skip this block. + } + body := chain.GetBodyRLP(hash) + if body == nil { + continue // The block body is missing, we also have to skip. + } + q := receiptQueryParams{sizeLimit: uint64(maxPacketSize - bytes)} + if i == 0 { + q.firstIndex = firstBlockReceiptIndex + } + results, incomplete, err := blockReceiptsToNetwork(results, body, q) + if err != nil { + log.Error("Error in block receipts conversion", "hash", hash, "err", err) + continue + } + 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, false +} + func handleBlockHeaders(backend Backend, msg Decoder, peer *Peer) error { // A batch of headers arrived to one of our previous requests res := new(BlockHeadersPacket) @@ -435,9 +483,9 @@ func writeTxForHash(tx []byte, buf *bytes.Buffer) { } } -func handleReceipts(backend Backend, msg Decoder, peer *Peer) error { +func handleReceipts69(backend Backend, msg Decoder, peer *Peer) error { // A batch of receipts arrived to one of our previous requests - res := new(ReceiptsPacket) + res := new(ReceiptsPacket69) if err := msg.Decode(res); err != nil { return err } @@ -452,6 +500,41 @@ func handleReceipts(backend Backend, msg Decoder, peer *Peer) error { 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(receiptLists)) @@ -470,7 +553,7 @@ func handleReceipts(backend Backend, msg Decoder, peer *Peer) error { enc = append(enc, encReceipts) } return peer.dispatchResponse(&Response{ - id: res.RequestId, + id: requestId, code: ReceiptsMsg, Res: &enc, }, metadata) diff --git a/eth/protocols/eth/handshake_test.go b/eth/protocols/eth/handshake_test.go index e2f1e7592a..5746d5896d 100644 --- a/eth/protocols/eth/handshake_test.go +++ b/eth/protocols/eth/handshake_test.go @@ -77,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 3c6d58d670..754fd02be3 100644 --- a/eth/protocols/eth/peer.go +++ b/eth/protocols/eth/peer.go @@ -17,7 +17,10 @@ package eth import ( + "errors" + "fmt" "math/rand" + "sync" "sync/atomic" "time" @@ -26,6 +29,7 @@ import ( "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" ) @@ -43,6 +47,15 @@ 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 @@ -63,28 +76,35 @@ type Peer struct { 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: id, - 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, - 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() @@ -214,14 +234,23 @@ func (p *Peer) ReplyBlockBodiesRLP(id uint64, bodies []rlp.RawValue) error { }) } -// ReplyReceiptsRLP is the response to GetReceipts. -func (p *Peer) ReplyReceiptsRLP(id uint64, receipts rlp.RawList[*ReceiptList]) error { - return p2p.Send(p.rw, ReceiptsMsg, &ReceiptsPacket{ +// 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, + List: receipts, + LastBlockIncomplete: lastBlockIncomplete, + }) +} + // RequestOneHeader is a wrapper around the header query functions to fetch a // single header. It is used solely by the fetcher. func (p *Peer) RequestOneHeader(hash common.Hash, sink chan *Response) (*Request, error) { @@ -330,20 +359,45 @@ 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() - req := &Request{ - id: id, - sink: sink, - code: GetReceiptsMsg, - want: ReceiptsMsg, - numItems: len(hashes), - data: &GetReceiptsPacket{ - RequestId: id, - GetReceiptsRequest: hashes, - }, + 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 @@ -351,6 +405,153 @@ func (p *Peer) RequestReceipts(hashes []common.Hash, sink chan *Response) (*Requ 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: nil, + code: GetReceiptsMsg, + want: ReceiptsMsg, + data: &GetReceiptsPacket70{ + RequestId: id, + FirstBlockReceiptIndex: uint64(lastReceipt), + GetReceiptsRequest: hashes, + }, + numItems: len(hashes), + } + 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 + } + // 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().Trace("Fetching batch of transactions", "count", len(hashes)) diff --git a/eth/protocols/eth/peer_test.go b/eth/protocols/eth/peer_test.go index efbbbc6fff..81b762452e 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 ef65a7d034..0df0776c27 100644 --- a/eth/protocols/eth/protocol.go +++ b/eth/protocols/eth/protocol.go @@ -30,6 +30,7 @@ import ( // Constants to match up protocol versions and messages const ( ETH69 = 69 + ETH70 = 70 ) // ProtocolName is the official short name of the `eth` protocol used during @@ -38,11 +39,11 @@ const ProtocolName = "eth" // ProtocolVersions are the supported versions of the `eth` protocol (first // is primary). -var ProtocolVersions = []uint{ETH69} +var ProtocolVersions = []uint{ETH70, ETH69} // protocolLengths are the number of implemented message corresponding to // different protocol versions. -var protocolLengths = map[uint]uint64{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 @@ -211,22 +212,36 @@ type BlockBody struct { // 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 -// 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 struct { +type ReceiptsPacket69 struct { RequestId uint64 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 diff --git a/eth/protocols/eth/protocol_test.go b/eth/protocols/eth/protocol_test.go index f93d01123b..04c4c0fc06 100644 --- a/eth/protocols/eth/protocol_test.go +++ b/eth/protocols/eth/protocol_test.go @@ -82,11 +82,10 @@ func TestEmptyMessages(t *testing.T) { GetBlockBodiesPacket{1111, nil}, BlockBodiesRLPPacket{1111, nil}, // Receipts - GetReceiptsPacket{1111, nil}, + GetReceiptsPacket69{1111, nil}, // Transactions GetPooledTransactionsPacket{1111, nil}, PooledTransactionsRLPPacket{1111, nil}, - // Headers BlockHeadersPacket{1111, encodeRL([]*types.Header{})}, // Bodies @@ -94,8 +93,8 @@ func TestEmptyMessages(t *testing.T) { BlockBodiesPacket{1111, encodeRL([]BlockBody{})}, BlockBodiesRLPPacket{1111, BlockBodiesRLPResponse([]rlp.RawValue{})}, // Receipts - GetReceiptsPacket{1111, GetReceiptsRequest([]common.Hash{})}, - ReceiptsPacket{1111, encodeRL([]*ReceiptList{})}, + GetReceiptsPacket69{1111, GetReceiptsRequest([]common.Hash{})}, + ReceiptsPacket69{1111, encodeRL([]*ReceiptList{})}, // Transactions GetPooledTransactionsPacket{1111, GetPooledTransactionsRequest([]common.Hash{})}, PooledTransactionsPacket{1111, encodeRL([]*types.Transaction{})}, @@ -220,11 +219,11 @@ func TestMessages(t *testing.T) { common.FromHex("f902dc820457f902d6f902d3f8d2f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afbf901fcf901f9a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008208ae820d0582115c8215b3821a0a827788a00000000000000000000000000000000000000000000000000000000000000000880000000000000000"), }, { - GetReceiptsPacket{1111, GetReceiptsRequest(hashes)}, + GetReceiptsPacket69{1111, GetReceiptsRequest(hashes)}, common.FromHex("f847820457f842a000000000000000000000000000000000000000000000000000000000deadc0dea000000000000000000000000000000000000000000000000000000000feedbeef"), }, { - ReceiptsPacket{1111, encodeRL([]*ReceiptList{NewReceiptList(receipts)})}, + ReceiptsPacket69{1111, encodeRL([]*ReceiptList{NewReceiptList(receipts)})}, common.FromHex("f8da820457f8d5f8d3f866808082014df85ff85d940000000000000000000000000000000000000011f842a0000000000000000000000000000000000000000000000000000000000000deada0000000000000000000000000000000000000000000000000000000000000beef830100fff86901018201bcf862f860940000000000000000000000000000000000000022f842a00000000000000000000000000000000000000000000000000000000000005668a0000000000000000000000000000000000000000000000000000000000000977386020f0f0f0608"), }, { diff --git a/eth/protocols/eth/receipt.go b/eth/protocols/eth/receipt.go index 96e8c4399b..84185bea4a 100644 --- a/eth/protocols/eth/receipt.go +++ b/eth/protocols/eth/receipt.go @@ -202,12 +202,55 @@ func (rl *ReceiptList) Derivable() types.DerivableList { }) } -// blockReceiptsToNetwork takes a slice of rlp-encoded receipts, and transactions, -// and re-encodes them for the network protocol. -func blockReceiptsToNetwork(blockReceipts, blockBody rlp.RawValue) ([]byte, error) { +// 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 0, fmt.Errorf("invalid receipt logs: %v", err) + } + size += uint64(len(logsContent)) + } + return size, nil +} + +type receiptQueryParams struct { + firstIndex uint64 + sizeLimit uint64 +} + +// 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() @@ -219,8 +262,28 @@ func blockReceiptsToNetwork(blockReceipts, blockBody rlp.RawValue) ([]byte, erro ) 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) @@ -228,7 +291,7 @@ func blockReceiptsToNetwork(blockReceipts, blockBody rlp.RawValue) ([]byte, erro } 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 693ccd6918..237f7b9420 100644 --- a/eth/protocols/eth/receipt_test.go +++ b/eth/protocols/eth/receipt_test.go @@ -105,10 +105,13 @@ func TestReceiptList(t *testing.T) { canonBody, _ := rlp.EncodeToBytes(blockBody) // convert from storage encoding to network encoding - network, err := blockReceiptsToNetwork(canonDB, canonBody) + network, incomplete, err := blockReceiptsToNetwork(canonDB, canonBody, receiptQueryParams{}) if err != nil { 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 ReceiptList diff --git a/eth/sync_test.go b/eth/sync_test.go index 77a50bf6d3..e22c495275 100644 --- a/eth/sync_test.go +++ b/eth/sync_test.go @@ -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() diff --git a/rlp/rlpgen/testdata/pkgclash.in.txt b/rlp/rlpgen/testdata/pkgclash.in.txt index 1d407881ce..a8c4092601 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 d119639b99..302f1ec1cd 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 From dc3794e3dc23fc8df9f202a7df7fde0b4604e951 Mon Sep 17 00:00:00 2001 From: Jonny Rhea <5555162+jrhea@users.noreply.github.com> Date: Tue, 31 Mar 2026 02:05:31 -0500 Subject: [PATCH 033/183] core/rawdb: BAL storage layer (#34064) Add persistent storage for Block Access Lists (BALs) in `core/rawdb/`. This provides read/write/delete accessors for BALs in the active key-value store. --------- Co-authored-by: Jared Wasinger Co-authored-by: Gary Rong --- consensus/beacon/consensus.go | 20 +++++-- core/rawdb/accessors_chain.go | 66 +++++++++++++++++++- core/rawdb/accessors_chain_test.go | 77 ++++++++++++++++++++++++ core/rawdb/database.go | 5 ++ core/rawdb/schema.go | 6 ++ core/types/bal/bal_encoding.go | 11 ++-- core/types/bal/bal_test.go | 4 +- core/types/block.go | 30 +++++++++- core/types/gen_header_json.go | 96 ++++++++++++++++-------------- core/types/gen_header_rlp.go | 24 +++++--- 10 files changed, 270 insertions(+), 69 deletions(-) diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go index 25f4f9d2b2..c4a284d485 100644 --- a/consensus/beacon/consensus.go +++ b/consensus/beacon/consensus.go @@ -275,12 +275,22 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa } } + // Verify the existence / non-existence of Amsterdam-specific header fields amsterdam := chain.Config().IsAmsterdam(header.Number, header.Time) - if amsterdam && header.SlotNumber == nil { - return errors.New("header is missing slotNumber") - } - if !amsterdam && header.SlotNumber != nil { - return fmt.Errorf("invalid slotNumber: have %d, expected nil", *header.SlotNumber) + 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 } diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go index 6ae64fb2fd..0582e842c3 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" @@ -605,6 +606,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 +709,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 280fc21e8f..c35f56ee07 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" + "github.com/holiman/uint256" ) // Tests block header storage and retrieval operations. @@ -899,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/database.go b/core/rawdb/database.go index 945fd9097d..39e1a64e5a 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -413,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 @@ -484,6 +485,9 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error { 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: @@ -625,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()}, diff --git a/core/rawdb/schema.go b/core/rawdb/schema.go index d9140c5fd6..54c76143b4 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/types/bal/bal_encoding.go b/core/types/bal/bal_encoding.go index 1b1406ea32..6d52c17c83 100644 --- a/core/types/bal/bal_encoding.go +++ b/core/types/bal/bal_encoding.go @@ -350,9 +350,12 @@ func (e *BlockAccessList) PrettyPrint() 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 := &BlockAccessList{ + Accesses: make([]AccountAccess, 0, len(e.Accesses)), } - return + for _, accountAccess := range e.Accesses { + cpy.Accesses = append(cpy.Accesses, accountAccess.Copy()) + } + return cpy } diff --git a/core/types/bal/bal_test.go b/core/types/bal/bal_test.go index 52c0de825e..58ba639ff0 100644 --- a/core/types/bal/bal_test.go +++ b/core/types/bal/bal_test.go @@ -190,8 +190,8 @@ func makeTestAccountAccess(sort bool) AccountAccess { } } -func makeTestBAL(sort bool) BlockAccessList { - list := BlockAccessList{} +func makeTestBAL(sort bool) *BlockAccessList { + list := &BlockAccessList{} for i := 0; i < 5; i++ { list.Accesses = append(list.Accesses, makeTestAccountAccess(sort)) } diff --git a/core/types/block.go b/core/types/block.go index d092351b58..2d65adeff3 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -30,6 +30,7 @@ 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" ) @@ -99,6 +100,9 @@ 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"` } @@ -204,6 +208,7 @@ type Block struct { uncles []*Header transactions Transactions withdrawals Withdrawals + accessList *bal.BlockAccessList // caches hash atomic.Pointer[common.Hash] @@ -358,9 +363,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 { @@ -513,6 +519,24 @@ func (b *Block) WithBody(body Body) *Block { return 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, + accessList: accessList, + } +} + // Hash returns the keccak256 hash of b's header. // The hash is computed on the first call and cached thereafter. func (b *Block) Hash() common.Hash { diff --git a/core/types/gen_header_json.go b/core/types/gen_header_json.go index 16fb03f612..2e2f1cdca5 100644 --- a/core/types/gen_header_json.go +++ b/core/types/gen_header_json.go @@ -16,29 +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"` - SlotNumber *hexutil.Uint64 `json:"slotNumber" 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 @@ -62,6 +63,7 @@ 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) @@ -70,28 +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"` - SlotNumber *hexutil.Uint64 `json:"slotNumber" 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 { @@ -172,6 +175,9 @@ 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) } diff --git a/core/types/gen_header_rlp.go b/core/types/gen_header_rlp.go index cfbd57ab8a..3b7eb2c926 100644 --- a/core/types/gen_header_rlp.go +++ b/core/types/gen_header_rlp.go @@ -43,8 +43,9 @@ func (obj *Header) EncodeRLP(_w io.Writer) error { _tmp4 := obj.ExcessBlobGas != nil _tmp5 := obj.ParentBeaconRoot != nil _tmp6 := obj.RequestsHash != nil - _tmp7 := obj.SlotNumber != nil - if _tmp1 || _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 { + _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 { @@ -54,42 +55,49 @@ func (obj *Header) EncodeRLP(_w io.Writer) error { w.WriteBigInt(obj.BaseFee) } } - if _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 { + 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 || _tmp7 { + if _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.BlobGasUsed == nil { w.Write([]byte{0x80}) } else { w.WriteUint64((*obj.BlobGasUsed)) } } - if _tmp4 || _tmp5 || _tmp6 || _tmp7 { + if _tmp4 || _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.ExcessBlobGas == nil { w.Write([]byte{0x80}) } else { w.WriteUint64((*obj.ExcessBlobGas)) } } - if _tmp5 || _tmp6 || _tmp7 { + if _tmp5 || _tmp6 || _tmp7 || _tmp8 { if obj.ParentBeaconRoot == nil { w.Write([]byte{0x80}) } else { w.WriteBytes(obj.ParentBeaconRoot[:]) } } - if _tmp6 || _tmp7 { + if _tmp6 || _tmp7 || _tmp8 { if obj.RequestsHash == nil { w.Write([]byte{0x80}) } else { w.WriteBytes(obj.RequestsHash[:]) } } - if _tmp7 { + 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 { From 3da517e239eafdb7839650bd8e4667eb85feb5ba Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Tue, 31 Mar 2026 15:47:07 +0200 Subject: [PATCH 034/183] core/state: fix storage counters in binary trie IntermediateRoot (#34110) Add missing `StorageUpdated` and `StorageDeleted` counter increments in the binary trie fast path of `IntermediateRoot()`. --- core/state/statedb.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/core/state/statedb.go b/core/state/statedb.go index 93dd7d6488..769c8504c2 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -879,10 +879,12 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) 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) } } } From 92b4cb266354076fc9e8cb8b4c77fbac7a42cec4 Mon Sep 17 00:00:00 2001 From: Chase Wright Date: Tue, 31 Mar 2026 09:02:40 -0500 Subject: [PATCH 035/183] eth/tracers/logger: conform structLog tracing to spec (#34093) This is a breaking change in the opcode (structLog) tracer. Several fields will have a slight formatting difference to conform to the newly established spec at: https://github.com/ethereum/execution-apis/pull/762. The differences include: - `memory`: words will have the 0x prefix. Also last word of memory will be padded to 32-bytes. - `storage`: keys and values will have the 0x prefix. --------- Co-authored-by: Sina M <1591639+s1na@users.noreply.github.com> --- eth/api_backend.go | 8 +- eth/api_debug.go | 2 +- eth/state_accessor.go | 26 +++-- eth/tracers/api.go | 50 ++------ eth/tracers/api_test.go | 188 +++++++++++++++++++++++++++++- eth/tracers/logger/logger.go | 17 ++- eth/tracers/logger/logger_test.go | 43 +++++++ 7 files changed, 269 insertions(+), 65 deletions(-) diff --git a/eth/api_backend.go b/eth/api_backend.go index 726d8316a0..fe2105f47b 100644 --- a/eth/api_backend.go +++ b/eth/api_backend.go @@ -484,12 +484,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 b8267902b2..988eb44216 100644 --- a/eth/api_debug.go +++ b/eth/api_debug.go @@ -222,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 } diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 871f2c9269..04aac321cb 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 @@ -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 } @@ -190,10 +194,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 +205,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 +213,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 +227,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,7 +239,7 @@ 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 } diff --git a/eth/tracers/api.go b/eth/tracers/api.go index eed404622e..53a09087e4 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 @@ -522,11 +511,7 @@ 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 } @@ -591,11 +576,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 } @@ -743,11 +724,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 } @@ -877,15 +854,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 +912,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 diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 1d5024ad08..ecf3c99c8f 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -151,7 +151,7 @@ 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) { +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.Root()) 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 } @@ -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 diff --git a/eth/tracers/logger/logger.go b/eth/tracers/logger/logger.go index 67e07f78d0..7f2b2aecf2 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 } diff --git a/eth/tracers/logger/logger_test.go b/eth/tracers/logger/logger_test.go index acc3069e70..554a37aff1 100644 --- a/eth/tracers/logger/logger_test.go +++ b/eth/tracers/logger/logger_test.go @@ -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) + } + }) + } +} From fc43170cdd2a72bfb1e99e72f4e836a2e8036501 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felf=C3=B6ldi=20Zsolt?= Date: Wed, 1 Apr 2026 16:05:57 +0200 Subject: [PATCH 036/183] beacon/light: keep retrying checkpoint init if failed (#33966) This PR changes the blsync checkpoint init logic so that even if the initialization fails with a certain server and an error log message is printed, the server goes back to its initial state and is allowed to retry initialization after the failure delay period. The previous logic had an `ssDone` server state that did put the server in a permanently unusable state once the checkpoint init failed for an apparently permanent reason. This was not the correct behavior because different servers behave differently in case of overload and sometimes the response to a permanently missing item is not clearly distinguishable from an overload response. A safer logic is to never assume anything to be permanent and always give a chance to retry. The failure delay formula is also fixed; now it is properly capped at `maxFailureDelay`. The previous formula did allow the delay to grow unlimited if a retry was attempted immediately after each delay period. --- beacon/light/request/server.go | 5 +---- beacon/light/sync/update_sync.go | 4 ++-- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/beacon/light/request/server.go b/beacon/light/request/server.go index a06dec99ae..d39570b8e5 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/update_sync.go b/beacon/light/sync/update_sync.go index 9549ee5992..d84a3d64da 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") } } From 14a26d9cccb3761b6a2034c30b831c06acb1694f Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Thu, 2 Apr 2026 02:32:17 +0800 Subject: [PATCH 037/183] eth/gasestimator: fix block overrides in estimate gas (#34081) Block overrides were to a great extent ignored by the gasestimator. This PR fixes that. --- eth/gasestimator/gasestimator.go | 29 +++++++++-------------------- internal/ethapi/api.go | 17 +++++++++++------ internal/ethapi/api_test.go | 28 ++++++++++++++++++++++++++-- 3 files changed, 46 insertions(+), 28 deletions(-) diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index 80aeb3d3b2..ad6491fd93 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -27,7 +27,6 @@ import ( "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" ) @@ -38,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,16 +64,7 @@ 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) { + if opts.Config.IsOsaka(opts.Header.Number, opts.Header.Time) { hi = params.MaxTxGas } } @@ -241,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). diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 4f217d0578..694fbf9c15 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -897,6 +897,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) @@ -904,13 +905,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. diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go index 62e9979d3d..b010eeaa08 100644 --- a/internal/ethapi/api_test.go +++ b/internal/ethapi/api_test.go @@ -780,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, @@ -861,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; // @@ -1014,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"), }, }, }, @@ -3795,7 +3819,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"), }, }, } From db6c7d06a2b3d18a17a0a79468fe76a355e78e14 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Thu, 2 Apr 2026 06:21:58 +0800 Subject: [PATCH 038/183] triedb/pathdb: implement history index pruner (#33999) This PR implements the missing functionality for archive nodes by pruning stale index data. The current mechanism is relatively simple but sufficient for now: it periodically iterates over index entries and deletes outdated data on a per-block basis. The pruning process is triggered every 90,000 new blocks (approximately every 12 days), and the iteration typically takes ~30 minutes on a mainnet node. This mechanism is only applied with `gcmode=archive` enabled, having no impact on normal full node. --- triedb/pathdb/disklayer.go | 5 + triedb/pathdb/history_index_pruner.go | 385 +++++++++++++++++++++ triedb/pathdb/history_index_pruner_test.go | 355 +++++++++++++++++++ triedb/pathdb/history_indexer.go | 20 ++ triedb/pathdb/metrics.go | 10 +- 5 files changed, 771 insertions(+), 4 deletions(-) create mode 100644 triedb/pathdb/history_index_pruner.go create mode 100644 triedb/pathdb/history_index_pruner_test.go diff --git a/triedb/pathdb/disklayer.go b/triedb/pathdb/disklayer.go index 5bad19b4f5..50c7279d0e 100644 --- a/triedb/pathdb/disklayer.go +++ b/triedb/pathdb/disklayer.go @@ -408,6 +408,11 @@ func (dl *diskLayer) writeHistory(typ historyType, diff *diffLayer) (bool, error if err != nil { return false, err } + // 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 } diff --git a/triedb/pathdb/history_index_pruner.go b/triedb/pathdb/history_index_pruner.go new file mode 100644 index 0000000000..c9be3618e8 --- /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 0000000000..b3094de3e6 --- /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_indexer.go b/triedb/pathdb/history_indexer.go index c9bf3e87f1..9b215b917f 100644 --- a/triedb/pathdb/history_indexer.go +++ b/triedb/pathdb/history_indexer.go @@ -719,6 +719,7 @@ func (i *indexIniter) recover() bool { // state history. type historyIndexer struct { initer *indexIniter + pruner *indexPruner typ historyType disk ethdb.KeyValueStore freezer ethdb.AncientStore @@ -774,6 +775,7 @@ func newHistoryIndexer(disk ethdb.Database, freezer ethdb.AncientStore, lastHist checkVersion(disk, typ) return &historyIndexer{ initer: newIndexIniter(disk, freezer, typ, lastHistoryID, noWait), + pruner: newIndexPruner(disk, typ), typ: typ, disk: disk, freezer: freezer, @@ -782,6 +784,7 @@ func newHistoryIndexer(disk ethdb.Database, freezer ethdb.AncientStore, lastHist func (i *historyIndexer) close() { i.initer.close() + i.pruner.close() } // inited returns a flag indicating whether the existing state histories @@ -802,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 @@ -819,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/metrics.go b/triedb/pathdb/metrics.go index a0a626f9b5..e01dfdfb86 100644 --- a/triedb/pathdb/metrics.go +++ b/triedb/pathdb/metrics.go @@ -77,10 +77,12 @@ var ( 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) From bcb0efd756b00112422a50919d2a00810ad662ad Mon Sep 17 00:00:00 2001 From: cui Date: Thu, 2 Apr 2026 20:40:45 +0800 Subject: [PATCH 039/183] core/types: copy block access list hash in CopyHeader (#34636) --- core/types/block.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/types/block.go b/core/types/block.go index 2d65adeff3..60c83c9db1 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -325,6 +325,10 @@ 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 From 0ba4314321c3f36b2cc82e71afcb3b77115c257b Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Fri, 3 Apr 2026 10:35:32 +0800 Subject: [PATCH 040/183] core/state: introduce state iterator interface (#33102) In this PR, the Database interface in `core/state` has been extended with one more function: ```go // 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) ``` With this additional abstraction layer, the implementation details can be hidden behind the interface. For example, state traversal can now operate directly on the flat state for Verkle or binary trees, which do not natively support traversal. Moreover, state dumping will now prefer using the flat state iterator as the primary option, offering better efficiency. Edit: this PR also fixes a tiny issue in the state dump, marshalling the next field in the correct way. --- core/state/database.go | 13 +- core/state/database_history.go | 12 +- core/state/database_iterator.go | 435 +++++++++++++++++++++++++++ core/state/database_iterator_test.go | 262 ++++++++++++++++ core/state/dump.go | 65 ++-- core/state/statedb.go | 98 ++---- core/state/statedb_test.go | 4 +- eth/api_debug.go | 2 + 8 files changed, 763 insertions(+), 128 deletions(-) create mode 100644 core/state/database_iterator.go create mode 100644 core/state/database_iterator_test.go diff --git a/core/state/database.go b/core/state/database.go index 002ce57fbc..c603e3ad7a 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -39,6 +39,10 @@ type Database interface { // 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) @@ -48,9 +52,6 @@ type Database interface { // 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. @@ -310,6 +311,12 @@ func (db *CachingDB) Commit(update *stateUpdate) error { return db.triedb.Update(update.root, update.originRoot, update.blockNumber, update.nodes, update.stateSet()) } +// Iteratee returns a state iteratee associated with the specified state root, +// through which the account iterator and storage iterator can be created. +func (db *CachingDB) Iteratee(root common.Hash) (Iteratee, error) { + return newStateIteratee(!db.triedb.IsVerkle(), root, db.triedb, db.snap) +} + // mustCopyTrie returns a deep-copied trie. func mustCopyTrie(t Trie) Trie { switch t := t.(type) { diff --git a/core/state/database_history.go b/core/state/database_history.go index c25c4eae4b..0dbb8cc546 100644 --- a/core/state/database_history.go +++ b/core/state/database_history.go @@ -22,7 +22,6 @@ import ( "sync" "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/crypto" "github.com/ethereum/go-ethereum/rlp" @@ -289,14 +288,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 0000000000..8fad66a1e8 --- /dev/null +++ b/core/state/database_iterator.go @@ -0,0 +1,435 @@ +// 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/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 RLP encoded account the iterator is currently at. + // An error will be retained if the iterator becomes invalid. + Account() []byte +} + +// 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() []byte +} + +// 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 { + if ai.err != nil { + return ai.err + } + return 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() []byte { + data, err := types.FullAccountRLP(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 { + 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 { + 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 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() []byte { + return si.it.Slot() +} + +// 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 + 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 { + 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 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() []byte { + if !ti.account { + return nil + } + return ti.it.Value +} + +// 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() []byte { + if ti.account { + return nil + } + return ti.it.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() []byte { + return nil +} diff --git a/core/state/database_iterator_test.go b/core/state/database_iterator_test.go new file mode 100644 index 0000000000..87819e5526 --- /dev/null +++ b/core/state/database_iterator_test.go @@ -0,0 +1,262 @@ +// 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/rlp" + "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 != nil { + 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. + blob := acctIt.Account() + if blob == nil { + t.Fatalf("(%s) nil account at %x", scheme, hash) + } + var decoded types.StateAccount + if err := rlp.DecodeBytes(blob, &decoded); err != nil { + t.Fatalf("(%s) bad RLP at %x: %v", scheme, hash, err) + } + acc := addrByHash[hash] + if decoded.Nonce != acc.nonce { + t.Fatalf("(%s) nonce %x: got %d, want %d", scheme, hash, decoded.Nonce, acc.nonce) + } + if decoded.Balance.Cmp(acc.balance) != 0 { + t.Fatalf("(%s) balance %x: got %v, want %v", scheme, hash, decoded.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() == nil { + 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/dump.go b/core/state/dump.go index 829d106ed3..71138143d9 100644 --- a/core/state/dump.go +++ b/core/state/dump.go @@ -27,7 +27,6 @@ import ( "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 +44,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 +65,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,9 +115,6 @@ 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) { // Sanitize the input to allow nil configs if conf == nil { @@ -131,20 +129,23 @@ 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 } - 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 } - it := trie.NewIterator(trieIt) + defer acctIt.Release() - for it.Next() { + for acctIt.Next() { var data types.StateAccount - if err := rlp.DecodeBytes(it.Value, &data); err != nil { + if err := rlp.DecodeBytes(acctIt.Account(), &data); err != nil { panic(err) } var ( @@ -153,63 +154,55 @@ 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) + storageIt, err := iteratee.NewStorageIterator(acctIt.Hash(), common.Hash{}) if err != nil { log.Error("Failed to load storage trie", "err", err) continue } - trieIt, err := storageTr.NodeIterator(nil) - if err != nil { - log.Error("Failed to create trie iterator", "err", err) - continue - } - storageIt := trie.NewIterator(trieIt) for storageIt.Next() { - _, content, _, err := rlp.Split(storageIt.Value) + _, content, _, err := rlp.Split(storageIt.Slot()) if err != nil { log.Error("Failed to decode the value returned by iterator", "error", err) continue } - 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(content) } + 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,9 +210,7 @@ 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))) - + log.Info("Trie dumping complete", "accounts", accounts, "elapsed", common.PrettyDuration(time.Since(start))) return nextKey } diff --git a/core/state/statedb.go b/core/state/statedb.go index 769c8504c2..854aaf6109 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -28,7 +28,6 @@ import ( "time" "github.com/ethereum/go-ethereum/common" - "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" @@ -1039,31 +1038,32 @@ 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{}) - if err != nil { - return nil, nil, nil, err - } - defer iter.Release() - +// 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][]byte, map[common.Hash][]byte, *trienode.NodeSet, error) { 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 ) + 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 it.Release() + 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 := common.CopyBytes(it.Slot()) + if err := it.Error(); err != nil { // error might occur after Slot function return nil, nil, nil, err } - key := iter.Hash() + key := it.Hash() storages[key] = nil storageOrigins[key] = slot @@ -1071,7 +1071,7 @@ func (s *StateDB) fastDeleteStorage(snaps *snapshot.Tree, addrHash common.Hash, return nil, nil, nil, err } } - if err := iter.Error(); err != nil { // error might occur during iteration + if err := it.Error(); err != nil { // error might occur during iteration return nil, nil, nil, err } if stack.Hash() != root { @@ -1080,68 +1080,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: @@ -1192,7 +1130,7 @@ func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*acco 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) } diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index 8d1f93ca1b..d29b262eea 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -1296,12 +1296,12 @@ func TestDeleteStorage(t *testing.T) { 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) } diff --git a/eth/api_debug.go b/eth/api_debug.go index 988eb44216..5dd535e672 100644 --- a/eth/api_debug.go +++ b/eth/api_debug.go @@ -236,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 { From 00da4f51fffbbfaf2a9b962ba2324629d5f0c45f Mon Sep 17 00:00:00 2001 From: Jonny Rhea <5555162+jrhea@users.noreply.github.com> Date: Fri, 3 Apr 2026 01:10:32 -0500 Subject: [PATCH 041/183] core, eth/protocols/snap: Snap/2 Protocol + BAL Serving (#34083) Implement the snap/2 wire protocol with BAL serving --------- Co-authored-by: Gary Rong --- core/blockchain_reader.go | 8 + eth/downloader/downloader_test.go | 2 +- eth/protocols/eth/handler.go | 1 - eth/protocols/snap/handler.go | 571 ++------------------ eth/protocols/snap/handler_fuzzing_test.go | 6 + eth/protocols/snap/handler_test.go | 195 +++++++ eth/protocols/snap/handlers.go | 593 +++++++++++++++++++++ eth/protocols/snap/protocol.go | 25 +- 8 files changed, 874 insertions(+), 527 deletions(-) create mode 100644 eth/protocols/snap/handler_test.go create mode 100644 eth/protocols/snap/handlers.go diff --git a/core/blockchain_reader.go b/core/blockchain_reader.go index f1b40d0d0c..8b026680d2 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 { diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go index 01a994dbfd..9280d455fb 100644 --- a/eth/downloader/downloader_test.go +++ b/eth/downloader/downloader_test.go @@ -370,7 +370,7 @@ func (dlp *downloadTesterPeer) RequestTrieNodes(id uint64, root common.Hash, cou 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 } diff --git a/eth/protocols/eth/handler.go b/eth/protocols/eth/handler.go index 59512f5be7..f7d25bd8ca 100644 --- a/eth/protocols/eth/handler.go +++ b/eth/protocols/eth/handler.go @@ -167,7 +167,6 @@ 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 eth69 = map[uint64]msgHandler{ diff --git a/eth/protocols/snap/handler.go b/eth/protocols/snap/handler.go index 071a0419fb..26545f2960 100644 --- a/eth/protocols/snap/handler.go +++ b/eth/protocols/snap/handler.go @@ -17,25 +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/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" ) const ( @@ -55,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. @@ -123,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. @@ -136,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) { @@ -149,520 +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: - 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: - 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}) - - case msg.Code == GetStorageRangesMsg: - 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: - 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}) - - case msg.Code == GetByteCodesMsg: - 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: - 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}) - - case msg.Code == GetTrieNodesMsg: - 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: - 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}) - - default: - return fmt.Errorf("%w: %v", errInvalidMsgCode, msg.Code) + if handler := handlers[msg.Code]; handler != nil { + return handler(backend, msg, peer) } -} - -// 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 ( - 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 nextBytes(it *rlp.Iterator) []byte { - if !it.Next() { - return nil - } - content, _, err := rlp.SplitString(it.Value()) - if err != nil { - return nil - } - return content + 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 4930ae9ae6..a52da0aac5 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 0000000000..cb4b378a8d --- /dev/null +++ b/eth/protocols/snap/handler_test.go @@ -0,0 +1,195 @@ +// 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" + "testing" + "time" + + "github.com/ethereum/go-ethereum/common" + "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/params" + "github.com/ethereum/go-ethereum/rlp" +) + +// 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.TestChainConfig, + } + db := rawdb.NewMemoryDatabase() + _, blocks, _ := core.GenerateChainWithGenesis(gspec, ethash.NewFaker(), nBlocks, func(i int, gen *core.BlockGen) {}) + options := &core.BlockChainConfig{ + TrieCleanLimit: 0, + TrieDirtyLimit: 0, + TrieTimeLimit: 5 * time.Minute, + NoPrefetch: true, + SnapshotLimit: 0, + } + bc, err := core.NewBlockChain(db, gspec, ethash.NewFaker(), options) + if err != nil { + panic(err) + } + if _, err := bc.InsertChain(blocks); err != nil { + panic(err) + } + + // Store BALs for each block + var hashes []common.Hash + var bals []rlp.RawValue + for _, block := range blocks { + hash := block.Hash() + number := block.NumberU64() + bal := make(rlp.RawValue, balSize) + + // Fill with data based on block number + for j := range bal { + bal[j] = byte(number + uint64(j)) + } + rawdb.WriteAccessListRLP(db, hash, number, bal) + hashes = append(hashes, hash) + bals = append(bals, bal) + } + 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, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Verify the results + if len(result) != len(hashes) { + t.Fatalf("expected %d results, got %d", len(hashes), len(result)) + } + for i, bal := range result { + if !bytes.Equal(bal, bals[i]) { + t.Errorf("BAL %d mismatch: got %x, want %x", i, bal, bals[i]) + } + } +} + +// 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, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Verify length + if len(result) != len(mixed) { + t.Fatalf("expected %d results, got %d", len(mixed), len(result)) + } + + // Check positional correspondence + if !bytes.Equal(result[0], bals[0]) { + t.Errorf("index 0: expected known BAL, got %x", result[0]) + } + if result[1] != nil { + t.Errorf("index 1: expected nil for unknown hash, got %x", result[1]) + } + if !bytes.Equal(result[2], bals[1]) { + t.Errorf("index 2: expected known BAL, got %x", result[2]) + } + if result[3] != nil { + t.Errorf("index 3: expected nil for unknown hash, got %x", result[3]) + } + if !bytes.Equal(result[4], bals[2]) { + t.Errorf("index 4: expected known BAL, got %x", result[4]) + } +} + +// 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, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Can't get more than maxAccessListLookups results + if len(result) > maxAccessListLookups { + t.Fatalf("expected at most %d results, got %d", maxAccessListLookups, len(result)) + } +} + +// 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, + } + result := ServiceGetAccessListsQuery(bc, req) + + // Should have stopped before returning all blocks + if len(result) >= nBlocks { + t.Fatalf("expected fewer than %d results due to byte limit, got %d", nBlocks, len(result)) + } + + // Should have returned at least one + if len(result) == 0 { + t.Fatal("expected at least one result") + } + + // The total size should exceed the limit (the entry that crosses it is included) + var total uint64 + for _, bal := range result { + total += uint64(len(bal)) + } + if total <= softResponseLimit { + t.Errorf("total response size %d should exceed soft limit %d (includes one entry past limit)", total, softResponseLimit) + } +} diff --git a/eth/protocols/snap/handlers.go b/eth/protocols/snap/handlers.go new file mode 100644 index 0000000000..64522343f9 --- /dev/null +++ b/eth/protocols/snap/handlers.go @@ -0,0 +1,593 @@ +// 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) + } + bals := ServiceGetAccessListsQuery(backend.Chain(), &req) + return p2p.Send(peer.rw, AccessListsMsg, &AccessListsPacket{ + ID: req.ID, + AccessLists: bals, + }) +} + +// 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.RawValue { + // Cap the number of lookups + if len(req.Hashes) > maxAccessListLookups { + req.Hashes = req.Hashes[:maxAccessListLookups] + } + var ( + bals []rlp.RawValue + bytes uint64 + ) + for _, hash := range req.Hashes { + if bal := chain.GetAccessListRLP(hash); len(bal) > 0 { + bals = append(bals, bal) + bytes += uint64(len(bal)) + } else { + // Either the block is unknown or the BAL doesn't exist + bals = append(bals, nil) + } + if bytes > softResponseLimit { + break + } + } + return bals +} diff --git a/eth/protocols/snap/protocol.go b/eth/protocols/snap/protocol.go index 25fe25822b..57b29bbe36 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 ( @@ -215,6 +218,20 @@ type TrieNodesPacket struct { 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 +} + +// 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.RawValue // Requested BALs +} + func (*GetAccountRangePacket) Name() string { return "GetAccountRange" } func (*GetAccountRangePacket) Kind() byte { return GetAccountRangeMsg } @@ -238,3 +255,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 } From a608ac94ecdae126f90372cbfb5ff88528b35ffa Mon Sep 17 00:00:00 2001 From: Jonny Rhea <5555162+jrhea@users.noreply.github.com> Date: Sat, 4 Apr 2026 07:53:54 -0500 Subject: [PATCH 042/183] eth/protocols/snap: restore Bytes soft limit to GetAccessListsPacket (#34649) This PR adds Bytes field back to GetAccesListsPacket --- eth/protocols/snap/handler_test.go | 4 ++++ eth/protocols/snap/handlers.go | 5 ++++- eth/protocols/snap/protocol.go | 1 + 3 files changed, 9 insertions(+), 1 deletion(-) diff --git a/eth/protocols/snap/handler_test.go b/eth/protocols/snap/handler_test.go index cb4b378a8d..53b22ca7f7 100644 --- a/eth/protocols/snap/handler_test.go +++ b/eth/protocols/snap/handler_test.go @@ -80,6 +80,7 @@ func TestServiceGetAccessListsQuery(t *testing.T) { req := &GetAccessListsPacket{ ID: 1, Hashes: hashes, + Bytes: softResponseLimit, } result := ServiceGetAccessListsQuery(bc, req) @@ -105,6 +106,7 @@ func TestServiceGetAccessListsQueryEmpty(t *testing.T) { req := &GetAccessListsPacket{ ID: 2, Hashes: mixed, + Bytes: softResponseLimit, } result := ServiceGetAccessListsQuery(bc, req) @@ -147,6 +149,7 @@ func TestServiceGetAccessListsQueryCap(t *testing.T) { req := &GetAccessListsPacket{ ID: 3, Hashes: hashes, + Bytes: softResponseLimit, } result := ServiceGetAccessListsQuery(bc, req) @@ -171,6 +174,7 @@ func TestServiceGetAccessListsQueryByteLimit(t *testing.T) { req := &GetAccessListsPacket{ ID: 0, Hashes: hashes, + Bytes: softResponseLimit, } result := ServiceGetAccessListsQuery(bc, req) diff --git a/eth/protocols/snap/handlers.go b/eth/protocols/snap/handlers.go index 64522343f9..4d60aab1f6 100644 --- a/eth/protocols/snap/handlers.go +++ b/eth/protocols/snap/handlers.go @@ -569,6 +569,9 @@ func handleGetAccessLists(backend Backend, msg Decoder, peer *Peer) error { // 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.RawValue { + if req.Bytes > softResponseLimit { + req.Bytes = softResponseLimit + } // Cap the number of lookups if len(req.Hashes) > maxAccessListLookups { req.Hashes = req.Hashes[:maxAccessListLookups] @@ -585,7 +588,7 @@ func ServiceGetAccessListsQuery(chain *core.BlockChain, req *GetAccessListsPacke // Either the block is unknown or the BAL doesn't exist bals = append(bals, nil) } - if bytes > softResponseLimit { + if bytes > req.Bytes { break } } diff --git a/eth/protocols/snap/protocol.go b/eth/protocols/snap/protocol.go index 57b29bbe36..7913f8b053 100644 --- a/eth/protocols/snap/protocol.go +++ b/eth/protocols/snap/protocol.go @@ -222,6 +222,7 @@ type TrieNodesPacket struct { 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. From d8cb8a962b2de18cac5f2b6a820a3dea5d33db0e Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Sat, 4 Apr 2026 21:00:07 +0800 Subject: [PATCH 043/183] core, eth, ethclient, triedb: report trienode index progress (#34633) The trienode history indexing progress is also exposed via an RPC endpoint and contributes to the eth_syncing status. --- core/blockchain_reader.go | 2 +- eth/api_backend.go | 5 +++-- eth/downloader/api.go | 5 +++-- ethclient/ethclient.go | 2 ++ graphql/graphql.go | 3 +++ interfaces.go | 7 ++++--- internal/ethapi/api.go | 1 + triedb/database.go | 4 ++-- triedb/pathdb/database.go | 23 +++++++++++++++++++---- triedb/pathdb/database_test.go | 4 ++-- 10 files changed, 40 insertions(+), 16 deletions(-) diff --git a/core/blockchain_reader.go b/core/blockchain_reader.go index 8b026680d2..3614702d1a 100644 --- a/core/blockchain_reader.go +++ b/core/blockchain_reader.go @@ -476,7 +476,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() } diff --git a/eth/api_backend.go b/eth/api_backend.go index fe2105f47b..a4e976b1b8 100644 --- a/eth/api_backend.go +++ b/eth/api_backend.go @@ -414,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 } diff --git a/eth/downloader/api.go b/eth/downloader/api.go index f97371de5f..1fea35775e 100644 --- a/eth/downloader/api.go +++ b/eth/downloader/api.go @@ -81,9 +81,10 @@ 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 } diff --git a/ethclient/ethclient.go b/ethclient/ethclient.go index bc4eaad6fa..85286ec919 100644 --- a/ethclient/ethclient.go +++ b/ethclient/ethclient.go @@ -838,6 +838,7 @@ type rpcProgress struct { TxIndexFinishedBlocks hexutil.Uint64 TxIndexRemainingBlocks hexutil.Uint64 StateIndexRemaining hexutil.Uint64 + TrienodeIndexRemaining hexutil.Uint64 } func (p *rpcProgress) toSyncProgress() *ethereum.SyncProgress { @@ -865,6 +866,7 @@ func (p *rpcProgress) toSyncProgress() *ethereum.SyncProgress { TxIndexFinishedBlocks: uint64(p.TxIndexFinishedBlocks), TxIndexRemainingBlocks: uint64(p.TxIndexRemainingBlocks), StateIndexRemaining: uint64(p.StateIndexRemaining), + TrienodeIndexRemaining: uint64(p.TrienodeIndexRemaining), } } diff --git a/graphql/graphql.go b/graphql/graphql.go index f25bfd127a..dadc91fac0 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -1531,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 21d42c6d34..8b3dbe3a42 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/ethapi/api.go b/internal/ethapi/api.go index 694fbf9c15..149e12c5b8 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -180,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 } diff --git a/triedb/database.go b/triedb/database.go index e7e47bb91a..c1abe93462 100644 --- a/triedb/database.go +++ b/triedb/database.go @@ -367,10 +367,10 @@ 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() } diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go index 86a42c69f4..a61d302b1d 100644 --- a/triedb/pathdb/database.go +++ b/triedb/pathdb/database.go @@ -626,11 +626,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 } - return db.stateIndexer.progress() + if db.trienodeIndexer != nil { + prog, err := db.trienodeIndexer.progress() + if err != nil { + return 0, 0, err + } + trieProgress = prog + } + 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 8ece83cad7..e70a3ec2a2 100644 --- a/triedb/pathdb/database_test.go +++ b/triedb/pathdb/database_test.go @@ -987,7 +987,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) } @@ -1001,7 +1001,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) } From 44257950f132cf0d7bfd7a96d4447d12567412a2 Mon Sep 17 00:00:00 2001 From: Martin HS Date: Tue, 7 Apr 2026 08:13:25 +0200 Subject: [PATCH 044/183] tests: enable execution of amsterdam statetests (#34671) :wave: This PR makes it possible to run "Amsterdam" in statetests. I'm aware that they'll be failing and not in consensus with other clients, yet, but it's nice to be able to run tests and see what works and what doesn't Before the change: ``` $ go run ./cmd/evm statetest ./amsterdam.json [ { "name": "00000019-mixed-1", "pass": false, "fork": "Amsterdam", "error": "unexpected error: unsupported fork \"Amsterdam\"" } ] ``` After ``` $ go run ./cmd/evm statetest ./amsterdam.json {"stateRoot": "0x25b78260b76493a783c77c513125c8b0c5d24e058b4e87130bbe06f1d8b9419e"} [ { "name": "00000019-mixed-1", "pass": false, "stateRoot": "0x25b78260b76493a783c77c513125c8b0c5d24e058b4e87130bbe06f1d8b9419e", "fork": "Amsterdam", "error": "post state root mismatch: got 25b78260b76493a783c77c513125c8b0c5d24e058b4e87130bbe06f1d8b9419e, want 0000000000000000000000000000000000000000000000000000000000000000" } ] ``` --- tests/init.go | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tests/init.go b/tests/init.go index d10b47986c..f115e427a5 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), From bd6530a1d479893a881d49e1157fd0a4425e9399 Mon Sep 17 00:00:00 2001 From: Jonny Rhea <5555162+jrhea@users.noreply.github.com> Date: Tue, 7 Apr 2026 01:36:53 -0500 Subject: [PATCH 045/183] triedb, triedb/internal, triedb/pathdb: add GenerateTrie + extract shared pipeline into triedb/internal (#34654) This PR adds `GenerateTrie(db, scheme, root)` to the `triedb` package, which rebuilds all tries from flat snapshot KV data. This is needed by snap/2 sync so it can rebuild the trie after downloading the flat state. The shared trie generation pipeline from `pathdb/verifier.go` was moved into `triedb/internal/conversion.go` so both `GenerateTrie` and `VerifyState` reuse the same code. --- triedb/generate.go | 108 ++++++++++ triedb/generate_test.go | 178 +++++++++++++++++ triedb/internal/conversion.go | 363 ++++++++++++++++++++++++++++++++++ triedb/pathdb/iterator.go | 47 +---- triedb/pathdb/verifier.go | 289 +-------------------------- 5 files changed, 663 insertions(+), 322 deletions(-) create mode 100644 triedb/generate.go create mode 100644 triedb/generate_test.go create mode 100644 triedb/internal/conversion.go diff --git a/triedb/generate.go b/triedb/generate.go new file mode 100644 index 0000000000..259e139848 --- /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 0000000000..42bccd9aa3 --- /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/internal/conversion.go b/triedb/internal/conversion.go new file mode 100644 index 0000000000..b331b63e21 --- /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/iterator.go b/triedb/pathdb/iterator.go index 8ca8247206..2d333dfa1b 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/verifier.go b/triedb/pathdb/verifier.go index a69b10f4f3..c53590f2fd 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() } From b5d322000cc499d802b2b3768a4eb1a1a5dd1f28 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Tue, 7 Apr 2026 20:13:19 +0800 Subject: [PATCH 046/183] eth/protocols/snap: fix block accessList encoding rule (#34644) This PR refactors the encoding rules for `AccessListsPacket` in the wire protocol. Specifically: - The response is now encoded as a list of `rlp.RawValue` - `rlp.EmptyString` is used as a placeholder for unavailable BAL objects --- eth/protocols/snap/handler_test.go | 207 ++++++++++++++++++++++------- eth/protocols/snap/handlers.go | 20 +-- eth/protocols/snap/protocol.go | 4 +- 3 files changed, 175 insertions(+), 56 deletions(-) diff --git a/eth/protocols/snap/handler_test.go b/eth/protocols/snap/handler_test.go index 53b22ca7f7..3f6a43a059 100644 --- a/eth/protocols/snap/handler_test.go +++ b/eth/protocols/snap/handler_test.go @@ -18,33 +18,48 @@ 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" ) +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([][32]byte, n), + } + for i := range access.StorageReads { + binary.BigEndian.PutUint64(access.StorageReads[i][24:], uint64(i)) + } + return &bal.BlockAccessList{Accesses: []bal.AccountAccess{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.TestChainConfig, + Config: params.MergedTestChainConfig, } db := rawdb.NewMemoryDatabase() - _, blocks, _ := core.GenerateChainWithGenesis(gspec, ethash.NewFaker(), nBlocks, func(i int, gen *core.BlockGen) {}) + engine := beacon.New(ethash.NewFaker()) + _, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, nBlocks, func(i int, gen *core.BlockGen) {}) options := &core.BlockChainConfig{ - TrieCleanLimit: 0, - TrieDirtyLimit: 0, - TrieTimeLimit: 5 * time.Minute, - NoPrefetch: true, - SnapshotLimit: 0, + StateScheme: rawdb.PathScheme, + TrieTimeLimit: 5 * time.Minute, + NoPrefetch: true, } - bc, err := core.NewBlockChain(db, gspec, ethash.NewFaker(), options) + bc, err := core.NewBlockChain(db, gspec, engine, options) if err != nil { panic(err) } @@ -53,20 +68,22 @@ func getChainWithBALs(nBlocks int, balSize int) (*core.BlockChain, []common.Hash } // Store BALs for each block - var hashes []common.Hash - var bals []rlp.RawValue + var ( + hashes []common.Hash + bals []rlp.RawValue + ) for _, block := range blocks { hash := block.Hash() number := block.NumberU64() - bal := make(rlp.RawValue, balSize) // Fill with data based on block number - for j := range bal { - bal[j] = byte(number + uint64(j)) + bytes, err := rlp.EncodeToBytes(makeTestBAL(balSize)) + if err != nil { + panic(err) } - rawdb.WriteAccessListRLP(db, hash, number, bal) + rawdb.WriteAccessListRLP(db, hash, number, bytes) hashes = append(hashes, hash) - bals = append(bals, bal) + bals = append(bals, bytes) } return bc, hashes, bals } @@ -85,13 +102,18 @@ func TestServiceGetAccessListsQuery(t *testing.T) { result := ServiceGetAccessListsQuery(bc, req) // Verify the results - if len(result) != len(hashes) { - t.Fatalf("expected %d results, got %d", len(hashes), len(result)) + if result.Len() != len(hashes) { + t.Fatalf("expected %d results, got %d", len(hashes), result.Len()) } - for i, bal := range result { - if !bytes.Equal(bal, bals[i]) { - t.Errorf("BAL %d mismatch: got %x, want %x", i, bal, bals[i]) + 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++ } } @@ -111,25 +133,23 @@ func TestServiceGetAccessListsQueryEmpty(t *testing.T) { result := ServiceGetAccessListsQuery(bc, req) // Verify length - if len(result) != len(mixed) { - t.Fatalf("expected %d results, got %d", len(mixed), len(result)) + if result.Len() != len(mixed) { + t.Fatalf("expected %d results, got %d", len(mixed), result.Len()) } // Check positional correspondence - if !bytes.Equal(result[0], bals[0]) { - t.Errorf("index 0: expected known BAL, got %x", result[0]) + var expectVal = []rlp.RawValue{ + bals[0], rlp.EmptyString, bals[1], rlp.EmptyString, bals[2], } - if result[1] != nil { - t.Errorf("index 1: expected nil for unknown hash, got %x", result[1]) - } - if !bytes.Equal(result[2], bals[1]) { - t.Errorf("index 2: expected known BAL, got %x", result[2]) - } - if result[3] != nil { - t.Errorf("index 3: expected nil for unknown hash, got %x", result[3]) - } - if !bytes.Equal(result[4], bals[2]) { - t.Errorf("index 4: expected known BAL, got %x", result[4]) + 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++ } } @@ -154,8 +174,8 @@ func TestServiceGetAccessListsQueryCap(t *testing.T) { result := ServiceGetAccessListsQuery(bc, req) // Can't get more than maxAccessListLookups results - if len(result) > maxAccessListLookups { - t.Fatalf("expected at most %d results, got %d", maxAccessListLookups, len(result)) + if result.Len() > maxAccessListLookups { + t.Fatalf("expected at most %d results, got %d", maxAccessListLookups, result.Len()) } } @@ -179,21 +199,116 @@ func TestServiceGetAccessListsQueryByteLimit(t *testing.T) { result := ServiceGetAccessListsQuery(bc, req) // Should have stopped before returning all blocks - if len(result) >= nBlocks { - t.Fatalf("expected fewer than %d results due to byte limit, got %d", nBlocks, len(result)) + 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 len(result) == 0 { + 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) - var total uint64 - for _, bal := range result { - total += uint64(len(bal)) - } - if total <= softResponseLimit { - t.Errorf("total response size %d should exceed soft limit %d (includes one entry past limit)", total, softResponseLimit) + 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 index 4d60aab1f6..5a5733bdb4 100644 --- a/eth/protocols/snap/handlers.go +++ b/eth/protocols/snap/handlers.go @@ -559,16 +559,15 @@ func handleGetAccessLists(backend Backend, msg Decoder, peer *Peer) error { if err := msg.Decode(&req); err != nil { return fmt.Errorf("%w: message %v: %v", errDecode, msg, err) } - bals := ServiceGetAccessListsQuery(backend.Chain(), &req) return p2p.Send(peer.rw, AccessListsMsg, &AccessListsPacket{ ID: req.ID, - AccessLists: bals, + 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.RawValue { +func ServiceGetAccessListsQuery(chain *core.BlockChain, req *GetAccessListsPacket) rlp.RawList[rlp.RawValue] { if req.Bytes > softResponseLimit { req.Bytes = softResponseLimit } @@ -577,20 +576,25 @@ func ServiceGetAccessListsQuery(chain *core.BlockChain, req *GetAccessListsPacke req.Hashes = req.Hashes[:maxAccessListLookups] } var ( - bals []rlp.RawValue - bytes uint64 + err error + bytes uint64 + response = rlp.RawList[rlp.RawValue]{} ) for _, hash := range req.Hashes { if bal := chain.GetAccessListRLP(hash); len(bal) > 0 { - bals = append(bals, bal) + err = response.AppendRaw(bal) bytes += uint64(len(bal)) } else { // Either the block is unknown or the BAL doesn't exist - bals = append(bals, nil) + err = response.AppendRaw(rlp.EmptyString) + bytes += 1 + } + if err != nil { + break } if bytes > req.Bytes { break } } - return bals + return response } diff --git a/eth/protocols/snap/protocol.go b/eth/protocols/snap/protocol.go index 7913f8b053..685f468da3 100644 --- a/eth/protocols/snap/protocol.go +++ b/eth/protocols/snap/protocol.go @@ -229,8 +229,8 @@ type GetAccessListsPacket struct { // 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.RawValue // Requested BALs + ID uint64 // ID of the request this is a response for + AccessLists rlp.RawList[rlp.RawValue] // Requested BALs } func (*GetAccountRangePacket) Name() string { return "GetAccountRange" } From 52b8c09fdfe2a6cc6efc29c87186778a5260ba17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Diego=20L=C3=B3pez=20Le=C3=B3n?= Date: Tue, 7 Apr 2026 10:31:41 -0300 Subject: [PATCH 047/183] triedb/pathdb: skip duplicate-root layer insertion (#34642) PathDB keys diff layers by state root, not by block hash. That means a side-chain block can legitimately collide with an existing canonical diff layer when both blocks produce the same post-state (for example same parent, same coinbase, no txs). Today `layerTree.add` blindly inserts that second layer. If the root already exists, this overwrites `tree.layers[root]` and appends the same root to the mutation lookup again. Later account/storage lookups resolve that root to the wrong diff layer, which can corrupt reads for descendant canonical states. At runtime, the corruption is silent: no error is logged and no invariant check fires. State reads against affected descendants simply return stale data from the wrong diff layer (for example, an account balance that reflects one fewer block reward), which can propagate into RPC responses and block validation. This change makes duplicate-root inserts idempotent. A second layer with the same state root does not add any new retrievable state to a tree that is already keyed by root; keeping the original layer preserves the existing parent chain and avoids polluting the lookup history with duplicate roots. The regression test imports a canonical chain of two layers followed by a fork layer at height 1 with the same state root but a different block hash. Before the fix, account and storage lookups at the head resolve the fork layer instead of the canonical one. After the fix, the duplicate insert is skipped and lookups remain correct. --- triedb/pathdb/layertree.go | 9 +++++++++ triedb/pathdb/layertree_test.go | 34 +++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/triedb/pathdb/layertree.go b/triedb/pathdb/layertree.go index ec45257db5..0d7ca5a5b4 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) diff --git a/triedb/pathdb/layertree_test.go b/triedb/pathdb/layertree_test.go index a74c6eb045..285ca67b6c 100644 --- a/triedb/pathdb/layertree_test.go +++ b/triedb/pathdb/layertree_test.go @@ -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) From 0bafb29490751ad807ca1433962d5aef5ae27986 Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 7 Apr 2026 22:04:07 +0800 Subject: [PATCH 048/183] core/types: add accessList to WithSeal and WithBody (#34651) Co-authored-by: Felix Lange --- core/types/block.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/core/types/block.go b/core/types/block.go index 60c83c9db1..ea576ed232 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -505,6 +505,7 @@ func (b *Block) WithSeal(header *Header) *Block { transactions: b.transactions, uncles: b.uncles, withdrawals: b.withdrawals, + accessList: b.accessList, } } @@ -516,6 +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), + accessList: b.accessList, } for i := range body.Uncles { block.uncles[i] = CopyHeader(body.Uncles[i]) From 9878ef926db2fb45d33a9331feff1e38221ad267 Mon Sep 17 00:00:00 2001 From: locoholy <68823405+locoholy@users.noreply.github.com> Date: Tue, 7 Apr 2026 21:01:26 +0500 Subject: [PATCH 049/183] ethclient: omit empty address/topics fields in RPC filter requests (#33884) Changes JSON serialization of FilterCriteria to exclude "address" when it is empty. --- ethclient/ethclient.go | 6 +++++- ethclient/types_test.go | 16 ++++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/ethclient/ethclient.go b/ethclient/ethclient.go index 85286ec919..412f8955ba 100644 --- a/ethclient/ethclient.go +++ b/ethclient/ethclient.go @@ -498,7 +498,11 @@ func (ec *Client) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuer func toFilterArg(q ethereum.FilterQuery) (interface{}, error) { arg := map[string]interface{}{} - if q.Addresses != nil { + // 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 { diff --git a/ethclient/types_test.go b/ethclient/types_test.go index dcb9a579b7..8820b11162 100644 --- a/ethclient/types_test.go +++ b/ethclient/types_test.go @@ -53,6 +53,22 @@ func TestToFilterArg(t *testing.T) { }, 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{ From 04e40995d9898ae84e11ba6ec2354c1a4d5e5ee9 Mon Sep 17 00:00:00 2001 From: DELENE-TCHIO <119831304+DELENE-TCHIO-ROMUALD@users.noreply.github.com> Date: Tue, 7 Apr 2026 20:55:09 +0100 Subject: [PATCH 050/183] core: merge access events for all system calls (#34637) ProcessBeaconBlockRoot (EIP-4788) and processRequestsSystemCall (EIP-7002/7251) do not merge the EVM access events into the state after execution. ProcessParentBlockHash (EIP-2935) already does this correctly at line 290-291. Without this merge, the Verkle witness will be missing the storage accesses from the beacon root and request system calls, leading to incomplete witnesses and potential consensus issues when Verkle activates. --- core/state_processor.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/core/state_processor.go b/core/state_processor.go index 85f106d58c..bbb1341299 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -260,6 +260,9 @@ func ProcessBeaconBlockRoot(beaconRoot common.Hash, evm *vm.EVM) { evm.SetTxContext(NewEVMTxContext(msg)) evm.StateDB.AddAddressToAccessList(params.BeaconRootsAddress) _, _, _ = evm.Call(msg.From, *msg.To, msg.Data, 30_000_000, common.U2560) + if evm.StateDB.AccessEvents() != nil { + evm.StateDB.AccessEvents().Merge(evm.AccessEvents) + } evm.StateDB.Finalise(true) } @@ -323,6 +326,9 @@ func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte evm.SetTxContext(NewEVMTxContext(msg)) evm.StateDB.AddAddressToAccessList(addr) ret, _, err := evm.Call(msg.From, *msg.To, msg.Data, 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) From a8ea6319f1551056205c6c436b9b0e0a1fbbef5e Mon Sep 17 00:00:00 2001 From: Mael Regnery Date: Wed, 8 Apr 2026 12:57:29 +0200 Subject: [PATCH 051/183] eth/filters: return -32602 when exceeding the block range limit (#34647) Co-authored-by: Felix Lange --- eth/filters/filter.go | 3 +-- eth/filters/filter_test.go | 17 +++++++++++++++-- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/eth/filters/filter.go b/eth/filters/filter.go index 04e11f0475..f31b9568cd 100644 --- a/eth/filters/filter.go +++ b/eth/filters/filter.go @@ -19,7 +19,6 @@ package filters import ( "context" "errors" - "fmt" "math" "math/big" "slices" @@ -147,7 +146,7 @@ func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) { return nil, err } if f.rangeLimit != 0 && (end-begin) > f.rangeLimit { - return nil, fmt.Errorf("exceed maximum block range: %d", f.rangeLimit) + return nil, invalidParamsErr("exceed maximum block range %d", f.rangeLimit) } return f.rangeLogs(ctx, begin, end) } diff --git a/eth/filters/filter_test.go b/eth/filters/filter_test.go index e7b1b08046..c133438c64 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" @@ -634,7 +635,19 @@ func TestRangeLimit(t *testing.T) { // 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 || !strings.Contains(err.Error(), "exceed maximum block range") { - t.Fatalf("expected range limit error, got %v", err) + 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) } } From 21b19362c27762e2a1922e6a0f619c299b62d1b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felf=C3=B6ldi=20Zsolt?= Date: Thu, 9 Apr 2026 03:12:35 +0200 Subject: [PATCH 052/183] core/state: fix tracer hook for EIP-7708 burn logs (#34688) This PR fixes https://github.com/ethereum/go-ethereum/issues/34623 by changing the `vm.StateDB` interface: Instead of `EmitLogsForBurnAccounts()` emitting burn logs, `LogsForBurnAccounts() []*types.Log` just returns these logs which are then emitted by the caller. This way when tracing is used, `hookedStateDB.AddLog` will be used automatically and there is no need to duplicate either the burn log logic or the `OnLog` tracing hook. --- core/state/statedb.go | 19 +++++++++++-------- core/state/statedb_hooked.go | 4 ++-- core/state_transition.go | 4 +++- core/vm/interface.go | 2 +- 4 files changed, 17 insertions(+), 12 deletions(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index 854aaf6109..8b09ea89f6 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -745,7 +745,7 @@ type removedAccountWithBalance struct { balance *uint256.Int } -// EmitLogsForBurnAccounts emits the eth burn logs for accounts scheduled for +// 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 @@ -755,7 +755,7 @@ type removedAccountWithBalance struct { // // This function should only be invoked at the transaction boundary, specifically // before the Finalise. -func (s *StateDB) EmitLogsForBurnAccounts() { +func (s *StateDB) LogsForBurnAccounts() []*types.Log { var list []removedAccountWithBalance for addr := range s.journal.dirties { if obj, exist := s.stateObjects[addr]; exist && obj.selfDestructed && !obj.Balance().IsZero() { @@ -765,14 +765,17 @@ func (s *StateDB) EmitLogsForBurnAccounts() { }) } } - if list != nil { - sort.Slice(list, func(i, j int) bool { - return list[i].address.Cmp(list[j].address) < 0 - }) + if list == nil { + return nil } - for _, acct := range list { - s.AddLog(types.EthBurnLog(acct.address, acct.balance)) + 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 diff --git a/core/state/statedb_hooked.go b/core/state/statedb_hooked.go index 8c217fba48..52cf98d19b 100644 --- a/core/state/statedb_hooked.go +++ b/core/state/statedb_hooked.go @@ -229,8 +229,8 @@ func (s *hookedStateDB) AddLog(log *types.Log) { } } -func (s *hookedStateDB) EmitLogsForBurnAccounts() { - s.inner.EmitLogsForBurnAccounts() +func (s *hookedStateDB) LogsForBurnAccounts() []*types.Log { + return s.inner.LogsForBurnAccounts() } func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) { diff --git a/core/state_transition.go b/core/state_transition.go index 52375bedaa..bd7e5daeff 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -584,7 +584,9 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { } } if rules.IsAmsterdam { - st.evm.StateDB.EmitLogsForBurnAccounts() + for _, log := range st.evm.StateDB.LogsForBurnAccounts() { + st.evm.StateDB.AddLog(log) + } } return &ExecutionResult{ UsedGas: st.gasUsed(), diff --git a/core/vm/interface.go b/core/vm/interface.go index 6a93846ac5..d7c4340e06 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -87,7 +87,7 @@ type StateDB interface { Snapshot() int AddLog(*types.Log) - EmitLogsForBurnAccounts() + LogsForBurnAccounts() []*types.Log AddPreimage(common.Hash, []byte) Witness() *stateless.Witness From 68c7058a80859dc5de75d3e34708cd1ea2f094e5 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Thu, 9 Apr 2026 03:19:54 +0200 Subject: [PATCH 053/183] core/stateless: fix parsing an empty witness (#34683) This is to fix a crasher in keeper. --- core/stateless/encoding.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/stateless/encoding.go b/core/stateless/encoding.go index d559178892..1b20c4cb2a 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" @@ -42,6 +43,9 @@ func (w *Witness) ToExtWitness() *ExtWitness { // 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)) From 3772bb536a67a2f17ed98244775eb16698f79140 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Thu, 9 Apr 2026 07:39:38 +0200 Subject: [PATCH 054/183] triedb/pathdb: fix lookup sentinel collision with zero disk layer root (#34680) --- triedb/pathdb/layertree.go | 8 +-- triedb/pathdb/layertree_test.go | 115 ++++++++++++++++++++++++++++++++ triedb/pathdb/lookup.go | 37 +++++----- 3 files changed, 137 insertions(+), 23 deletions(-) diff --git a/triedb/pathdb/layertree.go b/triedb/pathdb/layertree.go index 0d7ca5a5b4..b20e40bd05 100644 --- a/triedb/pathdb/layertree.go +++ b/triedb/pathdb/layertree.go @@ -319,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] @@ -337,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 285ca67b6c..82eb182990 100644 --- a/triedb/pathdb/layertree_test.go +++ b/triedb/pathdb/layertree_test.go @@ -916,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 719546f410..9b300ec871 100644 --- a/triedb/pathdb/lookup.go +++ b/triedb/pathdb/lookup.go @@ -92,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: // @@ -123,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 @@ -155,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 From 58557cb4635d4e6f3e49fcdc82a6469554e929a6 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Thu, 9 Apr 2026 10:27:19 +0200 Subject: [PATCH 055/183] cmd/geth: add subcommand for offline binary tree conversion (#33740) This tool is designed for the offline translation of an MPT database to a binary trie. This is to be used for users who e.g. want to prove equivalence of a binary tree chain shadowing the MPT chain. It adds a `bintrie` command, cleanly separating the concerns. --- cmd/geth/bintrie_convert.go | 408 +++++++++++++++++++++++++++++++ cmd/geth/bintrie_convert_test.go | 229 +++++++++++++++++ cmd/geth/main.go | 2 + 3 files changed, 639 insertions(+) create mode 100644 cmd/geth/bintrie_convert.go create mode 100644 cmd/geth/bintrie_convert_test.go diff --git a/cmd/geth/bintrie_convert.go b/cmd/geth/bintrie_convert.go new file mode 100644 index 0000000000..3730768697 --- /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{ + IsVerkle: true, + PathDB: &pathdb.Config{ + JournalDirectory: stack.ResolvePath("triedb-bintrie"), + }, + }) + defer destTriedb.Close() + + binTrie, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) + 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) + 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 0000000000..9b95f6a70f --- /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{ + IsVerkle: true, + PathDB: pathdb.Defaults, + }) + defer destTriedb.Close() + + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) + 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) + 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{ + IsVerkle: true, + PathDB: pathdb.Defaults, + }) + + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) + 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) + 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/main.go b/cmd/geth/main.go index b72cbb9885..e196ac8688 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -260,6 +260,8 @@ func init() { utils.ShowDeprecated, // See snapshot.go snapshotCommand, + // See bintrie_convert.go + bintrieCommand, } if logTestCommand != nil { app.Commands = append(app.Commands, logTestCommand) From ea5448814f14a5e946522891e4d14399c1c888d3 Mon Sep 17 00:00:00 2001 From: cui Date: Fri, 10 Apr 2026 23:41:59 +0800 Subject: [PATCH 056/183] core/filtermaps: remove dead condition check (#34695) already check on line 40 before. --- core/filtermaps/math_test.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/core/filtermaps/math_test.go b/core/filtermaps/math_test.go index a4c1609059..0cd0046a7d 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) } } } From f71a884e37857e6cbb093e2fc3e03b33bda85d6f Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Fri, 10 Apr 2026 19:23:44 +0200 Subject: [PATCH 057/183] trie/bintrie: fix DeleteAccount no-op (#34676) `BinaryTrie.DeleteAccount` was a no-op, silently ignoring the caller's deletion request and leaving the old `BasicData` and `CodeHash` in the trie. Co-authored-by: Guillaume Ballet <3272758+gballet@users.noreply.github.com> --- trie/bintrie/trie.go | 26 ++- trie/bintrie/trie_test.go | 328 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 349 insertions(+), 5 deletions(-) diff --git a/trie/bintrie/trie.go b/trie/bintrie/trie.go index 6c29239a87..45f9edd46c 100644 --- a/trie/bintrie/trie.go +++ b/trie/bintrie/trie.go @@ -216,10 +216,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 } @@ -294,8 +296,22 @@ func (t *BinaryTrie) UpdateStorage(address common.Address, key, value []byte) er 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 { + var ( + values = make([][]byte, StemNodeWidth) + stem = GetBinaryTreeKey(addr, zero[:]) + ) + // Clear BasicData (nonce, balance, code size) and CodeHash. + values[BasicDataLeafKey] = zero[:] + values[CodeHashLeafKey] = zero[:] + + root, err := t.root.InsertValuesAtStem(stem, values, t.nodeResolver, 0) + if err != nil { + return fmt.Errorf("DeleteAccount (%x) error: %v", addr, err) + } + t.root = root return nil } diff --git a/trie/bintrie/trie_test.go b/trie/bintrie/trie_test.go index 256fd218e2..f420f53ef8 100644 --- a/trie/bintrie/trie_test.go +++ b/trie/bintrie/trie_test.go @@ -267,6 +267,334 @@ func TestStorageRoundTrip(t *testing.T) { } } +// 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{ + root: NewBinaryNode(), + 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() From deda47f6a1c0588b9e2600ca97552994c2889d37 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Fri, 10 Apr 2026 19:43:48 +0200 Subject: [PATCH 058/183] =?UTF-8?q?trie/bintrie:=20fix=20GetAccount/GetSto?= =?UTF-8?q?rage=20non-membership=20=E2=80=94=20verify=20stem=20before=20re?= =?UTF-8?q?turning=20values=20(#34690)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix `GetAccount` returning **wrong account data** for non-existent addresses when the trie root is a `StemNode` (single-account trie) — the `StemNode` branch returned `r.Values` without verifying the queried address's stem matches. Co-authored-by: Guillaume Ballet <3272758+gballet@users.noreply.github.com> --- trie/bintrie/stem_node.go | 5 +- trie/bintrie/stem_node_test.go | 44 +++++++++ trie/bintrie/trie.go | 2 +- trie/bintrie/trie_test.go | 159 +++++++++++++++++++++++++++++++++ 4 files changed, 208 insertions(+), 2 deletions(-) diff --git a/trie/bintrie/stem_node.go b/trie/bintrie/stem_node.go index 3f69261d62..e5729e6182 100644 --- a/trie/bintrie/stem_node.go +++ b/trie/bintrie/stem_node.go @@ -37,7 +37,10 @@ type StemNode struct { // Get retrieves the value for the given key. func (bt *StemNode) Get(key []byte, _ NodeResolverFn) ([]byte, error) { - panic("this should not be called directly") + if !bytes.Equal(bt.Stem, key[:StemSize]) { + return nil, nil + } + return bt.Values[key[StemSize]], nil } // Insert inserts a new key-value pair into the node. diff --git a/trie/bintrie/stem_node_test.go b/trie/bintrie/stem_node_test.go index 92c1b49e02..310c553d39 100644 --- a/trie/bintrie/stem_node_test.go +++ b/trie/bintrie/stem_node_test.go @@ -23,6 +23,50 @@ import ( "github.com/ethereum/go-ethereum/common" ) +// TestStemNodeGet tests the Get method for matching stem, non-matching stem, +// and nil-value suffix scenarios. +func TestStemNodeGet(t *testing.T) { + stem := make([]byte, StemSize) + stem[0] = 0xAB + var values [StemNodeWidth][]byte + values[5] = common.HexToHash("0xdeadbeef").Bytes() + + node := &StemNode{Stem: stem, Values: values[:], depth: 0} + + // Matching stem, populated suffix → returns value. + key := make([]byte, HashSize) + copy(key[:StemSize], stem) + key[StemSize] = 5 + got, err := node.Get(key, nil) + if err != nil { + t.Fatalf("Get error: %v", err) + } + if !bytes.Equal(got, values[5]) { + t.Fatalf("Get = %x, want %x", got, values[5]) + } + + // Matching stem, empty suffix → returns nil (slot not set). + key[StemSize] = 99 + got, err = node.Get(key, nil) + if err != nil { + t.Fatalf("Get error: %v", err) + } + if got != nil { + t.Fatalf("Get(empty suffix) = %x, want nil", got) + } + + // Non-matching stem → returns nil, nil. + otherKey := make([]byte, HashSize) + otherKey[0] = 0xFF + got, err = node.Get(otherKey, nil) + if err != nil { + t.Fatalf("Get error: %v", err) + } + if got != nil { + t.Fatalf("Get(wrong stem) = %x, want nil", got) + } +} + // TestStemNodeInsertSameStem tests inserting values with the same stem func TestStemNodeInsertSameStem(t *testing.T) { stem := make([]byte, 31) diff --git a/trie/bintrie/trie.go b/trie/bintrie/trie.go index 45f9edd46c..b1e3c991c0 100644 --- a/trie/bintrie/trie.go +++ b/trie/bintrie/trie.go @@ -191,7 +191,7 @@ func (t *BinaryTrie) GetAccount(addr common.Address) (*types.StateAccount, error case *InternalNode: values, err = r.GetValuesAtStem(key[:StemSize], t.nodeResolver) case *StemNode: - values = r.Values + values, err = r.GetValuesAtStem(key[:StemSize], t.nodeResolver) case Empty: return nil, nil default: diff --git a/trie/bintrie/trie_test.go b/trie/bintrie/trie_test.go index f420f53ef8..5b104ddde4 100644 --- a/trie/bintrie/trie_test.go +++ b/trie/bintrie/trie_test.go @@ -620,3 +620,162 @@ func TestBinaryTrieWitness(t *testing.T) { 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{ + root: NewBinaryNode(), + 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 _, ok := tr.root.(*StemNode); !ok { + t.Fatalf("expected StemNode root, got %T", tr.root) + } + + // 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{ + root: NewBinaryNode(), + 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 _, ok := tr.root.(*InternalNode); !ok { + t.Fatalf("expected InternalNode root, got %T", tr.root) + } + + // 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 _, ok := tr.root.(*StemNode); !ok { + t.Fatalf("expected StemNode root, got %T", tr.root) + } + + // 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{ + root: NewBinaryNode(), + 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 _, ok := tr.root.(*InternalNode); !ok { + t.Fatalf("expected InternalNode root, got %T", tr.root) + } + + // 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) + } +} From 6333855163d0ac99240f966df875be64c0885983 Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Mon, 13 Apr 2026 08:09:42 +0200 Subject: [PATCH 059/183] core: turn gas into a vector (#34691) Pre-refactor PR to get 8037 upstreamed in chunks --------- Co-authored-by: Gary Rong --- core/vm/contract.go | 14 +-- core/vm/eips.go | 6 +- core/vm/evm.go | 14 +-- core/vm/gas_table.go | 190 ++++++++++++++++++---------------- core/vm/gascosts.go | 36 +++++++ core/vm/instructions.go | 6 +- core/vm/instructions_test.go | 2 +- core/vm/interpreter.go | 16 +-- core/vm/jump_table.go | 2 +- core/vm/operations_acl.go | 98 +++++++++--------- core/vm/operations_verkle.go | 115 ++++++++++---------- eth/tracers/js/tracer_test.go | 4 +- 12 files changed, 278 insertions(+), 225 deletions(-) create mode 100644 core/vm/gascosts.go diff --git a/core/vm/contract.go b/core/vm/contract.go index 165ca833f8..3b5695e21a 100644 --- a/core/vm/contract.go +++ b/core/vm/contract.go @@ -42,7 +42,7 @@ type Contract struct { IsDeployment bool IsSystemCall bool - Gas uint64 + Gas GasCosts value *uint256.Int } @@ -56,7 +56,7 @@ func NewContract(caller common.Address, address common.Address, value *uint256.I caller: caller, address: address, jumpDests: jumpDests, - Gas: gas, + Gas: GasCosts{RegularGas: gas}, value: value, } } @@ -127,13 +127,13 @@ 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 { + if c.Gas.RegularGas < gas { return false } if logger != nil && logger.OnGasChange != nil && reason != tracing.GasChangeIgnored { - logger.OnGasChange(c.Gas, c.Gas-gas, reason) + logger.OnGasChange(c.Gas.RegularGas, c.Gas.RegularGas-gas, reason) } - c.Gas -= gas + c.Gas.RegularGas -= gas return true } @@ -143,9 +143,9 @@ func (c *Contract) RefundGas(gas uint64, logger *tracing.Hooks, reason tracing.G return } if logger != nil && logger.OnGasChange != nil && reason != tracing.GasChangeIgnored { - logger.OnGasChange(c.Gas, c.Gas+gas, reason) + logger.OnGasChange(c.Gas.RegularGas, c.Gas.RegularGas+gas, reason) } - c.Gas += gas + c.Gas.RegularGas += gas } // Address returns the contracts address diff --git a/core/vm/eips.go b/core/vm/eips.go index 3ccd9aaaf0..8f4ca3ae41 100644 --- a/core/vm/eips.go +++ b/core/vm/eips.go @@ -381,7 +381,7 @@ 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) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(addr, copyOffset, nonPaddedCopyLength, uint64(len(code)), false, scope.Contract.Gas.RegularGas) scope.Contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas @@ -407,7 +407,7 @@ func opPush1EIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // 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) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(contractAddr, *pc+1, uint64(1), uint64(len(scope.Contract.Code)), false, scope.Contract.Gas.RegularGas) scope.Contract.UseGas(wanted, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas @@ -435,7 +435,7 @@ func makePushEIP4762(size uint64, pushByteSize int) executionFunc { 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) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(contractAddr, uint64(start), uint64(pushByteSize), uint64(len(scope.Contract.Code)), false, scope.Contract.Gas.RegularGas) scope.Contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas diff --git a/core/vm/evm.go b/core/vm/evm.go index 36494de2a8..4df2627486 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -303,7 +303,7 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g contract.IsSystemCall = isSystemCall(caller) contract.SetCallCode(evm.resolveCodeHash(addr), code) ret, err = evm.Run(contract, input, false) - gas = contract.Gas + gas = contract.Gas.RegularGas } } // When an error was returned by the EVM or when setting the creation code @@ -365,7 +365,7 @@ func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byt contract := NewContract(caller, caller, value, gas, evm.jumpDests) contract.SetCallCode(evm.resolveCodeHash(addr), evm.resolveCode(addr)) ret, err = evm.Run(contract, input, false) - gas = contract.Gas + gas = contract.Gas.RegularGas } if err != nil { evm.StateDB.RevertToSnapshot(snapshot) @@ -413,7 +413,7 @@ func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, contract := NewContract(originCaller, caller, value, gas, evm.jumpDests) contract.SetCallCode(evm.resolveCodeHash(addr), evm.resolveCode(addr)) ret, err = evm.Run(contract, input, false) - gas = contract.Gas + gas = contract.Gas.RegularGas } if err != nil { evm.StateDB.RevertToSnapshot(snapshot) @@ -472,7 +472,7 @@ func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []b // above we revert to the snapshot and consume any gas remaining. Additionally // when we're in Homestead this also counts for code storage gas errors. ret, err = evm.Run(contract, input, true) - gas = contract.Gas + gas = contract.Gas.RegularGas } if err != nil { evm.StateDB.RevertToSnapshot(snapshot) @@ -583,10 +583,10 @@ 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(contract.Gas.RegularGas, evm.Config.Tracer, tracing.GasChangeCallFailedExecution) } } - return ret, address, contract.Gas, err + return ret, address, contract.Gas.RegularGas, err } // initNewContract runs a new contract's creation code, performs checks on the @@ -613,7 +613,7 @@ func (evm *EVM) initNewContract(contract *Contract, address common.Address) ([]b return ret, ErrCodeStoreOutOfGas } } else { - consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(address, 0, uint64(len(ret)), uint64(len(ret)), true, contract.Gas) + consumed, wanted := evm.AccessEvents.CodeChunksRangeGas(address, 0, uint64(len(ret)), uint64(len(ret)), true, contract.Gas.RegularGas) contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) if len(ret) > 0 && (consumed < wanted) { return ret, ErrCodeStoreOutOfGas diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index f075a99468..b3259b2ec7 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -64,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() 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 } } @@ -95,9 +95,9 @@ 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 0, ErrWriteProtection + return GasCosts{}, ErrWriteProtection } var ( y, x = stack.Back(1), stack.Back(0) @@ -114,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 } } @@ -139,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) @@ -164,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: @@ -182,13 +182,13 @@ 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 0, ErrWriteProtection + 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 ( @@ -198,16 +198,16 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m 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) @@ -223,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) { + 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() 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 ( @@ -290,64 +294,64 @@ 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() 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() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if err := CheckMaxInitCodeSize(&evm.chainRules, size); err != nil { - return 0, err + return GasCosts{}, err } // 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() if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } if err := CheckMaxInitCodeSize(&evm.chainRules, size); err != nil { - return 0, err + return GasCosts{}, err } // 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) { +func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) var ( @@ -355,12 +359,12 @@ func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, mem 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) { +func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) var ( @@ -368,9 +372,9 @@ func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor 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 } var ( @@ -381,36 +385,36 @@ var ( ) func makeCallVariantGasCost(intrinsicFunc gasFunc) 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) { intrinsic, err := intrinsicFunc(evm, contract, stack, mem, memorySize) if err != nil { - return 0, err + return GasCosts{}, err } - evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, intrinsic, stack.Back(0)) + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsic.RegularGas, stack.Back(0)) if err != nil { - return 0, err + return GasCosts{}, err } - gas, overflow := math.SafeAdd(intrinsic, evm.callGasTemp) + gas, overflow := math.SafeAdd(intrinsic.RegularGas, evm.callGasTemp) if overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } } -func gasCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { +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()) ) if evm.readOnly && transfersValue { - return 0, ErrWriteProtection + 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 { @@ -418,12 +422,12 @@ func gasCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m } var overflow bool if gas, overflow = math.SafeAdd(memoryGas, transferGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } // 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 < gas { - return 0, ErrOutOfGas + if contract.Gas.RegularGas < gas { + return GasCosts{}, ErrOutOfGas } // Stateful check var stateGas uint64 @@ -435,15 +439,15 @@ func gasCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m stateGas += params.CallNewAccountGas } if gas, overflow = math.SafeAdd(gas, stateGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasCallCodeIntrinsic(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 @@ -453,22 +457,30 @@ func gasCallCodeIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memor gas += params.CallValueTransferGas } if gas, overflow = math.SafeAdd(gas, memoryGas); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return gas, nil + return GasCosts{RegularGas: gas}, nil } -func gasDelegateCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - return memoryGasCost(mem, memorySize) +func gasDelegateCallIntrinsic(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 } -func gasStaticCallIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - return memoryGasCost(mem, memorySize) +func gasStaticCallIntrinsic(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 } -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 0, ErrWriteProtection + return GasCosts{}, ErrWriteProtection } var gas uint64 @@ -490,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/gascosts.go b/core/vm/gascosts.go new file mode 100644 index 0000000000..ba6746758b --- /dev/null +++ b/core/vm/gascosts.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 . + +package vm + +import "fmt" + +// GasCosts denotes a vector of gas costs in the +// multidimensional metering paradigm. +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) +} diff --git a/core/vm/instructions.go b/core/vm/instructions.go index a5fa11e307..74400732ac 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -566,7 +566,7 @@ func opMsize(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opGas(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(new(uint256.Int).SetUint64(scope.Contract.Gas)) + scope.Stack.push(new(uint256.Int).SetUint64(scope.Contract.Gas.RegularGas)) return nil, nil } @@ -658,7 +658,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 @@ -702,7 +702,7 @@ 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 diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go index 4c6d093d2e..1f69eea3da 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -879,7 +879,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 { diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index 620c069fc8..b507595fab 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -166,14 +166,14 @@ 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) + consumed, wanted := evm.TxContext.AccessEvents.CodeChunksRangeGas(contractAddr, pc, 1, uint64(len(contract.Code)), false, contract.Gas.RegularGas) contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) if consumed < wanted { return nil, ErrOutOfGas @@ -192,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. @@ -218,17 +218,17 @@ 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 } } diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go index a2e2c91194..82fc43ec13 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) ) diff --git a/core/vm/operations_acl.go b/core/vm/operations_acl.go index addd2b162f..154c261cae 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -27,13 +27,13 @@ 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 0, ErrWriteProtection + 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 ( @@ -53,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) @@ -89,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) } } @@ -98,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 @@ -106,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 @@ -116,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) { @@ -129,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. @@ -143,20 +144,20 @@ 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) { + 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) @@ -168,7 +169,7 @@ func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) g // 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 + return GasCosts{}, ErrOutOfGas } } // Now call the old calculator, which takes into account @@ -176,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 } } @@ -224,13 +226,13 @@ 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 0, ErrWriteProtection + return GasCosts{}, ErrWriteProtection } if !evm.StateDB.AddressInAccessList(address) { // If the caller cannot afford the cost, this change will be rolled back @@ -239,8 +241,8 @@ func makeSelfdestructGasFn(refundsEnabled bool) gasFunc { // 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 < gas { - return 0, ErrOutOfGas + if contract.Gas.RegularGas < gas { + return GasCosts{}, ErrOutOfGas } } // if empty and transfers value @@ -250,7 +252,7 @@ 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 } @@ -262,20 +264,20 @@ var ( gasCallCodeEIP7702 = makeCallVariantGasCallEIP7702(gasCallCodeIntrinsic) ) -func gasCallEIP7702(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 0, ErrWriteProtection + 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) (uint64, error) { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { var ( eip2929Cost uint64 eip7702Cost uint64 @@ -294,7 +296,7 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { // Charge the remaining difference here already, to correctly calculate // available gas for call if !contract.UseGas(eip2929Cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { - return 0, ErrOutOfGas + return GasCosts{}, ErrOutOfGas } } @@ -305,13 +307,13 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { // - create new account intrinsicCost, err := intrinsicFunc(evm, contract, stack, mem, memorySize) if err != nil { - return 0, err + 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 < intrinsicCost { - return 0, ErrOutOfGas + if contract.Gas.RegularGas < intrinsicCost.RegularGas { + return GasCosts{}, ErrOutOfGas } // Check if code is a delegation and if so, charge for resolution. @@ -323,20 +325,20 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { eip7702Cost = params.ColdAccountAccessCostEIP2929 } if !contract.UseGas(eip7702Cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { - return 0, ErrOutOfGas + return GasCosts{}, ErrOutOfGas } } // 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, intrinsicCost, stack.Back(0)) + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsicCost.RegularGas, stack.Back(0)) if err != nil { - return 0, 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 += eip2929Cost + eip7702Cost + contract.Gas.RegularGas += eip2929Cost + eip7702Cost // Aggregate the gas costs from all components, including EIP-2929, EIP-7702, // the CALL opcode itself, and the cost incurred by nested calls. @@ -345,14 +347,14 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { totalCost uint64 ) if totalCost, overflow = math.SafeAdd(eip2929Cost, eip7702Cost); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - if totalCost, overflow = math.SafeAdd(totalCost, intrinsicCost); overflow { - return 0, ErrGasUintOverflow + if totalCost, overflow = math.SafeAdd(totalCost, intrinsicCost.RegularGas); overflow { + return GasCosts{}, ErrGasUintOverflow } if totalCost, overflow = math.SafeAdd(totalCost, evm.callGasTemp); overflow { - return 0, ErrGasUintOverflow + return GasCosts{}, ErrGasUintOverflow } - return totalCost, nil + return GasCosts{RegularGas: totalCost}, nil } } diff --git a/core/vm/operations_verkle.go b/core/vm/operations_verkle.go index 30f9957775..d57f2c4dcf 100644 --- a/core/vm/operations_verkle.go +++ b/core/vm/operations_verkle.go @@ -24,37 +24,37 @@ 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()) witnessGas uint64 @@ -65,9 +65,9 @@ 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 + 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,44 +127,45 @@ 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) @@ -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/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go index b21e104abc..694debcf98 100644 --- a/eth/tracers/js/tracer_test.go +++ b/eth/tracers/js/tracer_test.go @@ -66,9 +66,9 @@ func runTrace(tracer *tracers.Tracer, vmctx *vmContext, chaincfg *params.ChainCo 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 } From 735bfd121a738eb35efb9b88e9fe25618b807fa4 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Mon, 13 Apr 2026 09:42:37 +0200 Subject: [PATCH 060/183] trie/bintrie: spec change, big endian hashing of slot key (#34670) The spec has been changed during SIC #49, the offset is encoded as a big-endian number. --- core/genesis_test.go | 2 +- trie/bintrie/key_encoding.go | 9 +++------ 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/core/genesis_test.go b/core/genesis_test.go index 2b08b36690..2ff64e8d21 100644 --- a/core/genesis_test.go +++ b/core/genesis_test.go @@ -308,7 +308,7 @@ func TestVerkleGenesisCommit(t *testing.T) { }, } - expected := common.FromHex("1fd154971d9a386c4ec75fe7138c17efb569bfc2962e46e94a376ba997e3fadc") + 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) diff --git a/trie/bintrie/key_encoding.go b/trie/bintrie/key_encoding.go index c009f1529f..265935293b 100644 --- a/trie/bintrie/key_encoding.go +++ b/trie/bintrie/key_encoding.go @@ -54,15 +54,12 @@ func getBinaryTreeKey(addr common.Address, offset []byte, overflow bool) []byte defer returnSha256(hasher) hasher.Write(zeroHash[:12]) hasher.Write(addr[:]) - var buf [32]byte - // key is big endian, hashed value is little endian - for i := range offset[:31] { - buf[i] = offset[30-i] - } + 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[31] = 1 + buf[0] = 1 } hasher.Write(buf[:]) k := hasher.Sum(nil) From ecae519972c0c8b4b702fae651e1825be64275e0 Mon Sep 17 00:00:00 2001 From: Gaurav Dhiman Date: Mon, 13 Apr 2026 17:15:35 +0530 Subject: [PATCH 061/183] beacon/engine, miner: fix testing_buildBlockV1 response (#34704) Two fixes for `testing_buildBlockV1`: 1. Add `omitempty` to `SlotNumber` in `ExecutableData` so it is omitted for pre-Amsterdam payloads. The spec defines the response as `ExecutionPayloadV3` which does not include `slotNumber`. 2. Pass `res.fees` instead of `new(big.Int)` in `BuildTestingPayload` so `blockValue` reflects actual priority fees instead of always being zero. Corresponding fixture update: ethereum/execution-apis#783 --- beacon/engine/gen_ed.go | 4 ++-- beacon/engine/types.go | 2 +- miner/payload_building.go | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/beacon/engine/gen_ed.go b/beacon/engine/gen_ed.go index b460368b84..c733b3f350 100644 --- a/beacon/engine/gen_ed.go +++ b/beacon/engine/gen_ed.go @@ -34,7 +34,7 @@ func (e ExecutableData) MarshalJSON() ([]byte, error) { Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` - SlotNumber *hexutil.Uint64 `json:"slotNumber"` + SlotNumber *hexutil.Uint64 `json:"slotNumber,omitempty"` } var enc ExecutableData enc.ParentHash = e.ParentHash @@ -83,7 +83,7 @@ func (e *ExecutableData) UnmarshalJSON(input []byte) error { Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed"` ExcessBlobGas *hexutil.Uint64 `json:"excessBlobGas"` - SlotNumber *hexutil.Uint64 `json:"slotNumber"` + SlotNumber *hexutil.Uint64 `json:"slotNumber,omitempty"` } var dec ExecutableData if err := json.Unmarshal(input, &dec); err != nil { diff --git a/beacon/engine/types.go b/beacon/engine/types.go index 5c94e67de1..a312fee88a 100644 --- a/beacon/engine/types.go +++ b/beacon/engine/types.go @@ -99,7 +99,7 @@ type ExecutableData struct { Withdrawals []*types.Withdrawal `json:"withdrawals"` BlobGasUsed *uint64 `json:"blobGasUsed"` ExcessBlobGas *uint64 `json:"excessBlobGas"` - SlotNumber *uint64 `json:"slotNumber"` + SlotNumber *uint64 `json:"slotNumber,omitempty"` } // JSON type overrides for executableData. diff --git a/miner/payload_building.go b/miner/payload_building.go index ccaabec373..db8126828a 100644 --- a/miner/payload_building.go +++ b/miner/payload_building.go @@ -360,5 +360,5 @@ func (miner *Miner) BuildTestingPayload(args *BuildPayloadArgs, transactions []* if res.err != nil { return nil, res.err } - return engine.BlockToExecutableData(res.block, new(big.Int), res.sidecars, res.requests), nil + return engine.BlockToExecutableData(res.block, res.fees, res.sidecars, res.requests), nil } From f7f57d29d43704cb49a3154da044f31970875f04 Mon Sep 17 00:00:00 2001 From: bigbear <155267841+aso20455@users.noreply.github.com> Date: Mon, 13 Apr 2026 13:57:11 +0200 Subject: [PATCH 062/183] crypto/bn256: fix comment in MulXi (#34659) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The comment formula showed (i+3) but the code multiplies by 9 (Lsh 3 + add = 8+1). This was a error when porting from upstream golang.org/x/crypto/bn256 where ξ=i+3. Go-ethereum changed the constant to ξ=i+9 but forgot to update the inner formula. --- crypto/bn256/google/gfp2.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crypto/bn256/google/gfp2.go b/crypto/bn256/google/gfp2.go index 3981f6cb4f..394ef83548 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) From 7d463aedd3ad1a88964a4286f443c712164543ec Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Mon, 13 Apr 2026 20:10:56 +0800 Subject: [PATCH 063/183] accounts/keystore: fix flaky TestUpdatedKeyfileContents (#34084) TestUpdatedKeyfileContents was intermittently failing with: - Emptying account file failed - wasn't notified of new accounts Root cause: waitForAccounts required the account list match and an immediately readable ks.changes notification in the same instant, creating a timing race between cache update visibility and channel delivery. This change keeps the same timeout window but waits until both conditions are observed, which preserves test intent while removing the flaky timing dependency. Validation: - go test ./accounts/keystore -run '^TestUpdatedKeyfileContents$' -count=100 --- accounts/keystore/account_cache_test.go | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/accounts/keystore/account_cache_test.go b/accounts/keystore/account_cache_test.go index c9a8cdfcef..e49b110e7e 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) } From 5b7511eeeda9a750214ea16b63d980dda6e8cd5e Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Mon, 13 Apr 2026 20:13:33 +0800 Subject: [PATCH 064/183] core/vm: include operand in error message (#34635) Return ErrInvalidOpCode with the executing opcode and offending immediate for forbidden DUPN, SWAPN, and EXCHANGE operands. Extend TestEIP8024_Execution to assert both opcode and operand for all invalid-immediate paths. --- core/vm/errors.go | 10 +++++-- core/vm/instructions.go | 9 ++++-- core/vm/instructions_test.go | 56 ++++++++++++++++++++++++++---------- 3 files changed, 55 insertions(+), 20 deletions(-) diff --git a/core/vm/errors.go b/core/vm/errors.go index e33c9fcb85..b6235d44a6 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/instructions.go b/core/vm/instructions.go index 74400732ac..c3d1633c78 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -996,7 +996,8 @@ func opDupN(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // 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) @@ -1023,7 +1024,8 @@ func opSwapN(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // 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) @@ -1053,7 +1055,8 @@ func opExchange(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // This range is excluded both to preserve compatibility with existing opcodes // and to keep decode_pair’s 16-aligned arithmetic mapping valid (0–81, 128–255). if x > 81 && x < 128 { - return nil, &ErrInvalidOpCode{opcode: OpCode(x)} + operand := x + return nil, &ErrInvalidOpCode{opcode: EXCHANGE, operand: &operand} } n, m := decodePair(x) need := max(n, m) + 1 diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go index 1f69eea3da..5055ccb16d 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -1014,11 +1014,12 @@ func TestEIP8024_Execution(t *testing.T) { evm := NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) tests := []struct { - name string - codeHex string - wantErr error - wantOpcode OpCode - wantVals []uint64 + name string + codeHex string + wantErr error + wantOpcode OpCode + wantOperand *byte + wantVals []uint64 }{ { name: "DUPN", @@ -1063,10 +1064,18 @@ func TestEIP8024_Execution(t *testing.T) { }, }, { - name: "INVALID_SWAPN_LOW", - codeHex: "e75b", - wantErr: &ErrInvalidOpCode{}, - wantOpcode: SWAPN, + name: "INVALID_DUPN_LOW", + codeHex: "e65b", + wantErr: &ErrInvalidOpCode{}, + wantOpcode: DUPN, + wantOperand: ptrToByte(0x5b), + }, + { + name: "INVALID_SWAPN_LOW", + codeHex: "e75b", + wantErr: &ErrInvalidOpCode{}, + wantOpcode: SWAPN, + wantOperand: ptrToByte(0x5b), }, { name: "JUMP_OVER_INVALID_DUPN", @@ -1079,10 +1088,11 @@ func TestEIP8024_Execution(t *testing.T) { wantVals: []uint64{1, 0, 0}, }, { - name: "INVALID_EXCHANGE", - codeHex: "e852", - wantErr: &ErrInvalidOpCode{}, - wantOpcode: EXCHANGE, + name: "INVALID_EXCHANGE", + codeHex: "e852", + wantErr: &ErrInvalidOpCode{}, + wantOpcode: EXCHANGE, + wantOperand: ptrToByte(0x52), }, { name: "UNDERFLOW_DUPN", @@ -1150,10 +1160,21 @@ func TestEIP8024_Execution(t *testing.T) { // Fail if we don't get the error we expect. switch tc.wantErr.(type) { case *ErrInvalidOpCode: - var want *ErrInvalidOpCode - if !errors.As(err, &want) { + 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) { @@ -1183,3 +1204,8 @@ func TestEIP8024_Execution(t *testing.T) { }) } } + +func ptrToByte(v byte) *byte { + b := v + return &b +} From 289826fefbc9e36968807c37f9d5cd32a276fb12 Mon Sep 17 00:00:00 2001 From: Vadim Tertilov <97807449+rglKali@users.noreply.github.com> Date: Mon, 13 Apr 2026 14:42:34 +0200 Subject: [PATCH 065/183] cmd/abigen/v2: add package-level errors (#34076) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # Summary Replaces the inline `errors.New("event signature mismatch")` in generated `UnpackXxxEvent` methods with per-event package-level sentinel errors (e.g. `ErrTransferSignatureMismatch`, `ErrApprovalSignatureMismatch`), allowing callers to reliably distinguish a topic mismatch from a genuine decoding failure via `errors.Is`. Each event gets its own sentinel, generated via the abigen template: ```go var ErrTransferSignatureMismatch = errors.New("event signature mismatch") ``` This scoping is intentional — it allows callers to be precise about *which* event was mismatched, which is useful when routing logs across multiple unpackers. # Motivation Previously, all errors returned from `UnpackXxxEvent` were indistinguishable without string matching. This is especially problematic when processing logs sourced from `eth_getBlockReceipts`, where a caller receives the full set of logs for a block across all contracts and event types. In that context, a signature mismatch is expected and should be skipped, while any other error (malformed data, topic parsing failure) indicates something is genuinely wrong and should halt execution: ```go for _, log := range blockLogs { event, err := contract.UnpackTransferEvent(log) if errors.Is(err, gen.ErrTransferSignatureMismatch) { continue // not our event, expected } if err != nil { return fmt.Errorf("unexpected decode failure: %w", err) // alert } // process event } ``` **Changes:** - `abigen` template: generates a `ErrXxxSignatureMismatch` sentinel per event and returns it on topic mismatch instead of an inline error - Existing generated bindings & testdata: regenerated to reflect the update Implements #34075 --- accounts/abi/abigen/source2.go.tpl | 7 ++-- .../abi/abigen/testdata/v2/crowdsale.go.txt | 7 ++-- accounts/abi/abigen/testdata/v2/dao.go.txt | 35 +++++++++++++------ .../abigen/testdata/v2/eventchecker.go.txt | 35 +++++++++++++------ .../abigen/testdata/v2/nameconflict.go.txt | 7 ++-- .../testdata/v2/numericmethodname.go.txt | 7 ++-- .../abi/abigen/testdata/v2/overload.go.txt | 14 +++++--- accounts/abi/abigen/testdata/v2/token.go.txt | 7 ++-- accounts/abi/abigen/testdata/v2/tuple.go.txt | 14 +++++--- accounts/abi/bind/v2/base.go | 12 +++---- .../bind/v2/internal/contracts/db/bindings.go | 14 +++++--- .../v2/internal/contracts/events/bindings.go | 14 +++++--- accounts/abi/bind/v2/lib_test.go | 8 ++--- 13 files changed, 125 insertions(+), 56 deletions(-) diff --git a/accounts/abi/abigen/source2.go.tpl b/accounts/abi/abigen/source2.go.tpl index 3d98cbb700..c517caf6f4 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 b548b6cdae..f0bba246ab 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 c246771d6d..0e9adba31e 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 8ad59e63b1..d0600d7c3e 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 3fbabee5a5..5e4a9ecaf0 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 d962583e48..0af31a1cfb 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 ddddd10186..563edf7842 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 6ebc96861b..3bd60a6cdd 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 4724fdd351..10b634f3db 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/v2/base.go b/accounts/abi/bind/v2/base.go index 4f2013b4a3..862175ee32 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/internal/contracts/db/bindings.go b/accounts/abi/bind/v2/internal/contracts/db/bindings.go index 4ac1652ff7..2fc57fba6d 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 40d2c44a44..2eb5751f23 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 11360fc7dd..38dfa74dfa 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) } } } From 4da1e29320a75cd22accf835b26a696bae2bad68 Mon Sep 17 00:00:00 2001 From: Conor Patrick Date: Mon, 13 Apr 2026 09:30:36 -0400 Subject: [PATCH 066/183] signer/core/apitypes: fix encoding of opening parenthesis (#33702) This fixes a truncation bug that results in an invalid serialization of empty EIP712. For example: ```json { "method": "eth_signTypedData_v4", "request": { "types": { "EIP712Domain": [ { "name": "version", "type": "string" } ], "Empty": [] }, "primaryType": "Empty", "domain": { "version": "0" }, "message": {} } } ``` When calculating the type-hash for the stuct-hash, it will incorrectly use `Empty)` instead of `Empty()` --- signer/core/apitypes/types.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/signer/core/apitypes/types.go b/signer/core/apitypes/types.go index 401f4fba07..ee12bb263e 100644 --- a/signer/core/apitypes/types.go +++ b/signer/core/apitypes/types.go @@ -454,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() From 527ea11e501c5eadfd3e465f490333f8c2de999c Mon Sep 17 00:00:00 2001 From: phrwlk Date: Mon, 13 Apr 2026 16:46:13 +0300 Subject: [PATCH 067/183] core/vm/runtime: don't overwrite user input with default value (#33510) runtime.setDefaults was unconditionally assigning cfg.Random = &common.Hash{}, which silently overwrote any caller-provided Random value. This made it impossible to simulate a specific PREVRANDAO and also forced post-merge rules whenever London was active, regardless of the intended environment. This change only initializes cfg.Random when it is nil, matching how other fields in Config are defaulted. Existing callers that did not set Random keep the same behavior (a non-nil zero hash still enables post-merge semantics), while callers that explicitly set Random now get their value respected. --- core/vm/runtime/runtime.go | 4 +++- core/vm/runtime/runtime_test.go | 15 +++++++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index b40e99d047..af394aa054 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. diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go index a001d81623..40fb770454 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) { From 01e33d14be264178c4fce4776ecd16f155e94ae2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marius=20Kj=C3=A6rstad?= Date: Mon, 13 Apr 2026 16:32:40 +0200 Subject: [PATCH 068/183] build: upgrade -dlgo version to Go 1.25.9 (#34707) --- build/checksums.txt | 84 ++++++++++++++++++++++----------------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/build/checksums.txt b/build/checksums.txt index ba80a3e201..1832ce41dd 100644 --- a/build/checksums.txt +++ b/build/checksums.txt @@ -5,49 +5,49 @@ # https://github.com/ethereum/execution-spec-tests/releases/download/v5.1.0 a3192784375acec7eaec492799d5c5d0c47a2909a3cc40178898e4ecd20cc416 fixtures_develop.tar.gz -# version:golang 1.25.7 +# version:golang 1.25.9 # https://go.dev/dl/ -178f2832820274b43e177d32f06a3ebb0129e427dd20a5e4c88df2c1763cf10a go1.25.7.src.tar.gz -81bf2a1f20633f62d55d826d82dde3b0570cf1408a91e15781b266037299285b go1.25.7.aix-ppc64.tar.gz -bf5050a2152f4053837b886e8d9640c829dbacbc3370f913351eb0904cb706f5 go1.25.7.darwin-amd64.tar.gz -ff18369ffad05c57d5bed888b660b31385f3c913670a83ef557cdfd98ea9ae1b go1.25.7.darwin-arm64.tar.gz -c5dccd7f192dd7b305dc209fb316ac1917776d74bd8e4d532ef2772f305bf42a go1.25.7.dragonfly-amd64.tar.gz -a2de97c8ac74bf64b0ae73fe9d379e61af530e061bc7f8f825044172ffe61a8b go1.25.7.freebsd-386.tar.gz -055f9e138787dcafa81eb0314c8ff70c6dd0f6dba1e8a6957fef5d5efd1ab8fd go1.25.7.freebsd-amd64.tar.gz -60e7f7a7c990f0b9539ac8ed668155746997d404643a4eecd47b3dee1b7e710b go1.25.7.freebsd-arm.tar.gz -631e03d5fd4c526e2f499154d8c6bf4cb081afb2fff171c428722afc9539d53a go1.25.7.freebsd-arm64.tar.gz -8a264fd685823808140672812e3ad9c43f6ad59444c0dc14cdd3a1351839ddd5 go1.25.7.freebsd-riscv64.tar.gz -57c672447d906a1bcab98f2b11492d54521a791aacbb4994a25169e59cbe289a go1.25.7.illumos-amd64.tar.gz -2866517e9ca81e6a2e85a930e9b11bc8a05cfeb2fc6dc6cb2765e7fb3c14b715 go1.25.7.linux-386.tar.gz -12e6d6a191091ae27dc31f6efc630e3a3b8ba409baf3573d955b196fdf086005 go1.25.7.linux-amd64.tar.gz -ba611a53534135a81067240eff9508cd7e256c560edd5d8c2fef54f083c07129 go1.25.7.linux-arm64.tar.gz -1ba07e0eb86b839e72467f4b5c7a5597d07f30bcf5563c951410454f7cda5266 go1.25.7.linux-armv6l.tar.gz -775753fc5952a334c415f08768df2f0b73a3228a16e8f5f63d545daacb4e3357 go1.25.7.linux-loong64.tar.gz -1a023bb367c5fbb4c637a2f6dc23ff17c6591ad929ce16ea88c74d857153b307 go1.25.7.linux-mips.tar.gz -a8e97223d8aa6fdfd45f132a4784d2f536bbac5f3d63a24b63d33b6bfe1549af go1.25.7.linux-mips64.tar.gz -eb9edb6223330d5e20275667c65dea076b064c08e595fe4eba5d7d6055cfaccf go1.25.7.linux-mips64le.tar.gz -9c1e693552a5f9bb9e0012d1c5e01456ecefbc59bef53a77305222ce10aba368 go1.25.7.linux-mipsle.tar.gz -28a788798e7329acbbc0ac2caa5e4368b1e5ede646cc24429c991214cfb45c63 go1.25.7.linux-ppc64.tar.gz -42124c0edc92464e2b37b2d7fcd3658f0c47ebd6a098732415a522be8cb88e3f go1.25.7.linux-ppc64le.tar.gz -88d59c6893c8425875d6eef8e3434bc2fa2552e5ad4c058c6cd8cd710a0301c8 go1.25.7.linux-riscv64.tar.gz -c6b77facf666dc68195ecab05dbf0ebb4e755b2a8b7734c759880557f1c29b0c go1.25.7.linux-s390x.tar.gz -f14c184d9ade0ee04c7735d4071257b90896ecbde1b32adae84135f055e6399b go1.25.7.netbsd-386.tar.gz -7e7389e404dca1088c31f0fc07f1dd60891d7182bcd621469c14f7e79eceb3ff go1.25.7.netbsd-amd64.tar.gz -70388bb3ef2f03dbf1357e9056bd09034a67e018262557354f8cf549766b3f9d go1.25.7.netbsd-arm.tar.gz -8c1cda9d25bfc9b18d24d5f95fc23949dd3ff99fa408a6cfa40e2cf12b07e362 go1.25.7.netbsd-arm64.tar.gz -42f0d1bfbe39b8401cccb84dd66b30795b97bfc9620dfdc17c5cd4fcf6495cb0 go1.25.7.openbsd-386.tar.gz -e514879c0a28bc32123cd52c4c093de912477fe83f36a6d07517d066ef55391a go1.25.7.openbsd-amd64.tar.gz -8cd22530695a0218232bf7efea8f162df1697a3106942ac4129b8c3de39ce4ef go1.25.7.openbsd-arm.tar.gz -938720f6ebc0d1c53d7840321d3a31f29fd02496e84a6538f442a9311dc1cc9a go1.25.7.openbsd-arm64.tar.gz -a4c378b73b98f89a3596c2ef51aabbb28783d9ca29f7e317d8ca07939660ce6f go1.25.7.openbsd-ppc64.tar.gz -937b58734fbeaa8c7941a0e4285e7e84b7885396e8d11c23f9ab1a8ff10ff20e go1.25.7.openbsd-riscv64.tar.gz -61a093c8c5244916f25740316386bb9f141545dcf01b06a79d1c78ece488403e go1.25.7.plan9-386.tar.gz -7fc8f6689c9de8ccb7689d2278035fa83c2d601409101840df6ddfe09ba58699 go1.25.7.plan9-amd64.tar.gz -9661dff8eaeeb62f1c3aadbc5ff189a2e6744e1ec885e32dbcb438f58a34def5 go1.25.7.plan9-arm.tar.gz -28ecba0e1d7950c8b29a4a04962dd49c3bf5221f55a44f17d98f369f82859cf4 go1.25.7.solaris-amd64.tar.gz -baa6b488291801642fa620026169e38bec2da2ac187cd3ae2145721cf826bbc3 go1.25.7.windows-386.zip -c75e5f4ff62d085cc0017be3ad19d5536f46825fa05db06ec468941f847e3228 go1.25.7.windows-amd64.zip -807033f85931bc4a589ca8497535dcbeb1f30d506e47fa200f5f04c4a71c3d9f go1.25.7.windows-arm64.zip +0ec9ef8ebcea097aac37decae9f09a7218b451cd96be7d6ed513d8e4bcf909cf go1.25.9.src.tar.gz +b9ede6378a8f8d3d22bf52e68beb69ef7abdb65929ab2456020383002da15846 go1.25.9.aix-ppc64.tar.gz +92cb78fba4796e218c1accb0ea0a214ef2094c382049a244ad6505505d015fbe go1.25.9.darwin-amd64.tar.gz +9528be7329b9770631a6bd09ca2f3a73ed7332bec01d87435e75e92d8f130363 go1.25.9.darwin-arm64.tar.gz +918e44a471c5524caa52f74185064240d5eb343aa8023d604776511fc7adffa6 go1.25.9.dragonfly-amd64.tar.gz +2d67dbdfd09c6fcaa0e64485367ef43b8837ea200c663d6417183237bcddf83d go1.25.9.freebsd-386.tar.gz +9152d0c0badbfeb0c0e148e47c12bec28099d8cf2db60958810c879e0b679d07 go1.25.9.freebsd-amd64.tar.gz +437dca59604ad4a806a6a88e3d7ec1cd98ac9b402a3671629f4e553dd8b9888f go1.25.9.freebsd-arm.tar.gz +4c0fe53977412036fc8081e8d0992bbaabe4d3e1926137271ba11c2f5753300f go1.25.9.freebsd-arm64.tar.gz +d6087cdd1c084bd186132f29e0d032852a745f3c7619003d0fd5612c1fa58c8a go1.25.9.freebsd-riscv64.tar.gz +f82e49037e195cb62beae6a6ad83497157b2af5a01bad2f1dcb65df41080aabb go1.25.9.illumos-amd64.tar.gz +1e14a73bc2b19e370e0d4c57ba87aabfe8aef1e435e14d246742d48a13254f36 go1.25.9.linux-386.tar.gz +00859d7bd6defe8bf84d9db9e57b9a4467b2887c18cd93ae7460e713db774bc1 go1.25.9.linux-amd64.tar.gz +ec342e7389b7f489564ed5463c63b16cf8040023dabc7861256677165a8c0e2b go1.25.9.linux-arm64.tar.gz +7d4f0d266d871301e08ef4ac31c56e66048688893b2848392e5c600276351ee8 go1.25.9.linux-armv6l.tar.gz +f3460d901a14496bc609636e4accf9110ee1869d41c64af7e29cd567cffcf49b go1.25.9.linux-loong64.tar.gz +1da96ea449382ff96c09c55cee74815324e01d687d5ac6d2ade58244b8574306 go1.25.9.linux-mips.tar.gz +311a7f5f01f9a4bd51288b575eb619dc8e28e1fbc0cd78256a428b3ca668ff01 go1.25.9.linux-mips64.tar.gz +0b4edaf9e2ba3f0a079547effda70ec6a4b51a6ca3271a1147652c87ebcf3735 go1.25.9.linux-mips64le.tar.gz +42667340df264896f20b12261429d954e736e9772ab83ba289e68c30cf6f9628 go1.25.9.linux-mipsle.tar.gz +b9cbb3a4894b5aca6966c23452608435e8535278ef019b18d8898fbbfab67e74 go1.25.9.linux-ppc64.tar.gz +b0c41c7da1fc8d39020d65296a0dc54167afd9f76d67064e22c31ce3d839a739 go1.25.9.linux-ppc64le.tar.gz +2a630be8f854177c13e5fa75f7812c721369ecb9bd6e4c0fb1bd1c708d08b37c go1.25.9.linux-riscv64.tar.gz +0cf55136ac7eaccfc36d849054f849510ea289c2d959ffbed7b3866b4f484d17 go1.25.9.linux-s390x.tar.gz +eaf8167ff10a6a3e5dd304ef5f2e020b3a7379e76fa1011dc49c895800bf367c go1.25.9.netbsd-386.tar.gz +3cc6a861e62e23feae660984e0f2f14a2efb5d1f655900afee1d51af98919ae4 go1.25.9.netbsd-amd64.tar.gz +c2c44dca10e882c30553f4aa2ab8f6722b670fb12882378c8f461a9105d40188 go1.25.9.netbsd-arm.tar.gz +f301b71a8ec448053a5d2597df2e178120204bc9a33266c81600dd5d020a61b4 go1.25.9.netbsd-arm64.tar.gz +c4543b7fdef9707b4896810c69b4160a43ecec210af45c300f3abd78aa0c9e72 go1.25.9.openbsd-386.tar.gz +37275325e314f5ab7cf8ae65c4efc7cbfdaf20b41c6849549739b57a3ac97544 go1.25.9.openbsd-amd64.tar.gz +f9c05b6b315e979ecdd47354dd287c01708d6a88dc6ae7af74c84df8fa00df94 go1.25.9.openbsd-arm.tar.gz +4e999f42cf959ff95ca84af1ea1db3771000f5e57e157904bc2ffc72c75e29a2 go1.25.9.openbsd-arm64.tar.gz +0c7fa6c7c2b1cc13ad32fa94fc31273b4adf39c1e0f0e5dcedac158ff526af3f go1.25.9.openbsd-ppc64.tar.gz +347b33953a4b6e8df17719296f360f60878fe48a2d482ceb3637a3dfd4950065 go1.25.9.openbsd-riscv64.tar.gz +889f77d567c06832e0d332fe2458653dc66d43cded7ddbca6f72ce0ca60029cc go1.25.9.plan9-386.tar.gz +978b1f931fadec2f2516237d2649ee845d93c8eaf47dd196cfd8d26c7b2706a1 go1.25.9.plan9-amd64.tar.gz +30b9565e5ad0a212fe00990ead700c751b416eb2ef8d7c91a204945a7ff83a48 go1.25.9.plan9-arm.tar.gz +9e9125ff84ab3c3522ec758cab9540a17e9cba12bfcc34b6bf556cb89b522591 go1.25.9.solaris-amd64.tar.gz +bf40515f5f4d834fa9ead31ff75581e61a38ac27bf49840b95c5c998d321c0f6 go1.25.9.windows-386.zip +a7a710e225467b34e9e09fb432b829c86c9b2da5821ee5418f7eb2e8ae1a22cc go1.25.9.windows-amd64.zip +33cd73cf1b3ceee655ef71bc96e94006c02ae3c617fdd67ac9be3dfae3957449 go1.25.9.windows-arm64.zip # version:golangci 2.10.1 # https://github.com/golangci/golangci-lint/releases/ From e1fe4a1a98e531ded82805dd1724b189b3f22037 Mon Sep 17 00:00:00 2001 From: Charles Dusek <38732970+cgdusek@users.noreply.github.com> Date: Tue, 14 Apr 2026 02:43:44 -0500 Subject: [PATCH 069/183] p2p/discover: fix flaky TestUDPv5_findnodeHandling (#34109) Fixes #34108 The UDPv5 test harness (`newUDPV5Test`) uses the default `PingInterval` of 3 seconds. When tests like `TestUDPv5_findnodeHandling` insert nodes into the routing table via `fillTable`, the table's revalidation loop may schedule PING packets for those nodes. Under the race detector or on slow CI runners, the test runs long enough for revalidation to fire, causing background pings to be written to the test pipe. The `close()` method then finds these as unmatched packets and fails. The fix sets `PingInterval` to a very large value in the test harness so revalidation never fires during tests. Verified locally: 100 iterations with `-race -count=100` pass reliably, where previously the test would fail within ~50 iterations. --- p2p/discover/v5_udp_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/p2p/discover/v5_udp_test.go b/p2p/discover/v5_udp_test.go index 9429fbaf0a..1c41941c70 100644 --- a/p2p/discover/v5_udp_test.go +++ b/p2p/discover/v5_udp_test.go @@ -937,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 From c453b99a57abdce283864ee29f1c90a10e7c887a Mon Sep 17 00:00:00 2001 From: Csaba Kiraly Date: Tue, 14 Apr 2026 12:15:39 +0200 Subject: [PATCH 070/183] cmd/devp2p/internal/v5test: fix hive test for discv5 findnode results (#34043) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This fixes the remaining Hive discv5/FindnodeResults failures in the cmd/devp2p/internal/v5test fixture. The issue was in the simulator-side bystander behavior, not in production discovery logic. The existing fixture could get bystanders inserted into the remote table, but under current geth behavior they were not stable enough to remain valid FINDNODE results. In particular, the fixture still had a few protocol/behavior mismatches: - incomplete WHOAREYOU recovery - replies not consistently following the UDP envelope source - incorrect endpoint echoing in PONG - fixture-originated PING using the wrong ENR sequence - bystanders answering background FINDNODE with empty NODES That last point was important because current lookup accounting can treat repeatedly unhelpful FINDNODE interactions as failures. As a result, a bystander could become live via PING/PONG and still later be dropped from the table before the final FindnodeResults assertion. This change updates the fixture so that bystanders behave more like stable discv5 peers: - perform one explicit initial handshake, then switch to passive response handling - resend the exact challenged packet when handling WHOAREYOU - reply to the actual UDP packet source and mirror that source in PONG.ToIP / PONG.ToPort - use the bystander’s own ENR sequence in fixture-originated PING - prefill each bystander with the bystander ENR set and answer FINDNODE from that set The result is that the fixture now forms a small self-consistent lookup environment instead of a set of peers that are live but systematically poor lookup participants. --- cmd/devp2p/internal/v5test/discv5tests.go | 196 +++++++++++++--------- cmd/devp2p/internal/v5test/framework.go | 50 ++++-- 2 files changed, 154 insertions(+), 92 deletions(-) diff --git a/cmd/devp2p/internal/v5test/discv5tests.go b/cmd/devp2p/internal/v5test/discv5tests.go index efe9144069..4dc2507693 100644 --- a/cmd/devp2p/internal/v5test/discv5tests.go +++ b/cmd/devp2p/internal/v5test/discv5tests.go @@ -257,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) @@ -295,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 + dest *enode.Node + conn *conn + l net.PacketConn + known []*enode.Node - addedCh chan enode.ID - done sync.WaitGroup + 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 @@ -351,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) { - case *v5wire.Ping: - bn.conn.write(bn.l, &v5wire.Pong{ - ReqID: p.ReqID, - ENRSeq: bn.conn.localNode.Seq(), - ToIP: bn.dest.IP(), - ToPort: uint16(bn.dest.UDP()), - }, nil) - wasAdded = true - bn.notifyAdded() - case *v5wire.Findnode: - bn.conn.write(bn.l, &v5wire.Nodes{ReqID: p.ReqID, RespCount: 1}, nil) - wasAdded = true - bn.notifyAdded() - case *v5wire.TalkRequest: - bn.conn.write(bn.l, &v5wire.TalkResponse{ReqID: p.ReqID}, nil) - case *readError: - if !netutil.IsTemporaryError(p.err) { - bn.conn.logf("shutting down: %v", p.err) - return + 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: + resp := &v5wire.Pong{ + ReqID: append([]byte(nil), p.ReqID...), + ENRSeq: bn.conn.localNode.Seq(), + 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: + 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: + 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) || 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 acab1eef79..0532dafb2c 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,24 +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, _, err := c.ReadFrom(buf) + n, from, err := c.ReadFrom(buf) if err != nil { - return &readError{err} + return &readError{err}, nil } - // Always use tc.remoteAddr for session lookup. The actual source address of - // the packet may differ from tc.remoteAddr when the remote node is reachable - // via multiple networks (e.g. Docker bridge vs. overlay), but the codec's - // session cache is keyed by the address used during Encode. + 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. From c2234462a84c1bb6000cfcc6195404d1caabf2a7 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Tue, 14 Apr 2026 14:47:43 +0200 Subject: [PATCH 071/183] .github/workflows: add freebsd test github action (#34078) This is meant to be run daily, in order to verify the FreeBSD build wasn't broken like last time. --- .github/workflows/freebsd.yml | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 .github/workflows/freebsd.yml diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml new file mode 100644 index 0000000000..8f58ebee9a --- /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 From c690d6041e058ffbe96ce7fbea9956de9aa964a1 Mon Sep 17 00:00:00 2001 From: jvn Date: Tue, 14 Apr 2026 18:28:27 +0530 Subject: [PATCH 072/183] cmd/geth: add Prague pruning points for hoodi (#34714) Adds config to add Prague prune point for the hoodi testnet. --- core/history/historymode.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/history/historymode.go b/core/history/historymode.go index 1adfe014b2..2ba746e7dd 100644 --- a/core/history/historymode.go +++ b/core/history/historymode.go @@ -107,6 +107,10 @@ var staticPrunePoints = map[HistoryMode]map[common.Hash]*PrunePoint{ BlockNumber: 7836331, BlockHash: common.HexToHash("0xe6571beb68bf24dbd8a6ba354518996920c55a3f8d8fdca423e391b8ad071f22"), }, + params.HoodiGenesisHash: { + BlockNumber: 60412, + BlockHash: common.HexToHash("0x1562792812ef418eaafc8f1f093d84d9634971e9dd6b0771302eb5b9fd4d2c46"), + }, }, } From 2414861d36a23b7ddf91275d7a95bcdac636a0f4 Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 14 Apr 2026 21:39:42 +0800 Subject: [PATCH 073/183] core/state: optimize transient storage (#33695) Optimizes the transient storage. Turns it from a map of maps into a single map keyed by . --- core/state/statedb_test.go | 2 +- core/state/transient_storage.go | 56 +++++++++++++++------------------ 2 files changed, 27 insertions(+), 31 deletions(-) diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index d29b262eea..680602631e 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -641,7 +641,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()) diff --git a/core/state/transient_storage.go b/core/state/transient_storage.go index 3bb4955425..a3cfaceb3e 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() From eb67d6193344db0a11cb6b344e4ad781e07bc51f Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Tue, 14 Apr 2026 21:54:36 +0800 Subject: [PATCH 074/183] cmd/geth, core/state, tests: rework EIP7610 check (#34718) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR simplifies the implementation of EIP-7610 by eliminating the need to check storage emptiness during contract deployment. EIP-7610 specifies that contract creation must be rejected if the destination account has a non-zero nonce, non-empty runtime code, or **non-empty storage**. After EIP-161, all newly deployed contracts are initialized with a nonce of one. As a result, such accounts are no longer eligible as deployment targets unless they are explicitly cleared. However, prior to EIP-161, contracts were initialized with a nonce of zero. This made it possible to end up with accounts that have: - zero nonce - empty runtime code - non-empty storage (created during constructor execution) - non-zero balance These edge-case accounts complicate the storage emptiness check. In practice, contract addresses are derived using one of the following formulas: - `Keccak256(rlp({sender, nonce}))[12:]` - `Keccak256([]byte{0xff}, sender, salt[:], initHash)[12:]` As such, an existing address is not selected as a deployment target unless a collision occurs, which is extremely unlikely. --- Previously, verifying storage emptiness relied on GetStorageRoot. However, with the transition to the block-based access list (BAL), the storage root is no longer available, as computing it would require reconstructing the full storage trie from all mutations of preceding transactions. To address this, this PR introduces a simplified approach: it hardcodes the set of known accounts that have zero nonce, empty runtime code, but non-empty storage and non-zero balance. During contract deployment, if the destination address belongs to this set, the deployment is rejected. This check is applied retroactively back to genesis. Since no address collision events have occurred in Ethereum’s history, this change does not alter existing behavior. Instead, it serves as a safeguard for future state transitions. --- cmd/geth/snapshot.go | 108 +++++++++++++++++++++++++++++ core/state/statedb.go | 3 + core/state/statedb_hooked.go | 4 -- core/state/statedb_test.go | 16 ++--- core/state/trie_prefetcher_test.go | 5 +- core/vm/eip7610.go | 98 ++++++++++++++++++++++++++ core/vm/eip7610_test.go | 62 +++++++++++++++++ core/vm/evm.go | 3 +- core/vm/interface.go | 1 - tests/block_test.go | 12 ++++ tests/state_test.go | 11 +++ 11 files changed, 304 insertions(+), 19 deletions(-) create mode 100644 core/vm/eip7610.go create mode 100644 core/vm/eip7610_test.go diff --git a/cmd/geth/snapshot.go b/cmd/geth/snapshot.go index c177fb5ea2..d168ee1d7d 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" @@ -168,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. `, }, }, @@ -801,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/core/state/statedb.go b/core/state/statedb.go index 8b09ea89f6..a4207a10c2 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -338,6 +338,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 { diff --git a/core/state/statedb_hooked.go b/core/state/statedb_hooked.go index 52cf98d19b..687c4bb52b 100644 --- a/core/state/statedb_hooked.go +++ b/core/state/statedb_hooked.go @@ -98,10 +98,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) } diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index 680602631e..6936372c50 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, diff --git a/core/state/trie_prefetcher_test.go b/core/state/trie_prefetcher_test.go index 41349c0c0e..dad208d01a 100644 --- a/core/state/trie_prefetcher_test.go +++ b/core/state/trie_prefetcher_test.go @@ -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/vm/eip7610.go b/core/vm/eip7610.go new file mode 100644 index 0000000000..883f4502b5 --- /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 0000000000..f881020c5c --- /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/evm.go b/core/vm/evm.go index 4df2627486..cfc837fb62 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -532,10 +532,9 @@ 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 + isEIP7610RejectedAccount(evm.ChainConfig().ChainID, address, evm.chainRules.IsEIP158) { if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) } diff --git a/core/vm/interface.go b/core/vm/interface.go index d7c4340e06..41b52a10dc 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -52,7 +52,6 @@ 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) diff --git a/tests/block_test.go b/tests/block_test.go index c718b304b6..0f087967bb 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/state_test.go b/tests/state_test.go index f80bda4372..25e90d388d 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -57,6 +57,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 +97,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) }) From 2253fce48d29cf252ae57f28e8bbd14e133b14c3 Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 14 Apr 2026 22:09:17 +0800 Subject: [PATCH 075/183] core/types: remove redundant ')' (#34719) --- core/types/tx_legacy.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/types/tx_legacy.go b/core/types/tx_legacy.go index 49f0a98809..eca9e210af 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. From c9fea44616560d42c4a67704c1cb79a1445741f8 Mon Sep 17 00:00:00 2001 From: felipe Date: Tue, 14 Apr 2026 17:00:29 -0600 Subject: [PATCH 076/183] eth/catalyst: respect slot num if specified in payload attributes for `testing_buildBlockV1` (#34722) This is a copy of #34721 but against `master` (rather than `bal-devnet-3`), as requested by @jwasinger, since the slotnum logic now exists on `master` as well. --- eth/catalyst/api_testing.go | 1 + 1 file changed, 1 insertion(+) diff --git a/eth/catalyst/api_testing.go b/eth/catalyst/api_testing.go index 8586029468..2818d7f0bb 100644 --- a/eth/catalyst/api_testing.go +++ b/eth/catalyst/api_testing.go @@ -74,6 +74,7 @@ func (api *testingAPI) BuildBlockV1(parentHash common.Hash, payloadAttributes en Random: payloadAttributes.Random, Withdrawals: payloadAttributes.Withdrawals, BeaconRoot: payloadAttributes.BeaconRoot, + SlotNum: payloadAttributes.SlotNumber, } return api.eth.Miner().BuildTestingPayload(args, txs, buildEmpty, extra) } From ef0f1f96f96a90a3ff9ac78605ef7e28cb871b8f Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Wed, 15 Apr 2026 11:15:43 +0800 Subject: [PATCH 077/183] core/state: ignore the root returned in Commit function for simplicity (#34723) StateDB.Commit first commits all storage changes into the storage trie, then updates the account metadata with the new storage root into the account trie. Within StateDB.Commit, the new storage trie root has already been computed and applied as the storage root. This PR explicitly skips the redundant storage trie root assignment for readability. --- core/state/state_object.go | 5 +++-- core/state/statedb.go | 7 ++----- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/core/state/state_object.go b/core/state/state_object.go index ec0c511737..a4a9f5121b 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -482,8 +482,9 @@ func (s *stateObject) commit() (*accountUpdate, *trienode.NodeSet, error) { s.origin = s.data.Copy() return op, nil, nil } - root, nodes := s.trie.Commit(false) - s.data.Root = root + // 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 } diff --git a/core/state/statedb.go b/core/state/statedb.go index a4207a10c2..fc2da59a05 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -1162,7 +1162,7 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool, blockNum 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 { @@ -1224,7 +1224,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 @@ -1238,9 +1237,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 } From 0b35ad95f5cf307e243a7ec338fc1f443d66cecc Mon Sep 17 00:00:00 2001 From: Rahman Date: Thu, 16 Apr 2026 06:17:01 +0300 Subject: [PATCH 078/183] cmd/utils: fix witness stats auto-enable to respect config file (#34729) Auto-enable logic for `StatelessSelfValidation` was reading CLI flag directly via `ctx.Bool()`, bypassing the merged `cfg.EnableWitnessStats` value. Now uses `cfg.EnableWitnessStats` so config file settings trigger the same auto-enable behavior as CLI flags. --- cmd/utils/flags.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index c1284044eb..b6f64bdc15 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -1899,7 +1899,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 } From d07a946a5b9a94125e682bdc89cf4e49d43ae6c2 Mon Sep 17 00:00:00 2001 From: Jonny Rhea <5555162+jrhea@users.noreply.github.com> Date: Thu, 16 Apr 2026 01:53:08 -0500 Subject: [PATCH 079/183] =?UTF-8?q?log:=20allow=20=E2=80=93vmodule=20to=20?= =?UTF-8?q?downgrade=20log=20levels=20(#33111)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Changes the log handler to check for vmodule level overrides even for messages above the current level. This enables the user to selectively hide messages from certain packages, among other things. Also fixes a bug where handler instances created by WithAttr would not follow the level setting anymore. The WithAttrs method is calledd by slog.Logger.With, which we also use in go-ethereum to create context specific loggers with pre-filled attributes. Under the previous implementation of WithAttrs, if the application created a long-lived logger (for example, for a specific peer), then that logger would not be affected by later level changes done on the top-level logger, leading to potentially missed events. Closes: #30717 --------- Co-authored-by: Marius van der Wijden Co-authored-by: Felix Lange --- log/handler_glog.go | 147 ++++++++++++++++++++++++-------------------- log/logger_test.go | 58 +++++++++++++++++ 2 files changed, 139 insertions(+), 66 deletions(-) diff --git a/log/handler_glog.go b/log/handler_glog.go index 739f8c5b42..13afb62ca4 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) - } +func (h *GlogHandler) Handle(ctx context.Context, r slog.Record) error { + return h.handle(ctx, r, h.origin) +} - // Check callsite cache for previously calculated log levels - h.lock.RLock() - lvl, ok := h.siteCache[r.PC] - h.lock.RUnlock() - - // 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 dae8497204..c585ddab66 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")})) From b1baab4427ef8d6f1b09c9465a89a46623d5fbde Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Thu, 16 Apr 2026 16:16:53 +0800 Subject: [PATCH 080/183] cmd/evm: fix trace.noreturndata usage string (#34731) `trace.noreturndata` is documented as "enable return data output" but the flag name/value imply it disables return data. This is confusing for users and likely inverted wording. Update the Usage string to reflect the actual behavior (disable return data output). --- cmd/evm/main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 77a06bec26..2b77741738 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, } From f63e9f3a80cd568f6d68c3c9858839784220d038 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Thu, 16 Apr 2026 10:51:26 +0200 Subject: [PATCH 081/183] eth/tracers: fix codehash in prestate diffmode (#34675) Fixes https://github.com/ethereum/go-ethereum/issues/34648. --- .../eip7702_deauth.json | 98 +++++++++++++++++++ eth/tracers/native/gen_account_json.go | 6 +- eth/tracers/native/prestate.go | 38 ++++--- 3 files changed, 125 insertions(+), 17 deletions(-) create mode 100644 eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/eip7702_deauth.json 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 0000000000..e376a98946 --- /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/native/gen_account_json.go b/eth/tracers/native/gen_account_json.go index 5fec2648b7..9417536a23 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/prestate.go b/eth/tracers/native/prestate.go index 159a91b310..36cb16e44b 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 { @@ -266,24 +269,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 +330,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. From ba215fd927b2e6377a64cb0b4ce668f106763119 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Fri, 17 Apr 2026 02:55:54 +0200 Subject: [PATCH 082/183] cmd, core, trie, triedb: split CachingDB into merkle + binary dbs. (#34700) This Pr implements some prerequisite changes for #34004 : split the `CachingDB` into a `MerkleDB` and a `UBTDB`, so that very different behaviors don't clash as much. The transition isn't handled by this PR, but after talking to Gary we agreed that `UBTDB` should receive another `triedb`, which will only be loaded if the `Ended` flag is set to false in the conversion contract. If this is too hard to achieve, it makes sense to load it regardless, and then loading can be prevented at a later stage by adding a `UBTTransitionFinalizationTime` in `ChainConfig`. --------- Co-authored-by: Gary Rong --- cmd/evm/internal/t8ntool/execution.go | 4 +- cmd/evm/internal/t8ntool/transition.go | 6 +- cmd/geth/bintrie_convert.go | 2 +- cmd/geth/bintrie_convert_test.go | 8 +- cmd/geth/chaincmd.go | 10 +- cmd/geth/config.go | 6 +- cmd/geth/main.go | 2 +- cmd/utils/flags.go | 10 +- core/bintrie_witness_test.go | 34 +-- core/blockchain.go | 30 ++- core/blockchain_reader.go | 35 ++- core/blockchain_test.go | 2 +- core/chain_makers.go | 12 +- core/genesis.go | 44 ++-- core/genesis_test.go | 12 +- core/overlay/state_transition.go | 6 +- core/state/database.go | 199 +++--------------- core/state/database_history.go | 6 + core/state/database_mpt.go | 178 ++++++++++++++++ core/state/database_ubt.go | 138 ++++++++++++ core/state/reader.go | 6 +- core/state/state_object.go | 4 +- core/state/statedb.go | 14 +- core/state/statedb_fuzz_test.go | 2 +- core/state/statedb_test.go | 6 +- core/state/trie_prefetcher.go | 16 +- core/state/trie_prefetcher_test.go | 2 +- core/state_processor.go | 4 +- core/txpool/blobpool/blobpool.go | 6 +- core/txpool/blobpool/blobpool_test.go | 7 +- core/txpool/blobpool/interface.go | 7 +- core/txpool/legacypool/legacypool.go | 13 +- core/txpool/legacypool/legacypool_test.go | 6 +- core/txpool/locals/tx_tracker_test.go | 4 +- core/txpool/txpool.go | 13 +- core/types/hashes.go | 3 - core/vm/contracts.go | 2 +- core/vm/evm.go | 2 +- core/vm/jump_table_export.go | 2 +- eth/api_backend.go | 8 +- eth/api_debug.go | 6 +- eth/backend.go | 4 +- eth/catalyst/api_test.go | 8 +- eth/ethconfig/config.go | 4 +- eth/ethconfig/gen_config.go | 10 +- eth/gasprice/gasprice_test.go | 2 +- eth/state_accessor.go | 7 +- eth/tracers/api.go | 4 +- eth/tracers/api_test.go | 2 +- .../tracetest/selfdestruct_state_test.go | 2 +- internal/ethapi/api_test.go | 2 +- internal/ethapi/simulate.go | 2 +- miner/miner_test.go | 6 +- miner/worker.go | 2 +- params/config.go | 64 +++--- tests/block_test_util.go | 4 +- tests/init.go | 2 +- tests/state_test_util.go | 2 +- trie/bintrie/trie.go | 4 +- trie/secure_trie.go | 2 +- trie/transitiontrie/transition.go | 4 +- triedb/database.go | 18 +- triedb/pathdb/database.go | 20 +- triedb/pathdb/database_test.go | 4 +- triedb/pathdb/history.go | 6 +- triedb/pathdb/layertree_test.go | 102 ++++----- triedb/pathdb/reader.go | 2 +- 67 files changed, 703 insertions(+), 463 deletions(-) create mode 100644 core/state/database_mpt.go create mode 100644 core/state/database_ubt.go diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index efe22d36f5..f17829ec53 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -146,7 +146,7 @@ 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) + isEIP4762 = chainConfig.IsUBT(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) statedb = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre, isEIP4762) signer = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp) gaspool = core.NewGasPool(pre.Env.GasLimit) @@ -378,7 +378,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 diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index d7cdc98e74..6a23e9dc70 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -228,7 +228,7 @@ func Transition(ctx *cli.Context) error { collector = make(Alloc) btleaves map[common.Hash]hexutil.Bytes ) - isBinary := chainConfig.IsVerkle(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) + isBinary := chainConfig.IsUBT(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) if !isBinary { s.DumpToCollector(collector, nil) } else { @@ -452,7 +452,7 @@ 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) @@ -496,7 +496,7 @@ 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) diff --git a/cmd/geth/bintrie_convert.go b/cmd/geth/bintrie_convert.go index 3730768697..43d2e629ac 100644 --- a/cmd/geth/bintrie_convert.go +++ b/cmd/geth/bintrie_convert.go @@ -144,7 +144,7 @@ func convertToBinaryTrie(ctx *cli.Context) error { defer srcTriedb.Close() destTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ - IsVerkle: true, + IsUBT: true, PathDB: &pathdb.Config{ JournalDirectory: stack.ResolvePath("triedb-bintrie"), }, diff --git a/cmd/geth/bintrie_convert_test.go b/cmd/geth/bintrie_convert_test.go index 9b95f6a70f..50ae752358 100644 --- a/cmd/geth/bintrie_convert_test.go +++ b/cmd/geth/bintrie_convert_test.go @@ -82,8 +82,8 @@ func TestBintrieConvert(t *testing.T) { defer srcTriedb2.Close() destTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ - IsVerkle: true, - PathDB: pathdb.Defaults, + IsUBT: true, + PathDB: pathdb.Defaults, }) defer destTriedb.Close() @@ -190,8 +190,8 @@ func TestBintrieConvertDeleteSource(t *testing.T) { }) destTriedb := triedb.NewDatabase(chaindb, &triedb.Config{ - IsVerkle: true, - PathDB: pathdb.Defaults, + IsUBT: true, + PathDB: pathdb.Defaults, }) bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go index 1084100f39..0aacb0878a 100644 --- a/cmd/geth/chaincmd.go +++ b/cmd/geth/chaincmd.go @@ -64,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. @@ -297,15 +297,15 @@ 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, nil) diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 720d1ef9fc..8e2db32d76 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -235,9 +235,9 @@ 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. diff --git a/cmd/geth/main.go b/cmd/geth/main.go index e196ac8688..ae869ec970 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -64,7 +64,7 @@ var ( utils.OverrideOsaka, utils.OverrideBPO1, utils.OverrideBPO2, - utils.OverrideVerkle, + utils.OverrideUBT, utils.OverrideGenesisFlag, utils.EnablePersonal, // deprecated utils.TxPoolLocalsFlag, diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index b6f64bdc15..aff45087db 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -264,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{ @@ -2516,10 +2516,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/core/bintrie_witness_test.go b/core/bintrie_witness_test.go index 7704ba41fb..e4cb34cb56 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,16 +51,16 @@ 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) @@ -69,12 +69,12 @@ func TestProcessVerkle(t *testing.T) { // 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) + 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,7 +87,7 @@ 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) @@ -188,7 +188,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 +196,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 +205,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 +215,22 @@ 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.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/blockchain.go b/core/blockchain.go index 35b2d35dc7..296ef6bc16 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -258,10 +258,10 @@ 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, + IsUBT: isUBT, } if cfg.StateScheme == rawdb.HashScheme { config.HashDB = &hashdb.Config{ @@ -378,7 +378,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 } @@ -2116,11 +2116,29 @@ func (bc *BlockChain) ProcessBlock(ctx context.Context, parentRoot common.Hash, startTime = time.Now() statedb *state.StateDB interrupt atomic.Bool - sdb = state.NewDatabase(bc.triedb, bc.codedb).WithSnapshot(bc.snaps) + sdb state.Database ) defer interrupt.Store(true) // terminate the prefetch at the end - if bc.cfg.NoPrefetch { + 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 @@ -2131,7 +2149,7 @@ func (bc *BlockChain) ProcessBlock(ctx context.Context, parentRoot common.Hash, // // Note: the main processor and prefetcher share the same reader with a local // cache for mitigating the overhead of state access. - prefetch, process, err := sdb.ReadersWithCacheStats(parentRoot) + prefetch, process, err := warmer.ReadersWithCacheStats(parentRoot) if err != nil { return nil, err } diff --git a/core/blockchain_reader.go b/core/blockchain_reader.go index 3614702d1a..18afa9ce9d 100644 --- a/core/blockchain_reader.go +++ b/core/blockchain_reader.go @@ -416,19 +416,42 @@ func (bc *BlockChain) ContractCodeWithPrefix(hash common.Hash) []byte { // 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, state.NewDatabase(bc.triedb, bc.codedb).WithSnapshot(bc.snaps)) +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)) } -// HistoricState returns a historic state specified by the given root. +// 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 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.triedb, bc.codedb)) +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. diff --git a/core/blockchain_test.go b/core/blockchain_test.go index d3ca21b2b3..1a2ee45291 100644 --- a/core/blockchain_test.go +++ b/core/blockchain_test.go @@ -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) } diff --git a/core/chain_makers.go b/core/chain_makers.go index 8f6eed1697..3bc7f6528b 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -126,7 +126,7 @@ func (b *BlockGen) addTx(bc *BlockChain, vmConfig vm.Config, tx *types.Transacti // 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) @@ -392,7 +392,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 @@ -430,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() @@ -479,8 +479,8 @@ 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 } genesisTriedb := triedb.NewDatabase(db, triedbConfig) block, err := genesis.Commit(db, genesisTriedb, nil) diff --git a/core/genesis.go b/core/genesis.go index 6edc6e6779..d77ea10d8c 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -129,22 +129,22 @@ func ReadGenesis(db ethdb.Database) (*Genesis, error) { } // 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, } } // 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)) @@ -168,8 +168,8 @@ func hashAlloc(ga *types.GenesisAlloc, isVerkle bool) (common.Hash, error) { // generated states will be persisted into the given database. 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 { @@ -276,10 +276,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. @@ -296,8 +296,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() } @@ -469,15 +469,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) } @@ -609,24 +609,24 @@ func (g *Genesis) MustCommit(db ethdb.Database, triedb *triedb.Database) *types. 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 2ff64e8d21..e15ad00222 100644 --- a/core/genesis_test.go +++ b/core/genesis_test.go @@ -285,16 +285,16 @@ func TestVerkleGenesisCommit(t *testing.T) { CancunTime: &verkleTime, PragueTime: &verkleTime, OsakaTime: &verkleTime, - VerkleTime: &verkleTime, + UBTTime: &verkleTime, 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, }, } @@ -320,8 +320,8 @@ func TestVerkleGenesisCommit(t *testing.T) { config.NoAsyncFlush = true triedb := triedb.NewDatabase(db, &triedb.Config{ - IsVerkle: true, - PathDB: &config, + IsUBT: true, + PathDB: &config, }) block := genesis.MustCommit(db, triedb) if !bytes.Equal(block.Root().Bytes(), expected) { @@ -329,7 +329,7 @@ func TestVerkleGenesisCommit(t *testing.T) { } // Test that the trie is verkle - if !triedb.IsVerkle() { + if !triedb.IsUBT() { t.Fatalf("expected trie to be verkle") } vdb := rawdb.NewTable(db, string(rawdb.VerklePrefix)) diff --git a/core/overlay/state_transition.go b/core/overlay/state_transition.go index a52d9139c9..afd2bab017 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", "verkle", isVerkle) + 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/state/database.go b/core/state/database.go index c603e3ad7a..6de58af63b 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -20,22 +20,36 @@ import ( "fmt" "github.com/ethereum/go-ethereum/common" - "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/log" "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/triedb" ) +// DatabaseType represents the type of trie backing the state database. +type DatabaseType int + +const ( + // TypeMPT indicates a Merkle Patricia Trie (MPT) backed database. + TypeMPT DatabaseType = iota + + // 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) @@ -139,184 +153,27 @@ 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 { - triedb *triedb.Database - codedb *CodeDB - snap *snapshot.Tree + // 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, codedb *CodeDB) *CachingDB { - if codedb == nil { - codedb = NewCodeDB(triedb.Disk()) - } - return &CachingDB{ - triedb: triedb, - codedb: codedb, +// +// 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 { +func NewDatabaseForTesting() Database { db := rawdb.NewMemoryDatabase() return NewDatabase(triedb.NewDatabase(db, nil), NewCodeDB(db)) } -// WithSnapshot configures the provided contract code cache. Note that this -// registration must be performed before the cachingDB is used. -func (db *CachingDB) WithSnapshot(snapshot *snapshot.Tree) *CachingDB { - db.snap = snapshot - return db -} - -// StateReader returns a state reader associated with the specified state root. -func (db *CachingDB) 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 := newTrieReader(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 *CachingDB) 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 *CachingDB) 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 *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 -} - -// TrieDB retrieves any intermediate trie-node caching layer. -func (db *CachingDB) TrieDB() *triedb.Database { - return db.triedb -} - -// Snapshot returns the underlying state snapshot. -func (db *CachingDB) Snapshot() *snapshot.Tree { - return db.snap -} - -// 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 *CachingDB) 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 - } - } - // 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, update.accounts, update.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, update.stateSet()) -} - -// Iteratee returns a state iteratee associated with the specified state root, -// through which the account iterator and storage iterator can be created. -func (db *CachingDB) Iteratee(root common.Hash) (Iteratee, error) { - return newStateIteratee(!db.triedb.IsVerkle(), root, db.triedb, db.snap) -} - // mustCopyTrie returns a deep-copied trie. func mustCopyTrie(t Trie) Trie { switch t := t.(type) { diff --git a/core/state/database_history.go b/core/state/database_history.go index 0dbb8cc546..d1ed2fe194 100644 --- a/core/state/database_history.go +++ b/core/state/database_history.go @@ -223,6 +223,12 @@ type HistoricDB struct { 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(triedb *triedb.Database, codedb *CodeDB) *HistoricDB { return &HistoricDB{ diff --git a/core/state/database_mpt.go b/core/state/database_mpt.go new file mode 100644 index 0000000000..bf9c7c9fff --- /dev/null +++ b/core/state/database_mpt.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 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 := newTrieReader(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 + } + } + // 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, update.accounts, update.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, update.stateSet()) +} + +// 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 0000000000..39aa64508b --- /dev/null +++ b/core/state/database_ubt.go @@ -0,0 +1,138 @@ +// 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 := newTrieReader(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) +} + +// 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 + } + } + return db.triedb.Update(update.root, update.originRoot, update.blockNumber, update.nodes, update.stateSet()) +} + +// 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/reader.go b/core/state/reader.go index fe0ec71f2d..b837c6a0a1 100644 --- a/core/state/reader.go +++ b/core/state/reader.go @@ -172,10 +172,10 @@ func newTrieReader(root common.Hash, db *triedb.Database) (*trieReader, error) { tr Trie err error ) - if !db.IsVerkle() { + if !db.IsUBT() { tr, err = trie.NewStateTrie(trie.StateTrieID(root), db) } else { - // When IsVerkle() is true, create a BinaryTrie wrapped in TransitionTrie + // When IsUBT() is true, create a BinaryTrie wrapped in TransitionTrie binTrie, binErr := bintrie.NewBinaryTrie(root, db) if binErr != nil { return nil, binErr @@ -259,7 +259,7 @@ func (r *trieReader) Storage(addr common.Address, key common.Hash) (common.Hash, found bool value common.Hash ) - if r.db.IsVerkle() { + if r.db.IsUBT() { tr = r.mainTrie } else { tr, found = r.subTries[addr] diff --git a/core/state/state_object.go b/core/state/state_object.go index a4a9f5121b..a812359368 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -154,7 +154,7 @@ 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 @@ -478,7 +478,7 @@ func (s *stateObject) commit() (*accountUpdate, *trienode.NodeSet, error) { // 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().IsVerkle() { + if s.db.GetTrie().IsUBT() { s.origin = s.data.Copy() return op, nil, nil } diff --git a/core/state/statedb.go b/core/state/statedb.go index fc2da59a05..956871472d 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -190,7 +190,7 @@ func NewWithReader(root common.Hash, db Database, reader Reader) (*StateDB, erro accessList: newAccessList(), transientStorage: newTransientStorage(), } - if db.TrieDB().IsVerkle() { + if db.Type().Is(TypeUBT) { sdb.accessEvents = NewAccessEvents() } return sdb, nil @@ -861,7 +861,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { start = time.Now() workers errgroup.Group ) - if s.db.TrieDB().IsVerkle() { + 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, @@ -925,9 +925,9 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { } } // 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 @@ -968,7 +968,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 && !s.db.TrieDB().IsVerkle() { + 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 { @@ -1129,7 +1129,7 @@ func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*acco 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 { diff --git a/core/state/statedb_fuzz_test.go b/core/state/statedb_fuzz_test.go index 3582185344..a8017e5568 100644 --- a/core/state/statedb_fuzz_test.go +++ b/core/state/statedb_fuzz_test.go @@ -209,7 +209,7 @@ func (test *stateTest) run() bool { if i != 0 { root = roots[len(roots)-1] } - state, err := New(root, NewDatabase(tdb, nil).WithSnapshot(snaps)) + state, err := New(root, NewMPTDatabase(tdb, nil).WithSnapshot(snaps)) if err != nil { panic(err) } diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index 6936372c50..601970ff20 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -1274,7 +1274,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, nil).WithSnapshot(snaps) + db = NewMPTDatabase(tdb, nil).WithSnapshot(snaps) state, _ = New(types.EmptyRootHash, db) addr = common.HexToAddress("0x1") ) @@ -1288,8 +1288,8 @@ 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, nil).WithSnapshot(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 diff --git a/core/state/trie_prefetcher.go b/core/state/trie_prefetcher.go index a9faddcdff..a0310eb3b3 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 dad208d01a..8a03d93a08 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) diff --git a/core/state_processor.go b/core/state_processor.go index bbb1341299..0a324379f9 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -90,7 +90,7 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated if beaconRoot := block.BeaconRoot(); beaconRoot != nil { ProcessBeaconBlockRoot(*beaconRoot, evm) } - if config.IsPrague(block.Number(), block.Time()) || config.IsVerkle(block.Number(), block.Time()) { + if config.IsPrague(block.Number(), block.Time()) || config.IsUBT(block.Number(), block.Time()) { ProcessParentBlockHash(block.ParentHash(), evm) } @@ -182,7 +182,7 @@ func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, } // 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, gp.CumulativeUsed(), root), nil diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index 7155a67a9b..4030a0c339 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -441,9 +441,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 @@ -894,7 +894,7 @@ func (p *BlobPool) Reset(oldHead, newHead *types.Header) { // Handle reorg buffer timeouts evicting old gapped transactions p.evictGapped() - statedb, err := p.chain.StateAt(newHead.Root) + statedb, err := p.chain.StateAt(newHead) if err != nil { log.Error("Failed to reset blobpool state", "err", err) return diff --git a/core/txpool/blobpool/blobpool_test.go b/core/txpool/blobpool/blobpool_test.go index ba96bea8ed..7c57755401 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" ) @@ -180,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 { diff --git a/core/txpool/blobpool/interface.go b/core/txpool/blobpool/interface.go index 6f296a54bd..d7beae9b25 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/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index 93b3cb5be2..78a0161c41 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -129,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. @@ -317,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 @@ -1379,7 +1382,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 diff --git a/core/txpool/legacypool/legacypool_test.go b/core/txpool/legacypool/legacypool_test.go index fb994d8208..f8592ba001 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/locals/tx_tracker_test.go b/core/txpool/locals/tx_tracker_test.go index dde8754605..34fb4d0b74 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/txpool.go b/core/txpool/txpool.go index 25647e0cce..9c78748422 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() diff --git a/core/types/hashes.go b/core/types/hashes.go index 22f1f946dc..db8912a66f 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/vm/contracts.go b/core/vm/contracts.go index 010f477337..b4cddf0bca 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 diff --git a/core/vm/evm.go b/core/vm/evm.go index cfc837fb62..8f68478842 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -149,7 +149,7 @@ func NewEVM(blockCtx BlockContext, statedb StateDB, chainConfig *params.ChainCon 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: diff --git a/core/vm/jump_table_export.go b/core/vm/jump_table_export.go index fdf814d64c..a4a99ea498 100644 --- a/core/vm/jump_table_export.go +++ b/core/vm/jump_table_export.go @@ -26,7 +26,7 @@ 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 diff --git a/eth/api_backend.go b/eth/api_backend.go index a4e976b1b8..33fe4fe5d9 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 } diff --git a/eth/api_debug.go b/eth/api_debug.go index 5dd535e672..260e24c2ee 100644 --- a/eth/api_debug.go +++ b/eth/api_debug.go @@ -82,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 } @@ -167,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 } @@ -177,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 } diff --git a/eth/backend.go b/eth/backend.go index e9bea59734..08a3c70c9d 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -277,8 +277,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 diff --git a/eth/catalyst/api_test.go b/eth/catalyst/api_test.go index d126c362fe..1f38c4dd8a 100644 --- a/eth/catalyst/api_test.go +++ b/eth/catalyst/api_test.go @@ -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) @@ -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) @@ -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), @@ -1263,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. diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go index 01aaaa751b..dd7436bf52 100644 --- a/eth/ethconfig/config.go +++ b/eth/ethconfig/config.go @@ -200,8 +200,8 @@ 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"` diff --git a/eth/ethconfig/gen_config.go b/eth/ethconfig/gen_config.go index 6f94a409e5..ed85562f44 100644 --- a/eth/ethconfig/gen_config.go +++ b/eth/ethconfig/gen_config.go @@ -64,7 +64,7 @@ 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"` @@ -117,7 +117,7 @@ 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 @@ -174,7 +174,7 @@ 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"` @@ -324,8 +324,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 diff --git a/eth/gasprice/gasprice_test.go b/eth/gasprice/gasprice_test.go index 02a25bc4d8..e57c6e11c5 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/state_accessor.go b/eth/state_accessor.go index 04aac321cb..7467e1e590 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -56,7 +56,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, base *st // 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()) @@ -182,11 +182,12 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, base *st 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 } diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 53a09087e4..b5ddc78a10 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -1086,8 +1086,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 ecf3c99c8f..0e62b9631d 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -152,7 +152,7 @@ func (b *testBackend) teardown() { } 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.Root()) + statedb, err := b.chain.StateAt(block.Header()) if err != nil { return nil, nil, errStateNotFound } diff --git a/eth/tracers/internal/tracetest/selfdestruct_state_test.go b/eth/tracers/internal/tracetest/selfdestruct_state_test.go index bb1a3d9f18..692c5eb775 100644 --- a/eth/tracers/internal/tracetest/selfdestruct_state_test.go +++ b/eth/tracers/internal/tracetest/selfdestruct_state_test.go @@ -162,7 +162,7 @@ func setupTestBlockchain(t *testing.T, genesis *core.Genesis, tx *types.Transact if genesisBlock == nil { t.Fatalf("failed to get genesis block") } - statedb, err := blockchain.StateAt(genesisBlock.Root()) + statedb, err := blockchain.StateAt(genesisBlock.Header()) if err != nil { t.Fatalf("failed to get state: %v", err) } diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go index b010eeaa08..6cf52d636a 100644 --- a/internal/ethapi/api_test.go +++ b/internal/ethapi/api_test.go @@ -572,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) { diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index eacb296132..90e88e83ee 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -317,7 +317,7 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, if precompiles != nil { evm.SetPrecompiles(precompiles) } - if sim.chainConfig.IsPrague(header.Number, header.Time) || sim.chainConfig.IsVerkle(header.Number, header.Time) { + if sim.chainConfig.IsPrague(header.Number, header.Time) || sim.chainConfig.IsUBT(header.Number, header.Time) { core.ProcessParentBlockHash(header.ParentHash, evm) } if header.ParentBeaconRoot != nil { diff --git a/miner/miner_test.go b/miner/miner_test.go index 13475a19b6..5411418b13 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 } diff --git a/miner/worker.go b/miner/worker.go index 39a61de318..1d648f0ee1 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -324,7 +324,7 @@ func (miner *Miner) prepareWork(ctx context.Context, genParams *generateParams, // 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 } diff --git a/params/config.go b/params/config.go index 197ed56f8a..17508cbf27 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) @@ -1380,14 +1380,14 @@ type Rules struct { 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 { // 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{ IsHomestead: c.IsHomestead(num), IsEIP150: c.IsEIP150(num), @@ -1398,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), @@ -1406,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/tests/block_test_util.go b/tests/block_test_util.go index 00411073e2..bece8ae610 100644 --- a/tests/block_test_util.go +++ b/tests/block_test_util.go @@ -126,10 +126,10 @@ func (t *BlockTest) Run(snapshotter bool, scheme string, witness bool, tracer *t 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 diff --git a/tests/init.go b/tests/init.go index f115e427a5..3db988a993 100644 --- a/tests/init.go +++ b/tests/init.go @@ -774,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_util.go b/tests/state_test_util.go index 1dd1bf6a04..569cc37913 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -544,7 +544,7 @@ func MakePreState(db ethdb.Database, accounts types.GenesisAlloc, snapshotter bo } snaps, _ = snapshot.New(snapconfig, db, triedb, root) } - sdb = state.NewDatabase(triedb, nil).WithSnapshot(snaps) + sdb = state.NewMPTDatabase(triedb, nil).WithSnapshot(snaps) statedb, _ = state.New(root, sdb) return StateTestState{statedb, triedb, snaps} } diff --git a/trie/bintrie/trie.go b/trie/bintrie/trie.go index b1e3c991c0..23d014eb33 100644 --- a/trie/bintrie/trie.go +++ b/trie/bintrie/trie.go @@ -377,8 +377,8 @@ func (t *BinaryTrie) Copy() *BinaryTrie { } } -// 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. diff --git a/trie/secure_trie.go b/trie/secure_trie.go index 1f150ede8c..4d03ca45f0 100644 --- a/trie/secure_trie.go +++ b/trie/secure_trie.go @@ -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 4c73022082..3e5511be9e 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/triedb/database.go b/triedb/database.go index c1abe93462..533097c9e3 100644 --- a/triedb/database.go +++ b/triedb/database.go @@ -32,7 +32,7 @@ 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 + IsUBT 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 } @@ -41,15 +41,15 @@ type Config struct { // 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 verkle trie data // using path-based scheme with default settings. -var VerkleDefaults = &Config{ +var UBTDefaults = &Config{ Preimages: false, - IsVerkle: true, + IsUBT: true, PathDB: pathdb.Defaults, } @@ -109,7 +109,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) } @@ -375,9 +375,9 @@ func (db *Database) IndexProgress() (uint64, uint64, error) { 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. diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go index a61d302b1d..04c76cfd53 100644 --- a/triedb/pathdb/database.go +++ b/triedb/pathdb/database.go @@ -100,7 +100,7 @@ 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 { @@ -127,7 +127,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 @@ -146,7 +146,7 @@ type Database struct { // 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 } @@ -154,7 +154,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, @@ -164,7 +164,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 } @@ -174,7 +174,7 @@ func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { // 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, isVerkle, db.config.ReadOnly, db.tree.bottom().stateID(), db.config.TrienodeHistory >= 0) + 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) } @@ -196,7 +196,7 @@ func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database { db.setHistoryIndexer() fields := config.fields() - if db.isVerkle { + if db.isUBT { fields = append(fields, "verkle", true) } log.Info("Initialized path database", fields...) @@ -265,7 +265,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 @@ -408,7 +408,7 @@ func (db *Database) Enable(root common.Hash) error { // 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)) + 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: @@ -586,7 +586,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") diff --git a/triedb/pathdb/database_test.go b/triedb/pathdb/database_test.go index e70a3ec2a2..8ceb22eaba 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 @@ -183,7 +183,7 @@ func newTester(t *testing.T, config *testerConfig) *tester { NoAsyncFlush: true, JournalDirectory: config.journalDir, NoHistoryIndexDelay: true, - }, config.isVerkle) + }, config.isUBT) obj = &tester{ db: db, diff --git a/triedb/pathdb/history.go b/triedb/pathdb/history.go index 0a9f7091fa..7f5b0e35ba 100644 --- a/triedb/pathdb/history.go +++ b/triedb/pathdb/history.go @@ -376,7 +376,7 @@ func syncHistory(stores ...ethdb.AncientWriter) error { // 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, isVerkle bool, readOnly bool, stateID uint64, enableTrienode bool) (ethdb.ResettableAncientStore, ethdb.ResettableAncientStore, error) { +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 @@ -386,7 +386,7 @@ func repairHistory(db ethdb.Database, isVerkle bool, readOnly bool, stateID uint } // State history is mandatory as it is the key component that ensures // resilience to deep reorgs. - states, err := rawdb.NewStateFreezer(ancient, isVerkle, readOnly) + states, err := rawdb.NewStateFreezer(ancient, isUBT, readOnly) if err != nil { log.Crit("Failed to open state history freezer", "err", err) } @@ -395,7 +395,7 @@ func repairHistory(db ethdb.Database, isVerkle bool, readOnly bool, stateID uint // node with state proofs. var trienodes ethdb.ResettableAncientStore if enableTrienode { - trienodes, err = rawdb.NewTrienodeFreezer(ancient, isVerkle, readOnly) + trienodes, err = rawdb.NewTrienodeFreezer(ancient, isUBT, readOnly) if err != nil { log.Crit("Failed to open trienode history freezer", "err", err) } diff --git a/triedb/pathdb/layertree_test.go b/triedb/pathdb/layertree_test.go index 82eb182990..0dcfd7aae8 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}: {}, }, }, diff --git a/triedb/pathdb/reader.go b/triedb/pathdb/reader.go index e3cfbcba8a..18ec5f2028 100644 --- a/triedb/pathdb/reader.go +++ b/triedb/pathdb/reader.go @@ -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 } From 89c1c16a46ce6390d53f8d17cd56caca9c2b15ac Mon Sep 17 00:00:00 2001 From: Edgar Date: Fri, 17 Apr 2026 03:53:00 +0200 Subject: [PATCH 083/183] cmd/geth: add code exporter for db export (#34696) Adds a 'code' exporter to 'geth db export' that iterates over all contract bytecode entries (CodePrefix + code_hash -> bytecode). Usage: geth --datadir db export code code.rlp This enables exporting contract bytecode. --- cmd/geth/dbcmd.go | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/cmd/geth/dbcmd.go b/cmd/geth/dbcmd.go index 455dd05aca..173fc97def 100644 --- a/cmd/geth/dbcmd.go +++ b/cmd/geth/dbcmd.go @@ -806,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 { @@ -817,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 { From 4c03a0631e6bc270c4481159ff9aa641ec513731 Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Fri, 17 Apr 2026 19:43:53 +0800 Subject: [PATCH 084/183] cmd/evm: compare errors by value in timedExec instead of interface identity (#34733) `timedExec` compares errors by direct interface inequality (haveErr != err). If execFunc returns newly constructed errors with the same message each run, this will panic even though behavior is equivalent. --- cmd/evm/runner.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index ebb3e04461..82e7bdff3d 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())) } } }) From 573d94013c92cec161f23aef1d74549dcb236ae1 Mon Sep 17 00:00:00 2001 From: Snehendu Roy <81818503+snehendu098@users.noreply.github.com> Date: Fri, 17 Apr 2026 17:15:03 +0530 Subject: [PATCH 085/183] core/rawdb: fix incorrect fsync ordering for index file truncation (#34728) --- core/rawdb/freezer_utils.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/core/rawdb/freezer_utils.go b/core/rawdb/freezer_utils.go index 7f1a978b63..eb9aeab451 100644 --- a/core/rawdb/freezer_utils.go +++ b/core/rawdb/freezer_utils.go @@ -76,6 +76,11 @@ 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 } From 61bfacc52f79df35f2e3caa5c72f5dc9e650c685 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Sat, 18 Apr 2026 11:42:58 +0200 Subject: [PATCH 086/183] trie/bintrie: skip clean nodes in CollectNodes to reduce commit write amplification (#34754) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Problem `BinaryTrie.Commit` unconditionally walked every resolved in-memory node and flushed it into the `NodeSet`, producing one Pebble write per resolved internal + stem node on every block — even when the node's on-disk blob was bitwise identical to the previous commit. On a warm 400M-state workload this meant tens of thousands of redundant 65-byte writes per block, compounding Pebble compaction pressure on every commit. The existing `mustRecompute` flag tracks *hash* staleness, not *disk-blob* staleness: after `Hash()` completes, `mustRecompute` is cleared even though the fresh blob has not been persisted. It is therefore insufficient for a skip-flush optimization. ## Fix Mirror the MPT committer pattern (`trie/committer.go:51-56`) by adding a `dirty` flag on `InternalNode` and `StemNode` with the semantics *the on-disk blob is stale*. The flag is: - set to `true` wherever the node is created or structurally modified (the same call sites that already set `mustRecompute = true`); - set to `false` only after the node has been passed to the `flushfn` inside `CollectNodes`; - left `false` on nodes produced by `DeserializeNodeWithHash`, matching the *loaded from disk, already persisted* semantics. `CollectNodes` short-circuits on `!dirty` subtrees. The propagation invariant (an ancestor of any dirty node is itself dirty) is already maintained by the existing `InsertValuesAtStem` / `Insert` paths, which now mirror every `mustRecompute = true` setter with a `dirty = true` setter. ## Benchmark New `BenchmarkCollectNodes_SparseWrite` measures commit cost when only one leaf changes between blocks — the common case for state updates. 10,000-stem trie, one-leaf modification + Commit per iteration, Apple M4 Pro: | | before | after | delta | |---|---|---|---| | time / op | 12,653,000 ns | 7,336 ns | **~1,725×** | | bytes / op | 107,224,740 B | 37,774 B | **~2,839×** | | allocs / op | 80,953 | 134 | **~604×** | End-to-end impact on a real workload depends on the resolved-footprint-to-dirty-path ratio; the new `TestBinaryTrieCommitIncremental` provides a structural regression guard (asserts that a Commit following a single-leaf modification flushes a root-to-leaf path, not the whole tree). --- Found all of this stuff while bloating my #34706 DB to make some benchmarks. And saw we were spending A LOT OF TIME on hashing. Hope this helps the perf a bit. Will rebase the flat-state PR on top of this once merged. --- trie/bintrie/binary_node.go | 8 +- trie/bintrie/empty.go | 2 + trie/bintrie/empty_test.go | 42 ++++++++++ trie/bintrie/internal_node.go | 11 ++- trie/bintrie/internal_node_test.go | 52 ++++++++++++- trie/bintrie/stem_node.go | 24 +++++- trie/bintrie/stem_node_test.go | 42 ++++++++++ trie/bintrie/trie_test.go | 120 +++++++++++++++++++++++++++++ 8 files changed, 292 insertions(+), 9 deletions(-) diff --git a/trie/bintrie/binary_node.go b/trie/bintrie/binary_node.go index a7392ec958..8905a82285 100644 --- a/trie/bintrie/binary_node.go +++ b/trie/bintrie/binary_node.go @@ -93,15 +93,15 @@ var invalidSerializedLength = errors.New("invalid serialized node length") // DeserializeNode deserializes a binary trie node from a byte slice. The // hash will be recomputed from the deserialized data. func DeserializeNode(serialized []byte, depth int) (BinaryNode, error) { - return deserializeNode(serialized, depth, common.Hash{}, true) + return deserializeNode(serialized, depth, common.Hash{}, true, true) } // DeserializeNodeWithHash deserializes a binary trie node from a byte slice, using the provided hash. func DeserializeNodeWithHash(serialized []byte, depth int, hn common.Hash) (BinaryNode, error) { - return deserializeNode(serialized, depth, hn, false) + return deserializeNode(serialized, depth, hn, false, false) } -func deserializeNode(serialized []byte, depth int, hn common.Hash, mustRecompute bool) (BinaryNode, error) { +func deserializeNode(serialized []byte, depth int, hn common.Hash, mustRecompute, dirty bool) (BinaryNode, error) { if len(serialized) == 0 { return Empty{}, nil } @@ -117,6 +117,7 @@ func deserializeNode(serialized []byte, depth int, hn common.Hash, mustRecompute right: HashedNode(common.BytesToHash(serialized[33:65])), hash: hn, mustRecompute: mustRecompute, + dirty: dirty, }, nil case nodeTypeStem: if len(serialized) < 64 { @@ -141,6 +142,7 @@ func deserializeNode(serialized []byte, depth int, hn common.Hash, mustRecompute depth: depth, hash: hn, mustRecompute: mustRecompute, + dirty: dirty, }, nil default: return nil, errors.New("invalid node type") diff --git a/trie/bintrie/empty.go b/trie/bintrie/empty.go index 252146a4a7..c47e284dac 100644 --- a/trie/bintrie/empty.go +++ b/trie/bintrie/empty.go @@ -36,6 +36,7 @@ func (e Empty) Insert(key []byte, value []byte, _ NodeResolverFn, depth int) (Bi Values: values[:], depth: depth, mustRecompute: true, + dirty: true, }, nil } @@ -58,6 +59,7 @@ func (e Empty) InsertValuesAtStem(key []byte, values [][]byte, _ NodeResolverFn, Values: values, depth: depth, mustRecompute: true, + dirty: true, }, nil } diff --git a/trie/bintrie/empty_test.go b/trie/bintrie/empty_test.go index 574ae1830b..4da1ed15a0 100644 --- a/trie/bintrie/empty_test.go +++ b/trie/bintrie/empty_test.go @@ -220,3 +220,45 @@ func TestEmptyGetHeight(t *testing.T) { t.Errorf("Expected height 0 for empty node, got %d", height) } } + +// TestEmptyInsertMarksDirty verifies that a StemNode produced by Empty.Insert +// is marked dirty. Without this, CollectNodes would skip the freshly created +// stem and its blob would never reach disk, producing "missing trie node" +// errors on subsequent reads. +func TestEmptyInsertMarksDirty(t *testing.T) { + key := make([]byte, 32) + key[0] = 0xaa + val := make([]byte, 32) + val[0] = 0xbb + n, err := Empty{}.Insert(key, val, nil, 0) + if err != nil { + t.Fatalf("Insert: %v", err) + } + sn, ok := n.(*StemNode) + if !ok { + t.Fatalf("expected *StemNode, got %T", n) + } + if !sn.dirty { + t.Fatalf("stem produced by Empty.Insert must have dirty=true") + } +} + +// TestEmptyInsertValuesAtStemMarksDirty is the analogous guard for the +// bulk-insert entry point. Fresh stems created here must be dirty. +func TestEmptyInsertValuesAtStemMarksDirty(t *testing.T) { + key := make([]byte, 32) + key[0] = 0xcc + values := make([][]byte, 256) + values[0] = make([]byte, 32) + n, err := Empty{}.InsertValuesAtStem(key, values, nil, 3) + if err != nil { + t.Fatalf("InsertValuesAtStem: %v", err) + } + sn, ok := n.(*StemNode) + if !ok { + t.Fatalf("expected *StemNode, got %T", n) + } + if !sn.dirty { + t.Fatalf("stem produced by Empty.InsertValuesAtStem must have dirty=true") + } +} diff --git a/trie/bintrie/internal_node.go b/trie/bintrie/internal_node.go index 946203bcfb..811f65bcd8 100644 --- a/trie/bintrie/internal_node.go +++ b/trie/bintrie/internal_node.go @@ -62,6 +62,7 @@ type InternalNode struct { depth int mustRecompute bool // true if the hash needs to be recomputed + dirty bool // true if the node's on-disk blob is stale (needs flush) hash common.Hash // cached hash when mustRecompute == false } @@ -135,6 +136,7 @@ func (bt *InternalNode) Copy() BinaryNode { right: bt.right.Copy(), depth: bt.depth, mustRecompute: bt.mustRecompute, + dirty: bt.dirty, hash: bt.hash, } } @@ -213,6 +215,7 @@ func (bt *InternalNode) InsertValuesAtStem(stem []byte, values [][]byte, resolve bt.left, err = bt.left.InsertValuesAtStem(stem, values, resolver, depth+1) bt.mustRecompute = true + bt.dirty = true return bt, err } @@ -238,12 +241,17 @@ func (bt *InternalNode) InsertValuesAtStem(stem []byte, values [][]byte, resolve bt.right, err = bt.right.InsertValuesAtStem(stem, values, resolver, depth+1) bt.mustRecompute = true + bt.dirty = true return bt, err } // CollectNodes collects all child nodes at a given path, and flushes it -// into the provided node collector. +// into the provided node collector. Clean subtrees (dirty == false) are +// skipped. func (bt *InternalNode) CollectNodes(path []byte, flushfn NodeFlushFn) error { + if !bt.dirty { + return nil + } if bt.left != nil { var p [256]byte copy(p[:], path) @@ -263,6 +271,7 @@ func (bt *InternalNode) CollectNodes(path []byte, flushfn NodeFlushFn) error { } } flushfn(path, bt) + bt.dirty = false return nil } diff --git a/trie/bintrie/internal_node_test.go b/trie/bintrie/internal_node_test.go index 69097483fd..ddcec8085d 100644 --- a/trie/bintrie/internal_node_test.go +++ b/trie/bintrie/internal_node_test.go @@ -351,17 +351,20 @@ func TestInternalNodeInsertValuesAtStem(t *testing.T) { // TestInternalNodeCollectNodes tests CollectNodes method func TestInternalNodeCollectNodes(t *testing.T) { - // Create an internal node with two stem children + // Create an internal node with two stem children. All three are + // marked dirty to mirror production semantics — see CollectNodes. leftStem := &StemNode{ Stem: make([]byte, 31), Values: make([][]byte, 256), depth: 1, + dirty: true, } rightStem := &StemNode{ Stem: make([]byte, 31), Values: make([][]byte, 256), depth: 1, + dirty: true, } rightStem.Stem[0] = 0x80 @@ -369,6 +372,7 @@ func TestInternalNodeCollectNodes(t *testing.T) { depth: 0, left: leftStem, right: rightStem, + dirty: true, } var collectedPaths [][]byte @@ -405,6 +409,52 @@ func TestInternalNodeCollectNodes(t *testing.T) { } } +// TestInternalNodeCollectNodesSkipsClean verifies clean subtrees are not +// flushed. A dirty internal node over clean children only flushes itself; +// a fully clean tree flushes nothing. +func TestInternalNodeCollectNodesSkipsClean(t *testing.T) { + leftStem := &StemNode{ + Stem: make([]byte, 31), + Values: make([][]byte, 256), + depth: 1, + } + rightStem := &StemNode{ + Stem: make([]byte, 31), + Values: make([][]byte, 256), + depth: 1, + } + rightStem.Stem[0] = 0x80 + + dirtyParent := &InternalNode{ + depth: 0, + left: leftStem, + right: rightStem, + dirty: true, + } + + var collected []BinaryNode + flushFn := func(_ []byte, n BinaryNode) { collected = append(collected, n) } + + if err := dirtyParent.CollectNodes([]byte{1}, flushFn); err != nil { + t.Fatalf("CollectNodes: %v", err) + } + if len(collected) != 1 || collected[0] != dirtyParent { + t.Fatalf("expected only the dirty parent to be flushed, got %d nodes", len(collected)) + } + if dirtyParent.dirty { + t.Errorf("parent dirty flag should be cleared after flush") + } + + // Second call on the same tree should be a no-op: everything is clean. + collected = nil + if err := dirtyParent.CollectNodes([]byte{1}, flushFn); err != nil { + t.Fatalf("CollectNodes (second call): %v", err) + } + if len(collected) != 0 { + t.Errorf("expected no nodes to be flushed on clean tree, got %d", len(collected)) + } +} + // TestInternalNodeGetHeight tests GetHeight method func TestInternalNodeGetHeight(t *testing.T) { // Create a tree with different heights diff --git a/trie/bintrie/stem_node.go b/trie/bintrie/stem_node.go index e5729e6182..0ceae6b062 100644 --- a/trie/bintrie/stem_node.go +++ b/trie/bintrie/stem_node.go @@ -32,6 +32,7 @@ type StemNode struct { depth int // Depth of the node mustRecompute bool // true if the hash needs to be recomputed + dirty bool // true if the node's on-disk blob is stale (needs flush) hash common.Hash // cached hash when mustRecompute == false } @@ -48,8 +49,11 @@ func (bt *StemNode) Insert(key []byte, value []byte, _ NodeResolverFn, depth int if !bytes.Equal(bt.Stem, key[:StemSize]) { bitStem := bt.Stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1 - n := &InternalNode{depth: bt.depth, mustRecompute: true} + n := &InternalNode{depth: bt.depth, mustRecompute: true, dirty: true} bt.depth++ + // bt is re-parented under n and sits at a new path — rewrite its blob. + bt.mustRecompute = true + bt.dirty = true var child, other *BinaryNode if bitStem == 0 { n.left = bt @@ -77,6 +81,7 @@ func (bt *StemNode) Insert(key []byte, value []byte, _ NodeResolverFn, depth int Values: values[:], depth: depth + 1, mustRecompute: true, + dirty: true, } } return n, nil @@ -86,6 +91,7 @@ func (bt *StemNode) Insert(key []byte, value []byte, _ NodeResolverFn, depth int } bt.Values[key[StemSize]] = value bt.mustRecompute = true + bt.dirty = true return bt, nil } @@ -101,6 +107,7 @@ func (bt *StemNode) Copy() BinaryNode { depth: bt.depth, hash: bt.hash, mustRecompute: bt.mustRecompute, + dirty: bt.dirty, } } @@ -151,10 +158,14 @@ func (bt *StemNode) Hash() common.Hash { return bt.hash } -// CollectNodes collects all child nodes at a given path, and flushes it -// into the provided node collector. +// CollectNodes flushes the stem via the collector when dirty; clean stems +// are skipped. func (bt *StemNode) CollectNodes(path []byte, flush NodeFlushFn) error { + if !bt.dirty { + return nil + } flush(path, bt) + bt.dirty = false return nil } @@ -172,8 +183,11 @@ func (bt *StemNode) InsertValuesAtStem(key []byte, values [][]byte, _ NodeResolv if !bytes.Equal(bt.Stem, key[:StemSize]) { bitStem := bt.Stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1 - n := &InternalNode{depth: bt.depth, mustRecompute: true} + n := &InternalNode{depth: bt.depth, mustRecompute: true, dirty: true} bt.depth++ + // bt is re-parented under n and sits at a new path — rewrite its blob. + bt.mustRecompute = true + bt.dirty = true var child, other *BinaryNode if bitStem == 0 { n.left = bt @@ -199,6 +213,7 @@ func (bt *StemNode) InsertValuesAtStem(key []byte, values [][]byte, _ NodeResolv Values: values, depth: n.depth + 1, mustRecompute: true, + dirty: true, } } return n, nil @@ -209,6 +224,7 @@ func (bt *StemNode) InsertValuesAtStem(key []byte, values [][]byte, _ NodeResolv if v != nil { bt.Values[i] = v bt.mustRecompute = true + bt.dirty = true } } return bt, nil diff --git a/trie/bintrie/stem_node_test.go b/trie/bintrie/stem_node_test.go index 310c553d39..2743e7ce9b 100644 --- a/trie/bintrie/stem_node_test.go +++ b/trie/bintrie/stem_node_test.go @@ -379,6 +379,7 @@ func TestStemNodeCollectNodes(t *testing.T) { Stem: stem, Values: values[:], depth: 0, + dirty: true, } var collectedPaths [][]byte @@ -412,3 +413,44 @@ func TestStemNodeCollectNodes(t *testing.T) { t.Errorf("Path mismatch: expected [0, 1, 0], got %v", collectedPaths[0]) } } + +// TestStemNodeCollectNodesSkipsClean verifies that a clean stem is not +// flushed, and that flushing a dirty stem clears its dirty flag so that +// a subsequent CollectNodes on the same node is a no-op. +func TestStemNodeCollectNodesSkipsClean(t *testing.T) { + stem := make([]byte, 31) + node := &StemNode{ + Stem: stem, + Values: make([][]byte, 256), + depth: 0, + } + + var collected []BinaryNode + flushFn := func(_ []byte, n BinaryNode) { collected = append(collected, n) } + + if err := node.CollectNodes([]byte{0}, flushFn); err != nil { + t.Fatalf("CollectNodes on clean stem: %v", err) + } + if len(collected) != 0 { + t.Fatalf("expected clean stem not to be flushed, got %d", len(collected)) + } + + node.dirty = true + if err := node.CollectNodes([]byte{0}, flushFn); err != nil { + t.Fatalf("CollectNodes on dirty stem: %v", err) + } + if len(collected) != 1 { + t.Fatalf("expected dirty stem to be flushed once, got %d", len(collected)) + } + if node.dirty { + t.Errorf("stem dirty flag should be cleared after flush") + } + + collected = nil + if err := node.CollectNodes([]byte{0}, flushFn); err != nil { + t.Fatalf("CollectNodes after flush: %v", err) + } + if len(collected) != 0 { + t.Errorf("expected no flush on clean stem, got %d", len(collected)) + } +} diff --git a/trie/bintrie/trie_test.go b/trie/bintrie/trie_test.go index 5b104ddde4..c436501464 100644 --- a/trie/bintrie/trie_test.go +++ b/trie/bintrie/trie_test.go @@ -779,3 +779,123 @@ func TestGetStorageNonMembershipInternalRoot(t *testing.T) { t.Fatalf("expected nil/zero for non-existent storage, got %x", got) } } + +// commitKeyN derives a distinct 32-byte key from a seed integer. Used by +// TestBinaryTrieCommitIncremental and BenchmarkCollectNodes_SparseWrite to +// populate a trie with many disjoint stems. +func commitKeyN(i int) [HashSize]byte { + var k [HashSize]byte + binary.BigEndian.PutUint64(k[:8], uint64(i)*0x9e3779b97f4a7c15) + binary.BigEndian.PutUint64(k[8:16], uint64(i)*0xc2b2ae3d27d4eb4f) + binary.BigEndian.PutUint64(k[16:24], uint64(i)*0x165667b19e3779f9) + binary.BigEndian.PutUint64(k[24:32], uint64(i)*0x85ebca77c2b2ae63) + return k +} + +// TestBinaryTrieCommitIncremental verifies that a second Commit with only a +// single modified leaf flushes only the path from that leaf to the root, +// not the entire tree. +func TestBinaryTrieCommitIncremental(t *testing.T) { + tr := &BinaryTrie{ + root: NewBinaryNode(), + tracer: trie.NewPrevalueTracer(), + } + + const n = 512 + keys := make([][HashSize]byte, n) + for i := range n { + keys[i] = commitKeyN(i + 1) + var v [HashSize]byte + binary.BigEndian.PutUint64(v[24:], uint64(i+1)) + var err error + tr.root, err = tr.root.Insert(keys[i][:], v[:], nil, 0) + if 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") + } + if len(ns1.Nodes) < n { + t.Fatalf("first Commit: expected at least %d nodes, got %d", n, len(ns1.Nodes)) + } + + // Second Commit on the same trie with no modifications: NodeSet must + // be empty because every subtree is clean. + _, nsNoop := tr.Commit(false) + if len(nsNoop.Nodes) != 0 { + t.Fatalf("no-op Commit: expected empty NodeSet, got %d nodes", len(nsNoop.Nodes)) + } + + // Modify a single leaf's value. Only the path from that leaf to the + // root should appear in the next Commit's NodeSet. + var newVal [HashSize]byte + newVal[0] = 0xff + var err error + tr.root, err = tr.root.Insert(keys[n/2][:], newVal[:], nil, 0) + if err != nil { + t.Fatalf("Insert (modify): %v", err) + } + _, ns2 := tr.Commit(false) + + // Path length for a binary trie of n=512 stems is bounded by the + // internal depth at which the modified stem sits. Allow generous + // slack: up to 64 nodes is fine, anywhere near n (512) is a regression. + if len(ns2.Nodes) == 0 { + t.Fatal("modified Commit produced empty NodeSet") + } + if len(ns2.Nodes) > 64 { + t.Fatalf("modified Commit: expected small NodeSet, got %d nodes (first Commit had %d)", len(ns2.Nodes), len(ns1.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)) + } +} + +// BenchmarkCollectNodes_SparseWrite measures Commit cost when only one leaf +// changes between blocks — the common case for state updates. After warm-up +// (populate + initial Commit), each iteration modifies a single leaf and +// re-Commits. Under the skip-clean optimization, each iteration flushes +// only the root-to-leaf path; pre-fix behavior would re-flush the entire +// tree every iteration. +func BenchmarkCollectNodes_SparseWrite(b *testing.B) { + const n = 10_000 + + tr := &BinaryTrie{ + root: NewBinaryNode(), + tracer: trie.NewPrevalueTracer(), + } + keys := make([][HashSize]byte, n) + for i := range n { + keys[i] = commitKeyN(i + 1) + var v [HashSize]byte + binary.BigEndian.PutUint64(v[24:], uint64(i+1)) + var err error + tr.root, err = tr.root.Insert(keys[i][:], v[:], nil, 0) + if err != nil { + b.Fatalf("Insert %d: %v", i, err) + } + } + // Flush the initial tree so subsequent Commits reflect the + // single-modification workload we want to measure. + _, _ = tr.Commit(false) + + 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)) + var err error + tr.root, err = tr.root.Insert(keys[idx][:], newVal[:], nil, 0) + if err != nil { + b.Fatalf("Insert at iter %d: %v", i, err) + } + _, ns := tr.Commit(false) + if len(ns.Nodes) == 0 { + b.Fatalf("iter %d: empty NodeSet", i) + } + } +} From 53ff723cc70de40dd31e819053fdb7e054f683d0 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Sat, 18 Apr 2026 18:47:22 +0200 Subject: [PATCH 087/183] core/state: handle *bintrie.BinaryTrie in mustCopyTrie (#34758) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Problem `mustCopyTrie` in `core/state/database.go` panics on any trie type not in its type switch: ```go func mustCopyTrie(t Trie) Trie { switch t := t.(type) { case *trie.StateTrie: return t.Copy() case *transitiontrie.TransitionTrie: return t.Copy() default: panic(fmt.Errorf("unknown trie type %T", t)) } } ``` On UBT-backed databases (`state.NewUBTDatabase(...)`, used by `blockchain.go:2124` when the triedb is configured for binary trie), `StateDB.trie` is `*bintrie.BinaryTrie` — so every `StateDB.Copy()` call (hit from `statedb.go:699` and the `*trie.StateTrie` branch of `state_object.go:546`) crashes with `unknown trie type *bintrie.BinaryTrie`. ## Fix Add the `*bintrie.BinaryTrie` case. `BinaryTrie.Copy()` already exists at `trie/bintrie/trie.go:372` and produces a correct deep copy — this just wires it into the switch. --- core/state/database.go | 3 +++ core/state/statedb_test.go | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/core/state/database.go b/core/state/database.go index 6de58af63b..b9ccff658f 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -24,6 +24,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "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/triedb" @@ -181,6 +182,8 @@ func mustCopyTrie(t Trie) Trie { 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/statedb_test.go b/core/state/statedb_test.go index 601970ff20..b5ef42b3e0 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -1366,3 +1366,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) + } +} From 78505e48ddd27ce9e401b2f6f3bbb31d394acc99 Mon Sep 17 00:00:00 2001 From: cui Date: Mon, 20 Apr 2026 10:07:41 +0800 Subject: [PATCH 088/183] triedb/pathdb: fix typo (#34762) --- triedb/pathdb/reader.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/triedb/pathdb/reader.go b/triedb/pathdb/reader.go index 18ec5f2028..e087ef26ed 100644 --- a/triedb/pathdb/reader.go +++ b/triedb/pathdb/reader.go @@ -229,7 +229,7 @@ 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, @@ -352,7 +352,7 @@ func (db *Database) HistoricNodeReader(root common.Hash) (*HistoricalNodeReader, 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 canonincal", root) + return nil, fmt.Errorf("state %#x is not canonical", root) } return &HistoricalNodeReader{ id: *id, From 8c7d61fcfe8465a762a6b5e6da7a16732f6e9649 Mon Sep 17 00:00:00 2001 From: cui Date: Mon, 20 Apr 2026 11:02:42 +0800 Subject: [PATCH 089/183] tests: fix invalid eip parse error (#34750) --- tests/state_test_util.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 569cc37913..f7cf1c0697 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -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) From 5af5510b1ec05803593aa3d34e6c31264bdc1bd1 Mon Sep 17 00:00:00 2001 From: rayoo Date: Mon, 20 Apr 2026 11:06:17 +0800 Subject: [PATCH 090/183] core/rawdb: fix file descriptor leak in freezer error paths (#34735) In openFreezerFileForAppend, if Seek fails after the file is successfully opened, the file handle is not closed, leaking a descriptor. Similarly in newTable, if opening the meta file fails, the already-opened index file is not closed. And if newMetadata fails, both the index and meta files are leaked. Under repeated error conditions (e.g., corrupted filesystem), these leaks accumulate and may exhaust the OS file descriptor limit, causing cascading failures. --- core/rawdb/freezer_table.go | 4 ++++ core/rawdb/freezer_utils.go | 1 + 2 files changed, 5 insertions(+) diff --git a/core/rawdb/freezer_table.go b/core/rawdb/freezer_table.go index 280f6e1aaa..c770e89989 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 diff --git a/core/rawdb/freezer_utils.go b/core/rawdb/freezer_utils.go index eb9aeab451..cd5239adc0 100644 --- a/core/rawdb/freezer_utils.go +++ b/core/rawdb/freezer_utils.go @@ -134,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 From 29e0a6f4042d19f507c6a11c8a468bda3c332f04 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 20 Apr 2026 15:33:29 +0800 Subject: [PATCH 091/183] core/vm, eth, tests: introduce gas budget (#34712) This PR introduces a gasBudget struct to track the available gas for EVM execution. With the upcoming EIP-8037, multi-dimensional gas accounting will be introduced, requiring multiple gas budget counters to be tracked simultaneously. To support this, the counters are grouped into a gasBudget structure. This change is a prerequisite for internal refactoring in preparation for EIP-8037. --------- Co-authored-by: MariusVanDerWijden --- cmd/evm/internal/t8ntool/transaction.go | 8 +- core/bench_test.go | 4 +- core/bintrie_witness_test.go | 4 +- core/state_processor.go | 6 +- core/state_transition.go | 69 ++++++++------- core/tracing/hooks.go | 2 + core/txpool/validation.go | 4 +- core/vm/contract.go | 24 +++--- core/vm/contracts.go | 16 ++-- core/vm/contracts_fuzz_test.go | 2 +- core/vm/contracts_test.go | 8 +- core/vm/eips.go | 6 +- core/vm/evm.go | 110 ++++++++++++------------ core/vm/gas_table_test.go | 12 +-- core/vm/gascosts.go | 63 +++++++++++++- core/vm/instructions.go | 16 ++-- core/vm/instructions_test.go | 2 +- core/vm/interpreter.go | 2 +- core/vm/interpreter_test.go | 4 +- core/vm/operations_acl.go | 6 +- core/vm/runtime/runtime.go | 16 ++-- eth/tracers/js/tracer_test.go | 6 +- eth/tracers/logger/logger_test.go | 2 +- tests/state_test.go | 8 +- tests/transaction_test_util.go | 3 +- 25 files changed, 235 insertions(+), 168 deletions(-) diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go index 3a457eeaec..82c0f30b42 100644 --- a/cmd/evm/internal/t8ntool/transaction.go +++ b/cmd/evm/internal/t8ntool/transaction.go @@ -133,15 +133,15 @@ 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) 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 } diff --git a/core/bench_test.go b/core/bench_test.go index 932188f8e2..20d1a7794b 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) 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 e4cb34cb56..1b033151d3 100644 --- a/core/bintrie_witness_test.go +++ b/core/bintrie_witness_test.go @@ -97,11 +97,11 @@ func TestProcessUBT(t *testing.T) { 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 */ diff --git a/core/state_processor.go b/core/state_processor.go index 0a324379f9..9cb7cc73bc 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -259,7 +259,7 @@ func ProcessBeaconBlockRoot(beaconRoot common.Hash, evm *vm.EVM) { } evm.SetTxContext(NewEVMTxContext(msg)) 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) } @@ -286,7 +286,7 @@ func ProcessParentBlockHash(prevHash common.Hash, evm *vm.EVM) { } evm.SetTxContext(NewEVMTxContext(msg)) 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) } @@ -325,7 +325,7 @@ func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte } evm.SetTxContext(NewEVMTxContext(msg)) 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) } diff --git a/core/state_transition.go b/core/state_transition.go index bd7e5daeff..297e8580ee 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -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 bool) (vm.GasCosts, error) { // Set the starting gas for the raw transaction var gas uint64 if isContractCreation && isHomestead { @@ -89,19 +89,19 @@ 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 } @@ -113,7 +113,7 @@ func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.Set 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). @@ -242,12 +242,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. @@ -304,8 +304,8 @@ func (st *stateTransition) buyGas() error { if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil { st.evm.Config.Tracer.OnGasChange(0, st.msg.GasLimit, tracing.GasChangeTxInitialBalance) } - st.gasRemaining = st.msg.GasLimit - st.initialGas = st.msg.GasLimit + st.gasRemaining = vm.NewGasBudget(st.msg.GasLimit) + st.initialBudget = st.gasRemaining.Copy() mgvalU256, _ := uint256.FromBig(mgval) st.state.SubBalance(st.msg.From, mgvalU256, tracing.BalanceDecreaseGasBuy) @@ -446,14 +446,17 @@ 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) 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 t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil { + t.OnGasChange(prior, st.gasRemaining.RegularGas, tracing.GasChangeTxIntrinsicGas) } // Gas limit suffices for the floor data cost (EIP-7623) if rules.IsPrague { @@ -465,10 +468,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) @@ -535,14 +534,14 @@ 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 used := st.gasUsed(); used < floorDataGas { + prior, _ := st.gasRemaining.Charge(vm.GasCosts{RegularGas: floorDataGas - used}) if t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil { - t.OnGasChange(prev, st.gasRemaining, tracing.GasChangeTxDataFloor) + t.OnGasChange(prior, st.gasRemaining.RegularGas, tracing.GasChangeTxDataFloor) } } if peakGasUsed < floorDataGas { @@ -555,10 +554,10 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { // Return gas to the gas pool if rules.IsAmsterdam { // Refund is excluded for returning - err = st.gp.ReturnGas(st.initialGas-peakGasUsed, st.gasUsed()) + err = st.gp.ReturnGas(st.initialBudget.RegularGas-peakGasUsed, st.gasUsed()) } else { // Refund is included for returning - err = st.gp.ReturnGas(st.gasRemaining, st.gasUsed()) + err = st.gp.ReturnGas(st.gasRemaining.RegularGas, st.gasUsed()) } if err != nil { return nil, err @@ -655,7 +654,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 @@ -668,26 +667,26 @@ func (st *stateTransition) calcRefund() uint64 { 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) + st.evm.Config.Tracer.OnGasChange(st.gasRemaining.RegularGas, st.gasRemaining.RegularGas+refund, 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 := uint256.NewInt(st.gasRemaining.RegularGas) remaining.Mul(remaining, uint256.MustFromBig(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.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && st.gasRemaining.RegularGas > 0 { + st.evm.Config.Tracer.OnGasChange(st.gasRemaining.RegularGas, 0, tracing.GasChangeTxLeftOverReturned) } } // 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/tracing/hooks.go b/core/tracing/hooks.go index de63689bc5..62c62ac3b3 100644 --- a/core/tracing/hooks.go +++ b/core/tracing/hooks.go @@ -167,6 +167,8 @@ type ( // GasChangeHook is invoked when the gas changes. GasChangeHook = func(old, new uint64, reason GasChangeReason) + // TODO(sina, rjl), please add GasChangeV2Hook by landing the multi-dimensional gas + /* - Chain events - */ diff --git a/core/txpool/validation.go b/core/txpool/validation.go index 13b1bfa312..3569bba08d 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -129,8 +129,8 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types 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 rules.IsPrague { diff --git a/core/vm/contract.go b/core/vm/contract.go index 3b5695e21a..a55a5dde8b 100644 --- a/core/vm/contract.go +++ b/core/vm/contract.go @@ -42,12 +42,12 @@ type Contract struct { IsDeployment bool IsSystemCall bool - Gas GasCosts + 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() @@ -56,7 +56,7 @@ func NewContract(caller common.Address, address common.Address, value *uint256.I caller: caller, address: address, jumpDests: jumpDests, - Gas: GasCosts{RegularGas: gas}, + Gas: gas, value: value, } } @@ -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.RegularGas < 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.RegularGas, c.Gas.RegularGas-gas, reason) + logger.OnGasChange(prior, c.Gas.RegularGas, reason) } - c.Gas.RegularGas -= 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.RegularGas, c.Gas.RegularGas+gas, reason) + logger.OnGasChange(prior, c.Gas.RegularGas, reason) } - c.Gas.RegularGas += gas } // Address returns the contracts address diff --git a/core/vm/contracts.go b/core/vm/contracts.go index b4cddf0bca..b1eed79282 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -260,25 +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(stateDB StateDB, p PrecompiledContract, address common.Address, 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) (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) + logger.OnGasChange(prior, gas.RegularGas, tracing.GasChangeCallPrecompiledContract) } - suppliedGas -= gasCost - // Touch the precompile for block-level accessList recording once Amsterdam // fork is activated. if stateDB != nil { stateDB.Exist(address) } output, err := p.Run(input) - return output, suppliedGas, err + return output, gas, err } // ecrecover implemented as a native contract. diff --git a/core/vm/contracts_fuzz_test.go b/core/vm/contracts_fuzz_test.go index 34ed1d87fe..35a9bd0257 100644 --- a/core/vm/contracts_fuzz_test.go +++ b/core/vm/contracts_fuzz_test.go @@ -36,7 +36,7 @@ func FuzzPrecompiledContracts(f *testing.F) { return } inWant := string(input) - RunPrecompiledContract(nil, p, a, input, gas, nil) + RunPrecompiledContract(nil, p, a, input, NewGasBudget(gas), nil) 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 b647dcc62b..dda753f504 100644 --- a/core/vm/contracts_test.go +++ b/core/vm/contracts_test.go @@ -99,7 +99,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(nil, p, common.HexToAddress(addr), in, gas, nil); err != nil { + if res, _, err := RunPrecompiledContract(nil, p, common.HexToAddress(addr), in, NewGasBudget(gas), nil); 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 +121,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(nil, p, common.HexToAddress(addr), in, gas, nil) + _, _, err := RunPrecompiledContract(nil, p, common.HexToAddress(addr), in, NewGasBudget(gas), nil) if err.Error() != "out of gas" { t.Errorf("Expected error [out of gas], got [%v]", err) } @@ -138,7 +138,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(nil, p, common.HexToAddress(addr), in, gas, nil) + _, _, err := RunPrecompiledContract(nil, p, common.HexToAddress(addr), in, NewGasBudget(gas), nil) if err.Error() != test.ExpectedError { t.Errorf("Expected error [%v], got [%v]", test.ExpectedError, err) } @@ -169,7 +169,7 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) { start := time.Now() for bench.Loop() { copy(data, in) - res, _, err = RunPrecompiledContract(nil, p, common.HexToAddress(addr), data, reqGas, nil) + res, _, err = RunPrecompiledContract(nil, p, common.HexToAddress(addr), data, NewGasBudget(reqGas), nil) } elapsed := uint64(time.Since(start)) if elapsed < 1 { diff --git a/core/vm/eips.go b/core/vm/eips.go index 8f4ca3ae41..54e5cb0c60 100644 --- a/core/vm/eips.go +++ b/core/vm/eips.go @@ -382,7 +382,7 @@ func opExtCodeCopyEIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, er 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.RegularGas) - scope.Contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeUnspecified) + scope.Contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas } @@ -408,7 +408,7 @@ func opPush1EIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // 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.RegularGas) - scope.Contract.UseGas(wanted, evm.Config.Tracer, tracing.GasChangeUnspecified) + scope.Contract.UseGas(GasCosts{RegularGas: wanted}, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas } @@ -436,7 +436,7 @@ func makePushEIP4762(size uint64, pushByteSize int) executionFunc { 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.RegularGas) - scope.Contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeUnspecified) + scope.Contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeUnspecified) if consumed < wanted { return nil, ErrOutOfGas } diff --git a/core/vm/evm.go b/core/vm/evm.go index 8f68478842..ca8d8967ec 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -236,13 +236,13 @@ 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) { @@ -265,12 +265,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() { @@ -303,7 +303,7 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g contract.IsSystemCall = isSystemCall(caller) contract.SetCallCode(evm.resolveCodeHash(addr), code) ret, err = evm.Run(contract, input, false) - gas = contract.Gas.RegularGas + gas = contract.Gas } } // When an error was returned by the EVM or when setting the creation code @@ -313,9 +313,9 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g 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) + evm.Config.Tracer.OnGasChange(gas.RegularGas, 0, tracing.GasChangeCallFailedExecution) } - gas = 0 + gas.Exhaust() } // TODO: consider clearing up unused snapshots: //} else { @@ -331,13 +331,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) { @@ -365,15 +365,15 @@ func (evm *EVM) CallCode(caller common.Address, addr common.Address, input []byt contract := NewContract(caller, caller, value, gas, evm.jumpDests) contract.SetCallCode(evm.resolveCodeHash(addr), evm.resolveCode(addr)) ret, err = evm.Run(contract, input, false) - gas = contract.Gas.RegularGas + gas = contract.Gas } 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) + evm.Config.Tracer.OnGasChange(gas.RegularGas, 0, tracing.GasChangeCallFailedExecution) } - gas = 0 + gas.Exhaust() } } return ret, gas, err @@ -384,14 +384,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) { @@ -413,15 +413,15 @@ func (evm *EVM) DelegateCall(originCaller common.Address, caller common.Address, contract := NewContract(originCaller, caller, value, gas, evm.jumpDests) contract.SetCallCode(evm.resolveCodeHash(addr), evm.resolveCode(addr)) ret, err = evm.Run(contract, input, false) - gas = contract.Gas.RegularGas + gas = contract.Gas } 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) + evm.Config.Tracer.OnGasChange(gas.RegularGas, 0, tracing.GasChangeCallFailedExecution) } - gas = 0 + gas.Exhaust() } } return ret, gas, err @@ -431,13 +431,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) { @@ -472,28 +472,27 @@ func (evm *EVM) StaticCall(caller common.Address, addr common.Address, input []b // above we revert to the snapshot and consume any gas remaining. Additionally // when we're in Homestead this also counts for code storage gas errors. ret, err = evm.Run(contract, input, true) - gas = contract.Gas.RegularGas + gas = contract.Gas } 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) + evm.Config.Tracer.OnGasChange(gas.RegularGas, 0, 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. @@ -511,14 +510,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) + evm.Config.Tracer.OnGasChange(prior, gas.RegularGas, tracing.GasChangeWitnessContractCollisionCheck) } - gas = gas - statelessGas } // We add this to the access list _before_ taking a snapshot. Even if the @@ -536,9 +536,10 @@ func (evm *EVM) create(caller common.Address, code []byte, gas uint64, value *ui (contractHash != (common.Hash{}) && contractHash != types.EmptyCodeHash) || // non-empty code isEIP7610RejectedAccount(evm.ChainConfig().ChainID, address, evm.chainRules.IsEIP158) { if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution) + evm.Config.Tracer.OnGasChange(gas.RegularGas, 0, 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 @@ -558,14 +559,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 { - 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 } + prior, _ := gas.Charge(GasCosts{RegularGas: consumed}) if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas, gas-consumed, tracing.GasChangeWitnessContractInit) + evm.Config.Tracer.OnGasChange(prior, gas.RegularGas, tracing.GasChangeWitnessContractInit) } - gas = gas - consumed } evm.Context.Transfer(evm.StateDB, caller, address, value, &evm.chainRules) @@ -582,10 +584,10 @@ 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.RegularGas, evm.Config.Tracer, tracing.GasChangeCallFailedExecution) + contract.UseGas(GasCosts{RegularGas: contract.Gas.RegularGas}, evm.Config.Tracer, tracing.GasChangeCallFailedExecution) } } - return ret, address, contract.Gas.RegularGas, err + return ret, address, contract.Gas, err } // initNewContract runs a new contract's creation code, performs checks on the @@ -608,12 +610,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.RegularGas) - contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) + contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) if len(ret) > 0 && (consumed < wanted) { return ret, ErrCodeStoreOutOfGas } @@ -626,7 +628,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) } @@ -635,7 +637,7 @@ 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) { +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) diff --git a/core/vm/gas_table_test.go b/core/vm/gas_table_test.go index e9e56038dd..16ce651a7d 100644 --- a/core/vm/gas_table_test.go +++ b/core/vm/gas_table_test.go @@ -97,12 +97,12 @@ func TestEIP2200(t *testing.T) { 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 { @@ -157,12 +157,12 @@ func TestCreateGas(t *testing.T) { } evm := NewEVM(vmctx, statedb, chainConfig, config) - var startGas = uint64(testGas) - ret, gas, err := evm.Call(common.Address{}, address, nil, startGas, new(uint256.Int)) + 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 index ba6746758b..cc90c54798 100644 --- a/core/vm/gascosts.go +++ b/core/vm/gascosts.go @@ -19,7 +19,8 @@ package vm import "fmt" // GasCosts denotes a vector of gas costs in the -// multidimensional metering paradigm. +// multidimensional metering paradigm. It represents the cost +// charged by an individual operation. type GasCosts struct { RegularGas uint64 StateGas uint64 @@ -34,3 +35,63 @@ func (g GasCosts) Sum() uint64 { 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 gas value and false if the budget does not have sufficient +// gas to cover the cost. +func (g *GasBudget) Charge(cost GasCosts) (uint64, bool) { + prior := g.RegularGas + if prior < cost.RegularGas { + return prior, false + } + g.RegularGas -= cost.RegularGas + return prior, true +} + +// Refund adds the given gas budget back. It returns the pre-refund gas +// value and whether the budget was actually changed. +func (g *GasBudget) Refund(other GasBudget) (uint64, bool) { + prior := g.RegularGas + g.RegularGas += other.RegularGas + return prior, g.RegularGas != prior +} diff --git a/core/vm/instructions.go b/core/vm/instructions.go index c3d1633c78..3311af0d22 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -667,9 +667,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 @@ -707,10 +707,10 @@ func opCreate2(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { // 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 { @@ -747,7 +747,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() @@ -781,7 +781,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 { @@ -810,7 +810,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 { @@ -839,7 +839,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 { diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go index 5055ccb16d..dbe055f2ac 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -565,7 +565,7 @@ func TestOpTstore(t *testing.T) { 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") ) diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index b507595fab..9dc0a0b787 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -174,7 +174,7 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte // associated costs. contractAddr := contract.Address() consumed, wanted := evm.TxContext.AccessEvents.CodeChunksRangeGas(contractAddr, pc, 1, uint64(len(contract.Code)), false, contract.Gas.RegularGas) - contract.UseGas(consumed, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) + contract.UseGas(GasCosts{RegularGas: consumed}, evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) if consumed < wanted { return nil, ErrOutOfGas } diff --git a/core/vm/interpreter_test.go b/core/vm/interpreter_test.go index 28df8546b5..69c2316907 100644 --- a/core/vm/interpreter_test.go +++ b/core/vm/interpreter_test.go @@ -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) @@ -85,7 +85,7 @@ func BenchmarkInterpreter(b *testing.B) { value = uint256.NewInt(0) stack = newstack() 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/operations_acl.go b/core/vm/operations_acl.go index 154c261cae..313d03819e 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -168,7 +168,7 @@ 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) { + if !contract.UseGas(GasCosts{RegularGas: coldCost}, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { return GasCosts{}, ErrOutOfGas } } @@ -295,7 +295,7 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { // Charge the remaining difference here already, to correctly calculate // available gas for call - if !contract.UseGas(eip2929Cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { + if !contract.UseGas(GasCosts{RegularGas: eip2929Cost}, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { return GasCosts{}, ErrOutOfGas } } @@ -324,7 +324,7 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { evm.StateDB.AddAddressToAccessList(target) eip7702Cost = params.ColdAccountAccessCostEIP2929 } - if !contract.UseGas(eip7702Cost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { + if !contract.UseGas(GasCosts{RegularGas: eip7702Cost}, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { return GasCosts{}, ErrOutOfGas } } diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index af394aa054..4fafdf3a50 100644 --- a/core/vm/runtime/runtime.go +++ b/core/vm/runtime/runtime.go @@ -148,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 } @@ -182,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 @@ -217,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/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go index 694debcf98..6570d73575 100644 --- a/eth/tracers/js/tracer_test.go +++ b/eth/tracers/js/tracer_test.go @@ -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} @@ -183,7 +183,7 @@ 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: uint256.NewInt(1)}) @@ -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/logger/logger_test.go b/eth/tracers/logger/logger_test.go index 554a37aff1..decdf588e1 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 diff --git a/tests/state_test.go b/tests/state_test.go index 25e90d388d..8444d211cf 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -312,7 +312,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 @@ -326,8 +326,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(), uint256.MustFromBig(msg.Value)) if err != nil { b.Error(err) return @@ -336,7 +338,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/transaction_test_util.go b/tests/transaction_test_util.go index a90c2d522f..a659a1f786 100644 --- a/tests/transaction_test_util.go +++ b/tests/transaction_test_util.go @@ -81,10 +81,11 @@ 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) if err != nil { return } + requiredGas = cost.RegularGas if requiredGas > tx.Gas() { return sender, hash, 0, fmt.Errorf("insufficient gas ( %d < %d )", tx.Gas(), requiredGas) } From b6d415c88d79d165acad68db69666f35871457e4 Mon Sep 17 00:00:00 2001 From: CPerezz <37264926+CPerezz@users.noreply.github.com> Date: Mon, 20 Apr 2026 14:08:30 +0200 Subject: [PATCH 092/183] trie/bintrie: replace BinaryNode interface with GC-free NodeRef arena (#34055) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Replace the `BinaryNode` interface with `NodeRef uint32` indices into typed arena pools, eliminating GC-scanned pointers from binary trie nodes. Inspired by [fjl's observation](https://github.com/ethereum/go-ethereum/pull/34034#issuecomment-4075176446): > *"if the binary trie produces such a large graph, it should probably be changed so that the trie node type does not contain pointers. The runtime does not scan objects that do not contain pointers, so it can really help with the performance to build it this way."* ### The problem CPU profiling of the binary trie (EIP-7864) showed **44% of CPU time in garbage collection**. Each `InternalNode` held two `BinaryNode` interface values (2 pointer-words each), and the GC scanned every one. With ~25K `InternalNode`s in memory during block processing, this created enormous GC pressure. ### The solution `NodeRef` is a compact `uint32` (2-bit kind tag + 30-bit pool index). `NodeStore` manages chunked typed pools per node kind: - **InternalNode pool**: ZERO Go pointers (children are `NodeRef`, hash is `[32]byte`) → noscan spans - **HashedNode pool**: ZERO Go pointers → noscan spans - **StemNode pool**: retains `Values [][]byte` (matching existing format) The serialization format is unchanged — flat InternalNode `[type][leftHash][rightHash]` = 65 bytes. ## Benchmark: Apple M4 Pro (`--benchtime=10s --count=3`, on top of #34021) | Metric | Baseline | Arena | Delta | |--------|----------|-------|-------| | Approve (Mgas/s) | 374 | 382 | **+2.1%** | | BalanceOf (Mgas/s) | 885 | 901 | **+1.8%** | | Approve allocs/op | 775K | **607K** | **-21.7%** | | BalanceOf allocs/op | 265K | **228K** | **-14.0%** | ## Benchmark: AMD EPYC 48-core (50GB state, execution-specs ERC-20, on top of #34021 + #34032) | Benchmark | Baseline | Arena | Delta | |-----------|----------|-------|-------| | erc20_approve (write) | 22.4 Mgas/s | **27.0 Mgas/s** | **+20.5%** | | mixed_sload_sstore | 62.9 Mgas/s | **97.3 Mgas/s** | **+54.7%** | | erc20_balanceof (read) | 180.8 Mgas/s | 167.6 Mgas/s | -7.3% (cold cache variance) | The arena benefit scales with heap size — the EPYC (larger heap, more GC pressure) shows much larger gains than the M4 Pro (efficient unified memory). The mixed workload baseline was unstable (62.9 vs 16.3 Mgas/s between runs due to GC-induced throughput collapse); the arena eliminates this entirely (95-97 Mgas/s, stable). ## Dependencies Benchmarked with #34021 (H01 N+1 fix) + #34032 (R14 parallel hashing). No code dependency — applies independently to master. All test suites pass (`trie/bintrie` with `-race`, `core/state`, `triedb/pathdb`, `cmd/geth`). --------- Co-authored-by: Guillaume Ballet <3272758+gballet@users.noreply.github.com> --- trie/bintrie/binary_node.go | 140 +-------- trie/bintrie/binary_node_test.go | 148 ++++++---- trie/bintrie/empty.go | 76 ----- trie/bintrie/empty_test.go | 264 ----------------- trie/bintrie/hashed_node.go | 73 +---- trie/bintrie/hashed_node_test.go | 181 +++++------- trie/bintrie/internal_node.go | 278 +---------------- trie/bintrie/internal_node_test.go | 459 +++++++++-------------------- trie/bintrie/iterator.go | 241 ++++++++------- trie/bintrie/iterator_test.go | 36 ++- trie/bintrie/node_ref.go | 56 ++++ trie/bintrie/node_store.go | 184 ++++++++++++ trie/bintrie/stem_node.go | 245 ++++----------- trie/bintrie/stem_node_test.go | 425 ++++++++++---------------- trie/bintrie/store_commit.go | 310 +++++++++++++++++++ trie/bintrie/store_ops.go | 345 ++++++++++++++++++++++ trie/bintrie/trie.go | 83 ++---- trie/bintrie/trie_test.go | 231 ++++++--------- triedb/pathdb/database.go | 6 +- 19 files changed, 1689 insertions(+), 2092 deletions(-) delete mode 100644 trie/bintrie/empty.go delete mode 100644 trie/bintrie/empty_test.go create mode 100644 trie/bintrie/node_ref.go create mode 100644 trie/bintrie/node_store.go create mode 100644 trie/bintrie/store_commit.go create mode 100644 trie/bintrie/store_ops.go diff --git a/trie/bintrie/binary_node.go b/trie/bintrie/binary_node.go index 8905a82285..e7f57d45a2 100644 --- a/trie/bintrie/binary_node.go +++ b/trie/bintrie/binary_node.go @@ -16,140 +16,32 @@ 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 + nodeTypeStem = iota + 1 nodeTypeInternal ) -// 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") +// 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 } -} - -var invalidSerializedLength = errors.New("invalid serialized node length") - -// DeserializeNode deserializes a binary trie node from a byte slice. The -// hash will be recomputed from the deserialized data. -func DeserializeNode(serialized []byte, depth int) (BinaryNode, error) { - return deserializeNode(serialized, depth, common.Hash{}, true, true) -} - -// DeserializeNodeWithHash deserializes a binary trie node from a byte slice, using the provided hash. -func DeserializeNodeWithHash(serialized []byte, depth int, hn common.Hash) (BinaryNode, error) { - return deserializeNode(serialized, depth, hn, false, false) -} - -func deserializeNode(serialized []byte, depth int, hn common.Hash, mustRecompute, dirty bool) (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])), - hash: hn, - mustRecompute: mustRecompute, - dirty: dirty, - }, 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 - - 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, - hash: hn, - mustRecompute: mustRecompute, - dirty: dirty, - }, nil - default: - return nil, errors.New("invalid node type") - } -} - -// 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 242743ba53..12ac199903 100644 --- a/trie/bintrie/binary_node_test.go +++ b/trie/bintrie/binary_node_test.go @@ -23,79 +23,100 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestSerializeDeserializeInternalNode tests serialization and deserialization of InternalNode +// TestSerializeDeserializeInternalNode tests flat 65-byte serialization and +// deserialization of InternalNode through nodeStore. 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 - // Check the serialized format + // Serialize the node — flat 65-byte format + serialized := s.serializeNode(rootRef) + + // Check the serialized format: [type(1)][leftHash(32)][rightHash(32)] if serialized[0] != nodeTypeInternal { t.Errorf("Expected type byte to be %d, got %d", nodeTypeInternal, serialized[0]) } - if len(serialized) != 65 { - t.Errorf("Expected serialized length to be 65, got %d", len(serialized)) + expectedLen := NodeTypeBytes + 2*HashSize // 1 + 64 = 65 + if len(serialized) != expectedLen { + t.Errorf("Expected serialized length to be %d, got %d", expectedLen, len(serialized)) } - // Deserialize the node - deserialized, err := DeserializeNode(serialized, 5) + // Check that left and right hashes are embedded directly + if !bytes.Equal(serialized[NodeTypeBytes:NodeTypeBytes+HashSize], leftHash[:]) { + t.Error("Left hash not found at expected position") + } + if !bytes.Equal(serialized[NodeTypeBytes+HashSize:], rightHash[:]) { + t.Error("Right hash not found at expected position") + } + + // 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) // Check the serialized format if serialized[0] != nodeTypeStem { @@ -107,31 +128,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 +162,43 @@ 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 with valid type byte but wrong length (needs exactly 65 bytes) + invalidData := []byte{nodeTypeInternal, 0, 0, 0} - _, err := DeserializeNode(invalidData, 0) + _, err := s.deserializeNode(invalidData, 0) if err == nil { t.Fatal("Expected error for invalid data length, got nil") } @@ -186,7 +208,7 @@ func TestDeserializeInvalidLength(t *testing.T) { } } -// TestKeyToPath tests the keyToPath function +// TestKeyToPath tests the keyToPath function. func TestKeyToPath(t *testing.T) { tests := []struct { name string @@ -218,14 +240,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 c47e284dac..0000000000 --- a/trie/bintrie/empty.go +++ /dev/null @@ -1,76 +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, - mustRecompute: true, - dirty: true, - }, 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, - mustRecompute: true, - dirty: true, - }, 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 4da1ed15a0..0000000000 --- a/trie/bintrie/empty_test.go +++ /dev/null @@ -1,264 +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) - } -} - -// TestEmptyInsertMarksDirty verifies that a StemNode produced by Empty.Insert -// is marked dirty. Without this, CollectNodes would skip the freshly created -// stem and its blob would never reach disk, producing "missing trie node" -// errors on subsequent reads. -func TestEmptyInsertMarksDirty(t *testing.T) { - key := make([]byte, 32) - key[0] = 0xaa - val := make([]byte, 32) - val[0] = 0xbb - n, err := Empty{}.Insert(key, val, nil, 0) - if err != nil { - t.Fatalf("Insert: %v", err) - } - sn, ok := n.(*StemNode) - if !ok { - t.Fatalf("expected *StemNode, got %T", n) - } - if !sn.dirty { - t.Fatalf("stem produced by Empty.Insert must have dirty=true") - } -} - -// TestEmptyInsertValuesAtStemMarksDirty is the analogous guard for the -// bulk-insert entry point. Fresh stems created here must be dirty. -func TestEmptyInsertValuesAtStemMarksDirty(t *testing.T) { - key := make([]byte, 32) - key[0] = 0xcc - values := make([][]byte, 256) - values[0] = make([]byte, 32) - n, err := Empty{}.InsertValuesAtStem(key, values, nil, 3) - if err != nil { - t.Fatalf("InsertValuesAtStem: %v", err) - } - sn, ok := n.(*StemNode) - if !ok { - t.Fatalf("expected *StemNode, got %T", n) - } - if !sn.dirty { - t.Fatalf("stem produced by Empty.InsertValuesAtStem must have dirty=true") - } -} diff --git a/trie/bintrie/hashed_node.go b/trie/bintrie/hashed_node.go index e44c6d1e8a..b176df079b 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 := DeserializeNodeWithHash(data, depth, common.Hash(h)) - 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 f9e6984888..ae77b7c570 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) - // 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/internal_node.go b/trie/bintrie/internal_node.go index 811f65bcd8..b83cb92d87 100644 --- a/trie/bintrie/internal_node.go +++ b/trie/bintrie/internal_node.go @@ -17,35 +17,13 @@ package bintrie import ( - "crypto/sha256" "errors" - "fmt" - "math/bits" - "runtime" - "sync" "github.com/ethereum/go-ethereum/common" ) -// parallelDepth returns the tree depth below which Hash() spawns goroutines. -func parallelDepth() int { - return min(bits.Len(uint(runtime.NumCPU())), 8) -} - -// isDirty reports whether a BinaryNode child needs rehashing. -func isDirty(n BinaryNode) bool { - switch v := n.(type) { - case *InternalNode: - return v.mustRecompute - case *StemNode: - return v.mustRecompute - default: - return false - } -} - 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) @@ -56,252 +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 - - mustRecompute bool // true if the hash needs to be recomputed - dirty bool // true if the node's on-disk blob is stale (needs flush) - hash common.Hash // cached hash when mustRecompute == false -} - -// 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 := DeserializeNodeWithHash(data, bt.depth+1, common.Hash(hn)) - 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 := DeserializeNodeWithHash(data, bt.depth+1, common.Hash(hn)) - 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, - mustRecompute: bt.mustRecompute, - dirty: bt.dirty, - hash: bt.hash, - } -} - -// Hash returns the hash of the node. -func (bt *InternalNode) Hash() common.Hash { - if !bt.mustRecompute { - return bt.hash - } - - // At shallow depths, parallelize when both children need rehashing: - // hash left subtree in a goroutine, right subtree inline, then combine. - // Skip goroutine overhead when only one child is dirty (common case - // for narrow state updates that touch a single path through the trie). - if bt.depth < parallelDepth() && isDirty(bt.left) && isDirty(bt.right) { - var input [64]byte - var lh common.Hash - var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() - lh = bt.left.Hash() - }() - rh := bt.right.Hash() - copy(input[32:], rh[:]) - wg.Wait() - copy(input[:32], lh[:]) - bt.hash = sha256.Sum256(input[:]) - bt.mustRecompute = false - return bt.hash - } - - // Deeper nodes: sequential using pooled hasher (goroutine overhead > hash cost) - h := newSha256() - defer returnSha256(h) - 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[:]) - } - bt.hash = common.BytesToHash(h.Sum(nil)) - bt.mustRecompute = false - return bt.hash -} - -// 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 := DeserializeNodeWithHash(data, bt.depth+1, common.Hash(hn)) - 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) - bt.mustRecompute = true - bt.dirty = true - 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 := DeserializeNodeWithHash(data, bt.depth+1, common.Hash(hn)) - 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) - bt.mustRecompute = true - bt.dirty = true - return bt, err -} - -// CollectNodes collects all child nodes at a given path, and flushes it -// into the provided node collector. Clean subtrees (dirty == false) are -// skipped. -func (bt *InternalNode) CollectNodes(path []byte, flushfn NodeFlushFn) error { - if !bt.dirty { - return nil - } - 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) - bt.dirty = false - 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 ddcec8085d..8d5a75de8c 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), 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,179 +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) + // Verify the value was stored + value, err := s.Get(leftKey, nil) + if err != nil { + t.Fatalf("Failed to get: %v", err) } - - // 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]) - } - - // 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() + s := newNodeStore() - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - rightStem.Stem[0] = 0x80 - rightStem.Values[0] = common.HexToHash("0x0202").Bytes() + leftKey := make([]byte, 32) + leftKey[31] = 0 + leftValue := common.HexToHash("0x0101").Bytes() - node := &InternalNode{ - depth: 0, - left: leftStem, - right: rightStem, + rightKey := make([]byte, 32) + rightKey[0] = 0x80 + rightKey[31] = 0 + rightValue := common.HexToHash("0x0202").Bytes() + + if err := s.Insert(leftKey, leftValue, nil); err != nil { + t.Fatal(err) + } + if err := s.Insert(rightKey, rightValue, nil); err != nil { + t.Fatal(err) } - // Create a copy - copied := node.Copy() - copiedInternal, ok := copied.(*InternalNode) - if !ok { - t.Fatalf("Expected InternalNode, got %T", copied) - } + ns := s.Copy() - // Check depth - if copiedInternal.depth != node.depth { - t.Errorf("Depth mismatch: expected %d, got %d", node.depth, copiedInternal.depth) - } - - // Check that children are copied - copiedLeft, ok := copiedInternal.left.(*StemNode) - if !ok { - t.Fatalf("Expected left child to be StemNode, got %T", copiedInternal.left) - } - - copiedRight, ok := copiedInternal.right.(*StemNode) - if !ok { - t.Fatalf("Expected right child to be StemNode, got %T", copiedInternal.right) - } - - // 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") - } - - // 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")) - node.mustRecompute = true - 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")), - mustRecompute: true, - } - 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) } @@ -298,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) } @@ -310,201 +239,103 @@ 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 the values are stored + retrieved, err := s.GetValuesAtStem(stem, nil) + if err != nil { + t.Fatalf("Failed to get values: %v", err) } - - // 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) - } - - 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. All three are - // marked dirty to mirror production semantics — see CollectNodes. - leftStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - dirty: true, - } + s := newNodeStore() - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - dirty: true, - } - rightStem.Stem[0] = 0x80 + leftStem := make([]byte, 31) + rightStem := make([]byte, 31) + rightStem[0] = 0x80 - node := &InternalNode{ - depth: 0, - left: leftStem, - right: rightStem, - dirty: true, + 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) + err := s.collectNodes(s.root, []byte{1}, flushFn) if err != nil { t.Fatalf("Failed to collect nodes: %v", err) } // 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)) } } -// TestInternalNodeCollectNodesSkipsClean verifies clean subtrees are not -// flushed. A dirty internal node over clean children only flushes itself; -// a fully clean tree flushes nothing. -func TestInternalNodeCollectNodesSkipsClean(t *testing.T) { - leftStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - rightStem.Stem[0] = 0x80 - - dirtyParent := &InternalNode{ - depth: 0, - left: leftStem, - right: rightStem, - dirty: true, - } - - var collected []BinaryNode - flushFn := func(_ []byte, n BinaryNode) { collected = append(collected, n) } - - if err := dirtyParent.CollectNodes([]byte{1}, flushFn); err != nil { - t.Fatalf("CollectNodes: %v", err) - } - if len(collected) != 1 || collected[0] != dirtyParent { - t.Fatalf("expected only the dirty parent to be flushed, got %d nodes", len(collected)) - } - if dirtyParent.dirty { - t.Errorf("parent dirty flag should be cleared after flush") - } - - // Second call on the same tree should be a no-op: everything is clean. - collected = nil - if err := dirtyParent.CollectNodes([]byte{1}, flushFn); err != nil { - t.Fatalf("CollectNodes (second call): %v", err) - } - if len(collected) != 0 { - t.Errorf("expected no nodes to be flushed on clean tree, got %d", len(collected)) - } -} - -// 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() + + // 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 + + 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) } - rightStem := &StemNode{ - Stem: make([]byte, 31), - Values: make([][]byte, 256), - depth: 1, - } - - node := &InternalNode{ - depth: 0, - left: leftInternal, - right: rightStem, - } - - 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 048d37f766..31645430c3 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,51 +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 - resolverPath := it.Path() - data, err := it.trie.nodeResolver(resolverPath, common.Hash(node)) - if err != nil { - panic(err) - } - if data == nil { - // Empty/nil node — treat as Empty, backtrack - it.current = Empty{} - it.stack[len(it.stack)-1].Node = it.current - return it.Next(descend) - } - it.current, err = DeserializeNodeWithHash(data, len(it.stack)-1, common.Hash(node)) - if err != nil { - panic(err) - } - // update the stack and parent with the resolved node - it.stack[len(it.stack)-1].Node = it.current - if len(it.stack) >= 2 { - parent := &it.stack[len(it.stack)-2] - if parent.Index == 0 { - parent.Node.(*InternalNode).left = it.current - } else { - parent.Node.(*InternalNode).right = it.current - } - } - return it.Next(descend) - case Empty: - // Empty node - go back to parent and continue - if len(it.stack) <= 1 { - it.lastErr = errIteratorEnd + 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 } - it.stack = it.stack[:len(it.stack)-1] - it.current = it.stack[len(it.stack)-1].Node - it.stack[len(it.stack)-1].Index++ + hn := it.store.getHashed(it.current.Index()) + data, err := it.trie.nodeResolver(it.Path(), hn.Hash()) + if err != nil { + it.lastErr = err + return false + } + resolved, err := it.store.deserializeNodeWithHash(data, len(it.stack)-1, hn.Hash()) + if err != nil { + it.lastErr = err + return false + } + + 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 { + parentNode.left = resolved + } else { + parentNode.right = resolved + } + it.store.freeHashedNode(oldHashedIdx) return it.Next(descend) + + 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 @@ -169,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 } @@ -198,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) } -// 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 index 3e717c07ba..746f6e8c0f 100644 --- a/trie/bintrie/iterator_test.go +++ b/trie/bintrie/iterator_test.go @@ -27,14 +27,13 @@ import ( // 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{ - root: NewBinaryNode(), + store: store, tracer: trie.NewPrevalueTracer(), } for _, kv := range entries { - var err error - tr.root, err = tr.root.Insert(kv[0][:], kv[1][:], nil, 0) - if err != nil { + if err := store.Insert(kv[0][:], kv[1][:], nil); err != nil { t.Fatal(err) } } @@ -64,7 +63,7 @@ func countLeaves(t *testing.T, tr *BinaryTrie) int { // no nodes and reports no error. func TestIteratorEmptyTrie(t *testing.T) { tr := &BinaryTrie{ - root: Empty{}, + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } it, err := newBinaryNodeIterator(tr, nil) @@ -145,8 +144,8 @@ func TestIteratorEmptyNodeBacktrack(t *testing.T) { {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000001"), oneKey}, }) - if _, ok := tr.root.(*InternalNode); !ok { - t.Fatalf("expected InternalNode root, got %T", tr.root) + 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) @@ -162,18 +161,31 @@ func TestIteratorHashedNodeNilData(t *testing.T) { {common.HexToHash("8000000000000000000000000000000000000000000000000000000000000001"), oneKey}, }) - root, ok := tr.root.(*InternalNode) - if !ok { - t.Fatalf("expected InternalNode root, got %T", tr.root) + 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. - root.right = HashedNode(common.Hash{}) + rootNode.right = tr.store.newHashedRef(common.Hash{}) // Should not panic; the zero-hash right child should be treated as Empty. - if leaves := countLeaves(t, tr); leaves != 1 { + // 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) } } diff --git a/trie/bintrie/node_ref.go b/trie/bintrie/node_ref.go new file mode 100644 index 0000000000..1c9c0f6284 --- /dev/null +++ b/trie/bintrie/node_ref.go @@ -0,0 +1,56 @@ +// 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 + +// 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 0000000000..8a35f06ee1 --- /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 0ceae6b062..93c55acefa 100644 --- a/trie/bintrie/stem_node.go +++ b/trie/bintrie/stem_node.go @@ -17,236 +17,93 @@ package bintrie import ( - "bytes" - "errors" - "fmt" - "slices" + "crypto/sha256" "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 - mustRecompute bool // true if the hash needs to be recomputed - dirty bool // true if the node's on-disk blob is stale (needs flush) + depth uint8 + + 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 } -// Get retrieves the value for the given key. -func (bt *StemNode) Get(key []byte, _ NodeResolverFn) ([]byte, error) { - if !bytes.Equal(bt.Stem, key[:StemSize]) { - return nil, nil - } - return bt.Values[key[StemSize]], nil +func (sn *StemNode) getValue(suffix byte) []byte { + return sn.values[suffix] } -// 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, mustRecompute: true, dirty: true} - bt.depth++ - // bt is re-parented under n and sits at a new path — rewrite its blob. - bt.mustRecompute = true - bt.dirty = true - 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).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, - mustRecompute: true, - dirty: true, - } - } - return n, nil - } - if len(value) != HashSize { - return bt, errors.New("invalid insertion: value length") - } - bt.Values[key[StemSize]] = value - bt.mustRecompute = true - bt.dirty = true - 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, - hash: bt.hash, - mustRecompute: bt.mustRecompute, - dirty: bt.dirty, - } +// 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 { - if !bt.mustRecompute { - return bt.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 - h := newSha256() - defer returnSha256(h) - for i, v := range bt.Values { + + for i, v := range sn.values { if v != nil { - h.Reset() - h.Write(v) - h.Sum(data[i][:0]) + data[i] = sha256.Sum256(v) } } - h.Reset() + 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][:]) - bt.hash = common.BytesToHash(h.Sum(nil)) - bt.mustRecompute = false - return bt.hash + 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 } -// CollectNodes flushes the stem via the collector when dirty; clean stems -// are skipped. -func (bt *StemNode) CollectNodes(path []byte, flush NodeFlushFn) error { - if !bt.dirty { - return nil - } - flush(path, bt) - bt.dirty = false - 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, mustRecompute: true, dirty: true} - bt.depth++ - // bt is re-parented under n and sits at a new path — rewrite its blob. - bt.mustRecompute = true - bt.dirty = true - 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, - mustRecompute: true, - dirty: true, - } - } - return n, nil - } - - // same stem, just merge the two value lists - for i, v := range values { - if v != nil { - bt.Values[i] = v - bt.mustRecompute = true - bt.dirty = true - } - } - 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 -} - -// 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 2743e7ce9b..5faf903fba 100644 --- a/trie/bintrie/stem_node_test.go +++ b/trie/bintrie/stem_node_test.go @@ -23,165 +23,99 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestStemNodeGet tests the Get method for matching stem, non-matching stem, -// and nil-value suffix scenarios. -func TestStemNodeGet(t *testing.T) { - stem := make([]byte, StemSize) - stem[0] = 0xAB - var values [StemNodeWidth][]byte - values[5] = common.HexToHash("0xdeadbeef").Bytes() - - node := &StemNode{Stem: stem, Values: values[:], depth: 0} - - // Matching stem, populated suffix → returns value. - key := make([]byte, HashSize) - copy(key[:StemSize], stem) - key[StemSize] = 5 - got, err := node.Get(key, nil) - if err != nil { - t.Fatalf("Get error: %v", err) - } - if !bytes.Equal(got, values[5]) { - t.Fatalf("Get = %x, want %x", got, values[5]) - } - - // Matching stem, empty suffix → returns nil (slot not set). - key[StemSize] = 99 - got, err = node.Get(key, nil) - if err != nil { - t.Fatalf("Get error: %v", err) - } - if got != nil { - t.Fatalf("Get(empty suffix) = %x, want nil", got) - } - - // Non-matching stem → returns nil, nil. - otherKey := make([]byte, HashSize) - otherKey[0] = 0xFF - got, err = node.Get(otherKey, nil) - if err != nil { - t.Fatalf("Get error: %v", err) - } - if got != nil { - t.Fatalf("Get(wrong stem) = %x, want nil", got) - } -} - -// 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) + rootNode := s.getInternal(s.root.Index()) + if rootNode.depth != 0 { + t.Errorf("Expected depth 0, got %d", rootNode.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) + // Verify both values are retrievable + v1, _ := s.Get(key1, nil) + if !bytes.Equal(v1, value1) { + t.Error("Value 1 mismatch") } - if !bytes.Equal(leftStem.Stem, stem1) { - t.Errorf("Left stem mismatch") - } - - // 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) - } - 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 + s := newNodeStore() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 0, - } - - // 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") } @@ -191,221 +125,209 @@ 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) + s := newNodeStore() + + key1 := make([]byte, 32) + for i := range 31 { + key1[i] = byte(i) + } + key1[31] = 0 + value1 := common.HexToHash("0x0101").Bytes() + + key2 := make([]byte, 32) + copy(key2[:31], key1[:31]) + key2[31] = 255 + value2 := common.HexToHash("0x0202").Bytes() + + if err := s.Insert(key1, value1, nil); err != nil { + t.Fatal(err) + } + if err := s.Insert(key2, value2, nil); err != nil { + t.Fatal(err) } - var values [256][]byte - values[0] = common.HexToHash("0x0101").Bytes() - values[255] = common.HexToHash("0x0202").Bytes() + ns := s.Copy() - node := &StemNode{ - Stem: stem, - Values: values[:], - depth: 10, - } - - // Create a copy - copied := node.Copy() - copiedStem, ok := copied.(*StemNode) - if !ok { - t.Fatalf("Expected StemNode, got %T", copied) - } - - // Check that values are equal but not the same slice - if !bytes.Equal(copiedStem.Stem, node.Stem) { - t.Errorf("Stem mismatch after copy") - } - if &copiedStem.Stem[0] == &node.Stem[0] { - t.Error("Stem slice not properly cloned") - } - - // Check values - if !bytes.Equal(copiedStem.Values[0], node.Values[0]) { + // 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() - node.mustRecompute = true - 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, - dirty: true, + 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) + err := s.collectNodes(s.root, []byte{0, 1, 0}, flushFn) if err != nil { t.Fatalf("Failed to collect nodes: %v", err) } // 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 @@ -413,44 +335,3 @@ func TestStemNodeCollectNodes(t *testing.T) { t.Errorf("Path mismatch: expected [0, 1, 0], got %v", collectedPaths[0]) } } - -// TestStemNodeCollectNodesSkipsClean verifies that a clean stem is not -// flushed, and that flushing a dirty stem clears its dirty flag so that -// a subsequent CollectNodes on the same node is a no-op. -func TestStemNodeCollectNodesSkipsClean(t *testing.T) { - stem := make([]byte, 31) - node := &StemNode{ - Stem: stem, - Values: make([][]byte, 256), - depth: 0, - } - - var collected []BinaryNode - flushFn := func(_ []byte, n BinaryNode) { collected = append(collected, n) } - - if err := node.CollectNodes([]byte{0}, flushFn); err != nil { - t.Fatalf("CollectNodes on clean stem: %v", err) - } - if len(collected) != 0 { - t.Fatalf("expected clean stem not to be flushed, got %d", len(collected)) - } - - node.dirty = true - if err := node.CollectNodes([]byte{0}, flushFn); err != nil { - t.Fatalf("CollectNodes on dirty stem: %v", err) - } - if len(collected) != 1 { - t.Fatalf("expected dirty stem to be flushed once, got %d", len(collected)) - } - if node.dirty { - t.Errorf("stem dirty flag should be cleared after flush") - } - - collected = nil - if err := node.CollectNodes([]byte{0}, flushFn); err != nil { - t.Fatalf("CollectNodes after flush: %v", err) - } - if len(collected) != 0 { - t.Errorf("expected no flush on clean stem, got %d", len(collected)) - } -} diff --git a/trie/bintrie/store_commit.go b/trie/bintrie/store_commit.go new file mode 100644 index 0000000000..b142ecb34c --- /dev/null +++ b/trie/bintrie/store_commit.go @@ -0,0 +1,310 @@ +// 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 +} + +// SerializeNode serializes a node into the flat on-disk format. +func (s *nodeStore) serializeNode(ref nodeRef) []byte { + switch ref.Kind() { + case kindInternal: + node := s.getInternal(ref.Index()) + var serialized [NodeTypeBytes + HashSize + HashSize]byte + serialized[0] = nodeTypeInternal + lh := s.computeHash(node.left) + rh := s.computeHash(node.right) + copy(serialized[NodeTypeBytes:NodeTypeBytes+HashSize], lh[:]) + copy(serialized[NodeTypeBytes+HashSize:], rh[:]) + 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) +} + +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: + if len(serialized) != NodeTypeBytes+2*HashSize { + return emptyRef, errInvalidSerializedLength + } + var leftHash, rightHash common.Hash + copy(leftHash[:], serialized[NodeTypeBytes:NodeTypeBytes+HashSize]) + copy(rightHash[:], serialized[NodeTypeBytes+HashSize:]) + + var leftRef, rightRef nodeRef + if leftHash != (common.Hash{}) { + leftRef = s.newHashedRef(leftHash) + } + if rightHash != (common.Hash{}) { + rightRef = s.newHashedRef(rightHash) + } + + ref := s.newInternalRef(depth) + node := s.getInternal(ref.Index()) + node.left = leftRef + node.right = rightRef + if !mustRecompute { + node.hash = hn + node.mustRecompute = false + } + node.dirty = dirty + return ref, nil + + 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) error { + switch ref.Kind() { + case kindEmpty: + return nil + case kindInternal: + node := s.getInternal(ref.Index()) + if !node.dirty { + return nil + } + // Reuse path buffer across children: flushfn consumers + // (NodeSet.AddNode, tracer.Get) clone via string(path), so in-place + // mutation is safe. + path = append(path, 0) + if err := s.collectNodes(node.left, path, flushfn); err != nil { + return err + } + path[len(path)-1] = 1 + if err := s.collectNodes(node.right, path, flushfn); err != nil { + return err + } + path = path[:len(path)-1] + flushfn(path, s.computeHash(ref), s.serializeNode(ref)) + node.dirty = false + return nil + case kindStem: + sn := s.getStem(ref.Index()) + if !sn.dirty { + return nil + } + flushfn(path, s.computeHash(ref), s.serializeNode(ref)) + sn.dirty = false + return nil + case kindHashed: + return nil // Already committed + default: + return fmt.Errorf("CollectNodes: unexpected kind %d", ref.Kind()) + } +} + +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%02x", path, 0)) + } + if !node.right.IsEmpty() { + ret += s.toDot(node.right, me, fmt.Sprintf("%s%02x", 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 0000000000..9a73c8bd64 --- /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 23d014eb33..8c69e0aa00 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 @@ -108,22 +105,17 @@ 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 + store *nodeStore reader *trie.Reader tracer *trie.PrevalueTracer } // 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. @@ -133,7 +125,7 @@ func NewBinaryTrie(root common.Hash, db database.NodeDatabase) (*BinaryTrie, err return nil, err } t := &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), reader: reader, tracer: trie.NewPrevalueTracer(), } @@ -143,11 +135,11 @@ func NewBinaryTrie(root common.Hash, db database.NodeDatabase) (*BinaryTrie, err if err != nil { return nil, err } - node, err := DeserializeNodeWithHash(blob, 0, root) + ref, err := t.store.deserializeNodeWithHash(blob, 0, root) if err != nil { return nil, err } - t.root = node + t.store.root = ref } return t, nil } @@ -176,29 +168,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, err = r.GetValuesAtStem(key[:StemSize], t.nodeResolver) - 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,7 +200,7 @@ func (t *BinaryTrie) GetAccount(addr common.Address) (*types.StateAccount, error // 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.. + // so this branch won't activate. if bytes.Equal(values[BasicDataLeafKey], zero[:]) && bytes.Equal(values[CodeHashLeafKey], zero[:]) { return nil, nil @@ -238,13 +219,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(GetBinaryTreeKeyStorageSlot(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[:]) @@ -265,15 +245,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 @@ -288,11 +265,10 @@ 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 } @@ -307,12 +283,7 @@ func (t *BinaryTrie) DeleteAccount(addr common.Address) error { values[BasicDataLeafKey] = zero[:] values[CodeHashLeafKey] = zero[:] - root, err := t.root.InsertValuesAtStem(stem, values, t.nodeResolver, 0) - if err != nil { - return fmt.Errorf("DeleteAccount (%x) error: %v", addr, err) - } - t.root = root - return nil + return t.store.InsertValuesAtStem(stem, values, t.nodeResolver) } // DeleteStorage removes any existing value for key from the trie. If a node was not @@ -320,18 +291,17 @@ func (t *BinaryTrie) DeleteAccount(addr common.Address) error { func (t *BinaryTrie) DeleteStorage(addr common.Address, key []byte) error { 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 @@ -339,15 +309,15 @@ 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))) + // 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) + err := 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))) }) if err != nil { panic(fmt.Errorf("CollectNodes failed: %v", err)) } - // Serialize root commitment form return t.Hash(), nodeset } @@ -371,7 +341,7 @@ 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(), + store: t.store.Copy(), reader: t.reader, tracer: t.tracer.Copy(), } @@ -407,7 +377,6 @@ func (t *BinaryTrie) UpdateContractCode(addr common.Address, codeHash common.Has 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) } diff --git a/trie/bintrie/trie_test.go b/trie/bintrie/trie_test.go index c436501464..73aacb76c4 100644 --- a/trie/bintrie/trie_test.go +++ b/trie/bintrie/trie_test.go @@ -37,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(), @@ -187,12 +170,11 @@ 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) @@ -206,7 +188,7 @@ func TestMerkleizeMultipleEntries(t *testing.T) { func TestStorageRoundTrip(t *testing.T) { tracer := trie.NewPrevalueTracer() tr := &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: tracer, } addr := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678") @@ -274,7 +256,7 @@ func TestStorageRoundTrip(t *testing.T) { func newEmptyTestTrie(t *testing.T) *BinaryTrie { t.Helper() return &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } } @@ -599,7 +581,7 @@ func TestBinaryTrieWitness(t *testing.T) { tracer := trie.NewPrevalueTracer() tr := &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: tracer, } if w := tr.Witness(); len(w) != 0 { @@ -626,7 +608,7 @@ func TestBinaryTrieWitness(t *testing.T) { func testAccount(t *testing.T, addr common.Address, nonce uint64, balance uint64) *BinaryTrie { t.Helper() tr := &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } acc := &types.StateAccount{ @@ -649,8 +631,8 @@ func TestGetAccountNonMembershipStemRoot(t *testing.T) { tr := testAccount(t, addr, 42, 100) // Verify root is a StemNode (single stem inserted). - if _, ok := tr.root.(*StemNode); !ok { - t.Fatalf("expected StemNode root, got %T", tr.root) + 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. @@ -680,7 +662,7 @@ func TestGetAccountNonMembershipStemRoot(t *testing.T) { // address returns nil when the trie root is an InternalNode (multi-account trie). func TestGetAccountNonMembershipInternalRoot(t *testing.T) { tr := &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } @@ -700,8 +682,8 @@ func TestGetAccountNonMembershipInternalRoot(t *testing.T) { } // Verify root is an InternalNode. - if _, ok := tr.root.(*InternalNode); !ok { - t.Fatalf("expected InternalNode root, got %T", tr.root) + 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. @@ -723,8 +705,8 @@ func TestGetStorageNonMembershipStemRoot(t *testing.T) { tr := testAccount(t, addr, 1, 100) // Verify root is a StemNode. - if _, ok := tr.root.(*StemNode); !ok { - t.Fatalf("expected StemNode root, got %T", tr.root) + 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. @@ -743,7 +725,7 @@ func TestGetStorageNonMembershipStemRoot(t *testing.T) { // non-existent address returns nil when the root is an InternalNode. func TestGetStorageNonMembershipInternalRoot(t *testing.T) { tr := &BinaryTrie{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } @@ -765,8 +747,8 @@ func TestGetStorageNonMembershipInternalRoot(t *testing.T) { t.Fatalf("UpdateStorage error: %v", err) } - if _, ok := tr.root.(*InternalNode); !ok { - t.Fatalf("expected InternalNode root, got %T", tr.root) + 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. @@ -780,36 +762,29 @@ func TestGetStorageNonMembershipInternalRoot(t *testing.T) { } } -// commitKeyN derives a distinct 32-byte key from a seed integer. Used by -// TestBinaryTrieCommitIncremental and BenchmarkCollectNodes_SparseWrite to -// populate a trie with many disjoint stems. -func commitKeyN(i int) [HashSize]byte { - var k [HashSize]byte - binary.BigEndian.PutUint64(k[:8], uint64(i)*0x9e3779b97f4a7c15) - binary.BigEndian.PutUint64(k[8:16], uint64(i)*0xc2b2ae3d27d4eb4f) - binary.BigEndian.PutUint64(k[16:24], uint64(i)*0x165667b19e3779f9) - binary.BigEndian.PutUint64(k[24:32], uint64(i)*0x85ebca77c2b2ae63) - return k -} - -// TestBinaryTrieCommitIncremental verifies that a second Commit with only a -// single modified leaf flushes only the path from that leaf to the root, -// not the entire tree. -func TestBinaryTrieCommitIncremental(t *testing.T) { +// 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{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } - - const n = 512 - keys := make([][HashSize]byte, n) + 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 { - keys[i] = commitKeyN(i + 1) + k := key(i) var v [HashSize]byte binary.BigEndian.PutUint64(v[24:], uint64(i+1)) - var err error - tr.root, err = tr.root.Insert(keys[i][:], v[:], nil, 0) - if err != nil { + if err := tr.store.Insert(k[:], v[:], nil); err != nil { t.Fatalf("Insert %d: %v", i, err) } } @@ -818,69 +793,55 @@ func TestBinaryTrieCommitIncremental(t *testing.T) { if len(ns1.Nodes) == 0 { t.Fatal("first Commit produced empty NodeSet") } - if len(ns1.Nodes) < n { - t.Fatalf("first Commit: expected at least %d nodes, got %d", n, len(ns1.Nodes)) - } - // Second Commit on the same trie with no modifications: NodeSet must - // be empty because every subtree is clean. _, nsNoop := tr.Commit(false) if len(nsNoop.Nodes) != 0 { - t.Fatalf("no-op Commit: expected empty NodeSet, got %d nodes", len(nsNoop.Nodes)) + t.Fatalf("no-op Commit: expected empty NodeSet, got %d", len(nsNoop.Nodes)) } - // Modify a single leaf's value. Only the path from that leaf to the - // root should appear in the next Commit's NodeSet. + // Modify a single leaf — only the root-to-leaf path should flush. + k := key(n / 2) var newVal [HashSize]byte newVal[0] = 0xff - var err error - tr.root, err = tr.root.Insert(keys[n/2][:], newVal[:], nil, 0) - if err != nil { + if err := tr.store.Insert(k[:], newVal[:], nil); err != nil { t.Fatalf("Insert (modify): %v", err) } _, ns2 := tr.Commit(false) - - // Path length for a binary trie of n=512 stems is bounded by the - // internal depth at which the modified stem sits. Allow generous - // slack: up to 64 nodes is fine, anywhere near n (512) is a regression. if len(ns2.Nodes) == 0 { t.Fatal("modified Commit produced empty NodeSet") } - if len(ns2.Nodes) > 64 { - t.Fatalf("modified Commit: expected small NodeSet, got %d nodes (first Commit had %d)", len(ns2.Nodes), len(ns1.Nodes)) + 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)) } } -// BenchmarkCollectNodes_SparseWrite measures Commit cost when only one leaf -// changes between blocks — the common case for state updates. After warm-up +// 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. Under the skip-clean optimization, each iteration flushes -// only the root-to-leaf path; pre-fix behavior would re-flush the entire -// tree every iteration. -func BenchmarkCollectNodes_SparseWrite(b *testing.B) { +// 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{ - root: NewBinaryNode(), + store: newNodeStore(), tracer: trie.NewPrevalueTracer(), } keys := make([][HashSize]byte, n) for i := range n { - keys[i] = commitKeyN(i + 1) + 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)) - var err error - tr.root, err = tr.root.Insert(keys[i][:], v[:], nil, 0) - if err != nil { - b.Fatalf("Insert %d: %v", i, err) + if err := tr.store.Insert(keys[i][:], v[:], nil); err != nil { + b.Fatalf("warmup Insert %d: %v", i, err) } } - // Flush the initial tree so subsequent Commits reflect the - // single-modification workload we want to measure. - _, _ = tr.Commit(false) + _, _ = tr.Commit(false) // warmup flush var newVal [HashSize]byte b.ReportAllocs() @@ -888,10 +849,8 @@ func BenchmarkCollectNodes_SparseWrite(b *testing.B) { for i := 0; i < b.N; i++ { idx := i % n binary.BigEndian.PutUint64(newVal[24:], uint64(i+1)) - var err error - tr.root, err = tr.root.Insert(keys[idx][:], newVal[:], nil, 0) - if err != nil { - b.Fatalf("Insert at iter %d: %v", i, err) + 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 { diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go index 04c76cfd53..98975d7fa5 100644 --- a/triedb/pathdb/database.go +++ b/triedb/pathdb/database.go @@ -102,11 +102,7 @@ func binaryNodeHasher(blob []byte) (common.Hash, error) { if len(blob) == 0 { 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 From 7e388fd09ee286967a47c2213c5d49a393350c0e Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 20 Apr 2026 21:04:42 +0800 Subject: [PATCH 093/183] core/state: separate trie reader to mptReader and ubtReader (#34763) This PR separates the trie reader to mptTrieReader and ubtTrieReader for improved readability and extensibility. --------- Co-authored-by: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- core/state/database_mpt.go | 2 +- core/state/database_ubt.go | 2 +- core/state/reader.go | 193 ++++++++++++++++++++++--------------- 3 files changed, 115 insertions(+), 82 deletions(-) diff --git a/core/state/database_mpt.go b/core/state/database_mpt.go index bf9c7c9fff..4099ea495f 100644 --- a/core/state/database_mpt.go +++ b/core/state/database_mpt.go @@ -81,7 +81,7 @@ func (db *MPTDatabase) StateReader(stateRoot common.Hash) (StateReader, error) { } // Configure the trie reader, which is expected to be available as the // gatekeeper unless the state is corrupted. - tr, err := newTrieReader(stateRoot, db.triedb) + tr, err := newMPTTrieReader(stateRoot, db.triedb) if err != nil { return nil, err } diff --git a/core/state/database_ubt.go b/core/state/database_ubt.go index 39aa64508b..f854f2f46b 100644 --- a/core/state/database_ubt.go +++ b/core/state/database_ubt.go @@ -61,7 +61,7 @@ func (db *UBTDatabase) StateReader(stateRoot common.Hash) (StateReader, error) { } // Configure the trie reader, which is expected to be available as the // gatekeeper unless the state is corrupted. - tr, err := newTrieReader(stateRoot, db.triedb) + tr, err := newUBTTrieReader(stateRoot, db.triedb) if err != nil { return nil, err } diff --git a/core/state/reader.go b/core/state/reader.go index b837c6a0a1..5df0acbb9b 100644 --- a/core/state/reader.go +++ b/core/state/reader.go @@ -148,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) (*trieReader, error) { - var ( - tr Trie - err error - ) - if !db.IsUBT() { - tr, err = trie.NewStateTrie(trie.StateTrieID(root), db) - } else { - // When IsUBT() 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, @@ -221,7 +179,7 @@ func newTrieReader(root common.Hash, db *triedb.Database) (*trieReader, error) { } // 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 @@ -236,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() @@ -250,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.IsUBT() { - tr = r.mainTrie - } else { - tr, found = r.subTries[addr] - if !found { - root, ok := r.subRoots[addr] + 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) + // 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) + 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 } From acbf699c33254b3517683c2098cf5e956920f2f7 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 20 Apr 2026 23:12:10 +0800 Subject: [PATCH 094/183] core/state: export StateUpdate struct (#34724) In the recent refactoring, the state commit logic has been abstracted, making it more flexible to design state databases for various use cases. For example, execution-only modes where state mutation is disabled. As part of this change, the database interface was extended with a Commit function. However, it currently accepts an unexported struct `stateUpdate`, which prevents downstream projects from customizing the state commit behavior. To address this limitation, the stateUpdate type is now exported. --- core/state/database.go | 2 +- core/state/database_history.go | 2 +- core/state/database_iterator.go | 68 +++-- core/state/database_iterator_test.go | 21 +- core/state/database_mpt.go | 33 ++- core/state/database_ubt.go | 23 +- core/state/dump.go | 37 +-- core/state/state_object.go | 62 ++-- core/state/state_sizer.go | 59 ++-- core/state/state_sizer_test.go | 4 +- core/state/statedb.go | 55 ++-- core/state/statedb_fuzz_test.go | 15 +- core/state/stateupdate.go | 419 +++++++++++++++------------ 13 files changed, 445 insertions(+), 355 deletions(-) diff --git a/core/state/database.go b/core/state/database.go index b9ccff658f..3b1e627f28 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -70,7 +70,7 @@ type Database interface { // 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 + Commit(update *StateUpdate) error } // Trie is a Ethereum Merkle Patricia trie. diff --git a/core/state/database_history.go b/core/state/database_history.go index d1ed2fe194..fbf4ab5f9c 100644 --- a/core/state/database_history.go +++ b/core/state/database_history.go @@ -297,7 +297,7 @@ func (db *HistoricDB) TrieDB() *triedb.Database { // 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 { +func (db *HistoricDB) Commit(update *StateUpdate) error { return errors.New("not implemented") } diff --git a/core/state/database_iterator.go b/core/state/database_iterator.go index 8fad66a1e8..1ff164b002 100644 --- a/core/state/database_iterator.go +++ b/core/state/database_iterator.go @@ -23,6 +23,7 @@ import ( "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" ) @@ -57,9 +58,9 @@ type AccountIterator interface { // An error will be returned if the preimage is not available. Address() (common.Address, error) - // Account returns the RLP encoded account the iterator is currently at. + // Account returns the account the iterator is currently at. // An error will be retained if the iterator becomes invalid. - Account() []byte + Account() *types.StateAccount } // StorageIterator is an iterator to step over the specific storage in the @@ -73,7 +74,7 @@ type StorageIterator interface { // Slot returns the storage slot the iterator is currently at. An error will // be retained if the iterator becomes invalid. - Slot() []byte + Slot() common.Hash } // Iteratee wraps the NewIterator methods for traversing the accounts and @@ -131,10 +132,7 @@ func (ai *flatAccountIterator) Next() bool { // Error returns any failure that occurred during iteration, which might have // caused a premature iteration exit. func (ai *flatAccountIterator) Error() error { - if ai.err != nil { - return ai.err - } - return ai.it.Error() + return errors.Join(ai.err, ai.it.Error()) } // Hash returns the hash of the account or storage slot the iterator is @@ -165,8 +163,8 @@ func (ai *flatAccountIterator) Address() (common.Address, error) { // 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() []byte { - data, err := types.FullAccountRLP(ai.it.Account()) +func (ai *flatAccountIterator) Account() *types.StateAccount { + data, err := types.FullAccount(ai.it.Account()) if err != nil { ai.err = err return nil @@ -176,6 +174,7 @@ func (ai *flatAccountIterator) Account() []byte { // flatStorageIterator is a wrapper around the underlying flat state iterator. type flatStorageIterator struct { + err error it snapshot.StorageIterator preimage PreimageReader } @@ -190,13 +189,16 @@ func newFlatStorageIterator(it snapshot.StorageIterator, preimage PreimageReader // 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 si.it.Error() + return errors.Join(si.err, si.it.Error()) } // Hash returns the hash of the account or storage slot the iterator is @@ -225,14 +227,24 @@ func (si *flatStorageIterator) Key() (common.Hash, error) { } // Slot returns the storage slot data the iterator is currently at. -func (si *flatStorageIterator) Slot() []byte { - return si.it.Slot() +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 } @@ -254,13 +266,16 @@ func newMerkleTrieIterator(tr Trie, start common.Hash, account bool) (*merkleIte // 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 ti.it.Err + return errors.Join(ti.err, ti.it.Err) } // Hash returns the hash of the account or storage slot the iterator is @@ -287,11 +302,16 @@ func (ti *merkleIterator) Address() (common.Address, error) { } // Account returns the account data the iterator is currently at. -func (ti *merkleIterator) Account() []byte { +func (ti *merkleIterator) Account() *types.StateAccount { if !ti.account { return nil } - return ti.it.Value + 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. @@ -308,11 +328,19 @@ func (ti *merkleIterator) Key() (common.Hash, error) { } // Slot returns the storage slot the iterator is currently at. -func (ti *merkleIterator) Slot() []byte { +func (ti *merkleIterator) Slot() common.Hash { if ti.account { - return nil + return common.Hash{} } - return ti.it.Value + // 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 @@ -430,6 +458,6 @@ func (e exhaustedIterator) Key() (common.Hash, error) { return common.Hash{}, nil } -func (e exhaustedIterator) Slot() []byte { - return 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 index 87819e5526..8313f86403 100644 --- a/core/state/database_iterator_test.go +++ b/core/state/database_iterator_test.go @@ -24,7 +24,6 @@ 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/rlp" "github.com/ethereum/go-ethereum/trie" ) @@ -45,7 +44,7 @@ func TestExhaustedIterator(t *testing.T) { 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 != nil { + if slot := it.Slot(); slot != (common.Hash{}) { t.Fatalf("Slot() = %x, want nil", slot) } it.Release() @@ -95,20 +94,16 @@ func testAccountIterator(t *testing.T, scheme string) { hashes = append(hashes, hash) // Decode and verify account data. - blob := acctIt.Account() - if blob == nil { + got := acctIt.Account() + if got == nil { t.Fatalf("(%s) nil account at %x", scheme, hash) } - var decoded types.StateAccount - if err := rlp.DecodeBytes(blob, &decoded); err != nil { - t.Fatalf("(%s) bad RLP at %x: %v", scheme, hash, err) - } acc := addrByHash[hash] - if decoded.Nonce != acc.nonce { - t.Fatalf("(%s) nonce %x: got %d, want %d", scheme, hash, decoded.Nonce, acc.nonce) + if got.Nonce != acc.nonce { + t.Fatalf("(%s) nonce %x: got %d, want %d", scheme, hash, got.Nonce, acc.nonce) } - if decoded.Balance.Cmp(acc.balance) != 0 { - t.Fatalf("(%s) balance %x: got %v, want %v", scheme, hash, decoded.Balance, acc.balance) + 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() @@ -183,7 +178,7 @@ func testStorageIterator(t *testing.T, scheme string) { t.Fatalf("(%s) storage hashes not ascending for %x", scheme, acc.address) } prevHash = hash - if storageIt.Slot() == nil { + if storageIt.Slot() == (common.Hash{}) { t.Fatalf("(%s) nil slot at %x", scheme, hash) } // Check key preimage resolution on first slot. diff --git a/core/state/database_mpt.go b/core/state/database_mpt.go index 4099ea495f..42c5f2e5ef 100644 --- a/core/state/database_mpt.go +++ b/core/state/database_mpt.go @@ -140,35 +140,44 @@ func (db *MPTDatabase) TrieDB() *triedb.Database { // 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 { +func (db *MPTDatabase) Commit(update *StateUpdate) error { // Short circuit if nothing to commit - if update.empty() { + 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 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, update.accounts, update.storages); err != nil { - log.Warn("Failed to update snapshot tree", "from", update.originRoot, "to", update.root, "err", err) + 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) + 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, update.stateSet()) + 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, diff --git a/core/state/database_ubt.go b/core/state/database_ubt.go index f854f2f46b..718d93df87 100644 --- a/core/state/database_ubt.go +++ b/core/state/database_ubt.go @@ -113,22 +113,31 @@ func (db *UBTDatabase) TrieDB() *triedb.Database { // 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 { +func (db *UBTDatabase) Commit(update *StateUpdate) error { // Short circuit if nothing to commit - if update.empty() { + 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 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 } } - return db.triedb.Update(update.root, update.originRoot, update.blockNumber, update.nodes, update.stateSet()) + // 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, diff --git a/core/state/dump.go b/core/state/dump.go index 71138143d9..cbf53de053 100644 --- a/core/state/dump.go +++ b/core/state/dump.go @@ -24,9 +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/bintrie" ) @@ -115,7 +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. -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,7 +129,7 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] iteratee, err := s.db.Iteratee(s.originalRoot) if err != nil { - return nil + return nil, err } var startHash common.Hash if conf.Start != nil { @@ -139,14 +137,17 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] } acctIt, err := iteratee.NewAccountIterator(startHash) if err != nil { - return nil + return nil, err } defer acctIt.Release() for acctIt.Next() { - var data types.StateAccount - if err := rlp.DecodeBytes(acctIt.Account(), &data); err != nil { - panic(err) + 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{ @@ -168,7 +169,7 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] address = &addrBytes account.Address = address } - obj := newObject(s, addrBytes, &data) + obj := newObject(s, addrBytes, data) if !conf.SkipCode { account.Code = obj.Code() } @@ -177,20 +178,19 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] storageIt, err := iteratee.NewStorageIterator(acctIt.Hash(), common.Hash{}) if err != nil { - log.Error("Failed to load storage trie", "err", err) - continue + return nil, err } for storageIt.Next() { - _, content, _, err := rlp.Split(storageIt.Slot()) - 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, err := storageIt.Key() if err != nil { continue } - account.Storage[key] = common.Bytes2Hex(content) + account.Storage[key] = common.Bytes2Hex(common.TrimLeftZeroes(val[:])) } storageIt.Release() } @@ -211,7 +211,7 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey [] 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 + return nextKey, nil } // DumpBinTrieLeaves collects all binary trie leaf nodes into the provided map. @@ -242,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/state_object.go b/core/state/state_object.go index a812359368..df54733d63 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -27,7 +27,6 @@ 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" @@ -398,17 +397,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 @@ -418,20 +408,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 @@ -444,32 +434,32 @@ 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 + op.Code.OriginHash = types.EmptyCodeHash } else { - op.code.originHash = common.BytesToHash(s.origin.CodeHash) + 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 diff --git a/core/state/state_sizer.go b/core/state/state_sizer.go index 02b73e5575..3293d7e950 100644 --- a/core/state/state_sizer.go +++ b/core/state/state_sizer.go @@ -125,16 +125,17 @@ 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, + 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 +157,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 +168,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 +195,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 +245,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.duplicate { + 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,7 +268,7 @@ type SizeTracker struct { triedb *triedb.Database abort chan struct{} aborted chan struct{} - updateCh chan *stateUpdate + updateCh chan *StateUpdate queryCh chan *stateSizeQuery } @@ -281,7 +282,7 @@ func NewSizeTracker(db ethdb.KeyValueStore, triedb *triedb.Database) (*SizeTrack triedb: triedb, abort: make(chan struct{}), aborted: make(chan struct{}), - updateCh: make(chan *stateUpdate), + updateCh: make(chan *StateUpdate), queryCh: make(chan *stateSizeQuery), } go t.run() @@ -328,9 +329,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 +339,15 @@ 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() // Evict the stale statistics - heap.Push(&h, stats[u.root]) - for len(h) > 0 && u.blockNumber-h[0].BlockNumber > statEvictThreshold { + heap.Push(&h, stats[u.Root]) + for len(h) > 0 && u.BlockNumber-h[0].BlockNumber > statEvictThreshold { delete(stats, h[0].StateRoot) heap.Pop(&h) } @@ -402,7 +403,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 +411,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 +433,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 +647,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 b3203afd74..539f160985 100644 --- a/core/state/state_sizer_test.go +++ b/core/state/state_sizer_test.go @@ -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 956871472d..8c57edf08e 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -1045,11 +1045,11 @@ func (s *StateDB) clearJournalAndRefund() { } // 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][]byte, map[common.Hash][]byte, *trienode.NodeSet, error) { +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][]byte) // the set for storage mutations (value is nil) - storageOrigins = make(map[common.Hash][]byte) // the set for tracking the original value of slot + 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 { @@ -1065,19 +1065,24 @@ func (s *StateDB) deleteStorage(addrHash common.Hash, root common.Hash) (map[com nodes.AddNode(path, trienode.NewDeletedWithPrev(blob)) }) for it.Next() { - slot := common.CopyBytes(it.Slot()) - if err := it.Error(); err != nil { // error might occur after Slot function + slot := it.Slot() + // Error might occur after Slot function + if err := it.Error(); err != nil { return nil, nil, nil, err } + 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] = nil + 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 := it.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 { @@ -1104,10 +1109,10 @@ func (s *StateDB) deleteStorage(addrHash common.Hash, root common.Hash) (map[com // 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 @@ -1122,9 +1127,9 @@ func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*acco } // 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), + op := &AccountDelete{ + Address: addr, + Origin: prev, } deletes[addrHash] = op @@ -1140,8 +1145,8 @@ func (s *StateDB) handleDestruction(noStorageWiping bool) (map[common.Hash]*acco 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) @@ -1156,7 +1161,7 @@ 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) @@ -1177,7 +1182,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. // @@ -1305,12 +1310,16 @@ 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, deriveCodeFields 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 @@ -1351,17 +1360,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 } // 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) { +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{}, nil, err } - return ret.root, ret, nil + return ret.Root, ret, nil } // Prepare handles the preparatory steps for executing a state transition with. diff --git a/core/state/statedb_fuzz_test.go b/core/state/statedb_fuzz_test.go index a8017e5568..c796b416a3 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}) @@ -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/stateupdate.go b/core/state/stateupdate.go index 1c171cbd5e..582bcc3ec8 100644 --- a/core/state/stateupdate.go +++ b/core/state/stateupdate.go @@ -26,139 +26,143 @@ import ( "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 contract bytecode 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. +// 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. + 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. - - // storages stores mutated slots, the value should be nil. - storages map[common.Hash][]byte - - // 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 +// 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. } -// 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. +// 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. - // 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 + // 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 } -// stateUpdate represents the difference between two states resulting from state +// StorageKeyEncoding specifies the encoding scheme of a storage key. +type StorageKeyEncoding int + +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 +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 + // Accounts contains mutated accounts, keyed by address hash. + Accounts map[common.Hash]*types.StateAccount - // 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 + // Storages contains mutated storage slots, keyed by address + // hash and storage slot key hash. + Storages map[common.Hash]map[common.Hash]common.Hash - // 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 + // AccountsOrigin holds the original values of mutated accounts, keyed by address. + AccountsOrigin map[common.Address]*types.StateAccount - codes map[common.Address]*contractCode // codes contains the set of dirty codes - nodes *trienode.MergedNodeSet // Aggregated dirty nodes caused by state changes + // 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] @@ -173,32 +177,114 @@ 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, } } -// 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, +// 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 +} + +// 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 } // deriveCodeFields derives the missing fields of contract code changes @@ -207,135 +293,96 @@ func (sc *stateUpdate) stateSet() *triedb.StateSet { // 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 { +func (sc *StateUpdate) deriveCodeFields(reader ContractCodeReader) error { cache := make(map[common.Hash]bool) - for addr, code := range sc.codes { - if code.originHash != types.EmptyCodeHash { - blob := reader.Code(addr, code.originHash) + 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 + code.OriginBlob = blob } - if exists, ok := cache[code.hash]; ok { - code.duplicate = exists + if exists, ok := cache[code.Hash]; ok { + code.Duplicate = exists continue } - res := reader.Has(addr, code.hash) - cache[code.hash] = res - code.duplicate = 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) { +// 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)), + 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)), + 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 { + for addr, oldData := range sc.AccountsOrigin { addrHash := crypto.Keccak256Hash(addr.Bytes()) - newData, exists := sc.accounts[addrHash] + newData, exists := sc.Accounts[addrHash] if !exists { return nil, fmt.Errorf("account %x not found", addr) } - change := &tracing.AccountChange{} - - if len(oldData) > 0 { - acct, err := types.FullAccount(oldData) - if err != nil { - return nil, err - } - change.Prev = &types.StateAccount{ - Nonce: acct.Nonce, - Balance: acct.Balance, - Root: acct.Root, - CodeHash: acct.CodeHash, - } - } - if len(newData) > 0 { - acct, err := types.FullAccount(newData) - if err != nil { - return nil, err - } - change.New = &types.StateAccount{ - Nonce: acct.Nonce, - Balance: acct.Balance, - Root: acct.Root, - CodeHash: acct.CodeHash, - } + change := &tracing.AccountChange{ + Prev: oldData, + New: newData, } update.AccountChanges[addr] = change } // Gather all storage slot changes - for addr, slots := range sc.storagesOrigin { + for addr, slots := range sc.StoragesOrigin { addrHash := crypto.Keccak256Hash(addr.Bytes()) - subset, exists := sc.storages[addrHash] + 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, encPrev := range slots { + for key, oldData := range slots { // Get new value - handle both raw and hashed key formats var ( exists bool - encNew []byte - decPrev []byte - decNew []byte - err error + newData common.Hash ) - if sc.rawStorageKey { - encNew, exists = subset[crypto.Keccak256Hash(key.Bytes())] + if sc.StorageKeyType == StorageKeyPlain { + newData, exists = subset[crypto.Keccak256Hash(key.Bytes())] } else { - encNew, exists = subset[key] + newData, exists = subset[key] } if !exists { return nil, fmt.Errorf("storage slot %x-%x not found", addr, key) } - - // Decode the prev and new values - if len(encPrev) > 0 { - _, decPrev, _, err = rlp.Split(encPrev) - if err != nil { - return nil, fmt.Errorf("failed to decode prevValue: %v", err) - } - } - if len(encNew) > 0 { - _, decNew, _, err = rlp.Split(encNew) - if err != nil { - return nil, fmt.Errorf("failed to decode newValue: %v", err) - } - } storageChanges[key] = &tracing.StorageChange{ - Prev: common.BytesToHash(decPrev), - New: common.BytesToHash(decNew), + Prev: oldData, + New: newData, } } update.StorageChanges[addr] = storageChanges } // Gather all contract code changes - for addr, code := range sc.codes { + for addr, code := range sc.Codes { change := &tracing.CodeChange{ New: &tracing.ContractCode{ - Hash: code.hash, - Code: code.blob, - Exists: code.duplicate, + Hash: code.Hash, + Code: code.Blob, + Exists: code.Duplicate, }, } - if code.originHash != types.EmptyCodeHash { + if code.OriginHash != types.EmptyCodeHash { change.Prev = &tracing.ContractCode{ - Hash: code.originHash, - Code: code.originBlob, + Hash: code.OriginHash, + Code: code.OriginBlob, Exists: true, } } @@ -343,8 +390,8 @@ func (sc *stateUpdate) ToTracingUpdate() (*tracing.StateUpdate, error) { } // Gather all trie node changes - if sc.nodes != nil { - for owner, subset := range sc.nodes.Sets { + 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] From e447a2696de71d9d6c56664a9e7c87ac6077f178 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Toni=20Wahrst=C3=A4tter?= <51536394+nerolation@users.noreply.github.com> Date: Tue, 21 Apr 2026 03:19:03 +0200 Subject: [PATCH 095/183] core/rawdb: clarify ReadLastPivotNumber comment (#34773) clarify that `ReadLastPivotNumber` returns `nil` only when snap sync has never been attempted, since the marker is written during snap sync and never cleared. --- core/rawdb/accessors_chain.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go index 0582e842c3..987b8df392 100644 --- a/core/rawdb/accessors_chain.go +++ b/core/rawdb/accessors_chain.go @@ -175,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 { From ac406c2fe752b0624c62f66095c9240ecec40078 Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Tue, 21 Apr 2026 10:20:02 +0200 Subject: [PATCH 096/183] core: implement eip-7976: Increase Calldata Floor Cost (#34748) Increases calldata floor cost from 10/40 to 64/64 --- cmd/evm/internal/t8ntool/transaction.go | 2 +- core/state_transition.go | 28 ++++++++++++++++++------- core/txpool/validation.go | 2 +- params/protocol_params.go | 1 + tests/transaction_test_util.go | 6 +++--- 5 files changed, 27 insertions(+), 12 deletions(-) diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go index 82c0f30b42..ad89876601 100644 --- a/cmd/evm/internal/t8ntool/transaction.go +++ b/cmd/evm/internal/t8ntool/transaction.go @@ -147,7 +147,7 @@ func Transaction(ctx *cli.Context) error { } // For Prague txs, validate the floor data gas. if rules.IsPrague { - floorDataGas, err := core.FloorDataGas(tx.Data()) + floorDataGas, err := core.FloorDataGas(rules, tx.Data()) if err != nil { r.Error = err results = append(results, r) diff --git a/core/state_transition.go b/core/state_transition.go index 297e8580ee..c3ebffd060 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -117,18 +117,32 @@ func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.Set } // 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) (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. + tokens = uint64(len(data)) * params.TxTokenPerNonZeroByte + tokenCost = params.TxCostFloorPerToken7976 + } else { + var ( + z = uint64(bytes.Count(data, []byte{0})) + nz = uint64(len(data)) - z + ) + // Pre-Amsterdam + tokens = nz*params.TxTokenPerNonZeroByte + 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. @@ -460,7 +474,7 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { } // Gas limit suffices for the floor data cost (EIP-7623) if rules.IsPrague { - floorDataGas, err = FloorDataGas(msg.Data) + floorDataGas, err = FloorDataGas(rules, msg.Data) if err != nil { return nil, err } diff --git a/core/txpool/validation.go b/core/txpool/validation.go index 3569bba08d..85bf65ac40 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -134,7 +134,7 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types } // Ensure the transaction can cover floor data gas. if rules.IsPrague { - floorDataGas, err := core.FloorDataGas(tx.Data()) + floorDataGas, err := core.FloorDataGas(rules, tx.Data()) if err != nil { return err } diff --git a/params/protocol_params.go b/params/protocol_params.go index 652574287c..9da275c486 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -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 diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index a659a1f786..8b8d0357bf 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 @@ -92,7 +92,7 @@ func (tt *TransactionTest) Run() error { if rules.IsPrague { var floorDataGas uint64 - floorDataGas, err = core.FloorDataGas(tx.Data()) + floorDataGas, err = core.FloorDataGas(rules, tx.Data()) if err != nil { return } @@ -133,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) From 077d83387a2883b571fe1570f1318005264a2009 Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 21 Apr 2026 19:58:49 +0800 Subject: [PATCH 097/183] metrics: reset internal value slice in Clear (#34761) --- metrics/sample.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/metrics/sample.go b/metrics/sample.go index dc8167809f..95092ffc3c 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. From f568ab9931167ecfaef8f9696dfd0d52a861f2fd Mon Sep 17 00:00:00 2001 From: Barnabas Busa Date: Tue, 21 Apr 2026 14:48:21 +0200 Subject: [PATCH 098/183] internal/telemetry: add gRPC transport for OTLP trace export (#33941) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary - Add `grpc://` and `grpcs://` URL scheme support for OTLP trace export alongside existing `http://`/`https://` - The OTLP spec defines two transports: HTTP (port 4318) and gRPC (port 4317). Many observability backends (Jaeger, Tempo, Datadog) prefer gRPC for lower overhead - Both `otlptracehttp` and `otlptracegrpc` return `*otlptrace.Exporter`, so only exporter construction changes — everything downstream (batch processor, tracer provider, lifecycle) is untouched - Update flag usage strings to be transport-agnostic ## Example usage ``` geth --rpc.telemetry --rpc.telemetry.endpoint grpc://localhost:4317 geth --rpc.telemetry --rpc.telemetry.endpoint grpcs://tempo-grpc.example.com:443 ``` --------- Co-authored-by: Claude Opus 4.6 --- cmd/keeper/go.mod | 4 +-- cmd/keeper/go.sum | 12 +++---- cmd/utils/flags.go | 6 ++-- go.mod | 25 ++++++------- go.sum | 50 +++++++++++++------------- internal/telemetry/tracesetup/setup.go | 29 ++++++++++++--- 6 files changed, 75 insertions(+), 51 deletions(-) diff --git a/cmd/keeper/go.mod b/cmd/keeper/go.mod index 8303b4ab2e..2d99cb2232 100644 --- a/cmd/keeper/go.mod +++ b/cmd/keeper/go.mod @@ -38,8 +38,8 @@ require ( 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.44.0 // indirect - golang.org/x/sync v0.18.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 a162537c88..09c8e55822 100644 --- a/cmd/keeper/go.sum +++ b/cmd/keeper/go.sum @@ -127,20 +127,20 @@ go.opentelemetry.io/otel/sdk v1.40.0 h1:KHW/jUzgo6wsPh9At46+h4upjtccTmuZCFAc9OJ7 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.44.0 h1:A97SsFvM3AIwEEmTBiaxPPTYpDC47w720rdiiUvgoAU= -golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc= +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.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I= -golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +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.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ= golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM= -golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM= +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= diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index aff45087db..9d996f15cb 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -1067,19 +1067,19 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server. RPCTelemetryEndpointFlag = &cli.StringFlag{ Name: "rpc.telemetry.endpoint", - Usage: "Defines where RPC telemetry is sent (e.g., http://localhost:4318)", + 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: "HTTP Basic Auth username for OpenTelemetry", + Usage: "Basic Auth username for OpenTelemetry", Category: flags.APICategory, } RPCTelemetryPasswordFlag = &cli.StringFlag{ Name: "rpc.telemetry.password", - Usage: "HTTP Basic Auth password for OpenTelemetry", + Usage: "Basic Auth password for OpenTelemetry", Category: flags.APICategory, } diff --git a/go.mod b/go.mod index 37a2537dd0..a623668b89 100644 --- a/go.mod +++ b/go.mod @@ -62,19 +62,20 @@ require ( 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.39.0 - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.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.44.0 + golang.org/x/crypto v0.47.0 golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df - golang.org/x/sync v0.18.0 + golang.org/x/sync v0.19.0 golang.org/x/sys v0.40.0 - golang.org/x/text v0.31.0 + golang.org/x/text v0.33.0 golang.org/x/time v0.9.0 - golang.org/x/tools v0.38.0 + 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 @@ -84,13 +85,13 @@ 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.3 // 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-20251222181119-0a764e51fe1b // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20251222181119-0a764e51fe1b // indirect - google.golang.org/grpc v1.77.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 ( @@ -161,8 +162,8 @@ require ( 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.29.0 // indirect - golang.org/x/net v0.47.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 c465603242..4713387020 100644 --- a/go.sum +++ b/go.sum @@ -196,8 +196,8 @@ github.com/grafana/pyroscope-go/godeltaprof v0.1.9 h1:c1Us8i6eSmkW+Ez05d3co8kasn 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.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4= +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= @@ -382,10 +382,12 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ 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.39.0 h1:f0cb2XPmrqn4XMy9PNliTgRKJgS5WcL/u0/WRYGz4t0= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.39.0/go.mod h1:vnakAaFckOMiMtOIhFI2MNH4FYrZzXCYxmb1LlhoGz8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.0 h1:Ckwye2FpXkYgiHX7fyVrN1uA/UYd9ounqqTuSNAv0k4= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.0/go.mod h1:teIFJh5pW2y+AN7riv6IBPX2DuesS3HgP39mwOspKwU= +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= @@ -408,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.44.0 h1:A97SsFvM3AIwEEmTBiaxPPTYpDC47w720rdiiUvgoAU= -golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc= +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.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA= -golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w= +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= @@ -433,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.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY= -golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU= +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= @@ -443,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.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I= -golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +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= @@ -496,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.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM= -golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM= +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= @@ -509,8 +511,8 @@ 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.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ= -golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs= +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= @@ -518,12 +520,12 @@ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1N 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-20251222181119-0a764e51fe1b h1:uA40e2M6fYRBf0+8uN5mLlqUtV192iiksiICIBkYJ1E= -google.golang.org/genproto/googleapis/api v0.0.0-20251222181119-0a764e51fe1b/go.mod h1:Xa7le7qx2vmqB/SzWUBa7KdMjpdpAHlh5QCSnjessQk= -google.golang.org/genproto/googleapis/rpc v0.0.0-20251222181119-0a764e51fe1b h1:Mv8VFug0MP9e5vUxfBcE3vUkV6CImK3cMNMIDFjmzxU= -google.golang.org/genproto/googleapis/rpc v0.0.0-20251222181119-0a764e51fe1b/go.mod h1:j9x/tPzZkyxcgEFkiKEEGxfvyumM01BEtsW8xzOahRQ= -google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM= -google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig= +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= diff --git a/internal/telemetry/tracesetup/setup.go b/internal/telemetry/tracesetup/setup.go index 444416dd26..08c5f739b6 100644 --- a/internal/telemetry/tracesetup/setup.go +++ b/internal/telemetry/tracesetup/setup.go @@ -30,6 +30,7 @@ import ( "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" @@ -83,6 +84,14 @@ func SetupTelemetry(cfg node.OpenTelemetryConfig, stack *node.Node) error { 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": @@ -95,12 +104,24 @@ func SetupTelemetry(cfg node.OpenTelemetryConfig, stack *node.Node) error { if u.Path != "" && u.Path != "/" { opts = append(opts, otlptracehttp.WithURLPath(u.Path)) } - if cfg.AuthUser != "" { - opts = append(opts, otlptracehttp.WithHeaders(map[string]string{ - "Authorization": "Basic " + base64.StdEncoding.EncodeToString([]byte(cfg.AuthUser+":"+cfg.AuthPassword)), - })) + 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) } From c374e74ee189f1f3068cea41f676dd61dfa66209 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Tue, 21 Apr 2026 14:50:09 +0200 Subject: [PATCH 099/183] trie/bintrie: print todot path in binary (#34777) The nodes were named using the byte representation of the path, instead of the binary representation. This was confusing to other client devs trying to achieve interop. --- trie/bintrie/store_commit.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/trie/bintrie/store_commit.go b/trie/bintrie/store_commit.go index b142ecb34c..7101087b51 100644 --- a/trie/bintrie/store_commit.go +++ b/trie/bintrie/store_commit.go @@ -279,10 +279,10 @@ func (s *nodeStore) toDot(ref nodeRef, parent, path string) string { ret = fmt.Sprintf("%s %s -> %s\n", ret, parent, me) } if !node.left.IsEmpty() { - ret += s.toDot(node.left, me, fmt.Sprintf("%s%02x", path, 0)) + 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%02x", path, 1)) + ret += s.toDot(node.right, me, fmt.Sprintf("%s%b", path, 1)) } return ret case kindStem: From d422ab39d5a34d2317d329d6407068792ae29a73 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Wed, 22 Apr 2026 02:58:21 +0800 Subject: [PATCH 100/183] consensus, core, internal, miner: remove FinalizeAndAssemble (#34726) This PR removes `FinalizeAndAssemble` from the consensus engine interface and relocates block assembly logic outside of the consensus engine. Block assembly is consensus-agnostic. Most validations can be performed by the caller. For example: - Withdrawals must be nil prior to Shanghai - After Shanghai upgrade, withdrawals must be non-nil, even if empty. The only notable consensus-specific validation is related to uncles. In clique, the concept of uncles does not exist, and any block containing uncles should be considered invalid. Within the block production package, the policy is to produce blocks according to the latest chain specification. As a result, Clique-specific block production is no longer supported. This tradeoff is considered acceptable. --- consensus/beacon/consensus.go | 46 ----------------------------------- consensus/clique/clique.go | 19 --------------- consensus/consensus.go | 9 ------- consensus/ethash/consensus.go | 19 --------------- core/chain_makers.go | 20 +++++++++++---- core/state_processor.go | 10 ++++++++ internal/ethapi/simulate.go | 10 ++++---- miner/worker.go | 26 ++++++++++++++++---- 8 files changed, 51 insertions(+), 108 deletions(-) diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go index c4a284d485..72ac75c036 100644 --- a/consensus/beacon/consensus.go +++ b/consensus/beacon/consensus.go @@ -17,7 +17,6 @@ package beacon import ( - "context" "errors" "fmt" "math/big" @@ -26,13 +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/internal/telemetry" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie" "github.com/holiman/uint256" ) @@ -361,48 +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(ctx context.Context, chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, body *types.Body, receipts []*types.Receipt) (result *types.Block, err error) { - ctx, _, spanEnd := telemetry.StartSpan(ctx, "consensus.beacon.FinalizeAndAssemble", - telemetry.Int64Attribute("block.number", int64(header.Number.Uint64())), - telemetry.Int64Attribute("txs.count", int64(len(body.Transactions))), - telemetry.Int64Attribute("withdrawals.count", int64(len(body.Withdrawals))), - ) - defer spanEnd(&err) - - if !beacon.IsPoSHeader(header) { - block, delegateErr := beacon.ethone.FinalizeAndAssemble(ctx, chain, header, state, body, receipts) - return block, delegateErr - } - 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. - _, _, finalizeSpanEnd := telemetry.StartSpan(ctx, "consensus.beacon.Finalize") - beacon.Finalize(chain, header, state, body) - finalizeSpanEnd(nil) - - // Assign the final state root to header. - _, _, rootSpanEnd := telemetry.StartSpan(ctx, "consensus.beacon.IntermediateRoot") - header.Root = state.IntermediateRoot(true) - rootSpanEnd(nil) - - // Assemble the final block. - _, _, blockSpanEnd := telemetry.StartSpan(ctx, "consensus.beacon.NewBlock") - block := types.NewBlock(header, body, receipts, trie.NewStackTrie(nil)) - blockSpanEnd(nil) - 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 3bf79d5a62..ceaec44656 100644 --- a/consensus/clique/clique.go +++ b/consensus/clique/clique.go @@ -19,7 +19,6 @@ package clique import ( "bytes" - "context" "errors" "fmt" "io" @@ -34,7 +33,6 @@ 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" @@ -43,7 +41,6 @@ import ( "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" - "github.com/ethereum/go-ethereum/trie" ) const ( @@ -580,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(ctx context.Context, 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) { diff --git a/consensus/consensus.go b/consensus/consensus.go index 094026b614..4ba389292f 100644 --- a/consensus/consensus.go +++ b/consensus/consensus.go @@ -18,11 +18,9 @@ package consensus import ( - "context" "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" @@ -88,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(ctx context.Context, 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 56256d1215..ee9d9d97d6 100644 --- a/consensus/ethash/consensus.go +++ b/consensus/ethash/consensus.go @@ -17,7 +17,6 @@ package ethash import ( - "context" "errors" "fmt" "math/big" @@ -28,14 +27,12 @@ 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" ) @@ -512,22 +509,6 @@ 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(ctx context.Context, 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 := keccak.NewLegacyKeccak256() diff --git a/core/chain_makers.go b/core/chain_makers.go index 3bc7f6528b..46cd98de61 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -17,7 +17,6 @@ package core import ( - "context" "fmt" "math/big" @@ -411,11 +410,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(context.Background(), 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)) diff --git a/core/state_processor.go b/core/state_processor.go index 9cb7cc73bc..1c801ec9a4 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -22,6 +22,7 @@ import ( "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" @@ -30,6 +31,7 @@ import ( "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" ) // StateProcessor is a basic Processor, which takes care of transitioning @@ -372,3 +374,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/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index 90e88e83ee..d18561760e 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -416,13 +416,13 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, blockBody := &types.Body{ Transactions: txes, - Withdrawals: *block.BlockOverrides.Withdrawals, + Withdrawals: *block.BlockOverrides.Withdrawals, // Withdrawal is also sanitized as non-nil } chainHeadReader := &simChainHeadReader{ctx, sim.b} - b, err := sim.b.Engine().FinalizeAndAssemble(ctx, chainHeadReader, header, sim.state, blockBody, receipts) - if err != nil { - return nil, nil, nil, err - } + + // Assemble the block + b := core.AssembleBlock(sim.b.Engine(), chainHeadReader, header, sim.state, blockBody, receipts) + repairLogs(callResults, b.Hash()) return b, callResults, senders, nil } diff --git a/miner/worker.go b/miner/worker.go index 1d648f0ee1..ae5d6c306f 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -183,7 +183,21 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams, } } } - body := types.Body{Transactions: work.txs, Withdrawals: genParam.withdrawals} + // 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) + } + } allLogs := make([]*types.Log, 0) for _, r := range work.receipts { @@ -211,11 +225,11 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams, 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(ctx, 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), @@ -413,6 +427,7 @@ func (miner *Miner) applyTransaction(env *environment, tx *types.Transaction) (* 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. @@ -529,6 +544,7 @@ func (miner *Miner) commitTransactions(ctx context.Context, env *environment, pl 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 From dca3cf02a22cdc6aae266f4c7e013db1c330e1a0 Mon Sep 17 00:00:00 2001 From: cui Date: Wed, 22 Apr 2026 11:02:44 +0800 Subject: [PATCH 101/183] core: pre-allocate the receipt slice (#34786) --- core/state_processor.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/state_processor.go b/core/state_processor.go index 1c801ec9a4..fda3bf8fe7 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -64,7 +64,7 @@ func (p *StateProcessor) chainConfig() *params.ChainConfig { 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 + receipts = make(types.Receipts, 0, len(block.Transactions())) header = block.Header() blockHash = block.Hash() blockNumber = block.Number() From 3abc4cea3532e71f944a9b3e06b4341a6e338b59 Mon Sep 17 00:00:00 2001 From: cui Date: Wed, 22 Apr 2026 11:05:59 +0800 Subject: [PATCH 102/183] core/state: use address hash cache if available (#34780) --- core/state/statedb.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index 8c57edf08e..a62e3c2020 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -1126,7 +1126,7 @@ 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()) + addrHash := prevObj.addrHash() op := &AccountDelete{ Address: addr, Origin: prev, From 6f02965aab977e8e73942163a357443d43fe9139 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Wed, 22 Apr 2026 13:42:49 +0800 Subject: [PATCH 103/183] core: track the state access footprint (#34776) This is a pre-requisite PR for landing the BAL construction --- core/state/state_object.go | 16 ++----- core/state/statedb.go | 21 ++++++++- core/state/statedb_hooked.go | 13 +++--- core/types/bal/access_list.go | 80 ++++++++++++++++++++++++++++++++++ core/vm/contracts.go | 6 +-- core/vm/contracts_fuzz_test.go | 3 +- core/vm/contracts_test.go | 9 ++-- core/vm/evm.go | 24 ++-------- core/vm/interface.go | 6 ++- 9 files changed, 130 insertions(+), 48 deletions(-) create mode 100644 core/types/bal/access_list.go diff --git a/core/state/state_object.go b/core/state/state_object.go index df54733d63..264dfd920d 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -180,6 +180,9 @@ 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. + s.db.stateReadList.AddState(s.address, key) + // If we have a pending write or clean cached, return that if value, pending := s.pendingStorage[key]; pending { return value @@ -194,19 +197,6 @@ func (s *stateObject) GetCommittedState(key common.Hash) common.Hash { // have been handles via pendingStorage above. // 2) we don't have new values, and can deliver empty response back if _, destructed := s.db.stateObjectsDestruct[s.address]; destructed { - // Invoke the reader regardless and discard the returned value. - // The returned value may not be empty, as it could belong to a - // self-destructed contract. - // - // The read operation is still essential for correctly building - // the block-level access list. - // - // TODO(rjl493456442) the reader interface can be extended with - // Touch, recording the read access without the actual disk load. - _, err := s.db.reader.Storage(s.address, key) - if err != nil { - s.db.setError(err) - } s.originStorage[key] = common.Hash{} // track the empty slot as origin value return common.Hash{} } diff --git a/core/state/statedb.go b/core/state/statedb.go index a62e3c2020..5d94d4806d 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -31,6 +31,7 @@ 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/crypto" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -126,6 +127,9 @@ type StateDB struct { accessList *accessList accessEvents *AccessEvents + // Per-transaction state access footprint for EIP-7928 + stateReadList *bal.StateAccessList + // Transient storage transientStorage transientStorage @@ -317,6 +321,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) @@ -579,6 +588,9 @@ 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. + s.stateReadList.AddAccount(addr) + // Prefer live objects if any is available if obj := s.stateObjects[addr]; obj != nil { return obj @@ -784,7 +796,7 @@ func (s *StateDB) LogsForBurnAccounts() []*types.Log { // 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) { +func (s *StateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { addressesToPrefetch := make([]common.Address, 0, len(s.journal.dirties)) for addr := range s.journal.dirties { obj, exist := s.stateObjects[addr] @@ -800,6 +812,7 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) { 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. @@ -822,6 +835,8 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) { } // Invalidate journal because reverting across transactions is not allowed. s.clearJournalAndRefund() + + return s.stateReadList } // IntermediateRoot computes the current root hash of the state trie. @@ -1415,6 +1430,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.stateReadList = bal.NewStateAccessList() + } } // AddAddressToAccessList adds the given address to the access list diff --git a/core/state/statedb_hooked.go b/core/state/statedb_hooked.go index 687c4bb52b..c5faa7c98e 100644 --- a/core/state/statedb_hooked.go +++ b/core/state/statedb_hooked.go @@ -25,6 +25,7 @@ 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/crypto" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" @@ -114,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) } @@ -229,11 +234,10 @@ func (s *hookedStateDB) LogsForBurnAccounts() []*types.Log { return s.inner.LogsForBurnAccounts() } -func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) { +func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { 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. - s.inner.Finalise(deleteEmptyObjects) - return + return s.inner.Finalise(deleteEmptyObjects) } // Collect all self-destructed addresses first, then sort them to ensure @@ -282,6 +286,5 @@ func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) { s.hooks.OnCodeChange(addr, prevCodeHash, s.inner.GetCode(addr), types.EmptyCodeHash, nil) } } - - s.inner.Finalise(deleteEmptyObjects) + return s.inner.Finalise(deleteEmptyObjects) } diff --git a/core/types/bal/access_list.go b/core/types/bal/access_list.go new file mode 100644 index 0000000000..91da5ebcb7 --- /dev/null +++ b/core/types/bal/access_list.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 bal + +import ( + "maps" + + "github.com/ethereum/go-ethereum/common" +) + +// StorageAccessList represents a set of storage slots accessed within an account. +type StorageAccessList map[common.Hash]struct{} + +// StateAccessList records the set of accounts and storage slots that have been +// accessed. An entry with an empty StorageAccessList denotes an account access +// without any storage slot access. +type StateAccessList struct { + list map[common.Address]StorageAccessList +} + +// NewStateAccessList returns an empty StateAccessList ready for use. +func NewStateAccessList() *StateAccessList { + return &StateAccessList{ + list: make(map[common.Address]StorageAccessList), + } +} + +// AddAccount records an access to the given account. It is a no-op if the +// account is already present. +func (s *StateAccessList) AddAccount(addr common.Address) { + if s == nil { + return + } + if _, exists := s.list[addr]; !exists { + s.list[addr] = make(StorageAccessList) + } +} + +// AddState records an access to the given storage slot. The owning account is +// implicitly recorded as well. +func (s *StateAccessList) AddState(addr common.Address, slot common.Hash) { + if s == nil { + return + } + slots, exists := s.list[addr] + if !exists { + slots = make(StorageAccessList) + s.list[addr] = slots + } + slots[slot] = struct{}{} +} + +// Merge merges the entries from other into the receiver. +func (s *StateAccessList) Merge(other *StateAccessList) { + if s == nil || other == nil { + return + } + for addr, otherSlots := range other.list { + slots, exists := s.list[addr] + if !exists { + s.list[addr] = otherSlots + continue + } + maps.Copy(slots, otherSlots) + } +} diff --git a/core/vm/contracts.go b/core/vm/contracts.go index b1eed79282..6dadb64873 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -262,7 +262,7 @@ func ActivePrecompiles(rules params.Rules) []common.Address { // - the returned bytes, // - the remaining gas budget, // - any error that occurred -func RunPrecompiledContract(stateDB StateDB, p PrecompiledContract, address common.Address, input []byte, gas GasBudget, logger *tracing.Hooks) (ret []byte, remaining GasBudget, 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) prior, ok := gas.Charge(GasCosts{RegularGas: gasCost}) if !ok { @@ -274,8 +274,8 @@ func RunPrecompiledContract(stateDB StateDB, p PrecompiledContract, address comm } // Touch the precompile for block-level accessList recording once Amsterdam // fork is activated. - if stateDB != nil { - stateDB.Exist(address) + if rules.IsAmsterdam { + stateDB.Touch(address) } output, err := p.Run(input) return output, gas, err diff --git a/core/vm/contracts_fuzz_test.go b/core/vm/contracts_fuzz_test.go index 35a9bd0257..988cdb91f2 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(nil, p, a, input, NewGasBudget(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 dda753f504..e7841c8552 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(nil, p, common.HexToAddress(addr), in, NewGasBudget(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(nil, p, common.HexToAddress(addr), in, NewGasBudget(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(nil, p, common.HexToAddress(addr), in, NewGasBudget(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(nil, p, common.HexToAddress(addr), data, NewGasBudget(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/evm.go b/core/vm/evm.go index ca8d8967ec..59e301c0a7 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -287,11 +287,7 @@ func (evm *EVM) Call(caller common.Address, addr common.Address, input []byte, g } if isPrecompile { - var stateDB StateDB - if evm.chainRules.IsAmsterdam { - stateDB = evm.StateDB - } - ret, gas, err = RunPrecompiledContract(stateDB, p, addr, 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) @@ -354,11 +350,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 { - var stateDB StateDB - if evm.chainRules.IsAmsterdam { - stateDB = evm.StateDB - } - ret, gas, err = RunPrecompiledContract(stateDB, p, addr, 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. @@ -401,11 +393,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 { - var stateDB StateDB - if evm.chainRules.IsAmsterdam { - stateDB = evm.StateDB - } - ret, gas, err = RunPrecompiledContract(stateDB, p, addr, 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 // @@ -457,11 +445,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 { - var stateDB StateDB - if evm.chainRules.IsAmsterdam { - stateDB = evm.StateDB - } - ret, gas, err = RunPrecompiledContract(stateDB, p, addr, 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. diff --git a/core/vm/interface.go b/core/vm/interface.go index 41b52a10dc..487d8002f9 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -22,6 +22,7 @@ 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/holiman/uint256" ) @@ -63,6 +64,9 @@ type StateDB interface { // 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 @@ -94,5 +98,5 @@ type StateDB interface { AccessEvents() *state.AccessEvents // Finalise must be invoked at the end of a transaction - Finalise(bool) + Finalise(bool) *bal.StateAccessList } From 87b030780e0edc82a1d48969fd05a0f9a84727f2 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Wed, 22 Apr 2026 12:18:56 +0200 Subject: [PATCH 104/183] .github: add windows runner (#34742) Difference to Appveyor: - Missing 386 build. Hit some issue because user-space memory there is around 2Gbs. Also seems generally extremely niche. - Not doing the archive step and NSIS installer and uploads (those are done on the builder). --- .github/workflows/go.yml | 41 ++++++++++++++++++++++++++++++++++++++++ rlp/rlpgen/gen_test.go | 4 ++++ 2 files changed, 45 insertions(+) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 507057afe5..3e811072ff 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -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/rlp/rlpgen/gen_test.go b/rlp/rlpgen/gen_test.go index 4bfb1b9d25..2e35ef933d 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") From eb3283fb2ef8b606d35fb6e30d2e036c186be45e Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Wed, 22 Apr 2026 12:32:19 +0200 Subject: [PATCH 105/183] accounts/usbwallet: revert github.com/karalabe/hid to fix freebsd build (#34784) This PR reverts the last change to the freebsd build, and it fixes the _direct_ FreeBSD build. Here, we change the upstream of github.com/karalabe/hid to its new home, github.com/ethereum/hid. The new dependency includes a dummy.go file that makes `go mod vendor` work. ##### Origin of the problem Enrique is maintaining the FreeBSD ports, and FreeBSD ports only support vendored go modules. It turns out that `go mod vendor` will not include C files if there is no `.go` file in the directory. Since the C files were missing for `karalabe/hid`, the ports maintainer tried to use the version of `hidapi` that is provided by the ports. To do so, he had to modify the way things are included. This broke the _out of ports_ FreeBSD build. --- accounts/usbwallet/hub.go | 2 +- accounts/usbwallet/wallet.go | 2 +- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/accounts/usbwallet/hub.go b/accounts/usbwallet/hub.go index 6f8ac0d8d9..cfa844b345 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. diff --git a/accounts/usbwallet/wallet.go b/accounts/usbwallet/wallet.go index f1597ca1a7..5da58a2ec2 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/go.mod b/go.mod index a623668b89..17897a62c0 100644 --- a/go.mod +++ b/go.mod @@ -23,6 +23,7 @@ require ( github.com/dop251/goja v0.0.0-20230605162241-28ee0ee714f3 github.com/ethereum/c-kzg-4844/v2 v2.1.6 github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab + 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 @@ -43,7 +44,6 @@ 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.20260315100226-f5d04adeffeb github.com/klauspost/compress v1.17.8 github.com/kylelemons/godebug v1.1.0 github.com/mattn/go-colorable v0.1.13 diff --git a/go.sum b/go.sum index 4713387020..bad8a44cfd 100644 --- a/go.sum +++ b/go.sum @@ -117,6 +117,8 @@ github.com/ethereum/c-kzg-4844/v2 v2.1.6 h1:xQymkKCT5E2Jiaoqf3v4wsNgjZLY0lRSkZn2 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/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= @@ -225,8 +227,6 @@ 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.20260315100226-f5d04adeffeb h1:Ag83At00qa4FLkcdMgrwHVSakqky/eZczOlxd4q336E= -github.com/karalabe/hid v1.0.1-0.20260315100226-f5d04adeffeb/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= From b0ead5e17bb3e479137fb545da2fef27e1e51672 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Wed, 22 Apr 2026 16:18:29 +0200 Subject: [PATCH 106/183] .gitea: add installer and archive steps for windows (#34793) Adds the installer + archive steps that were done on appveyor to gitea builder. --- .gitea/workflows/release.yml | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml index 41defedd00..efe76cf170 100644 --- a/.gitea/workflows/release.yml +++ b/.gitea/workflows/release.yml @@ -166,6 +166,24 @@ jobs: env: GETH_MINGW: 'C:\msys64\mingw64' + - name: "Create/upload archive (amd64)" + shell: cmd + run: | + go run build/ci.go archive -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)" + shell: cmd + run: | + set "PATH=C:\Program Files (x86)\NSIS;%PATH%" + go run build/ci.go nsis -arch amd64 -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + del /Q build\bin\* + env: + WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} + AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} + - name: "Build (386)" shell: cmd run: | @@ -174,6 +192,24 @@ jobs: env: GETH_MINGW: 'C:\msys64\mingw32' + - name: "Create/upload archive (386)" + shell: cmd + run: | + go run build/ci.go archive -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)" + shell: cmd + run: | + set "PATH=C:\Program Files (x86)\NSIS;%PATH%" + go run build/ci.go nsis -arch 386 -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + del /Q build\bin\* + env: + WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} + AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} + docker: name: Docker Image runs-on: ubuntu-latest From 8e2107dc39dc9dab132150ec915e7ac299f9eb48 Mon Sep 17 00:00:00 2001 From: Matus Kysel Date: Wed, 22 Apr 2026 16:48:38 +0200 Subject: [PATCH 107/183] cmd/devp2p: fix disconnect decoding in rlpx ping (#34781) The rlpx ping command mishandled disconnect responses on two counts: the error return from rlp.DecodeBytes was ignored, so decode failures silently produced an "invalid disconnect message" error with no context; and the decoder assumed the spec-compliant list form exclusively, while older geth and some other implementations send the reason as a bare byte. Accept both wire forms (matching the legacy-tolerant behavior already in p2p.decodeDisconnectMessage), and on decode failure include the raw payload so operators can see exactly what the peer sent. Add a unit test for the decoder covering both forms plus the empty-payload error path. --- cmd/devp2p/rlpxcmd.go | 38 +++++++++++++++++-- cmd/devp2p/rlpxcmd_test.go | 75 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 109 insertions(+), 4 deletions(-) create mode 100644 cmd/devp2p/rlpxcmd_test.go diff --git a/cmd/devp2p/rlpxcmd.go b/cmd/devp2p/rlpxcmd.go index 1dc8f82460..ec73171e76 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 0000000000..d7b374c47d --- /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) + } + }) + } +} From 2ca74d2ef9314c18a70e396858ddc6dc7de2350f Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Wed, 22 Apr 2026 17:55:43 +0000 Subject: [PATCH 108/183] eth/fetcher: lazy-allocate hashes slice in scheduleFetches scheduleFetches.func1 is the single biggest allocator in the Pyroscope profile of a busy node (~13.5 GB/hr, 8% of total alloc_space). Each peer-iteration pre-allocated 'make([]common.Hash, 0, maxTxRetrievals)' = 8 KB, even for peers that end up collecting no new hashes (all their announces were already being fetched by someone else). Defer the slice allocation to the first append. Peers that collect zero hashes now pay zero allocation, which is the common case on the timeoutTrigger path where all peers with any announces are iterated. New benchmarks BenchmarkScheduleFetches_{100peers_10new, 100peers_allFetching, 500peers_3new} (benchstat, 6 samples): scenario ns/op B/op allocs/op 100p/10new unchanged unchanged unchanged (fast path) 100p/allFetching -62% -92% -20% 500p/3new -22% -44% -7% geomean -33% -65% -9% --- eth/fetcher/tx_fetcher.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/eth/fetcher/tx_fetcher.go b/eth/fetcher/tx_fetcher.go index 5817dfbcf5..2165b7f103 100644 --- a/eth/fetcher/tx_fetcher.go +++ b/eth/fetcher/tx_fetcher.go @@ -991,8 +991,10 @@ func (f *TxFetcher) scheduleFetches(timer *mclock.Timer, timeout chan struct{}, if len(f.announces[peer]) == 0 { return // continue in the for-each } + // hashes is allocated lazily: peers that collect no new hashes + // (all announces already being fetched) skip the 8KB allocation. var ( - hashes = make([]common.Hash, 0, maxTxRetrievals) + hashes []common.Hash bytes uint64 ) f.forEachAnnounce(f.announces[peer], func(hash common.Hash, meta txMetadata) bool { @@ -1009,6 +1011,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 { From 526ad4f6f1dc79d36ae8a7bd75a3ff18ac8a0a60 Mon Sep 17 00:00:00 2001 From: Bosul Mun Date: Thu, 23 Apr 2026 15:39:07 +0200 Subject: [PATCH 109/183] crypto/kzg4844: add cell-related functions (#34766) This PR adds three cell-level kzg functions required for the sparse blobpool (eth/72). - VerifyCells: Verifies cells corresponding to proofs. This is used to verify cells received from eth/72 peers. - ComputeCells: Computes cells from blobs. This is needed because user submissions and eth/71 transaction deliveries contain blobs, while eth/72 peers expect cells. - RecoverBlobs: Recovers blobs from partial cells. This is needed to support both eth/71 and eth/72 --------- Co-authored-by: Felix Lange --- crypto/kzg4844/kzg4844.go | 92 ++++++++- crypto/kzg4844/kzg4844_ckzg_cgo.go | 89 +++++++++ crypto/kzg4844/kzg4844_ckzg_nocgo.go | 12 ++ crypto/kzg4844/kzg4844_gokzg.go | 82 ++++++++ crypto/kzg4844/kzg4844_test.go | 269 ++++++++++++++++++++++----- 5 files changed, 499 insertions(+), 45 deletions(-) diff --git a/crypto/kzg4844/kzg4844.go b/crypto/kzg4844/kzg4844.go index 3ccc204838..1e021d64a6 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 93d5f4ff94..bacfa7095a 100644 --- a/crypto/kzg4844/kzg4844_ckzg_cgo.go +++ b/crypto/kzg4844/kzg4844_ckzg_cgo.go @@ -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 7c552e9a18..e1a3c0af1e 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 03627ebafb..ca45a6a560 100644 --- a/crypto/kzg4844/kzg4844_gokzg.go +++ b/crypto/kzg4844/kzg4844_gokzg.go @@ -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 743a277199..056decfb8b 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)) + } +} From 6ece4cd1436fa5ea2380eb819e125ee125efc643 Mon Sep 17 00:00:00 2001 From: cui Date: Fri, 24 Apr 2026 10:02:34 +0800 Subject: [PATCH 110/183] crypto: fix unit test (#34811) --- crypto/crypto_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crypto/crypto_test.go b/crypto/crypto_test.go index d803ab27c5..0636427a4f 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) From 33c1bd59ff23a7b22f8804a6b83833015edfc159 Mon Sep 17 00:00:00 2001 From: YQ Date: Fri, 24 Apr 2026 17:27:39 +0800 Subject: [PATCH 111/183] rpc: send WebSocket close frame on client disconnect (#33909) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When `rpc.Client.Close()` is called, the TCP connection is torn down without sending a WebSocket Close frame. The server sees `websocket: close 1006 (abnormal closure): unexpected EOF` instead of a clean 1000 (normal closure). ### Root cause `websocketCodec.close()` delegates to `jsonCodec.close()` which calls `c.conn.Close()` — gorilla/websocket's `Conn.Close` explicitly "[closes the underlying network connection without sending or waiting for a close message](https://pkg.go.dev/github.com/gorilla/websocket#Conn.Close)" (per RFC 6455). ### Fix Send a WebSocket Close control frame (opcode 0x8, status 1000) before closing the underlying connection. Uses `WriteControl` with the same `encMu` mutex pattern already used by `pingLoop` for write serialization, and reuses the existing `wsPingWriteTimeout` (5s) constant. `WriteControl` errors are safe to ignore — the connection may already be broken by the time we attempt the close frame. Fixes #30482 --- rpc/websocket.go | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/rpc/websocket.go b/rpc/websocket.go index 543ff617ba..ec676b9caf 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() } From c876755839b2d6ebffa1c43538c42713e769347d Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Fri, 24 Apr 2026 12:12:26 +0200 Subject: [PATCH 112/183] Update eth/fetcher/tx_fetcher.go Co-authored-by: jwasinger --- eth/fetcher/tx_fetcher.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/eth/fetcher/tx_fetcher.go b/eth/fetcher/tx_fetcher.go index 2165b7f103..20621c531d 100644 --- a/eth/fetcher/tx_fetcher.go +++ b/eth/fetcher/tx_fetcher.go @@ -991,8 +991,6 @@ func (f *TxFetcher) scheduleFetches(timer *mclock.Timer, timeout chan struct{}, if len(f.announces[peer]) == 0 { return // continue in the for-each } - // hashes is allocated lazily: peers that collect no new hashes - // (all announces already being fetched) skip the 8KB allocation. var ( hashes []common.Hash bytes uint64 From 8091994e7b5954827ad68ccca463647b220b1621 Mon Sep 17 00:00:00 2001 From: rayoo Date: Fri, 24 Apr 2026 19:37:34 +0800 Subject: [PATCH 113/183] eth/protocols/snap: fix data race on testPeer counters (#34802) The testPeer request counters (nAccountRequests, nStorageRequests, nBytecodeRequests, nTrienodeRequests) were plain int fields incremented with ++. These increments happen in Request* methods that are invoked concurrently by the Syncer from multiple goroutines (assignBytecodeTasks, assignStorageTasks, etc.), causing a data race reliably detected by go test -race. Change the counters to atomic.Int64 so increments and reads are synchronized without introducing a mutex. Fixes races detected in TestMultiSyncManyUseless, TestMultiSyncManyUselessWithLowTimeout, TestMultiSyncManyUnresponsive, TestSyncWithStorageAndOneCappedPeer, TestSyncWithStorageAndCorruptPeer, and TestSyncWithStorageAndNonProvingPeer. --- eth/protocols/snap/sync_test.go | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/eth/protocols/snap/sync_test.go b/eth/protocols/snap/sync_test.go index b11ad4e78a..c506488e91 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" @@ -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 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, 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 int) error { - t.nStorageRequests++ + 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 { @@ -208,7 +209,7 @@ func (t *testPeer) RequestStorageRanges(id uint64, root common.Hash, accounts [] } func (t *testPeer) RequestByteCodes(id uint64, hashes []common.Hash, bytes int) error { - t.nBytecodeRequests++ + 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 @@ -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) } From b70d9a4b8e409640d5f77af860864e1369dc87fd Mon Sep 17 00:00:00 2001 From: rayoo Date: Fri, 24 Apr 2026 23:30:03 +0800 Subject: [PATCH 114/183] core/state,core/types/bal: copy stateReadList in StateDB.Copy The stateReadList field introduced by #34776 to track the state access footprint for EIP-7928 was not propagated by StateDB.Copy. Every other per-transaction field that lives alongside it (accessList, transientStorage, journal, witness, accessEvents) is copied explicitly, so this field was simply missed. After Copy the copy's stateReadList is nil while the original keeps its entries, so the nil-safe guards on StateAccessList.AddAccount / AddState silently drop every access recorded on the copy. For any post-Amsterdam code path that copies a prepared state and keeps reading from the copy, the BAL footprint becomes incomplete. Add a Copy method on bal.StateAccessList and invoke it from StateDB.Copy, matching the pattern used for accessList and accessEvents. --------- Co-authored-by: jwasinger --- core/state/statedb.go | 3 +++ core/types/bal/access_list.go | 14 ++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/core/state/statedb.go b/core/state/statedb.go index 5d94d4806d..1858f4758d 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -716,6 +716,9 @@ func (s *StateDB) Copy() *StateDB { if s.accessEvents != nil { state.accessEvents = s.accessEvents.Copy() } + if s.stateReadList != nil { + state.stateReadList = s.stateReadList.Copy() + } // Deep copy cached state objects. for addr, obj := range s.stateObjects { state.stateObjects[addr] = obj.deepCopy(state) diff --git a/core/types/bal/access_list.go b/core/types/bal/access_list.go index 91da5ebcb7..e563fa22e2 100644 --- a/core/types/bal/access_list.go +++ b/core/types/bal/access_list.go @@ -78,3 +78,17 @@ func (s *StateAccessList) Merge(other *StateAccessList) { maps.Copy(slots, otherSlots) } } + +// Copy returns a deep copy of the StateAccessList. +func (s *StateAccessList) Copy() *StateAccessList { + if s == nil { + return nil + } + cpy := &StateAccessList{ + list: make(map[common.Address]StorageAccessList, len(s.list)), + } + for addr, slots := range s.list { + cpy.list[addr] = maps.Clone(slots) + } + return cpy +} From b26391773d7cec44dcc52326b5fbfae9cc63f573 Mon Sep 17 00:00:00 2001 From: cui Date: Sun, 26 Apr 2026 17:54:07 +0800 Subject: [PATCH 115/183] core/state: and instead of or (#34819) --- core/state/snapshot/iterator_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/state/snapshot/iterator_test.go b/core/state/snapshot/iterator_test.go index dd6c4cf968..a95bd66dde 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 { From 2d5da603717417ffe63d238a92a8cd9dc4e02745 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Sun, 26 Apr 2026 23:32:39 +0800 Subject: [PATCH 116/183] core/types/bal: update the BAL definition to the latest spec (#34799) This PR updates the BAL structure definition to the latest the spec, - Balance has been changed from [16]byte to uint256 - Storage key and value has been changed from [32]byte to uint256 - BlockAccessList has been changed from a struct to a slice of AccountChanges - TxIndex has been changed from uint16 to uint32 --- core/types/bal/bal.go | 34 +- core/types/bal/bal_encoding.go | 210 ++++++---- core/types/bal/bal_encoding_rlp_generated.go | 400 +++++++++---------- core/types/bal/bal_test.go | 97 ++--- eth/protocols/snap/handler_test.go | 12 +- 5 files changed, 399 insertions(+), 354 deletions(-) diff --git a/core/types/bal/bal.go b/core/types/bal/bal.go index 86dc8e5426..99ead8d6f0 100644 --- a/core/types/bal/bal.go +++ b/core/types/bal/bal.go @@ -25,13 +25,13 @@ import ( ) // 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. @@ -42,25 +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 contains the post-state contract code of an account keyed // by tx index. - CodeChange map[uint16][]byte `json:"codeChange,omitempty"` + 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), - CodeChange: make(map[uint16][]byte), + BalanceChanges: make(map[uint32]*uint256.Int), + NonceChanges: make(map[uint32]uint64), + CodeChange: make(map[uint32][]byte), } } @@ -97,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 @@ -110,7 +110,7 @@ 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() } @@ -120,7 +120,7 @@ func (b *ConstructionBlockAccessList) CodeChange(address common.Address, txIndex // 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() } @@ -129,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() } @@ -148,21 +148,21 @@ 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) - codes := make(map[uint16][]byte, len(aa.CodeChange)) + codes := make(map[uint32][]byte, len(aa.CodeChange)) for index, code := range aa.CodeChange { codes[index] = bytes.Clone(code) } diff --git a/core/types/bal/bal_encoding.go b/core/types/bal/bal_encoding.go index 6d52c17c83..03f97f3809 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,56 +95,44 @@ 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 } @@ -122,27 +142,27 @@ func (e *encodingSlotWrites) validate() error { // encodingCodeChange contains the runtime bytecode deployed at an address // and the transaction index where the deployment took place. type encodingCodeChange struct { - TxIndex uint16 `ssz-size:"2"` - Code []byte `ssz-max:"300000"` // TODO(rjl493456442) shall we put the limit here? The limit will be increased gradually + 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]) - CodeChanges []encodingCodeChange `ssz-max:"300000"` // 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") } @@ -153,36 +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") } // Check the code changes are sorted in order if !slices.IsSortedFunc(e.CodeChanges, func(a, b encodingCodeChange) int { - return cmp.Compare[uint16](a.TxIndex, b.TxIndex) + 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 { - // TODO(rjl493456442): This check should be fork-aware, since the limit may - // differ across forks. - if len(change.Code) > params.MaxCodeSize { + 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") } } @@ -193,16 +218,32 @@ 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, }) } for _, codeChange := range e.CodeChanges { @@ -221,13 +262,13 @@ 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, len(a.StorageWrites)), - StorageReads: make([][32]byte, 0, len(a.StorageReads)), + 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)), @@ -237,18 +278,19 @@ func (a *ConstructionAccountAccess) toEncodingObj(addr common.Address) AccountAc 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) @@ -258,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, @@ -283,11 +325,16 @@ func (a *ConstructionAccountAccess) toEncodingObj(addr common.Address) AccountAc // Convert code change codeIndices := slices.Collect(maps.Keys(a.CodeChange)) - slices.SortFunc(codeIndices, cmp.Compare[uint16]) + slices.SortFunc(codeIndices, cmp.Compare[uint32]) for _, idx := range codeIndices { res.CodeChanges = append(res.CodeChanges, encodingCodeChange{ TxIndex: idx, - Code: a.CodeChange[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 @@ -302,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 } @@ -314,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:") @@ -351,11 +397,9 @@ func (e *BlockAccessList) PrettyPrint() string { // Copy returns a deep copy of the access list func (e *BlockAccessList) Copy() *BlockAccessList { - cpy := &BlockAccessList{ - Accesses: make([]AccountAccess, 0, len(e.Accesses)), + cpy := make(BlockAccessList, 0, len(*e)) + for _, accountAccess := range *e { + cpy = append(cpy, accountAccess.Copy()) } - for _, accountAccess := range e.Accesses { - cpy.Accesses = append(cpy.Accesses, accountAccess.Copy()) - } - return cpy + return &cpy } diff --git a/core/types/bal/bal_encoding_rlp_generated.go b/core/types/bal/bal_encoding_rlp_generated.go index 640035e30e..540987c076 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.CodeChanges { - _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 - { - 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 { - 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 { - return err - } - _tmp5.Accesses = _tmp7 - if err := dec.ListEnd(); err != nil { - return err - } - } - _tmp4 = append(_tmp4, _tmp5) - } - 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) - } - if err := dec.ListEnd(); err != nil { - return err - } - _tmp2.StorageReads = _tmp11 - // BalanceChanges: - var _tmp13 []encodingBalanceChange - if _, err := dec.List(); err != nil { - return err - } - for dec.MoreDataInList() { - var _tmp14 encodingBalanceChange + var _tmp6 encodingStorageWrite { if _, err := dec.List(); err != nil { return err } // TxIdx: - _tmp15, err := dec.Uint16() + _tmp7, err := dec.Uint32() if err != nil { return err } - _tmp14.TxIdx = _tmp15 - // Balance: - var _tmp16 [16]byte - if err := dec.ReadBytes(_tmp16[:]); err != nil { + _tmp6.TxIdx = _tmp7 + // ValueAfter: + var _tmp8 uint256.Int + if err := dec.ReadUint256(&_tmp8); err != nil { return err } - _tmp14.Balance = _tmp16 + _tmp6.ValueAfter = &_tmp8 if err := dec.ListEnd(); err != nil { return err } } - _tmp13 = append(_tmp13, _tmp14) + _tmp5 = append(_tmp5, _tmp6) } if err := dec.ListEnd(); err != nil { return err } - _tmp2.BalanceChanges = _tmp13 - // NonceChanges: - var _tmp17 []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) - } - if err := dec.ListEnd(); err != nil { - return err - } - _tmp2.NonceChanges = _tmp17 - // CodeChanges: - var _tmp21 []encodingCodeChange - if _, err := dec.List(); err != nil { - return err - } - for dec.MoreDataInList() { - var _tmp22 encodingCodeChange - { - 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) - } - if err := dec.ListEnd(); err != nil { - return err - } - _tmp2.CodeChanges = _tmp21 + _tmp3.Accesses = _tmp5 if err := dec.ListEnd(); err != nil { return err } } - _tmp1 = append(_tmp1, _tmp2) + _tmp2 = append(_tmp2, _tmp3) } if err := dec.ListEnd(); err != nil { return err } - _tmp0.Accesses = _tmp1 + _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 + } + // 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 + } + } + _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 + } + // 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 + } + } + _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 + } + // TxIndex: + _tmp21, err := dec.Uint32() + if err != nil { + return err + } + _tmp20.TxIndex = _tmp21 + // Code: + _tmp22, err := dec.Bytes() + if err != nil { + return err + } + _tmp20.Code = _tmp22 + if err := dec.ListEnd(); err != nil { + return err + } + } + _tmp19 = append(_tmp19, _tmp20) + } + if err := dec.ListEnd(); err != nil { + return err + } + _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 58ba639ff0..32a0292f2e 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,20 +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: map[uint16][]byte{ + 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}), @@ -77,14 +71,14 @@ 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[uint16][]byte{ + CodeChange: map[uint32][]byte{ 0: common.Hex2Bytes("deadbeef"), }, }, @@ -101,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") } } @@ -115,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) }) } @@ -181,26 +191,21 @@ func makeTestAccountAccess(sort bool) AccountAccess { StorageReads: storageReads, BalanceChanges: balances, NonceChanges: nonces, - CodeChanges: []encodingCodeChange{ - { - TxIndex: 100, - Code: testrand.Bytes(256), - }, - }, + CodeChanges: codes, } } func makeTestBAL(sort bool) *BlockAccessList { - list := &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) { @@ -216,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) { @@ -229,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 @@ -241,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/eth/protocols/snap/handler_test.go b/eth/protocols/snap/handler_test.go index 3f6a43a059..b0522c20bb 100644 --- a/eth/protocols/snap/handler_test.go +++ b/eth/protocols/snap/handler_test.go @@ -31,18 +31,24 @@ import ( "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([][32]byte, n), + 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 { - binary.BigEndian.PutUint64(access.StorageReads[i][24:], uint64(i)) + 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{Accesses: []bal.AccountAccess{access}} + return &bal.BlockAccessList{access} } // getChainWithBALs creates a minimal test chain with BALs stored for each block. From a06558042299eba2e19ca656d3f46edb85df1420 Mon Sep 17 00:00:00 2001 From: Rahman Date: Mon, 27 Apr 2026 01:25:57 -0600 Subject: [PATCH 117/183] triedb/pathdb: compute size in StateSetWithOrigin.decode (#34828) `StateSetWithOrigin.decode()` was missing size computation after deserializing origin data, causing `size` to remain zero after journal reload. Added the same calculation logic used in `NewStateSetWithOrigin()`. --- triedb/pathdb/states.go | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/triedb/pathdb/states.go b/triedb/pathdb/states.go index c54d8b1136..27a6c1d422 100644 --- a/triedb/pathdb/states.go +++ b/triedb/pathdb/states.go @@ -583,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 } From 442bd28b0bad76674348a67b4c9f8689170bfcdb Mon Sep 17 00:00:00 2001 From: felipe Date: Mon, 27 Apr 2026 14:35:49 +0200 Subject: [PATCH 118/183] cmd/evm/internal/t8ntool: stream t8n alloc to ease heavy memory cases (#34785) --- cmd/evm/internal/t8ntool/execution.go | 90 ++++++++++++++++++- cmd/evm/internal/t8ntool/transition.go | 119 ++++++++++++++++++++++--- 2 files changed, 193 insertions(+), 16 deletions(-) diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index f17829ec53..253ebe1111 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -17,9 +17,11 @@ package t8ntool import ( + "encoding/json" "fmt" stdmath "math" "math/big" + "os" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -47,6 +49,9 @@ 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 @@ -146,8 +151,19 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, return h } var ( - isEIP4762 = chainConfig.IsUBT(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 = core.NewGasPool(pre.Env.GasLimit) blockHash = common.Hash{0x13, 0x37} @@ -414,6 +430,76 @@ 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 := keccak.NewLegacyKeccak256() rlp.Encode(hw, x) diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index 6a23e9dc70..e0bb3a449d 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" @@ -115,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 { @@ -223,22 +223,57 @@ func Transition(ctx *cli.Context) error { return err } } - // Dump the execution result + // Dump the execution result. var ( - collector = make(Alloc) + collector Alloc btleaves map[common.Hash]hexutil.Bytes ) isBinary := chainConfig.IsUBT(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) - if !isBinary { + 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 { @@ -327,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 { @@ -335,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 @@ -359,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 { @@ -378,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 { From 822e7c648618a43e7f8326868b9334b9976185c8 Mon Sep 17 00:00:00 2001 From: cui Date: Mon, 27 Apr 2026 22:13:42 +0800 Subject: [PATCH 119/183] accounts/scwallet: truncate before write (#34815) Co-authored-by: Guillaume Ballet <3272758+gballet@users.noreply.github.com> --- accounts/scwallet/hub.go | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/accounts/scwallet/hub.go b/accounts/scwallet/hub.go index 1b1899dc8e..185815365e 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 { From 51c97216c5f1c512781de46a85e756c15ed2c888 Mon Sep 17 00:00:00 2001 From: Rahman Date: Tue, 28 Apr 2026 02:57:58 -0600 Subject: [PATCH 120/183] p2p/discover: fix timeout loop early exit when removing expired matchers (#34743) Save `el.Next()` before calling `plist.Remove(el)` so iteration continues correctly. Previously the loop exited after removing the first expired matcher because `Remove` invalidates the element's links. --------- Co-authored-by: Felix Lange --- p2p/discover/common.go | 15 +++++++++++++++ p2p/discover/v4_udp.go | 11 ++++------- 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/p2p/discover/common.go b/p2p/discover/common.go index 767cc23b92..5513afd54d 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/v4_udp.go b/p2p/discover/v4_udp.go index dd3f363f7e..9e824dae18 100644 --- a/p2p/discover/v4_udp.go +++ b/p2p/discover/v4_udp.go @@ -446,9 +446,8 @@ 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) { + if dist := p.deadline.Sub(now); dist < 2*respTimeout { timeout.Reset(dist) return } @@ -478,8 +477,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 +497,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) From 4dc7d461556a2ccde3cd6bbe816bd448755a0e07 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Tue, 28 Apr 2026 11:10:44 +0200 Subject: [PATCH 121/183] core/vm: implement stack arena (#33960) Here, we change the EVM stack implementation to use an 'arena', i.e. a shared allocation pool for sub-call stacks. The stack is now more GC-friendly, since it is a slice of uint256 values instead of a slice of pointers. Code that pushes an item to the stack has been changed to get() the top item, then overwrite it. The PR is a rewrite/rebase of #30362. --------- Co-authored-by: Martin Holst Swende Co-authored-by: Marius van der Wijden --- core/state_prefetcher.go | 1 + core/state_processor.go | 1 + core/vm/eips.go | 28 ++--- core/vm/evm.go | 9 ++ core/vm/gas_table.go | 30 ++--- core/vm/instructions.go | 74 ++++++----- core/vm/instructions_test.go | 77 +++++++----- core/vm/interpreter.go | 6 +- core/vm/interpreter_test.go | 2 +- core/vm/memory_table.go | 46 +++---- core/vm/operations_acl.go | 10 +- core/vm/operations_verkle.go | 8 +- core/vm/runtime/runtime_test.go | 60 +++++++++ core/vm/stack.go | 209 ++++++++++++++++++++----------- eth/gasestimator/gasestimator.go | 1 + eth/state_accessor.go | 1 + eth/tracers/api.go | 9 +- internal/ethapi/api.go | 2 + internal/ethapi/simulate.go | 1 + miner/worker.go | 3 + 20 files changed, 366 insertions(+), 212 deletions(-) diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index c91d40d94f..ed292d0beb 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) diff --git a/core/state_processor.go b/core/state_processor.go index fda3bf8fe7..54ebbd047b 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -88,6 +88,7 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated // Apply pre-execution system calls. context = NewEVMBlockContext(header, p.chain, nil) evm := vm.NewEVM(context, tracingStateDB, config, cfg) + defer evm.Release() if beaconRoot := block.BeaconRoot(); beaconRoot != nil { ProcessBeaconBlockRoot(*beaconRoot, evm) diff --git a/core/vm/eips.go b/core/vm/eips.go index 54e5cb0c60..33af8fd4fd 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){ @@ -92,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 } @@ -111,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 } @@ -222,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 } @@ -240,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 } @@ -291,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 } @@ -397,11 +392,11 @@ 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 @@ -414,7 +409,7 @@ func opPush1EIP4762(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } } } else { - scope.Stack.push(integer.Clear()) + elem.Clear() } return nil, nil } @@ -426,12 +421,11 @@ 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() @@ -583,7 +577,7 @@ func enable7702(jt *JumpTable) { // opSlotNum enables the SLOTNUM opcode func opSlotNum(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(uint256.NewInt(evm.Context.SlotNum)) + scope.Stack.get().SetUint64(evm.Context.SlotNum) return nil, nil } diff --git a/core/vm/evm.go b/core/vm/evm.go index 59e301c0a7..26b2f73a00 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -127,6 +127,8 @@ type EVM struct { 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 @@ -141,6 +143,7 @@ func NewEVM(blockCtx BlockContext, statedb StateDB, chainConfig *params.ChainCon chainConfig: chainConfig, chainRules: chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil, blockCtx.Time), jumpDests: newMapJumpDests(), + arena: newArena(), } evm.precompiles = activePrecompiledContracts(evm.chainRules) @@ -223,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() diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index b3259b2ec7..046311f9cc 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -71,7 +71,7 @@ func memoryCopierGas(stackpos int) gasFunc { 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 GasCosts{}, ErrGasUintOverflow } @@ -100,7 +100,7 @@ func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySi 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 @@ -192,7 +192,7 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m } // 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()) @@ -228,7 +228,7 @@ func gasSStoreEIP2200(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m func makeGasLog(n uint64) gasFunc { return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { - requestedSize, overflow := stack.Back(1).Uint64WithOverflow() + requestedSize, overflow := stack.back(1).Uint64WithOverflow() if overflow { return GasCosts{}, ErrGasUintOverflow } @@ -261,7 +261,7 @@ func gasKeccak256(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor if err != nil { return GasCosts{}, err } - wordGas, overflow := stack.Back(1).Uint64WithOverflow() + wordGas, overflow := stack.back(1).Uint64WithOverflow() if overflow { return GasCosts{}, ErrGasUintOverflow } @@ -299,7 +299,7 @@ func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memoryS if err != nil { return GasCosts{}, err } - wordGas, overflow := stack.Back(2).Uint64WithOverflow() + wordGas, overflow := stack.back(2).Uint64WithOverflow() if overflow { return GasCosts{}, ErrGasUintOverflow } @@ -317,7 +317,7 @@ func gasCreateEip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m if err != nil { return GasCosts{}, err } - size, overflow := stack.Back(2).Uint64WithOverflow() + size, overflow := stack.back(2).Uint64WithOverflow() if overflow { return GasCosts{}, ErrGasUintOverflow } @@ -336,7 +336,7 @@ func gasCreate2Eip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, if err != nil { return GasCosts{}, err } - size, overflow := stack.Back(2).Uint64WithOverflow() + size, overflow := stack.back(2).Uint64WithOverflow() if overflow { return GasCosts{}, ErrGasUintOverflow } @@ -352,7 +352,7 @@ func gasCreate2Eip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, } func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { - expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) + expByteLen := uint64((stack.back(1).BitLen() + 7) / 8) var ( gas = expByteLen * params.ExpByteFrontier // no overflow check required. Max is 256 * ExpByte gas @@ -365,7 +365,7 @@ func gasExpFrontier(evm *EVM, contract *Contract, stack *Stack, mem *Memory, mem } func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { - expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) + expByteLen := uint64((stack.back(1).BitLen() + 7) / 8) var ( gas = expByteLen * params.ExpByteEIP158 // no overflow check required. Max is 256 * ExpByte gas @@ -390,7 +390,7 @@ func makeCallVariantGasCost(intrinsicFunc gasFunc) gasFunc { if err != nil { return GasCosts{}, err } - evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsic.RegularGas, stack.Back(0)) + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsic.RegularGas, stack.back(0)) if err != nil { return GasCosts{}, err } @@ -405,8 +405,8 @@ func makeCallVariantGasCost(intrinsicFunc gasFunc) gasFunc { 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.readOnly && transfersValue { return GasCosts{}, ErrWriteProtection @@ -453,7 +453,7 @@ func gasCallCodeIntrinsic(evm *EVM, contract *Contract, stack *Stack, mem *Memor 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 { @@ -487,7 +487,7 @@ func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me // 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 diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 3311af0d22..4b05092cc7 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -24,7 +24,6 @@ import ( "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) { @@ -244,7 +243,7 @@ func opKeccak256(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } 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 } @@ -256,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 } @@ -282,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 } @@ -305,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 } @@ -338,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 } @@ -416,7 +415,7 @@ func opExtCodeHash(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { } func opGasprice(pc *uint64, evm *EVM, scope *ScopeContext) ([]byte, error) { - scope.Stack.push(evm.GasPrice.Clone()) + scope.Stack.get().Set(evm.GasPrice) return nil, nil } @@ -451,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 } @@ -556,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.RegularGas)) + scope.Stack.get().SetUint64(scope.Contract.Gas.RegularGas) return nil, nil } @@ -1007,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 } @@ -1034,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 } @@ -1067,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 } @@ -1106,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 } @@ -1121,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 @@ -1142,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 dbe055f2ac..354d2ce5ab 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -25,6 +25,7 @@ import ( "os" "strings" "testing" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -98,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) ) @@ -109,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() @@ -196,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 { @@ -239,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)) @@ -282,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)) @@ -519,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) @@ -542,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) @@ -561,7 +579,7 @@ 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} @@ -600,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) @@ -672,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 @@ -701,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())) @@ -741,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())) @@ -844,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, " ", "")) @@ -907,7 +925,7 @@ func TestPush(t *testing.T) { scope := &ScopeContext{ Memory: nil, - Stack: newstack(), + Stack: newStackForTesting(), Contract: &Contract{ Code: code, }, @@ -988,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 @@ -1111,7 +1129,7 @@ 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 @@ -1189,8 +1207,9 @@ func TestEIP8024_Execution(t *testing.T) { 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)) diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index 9dc0a0b787..4c278fc857 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -116,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, @@ -140,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 diff --git a/core/vm/interpreter_test.go b/core/vm/interpreter_test.go index 69c2316907..868cb12d04 100644 --- a/core/vm/interpreter_test.go +++ b/core/vm/interpreter_test.go @@ -83,7 +83,7 @@ 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, NewGasBudget(startGas), nil) ) diff --git a/core/vm/memory_table.go b/core/vm/memory_table.go index 63ad967850..8f30cbeee6 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/operations_acl.go b/core/vm/operations_acl.go index 313d03819e..86ac262a93 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -37,7 +37,7 @@ func makeGasSStoreFunc(clearingRefund uint64) gasFunc { } // 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) @@ -158,7 +158,7 @@ func gasEip2929AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Mem func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) gasFunc { return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (GasCosts, error) { - addr := common.Address(stack.Back(addressPosition).Bytes20()) + 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 @@ -269,7 +269,7 @@ func gasCallEIP7702(evm *EVM, contract *Contract, stack *Stack, mem *Memory, mem // 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() + transfersValue := !stack.back(2).IsZero() if evm.readOnly && transfersValue { return GasCosts{}, ErrWriteProtection } @@ -281,7 +281,7 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { var ( eip2929Cost uint64 eip7702Cost uint64 - addr = common.Address(stack.Back(1).Bytes20()) + addr = common.Address(stack.back(1).Bytes20()) ) // Perform EIP-2929 checks (stateless), checking address presence // in the accessList and charge the cold access accordingly. @@ -330,7 +330,7 @@ func makeCallVariantGasCallEIP7702(intrinsicFunc gasFunc) gasFunc { } // 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)) + evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas.RegularGas, intrinsicCost.RegularGas, stack.back(0)) if err != nil { return GasCosts{}, err } diff --git a/core/vm/operations_verkle.go b/core/vm/operations_verkle.go index d57f2c4dcf..4d3960a174 100644 --- a/core/vm/operations_verkle.go +++ b/core/vm/operations_verkle.go @@ -56,7 +56,7 @@ func gasExtCodeHash4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, func makeCallVariantGasEIP4762(oldCalculator gasFunc, withTransferCosts bool) gasFunc { 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,7 +64,7 @@ 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() { + 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 @@ -168,8 +168,8 @@ func gasCodeCopyEip4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, 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 { diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go index 40fb770454..bc2ffd622d 100644 --- a/core/vm/runtime/runtime_test.go +++ b/core/vm/runtime/runtime_test.go @@ -959,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 879dc9aa6d..d8000bc86d 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) -} - -func returnStack(s *Stack) { - s.data = s.data[:0] - stackPool.Put(s) +// 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 } // Data returns the underlying uint256.Int array. -func (st *Stack) Data() []uint256.Int { - return st.data +func (s *Stack) Data() []uint256.Int { + return s.inner.data[s.bottom : s.bottom+s.size] } -func (st *Stack) push(d *uint256.Int) { - // NOTE push limit (1024) is checked in baseCheck - st.data = append(st.data, *d) +func (s *Stack) push(d *uint256.Int) { + elem := s.get() + *elem = *d } -func (st *Stack) pop() (ret uint256.Int) { - ret = st.data[len(st.data)-1] - st.data = st.data[:len(st.data)-1] - return +// 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) len() int { - return len(st.data) +func (s *Stack) pop() uint256.Int { + s.inner.top-- + s.size-- + return s.inner.data[s.inner.top] } -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 (st *Stack) swap2() { - st.data[st.len()-3], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (st *Stack) swap4() { - st.data[st.len()-5], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (st *Stack) swap6() { - st.data[st.len()-7], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (st *Stack) swap8() { - st.data[st.len()-9], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (st *Stack) swap10() { - st.data[st.len()-11], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (st *Stack) swap12() { - st.data[st.len()-13], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (st *Stack) swap14() { - st.data[st.len()-15], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-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 (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) len() int { + return s.size } -func (st *Stack) dup(n int) { - st.push(&st.data[st.len()-n]) +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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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) peek() *uint256.Int { - return &st.data[st.len()-1] +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++ } -// Back returns the n'th item in stack -func (st *Stack) Back(n int) *uint256.Int { - return &st.data[st.len()-n-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 (s *Stack) back(n int) *uint256.Int { + return &s.inner.data[s.bottom+s.size-n-1] } diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index ad6491fd93..efb089d456 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -244,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 diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 7467e1e590..a806a4fc56 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -247,6 +247,7 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, // 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{}) + defer evm.Release() if beaconRoot := block.BeaconRoot(); beaconRoot != nil { core.ProcessBeaconBlockRoot(*beaconRoot, evm) } diff --git a/eth/tracers/api.go b/eth/tracers/api.go index b5ddc78a10..dae11b81de 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -379,6 +379,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed if api.backend.ChainConfig().IsPrague(next.Number(), next.Time()) { core.ProcessParentBlockHash(next.ParentHash(), evm) } + 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 @@ -524,6 +525,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config deleteEmptyObjects = chainConfig.IsEIP158(block.Number()) ) evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{}) + defer evm.Release() if beaconRoot := block.BeaconRoot(); beaconRoot != nil { core.ProcessBeaconBlockRoot(*beaconRoot, evm) } @@ -584,6 +586,7 @@ 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{}) + defer evm.Release() if beaconRoot := block.BeaconRoot(); beaconRoot != nil { core.ProcessBeaconBlockRoot(*beaconRoot, evm) } @@ -673,6 +676,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 { @@ -758,6 +762,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block } evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{}) + defer evm.Release() if beaconRoot := block.BeaconRoot(); beaconRoot != nil { core.ProcessBeaconBlockRoot(*beaconRoot, evm) } @@ -805,6 +810,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block tracer.OnTxStart(evm.GetVMContext(), tx, msg.From) } _, err = core.ApplyMessage(evm, msg, nil) + evm.Release() if writer != nil { writer.Flush() } @@ -817,7 +823,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 { @@ -999,6 +1005,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) } diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 149e12c5b8..e8669b86c6 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -775,6 +775,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) } @@ -1390,6 +1391,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH evm.Context.BlobBaseFee = new(big.Int) } 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) } diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index d18561760e..e3a14bf5d6 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -312,6 +312,7 @@ 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 { diff --git a/miner/worker.go b/miner/worker.go index ae5d6c306f..158f1b26c0 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -83,6 +83,9 @@ func (env *environment) txFitsSize(tx *types.Transaction) bool { // discard terminates the background threads before discarding it. func (env *environment) discard() { env.state.StopPrefetcher() + if env.evm != nil { + env.evm.Release() + } } const ( From b5d9c8d1c2745256b6fb45e1108758720cc4868b Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Tue, 28 Apr 2026 19:10:15 +0800 Subject: [PATCH 122/183] core: implement BAL reader for prefetching (#33737) --- core/state/reader_eip_7928.go | 247 +++++++++++++++++++++++++++++ core/state/reader_eip_7928_test.go | 145 +++++++++++++++++ 2 files changed, 392 insertions(+) create mode 100644 core/state/reader_eip_7928.go create mode 100644 core/state/reader_eip_7928_test.go diff --git a/core/state/reader_eip_7928.go b/core/state/reader_eip_7928.go new file mode 100644 index 0000000000..ff315ac5eb --- /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 0000000000..b2d432258c --- /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) + } + } +} From 0c0d299c52c84141ad1f8ee5ea56df0003739afb Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 28 Apr 2026 20:33:40 +0800 Subject: [PATCH 123/183] core/state: opt stateObject.GetState (#34825) --- core/state/state_object.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/core/state/state_object.go b/core/state/state_object.go index 264dfd920d..8e72486825 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -162,8 +162,11 @@ func (s *stateObject) getPrefetchedTrie() Trie { // 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 From db8d6abced13e81b9a493d5a315164d3cbc9872f Mon Sep 17 00:00:00 2001 From: Miki Noir Date: Tue, 28 Apr 2026 14:36:01 +0100 Subject: [PATCH 124/183] accounts/keystore: enable fsnotify watcher on linux/arm64 (#34834) --- accounts/keystore/watch.go | 4 ++-- accounts/keystore/watch_fallback.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/accounts/keystore/watch.go b/accounts/keystore/watch.go index 1bef321cd1..e2fcd1871a 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 e3c133b3f6..ee1b989e63 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. From 01036bed831186d892a3e3e35b32fcf304d4cc29 Mon Sep 17 00:00:00 2001 From: Giulio rebuffo Date: Tue, 28 Apr 2026 17:25:16 +0200 Subject: [PATCH 125/183] core: skip tx gas cap after Amsterdam (#34841) EIP-7825 caps the transaction gas limit at `MaxTxGas`, but after Amsterdam/EIP-8037 the transaction gas limit can include state gas reservoir in addition to the regular gas dimension. Applying the Osaka cap to the full `tx.Gas()` rejects otherwise valid Amsterdam transactions that need more than `MaxTxGas` total gas because of state gas, while their regular gas use remains within the intended limit. This changes geth to stop applying the full transaction gas cap once Amsterdam is active: - txpool stateless validation no longer rejects `tx.Gas() > MaxTxGas` under Amsterdam - legacy pool reorg cleanup does not purge high-total-gas transactions at the Osaka transition if Amsterdam is also active - execution precheck mirrors the txpool behavior and does not reject high-total-gas messages under Amsterdam The block gas limit check remains in place, so transactions still cannot request more total gas than the current block gas limit. Validation run: ``` go test ./core/txpool ./core/txpool/legacypool go test ./core -run TestStateProcessorErrors ``` --------- Co-authored-by: Gary Rong --- cmd/evm/internal/t8ntool/transaction.go | 4 +++- core/state_transition.go | 3 ++- core/txpool/legacypool/legacypool.go | 6 ++++-- core/txpool/validation.go | 2 +- eth/gasestimator/gasestimator.go | 8 ++++---- miner/worker.go | 2 +- 6 files changed, 15 insertions(+), 10 deletions(-) diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go index ad89876601..7e068c06af 100644 --- a/cmd/evm/internal/t8ntool/transaction.go +++ b/cmd/evm/internal/t8ntool/transaction.go @@ -185,7 +185,9 @@ func Transaction(ctx *cli.Context) error { } } - 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) diff --git a/core/state_transition.go b/core/state_transition.go index c3ebffd060..c7b0593857 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -344,9 +344,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 diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index 78a0161c41..00630de04c 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -1222,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 { diff --git a/core/txpool/validation.go b/core/txpool/validation.go index 85bf65ac40..6891dc94d2 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -92,7 +92,7 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types 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 diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index efb089d456..ace0752037 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -63,10 +63,10 @@ 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 { - if opts.Config.IsOsaka(opts.Header.Number, opts.Header.Time) { - 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. diff --git a/miner/worker.go b/miner/worker.go index 158f1b26c0..42e3695025 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -563,7 +563,7 @@ func (miner *Miner) fillTransactions(ctx context.Context, interrupt *atomic.Int3 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 From 75a64ee3413ef324641b9306efdb5d57e8a01cf8 Mon Sep 17 00:00:00 2001 From: Bosul Mun Date: Thu, 30 Apr 2026 17:55:26 +0200 Subject: [PATCH 126/183] eth/downloader: drop peers sending invalid bodies or receipts (#34745) - Fixes an error shadowing issue in the deliver() function, where a stale result from GetDeliverySlot caused the original failure to be overwritten by errStaleDelivery. - Adds errInvalidBody and errInvalidReceipt to the downloader error checks to properly drop peers who sent invalid responses. --------- Co-authored-by: Felix Lange --- eth/downloader/downloader_test.go | 35 ++++++++++++++++++- eth/downloader/fetchers_concurrent.go | 49 +++++++++++++++++---------- eth/downloader/queue.go | 29 ++++++++-------- 3 files changed, 80 insertions(+), 33 deletions(-) diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go index 9280d455fb..6d5d159631 100644 --- a/eth/downloader/downloader_test.go +++ b/eth/downloader/downloader_test.go @@ -96,6 +96,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 @@ -121,8 +122,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 { @@ -236,6 +240,11 @@ 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, } @@ -248,10 +257,16 @@ func (dlp *downloadTesterPeer) RequestBodies(hashes []common.Hash, sink chan *et 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 } @@ -704,3 +719,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/fetchers_concurrent.go b/eth/downloader/fetchers_concurrent.go index 9d8cd114c1..51bf3404bd 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/queue.go b/eth/downloader/queue.go index c0cb9b174a..dd17b7f1ed 100644 --- a/eth/downloader/queue.go +++ b/eth/downloader/queue.go @@ -671,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 @@ -686,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] { if res, stale, err := q.resultCache.GetDeliverySlot(header.Number.Uint64()); err == nil && !stale { reconstruct(accepted, 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 From 19dc690af86278b4e84fd3d7eee9fd810bcbac25 Mon Sep 17 00:00:00 2001 From: cui Date: Fri, 1 May 2026 00:24:22 +0800 Subject: [PATCH 127/183] triedb/pathdb: fix layer 5 key range in account iterator traversal test (#34639) The layer-5 diff condition used `i > 50 || i < 85`, which is true for almost all keys in the 0..255 loop. Use `i > 50 && i < 85` so layer 5 only covers the intended band (51..84), consistent with the snapshot iterator test fix. --- triedb/pathdb/iterator_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/triedb/pathdb/iterator_test.go b/triedb/pathdb/iterator_test.go index adb534f47d..2197e85272 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 { From 68646229a0275acb18fceef83bf1733ced88ef00 Mon Sep 17 00:00:00 2001 From: cui Date: Fri, 1 May 2026 20:10:41 +0800 Subject: [PATCH 128/183] internal/era/onedb: return false if err (#34816) Next() function in RawIterator returned true on decompression errors.Now it returns false on those cases. Redundant error check on cmd/era/main.go is also removed. --------- Co-authored-by: Bosul Mun --- cmd/era/main.go | 3 --- internal/era/onedb/iterator.go | 8 ++++---- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/cmd/era/main.go b/cmd/era/main.go index 1c26f44ad4..43279e7001 100644 --- a/cmd/era/main.go +++ b/cmd/era/main.go @@ -337,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) diff --git a/internal/era/onedb/iterator.go b/internal/era/onedb/iterator.go index b80fbabbc5..21dc5acbe0 100644 --- a/internal/era/onedb/iterator.go +++ b/internal/era/onedb/iterator.go @@ -156,22 +156,22 @@ func (it *RawIterator) Next() bool { var n int64 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, era.TypeCompressedBody, off); it.err != nil { it.clear() - return true + return false } off += n 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(era.TypeTotalDifficulty, off); it.err != nil { it.clear() - return true + return false } it.next += 1 return true From a15778c52f3f5e5922d6ecd29bf62df500733c6b Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Fri, 1 May 2026 15:28:19 +0200 Subject: [PATCH 129/183] trie: group 2^N binary trie nodes in serialization (#34794) This PR addresses one of the biggest performance issue with binary tries: storing each internal node individually bloats the index, the disk, and triggers a lot of write amplifications. To fix this issue, this PR serializes groups of nodes together. Because we are still looking for the ideal group size, the "depth" of the group tree is made a parameter, but that will be removed in the future, once the perfect size is known. This is a rebase of #33658 --------- Co-authored-by: Copilot --- cmd/evm/internal/t8ntool/transition.go | 8 +- cmd/geth/bintrie_convert.go | 4 +- cmd/geth/bintrie_convert_test.go | 8 +- cmd/geth/main.go | 1 + cmd/utils/flags.go | 10 + core/bintrie_witness_test.go | 2 + core/blockchain.go | 12 +- core/genesis.go | 5 +- core/genesis_test.go | 29 +-- core/state/database_ubt.go | 2 +- core/state/reader.go | 2 +- eth/backend.go | 1 + eth/ethconfig/config.go | 7 + eth/ethconfig/gen_config.go | 6 + trie/bintrie/binary_node.go | 11 + trie/bintrie/binary_node_test.go | 48 +++-- trie/bintrie/hashed_node_test.go | 2 +- trie/bintrie/internal_node_test.go | 7 +- trie/bintrie/iterator.go | 2 +- trie/bintrie/stem_node_test.go | 5 +- trie/bintrie/store_commit.go | 285 ++++++++++++++++++++----- trie/bintrie/trie.go | 38 ++-- trie/bintrie/trie_test.go | 5 +- triedb/database.go | 24 ++- triedb/pathdb/journal.go | 14 +- 25 files changed, 402 insertions(+), 136 deletions(-) diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index e0bb3a449d..89b703d3b8 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -546,7 +546,7 @@ func BinKeys(ctx *cli.Context) error { 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) } @@ -590,7 +590,7 @@ func BinTrieRoot(ctx *cli.Context) error { 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) } @@ -600,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/geth/bintrie_convert.go b/cmd/geth/bintrie_convert.go index 43d2e629ac..46cb3aa7e4 100644 --- a/cmd/geth/bintrie_convert.go +++ b/cmd/geth/bintrie_convert.go @@ -151,7 +151,7 @@ func convertToBinaryTrie(ctx *cli.Context) error { }) defer destTriedb.Close() - binTrie, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) + 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) } @@ -319,7 +319,7 @@ func commitBinaryTrie(bt *bintrie.BinaryTrie, currentRoot common.Hash, destDB *t runtime.GC() debug.FreeOSMemory() - bt, err := bintrie.NewBinaryTrie(newRoot, destDB) + bt, err := bintrie.NewBinaryTrie(newRoot, destDB, bt.GroupDepth()) if err != nil { return nil, common.Hash{}, fmt.Errorf("failed to reload binary trie: %w", err) } diff --git a/cmd/geth/bintrie_convert_test.go b/cmd/geth/bintrie_convert_test.go index 50ae752358..32e8c7e55b 100644 --- a/cmd/geth/bintrie_convert_test.go +++ b/cmd/geth/bintrie_convert_test.go @@ -87,7 +87,7 @@ func TestBintrieConvert(t *testing.T) { }) defer destTriedb.Close() - bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb, 8) if err != nil { t.Fatalf("failed to create binary trie: %v", err) } @@ -98,7 +98,7 @@ func TestBintrieConvert(t *testing.T) { } t.Logf("Binary trie root: %x", currentRoot) - bt2, err := bintrie.NewBinaryTrie(currentRoot, destTriedb) + bt2, err := bintrie.NewBinaryTrie(currentRoot, destTriedb, 8) if err != nil { t.Fatalf("failed to reload binary trie: %v", err) } @@ -194,7 +194,7 @@ func TestBintrieConvertDeleteSource(t *testing.T) { PathDB: pathdb.Defaults, }) - bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb) + bt, err := bintrie.NewBinaryTrie(types.EmptyBinaryHash, destTriedb, 8) if err != nil { t.Fatalf("failed to create binary trie: %v", err) } @@ -209,7 +209,7 @@ func TestBintrieConvertDeleteSource(t *testing.T) { } srcTriedb2.Close() - bt2, err := bintrie.NewBinaryTrie(newRoot, destTriedb) + bt2, err := bintrie.NewBinaryTrie(newRoot, destTriedb, 8) if err != nil { t.Fatalf("failed to reload binary trie after deletion: %v", err) } diff --git a/cmd/geth/main.go b/cmd/geth/main.go index ae869ec970..c8d7abc65b 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -95,6 +95,7 @@ var ( utils.StateHistoryFlag, utils.TrienodeHistoryFlag, utils.TrienodeHistoryFullValueCheckpointFlag, + utils.BinTrieGroupDepthFlag, utils.LightKDFFlag, utils.EthRequiredBlocksFlag, utils.LegacyWhitelistFlag, // deprecated diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 9d996f15cb..cc4c3bff5c 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -297,6 +297,12 @@ 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, + } 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)", @@ -1817,6 +1823,9 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) { 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) } @@ -2433,6 +2442,7 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh 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, diff --git a/core/bintrie_witness_test.go b/core/bintrie_witness_test.go index 1b033151d3..66feef0675 100644 --- a/core/bintrie_witness_test.go +++ b/core/bintrie_witness_test.go @@ -92,6 +92,7 @@ func TestProcessUBT(t *testing.T) { // 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() @@ -218,6 +219,7 @@ func TestProcessParentBlockHash(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.EmptyBinaryHash, state.NewDatabase(triedb, nil)) diff --git a/core/blockchain.go b/core/blockchain.go index 296ef6bc16..f21a1462ea 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -170,9 +170,10 @@ 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; @@ -260,8 +261,9 @@ func (cfg BlockChainConfig) WithNoAsyncFlush(on bool) *BlockChainConfig { // triedbConfig derives the configures for trie database. func (cfg *BlockChainConfig) triedbConfig(isUBT bool) *triedb.Config { config := &triedb.Config{ - Preimages: cfg.Preimages, - IsUBT: isUBT, + Preimages: cfg.Preimages, + IsUBT: isUBT, + BinTrieGroupDepth: cfg.BinTrieGroupDepth, } if cfg.StateScheme == rawdb.HashScheme { config.HashDB = &hashdb.Config{ diff --git a/core/genesis.go b/core/genesis.go index d77ea10d8c..6a0affa52e 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -136,8 +136,9 @@ func hashAlloc(ga *types.GenesisAlloc, isUBT bool) (common.Hash, error) { var config *triedb.Config if isUBT { config = &triedb.Config{ - PathDB: pathdb.Defaults, - IsUBT: true, + PathDB: pathdb.Defaults, + IsUBT: true, + BinTrieGroupDepth: triedb.UBTDefaults.BinTrieGroupDepth, } } // Create an ephemeral in-memory database for computing hash, diff --git a/core/genesis_test.go b/core/genesis_test.go index e15ad00222..94f1b3a4fd 100644 --- a/core/genesis_test.go +++ b/core/genesis_test.go @@ -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,11 +281,11 @@ func TestVerkleGenesisCommit(t *testing.T) { ArrowGlacierBlock: big.NewInt(0), GrayGlacierBlock: big.NewInt(0), MergeNetsplitBlock: nil, - ShanghaiTime: &verkleTime, - CancunTime: &verkleTime, - PragueTime: &verkleTime, - OsakaTime: &verkleTime, - UBTTime: &verkleTime, + ShanghaiTime: &ubtTime, + CancunTime: &ubtTime, + PragueTime: &ubtTime, + OsakaTime: &ubtTime, + UBTTime: &ubtTime, TerminalTotalDifficulty: big.NewInt(0), EnableUBTAtGenesis: true, Ethash: nil, @@ -300,8 +300,8 @@ func TestVerkleGenesisCommit(t *testing.T) { 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}}}, @@ -320,17 +320,18 @@ func TestVerkleGenesisCommit(t *testing.T) { config.NoAsyncFlush = true triedb := triedb.NewDatabase(db, &triedb.Config{ - IsUBT: 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 + // Test that the trie is a unified binary trie if !triedb.IsUBT() { - t.Fatalf("expected trie to be verkle") + 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/state/database_ubt.go b/core/state/database_ubt.go index 718d93df87..16579f6d6a 100644 --- a/core/state/database_ubt.go +++ b/core/state/database_ubt.go @@ -96,7 +96,7 @@ func (db *UBTDatabase) ReadersWithCacheStats(stateRoot common.Hash) (Reader, Rea // 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) + return bintrie.NewBinaryTrie(root, db.triedb, db.triedb.BinTrieGroupDepth()) } // OpenStorageTrie opens the storage trie of an account. In binary trie mode, diff --git a/core/state/reader.go b/core/state/reader.go index 5df0acbb9b..be07cec0f9 100644 --- a/core/state/reader.go +++ b/core/state/reader.go @@ -255,7 +255,7 @@ type ubtTrieReader struct { // 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) + binTrie, binErr := bintrie.NewBinaryTrie(root, db, db.BinTrieGroupDepth()) if binErr != nil { return nil, binErr } diff --git a/eth/backend.go b/eth/backend.go index 08a3c70c9d..6cfd1f6fa0 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -237,6 +237,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) { StateHistory: config.StateHistory, TrienodeHistory: config.TrienodeHistory, NodeFullValueCheckpoint: config.NodeFullValueCheckpoint, + BinTrieGroupDepth: config.BinTrieGroupDepth, StateScheme: scheme, HistoryPolicy: histPolicy, TxLookupLimit: int64(min(config.TransactionHistory, math.MaxInt64)), diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go index dd7436bf52..b51b78e199 100644 --- a/eth/ethconfig/config.go +++ b/eth/ethconfig/config.go @@ -35,6 +35,7 @@ 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" ) @@ -59,6 +60,7 @@ var Defaults = Config{ StateHistory: pathdb.Defaults.StateHistory, TrienodeHistory: pathdb.Defaults.TrienodeHistory, NodeFullValueCheckpoint: pathdb.Defaults.FullValueCheckpoint, + BinTrieGroupDepth: triedb.DefaultBinTrieGroupDepth, DatabaseCache: 2048, TrieCleanCache: 614, TrieDirtyCache: 1024, @@ -125,6 +127,11 @@ type Config struct { // 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. diff --git a/eth/ethconfig/gen_config.go b/eth/ethconfig/gen_config.go index ed85562f44..c5e45348be 100644 --- a/eth/ethconfig/gen_config.go +++ b/eth/ethconfig/gen_config.go @@ -34,6 +34,7 @@ func (c Config) MarshalTOML() (interface{}, error) { 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:"-"` @@ -87,6 +88,7 @@ func (c Config) MarshalTOML() (interface{}, error) { 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 @@ -144,6 +146,7 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { 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:"-"` @@ -234,6 +237,9 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { if dec.StateScheme != nil { c.StateScheme = *dec.StateScheme } + if dec.BinTrieGroupDepth != nil { + c.BinTrieGroupDepth = *dec.BinTrieGroupDepth + } if dec.RequiredBlocks != nil { c.RequiredBlocks = dec.RequiredBlocks } diff --git a/trie/bintrie/binary_node.go b/trie/bintrie/binary_node.go index e7f57d45a2..3516bf6bd5 100644 --- a/trie/bintrie/binary_node.go +++ b/trie/bintrie/binary_node.go @@ -27,8 +27,19 @@ const ( 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) + + MaxGroupDepth = 8 ) +// 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) +} + const ( nodeTypeStem = iota + 1 nodeTypeInternal diff --git a/trie/bintrie/binary_node_test.go b/trie/bintrie/binary_node_test.go index 12ac199903..857060a0c0 100644 --- a/trie/bintrie/binary_node_test.go +++ b/trie/bintrie/binary_node_test.go @@ -23,8 +23,8 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestSerializeDeserializeInternalNode tests flat 65-byte serialization and -// deserialization of InternalNode through nodeStore. +// TestSerializeDeserializeInternalNode tests grouped serialization and +// deserialization of InternalNode through nodeStore at groupDepth=1. func TestSerializeDeserializeInternalNode(t *testing.T) { leftHash := common.HexToHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef") rightHash := common.HexToHash("0xfedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321") @@ -39,24 +39,32 @@ func TestSerializeDeserializeInternalNode(t *testing.T) { rootNode.right = rightRef s.root = rootRef - // Serialize the node — flat 65-byte format - serialized := s.serializeNode(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: [type(1)][leftHash(32)][rightHash(32)] 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]) + } - expectedLen := NodeTypeBytes + 2*HashSize // 1 + 64 = 65 + 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)) } - // Check that left and right hashes are embedded directly - if !bytes.Equal(serialized[NodeTypeBytes:NodeTypeBytes+HashSize], leftHash[:]) { + // 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[NodeTypeBytes+HashSize:], rightHash[:]) { + if !bytes.Equal(serialized[hashesStart+HashSize:], rightHash[:]) { t.Error("Right hash not found at expected position") } @@ -116,7 +124,7 @@ func TestSerializeDeserializeStemNode(t *testing.T) { } // Serialize the node - serialized := s.serializeNode(ref) + serialized := s.serializeNode(ref, 8) // Check the serialized format if serialized[0] != nodeTypeStem { @@ -195,8 +203,9 @@ func TestDeserializeInvalidType(t *testing.T) { // TestDeserializeInvalidLength tests deserialization with invalid data length. func TestDeserializeInvalidLength(t *testing.T) { s := newNodeStore() - // InternalNode with valid type byte but wrong length (needs exactly 65 bytes) - invalidData := []byte{nodeTypeInternal, 0, 0, 0} + // 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 := s.deserializeNode(invalidData, 0) if err == nil { @@ -208,6 +217,21 @@ func TestDeserializeInvalidLength(t *testing.T) { } } +// 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 { diff --git a/trie/bintrie/hashed_node_test.go b/trie/bintrie/hashed_node_test.go index ae77b7c570..2e12bfba5e 100644 --- a/trie/bintrie/hashed_node_test.go +++ b/trie/bintrie/hashed_node_test.go @@ -95,7 +95,7 @@ func TestHashedNodeInsertValuesAtStem(t *testing.T) { sn.setValue(byte(i), v) } } - serialized := rs.serializeNode(ref) + serialized := rs.serializeNode(ref, 8) validResolver := func(path []byte, hash common.Hash) ([]byte, error) { return serialized, nil diff --git a/trie/bintrie/internal_node_test.go b/trie/bintrie/internal_node_test.go index 8d5a75de8c..4d8da8af37 100644 --- a/trie/bintrie/internal_node_test.go +++ b/trie/bintrie/internal_node_test.go @@ -90,7 +90,7 @@ func TestInternalNodeGetWithResolver(t *testing.T) { ref := rs.newStemRef(stem, 1) sn := rs.getStem(ref.Index()) sn.setValue(5, common.HexToHash("0xabcd").Bytes()) - return rs.serializeNode(ref), nil + return rs.serializeNode(ref, 8), nil } return nil, errors.New("node not found") } @@ -290,10 +290,7 @@ func TestInternalNodeCollectNodes(t *testing.T) { collectedPaths = append(collectedPaths, pathCopy) } - err := s.collectNodes(s.root, []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(collectedPaths) != 3 { diff --git a/trie/bintrie/iterator.go b/trie/bintrie/iterator.go index 31645430c3..a920f91378 100644 --- a/trie/bintrie/iterator.go +++ b/trie/bintrie/iterator.go @@ -205,7 +205,7 @@ func (it *binaryNodeIterator) Path() []byte { } func (it *binaryNodeIterator) NodeBlob() []byte { - return it.store.serializeNode(it.current) + return it.store.serializeNode(it.current, it.trie.groupDepth) } // Leaf reports whether the iterator is currently positioned at a leaf value. diff --git a/trie/bintrie/stem_node_test.go b/trie/bintrie/stem_node_test.go index 5faf903fba..ae6b57ab34 100644 --- a/trie/bintrie/stem_node_test.go +++ b/trie/bintrie/stem_node_test.go @@ -320,10 +320,7 @@ func TestStemNodeCollectNodes(t *testing.T) { collectedPaths = append(collectedPaths, pathCopy) } - err := s.collectNodes(s.root, []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(collectedPaths) != 1 { diff --git a/trie/bintrie/store_commit.go b/trie/bintrie/store_commit.go index 7101087b51..b14bffbc6c 100644 --- a/trie/bintrie/store_commit.go +++ b/trie/bintrie/store_commit.go @@ -107,18 +107,83 @@ func (s *nodeStore) hashInternal(idx uint32) common.Hash { return node.hash } -// SerializeNode serializes a node into the flat on-disk format. -func (s *nodeStore) serializeNode(ref nodeRef) []byte { +// 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()) - var serialized [NodeTypeBytes + HashSize + HashSize]byte + 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 - lh := s.computeHash(node.left) - rh := s.computeHash(node.right) - copy(serialized[NodeTypeBytes:NodeTypeBytes+HashSize], lh[:]) - copy(serialized[NodeTypeBytes+HashSize:], rh[:]) - return serialized[:] + 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()) @@ -163,6 +228,59 @@ func (s *nodeStore) deserializeNodeWithHash(serialized []byte, depth int, hn com 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 @@ -170,31 +288,23 @@ func (s *nodeStore) decodeNode(serialized []byte, depth int, hn common.Hash, mus switch serialized[0] { case nodeTypeInternal: - if len(serialized) != NodeTypeBytes+2*HashSize { + // Grouped format: 1 byte type + 1 byte group depth + variable bitmap + N×32 byte hashes + if len(serialized) < NodeTypeBytes+1 { return emptyRef, errInvalidSerializedLength } - var leftHash, rightHash common.Hash - copy(leftHash[:], serialized[NodeTypeBytes:NodeTypeBytes+HashSize]) - copy(rightHash[:], serialized[NodeTypeBytes+HashSize:]) + 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:] - var leftRef, rightRef nodeRef - if leftHash != (common.Hash{}) { - leftRef = s.newHashedRef(leftHash) - } - if rightHash != (common.Hash{}) { - rightRef = s.newHashedRef(rightHash) - } - - ref := s.newInternalRef(depth) - node := s.getInternal(ref.Index()) - node.left = leftRef - node.right = rightRef - if !mustRecompute { - node.hash = hn - node.mustRecompute = false - } - node.dirty = dirty - return ref, nil + hashIdx := 0 + return s.deserializeSubtree(hn, groupDepth, 0, depth, bitmap, hashData, &hashIdx, mustRecompute, dirty) case nodeTypeStem: if len(serialized) < NodeTypeBytes+StemSize+StemBitmapSize { @@ -230,45 +340,112 @@ func (s *nodeStore) decodeNode(serialized []byte, depth int, hn common.Hash, mus // 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) error { +func (s *nodeStore) collectNodes(ref nodeRef, path []byte, flushfn nodeFlushFn, groupDepth int) { switch ref.Kind() { - case kindEmpty: - return nil case kindInternal: node := s.getInternal(ref.Index()) if !node.dirty { - return nil + return } - // Reuse path buffer across children: flushfn consumers - // (NodeSet.AddNode, tracer.Get) clone via string(path), so in-place - // mutation is safe. - path = append(path, 0) - if err := s.collectNodes(node.left, path, flushfn); err != nil { - return err + // 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 } - path[len(path)-1] = 1 - if err := s.collectNodes(node.right, path, flushfn); err != nil { - return err - } - path = path[:len(path)-1] - flushfn(path, s.computeHash(ref), s.serializeNode(ref)) - node.dirty = false - return nil + // 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 nil + return } - flushfn(path, s.computeHash(ref), s.serializeNode(ref)) + flushfn(path, s.computeHash(ref), s.serializeNode(ref, groupDepth)) sn.dirty = false - return nil - case kindHashed: - return nil // Already committed + case kindHashed, kindEmpty: default: - return fmt.Errorf("CollectNodes: unexpected kind %d", ref.Kind()) + 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: diff --git a/trie/bintrie/trie.go b/trie/bintrie/trie.go index 8c69e0aa00..e3436e3df1 100644 --- a/trie/bintrie/trie.go +++ b/trie/bintrie/trie.go @@ -107,9 +107,14 @@ func ChunkifyCode(code []byte) ChunkedCode { // BinaryTrie is the implementation of https://eips.ethereum.org/EIPS/eip-7864. type BinaryTrie struct { - store *nodeStore - 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. @@ -119,15 +124,20 @@ func (t *BinaryTrie) ToDot() string { } // 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{ - store: newNodeStore(), - 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 { @@ -312,12 +322,9 @@ func (t *BinaryTrie) Commit(_ bool) (common.Hash, *trienode.NodeSet) { // 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) - err := t.store.collectNodes(t.store.root, pathBuf, func(path []byte, hash common.Hash, serialized []byte) { + 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))) - }) - if err != nil { - panic(fmt.Errorf("CollectNodes failed: %v", err)) - } + }, t.groupDepth) return t.Hash(), nodeset } @@ -341,9 +348,10 @@ 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{ - store: t.store.Copy(), - reader: t.reader, - tracer: t.tracer.Copy(), + store: t.store.Copy(), + reader: t.reader, + tracer: t.tracer.Copy(), + groupDepth: t.groupDepth, } } diff --git a/trie/bintrie/trie_test.go b/trie/bintrie/trie_test.go index 73aacb76c4..8b7d9e46d6 100644 --- a/trie/bintrie/trie_test.go +++ b/trie/bintrie/trie_test.go @@ -768,8 +768,9 @@ func TestGetStorageNonMembershipInternalRoot(t *testing.T) { // flushes only the root-to-leaf path. func TestCommitSkipCleanSubtrees(t *testing.T) { tr := &BinaryTrie{ - store: newNodeStore(), - tracer: trie.NewPrevalueTracer(), + store: newNodeStore(), + tracer: trie.NewPrevalueTracer(), + groupDepth: 1, } const n = 200 key := func(i int) [HashSize]byte { diff --git a/triedb/database.go b/triedb/database.go index 533097c9e3..0fd3e1aa91 100644 --- a/triedb/database.go +++ b/triedb/database.go @@ -31,12 +31,15 @@ import ( // Config defines all necessary options for database. type Config struct { - Preimages bool // Flag whether the preimage of node key is recorded - IsUBT 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{ @@ -45,12 +48,13 @@ var HashDefaults = &Config{ HashDB: hashdb.Defaults, } -// UBTDefaults 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 UBTDefaults = &Config{ - Preimages: false, - IsUBT: true, - PathDB: pathdb.Defaults, + Preimages: false, + IsUBT: true, + BinTrieGroupDepth: DefaultBinTrieGroupDepth, + PathDB: pathdb.Defaults, } // backend defines the methods needed to access/update trie nodes in different @@ -393,3 +397,7 @@ func (db *Database) SnapshotCompleted() bool { } return pdb.SnapshotCompleted() } + +func (db *Database) BinTrieGroupDepth() int { + return db.config.BinTrieGroupDepth +} diff --git a/triedb/pathdb/journal.go b/triedb/pathdb/journal.go index efcc3f2549..657fbbff27 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) } From b9c5fe6d26342d625c9a393bef9ccd5209c6d888 Mon Sep 17 00:00:00 2001 From: felipe Date: Fri, 1 May 2026 16:38:33 +0200 Subject: [PATCH 130/183] eth/tracers: fix evm trace for t8n (#34862) The mux tracer fanned out every standard hook to its children but never forwarded OnSystemCall{Start,End}. Tracers that rely on these - like `logger.jsonLogger`, which uses the start hook to silence its opcode hook for the duration of a system call - never got the signal when wrapped behind a mux. In evm t8n, combining `--trace` with `--opcode-count` (default for geth with exec specs) produces exactly that wrapping. The first system call (e.g. `ProcessBeaconBlockRoot`) then fires `OnOpcode` on the json logger before any `OnTxStart` has run, dereferencing a nil env and crashing t8n. Forward both hooks through the mux. The V2 fan-out falls back to V1 for children that only implement the legacy hook, mirroring the precedence already used in `core/state_processor.go`. --- eth/tracers/native/mux.go | 44 ++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 12 deletions(-) diff --git a/eth/tracers/native/mux.go b/eth/tracers/native/mux.go index b7d6f29a6a..362fb24297 100644 --- a/eth/tracers/native/mux.go +++ b/eth/tracers/native/mux.go @@ -67,18 +67,20 @@ func NewMuxTracer(names []string, objects []*tracers.Tracer) (*tracers.Tracer, e 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, + OnGasChange: t.OnGasChange, + OnBalanceChange: t.OnBalanceChange, + OnNonceChange: t.OnNonceChange, + OnCodeChange: t.OnCodeChange, + OnStorageChange: t.OnStorageChange, + OnLog: t.OnLog, + OnSystemCallStartV2: t.OnSystemCallStart, + OnSystemCallEnd: t.OnSystemCallEnd, }, GetResult: t.GetResult, Stop: t.Stop, @@ -189,6 +191,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) From 41b856d472153296c14b145514f202ad3e67c683 Mon Sep 17 00:00:00 2001 From: Richard Creighton Date: Fri, 1 May 2026 19:18:14 +0100 Subject: [PATCH 131/183] ethclient: add maxUsedGas to simulate call results (#34820) This updates the typed `ethclient` model for `eth_simulateV1` call results to include `maxUsedGas`, matching the field already returned by the server-side RPC response. Follow-up to #32789. --- ethclient/ethclient.go | 2 ++ ethclient/ethclient_test.go | 6 ++++++ ethclient/gen_simulate_call_result.go | 6 ++++++ 3 files changed, 14 insertions(+) diff --git a/ethclient/ethclient.go b/ethclient/ethclient.go index 412f8955ba..1d8573f982 100644 --- a/ethclient/ethclient.go +++ b/ethclient/ethclient.go @@ -914,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"` } @@ -921,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 f9e761e412..fb04d77669 100644 --- a/ethclient/ethclient_test.go +++ b/ethclient/ethclient_test.go @@ -861,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 55e14cd697..18373bbb88 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) } From d270e211d1bfdee7e1a4f9f03b0898327636f85a Mon Sep 17 00:00:00 2001 From: cui Date: Sat, 2 May 2026 02:22:48 +0800 Subject: [PATCH 132/183] core/state/snapshot: fix condition in iterator traversal test (#34638) Fixes a condition in a snapshot-related test. --- core/state/snapshot/iterator_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/state/snapshot/iterator_test.go b/core/state/snapshot/iterator_test.go index a95bd66dde..8e473aa312 100644 --- a/core/state/snapshot/iterator_test.go +++ b/core/state/snapshot/iterator_test.go @@ -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 { From 8656efcf5b2bf1e377fe162489d52dd09afac2e4 Mon Sep 17 00:00:00 2001 From: hero5512 Date: Fri, 1 May 2026 14:27:57 -0400 Subject: [PATCH 133/183] ethclient/simulated: disable log indexing by default (#32594) Disables the recently added log indexer from a simulated backend. In most cases the log indexer is not required and unindexed search should be fast enough. Fixes https://github.com/ethereum/go-ethereum/issues/32552. --- ethclient/simulated/backend.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ethclient/simulated/backend.go b/ethclient/simulated/backend.go index d573c7e750..160ad924bf 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) From 7155c65abbeec23981ea10ecdbeb1a661426e934 Mon Sep 17 00:00:00 2001 From: rayoo Date: Sat, 2 May 2026 02:32:49 +0800 Subject: [PATCH 134/183] internal/ethapi: apply block overrides to header in eth_call (#34842) Apply block overrides to header in eth_call so EIP-1559 fee fields use the correct overridden basefee. --- internal/ethapi/api.go | 4 ++++ internal/ethapi/api_test.go | 21 +++++++++++++++++++++ 2 files changed, 25 insertions(+) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index e8669b86c6..6fc43a370b 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -734,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) diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go index 6cf52d636a..161d97b4eb 100644 --- a/internal/ethapi/api_test.go +++ b/internal/ethapi/api_test.go @@ -1315,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) From f0b21fa11061d3f46de621e38cbbc82c1dc2f819 Mon Sep 17 00:00:00 2001 From: Rahman Date: Sat, 2 May 2026 05:29:21 -0600 Subject: [PATCH 135/183] core/txpool/blobpool: fix gapped queue size cap (#34831) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit the gapped queue cap was effectively per-sender rather than total — a sender pool spread across enough distinct addresses could grow `p.gapped` well past `maxGapped`, defeating the resource bound. `maxGapped` was being compared against `len(p.gapped)`, which is a `map[address][]tx` and counts unique senders, not queued txs. Switched the check to `len(p.gappedSource)` (keyed by tx hash, so its length is the real total). Also wired up a `blobpool/gapped/count` gauge plus `promoted`, `evicted`, and `gappedfull` meters so queue size and churn are actually observable in prod. --- core/txpool/blobpool/blobpool.go | 12 +++++++++--- core/txpool/blobpool/metrics.go | 6 ++++++ 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index 4030a0c339..efa41a0649 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -1596,9 +1596,10 @@ func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (err error // Store the tx in memory, and revalidate later from, _ := types.Sender(p.signer, tx) allowance := p.gappedAllowance(from) - if allowance >= 1 && len(p.gapped) < maxGapped { + 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 { @@ -1606,6 +1607,7 @@ func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (err error // 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): @@ -1791,6 +1793,7 @@ func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (err error // 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) @@ -1802,6 +1805,7 @@ func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (err error } else { p.gapped[from] = gtxs } + gappedGauge.Update(int64(len(p.gappedSource))) } return nil } @@ -2069,8 +2073,9 @@ func (p *BlobPool) evictGapped() { keep = append(keep, gtx) } } - if len(keep) < len(txs) { - log.Trace("Evicting old gapped blob transactions", "count", len(txs)-len(keep), "from", from) + 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) @@ -2078,6 +2083,7 @@ func (p *BlobPool) evictGapped() { p.gapped[from] = keep } } + gappedGauge.Update(int64(len(p.gappedSource))) } // isAnnouncable checks whether a transaction is announcable based on its diff --git a/core/txpool/blobpool/metrics.go b/core/txpool/blobpool/metrics.go index 52419ade09..44e2098b22 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 ) From efd6cdcff111c37bf49aefba0a7376997780a8c8 Mon Sep 17 00:00:00 2001 From: rayoo Date: Tue, 5 May 2026 03:36:26 +0800 Subject: [PATCH 136/183] eth/tracers: forward V2 state hooks through mux tracer (#34869) Fixes the muxTracer to correctly forward events to v2 state hooks, i.e. `OnCodeChangeV2` and `OnNonceChangeV2`. --- eth/tracers/native/mux.go | 26 +++++----- eth/tracers/native/mux_test.go | 87 ++++++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+), 12 deletions(-) create mode 100644 eth/tracers/native/mux_test.go diff --git a/eth/tracers/native/mux.go b/eth/tracers/native/mux.go index 362fb24297..bb2101deec 100644 --- a/eth/tracers/native/mux.go +++ b/eth/tracers/native/mux.go @@ -63,6 +63,12 @@ func newMuxTracerFromConfig(ctx *tracers.Context, cfg json.RawMessage, chainConf // // 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, 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{ @@ -75,8 +81,8 @@ func NewMuxTracer(names []string, objects []*tracers.Tracer) (*tracers.Tracer, e OnFault: t.OnFault, OnGasChange: t.OnGasChange, OnBalanceChange: t.OnBalanceChange, - OnNonceChange: t.OnNonceChange, - OnCodeChange: t.OnCodeChange, + OnNonceChangeV2: t.OnNonceChangeV2, + OnCodeChangeV2: t.OnCodeChangeV2, OnStorageChange: t.OnStorageChange, OnLog: t.OnLog, OnSystemCallStartV2: t.OnSystemCallStart, @@ -151,26 +157,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) } } } diff --git a/eth/tracers/native/mux_test.go b/eth/tracers/native/mux_test.go new file mode 100644 index 0000000000..902b7a026a --- /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) + } +} From d5edb8043824333459a7bd02bcd05868b0d0d997 Mon Sep 17 00:00:00 2001 From: TenderDeve Date: Tue, 5 May 2026 14:59:26 +0530 Subject: [PATCH 137/183] accounts/abi/bind: re-export event signature errors (#34868) Re-exports errors in bind package. --------- Co-authored-by: Marius van der Wijden --- accounts/abi/bind/old.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/accounts/abi/bind/old.go b/accounts/abi/bind/old.go index b09f5f3c7a..1fe1b1cca5 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 From 5b837e578689e7db5679b25d0a159956563f6a93 Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 5 May 2026 18:41:22 +0800 Subject: [PATCH 138/183] eth/downloader: use batch index in deliver reconstruct (#34870) The reconstruct callback indexes parallel response slices (bodies, receipts). Passing the accept counter used the wrong element when an earlier header in the same batch hit a stale slot. --- eth/downloader/queue.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/eth/downloader/queue.go b/eth/downloader/queue.go index dd17b7f1ed..585906b8bd 100644 --- a/eth/downloader/queue.go +++ b/eth/downloader/queue.go @@ -689,9 +689,9 @@ func (q *queue) deliver(id string, taskPool map[common.Hash]*types.Header, 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 { // Between here and above, some other peer filled this result, From 60db25b070d5060a379231e6e0f69c047d0ffcbb Mon Sep 17 00:00:00 2001 From: rayoo Date: Tue, 5 May 2026 21:28:28 +0800 Subject: [PATCH 139/183] p2p/discover: restore nextTimeout update in UDPv4 resetTimeout loop (#34878) The refactor from `for el := plist.Front(); ...; el = el.Next()` to the new `iterList` iterator in #34743 silently dropped two things needed by resetTimeout: 1. `nextTimeout = el.Value.(*replyMatcher)` at the top of the loop. This assignment is what gives `nextTimeout` its documented meaning ("head of plist when timeout was last reset"), and what makes the early-return optimization at the top of resetTimeout work. Without it, nextTimeout is only ever written to nil, so `nextTimeout == plist.Front().Value` is always false and the optimization is dead. 2. `nextTimeout.errc <- errClockWarp` in the clock-warp branch now reads a stale or nil pointer. Prior to the refactor, the inner assignment kept nextTimeout pointing at the current matcher so its errc was the right channel to receive the errClockWarp signal. After the refactor, on first entry into the clock-warp branch nextTimeout is nil, which panics the UDPv4 loop goroutine with a nil pointer deref and takes discv4 down. Re-assign `nextTimeout = p` at the head of the loop (restoring the documented invariant) and send the clock-warp error on `p.errc` rather than the now-stale `nextTimeout.errc`. The clock-warp branch triggers only when the system clock jumps backward after a deadline is assigned (deadline - time.Now() >= 2*respTimeout, i.e. at least ~500ms backward jump), which is why this regression slipped past CI - it is not exercised by any existing unit test, and writing one would require plumbing a clock through the loop. --- p2p/discover/v4_udp.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/p2p/discover/v4_udp.go b/p2p/discover/v4_udp.go index 9e824dae18..b06db4bdb2 100644 --- a/p2p/discover/v4_udp.go +++ b/p2p/discover/v4_udp.go @@ -447,6 +447,7 @@ func (t *UDPv4) loop() { // Start the timer so it fires when the next pending reply has expired. now := time.Now() for p, el := range iterList[*replyMatcher](plist) { + nextTimeout = p if dist := p.deadline.Sub(now); dist < 2*respTimeout { timeout.Reset(dist) return @@ -454,7 +455,7 @@ func (t *UDPv4) loop() { // 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 From 4ff33ba1b6ecfff7087136136ed13dd8c3a3ac38 Mon Sep 17 00:00:00 2001 From: Andrii Furmanets Date: Tue, 5 May 2026 23:17:09 +0300 Subject: [PATCH 140/183] internal/download: only report stale existing downloads (#34849) ## Summary Fixes #31917. `geth era-download` now only prints `is stale` when an existing downloaded file fails checksum verification. Missing files are still downloaded normally, but no longer get mislabeled as stale. ## Why `DownloadFile` used `verifyHash` for both missing files and checksum mismatches, then printed `is stale` for any error. This made first-time downloads look like corrupt or outdated files. ## Validation - `make all` - `go run ./build/ci.go test` - `go run ./build/ci.go lint` - `go run ./build/ci.go check_generate` - `go run ./build/ci.go check_baddeps` --------- Co-authored-by: Felix Lange --- internal/download/download.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/internal/download/download.go b/internal/download/download.go index c59c8a90c3..79cf27a56b 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 { From 84949107ce4592f901ef77ab082121432bf4b5f6 Mon Sep 17 00:00:00 2001 From: cui Date: Wed, 6 May 2026 15:18:12 +0800 Subject: [PATCH 141/183] beacon/engine: fix wrong presize bound (#34860) --- beacon/engine/types.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/beacon/engine/types.go b/beacon/engine/types.go index a312fee88a..9b0b186df7 100644 --- a/beacon/engine/types.go +++ b/beacon/engine/types.go @@ -276,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()...) } From 4d2af275e1fe34eeafc50bbb61ea5bb96f11b10c Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Wed, 6 May 2026 09:59:51 +0200 Subject: [PATCH 142/183] eth/catalyst: allow reorging the head block to a parent (#34767) Implements https://github.com/ethereum/execution-apis/pull/786/changes as discussed on standup today --------- Co-authored-by: Gary Rong --- beacon/engine/errors.go | 1 + core/blockchain.go | 9 +++++++-- eth/catalyst/api.go | 25 +++++++++++++++++++++---- 3 files changed, 29 insertions(+), 6 deletions(-) diff --git a/beacon/engine/errors.go b/beacon/engine/errors.go index 62773a0ea9..80e13b11b9 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/core/blockchain.go b/core/blockchain.go index f21a1462ea..2b49111121 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -2596,8 +2596,13 @@ 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 diff --git a/eth/catalyst/api.go b/eth/catalyst/api.go index 8a4aced04b..b81ed57a2c 100644 --- a/eth/catalyst/api.go +++ b/eth/catalyst/api.go @@ -82,6 +82,9 @@ const ( // beaconUpdateWarnFrequency is the frequency at which to warn the user that // the beacon client is offline. beaconUpdateWarnFrequency = 5 * time.Minute + + // maxReorgDepth is the maximum reorg depth accepted via forkchoiceUpdated. + maxReorgDepth = 32 ) type ConsensusAPI struct { @@ -237,6 +240,7 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV4(ctx context.Context, update engine. 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() @@ -321,10 +325,23 @@ func (api *ConsensusAPI) forkchoiceUpdated(ctx context.Context, update engine.Fo // 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() From aaa2b662856dcd8527dfb452ceee605467967fb1 Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Wed, 6 May 2026 12:03:11 +0200 Subject: [PATCH 143/183] core: implement eip-7981: Increase Access List Cost (#34755) based on: https://github.com/ethereum/go-ethereum/pull/34748 spec: https://eips.ethereum.org/EIPS/eip-7981 --- cmd/evm/internal/t8ntool/transaction.go | 4 +- core/bench_test.go | 2 +- core/bintrie_witness_test.go | 4 +- core/state_transition.go | 66 +++++- core/state_transition_test.go | 287 ++++++++++++++++++++++++ core/txpool/validation.go | 4 +- tests/transaction_test_util.go | 4 +- 7 files changed, 354 insertions(+), 17 deletions(-) create mode 100644 core/state_transition_test.go diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go index 7e068c06af..ca19ae3386 100644 --- a/cmd/evm/internal/t8ntool/transaction.go +++ b/cmd/evm/internal/t8ntool/transaction.go @@ -133,7 +133,7 @@ func Transaction(ctx *cli.Context) error { } // Check intrinsic gas rules := chainConfig.Rules(common.Big0, true, 0) - cost, 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) @@ -147,7 +147,7 @@ func Transaction(ctx *cli.Context) error { } // For Prague txs, validate the floor data gas. if rules.IsPrague { - floorDataGas, err := core.FloorDataGas(rules, tx.Data()) + floorDataGas, err := core.FloorDataGas(rules, tx.Data(), tx.AccessList()) if err != nil { r.Error = err results = append(results, r) diff --git a/core/bench_test.go b/core/bench_test.go index 20d1a7794b..65179c54d4 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{} - cost, _ := 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 { diff --git a/core/bintrie_witness_test.go b/core/bintrie_witness_test.go index 66feef0675..5f6239e4fa 100644 --- a/core/bintrie_witness_test.go +++ b/core/bintrie_witness_test.go @@ -63,12 +63,12 @@ var ( 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) + 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 diff --git a/core/state_transition.go b/core/state_transition.go index c7b0593857..b5b8b22155 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -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) (vm.GasCosts, 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 { @@ -107,8 +107,32 @@ func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.Set } } 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 @@ -117,7 +141,7 @@ func IntrinsicGas(data []byte, accessList types.AccessList, authList []types.Set } // FloorDataGas computes the minimum gas required for a transaction based on its data tokens (EIP-7623). -func FloorDataGas(rules params.Rules, data []byte) (uint64, error) { +func FloorDataGas(rules params.Rules, data []byte, accessList types.AccessList) (uint64, error) { var ( tokens uint64 tokenCost uint64 @@ -125,15 +149,41 @@ func FloorDataGas(rules params.Rules, data []byte) (uint64, error) { if rules.IsAmsterdam { // EIP-7976 changes how calldata is priced. // From 10/40 to 64/64 for zero/non-zero bytes. - tokens = uint64(len(data)) * params.TxTokenPerNonZeroByte 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 - tokens = nz*params.TxTokenPerNonZeroByte + z + 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 } @@ -462,7 +512,7 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { floorDataGas uint64 ) // Check clauses 4-5, subtract intrinsic gas if everything is correct - cost, 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 } @@ -475,7 +525,7 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { } // Gas limit suffices for the floor data cost (EIP-7623) if rules.IsPrague { - floorDataGas, err = FloorDataGas(rules, msg.Data) + floorDataGas, err = FloorDataGas(rules, msg.Data, msg.AccessList) if err != nil { return nil, err } diff --git a/core/state_transition_test.go b/core/state_transition_test.go new file mode 100644 index 0000000000..8aab016123 --- /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/txpool/validation.go b/core/txpool/validation.go index 6891dc94d2..c87bba31ac 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -125,7 +125,7 @@ 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 } @@ -134,7 +134,7 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types } // Ensure the transaction can cover floor data gas. if rules.IsPrague { - floorDataGas, err := core.FloorDataGas(rules, tx.Data()) + floorDataGas, err := core.FloorDataGas(rules, tx.Data(), tx.AccessList()) if err != nil { return err } diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index 8b8d0357bf..572c109f1e 100644 --- a/tests/transaction_test_util.go +++ b/tests/transaction_test_util.go @@ -81,7 +81,7 @@ func (tt *TransactionTest) Run() error { return } // Intrinsic gas - cost, 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 } @@ -92,7 +92,7 @@ func (tt *TransactionTest) Run() error { if rules.IsPrague { var floorDataGas uint64 - floorDataGas, err = core.FloorDataGas(rules, tx.Data()) + floorDataGas, err = core.FloorDataGas(rules, tx.Data(), tx.AccessList()) if err != nil { return } From b92c86deb79dff0338545b0a530442b2c7abf36c Mon Sep 17 00:00:00 2001 From: Rahman Date: Wed, 6 May 2026 07:02:03 -0600 Subject: [PATCH 144/183] internal/download: don't discard `dst.Close` error (#34866) When `io.Copy` succeeds but the buffered `Close` fails (e.g. disk full on `Flush`), the error was swallowed and verification reported a misleading hash mismatch instead of the real I/O failure. Keep the `Close` error when `io.Copy` didn't already produce one. --------- Co-authored-by: Jared Wasinger --- internal/download/download.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/internal/download/download.go b/internal/download/download.go index 79cf27a56b..27d3732731 100644 --- a/internal/download/download.go +++ b/internal/download/download.go @@ -211,9 +211,11 @@ func (db *ChecksumDB) DownloadFile(url, dstPath string) error { if resp.ContentLength > 0 { dst = newDownloadWriter(fd, resp.ContentLength) } - _, err = io.Copy(dst, resp.Body) - dst.Close() - if err != nil { + if _, err = io.Copy(dst, resp.Body); err != nil { + os.Remove(tmpfile) + return err + } + if err = dst.Close(); err != nil { os.Remove(tmpfile) return err } From 06c30cc7e113a639499c2c5d669901bbfc8c189d Mon Sep 17 00:00:00 2001 From: Jonny Rhea <5555162+jrhea@users.noreply.github.com> Date: Wed, 6 May 2026 08:08:15 -0500 Subject: [PATCH 145/183] triedb/pathdb: add AdoptSyncedState for snap/2 completion path (#34874) This PR adds `AdoptSyncedState()` alongside `Enable()`. It does the same pathdb bookkeeping (now factored into a shared `resetForReactivation()` helper), but skips the regeneration. The wiring/calling code lands in #34626 --------- Co-authored-by: Gary Rong --- triedb/database.go | 10 +++++ triedb/pathdb/database.go | 81 ++++++++++++++++++++++++++-------- triedb/pathdb/database_test.go | 78 ++++++++++++++++++++++++++++++++ 3 files changed, 150 insertions(+), 19 deletions(-) diff --git a/triedb/database.go b/triedb/database.go index 0fd3e1aa91..ef95169df1 100644 --- a/triedb/database.go +++ b/triedb/database.go @@ -327,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 diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go index 98975d7fa5..e52949c93e 100644 --- a/triedb/pathdb/database.go +++ b/triedb/pathdb/database.go @@ -365,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 { @@ -383,27 +376,40 @@ 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. + // 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 step. + // Re-enable the database as the final bookkeeping step. db.waitSync = false rawdb.WriteSnapSyncStatusFlag(db.diskdb, rawdb.StateSyncFinished) + return nil +} - // Re-construct a new disk layer backed by persistent state - // and schedule the state snapshot generation if it's permitted. +// 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() + + 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. @@ -416,6 +422,43 @@ func (db *Database) Enable(root common.Hash) error { 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. diff --git a/triedb/pathdb/database_test.go b/triedb/pathdb/database_test.go index 8ceb22eaba..41212dc9d0 100644 --- a/triedb/pathdb/database_test.go +++ b/triedb/pathdb/database_test.go @@ -748,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 From ea1cf7bf5ee07562284f9d050a6def9704d258e7 Mon Sep 17 00:00:00 2001 From: Bosul Mun Date: Wed, 6 May 2026 15:36:54 +0200 Subject: [PATCH 146/183] eth/protocols/eth: stop serving on unavailable responses (#34787) This is an alternative PR for https://github.com/ethereum/go-ethereum/pull/34746. This PR implements the second approach among the two possible solutions mentioned in the above PR. Requests for unavailable items are possible when the peer is following a different fork from us. However this is not expected to happen frequently. Considering the amount of complexity added to the codebase, the simpler approach (this PR) can be preferred. --- eth/protocols/eth/handler_test.go | 16 ++++++++++------ eth/protocols/eth/handlers.go | 21 ++++++++++++--------- 2 files changed, 22 insertions(+), 15 deletions(-) diff --git a/eth/protocols/eth/handler_test.go b/eth/protocols/eth/handler_test.go index a45abc90eb..d056d121d9 100644 --- a/eth/protocols/eth/handler_test.go +++ b/eth/protocols/eth/handler_test.go @@ -424,16 +424,20 @@ 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{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(), - {}, - backend.chain.GetBlockByNumber(100).Hash(), - {}, - }, []bool{false, true, false, true, false, true, false}, 3}, + }, []bool{false, true, true}, 0}, } // Run each of the tests and verify the results against the chain for i, tt := range tests { diff --git a/eth/protocols/eth/handlers.go b/eth/protocols/eth/handlers.go index 7556df9af2..3254a0abc2 100644 --- a/eth/protocols/eth/handlers.go +++ b/eth/protocols/eth/handlers.go @@ -238,10 +238,12 @@ 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 } @@ -281,16 +283,16 @@ func ServiceGetReceiptsQuery69(chain *core.BlockChain, query GetReceiptsRequest) // Retrieve the requested block's receipts results := chain.GetReceiptsRLP(hash) if results == nil { - continue // Can't retrieve the receipts, so we just skip this block. + break // Don't have this block's receipts, stop serving. } body := chain.GetBodyRLP(hash) if body == nil { - continue // The block body is missing, we also have to skip. + 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) - continue + break } receipts.AppendRaw(results) bytes += len(results) @@ -312,12 +314,13 @@ func serviceGetReceiptsQuery70(chain *core.BlockChain, query GetReceiptsRequest, break } results := chain.GetReceiptsRLP(hash) + // If we don't have this block's receipts or body, stop serving. if results == nil { - continue // Can't retrieve the receipts, so we just skip this block. + break } body := chain.GetBodyRLP(hash) if body == nil { - continue // The block body is missing, we also have to skip. + break } q := receiptQueryParams{sizeLimit: uint64(maxPacketSize - bytes)} if i == 0 { @@ -326,7 +329,7 @@ func serviceGetReceiptsQuery70(chain *core.BlockChain, query GetReceiptsRequest, results, incomplete, err := blockReceiptsToNetwork(results, body, q) if err != nil { log.Error("Error in block receipts conversion", "hash", hash, "err", err) - continue + break } if results == nil { // This case triggers when the first receipt of the block receipts list doesn't From c5598fe9588be9d19ab210ebf53e760c7e195d95 Mon Sep 17 00:00:00 2001 From: Roshan <48975233+pythonberg1997@users.noreply.github.com> Date: Thu, 7 May 2026 16:44:26 +0800 Subject: [PATCH 147/183] core/txpool: change lock in Pending method of legacy pool to read lock (#32924) This PR makes a small update to the `Pending()` method in the legacy pool. By changing the lock from exclusive to read-only, it aims to improve concurrency performance. --------- Co-authored-by: rjl493456442 --- core/txpool/legacypool/legacypool.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/core/txpool/legacypool/legacypool.go b/core/txpool/legacypool/legacypool.go index 00630de04c..3d66803fd7 100644 --- a/core/txpool/legacypool/legacypool.go +++ b/core/txpool/legacypool/legacypool.go @@ -467,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 { @@ -503,8 +503,8 @@ func (pool *LegacyPool) Pending(filter txpool.PendingFilter) (map[common.Address if filter.BlobTxs { 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)) From f7b7d4c7e5cd9cd3b596c7a7430942cea8f5a755 Mon Sep 17 00:00:00 2001 From: cui Date: Thu, 7 May 2026 20:03:32 +0800 Subject: [PATCH 148/183] eth/tracers/logger: fix exclude address list (#34887) Fixes the exclusion list of the accessListTracer. --------- Co-authored-by: Sina M <1591639+s1na@users.noreply.github.com> --- eth/tracers/logger/access_list_tracer.go | 5 ++- eth/tracers/logger/access_list_tracer_test.go | 39 +++++++++++++++++++ 2 files changed, 42 insertions(+), 2 deletions(-) create mode 100644 eth/tracers/logger/access_list_tracer_test.go diff --git a/eth/tracers/logger/access_list_tracer.go b/eth/tracers/logger/access_list_tracer.go index 749aade61b..31c3ebde93 100644 --- a/eth/tracers/logger/access_list_tracer.go +++ b/eth/tracers/logger/access_list_tracer.go @@ -112,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 0000000000..04b2b4b31b --- /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) + } +} From e1e3eaa38140c2ba1ed1eefafc126ae08d352ce9 Mon Sep 17 00:00:00 2001 From: cui Date: Thu, 7 May 2026 21:18:04 +0800 Subject: [PATCH 149/183] p2p/discover: copy buffer before sending read errors to unhandled (#34888) This fixes an issue where packets send to the `Unhandled` channel configured on discv4 could be corrupted when the packet buffer gets reused. --------- Co-authored-by: Felix Lange --- p2p/discover/v4_udp.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/p2p/discover/v4_udp.go b/p2p/discover/v4_udp.go index b06db4bdb2..ae8cbec3e2 100644 --- a/p2p/discover/v4_udp.go +++ b/p2p/discover/v4_udp.go @@ -555,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: } } From e71098ba4e0814f2ced7165d518f63b281ad0697 Mon Sep 17 00:00:00 2001 From: cui Date: Fri, 8 May 2026 06:40:26 +0800 Subject: [PATCH 150/183] core/state: fix StateDB Reader Error Discard After Commit (#34899) --- core/state/statedb.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index 1858f4758d..e6d8b5bffc 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -1355,7 +1355,7 @@ func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorag // The reader update must be performed as the final step, otherwise, // the new state would not be visible before db.commit. - s.reader, _ = s.db.Reader(s.originalRoot) + s.reader, err = s.db.Reader(s.originalRoot) return ret, err } From 1abbae239d9a9f5797a5967350023c0f6b6aabb9 Mon Sep 17 00:00:00 2001 From: Delweng Date: Fri, 8 May 2026 10:12:46 +0800 Subject: [PATCH 151/183] eth,node: replace the deprecated TypeMux with Feed (#32585) replace the not used event.Typemux to event.Feed --------- Co-authored-by: Felix Lange --- cmd/geth/config.go | 10 ++- cmd/geth/main.go | 27 -------- cmd/utils/flags.go | 8 +-- eth/backend.go | 7 +- eth/downloader/api.go | 22 +++--- eth/downloader/downloader.go | 28 +++++--- eth/downloader/downloader_test.go | 3 +- eth/downloader/events.go | 24 +++++-- eth/handler.go | 35 ++++------ eth/syncer/syncer.go | 108 ++++++++++++++++++------------ node/node.go | 9 --- 11 files changed, 140 insertions(+), 141 deletions(-) diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 8e2db32d76..40458186f4 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -38,6 +38,7 @@ 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" @@ -276,16 +277,19 @@ func makeFullNode(ctx *cli.Context) *node.Node { 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) { // Start dev mode. diff --git a/cmd/geth/main.go b/cmd/geth/main.go index c8d7abc65b..850e26d161 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -22,13 +22,10 @@ import ( "os" "slices" "sort" - "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" @@ -387,28 +384,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/utils/flags.go b/cmd/utils/flags.go index cc4c3bff5c..ea0f6f5ee4 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -2237,13 +2237,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. diff --git a/eth/backend.go b/eth/backend.go index 6cfd1f6fa0..af8b04bda6 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -49,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" @@ -105,7 +104,6 @@ type Ethereum struct { // DB interfaces chainDb ethdb.Database // Block chain database - eventMux *event.TypeMux engine consensus.Engine accountManager *accounts.Manager @@ -194,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, @@ -344,7 +341,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 @@ -405,7 +401,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), @@ -600,7 +596,6 @@ func (s *Ethereum) Stop() error { s.shutdownTracker.Stop() s.chainDb.Close() - s.eventMux.Stop() return nil } diff --git a/eth/downloader/api.go b/eth/downloader/api.go index 1fea35775e..6033e44474 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) @@ -90,6 +88,7 @@ func (api *DownloaderAPI) eventLoop() { } ) defer checkTimer.Stop() + defer sub.Unsubscribe() for { select { @@ -101,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/downloader.go b/eth/downloader/downloader.go index 1de0933842..4a575d6856 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 @@ -229,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, @@ -427,20 +429,25 @@ func (d *Downloader) ConfigSyncMode() SyncMode { 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) { @@ -662,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 { diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go index 6d5d159631..e6c477cd33 100644 --- a/eth/downloader/downloader_test.go +++ b/eth/downloader/downloader_test.go @@ -32,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" @@ -75,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 } diff --git a/eth/downloader/events.go b/eth/downloader/events.go index 25255a3a72..0fb380a857 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/handler.go b/eth/handler.go index 27b5e60697..76df635fb0 100644 --- a/eth/handler.go +++ b/eth/handler.go @@ -107,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 } @@ -126,7 +125,6 @@ type handler struct { peers *peerSet txBroadcastKey [16]byte - eventMux *event.TypeMux txsCh chan core.NewTxsEvent txsSub event.Subscription blockRange *blockRangeState @@ -144,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, @@ -163,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) { @@ -420,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 @@ -536,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()) @@ -561,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: @@ -593,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/syncer/syncer.go b/eth/syncer/syncer.go index c0d54b953b..b04d8f22e8 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 } + if ev.Type == downloader.SyncFailed { + log.Debug("Synchronization failed", "err", ev.Err) + continue + } + + head := s.backend.BlockChain().CurrentHeader() + 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) + } + } + } // 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 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 } - } - // 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 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 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/node/node.go b/node/node.go index 01318881d4..56ecd7d522 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}, @@ -692,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. From 281dc4c2091400ea1388b030300e5adc7672ffa0 Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Fri, 8 May 2026 11:33:19 +0200 Subject: [PATCH 152/183] p2p/discover: decouple nodeFeed from Table mutex in waitForNodes (#34898) Fixes #34881 This fixes a hang in `Table.waitForNodes`. It is a replacement for PRs #34890, #33665 which tried to fix the same issue in a different way. - #34890 doesn't really fix the issue, just makes it less likely - #33665 tries to fix it by moving the feed send outside of the lock I created this PR because I want to keep the synchronous node feed sending in `Table.nodeAdded`. --------- Co-authored-by: Csaba Kiraly --- p2p/discover/table.go | 55 +++++++++++++++++++++++++++++--------- p2p/discover/table_test.go | 40 +++++++++++++++++++++++++++ 2 files changed, 83 insertions(+), 12 deletions(-) diff --git a/p2p/discover/table.go b/p2p/discover/table.go index 721cd7b589..016a2d1af3 100644 --- a/p2p/discover/table.go +++ b/p2p/discover/table.go @@ -753,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) @@ -760,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 c3b71ea5a6..a16b4d9cab 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" @@ -550,6 +551,45 @@ func TestSetFallbackNodes_DNSHostname(t *testing.T) { 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 { From 0ad890e3af967f1d2d3bec3b972f76fc4c208929 Mon Sep 17 00:00:00 2001 From: Miki Noir Date: Fri, 8 May 2026 11:43:31 +0100 Subject: [PATCH 153/183] core/txpool/blobpool: continue on cell proof error in `GetBlobs` (#34891) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `GetBlobs` returned early when `CellProofsAt` reported corrupted/out-of-bounds proofs, dropping every blob already collected and aborting the remaining hashes — a single bad sidecar killed the whole Engine API batch for consensus clients. Replaced the `return nil, nil, nil, err` with `log.Error + continue` so the slot stays `nil` per the sparse-array contract, matching the store/RLP/nil-sidecar branches a few lines above. --- core/txpool/blobpool/blobpool.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index efa41a0649..f2e0d5f9d2 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -1517,7 +1517,8 @@ func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte) ([]*kzg4844.Blo case types.BlobSidecarVersion1: cellProofs, err := sidecar.CellProofsAt(i) if err != nil { - return nil, nil, nil, err + log.Error("Failed to get cell proofs", "id", txID, "err", err) + continue } pf = cellProofs } From 592209c0ee99bd9c3046d27ecea5b970c64a8730 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Fri, 8 May 2026 15:18:24 +0200 Subject: [PATCH 154/183] .gitea, build: cross-compile windows binaries (#34889) --- .gitea/workflows/release.yml | 35 ++++------ build/ci.go | 125 ++++++++++++++++++++++------------- internal/build/gotool.go | 13 +++- 3 files changed, 100 insertions(+), 73 deletions(-) diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml index efe76cf170..a3fa4a2ea7 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,57 +155,46 @@ 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 - env: - GETH_MINGW: 'C:\msys64\mingw64' + go run build/ci.go install -dlgo -os windows -arch amd64 -cc x86_64-w64-mingw32-gcc - name: "Create/upload archive (amd64)" - shell: cmd run: | - go run build/ci.go archive -arch amd64 -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + 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)" - shell: cmd run: | - set "PATH=C:\Program Files (x86)\NSIS;%PATH%" go run build/ci.go nsis -arch amd64 -signer WINDOWS_SIGNING_KEY -upload gethstore/builds - del /Q build\bin\* + rm -f build/bin/* env: 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 - env: - GETH_MINGW: 'C:\msys64\mingw32' + go run build/ci.go install -dlgo -os windows -arch 386 -cc i686-w64-mingw32-gcc - name: "Create/upload archive (386)" - shell: cmd run: | - go run build/ci.go archive -arch 386 -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + 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)" - shell: cmd run: | - set "PATH=C:\Program Files (x86)\NSIS;%PATH%" go run build/ci.go nsis -arch 386 -signer WINDOWS_SIGNING_KEY -upload gethstore/builds - del /Q build\bin\* + rm -f build/bin/* env: WINDOWS_SIGNING_KEY: ${{ secrets.WINDOWS_SIGNING_KEY }} AZURE_BLOBSTORE_TOKEN: ${{ secrets.AZURE_BLOBSTORE_TOKEN }} diff --git a/build/ci.go b/build/ci.go index 173288bcdc..173a3280ce 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 { @@ -180,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) @@ -233,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") @@ -241,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) @@ -255,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") @@ -270,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}) } @@ -297,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") @@ -307,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, 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 @@ -326,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 @@ -682,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 { @@ -701,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} { @@ -735,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) @@ -745,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") } @@ -1209,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 } @@ -1252,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/internal/build/gotool.go b/internal/build/gotool.go index 172fa13464..00aa9d6f02 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. From 1f3989dc708fcba783eae5e10932b1102de608d8 Mon Sep 17 00:00:00 2001 From: cui Date: Sat, 9 May 2026 08:51:12 +0800 Subject: [PATCH 155/183] signer/core: avoid mutating the input (#34908) --- signer/core/signed_data.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/signer/core/signed_data.go b/signer/core/signed_data.go index c62b513145..d8b6ef0674 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 { From b927ff8b53c070e8b369324fd0f63ffa28aea83a Mon Sep 17 00:00:00 2001 From: cui Date: Sat, 9 May 2026 21:59:03 +0800 Subject: [PATCH 156/183] cmd/devp2p: fix typo in ENR IP printing code (#34909) --- cmd/devp2p/enrcmd.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/devp2p/enrcmd.go b/cmd/devp2p/enrcmd.go index c9b692612f..af2cf90a81 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 From 2ca3a6447d5f0bbea325cd99acad6537d0de8e9b Mon Sep 17 00:00:00 2001 From: Richard Creighton Date: Sat, 9 May 2026 15:07:12 +0100 Subject: [PATCH 157/183] cmd/geth: respect --graphql=false (#34914) Passing `--graphql=false` currently still registers the GraphQL handler because the startup path checks whether the flag was set, not its boolean value. This switches the registration condition to use `ctx.Bool`, so explicit false disables GraphQL while the default behavior remains unchanged. --- cmd/geth/config.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 40458186f4..31f19e7a32 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -270,7 +270,7 @@ 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. From 2ba9be9c0efcb640860cfedc4a43b6f6b2d68c7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marius=20Kj=C3=A6rstad?= Date: Sun, 10 May 2026 11:45:23 +0200 Subject: [PATCH 158/183] build: upgrade -dlgo version to Go 1.25.10 (#34911) New security fix: https://groups.google.com/g/golang-announce/c/qcCIEXso47M --- build/checksums.txt | 84 ++++++++++++++++++++++----------------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/build/checksums.txt b/build/checksums.txt index 1832ce41dd..454efa93c4 100644 --- a/build/checksums.txt +++ b/build/checksums.txt @@ -5,49 +5,49 @@ # https://github.com/ethereum/execution-spec-tests/releases/download/v5.1.0 a3192784375acec7eaec492799d5c5d0c47a2909a3cc40178898e4ecd20cc416 fixtures_develop.tar.gz -# version:golang 1.25.9 +# version:golang 1.25.10 # https://go.dev/dl/ -0ec9ef8ebcea097aac37decae9f09a7218b451cd96be7d6ed513d8e4bcf909cf go1.25.9.src.tar.gz -b9ede6378a8f8d3d22bf52e68beb69ef7abdb65929ab2456020383002da15846 go1.25.9.aix-ppc64.tar.gz -92cb78fba4796e218c1accb0ea0a214ef2094c382049a244ad6505505d015fbe go1.25.9.darwin-amd64.tar.gz -9528be7329b9770631a6bd09ca2f3a73ed7332bec01d87435e75e92d8f130363 go1.25.9.darwin-arm64.tar.gz -918e44a471c5524caa52f74185064240d5eb343aa8023d604776511fc7adffa6 go1.25.9.dragonfly-amd64.tar.gz -2d67dbdfd09c6fcaa0e64485367ef43b8837ea200c663d6417183237bcddf83d go1.25.9.freebsd-386.tar.gz -9152d0c0badbfeb0c0e148e47c12bec28099d8cf2db60958810c879e0b679d07 go1.25.9.freebsd-amd64.tar.gz -437dca59604ad4a806a6a88e3d7ec1cd98ac9b402a3671629f4e553dd8b9888f go1.25.9.freebsd-arm.tar.gz -4c0fe53977412036fc8081e8d0992bbaabe4d3e1926137271ba11c2f5753300f go1.25.9.freebsd-arm64.tar.gz -d6087cdd1c084bd186132f29e0d032852a745f3c7619003d0fd5612c1fa58c8a go1.25.9.freebsd-riscv64.tar.gz -f82e49037e195cb62beae6a6ad83497157b2af5a01bad2f1dcb65df41080aabb go1.25.9.illumos-amd64.tar.gz -1e14a73bc2b19e370e0d4c57ba87aabfe8aef1e435e14d246742d48a13254f36 go1.25.9.linux-386.tar.gz -00859d7bd6defe8bf84d9db9e57b9a4467b2887c18cd93ae7460e713db774bc1 go1.25.9.linux-amd64.tar.gz -ec342e7389b7f489564ed5463c63b16cf8040023dabc7861256677165a8c0e2b go1.25.9.linux-arm64.tar.gz -7d4f0d266d871301e08ef4ac31c56e66048688893b2848392e5c600276351ee8 go1.25.9.linux-armv6l.tar.gz -f3460d901a14496bc609636e4accf9110ee1869d41c64af7e29cd567cffcf49b go1.25.9.linux-loong64.tar.gz -1da96ea449382ff96c09c55cee74815324e01d687d5ac6d2ade58244b8574306 go1.25.9.linux-mips.tar.gz -311a7f5f01f9a4bd51288b575eb619dc8e28e1fbc0cd78256a428b3ca668ff01 go1.25.9.linux-mips64.tar.gz -0b4edaf9e2ba3f0a079547effda70ec6a4b51a6ca3271a1147652c87ebcf3735 go1.25.9.linux-mips64le.tar.gz -42667340df264896f20b12261429d954e736e9772ab83ba289e68c30cf6f9628 go1.25.9.linux-mipsle.tar.gz -b9cbb3a4894b5aca6966c23452608435e8535278ef019b18d8898fbbfab67e74 go1.25.9.linux-ppc64.tar.gz -b0c41c7da1fc8d39020d65296a0dc54167afd9f76d67064e22c31ce3d839a739 go1.25.9.linux-ppc64le.tar.gz -2a630be8f854177c13e5fa75f7812c721369ecb9bd6e4c0fb1bd1c708d08b37c go1.25.9.linux-riscv64.tar.gz -0cf55136ac7eaccfc36d849054f849510ea289c2d959ffbed7b3866b4f484d17 go1.25.9.linux-s390x.tar.gz -eaf8167ff10a6a3e5dd304ef5f2e020b3a7379e76fa1011dc49c895800bf367c go1.25.9.netbsd-386.tar.gz -3cc6a861e62e23feae660984e0f2f14a2efb5d1f655900afee1d51af98919ae4 go1.25.9.netbsd-amd64.tar.gz -c2c44dca10e882c30553f4aa2ab8f6722b670fb12882378c8f461a9105d40188 go1.25.9.netbsd-arm.tar.gz -f301b71a8ec448053a5d2597df2e178120204bc9a33266c81600dd5d020a61b4 go1.25.9.netbsd-arm64.tar.gz -c4543b7fdef9707b4896810c69b4160a43ecec210af45c300f3abd78aa0c9e72 go1.25.9.openbsd-386.tar.gz -37275325e314f5ab7cf8ae65c4efc7cbfdaf20b41c6849549739b57a3ac97544 go1.25.9.openbsd-amd64.tar.gz -f9c05b6b315e979ecdd47354dd287c01708d6a88dc6ae7af74c84df8fa00df94 go1.25.9.openbsd-arm.tar.gz -4e999f42cf959ff95ca84af1ea1db3771000f5e57e157904bc2ffc72c75e29a2 go1.25.9.openbsd-arm64.tar.gz -0c7fa6c7c2b1cc13ad32fa94fc31273b4adf39c1e0f0e5dcedac158ff526af3f go1.25.9.openbsd-ppc64.tar.gz -347b33953a4b6e8df17719296f360f60878fe48a2d482ceb3637a3dfd4950065 go1.25.9.openbsd-riscv64.tar.gz -889f77d567c06832e0d332fe2458653dc66d43cded7ddbca6f72ce0ca60029cc go1.25.9.plan9-386.tar.gz -978b1f931fadec2f2516237d2649ee845d93c8eaf47dd196cfd8d26c7b2706a1 go1.25.9.plan9-amd64.tar.gz -30b9565e5ad0a212fe00990ead700c751b416eb2ef8d7c91a204945a7ff83a48 go1.25.9.plan9-arm.tar.gz -9e9125ff84ab3c3522ec758cab9540a17e9cba12bfcc34b6bf556cb89b522591 go1.25.9.solaris-amd64.tar.gz -bf40515f5f4d834fa9ead31ff75581e61a38ac27bf49840b95c5c998d321c0f6 go1.25.9.windows-386.zip -a7a710e225467b34e9e09fb432b829c86c9b2da5821ee5418f7eb2e8ae1a22cc go1.25.9.windows-amd64.zip -33cd73cf1b3ceee655ef71bc96e94006c02ae3c617fdd67ac9be3dfae3957449 go1.25.9.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.10.1 # https://github.com/golangci/golangci-lint/releases/ From 8581125a21ee4592631abe127749d6ca3f1020fa Mon Sep 17 00:00:00 2001 From: vickkkkkyy Date: Sun, 10 May 2026 17:49:17 +0800 Subject: [PATCH 159/183] crypto: add hash length check in nocgo VerifySignature (#33839) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit I was tracing a signature verification issue in a nocgo build and found that `VerifySignature` doesn't validate hash length. #33104 added the check to `Sign` and `sigToPub` but missed this one. The cgo path in `secp256k1/secp256.go` already rejects non-32-byte hashes, so the nocgo path should do the same — otherwise a wrong-length hash gets passed to decred's `Verify` and silently gives a bogus result. --- crypto/signature_nocgo.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crypto/signature_nocgo.go b/crypto/signature_nocgo.go index 0aab7180d3..bf273612e9 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 From bcb68d23b3e78855be7d825ede37815d83b3142b Mon Sep 17 00:00:00 2001 From: cui Date: Sun, 10 May 2026 19:02:46 +0800 Subject: [PATCH 160/183] p2p: handle return false from TCPEndpoint (#34916) --- p2p/dial.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/p2p/dial.go b/p2p/dial.go index f9463d6d89..0ffcd10497 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()) } From 7facf9c1292d3783cb079a16ba797def4738e1c8 Mon Sep 17 00:00:00 2001 From: cui Date: Sun, 10 May 2026 19:03:57 +0800 Subject: [PATCH 161/183] core/txpool: use cmp.Compare instead of subtraction (#34918) This fixes a theoretical overflow condition if an account has an impossibly high nonce. --- core/txpool/locals/tx_tracker.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/txpool/locals/tx_tracker.go b/core/txpool/locals/tx_tracker.go index bb178f175e..66f3248105 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 From f63c26509298ecfdf7e50d7b08f96809b2235ddd Mon Sep 17 00:00:00 2001 From: rayoo Date: Sun, 10 May 2026 19:43:40 +0800 Subject: [PATCH 162/183] internal/download: close dst on io.Copy error (#34910) --- internal/download/download.go | 1 + 1 file changed, 1 insertion(+) diff --git a/internal/download/download.go b/internal/download/download.go index 27d3732731..94517166f5 100644 --- a/internal/download/download.go +++ b/internal/download/download.go @@ -212,6 +212,7 @@ func (db *ChecksumDB) DownloadFile(url, dstPath string) error { dst = newDownloadWriter(fd, resp.ContentLength) } if _, err = io.Copy(dst, resp.Body); err != nil { + dst.Close() os.Remove(tmpfile) return err } From 18becee8cb01f6d35224a6bac3e45d49b2074857 Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Sun, 10 May 2026 22:54:57 +0200 Subject: [PATCH 163/183] appveyor.yml: remove appveyor configuration (#34720) Removes the appveyor.yml since we moved to github runners. --------- Co-authored-by: Sina Mahmoodi Co-authored-by: Felix Lange --- appveyor.yml | 39 --------------------------------------- 1 file changed, 39 deletions(-) delete mode 100644 appveyor.yml diff --git a/appveyor.yml b/appveyor.yml deleted file mode 100644 index aeafcfc838..0000000000 --- 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 From 934a0091fa66b474832b3664854e979fe8bf76b2 Mon Sep 17 00:00:00 2001 From: rayoo Date: Mon, 11 May 2026 10:23:58 +0800 Subject: [PATCH 164/183] triedb/pathdb: fix layer 5 key range in storage iterator traversal test (#34883) --- triedb/pathdb/iterator_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/triedb/pathdb/iterator_test.go b/triedb/pathdb/iterator_test.go index 2197e85272..191c2fadf5 100644 --- a/triedb/pathdb/iterator_test.go +++ b/triedb/pathdb/iterator_test.go @@ -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 { From 2f11dccca00bc66b68f348193e98dee4b6e2206d Mon Sep 17 00:00:00 2001 From: Richard Creighton Date: Mon, 11 May 2026 15:08:55 +0100 Subject: [PATCH 165/183] cmd/geth: respect --dev=false (#34920) Passing `--dev=false` currently still enters the dev-mode startup path because a couple of branches check whether the flag was set, not its boolean value. This switches those branches to use `ctx.Bool`, so explicit false does not start dev mode or emit a dev genesis, while `--dev` keeps its existing behavior. --- cmd/geth/chaincmd.go | 2 +- cmd/geth/config.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go index 0aacb0878a..98ed348d8c 100644 --- a/cmd/geth/chaincmd.go +++ b/cmd/geth/chaincmd.go @@ -325,7 +325,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) } diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 31f19e7a32..c02e307bdc 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -291,7 +291,7 @@ func makeFullNode(ctx *cli.Context) *node.Node { } 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 { From e1047b9c8489ed2e26845498b58e3e30dad66f1c Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Mon, 11 May 2026 16:25:57 +0200 Subject: [PATCH 166/183] core: use uint256 in core.Message (#34934) Changes core.Message to use Uint256 which is faster --------- Co-authored-by: Gary Rong --- common/hexutil/json.go | 4 + core/evm.go | 2 +- core/state_processor.go | 19 ++-- core/state_transition.go | 151 ++++++++++++++++++---------- eth/gasestimator/gasestimator.go | 16 +-- internal/ethapi/transaction_args.go | 24 +++-- tests/state_test.go | 3 +- tests/state_test_util.go | 10 +- 8 files changed, 142 insertions(+), 87 deletions(-) diff --git a/common/hexutil/json.go b/common/hexutil/json.go index 6b9f412078..c00cd879c8 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/core/evm.go b/core/evm.go index 818b23bee5..73e4c01a99 100644 --- a/core/evm.go +++ b/core/evm.go @@ -87,7 +87,7 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common func NewEVMTxContext(msg *Message) vm.TxContext { ctx := vm.TxContext{ Origin: msg.From, - GasPrice: uint256.MustFromBig(msg.GasPrice), + GasPrice: msg.GasPrice, BlobHashes: msg.BlobHashes, } return ctx diff --git a/core/state_processor.go b/core/state_processor.go index 54ebbd047b..9dcb4cf07c 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -32,6 +32,7 @@ import ( "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 @@ -254,9 +255,9 @@ 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[:], } @@ -281,9 +282,9 @@ 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(), } @@ -321,9 +322,9 @@ 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)) diff --git a/core/state_transition.go b/core/state_transition.go index b5b8b22155..fcd483eeb7 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -210,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 @@ -238,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: tx.GasPrice(), - GasFeeCap: tx.GasFeeCap(), - GasTipCap: 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 @@ -333,32 +365,55 @@ 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 { @@ -371,8 +426,7 @@ func (st *stateTransition) buyGas() error { st.gasRemaining = vm.NewGasBudget(st.msg.GasLimit) st.initialBudget = st.gasRemaining.Copy() - mgvalU256, _ := uint256.FromBig(mgval) - st.state.SubBalance(st.msg.From, mgvalU256, tracing.BalanceDecreaseGasBuy) + st.state.SubBalance(st.msg.From, mgval, tracing.BalanceDecreaseGasBuy) return nil } @@ -412,21 +466,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) } @@ -460,7 +506,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) } @@ -543,9 +589,9 @@ 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()) @@ -629,9 +675,12 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { } 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 @@ -639,7 +688,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 @@ -741,7 +790,7 @@ func (st *stateTransition) calcRefund() vm.GasBudget { // exchanged at the original rate. func (st *stateTransition) returnGas() { remaining := uint256.NewInt(st.gasRemaining.RegularGas) - remaining.Mul(remaining, uint256.MustFromBig(st.msg.GasPrice)) + 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.RegularGas > 0 { diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index ace0752037..f45fc0d8c9 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -22,13 +22,13 @@ import ( "fmt" "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/log" "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" ) // Options are the contextual parameters to execute the requested call. @@ -70,17 +70,17 @@ func Estimate(ctx context.Context, call *core.Message, opts *Options, gasCap uin } // 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 { @@ -90,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 { @@ -99,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) diff --git a/internal/ethapi/transaction_args.go b/internal/ethapi/transaction_args.go index 4fb30e6289..1032d067f1 100644 --- a/internal/ethapi/transaction_args.go +++ b/internal/ethapi/transaction_args.go @@ -446,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 } @@ -477,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, @@ -488,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/tests/state_test.go b/tests/state_test.go index 8444d211cf..cf1d4bce4c 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) { @@ -329,7 +328,7 @@ func runBenchmark(b *testing.B, t *StateTest) { initialGas := vm.NewGasBudget(msg.GasLimit) // Execute the message. - _, leftOverGas, err := evm.Call(sender.Address(), *msg.To, msg.Data, initialGas.Copy(), 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 diff --git a/tests/state_test_util.go b/tests/state_test_util.go index f7cf1c0697..e33e15fc8c 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -479,15 +479,15 @@ 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 From 117e067f0f0bae1a17082321f224dedb6765b10f Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 11 May 2026 23:19:24 +0800 Subject: [PATCH 167/183] version: release go-ethereum v1.17.3 stable (#34937) --- version/version.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/version/version.go b/version/version.go index ea1f5fc632..4b64b58bb7 100644 --- a/version/version.go +++ b/version/version.go @@ -17,8 +17,8 @@ package version const ( - Major = 1 // Major version component of the current release - Minor = 17 // Minor version component of the current release - Patch = 3 // Patch version component of the current release - Meta = "unstable" // Version metadata to append to the version string + Major = 1 // Major version component of the current release + Minor = 17 // Minor version component of the current release + Patch = 3 // Patch version component of the current release + Meta = "stable" // Version metadata to append to the version string ) From 8b39453122d9df81744fe44a7c1f3d6c4de88ab4 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Mon, 11 May 2026 23:57:06 +0800 Subject: [PATCH 168/183] version: start release 1.17.4 cycle (#34938) --- version/version.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/version/version.go b/version/version.go index 4b64b58bb7..5d402f3009 100644 --- a/version/version.go +++ b/version/version.go @@ -17,8 +17,8 @@ package version const ( - Major = 1 // Major version component of the current release - Minor = 17 // Minor version component of the current release - Patch = 3 // Patch version component of the current release - Meta = "stable" // Version metadata to append to the version string + Major = 1 // Major 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 ) From 22919cec1b257b3f2d3a2c348f432c08efae7114 Mon Sep 17 00:00:00 2001 From: rayoo Date: Tue, 12 May 2026 03:21:31 +0800 Subject: [PATCH 169/183] eth/tracers: fix data race on interruption reason across tracers (#34827) Every tracer that implements Stop/GetResult held a `reason error` field that is written by Stop (called from the trace-timeout watchdog goroutine in api.go) and read by GetResult (called by the RPC handler main goroutine). These accesses were unsynchronized. --- eth/tracers/logger/logger.go | 12 ++--- eth/tracers/native/4byte.go | 13 +++-- eth/tracers/native/call.go | 11 +++-- eth/tracers/native/call_flat.go | 5 +- eth/tracers/native/erc7562.go | 16 +++++-- eth/tracers/native/prestate.go | 11 +++-- eth/tracers/native/tracer_test.go | 80 +++++++++++++++++++++++++++++++ 7 files changed, 123 insertions(+), 25 deletions(-) create mode 100644 eth/tracers/native/tracer_test.go diff --git a/eth/tracers/logger/logger.go b/eth/tracers/logger/logger.go index 7f2b2aecf2..8e445818ef 100644 --- a/eth/tracers/logger/logger.go +++ b/eth/tracers/logger/logger.go @@ -229,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. @@ -357,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) @@ -376,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/native/4byte.go b/eth/tracers/native/4byte.go index cec45a1e7a..a542eeffa2 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 06220da84d..dfa804827b 100644 --- a/eth/tracers/native/call.go +++ b/eth/tracers/native/call.go @@ -116,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 { @@ -268,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 4e7fc31a9c..484f2d4e3b 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 34e202f667..0bf80d77b5 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) } diff --git a/eth/tracers/native/prestate.go b/eth/tracers/native/prestate.go index 36cb16e44b..7026cca7f3 100644 --- a/eth/tracers/native/prestate.go +++ b/eth/tracers/native/prestate.go @@ -71,8 +71,8 @@ type prestateTracer struct { to common.Address 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 } @@ -240,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) } diff --git a/eth/tracers/native/tracer_test.go b/eth/tracers/native/tracer_test.go new file mode 100644 index 0000000000..70e6283d34 --- /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() + }) + } +} From 298c83502bae65bf4178159114b5a6f689f1e8b3 Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Tue, 12 May 2026 03:32:19 +0800 Subject: [PATCH 170/183] cmd/evm: fix gasUsed in evm run cmd (#34732) In the --create path, execFunc returns gasLeft as the second return value, but the rest of the code treats this value as "gas used" (printed as such, and compared in timedExec). This makes gas reporting incorrect and can cause benchmark consistency checks to fail. --- cmd/evm/runner.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index 82e7bdff3d..6d80056d04 100644 --- a/cmd/evm/runner.go +++ b/cmd/evm/runner.go @@ -321,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 { From 56d391b60157234474bcdfba0545c2cbd4898c4b Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Tue, 12 May 2026 04:17:48 +0800 Subject: [PATCH 171/183] cmd, core, internal, miner: wrap pre/post-execution (#34812) This is a refactoring PR to wrap all pre/post-execution system calls as the exported functions, eliminating the duplicated system calls across the codebase. There are a few things unchanged but worths highlight: - ChainMaker is left as unchanged, a significant rewrite is required - BeaconRoot in header should be non-nil if Cancun is enabled --------- Co-authored-by: jwasinger --- cmd/evm/internal/t8ntool/execution.go | 28 +++++---------- core/chain_makers.go | 32 ++++++----------- core/state_processor.go | 52 +++++++++++++++------------ eth/state_accessor.go | 11 +++--- eth/tracers/api.go | 48 ++++++++++--------------- internal/ethapi/simulate.go | 29 ++++----------- miner/worker.go | 26 +++----------- 7 files changed, 82 insertions(+), 144 deletions(-) diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index 253ebe1111..15973e934d 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -17,6 +17,7 @@ package t8ntool import ( + "context" "encoding/json" "fmt" stdmath "math" @@ -331,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) + 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 { diff --git a/core/chain_makers.go b/core/chain_makers.go index 46cd98de61..7474d892b1 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -17,6 +17,7 @@ package core import ( + "context" "fmt" "math/big" @@ -314,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) + if err != nil { + panic(fmt.Sprintf("failed to run post-execution: %v", err)) } return requests } diff --git a/core/state_processor.go b/core/state_processor.go index 9dcb4cf07c..4bffece7ac 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -76,28 +76,18 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated 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) defer evm.Release() - - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if config.IsPrague(block.Number(), block.Time()) || config.IsUBT(block.Number(), block.Time()) { - ProcessParentBlockHash(block.ParentHash(), evm) - } - + // 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) @@ -119,11 +109,11 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated allLogs = append(allLogs, receipt.Logs...) spanEnd(nil) } - requests, err := postExecution(ctx, config, block, allLogs, evm) + // Run the post-execution system calls + requests, err := PostExecution(ctx, config, block.Number(), block.Time(), allLogs, evm) 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()) @@ -135,28 +125,44 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated }, nil } -// postExecution processes the post-execution system calls if Prague is enabled. -func postExecution(ctx context.Context, config *params.ChainConfig, block *types.Block, allLogs []*types.Log, evm *vm.EVM) (requests [][]byte, err error) { +// 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) (requests [][]byte, err error) { _, _, spanEnd := telemetry.StartSpan(ctx, "core.postExecution") defer spanEnd(&err) // Read requests if Prague is enabled. - 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 requests, fmt.Errorf("failed to parse deposit logs: %w", err) + return nil, fmt.Errorf("failed to parse deposit logs: %w", err) } // EIP-7002 if err := ProcessWithdrawalQueue(&requests, evm); err != nil { - return requests, fmt.Errorf("failed to process withdrawal queue: %w", err) + return nil, fmt.Errorf("failed to process withdrawal queue: %w", err) } // EIP-7251 if err := ProcessConsolidationQueue(&requests, evm); err != nil { - return requests, fmt.Errorf("failed to process consolidation queue: %w", err) + return nil, fmt.Errorf("failed to process consolidation queue: %w", err) } } - return requests, nil } diff --git a/eth/state_accessor.go b/eth/state_accessor.go index a806a4fc56..53dfb7d458 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -248,13 +248,10 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil) evm := vm.NewEVM(context, statedb, eth.blockchain.Config(), vm.Config{}) defer evm.Release() - 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) - } + + // 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 } diff --git a/eth/tracers/api.go b/eth/tracers/api.go index dae11b81de..d9e40f7ec1 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -372,13 +372,8 @@ 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 @@ -494,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 { @@ -517,21 +512,19 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config 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{}) defer evm.Release() - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if chainConfig.IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + // 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 @@ -548,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)) } @@ -587,12 +580,9 @@ 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{}) defer evm.Release() - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if api.backend.ChainConfig().IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + + // 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 @@ -760,15 +750,12 @@ 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{}) defer evm.Release() - if beaconRoot := block.BeaconRoot(); beaconRoot != nil { - core.ProcessBeaconBlockRoot(*beaconRoot, evm) - } - if chainConfig.IsPrague(block.Number(), block.Time()) { - core.ProcessParentBlockHash(block.ParentHash(), evm) - } + + // 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()) @@ -795,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) diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index e3a14bf5d6..170104fbdf 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -318,12 +318,9 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, if precompiles != nil { evm.SetPrecompiles(precompiles) } - if sim.chainConfig.IsPrague(header.Number, header.Time) || sim.chainConfig.IsUBT(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 @@ -393,22 +390,10 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, header.BlobGasUsed = &blobGasUsed } - // Process EIP-7685 requests - var requests [][]byte - 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 - } + // Run post-execution system calls + requests, err := core.PostExecution(ctx, sim.chainConfig, header.Number, header.Time, allLogs, evm) + if err != nil { + return nil, nil, nil, err } if requests != nil { reqHash := types.CalcRequestsHash(requests) diff --git a/miner/worker.go b/miner/worker.go index 42e3695025..ccafa20b29 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -208,21 +208,9 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams, } // 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) + if err != nil { + return &newPayloadResult{err: err} } if requests != nil { reqHash := types.CalcRequestsHash(requests) @@ -329,12 +317,8 @@ func (miner *Miner) prepareWork(ctx context.Context, genParams *generateParams, 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 } From c16684c1eec23bdc3f806827713aad380a6a90f3 Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Tue, 12 May 2026 02:33:43 +0200 Subject: [PATCH 172/183] internal/ethapi: fix withdrawal regression in eth_simulateV1 (#34939) Fixes the regression caught by https://hive.ethpandaops.io/#/test/generic/1778481210-e59b7465e1d04f7ed1b0200838584b16?testnumber=137. engine.AssembleBlock explicitly expects withdrawals to be non-nil for pre-Shanghai blocks as opposed to FinaliseAndAssemble which stripped off the withdrawal. --- internal/ethapi/api_test.go | 61 +++++++++++++++++++++++++++++++++++++ internal/ethapi/simulate.go | 7 ++++- 2 files changed, 67 insertions(+), 1 deletion(-) diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go index 161d97b4eb..63e75bd3e3 100644 --- a/internal/ethapi/api_test.go +++ b/internal/ethapi/api_test.go @@ -2680,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 diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index 170104fbdf..c34970578c 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -402,7 +402,12 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, blockBody := &types.Body{ Transactions: txes, - Withdrawals: *block.BlockOverrides.Withdrawals, // Withdrawal is also sanitized as non-nil + } + // 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} From d446676fc448ff6ea3e14f9bcfe725d70e1c49ee Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 12 May 2026 10:05:39 +0800 Subject: [PATCH 173/183] core: write head hash to db after snap sync is complete (#34912) --- core/blockchain.go | 1 + 1 file changed, 1 insertion(+) diff --git a/core/blockchain.go b/core/blockchain.go index 2b49111121..7b5a910b7a 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -1186,6 +1186,7 @@ func (bc *BlockChain) SnapSyncComplete(hash common.Hash) error { } // If all checks out, manually set the head block. + rawdb.WriteHeadBlockHash(bc.db, hash) bc.currentBlock.Store(block.Header()) headBlockGauge.Update(int64(block.NumberU64())) From ab28bda83ecb1e73cd2549b08edfb8f3c683ea13 Mon Sep 17 00:00:00 2001 From: Lessa <230214854+adblesss@users.noreply.github.com> Date: Tue, 12 May 2026 06:16:44 -0400 Subject: [PATCH 174/183] eth/catalyst: fix getBlobsV3 partial/complete metrics (#34666) In b2843a11d, metrics check len(res) == len(hashes) but res is pre-allocated with make(), so length is always equal. Partial hit metric never fires. Count non-nil elements instead. --------- Co-authored-by: Bosul Mun --- eth/catalyst/api.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/eth/catalyst/api.go b/eth/catalyst/api.go index b81ed57a2c..1def169ae0 100644 --- a/eth/catalyst/api.go +++ b/eth/catalyst/api.go @@ -646,6 +646,7 @@ func (api *ConsensusAPI) getBlobs(hashes []common.Hash, v2 bool) ([]*engine.Blob return nil, engine.InvalidParams.With(err) } // Validate the blobs from the pool and assemble the response + filled := 0 res := make([]*engine.BlobAndProofV2, len(hashes)) for i := range blobs { // The blob has been evicted since the last AvailableBlobs call. @@ -666,10 +667,11 @@ func (api *ConsensusAPI) getBlobs(hashes []common.Hash, v2 bool) ([]*engine.Blob Blob: blobs[i][:], CellProofs: cellProofs, } + filled++ } - if len(res) == len(hashes) { + if filled == len(hashes) { getBlobsRequestCompleteHit.Inc(1) - } else if len(res) > 0 { + } else if filled > 0 { getBlobsRequestPartialHit.Inc(1) } else { getBlobsRequestMiss.Inc(1) From 726d657a4a03015171b649daca70abf6a54a9d6b Mon Sep 17 00:00:00 2001 From: Bosul Mun Date: Tue, 12 May 2026 13:59:33 +0200 Subject: [PATCH 175/183] core/txpool/blobpool: add blobTxForPool type (#34882) This PR introduces a separate transaction pool type for sparse blobpool. In sparse blobpool, PooledTransactions message delivers transactions without blobs, partial or full cells are downloaded by Cells message. Blobpool no longer stores transactions with complete sidecars, and it stores transactions without blobs, along with the corresponding cells. Because of this, a dedicated type distinct from types.Transaction is required. This PR introduces a type called `BlobTxForPool` and stores each sidecar field independently, in order to bypass the assumption that a sidecar always exists as a complete unit. Reintroducing the conversion queue was considered, but was ultimately omitted because type conversion should be sufficiently fast. With sparse blobpool, blob -> cell computation would take about ~13ms per blob. Not sure whether this is fast enough, but otherwise we can add the conversion queue later on the sparse blobpool branch. --- core/txpool/blobpool/blobpool.go | 311 +++++++++++++++++++------- core/txpool/blobpool/blobpool_test.go | 163 +++++++++++--- core/txpool/blobpool/limbo.go | 27 ++- 3 files changed, 386 insertions(+), 115 deletions(-) diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index f2e0d5f9d2..f8021e00c4 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -116,6 +116,8 @@ const ( 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 @@ -147,28 +149,137 @@ 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 = dynamicBlobFeeJumps(meta.blobFeeCap) @@ -460,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) @@ -472,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) - for _, id := range fails { + // 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 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 { @@ -558,36 +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. -// Announced state is not initialized here, it needs to be iniitalized seprately. +// 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 { @@ -863,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 } @@ -1108,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 @@ -1124,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} @@ -1404,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 @@ -1486,18 +1650,14 @@ func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte) ([]*kzg4844.Blo } // 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 @@ -1644,7 +1804,8 @@ func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (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 @@ -1653,7 +1814,7 @@ func (p *BlobPool) addLocked(tx *types.Transaction, checkGapped bool) (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) diff --git a/core/txpool/blobpool/blobpool_test.go b/core/txpool/blobpool/blobpool_test.go index 7c57755401..8032e21e8a 100644 --- a/core/txpool/blobpool/blobpool_test.go +++ b/core/txpool/blobpool/blobpool_test.go @@ -235,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 { @@ -530,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 { @@ -547,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{}{} @@ -560,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{}{} @@ -573,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 { @@ -595,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{}{} @@ -614,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 { @@ -636,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{}{} @@ -654,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 { @@ -670,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 { @@ -686,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) @@ -705,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 { @@ -842,7 +848,7 @@ func TestOpenIndex(t *testing.T) { ) 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() @@ -934,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} @@ -1009,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} @@ -1098,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 @@ -1201,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 @@ -1281,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 ( @@ -1746,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) } } @@ -1853,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 @@ -2055,6 +2140,32 @@ func TestGetBlobs(t *testing.T) { pool.Close() } +// 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) }) +} + +func testEncodeForNetwork(t *testing.T, version byte) { + key, _ := crypto.GenerateKey() + tx := makeMultiBlobTx(0, 1, 1, 1, 1, 0, key, version) + + wantRLP, err := rlp.EncodeToBytes(tx) + if err != nil { + t.Fatalf("failed to encode tx: %v", err) + } + storedRLP := encodeForPool(tx) + + gotRLP, err := encodeForNetwork(storedRLP) + if err != nil { + t.Fatalf("encodeForNetwork failed: %v", err) + } + if !bytes.Equal(gotRLP, wantRLP) { + t.Fatalf("network encoding mismatch (version %d): got %d bytes, want %d bytes", version, len(gotRLP), len(wantRLP)) + } +} + // fakeBilly is a billy.Database implementation which just drops data on the floor. type fakeBilly struct { billy.Database diff --git a/core/txpool/blobpool/limbo.go b/core/txpool/blobpool/limbo.go index 36284d6a03..b8bee2f22a 100644 --- a/core/txpool/blobpool/limbo.go +++ b/core/txpool/blobpool/limbo.go @@ -33,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 @@ -146,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 @@ -163,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. @@ -177,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 @@ -209,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 } @@ -240,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 { From 91f8e7cd9ef38e9e87385557840179d8335ef38b Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 12 May 2026 20:49:33 +0800 Subject: [PATCH 176/183] internal/ethapi: add balHash to block results (#34652) --- internal/ethapi/api.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 6fc43a370b..6d38c6c7c8 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -996,6 +996,9 @@ 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) } From 6af374e6aa35d9a6be18184ffa831815dbc42155 Mon Sep 17 00:00:00 2001 From: cui Date: Tue, 12 May 2026 20:50:04 +0800 Subject: [PATCH 177/183] accounts/abi: fix unittest code (#34740) 1. should use !reflect.DeepEqual. 2. big.NewInt(0).SetBits([]big.Word{}) work around for DeepEqual when big.Int is zero, unpack return a []big.Word{}. --- accounts/abi/unpack_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go index 90713c03ca..90cfa68655 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") } } From 21c5a287f91640f383bc09ffe97d922999e171c7 Mon Sep 17 00:00:00 2001 From: Richard Creighton Date: Tue, 12 May 2026 14:02:40 +0100 Subject: [PATCH 178/183] cmd/abigen: respect --v2=false (#34943) Passing `--v2=false` currently still selects the v2 binding generator because the command checks whether the flag was set. This switches generation to use the boolean flag value, so explicit false continues to generate legacy bindings while `--v2` keeps selecting v2. --- cmd/abigen/main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/abigen/main.go b/cmd/abigen/main.go index c82358be49..d9d1fa02ac 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) From 0494cdce23dcbad953f488a62b15eb024cdc7e16 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Wed, 13 May 2026 16:53:47 +0800 Subject: [PATCH 179/183] core: introduce GasChangeHook v2 (#34946) This PR introduces OnGasChangeV2 tracing hook, as the pre-requisite for landing EIP-8037. --------- Co-authored-by: Sina M <1591639+s1na@users.noreply.github.com> --- core/state_transition.go | 27 +++++++----- core/tracing/hooks.go | 87 ++++++++++++++++++++++++++++++++++---- core/vm/contract.go | 8 ++-- core/vm/contracts.go | 4 +- core/vm/evm.go | 38 +++++++++-------- core/vm/gascosts.go | 29 ++++++++----- core/vm/interpreter.go | 8 +++- eth/tracers/live/noop.go | 4 ++ eth/tracers/native/mux.go | 19 +++++---- eth/tracers/native/noop.go | 3 ++ 10 files changed, 164 insertions(+), 63 deletions(-) diff --git a/core/state_transition.go b/core/state_transition.go index fcd483eeb7..0a6994505d 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -420,8 +420,10 @@ func (st *stateTransition) buyGas() error { 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 = vm.NewGasBudget(st.msg.GasLimit) st.initialBudget = st.gasRemaining.Copy() @@ -566,8 +568,8 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { if !sufficient { return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gasRemaining.RegularGas, cost.RegularGas) } - if t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil { - t.OnGasChange(prior, st.gasRemaining.RegularGas, tracing.GasChangeTxIntrinsicGas) + 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 { @@ -651,8 +653,8 @@ func (st *stateTransition) execute() (*ExecutionResult, error) { // After EIP-7623: Data-heavy transactions pay the floor gas. if used := st.gasUsed(); used < floorDataGas { prior, _ := st.gasRemaining.Charge(vm.GasCosts{RegularGas: floorDataGas - used}) - if t := st.evm.Config.Tracer; t != nil && t.OnGasChange != nil { - t.OnGasChange(prior, st.gasRemaining.RegularGas, tracing.GasChangeTxDataFloor) + if st.evm.Config.Tracer.HasGasHook() { + st.evm.Config.Tracer.EmitGasChange(prior.AsTracing(), st.gasRemaining.AsTracing(), tracing.GasChangeTxDataFloor) } } if peakGasUsed < floorDataGas { @@ -780,8 +782,11 @@ func (st *stateTransition) calcRefund() vm.GasBudget { 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.RegularGas, st.gasRemaining.RegularGas+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 vm.NewGasBudget(refund) } @@ -793,8 +798,10 @@ func (st *stateTransition) returnGas() { 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.RegularGas > 0 { - st.evm.Config.Tracer.OnGasChange(st.gasRemaining.RegularGas, 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) } } diff --git a/core/tracing/hooks.go b/core/tracing/hooks.go index 62c62ac3b3..6ea3f7ebbf 100644 --- a/core/tracing/hooks.go +++ b/core/tracing/hooks.go @@ -164,10 +164,36 @@ 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) - // TODO(sina, rjl), please add GasChangeV2Hook by landing the multi-dimensional gas + // 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 - @@ -250,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 @@ -280,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 @@ -335,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. // diff --git a/core/vm/contract.go b/core/vm/contract.go index a55a5dde8b..45c879c80f 100644 --- a/core/vm/contract.go +++ b/core/vm/contract.go @@ -131,8 +131,8 @@ func (c *Contract) UseGas(cost GasCosts, logger *tracing.Hooks, reason tracing.G if !ok { return false } - if logger != nil && logger.OnGasChange != nil && reason != tracing.GasChangeIgnored { - logger.OnGasChange(prior, c.Gas.RegularGas, reason) + if logger.HasGasHook() && reason != tracing.GasChangeIgnored { + logger.EmitGasChange(prior.AsTracing(), c.Gas.AsTracing(), reason) } return true } @@ -143,8 +143,8 @@ func (c *Contract) RefundGas(refund GasBudget, logger *tracing.Hooks, reason tra if !changed { return } - if logger != nil && logger.OnGasChange != nil && reason != tracing.GasChangeIgnored { - logger.OnGasChange(prior, c.Gas.RegularGas, reason) + if logger.HasGasHook() && reason != tracing.GasChangeIgnored { + logger.EmitGasChange(prior.AsTracing(), c.Gas.AsTracing(), reason) } } diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 6dadb64873..71cfdbc527 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -269,8 +269,8 @@ func RunPrecompiledContract(stateDB StateDB, p PrecompiledContract, address comm gas.Exhaust() return nil, gas, ErrOutOfGas } - if logger != nil && logger.OnGasChange != nil { - logger.OnGasChange(prior, gas.RegularGas, 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. diff --git a/core/vm/evm.go b/core/vm/evm.go index 26b2f73a00..9fe6faa3a2 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -317,8 +317,8 @@ 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.RegularGas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } gas.Exhaust() } @@ -371,8 +371,8 @@ 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.RegularGas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } gas.Exhaust() } @@ -415,8 +415,8 @@ 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.RegularGas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } gas.Exhaust() } @@ -470,8 +470,8 @@ 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.RegularGas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } gas.Exhaust() } @@ -509,8 +509,8 @@ func (evm *EVM) create(caller common.Address, code []byte, gas GasBudget, value gas.Exhaust() return nil, common.Address{}, gas, ErrOutOfGas } - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(prior, gas.RegularGas, tracing.GasChangeWitnessContractCollisionCheck) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(prior.AsTracing(), gas.AsTracing(), tracing.GasChangeWitnessContractCollisionCheck) } } @@ -528,8 +528,8 @@ func (evm *EVM) create(caller common.Address, code []byte, gas GasBudget, value if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != types.EmptyCodeHash) || // non-empty code isEIP7610RejectedAccount(evm.ChainConfig().ChainID, address, evm.chainRules.IsEIP158) { - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(gas.RegularGas, 0, tracing.GasChangeCallFailedExecution) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(gas.AsTracing(), tracing.Gas{}, tracing.GasChangeCallFailedExecution) } gas.Exhaust() return nil, common.Address{}, gas, ErrContractAddressCollision @@ -558,8 +558,8 @@ func (evm *EVM) create(caller common.Address, code []byte, gas GasBudget, value return nil, common.Address{}, gas, ErrOutOfGas } prior, _ := gas.Charge(GasCosts{RegularGas: consumed}) - if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil { - evm.Config.Tracer.OnGasChange(prior, gas.RegularGas, tracing.GasChangeWitnessContractInit) + if evm.Config.Tracer.HasGasHook() { + evm.Config.Tracer.EmitGasChange(prior.AsTracing(), gas.AsTracing(), tracing.GasChangeWitnessContractInit) } } evm.Context.Transfer(evm.StateDB, caller, address, value, &evm.chainRules) @@ -673,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/gascosts.go b/core/vm/gascosts.go index cc90c54798..ed938ae41f 100644 --- a/core/vm/gascosts.go +++ b/core/vm/gascosts.go @@ -16,7 +16,11 @@ package vm -import "fmt" +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 @@ -77,21 +81,26 @@ func (g GasBudget) CanAfford(cost GasCosts) bool { } // Charge deducts the given gas cost from the budget. It returns the -// pre-charge gas value and false if the budget does not have sufficient +// pre-charge budget and false if the budget does not have sufficient // gas to cover the cost. -func (g *GasBudget) Charge(cost GasCosts) (uint64, bool) { - prior := g.RegularGas - if prior < cost.RegularGas { +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 gas -// value and whether the budget was actually changed. -func (g *GasBudget) Refund(other GasBudget) (uint64, bool) { - prior := g.RegularGas +// 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 + 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/interpreter.go b/core/vm/interpreter.go index 4c278fc857..3994327247 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -234,8 +234,12 @@ func (evm *EVM) Run(contract *Contract, input []byte, readOnly bool) (ret []byte // 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/eth/tracers/live/noop.go b/eth/tracers/live/noop.go index f3def85606..b1784dbd91 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/native/mux.go b/eth/tracers/native/mux.go index bb2101deec..73f8585a6b 100644 --- a/eth/tracers/native/mux.go +++ b/eth/tracers/native/mux.go @@ -65,10 +65,11 @@ func newMuxTracerFromConfig(ctx *tracers.Context, cfg json.RawMessage, chainConf // the aggregated JSON result returned by GetResult. // // For hooks that have both a V1 and V2 form (OnCodeChange / OnCodeChangeV2, -// OnNonceChange / OnNonceChangeV2, 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. +// 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{ @@ -79,7 +80,7 @@ func NewMuxTracer(names []string, objects []*tracers.Tracer) (*tracers.Tracer, e OnExit: t.OnExit, OnOpcode: t.OnOpcode, OnFault: t.OnFault, - OnGasChange: t.OnGasChange, + OnGasChangeV2: t.OnGasChangeV2, OnBalanceChange: t.OnBalanceChange, OnNonceChangeV2: t.OnNonceChangeV2, OnCodeChangeV2: t.OnCodeChangeV2, @@ -109,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) } } } diff --git a/eth/tracers/native/noop.go b/eth/tracers/native/noop.go index ac174cc25e..323bf4338f 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) { } From b2aa6987ded983b98a56ad14aff0708e9b003567 Mon Sep 17 00:00:00 2001 From: rjl493456442 Date: Wed, 13 May 2026 20:38:47 +0800 Subject: [PATCH 180/183] core/state: track the block-level accessList (#34803) This PR extends the journal to track the pre-transaction values of mutated balances, nonces, and code. At the end of the transaction, these values are used to filter out no-op changes, such as balance transitions from a-> b->a. These changes are excluded from the block-level access list. Additionally, there is a dedicated `bal.ConstructionBlockAccessList` objects for gathering the state reads and writes within the current transaction. These state writes will be keyed by the block accessList index. --------- Co-authored-by: jwasinger --- cmd/evm/internal/t8ntool/execution.go | 4 +- core/chain_makers.go | 4 +- core/state/journal.go | 274 +++++++++++++++++++++----- core/state/journal_test.go | 219 ++++++++++++++++++++ core/state/state_object.go | 12 +- core/state/statedb.go | 84 ++++++-- core/state/statedb_hooked.go | 8 +- core/state/statedb_hooked_test.go | 2 +- core/state/statedb_test.go | 86 ++++++-- core/state_prefetcher.go | 2 +- core/state_processor.go | 24 +-- core/types/bal/access_list.go | 94 --------- core/types/bal/bal.go | 6 +- core/vm/interface.go | 3 +- eth/state_accessor.go | 2 +- eth/tracers/api.go | 8 +- internal/ethapi/simulate.go | 6 +- miner/worker.go | 6 +- 18 files changed, 624 insertions(+), 220 deletions(-) create mode 100644 core/state/journal_test.go delete mode 100644 core/types/bal/access_list.go diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index 15973e934d..a2de58ad46 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -270,7 +270,7 @@ 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() gp = gaspool.Snapshot() @@ -336,7 +336,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig, for _, receipt := range receipts { allLogs = append(allLogs, receipt.Logs...) } - requests, err := core.PostExecution(context.Background(), chainConfig, vmContext.BlockNumber, vmContext.Time, allLogs, evm) + 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)) } diff --git a/core/chain_makers.go b/core/chain_makers.go index 7474d892b1..cfd6302794 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -117,7 +117,7 @@ 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)) + 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) @@ -323,7 +323,7 @@ func (b *BlockGen) collectRequests(readonly bool) (requests [][]byte) { blockContext := NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase) evm := vm.NewEVM(blockContext, statedb, b.cm.config, vm.Config{}) - requests, err := PostExecution(context.Background(), b.cm.config, b.header.Number, b.header.Time, blockLogs, evm) + 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)) } diff --git a/core/state/journal.go b/core/state/journal.go index a79bd7331a..353144a1c7 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -18,7 +18,6 @@ package state import ( "fmt" - "maps" "slices" "sort" @@ -32,26 +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. - // indicates false if no address was changed. - dirtied() (common.Address, bool) + // 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 @@ -60,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), } } @@ -70,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 } @@ -101,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, dirty := entry.dirtied(); dirty { - 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, dirty := j.entries[i].dirtied(); dirty { - 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. @@ -141,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, } @@ -187,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, @@ -201,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, @@ -212,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() } } @@ -295,8 +467,8 @@ func (ch createObjectChange) revert(s *StateDB) { delete(s.stateObjects, ch.account) } -func (ch createObjectChange) dirtied() (common.Address, bool) { - return ch.account, true +func (ch createObjectChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindCreate, true } func (ch createObjectChange) copy() journalEntry { @@ -309,8 +481,8 @@ func (ch createContractChange) revert(s *StateDB) { s.getStateObject(ch.account).newContract = false } -func (ch createContractChange) dirtied() (common.Address, bool) { - return common.Address{}, false +func (ch createContractChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch createContractChange) copy() journalEntry { @@ -326,8 +498,8 @@ func (ch selfDestructChange) revert(s *StateDB) { } } -func (ch selfDestructChange) dirtied() (common.Address, bool) { - return ch.account, true +func (ch selfDestructChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindSelfDestruct, true } func (ch selfDestructChange) copy() journalEntry { @@ -341,8 +513,8 @@ var ripemd = common.HexToAddress("0000000000000000000000000000000000000003") func (ch touchChange) revert(s *StateDB) { } -func (ch touchChange) dirtied() (common.Address, bool) { - return ch.account, true +func (ch touchChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindTouch, true } func (ch touchChange) copy() journalEntry { @@ -355,8 +527,8 @@ func (ch balanceChange) revert(s *StateDB) { s.getStateObject(ch.account).setBalance(ch.prev) } -func (ch balanceChange) dirtied() (common.Address, bool) { - return ch.account, true +func (ch balanceChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindBalance, true } func (ch balanceChange) copy() journalEntry { @@ -370,8 +542,8 @@ func (ch nonceChange) revert(s *StateDB) { s.getStateObject(ch.account).setNonce(ch.prev) } -func (ch nonceChange) dirtied() (common.Address, bool) { - return ch.account, true +func (ch nonceChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindNonce, true } func (ch nonceChange) copy() journalEntry { @@ -385,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, bool) { - return ch.account, true +func (ch codeChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindCode, true } func (ch codeChange) copy() journalEntry { @@ -400,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, bool) { - return ch.account, true +func (ch storageChange) mutation() (common.Address, journalMutationKind, bool) { + return ch.account, journalMutationKindStorage, true } func (ch storageChange) copy() journalEntry { @@ -417,8 +589,8 @@ func (ch transientStorageChange) revert(s *StateDB) { s.setTransientState(ch.account, ch.key, ch.prevalue) } -func (ch transientStorageChange) dirtied() (common.Address, bool) { - return common.Address{}, false +func (ch transientStorageChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch transientStorageChange) copy() journalEntry { @@ -433,8 +605,8 @@ func (ch refundChange) revert(s *StateDB) { s.refund = ch.prev } -func (ch refundChange) dirtied() (common.Address, bool) { - return common.Address{}, false +func (ch refundChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch refundChange) copy() journalEntry { @@ -453,8 +625,8 @@ func (ch addLogChange) revert(s *StateDB) { s.logSize-- } -func (ch addLogChange) dirtied() (common.Address, bool) { - return common.Address{}, false +func (ch addLogChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch addLogChange) copy() journalEntry { @@ -476,8 +648,8 @@ func (ch accessListAddAccountChange) revert(s *StateDB) { s.accessList.DeleteAddress(ch.address) } -func (ch accessListAddAccountChange) dirtied() (common.Address, bool) { - return common.Address{}, false +func (ch accessListAddAccountChange) mutation() (common.Address, journalMutationKind, bool) { + return common.Address{}, journalMutationKindNone, false } func (ch accessListAddAccountChange) copy() journalEntry { @@ -490,8 +662,8 @@ func (ch accessListAddSlotChange) revert(s *StateDB) { s.accessList.DeleteSlot(ch.address, ch.slot) } -func (ch accessListAddSlotChange) dirtied() (common.Address, bool) { - return common.Address{}, false +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 0000000000..262cee77fe --- /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/state_object.go b/core/state/state_object.go index 8e72486825..ce456e7668 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -184,8 +184,9 @@ func (s *stateObject) getState(key common.Hash) (common.Hash, common.Hash) { // 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. - s.db.stateReadList.AddState(s.address, key) - + 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 @@ -274,6 +275,13 @@ 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 { diff --git a/core/state/statedb.go b/core/state/statedb.go index e6d8b5bffc..1c49d46020 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -18,6 +18,7 @@ package state import ( + "bytes" "errors" "fmt" "maps" @@ -128,7 +129,10 @@ type StateDB struct { accessEvents *AccessEvents // Per-transaction state access footprint for EIP-7928 - stateReadList *bal.StateAccessList + 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 @@ -589,8 +593,9 @@ func (s *StateDB) deleteStateObject(addr common.Address) { // 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. - s.stateReadList.AddAccount(addr) - + if s.stateAccessList != nil { + s.stateAccessList.AccountRead(addr) + } // Prefer live objects if any is available if obj := s.stateObjects[addr]; obj != nil { return obj @@ -693,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), @@ -716,9 +722,6 @@ func (s *StateDB) Copy() *StateDB { if s.accessEvents != nil { state.accessEvents = s.accessEvents.Copy() } - if s.stateReadList != nil { - state.stateReadList = s.stateReadList.Copy() - } // Deep copy cached state objects. for addr, obj := range s.stateObjects { state.stateObjects[addr] = obj.deepCopy(state) @@ -740,6 +743,9 @@ func (s *StateDB) Copy() *StateDB { } state.logs[hash] = cpy } + if s.stateAccessList != nil { + state.stateAccessList = s.stateAccessList.Copy() + } return state } @@ -775,7 +781,7 @@ type removedAccountWithBalance struct { // before the Finalise. func (s *StateDB) LogsForBurnAccounts() []*types.Log { var list []removedAccountWithBalance - for addr := range s.journal.dirties { + 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, @@ -799,17 +805,20 @@ func (s *StateDB) LogsForBurnAccounts() []*types.Log { // 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) *bal.StateAccessList { - 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()) { @@ -822,7 +831,43 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { 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) } @@ -839,7 +884,7 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { // Invalidate journal because reverting across transactions is not allowed. s.clearJournalAndRefund() - return s.stateReadList + return s.stateAccessList } // IntermediateRoot computes the current root hash of the state trie. @@ -1052,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() { @@ -1435,7 +1481,7 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d s.transientStorage = newTransientStorage() if rules.IsAmsterdam { - s.stateReadList = bal.NewStateAccessList() + s.stateAccessList = bal.NewConstructionBlockAccessList() } } diff --git a/core/state/statedb_hooked.go b/core/state/statedb_hooked.go index c5faa7c98e..98d01343a4 100644 --- a/core/state/statedb_hooked.go +++ b/core/state/statedb_hooked.go @@ -234,7 +234,7 @@ func (s *hookedStateDB) LogsForBurnAccounts() []*types.Log { return s.inner.LogsForBurnAccounts() } -func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { +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) @@ -244,7 +244,7 @@ func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { // 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.dirties { + for addr := range s.inner.journal.mutations { obj := s.inner.stateObjects[addr] if obj == nil || !obj.selfDestructed { // Not self-destructed, keep searching. @@ -288,3 +288,7 @@ func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) *bal.StateAccessList { } return s.inner.Finalise(deleteEmptyObjects) } + +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 6fe17ec1b4..fad234f848 100644 --- a/core/state/statedb_hooked_test.go +++ b/core/state/statedb_hooked_test.go @@ -82,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)", diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index b5ef42b3e0..0bf9b50e7b 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -662,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{}) @@ -691,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") } } diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index ed292d0beb..d99611ff2c 100644 --- a/core/state_prefetcher.go +++ b/core/state_prefetcher.go @@ -104,7 +104,7 @@ 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. diff --git a/core/state_processor.go b/core/state_processor.go index 4bffece7ac..13466b7815 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -94,7 +94,7 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated 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)), @@ -109,8 +109,7 @@ func (p *StateProcessor) Process(ctx context.Context, block *types.Block, stated allLogs = append(allLogs, receipt.Logs...) spanEnd(nil) } - // Run the post-execution system calls - requests, err := PostExecution(ctx, config, block.Number(), block.Time(), allLogs, evm) + requests, err := PostExecution(ctx, config, block.Number(), block.Time(), allLogs, evm, uint32(len(block.Transactions())+1)) if err != nil { return nil, err } @@ -143,7 +142,7 @@ func PreExecution(ctx context.Context, beaconRoot *common.Hash, parent common.Ha // 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) (requests [][]byte, err error) { +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) @@ -155,11 +154,11 @@ func PostExecution(ctx context.Context, config *params.ChainConfig, number *big. 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) } } @@ -268,6 +267,7 @@ func ProcessBeaconBlockRoot(beaconRoot common.Hash, evm *vm.EVM) { 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, vm.NewGasBudget(30_000_000), common.U2560) if evm.StateDB.AccessEvents() != nil { @@ -295,6 +295,7 @@ func ProcessParentBlockHash(prevHash common.Hash, evm *vm.EVM) { 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, vm.NewGasBudget(30_000_000), common.U2560) if err != nil { @@ -308,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 { @@ -334,6 +335,7 @@ func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte 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, vm.NewGasBudget(30_000_000), common.U2560) if evm.StateDB.AccessEvents() != nil { diff --git a/core/types/bal/access_list.go b/core/types/bal/access_list.go deleted file mode 100644 index e563fa22e2..0000000000 --- a/core/types/bal/access_list.go +++ /dev/null @@ -1,94 +0,0 @@ -// 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 bal - -import ( - "maps" - - "github.com/ethereum/go-ethereum/common" -) - -// StorageAccessList represents a set of storage slots accessed within an account. -type StorageAccessList map[common.Hash]struct{} - -// StateAccessList records the set of accounts and storage slots that have been -// accessed. An entry with an empty StorageAccessList denotes an account access -// without any storage slot access. -type StateAccessList struct { - list map[common.Address]StorageAccessList -} - -// NewStateAccessList returns an empty StateAccessList ready for use. -func NewStateAccessList() *StateAccessList { - return &StateAccessList{ - list: make(map[common.Address]StorageAccessList), - } -} - -// AddAccount records an access to the given account. It is a no-op if the -// account is already present. -func (s *StateAccessList) AddAccount(addr common.Address) { - if s == nil { - return - } - if _, exists := s.list[addr]; !exists { - s.list[addr] = make(StorageAccessList) - } -} - -// AddState records an access to the given storage slot. The owning account is -// implicitly recorded as well. -func (s *StateAccessList) AddState(addr common.Address, slot common.Hash) { - if s == nil { - return - } - slots, exists := s.list[addr] - if !exists { - slots = make(StorageAccessList) - s.list[addr] = slots - } - slots[slot] = struct{}{} -} - -// Merge merges the entries from other into the receiver. -func (s *StateAccessList) Merge(other *StateAccessList) { - if s == nil || other == nil { - return - } - for addr, otherSlots := range other.list { - slots, exists := s.list[addr] - if !exists { - s.list[addr] = otherSlots - continue - } - maps.Copy(slots, otherSlots) - } -} - -// Copy returns a deep copy of the StateAccessList. -func (s *StateAccessList) Copy() *StateAccessList { - if s == nil { - return nil - } - cpy := &StateAccessList{ - list: make(map[common.Address]StorageAccessList, len(s.list)), - } - for addr, slots := range s.list { - cpy.list[addr] = maps.Clone(slots) - } - return cpy -} diff --git a/core/types/bal/bal.go b/core/types/bal/bal.go index 99ead8d6f0..9cbc1faeb9 100644 --- a/core/types/bal/bal.go +++ b/core/types/bal/bal.go @@ -71,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), } } @@ -169,5 +169,5 @@ func (b *ConstructionBlockAccessList) Copy() *ConstructionBlockAccessList { aaCopy.CodeChange = codes res.Accounts[addr] = &aaCopy } - return &res + return res } diff --git a/core/vm/interface.go b/core/vm/interface.go index 487d8002f9..a9938c2a28 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -98,5 +98,6 @@ type StateDB interface { AccessEvents() *state.AccessEvents // Finalise must be invoked at the end of a transaction - Finalise(bool) *bal.StateAccessList + Finalise(bool) *bal.ConstructionBlockAccessList + SetTxContext(thash common.Hash, ti int, blockAccessIndex uint32) } diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 53dfb7d458..284ddf4305 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -265,7 +265,7 @@ 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) + 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) } diff --git a/eth/tracers/api.go b/eth/tracers/api.go index d9e40f7ec1..0df02388b3 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -530,7 +530,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config return nil, err } msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) - statedb.SetTxContext(tx.Hash(), i) + 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 @@ -681,7 +681,7 @@ txloop: // Generate the next state snapshot fast without tracing msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee()) - statedb.SetTxContext(tx.Hash(), i) + statedb.SetTxContext(tx.Hash(), i, uint32(i+1)) if _, err := core.ApplyMessage(evm, msg, nil); err != nil { failed = err break txloop @@ -793,7 +793,7 @@ 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) } @@ -1016,7 +1016,7 @@ 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) + 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 { diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go index c34970578c..fa2ff2c32b 100644 --- a/internal/ethapi/simulate.go +++ b/internal/ethapi/simulate.go @@ -340,7 +340,7 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, tracer.reset(txHash, uint(i)) // EoA check is always skipped, even in validation mode. - sim.state.SetTxContext(txHash, i) + sim.state.SetTxContext(txHash, i, uint32(i+1)) msg := call.ToMessage(header.BaseFee, !sim.validate) result, err := applyMessageWithEVM(ctx, evm, msg, timeout, gp) if err != nil { @@ -390,8 +390,8 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, header.BlobGasUsed = &blobGasUsed } - // Run post-execution system calls - requests, err := core.PostExecution(ctx, sim.chainConfig, header.Number, header.Time, allLogs, evm) + // Process EIP-7685 requests + 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 } diff --git a/miner/worker.go b/miner/worker.go index ccafa20b29..026bafc4e5 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -167,7 +167,7 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams, // 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) + 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} @@ -208,7 +208,7 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams, } // Collect consensus-layer requests if Prague is enabled. - requests, err := core.PostExecution(ctx, miner.chainConfig, work.header.Number, work.header.Time, allLogs, work.evm) + 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} } @@ -502,7 +502,7 @@ func (miner *Miner) commitTransactions(ctx context.Context, env *environment, pl 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(ctx, env, tx) switch { From da34eb59fdee4b0d12e3cf0b8a5e5b3546cb0632 Mon Sep 17 00:00:00 2001 From: Barnabas Busa Date: Wed, 13 May 2026 21:08:21 +0200 Subject: [PATCH 181/183] node: default OpenTelemetry SampleRatio to 1.0 (#34948) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary The `--rpc.telemetry.sample-ratio` flag declares `Value: 1.0` and `geth --help` advertises `(default: 1)`. In practice, however, omitting the flag produces a sample ratio of `0`, causing `sdktrace.TraceIDRatioBased(0)` to drop 100% of spans. Users who enable `--rpc.telemetry` see the `OpenTelemetry trace export enabled` log line and a clean startup, but no traces ever leave the process. The root cause is the interaction between two pieces of code: 1. `cmd/utils/flags.go:setOpenTelemetry` (added in #34062) only copies the flag value when `ctx.IsSet(...)` returns true: ```go if ctx.IsSet(RPCTelemetrySampleRatioFlag.Name) { tcfg.SampleRatio = ctx.Float64(RPCTelemetrySampleRatioFlag.Name) } ``` That is the right pattern for "don't clobber a config-file value with the CLI default," but it implies that something else must initialise the field when neither source sets it. 2. `node/defaults.go:DefaultConfig` never initialises `OpenTelemetry.SampleRatio`, leaving it at the float64 zero value. The result for the common CLI-only user (no TOML config) is `SampleRatio = 0` → every span is silently dropped, despite the documented default of 1. ## Change Seed `OpenTelemetry: OpenTelemetryConfig{SampleRatio: 1.0}` in `node.DefaultConfig` so the documented default matches runtime behavior and the `ctx.IsSet` guard in `setOpenTelemetry` continues to do what it was designed to do. --- cmd/utils/flags.go | 2 +- node/defaults.go | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index ea0f6f5ee4..c41cf4ee40 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -1104,7 +1104,7 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server. RPCTelemetrySampleRatioFlag = &cli.Float64Flag{ Name: "rpc.telemetry.sample-ratio", Usage: "Defines the sampling ratio for RPC telemetry (0.0 to 1.0)", - Value: 1.0, + Value: node.DefaultConfig.OpenTelemetry.SampleRatio, Category: flags.APICategory, } // Era flags are a group of flags related to the era archive format. diff --git a/node/defaults.go b/node/defaults.go index 403a7f88a3..3410fa2ae5 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 From 31bb680997b0d24554ddd3eab8da8e179eed9ee7 Mon Sep 17 00:00:00 2001 From: cui Date: Thu, 14 May 2026 19:45:49 +0800 Subject: [PATCH 182/183] miner: re-use basefee and big.Int in loop (#34783) --- miner/worker.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/miner/worker.go b/miner/worker.go index 026bafc4e5..1ecee96688 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -601,10 +601,14 @@ func (miner *Miner) fillTransactions(ctx context.Context, interrupt *atomic.Int3 // totalFees computes total consumed miner fees in Wei. Block transactions and receipts have to have the same order. func totalFees(block *types.Block, receipts []*types.Receipt) *big.Int { + baseFee := block.BaseFee() feesWei := new(big.Int) + var gasUsed, product big.Int for i, tx := range block.Transactions() { - minerFee, _ := tx.EffectiveGasTip(block.BaseFee()) - feesWei.Add(feesWei, new(big.Int).Mul(new(big.Int).SetUint64(receipts[i].GasUsed), minerFee)) + minerFee, _ := tx.EffectiveGasTip(baseFee) + gasUsed.SetUint64(receipts[i].GasUsed) + product.Mul(&gasUsed, minerFee) + feesWei.Add(feesWei, &product) } return feesWei } From 6f6d006f74ffc650b9a598e8fcb1c757b8aaa15a Mon Sep 17 00:00:00 2001 From: Sina M <1591639+s1na@users.noreply.github.com> Date: Fri, 15 May 2026 12:04:37 +0200 Subject: [PATCH 183/183] core/txpool/blobpool: silence GetRLP miss-log spam (#34965) Avoids every legacy tx hash query hitting the blob pool on the path of BlobPool.GetRLP. --- core/txpool/blobpool/blobpool.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go index f8021e00c4..3b2bc03422 100644 --- a/core/txpool/blobpool/blobpool.go +++ b/core/txpool/blobpool/blobpool.go @@ -1575,12 +1575,15 @@ func (p *BlobPool) Get(hash common.Hash) *types.Transaction { // e.g. type_byte || [..., version, [blobs], [comms], [proofs]] func (p *BlobPool) GetRLP(hash common.Hash) []byte { data := p.getRLP(hash) + if len(data) == 0 { + // Not in this pool, do not log. + return nil + } 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 }