Merge branch 'ethereum:master' into portal

build/checksums.txt

@@ -1,9 +1,9 @@
 # This file contains sha256 checksums of optional build dependencies.
 
-# version:spec-tests 1.0.6
+# version:spec-tests 2.1.0
 # https://github.com/ethereum/execution-spec-tests/releases
-# https://github.com/ethereum/execution-spec-tests/releases/download/v1.0.6/
+# https://github.com/ethereum/execution-spec-tests/releases/download/v2.1.0/
-485af7b66cf41eb3a8c1bd46632913b8eb95995df867cf665617bbc9b4beedd1  fixtures_develop.tar.gz
+ca89c76851b0900bfcc3cbb9a26cbece1f3d7c64a3bed38723e914713290df6c  fixtures_develop.tar.gz
 
 # version:golang 1.21.6
 # https://go.dev/dl/

cmd/devp2p/internal/ethtest/suite.go

@@ -64,23 +64,23 @@ func NewSuite(dest *enode.Node, chainDir, engineURL, jwt string) (*Suite, error)
 func (s *Suite) EthTests() []utesting.Test {
 	return []utesting.Test{
 		// status
-		{Name: "TestStatus", Fn: s.TestStatus},
+		{Name: "Status", Fn: s.TestStatus},
 		// get block headers
-		{Name: "TestGetBlockHeaders", Fn: s.TestGetBlockHeaders},
+		{Name: "GetBlockHeaders", Fn: s.TestGetBlockHeaders},
-		{Name: "TestSimultaneousRequests", Fn: s.TestSimultaneousRequests},
+		{Name: "SimultaneousRequests", Fn: s.TestSimultaneousRequests},
-		{Name: "TestSameRequestID", Fn: s.TestSameRequestID},
+		{Name: "SameRequestID", Fn: s.TestSameRequestID},
-		{Name: "TestZeroRequestID", Fn: s.TestZeroRequestID},
+		{Name: "ZeroRequestID", Fn: s.TestZeroRequestID},
 		// get block bodies
-		{Name: "TestGetBlockBodies", Fn: s.TestGetBlockBodies},
+		{Name: "GetBlockBodies", Fn: s.TestGetBlockBodies},
 		// // malicious handshakes + status
-		{Name: "TestMaliciousHandshake", Fn: s.TestMaliciousHandshake},
+		{Name: "MaliciousHandshake", Fn: s.TestMaliciousHandshake},
-		{Name: "TestMaliciousStatus", Fn: s.TestMaliciousStatus},
+		{Name: "MaliciousStatus", Fn: s.TestMaliciousStatus},
 		// test transactions
-		{Name: "TestLargeTxRequest", Fn: s.TestLargeTxRequest, Slow: true},
+		{Name: "LargeTxRequest", Fn: s.TestLargeTxRequest, Slow: true},
-		{Name: "TestTransaction", Fn: s.TestTransaction},
+		{Name: "Transaction", Fn: s.TestTransaction},
-		{Name: "TestInvalidTxs", Fn: s.TestInvalidTxs},
+		{Name: "InvalidTxs", Fn: s.TestInvalidTxs},
-		{Name: "TestNewPooledTxs", Fn: s.TestNewPooledTxs},
+		{Name: "NewPooledTxs", Fn: s.TestNewPooledTxs},
-		{Name: "TestBlobViolations", Fn: s.TestBlobViolations},
+		{Name: "BlobViolations", Fn: s.TestBlobViolations},
 	}
 }
 
@@ -94,9 +94,9 @@ func (s *Suite) SnapTests() []utesting.Test {
 	}
 }
 
-// TestStatus attempts to connect to the given node and exchange a status
-// message with it on the eth protocol.
 func (s *Suite) TestStatus(t *utesting.T) {
+	t.Log(`This test is just a sanity check. It performs an eth protocol handshake.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -112,9 +112,9 @@ func headersMatch(expected []*types.Header, headers []*types.Header) bool {
 	return reflect.DeepEqual(expected, headers)
 }
 
-// TestGetBlockHeaders tests whether the given node can respond to an eth
-// `GetBlockHeaders` request and that the response is accurate.
 func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
+	t.Log(`This test requests block headers from the node.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -154,10 +154,10 @@ func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
 	}
 }
 
