all: sync with go-ethereum v1.17.2 (upstream merge 4/6)

accounts/abi/bind/backends/simulated.go

@@ -735,7 +735,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 	// about the transaction and calling mechanisms.
 	evmContext := core.NewEVMBlockContext(header, b.blockchain, nil)
 	vmEnv := vm.NewEVM(evmContext, stateDB, b.config, vm.Config{NoBaseFee: true})
-	gasPool := new(core.GasPool).AddGas(gomath.MaxUint64)
+	gasPool := core.NewGasPool(gomath.MaxUint64)
 
 	return core.ApplyMessage(vmEnv, msg, gasPool)
 }

build/ci.go

@@ -107,17 +107,21 @@ var (
 			Tags: "ziren",
 			Env:  map[string]string{"GOMIPS": "softfloat", "CGO_ENABLED": "0"},
 		},
+		{
+			Name:   "womir",
+			GOOS:   "wasip1",
+			GOARCH: "wasm",
+			Tags:   "womir",
+		},
 		{
 			Name:   "wasm-js",
 			GOOS:   "js",
 			GOARCH: "wasm",
-			Tags:   "example",
 		},
 		{
 			Name:   "wasm-wasi",
 			GOOS:   "wasip1",
 			GOARCH: "wasm",
-			Tags:   "example",
 		},
 		{
 			Name: "example",
@@ -163,11 +167,11 @@ var (
 
 	// Distros for which packages are created
 	debDistros = []string{
-		"xenial",   // 16.04, EOL: 04/2026
-		"bionic",   // 18.04, EOL: 04/2028
-		"focal",    // 20.04, EOL: 04/2030
-		"jammy",    // 22.04, EOL: 04/2032
-		"noble",    // 24.04, EOL: 04/2034
+		"xenial", // 16.04, EOL: 04/2026
+		"bionic", // 18.04, EOL: 04/2028
+		"focal",  // 20.04, EOL: 04/2030
+		"jammy",  // 22.04, EOL: 04/2032
+		"noble",  // 24.04, EOL: 04/2034
 	}
 
 	// This is where the tests should be unpacked.
@@ -305,7 +309,7 @@ func doInstallKeeper(cmdline []string) {
 		args := slices.Clone(gobuild.Args)
 		args = append(args, "-o", executablePath(outputName))
 		args = append(args, ".")
-		build.MustRun(&exec.Cmd{Path: gobuild.Path, Args: args, Env: gobuild.Env})
+		build.MustRun(&exec.Cmd{Path: gobuild.Path, Args: args, Env: gobuild.Env, Dir: gobuild.Dir})
 	}
 }
 
@@ -1203,7 +1207,7 @@ func doWindowsInstaller(cmdline []string) {
 	var (
 		arch    = flag.String("arch", runtime.GOARCH, "Architecture for cross build packaging")
 		signer  = flag.String("signer", "", `Environment variable holding the signing key (e.g. WINDOWS_SIGNING_KEY)`)
-		signify = flag.String("signify key", "", `Environment variable holding the signify signing key (e.g. WINDOWS_SIGNIFY_KEY)`)
+		signify = flag.String("signify", "", `Environment variable holding the signify signing key (e.g. WINDOWS_SIGNIFY_KEY)`)
 		upload  = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`)
 		workdir = flag.String("workdir", "", `Output directory for packages (uses temp dir if unset)`)
 	)

cmd/devp2p/internal/v5test/framework.go

@@ -235,12 +235,16 @@ func (tc *conn) read(c net.PacketConn) v5wire.Packet {
 		return &readError{err}
 	}
 
-	n, fromAddr, err := c.ReadFrom(buf)
+	n, _, err := c.ReadFrom(buf)
 	if err != nil {
 		return &readError{err}
 	}
 
-	_, _, p, err := tc.codec.Decode(buf[:n], fromAddr.String())
+	// Always use tc.remoteAddr for session lookup. The actual source address of
+	// the packet may differ from tc.remoteAddr when the remote node is reachable
+	// via multiple networks (e.g. Docker bridge vs. overlay), but the codec's
+	// session cache is keyed by the address used during Encode.
+	_, _, p, err := tc.codec.Decode(buf[:n], tc.remoteAddr.String())
 	if err != nil {
 		return &readError{err}
 	}

cmd/evm/internal/t8ntool/execution.go

@@ -154,16 +154,13 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		isEIP4762   = chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)))
 		statedb     = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre, isEIP4762)
 		signer      = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp)
-		gaspool     = new(core.GasPool)
+		gaspool     = core.NewGasPool(pre.Env.GasLimit)
 		blockHash   = common.Hash{0x13, 0x37}
 		rejectedTxs []*rejectedTx
 		includedTxs types.Transactions
-		gasUsed     = uint64(0)
 		blobGasUsed = uint64(0)
 		receipts    = make(types.Receipts, 0)
 	)
-
-	gaspool.AddGas(pre.Env.GasLimit)
 	vmContext := vm.BlockContext{
 		CanTransfer: core.CanTransfer,
 		Transfer:    core.Transfer,
@@ -265,15 +262,15 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		statedb.SetTxContext(tx.Hash(), len(receipts))
 		var (
 			snapshot = statedb.Snapshot()
-			prevGas  = gaspool.Gas()
+			gp       = gaspool.Snapshot()
 		)
-		receipt, err := core.ApplyTransactionWithEVM(msg, gaspool, statedb, vmContext.BlockNumber, blockHash, pre.Env.Timestamp, tx, &gasUsed, evm)
+		receipt, err := core.ApplyTransactionWithEVM(msg, gaspool, statedb, vmContext.BlockNumber, blockHash, pre.Env.Timestamp, tx, evm)
 		if err != nil {
 			statedb.RevertToSnapshot(snapshot)
 			log.Info("rejected tx", "index", i, "hash", tx.Hash(), "from", msg.From, "error", err)
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})
 
-			gaspool.SetGas(prevGas)
+			gaspool.Set(gp)
 			continue
 		}
 		if receipt.Logs == nil {
@@ -364,7 +361,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		Receipts:    receipts,
 		Rejected:    rejectedTxs,
 		Difficulty:  (*math.HexOrDecimal256)(vmContext.Difficulty),
-		GasUsed:     (math.HexOrDecimal64)(gasUsed),
+		GasUsed:     (math.HexOrDecimal64)(gaspool.Used()),
 		BaseFee:     (*math.HexOrDecimal256)(vmContext.BaseFee),
 	}
 
@@ -380,10 +377,6 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		// Set requestsHash on block.
 		h := types.CalcRequestsHash(requests)
 		execRs.RequestsHash = &h
-		for i := range requests {
-			// remove prefix
-			requests[i] = requests[i][1:]
-		}
 		execRs.Requests = requests
 	}
 

cmd/evm/internal/t8ntool/transaction.go

@@ -29,7 +29,9 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
+
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/tests"
@@ -194,8 +196,10 @@ func Transaction(ctx *cli.Context) error {
 			r.Error = errors.New("gas * maxFeePerGas exceeds 256 bits")
 		}
 		// Check whether the init code size has been exceeded.
-		if chainConfig.IsShanghai(new(big.Int)) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {
-			r.Error = errors.New("max initcode size exceeded")
+		if tx.To() == nil {
+			if err := vm.CheckMaxInitCodeSize(&rules, uint64(len(tx.Data()))); err != nil {
+				r.Error = err
+			}
 		}
 
 		// Bor: EIP-7825 at Madhugiri HF block

cmd/fetchpayload/main.go

@@ -0,0 +1,177 @@
+// Copyright 2026 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+// fetchpayload queries an Ethereum node over RPC, fetches a block and its
+// execution witness, and writes the combined Payload (ChainID + Block +
+// Witness) to disk in the format consumed by cmd/keeper.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/stateless"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// Payload is duplicated from cmd/keeper/main.go (package main, not importable).
+type Payload struct {
+	ChainID uint64
+	Block   *types.Block
+	Witness *stateless.Witness
+}
+
+func main() {
+	var (
+		rpcURL   = flag.String("rpc", "http://localhost:8545", "RPC endpoint URL")
+		blockArg = flag.String("block", "latest", `Block number: decimal, 0x-hex, or "latest"`)
+		format   = flag.String("format", "rlp", "Comma-separated output formats: rlp, hex, json")
+		outDir   = flag.String("out", "", "Output directory (default: current directory)")
+	)
+	flag.Parse()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// Parse block number (nil means "latest" in ethclient).
+	blockNum, err := parseBlockNumber(*blockArg)
+	if err != nil {
+		fatal("invalid block number %q: %v", *blockArg, err)
+	}
+
+	// Connect to the node.
+	client, err := ethclient.DialContext(ctx, *rpcURL)
+	if err != nil {
+		fatal("failed to connect to %s: %v", *rpcURL, err)
+	}
+	defer client.Close()
+
+	chainID, err := client.ChainID(ctx)
+	if err != nil {
+		fatal("failed to get chain ID: %v", err)
+	}
+
+	// Fetch the block first so we have a concrete number for the witness call,
+	// avoiding a race where "latest" advances between the two RPCs.
+	block, err := client.BlockByNumber(ctx, blockNum)
+	if err != nil {
+		fatal("failed to fetch block: %v", err)
+	}
+	fmt.Printf("Fetched block %d (%#x)\n", block.NumberU64(), block.Hash())
+
+	// Fetch the execution witness via the debug namespace.
+	var extWitness stateless.ExtWitness
+	err = client.Client().CallContext(ctx, &extWitness, "debug_executionWitness", rpc.BlockNumber(block.NumberU64()))
+	if err != nil {
+		fatal("failed to fetch execution witness: %v", err)
+	}
+
+	witness := new(stateless.Witness)
+	err = witness.FromExtWitness(&extWitness)
+	if err != nil {
+		fatal("failed to convert witness: %v", err)
+	}
+
+	payload := Payload{
+		ChainID: chainID.Uint64(),
+		Block:   block,
+		Witness: witness,
+	}
+
+	// Encode payload as RLP (shared by "rlp" and "hex" formats).
+	rlpBytes, err := rlp.EncodeToBytes(payload)
+	if err != nil {
+		fatal("failed to RLP-encode payload: %v", err)
+	}
+
+	// Write one output file per requested format.
+	blockHex := fmt.Sprintf("%x", block.NumberU64())
+	for f := range strings.SplitSeq(*format, ",") {
+		f = strings.TrimSpace(f)
+		outPath := filepath.Join(*outDir, fmt.Sprintf("%s_payload.%s", blockHex, f))
+
+		var data []byte
+		switch f {
+		case "rlp":
+			data = rlpBytes
+		case "hex":
+			data = []byte(hexutil.Encode(rlpBytes))
+		case "json":
+			data, err = marshalJSONPayload(chainID, block, &extWitness)
+			if err != nil {
+				fatal("failed to JSON-encode payload: %v", err)
+			}
+		default:
+			fatal("unknown format %q (valid: rlp, hex, json)", f)
+		}
+
+		if err := os.WriteFile(outPath, data, 0644); err != nil {
+			fatal("failed to write %s: %v", outPath, err)
+		}
+		fmt.Printf("Wrote %s (%d bytes)\n", outPath, len(data))
+	}
+}
+
+// parseBlockNumber converts a CLI string to *big.Int.
+// Returns nil for "latest" (ethclient convention for the head block).
+func parseBlockNumber(s string) (*big.Int, error) {
+	if strings.EqualFold(s, "latest") {
+		return nil, nil
+	}
+	n := new(big.Int)
+	if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") {
+		if _, ok := n.SetString(s[2:], 16); !ok {
+			return nil, fmt.Errorf("invalid hex number")
+		}
+		return n, nil
+	}
+	if _, ok := n.SetString(s, 10); !ok {
+		return nil, fmt.Errorf("invalid decimal number")
+	}
+	return n, nil
+}
+
+// jsonPayload is a JSON-friendly representation of Payload. It uses ExtWitness
+// instead of the internal Witness (which has no JSON marshaling).
+type jsonPayload struct {
+	ChainID uint64                `json:"chainId"`
+	Block   *types.Block          `json:"block"`
+	Witness *stateless.ExtWitness `json:"witness"`
+}
+
+func marshalJSONPayload(chainID *big.Int, block *types.Block, ext *stateless.ExtWitness) ([]byte, error) {
+	return json.MarshalIndent(jsonPayload{
+		ChainID: chainID.Uint64(),
+		Block:   block,
+		Witness: ext,
+	}, "", "  ")
+}
+
+func fatal(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, format+"\n", args...)
+	os.Exit(1)
+}