resolve merge conflicts

2026-08-19 18:32:23 +00:00 · 2023-09-13 17:26:05 +02:00 · 2023-09-13 17:26:05 +02:00 · ed4cbaf20f
commit ed4cbaf20f
parent a0d2706907 43df612268
652 changed files with 30721 additions and 22380 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -13,7 +13,7 @@ jobs:
    - stage: lint
      os: linux
      dist: bionic
-      go: 1.20.x
+      go: 1.21.x
      env:
        - lint
      git:
@ -28,7 +28,7 @@ jobs:
      os: linux
      arch: amd64
      dist: bionic
-      go: 1.20.x
+      go: 1.21.x
      env:
        - docker
      services:
@ -45,7 +45,7 @@ jobs:
      os: linux
      arch: arm64
      dist: bionic
-      go: 1.20.x
+      go: 1.21.x
      env:
        - docker
      services:
@ -63,10 +63,9 @@ jobs:
      os: linux
      dist: bionic
      sudo: required
-      go: 1.20.x
+      go: 1.21.x
      env:
        - azure-linux
-        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      addons:
@ -97,10 +96,9 @@ jobs:
    - stage: build
      if: type = push
      os: osx
-      go: 1.20.x
+      go: 1.21.x
      env:
        - azure-osx
-        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      script:
@ -112,41 +110,34 @@ jobs:
      os: linux
      arch: amd64
      dist: bionic
-      go: 1.20.x
-      env:
-        - GO111MODULE=on
+      go: 1.21.x
      script:
-        - go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES

    - stage: build
      if: type = pull_request
      os: linux
      arch: arm64
      dist: bionic
-      go: 1.19.x
-      env:
-        - GO111MODULE=on
+      go: 1.20.x
      script:
-        - go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES

    - stage: build
      os: linux
      dist: bionic
-      go: 1.19.x
-      env:
-        - GO111MODULE=on
+      go: 1.20.x
      script:
-        - go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES

    # This builder does the Ubuntu PPA nightly uploads
    - stage: build
      if: type = cron || (type = push && tag ~= /^v[0-9]/)
      os: linux
      dist: bionic
-      go: 1.20.x
+      go: 1.21.x
      env:
        - ubuntu-ppa
-        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      addons:
@ -167,10 +158,9 @@ jobs:
      if: type = cron
      os: linux
      dist: bionic
-      go: 1.20.x
+      go: 1.21.x
      env:
        - azure-purge
-        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      script:
@ -181,9 +171,7 @@ jobs:
      if: type = cron
      os: linux
      dist: bionic
-      go: 1.20.x
-      env:
-        - GO111MODULE=on
+      go: 1.21.x
      script:
-        - go run build/ci.go test  -race $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test  -race $TEST_PACKAGES

--- a/2
+++ b/2
@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""

 # Build Geth in a stock Go builder container
-FROM golang:1.20-alpine as builder
+FROM golang:1.21-alpine as builder

 RUN apk add --no-cache gcc musl-dev linux-headers git

--- a/4
+++ b/4
@ -6,7 +6,7 @@

 GOBIN = ./build/bin
 GO ?= latest
-GORUN = env GO111MODULE=on go run
+GORUN = go run

 geth:
 	$(GORUN) build/ci.go install ./cmd/geth
@ -23,7 +23,7 @@ lint: ## Run linters.
 	$(GORUN) build/ci.go lint

 clean:
