Merge pull request #322 from bnb-chain/develop

chore: release for v0.5.10

Author: joey0612

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+
+## v0.5.10
+
+This release enforces a per-transaction gas limit (EIP-7825, 16,777,216) at both tx pool admission and block packing to prevent oversized transactions from impacting network security. It also adds essential logging to the bundle pool for production debugging, and adjusts MaxBundleAliveBlock to 240 to align with the current 250ms block time.
+
+### What's Changed
+
+### BUGFIX
+
+* [\#315](https://github.com/bnb-chain/op-geth/pull/315) fix: add bundle logs
+* [\#318](https://github.com/bnb-chain/op-geth/pull/318) feat: support config tx gas limit
+* [\#319](https://github.com/bnb-chain/op-geth/pull/318) fix: adjust MaxBundleAliveBlock to 240
+
+### Docker Images
+
+ghcr.io/bnb-chain/op-geth:v0.5.10
+
+**Full Changelog**: https://github.com/bnb-chain/op-geth/compare/v0.5.9...v0.5.10
+
+
 ## v0.5.9
 
 This release confirm the time of Mainnet Fourier Hardfork, effectively reducing the block time from 500 milliseconds to an impressive 250 milliseconds.

cmd/geth/main.go

@@ -476,6 +476,13 @@ func startNode(ctx *cli.Context, stack *node.Node, backend ethapi.Backend, isCon
 		}()
 	}
 
+	// Set per-transaction gas limit cap on the txpool if configured
+	if ethBackend, ok := backend.(*eth.EthAPIBackend); ok {
+		if txGasLimit := ethBackend.Miner().TxGasLimit(); txGasLimit > 0 {
+			ethBackend.TxPool().SetMaxTxGas(txGasLimit)
+		}
+	}
+
 	// Start auxiliary services if enabled
 	if ctx.Bool(utils.MiningEnabledFlag.Name) {
 		// Mining only makes sense if a full Ethereum node is running

cmd/utils/flags.go

@@ -1798,6 +1798,8 @@ func setMiner(ctx *cli.Context, cfg *miner.Config) {
 	if ctx.IsSet(MevBundleGasPriceFloorFlag.Name) {
 		cfg.Mev.MevBundleGasPriceFloor = ctx.Int64(MevBundleGasPriceFloorFlag.Name)
 	}
+	// Set the maximum gas allowed per individual transaction to the default 16,777,216
+	cfg.TxGasLimit = params.MaxTxGas
 }
 
 func setRequiredBlocks(ctx *cli.Context, cfg *ethconfig.Config) {

core/error.go

@@ -113,4 +113,8 @@ var (
 
 	// ErrSystemTxNotSupported is returned for any deposit tx with IsSystemTx=true after the Regolith fork
 	ErrSystemTxNotSupported = errors.New("system tx not supported")
+
+	// -- EIP-7825 errors --
+	// ErrTxGasLimitTooHigh is returned if a transaction's gas limit exceeds the per-tx cap.
+	ErrTxGasLimitTooHigh = errors.New("transaction gas limit too high")
 )

core/txpool/blobpool/blobpool.go

@@ -27,6 +27,7 @@ import (
 	"path/filepath"
 	"sort"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -306,6 +307,8 @@ type BlobPool struct {
 	state  *state.StateDB // Current state at the head of the chain
 	gasTip *uint256.Int   // Currently accepted minimum gas tip
 
+	maxTxGas atomic.Uint64 // Maximum gas allowed per individual transaction
+
 	lookup map[common.Hash]uint64           // Lookup table mapping hashes to tx billy entries
 	index  map[common.Address][]*blobTxMeta // Blob transactions grouped by accounts, sorted by nonce
 	spent  map[common.Address]*uint256.Int  // Expenditure tracking for individual accounts
@@ -1076,16 +1079,27 @@ func (p *BlobPool) SetGasTip(tip *big.Int) {
 	p.updateStorageMetrics()
 }
 
+// SetMaxTxGas implements txpool.SubPool, allowing the blob pool's per-tx gas
+// limit to be kept in sync with the main transaction pool.
+func (p *BlobPool) SetMaxTxGas(maxTxGas uint64) {
+	p.maxTxGas.Store(maxTxGas)
+}
+
+func (p *BlobPool) GetMaxTxGas() uint64 {
+	return p.maxTxGas.Load()
+}
+
 // validateTx checks whether a transaction is valid according to the consensus
 // rules and adheres to some heuristic limits of the local node (price and size).
 func (p *BlobPool) validateTx(tx *types.Transaction) error {
 	// Ensure the transaction adheres to basic pool filters (type, size, tip) and
 	// consensus rules
 	baseOpts := &txpool.ValidationOptions{
-		Config:  p.chain.Config(),
-		Accept:  1 << types.BlobTxType,
-		MaxSize: txMaxSize,
-		MinTip:  p.gasTip.ToBig(),
+		Config:   p.chain.Config(),
+		Accept:   1 << types.BlobTxType,
+		MaxSize:  txMaxSize,
+		MinTip:   p.gasTip.ToBig(),
+		MaxTxGas: p.GetMaxTxGas(),
 	}
 	if err := txpool.ValidateTransaction(tx, p.head, p.signer, baseOpts); err != nil {
 		return err
@@ -1488,6 +1502,9 @@ func (p *BlobPool) Pending(filter txpool.PendingFilter) map[common.Address][]*tx
 					break // blobfee too low, cannot be included, discard rest of txs from the account
 				}
 			}
+			if filter.GasLimitCap != 0 && tx.execGas > filter.GasLimitCap {
+				break // execution gas limit too high, discard rest of txs from the account
+			}
 			// Transaction was accepted according to the filter, append to the pending list
 			lazies = append(lazies, &txpool.LazyTransaction{
 				Pool:      p,

core/txpool/bundlepool/bundlepool.go

@@ -4,13 +4,11 @@ import (
 	"container/heap"
 	"context"
 	"errors"
-	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/ethereum/go-ethereum/miner"
-	"github.com/ethereum/go-ethereum/rpc"
 	"math/big"
 	"sync"
 	"time"
 
+	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -19,7 +17,9 @@ import (
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rpc"
 )
 
 const (
@@ -167,22 +167,25 @@ func (p *BundlePool) AddBundle(bundle *types.Bundle, originBundle *types.SendBun
 		return ErrBundleTimestampTooHigh
 	}
 
+	hash := bundle.Hash()
 	price, err := p.simulator.SimulateBundle(bundle)
 	if err != nil {
+		log.Warn("Bundle simulation failed", "hash", hash, "err", err)
 		return err
 	}
 	bundle.Price = price
 
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
-	hash := bundle.Hash()
 	if _, ok := p.bundles[hash]; ok {
+		log.Debug("Bundle already exists in pool", "hash", hash)
 		return ErrBundleAlreadyExist
 	}
 
 	if p.slots+numSlots(bundle) > p.config.GlobalSlots {
 		if !p.drop(bundle) {
+			log.Warn("Bundle rejected, gas price too low to replace existing", "hash", hash, "price", price)
 			return ErrBundleGasPriceLow
 		}
 	}
@@ -205,13 +208,15 @@ func (p *BundlePool) AddBundle(bundle *types.Bundle, originBundle *types.SendBun
 	heap.Push(&p.bundleHeap, bundle)
 	p.slots += numSlots(bundle)
 
+	log.Info("Bundle added to pool", "hash", hash, "price", price, "txCount", len(bundle.Txs), "poolSize", len(p.bundles), "slots", p.slots)
+
 	bundleGauge.Update(int64(len(p.bundles)))
 	slotsGauge.Update(int64(p.slots))
 	return nil
 }
 
 func (p *BundlePool) GetBundle(hash common.Hash) *types.Bundle {
-	p.mu.RUnlock()
+	p.mu.RLock()
 	defer p.mu.RUnlock()
 
 	return p.bundles[hash]
@@ -220,6 +225,7 @@ func (p *BundlePool) GetBundle(hash common.Hash) *types.Bundle {
 func (p *BundlePool) PruneBundle(hash common.Hash) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
+	log.Debug("Bundle pruned externally", "hash", hash)
 	p.deleteBundle(hash)
 }
 
@@ -232,6 +238,7 @@ func (p *BundlePool) PendingBundles(blockNumber uint64, blockTimestamp uint64) [
 		// Prune outdated bundles
 		if (bundle.MaxTimestamp != 0 && blockTimestamp > bundle.MaxTimestamp) ||
 			(bundle.MaxBlockNumber != 0 && blockNumber > bundle.MaxBlockNumber) {
+			log.Debug("Bundle expired in PendingBundles", "hash", hash, "maxTimestamp", bundle.MaxTimestamp, "blockTimestamp", blockTimestamp, "maxBlockNumber", bundle.MaxBlockNumber, "blockNumber", blockNumber)
 			p.deleteBundle(hash)
 			continue
 		}
@@ -373,9 +380,11 @@ func (p *BundlePool) reset(newHead *types.Header) {
 	for hash, bundle := range p.bundles {
 		if (bundle.MaxTimestamp != 0 && newHead.Time > bundle.MaxTimestamp) ||
 			(bundle.MaxBlockNumber != 0 && newHead.Number.Cmp(new(big.Int).SetUint64(bundle.MaxBlockNumber)) > 0) {
+			log.Debug("Bundle pruned on reset (expired)", "hash", hash, "headNumber", newHead.Number, "headTime", newHead.Time, "maxBlockNumber", bundle.MaxBlockNumber, "maxTimestamp", bundle.MaxTimestamp)
 			p.slots -= numSlots(p.bundles[hash])
 			delete(p.bundles, hash)
 		} else if txSet.Contains(bundle.Txs[0].Hash()) {
+			log.Debug("Bundle pruned on reset (tx already included)", "hash", hash, "headNumber", newHead.Number, "firstTx", bundle.Txs[0].Hash())
 			p.slots -= numSlots(p.bundles[hash])
 			delete(p.bundles, hash)
 		}
@@ -402,6 +411,7 @@ func (p *BundlePool) drop(bundle *types.Bundle) bool {
 	for len(p.bundleHeap) > 0 {
 		if dropSlots >= numSlots(bundle) {
 			for _, dropBundle := range dropBundles {
+				log.Info("Bundle dropped due to slot limit", "hash", dropBundle.Hash(), "price", dropBundle.Price)
 				p.deleteBundle(dropBundle.Hash())
 			}
 			return true
@@ -438,7 +448,7 @@ func (p *BundlePool) minimalBundleGasPrice() *big.Int {
 	return new(big.Int)
 }
 
-func (p *BundlePool) SetMaxGas(maxGas uint64) {}
+func (p *BundlePool) SetMaxTxGas(maxTxGas uint64) {}
 
 // =====================================================================================================================
 

core/txpool/legacypool/legacypool.go

@@ -276,6 +276,7 @@ type LegacyPool struct {
 	chainconfig  *params.ChainConfig
 	chain        BlockChain
 	gasTip       atomic.Pointer[uint256.Int]
+	maxTxGas     atomic.Uint64
 	txFeed       event.Feed
 	reannoTxFeed event.Feed
 	signer       types.Signer
@@ -585,6 +586,15 @@ func (pool *LegacyPool) SetGasTip(tip *big.Int) {
 	log.Info("Legacy pool tip threshold updated", "tip", newTip)
 }
 
+func (pool *LegacyPool) GetMaxTxGas() uint64 {
+	return pool.maxTxGas.Load()
+}
+
+// SetMaxGas updates the maximum gas allowed per individual transaction.
+func (pool *LegacyPool) SetMaxTxGas(maxTxGas uint64) {
+	pool.maxTxGas.Store(maxTxGas)
+}
+
 // Nonce returns the next nonce of an account, with all transactions executable
 // by the pool already applied on top.
 func (pool *LegacyPool) Nonce(addr common.Address) uint64 {
@@ -705,10 +715,16 @@ func (pool *LegacyPool) Pending(filter txpool.PendingFilter) map[common.Address]
 			txs = txs[noncetoolow+1:]
 		}
 
-		// If the miner requests tip enforcement, cap the lists now
-		if minTipBig != nil && !localAddrs[addr] {
+		// If the miner requests tip enforcement or tx gas cap, filter the lists now
+		if (minTipBig != nil && !localAddrs[addr]) || filter.GasLimitCap != 0 {
 			for i, tx := range txs {
-				if tx.EffectiveGasTipIntCmp(minTipBig, baseFeeBig) < 0 {
+				if minTipBig != nil && !localAddrs[addr] {
+					if tx.EffectiveGasTipIntCmp(minTipBig, baseFeeBig) < 0 {
+						txs = txs[:i]
+						break
+					}
+				}
+				if filter.GasLimitCap != 0 && tx.Gas() > filter.GasLimitCap {
 					txs = txs[:i]
 					break
 				}
@@ -790,6 +806,7 @@ func (pool *LegacyPool) validateTxBasics(tx *types.Transaction, local bool) erro
 		MaxSize:          txMaxSize,
 		MinTip:           pool.gasTip.Load().ToBig(),
 		EffectiveGasCeil: pool.config.EffectiveGasCeil,
+		MaxTxGas:         pool.GetMaxTxGas(),
 	}
 	if local {
 		opts.MinTip = new(big.Int)

core/txpool/subpool.go

@@ -81,6 +81,8 @@ type PendingFilter struct {
 	BaseFee *uint256.Int // Minimum 1559 basefee needed to include a transaction
 	BlobFee *uint256.Int // Minimum 4844 blobfee needed to include a blob transaction
 
+	GasLimitCap uint64 // Maximum gas allowed per transaction (0 = no cap)
+
 	OnlyPlainTxs bool // Return only plain EVM transactions (peer-join announces, block space filling)
 	OnlyBlobTxs  bool // Return only blob transactions (block blob-space filling)
 }
@@ -166,6 +168,9 @@ type SubPool interface {
 	// Status returns the known status (unknown/pending/queued) of a transaction
 	// identified by their hashes.
 	Status(hash common.Hash) TxStatus
+
+	// SetMaxTxGas updates the maximum gas allowed per individual transaction.
+	SetMaxTxGas(maxTxGas uint64)
 }
 
 type BundleSubpool interface {

core/txpool/txpool.go

@@ -286,6 +286,14 @@ func (p *TxPool) SetGasTip(tip *big.Int) {
 	}
 }
 
+// SetMaxTxGas updates the maximum gas allowed per individual transaction across
+// all subpools.
+func (p *TxPool) SetMaxTxGas(maxTxGas uint64) {
+	for _, subpool := range p.subpools {
+		subpool.SetMaxTxGas(maxTxGas)
+	}
+}
+
 // Has returns an indicator whether the pool has a transaction cached with the
 // given hash.
 func (p *TxPool) Has(hash common.Hash) bool {

core/txpool/validation.go

@@ -65,6 +65,7 @@ type ValidationOptions struct {
 	MinTip  *big.Int // Minimum gas tip needed to allow a transaction into the caller pool
 
 	EffectiveGasCeil uint64 // if non-zero, a gas ceiling to enforce independent of the header's gaslimit value
+	MaxTxGas         uint64 // if non-zero, maximum gas allowed per individual transaction
 }
 
 // ValidateTransaction is a helper method to check whether a transaction is valid
@@ -120,6 +121,10 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types
 	if EffectiveGasLimit(opts.Config, head.GasLimit, opts.EffectiveGasCeil) < tx.Gas() {
 		return ErrGasLimit
 	}
+	// Ensure the transaction doesn't exceed the per-tx gas limit cap
+	if opts.MaxTxGas > 0 && tx.Gas() > opts.MaxTxGas {
+		return fmt.Errorf("%w (cap: %d, tx: %d)", core.ErrTxGasLimitTooHigh, opts.MaxTxGas, tx.Gas())
+	}
 	// Sanity check for extremely large numbers (supported by RLP or RPC)
 	if tx.GasFeeCap().BitLen() > 256 {
 		Meter(FeeCapVeryHigh).Mark(1)