execution: implement EIP-8037 changes and simplifications for bal-devnet-7 (#21207)

for https://notes.ethereum.org/@ethpandaops/bal-devnet-7

Author: taratorio

execution/exec/block_assembler.go

@@ -182,15 +182,20 @@ func (ba *BlockAssembler) AddTransactions(
 	// based on position in the block's transaction list).
 	txnIdx := len(ba.Txns)
 	header := ba.AssembledBlock.Header
-	// EIP-8037: initialize the pool from cumulative regular gas, not the
-	// bottleneck (max of regular, state) stored in header.GasUsed. This
-	// gives compute-heavy transactions access to the full regular gas
-	// budget even when state gas dominates the bottleneck. State gas is
-	// enforced in applyTransaction before FinalizeTx.
-	gasPool := new(protocol.GasPool).AddGas(header.GasLimit - ba.gasUsed.BlockRegular)
+	// EIP-8037: regular and state gas pools deplete independently. The
+	// builder calls AddTransactions repeatedly with batches from the txpool,
+	// so each call must initialise both dimensions from their own cumulative
+	// usage. Seeding both from BlockRegular only would over-inflate the
+	// state pool whenever state gas has run ahead of regular gas.
+	blobBudget := uint64(0)
 	if header.BlobGasUsed != nil {
-		gasPool.AddBlobGas(ba.cfg.ChainConfig.GetMaxBlobGasPerBlock(header.Time) - *header.BlobGasUsed)
+		blobBudget = ba.cfg.ChainConfig.GetMaxBlobGasPerBlock(header.Time) - *header.BlobGasUsed
 	}
+	gasPool := protocol.NewBlockGasPool(
+		header.GasLimit-ba.gasUsed.BlockRegular,
+		header.GasLimit-ba.gasUsed.BlockState,
+		blobBudget,
+	)
 	signer := types.MakeSigner(ba.cfg.ChainConfig, header.Number.Uint64(), header.Time)
 
 	var coalescedLogs types.Logs
@@ -217,7 +222,13 @@ func (ba *BlockAssembler) AddTransactions(
 
 	var commitTx = func(txn types.Transaction, coinbase accounts.Address, vmConfig *vm.Config, chainConfig *chain.Config, ibs *state.IntraBlockState, current *AssembledBlock) ([]*types.Log, error) {
 		ibs.SetTxContext(current.Header.Number.Uint64(), txnIdx)
-		gasSnap := gasPool.Gas()
+		// EIP-8037: regular and state gas pool dimensions can deplete
+		// independently — execution-time state-gas (e.g. CREATE code deposit)
+		// is not visible to the txpool's intrinsic-state-gas filter and may
+		// drain the state pool faster than the regular pool. Snapshot both
+		// dimensions so a failed-inclusion restore puts each one back.
+		regularGasSnap := gasPool.RegularGasAvailable()
+		stateGasSnap := gasPool.StateGasAvailable()
 		blobGasSnap := gasPool.BlobGas()
 		snap := ibs.PushSnapshot()
 		defer ibs.PopSnapshot(snap)
@@ -229,14 +240,14 @@ func (ba *BlockAssembler) AddTransactions(
 			paymasterContext, validationGasUsed, err := aa.ValidateAATransaction(aaTxn, ibs, gasPool, header, evm, chainConfig)
 			if err != nil {
 				ibs.RevertToSnapshot(snap, err)
-				gasPool = new(protocol.GasPool).AddGas(gasSnap).AddBlobGas(blobGasSnap)
+				gasPool = protocol.NewBlockGasPool(regularGasSnap, stateGasSnap, blobGasSnap)
 				return nil, err
 			}
 
 			status, aaGasUsed, err := aa.ExecuteAATransaction(aaTxn, paymasterContext, validationGasUsed, gasPool, evm, header, ibs)
 			if err != nil {
 				ibs.RevertToSnapshot(snap, err)
-				gasPool = new(protocol.GasPool).AddGas(gasSnap).AddBlobGas(blobGasSnap)
+				gasPool = protocol.NewBlockGasPool(regularGasSnap, stateGasSnap, blobGasSnap)
 				return nil, err
 			}
 
@@ -263,7 +274,7 @@ func (ba *BlockAssembler) AddTransactions(
 			// Restore cumulative gas to pre-tx values.
 			*gasUsed = gasSnapshot
 			ibs.RevertToSnapshot(snap, err)
-			gasPool = new(protocol.GasPool).AddGas(gasSnap).AddBlobGas(blobGasSnap)
+			gasPool = protocol.NewBlockGasPool(regularGasSnap, stateGasSnap, blobGasSnap)
 			return nil, err
 		}
 		protocol.SetGasUsed(header, gasUsed)

execution/execmodule/exec_module_test.go

@@ -19,6 +19,7 @@ package execmodule_test
 import (
 	"bytes"
 	"context"
+	"crypto/ecdsa"
 	"crypto/rand"
 	"encoding/binary"
 	"encoding/hex"
@@ -524,7 +525,7 @@ func TestAssembleBlockWithContractCreation(t *testing.T) {
 	require.NoError(t, err)
 
 	contractTx, err := types.SignTx(
-		types.NewContractCreation(1, uint256.NewInt(0), 200_000, uint256.NewInt(baseFee), changerBytecode),
+		types.NewContractCreation(1, uint256.NewInt(0), 300_000, uint256.NewInt(baseFee), changerBytecode),
 		*types.LatestSignerForChainID(m.ChainConfig.ChainID), m.Key,
 	)
 	require.NoError(t, err)
@@ -678,7 +679,7 @@ func TestAssembleBlockMixedTxTypes(t *testing.T) {
 	changerBytecode, err := hex.DecodeString(contracts.ChangerBin[2:])
 	require.NoError(t, err)
 	tx2, err := types.SignTx(
-		types.NewContractCreation(2, uint256.NewInt(0), 200_000, uint256.NewInt(baseFee), changerBytecode),
+		types.NewContractCreation(2, uint256.NewInt(0), 300_000, uint256.NewInt(baseFee), changerBytecode),
 		*types.LatestSignerForChainID(m.ChainConfig.ChainID), m.Key)
 	require.NoError(t, err)
 
@@ -1108,10 +1109,11 @@ func drainHeaders(t *testing.T, ch <-chan [][]byte, timeout time.Duration) {
 // TestAssembleBlockStateGasLimit verifies that the builder respects the EIP-8037
 // block validity invariant: gas_used = max(regular, state) <= gas_limit.
 //
-// Contract creations have high intrinsic state gas (~131K per create at
-// CostPerStateByte=1174) but low regular gas (~30K). With a 500K gas limit,
-// about 4 creates would push state gas past the limit even though regular gas
-// has room. Without the fix the builder would produce an invalid block.
+// Contract creations have high intrinsic state gas (~184K per create at
+// CostPerStateByte=1530, STATE_BYTES_PER_NEW_ACCOUNT=120) but low regular gas
+// (~30K). With a 500K gas limit, about 3 creates would push state gas past
+// the limit even though regular gas has room. Without the fix the builder
+// would produce an invalid block.
 func TestAssembleBlockStateGasLimit(t *testing.T) {
 	t.Parallel()
 	ctx := t.Context()
@@ -1150,7 +1152,7 @@ func TestAssembleBlockStateGasLimit(t *testing.T) {
 	rlpTxs := make([][]byte, 10)
 	for i := range rlpTxs {
 		tx, txErr := types.SignTx(
-			types.NewContractCreation(uint64(i), uint256.NewInt(0), 200_000, uint256.NewInt(baseFee), deployCode),
+			types.NewContractCreation(uint64(i), uint256.NewInt(0), 300_000, uint256.NewInt(baseFee), deployCode),
 			*types.LatestSignerForChainID(m.ChainConfig.ChainID), privKey,
 		)
 		require.NoError(t, txErr)
@@ -1303,6 +1305,255 @@ func TestAssembleBlockStateGasLimitSSTORE(t *testing.T) {
 	require.NoError(t, err)
 }
 
+// TestAssembleBlockGasPoolSnapshotRestoreBug exercises the per-tx gas pool
+// snapshot/restore in the block assembler's commitTx path. Under EIP-8037 the
+// pool tracks regular and state gas as separate dimensions, so a restore that
+// only captures the regular dimension and seeds both on restore wrongly
+// inflates the state pool, letting a follow-up tx exceed the block's
+// state-gas limit.
+//
+// The scenario relies on a tx whose intrinsic state gas (the part the txpool
+// can see when filtering) fits in the remaining pool but whose total state
+// gas (intrinsic + on-success code-deposit) does not: such a tx passes the
+// txpool's filter, reaches the assembler, and fails ConsumeState inside
+// ApplyTransaction. The bug then surfaces if a successor tx in the same
+// batch consumes the inflated state pool that the restore wrongly handed
+// back.
+//
+// Fresh senders (each at nonce 0) are required so a failed tx doesn't
+// nonce-block its successors within the batch.
+func TestAssembleBlockGasPoolSnapshotRestoreBug(t *testing.T) {
+	t.Parallel()
+	ctx := t.Context()
+
+	// Initcode that deploys a 100-byte runtime (100 zero bytes) via CODECOPY.
+	// Per byte deployed: 1530 state gas (CPSB) + 200 regular gas. So each
+	// CREATE consumes ~153K state gas on top of the 183.6K intrinsic
+	// NEW_ACCOUNT charge — a total of ~337K state per tx.
+	const runtimeLen = 100
+	initHeader := []byte{
+		0x60, byte(runtimeLen), // PUSH1 length
+		0x60, 0x0c, //             PUSH1 12 (runtime offset in initcode)
+		0x60, 0x00, //             PUSH1 0  (memory destination)
+		0x39,                   // CODECOPY
+		0x60, byte(runtimeLen), // PUSH1 length
+		0x60, 0x00, //             PUSH1 0 (memory offset)
+		0xf3, //                   RETURN
+	}
+	deployCode := append(initHeader, make([]byte, runtimeLen)...)
+
+	// With a 1_000_000 block gas limit, two txs (~337K state each) leave
+	// the pool at ~326K; a third has 184K intrinsic state (fits in pool by
+	// txpool's filter) but needs 337K total (fails ConsumeState during
+	// execution). A fourth tx then succeeds against the wrongly inflated
+	// pool, pushing the block's total state gas past gas_limit.
+	const numSenders = 4
+	keys := make([]*ecdsa.PrivateKey, numSenders)
+	addrs := make([]common.Address, numSenders)
+	for i := range keys {
+		k, err := crypto.GenerateKey()
+		require.NoError(t, err)
+		keys[i] = k
+		addrs[i] = crypto.PubkeyToAddress(k.PublicKey)
+	}
+
+	alloc := types.GenesisAlloc{}
+	for _, a := range addrs {
+		alloc[a] = types.GenesisAccount{Balance: new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)}
+	}
+	genesis := &types.Genesis{
+		Config:   chain.AllProtocolChanges,
+		GasLimit: 1_000_000,
+		Alloc:    alloc,
+	}
+
+	m := execmoduletester.New(t,
+		execmoduletester.WithGenesisSpec(genesis),
+		execmoduletester.WithKey(keys[0]),
+		execmoduletester.WithTxPool(),
+	)
+	exec := m.ExecModule
+	txpool := m.TxPoolGrpcServer
+
+	chainPack, err := blockgen.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 1,
+		func(i int, gen *blockgen.BlockGen) {})
+	require.NoError(t, err)
+	require.NoError(t, m.InsertChain(chainPack))
+
+	signer := *types.LatestSignerForChainID(m.ChainConfig.ChainID)
+	baseFee := chainPack.TopBlock.BaseFee().Uint64()
+
+	rlpTxs := make([][]byte, numSenders)
+	for i, k := range keys {
+		tx, err := types.SignTx(
+			types.NewContractCreation(0, uint256.NewInt(0), 400_000, uint256.NewInt(baseFee), deployCode),
+			signer, k,
+		)
+		require.NoError(t, err)
+		var buf bytes.Buffer
+		require.NoError(t, tx.EncodeRLP(&buf))
+		rlpTxs[i] = buf.Bytes()
+	}
+	r, err := txpool.Add(ctx, &txpoolproto.AddRequest{RlpTxs: rlpTxs})
+	require.NoError(t, err)
+	for _, e := range r.Errors {
+		require.Equal(t, "success", e)
+	}
+
+	slotNumber := uint64(1)
+	parentBeaconBlockRoot := randomHash()
+	payloadId, err := assembleBlock(ctx, exec, &builder.Parameters{
+		ParentHash:            chainPack.TopBlock.Hash(),
+		Timestamp:             chainPack.TopBlock.Header().Time + 1,
+		PrevRandao:            randomHash(),
+		SuggestedFeeRecipient: common.Address{1},
+		Withdrawals:           make([]*types.Withdrawal, 0),
+		ParentBeaconBlockRoot: &parentBeaconBlockRoot,
+		SlotNumber:            &slotNumber,
+	})
+	require.NoError(t, err)
+	block, err := getAssembledBlock(ctx, exec, payloadId)
+	require.NoError(t, err)
+
+	require.Greater(t, len(block.Transactions()), 0, "block should contain at least one tx")
+	require.LessOrEqual(t, block.GasUsed(), block.GasLimit(),
+		"gas_used (max of regular, state) must not exceed gas_limit")
+
+	require.NoError(t, insertValidateAndUfc1By1(ctx, exec, []*types.Block{block}))
+}
+
+// TestAssembleBlockGasPoolMultiBatchInitBug exercises the block assembler's
+// per-batch gas-pool initialisation. The block builder calls AddTransactions
+// repeatedly with batches of up to 50 txs from the txpool. Each call must
+// build the pool with the *per-dimension* remaining budget; seeding both
+// dimensions from the regular-only cumulative gas wrongly inflates the state
+// pool when state gas has run ahead of regular gas after the previous batch,
+// letting a tx in the next batch consume state past gas_limit.
+//
+// The scenario: 50 contract creations in batch 1 push cumulative state gas
+// near the block gas limit while keeping cumulative regular gas low (CREATE
+// has ~184K intrinsic state vs ~30K intrinsic regular per tx). The 51st tx
+// has small intrinsic state (so the txpool's state-aware filter admits it
+// into batch 2) but a large code-deposit state on execution. With the pool
+// init seeded from regular gas only, batch 2 starts with a state pool that
+// matches the regular dimension — i.e. far more than the real remaining
+// state budget — and the 51st tx is wrongly accepted.
+func TestAssembleBlockGasPoolMultiBatchInitBug(t *testing.T) {
+	t.Parallel()
+	ctx := t.Context()
+
+	// 50 zero-deposit CREATE txs (initcode returns nothing) at higher gas
+	// price for batch 1, plus 1 large-deposit CREATE at lower gas price so
+	// the txpool orders it into batch 2.
+	const numBatch1 = 50
+	const numTotal = numBatch1 + 1
+	keys := make([]*ecdsa.PrivateKey, numTotal)
+	addrs := make([]common.Address, numTotal)
+	for i := range keys {
+		k, err := crypto.GenerateKey()
+		require.NoError(t, err)
+		keys[i] = k
+		addrs[i] = crypto.PubkeyToAddress(k.PublicKey)
+	}
+
+	alloc := types.GenesisAlloc{}
+	for _, a := range addrs {
+		alloc[a] = types.GenesisAccount{Balance: new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)}
+	}
+	// 10M block limit fits ~54 CREATEs by intrinsic state (184K each ≈ 9.2M
+	// for 50). Leaves ~800K of state headroom for batch 2, which the trigger
+	// tx's ~1.2M total state exceeds.
+	genesis := &types.Genesis{
+		Config:   chain.AllProtocolChanges,
+		GasLimit: 10_000_000,
+		Alloc:    alloc,
+	}
+
+	m := execmoduletester.New(t,
+		execmoduletester.WithGenesisSpec(genesis),
+		execmoduletester.WithKey(keys[0]),
+		execmoduletester.WithTxPool(),
+	)
+	exec := m.ExecModule
+	txpool := m.TxPoolGrpcServer
+
+	chainPack, err := blockgen.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 1,
+		func(i int, gen *blockgen.BlockGen) {})
+	require.NoError(t, err)
+	require.NoError(t, m.InsertChain(chainPack))
+
+	signer := *types.LatestSignerForChainID(m.ChainConfig.ChainID)
+	baseFee := chainPack.TopBlock.BaseFee().Uint64()
+	highPrice := uint256.NewInt(baseFee * 2) // higher tip → batch 1
+	lowPrice := uint256.NewInt(baseFee)      // baseFee only → batch 2
+
+	// Batch 1 initcode: PUSH1 0, PUSH1 0, RETURN → zero-byte runtime, no
+	// code-deposit state. Per-tx state is just the 184K intrinsic.
+	batch1Init := []byte{0x60, 0x00, 0x60, 0x00, 0xf3}
+
+	// Batch 2 initcode deploys a ~660-byte runtime via CODECOPY. Per-byte
+	// deposit cost: 1530 state + 200 regular. ~660 bytes → ~1M state on top
+	// of the 184K intrinsic.
+	const triggerRuntimeLen = 660
+	triggerInit := []byte{
+		0x61, byte(triggerRuntimeLen >> 8), byte(triggerRuntimeLen & 0xff), // PUSH2 length
+		0x60, 0x0d, //             PUSH1 13 (runtime offset)
+		0x60, 0x00, //             PUSH1 0  (memory dest)
+		0x39,                                                               //                   CODECOPY
+		0x61, byte(triggerRuntimeLen >> 8), byte(triggerRuntimeLen & 0xff), // PUSH2 length
+		0x60, 0x00, //             PUSH1 0  (memory offset)
+		0xf3, //                   RETURN
+	}
+	triggerInit = append(triggerInit, make([]byte, triggerRuntimeLen)...)
+
+	rlpTxs := make([][]byte, numTotal)
+	for i := range numBatch1 {
+		tx, txErr := types.SignTx(
+			types.NewContractCreation(0, uint256.NewInt(0), 250_000, highPrice, batch1Init),
+			signer, keys[i],
+		)
+		require.NoError(t, txErr)
+		var buf bytes.Buffer
+		require.NoError(t, tx.EncodeRLP(&buf))
+		rlpTxs[i] = buf.Bytes()
+	}
+	triggerTx, err := types.SignTx(
+		types.NewContractCreation(0, uint256.NewInt(0), 2_000_000, lowPrice, triggerInit),
+		signer, keys[numBatch1],
+	)
+	require.NoError(t, err)
+	var triggerBuf bytes.Buffer
+	require.NoError(t, triggerTx.EncodeRLP(&triggerBuf))
+	rlpTxs[numBatch1] = triggerBuf.Bytes()
+
+	r, err := txpool.Add(ctx, &txpoolproto.AddRequest{RlpTxs: rlpTxs})
+	require.NoError(t, err)
+	for _, e := range r.Errors {
+		require.Equal(t, "success", e)
+	}
+
+	slotNumber := uint64(1)
+	parentBeaconBlockRoot := randomHash()
+	payloadId, err := assembleBlock(ctx, exec, &builder.Parameters{
+		ParentHash:            chainPack.TopBlock.Hash(),
+		Timestamp:             chainPack.TopBlock.Header().Time + 1,
+		PrevRandao:            randomHash(),
+		SuggestedFeeRecipient: common.Address{1},
+		Withdrawals:           make([]*types.Withdrawal, 0),
+		ParentBeaconBlockRoot: &parentBeaconBlockRoot,
+		SlotNumber:            &slotNumber,
+	})
+	require.NoError(t, err)
+	block, err := getAssembledBlock(ctx, exec, payloadId)
+	require.NoError(t, err)
+
+	require.Greater(t, len(block.Transactions()), 0, "block should contain at least one tx")
+	require.LessOrEqual(t, block.GasUsed(), block.GasLimit(),
+		"gas_used (max of regular, state) must not exceed gas_limit")
+
+	require.NoError(t, insertValidateAndUfc1By1(ctx, exec, []*types.Block{block}))
+}
+
 func TestEIP7708BurnLogWhenCoinbaseSelfDestructs(t *testing.T) {
 	// Regression test for https://github.com/erigontech/erigon/issues/19951
 	//
@@ -1346,7 +1597,7 @@ func TestEIP7708BurnLogWhenCoinbaseSelfDestructs(t *testing.T) {
 		gen.SetCoinbase(coinbaseAddr)
 
 		tx, txErr := types.SignTx(
-			types.NewContractCreation(nonce, uint256.NewInt(0), 200_000, uint256.NewInt(gasPrice), initCode),
+			types.NewContractCreation(nonce, uint256.NewInt(0), 300_000, uint256.NewInt(gasPrice), initCode),
 			*signer,
 			privKey,
 		)