-// TestSimultaneousRequests sends two simultaneous `GetBlockHeader` requests
-// from the same connection with different request IDs and checks to make sure
-// the node responds with the correct headers per request.
 func (s *Suite) TestSimultaneousRequests(t *utesting.T) {
+	t.Log(`This test requests blocks headers from the node, performing two requests
+concurrently, with different request IDs.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -228,9 +228,10 @@ func (s *Suite) TestSimultaneousRequests(t *utesting.T) {
 	}
 }
 
-// TestSameRequestID sends two requests with the same request ID to a single
-// node.
 func (s *Suite) TestSameRequestID(t *utesting.T) {
+	t.Log(`This test requests block headers, performing two concurrent requests with the
+same request ID. The node should handle the request by responding to both requests.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -298,9 +299,10 @@ func (s *Suite) TestSameRequestID(t *utesting.T) {
 	}
 }
 
-// TestZeroRequestID checks that a message with a request ID of zero is still handled
-// by the node.
 func (s *Suite) TestZeroRequestID(t *utesting.T) {
+	t.Log(`This test sends a GetBlockHeaders message with a request-id of zero,
+and expects a response.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -333,9 +335,9 @@ func (s *Suite) TestZeroRequestID(t *utesting.T) {
 	}
 }
 
-// TestGetBlockBodies tests whether the given node can respond to a
-// `GetBlockBodies` request and that the response is accurate.
 func (s *Suite) TestGetBlockBodies(t *utesting.T) {
+	t.Log(`This test sends GetBlockBodies requests to the node for known blocks in the test chain.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -376,12 +378,12 @@ func randBuf(size int) []byte {
 	return buf
 }
 
-// TestMaliciousHandshake tries to send malicious data during the handshake.
 func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
-	key, _ := crypto.GenerateKey()
+	t.Log(`This test tries to send malicious data during the devp2p handshake, in various ways.`)
 
 	// Write hello to client.
 	var (
+		key, _  = crypto.GenerateKey()
 		pub0    = crypto.FromECDSAPub(&key.PublicKey)[1:]
 		version = eth.ProtocolVersions[0]
 	)
@@ -451,8 +453,9 @@ func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
 	}
 }
 
-// TestMaliciousStatus sends a status package with a large total difficulty.
 func (s *Suite) TestMaliciousStatus(t *utesting.T) {
+	t.Log(`This test sends a malicious eth Status message to the node and expects a disconnect.`)
+
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -486,9 +489,10 @@ func (s *Suite) TestMaliciousStatus(t *utesting.T) {
 	}
 }
 
-// TestTransaction sends a valid transaction to the node and checks if the
-// transaction gets propagated.
 func (s *Suite) TestTransaction(t *utesting.T) {
+	t.Log(`This test sends a valid transaction to the node and checks if the
+transaction gets propagated.`)
+
 	// Nudge client out of syncing mode to accept pending txs.
 	if err := s.engine.sendForkchoiceUpdated(); err != nil {
 		t.Fatalf("failed to send next block: %v", err)
@@ -507,15 +511,16 @@ func (s *Suite) TestTransaction(t *utesting.T) {
 	if err != nil {
 		t.Fatalf("failed to sign tx: %v", err)
 	}
-	if err := s.sendTxs([]*types.Transaction{tx}); err != nil {
+	if err := s.sendTxs(t, []*types.Transaction{tx}); err != nil {
 		t.Fatal(err)
 	}
 	s.chain.IncNonce(from, 1)
 }
 
-// TestInvalidTxs sends several invalid transactions and tests whether
-// the node will propagate them.
 func (s *Suite) TestInvalidTxs(t *utesting.T) {
+	t.Log(`This test sends several kinds of invalid transactions and checks that the node
+does not propagate them.`)
+
 	// Nudge client out of syncing mode to accept pending txs.
 	if err := s.engine.sendForkchoiceUpdated(); err != nil {
 		t.Fatalf("failed to send next block: %v", err)
@@ -534,7 +539,7 @@ func (s *Suite) TestInvalidTxs(t *utesting.T) {
 	if err != nil {
 		t.Fatalf("failed to sign tx: %v", err)
 	}
-	if err := s.sendTxs([]*types.Transaction{tx}); err != nil {
+	if err := s.sendTxs(t, []*types.Transaction{tx}); err != nil {
 		t.Fatalf("failed to send txs: %v", err)
 	}
 	s.chain.IncNonce(from, 1)
@@ -590,14 +595,15 @@ func (s *Suite) TestInvalidTxs(t *utesting.T) {
 		}
 		txs = append(txs, tx)
 	}
-	if err := s.sendInvalidTxs(txs); err != nil {
+	if err := s.sendInvalidTxs(t, txs); err != nil {
 		t.Fatalf("failed to send invalid txs: %v", err)
 	}
 }
 
-// TestLargeTxRequest tests whether a node can fulfill a large GetPooledTransactions
-// request.
 func (s *Suite) TestLargeTxRequest(t *utesting.T) {
+	t.Log(`This test first send ~2000 transactions to the node, then requests them
+on another peer connection using GetPooledTransactions.`)
+
 	// Nudge client out of syncing mode to accept pending txs.
 	if err := s.engine.sendForkchoiceUpdated(); err != nil {
 		t.Fatalf("failed to send next block: %v", err)
@@ -630,7 +636,7 @@ func (s *Suite) TestLargeTxRequest(t *utesting.T) {
 	s.chain.IncNonce(from, uint64(count))
 
 	// Send txs.
-	if err := s.sendTxs(txs); err != nil {
+	if err := s.sendTxs(t, txs); err != nil {
 		t.Fatalf("failed to send txs: %v", err)
 	}
 
@@ -667,13 +673,15 @@ func (s *Suite) TestLargeTxRequest(t *utesting.T) {
 	}
 }
 
-// TestNewPooledTxs tests whether a node will do a GetPooledTransactions request
-// upon receiving a NewPooledTransactionHashes announcement.
 func (s *Suite) TestNewPooledTxs(t *utesting.T) {
+	t.Log(`This test announces transaction hashes to the node and expects it to fetch
+the transactions using a GetPooledTransactions request.`)
+
 	// Nudge client out of syncing mode to accept pending txs.
 	if err := s.engine.sendForkchoiceUpdated(); err != nil {
 		t.Fatalf("failed to send next block: %v", err)
 	}
+
 	var (
 		count       = 50
 		from, nonce = s.chain.GetSender(1)
@@ -787,6 +795,8 @@ func (s *Suite) makeBlobTxs(count, blobs int, discriminator byte) (txs types.Tra
 }
 
 func (s *Suite) TestBlobViolations(t *utesting.T) {
+	t.Log(`This test sends some invalid blob tx announcements and expects the node to disconnect.`)
+
 	if err := s.engine.sendForkchoiceUpdated(); err != nil {
 		t.Fatalf("send fcu failed: %v", err)
 	}

cmd/devp2p/internal/ethtest/transaction.go

@@ -25,11 +25,12 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/eth/protocols/eth"
+	"github.com/ethereum/go-ethereum/internal/utesting"
 )
 
 // sendTxs sends the given transactions to the node and
 // expects the node to accept and propagate them.
-func (s *Suite) sendTxs(txs []*types.Transaction) error {
+func (s *Suite) sendTxs(t *utesting.T, txs []*types.Transaction) error {
 	// Open sending conn.
 	sendConn, err := s.dial()
 	if err != nil {
@@ -74,6 +75,15 @@ func (s *Suite) sendTxs(txs []*types.Transaction) error {
 			for _, hash := range msg.Hashes {
 				got[hash] = true
 			}
+		case *eth.GetBlockHeadersPacket:
+			headers, err := s.chain.GetHeaders(msg)
+			if err != nil {
+				t.Logf("invalid GetBlockHeaders request: %v", err)
+			}
+			recvConn.Write(ethProto, eth.BlockHeadersMsg, &eth.BlockHeadersPacket{
+				RequestId:           msg.RequestId,
+				BlockHeadersRequest: headers,
+			})
 		default:
 			return fmt.Errorf("unexpected eth wire msg: %s", pretty.Sdump(msg))
 		}
@@ -95,7 +105,7 @@ func (s *Suite) sendTxs(txs []*types.Transaction) error {
 	return fmt.Errorf("timed out waiting for txs")
 }
 
-func (s *Suite) sendInvalidTxs(txs []*types.Transaction) error {
+func (s *Suite) sendInvalidTxs(t *utesting.T, txs []*types.Transaction) error {
 	// Open sending conn.
 	sendConn, err := s.dial()
 	if err != nil {
@@ -152,6 +162,15 @@ func (s *Suite) sendInvalidTxs(txs []*types.Transaction) error {
 					return fmt.Errorf("received bad tx: %s", hash)
 				}
 			}
+		case *eth.GetBlockHeadersPacket:
+			headers, err := s.chain.GetHeaders(msg)
+			if err != nil {
+				t.Logf("invalid GetBlockHeaders request: %v", err)
+			}
+			recvConn.Write(ethProto, eth.BlockHeadersMsg, &eth.BlockHeadersPacket{
+				RequestId:           msg.RequestId,
+				BlockHeadersRequest: headers,
+			})
 		default:
 			return fmt.Errorf("unexpected eth message: %v", pretty.Sdump(msg))
 		}

cmd/evm/transition-test.sh

@@ -103,7 +103,7 @@ type Env struct {
     CurrentTimestamp uint64              `json:"currentTimestamp"`
     Withdrawals      []*Withdrawal       `json:"withdrawals"`
     // optional
-    CurrentDifficulty *big.Int           `json:"currentDifficuly"`
+    CurrentDifficulty *big.Int           `json:"currentDifficulty"`
     CurrentRandom     *big.Int           `json:"currentRandom"`
     CurrentBaseFee    *big.Int           `json:"currentBaseFee"`
     ParentDifficulty  *big.Int           `json:"parentDifficulty"`

core/txpool/legacypool/list.go

@@ -28,6 +28,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/holiman/uint256"
+	"golang.org/x/exp/slices"
 )
 
 // nonceHeap is a heap.Interface implementation over 64bit unsigned integers for
@@ -160,14 +161,14 @@ func (m *sortedMap) Cap(threshold int) types.Transactions {
 	}
 	// Otherwise gather and drop the highest nonce'd transactions
 	var drops types.Transactions
-
+	slices.Sort(*m.index)
-	sort.Sort(*m.index)
 	for size := len(m.items); size > threshold; size-- {
 		drops = append(drops, m.items[(*m.index)[size-1]])
 		delete(m.items, (*m.index)[size-1])
 	}
 	*m.index = (*m.index)[:threshold]
-	heap.Init(m.index)
+	// The sorted m.index slice is still a valid heap, so there is no need to
+	// reheap after deleting tail items.
 
 	// If we had a cache, shift the back
 	m.cacheMu.Lock()

core/txpool/legacypool/list_test.go

@@ -87,3 +87,25 @@ func BenchmarkListAdd(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkListCapOneTx(b *testing.B) {
+	// Generate a list of transactions to insert
+	key, _ := crypto.GenerateKey()
+
+	txs := make(types.Transactions, 32)
+	for i := 0; i < len(txs); i++ {
+		txs[i] = transaction(uint64(i), 0, key)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		list := newList(true)
+		// Insert the transactions in a random order
+		for _, v := range rand.Perm(len(txs)) {
+			list.Add(txs[v], DefaultConfig.PriceBump)
+		}
+		b.StartTimer()
+		list.Cap(list.Len() - 1)
+		b.StopTimer()
+	}
+}

eth/catalyst/api.go

@@ -90,6 +90,7 @@ var caps = []string{
 	"engine_newPayloadV3",
 	"engine_getPayloadBodiesByHashV1",
 	"engine_getPayloadBodiesByRangeV1",
+	"engine_getClientVersionV1",
 }
 
 type ConsensusAPI struct {

tests/block_test.go

@@ -61,14 +61,14 @@ func TestBlockchain(t *testing.T) {
 	// which run natively, so there's no reason to run them here.
 }
 
-// TestExecutionSpec runs the test fixtures from execution-spec-tests.
+// TestExecutionSpecBlocktests runs the test fixtures from execution-spec-tests.
-func TestExecutionSpec(t *testing.T) {
+func TestExecutionSpecBlocktests(t *testing.T) {
-	if !common.FileExist(executionSpecDir) {
+	if !common.FileExist(executionSpecBlockchainTestDir) {
-		t.Skipf("directory %s does not exist", executionSpecDir)
+		t.Skipf("directory %s does not exist", executionSpecBlockchainTestDir)
 	}
 	bt := new(testMatcher)
 
-	bt.walk(t, executionSpecDir, func(t *testing.T, name string, test *BlockTest) {
+	bt.walk(t, executionSpecBlockchainTestDir, func(t *testing.T, name string, test *BlockTest) {
 		execBlockTest(t, bt, test)
 	})
 }

tests/init_test.go

@@ -34,15 +34,16 @@ import (
 )
 
 var (
-	baseDir            = filepath.Join(".", "testdata")
+	baseDir                        = filepath.Join(".", "testdata")
-	blockTestDir       = filepath.Join(baseDir, "BlockchainTests")
+	blockTestDir                   = filepath.Join(baseDir, "BlockchainTests")
-	stateTestDir       = filepath.Join(baseDir, "GeneralStateTests")
+	stateTestDir                   = filepath.Join(baseDir, "GeneralStateTests")
-	legacyStateTestDir = filepath.Join(baseDir, "LegacyTests", "Constantinople", "GeneralStateTests")
+	legacyStateTestDir             = filepath.Join(baseDir, "LegacyTests", "Constantinople", "GeneralStateTests")
-	transactionTestDir = filepath.Join(baseDir, "TransactionTests")
+	transactionTestDir             = filepath.Join(baseDir, "TransactionTests")
-	rlpTestDir         = filepath.Join(baseDir, "RLPTests")
+	rlpTestDir                     = filepath.Join(baseDir, "RLPTests")
-	difficultyTestDir  = filepath.Join(baseDir, "BasicTests")
+	difficultyTestDir              = filepath.Join(baseDir, "BasicTests")
-	executionSpecDir   = filepath.Join(".", "spec-tests", "fixtures")
+	executionSpecBlockchainTestDir = filepath.Join(".", "spec-tests", "fixtures", "blockchain_tests")
-	benchmarksDir      = filepath.Join(".", "evm-benchmarks", "benchmarks")
+	executionSpecStateTestDir      = filepath.Join(".", "spec-tests", "fixtures", "state_tests")
+	benchmarksDir                  = filepath.Join(".", "evm-benchmarks", "benchmarks")
 )
 
 func readJSON(reader io.Reader, value interface{}) error {

tests/state_test.go

@@ -30,6 +30,7 @@ import (
 	"testing"
 	"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/types"
@@ -38,10 +39,7 @@ import (
 	"github.com/holiman/uint256"
 )
 
-func TestState(t *testing.T) {
+func initMatcher(st *testMatcher) {
-	t.Parallel()
-
-	st := new(testMatcher)
 	// Long tests:
 	st.slow(`^stAttackTest/ContractCreationSpam`)
 	st.slow(`^stBadOpcode/badOpcodes`)
@@ -60,72 +58,102 @@ func TestState(t *testing.T) {
 	// Broken tests:
 	// EOF is not part of cancun
 	st.skipLoad(`^stEOF/`)
+}
 
-	// For Istanbul, older tests were moved into LegacyTests
+func TestState(t *testing.T) {
+	t.Parallel()
+
+	st := new(testMatcher)
+	initMatcher(st)
 	for _, dir := range []string{
 		filepath.Join(baseDir, "EIPTests", "StateTests"),
 		stateTestDir,
-		legacyStateTestDir,
 		benchmarksDir,
 	} {
 		st.walk(t, dir, func(t *testing.T, name string, test *StateTest) {
-			if runtime.GOARCH == "386" && runtime.GOOS == "windows" && rand.Int63()%2 == 0 {
+			execStateTest(t, st, test)
-				t.Skip("test (randomly) skipped on 32-bit windows")
+		})
-				return
+	}
-			}
+}
-			for _, subtest := range test.Subtests() {
-				subtest := subtest
-				key := fmt.Sprintf("%s/%d", subtest.Fork, subtest.Index)
 
-				t.Run(key+"/hash/trie", func(t *testing.T) {
+// TestLegacyState tests some older tests, which were moved to the folder
-					withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
+// 'LegacyTests' for the Istanbul fork.
-						var result error
+func TestLegacyState(t *testing.T) {
-						test.Run(subtest, vmconfig, false, rawdb.HashScheme, func(err error, state *StateTestState) {
+	st := new(testMatcher)
-							result = st.checkFailure(t, err)
+	initMatcher(st)
-						})
+	st.walk(t, legacyStateTestDir, func(t *testing.T, name string, test *StateTest) {
-						return result
+		execStateTest(t, st, test)
-					})
+	})
+}
+
+// TestExecutionSpecState runs the test fixtures from execution-spec-tests.
+func TestExecutionSpecState(t *testing.T) {
+	if !common.FileExist(executionSpecStateTestDir) {
+		t.Skipf("directory %s does not exist", executionSpecStateTestDir)
+	}
+	st := new(testMatcher)
+
+	st.walk(t, executionSpecStateTestDir, func(t *testing.T, name string, test *StateTest) {
+		execStateTest(t, st, test)
+	})
+}
+
+func execStateTest(t *testing.T, st *testMatcher, test *StateTest) {
+	if runtime.GOARCH == "386" && runtime.GOOS == "windows" && rand.Int63()%2 == 0 {
+		t.Skip("test (randomly) skipped on 32-bit windows")
+		return
+	}
+	for _, subtest := range test.Subtests() {
+		subtest := subtest
+		key := fmt.Sprintf("%s/%d", subtest.Fork, subtest.Index)
+
+		t.Run(key+"/hash/trie", func(t *testing.T) {
+			withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
+				var result error
+				test.Run(subtest, vmconfig, false, rawdb.HashScheme, func(err error, state *StateTestState) {
+					result = st.checkFailure(t, err)
 				})
-				t.Run(key+"/hash/snap", func(t *testing.T) {
+				return result
-					withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
+			})
-						var result error
+		})
-						test.Run(subtest, vmconfig, true, rawdb.HashScheme, func(err error, state *StateTestState) {
+		t.Run(key+"/hash/snap", func(t *testing.T) {
-							if state.Snapshots != nil && state.StateDB != nil {
+			withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
-								if _, err := state.Snapshots.Journal(state.StateDB.IntermediateRoot(false)); err != nil {
+				var result error
-									result = err
+				test.Run(subtest, vmconfig, true, rawdb.HashScheme, func(err error, state *StateTestState) {
-									return
+					if state.Snapshots != nil && state.StateDB != nil {
-								}
+						if _, err := state.Snapshots.Journal(state.StateDB.IntermediateRoot(false)); err != nil {
-							}
+							result = err
-							result = st.checkFailure(t, err)
+							return
-						})
+						}
-						return result
+					}
-					})
+					result = st.checkFailure(t, err)
 				})
-				t.Run(key+"/path/trie", func(t *testing.T) {
+				return result
-					withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
+			})
-						var result error
+		})
-						test.Run(subtest, vmconfig, false, rawdb.PathScheme, func(err error, state *StateTestState) {
+		t.Run(key+"/path/trie", func(t *testing.T) {
-							result = st.checkFailure(t, err)
+			withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
-						})
+				var result error
-						return result
+				test.Run(subtest, vmconfig, false, rawdb.PathScheme, func(err error, state *StateTestState) {
-					})
+					result = st.checkFailure(t, err)
 				})
-				t.Run(key+"/path/snap", func(t *testing.T) {
+				return result
-					withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
+			})
-						var result error
+		})
-						test.Run(subtest, vmconfig, true, rawdb.PathScheme, func(err error, state *StateTestState) {
+		t.Run(key+"/path/snap", func(t *testing.T) {
-							if state.Snapshots != nil && state.StateDB != nil {
+			withTrace(t, test.gasLimit(subtest), func(vmconfig vm.Config) error {
-								if _, err := state.Snapshots.Journal(state.StateDB.IntermediateRoot(false)); err != nil {
+				var result error
-									result = err
+				test.Run(subtest, vmconfig, true, rawdb.PathScheme, func(err error, state *StateTestState) {
-									return
+					if state.Snapshots != nil && state.StateDB != nil {
-								}
+						if _, err := state.Snapshots.Journal(state.StateDB.IntermediateRoot(false)); err != nil {
-							}
+							result = err
-							result = st.checkFailure(t, err)
+							return
-						})
+						}
-						return result
+					}
-					})
+					result = st.checkFailure(t, err)
 				})
-			}
+				return result
+			})
 		})
 	}
 }