From f460f019e9d81808bf8a15b7d7f1134ab456fb4f Mon Sep 17 00:00:00 2001
From: Martin Redmond <21436+reds@users.noreply.github.com>
Date: Mon, 13 Jan 2025 10:12:15 -0500
Subject: [PATCH 1/9] eth/tracers/logger: return revert reason (#31013)

Fix the error comparison in tracer to prevent dropping revert reason data

---------

Co-authored-by: Martin <mrscdevel@gmail.com>
Co-authored-by: rjl493456442 <garyrong0905@gmail.com>
---
 eth/tracers/logger/logger.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/eth/tracers/logger/logger.go b/eth/tracers/logger/logger.go
index 07de871f14..596ee97146 100644
--- a/eth/tracers/logger/logger.go
+++ b/eth/tracers/logger/logger.go
@@ -19,6 +19,7 @@ package logger
 import (
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"maps"
@@ -350,7 +351,7 @@ func (l *StructLogger) GetResult() (json.RawMessage, error) {
 	returnData := common.CopyBytes(l.output)
 	// Return data when successful and revert reason when reverted, otherwise empty.
 	returnVal := fmt.Sprintf("%x", returnData)
-	if failed && l.err != vm.ErrExecutionReverted {
+	if failed && !errors.Is(l.err, vm.ErrExecutionReverted) {
 		returnVal = ""
 	}
 	return json.Marshal(&ExecutionResult{

From 8752785a9889a09abc6dd7354b9747caecdafa97 Mon Sep 17 00:00:00 2001
From: dashangcun <907225865@qq.com>
Date: Mon, 13 Jan 2025 18:00:25 +0100
Subject: [PATCH 2/9] cmd/devp2p/internal/ethtest: using slices.SortFunc to
 simplify the code (#31012)

Co-authored-by: Felix Lange <fjl@twurst.com>
---
 cmd/devp2p/internal/ethtest/chain.go | 25 +++----------------------
 1 file changed, 3 insertions(+), 22 deletions(-)

diff --git a/cmd/devp2p/internal/ethtest/chain.go b/cmd/devp2p/internal/ethtest/chain.go
index 2a70e0328f..222c66d4df 100644
--- a/cmd/devp2p/internal/ethtest/chain.go
+++ b/cmd/devp2p/internal/ethtest/chain.go
@@ -28,7 +28,6 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
-	"sort"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -41,6 +40,7 @@ import (
 	"github.com/ethereum/go-ethereum/eth/protocols/eth"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
+	"golang.org/x/exp/maps"
 )
 
 // Chain is a lightweight blockchain-like store which can read a hivechain
@@ -166,11 +166,8 @@ func (c *Chain) RootAt(height int) common.Hash {
 // GetSender returns the address associated with account at the index in the
 // pre-funded accounts list.
 func (c *Chain) GetSender(idx int) (common.Address, uint64) {
-	var accounts Addresses
-	for addr := range c.senders {
-		accounts = append(accounts, addr)
-	}
-	sort.Sort(accounts)
+	accounts := maps.Keys(c.senders)
+	slices.SortFunc(accounts, common.Address.Cmp)
 	addr := accounts[idx]
 	return addr, c.senders[addr].Nonce
 }
@@ -260,22 +257,6 @@ func loadGenesis(genesisFile string) (core.Genesis, error) {
 	return gen, nil
 }
 
-type Addresses []common.Address
-
-func (a Addresses) Len() int {
-	return len(a)
-}
-
-func (a Addresses) Less(i, j int) bool {
-	return bytes.Compare(a[i][:], a[j][:]) < 0
-}
-
-func (a Addresses) Swap(i, j int) {
-	tmp := a[i]
-	a[i] = a[j]
-	a[j] = tmp
-}
-
 func blocksFromFile(chainfile string, gblock *types.Block) ([]*types.Block, error) {
 	// Load chain.rlp.
 	fh, err := os.Open(chainfile)

From fcf5204a02c8b80ad3c53274374a14ef45d83e2d Mon Sep 17 00:00:00 2001
From: Quentin McGaw <quentin.mcgaw@gmail.com>
Date: Mon, 13 Jan 2025 19:33:49 +0100
Subject: [PATCH 3/9] core/txpool/legacypool: fix flaky test TestAllowedTxSize
 (#30975)

- it was failing because the maximum data length (previously `dataSize`)
was set to `txMaxSize - 213` but should had been `txMaxSize - 103` and
the last call `dataSize+1+uint64(rand.Intn(10*txMaxSize)))` would
sometimes fail depending on rand.Intn.
- Maximal transaction data size comment (invalid) replaced by code logic
to find the maximum tx length without its data length
- comments and variable naming improved for clarity
- 3rd pool add test replaced to add just 1 above the maximum length,
which is important to ensure the logic is correct
---
 core/txpool/legacypool/legacypool_test.go | 31 ++++++++++-------------
 1 file changed, 13 insertions(+), 18 deletions(-)

diff --git a/core/txpool/legacypool/legacypool_test.go b/core/txpool/legacypool/legacypool_test.go
index 39673d176d..abbde8cae3 100644
--- a/core/txpool/legacypool/legacypool_test.go
+++ b/core/txpool/legacypool/legacypool_test.go
@@ -1243,33 +1243,28 @@ func TestAllowedTxSize(t *testing.T) {
 	account := crypto.PubkeyToAddress(key.PublicKey)
 	testAddBalance(pool, account, big.NewInt(1000000000))
 
-	// Compute maximal data size for transactions (lower bound).
-	//
-	// It is assumed the fields in the transaction (except of the data) are:
-	//   - nonce     <= 32 bytes
-	//   - gasTip  <= 32 bytes
-	//   - gasLimit  <= 32 bytes
-	//   - recipient == 20 bytes
-	//   - value     <= 32 bytes
-	//   - signature == 65 bytes
-	// All those fields are summed up to at most 213 bytes.
-	baseSize := uint64(213)
-	dataSize := txMaxSize - baseSize
+	// Find the maximum data length for the kind of transaction which will
+	// be generated in the pool.addRemoteSync calls below.
+	const largeDataLength = txMaxSize - 200 // enough to have a 5 bytes RLP encoding of the data length number
+	txWithLargeData := pricedDataTransaction(0, pool.currentHead.Load().GasLimit, big.NewInt(1), key, largeDataLength)
+	maxTxLengthWithoutData := txWithLargeData.Size() - largeDataLength // 103 bytes
+	maxTxDataLength := txMaxSize - maxTxLengthWithoutData              // 131072 - 103 = 130953 bytes
+
 	// Try adding a transaction with maximal allowed size
-	tx := pricedDataTransaction(0, pool.currentHead.Load().GasLimit, big.NewInt(1), key, dataSize)
+	tx := pricedDataTransaction(0, pool.currentHead.Load().GasLimit, big.NewInt(1), key, maxTxDataLength)
 	if err := pool.addRemoteSync(tx); err != nil {
 		t.Fatalf("failed to add transaction of size %d, close to maximal: %v", int(tx.Size()), err)
 	}
 	// Try adding a transaction with random allowed size
-	if err := pool.addRemoteSync(pricedDataTransaction(1, pool.currentHead.Load().GasLimit, big.NewInt(1), key, uint64(rand.Intn(int(dataSize))))); err != nil {
+	if err := pool.addRemoteSync(pricedDataTransaction(1, pool.currentHead.Load().GasLimit, big.NewInt(1), key, uint64(rand.Intn(int(maxTxDataLength+1))))); err != nil {
 		t.Fatalf("failed to add transaction of random allowed size: %v", err)
 	}
-	// Try adding a transaction of minimal not allowed size
-	if err := pool.addRemoteSync(pricedDataTransaction(2, pool.currentHead.Load().GasLimit, big.NewInt(1), key, txMaxSize)); err == nil {
+	// Try adding a transaction above maximum size by one
+	if err := pool.addRemoteSync(pricedDataTransaction(2, pool.currentHead.Load().GasLimit, big.NewInt(1), key, maxTxDataLength+1)); err == nil {
 		t.Fatalf("expected rejection on slightly oversize transaction")
 	}
-	// Try adding a transaction of random not allowed size
-	if err := pool.addRemoteSync(pricedDataTransaction(2, pool.currentHead.Load().GasLimit, big.NewInt(1), key, dataSize+1+uint64(rand.Intn(10*txMaxSize)))); err == nil {
+	// Try adding a transaction above maximum size by more than one
+	if err := pool.addRemoteSync(pricedDataTransaction(2, pool.currentHead.Load().GasLimit, big.NewInt(1), key, maxTxDataLength+1+uint64(rand.Intn(10*txMaxSize)))); err == nil {
 		t.Fatalf("expected rejection on oversize transaction")
 	}
 	// Run some sanity checks on the pool internals

From 864e717b56e80a4970700fd50fe10188b98d670d Mon Sep 17 00:00:00 2001
From: Paul Lange <palango@users.noreply.github.com>
Date: Mon, 13 Jan 2025 19:35:49 +0100
Subject: [PATCH 4/9] core: remove unused function parameters (#31001)

---
 core/blockchain_test.go  | 17 ++++-------------
 core/state_transition.go |  4 ++--
 2 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index fc0e3d8446..f2a9b953a1 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -2535,7 +2535,7 @@ func testReorgToShorterRemovesCanonMappingHeaderChain(t *testing.T, scheme strin
 }
 
 // Benchmarks large blocks with value transfers to non-existing accounts
-func benchmarkLargeNumberOfValueToNonexisting(b *testing.B, numTxs, numBlocks int, recipientFn func(uint64) common.Address, dataFn func(uint64) []byte) {
+func benchmarkLargeNumberOfValueToNonexisting(b *testing.B, numTxs, numBlocks int, recipientFn func(uint64) common.Address) {
 	var (
 		signer          = types.HomesteadSigner{}
 		testBankKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
@@ -2598,10 +2598,7 @@ func BenchmarkBlockChain_1x1000ValueTransferToNonexisting(b *testing.B) {
 	recipientFn := func(nonce uint64) common.Address {
 		return common.BigToAddress(new(big.Int).SetUint64(1337 + nonce))
 	}
-	dataFn := func(nonce uint64) []byte {
-		return nil
-	}
-	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
+	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn)
 }
 
 func BenchmarkBlockChain_1x1000ValueTransferToExisting(b *testing.B) {
@@ -2615,10 +2612,7 @@ func BenchmarkBlockChain_1x1000ValueTransferToExisting(b *testing.B) {
 	recipientFn := func(nonce uint64) common.Address {
 		return common.BigToAddress(new(big.Int).SetUint64(1337))
 	}
-	dataFn := func(nonce uint64) []byte {
-		return nil
-	}
-	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
+	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn)
 }
 
 func BenchmarkBlockChain_1x1000Executions(b *testing.B) {
@@ -2632,10 +2626,7 @@ func BenchmarkBlockChain_1x1000Executions(b *testing.B) {
 	recipientFn := func(nonce uint64) common.Address {
 		return common.BigToAddress(new(big.Int).SetUint64(0xc0de))
 	}
-	dataFn := func(nonce uint64) []byte {
-		return nil
-	}
-	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
+	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn)
 }
 
 // Tests that importing a some old blocks, where all blocks are before the
diff --git a/core/state_transition.go b/core/state_transition.go
index 93d72d16b7..009b679b27 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -470,7 +470,7 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 		if msg.SetCodeAuthorizations != nil {
 			for _, auth := range msg.SetCodeAuthorizations {
 				// Note errors are ignored, we simply skip invalid authorizations here.
-				st.applyAuthorization(msg, &auth)
+				st.applyAuthorization(&auth)
 			}
 		}
 
@@ -559,7 +559,7 @@ func (st *stateTransition) validateAuthorization(auth *types.SetCodeAuthorizatio
 }
 
 // applyAuthorization applies an EIP-7702 code delegation to the state.
-func (st *stateTransition) applyAuthorization(msg *Message, auth *types.SetCodeAuthorization) error {
+func (st *stateTransition) applyAuthorization(auth *types.SetCodeAuthorization) error {
 	authority, err := st.validateAuthorization(auth)
 	if err != nil {
 		return err

From 37c0e6992e02190c4e6a3bc9d70c19967f8931db Mon Sep 17 00:00:00 2001
From: rjl493456442 <garyrong0905@gmail.com>
Date: Tue, 14 Jan 2025 18:49:30 +0800
Subject: [PATCH 5/9] cmd, core, miner: rework genesis setup (#30907)

This pull request refactors the genesis setup function, the major
changes are highlighted here:

**(a) Triedb is opened in verkle mode if `EnableVerkleAtGenesis` is
configured in chainConfig or the database has been initialized previously with
`EnableVerkleAtGenesis` configured**.

A new config field `EnableVerkleAtGenesis` has been added in the
chainConfig. This field must be configured with True if Geth wants to initialize
the genesis in Verkle mode.

In the verkle devnet-7, the verkle transition is activated at genesis.
Therefore, the verkle rules should be used since the genesis. In production
networks (mainnet and public testnets), verkle activation always occurs after
the genesis block. Therefore, this flag is only made for devnet and should be
deprecated later. Besides, verkle transition at non-genesis block hasn't been
implemented yet, it should be done in the following PRs.

**(b) The genesis initialization condition has been simplified**
There is a special mode supported by the Geth is that: Geth can be
initialized with an existing chain segment, which can fasten the node sync
process by retaining the chain freezer folder.

Originally, if the triedb is regarded as uninitialized and the genesis block can
be found in the chain freezer, the genesis block along with genesis state will be
committed. This condition has been simplified to checking the presence of chain
config in key-value store. The existence of chain config can represent the genesis
has been committed.
---
 cmd/geth/chaincmd.go        |   3 +-
 cmd/utils/history_test.go   |   2 +-
 core/blockchain.go          |  31 +++---
 core/genesis.go             | 202 +++++++++++++++++++++---------------
 core/genesis_test.go        |  41 ++++----
 core/verkle_witness_test.go |   2 +
 miner/miner_test.go         |   2 +-
 params/config.go            |  27 +++++
 triedb/database.go          |  10 --
 triedb/hashdb/database.go   |   6 --
 triedb/pathdb/database.go   |  15 ---
 11 files changed, 191 insertions(+), 150 deletions(-)

diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go
index 48564eb5eb..bbadb1cc19 100644
--- a/cmd/geth/chaincmd.go
+++ b/cmd/geth/chaincmd.go
@@ -230,11 +230,10 @@ func initGenesis(ctx *cli.Context) error {
 	triedb := utils.MakeTrieDatabase(ctx, chaindb, ctx.Bool(utils.CachePreimagesFlag.Name), false, genesis.IsVerkle())
 	defer triedb.Close()
 
-	_, hash, err := core.SetupGenesisBlockWithOverride(chaindb, triedb, genesis, &overrides)
+	_, hash, _, err := core.SetupGenesisBlockWithOverride(chaindb, triedb, genesis, &overrides)
 	if err != nil {
 		utils.Fatalf("Failed to write genesis block: %v", err)
 	}
-
 	log.Info("Successfully wrote genesis state", "database", "chaindata", "hash", hash)
 
 	return nil
diff --git a/cmd/utils/history_test.go b/cmd/utils/history_test.go
index 1074a358ec..07cf71234e 100644
--- a/cmd/utils/history_test.go
+++ b/cmd/utils/history_test.go
@@ -170,7 +170,7 @@ func TestHistoryImportAndExport(t *testing.T) {
 		db2.Close()
 	})
 
-	genesis.MustCommit(db2, triedb.NewDatabase(db, triedb.HashDefaults))
+	genesis.MustCommit(db2, triedb.NewDatabase(db2, triedb.HashDefaults))
 	imported, err := core.NewBlockChain(db2, nil, genesis, nil, ethash.NewFaker(), vm.Config{}, nil)
 	if err != nil {
 		t.Fatalf("unable to initialize chain: %v", err)
diff --git a/core/blockchain.go b/core/blockchain.go
index 0fe4812626..b056b7ed0c 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -269,14 +269,19 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 		cacheConfig = defaultCacheConfig
 	}
 	// Open trie database with provided config
-	triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(genesis != nil && genesis.IsVerkle()))
+	enableVerkle, err := EnableVerkleAtGenesis(db, genesis)
+	if err != nil {
+		return nil, err
+	}
+	triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(enableVerkle))
 
-	// Setup the genesis block, commit the provided genesis specification
-	// to database if the genesis block is not present yet, or load the
-	// stored one from database.
-	chainConfig, genesisHash, genesisErr := SetupGenesisBlockWithOverride(db, triedb, genesis, overrides)
-	if _, ok := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !ok {
-		return nil, genesisErr
+	// Write the supplied genesis to the database if it has not been initialized
+	// yet. The corresponding chain config will be returned, either from the
+	// provided genesis or from the locally stored configuration if the genesis
+	// has already been initialized.
+	chainConfig, genesisHash, compatErr, err := SetupGenesisBlockWithOverride(db, triedb, genesis, overrides)
+	if err != nil {
+		return nil, err
 	}
 	log.Info("")
 	log.Info(strings.Repeat("-", 153))
@@ -303,7 +308,6 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 		vmConfig:      vmConfig,
 		logger:        vmConfig.Tracer,
 	}
-	var err error
 	bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.insertStopped)
 	if err != nil {
 		return nil, err
@@ -453,16 +457,15 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 	}
 
 	// Rewind the chain in case of an incompatible config upgrade.
-	if compat, ok := genesisErr.(*params.ConfigCompatError); ok {
-		log.Warn("Rewinding chain to upgrade configuration", "err", compat)
-		if compat.RewindToTime > 0 {
-			bc.SetHeadWithTimestamp(compat.RewindToTime)
+	if compatErr != nil {
+		log.Warn("Rewinding chain to upgrade configuration", "err", compatErr)
+		if compatErr.RewindToTime > 0 {
+			bc.SetHeadWithTimestamp(compatErr.RewindToTime)
 		} else {
-			bc.SetHead(compat.RewindToBlock)
+			bc.SetHead(compatErr.RewindToBlock)
 		}
 		rawdb.WriteChainConfig(db, genesisHash, chainConfig)
 	}
-
 	// Start tx indexer if it's enabled.
 	if txLookupLimit != nil {
 		bc.txIndexer = newTxIndexer(*txLookupLimit, bc)
diff --git a/core/genesis.go b/core/genesis.go
index 347789cf0c..02cdc74d86 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -247,6 +247,24 @@ type ChainOverrides struct {
 	OverrideVerkle *uint64
 }
 
+// apply applies the chain overrides on the supplied chain config.
+func (o *ChainOverrides) apply(cfg *params.ChainConfig) (*params.ChainConfig, error) {
+	if o == nil || cfg == nil {
+		return cfg, nil
+	}
+	cpy := *cfg
+	if o.OverrideCancun != nil {
+		cpy.CancunTime = o.OverrideCancun
+	}
+	if o.OverrideVerkle != nil {
+		cpy.VerkleTime = o.OverrideVerkle
+	}
+	if err := cpy.CheckConfigForkOrder(); err != nil {
+		return nil, err
+	}
+	return &cpy, nil
+}
+
 // SetupGenesisBlock writes or updates the genesis block in db.
 // The block that will be used is:
 //
@@ -258,109 +276,102 @@ type ChainOverrides struct {
 // The stored chain configuration will be updated if it is compatible (i.e. does not
 // specify a fork block below the local head block). In case of a conflict, the
 // error is a *params.ConfigCompatError and the new, unwritten config is returned.
-//
-// The returned chain configuration is never nil.
-func SetupGenesisBlock(db ethdb.Database, triedb *triedb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, error) {
+func SetupGenesisBlock(db ethdb.Database, triedb *triedb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 	return SetupGenesisBlockWithOverride(db, triedb, genesis, nil)
 }
 
-func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, genesis *Genesis, overrides *ChainOverrides) (*params.ChainConfig, common.Hash, error) {
+func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, genesis *Genesis, overrides *ChainOverrides) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
+	// Sanitize the supplied genesis, ensuring it has the associated chain
+	// config attached.
 	if genesis != nil && genesis.Config == nil {
-		return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig
+		return nil, common.Hash{}, nil, errGenesisNoConfig
 	}
-	applyOverrides := func(config *params.ChainConfig) {
-		if config != nil {
-			if overrides != nil && overrides.OverrideCancun != nil {
-				config.CancunTime = overrides.OverrideCancun
-			}
-			if overrides != nil && overrides.OverrideVerkle != nil {
-				config.VerkleTime = overrides.OverrideVerkle
-			}
-		}
-	}
-	// Just commit the new block if there is no stored genesis block.
-	stored := rawdb.ReadCanonicalHash(db, 0)
-	if (stored == common.Hash{}) {
+	// Commit the genesis if the database is empty
+	ghash := rawdb.ReadCanonicalHash(db, 0)
+	if (ghash == common.Hash{}) {
 		if genesis == nil {
 			log.Info("Writing default main-net genesis block")
 			genesis = DefaultGenesisBlock()
 		} else {
 			log.Info("Writing custom genesis block")
 		}
+		chainCfg, err := overrides.apply(genesis.Config)
+		if err != nil {
+			return nil, common.Hash{}, nil, err
+		}
+		genesis.Config = chainCfg
 
-		applyOverrides(genesis.Config)
 		block, err := genesis.Commit(db, triedb)
 		if err != nil {
-			return genesis.Config, common.Hash{}, err
+			return nil, common.Hash{}, nil, err
 		}
-		return genesis.Config, block.Hash(), nil
+		return chainCfg, block.Hash(), nil, nil
 	}
-	// The genesis block is present(perhaps in ancient database) while the
-	// state database is not initialized yet. It can happen that the node
-	// is initialized with an external ancient store. Commit genesis state
-	// in this case.
-	header := rawdb.ReadHeader(db, stored, 0)
-	if header.Root != types.EmptyRootHash && !triedb.Initialized(header.Root) {
+	// Commit the genesis if the genesis block exists in the ancient database
+	// but the key-value database is empty without initializing the genesis
+	// fields. This scenario can occur when the node is created from scratch
+	// with an existing ancient store.
+	storedCfg := rawdb.ReadChainConfig(db, ghash)
+	if storedCfg == nil {
+		// Ensure the stored genesis block matches with the given genesis. Private
+		// networks must explicitly specify the genesis in the config file, mainnet
+		// genesis will be used as default and the initialization will always fail.
 		if genesis == nil {
+			log.Info("Writing default main-net genesis block")
 			genesis = DefaultGenesisBlock()
+		} else {
+			log.Info("Writing custom genesis block")
 		}
-		applyOverrides(genesis.Config)
-		// Ensure the stored genesis matches with the given one.
-		hash := genesis.ToBlock().Hash()
-		if hash != stored {
-			return genesis.Config, hash, &GenesisMismatchError{stored, hash}
+		chainCfg, err := overrides.apply(genesis.Config)
+		if err != nil {
+			return nil, common.Hash{}, nil, err
+		}
+		genesis.Config = chainCfg
+
+		if hash := genesis.ToBlock().Hash(); hash != ghash {
+			return nil, common.Hash{}, nil, &GenesisMismatchError{ghash, hash}
 		}
 		block, err := genesis.Commit(db, triedb)
 		if err != nil {
-			return genesis.Config, hash, err
+			return nil, common.Hash{}, nil, err
 		}
-		return genesis.Config, block.Hash(), nil
+		return chainCfg, block.Hash(), nil, nil
 	}
-	// Check whether the genesis block is already written.
+	// The genesis block has already been committed previously. Verify that the
+	// provided genesis with chain overrides matches the existing one, and update
+	// the stored chain config if necessary.
 	if genesis != nil {
-		applyOverrides(genesis.Config)
-		hash := genesis.ToBlock().Hash()
-		if hash != stored {
-			return genesis.Config, hash, &GenesisMismatchError{stored, hash}
+		chainCfg, err := overrides.apply(genesis.Config)
+		if err != nil {
+			return nil, common.Hash{}, nil, err
+		}
+		genesis.Config = chainCfg
+
+		if hash := genesis.ToBlock().Hash(); hash != ghash {
+			return nil, common.Hash{}, nil, &GenesisMismatchError{ghash, hash}
 		}
-	}
-	// Get the existing chain configuration.
-	newcfg := genesis.configOrDefault(stored)
-	applyOverrides(newcfg)
-	if err := newcfg.CheckConfigForkOrder(); err != nil {
-		return newcfg, common.Hash{}, err
-	}
-	storedcfg := rawdb.ReadChainConfig(db, stored)
-	if storedcfg == nil {
-		log.Warn("Found genesis block without chain config")
-		rawdb.WriteChainConfig(db, stored, newcfg)
-		return newcfg, stored, nil
-	}
-	storedData, _ := json.Marshal(storedcfg)
-	// Special case: if a private network is being used (no genesis and also no
-	// mainnet hash in the database), we must not apply the `configOrDefault`
-	// chain config as that would be AllProtocolChanges (applying any new fork
-	// on top of an existing private network genesis block). In that case, only
-	// apply the overrides.
-	if genesis == nil && stored != params.MainnetGenesisHash {
-		newcfg = storedcfg
-		applyOverrides(newcfg)
 	}
 	// Check config compatibility and write the config. Compatibility errors
 	// are returned to the caller unless we're already at block zero.
 	head := rawdb.ReadHeadHeader(db)
 	if head == nil {
-		return newcfg, stored, errors.New("missing head header")
+		return nil, common.Hash{}, nil, errors.New("missing head header")
 	}
-	compatErr := storedcfg.CheckCompatible(newcfg, head.Number.Uint64(), head.Time)
+	newCfg := genesis.chainConfigOrDefault(ghash, storedCfg)
+
+	// TODO(rjl493456442) better to define the comparator of chain config
+	// and short circuit if the chain config is not changed.
+	compatErr := storedCfg.CheckCompatible(newCfg, head.Number.Uint64(), head.Time)
 	if compatErr != nil && ((head.Number.Uint64() != 0 && compatErr.RewindToBlock != 0) || (head.Time != 0 && compatErr.RewindToTime != 0)) {
-		return newcfg, stored, compatErr
+		return newCfg, ghash, compatErr, nil
 	}
-	// Don't overwrite if the old is identical to the new
-	if newData, _ := json.Marshal(newcfg); !bytes.Equal(storedData, newData) {
-		rawdb.WriteChainConfig(db, stored, newcfg)
+	// Don't overwrite if the old is identical to the new. It's useful
+	// for the scenarios that database is opened in the read-only mode.
+	storedData, _ := json.Marshal(storedCfg)
+	if newData, _ := json.Marshal(newCfg); !bytes.Equal(storedData, newData) {
+		rawdb.WriteChainConfig(db, ghash, newCfg)
 	}
-	return newcfg, stored, nil
+	return newCfg, ghash, nil, nil
 }
 
 // LoadChainConfig loads the stored chain config if it is already present in
@@ -396,7 +407,10 @@ func LoadChainConfig(db ethdb.Database, genesis *Genesis) (*params.ChainConfig,
 	return params.MainnetChainConfig, nil
 }
 
-func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
+// chainConfigOrDefault retrieves the attached chain configuration. If the genesis
+// object is null, it returns the default chain configuration based on the given
+// genesis hash, or the locally stored config if it's not a pre-defined network.
+func (g *Genesis) chainConfigOrDefault(ghash common.Hash, stored *params.ChainConfig) *params.ChainConfig {
 	switch {
 	case g != nil:
 		return g.Config
@@ -407,14 +421,14 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
 	case ghash == params.SepoliaGenesisHash:
 		return params.SepoliaChainConfig
 	default:
-		return params.AllEthashProtocolChanges
+		return stored
 	}
 }
 
 // IsVerkle indicates whether the state is already stored in a verkle
 // tree at genesis time.
 func (g *Genesis) IsVerkle() bool {
-	return g.Config.IsVerkle(new(big.Int).SetUint64(g.Number), g.Timestamp)
+	return g.Config.IsVerkleGenesis()
 }
 
 // ToBlock returns the genesis block according to genesis specification.
@@ -494,7 +508,7 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Blo
 	}
 	config := g.Config
 	if config == nil {
-		config = params.AllEthashProtocolChanges
+		return nil, errors.New("invalid genesis without chain config")
 	}
 	if err := config.CheckConfigForkOrder(); err != nil {
 		return nil, err
@@ -514,16 +528,17 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Blo
 	if err != nil {
 		return nil, err
 	}
-	rawdb.WriteGenesisStateSpec(db, block.Hash(), blob)
-	rawdb.WriteTd(db, block.Hash(), block.NumberU64(), block.Difficulty())
-	rawdb.WriteBlock(db, block)
-	rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil)
-	rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64())
-	rawdb.WriteHeadBlockHash(db, block.Hash())
-	rawdb.WriteHeadFastBlockHash(db, block.Hash())
-	rawdb.WriteHeadHeaderHash(db, block.Hash())
-	rawdb.WriteChainConfig(db, block.Hash(), config)
-	return block, nil
+	batch := db.NewBatch()
+	rawdb.WriteGenesisStateSpec(batch, block.Hash(), blob)
+	rawdb.WriteTd(batch, block.Hash(), block.NumberU64(), block.Difficulty())
+	rawdb.WriteBlock(batch, block)
+	rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), nil)
+	rawdb.WriteCanonicalHash(batch, block.Hash(), block.NumberU64())
+	rawdb.WriteHeadBlockHash(batch, block.Hash())
+	rawdb.WriteHeadFastBlockHash(batch, block.Hash())
+	rawdb.WriteHeadHeaderHash(batch, block.Hash())
+	rawdb.WriteChainConfig(batch, block.Hash(), config)
+	return block, batch.Write()
 }
 
 // MustCommit writes the genesis block and state to db, panicking on error.
@@ -536,6 +551,29 @@ func (g *Genesis) MustCommit(db ethdb.Database, triedb *triedb.Database) *types.
 	return block
 }
 
+// EnableVerkleAtGenesis 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) {
+	if genesis != nil {
+		if genesis.Config == nil {
+			return false, errGenesisNoConfig
+		}
+		return genesis.Config.EnableVerkleAtGenesis, nil
+	}
+	if ghash := rawdb.ReadCanonicalHash(db, 0); ghash != (common.Hash{}) {
+		chainCfg := rawdb.ReadChainConfig(db, ghash)
+		if chainCfg != nil {
+			return chainCfg.EnableVerkleAtGenesis, nil
+		}
+	}
+	return false, nil
+}
+
 // DefaultGenesisBlock returns the Ethereum main net genesis block.
 func DefaultGenesisBlock() *Genesis {
 	return &Genesis{
diff --git a/core/genesis_test.go b/core/genesis_test.go
index 3ec87474e5..964ef928c7 100644
--- a/core/genesis_test.go
+++ b/core/genesis_test.go
@@ -54,23 +54,23 @@ func testSetupGenesis(t *testing.T, scheme string) {
 	oldcustomg.Config = &params.ChainConfig{HomesteadBlock: big.NewInt(2)}
 
 	tests := []struct {
-		name       string
-		fn         func(ethdb.Database) (*params.ChainConfig, common.Hash, error)
-		wantConfig *params.ChainConfig
-		wantHash   common.Hash
-		wantErr    error
+		name           string
+		fn             func(ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error)
+		wantConfig     *params.ChainConfig
+		wantHash       common.Hash
+		wantErr        error
+		wantCompactErr *params.ConfigCompatError
 	}{
 		{
 			name: "genesis without ChainConfig",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				return SetupGenesisBlock(db, triedb.NewDatabase(db, newDbConfig(scheme)), new(Genesis))
 			},
-			wantErr:    errGenesisNoConfig,
-			wantConfig: params.AllEthashProtocolChanges,
+			wantErr: errGenesisNoConfig,
 		},
 		{
 			name: "no block in DB, genesis == nil",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				return SetupGenesisBlock(db, triedb.NewDatabase(db, newDbConfig(scheme)), nil)
 			},
 			wantHash:   params.MainnetGenesisHash,
@@ -78,7 +78,7 @@ func testSetupGenesis(t *testing.T, scheme string) {
 		},
 		{
 			name: "mainnet block in DB, genesis == nil",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				DefaultGenesisBlock().MustCommit(db, triedb.NewDatabase(db, newDbConfig(scheme)))
 				return SetupGenesisBlock(db, triedb.NewDatabase(db, newDbConfig(scheme)), nil)
 			},
@@ -87,7 +87,7 @@ func testSetupGenesis(t *testing.T, scheme string) {
 		},
 		{
 			name: "custom block in DB, genesis == nil",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				tdb := triedb.NewDatabase(db, newDbConfig(scheme))
 				customg.Commit(db, tdb)
 				return SetupGenesisBlock(db, tdb, nil)
@@ -97,18 +97,16 @@ func testSetupGenesis(t *testing.T, scheme string) {
 		},
 		{
 			name: "custom block in DB, genesis == sepolia",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				tdb := triedb.NewDatabase(db, newDbConfig(scheme))
 				customg.Commit(db, tdb)
 				return SetupGenesisBlock(db, tdb, DefaultSepoliaGenesisBlock())
 			},
-			wantErr:    &GenesisMismatchError{Stored: customghash, New: params.SepoliaGenesisHash},
-			wantHash:   params.SepoliaGenesisHash,
-			wantConfig: params.SepoliaChainConfig,
+			wantErr: &GenesisMismatchError{Stored: customghash, New: params.SepoliaGenesisHash},
 		},
 		{
 			name: "compatible config in DB",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				tdb := triedb.NewDatabase(db, newDbConfig(scheme))
 				oldcustomg.Commit(db, tdb)
 				return SetupGenesisBlock(db, tdb, &customg)
@@ -118,7 +116,7 @@ func testSetupGenesis(t *testing.T, scheme string) {
 		},
 		{
 			name: "incompatible config in DB",
-			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, error) {
+			fn: func(db ethdb.Database) (*params.ChainConfig, common.Hash, *params.ConfigCompatError, error) {
 				// Commit the 'old' genesis block with Homestead transition at #2.
 				// Advance to block #4, past the homestead transition block of customg.
 				tdb := triedb.NewDatabase(db, newDbConfig(scheme))
@@ -135,7 +133,7 @@ func testSetupGenesis(t *testing.T, scheme string) {
 			},
 			wantHash:   customghash,
 			wantConfig: customg.Config,
-			wantErr: &params.ConfigCompatError{
+			wantCompactErr: &params.ConfigCompatError{
 				What:          "Homestead fork block",
 				StoredBlock:   big.NewInt(2),
 				NewBlock:      big.NewInt(3),
@@ -146,12 +144,16 @@ func testSetupGenesis(t *testing.T, scheme string) {
 
 	for _, test := range tests {
 		db := rawdb.NewMemoryDatabase()
-		config, hash, err := test.fn(db)
+		config, hash, compatErr, err := test.fn(db)
 		// Check the return values.
 		if !reflect.DeepEqual(err, test.wantErr) {
 			spew := spew.ConfigState{DisablePointerAddresses: true, DisableCapacities: true}
 			t.Errorf("%s: returned error %#v, want %#v", test.name, spew.NewFormatter(err), spew.NewFormatter(test.wantErr))
 		}
+		if !reflect.DeepEqual(compatErr, test.wantCompactErr) {
+			spew := spew.ConfigState{DisablePointerAddresses: true, DisableCapacities: true}
+			t.Errorf("%s: returned error %#v, want %#v", test.name, spew.NewFormatter(compatErr), spew.NewFormatter(test.wantCompactErr))
+		}
 		if !reflect.DeepEqual(config, test.wantConfig) {
 			t.Errorf("%s:\nreturned %v\nwant     %v", test.name, config, test.wantConfig)
 		}
@@ -279,6 +281,7 @@ func TestVerkleGenesisCommit(t *testing.T) {
 		PragueTime:              &verkleTime,
 		VerkleTime:              &verkleTime,
 		TerminalTotalDifficulty: big.NewInt(0),
+		EnableVerkleAtGenesis:   true,
 		Ethash:                  nil,
 		Clique:                  nil,
 	}
diff --git a/core/verkle_witness_test.go b/core/verkle_witness_test.go
index 5088231207..02e94963c4 100644
--- a/core/verkle_witness_test.go
+++ b/core/verkle_witness_test.go
@@ -57,6 +57,7 @@ var (
 		ShanghaiTime:            u64(0),
 		VerkleTime:              u64(0),
 		TerminalTotalDifficulty: common.Big0,
+		EnableVerkleAtGenesis:   true,
 		// TODO uncomment when proof generation is merged
 		// ProofInBlocks:                 true,
 	}
@@ -77,6 +78,7 @@ var (
 		ShanghaiTime:            u64(0),
 		VerkleTime:              u64(0),
 		TerminalTotalDifficulty: common.Big0,
+		EnableVerkleAtGenesis:   true,
 	}
 )
 
diff --git a/miner/miner_test.go b/miner/miner_test.go
index b92febdd12..04d84e2e1d 100644
--- a/miner/miner_test.go
+++ b/miner/miner_test.go
@@ -145,7 +145,7 @@ func createMiner(t *testing.T) *Miner {
 	chainDB := rawdb.NewMemoryDatabase()
 	triedb := triedb.NewDatabase(chainDB, nil)
 	genesis := minerTestGenesisBlock(15, 11_500_000, common.HexToAddress("12345"))
-	chainConfig, _, err := core.SetupGenesisBlock(chainDB, triedb, genesis)
+	chainConfig, _, _, err := core.SetupGenesisBlock(chainDB, triedb, genesis)
 	if err != nil {
 		t.Fatalf("can't create new chain config: %v", err)
 	}
diff --git a/params/config.go b/params/config.go
index 9b3b92484a..f1e139608c 100644
--- a/params/config.go
+++ b/params/config.go
@@ -326,6 +326,19 @@ type ChainConfig struct {
 
 	DepositContractAddress common.Address `json:"depositContractAddress,omitempty"`
 
+	// EnableVerkleAtGenesis 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.
+	//
+	// This is a temporary flag only for verkle devnet testing, where verkle 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 flag irrelevant in
+	// those cases.
+	EnableVerkleAtGenesis bool `json:"enableVerkleAtGenesis,omitempty"`
+
 	// Various consensus engines
 	Ethash *EthashConfig `json:"ethash,omitempty"`
 	Clique *CliqueConfig `json:"clique,omitempty"`
@@ -525,6 +538,20 @@ func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool {
 	return c.IsLondon(num) && isTimestampForked(c.VerkleTime, time)
 }
 
+// IsVerkleGenesis 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.
+// This is a temporary workaround for verkle devnet testing, where verkle 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 (c *ChainConfig) IsVerkleGenesis() bool {
+	return c.EnableVerkleAtGenesis
+}
+
 // 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)
diff --git a/triedb/database.go b/triedb/database.go
index b448d7cd07..f8ccc5ad33 100644
--- a/triedb/database.go
+++ b/triedb/database.go
@@ -64,10 +64,6 @@ type backend interface {
 	// state. An error will be returned if the specified state is not available.
 	StateReader(root common.Hash) (database.StateReader, error)
 
-	// Initialized returns an indicator if the state data is already initialized
-	// according to the state scheme.
-	Initialized(genesisRoot common.Hash) bool
-
 	// Size returns the current storage size of the diff layers on top of the
 	// disk layer and the storage size of the nodes cached in the disk layer.
 	//
@@ -178,12 +174,6 @@ func (db *Database) Size() (common.StorageSize, common.StorageSize, common.Stora
 	return diffs, nodes, preimages
 }
 
-// Initialized returns an indicator if the state data is already initialized
-// according to the state scheme.
-func (db *Database) Initialized(genesisRoot common.Hash) bool {
-	return db.backend.Initialized(genesisRoot)
-}
-
 // Scheme returns the node scheme used in the database.
 func (db *Database) Scheme() string {
 	if db.config.PathDB != nil {
diff --git a/triedb/hashdb/database.go b/triedb/hashdb/database.go
index fb718f4e74..38392aa519 100644
--- a/triedb/hashdb/database.go
+++ b/triedb/hashdb/database.go
@@ -532,12 +532,6 @@ func (c *cleaner) Delete(key []byte) error {
 	panic("not implemented")
 }
 
-// Initialized returns an indicator if state data is already initialized
-// in hash-based scheme by checking the presence of genesis state.
-func (db *Database) Initialized(genesisRoot common.Hash) bool {
-	return rawdb.HasLegacyTrieNode(db.diskdb, genesisRoot)
-}
-
 // Update inserts the dirty nodes in provided nodeset into database and link the
 // account trie with multiple storage tries if necessary.
 func (db *Database) Update(root common.Hash, parent common.Hash, block uint64, nodes *trienode.MergedNodeSet) error {
diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go
index c31f1d44f4..b0d84eb879 100644
--- a/triedb/pathdb/database.go
+++ b/triedb/pathdb/database.go
@@ -529,21 +529,6 @@ func (db *Database) Size() (diffs common.StorageSize, nodes common.StorageSize)
 	return diffs, nodes
 }
 
-// Initialized returns an indicator if the state data is already
-// initialized in path-based scheme.
-func (db *Database) Initialized(genesisRoot common.Hash) bool {
-	var inited bool
-	db.tree.forEach(func(layer layer) {
-		if layer.rootHash() != types.EmptyRootHash {
-			inited = true
-		}
-	})
-	if !inited {
-		inited = rawdb.ReadSnapSyncStatusFlag(db.diskdb) != rawdb.StateSyncUnknown
-	}
-	return inited
-}
-
 // modifyAllowed returns the indicator if mutation is allowed. This function
 // assumes the db.lock is already held.
 func (db *Database) modifyAllowed() error {

From 1843f2776603ed1b66bfe78916d61267f80201e7 Mon Sep 17 00:00:00 2001
From: georgehao <haohongfan@gmail.com>
Date: Tue, 14 Jan 2025 21:16:15 +0800
Subject: [PATCH 6/9] all: fix some typos in comments and names (#31023)

---
 accounts/accounts.go                       |  4 +++-
 cmd/devp2p/internal/ethtest/protocol.go    |  1 +
 cmd/devp2p/internal/v4test/discv4tests.go  | 18 ++++++++--------
 consensus/clique/snapshot_test.go          |  1 -
 core/tracing/hooks.go                      |  2 +-
 core/txpool/legacypool/legacypool2_test.go |  6 +++---
 core/types/deposit.go                      |  2 +-
 core/vm/eof_validation.go                  |  6 +++---
 core/vm/program/program.go                 |  5 +++--
 crypto/blake2b/blake2b.go                  |  8 +++----
 crypto/bn256/gnark/pairing.go              |  2 +-
 crypto/ecies/ecies.go                      | 12 +++++------
 eth/tracers/dir.go                         |  2 +-
 eth/tracers/internal/util.go               |  1 +
 internal/era/builder.go                    |  3 ++-
 internal/jsre/jsre.go                      | 25 +++++++++++++++++++---
 internal/reexec/reexec.go                  |  1 +
 metrics/exp/exp.go                         |  1 +
 metrics/gauge_info.go                      |  2 +-
 metrics/log.go                             |  2 +-
 metrics/metrics.go                         |  1 +
 metrics/resetting_timer.go                 |  6 +++---
 metrics/syslog.go                          |  2 +-
 p2p/discover/v5wire/encoding_test.go       | 12 +++++------
 params/protocol_params.go                  |  2 +-
 signer/core/api.go                         |  2 +-
 signer/core/uiapi.go                       |  2 +-
 27 files changed, 79 insertions(+), 52 deletions(-)

diff --git a/accounts/accounts.go b/accounts/accounts.go
index b995498a6d..7bd911577a 100644
--- a/accounts/accounts.go
+++ b/accounts/accounts.go
@@ -214,7 +214,9 @@ const (
 	// of starting any background processes such as automatic key derivation.
 	WalletOpened
 
-	// WalletDropped
+	// WalletDropped is fired when a wallet is removed or disconnected, either via USB
+	// or due to a filesystem event in the keystore. This event indicates that the wallet
+	// is no longer available for operations.
 	WalletDropped
 )
 
diff --git a/cmd/devp2p/internal/ethtest/protocol.go b/cmd/devp2p/internal/ethtest/protocol.go
index f5f5f7e489..5c2f7d9e48 100644
--- a/cmd/devp2p/internal/ethtest/protocol.go
+++ b/cmd/devp2p/internal/ethtest/protocol.go
@@ -13,6 +13,7 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
 package ethtest
 
 import (
diff --git a/cmd/devp2p/internal/v4test/discv4tests.go b/cmd/devp2p/internal/v4test/discv4tests.go
index ca556851b4..963df6cdbc 100644
--- a/cmd/devp2p/internal/v4test/discv4tests.go
+++ b/cmd/devp2p/internal/v4test/discv4tests.go
@@ -194,7 +194,7 @@ func PingExtraData(t *utesting.T) {
 	}
 }
 
-// This test sends a PING packet with additional data and wrong 'from' field
+// PingExtraDataWrongFrom sends a PING packet with additional data and wrong 'from' field
 // and expects a PONG response.
 func PingExtraDataWrongFrom(t *utesting.T) {
 	te := newTestEnv(Remote, Listen1, Listen2)
@@ -215,7 +215,7 @@ func PingExtraDataWrongFrom(t *utesting.T) {
 	}
 }
 
-// This test sends a PING packet with an expiration in the past.
+// PingPastExpiration sends a PING packet with an expiration in the past.
 // The remote node should not respond.
 func PingPastExpiration(t *utesting.T) {
 	te := newTestEnv(Remote, Listen1, Listen2)
@@ -234,7 +234,7 @@ func PingPastExpiration(t *utesting.T) {
 	}
 }
 
-// This test sends an invalid packet. The remote node should not respond.
+// WrongPacketType sends an invalid packet. The remote node should not respond.
 func WrongPacketType(t *utesting.T) {
 	te := newTestEnv(Remote, Listen1, Listen2)
 	defer te.close()
@@ -252,7 +252,7 @@ func WrongPacketType(t *utesting.T) {
 	}
 }
 
-// This test verifies that the default behaviour of ignoring 'from' fields is unaffected by
+// BondThenPingWithWrongFrom verifies that the default behaviour of ignoring 'from' fields is unaffected by
 // the bonding process. After bonding, it pings the target with a different from endpoint.
 func BondThenPingWithWrongFrom(t *utesting.T) {
 	te := newTestEnv(Remote, Listen1, Listen2)
@@ -289,7 +289,7 @@ waitForPong:
 	}
 }
 
-// This test just sends FINDNODE. The remote node should not reply
+// FindnodeWithoutEndpointProof sends FINDNODE. The remote node should not reply
 // because the endpoint proof has not completed.
 func FindnodeWithoutEndpointProof(t *utesting.T) {
 	te := newTestEnv(Remote, Listen1, Listen2)
@@ -332,7 +332,7 @@ func BasicFindnode(t *utesting.T) {
 	}
 }
 
-// This test sends an unsolicited NEIGHBORS packet after the endpoint proof, then sends
+// UnsolicitedNeighbors sends an unsolicited NEIGHBORS packet after the endpoint proof, then sends
 // FINDNODE to read the remote table. The remote node should not return the node contained
 // in the unsolicited NEIGHBORS packet.
 func UnsolicitedNeighbors(t *utesting.T) {
@@ -373,7 +373,7 @@ func UnsolicitedNeighbors(t *utesting.T) {
 	}
 }
 
-// This test sends FINDNODE with an expiration timestamp in the past.
+// FindnodePastExpiration sends FINDNODE with an expiration timestamp in the past.
 // The remote node should not respond.
 func FindnodePastExpiration(t *utesting.T) {
 	te := newTestEnv(Remote, Listen1, Listen2)
@@ -426,7 +426,7 @@ func bond(t *utesting.T, te *testenv) {
 	}
 }
 
-// This test attempts to perform a traffic amplification attack against a
+// FindnodeAmplificationInvalidPongHash attempts to perform a traffic amplification attack against a
 // 'victim' endpoint using FINDNODE. In this attack scenario, the attacker
 // attempts to complete the endpoint proof non-interactively by sending a PONG
 // with mismatching reply token from the 'victim' endpoint. The attack works if
@@ -478,7 +478,7 @@ func FindnodeAmplificationInvalidPongHash(t *utesting.T) {
 	}
 }
 
-// This test attempts to perform a traffic amplification attack using FINDNODE.
+// FindnodeAmplificationWrongIP attempts to perform a traffic amplification attack using FINDNODE.
 // The attack works if the remote node does not verify the IP address of FINDNODE
 // against the endpoint verification proof done by PING/PONG.
 func FindnodeAmplificationWrongIP(t *utesting.T) {
diff --git a/consensus/clique/snapshot_test.go b/consensus/clique/snapshot_test.go
index 6c46d1db4f..a83d6ca736 100644
--- a/consensus/clique/snapshot_test.go
+++ b/consensus/clique/snapshot_test.go
@@ -467,7 +467,6 @@ func (tt *cliqueTest) run(t *testing.T) {
 	for j := 0; j < len(batches)-1; j++ {
 		if k, err := chain.InsertChain(batches[j]); err != nil {
 			t.Fatalf("failed to import batch %d, block %d: %v", j, k, err)
-			break
 		}
 	}
 	if _, err = chain.InsertChain(batches[len(batches)-1]); err != tt.failure {
diff --git a/core/tracing/hooks.go b/core/tracing/hooks.go
index 728f15069b..4343edfe86 100644
--- a/core/tracing/hooks.go
+++ b/core/tracing/hooks.go
@@ -293,7 +293,7 @@ const (
 	GasChangeCallLeftOverRefunded GasChangeReason = 7
 	// GasChangeCallContractCreation is the amount of gas that will be burned for a CREATE.
 	GasChangeCallContractCreation GasChangeReason = 8
-	// GasChangeContractCreation is the amount of gas that will be burned for a CREATE2.
+	// GasChangeCallContractCreation2 is the amount of gas that will be burned for a CREATE2.
 	GasChangeCallContractCreation2 GasChangeReason = 9
 	// GasChangeCallCodeStorage is the amount of gas that will be charged for code storage.
 	GasChangeCallCodeStorage GasChangeReason = 10
diff --git a/core/txpool/legacypool/legacypool2_test.go b/core/txpool/legacypool/legacypool2_test.go
index 1377479da1..8af9624994 100644
--- a/core/txpool/legacypool/legacypool2_test.go
+++ b/core/txpool/legacypool/legacypool2_test.go
@@ -162,12 +162,12 @@ func TestTransactionZAttack(t *testing.T) {
 		var ivpendingNum int
 		pendingtxs, _ := pool.Content()
 		for account, txs := range pendingtxs {
-			cur_balance := new(big.Int).Set(pool.currentState.GetBalance(account).ToBig())
+			curBalance := new(big.Int).Set(pool.currentState.GetBalance(account).ToBig())
 			for _, tx := range txs {
-				if cur_balance.Cmp(tx.Value()) <= 0 {
+				if curBalance.Cmp(tx.Value()) <= 0 {
 					ivpendingNum++
 				} else {
-					cur_balance.Sub(cur_balance, tx.Value())
+					curBalance.Sub(curBalance, tx.Value())
 				}
 			}
 		}
diff --git a/core/types/deposit.go b/core/types/deposit.go
index 3bba2c7aa4..8015f29ca7 100644
--- a/core/types/deposit.go
+++ b/core/types/deposit.go
@@ -24,7 +24,7 @@ const (
 	depositRequestSize = 192
 )
 
-// UnpackIntoDeposit unpacks a serialized DepositEvent.
+// DepositLogToRequest unpacks a serialized DepositEvent.
 func DepositLogToRequest(data []byte) ([]byte, error) {
 	if len(data) != 576 {
 		return nil, fmt.Errorf("deposit wrong length: want 576, have %d", len(data))
diff --git a/core/vm/eof_validation.go b/core/vm/eof_validation.go
index fa534edce9..514f9fb58c 100644
--- a/core/vm/eof_validation.go
+++ b/core/vm/eof_validation.go
@@ -109,8 +109,8 @@ func validateCode(code []byte, section int, container *Container, jt *JumpTable,
 				return nil, err
 			}
 		case RJUMPV:
-			max_size := int(code[i+1])
-			length := max_size + 1
+			maxSize := int(code[i+1])
+			length := maxSize + 1
 			if len(code) <= i+length {
 				return nil, fmt.Errorf("%w: jump table truncated, op %s, pos %d", errTruncatedImmediate, op, i)
 			}
@@ -120,7 +120,7 @@ func validateCode(code []byte, section int, container *Container, jt *JumpTable,
 					return nil, err
 				}
 			}
-			i += 2 * max_size
+			i += 2 * maxSize
 		case CALLF:
 			arg, _ := parseUint16(code[i+1:])
 			if arg >= len(container.types) {
diff --git a/core/vm/program/program.go b/core/vm/program/program.go
index acc7fd25fc..3b00bbae6f 100644
--- a/core/vm/program/program.go
+++ b/core/vm/program/program.go
@@ -19,6 +19,7 @@
 // - There are not package guarantees. We might iterate heavily on this package, and do backwards-incompatible changes without warning
 // - There are no quality-guarantees. These utilities may produce evm-code that is non-functional. YMMV.
 // - There are no stability-guarantees. The utility will `panic` if the inputs do not align / make sense.
+
 package program
 
 import (
@@ -204,7 +205,7 @@ func (p *Program) StaticCall(gas *uint256.Int, address, inOffset, inSize, outOff
 	return p.Op(vm.STATICCALL)
 }
 
-// StaticCall is a convenience function to make a callcode. If 'gas' is nil, the opcode GAS will
+// CallCode is a convenience function to make a callcode. If 'gas' is nil, the opcode GAS will
 // be used to provide all gas.
 func (p *Program) CallCode(gas *uint256.Int, address, value, inOffset, inSize, outOffset, outSize any) *Program {
 	if outOffset == outSize && inSize == outSize && inOffset == outSize {
@@ -263,7 +264,7 @@ func (p *Program) InputAddressToStack(inputOffset uint32) *Program {
 	return p.Op(vm.AND)
 }
 
-// MStore stores the provided data (into the memory area starting at memStart).
+// Mstore stores the provided data (into the memory area starting at memStart).
 func (p *Program) Mstore(data []byte, memStart uint32) *Program {
 	var idx = 0
 	// We need to store it in chunks of 32 bytes
diff --git a/crypto/blake2b/blake2b.go b/crypto/blake2b/blake2b.go
index 7ecaab8139..c24a88b99d 100644
--- a/crypto/blake2b/blake2b.go
+++ b/crypto/blake2b/blake2b.go
@@ -23,13 +23,13 @@ import (
 )
 
 const (
-	// The blocksize of BLAKE2b in bytes.
+	// BlockSize the blocksize of BLAKE2b in bytes.
 	BlockSize = 128
-	// The hash size of BLAKE2b-512 in bytes.
+	// Size the hash size of BLAKE2b-512 in bytes.
 	Size = 64
-	// The hash size of BLAKE2b-384 in bytes.
+	// Size384 the hash size of BLAKE2b-384 in bytes.
 	Size384 = 48
-	// The hash size of BLAKE2b-256 in bytes.
+	// Size256 the hash size of BLAKE2b-256 in bytes.
 	Size256 = 32
 )
 
diff --git a/crypto/bn256/gnark/pairing.go b/crypto/bn256/gnark/pairing.go
index 39e8a657f4..439ce0a39d 100644
--- a/crypto/bn256/gnark/pairing.go
+++ b/crypto/bn256/gnark/pairing.go
@@ -4,7 +4,7 @@ import (
 	"github.com/consensys/gnark-crypto/ecc/bn254"
 )
 
-// Computes the following relation: ∏ᵢ e(Pᵢ, Qᵢ) =? 1
+// PairingCheck computes the following relation: ∏ᵢ e(Pᵢ, Qᵢ) =? 1
 //
 // To explain why gnark returns a (bool, error):
 //
diff --git a/crypto/ecies/ecies.go b/crypto/ecies/ecies.go
index 1b6c9e97c1..76f934c72d 100644
--- a/crypto/ecies/ecies.go
+++ b/crypto/ecies/ecies.go
@@ -60,12 +60,12 @@ type PublicKey struct {
 	Params *ECIESParams
 }
 
-// Export an ECIES public key as an ECDSA public key.
+// ExportECDSA exports an ECIES public key as an ECDSA public key.
 func (pub *PublicKey) ExportECDSA() *ecdsa.PublicKey {
 	return &ecdsa.PublicKey{Curve: pub.Curve, X: pub.X, Y: pub.Y}
 }
 
-// Import an ECDSA public key as an ECIES public key.
+// ImportECDSAPublic imports an ECDSA public key as an ECIES public key.
 func ImportECDSAPublic(pub *ecdsa.PublicKey) *PublicKey {
 	return &PublicKey{
 		X:      pub.X,
@@ -81,20 +81,20 @@ type PrivateKey struct {
 	D *big.Int
 }
 
-// Export an ECIES private key as an ECDSA private key.
+// ExportECDSA exports an ECIES private key as an ECDSA private key.
 func (prv *PrivateKey) ExportECDSA() *ecdsa.PrivateKey {
 	pub := &prv.PublicKey
 	pubECDSA := pub.ExportECDSA()
 	return &ecdsa.PrivateKey{PublicKey: *pubECDSA, D: prv.D}
 }
 
-// Import an ECDSA private key as an ECIES private key.
+// ImportECDSA imports an ECDSA private key as an ECIES private key.
 func ImportECDSA(prv *ecdsa.PrivateKey) *PrivateKey {
 	pub := ImportECDSAPublic(&prv.PublicKey)
 	return &PrivateKey{*pub, prv.D}
 }
 
-// Generate an elliptic curve public / private keypair. If params is nil,
+// GenerateKey generates an elliptic curve public / private keypair. If params is nil,
 // the recommended default parameters for the key will be chosen.
 func GenerateKey(rand io.Reader, curve elliptic.Curve, params *ECIESParams) (prv *PrivateKey, err error) {
 	sk, err := ecdsa.GenerateKey(curve, rand)
@@ -119,7 +119,7 @@ func MaxSharedKeyLength(pub *PublicKey) int {
 	return (pub.Curve.Params().BitSize + 7) / 8
 }
 
-// ECDH key agreement method used to establish secret keys for encryption.
+// GenerateShared ECDH key agreement method used to establish secret keys for encryption.
 func (prv *PrivateKey) GenerateShared(pub *PublicKey, skLen, macLen int) (sk []byte, err error) {
 	if prv.PublicKey.Curve != pub.Curve {
 		return nil, ErrInvalidCurve
diff --git a/eth/tracers/dir.go b/eth/tracers/dir.go
index 55bcb44d23..1cdfab5454 100644
--- a/eth/tracers/dir.go
+++ b/eth/tracers/dir.go
@@ -34,7 +34,7 @@ type Context struct {
 	TxHash      common.Hash // Hash of the transaction being traced (zero if dangling call)
 }
 
-// The set of methods that must be exposed by a tracer
+// Tracer represents the set of methods that must be exposed by a tracer
 // for it to be available through the RPC interface.
 // This involves a method to retrieve results and one to
 // stop tracing.
diff --git a/eth/tracers/internal/util.go b/eth/tracers/internal/util.go
index 347af43d51..cff6295566 100644
--- a/eth/tracers/internal/util.go
+++ b/eth/tracers/internal/util.go
@@ -13,6 +13,7 @@
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
 package internal
 
 import (
diff --git a/internal/era/builder.go b/internal/era/builder.go
index 75782a08c2..33261555ba 100644
--- a/internal/era/builder.go
+++ b/internal/era/builder.go
@@ -12,7 +12,8 @@
 // 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 <http://www.gnu.org/licenses/>.
+// along with go-ethereum. If not, see <http//www.gnu.org/licenses/>.
+
 package era
 
 import (
diff --git a/internal/jsre/jsre.go b/internal/jsre/jsre.go
index f6e21d2ef7..0dfeae8e1b 100644
--- a/internal/jsre/jsre.go
+++ b/internal/jsre/jsre.go
@@ -67,7 +67,19 @@ type evalReq struct {
 	done chan bool
 }
 
-// runtime must be stopped with Stop() after use and cannot be used after stopping
+// New creates and initializes a new JavaScript runtime environment (JSRE).
+// The runtime is configured with the provided assetPath for loading scripts and
+// an output writer for logging or printing results.
+//
+// The returned JSRE must be stopped by calling Stop() after use to release resources.
+// Attempting to use the JSRE after stopping it will result in undefined behavior.
+//
+// Parameters:
+//   - assetPath: The path to the directory containing script assets.
+//   - output: The writer used for logging or printing runtime output.
+//
+// Returns:
+//   - A pointer to the newly created JSRE instance.
 func New(assetPath string, output io.Writer) *JSRE {
 	re := &JSRE{
 		assetPath:     assetPath,
@@ -251,8 +263,15 @@ func (re *JSRE) Stop(waitForCallbacks bool) {
 	}
 }
 
-// Exec(file) loads and runs the contents of a file
-// if a relative path is given, the jsre's assetPath is used
+// Exec loads and executes the contents of a JavaScript file.
+// If a relative path is provided, the file is resolved relative to the JSRE's assetPath.
+// The file is read, compiled, and executed in the JSRE's runtime environment.
+//
+// Parameters:
+//   - file: The path to the JavaScript file to execute. Can be an absolute path or relative to assetPath.
+//
+// Returns:
+//   - error: An error if the file cannot be read, compiled, or executed.
 func (re *JSRE) Exec(file string) error {
 	code, err := os.ReadFile(common.AbsolutePath(re.assetPath, file))
 	if err != nil {
diff --git a/internal/reexec/reexec.go b/internal/reexec/reexec.go
index af8d347986..7dc6d9222e 100644
--- a/internal/reexec/reexec.go
+++ b/internal/reexec/reexec.go
@@ -7,6 +7,7 @@
 // we require because of the forking limitations of using Go.  Handlers can be
 // registered with a name and the argv 0 of the exec of the binary will be used
 // to find and execute custom init paths.
+
 package reexec
 
 import (
diff --git a/metrics/exp/exp.go b/metrics/exp/exp.go
index 5213979aa2..85cabca6b1 100644
--- a/metrics/exp/exp.go
+++ b/metrics/exp/exp.go
@@ -1,5 +1,6 @@
 // Hook go-metrics into expvar
 // on any /debug/metrics request, load all vars from the registry into expvar, and execute regular expvar handler
+
 package exp
 
 import (
diff --git a/metrics/gauge_info.go b/metrics/gauge_info.go
index 2f78455649..1862ed55c5 100644
--- a/metrics/gauge_info.go
+++ b/metrics/gauge_info.go
@@ -39,7 +39,7 @@ func NewRegisteredGaugeInfo(name string, r Registry) *GaugeInfo {
 	return c
 }
 
-// gaugeInfoSnapshot is a read-only copy of another GaugeInfo.
+// GaugeInfoSnapshot is a read-only copy of another GaugeInfo.
 type GaugeInfoSnapshot GaugeInfoValue
 
 // Value returns the value at the time the snapshot was taken.
diff --git a/metrics/log.go b/metrics/log.go
index 3380bbf9c4..08f3effb81 100644
--- a/metrics/log.go
+++ b/metrics/log.go
@@ -12,7 +12,7 @@ func Log(r Registry, freq time.Duration, l Logger) {
 	LogScaled(r, freq, time.Nanosecond, l)
 }
 
-// Output each metric in the given registry periodically using the given
+// LogScaled outputs each metric in the given registry periodically using the given
 // logger. Print timings in `scale` units (eg time.Millisecond) rather than nanos.
 func LogScaled(r Registry, freq time.Duration, scale time.Duration, l Logger) {
 	du := float64(scale)
diff --git a/metrics/metrics.go b/metrics/metrics.go
index a9d6623173..c4c43b7576 100644
--- a/metrics/metrics.go
+++ b/metrics/metrics.go
@@ -3,6 +3,7 @@
 // <https://github.com/rcrowley/go-metrics>
 //
 // Coda Hale's original work: <https://github.com/codahale/metrics>
+
 package metrics
 
 import (
diff --git a/metrics/resetting_timer.go b/metrics/resetting_timer.go
index 1b3e87bc3d..66458bdb91 100644
--- a/metrics/resetting_timer.go
+++ b/metrics/resetting_timer.go
@@ -53,14 +53,14 @@ func (t *ResettingTimer) Snapshot() *ResettingTimerSnapshot {
 	return snapshot
 }
 
-// Record the duration of the execution of the given function.
+// Time records the duration of the execution of the given function.
 func (t *ResettingTimer) Time(f func()) {
 	ts := time.Now()
 	f()
 	t.Update(time.Since(ts))
 }
 
-// Record the duration of an event.
+// Update records the duration of an event.
 func (t *ResettingTimer) Update(d time.Duration) {
 	if !metricsEnabled {
 		return
@@ -71,7 +71,7 @@ func (t *ResettingTimer) Update(d time.Duration) {
 	t.sum += int64(d)
 }
 
-// Record the duration of an event that started at a time and ends now.
+// UpdateSince records the duration of an event that started at a time and ends now.
 func (t *ResettingTimer) UpdateSince(ts time.Time) {
 	t.Update(time.Since(ts))
 }
diff --git a/metrics/syslog.go b/metrics/syslog.go
index 0bc4ed0da5..b265328f87 100644
--- a/metrics/syslog.go
+++ b/metrics/syslog.go
@@ -9,7 +9,7 @@ import (
 	"time"
 )
 
-// Output each metric in the given registry to syslog periodically using
+// Syslog outputs each metric in the given registry to syslog periodically using
 // the given syslogger.
 func Syslog(r Registry, d time.Duration, w *syslog.Writer) {
 	for range time.Tick(d) {
diff --git a/p2p/discover/v5wire/encoding_test.go b/p2p/discover/v5wire/encoding_test.go
index c66a0da9d3..df97e40e89 100644
--- a/p2p/discover/v5wire/encoding_test.go
+++ b/p2p/discover/v5wire/encoding_test.go
@@ -249,20 +249,20 @@ func TestHandshake_BadHandshakeAttack(t *testing.T) {
 	net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
 
 	// A -> B   FINDNODE
-	incorrect_challenge := &Whoareyou{
+	incorrectChallenge := &Whoareyou{
 		IDNonce:   [16]byte{5, 6, 7, 8, 9, 6, 11, 12},
 		RecordSeq: challenge.RecordSeq,
 		Node:      challenge.Node,
 		sent:      challenge.sent,
 	}
-	incorrect_findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, incorrect_challenge, &Findnode{})
-	incorrect_findnode2 := make([]byte, len(incorrect_findnode))
-	copy(incorrect_findnode2, incorrect_findnode)
+	incorrectFindNode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, incorrectChallenge, &Findnode{})
+	incorrectFindNode2 := make([]byte, len(incorrectFindNode))
+	copy(incorrectFindNode2, incorrectFindNode)
 
-	net.nodeB.expectDecodeErr(t, errInvalidNonceSig, incorrect_findnode)
+	net.nodeB.expectDecodeErr(t, errInvalidNonceSig, incorrectFindNode)
 
 	// Reject new findnode as previous handshake is now deleted.
-	net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, incorrect_findnode2)
+	net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, incorrectFindNode2)
 
 	// The findnode packet is again rejected even with a valid challenge this time.
 	findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
diff --git a/params/protocol_params.go b/params/protocol_params.go
index b46e8d66b2..030083aa9a 100644
--- a/params/protocol_params.go
+++ b/params/protocol_params.go
@@ -179,7 +179,7 @@ const (
 	HistoryServeWindow = 8192 // Number of blocks to serve historical block hashes for, EIP-2935.
 )
 
-// Gas discount table for BLS12-381 G1 and G2 multi exponentiation operations
+// Bls12381MultiExpDiscountTable gas discount table for BLS12-381 G1 and G2 multi exponentiation operations
 var Bls12381MultiExpDiscountTable = [128]uint64{1200, 888, 764, 641, 594, 547, 500, 453, 438, 423, 408, 394, 379, 364, 349, 334, 330, 326, 322, 318, 314, 310, 306, 302, 298, 294, 289, 285, 281, 277, 273, 269, 268, 266, 265, 263, 262, 260, 259, 257, 256, 254, 253, 251, 250, 248, 247, 245, 244, 242, 241, 239, 238, 236, 235, 233, 232, 231, 229, 228, 226, 225, 223, 222, 221, 220, 219, 219, 218, 217, 216, 216, 215, 214, 213, 213, 212, 211, 211, 210, 209, 208, 208, 207, 206, 205, 205, 204, 203, 202, 202, 201, 200, 199, 199, 198, 197, 196, 196, 195, 194, 193, 193, 192, 191, 191, 190, 189, 188, 188, 187, 186, 185, 185, 184, 183, 182, 182, 181, 180, 179, 179, 178, 177, 176, 176, 175, 174}
 
 // Difficulty parameters.
diff --git a/signer/core/api.go b/signer/core/api.go
index def2d6041f..12acf925f0 100644
--- a/signer/core/api.go
+++ b/signer/core/api.go
@@ -664,7 +664,7 @@ func (api *SignerAPI) SignGnosisSafeTx(ctx context.Context, signerAddress common
 	return &gnosisTx, nil
 }
 
-// Returns the external api version. This method does not require user acceptance. Available methods are
+// Version returns the external api version. This method does not require user acceptance. Available methods are
 // available via enumeration anyway, and this info does not contain user-specific data
 func (api *SignerAPI) Version(ctx context.Context) (string, error) {
 	return ExternalAPIVersion, nil
diff --git a/signer/core/uiapi.go b/signer/core/uiapi.go
index 43edfe7d97..2f511c7e19 100644
--- a/signer/core/uiapi.go
+++ b/signer/core/uiapi.go
@@ -48,7 +48,7 @@ func NewUIServerAPI(extapi *SignerAPI) *UIServerAPI {
 	return &UIServerAPI{extapi, extapi.am}
 }
 
-// List available accounts. As opposed to the external API definition, this method delivers
+// ListAccounts lists available accounts. As opposed to the external API definition, this method delivers
 // the full Account object and not only Address.
 // Example call
 // {"jsonrpc":"2.0","method":"clef_listAccounts","params":[], "id":4}

From 04a336aee8a911504b2bacc3fb755d726829b235 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 14 Jan 2025 14:42:18 +0100
Subject: [PATCH 7/9] core/types: change SetCodeTx.ChainID to uint256 (#30982)

We still need to decide how to handle non-specfic `chainId` in the JSON
encoding of authorizations. With `chainId` being a uint64, the previous
implementation just used value zero. However, it might actually be more
correct to use the value `null` for this case.
---
 core/blockchain_test.go               |  5 ++---
 core/state_transition.go              |  4 ++--
 core/types/gen_authorization.go       |  8 ++++----
 core/types/transaction_marshalling.go | 16 +++++++++++-----
 core/types/transaction_signing.go     |  2 +-
 core/types/tx_blob.go                 |  6 +++---
 core/types/tx_dynamic_fee.go          |  6 +++---
 core/types/tx_setcode.go              | 16 ++++++++--------
 internal/ethapi/transaction_args.go   |  2 +-
 tests/gen_stauthorization.go          | 11 ++++++-----
 tests/state_test_util.go              |  6 +++---
 11 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index f2a9b953a1..7805a7c6e8 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -4265,12 +4265,11 @@ func TestEIP7702(t *testing.T) {
 	// 2. addr1:0xaaaa calls into addr2:0xbbbb
 	// 3. addr2:0xbbbb  writes to storage
 	auth1, _ := types.SignSetCode(key1, types.SetCodeAuthorization{
-		ChainID: gspec.Config.ChainID.Uint64(),
+		ChainID: *uint256.MustFromBig(gspec.Config.ChainID),
 		Address: aa,
 		Nonce:   1,
 	})
 	auth2, _ := types.SignSetCode(key2, types.SetCodeAuthorization{
-		ChainID: 0,
 		Address: bb,
 		Nonce:   0,
 	})
@@ -4278,7 +4277,7 @@ func TestEIP7702(t *testing.T) {
 	_, blocks, _ := GenerateChainWithGenesis(gspec, engine, 1, func(i int, b *BlockGen) {
 		b.SetCoinbase(aa)
 		txdata := &types.SetCodeTx{
-			ChainID:   gspec.Config.ChainID.Uint64(),
+			ChainID:   uint256.MustFromBig(gspec.Config.ChainID),
 			Nonce:     0,
 			To:        addr1,
 			Gas:       500000,
diff --git a/core/state_transition.go b/core/state_transition.go
index 009b679b27..b6203e6aae 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -529,8 +529,8 @@ func (st *stateTransition) execute() (*ExecutionResult, error) {
 
 // validateAuthorization validates an EIP-7702 authorization against the state.
 func (st *stateTransition) validateAuthorization(auth *types.SetCodeAuthorization) (authority common.Address, err error) {
-	// Verify chain ID is 0 or equal to current chain ID.
-	if auth.ChainID != 0 && st.evm.ChainConfig().ChainID.Uint64() != auth.ChainID {
+	// Verify chain ID is null or equal to current chain ID.
+	if !auth.ChainID.IsZero() && auth.ChainID.CmpBig(st.evm.ChainConfig().ChainID) != 0 {
 		return authority, ErrAuthorizationWrongChainID
 	}
 	// Limit nonce to 2^64-1 per EIP-2681.
diff --git a/core/types/gen_authorization.go b/core/types/gen_authorization.go
index be5467c50d..57069cbb1f 100644
--- a/core/types/gen_authorization.go
+++ b/core/types/gen_authorization.go
@@ -16,7 +16,7 @@ var _ = (*authorizationMarshaling)(nil)
 // MarshalJSON marshals as JSON.
 func (s SetCodeAuthorization) MarshalJSON() ([]byte, error) {
 	type SetCodeAuthorization struct {
-		ChainID hexutil.Uint64 `json:"chainId" gencodec:"required"`
+		ChainID hexutil.U256   `json:"chainId" gencodec:"required"`
 		Address common.Address `json:"address" gencodec:"required"`
 		Nonce   hexutil.Uint64 `json:"nonce" gencodec:"required"`
 		V       hexutil.Uint64 `json:"yParity" gencodec:"required"`
@@ -24,7 +24,7 @@ func (s SetCodeAuthorization) MarshalJSON() ([]byte, error) {
 		S       hexutil.U256   `json:"s" gencodec:"required"`
 	}
 	var enc SetCodeAuthorization
-	enc.ChainID = hexutil.Uint64(s.ChainID)
+	enc.ChainID = hexutil.U256(s.ChainID)
 	enc.Address = s.Address
 	enc.Nonce = hexutil.Uint64(s.Nonce)
 	enc.V = hexutil.Uint64(s.V)
@@ -36,7 +36,7 @@ func (s SetCodeAuthorization) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals from JSON.
 func (s *SetCodeAuthorization) UnmarshalJSON(input []byte) error {
 	type SetCodeAuthorization struct {
-		ChainID *hexutil.Uint64 `json:"chainId" gencodec:"required"`
+		ChainID *hexutil.U256   `json:"chainId" gencodec:"required"`
 		Address *common.Address `json:"address" gencodec:"required"`
 		Nonce   *hexutil.Uint64 `json:"nonce" gencodec:"required"`
 		V       *hexutil.Uint64 `json:"yParity" gencodec:"required"`
@@ -50,7 +50,7 @@ func (s *SetCodeAuthorization) UnmarshalJSON(input []byte) error {
 	if dec.ChainID == nil {
 		return errors.New("missing required field 'chainId' for SetCodeAuthorization")
 	}
-	s.ChainID = uint64(*dec.ChainID)
+	s.ChainID = uint256.Int(*dec.ChainID)
 	if dec.Address == nil {
 		return errors.New("missing required field 'address' for SetCodeAuthorization")
 	}
diff --git a/core/types/transaction_marshalling.go b/core/types/transaction_marshalling.go
index 993d633c6f..1bbb97a3ec 100644
--- a/core/types/transaction_marshalling.go
+++ b/core/types/transaction_marshalling.go
@@ -155,7 +155,7 @@ func (tx *Transaction) MarshalJSON() ([]byte, error) {
 			enc.Proofs = itx.Sidecar.Proofs
 		}
 	case *SetCodeTx:
-		enc.ChainID = (*hexutil.Big)(new(big.Int).SetUint64(itx.ChainID))
+		enc.ChainID = (*hexutil.Big)(itx.ChainID.ToBig())
 		enc.Nonce = (*hexutil.Uint64)(&itx.Nonce)
 		enc.To = tx.To()
 		enc.Gas = (*hexutil.Uint64)(&itx.Gas)
@@ -353,7 +353,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.ChainID == nil {
 			return errors.New("missing required field 'chainId' in transaction")
 		}
-		itx.ChainID = uint256.MustFromBig((*big.Int)(dec.ChainID))
+		var overflow bool
+		itx.ChainID, overflow = uint256.FromBig(dec.ChainID.ToInt())
+		if overflow {
+			return errors.New("'chainId' value overflows uint256")
+		}
 		if dec.Nonce == nil {
 			return errors.New("missing required field 'nonce' in transaction")
 		}
@@ -395,7 +399,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		itx.BlobHashes = dec.BlobVersionedHashes
 
 		// signature R
-		var overflow bool
 		if dec.R == nil {
 			return errors.New("missing required field 'r' in transaction")
 		}
@@ -432,7 +435,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.ChainID == nil {
 			return errors.New("missing required field 'chainId' in transaction")
 		}
-		itx.ChainID = dec.ChainID.ToInt().Uint64()
+		var overflow bool
+		itx.ChainID, overflow = uint256.FromBig(dec.ChainID.ToInt())
+		if overflow {
+			return errors.New("'chainId' value overflows uint256")
+		}
 		if dec.Nonce == nil {
 			return errors.New("missing required field 'nonce' in transaction")
 		}
@@ -470,7 +477,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		itx.AuthList = dec.AuthorizationList
 
 		// signature R
-		var overflow bool
 		if dec.R == nil {
 			return errors.New("missing required field 'r' in transaction")
 		}
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index d72643b4a8..4d70f37bd3 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -219,7 +219,7 @@ func (s pragueSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
 	}
 	// Check that chain ID of tx matches the signer. We also accept ID zero here,
 	// because it indicates that the chain ID was not specified in the tx.
-	if txdata.ChainID != 0 && new(big.Int).SetUint64(txdata.ChainID).Cmp(s.chainId) != 0 {
+	if txdata.ChainID != nil && txdata.ChainID.CmpBig(s.chainId) != 0 {
 		return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.chainId)
 	}
 	R, S, _ = decodeSignature(sig)
diff --git a/core/types/tx_blob.go b/core/types/tx_blob.go
index ce1f287caa..88251ab957 100644
--- a/core/types/tx_blob.go
+++ b/core/types/tx_blob.go
@@ -47,9 +47,9 @@ type BlobTx struct {
 	Sidecar *BlobTxSidecar `rlp:"-"`
 
 	// Signature values
-	V *uint256.Int `json:"v" gencodec:"required"`
-	R *uint256.Int `json:"r" gencodec:"required"`
-	S *uint256.Int `json:"s" gencodec:"required"`
+	V *uint256.Int
+	R *uint256.Int
+	S *uint256.Int
 }
 
 // BlobTxSidecar contains the blobs of a blob transaction.
diff --git a/core/types/tx_dynamic_fee.go b/core/types/tx_dynamic_fee.go
index 8b5b514fde..981755cf70 100644
--- a/core/types/tx_dynamic_fee.go
+++ b/core/types/tx_dynamic_fee.go
@@ -37,9 +37,9 @@ type DynamicFeeTx struct {
 	AccessList AccessList
 
 	// Signature values
-	V *big.Int `json:"v" gencodec:"required"`
-	R *big.Int `json:"r" gencodec:"required"`
-	S *big.Int `json:"s" gencodec:"required"`
+	V *big.Int
+	R *big.Int
+	S *big.Int
 }
 
 // copy creates a deep copy of the transaction data and initializes all fields.
diff --git a/core/types/tx_setcode.go b/core/types/tx_setcode.go
index f14ae3bc9d..0fb5362c26 100644
--- a/core/types/tx_setcode.go
+++ b/core/types/tx_setcode.go
@@ -49,7 +49,7 @@ func AddressToDelegation(addr common.Address) []byte {
 // SetCodeTx implements the EIP-7702 transaction type which temporarily installs
 // the code at the signer's address.
 type SetCodeTx struct {
-	ChainID    uint64
+	ChainID    *uint256.Int
 	Nonce      uint64
 	GasTipCap  *uint256.Int // a.k.a. maxPriorityFeePerGas
 	GasFeeCap  *uint256.Int // a.k.a. maxFeePerGas
@@ -61,16 +61,16 @@ type SetCodeTx struct {
 	AuthList   []SetCodeAuthorization
 
 	// Signature values
-	V *uint256.Int `json:"v" gencodec:"required"`
-	R *uint256.Int `json:"r" gencodec:"required"`
-	S *uint256.Int `json:"s" gencodec:"required"`
+	V *uint256.Int
+	R *uint256.Int
+	S *uint256.Int
 }
 
 //go:generate go run github.com/fjl/gencodec -type SetCodeAuthorization -field-override authorizationMarshaling -out gen_authorization.go
 
 // SetCodeAuthorization is an authorization from an account to deploy code at its address.
 type SetCodeAuthorization struct {
-	ChainID uint64         `json:"chainId" gencodec:"required"`
+	ChainID uint256.Int    `json:"chainId" gencodec:"required"`
 	Address common.Address `json:"address" gencodec:"required"`
 	Nonce   uint64         `json:"nonce" gencodec:"required"`
 	V       uint8          `json:"yParity" gencodec:"required"`
@@ -80,7 +80,7 @@ type SetCodeAuthorization struct {
 
 // field type overrides for gencodec
 type authorizationMarshaling struct {
-	ChainID hexutil.Uint64
+	ChainID hexutil.U256
 	Nonce   hexutil.Uint64
 	V       hexutil.Uint64
 	R       hexutil.U256
@@ -180,7 +180,7 @@ func (tx *SetCodeTx) copy() TxData {
 
 // accessors for innerTx.
 func (tx *SetCodeTx) txType() byte           { return SetCodeTxType }
-func (tx *SetCodeTx) chainID() *big.Int      { return big.NewInt(int64(tx.ChainID)) }
+func (tx *SetCodeTx) chainID() *big.Int      { return tx.ChainID.ToBig() }
 func (tx *SetCodeTx) accessList() AccessList { return tx.AccessList }
 func (tx *SetCodeTx) data() []byte           { return tx.Data }
 func (tx *SetCodeTx) gas() uint64            { return tx.Gas }
@@ -207,7 +207,7 @@ func (tx *SetCodeTx) rawSignatureValues() (v, r, s *big.Int) {
 }
 
 func (tx *SetCodeTx) setSignatureValues(chainID, v, r, s *big.Int) {
-	tx.ChainID = chainID.Uint64()
+	tx.ChainID = uint256.MustFromBig(chainID)
 	tx.V.SetFromBig(v)
 	tx.R.SetFromBig(r)
 	tx.S.SetFromBig(s)
diff --git a/internal/ethapi/transaction_args.go b/internal/ethapi/transaction_args.go
index a39a6666f4..175ac13a0f 100644
--- a/internal/ethapi/transaction_args.go
+++ b/internal/ethapi/transaction_args.go
@@ -503,7 +503,7 @@ func (args *TransactionArgs) ToTransaction(defaultType int) *types.Transaction {
 		}
 		data = &types.SetCodeTx{
 			To:         *args.To,
-			ChainID:    args.ChainID.ToInt().Uint64(),
+			ChainID:    uint256.MustFromBig(args.ChainID.ToInt()),
 			Nonce:      uint64(*args.Nonce),
 			Gas:        uint64(*args.Gas),
 			GasFeeCap:  uint256.MustFromBig((*big.Int)(args.MaxFeePerGas)),
diff --git a/tests/gen_stauthorization.go b/tests/gen_stauthorization.go
index fbafd6fdea..4f2c50bd9f 100644
--- a/tests/gen_stauthorization.go
+++ b/tests/gen_stauthorization.go
@@ -16,7 +16,7 @@ var _ = (*stAuthorizationMarshaling)(nil)
 // MarshalJSON marshals as JSON.
 func (s stAuthorization) MarshalJSON() ([]byte, error) {
 	type stAuthorization struct {
-		ChainID math.HexOrDecimal64
+		ChainID *math.HexOrDecimal256 `json:"chainId" gencodec:"required"`
 		Address common.Address        `json:"address" gencodec:"required"`
 		Nonce   math.HexOrDecimal64   `json:"nonce" gencodec:"required"`
 		V       math.HexOrDecimal64   `json:"v" gencodec:"required"`
@@ -24,7 +24,7 @@ func (s stAuthorization) MarshalJSON() ([]byte, error) {
 		S       *math.HexOrDecimal256 `json:"s" gencodec:"required"`
 	}
 	var enc stAuthorization
-	enc.ChainID = math.HexOrDecimal64(s.ChainID)
+	enc.ChainID = (*math.HexOrDecimal256)(s.ChainID)
 	enc.Address = s.Address
 	enc.Nonce = math.HexOrDecimal64(s.Nonce)
 	enc.V = math.HexOrDecimal64(s.V)
@@ -36,7 +36,7 @@ func (s stAuthorization) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON unmarshals from JSON.
 func (s *stAuthorization) UnmarshalJSON(input []byte) error {
 	type stAuthorization struct {
-		ChainID *math.HexOrDecimal64
+		ChainID *math.HexOrDecimal256 `json:"chainId" gencodec:"required"`
 		Address *common.Address       `json:"address" gencodec:"required"`
 		Nonce   *math.HexOrDecimal64  `json:"nonce" gencodec:"required"`
 		V       *math.HexOrDecimal64  `json:"v" gencodec:"required"`
@@ -47,9 +47,10 @@ func (s *stAuthorization) UnmarshalJSON(input []byte) error {
 	if err := json.Unmarshal(input, &dec); err != nil {
 		return err
 	}
-	if dec.ChainID != nil {
-		s.ChainID = uint64(*dec.ChainID)
+	if dec.ChainID == nil {
+		return errors.New("missing required field 'chainId' for stAuthorization")
 	}
+	s.ChainID = (*big.Int)(dec.ChainID)
 	if dec.Address == nil {
 		return errors.New("missing required field 'address' for stAuthorization")
 	}
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index 6e66bbaa72..740ebd4afd 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -140,7 +140,7 @@ type stTransactionMarshaling struct {
 
 // Authorization is an authorization from an account to deploy code at it's address.
 type stAuthorization struct {
-	ChainID uint64
+	ChainID *big.Int       `json:"chainId" gencodec:"required"`
 	Address common.Address `json:"address" gencodec:"required"`
 	Nonce   uint64         `json:"nonce" gencodec:"required"`
 	V       uint8          `json:"v" gencodec:"required"`
@@ -150,7 +150,7 @@ type stAuthorization struct {
 
 // field type overrides for gencodec
 type stAuthorizationMarshaling struct {
-	ChainID math.HexOrDecimal64
+	ChainID *math.HexOrDecimal256
 	Nonce   math.HexOrDecimal64
 	V       math.HexOrDecimal64
 	R       *math.HexOrDecimal256
@@ -446,7 +446,7 @@ func (tx *stTransaction) toMessage(ps stPostState, baseFee *big.Int) (*core.Mess
 		authList = make([]types.SetCodeAuthorization, len(tx.AuthorizationList))
 		for i, auth := range tx.AuthorizationList {
 			authList[i] = types.SetCodeAuthorization{
-				ChainID: auth.ChainID,
+				ChainID: *uint256.MustFromBig(auth.ChainID),
 				Address: auth.Address,
 				Nonce:   auth.Nonce,
 				V:       auth.V,

From 8dfad579e961f4fdd718fdcf435ad68f4d6d67df Mon Sep 17 00:00:00 2001
From: jwasinger <j-wasinger@hotmail.com>
Date: Tue, 14 Jan 2025 23:26:24 +0800
Subject: [PATCH 8/9] eth/gasprice: ensure cache purging goroutine terminates
 with subscription (#31025)

---
 eth/gasprice/gasprice.go | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go
index fe2e4d408a..4fd3df7428 100644
--- a/eth/gasprice/gasprice.go
+++ b/eth/gasprice/gasprice.go
@@ -120,16 +120,23 @@ func NewOracle(backend OracleBackend, params Config, startPrice *big.Int) *Oracl
 
 	cache := lru.NewCache[cacheKey, processedFees](2048)
 	headEvent := make(chan core.ChainHeadEvent, 1)
-	backend.SubscribeChainHeadEvent(headEvent)
-	go func() {
-		var lastHead common.Hash
-		for ev := range headEvent {
-			if ev.Header.ParentHash != lastHead {
-				cache.Purge()
+	sub := backend.SubscribeChainHeadEvent(headEvent)
+	if sub != nil { // the gasprice testBackend doesn't support subscribing to head events
+		go func() {
+			var lastHead common.Hash
+			for {
+				select {
+				case ev := <-headEvent:
+					if ev.Header.ParentHash != lastHead {
+						cache.Purge()
+					}
+					lastHead = ev.Header.Hash()
+				case <-sub.Err():
+					return
+				}
 			}
-			lastHead = ev.Header.Hash()
-		}
-	}()
+		}()
+	}
 
 	return &Oracle{
 		backend:          backend,

From 9b68875d68b409eb2efdb68a4b623aaacc10a5b6 Mon Sep 17 00:00:00 2001
From: Sina M <1591639+s1na@users.noreply.github.com>
Date: Wed, 15 Jan 2025 19:45:20 +0100
Subject: [PATCH 9/9] beacon/engine: check for empty requests (#31010)

According to
https://github.com/ethereum/execution-apis/blob/main/src/engine/prague.md#engine_newpayloadv4:

> Elements of the list MUST be ordered by request_type in ascending
order. Elements with empty request_data MUST be excluded from the list.

---------

Co-authored-by: lightclient <14004106+lightclient@users.noreply.github.com>
---
 eth/catalyst/api.go | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/eth/catalyst/api.go b/eth/catalyst/api.go
index 3e45ad9e4f..91b6511f71 100644
--- a/eth/catalyst/api.go
+++ b/eth/catalyst/api.go
@@ -638,6 +638,9 @@ func (api *ConsensusAPI) NewPayloadV4(params engine.ExecutableData, versionedHas
 		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.UnsupportedFork.With(errors.New("newPayloadV4 must only be called for prague payloads"))
 	}
 	requests := convertRequests(executionRequests)
+	if err := validateRequests(requests); err != nil {
+		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(err)
+	}
 	return api.newPayload(params, versionedHashes, beaconRoot, requests, false)
 }
 
@@ -727,6 +730,9 @@ func (api *ConsensusAPI) NewPayloadWithWitnessV4(params engine.ExecutableData, v
 		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.UnsupportedFork.With(errors.New("newPayloadWithWitnessV4 must only be called for prague payloads"))
 	}
 	requests := convertRequests(executionRequests)
+	if err := validateRequests(requests); err != nil {
+		return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(err)
+	}
 	return api.newPayload(params, versionedHashes, beaconRoot, requests, true)
 }
 
@@ -1287,3 +1293,20 @@ func convertRequests(hex []hexutil.Bytes) [][]byte {
 	}
 	return req
 }
+
+// validateRequests checks that requests are ordered by their type and are not empty.
+func validateRequests(requests [][]byte) error {
+	var last byte
+	for _, req := range requests {
+		// No empty requests.
+		if len(req) < 2 {
+			return fmt.Errorf("empty request: %v", req)
+		}
+		// Check that requests are ordered by their type.
+		if req[0] < last {
+			return fmt.Errorf("invalid request order: %v", req)
+		}
+		last = req[0]
+	}
+	return nil
+}