-	env GO111MODULE=on go clean -cache
+	go clean -cache
 	rm -fr build/_workspace/pkg/ $(GOBIN)/*

 # The devtools target installs tools required for 'go generate'.
--- a/README.md
+++ b/README.md
@ -123,15 +123,6 @@ use separate accounts for play and real money. Unless you manually move
 accounts, `geth` will by default correctly separate the two networks and will not make any
 accounts available between them.*

-### Full node on the Rinkeby test network
-
-Go Ethereum also supports connecting to the older proof-of-authority based test network
-called [*Rinkeby*](https://www.rinkeby.io) which is operated by members of the community.
-
-```shell
-$ geth --rinkeby console
-```
-
 ### Configuration

 As an alternative to passing the numerous flags to the `geth` binary, you can also pass a
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math/big"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@ -222,6 +223,17 @@ func (abi *ABI) EventByID(topic common.Hash) (*Event, error) {
 	return nil, fmt.Errorf("no event with id: %#x", topic.Hex())
 }

+// ErrorByID looks up an error by the 4-byte id,
+// returns nil if none found.
+func (abi *ABI) ErrorByID(sigdata [4]byte) (*Error, error) {
+	for _, errABI := range abi.Errors {
+		if bytes.Equal(errABI.ID[:4], sigdata[:]) {
+			return &errABI, nil
+		}
+	}
+	return nil, fmt.Errorf("no error with id: %#x", sigdata[:])
+}
+
 // HasFallback returns an indicator whether a fallback function is included.
 func (abi *ABI) HasFallback() bool {
 	return abi.Fallback.Type == Fallback
@ -235,24 +247,65 @@ func (abi *ABI) HasReceive() bool {
 // revertSelector is a special function selector for revert reason unpacking.
 var revertSelector = crypto.Keccak256([]byte("Error(string)"))[:4]

+// panicSelector is a special function selector for panic reason unpacking.
+var panicSelector = crypto.Keccak256([]byte("Panic(uint256)"))[:4]
+
+// panicReasons map is for readable panic codes
+// see this linkage for the deails
+// https://docs.soliditylang.org/en/v0.8.21/control-structures.html#panic-via-assert-and-error-via-require
+// the reason string list is copied from ether.js
+// https://github.com/ethers-io/ethers.js/blob/fa3a883ff7c88611ce766f58bdd4b8ac90814470/src.ts/abi/interface.ts#L207-L218
+var panicReasons = map[uint64]string{
+	0x00: "generic panic",
+	0x01: "assert(false)",
+	0x11: "arithmetic underflow or overflow",
+	0x12: "division or modulo by zero",
+	0x21: "enum overflow",
+	0x22: "invalid encoded storage byte array accessed",
+	0x31: "out-of-bounds array access; popping on an empty array",
+	0x32: "out-of-bounds access of an array or bytesN",
+	0x41: "out of memory",
+	0x51: "uninitialized function",
+}
+
 // UnpackRevert resolves the abi-encoded revert reason. According to the solidity
 // spec https://solidity.readthedocs.io/en/latest/control-structures.html#revert,
-// the provided revert reason is abi-encoded as if it were a call to a function
-// `Error(string)`. So it's a special tool for it.
+// the provided revert reason is abi-encoded as if it were a call to function
+// `Error(string)` or `Panic(uint256)`. So it's a special tool for it.
 func UnpackRevert(data []byte) (string, error) {
 	if len(data) < 4 {
 		return "", errors.New("invalid data for unpacking")
 	}
-	if !bytes.Equal(data[:4], revertSelector) {
+	switch {
+	case bytes.Equal(data[:4], revertSelector):
+		typ, err := NewType("string", "", nil)
+		if err != nil {
+			return "", err
+		}
+		unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
+		if err != nil {
+			return "", err
+		}
+		return unpacked[0].(string), nil
+	case bytes.Equal(data[:4], panicSelector):
+		typ, err := NewType("uint256", "", nil)
+		if err != nil {
+			return "", err
+		}
+		unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
+		if err != nil {
+			return "", err
+		}
+		pCode := unpacked[0].(*big.Int)
+		// uint64 safety check for future
+		// but the code is not bigger than MAX(uint64) now
+		if pCode.IsUint64() {
+			if reason, ok := panicReasons[pCode.Uint64()]; ok {
+				return reason, nil
+			}
+		}
+		return fmt.Sprintf("unknown panic code: %#x", pCode), nil
+	default:
 		return "", errors.New("invalid data for unpacking")
 	}
-	typ, err := NewType("string", "", nil)
-	if err != nil {
-		return "", err
-	}
-	unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
-	if err != nil {
-		return "", err
-	}
-	return unpacked[0].(string), nil
 }
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@ -1057,6 +1057,34 @@ func TestABI_EventById(t *testing.T) {
 	}
 }

+func TestABI_ErrorByID(t *testing.T) {
+	abi, err := JSON(strings.NewReader(`[
+		{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"MyError1","type":"error"},
+		{"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"string","name":"b","type":"string"},{"internalType":"address","name":"c","type":"address"}],"internalType":"struct MyError.MyStruct","name":"x","type":"tuple"},{"internalType":"address","name":"y","type":"address"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"string","name":"b","type":"string"},{"internalType":"address","name":"c","type":"address"}],"internalType":"struct MyError.MyStruct","name":"z","type":"tuple"}],"name":"MyError2","type":"error"},
+		{"inputs":[{"internalType":"uint256[]","name":"x","type":"uint256[]"}],"name":"MyError3","type":"error"}
+	]`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, m := range abi.Errors {
+		a := fmt.Sprintf("%v", &m)
+		var id [4]byte
+		copy(id[:], m.ID[:4])
+		m2, err := abi.ErrorByID(id)
+		if err != nil {
+			t.Fatalf("Failed to look up ABI error: %v", err)
+		}
+		b := fmt.Sprintf("%v", m2)
+		if a != b {
+			t.Errorf("Error %v (id %x) not 'findable' by id in ABI", name, id)
+		}
+	}
+	// test unsuccessful lookups
+	if _, err = abi.ErrorByID([4]byte{}); err == nil {
+		t.Error("Expected error: no error with this id")
+	}
+}
+
 // TestDoubleDuplicateMethodNames checks that if transfer0 already exists, there won't be a name
 // conflict and that the second transfer method will be renamed transfer1.
 func TestDoubleDuplicateMethodNames(t *testing.T) {
@ -1145,6 +1173,8 @@ func TestUnpackRevert(t *testing.T) {
 		{"", "", errors.New("invalid data for unpacking")},
 		{"08c379a1", "", errors.New("invalid data for unpacking")},
 		{"08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d72657665727420726561736f6e00000000000000000000000000000000000000", "revert reason", nil},
+		{"4e487b710000000000000000000000000000000000000000000000000000000000000000", "generic panic", nil},
+		{"4e487b7100000000000000000000000000000000000000000000000000000000000000ff", "unknown panic code: 0xff", nil},
 	}
 	for index, c := range cases {
 		t.Run(fmt.Sprintf("case %d", index), func(t *testing.T) {
--- a/accounts/abi/bind/backend.go
+++ b/accounts/abi/bind/backend.go
@ -29,7 +29,7 @@ import (
 var (
 	// ErrNoCode is returned by call and transact operations for which the requested
 	// recipient contract to operate on does not exist in the state db or does not
-	// have any code associated with it (i.e. suicided).
+	// have any code associated with it (i.e. self-destructed).
 	ErrNoCode = errors.New("no contract code at given address")

 	// ErrNoPendingState is raised when attempting to perform a pending state action
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@ -681,7 +681,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 	// Get the last block
 	block, err := b.blockByHash(ctx, b.pendingBlock.ParentHash())
 	if err != nil {
-		return fmt.Errorf("could not fetch parent")
+		return errors.New("could not fetch parent")
 	}
 	// Check transaction validity
 	signer := types.MakeSigner(b.blockchain.Config(), block.Number(), block.Time())
@ -815,7 +815,7 @@ func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error {
 	// Get the last block
 	block := b.blockchain.GetBlockByHash(b.pendingBlock.ParentHash())
 	if block == nil {
-		return fmt.Errorf("could not find parent")
+		return errors.New("could not find parent")
 	}

 	blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
@ -892,7 +892,7 @@ func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (typ
 }

 func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
-	logs := rawdb.ReadLogs(fb.db, hash, number, fb.bc.Config())
+	logs := rawdb.ReadLogs(fb.db, hash, number)
 	return logs, nil
 }

--- a/accounts/abi/bind/backends/simulated_test.go
+++ b/accounts/abi/bind/backends/simulated_test.go
@ -161,6 +161,7 @@ func TestAdjustTime(t *testing.T) {
 func TestNewAdjustTimeFail(t *testing.T) {
 	testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
 	sim := simTestBackend(testAddr)
+	defer sim.blockchain.Stop()

 	// Create tx and send
 	head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
--- a/accounts/abi/error.go
+++ b/accounts/abi/error.go
@ -32,7 +32,7 @@ type Error struct {
 	str    string

 	// Sig contains the string signature according to the ABI spec.
-	// e.g.	 error foo(uint32 a, int b) = "foo(uint32,int256)"
+	// e.g. error foo(uint32 a, int b) = "foo(uint32,int256)"
 	// Please note that "int" is substitute for its canonical representation "int256"
 	Sig string

@ -78,7 +78,7 @@ func NewError(name string, inputs Arguments) Error {
 	}
 }

-func (e *Error) String() string {
+func (e Error) String() string {
 	return e.str
 }

--- a/accounts/abi/method.go
+++ b/accounts/abi/method.go
@ -127,11 +127,12 @@ func NewMethod(name string, rawName string, funType FunctionType, mutability str
 		state = state + " "
 	}
 	identity := fmt.Sprintf("function %v", rawName)
-	if funType == Fallback {
+	switch funType {
+	case Fallback:
 		identity = "fallback"
-	} else if funType == Receive {
+	case Receive:
 		identity = "receive"
-	} else if funType == Constructor {
+	case Constructor:
 		identity = "constructor"
 	}
 	str := fmt.Sprintf("%v(%v) %sreturns(%v)", identity, strings.Join(inputNames, ", "), state, strings.Join(outputNames, ", "))
--- a/accounts/abi/method_test.go
+++ b/accounts/abi/method_test.go
@ -84,11 +84,12 @@ func TestMethodString(t *testing.T) {

 	for _, test := range table {
 		var got string
-		if test.method == "fallback" {
+		switch test.method {
+		case "fallback":
 			got = abi.Fallback.String()
-		} else if test.method == "receive" {
+		case "receive":
 			got = abi.Receive.String()
-		} else {
+		default:
 			got = abi.Methods[test.method].String()
 		}
 		if got != test.expectation {
--- a/accounts/abi/reflect.go
+++ b/accounts/abi/reflect.go
@ -228,7 +228,7 @@ func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[stri
 		structFieldName := ToCamelCase(argName)

 		if structFieldName == "" {
-			return nil, fmt.Errorf("abi: purely underscored output cannot unpack to struct")
+			return nil, errors.New("abi: purely underscored output cannot unpack to struct")
 		}

 		// this abi has already been paired, skip it... unless there exists another, yet unassigned
--- a/accounts/abi/selector_parser.go
+++ b/accounts/abi/selector_parser.go
@ -17,6 +17,7 @@
 package abi

 import (
+	"errors"
 	"fmt"
 )

@ -40,7 +41,7 @@ func isIdentifierSymbol(c byte) bool {

 func parseToken(unescapedSelector string, isIdent bool) (string, string, error) {
 	if len(unescapedSelector) == 0 {
-		return "", "", fmt.Errorf("empty token")
+		return "", "", errors.New("empty token")
 	}
 	firstChar := unescapedSelector[0]
 	position := 1
@ -110,7 +111,7 @@ func parseCompositeType(unescapedSelector string) ([]interface{}, string, error)

 func parseType(unescapedSelector string) (interface{}, string, error) {
 	if len(unescapedSelector) == 0 {
-		return nil, "", fmt.Errorf("empty type")
+		return nil, "", errors.New("empty type")
 	}
 	if unescapedSelector[0] == '(' {
 		return parseCompositeType(unescapedSelector)
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@ -70,7 +70,7 @@ var (
 func NewType(t string, internalType string, components []ArgumentMarshaling) (typ Type, err error) {
 	// check that array brackets are equal if they exist
 	if strings.Count(t, "[") != strings.Count(t, "]") {
-		return Type{}, fmt.Errorf("invalid arg type in abi")
+		return Type{}, errors.New("invalid arg type in abi")
 	}
 	typ.stringKind = t

@ -109,7 +109,7 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 			}
 			typ.stringKind = embeddedType.stringKind + sliced
 		} else {
-			return Type{}, fmt.Errorf("invalid formatting of array type")
+			return Type{}, errors.New("invalid formatting of array type")
 		}
 		return typ, err
 	}
@ -348,7 +348,7 @@ func (t Type) pack(v reflect.Value) ([]byte, error) {
 	}
 }

-// requireLengthPrefix returns whether the type requires any sort of length
+// requiresLengthPrefix returns whether the type requires any sort of length
 // prefixing.
 func (t Type) requiresLengthPrefix() bool {
 	return t.T == StringTy || t.T == BytesTy || t.T == SliceTy
--- a/accounts/abi/unpack.go
+++ b/accounts/abi/unpack.go
@ -18,6 +18,7 @@ package abi

 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"math"
 	"math/big"
@ -125,7 +126,7 @@ func readBool(word []byte) (bool, error) {
 // readFunctionType enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes)
 func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
 	if t.T != FunctionTy {
-		return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array")
+		return [24]byte{}, errors.New("abi: invalid type in call to make function type byte array")
 	}
 	if garbage := binary.BigEndian.Uint64(word[24:32]); garbage != 0 {
 		err = fmt.Errorf("abi: got improperly encoded function type, got %v", word)
@ -138,7 +139,7 @@ func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
 // ReadFixedBytes uses reflection to create a fixed array to be read from.
 func ReadFixedBytes(t Type, word []byte) (interface{}, error) {
 	if t.T != FixedBytesTy {
-		return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array")
+		return nil, errors.New("abi: invalid type in call to make fixed byte array")
 	}
 	// convert
 	array := reflect.New(t.GetType()).Elem()
@ -159,14 +160,15 @@ func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error)
 	// this value will become our slice or our array, depending on the type
 	var refSlice reflect.Value

-	if t.T == SliceTy {
+	switch t.T {
+	case SliceTy:
 		// declare our slice
 		refSlice = reflect.MakeSlice(t.GetType(), size, size)
-	} else if t.T == ArrayTy {
+	case ArrayTy:
 		// declare our array
 		refSlice = reflect.New(t.GetType()).Elem()
-	} else {
-		return nil, fmt.Errorf("abi: invalid type in array/slice unpacking stage")
+	default:
+		return nil, errors.New("abi: invalid type in array/slice unpacking stage")
 	}

 	// Arrays have packed elements, resulting in longer unpack steps.
--- a/accounts/external/backend.go
+++ b/accounts/external/backend.go
@ -17,6 +17,7 @@
 package external

 import (
+	"errors"
 	"fmt"
 	"math/big"
 	"sync"
@ -98,11 +99,11 @@ func (api *ExternalSigner) Status() (string, error) {
 }

 func (api *ExternalSigner) Open(passphrase string) error {
-	return fmt.Errorf("operation not supported on external signers")
+	return errors.New("operation not supported on external signers")
 }

 func (api *ExternalSigner) Close() error {
-	return fmt.Errorf("operation not supported on external signers")
+	return errors.New("operation not supported on external signers")
 }

 func (api *ExternalSigner) Accounts() []accounts.Account {
@ -145,7 +146,7 @@ func (api *ExternalSigner) Contains(account accounts.Account) bool {
 }

 func (api *ExternalSigner) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) {
-	return accounts.Account{}, fmt.Errorf("operation not supported on external signers")
+	return accounts.Account{}, errors.New("operation not supported on external signers")
 }

 func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
@ -242,14 +243,14 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 }

 func (api *ExternalSigner) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
-	return []byte{}, fmt.Errorf("password-operations not supported on external signers")
+	return []byte{}, errors.New("password-operations not supported on external signers")
 }

 func (api *ExternalSigner) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	return nil, fmt.Errorf("password-operations not supported on external signers")
+	return nil, errors.New("password-operations not supported on external signers")
 }
 func (api *ExternalSigner) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
-	return nil, fmt.Errorf("password-operations not supported on external signers")
+	return nil, errors.New("password-operations not supported on external signers")
 }

 func (api *ExternalSigner) listAccounts() ([]common.Address, error) {
--- a/accounts/keystore/account_cache.go
+++ b/accounts/keystore/account_cache.go
@ -31,6 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
+	"golang.org/x/exp/slices"
 )

 // Minimum amount of time between cache reloads. This limit applies if the platform does
@ -38,11 +39,10 @@ import (
 // exist yet, the code will attempt to create a watcher at most this often.
 const minReloadInterval = 2 * time.Second

-type accountsByURL []accounts.Account
-
-func (s accountsByURL) Len() int           { return len(s) }
-func (s accountsByURL) Less(i, j int) bool { return s[i].URL.Cmp(s[j].URL) < 0 }
-func (s accountsByURL) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+// byURL defines the sorting order for accounts.
+func byURL(a, b accounts.Account) int {
+	return a.URL.Cmp(b.URL)
+}

 // AmbiguousAddrError is returned when attempting to unlock
 // an address for which more than one file exists.
@ -67,7 +67,7 @@ type accountCache struct {
 	keydir   string
 	watcher  *watcher
 	mu       sync.Mutex
-	all      accountsByURL
+	all      []accounts.Account
 	byAddr   map[common.Address][]accounts.Account
 	throttle *time.Timer
 	notify   chan struct{}
@ -194,7 +194,7 @@ func (ac *accountCache) find(a accounts.Account) (accounts.Account, error) {
 	default:
 		err := &AmbiguousAddrError{Addr: a.Address, Matches: make([]accounts.Account, len(matches))}
 		copy(err.Matches, matches)
-		sort.Sort(accountsByURL(err.Matches))
+		slices.SortFunc(err.Matches, byURL)
 		return accounts.Account{}, err
 	}
 }
--- a/accounts/keystore/account_cache_test.go
+++ b/accounts/keystore/account_cache_test.go
@ -17,12 +17,12 @@
 package keystore

 import (
+	"errors"
 	"fmt"
 	"math/rand"
 	"os"
 	"path/filepath"
 	"reflect"
-	"sort"
 	"testing"
 	"time"

@ -30,6 +30,7 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/exp/slices"
 )

 var (
@ -74,7 +75,7 @@ func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
 			select {
 			case <-ks.changes:
 			default:
-				return fmt.Errorf("wasn't notified of new accounts")
+				return errors.New("wasn't notified of new accounts")
 			}
 			return nil
 		}
@ -202,7 +203,7 @@ func TestCacheAddDeleteOrder(t *testing.T) {
 	// Check that the account list is sorted by filename.
 	wantAccounts := make([]accounts.Account, len(accs))
 	copy(wantAccounts, accs)
-	sort.Sort(accountsByURL(wantAccounts))
+	slices.SortFunc(wantAccounts, byURL)
 	list := cache.accounts()
 	if !reflect.DeepEqual(list, wantAccounts) {
 		t.Fatalf("got accounts: %s\nwant %s", spew.Sdump(accs), spew.Sdump(wantAccounts))
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@ -20,7 +20,6 @@ import (
 	"math/rand"
 	"os"
 	"runtime"
-	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
@ -31,6 +30,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/event"
+	"golang.org/x/exp/slices"
 )

 var testSigData = make([]byte, 32)
@ -397,19 +397,19 @@ func TestImportRace(t *testing.T) {
 		t.Fatalf("failed to export account: %v", acc)
 	}
 	_, ks2 := tmpKeyStore(t, true)
-	var atom uint32
+	var atom atomic.Uint32
 	var wg sync.WaitGroup
 	wg.Add(2)
 	for i := 0; i < 2; i++ {
 		go func() {
 			defer wg.Done()
 			if _, err := ks2.Import(json, "new", "new"); err != nil {
-				atomic.AddUint32(&atom, 1)
+				atom.Add(1)
 			}
 		}()
 	}
 	wg.Wait()
-	if atom != 1 {
+	if atom.Load() != 1 {
 		t.Errorf("Import is racy")
 	}
 }
@ -424,7 +424,7 @@ func checkAccounts(t *testing.T, live map[common.Address]accounts.Account, walle
 	for _, account := range live {
 		liveList = append(liveList, account)
 	}
-	sort.Sort(accountsByURL(liveList))
+	slices.SortFunc(liveList, byURL)
 	for j, wallet := range wallets {
 		if accs := wallet.Accounts(); len(accs) != 1 {
 			t.Errorf("wallet %d: contains invalid number of accounts: have %d, want 1", j, len(accs))
--- a/accounts/keystore/passphrase.go
+++ b/accounts/keystore/passphrase.go
@ -225,10 +225,13 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) {
 	if err != nil {
 		return nil, err
 	}
-	key := crypto.ToECDSAUnsafe(keyBytes)
+	key, err := crypto.ToECDSA(keyBytes)
+	if err != nil {
+		return nil, fmt.Errorf("invalid key: %w", err)
+	}
 	id, err := uuid.FromBytes(keyId)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("invalid UUID: %w", err)
 	}
 	return &Key{
 		Id:         id,
--- a/accounts/scwallet/securechannel.go
+++ b/accounts/scwallet/securechannel.go
@ -24,6 +24,7 @@ import (
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/sha512"
+	"errors"
 	"fmt"

 	"github.com/ethereum/go-ethereum/crypto"
@ -125,7 +126,7 @@ func (s *SecureChannelSession) Pair(pairingPassword []byte) error {
 // Unpair disestablishes an existing pairing.
 func (s *SecureChannelSession) Unpair() error {
 	if s.PairingKey == nil {
-		return fmt.Errorf("cannot unpair: not paired")
+		return errors.New("cannot unpair: not paired")
 	}

 	_, err := s.transmitEncrypted(claSCWallet, insUnpair, s.PairingIndex, 0, []byte{})
@ -141,7 +142,7 @@ func (s *SecureChannelSession) Unpair() error {
 // Open initializes the secure channel.
 func (s *SecureChannelSession) Open() error {
 	if s.iv != nil {
-		return fmt.Errorf("session already opened")
+		return errors.New("session already opened")
 	}

 	response, err := s.open()
@ -215,7 +216,7 @@ func (s *SecureChannelSession) pair(p1 uint8, data []byte) (*responseAPDU, error
 // transmitEncrypted sends an encrypted message, and decrypts and returns the response.
 func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []byte) (*responseAPDU, error) {
 	if s.iv == nil {
-		return nil, fmt.Errorf("channel not open")
+		return nil, errors.New("channel not open")
 	}

 	data, err := s.encryptAPDU(data)
@ -254,7 +255,7 @@ func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []b
 		return nil, err
 	}
 	if !bytes.Equal(s.iv, rmac) {
-		return nil, fmt.Errorf("invalid MAC in response")
+		return nil, errors.New("invalid MAC in response")
 	}

 	rapdu := &responseAPDU{}
@ -319,7 +320,7 @@ func unpad(data []byte, terminator byte) ([]byte, error) {
 			return nil, fmt.Errorf("expected end of padding, got %d", data[len(data)-i])
 		}
 	}
-	return nil, fmt.Errorf("expected end of padding, got 0")
+	return nil, errors.New("expected end of padding, got 0")
 }

 // updateIV is an internal method that updates the initialization vector after
--- a/accounts/scwallet/wallet.go
+++ b/accounts/scwallet/wallet.go
@ -252,7 +252,7 @@ func (w *Wallet) release() error {
 // with the wallet.
 func (w *Wallet) pair(puk []byte) error {
 	if w.session.paired() {
-		return fmt.Errorf("wallet already paired")
+		return errors.New("wallet already paired")
 	}
 	pairing, err := w.session.pair(puk)
 	if err != nil {
@ -813,7 +813,7 @@ func (s *Session) pair(secret []byte) (smartcardPairing, error) {
 // unpair deletes an existing pairing.
 func (s *Session) unpair() error {
 	if !s.verified {
-		return fmt.Errorf("unpair requires that the PIN be verified")
+		return errors.New("unpair requires that the PIN be verified")
 	}
 	return s.Channel.Unpair()
 }
@ -907,7 +907,7 @@ func (s *Session) initialize(seed []byte) error {
 		return err
 	}
 	if status == "Online" {
-		return fmt.Errorf("card is already initialized, cowardly refusing to proceed")
+		return errors.New("card is already initialized, cowardly refusing to proceed")
 	}

 	s.Wallet.lock.Lock()
--- a/accounts/usbwallet/hub.go
+++ b/accounts/usbwallet/hub.go
@ -63,9 +63,9 @@ type Hub struct {
 	stateLock sync.RWMutex // Protects the internals of the hub from racey access

 	// TODO(karalabe): remove if hotplug lands on Windows
-	commsPend int        // Number of operations blocking enumeration
-	commsLock sync.Mutex // Lock protecting the pending counter and enumeration
-	enumFails uint32     // Number of times enumeration has failed
+	commsPend int           // Number of operations blocking enumeration
+	commsLock sync.Mutex    // Lock protecting the pending counter and enumeration
+	enumFails atomic.Uint32 // Number of times enumeration has failed
 }

 // NewLedgerHub creates a new hardware wallet manager for Ledger devices.
@ -151,7 +151,7 @@ func (hub *Hub) refreshWallets() {
 		return
 	}
 	// If USB enumeration is continually failing, don't keep trying indefinitely
-	if atomic.LoadUint32(&hub.enumFails) > 2 {
+	if hub.enumFails.Load() > 2 {
 		return
 	}
 	// Retrieve the current list of USB wallet devices
@ -172,7 +172,7 @@ func (hub *Hub) refreshWallets() {
 	}
 	infos, err := usb.Enumerate(hub.vendorID, 0)
 	if err != nil {
-		failcount := atomic.AddUint32(&hub.enumFails, 1)
+		failcount := hub.enumFails.Add(1)
 		if runtime.GOOS == "linux" {
 			// See rationale before the enumeration why this is needed and only on Linux.
 			hub.commsLock.Unlock()
@ -181,7 +181,7 @@ func (hub *Hub) refreshWallets() {
 			"vendor", hub.vendorID, "failcount", failcount, "err", err)
 		return
 	}
-	atomic.StoreUint32(&hub.enumFails, 0)
+	hub.enumFails.Store(0)

 	for _, info := range infos {
 		for _, id := range hub.productIDs {
--- a/accounts/usbwallet/wallet.go
+++ b/accounts/usbwallet/wallet.go
@ -624,7 +624,7 @@ func (w *wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID
 	return signed, nil
 }

-// SignHashWithPassphrase implements accounts.Wallet, however signing arbitrary
+// SignTextWithPassphrase implements accounts.Wallet, however signing arbitrary
 // data is not supported for Ledger wallets, so this method will always return
 // an error.
 func (w *wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
--- a/beacon/engine/errors.go
+++ b/beacon/engine/errors.go
@ -80,6 +80,7 @@ var (
 	InvalidPayloadAttributes = &EngineAPIError{code: -38003, msg: "Invalid payload attributes"}
 	TooLargeRequest          = &EngineAPIError{code: -38004, msg: "Too large request"}
 	InvalidParams            = &EngineAPIError{code: -32602, msg: "Invalid parameters"}
+	UnsupportedFork          = &EngineAPIError{code: -38005, msg: "Unsupported fork"}

 	STATUS_INVALID         = ForkChoiceResponse{PayloadStatus: PayloadStatusV1{Status: INVALID}, PayloadID: nil}
 	STATUS_SYNCING         = ForkChoiceResponse{PayloadStatus: PayloadStatusV1{Status: SYNCING}, PayloadID: nil}
--- a/beacon/engine/gen_blockparams.go
+++ b/beacon/engine/gen_blockparams.go
@ -20,12 +20,14 @@ func (p PayloadAttributes) MarshalJSON() ([]byte, error) {
 		Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
 		SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
 		Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+		BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
 	}
 	var enc PayloadAttributes
 	enc.Timestamp = hexutil.Uint64(p.Timestamp)
 	enc.Random = p.Random
 	enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient
 	enc.Withdrawals = p.Withdrawals
+	enc.BeaconRoot = p.BeaconRoot
 	return json.Marshal(&enc)
 }

@ -36,6 +38,7 @@ func (p *PayloadAttributes) UnmarshalJSON(input []byte) error {
 		Random                *common.Hash        `json:"prevRandao"            gencodec:"required"`
 		SuggestedFeeRecipient *common.Address     `json:"suggestedFeeRecipient" gencodec:"required"`
 		Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+		BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
 	}
 	var dec PayloadAttributes
 	if err := json.Unmarshal(input, &dec); err != nil {
@ -56,5 +59,8 @@ func (p *PayloadAttributes) UnmarshalJSON(input []byte) error {
 	if dec.Withdrawals != nil {
 		p.Withdrawals = dec.Withdrawals
 	}
+	if dec.BeaconRoot != nil {
+		p.BeaconRoot = dec.BeaconRoot
+	}
 	return nil
 }
--- a/beacon/engine/gen_ed.go
+++ b/beacon/engine/gen_ed.go
@ -32,6 +32,8 @@ func (e ExecutableData) MarshalJSON() ([]byte, error) {
 		BlockHash     common.Hash         `json:"blockHash"     gencodec:"required"`
 		Transactions  []hexutil.Bytes     `json:"transactions"  gencodec:"required"`
 		Withdrawals   []*types.Withdrawal `json:"withdrawals"`
+		BlobGasUsed   *hexutil.Uint64     `json:"blobGasUsed"`
+		ExcessBlobGas *hexutil.Uint64     `json:"excessBlobGas"`
 	}
 	var enc ExecutableData
 	enc.ParentHash = e.ParentHash
@ -54,6 +56,8 @@ func (e ExecutableData) MarshalJSON() ([]byte, error) {
 		}
 	}
 	enc.Withdrawals = e.Withdrawals
+	enc.BlobGasUsed = (*hexutil.Uint64)(e.BlobGasUsed)
+	enc.ExcessBlobGas = (*hexutil.Uint64)(e.ExcessBlobGas)
 	return json.Marshal(&enc)
 }

@ -75,6 +79,8 @@ func (e *ExecutableData) UnmarshalJSON(input []byte) error {
 		BlockHash     *common.Hash        `json:"blockHash"     gencodec:"required"`
 		Transactions  []hexutil.Bytes     `json:"transactions"  gencodec:"required"`
 		Withdrawals   []*types.Withdrawal `json:"withdrawals"`
+		BlobGasUsed   *hexutil.Uint64     `json:"blobGasUsed"`
+		ExcessBlobGas *hexutil.Uint64     `json:"excessBlobGas"`
 	}
 	var dec ExecutableData
 	if err := json.Unmarshal(input, &dec); err != nil {
@ -142,5 +148,11 @@ func (e *ExecutableData) UnmarshalJSON(input []byte) error {
 	if dec.Withdrawals != nil {
 		e.Withdrawals = dec.Withdrawals
 	}
+	if dec.BlobGasUsed != nil {
+		e.BlobGasUsed = (*uint64)(dec.BlobGasUsed)
+	}
+	if dec.ExcessBlobGas != nil {
+		e.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
+	}
 	return nil
 }
--- a/beacon/engine/gen_epe.go
+++ b/beacon/engine/gen_epe.go
@ -17,10 +17,14 @@ func (e ExecutionPayloadEnvelope) MarshalJSON() ([]byte, error) {
 	type ExecutionPayloadEnvelope struct {
 		ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 		BlockValue       *hexutil.Big    `json:"blockValue"  gencodec:"required"`
+		BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
+		Override         bool            `json:"shouldOverrideBuilder"`
 	}
 	var enc ExecutionPayloadEnvelope
 	enc.ExecutionPayload = e.ExecutionPayload
 	enc.BlockValue = (*hexutil.Big)(e.BlockValue)
+	enc.BlobsBundle = e.BlobsBundle
+	enc.Override = e.Override
 	return json.Marshal(&enc)
 }

@ -29,6 +33,8 @@ func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
 	type ExecutionPayloadEnvelope struct {
 		ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 		BlockValue       *hexutil.Big    `json:"blockValue"  gencodec:"required"`
+		BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
+		Override         *bool           `json:"shouldOverrideBuilder"`
 	}
 	var dec ExecutionPayloadEnvelope
 	if err := json.Unmarshal(input, &dec); err != nil {
@ -42,5 +48,11 @@ func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
 		return errors.New("missing required field 'blockValue' for ExecutionPayloadEnvelope")
 	}
 	e.BlockValue = (*big.Int)(dec.BlockValue)
+	if dec.BlobsBundle != nil {
+		e.BlobsBundle = dec.BlobsBundle
+	}
+	if dec.Override != nil {
+		e.Override = *dec.Override
+	}
 	return nil
 }
--- a/beacon/engine/types.go
+++ b/beacon/engine/types.go
@ -35,6 +35,7 @@ type PayloadAttributes struct {
 	Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
 	SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
 	Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+	BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
 }

 // JSON type overrides for PayloadAttributes.
@ -61,6 +62,8 @@ type ExecutableData struct {
 	BlockHash     common.Hash         `json:"blockHash"     gencodec:"required"`
 	Transactions  [][]byte            `json:"transactions"  gencodec:"required"`
 	Withdrawals   []*types.Withdrawal `json:"withdrawals"`
+	BlobGasUsed   *uint64             `json:"blobGasUsed"`
+	ExcessBlobGas *uint64             `json:"excessBlobGas"`
 }

 // JSON type overrides for executableData.
@ -73,6 +76,8 @@ type executableDataMarshaling struct {
 	ExtraData     hexutil.Bytes
 	LogsBloom     hexutil.Bytes
 	Transactions  []hexutil.Bytes
+	BlobGasUsed   *hexutil.Uint64
+	ExcessBlobGas *hexutil.Uint64
 }

 //go:generate go run github.com/fjl/gencodec -type ExecutionPayloadEnvelope -field-override executionPayloadEnvelopeMarshaling -out gen_epe.go
@ -80,6 +85,14 @@ type executableDataMarshaling struct {
 type ExecutionPayloadEnvelope struct {
 	ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 	BlockValue       *big.Int        `json:"blockValue"  gencodec:"required"`
+	BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
+	Override         bool            `json:"shouldOverrideBuilder"`
+}
+
+type BlobsBundleV1 struct {
+	Commitments []hexutil.Bytes `json:"commitments"`
+	Proofs      []hexutil.Bytes `json:"proofs"`
+	Blobs       []hexutil.Bytes `json:"blobs"`
 }

 // JSON type overrides for ExecutionPayloadEnvelope.
@ -152,14 +165,15 @@ func decodeTransactions(enc [][]byte) ([]*types.Transaction, error) {
 // ExecutableDataToBlock constructs a block from executable data.
 // It verifies that the following fields:
 //
-//	len(extraData) <= 32
-//	uncleHash = emptyUncleHash
-//	difficulty = 0
+//		len(extraData) <= 32
+//		uncleHash = emptyUncleHash
+//		difficulty = 0
+//	 	if versionedHashes != nil, versionedHashes match to blob transactions
 //
 // and that the blockhash of the constructed block matches the parameters. Nil
 // Withdrawals value will propagate through the returned block. Empty
 // Withdrawals value must be passed via non-nil, length 0 value in params.
-func ExecutableDataToBlock(params ExecutableData) (*types.Block, error) {
+func ExecutableDataToBlock(params ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (*types.Block, error) {
 	txs, err := decodeTransactions(params.Transactions)
 	if err != nil {
 		return nil, err
@ -174,6 +188,18 @@ func ExecutableDataToBlock(params ExecutableData) (*types.Block, error) {
 	if params.BaseFeePerGas != nil && (params.BaseFeePerGas.Sign() == -1 || params.BaseFeePerGas.BitLen() > 256) {
 		return nil, fmt.Errorf("invalid baseFeePerGas: %v", params.BaseFeePerGas)
 	}
+	var blobHashes []common.Hash
+	for _, tx := range txs {
+		blobHashes = append(blobHashes, tx.BlobHashes()...)
+	}
+	if len(blobHashes) != len(versionedHashes) {
+		return nil, fmt.Errorf("invalid number of versionedHashes: %v blobHashes: %v", versionedHashes, blobHashes)
+	}
+	for i := 0; i < len(blobHashes); i++ {
+		if blobHashes[i] != versionedHashes[i] {
+			return nil, fmt.Errorf("invalid versionedHash at %v: %v blobHashes: %v", i, versionedHashes, blobHashes)
+		}
+	}
 	// Only set withdrawalsRoot if it is non-nil. This allows CLs to use
 	// ExecutableData before withdrawals are enabled by marshaling
 	// Withdrawals as the json null value.
@ -183,22 +209,25 @@ func ExecutableDataToBlock(params ExecutableData) (*types.Block, error) {
 		withdrawalsRoot = &h
 	}
 	header := &types.Header{
-		ParentHash:      params.ParentHash,
-		UncleHash:       types.EmptyUncleHash,
-		Coinbase:        params.FeeRecipient,
-		Root:            params.StateRoot,
-		TxHash:          types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil)),
-		ReceiptHash:     params.ReceiptsRoot,
-		Bloom:           types.BytesToBloom(params.LogsBloom),
-		Difficulty:      common.Big0,
-		Number:          new(big.Int).SetUint64(params.Number),
-		GasLimit:        params.GasLimit,
-		GasUsed:         params.GasUsed,
-		Time:            params.Timestamp,
-		BaseFee:         params.BaseFeePerGas,
-		Extra:           params.ExtraData,
-		MixDigest:       params.Random,
-		WithdrawalsHash: withdrawalsRoot,
+		ParentHash:       params.ParentHash,
+		UncleHash:        types.EmptyUncleHash,
+		Coinbase:         params.FeeRecipient,
+		Root:             params.StateRoot,
+		TxHash:           types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil)),
+		ReceiptHash:      params.ReceiptsRoot,
+		Bloom:            types.BytesToBloom(params.LogsBloom),
+		Difficulty:       common.Big0,
+		Number:           new(big.Int).SetUint64(params.Number),
+		GasLimit:         params.GasLimit,
+		GasUsed:          params.GasUsed,
+		Time:             params.Timestamp,
+		BaseFee:          params.BaseFeePerGas,
+		Extra:            params.ExtraData,
+		MixDigest:        params.Random,
+		WithdrawalsHash:  withdrawalsRoot,
+		ExcessBlobGas:    params.ExcessBlobGas,
+		BlobGasUsed:      params.BlobGasUsed,
+		ParentBeaconRoot: beaconRoot,
 	}
 	block := types.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */).WithWithdrawals(params.Withdrawals)
 	if block.Hash() != params.BlockHash {
@ -209,7 +238,7 @@ func ExecutableDataToBlock(params ExecutableData) (*types.Block, error) {

 // BlockToExecutableData constructs the ExecutableData structure by filling the
 // fields from the given block. It assumes the given block is post-merge block.
-func BlockToExecutableData(block *types.Block, fees *big.Int) *ExecutionPayloadEnvelope {
+func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.BlobTxSidecar) *ExecutionPayloadEnvelope {
 	data := &ExecutableData{
 		BlockHash:     block.Hash(),
 		ParentHash:    block.ParentHash(),
@ -226,8 +255,22 @@ func BlockToExecutableData(block *types.Block, fees *big.Int) *ExecutionPayloadE
 		Random:        block.MixDigest(),
 		ExtraData:     block.Extra(),
 		Withdrawals:   block.Withdrawals(),
+		BlobGasUsed:   block.BlobGasUsed(),
+		ExcessBlobGas: block.ExcessBlobGas(),
 	}
-	return &ExecutionPayloadEnvelope{ExecutionPayload: data, BlockValue: fees}
+	bundle := BlobsBundleV1{
+		Commitments: make([]hexutil.Bytes, 0),
+		Blobs:       make([]hexutil.Bytes, 0),
+		Proofs:      make([]hexutil.Bytes, 0),
+	}
+	for _, sidecar := range sidecars {
+		for j := range sidecar.Blobs {
+			bundle.Blobs = append(bundle.Blobs, hexutil.Bytes(sidecar.Blobs[j][:]))
+			bundle.Commitments = append(bundle.Commitments, hexutil.Bytes(sidecar.Commitments[j][:]))
+			bundle.Proofs = append(bundle.Proofs, hexutil.Bytes(sidecar.Proofs[j][:]))
+		}
+	}
+	return &ExecutionPayloadEnvelope{ExecutionPayload: data, BlockValue: fees, BlobsBundle: &bundle, Override: false}
 }

 // ExecutionPayloadBodyV1 is used in the response to GetPayloadBodiesByHashV1 and GetPayloadBodiesByRangeV1
--- a/beacon/merkle/merkle.go
+++ b/beacon/merkle/merkle.go
@ -0,0 +1,67 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// Package merkle implements proof verifications in binary merkle trees.
+package merkle
+
+import (
+	"crypto/sha256"
+	"errors"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// Value represents either a 32 byte leaf value or hash node in a binary merkle tree/partial proof.
+type Value [32]byte
+
+// Values represent a series of merkle tree leaves/nodes.
+type Values []Value
+
+var valueT = reflect.TypeOf(Value{})
+
+// UnmarshalJSON parses a merkle value in hex syntax.
+func (m *Value) UnmarshalJSON(input []byte) error {
+	return hexutil.UnmarshalFixedJSON(valueT, input, m[:])
+}
+
+// VerifyProof verifies a Merkle proof branch for a single value in a
+// binary Merkle tree (index is a generalized tree index).
+func VerifyProof(root common.Hash, index uint64, branch Values, value Value) error {
+	hasher := sha256.New()
+	for _, sibling := range branch {
+		hasher.Reset()
+		if index&1 == 0 {
+			hasher.Write(value[:])
+			hasher.Write(sibling[:])
+		} else {
+			hasher.Write(sibling[:])
+			hasher.Write(value[:])
+		}
+		hasher.Sum(value[:0])
+		if index >>= 1; index == 0 {
+			return errors.New("branch has extra items")
+		}
+	}
+	if index != 1 {
+		return errors.New("branch is missing items")
+	}
+	if common.Hash(value) != root {
+		return errors.New("root mismatch")
+	}
+	return nil
+}
--- a/core/state/snapshot/sort.go
+++ b/core/state/snapshot/sort.go
@ -1,4 +1,4 @@
-// Copyright 2019 The go-ethereum Authors
+// Copyright 2022 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@ -14,23 +14,31 @@
 // 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 snapshot
+package params

-import (
-	"bytes"
+const (
+	EpochLength      = 32
+	SyncPeriodLength = 8192

-	"github.com/ethereum/go-ethereum/common"
+	BLSSignatureSize = 96
+	BLSPubkeySize    = 48
+
+	SyncCommitteeSize          = 512
+	SyncCommitteeBitmaskSize   = SyncCommitteeSize / 8
+	SyncCommitteeSupermajority = (SyncCommitteeSize*2 + 2) / 3
 )

-// hashes is a helper to implement sort.Interface.
-type hashes []common.Hash
-
-// Len is the number of elements in the collection.
-func (hs hashes) Len() int { return len(hs) }
-
-// Less reports whether the element with index i should sort before the element
-// with index j.
-func (hs hashes) Less(i, j int) bool { return bytes.Compare(hs[i][:], hs[j][:]) < 0 }
-
-// Swap swaps the elements with indexes i and j.
-func (hs hashes) Swap(i, j int) { hs[i], hs[j] = hs[j], hs[i] }
+const (
+	StateIndexGenesisTime       = 32
+	StateIndexGenesisValidators = 33
+	StateIndexForkVersion       = 141
+	StateIndexLatestHeader      = 36
+	StateIndexBlockRoots        = 37
+	StateIndexStateRoots        = 38
+	StateIndexHistoricRoots     = 39
+	StateIndexFinalBlock        = 105
+	StateIndexSyncCommittee     = 54
+	StateIndexNextSyncCommittee = 55
+	StateIndexExecPayload       = 56
+	StateIndexExecHead          = 908
+)
--- a/beacon/types/committee.go
+++ b/beacon/types/committee.go
@ -0,0 +1,191 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"math/bits"
+
+	"github.com/ethereum/go-ethereum/beacon/params"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	bls "github.com/protolambda/bls12-381-util"
+)
+
+// SerializedSyncCommitteeSize is the size of the sync committee plus the
+// aggregate public key.
+const SerializedSyncCommitteeSize = (params.SyncCommitteeSize + 1) * params.BLSPubkeySize
+
+// SerializedSyncCommittee is the serialized version of a sync committee
+// plus the aggregate public key.
+type SerializedSyncCommittee [SerializedSyncCommitteeSize]byte
+
+// jsonSyncCommittee is the JSON representation of a sync committee.
+//
+// See data structure definition here:
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#syncaggregate
+type jsonSyncCommittee struct {
+	Pubkeys   []hexutil.Bytes `json:"pubkeys"`
+	Aggregate hexutil.Bytes   `json:"aggregate_pubkey"`
+}
+
+// MarshalJSON implements json.Marshaler.
+func (s *SerializedSyncCommittee) MarshalJSON() ([]byte, error) {
+	sc := jsonSyncCommittee{Pubkeys: make([]hexutil.Bytes, params.SyncCommitteeSize)}
+	for i := range sc.Pubkeys {
+		sc.Pubkeys[i] = make(hexutil.Bytes, params.BLSPubkeySize)
+		copy(sc.Pubkeys[i][:], s[i*params.BLSPubkeySize:(i+1)*params.BLSPubkeySize])
+	}
+	sc.Aggregate = make(hexutil.Bytes, params.BLSPubkeySize)
+	copy(sc.Aggregate[:], s[params.SyncCommitteeSize*params.BLSPubkeySize:])
+	return json.Marshal(&sc)
+}
+
+// UnmarshalJSON implements json.Marshaler.
+func (s *SerializedSyncCommittee) UnmarshalJSON(input []byte) error {
+	var sc jsonSyncCommittee
+	if err := json.Unmarshal(input, &sc); err != nil {
+		return err
+	}
+	if len(sc.Pubkeys) != params.SyncCommitteeSize {
+		return fmt.Errorf("invalid number of pubkeys %d", len(sc.Pubkeys))
+	}
+	for i, key := range sc.Pubkeys {
+		if len(key) != params.BLSPubkeySize {
+			return fmt.Errorf("pubkey %d has invalid size %d", i, len(key))
+		}
+		copy(s[i*params.BLSPubkeySize:], key[:])
+	}
+	if len(sc.Aggregate) != params.BLSPubkeySize {
+		return fmt.Errorf("invalid aggregate pubkey size %d", len(sc.Aggregate))
+	}
+	copy(s[params.SyncCommitteeSize*params.BLSPubkeySize:], sc.Aggregate[:])
+	return nil
+}
+
+// Root calculates the root hash of the binary tree representation of a sync
+// committee provided in serialized format.
+//
+// TODO(zsfelfoldi): Get rid of this when SSZ encoding lands.
+func (s *SerializedSyncCommittee) Root() common.Hash {
+	var (
+		hasher  = sha256.New()
+		padding [64 - params.BLSPubkeySize]byte
+		data    [params.SyncCommitteeSize]common.Hash
+		l       = params.SyncCommitteeSize
+	)
+	for i := range data {
+		hasher.Reset()
+		hasher.Write(s[i*params.BLSPubkeySize : (i+1)*params.BLSPubkeySize])
+		hasher.Write(padding[:])
+		hasher.Sum(data[i][:0])
+	}
+	for l > 1 {
+		for i := 0; i < l/2; i++ {
+			hasher.Reset()
+			hasher.Write(data[i*2][:])
+			hasher.Write(data[i*2+1][:])
+			hasher.Sum(data[i][:0])
+		}
+		l /= 2
+	}
+	hasher.Reset()
+	hasher.Write(s[SerializedSyncCommitteeSize-params.BLSPubkeySize : SerializedSyncCommitteeSize])
+	hasher.Write(padding[:])
+	hasher.Sum(data[1][:0])
+	hasher.Reset()
+	hasher.Write(data[0][:])
+	hasher.Write(data[1][:])
+	hasher.Sum(data[0][:0])
+	return data[0]
+}
+
+// Deserialize splits open the pubkeys into proper BLS key types.
+func (s *SerializedSyncCommittee) Deserialize() (*SyncCommittee, error) {
+	sc := new(SyncCommittee)
+	for i := 0; i <= params.SyncCommitteeSize; i++ {
+		key := new(bls.Pubkey)
+
+		var bytes [params.BLSPubkeySize]byte
+		copy(bytes[:], s[i*params.BLSPubkeySize:(i+1)*params.BLSPubkeySize])
+
+		if err := key.Deserialize(&bytes); err != nil {
+			return nil, err
+		}
+		if i < params.SyncCommitteeSize {
+			sc.keys[i] = key
+		} else {
+			sc.aggregate = key
+		}
+	}
+	return sc, nil
+}
+
+// SyncCommittee is a set of sync committee signer pubkeys and the aggregate key.
+//
+// See data structure definition here:
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#syncaggregate
+type SyncCommittee struct {
+	keys      [params.SyncCommitteeSize]*bls.Pubkey
+	aggregate *bls.Pubkey
+}
+
+// VerifySignature returns true if the given sync aggregate is a valid signature
+// or the given hash.
+func (sc *SyncCommittee) VerifySignature(signingRoot common.Hash, signature *SyncAggregate) bool {
+	var (
+		sig  bls.Signature
+		keys = make([]*bls.Pubkey, 0, params.SyncCommitteeSize)
+	)
+	if err := sig.Deserialize(&signature.Signature); err != nil {
+		return false
+	}
+	for i, key := range sc.keys {
+		if signature.Signers[i/8]&(byte(1)<<(i%8)) != 0 {
+			keys = append(keys, key)
+		}
+	}
+	return bls.FastAggregateVerify(keys, signingRoot[:], &sig)
+}
+
+//go:generate go run github.com/fjl/gencodec -type SyncAggregate -field-override syncAggregateMarshaling -out gen_syncaggregate_json.go
+
+// SyncAggregate represents an aggregated BLS signature with Signers referring
+// to a subset of the corresponding sync committee.
+//
+// See data structure definition here:
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#syncaggregate
+type SyncAggregate struct {
+	Signers   [params.SyncCommitteeBitmaskSize]byte `gencodec:"required" json:"sync_committee_bits"`
+	Signature [params.BLSSignatureSize]byte         `gencodec:"required" json:"sync_committee_signature"`
+}
+
+type syncAggregateMarshaling struct {
+	Signers   hexutil.Bytes
+	Signature hexutil.Bytes
+}
+
+// SignerCount returns the number of signers in the aggregate signature.
+func (s *SyncAggregate) SignerCount() int {
+	var count int
+	for _, v := range s.Signers {
+		count += bits.OnesCount8(v)
+	}
+	return count
+}
--- a/beacon/types/config.go
+++ b/beacon/types/config.go
@ -0,0 +1,176 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/beacon/merkle"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"gopkg.in/yaml.v3"
+)
+
+// syncCommitteeDomain specifies the signatures specific use to avoid clashes
+// across signing different data structures.
+const syncCommitteeDomain = 7
+
+// Fork describes a single beacon chain fork and also stores the calculated
+// signature domain used after this fork.
+type Fork struct {
+	// Name of the fork in the chain config (config.yaml) file{
+	Name string
+
+	// Epoch when given fork version is activated
+	Epoch uint64
+
+	// Fork version, see https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#custom-types
+	Version []byte
+
+	// calculated by computeDomain, based on fork version and genesis validators root
+	domain merkle.Value
+}
+
+// computeDomain returns the signature domain based on the given fork version
+// and genesis validator set root.
+func (f *Fork) computeDomain(genesisValidatorsRoot common.Hash) {
+	var (
+		hasher        = sha256.New()
+		forkVersion32 merkle.Value
+		forkDataRoot  merkle.Value
+	)
+	copy(forkVersion32[:], f.Version)
+	hasher.Write(forkVersion32[:])
+	hasher.Write(genesisValidatorsRoot[:])
+	hasher.Sum(forkDataRoot[:0])
+
+	f.domain[0] = syncCommitteeDomain
+	copy(f.domain[4:], forkDataRoot[:28])
+}
+
+// Forks is the list of all beacon chain forks in the chain configuration.
+type Forks []*Fork
+
+// domain returns the signature domain for the given epoch (assumes that domains
+// have already been calculated).
+func (f Forks) domain(epoch uint64) (merkle.Value, error) {
+	for i := len(f) - 1; i >= 0; i-- {
+		if epoch >= f[i].Epoch {
+			return f[i].domain, nil
+		}
+	}
+	return merkle.Value{}, fmt.Errorf("unknown fork for epoch %d", epoch)
+}
+
+// SigningRoot calculates the signing root of the given header.
+func (f Forks) SigningRoot(header Header) (common.Hash, error) {
+	domain, err := f.domain(header.Epoch())
+	if err != nil {
+		return common.Hash{}, err
+	}
+	var (
+		signingRoot common.Hash
+		headerHash  = header.Hash()
+		hasher      = sha256.New()
+	)
+	hasher.Write(headerHash[:])
+	hasher.Write(domain[:])
+	hasher.Sum(signingRoot[:0])
+
+	return signingRoot, nil
+}
+
+func (f Forks) Len() int           { return len(f) }
+func (f Forks) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
+func (f Forks) Less(i, j int) bool { return f[i].Epoch < f[j].Epoch }
+
+// ChainConfig contains the beacon chain configuration.
+type ChainConfig struct {
+	GenesisTime           uint64      // Unix timestamp of slot 0
+	GenesisValidatorsRoot common.Hash // Root hash of the genesis validator set, used for signature domain calculation
+	Forks                 Forks
+}
+
+// AddFork adds a new item to the list of forks.
+func (c *ChainConfig) AddFork(name string, epoch uint64, version []byte) *ChainConfig {
+	fork := &Fork{
+		Name:    name,
+		Epoch:   epoch,
+		Version: version,
+	}
+	fork.computeDomain(c.GenesisValidatorsRoot)
+
+	c.Forks = append(c.Forks, fork)
+	sort.Sort(c.Forks)
+
+	return c
+}
+
+// LoadForks parses the beacon chain configuration file (config.yaml) and extracts
+// the list of forks.
+func (c *ChainConfig) LoadForks(path string) error {
+	file, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("failed to read beacon chain config file: %v", err)
+	}
+	config := make(map[string]string)
+	if err := yaml.Unmarshal(file, &config); err != nil {
+		return fmt.Errorf("failed to parse beacon chain config file: %v", err)
+	}
+	var (
+		versions = make(map[string][]byte)
+		epochs   = make(map[string]uint64)
+	)
+	epochs["GENESIS"] = 0
+
+	for key, value := range config {
+		if strings.HasSuffix(key, "_FORK_VERSION") {
+			name := key[:len(key)-len("_FORK_VERSION")]
+			if v, err := hexutil.Decode(value); err == nil {
+				versions[name] = v
+			} else {
+				return fmt.Errorf("failed to decode hex fork id %q in beacon chain config file: %v", value, err)
+			}
+		}
+		if strings.HasSuffix(key, "_FORK_EPOCH") {
+			name := key[:len(key)-len("_FORK_EPOCH")]
+			if v, err := strconv.ParseUint(value, 10, 64); err == nil {
+				epochs[name] = v
+			} else {
+				return fmt.Errorf("failed to parse epoch number %q in beacon chain config file: %v", value, err)
+			}
+		}
+	}
+	for name, epoch := range epochs {
+		if version, ok := versions[name]; ok {
+			delete(versions, name)
+			c.AddFork(name, epoch, version)
+		} else {
+			return fmt.Errorf("fork id missing for %q in beacon chain config file", name)
+		}
+	}
+	for name := range versions {
+		return fmt.Errorf("epoch number missing for fork %q in beacon chain config file", name)
+	}
+	sort.Sort(c.Forks)
+	return nil
+}
--- a/beacon/types/gen_header_json.go
+++ b/beacon/types/gen_header_json.go
@ -0,0 +1,66 @@
+// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
+
+package types
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var _ = (*headerMarshaling)(nil)
+
+// MarshalJSON marshals as JSON.
+func (h Header) MarshalJSON() ([]byte, error) {
+	type Header struct {
+		Slot          common.Decimal `gencodec:"required" json:"slot"`
+		ProposerIndex common.Decimal `gencodec:"required" json:"proposer_index"`
+		ParentRoot    common.Hash    `gencodec:"required" json:"parent_root"`
+		StateRoot     common.Hash    `gencodec:"required" json:"state_root"`
+		BodyRoot      common.Hash    `gencodec:"required" json:"body_root"`
+	}
+	var enc Header
+	enc.Slot = common.Decimal(h.Slot)
+	enc.ProposerIndex = common.Decimal(h.ProposerIndex)
+	enc.ParentRoot = h.ParentRoot
+	enc.StateRoot = h.StateRoot
+	enc.BodyRoot = h.BodyRoot
+	return json.Marshal(&enc)
+}
+
+// UnmarshalJSON unmarshals from JSON.
+func (h *Header) UnmarshalJSON(input []byte) error {
+	type Header struct {
+		Slot          *common.Decimal `gencodec:"required" json:"slot"`
+		ProposerIndex *common.Decimal `gencodec:"required" json:"proposer_index"`
+		ParentRoot    *common.Hash    `gencodec:"required" json:"parent_root"`
+		StateRoot     *common.Hash    `gencodec:"required" json:"state_root"`
+		BodyRoot      *common.Hash    `gencodec:"required" json:"body_root"`
+	}
+	var dec Header
+	if err := json.Unmarshal(input, &dec); err != nil {
+		return err
+	}
+	if dec.Slot == nil {
+		return errors.New("missing required field 'slot' for Header")
+	}
+	h.Slot = uint64(*dec.Slot)
+	if dec.ProposerIndex == nil {
+		return errors.New("missing required field 'proposer_index' for Header")
+	}
+	h.ProposerIndex = uint64(*dec.ProposerIndex)
+	if dec.ParentRoot == nil {
+		return errors.New("missing required field 'parent_root' for Header")
+	}
+	h.ParentRoot = *dec.ParentRoot
+	if dec.StateRoot == nil {
+		return errors.New("missing required field 'state_root' for Header")
+	}
+	h.StateRoot = *dec.StateRoot
+	if dec.BodyRoot == nil {
+		return errors.New("missing required field 'body_root' for Header")
+	}
+	h.BodyRoot = *dec.BodyRoot
+	return nil
+}
--- a/beacon/types/gen_syncaggregate_json.go
+++ b/beacon/types/gen_syncaggregate_json.go
@ -0,0 +1,51 @@
+// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
+
+package types
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+var _ = (*syncAggregateMarshaling)(nil)
+
+// MarshalJSON marshals as JSON.
+func (s SyncAggregate) MarshalJSON() ([]byte, error) {
+	type SyncAggregate struct {
+		Signers   hexutil.Bytes `gencodec:"required" json:"sync_committee_bits"`
+		Signature hexutil.Bytes `gencodec:"required" json:"sync_committee_signature"`
+	}
+	var enc SyncAggregate
+	enc.Signers = s.Signers[:]
+	enc.Signature = s.Signature[:]
+	return json.Marshal(&enc)
+}
+
+// UnmarshalJSON unmarshals from JSON.
+func (s *SyncAggregate) UnmarshalJSON(input []byte) error {
+	type SyncAggregate struct {
+		Signers   *hexutil.Bytes `gencodec:"required" json:"sync_committee_bits"`
+		Signature *hexutil.Bytes `gencodec:"required" json:"sync_committee_signature"`
+	}
+	var dec SyncAggregate
+	if err := json.Unmarshal(input, &dec); err != nil {
+		return err
+	}
+	if dec.Signers == nil {
+		return errors.New("missing required field 'sync_committee_bits' for SyncAggregate")
+	}
+	if len(*dec.Signers) != len(s.Signers) {
+		return errors.New("field 'sync_committee_bits' has wrong length, need 64 items")
+	}
+	copy(s.Signers[:], *dec.Signers)
+	if dec.Signature == nil {
+		return errors.New("missing required field 'sync_committee_signature' for SyncAggregate")
+	}
+	if len(*dec.Signature) != len(s.Signature) {
+		return errors.New("field 'sync_committee_signature' has wrong length, need 96 items")
+	}
+	copy(s.Signature[:], *dec.Signature)
+	return nil
+}
--- a/beacon/types/header.go
+++ b/beacon/types/header.go
@ -0,0 +1,121 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// Package types implements a few types of the beacon chain for light client usage.
+package types
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+
+	"github.com/ethereum/go-ethereum/beacon/merkle"
+	"github.com/ethereum/go-ethereum/beacon/params"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+//go:generate go run github.com/fjl/gencodec -type Header -field-override headerMarshaling -out gen_header_json.go
+
+const (
+	headerIndexSlot          = 8
+	headerIndexProposerIndex = 9
+	headerIndexParentRoot    = 10
+	headerIndexStateRoot     = 11
+	headerIndexBodyRoot      = 12
+)
+
+// Header defines a beacon header.
+//
+// See data structure definition here:
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#beaconblockheader
+type Header struct {
+	// Monotonically increasing slot number for the beacon block (may be gapped)
+	Slot uint64 `gencodec:"required" json:"slot"`
+
+	// Index into the validator table who created the beacon block
+	ProposerIndex uint64 `gencodec:"required" json:"proposer_index"`
+
+	// SSZ hash of the parent beacon header
+	ParentRoot common.Hash `gencodec:"required" json:"parent_root"`
+
+	// SSZ hash of the beacon state (https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#beacon-state)
+	StateRoot common.Hash `gencodec:"required" json:"state_root"`
+
+	// SSZ hash of the beacon block body (https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#beaconblockbody)
+	BodyRoot common.Hash `gencodec:"required" json:"body_root"`
+}
+
+// headerMarshaling is a field type overrides for gencodec.
+type headerMarshaling struct {
+	Slot          common.Decimal
+	ProposerIndex common.Decimal
+}
+
+// Hash calculates the block root of the header.
+//
+// TODO(zsfelfoldi): Remove this when an SSZ encoder lands.
+func (h *Header) Hash() common.Hash {
+	var values [16]merkle.Value // values corresponding to indices 8 to 15 of the beacon header tree
+	binary.LittleEndian.PutUint64(values[headerIndexSlot][:8], h.Slot)
+	binary.LittleEndian.PutUint64(values[headerIndexProposerIndex][:8], h.ProposerIndex)
+	values[headerIndexParentRoot] = merkle.Value(h.ParentRoot)
+	values[headerIndexStateRoot] = merkle.Value(h.StateRoot)
+	values[headerIndexBodyRoot] = merkle.Value(h.BodyRoot)
+	hasher := sha256.New()
+	for i := 7; i > 0; i-- {
+		hasher.Reset()
+		hasher.Write(values[i*2][:])
+		hasher.Write(values[i*2+1][:])
+		hasher.Sum(values[i][:0])
+	}
+	return common.Hash(values[1])
+}
+
+// Epoch returns the epoch the header belongs to.
+func (h *Header) Epoch() uint64 {
+	return h.Slot / params.EpochLength
+}
+
+// SyncPeriod returns the sync period the header belongs to.
+func (h *Header) SyncPeriod() uint64 {
+	return SyncPeriod(h.Slot)
+}
+
+// SyncPeriodStart returns the first slot of the given period.
+func SyncPeriodStart(period uint64) uint64 {
+	return period * params.SyncPeriodLength
+}
+
+// SyncPeriod returns the sync period that the given slot belongs to.
+func SyncPeriod(slot uint64) uint64 {
+	return slot / params.SyncPeriodLength
+}
+
+// SignedHeader represents a beacon header signed by a sync committee.
+//
+// This structure is created from either an optimistic update or an instant update:
+//   - https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientoptimisticupdate
+//   - https://github.com/zsfelfoldi/beacon-APIs/blob/instant_update/apis/beacon/light_client/instant_update.yaml
+type SignedHeader struct {
+	// Beacon header being signed
+	Header Header
+
+	// Sync committee BLS signature aggregate
+	Signature SyncAggregate
+
+	// Slot in which the signature has been created (newer than Header.Slot,
+	// determines the signing sync committee)
+	SignatureSlot uint64
+}
--- a/beacon/types/update.go
+++ b/beacon/types/update.go
@ -0,0 +1,118 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/beacon/merkle"
+	"github.com/ethereum/go-ethereum/beacon/params"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// LightClientUpdate is a proof of the next sync committee root based on a header
+// signed by the sync committee of the given period. Optionally, the update can
+// prove quasi-finality by the signed header referring to a previous, finalized
+// header from the same period, and the finalized header referring to the next
+// sync committee root.
+//
+// See data structure definition here:
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientupdate
+type LightClientUpdate struct {
+	AttestedHeader          SignedHeader  // Arbitrary header out of the period signed by the sync committee
+	NextSyncCommitteeRoot   common.Hash   // Sync committee of the next period advertised in the current one
+	NextSyncCommitteeBranch merkle.Values // Proof for the next period's sync committee
+
+	FinalizedHeader *Header       `rlp:"nil"` // Optional header to announce a point of finality
+	FinalityBranch  merkle.Values // Proof for the announced finality
+
+	score *UpdateScore // Weight of the update to compare between competing ones
+}
+
+// Validate verifies the validity of the update.
+func (update *LightClientUpdate) Validate() error {
+	period := update.AttestedHeader.Header.SyncPeriod()
+	if SyncPeriod(update.AttestedHeader.SignatureSlot) != period {
+		return errors.New("signature slot and signed header are from different periods")
+	}
+	if update.FinalizedHeader != nil {
+		if update.FinalizedHeader.SyncPeriod() != period {
+			return errors.New("finalized header is from different period")
+		}
+		if err := merkle.VerifyProof(update.AttestedHeader.Header.StateRoot, params.StateIndexFinalBlock, update.FinalityBranch, merkle.Value(update.FinalizedHeader.Hash())); err != nil {
+			return fmt.Errorf("invalid finalized header proof: %w", err)
+		}
+	}
+	if err := merkle.VerifyProof(update.AttestedHeader.Header.StateRoot, params.StateIndexNextSyncCommittee, update.NextSyncCommitteeBranch, merkle.Value(update.NextSyncCommitteeRoot)); err != nil {
+		return fmt.Errorf("invalid next sync committee proof: %w", err)
+	}
+	return nil
+}
+
+// Score returns the UpdateScore describing the proof strength of the update
+// Note: thread safety can be ensured by always calling Score on a newly received
+// or decoded update before making it potentially available for other threads
+func (update *LightClientUpdate) Score() UpdateScore {
+	if update.score == nil {
+		update.score = &UpdateScore{
+			SignerCount:     uint32(update.AttestedHeader.Signature.SignerCount()),
+			SubPeriodIndex:  uint32(update.AttestedHeader.Header.Slot & 0x1fff),
+			FinalizedHeader: update.FinalizedHeader != nil,
+		}
+	}
+	return *update.score
+}
+
+// UpdateScore allows the comparison between updates at the same period in order
+// to find the best update chain that provides the strongest proof of being canonical.
+//
+// UpdateScores have a tightly packed binary encoding format for efficient p2p
+// protocol transmission. Each UpdateScore is encoded in 3 bytes.
+// When interpreted as a 24 bit little indian unsigned integer:
+//   - the lowest 10 bits contain the number of signers in the header signature aggregate
+//   - the next 13 bits contain the "sub-period index" which is he signed header's
+//     slot modulo params.SyncPeriodLength (which is correlated with the risk of the chain being
+//     re-orged before the previous period boundary in case of non-finalized updates)
+//   - the highest bit is set when the update is finalized (meaning that the finality
+//     header referenced by the signed header is in the same period as the signed
+//     header, making reorgs before the period boundary impossible
+type UpdateScore struct {
+	SignerCount     uint32 // number of signers in the header signature aggregate
+	SubPeriodIndex  uint32 // signed header's slot modulo params.SyncPeriodLength
+	FinalizedHeader bool   // update is considered finalized if has finalized header from the same period and 2/3 signatures
+}
+
+// finalized returns true if the update has a header signed by at least 2/3 of
+// the committee, referring to a finalized header that refers to the next sync
+// committee. This condition is a close approximation of the actual finality
+// condition that can only be verified by full beacon nodes.
+func (u *UpdateScore) finalized() bool {
+	return u.FinalizedHeader && u.SignerCount >= params.SyncCommitteeSupermajority
+}
+
+// BetterThan returns true if update u is considered better than w.
+func (u UpdateScore) BetterThan(w UpdateScore) bool {
+	var (
+		uFinalized = u.finalized()
+		wFinalized = w.finalized()
+	)
+	if uFinalized != wFinalized {
+		return uFinalized
+	}
+	return u.SignerCount > w.SignerCount
+}
--- a/build/checksums.txt
+++ b/build/checksums.txt
@ -1,20 +1,25 @@
 # This file contains sha256 checksums of optional build dependencies.

-e447b498cde50215c4f7619e5124b0fc4e25fb5d16ea47271c47f278e7aa763a  go1.20.3.src.tar.gz
-c1e1161d6d859deb576e6cfabeb40e3d042ceb1c6f444f617c3c9d76269c3565  go1.20.3.darwin-amd64.tar.gz
-86b0ed0f2b2df50fa8036eea875d1cf2d76cefdacf247c44639a1464b7e36b95  go1.20.3.darwin-arm64.tar.gz
-340e80abd047c597fdc0f50a6cc59617f06c297d62f7fc77f4a0164e2da6f7aa  go1.20.3.freebsd-386.tar.gz
-2169fcd8b6c94c5fbe07c0b470ccfb6001d343f6548ad49f3d9ab78e3b5753c7  go1.20.3.freebsd-amd64.tar.gz
-e12384311403f1389d14cc1c1295bfb4e0dd5ab919403b80da429f671a223507  go1.20.3.linux-386.tar.gz
-979694c2c25c735755bf26f4f45e19e64e4811d661dd07b8c010f7a8e18adfca  go1.20.3.linux-amd64.tar.gz
-eb186529f13f901e7a2c4438a05c2cd90d74706aaa0a888469b2a4a617b6ee54  go1.20.3.linux-arm64.tar.gz
-b421e90469a83671641f81b6e20df6500f033e9523e89cbe7b7223704dd1035c  go1.20.3.linux-armv6l.tar.gz
-943c89aa1624ea544a022b31e3d6e16a037200e436370bdd5fd67f3fa60be282  go1.20.3.linux-ppc64le.tar.gz
-126cf823a5634ef2544b866db107b9d351d3ea70d9e240b0bdcfb46f4dcae54b  go1.20.3.linux-s390x.tar.gz
-37e9146e1f9d681cfcaa6fee6c7b890c44c64bc50228c9588f3c4231346d33bd  go1.20.3.windows-386.zip
-143a2837821c7dbacf7744cbb1a8421c1f48307c6fdfaeffc5f8c2f69e1b7932  go1.20.3.windows-amd64.zip
-158cb159e00bc979f473e0f5b5a561613129c5e51067967b72b8e072e5a4db81  go1.20.3.windows-arm64.zip
+# https://github.com/ethereum/execution-spec-tests/releases
+24bac679f3a2d8240d8e08e7f6a70b70c2dabf673317d924cf1d1887b9fe1f81  fixtures.tar.gz

+# https://go.dev/dl/
+818d46ede85682dd551ad378ef37a4d247006f12ec59b5b755601d2ce114369a  go1.21.0.src.tar.gz
+b314de9f704ab122c077d2ec8e67e3670affe8865479d1f01991e7ac55d65e70  go1.21.0.darwin-amd64.tar.gz
+3aca44de55c5e098de2f406e98aba328898b05d509a2e2a356416faacf2c4566  go1.21.0.darwin-arm64.tar.gz
+312a0065714a50862af714e7a5b3fbbd70fe68f905ffb9bcc56d42eadf6bffab  go1.21.0.freebsd-386.tar.gz
+b8eaa36654625df799654f77f4af0ea7bd9e5e760ebe86e68fe7c484748ae995  go1.21.0.freebsd-amd64.tar.gz
+0e6f378d9b072fab0a3d9ff4d5e990d98487d47252dba8160015a61e6bd0bcba  go1.21.0.linux-386.tar.gz
+d0398903a16ba2232b389fb31032ddf57cac34efda306a0eebac34f0965a0742  go1.21.0.linux-amd64.tar.gz
+f3d4548edf9b22f26bbd49720350bbfe59d75b7090a1a2bff1afad8214febaf3  go1.21.0.linux-arm64.tar.gz
+e377a0004957c8c560a3ff99601bce612330a3d95ba3b0a2ae144165fc87deb1  go1.21.0.linux-armv6l.tar.gz
+e938ffc81d8ebe5efc179240960ba22da6a841ff05d5cab7ce2547112b14a47f  go1.21.0.linux-ppc64le.tar.gz
+be7338df8e5d5472dfa307b0df2b446d85d001b0a2a3cdb1a14048d751b70481  go1.21.0.linux-s390x.tar.gz
+af920fbb74fc3d173118dc3cc35f02a709c1de642700e92a91a7d16981df3fec  go1.21.0.windows-386.zip
+732121e64e0ecb07c77fdf6cc1bc5ce7b242c2d40d4ac29021ad4c64a08731f6  go1.21.0.windows-amd64.zip
+41342f5a0f8c083b14c68bde738ddcd313a4f53a5854bfdfab47f0e88247de12  go1.21.0.windows-arm64.zip
+
+# https://github.com/golangci/golangci-lint/releases
 fba08acc4027f69f07cef48fbff70b8a7ecdfaa1c2aba9ad3fb31d60d9f5d4bc  golangci-lint-1.51.1-darwin-amd64.tar.gz
 75b8f0ff3a4e68147156be4161a49d4576f1be37a0b506473f8c482140c1e7f2  golangci-lint-1.51.1-darwin-arm64.tar.gz
 e06b3459aaed356e1667580be00b05f41f3b2e29685d12cdee571c23e1edb414  golangci-lint-1.51.1-freebsd-386.tar.gz
--- a/build/ci.go
+++ b/build/ci.go
@ -120,15 +120,15 @@ var (
 	// Distros for which packages are created.
 	// Note: vivid is unsupported because there is no golang-1.6 package for it.
 	// Note: the following Ubuntu releases have been officially deprecated on Launchpad:
-	//   wily, yakkety, zesty, artful, cosmic, disco, eoan, groovy, hirsuite, impish
+	//   wily, yakkety, zesty, artful, cosmic, disco, eoan, groovy, hirsuite, impish,
+	//   kinetic
 	debDistroGoBoots = map[string]string{
-		"trusty":  "golang-1.11", // EOL: 04/2024
-		"xenial":  "golang-go",   // EOL: 04/2026
-		"bionic":  "golang-go",   // EOL: 04/2028
-		"focal":   "golang-go",   // EOL: 04/2030
-		"jammy":   "golang-go",   // EOL: 04/2032
-		"kinetic": "golang-go",   // EOL: 07/2023
-		"lunar":   "golang-go",   // EOL: 01/2024
+		"trusty": "golang-1.11", // EOL: 04/2024
+		"xenial": "golang-go",   // EOL: 04/2026
+		"bionic": "golang-go",   // EOL: 04/2028
+		"focal":  "golang-go",   // EOL: 04/2030
+		"jammy":  "golang-go",   // EOL: 04/2032
+		"lunar":  "golang-go",   // EOL: 01/2024
 	}

 	debGoBootPaths = map[string]string{
@ -139,7 +139,7 @@ var (
 	// This is the version of Go that will be downloaded by
 	//
 	//     go run ci.go install -dlgo
-	dlgoVersion = "1.20.3"
+	dlgoVersion = "1.21.0"

 	// This is the version of Go that will be used to bootstrap the PPA builder.
 	//
@ -148,6 +148,13 @@ var (
 	// we need to switch over to a recursive builder to jumpt across supported
 	// versions.
 	gobootVersion = "1.19.6"
+
+	// This is the version of execution-spec-tests that we are using.
+	// When updating, you must also update build/checksums.txt.
+	executionSpecTestsVersion = "1.0.2"
+
+	// This is where the tests should be unpacked.
+	executionSpecTestsDir = "tests/spec-tests"
 )

 var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
@ -200,6 +207,7 @@ func doInstall(cmdline []string) {
 		staticlink = flag.Bool("static", false, "Create statically-linked executable")
 	)
 	flag.CommandLine.Parse(cmdline)
+	env := build.Env()

 	// Configure the toolchain.
 	tc := build.GoToolchain{GOARCH: *arch, CC: *cc}
@ -207,12 +215,16 @@ func doInstall(cmdline []string) {
 		csdb := build.MustLoadChecksums("build/checksums.txt")
 		tc.Root = build.DownloadGo(csdb, dlgoVersion)
 	}
-	// Disable CLI markdown doc generation in release builds and enable linking
-	// the CKZG library since we can make it portable here.
-	buildTags := []string{"urfave_cli_no_docs", "ckzg"}
+
+	// Disable CLI markdown doc generation in release builds.
+	buildTags := []string{"urfave_cli_no_docs"}
+
+	// Enable linking the CKZG library since we can make it work with additional flags.
+	if env.UbuntuVersion != "trusty" {
+		buildTags = append(buildTags, "ckzg")
+	}

 	// Configure the build.
-	env := build.Env()
 	gobuild := tc.Go("build", buildFlags(env, *staticlink, buildTags)...)

 	// arm64 CI builders are memory-constrained and can't handle concurrent builds,
@ -289,16 +301,26 @@ func doTest(cmdline []string) {
 		coverage = flag.Bool("coverage", false, "Whether to record code coverage")
 		verbose  = flag.Bool("v", false, "Whether to log verbosely")
 		race     = flag.Bool("race", false, "Execute the race detector")
+		cachedir = flag.String("cachedir", "./build/cache", "directory for caching downloads")
 	)
 	flag.CommandLine.Parse(cmdline)

+	// Get test fixtures.
+	csdb := build.MustLoadChecksums("build/checksums.txt")
+	downloadSpecTestFixtures(csdb, *cachedir)
+
 	// Configure the toolchain.
 	tc := build.GoToolchain{GOARCH: *arch, CC: *cc}
 	if *dlgo {
-		csdb := build.MustLoadChecksums("build/checksums.txt")
 		tc.Root = build.DownloadGo(csdb, dlgoVersion)
 	}
-	gotest := tc.Go("test", "-tags=ckzg")
+	gotest := tc.Go("test")
+
+	// CI needs a bit more time for the statetests (default 10m).
+	gotest.Args = append(gotest.Args, "-timeout=20m")
+
+	// Enable CKZG backend in CI.
+	gotest.Args = append(gotest.Args, "-tags=ckzg")

 	// Test a single package at a time. CI builders are slow
 	// and some tests run into timeouts under load.
@ -321,6 +343,21 @@ func doTest(cmdline []string) {
 	build.MustRun(gotest)
 }

+// downloadSpecTestFixtures downloads and extracts the execution-spec-tests fixtures.
+func downloadSpecTestFixtures(csdb *build.ChecksumDB, cachedir string) string {
+	ext := ".tar.gz"
+	base := "fixtures" // TODO(MariusVanDerWijden) rename once the version becomes part of the filename
+	url := fmt.Sprintf("https://github.com/ethereum/execution-spec-tests/releases/download/v%s/%s%s", executionSpecTestsVersion, base, ext)
+	archivePath := filepath.Join(cachedir, base+ext)
+	if err := csdb.DownloadFile(url, archivePath); err != nil {
+		log.Fatal(err)
+	}
+	if err := build.ExtractArchive(archivePath, executionSpecTestsDir); err != nil {
+		log.Fatal(err)
+	}
+	return filepath.Join(cachedir, base)
+}
+
 // doLint runs golangci-lint on requested packages.
 func doLint(cmdline []string) {
 	var (
--- a/build/deb/ethereum/deb.rules
+++ b/build/deb/ethereum/deb.rules
@ -28,7 +28,7 @@ override_dh_auto_build:
 	mv .mod $(GOPATH)/pkg/mod

 	# A fresh Go was built, all dependency downloads faked, hope build works now
-	../.go/bin/go run build/ci.go install -git-commit={{.Env.Commit}} -git-branch={{.Env.Branch}} -git-tag={{.Env.Tag}} -buildnum={{.Env.Buildnum}} -pull-request={{.Env.IsPullRequest}}
+	../.go/bin/go run build/ci.go install -git-commit={{.Env.Commit}} -git-branch={{.Env.Branch}} -git-tag={{.Env.Tag}} -buildnum={{.Env.Buildnum}} -pull-request={{.Env.IsPullRequest}} -ubuntu {{.Distro}}

 override_dh_auto_test:

--- a/build/update-license.go
+++ b/build/update-license.go
@ -46,12 +46,13 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
 	"text/template"
 	"time"
+
+	"golang.org/x/exp/slices"
 )

 var (
@ -152,13 +153,6 @@ func (i info) gpl() bool {
 	return false
 }

-// authors implements the sort.Interface for strings in case-insensitive mode.
-type authors []string
-
-func (as authors) Len() int           { return len(as) }
-func (as authors) Less(i, j int) bool { return strings.ToLower(as[i]) < strings.ToLower(as[j]) }
-func (as authors) Swap(i, j int)      { as[i], as[j] = as[j], as[i] }
-
 func main() {
 	var (
 		files = getFiles()
@ -299,7 +293,9 @@ func writeAuthors(files []string) {
 		}
 	}
 	// Write sorted list of authors back to the file.
-	sort.Sort(authors(list))
+	slices.SortFunc(list, func(a, b string) bool {
+		return strings.ToLower(a) < strings.ToLower(b)
+	})
 	content := new(bytes.Buffer)
 	content.WriteString(authorsFileHeader)
 	for _, a := range list {
--- a/cmd/bootnode/main.go
+++ b/cmd/bootnode/main.go
@ -23,6 +23,7 @@ import (
 	"fmt"
 	"net"
 	"os"
+	"time"

 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/crypto"
@ -107,21 +108,20 @@ func main() {
 	if err != nil {
 		utils.Fatalf("-ListenUDP: %v", err)
 	}
-
-	realaddr := conn.LocalAddr().(*net.UDPAddr)
-	if natm != nil {
-		if !realaddr.IP.IsLoopback() {
-			go nat.Map(natm, nil, "udp", realaddr.Port, realaddr.Port, "ethereum discovery")
-		}
-		if ext, err := natm.ExternalIP(); err == nil {
-			realaddr = &net.UDPAddr{IP: ext, Port: realaddr.Port}
-		}
-	}
-
-	printNotice(&nodeKey.PublicKey, *realaddr)
+	defer conn.Close()

 	db, _ := enode.OpenDB("")
 	ln := enode.NewLocalNode(db, nodeKey)
+
+	listenerAddr := conn.LocalAddr().(*net.UDPAddr)
+	if natm != nil && !listenerAddr.IP.IsLoopback() {
+		natAddr := doPortMapping(natm, ln, listenerAddr)
+		if natAddr != nil {
+			listenerAddr = natAddr
+		}
+	}
+
+	printNotice(&nodeKey.PublicKey, *listenerAddr)
 	cfg := discover.Config{
 		PrivateKey:  nodeKey,
 		NetRestrict: restrictList,
@ -148,3 +148,61 @@ func printNotice(nodeKey *ecdsa.PublicKey, addr net.UDPAddr) {
 	fmt.Println("Note: you're using cmd/bootnode, a developer tool.")
 	fmt.Println("We recommend using a regular node as bootstrap node for production deployments.")
 }
+
+func doPortMapping(natm nat.Interface, ln *enode.LocalNode, addr *net.UDPAddr) *net.UDPAddr {
+	const (
+		protocol = "udp"
+		name     = "ethereum discovery"
+	)
+	newLogger := func(external int, internal int) log.Logger {
+		return log.New("proto", protocol, "extport", external, "intport", internal, "interface", natm)
+	}
+
+	var (
+		intport    = addr.Port
+		extaddr    = &net.UDPAddr{IP: addr.IP, Port: addr.Port}
+		mapTimeout = nat.DefaultMapTimeout
+		log        = newLogger(addr.Port, intport)
+	)
+	addMapping := func() {
+		// Get the external address.
+		var err error
+		extaddr.IP, err = natm.ExternalIP()
+		if err != nil {
+			log.Debug("Couldn't get external IP", "err", err)
+			return
+		}
+		// Create the mapping.
+		p, err := natm.AddMapping(protocol, extaddr.Port, intport, name, mapTimeout)
+		if err != nil {
+			log.Debug("Couldn't add port mapping", "err", err)
+			return
+		}
+		if p != uint16(extaddr.Port) {
+			extaddr.Port = int(p)
+			log = newLogger(extaddr.Port, intport)
+			log.Info("NAT mapped alternative port")
+		} else {
+			log.Info("NAT mapped port")
+		}
+		// Update IP/port information of the local node.
+		ln.SetStaticIP(extaddr.IP)
+		ln.SetFallbackUDP(extaddr.Port)
+	}
+
+	// Perform mapping once, synchronously.
+	log.Info("Attempting port mapping")
+	addMapping()
+
+	// Refresh the mapping periodically.
+	go func() {
+		refresh := time.NewTimer(mapTimeout)
+		defer refresh.Stop()
+		for range refresh.C {
+			addMapping()
+			refresh.Reset(mapTimeout)
+		}
+	}()
+
+	return extaddr
+}
--- a/cmd/clef/README.md
+++ b/cmd/clef/README.md
@ -29,7 +29,7 @@ GLOBAL OPTIONS:
   --loglevel value        log level to emit to the screen (default: 4)
   --keystore value        Directory for the keystore (default: "$HOME/.ethereum/keystore")
   --configdir value       Directory for Clef configuration (default: "$HOME/.clef")
-   --chainid value         Chain id to use for signing (1=mainnet, 4=Rinkeby, 5=Goerli) (default: 1)
+   --chainid value         Chain id to use for signing (1=mainnet, 5=Goerli) (default: 1)
   --lightkdf              Reduce key-derivation RAM & CPU usage at some expense of KDF strength
   --nousb                 Disables monitoring for and managing USB hardware wallets
   --pcscdpath value       Path to the smartcard daemon (pcscd) socket file (default: "/run/pcscd/pcscd.comm")
--- a/cmd/clef/main.go
+++ b/cmd/clef/main.go
@ -27,6 +27,7 @@ import (
 	"fmt"
 	"io"
 	"math/big"
+	"net"
 	"os"
 	"os/signal"
 	"path/filepath"
@ -99,7 +100,7 @@ var (
 	chainIdFlag = &cli.Int64Flag{
 		Name:  "chainid",
 		Value: params.MainnetChainConfig.ChainID.Int64(),
-		Usage: "Chain id to use for signing (1=mainnet, 4=Rinkeby, 5=Goerli)",
+		Usage: "Chain id to use for signing (1=mainnet, 5=Goerli)",
 	}
 	rpcPortFlag = &cli.IntFlag{
 		Name:     "http.port",
@ -326,7 +327,7 @@ func initializeSecrets(c *cli.Context) error {
 		return err
 	}
 	if num != len(masterSeed) {
-		return fmt.Errorf("failed to read enough random")
+		return errors.New("failed to read enough random")
 	}
 	n, p := keystore.StandardScryptN, keystore.StandardScryptP
 	if c.Bool(utils.LightKDFFlag.Name) {
@ -482,7 +483,7 @@ func initialize(c *cli.Context) error {
 		}
 	} else if !c.Bool(acceptFlag.Name) {
 		if !confirm(legalWarning) {
-			return fmt.Errorf("aborted by user")
+			return errors.New("aborted by user")
 		}
 		fmt.Println()
 	}
@ -732,6 +733,7 @@ func signer(c *cli.Context) error {
 		cors := utils.SplitAndTrim(c.String(utils.HTTPCORSDomainFlag.Name))

 		srv := rpc.NewServer()
+		srv.SetBatchLimits(node.DefaultConfig.BatchRequestLimit, node.DefaultConfig.BatchResponseMaxSize)
 		err := node.RegisterApis(rpcAPI, []string{"account"}, srv)
 		if err != nil {
 			utils.Fatalf("Could not register API: %w", err)
@ -742,7 +744,7 @@ func signer(c *cli.Context) error {
 		port := c.Int(rpcPortFlag.Name)

 		// start http server
-		httpEndpoint := fmt.Sprintf("%s:%d", c.String(utils.HTTPListenAddrFlag.Name), port)
+		httpEndpoint := net.JoinHostPort(c.String(utils.HTTPListenAddrFlag.Name), fmt.Sprintf("%d", port))
 		httpServer, addr, err := node.StartHTTPEndpoint(httpEndpoint, rpc.DefaultHTTPTimeouts, handler)
 		if err != nil {
 			utils.Fatalf("Could not start RPC api: %v", err)
@ -844,7 +846,7 @@ func readMasterKey(ctx *cli.Context, ui core.UIClientAPI) ([]byte, error) {
 	}
 	masterSeed, err := decryptSeed(cipherKey, password)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt the master seed of clef")
+		return nil, errors.New("failed to decrypt the master seed of clef")
 	}
 	if len(masterSeed) < 256 {
 		return nil, fmt.Errorf("master seed of insufficient length, expected >255 bytes, got %d", len(masterSeed))
--- a/cmd/devp2p/README.md
+++ b/cmd/devp2p/README.md
@ -44,7 +44,7 @@ set to standard output. The following filters are supported:
 - `-limit <N>` limits the output set to N entries, taking the top N nodes by score
 - `-ip <CIDR>` filters nodes by IP subnet
 - `-min-age <duration>` filters nodes by 'first seen' time
- `-eth-network <mainnet/rinkeby/goerli/sepolia>` filters nodes by "eth" ENR entry
+- `-eth-network <mainnet/goerli/sepolia/holesky>` filters nodes by "eth" ENR entry
 - `-les-server` filters nodes by LES server support
 - `-snap` filters nodes by snap protocol support

--- a/cmd/devp2p/crawl.go
+++ b/cmd/devp2p/crawl.go
@ -87,11 +87,11 @@ func (c *crawler) run(timeout time.Duration, nthreads int) nodeSet {
 		go c.runIterator(doneCh, it)
 	}
 	var (
-		added   uint64
-		updated uint64
-		skipped uint64
-		recent  uint64
-		removed uint64
+		added   atomic.Uint64
+		updated atomic.Uint64
+		skipped atomic.Uint64
+		recent  atomic.Uint64
+		removed atomic.Uint64
 		wg      sync.WaitGroup
 	)
 	wg.Add(nthreads)
@ -103,15 +103,15 @@ func (c *crawler) run(timeout time.Duration, nthreads int) nodeSet {
 				case n := <-c.ch:
 					switch c.updateNode(n) {
 					case nodeSkipIncompat:
-						atomic.AddUint64(&skipped, 1)
+						skipped.Add(1)
 					case nodeSkipRecent:
-						atomic.AddUint64(&recent, 1)
+						recent.Add(1)
 					case nodeRemoved:
-						atomic.AddUint64(&removed, 1)
+						removed.Add(1)
 					case nodeAdded:
-						atomic.AddUint64(&added, 1)
+						added.Add(1)
 					default:
-						atomic.AddUint64(&updated, 1)
+						updated.Add(1)
 					}
 				case <-c.closed:
 					return
@ -138,11 +138,11 @@ loop:
 			break loop
 		case <-statusTicker.C:
 			log.Info("Crawling in progress",
-				"added", atomic.LoadUint64(&added),
-				"updated", atomic.LoadUint64(&updated),
-				"removed", atomic.LoadUint64(&removed),
-				"ignored(recent)", atomic.LoadUint64(&recent),
-				"ignored(incompatible)", atomic.LoadUint64(&skipped))
+				"added", added.Load(),
+				"updated", updated.Load(),
+				"removed", removed.Load(),
+				"ignored(recent)", recent.Load(),
+				"ignored(incompatible)", skipped.Load())
 		}
 	}

--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@ -17,6 +17,7 @@
 package main

 import (
+	"errors"
 	"fmt"
 	"net"
 	"strconv"
@ -177,7 +178,7 @@ func discv4Resolve(ctx *cli.Context) error {

 func discv4ResolveJSON(ctx *cli.Context) error {
 	if ctx.NArg() < 1 {
-		return fmt.Errorf("need nodes file as argument")
+		return errors.New("need nodes file as argument")
 	}
 	nodesFile := ctx.Args().Get(0)
 	inputSet := make(nodeSet)
@ -207,7 +208,7 @@ func discv4ResolveJSON(ctx *cli.Context) error {

 func discv4Crawl(ctx *cli.Context) error {
 	if ctx.NArg() < 1 {
-		return fmt.Errorf("need nodes file as argument")
+		return errors.New("need nodes file as argument")
 	}
 	nodesFile := ctx.Args().First()
 	var inputSet nodeSet
@ -336,7 +337,7 @@ func listen(ctx *cli.Context, ln *enode.LocalNode) *net.UDPConn {
 }

 func parseBootnodes(ctx *cli.Context) ([]*enode.Node, error) {
-	s := params.RinkebyBootnodes
+	s := params.MainnetBootnodes
 	if ctx.IsSet(bootnodesFlag.Name) {
 		input := ctx.String(bootnodesFlag.Name)
 		if input == "" {
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@ -17,6 +17,7 @@
 package main

 import (
+	"errors"
 	"fmt"
 	"time"

@ -98,7 +99,7 @@ func discv5Resolve(ctx *cli.Context) error {

 func discv5Crawl(ctx *cli.Context) error {
 	if ctx.NArg() < 1 {
-		return fmt.Errorf("need nodes file as argument")
+		return errors.New("need nodes file as argument")
 	}
 	nodesFile := ctx.Args().First()
 	var inputSet nodeSet
--- a/cmd/devp2p/dns_cloudflare.go
+++ b/cmd/devp2p/dns_cloudflare.go
@ -18,6 +18,7 @@ package main

 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"

@ -48,7 +49,7 @@ type cloudflareClient struct {
 func newCloudflareClient(ctx *cli.Context) *cloudflareClient {
 	token := ctx.String(cloudflareTokenFlag.Name)
 	if token == "" {
-		exit(fmt.Errorf("need cloudflare API token to proceed"))
+		exit(errors.New("need cloudflare API token to proceed"))
 	}
 	api, err := cloudflare.NewWithAPIToken(token)
 	if err != nil {
--- a/cmd/devp2p/dns_route53.go
+++ b/cmd/devp2p/dns_route53.go
@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"sort"
 	"strconv"
 	"strings"
 	"time"
@ -33,6 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
 	"github.com/urfave/cli/v2"
+	"golang.org/x/exp/slices"
 )

 const (
@ -81,7 +81,7 @@ func newRoute53Client(ctx *cli.Context) *route53Client {
 	akey := ctx.String(route53AccessKeyFlag.Name)
 	asec := ctx.String(route53AccessSecretFlag.Name)
 	if akey == "" || asec == "" {
-		exit(fmt.Errorf("need Route53 Access Key ID and secret to proceed"))
+		exit(errors.New("need Route53 Access Key ID and secret to proceed"))
 	}
 	creds := aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(akey, asec, ""))
 	cfg, err := config.LoadDefaultConfig(context.Background(), config.WithCredentialsProvider(creds))
@ -288,11 +288,17 @@ func makeDeletionChanges(records map[string]recordSet, keep map[string]string) [
 // sortChanges ensures DNS changes are in leaf-added -> root-changed -> leaf-deleted order.
 func sortChanges(changes []types.Change) {
 	score := map[string]int{"CREATE": 1, "UPSERT": 2, "DELETE": 3}
-	sort.Slice(changes, func(i, j int) bool {
-		if changes[i].Action == changes[j].Action {
-			return *changes[i].ResourceRecordSet.Name < *changes[j].ResourceRecordSet.Name
+	slices.SortFunc(changes, func(a, b types.Change) int {
+		if a.Action == b.Action {
+			return strings.Compare(*a.ResourceRecordSet.Name, *b.ResourceRecordSet.Name)
 		}
-		return score[string(changes[i].Action)] < score[string(changes[j].Action)]
+		if score[string(a.Action)] < score[string(b.Action)] {
+			return -1
+		}
+		if score[string(a.Action)] > score[string(b.Action)] {
+			return 1
+		}
+		return 0
 	})
 }

--- a/cmd/devp2p/dnscmd.go
+++ b/cmd/devp2p/dnscmd.go
@ -19,6 +19,7 @@ package main
 import (
 	"crypto/ecdsa"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@ -147,7 +148,7 @@ func dnsSync(ctx *cli.Context) error {

 func dnsSign(ctx *cli.Context) error {
 	if ctx.NArg() < 2 {
-		return fmt.Errorf("need tree definition directory and key file as arguments")
+		return errors.New("need tree definition directory and key file as arguments")
 	}
 	var (
 		defdir  = ctx.Args().Get(0)
@ -201,7 +202,7 @@ func directoryName(dir string) string {
 // dnsToTXT performs dnsTXTCommand.
 func dnsToTXT(ctx *cli.Context) error {
 	if ctx.NArg() < 1 {
-		return fmt.Errorf("need tree definition directory as argument")
+		return errors.New("need tree definition directory as argument")
 	}
 	output := ctx.Args().Get(1)
 	if output == "" {
@ -218,7 +219,7 @@ func dnsToTXT(ctx *cli.Context) error {
 // dnsToCloudflare performs dnsCloudflareCommand.
 func dnsToCloudflare(ctx *cli.Context) error {
 	if ctx.NArg() != 1 {
-		return fmt.Errorf("need tree definition directory as argument")
+		return errors.New("need tree definition directory as argument")
 	}
 	domain, t, err := loadTreeDefinitionForExport(ctx.Args().Get(0))
 	if err != nil {
@ -231,7 +232,7 @@ func dnsToCloudflare(ctx *cli.Context) error {
 // dnsToRoute53 performs dnsRoute53Command.
 func dnsToRoute53(ctx *cli.Context) error {
 	if ctx.NArg() != 1 {
-		return fmt.Errorf("need tree definition directory as argument")
+		return errors.New("need tree definition directory as argument")
 	}
 	domain, t, err := loadTreeDefinitionForExport(ctx.Args().Get(0))
 	if err != nil {
@ -244,7 +245,7 @@ func dnsToRoute53(ctx *cli.Context) error {
 // dnsNukeRoute53 performs dnsRoute53NukeCommand.
 func dnsNukeRoute53(ctx *cli.Context) error {
 	if ctx.NArg() != 1 {
-		return fmt.Errorf("need domain name as argument")
+		return errors.New("need domain name as argument")
 	}
 	client := newRoute53Client(ctx)
 	return client.deleteDomain(ctx.Args().First())
@ -363,10 +364,10 @@ func loadTreeDefinitionForExport(dir string) (domain string, t *dnsdisc.Tree, er
 // tree's signature if valid.
 func ensureValidTreeSignature(t *dnsdisc.Tree, pubkey *ecdsa.PublicKey, sig string) error {
 	if sig == "" {
-		return fmt.Errorf("missing signature, run 'devp2p dns sign' first")
+		return errors.New("missing signature, run 'devp2p dns sign' first")
 	}
 	if err := t.SetSignature(pubkey, sig); err != nil {
-		return fmt.Errorf("invalid signature on tree, run 'devp2p dns sign' to update it")
+		return errors.New("invalid signature on tree, run 'devp2p dns sign' to update it")
 	}
 	return nil
 }
--- a/cmd/devp2p/enrcmd.go
+++ b/cmd/devp2p/enrcmd.go
@ -20,6 +20,7 @@ import (
 	"bytes"
 	"encoding/base64"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"io"
 	"net"
@ -48,7 +49,7 @@ func enrdump(ctx *cli.Context) error {
 	var source string
 	if file := ctx.String(fileFlag.Name); file != "" {
 		if ctx.NArg() != 0 {
-			return fmt.Errorf("can't dump record from command-line argument in -file mode")
+			return errors.New("can't dump record from command-line argument in -file mode")
 		}
 		var b []byte
 		var err error
@ -64,7 +65,7 @@ func enrdump(ctx *cli.Context) error {
 	} else if ctx.NArg() == 1 {
 		source = ctx.Args().First()
 	} else {
-		return fmt.Errorf("need record as argument")
+		return errors.New("need record as argument")
 	}

 	r, err := parseRecord(source)
--- a/cmd/devp2p/internal/ethtest/chain.go
+++ b/cmd/devp2p/internal/ethtest/chain.go
@ -19,6 +19,7 @@ package ethtest
 import (
 	"compress/gzip"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"math/big"
@ -76,7 +77,7 @@ func (c *Chain) RootAt(height int) common.Hash {

 // ForkID gets the fork id of the chain.
 func (c *Chain) ForkID() forkid.ID {
-	return forkid.NewID(c.chainConfig, c.blocks[0].Hash(), uint64(c.Len()), c.blocks[0].Time())
+	return forkid.NewID(c.chainConfig, c.blocks[0], uint64(c.Len()), c.blocks[0].Time())
 }

 // Shorten returns a copy chain of a desired height from the imported
@ -98,7 +99,7 @@ func (c *Chain) Head() *types.Block {

 func (c *Chain) GetHeaders(req *GetBlockHeaders) ([]*types.Header, error) {
 	if req.Amount < 1 {
-		return nil, fmt.Errorf("no block headers requested")
+		return nil, errors.New("no block headers requested")
 	}

 	headers := make([]*types.Header, req.Amount)
--- a/cmd/devp2p/internal/ethtest/helpers.go
+++ b/cmd/devp2p/internal/ethtest/helpers.go
@ -17,6 +17,7 @@
 package ethtest

 import (
+	"errors"
 	"fmt"
 	"net"
 	"reflect"
@ -185,7 +186,7 @@ loop:
 	}
 	// make sure eth protocol version is set for negotiation
 	if c.negotiatedProtoVersion == 0 {
-		return nil, fmt.Errorf("eth protocol version must be set in Conn")
+		return nil, errors.New("eth protocol version must be set in Conn")
 	}
 	if status == nil {
 		// default status message
--- a/cmd/devp2p/internal/ethtest/suite_test.go
+++ b/cmd/devp2p/internal/ethtest/suite_test.go
@ -109,15 +109,13 @@ func setupGeth(stack *node.Node) error {
 	}

 	backend, err := eth.New(stack, &ethconfig.Config{
-		Genesis:                 &chain.genesis,
-		NetworkId:               chain.genesis.Config.ChainID.Uint64(), // 19763
-		DatabaseCache:           10,
-		TrieCleanCache:          10,
-		TrieCleanCacheJournal:   "",
-		TrieCleanCacheRejournal: 60 * time.Minute,
-		TrieDirtyCache:          16,
-		TrieTimeout:             60 * time.Minute,
-		SnapshotCache:           10,
+		Genesis:        &chain.genesis,
+		NetworkId:      chain.genesis.Config.ChainID.Uint64(), // 19763
+		DatabaseCache:  10,
+		TrieCleanCache: 10,
+		TrieDirtyCache: 16,
+		TrieTimeout:    60 * time.Minute,
+		SnapshotCache:  10,
 	})
 	if err != nil {
 		return err
--- a/cmd/devp2p/internal/ethtest/transaction.go
+++ b/cmd/devp2p/internal/ethtest/transaction.go
@ -17,6 +17,7 @@
 package ethtest

 import (
+	"errors"
 	"fmt"
 	"math/big"
 	"strings"
@ -39,7 +40,7 @@ func (s *Suite) sendSuccessfulTxs(t *utesting.T) error {
 	}
 	for i, tx := range tests {
 		if tx == nil {
-			return fmt.Errorf("could not find tx to send")
+			return errors.New("could not find tx to send")
 		}
 		t.Logf("Testing tx propagation %d: sending tx %v %v %v\n", i, tx.Hash().String(), tx.GasPrice(), tx.Gas())
 		// get previous tx if exists for reference in case of old tx propagation
@ -348,7 +349,7 @@ func generateTxs(s *Suite, numTxs int) (map[common.Hash]common.Hash, []*types.Tr

 	nextTx := getNextTxFromChain(s)
 	if nextTx == nil {
-		return nil, nil, fmt.Errorf("failed to get the next transaction")
+		return nil, nil, errors.New("failed to get the next transaction")
 	}
 	gas := nextTx.Gas()

@ -357,7 +358,7 @@ func generateTxs(s *Suite, numTxs int) (map[common.Hash]common.Hash, []*types.Tr
 	for i := 0; i < numTxs; i++ {
 		tx := generateTx(s.chain.chainConfig, nonce, gas)
 		if tx == nil {
-			return nil, nil, fmt.Errorf("failed to get the next transaction")
+			return nil, nil, errors.New("failed to get the next transaction")
 		}
 		txHashMap[tx.Hash()] = tx.Hash()
 		txs[i] = tx
--- a/cmd/devp2p/internal/ethtest/types.go
+++ b/cmd/devp2p/internal/ethtest/types.go
@ -18,6 +18,7 @@ package ethtest

 import (
 	"crypto/ecdsa"
+	"errors"
 	"fmt"
 	"time"

@ -286,5 +287,5 @@ func (c *Conn) ReadSnap(id uint64) (Message, error) {
 		}
 		return snpMsg.(Message), nil
 	}
-	return nil, fmt.Errorf("request timed out")
+	return nil, errors.New("request timed out")
 }
--- a/cmd/devp2p/internal/v4test/discv4tests.go
+++ b/cmd/devp2p/internal/v4test/discv4tests.go
@ -19,6 +19,7 @@ package v4test
 import (
 	"bytes"
 	"crypto/rand"
+	"errors"
 	"fmt"
 	"net"
 	"time"
@ -119,7 +120,7 @@ func (te *testenv) checkPingPong(pingHash []byte) error {
 // and a PING. The two packets do not have to be in any particular order.
 func (te *testenv) checkPong(reply v4wire.Packet, pingHash []byte) error {
 	if reply == nil {
-		return fmt.Errorf("expected PONG reply, got nil")
+		return errors.New("expected PONG reply, got nil")
 	}
 	if reply.Kind() != v4wire.PongPacket {
 		return fmt.Errorf("expected PONG reply, got %v %v", reply.Name(), reply)
--- a/cmd/devp2p/keycmd.go
+++ b/cmd/devp2p/keycmd.go
@ -17,6 +17,7 @@
 package main

 import (
+	"errors"
 	"fmt"
 	"net"

@ -86,7 +87,7 @@ var (

 func genkey(ctx *cli.Context) error {
 	if ctx.NArg() != 1 {
-		return fmt.Errorf("need key file as argument")
+		return errors.New("need key file as argument")
 	}
 	file := ctx.Args().Get(0)

@ -126,7 +127,7 @@ func keyToRecord(ctx *cli.Context) error {

 func makeRecord(ctx *cli.Context) (*enode.Node, error) {
 	if ctx.NArg() != 1 {
-		return nil, fmt.Errorf("need key file as argument")
+		return nil, errors.New("need key file as argument")
 	}

 	var (
--- a/cmd/devp2p/nodeset.go
+++ b/cmd/devp2p/nodeset.go
@ -21,11 +21,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"sort"
 	"time"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/p2p/enode"
+	"golang.org/x/exp/slices"
 )

 const jsonIndent = "    "
@ -77,8 +77,8 @@ func (ns nodeSet) nodes() []*enode.Node {
 		result = append(result, n.N)
 	}
 	// Sort by ID.
-	sort.Slice(result, func(i, j int) bool {
-		return bytes.Compare(result[i].ID().Bytes(), result[j].ID().Bytes()) < 0
+	slices.SortFunc(result, func(a, b *enode.Node) int {
+		return bytes.Compare(a.ID().Bytes(), b.ID().Bytes())
 	})
 	return result
 }
@ -103,8 +103,14 @@ func (ns nodeSet) topN(n int) nodeSet {
 	for _, v := range ns {
 		byscore = append(byscore, v)
 	}
-	sort.Slice(byscore, func(i, j int) bool {
-		return byscore[i].Score >= byscore[j].Score
+	slices.SortFunc(byscore, func(a, b nodeJSON) int {
+		if a.Score > b.Score {
+			return -1
+		}
+		if a.Score < b.Score {
+			return 1
+		}
+		return 0
 	})
 	result := make(nodeSet, n)
 	for _, v := range byscore[:n] {
--- a/cmd/devp2p/nodesetcmd.go
+++ b/cmd/devp2p/nodesetcmd.go
@ -25,6 +25,7 @@ import (
 	"strings"
 	"time"

+	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/forkid"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/ethereum/go-ethereum/params"
@ -59,7 +60,7 @@ var (

 func nodesetInfo(ctx *cli.Context) error {
 	if ctx.NArg() < 1 {
-		return fmt.Errorf("need nodes file as argument")
+		return errors.New("need nodes file as argument")
 	}

 	ns := loadNodesJSON(ctx.Args().First())
@ -98,7 +99,7 @@ func showAttributeCounts(ns nodeSet) {

 func nodesetFilter(ctx *cli.Context) error {
 	if ctx.NArg() < 1 {
-		return fmt.Errorf("need nodes file as argument")
+		return errors.New("need nodes file as argument")
 	}
 	// Parse -limit.
 	limit, err := parseFilterLimit(ctx.Args().Tail())
@ -228,13 +229,13 @@ func ethFilter(args []string) (nodeFilter, error) {
 	var filter forkid.Filter
 	switch args[0] {
 	case "mainnet":
-		filter = forkid.NewStaticFilter(params.MainnetChainConfig, params.MainnetGenesisHash)
-	case "rinkeby":
-		filter = forkid.NewStaticFilter(params.RinkebyChainConfig, params.RinkebyGenesisHash)
+		filter = forkid.NewStaticFilter(params.MainnetChainConfig, core.DefaultGenesisBlock().ToBlock())
 	case "goerli":
-		filter = forkid.NewStaticFilter(params.GoerliChainConfig, params.GoerliGenesisHash)
+		filter = forkid.NewStaticFilter(params.GoerliChainConfig, core.DefaultGoerliGenesisBlock().ToBlock())
 	case "sepolia":
-		filter = forkid.NewStaticFilter(params.SepoliaChainConfig, params.SepoliaGenesisHash)
+		filter = forkid.NewStaticFilter(params.SepoliaChainConfig, core.DefaultSepoliaGenesisBlock().ToBlock())
+	case "holesky":
+		filter = forkid.NewStaticFilter(params.HoleskyChainConfig, core.DefaultHoleskyGenesisBlock().ToBlock())
 	default:
 		return nil, fmt.Errorf("unknown network %q", args[0])
 	}
--- a/cmd/devp2p/rlpxcmd.go
+++ b/cmd/devp2p/rlpxcmd.go
@ -17,6 +17,7 @@
 package main

 import (
+	"errors"
 	"fmt"
 	"net"

@ -91,7 +92,7 @@ func rlpxPing(ctx *cli.Context) error {
 	case 1:
 		var msg []p2p.DiscReason
 		if rlp.DecodeBytes(data, &msg); len(msg) == 0 {
-			return fmt.Errorf("invalid disconnect message")
+			return errors.New("invalid disconnect message")
 		}
 		return fmt.Errorf("received disconnect message: %v", msg[0])
 	default:
--- a/cmd/evm/README.md
+++ b/cmd/evm/README.md
@ -342,7 +342,7 @@ To make `t8n` apply these, the following inputs are required:
  - For ethash, it is `5000000000000000000` `wei`,
  - If this is not defined, mining rewards are not applied,
  - A value of `0` is valid, and causes accounts to be 'touched'.
- For each ommer, the tool needs to be given an `addres\` and a `delta`. This
+- For each ommer, the tool needs to be given an `address\` and a `delta`. This
  is done via the `ommers` field in `env`.

 Note: the tool does not verify that e.g. the normal uncle rules apply,
--- a/cmd/evm/blockrunner.go
+++ b/cmd/evm/blockrunner.go
@ -22,6 +22,9 @@ import (
 	"fmt"
 	"os"

+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/tests"
 	"github.com/urfave/cli/v2"
@ -42,7 +45,16 @@ func blockTestCmd(ctx *cli.Context) error {
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
 	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
-
+	var tracer vm.EVMLogger
+	// Configure the EVM logger
+	if ctx.Bool(MachineFlag.Name) {
+		tracer = logger.NewJSONLogger(&logger.Config{
+			EnableMemory:     !ctx.Bool(DisableMemoryFlag.Name),
+			DisableStack:     ctx.Bool(DisableStackFlag.Name),
+			DisableStorage:   ctx.Bool(DisableStorageFlag.Name),
+			EnableReturnData: !ctx.Bool(DisableReturnDataFlag.Name),
+		}, os.Stderr)
+	}
 	// Load the test content from the input file
 	src, err := os.ReadFile(ctx.Args().First())
 	if err != nil {
@ -53,7 +65,7 @@ func blockTestCmd(ctx *cli.Context) error {
 		return err
 	}
 	for i, test := range tests {
-		if err := test.Run(false); err != nil {
+		if err := test.Run(false, rawdb.HashScheme, tracer); err != nil {
 			return fmt.Errorf("test %v: %w", i, err)
 		}
 	}
--- a/cmd/evm/internal/t8ntool/block.go
+++ b/cmd/evm/internal/t8ntool/block.go
@ -171,18 +171,18 @@ func (i *bbInput) sealClique(block *types.Block) (*types.Block, error) {
 	// If any clique value overwrites an explicit header value, fail
 	// to avoid silently building a block with unexpected values.
 	if i.Header.Extra != nil {
-		return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data"))
+		return nil, NewError(ErrorConfig, errors.New("sealing with clique will overwrite provided extra data"))
 	}
 	header := block.Header()
 	if i.Clique.Voted != nil {
 		if i.Header.Coinbase != nil {
-			return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase"))
+			return nil, NewError(ErrorConfig, errors.New("sealing with clique and voting will overwrite provided coinbase"))
 		}
 		header.Coinbase = *i.Clique.Voted
 	}
 	if i.Clique.Authorize != nil {
 		if i.Header.Nonce != nil {
-			return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce"))
+			return nil, NewError(ErrorConfig, errors.New("sealing with clique and voting will overwrite provided nonce"))
 		}
 		if *i.Clique.Authorize {
 			header.Nonce = [8]byte{}
@ -306,7 +306,7 @@ func readInput(ctx *cli.Context) (*bbInput, error) {
 	return inputData, nil
 }

-// dispatchOutput writes the output data to either stderr or stdout, or to the specified
+// dispatchBlock writes the output data to either stderr or stdout, or to the specified
 // files
 func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error {
 	raw, _ := rlp.EncodeToBytes(block)
--- a/cmd/evm/internal/t8ntool/execution.go
+++ b/cmd/evm/internal/t8ntool/execution.go
@ -19,12 +19,12 @@ package t8ntool
 import (
 	"fmt"
 	"math/big"
-	"os"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/consensus/misc"
+	"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
@ -47,17 +47,19 @@ type Prestate struct {
 // ExecutionResult contains the execution status after running a state test, any
 // error that might have occurred and a dump of the final state if requested.
 type ExecutionResult struct {
-	StateRoot       common.Hash           `json:"stateRoot"`
-	TxRoot          common.Hash           `json:"txRoot"`
-	ReceiptRoot     common.Hash           `json:"receiptsRoot"`
-	LogsHash        common.Hash           `json:"logsHash"`
-	Bloom           types.Bloom           `json:"logsBloom"        gencodec:"required"`
-	Receipts        types.Receipts        `json:"receipts"`
-	Rejected        []*rejectedTx         `json:"rejected,omitempty"`
-	Difficulty      *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"`
-	GasUsed         math.HexOrDecimal64   `json:"gasUsed"`
-	BaseFee         *math.HexOrDecimal256 `json:"currentBaseFee,omitempty"`
-	WithdrawalsRoot *common.Hash          `json:"withdrawalsRoot,omitempty"`
+	StateRoot            common.Hash           `json:"stateRoot"`
+	TxRoot               common.Hash           `json:"txRoot"`
+	ReceiptRoot          common.Hash           `json:"receiptsRoot"`
+	LogsHash             common.Hash           `json:"logsHash"`
+	Bloom                types.Bloom           `json:"logsBloom"        gencodec:"required"`
+	Receipts             types.Receipts        `json:"receipts"`
+	Rejected             []*rejectedTx         `json:"rejected,omitempty"`
+	Difficulty           *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"`
+	GasUsed              math.HexOrDecimal64   `json:"gasUsed"`
+	BaseFee              *math.HexOrDecimal256 `json:"currentBaseFee,omitempty"`
+	WithdrawalsRoot      *common.Hash          `json:"withdrawalsRoot,omitempty"`
+	CurrentExcessBlobGas *math.HexOrDecimal64  `json:"currentExcessBlobGas,omitempty"`
+	CurrentBlobGasUsed   *math.HexOrDecimal64  `json:"currentBlobGasUsed,omitempty"`
 }

 type ommer struct {
@ -67,37 +69,44 @@ type ommer struct {

 //go:generate go run github.com/fjl/gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go
 type stEnv struct {
-	Coinbase         common.Address                      `json:"currentCoinbase"   gencodec:"required"`
-	Difficulty       *big.Int                            `json:"currentDifficulty"`
-	Random           *big.Int                            `json:"currentRandom"`
-	ParentDifficulty *big.Int                            `json:"parentDifficulty"`
-	ParentBaseFee    *big.Int                            `json:"parentBaseFee,omitempty"`
-	ParentGasUsed    uint64                              `json:"parentGasUsed,omitempty"`
-	ParentGasLimit   uint64                              `json:"parentGasLimit,omitempty"`
-	GasLimit         uint64                              `json:"currentGasLimit"   gencodec:"required"`
-	Number           uint64                              `json:"currentNumber"     gencodec:"required"`
-	Timestamp        uint64                              `json:"currentTimestamp"  gencodec:"required"`
-	ParentTimestamp  uint64                              `json:"parentTimestamp,omitempty"`
-	BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-	Ommers           []ommer                             `json:"ommers,omitempty"`
-	Withdrawals      []*types.Withdrawal                 `json:"withdrawals,omitempty"`
-	BaseFee          *big.Int                            `json:"currentBaseFee,omitempty"`
-	ParentUncleHash  common.Hash                         `json:"parentUncleHash"`
+	Coinbase              common.Address                      `json:"currentCoinbase"   gencodec:"required"`
+	Difficulty            *big.Int                            `json:"currentDifficulty"`
+	Random                *big.Int                            `json:"currentRandom"`
+	ParentDifficulty      *big.Int                            `json:"parentDifficulty"`
+	ParentBaseFee         *big.Int                            `json:"parentBaseFee,omitempty"`
+	ParentGasUsed         uint64                              `json:"parentGasUsed,omitempty"`
+	ParentGasLimit        uint64                              `json:"parentGasLimit,omitempty"`
+	GasLimit              uint64                              `json:"currentGasLimit"   gencodec:"required"`
+	Number                uint64                              `json:"currentNumber"     gencodec:"required"`
+	Timestamp             uint64                              `json:"currentTimestamp"  gencodec:"required"`
+	ParentTimestamp       uint64                              `json:"parentTimestamp,omitempty"`
+	BlockHashes           map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
+	Ommers                []ommer                             `json:"ommers,omitempty"`
+	Withdrawals           []*types.Withdrawal                 `json:"withdrawals,omitempty"`
+	BaseFee               *big.Int                            `json:"currentBaseFee,omitempty"`
+	ParentUncleHash       common.Hash                         `json:"parentUncleHash"`
+	ExcessBlobGas         *uint64                             `json:"excessBlobGas,omitempty"`
+	ParentExcessBlobGas   *uint64                             `json:"parentExcessBlobGas,omitempty"`
+	ParentBlobGasUsed     *uint64                             `json:"parentBlobGasUsed,omitempty"`
+	ParentBeaconBlockRoot *common.Hash                        `json:"parentBeaconBlockRoot"`
 }

 type stEnvMarshaling struct {
-	Coinbase         common.UnprefixedAddress
-	Difficulty       *math.HexOrDecimal256
-	Random           *math.HexOrDecimal256
-	ParentDifficulty *math.HexOrDecimal256
-	ParentBaseFee    *math.HexOrDecimal256
-	ParentGasUsed    math.HexOrDecimal64
-	ParentGasLimit   math.HexOrDecimal64
-	GasLimit         math.HexOrDecimal64
-	Number           math.HexOrDecimal64
-	Timestamp        math.HexOrDecimal64
-	ParentTimestamp  math.HexOrDecimal64
-	BaseFee          *math.HexOrDecimal256
+	Coinbase            common.UnprefixedAddress
+	Difficulty          *math.HexOrDecimal256
+	Random              *math.HexOrDecimal256
+	ParentDifficulty    *math.HexOrDecimal256
+	ParentBaseFee       *math.HexOrDecimal256
+	ParentGasUsed       math.HexOrDecimal64
+	ParentGasLimit      math.HexOrDecimal64
+	GasLimit            math.HexOrDecimal64
+	Number              math.HexOrDecimal64
+	Timestamp           math.HexOrDecimal64
+	ParentTimestamp     math.HexOrDecimal64
+	BaseFee             *math.HexOrDecimal256
+	ExcessBlobGas       *math.HexOrDecimal64
+	ParentExcessBlobGas *math.HexOrDecimal64
+	ParentBlobGasUsed   *math.HexOrDecimal64
 }

 type rejectedTx struct {
@ -154,6 +163,19 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		rnd := common.BigToHash(pre.Env.Random)
 		vmContext.Random = &rnd
 	}
+	// If excessBlobGas is defined, add it to the vmContext.
+	if pre.Env.ExcessBlobGas != nil {
+		vmContext.ExcessBlobGas = pre.Env.ExcessBlobGas
+	} else {
+		// If it is not explicitly defined, but we have the parent values, we try
+		// to calculate it ourselves.
+		parentExcessBlobGas := pre.Env.ParentExcessBlobGas
+		parentBlobGasUsed := pre.Env.ParentBlobGasUsed
+		if parentExcessBlobGas != nil && parentBlobGasUsed != nil {
+			excessBlobGas := eip4844.CalcExcessBlobGas(*parentExcessBlobGas, *parentBlobGasUsed)
+			vmContext.ExcessBlobGas = &excessBlobGas
+		}
+	}
 	// If DAO is supported/enabled, we need to handle it here. In geth 'proper', it's
 	// done in StateProcessor.Process(block, ...), right before transactions are applied.
 	if chainConfig.DAOForkSupport &&
@ -161,8 +183,18 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		chainConfig.DAOForkBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
 		misc.ApplyDAOHardFork(statedb)
 	}
-
+	if beaconRoot := pre.Env.ParentBeaconBlockRoot; beaconRoot != nil {
+		evm := vm.NewEVM(vmContext, vm.TxContext{}, statedb, chainConfig, vmConfig)
+		core.ProcessBeaconBlockRoot(*beaconRoot, evm, statedb)
+	}
+	var blobGasUsed uint64
 	for i, tx := range txs {
+		if tx.Type() == types.BlobTxType && vmContext.ExcessBlobGas == nil {
+			errMsg := "blob tx used but field env.ExcessBlobGas missing"
+			log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", errMsg)
+			rejectedTxs = append(rejectedTxs, &rejectedTx{i, errMsg})
+			continue
+		}
 		msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee)
 		if err != nil {
 			log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err)
@ -192,6 +224,9 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 			gaspool.SetGas(prevGas)
 			continue
 		}
+		if tx.Type() == types.BlobTxType {
+			blobGasUsed += params.BlobTxBlobGasPerBlob
+		}
 		includedTxs = append(includedTxs, tx)
 		if hashError != nil {
 			return nil, nil, NewError(ErrorMissingBlockhash, hashError)
@ -240,7 +275,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	if miningReward >= 0 {
 		// Add mining reward. The mining reward may be `0`, which only makes a difference in the cases
 		// where
-		// - the coinbase suicided, or
+		// - the coinbase self-destructed, or
 		// - there are only 'bad' transactions, which aren't executed. In those cases,
 		//   the coinbase gets no txfee, so isn't created, and thus needs to be touched
 		var (
@ -267,9 +302,8 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		statedb.AddBalance(w.Address, amount)
 	}
 	// Commit block
-	root, err := statedb.Commit(chainConfig.IsEIP158(vmContext.BlockNumber))
+	root, err := statedb.Commit(vmContext.BlockNumber.Uint64(), chainConfig.IsEIP158(vmContext.BlockNumber))
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Could not commit state: %v", err)
 		return nil, nil, NewError(ErrorEVM, fmt.Errorf("could not commit state: %v", err))
 	}
 	execRs := &ExecutionResult{
@ -288,6 +322,16 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		h := types.DeriveSha(types.Withdrawals(pre.Env.Withdrawals), trie.NewStackTrie(nil))
 		execRs.WithdrawalsRoot = &h
 	}
+	if vmContext.ExcessBlobGas != nil {
+		execRs.CurrentExcessBlobGas = (*math.HexOrDecimal64)(vmContext.ExcessBlobGas)
+		execRs.CurrentBlobGasUsed = (*math.HexOrDecimal64)(&blobGasUsed)
+	}
+	// Re-create statedb instance with new root upon the updated database
+	// for accessing latest states.
+	statedb, err = state.New(root, statedb.Database(), nil)
+	if err != nil {
+		return nil, nil, NewError(ErrorEVM, fmt.Errorf("could not reopen state: %v", err))
+	}
 	return statedb, execRs, nil
 }

@ -303,7 +347,7 @@ func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB
 		}
 	}
 	// Commit and re-open to start with a clean state.
-	root, _ := statedb.Commit(false)
+	root, _ := statedb.Commit(0, false)
 	statedb, _ = state.New(root, sdb, nil)
 	return statedb
 }
--- a/cmd/evm/internal/t8ntool/gen_stenv.go
+++ b/cmd/evm/internal/t8ntool/gen_stenv.go
@ -17,22 +17,26 @@ var _ = (*stEnvMarshaling)(nil)
 // MarshalJSON marshals as JSON.
 func (s stEnv) MarshalJSON() ([]byte, error) {
 	type stEnv struct {
-		Coinbase         common.UnprefixedAddress            `json:"currentCoinbase"   gencodec:"required"`
-		Difficulty       *math.HexOrDecimal256               `json:"currentDifficulty"`
-		Random           *math.HexOrDecimal256               `json:"currentRandom"`
-		ParentDifficulty *math.HexOrDecimal256               `json:"parentDifficulty"`
-		ParentBaseFee    *math.HexOrDecimal256               `json:"parentBaseFee,omitempty"`
-		ParentGasUsed    math.HexOrDecimal64                 `json:"parentGasUsed,omitempty"`
-		ParentGasLimit   math.HexOrDecimal64                 `json:"parentGasLimit,omitempty"`
-		GasLimit         math.HexOrDecimal64                 `json:"currentGasLimit"   gencodec:"required"`
-		Number           math.HexOrDecimal64                 `json:"currentNumber"     gencodec:"required"`
-		Timestamp        math.HexOrDecimal64                 `json:"currentTimestamp"  gencodec:"required"`
-		ParentTimestamp  math.HexOrDecimal64                 `json:"parentTimestamp,omitempty"`
-		BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-		Ommers           []ommer                             `json:"ommers,omitempty"`
-		Withdrawals      []*types.Withdrawal                 `json:"withdrawals,omitempty"`
-		BaseFee          *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
-		ParentUncleHash  common.Hash                         `json:"parentUncleHash"`
+		Coinbase              common.UnprefixedAddress            `json:"currentCoinbase"   gencodec:"required"`
+		Difficulty            *math.HexOrDecimal256               `json:"currentDifficulty"`
+		Random                *math.HexOrDecimal256               `json:"currentRandom"`
+		ParentDifficulty      *math.HexOrDecimal256               `json:"parentDifficulty"`
+		ParentBaseFee         *math.HexOrDecimal256               `json:"parentBaseFee,omitempty"`
+		ParentGasUsed         math.HexOrDecimal64                 `json:"parentGasUsed,omitempty"`
+		ParentGasLimit        math.HexOrDecimal64                 `json:"parentGasLimit,omitempty"`
+		GasLimit              math.HexOrDecimal64                 `json:"currentGasLimit"   gencodec:"required"`
+		Number                math.HexOrDecimal64                 `json:"currentNumber"     gencodec:"required"`
+		Timestamp             math.HexOrDecimal64                 `json:"currentTimestamp"  gencodec:"required"`
+		ParentTimestamp       math.HexOrDecimal64                 `json:"parentTimestamp,omitempty"`
+		BlockHashes           map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
+		Ommers                []ommer                             `json:"ommers,omitempty"`
+		Withdrawals           []*types.Withdrawal                 `json:"withdrawals,omitempty"`
+		BaseFee               *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
+		ParentUncleHash       common.Hash                         `json:"parentUncleHash"`
+		ExcessBlobGas         *math.HexOrDecimal64                `json:"excessBlobGas,omitempty"`
+		ParentExcessBlobGas   *math.HexOrDecimal64                `json:"parentExcessBlobGas,omitempty"`
+		ParentBlobGasUsed     *math.HexOrDecimal64                `json:"parentBlobGasUsed,omitempty"`
+		ParentBeaconBlockRoot *common.Hash                        `json:"parentBeaconBlockRoot"`
 	}
 	var enc stEnv
 	enc.Coinbase = common.UnprefixedAddress(s.Coinbase)
@ -51,28 +55,36 @@ func (s stEnv) MarshalJSON() ([]byte, error) {
 	enc.Withdrawals = s.Withdrawals
 	enc.BaseFee = (*math.HexOrDecimal256)(s.BaseFee)
 	enc.ParentUncleHash = s.ParentUncleHash
+	enc.ExcessBlobGas = (*math.HexOrDecimal64)(s.ExcessBlobGas)
+	enc.ParentExcessBlobGas = (*math.HexOrDecimal64)(s.ParentExcessBlobGas)
+	enc.ParentBlobGasUsed = (*math.HexOrDecimal64)(s.ParentBlobGasUsed)
+	enc.ParentBeaconBlockRoot = s.ParentBeaconBlockRoot
 	return json.Marshal(&enc)
 }

 // UnmarshalJSON unmarshals from JSON.
 func (s *stEnv) UnmarshalJSON(input []byte) error {
 	type stEnv struct {
-		Coinbase         *common.UnprefixedAddress           `json:"currentCoinbase"   gencodec:"required"`
-		Difficulty       *math.HexOrDecimal256               `json:"currentDifficulty"`
-		Random           *math.HexOrDecimal256               `json:"currentRandom"`
-		ParentDifficulty *math.HexOrDecimal256               `json:"parentDifficulty"`
-		ParentBaseFee    *math.HexOrDecimal256               `json:"parentBaseFee,omitempty"`
-		ParentGasUsed    *math.HexOrDecimal64                `json:"parentGasUsed,omitempty"`
-		ParentGasLimit   *math.HexOrDecimal64                `json:"parentGasLimit,omitempty"`
-		GasLimit         *math.HexOrDecimal64                `json:"currentGasLimit"   gencodec:"required"`
-		Number           *math.HexOrDecimal64                `json:"currentNumber"     gencodec:"required"`
-		Timestamp        *math.HexOrDecimal64                `json:"currentTimestamp"  gencodec:"required"`
-		ParentTimestamp  *math.HexOrDecimal64                `json:"parentTimestamp,omitempty"`
-		BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-		Ommers           []ommer                             `json:"ommers,omitempty"`
-		Withdrawals      []*types.Withdrawal                 `json:"withdrawals,omitempty"`
-		BaseFee          *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
-		ParentUncleHash  *common.Hash                        `json:"parentUncleHash"`
+		Coinbase              *common.UnprefixedAddress           `json:"currentCoinbase"   gencodec:"required"`
+		Difficulty            *math.HexOrDecimal256               `json:"currentDifficulty"`
+		Random                *math.HexOrDecimal256               `json:"currentRandom"`
+		ParentDifficulty      *math.HexOrDecimal256               `json:"parentDifficulty"`
+		ParentBaseFee         *math.HexOrDecimal256               `json:"parentBaseFee,omitempty"`
+		ParentGasUsed         *math.HexOrDecimal64                `json:"parentGasUsed,omitempty"`
+		ParentGasLimit        *math.HexOrDecimal64                `json:"parentGasLimit,omitempty"`
+		GasLimit              *math.HexOrDecimal64                `json:"currentGasLimit"   gencodec:"required"`
+		Number                *math.HexOrDecimal64                `json:"currentNumber"     gencodec:"required"`
+		Timestamp             *math.HexOrDecimal64                `json:"currentTimestamp"  gencodec:"required"`
+		ParentTimestamp       *math.HexOrDecimal64                `json:"parentTimestamp,omitempty"`
+		BlockHashes           map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
+		Ommers                []ommer                             `json:"ommers,omitempty"`
+		Withdrawals           []*types.Withdrawal                 `json:"withdrawals,omitempty"`
+		BaseFee               *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
+		ParentUncleHash       *common.Hash                        `json:"parentUncleHash"`
+		ExcessBlobGas         *math.HexOrDecimal64                `json:"excessBlobGas,omitempty"`
+		ParentExcessBlobGas   *math.HexOrDecimal64                `json:"parentExcessBlobGas,omitempty"`
+		ParentBlobGasUsed     *math.HexOrDecimal64                `json:"parentBlobGasUsed,omitempty"`
+		ParentBeaconBlockRoot *common.Hash                        `json:"parentBeaconBlockRoot"`
 	}
 	var dec stEnv
 	if err := json.Unmarshal(input, &dec); err != nil {
@ -130,5 +142,17 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 	if dec.ParentUncleHash != nil {
 		s.ParentUncleHash = *dec.ParentUncleHash
 	}
+	if dec.ExcessBlobGas != nil {
+		s.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
+	}
+	if dec.ParentExcessBlobGas != nil {
+		s.ParentExcessBlobGas = (*uint64)(dec.ParentExcessBlobGas)
+	}
+	if dec.ParentBlobGasUsed != nil {
+		s.ParentBlobGasUsed = (*uint64)(dec.ParentBlobGasUsed)
+	}
+	if dec.ParentBeaconBlockRoot != nil {
+		s.ParentBeaconBlockRoot = dec.ParentBeaconBlockRoot
+	}
 	return nil
 }
--- a/cmd/evm/internal/t8ntool/transaction.go
+++ b/cmd/evm/internal/t8ntool/transaction.go
@ -140,7 +140,7 @@ func Transaction(ctx *cli.Context) error {
 		}
 		// Check intrinsic gas
 		if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil,
-			chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(0)); err != nil {
+			chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(new(big.Int), 0)); err != nil {
 			r.Error = err
 			results = append(results, r)
 			continue
@ -172,7 +172,7 @@ func Transaction(ctx *cli.Context) error {
 			r.Error = errors.New("gas * maxFeePerGas exceeds 256 bits")
 		}
 		// Check whether the init code size has been exceeded.
-		if chainConfig.IsShanghai(0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {
+		if chainConfig.IsShanghai(new(big.Int), 0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {
 			r.Error = errors.New("max initcode size exceeded")
 		}
 		results = append(results, r)
--- a/cmd/evm/internal/t8ntool/transition.go
+++ b/cmd/evm/internal/t8ntool/transition.go
@ -28,7 +28,7 @@ import (

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/consensus/misc"
+	"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@ -192,105 +192,20 @@ func Transition(ctx *cli.Context) error {
 	// Set the chain id
 	chainConfig.ChainID = big.NewInt(ctx.Int64(ChainIDFlag.Name))

-	var txsWithKeys []*txWithKey
-	if txStr != stdinSelector {
-		inFile, err := os.Open(txStr)
-		if err != nil {
-			return NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err))
-		}
-		defer inFile.Close()
-		decoder := json.NewDecoder(inFile)
-		if strings.HasSuffix(txStr, ".rlp") {
-			var body hexutil.Bytes
-			if err := decoder.Decode(&body); err != nil {
-				return err
-			}
-			var txs types.Transactions
-			if err := rlp.DecodeBytes(body, &txs); err != nil {
-				return err
-			}
-			for _, tx := range txs {
-				txsWithKeys = append(txsWithKeys, &txWithKey{
-					key: nil,
-					tx:  tx,
-				})
-			}
-		} else {
-			if err := decoder.Decode(&txsWithKeys); err != nil {
-				return NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs-file: %v", err))
-			}
-		}
-	} else {
-		if len(inputData.TxRlp) > 0 {
-			// Decode the body of already signed transactions
-			body := common.FromHex(inputData.TxRlp)
-			var txs types.Transactions
-			if err := rlp.DecodeBytes(body, &txs); err != nil {
-				return err
-			}
-			for _, tx := range txs {
-				txsWithKeys = append(txsWithKeys, &txWithKey{
-					key: nil,
-					tx:  tx,
-				})
-			}
-		} else {
-			// JSON encoded transactions
-			txsWithKeys = inputData.Txs
-		}
+	if txs, err = loadTransactions(txStr, inputData, prestate.Env, chainConfig); err != nil {
+		return err
 	}
-	// We may have to sign the transactions.
-	signer := types.MakeSigner(chainConfig, big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp)
-
-	if txs, err = signUnsignedTransactions(txsWithKeys, signer); err != nil {
-		return NewError(ErrorJson, fmt.Errorf("failed signing transactions: %v", err))
+	if err := applyLondonChecks(&prestate.Env, chainConfig); err != nil {
+		return err
 	}
-	// Sanity check, to not `panic` in state_transition
-	if chainConfig.IsLondon(big.NewInt(int64(prestate.Env.Number))) {
-		if prestate.Env.BaseFee != nil {
-			// Already set, base fee has precedent over parent base fee.
-		} else if prestate.Env.ParentBaseFee != nil && prestate.Env.Number != 0 {
-			parent := &types.Header{
-				Number:   new(big.Int).SetUint64(prestate.Env.Number - 1),
-				BaseFee:  prestate.Env.ParentBaseFee,
-				GasUsed:  prestate.Env.ParentGasUsed,
-				GasLimit: prestate.Env.ParentGasLimit,
-			}
-			prestate.Env.BaseFee = misc.CalcBaseFee(chainConfig, parent)
-		} else {
-			return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
-		}
+	if err := applyShanghaiChecks(&prestate.Env, chainConfig); err != nil {
+		return err
 	}
-	if chainConfig.IsShanghai(prestate.Env.Number) && prestate.Env.Withdrawals == nil {
-		return NewError(ErrorConfig, errors.New("Shanghai config but missing 'withdrawals' in env section"))
+	if err := applyMergeChecks(&prestate.Env, chainConfig); err != nil {
+		return err
 	}
-	isMerged := chainConfig.TerminalTotalDifficulty != nil && chainConfig.TerminalTotalDifficulty.BitLen() == 0
-	env := prestate.Env
-	if isMerged {
-		// post-merge:
-		// - random must be supplied
-		// - difficulty must be zero
-		switch {
-		case env.Random == nil:
-			return NewError(ErrorConfig, errors.New("post-merge requires currentRandom to be defined in env"))
-		case env.Difficulty != nil && env.Difficulty.BitLen() != 0:
-			return NewError(ErrorConfig, errors.New("post-merge difficulty must be zero (or omitted) in env"))
-		}
-		prestate.Env.Difficulty = nil
-	} else if env.Difficulty == nil {
-		// pre-merge:
-		// If difficulty was not provided by caller, we need to calculate it.
-		switch {
-		case env.ParentDifficulty == nil:
-			return NewError(ErrorConfig, errors.New("currentDifficulty was not provided, and cannot be calculated due to missing parentDifficulty"))
-		case env.Number == 0:
-			return NewError(ErrorConfig, errors.New("currentDifficulty needs to be provided for block number 0"))
-		case env.Timestamp <= env.ParentTimestamp:
-			return NewError(ErrorConfig, fmt.Errorf("currentDifficulty cannot be calculated -- currentTime (%d) needs to be after parent time (%d)",
-				env.Timestamp, env.ParentTimestamp))
-		}
-		prestate.Env.Difficulty = calcDifficulty(chainConfig, env.Number, env.Timestamp,
-			env.ParentTimestamp, env.ParentDifficulty, env.ParentUncleHash)
+	if err := applyCancunChecks(&prestate.Env, chainConfig); err != nil {
+		return err
 	}
 	// Run the test and aggregate the result
 	s, result, err := prestate.Apply(vmConfig, chainConfig, txs, ctx.Int64(RewardFlag.Name), getTracer)
@ -358,38 +273,157 @@ func (t *txWithKey) UnmarshalJSON(input []byte) error {
 // and secondly to read them with the standard tx json format
 func signUnsignedTransactions(txs []*txWithKey, signer types.Signer) (types.Transactions, error) {
 	var signedTxs []*types.Transaction
-	for i, txWithKey := range txs {
-		tx := txWithKey.tx
-		key := txWithKey.key
-		v, r, s := tx.RawSignatureValues()
-		if key != nil && v.BitLen()+r.BitLen()+s.BitLen() == 0 {
-			// This transaction needs to be signed
-			var (
-				signed *types.Transaction
-				err    error
-			)
-			if txWithKey.protected {
-				signed, err = types.SignTx(tx, signer, key)
-			} else {
-				signed, err = types.SignTx(tx, types.FrontierSigner{}, key)
-			}
-			if err != nil {
-				return nil, NewError(ErrorJson, fmt.Errorf("tx %d: failed to sign tx: %v", i, err))
-			}
-			signedTxs = append(signedTxs, signed)
-		} else {
+	for i, tx := range txs {
+		var (
+			v, r, s = tx.tx.RawSignatureValues()
+			signed  *types.Transaction
+			err     error
+		)
+		if tx.key == nil || v.BitLen()+r.BitLen()+s.BitLen() != 0 {
 			// Already signed
-			signedTxs = append(signedTxs, tx)
+			signedTxs = append(signedTxs, tx.tx)
+			continue
 		}
+		// This transaction needs to be signed
+		if tx.protected {
+			signed, err = types.SignTx(tx.tx, signer, tx.key)
+		} else {
+			signed, err = types.SignTx(tx.tx, types.FrontierSigner{}, tx.key)
+		}
+		if err != nil {
+			return nil, NewError(ErrorJson, fmt.Errorf("tx %d: failed to sign tx: %v", i, err))
+		}
+		signedTxs = append(signedTxs, signed)
 	}
 	return signedTxs, nil
 }

+func loadTransactions(txStr string, inputData *input, env stEnv, chainConfig *params.ChainConfig) (types.Transactions, error) {
+	var txsWithKeys []*txWithKey
+	var signed types.Transactions
+	if txStr != stdinSelector {
+		data, err := os.ReadFile(txStr)
+		if err != nil {
+			return nil, NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err))
+		}
+		if strings.HasSuffix(txStr, ".rlp") { // A file containing an rlp list
+			var body hexutil.Bytes
+			if err := json.Unmarshal(data, &body); err != nil {
+				return nil, err
+			}
+			// Already signed transactions
+			if err := rlp.DecodeBytes(body, &signed); err != nil {
+				return nil, err
+			}
+			return signed, nil
+		}
+		if err := json.Unmarshal(data, &txsWithKeys); err != nil {
+			return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs-file: %v", err))
+		}
+	} else {
+		if len(inputData.TxRlp) > 0 {
+			// Decode the body of already signed transactions
+			body := common.FromHex(inputData.TxRlp)
+			// Already signed transactions
+			if err := rlp.DecodeBytes(body, &signed); err != nil {
+				return nil, err
+			}
+			return signed, nil
+		}
+		// JSON encoded transactions
+		txsWithKeys = inputData.Txs
+	}
+	// We may have to sign the transactions.
+	signer := types.MakeSigner(chainConfig, big.NewInt(int64(env.Number)), env.Timestamp)
+	return signUnsignedTransactions(txsWithKeys, signer)
+}
+
+func applyLondonChecks(env *stEnv, chainConfig *params.ChainConfig) error {
+	if !chainConfig.IsLondon(big.NewInt(int64(env.Number))) {
+		return nil
+	}
+	// Sanity check, to not `panic` in state_transition
+	if env.BaseFee != nil {
+		// Already set, base fee has precedent over parent base fee.
+		return nil
+	}
+	if env.ParentBaseFee == nil || env.Number == 0 {
+		return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
+	}
+	env.BaseFee = eip1559.CalcBaseFee(chainConfig, &types.Header{
+		Number:   new(big.Int).SetUint64(env.Number - 1),
+		BaseFee:  env.ParentBaseFee,
+		GasUsed:  env.ParentGasUsed,
+		GasLimit: env.ParentGasLimit,
+	})
+	return nil
+}
+
+func applyShanghaiChecks(env *stEnv, chainConfig *params.ChainConfig) error {
+	if !chainConfig.IsShanghai(big.NewInt(int64(env.Number)), env.Timestamp) {
+		return nil
+	}
+	if env.Withdrawals == nil {
+		return NewError(ErrorConfig, errors.New("Shanghai config but missing 'withdrawals' in env section"))
+	}
+	return nil
+}
+
+func applyMergeChecks(env *stEnv, chainConfig *params.ChainConfig) error {
+	isMerged := chainConfig.TerminalTotalDifficulty != nil && chainConfig.TerminalTotalDifficulty.BitLen() == 0
+	if !isMerged {
+		// pre-merge: If difficulty was not provided by caller, we need to calculate it.
+		if env.Difficulty != nil {
+			// already set
+			return nil
+		}
+		switch {
+		case env.ParentDifficulty == nil:
+			return NewError(ErrorConfig, errors.New("currentDifficulty was not provided, and cannot be calculated due to missing parentDifficulty"))
+		case env.Number == 0:
+			return NewError(ErrorConfig, errors.New("currentDifficulty needs to be provided for block number 0"))
+		case env.Timestamp <= env.ParentTimestamp:
+			return NewError(ErrorConfig, fmt.Errorf("currentDifficulty cannot be calculated -- currentTime (%d) needs to be after parent time (%d)",
+				env.Timestamp, env.ParentTimestamp))
+		}
+		env.Difficulty = calcDifficulty(chainConfig, env.Number, env.Timestamp,
+			env.ParentTimestamp, env.ParentDifficulty, env.ParentUncleHash)
+		return nil
+	}
+	// post-merge:
+	// - random must be supplied
+	// - difficulty must be zero
+	switch {
+	case env.Random == nil:
+		return NewError(ErrorConfig, errors.New("post-merge requires currentRandom to be defined in env"))
+	case env.Difficulty != nil && env.Difficulty.BitLen() != 0:
+		return NewError(ErrorConfig, errors.New("post-merge difficulty must be zero (or omitted) in env"))
+	}
+	env.Difficulty = nil
+	return nil
+}
+
+func applyCancunChecks(env *stEnv, chainConfig *params.ChainConfig) error {
+	if !chainConfig.IsCancun(big.NewInt(int64(env.Number)), env.Timestamp) {
+		env.ParentBeaconBlockRoot = nil // un-set it if it has been set too early
+		return nil
+	}
+	// Post-cancun
+	// We require EIP-4788 beacon root to be set in the env
+	if env.ParentBeaconBlockRoot == nil {
+		return NewError(ErrorConfig, errors.New("post-cancun env requires parentBeaconBlockRoot to be set"))
+	}
+	return nil
+}
+
 type Alloc map[common.Address]core.GenesisAccount

 func (g Alloc) OnRoot(common.Hash) {}

-func (g Alloc) OnAccount(addr common.Address, dumpAccount state.DumpAccount) {
+func (g Alloc) OnAccount(addr *common.Address, dumpAccount state.DumpAccount) {
+	if addr == nil {
+		return
+	}
 	balance, _ := new(big.Int).SetString(dumpAccount.Balance, 10)
 	var storage map[common.Hash]common.Hash
 	if dumpAccount.Storage != nil {
@ -404,7 +438,7 @@ func (g Alloc) OnAccount(addr common.Address, dumpAccount state.DumpAccount) {
 		Balance: balance,
 		Nonce:   dumpAccount.Nonce,
 	}
-	g[addr] = genesisAccount
+	g[*addr] = genesisAccount
 }

 // saveFile marshals the object to the given file
--- a/cmd/evm/runner.go
+++ b/cmd/evm/runner.go
@ -42,6 +42,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
+	"github.com/ethereum/go-ethereum/trie/triedb/hashdb"
 	"github.com/urfave/cli/v2"
 )

@ -128,6 +129,7 @@ func runCmd(ctx *cli.Context) error {
 		receiver      = common.BytesToAddress([]byte("receiver"))
 		genesisConfig *core.Genesis
 		preimages     = ctx.Bool(DumpFlag.Name)
+		blobHashes    []common.Hash // TODO (MariusVanDerWijden) implement blob hashes in state tests
 	)
 	if ctx.Bool(MachineFlag.Name) {
 		tracer = logger.NewJSONLogger(logconfig, os.Stdout)
@ -141,12 +143,23 @@ func runCmd(ctx *cli.Context) error {
 		gen := readGenesis(ctx.String(GenesisFlag.Name))
 		genesisConfig = gen
 		db := rawdb.NewMemoryDatabase()
-		genesis := gen.MustCommit(db)
-		sdb := state.NewDatabaseWithConfig(db, &trie.Config{Preimages: preimages})
+		triedb := trie.NewDatabase(db, &trie.Config{
+			Preimages: preimages,
+			HashDB:    hashdb.Defaults,
+		})
+		defer triedb.Close()
+		genesis := gen.MustCommit(db, triedb)
+		sdb := state.NewDatabaseWithNodeDB(db, triedb)
 		statedb, _ = state.New(genesis.Root(), sdb, nil)
 		chainConfig = gen.Config
 	} else {
-		sdb := state.NewDatabaseWithConfig(rawdb.NewMemoryDatabase(), &trie.Config{Preimages: preimages})
+		db := rawdb.NewMemoryDatabase()
+		triedb := trie.NewDatabase(db, &trie.Config{
+			Preimages: preimages,
+			HashDB:    hashdb.Defaults,
+		})
+		defer triedb.Close()
+		sdb := state.NewDatabaseWithNodeDB(db, triedb)
 		statedb, _ = state.New(types.EmptyRootHash, sdb, nil)
 		genesisConfig = new(core.Genesis)
 	}
@ -217,6 +230,7 @@ func runCmd(ctx *cli.Context) error {
 		Time:        genesisConfig.Timestamp,
 		Coinbase:    genesisConfig.Coinbase,
 		BlockNumber: new(big.Int).SetUint64(genesisConfig.Number),
+		BlobHashes:  blobHashes,
 		EVMConfig: vm.Config{
 			Tracer: tracer,
 		},
@ -278,8 +292,7 @@ func runCmd(ctx *cli.Context) error {
 	output, leftOverGas, stats, err := timedExec(bench, execFunc)

 	if ctx.Bool(DumpFlag.Name) {
-		statedb.Commit(true)
-		statedb.IntermediateRoot(true)
+		statedb.Commit(genesisConfig.Number, true)
 		fmt.Println(string(statedb.Dump(nil)))
 	}

--- a/cmd/evm/staterunner.go
+++ b/cmd/evm/staterunner.go
@ -17,13 +17,15 @@
 package main

 import (
+	"bufio"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"

 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/state/snapshot"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/ethereum/go-ethereum/log"
@ -34,7 +36,7 @@ import (
 var stateTestCommand = &cli.Command{
 	Action:    stateTestCmd,
 	Name:      "statetest",
-	Usage:     "executes the given state tests",
+	Usage:     "Executes the given state tests. Filenames can be fed via standard input (batch mode) or as an argument (one-off execution).",
 	ArgsUsage: "<file>",
 }

@ -50,9 +52,6 @@ type StatetestResult struct {
 }

 func stateTestCmd(ctx *cli.Context) error {
-	if len(ctx.Args().First()) == 0 {
-		return errors.New("path-to-test argument required")
-	}
 	// Configure the go-ethereum logger
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
 	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
@ -65,66 +64,66 @@ func stateTestCmd(ctx *cli.Context) error {
 		DisableStorage:   ctx.Bool(DisableStorageFlag.Name),
 		EnableReturnData: !ctx.Bool(DisableReturnDataFlag.Name),
 	}
-	var (
-		tracer   vm.EVMLogger
-		debugger *logger.StructLogger
-	)
+	var cfg vm.Config
 	switch {
 	case ctx.Bool(MachineFlag.Name):
-		tracer = logger.NewJSONLogger(config, os.Stderr)
+		cfg.Tracer = logger.NewJSONLogger(config, os.Stderr)

 	case ctx.Bool(DebugFlag.Name):
-		debugger = logger.NewStructLogger(config)
-		tracer = debugger
-
-	default:
-		debugger = logger.NewStructLogger(config)
+		cfg.Tracer = logger.NewStructLogger(config)
 	}
 	// Load the test content from the input file
-	src, err := os.ReadFile(ctx.Args().First())
+	if len(ctx.Args().First()) != 0 {
+		return runStateTest(ctx.Args().First(), cfg, ctx.Bool(MachineFlag.Name), ctx.Bool(DumpFlag.Name))
+	}
+	// Read filenames from stdin and execute back-to-back
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		fname := scanner.Text()
+		if len(fname) == 0 {
+			return nil
+		}
+		if err := runStateTest(fname, cfg, ctx.Bool(MachineFlag.Name), ctx.Bool(DumpFlag.Name)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// runStateTest loads the state-test given by fname, and executes the test.
+func runStateTest(fname string, cfg vm.Config, jsonOut, dump bool) error {
+	src, err := os.ReadFile(fname)
 	if err != nil {
 		return err
 	}
 	var tests map[string]tests.StateTest
-	if err = json.Unmarshal(src, &tests); err != nil {
+	if err := json.Unmarshal(src, &tests); err != nil {
 		return err
 	}
 	// Iterate over all the tests, run them and aggregate the results
-	cfg := vm.Config{
-		Tracer: tracer,
-	}
 	results := make([]StatetestResult, 0, len(tests))
 	for key, test := range tests {
 		for _, st := range test.Subtests() {
 			// Run the test and aggregate the result
 			result := &StatetestResult{Name: key, Fork: st.Fork, Pass: true}
-			_, s, err := test.Run(st, cfg, false)
-			// print state root for evmlab tracing
-			if s != nil {
-				root := s.IntermediateRoot(false)
-				result.Root = &root
-				if ctx.Bool(MachineFlag.Name) {
-					fmt.Fprintf(os.Stderr, "{\"stateRoot\": \"%#x\"}\n", root)
+			test.Run(st, cfg, false, rawdb.HashScheme, func(err error, snaps *snapshot.Tree, state *state.StateDB) {
+				if state != nil {
+					root := state.IntermediateRoot(false)
+					result.Root = &root
+					if jsonOut {
+						fmt.Fprintf(os.Stderr, "{\"stateRoot\": \"%#x\"}\n", root)
+					}
 				}
-			}
-			if err != nil {
-				// Test failed, mark as so and dump any state to aid debugging
-				result.Pass, result.Error = false, err.Error()
-				if ctx.Bool(DumpFlag.Name) && s != nil {
-					dump := s.RawDump(nil)
-					result.State = &dump
+				if err != nil {
+					// Test failed, mark as so and dump any state to aid debugging
+					result.Pass, result.Error = false, err.Error()
+					if dump {
+						dump := state.RawDump(nil)
+						result.State = &dump
+					}
 				}
-			}
-
+			})
 			results = append(results, *result)
-
-			// Print any structured logs collected
-			if ctx.Bool(DebugFlag.Name) {
-				if debugger != nil {
-					fmt.Fprintln(os.Stderr, "#### TRACE ####")
-					logger.WriteTrace(os.Stderr, debugger.StructLogs())
-				}
-			}
 		}
 	}
 	out, _ := json.MarshalIndent(results, "", "  ")
--- a/cmd/evm/t8n_test.go
+++ b/cmd/evm/t8n_test.go
@ -259,6 +259,22 @@ func TestT8n(t *testing.T) {
 			output: t8nOutput{alloc: true, result: true},
 			expOut: "exp.json",
 		},
+		{ // Cancun tests
+			base: "./testdata/28",
+			input: t8nInput{
+				"alloc.json", "txs.rlp", "env.json", "Cancun", "",
+			},
+			output: t8nOutput{alloc: true, result: true},
+			expOut: "exp.json",
+		},
+		{ // More cancun tests
+			base: "./testdata/29",
+			input: t8nInput{
+				"alloc.json", "txs.json", "env.json", "Cancun", "",
+			},
+			output: t8nOutput{alloc: true, result: true},
+			expOut: "exp.json",
+		},
 	} {
 		args := []string{"t8n"}
 		args = append(args, tc.output.get()...)
--- a/cmd/evm/testdata/13/readme.md
+++ b/cmd/evm/testdata/13/readme.md
@ -1,4 +1,4 @@
 ## Input transactions in RLP form

-This testdata folder is used to examplify how transaction input can be provided in rlp form. 
+This testdata folder is used to exemplify how transaction input can be provided in rlp form. 
 Please see the README in `evm` folder for how this is performed. 
--- a/cmd/evm/testdata/2/readme.md
+++ b/cmd/evm/testdata/2/readme.md
@ -1 +1 @@
-These files examplify a selfdestruct to the `0`-address. 
+These files exemplify a selfdestruct to the `0`-address. 
--- a/cmd/evm/testdata/23/readme.md
+++ b/cmd/evm/testdata/23/readme.md
@ -1 +1 @@
-These files examplify how to sign a transaction using the pre-EIP155 scheme. 
+These files exemplify how to sign a transaction using the pre-EIP155 scheme. 
--- a/cmd/evm/testdata/28/alloc.json
+++ b/cmd/evm/testdata/28/alloc.json
@ -0,0 +1,16 @@
+{
+  "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+    "balance" : "0x016345785d8a0000",
+    "code" : "0x",
+    "nonce" : "0x00",
+    "storage" : {
+    }
+  },
+  "0xb94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+    "balance" : "0x016345785d8a0000",
+    "code" : "0x60004960015500",
+    "nonce" : "0x00",
+    "storage" : {
+    }
+  }
+}
--- a/cmd/evm/testdata/28/env.json
+++ b/cmd/evm/testdata/28/env.json
@ -0,0 +1,23 @@
+{
+    "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+    "currentNumber" : "0x01",
+    "currentTimestamp" : "0x079e",
+    "currentGasLimit" : "0x7fffffffffffffff",
+    "previousHash" : "0x3a9b485972e7353edd9152712492f0c58d89ef80623686b6bf947a4a6dce6cb6",
+    "currentBlobGasUsed" : "0x00",
+    "parentTimestamp" : "0x03b6",
+    "parentDifficulty" : "0x00",
+    "parentUncleHash" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "currentRandom" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "withdrawals" : [
+    ],
+    "parentBaseFee" : "0x0a",
+    "parentGasUsed" : "0x00",
+    "parentGasLimit" : "0x7fffffffffffffff",
+    "parentExcessBlobGas" : "0x00",
+    "parentBlobGasUsed" : "0x00",
+    "blockHashes" : {
+        "0" : "0x3a9b485972e7353edd9152712492f0c58d89ef80623686b6bf947a4a6dce6cb6"
+    },
+    "parentBeaconBlockRoot": "0x0000beac00beac00beac00beac00beac00beac00beac00beac00beac00beac00"
+}
--- a/cmd/evm/testdata/28/exp.json
+++ b/cmd/evm/testdata/28/exp.json
@ -0,0 +1,47 @@
+{
+  "alloc": {
+    "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba": {
+      "balance": "0x150ca"
+    },
+    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+      "balance": "0x16345785d80c3a9",
+      "nonce": "0x1"
+    },
+    "0xb94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+      "code": "0x60004960015500",
+      "storage": {
+        "0x0000000000000000000000000000000000000000000000000000000000000001": "0x01a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"
+      },
+      "balance": "0x16345785d8a0000"
+    }
+  },
+  "result": {
+    "stateRoot": "0xa40cb3fab01848e922a48bd24191815df9f721ad4b60376edac75161517663e8",
+    "txRoot": "0x4409cc4b699384ba5f8248d92b784713610c5ff9c1de51e9239da0dac76de9ce",
+    "receiptsRoot": "0xbff643da765981266133094092d98c81d2ac8e9a83a7bbda46c3d736f1f874ac",
+    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "receipts": [
+      {
+        "type": "0x3",
+        "root": "0x",
+        "status": "0x1",
+        "cumulativeGasUsed": "0xa865",
+        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "logs": null,
+        "transactionHash": "0x7508d7139d002a4b3a26a4f12dec0d87cb46075c78bf77a38b569a133b509262",
+        "contractAddress": "0x0000000000000000000000000000000000000000",
+        "gasUsed": "0xa865",
+        "effectiveGasPrice": null,
+        "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "transactionIndex": "0x0"
+      }
+    ],
+    "currentDifficulty": null,
+    "gasUsed": "0xa865",
+    "currentBaseFee": "0x9",
+    "withdrawalsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "currentExcessBlobGas": "0x0",
+    "currentBlobGasUsed": "0x20000"
+  }
+}
--- a/cmd/evm/testdata/28/txs.rlp
+++ b/cmd/evm/testdata/28/txs.rlp
@ -0,0 +1 @@
+"0xf88bb88903f8860180026483061a8094b94f5374fce5edbc8e2a8697c15331677e6ebf0b8080c00ae1a001a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d801a025e16bb498552165016751911c3608d79000ab89dc3100776e729e6ea13091c7a03acacff7fc0cff6eda8a927dec93ca17765e1ee6cbc06c5954ce102e097c01d2"
--- a/cmd/evm/testdata/29/alloc.json
+++ b/cmd/evm/testdata/29/alloc.json
@ -0,0 +1,16 @@
+{
+  "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b" : {
+    "balance" : "0x016345785d8a0000",
+    "code" : "0x",
+    "nonce" : "0x00",
+    "storage" : {
+    }
+  },
+  "0xbEac00dDB15f3B6d645C48263dC93862413A222D" : {
+    "balance" : "0x1",
+    "code" : "0x3373fffffffffffffffffffffffffffffffffffffffe14604457602036146024575f5ffd5b620180005f350680545f35146037575f5ffd5b6201800001545f5260205ff35b6201800042064281555f359062018000015500",
+    "nonce" : "0x00",
+    "storage" : {
+    }
+  }
+}
--- a/cmd/evm/testdata/29/env.json
+++ b/cmd/evm/testdata/29/env.json
@ -0,0 +1,20 @@
+{
+    "currentCoinbase" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+    "currentNumber" : "0x01",
+    "currentTimestamp" : "0x079e",
+    "currentGasLimit" : "0x7fffffffffffffff",
+    "previousHash" : "0x3a9b485972e7353edd9152712492f0c58d89ef80623686b6bf947a4a6dce6cb6",
+    "currentBlobGasUsed" : "0x00",
+    "parentTimestamp" : "0x03b6",
+    "parentDifficulty" : "0x00",
+    "parentUncleHash" : "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "currentRandom" : "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "withdrawals" : [
+    ],
+    "parentBaseFee" : "0x0a",
+    "parentGasUsed" : "0x00",
+    "parentGasLimit" : "0x7fffffffffffffff",
+    "parentExcessBlobGas" : "0x00",
+    "parentBlobGasUsed" : "0x00",
+    "parentBeaconBlockRoot": "0x0000beac00beac00beac00beac00beac00beac00beac00beac00beac00beac00"
+}
--- a/cmd/evm/testdata/29/exp.json
+++ b/cmd/evm/testdata/29/exp.json
@ -0,0 +1,45 @@
+{
+  "alloc": {
+    "0xbeac00ddb15f3b6d645c48263dc93862413a222d": {
+      "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604457602036146024575f5ffd5b620180005f350680545f35146037575f5ffd5b6201800001545f5260205ff35b6201800042064281555f359062018000015500",
+      "storage": {
+        "0x000000000000000000000000000000000000000000000000000000000000079e": "0x000000000000000000000000000000000000000000000000000000000000079e",
+        "0x000000000000000000000000000000000000000000000000000000000001879e": "0x0000beac00beac00beac00beac00beac00beac00beac00beac00beac00beac00"
+      },
+      "balance": "0x1"
+    },
+    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+      "balance": "0x16345785d871db8",
+      "nonce": "0x1"
+    }
+  },
+  "result": {
+    "stateRoot": "0x2db9f6bc233e8fd0af2d8023404493a19b37d9d69ace71f4e73158851fced574",
+    "txRoot": "0x248074fabe112f7d93917f292b64932394f835bb98da91f21501574d58ec92ab",
+    "receiptsRoot": "0xf78dfb743fbd92ade140711c8bbc542b5e307f0ab7984eff35d751969fe57efa",
+    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "receipts": [
+      {
+        "type": "0x2",
+        "root": "0x",
+        "status": "0x1",
+        "cumulativeGasUsed": "0x5208",
+        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "logs": null,
+        "transactionHash": "0x84f70aba406a55628a0620f26d260f90aeb6ccc55fed6ec2ac13dd4f727032ed",
+        "contractAddress": "0x0000000000000000000000000000000000000000",
+        "gasUsed": "0x5208",
+        "effectiveGasPrice": null,
+        "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "transactionIndex": "0x0"
+      }
+    ],
+    "currentDifficulty": null,
+    "gasUsed": "0x5208",
+    "currentBaseFee": "0x9",
+    "withdrawalsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "currentExcessBlobGas": "0x0",
+    "currentBlobGasUsed": "0x0"
+  }
+}
--- a/cmd/evm/testdata/29/readme.md
+++ b/cmd/evm/testdata/29/readme.md
@ -0,0 +1,29 @@
+## EIP 4788
+
+This test contains testcases for EIP-4788. The 4788-contract is 
+located at address `0xbeac00ddb15f3b6d645c48263dc93862413a222d`, and this test executes a simple transaction. It also
+implicitly invokes the system tx, which sets calls the contract and sets the 
+storage values
+```
+$ dir=./testdata/29/ && go run . t8n --state.fork=Cancun  --input.alloc=$dir/alloc.json --input.txs=$dir/txs.json --input.env=$dir/env.json --output.alloc=stdout
+INFO [08-15|20:07:56.335] Trie dumping started                     root=ecde45..2af8a7
+INFO [08-15|20:07:56.335] Trie dumping complete                    accounts=2 elapsed="225.848µs"
+INFO [08-15|20:07:56.335] Wrote file                               file=result.json
+{
+  "alloc": {
+    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+      "balance": "0x16345785d871db8",
+      "nonce": "0x1"
+    },
+    "0xbeac00541d49391ed88abf392bfc1f4dea8c4143": {
+      "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604457602036146024575f5ffd5b620180005f350680545f35146037575f5ffd5b6201800001545f5260205ff35b6201800042064281555f359062018000015500",
+      "storage": {
+        "0x000000000000000000000000000000000000000000000000000000000000079e": "0x000000000000000000000000000000000000000000000000000000000000079e",
+        "0x000000000000000000000000000000000000000000000000000000000001879e": "0x0000beac00beac00beac00beac00beac00beac00beac00beac00beac00beac00"
+      },
+      "balance": "0x
+    }
+  }
+}
+
+```
--- a/cmd/evm/testdata/29/txs.json
+++ b/cmd/evm/testdata/29/txs.json
@ -0,0 +1,19 @@
+[
+  {
+    "input" : "0x",
+    "gas" : "0x10000000",
+    "nonce" : "0x0",
+    "to" : "0x1111111111111111111111111111111111111111",
+    "value" : "0x0",
+    "secretKey" : "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
+    "chainId" : "0x1",
+    "type" : "0x2",
+    "v": "0x0",
+    "r": "0x0",
+    "s": "0x0",
+    "maxFeePerGas" : "0xfa0",
+    "maxPriorityFeePerGas" : "0x0",
+    "accessList" : [
+    ]
+  }
+]
--- a/cmd/evm/testdata/3/readme.md
+++ b/cmd/evm/testdata/3/readme.md
@ -1,2 +1,2 @@
-These files examplify a transition where a transaction (excuted on block 5) requests
+These files exemplify a transition where a transaction (executed on block 5) requests
 the blockhash for block `1`. 
--- a/cmd/evm/testdata/4/readme.md
+++ b/cmd/evm/testdata/4/readme.md
@ -1,3 +1,3 @@
-These files examplify a transition where a transaction (excuted on block 5) requests
+These files exemplify a transition where a transaction (executed on block 5) requests
 the blockhash for block `4`, but where the hash for that block is missing. 
 It's expected that executing these should cause `exit` with errorcode `4`.
--- a/cmd/evm/testdata/5/readme.md
+++ b/cmd/evm/testdata/5/readme.md
@ -1 +1 @@
-These files examplify a transition where there are no transcations, two ommers, at block `N-1` (delta 1) and `N-2` (delta 2).
+These files exemplify a transition where there are no transactions, two ommers, at block `N-1` (delta 1) and `N-2` (delta 2).
--- a/cmd/evm/testdata/8/readme.md
+++ b/cmd/evm/testdata/8/readme.md
@ -7,7 +7,7 @@ This test contains testcases for EIP-2930, which uses transactions with access l
 The alloc portion contains one contract (`0x000000000000000000000000000000000000aaaa`), containing the 
 following code: `0x5854505854`: `PC ;SLOAD; POP; PC; SLOAD`.

-Essentialy, this contract does `SLOAD(0)` and `SLOAD(3)`.
+Essentially, this contract does `SLOAD(0)` and `SLOAD(3)`.

 The alloc also contains some funds on `0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b`. 

--- a/cmd/evm/testdata/9/readme.md
+++ b/cmd/evm/testdata/9/readme.md
@ -7,7 +7,7 @@ This test contains testcases for EIP-1559, which uses an new transaction type an
 The alloc portion contains one contract (`0x000000000000000000000000000000000000aaaa`), containing the 
 following code: `0x58585454`: `PC; PC; SLOAD; SLOAD`.

-Essentialy, this contract does `SLOAD(0)` and `SLOAD(1)`.
+Essentially, this contract does `SLOAD(0)` and `SLOAD(1)`.

 The alloc also contains some funds on `0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b`. 

--- a/cmd/evm/transition-test.sh
+++ b/cmd/evm/transition-test.sh
@ -280,7 +280,7 @@ To make `t8n` apply these, the following inputs are required:
  - For ethash, it is `5000000000000000000` `wei`,
  - If this is not defined, mining rewards are not applied,
  - A value of `0` is valid, and causes accounts to be 'touched'.
- For each ommer, the tool needs to be given an `addres\` and a `delta`. This
+- For each ommer, the tool needs to be given an `address\` and a `delta`. This
  is done via the `ommers` field in `env`.

 Note: the tool does not verify that e.g. the normal uncle rules apply,
--- a/cmd/faucet/README.md
+++ b/cmd/faucet/README.md
@ -12,7 +12,6 @@ First things first, the `faucet` needs to connect to an Ethereum network, for wh

 - `-genesis` is a path to a file containing the network `genesis.json`. or using:
  - `-goerli` with the faucet with Görli network config
-  - `-rinkeby` with the faucet with Rinkeby network config
  - `-sepolia` with the faucet with Sepolia network config
 - `-network` is the devp2p network id used during connection
 - `-bootnodes` is a list of `enode://` ids to join the network through
--- a/cmd/faucet/faucet.go
+++ b/cmd/faucet/faucet.go
@ -86,7 +86,6 @@ var (
 	twitterTokenV1Flag = flag.String("twitter.token.v1", "", "Bearer token to authenticate with the v1.1 Twitter API")

 	goerliFlag  = flag.Bool("goerli", false, "Initializes the faucet with Görli network config")
-	rinkebyFlag = flag.Bool("rinkeby", false, "Initializes the faucet with Rinkeby network config")
 	sepoliaFlag = flag.Bool("sepolia", false, "Initializes the faucet with Sepolia network config")
 )

@ -140,7 +139,7 @@ func main() {
 		log.Crit("Failed to render the faucet template", "err", err)
 	}
 	// Load and parse the genesis block requested by the user
-	genesis, err := getGenesis(*genesisFlag, *goerliFlag, *rinkebyFlag, *sepoliaFlag)
+	genesis, err := getGenesis(*genesisFlag, *goerliFlag, *sepoliaFlag)
 	if err != nil {
 		log.Crit("Failed to parse genesis config", "err", err)
 	}
@ -269,11 +268,7 @@ func newFaucet(genesis *core.Genesis, port int, enodes []*enode.Node, network ui
 		}
 	}
 	// Attach to the client and retrieve and interesting metadatas
-	api, err := stack.Attach()
-	if err != nil {
-		stack.Close()
-		return nil, err
-	}
+	api := stack.Attach()
 	client := ethclient.NewClient(api)

 	return &faucet{
@ -880,7 +875,7 @@ func authNoAuth(url string) (string, string, common.Address, error) {
 }

 // getGenesis returns a genesis based on input args
-func getGenesis(genesisFlag string, goerliFlag bool, rinkebyFlag bool, sepoliaFlag bool) (*core.Genesis, error) {
+func getGenesis(genesisFlag string, goerliFlag bool, sepoliaFlag bool) (*core.Genesis, error) {
 	switch {
 	case genesisFlag != "":
 		var genesis core.Genesis
@ -888,11 +883,9 @@ func getGenesis(genesisFlag string, goerliFlag bool, rinkebyFlag bool, sepoliaFl
 		return &genesis, err
 	case goerliFlag:
 		return core.DefaultGoerliGenesisBlock(), nil
-	case rinkebyFlag:
-		return core.DefaultRinkebyGenesisBlock(), nil
 	case sepoliaFlag:
 		return core.DefaultSepoliaGenesisBlock(), nil
 	default:
-		return nil, fmt.Errorf("no genesis flag provided")
+		return nil, errors.New("no genesis flag provided")
 	}
 }
--- a/cmd/geth/attach_test.go
+++ b/cmd/geth/attach_test.go
@ -61,7 +61,7 @@ func TestRemoteDbWithHeaders(t *testing.T) {
 }

 func testReceiveHeaders(t *testing.T, ln net.Listener, gethArgs ...string) {
-	var ok uint32
+	var ok atomic.Uint32
 	server := &http.Server{
 		Addr: "localhost:0",
 		Handler: &testHandler{func(w http.ResponseWriter, r *http.Request) {
@ -72,12 +72,12 @@ func testReceiveHeaders(t *testing.T, ln net.Listener, gethArgs ...string) {
 			if have, want := r.Header.Get("second"), "two"; have != want {
 				t.Fatalf("missing header, have %v want %v", have, want)
 			}
-			atomic.StoreUint32(&ok, 1)
+			ok.Store(1)
 		}}}
 	go server.Serve(ln)
 	defer server.Close()
 	runGeth(t, gethArgs...).WaitExit()
-	if atomic.LoadUint32(&ok) != 1 {
+	if ok.Load() != 1 {
 		t.Fatal("Test fail, expected invocation to succeed")
 	}
 }
--- a/cmd/geth/chaincmd.go
+++ b/cmd/geth/chaincmd.go
@ -39,7 +39,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/trie"
 	"github.com/urfave/cli/v2"
 )

@ -49,7 +48,10 @@ var (
 		Name:      "init",
 		Usage:     "Bootstrap and initialize a new genesis block",
 		ArgsUsage: "<genesisPath>",
-		Flags:     flags.Merge([]cli.Flag{utils.CachePreimagesFlag}, utils.DatabasePathFlags),
+		Flags: flags.Merge([]cli.Flag{
+			utils.CachePreimagesFlag,
+			utils.StateSchemeFlag,
+		}, utils.DatabasePathFlags),
 		Description: `
 The init command initializes a new genesis block and definition for the network.
 This is a destructive action and changes the network in which you will be
@ -94,6 +96,9 @@ if one is set.  Otherwise it prints the genesis from the datadir.`,
 			utils.MetricsInfluxDBBucketFlag,
 			utils.MetricsInfluxDBOrganizationFlag,
 			utils.TxLookupLimitFlag,
+			utils.TransactionHistoryFlag,
+			utils.StateSchemeFlag,
+			utils.StateHistoryFlag,
 		}, utils.DatabasePathFlags),
 		Description: `
 The import command imports blocks from an RLP-encoded form. The form can be one file
@ -110,6 +115,7 @@ processing will proceed even if an individual RLP-file import failure occurs.`,
 		Flags: flags.Merge([]cli.Flag{
 			utils.CacheFlag,
 			utils.SyncModeFlag,
+			utils.StateSchemeFlag,
 		}, utils.DatabasePathFlags),
 		Description: `
 Requires a first argument of the file to write to.
@ -159,6 +165,7 @@ It's deprecated, please use "geth db export" instead.
 			utils.IncludeIncompletesFlag,
 			utils.StartKeyFlag,
 			utils.DumpLimitFlag,
+			utils.StateSchemeFlag,
 		}, utils.DatabasePathFlags),
 		Description: `
 This command dumps out the state for a given block (or latest, if none provided).
@ -195,14 +202,15 @@ func initGenesis(ctx *cli.Context) error {
 		if err != nil {
 			utils.Fatalf("Failed to open database: %v", err)
 		}
-		triedb := trie.NewDatabaseWithConfig(chaindb, &trie.Config{
-			Preimages: ctx.Bool(utils.CachePreimagesFlag.Name),
-		})
+		defer chaindb.Close()
+
+		triedb := utils.MakeTrieDatabase(ctx, chaindb, ctx.Bool(utils.CachePreimagesFlag.Name), false)
+		defer triedb.Close()
+
 		_, hash, err := core.SetupGenesisBlock(chaindb, triedb, genesis)
 		if err != nil {
 			utils.Fatalf("Failed to write genesis block: %v", err)
 		}
-		chaindb.Close()
 		log.Info("Successfully wrote genesis state", "database", name, "hash", hash)
 	}
 	return nil
@ -241,7 +249,7 @@ func dumpGenesis(ctx *cli.Context) error {
 	if ctx.IsSet(utils.DataDirFlag.Name) {
 		utils.Fatalf("no existing datadir at %s", stack.Config().DataDir)
 	}
-	utils.Fatalf("no network preset provided.  no exisiting genesis in the default datadir")
+	utils.Fatalf("no network preset provided, no existing genesis in the default datadir")
 	return nil
 }

@ -261,16 +269,16 @@ func importChain(ctx *cli.Context) error {
 	defer db.Close()

 	// Start periodically gathering memory profiles
-	var peakMemAlloc, peakMemSys uint64
+	var peakMemAlloc, peakMemSys atomic.Uint64
 	go func() {
 		stats := new(runtime.MemStats)
 		for {
 			runtime.ReadMemStats(stats)
-			if atomic.LoadUint64(&peakMemAlloc) < stats.Alloc {
-				atomic.StoreUint64(&peakMemAlloc, stats.Alloc)
+			if peakMemAlloc.Load() < stats.Alloc {
+				peakMemAlloc.Store(stats.Alloc)
 			}
-			if atomic.LoadUint64(&peakMemSys) < stats.Sys {
-				atomic.StoreUint64(&peakMemSys, stats.Sys)
+			if peakMemSys.Load() < stats.Sys {
+				peakMemSys.Store(stats.Sys)
 			}
 			time.Sleep(5 * time.Second)
 		}
@ -303,8 +311,8 @@ func importChain(ctx *cli.Context) error {
 	mem := new(runtime.MemStats)
 	runtime.ReadMemStats(mem)

-	fmt.Printf("Object memory: %.3f MB current, %.3f MB peak\n", float64(mem.Alloc)/1024/1024, float64(atomic.LoadUint64(&peakMemAlloc))/1024/1024)
-	fmt.Printf("System memory: %.3f MB current, %.3f MB peak\n", float64(mem.Sys)/1024/1024, float64(atomic.LoadUint64(&peakMemSys))/1024/1024)
+	fmt.Printf("Object memory: %.3f MB current, %.3f MB peak\n", float64(mem.Alloc)/1024/1024, float64(peakMemAlloc.Load())/1024/1024)
+	fmt.Printf("System memory: %.3f MB current, %.3f MB peak\n", float64(mem.Sys)/1024/1024, float64(peakMemSys.Load())/1024/1024)
 	fmt.Printf("Allocations:   %.3f million\n", float64(mem.Mallocs)/1000000)
 	fmt.Printf("GC pause:      %v\n\n", time.Duration(mem.PauseTotalNs))

@ -465,10 +473,10 @@ func dump(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	config := &trie.Config{
-		Preimages: true, // always enable preimage lookup
-	}
-	state, err := state.New(root, state.NewDatabaseWithConfig(db, config), nil)
+	triedb := utils.MakeTrieDatabase(ctx, db, true, false) // always enable preimage lookup
+	defer triedb.Close()
+
+	state, err := state.New(root, state.NewDatabaseWithNodeDB(db, triedb), nil)
 	if err != nil {
 		return err
 	}
@ -478,7 +486,7 @@ func dump(ctx *cli.Context) error {
 		if conf.OnlyWithAddresses {
 			fmt.Fprintf(os.Stderr, "If you want to include accounts with missing preimages, you need iterative output, since"+
 				" otherwise the accounts will overwrite each other in the resulting mapping.")
-			return fmt.Errorf("incompatible options")
+			return errors.New("incompatible options")
 		}
 		fmt.Println(string(state.Dump(conf)))
 	}
--- a/cmd/geth/config.go
+++ b/cmd/geth/config.go
@ -22,16 +22,17 @@ import (
 	"fmt"
 	"os"
 	"reflect"
+	"runtime"
+	"strings"
 	"unicode"

-	"github.com/urfave/cli/v2"
-
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/external"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/accounts/scwallet"
 	"github.com/ethereum/go-ethereum/accounts/usbwallet"
 	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/eth/catalyst"
 	"github.com/ethereum/go-ethereum/eth/downloader"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
@ -42,6 +43,7 @@ import (
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/naoina/toml"
+	"github.com/urfave/cli/v2"
 )

 var (
@ -170,8 +172,26 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		v := ctx.Uint64(utils.OverrideCancun.Name)
 		cfg.Eth.OverrideCancun = &v
 	}
+	if ctx.IsSet(utils.OverrideVerkle.Name) {
+		v := ctx.Uint64(utils.OverrideVerkle.Name)
+		cfg.Eth.OverrideVerkle = &v
+	}
 	backend, eth := utils.RegisterEthService(stack, &cfg.Eth)

+	// Create gauge with geth system and build information
+	if eth != nil { // The 'eth' backend may be nil in light mode
+		var protos []string
+		for _, p := range eth.Protocols() {
+			protos = append(protos, fmt.Sprintf("%v/%d", p.Name, p.Version))
+		}
+		metrics.NewRegisteredGaugeInfo("geth/info", nil).Update(metrics.GaugeInfoValue{
+			"arch":          runtime.GOARCH,
+			"os":            runtime.GOOS,
+			"version":       cfg.Node.Version,
+			"eth_protocols": strings.Join(protos, ","),
+		})
+	}
+
 	// Configure log filter RPC API.
 	filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth)

@ -189,6 +209,22 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 	if ctx.IsSet(utils.SyncTargetFlag.Name) && cfg.Eth.SyncMode == downloader.FullSync {
 		utils.RegisterFullSyncTester(stack, eth, ctx.Path(utils.SyncTargetFlag.Name))
 	}
+
+	// Start the dev mode if requested, or launch the engine API for
+	// interacting with external consensus client.
+	if ctx.IsSet(utils.DeveloperFlag.Name) {
+		simBeacon, err := catalyst.NewSimulatedBeacon(ctx.Uint64(utils.DeveloperPeriodFlag.Name), eth)
+		if err != nil {
+			utils.Fatalf("failed to register dev mode catalyst service: %v", err)
+		}
+		catalyst.RegisterSimulatedBeaconAPIs(stack, simBeacon)
+		stack.RegisterLifecycle(simBeacon)
+	} else if cfg.Eth.SyncMode != downloader.LightSync {
+		err := catalyst.Register(stack, eth)
+		if err != nil {
+			utils.Fatalf("failed to register catalyst service: %v", err)
+		}
+	}
 	return stack, backend
 }

@ -272,6 +308,10 @@ func deprecated(field string) bool {
 		return true
 	case "ethconfig.Config.EWASMInterpreter":
 		return true
+	case "ethconfig.Config.TrieCleanCacheJournal":
+		return true
+	case "ethconfig.Config.TrieCleanCacheRejournal":
+		return true
 	default:
 		return false
 	}
--- a/cmd/geth/consolecmd.go
+++ b/cmd/geth/consolecmd.go
@ -75,10 +75,7 @@ func localConsole(ctx *cli.Context) error {
 	defer stack.Close()

 	// Attach to the newly started node and create the JavaScript console.
-	client, err := stack.Attach()
-	if err != nil {
-		return fmt.Errorf("failed to attach to the inproc geth: %v", err)
-	}
+	client := stack.Attach()
 	config := console.Config{
 		DataDir: utils.MakeDataDir(ctx),
 		DocRoot: ctx.String(utils.JSpathFlag.Name),
--- a/cmd/geth/consolecmd_test.go
+++ b/cmd/geth/consolecmd_test.go
@ -116,7 +116,7 @@ func TestAttachWelcome(t *testing.T) {
 		waitForEndpoint(t, endpoint, 3*time.Second)
 		testAttachWelcome(t, geth, endpoint, httpAPIs)
 	})
-	geth.ExpectExit()
+	geth.Kill()
 }

 func testAttachWelcome(t *testing.T, geth *testgeth, endpoint, apis string) {
--- a/cmd/geth/dbcmd.go
+++ b/cmd/geth/dbcmd.go
@ -151,6 +151,7 @@ WARNING: This is a low-level operation which may cause database corruption!`,
 		ArgsUsage: "<hex-encoded state root> <hex-encoded account hash> <hex-encoded storage trie root> <hex-encoded start (optional)> <int max elements (optional)>",
 		Flags: flags.Merge([]cli.Flag{
 			utils.SyncModeFlag,
+			utils.StateSchemeFlag,
 		}, utils.NetworkFlags, utils.DatabasePathFlags),
 		Description: "This command looks up the specified database key from the database.",
 	}
@ -482,6 +483,9 @@ func dbDumpTrie(ctx *cli.Context) error {
 	db := utils.MakeChainDatabase(ctx, stack, true)
 	defer db.Close()

+	triedb := utils.MakeTrieDatabase(ctx, db, false, true)
+	defer triedb.Close()
+
 	var (
 		state   []byte
 		storage []byte
@ -515,12 +519,16 @@ func dbDumpTrie(ctx *cli.Context) error {
 		}
 	}
 	id := trie.StorageTrieID(common.BytesToHash(state), common.BytesToHash(account), common.BytesToHash(storage))
-	theTrie, err := trie.New(id, trie.NewDatabase(db))
+	theTrie, err := trie.New(id, triedb)
+	if err != nil {
+		return err
+	}
+	trieIt, err := theTrie.NodeIterator(start)
 	if err != nil {
 		return err
 	}
 	var count int64
-	it := trie.NewIterator(theTrie.NodeIterator(start))
+	it := trie.NewIterator(trieIt)
 	for it.Next() {
 		if max > 0 && count == max {
 			fmt.Printf("Exiting after %d values\n", count)
--- a/cmd/geth/genesis_test.go
+++ b/cmd/geth/genesis_test.go
@ -176,12 +176,12 @@ func TestCustomBackend(t *testing.T) {
 		{ // Can't start pebble on top of leveldb
 			initArgs:   []string{"--db.engine", "leveldb"},
 			execArgs:   []string{"--db.engine", "pebble"},
-			execExpect: `Fatal: Failed to register the Ethereum service: db.engine choice was pebble but found pre-existing leveldb database in specified data directory`,
+			execExpect: `Fatal: Could not open database: db.engine choice was pebble but found pre-existing leveldb database in specified data directory`,
 		},
 		{ // Can't start leveldb on top of pebble
 			initArgs:   []string{"--db.engine", "pebble"},
 			execArgs:   []string{"--db.engine", "leveldb"},
-			execExpect: `Fatal: Failed to register the Ethereum service: db.engine choice was leveldb but found pre-existing pebble database in specified data directory`,
+			execExpect: `Fatal: Could not open database: db.engine choice was leveldb but found pre-existing pebble database in specified data directory`,
 		},
 		{ // Reject invalid backend choice
 			initArgs:   []string{"--db.engine", "mssql"},
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`"0xf88bb88903f8860180026483061a8094b94f5374fce5edbc8e2a8697c15331677e6ebf0b8080c00ae1a001a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d801a025e16bb498552165016751911c3608d79000ab89dc3100776e729e6ea13091c7a03acacff7fc0cff6eda8a927dec93ca17765e1ee6cbc06c5954ce102e097c01d2"`