Transaction Gas Limit Cap

Author: ucwong

core/error.go

@@ -68,4 +68,6 @@ var (
 
 	//ErrMetaInfoNotMature     = errors.New("cvm: errMetaInfoNotMature")
 	ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer")
+
+	ErrGasLimitTooHigh = errors.New("transaction gas limit too high")
 )

core/state_transition.go

@@ -245,6 +245,11 @@ func (st *stateTransition) preCheck() error {
 		return err
 	}
 
+	// Verify tx gas limit does not exceed EIP-7825 cap.
+	if st.cvm.ChainConfig().IsOsaka(st.cvm.Context.BlockNumber, st.cvm.Context.Time) && msg.GasLimit > params.MaxTxGas {
+		return fmt.Errorf("%w (cap: %d, tx: %d)", ErrGasLimitTooHigh, params.MaxTxGas, msg.GasLimit)
+	}
+
 	return st.buyGas()
 }
 

core/txpool/txpool.go

@@ -231,6 +231,10 @@ func (config *Config) sanitize() Config {
 	return conf
 }
 
+type PendingFilter struct {
+	GasLimitCap uint64 // Maximum gas can be used for a single transaction execution (0 means no limit)
+}
+
 // TxPool contains all currently known transactions. Transactions
 // enter the pool when they are received from the network or submitted
 // locally. They exit the pool when they are included in the blockchain.
@@ -524,13 +528,27 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 // Pending retrieves all currently processable transactions, grouped by origin
 // account and sorted by nonce. The returned transaction set is a copy and can be
 // freely modified by calling code.
-func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transactions {
+func (pool *TxPool) Pending(filter PendingFilter) map[common.Address]types.Transactions {
 	pool.mu.Lock()
 	defer pool.mu.Unlock()
 
 	pending := make(map[common.Address]types.Transactions, len(pool.pending))
 	for addr, list := range pool.pending {
-		pending[addr] = list.Flatten()
+		//pending[addr] = list.Flatten()
+		txs := list.Flatten()
+		if filter.GasLimitCap != 0 {
+			for i, tx := range txs {
+				if filter.GasLimitCap != 0 {
+					if tx.Gas() > filter.GasLimitCap {
+						txs = txs[:i]
+						break
+					}
+				}
+			}
+		}
+		if len(txs) > 0 {
+			pending[addr] = txs
+		}
 	}
 	return pending
 }
@@ -568,6 +586,9 @@ func (pool *TxPool) validateTxBasics(tx *types.Transaction, local bool) error {
 	if tx.Size() > txMaxSize {
 		return ErrOversizedData
 	}
+	//if pool.chainconfig.IsOsaka && tx.Gas() > params.MaxTxGas {
+	//	return fmt.Errorf("%w (cap: %d, tx: %d)", core.ErrGasLimitTooHigh, params.MaxTxGas, tx.Gas())
+	//}
 	// Transactions can't be negative. This may never happen using RLP decoded
 	// transactions but may occur if you create a transaction using the RPC.
 	if tx.Value().Sign() < 0 {
@@ -1191,6 +1212,21 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 	}
 	pool.mu.Lock()
 	if reset != nil {
+		if reset.newHead != nil && reset.oldHead != nil {
+			// Discard the transactions with the gas limit higher than the cap.
+			if pool.chainconfig.IsOsaka(reset.newHead.Number, reset.newHead.Time) && !pool.chainconfig.IsOsaka(reset.oldHead.Number, reset.oldHead.Time) {
+				var hashes []common.Hash
+				pool.all.Range(func(hash common.Hash, tx *types.Transaction, local bool) bool {
+					if tx.Gas() > params.MaxTxGas {
+						hashes = append(hashes, hash)
+					}
+					return true
+				}, false, true)
+				for _, hash := range hashes {
+					pool.removeTx(hash, true)
+				}
+			}
+		}
 		// Reset from the old head to the new, rescheduling any reorged transactions
 		pool.reset(reset.oldHead, reset.newHead)
 

ctxc/api_backend.go

@@ -266,7 +266,7 @@ func (b *CortexAPIBackend) SendTx(ctx context.Context, signedTx *types.Transacti
 }
 
 func (b *CortexAPIBackend) GetPoolTransactions() (types.Transactions, error) {
-	pending := b.ctxc.txPool.Pending(false)
+	pending := b.ctxc.txPool.Pending(txpool.PendingFilter{})
 	var txs types.Transactions
 	for _, batch := range pending {
 		txs = append(txs, batch...)

ctxc/handler.go

@@ -29,6 +29,7 @@ import (
 	"github.com/CortexFoundation/CortexTheseus/common"
 	"github.com/CortexFoundation/CortexTheseus/core"
 	"github.com/CortexFoundation/CortexTheseus/core/forkid"
+	"github.com/CortexFoundation/CortexTheseus/core/txpool"
 	"github.com/CortexFoundation/CortexTheseus/core/types"
 	"github.com/CortexFoundation/CortexTheseus/crypto"
 	"github.com/CortexFoundation/CortexTheseus/ctxc/downloader"
@@ -95,7 +96,7 @@ type txPool interface {
 
 	// Pending should return pending transactions.
 	// The slice should be modifiable by the caller.
-	Pending(enforceTips bool) map[common.Address]types.Transactions
+	Pending(filter txpool.PendingFilter) map[common.Address]types.Transactions
 
 	// SubscribeNewTxsEvent should return an event subscription of
 	// NewTxsEvent and send events to the given channel.

ctxc/helper_test.go

@@ -32,6 +32,7 @@ import (
 	"github.com/CortexFoundation/CortexTheseus/core"
 	"github.com/CortexFoundation/CortexTheseus/core/forkid"
 	"github.com/CortexFoundation/CortexTheseus/core/rawdb"
+	"github.com/CortexFoundation/CortexTheseus/core/txpool"
 	"github.com/CortexFoundation/CortexTheseus/core/types"
 	"github.com/CortexFoundation/CortexTheseus/core/vm"
 	"github.com/CortexFoundation/CortexTheseus/crypto"
@@ -142,7 +143,7 @@ func (p *testTxPool) AddRemotes(txs []*types.Transaction) []error {
 }
 
 // Pending returns all the transactions known to the pool
-func (p *testTxPool) Pending(b bool) map[common.Address]types.Transactions {
+func (p *testTxPool) Pending(b txpool.PendingFilter) map[common.Address]types.Transactions {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 

ctxc/sync.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/CortexFoundation/CortexTheseus/common"
 	"github.com/CortexFoundation/CortexTheseus/core/rawdb"
+	"github.com/CortexFoundation/CortexTheseus/core/txpool"
 	"github.com/CortexFoundation/CortexTheseus/core/types"
 	"github.com/CortexFoundation/CortexTheseus/ctxc/downloader"
 	"github.com/CortexFoundation/CortexTheseus/log"
@@ -52,7 +53,7 @@ func (pm *ProtocolManager) syncTransactions(p *peer) {
 	//
 	// TODO(karalabe): Figure out if we could get away with random order somehow
 	var txs types.Transactions
-	pending := pm.txpool.Pending(false)
+	pending := pm.txpool.Pending(txpool.PendingFilter{})
 	for _, batch := range pending {
 		txs = append(txs, batch...)
 	}

miner/worker.go

@@ -27,6 +27,7 @@ import (
 	"github.com/CortexFoundation/CortexTheseus/consensus"
 	"github.com/CortexFoundation/CortexTheseus/core"
 	"github.com/CortexFoundation/CortexTheseus/core/state"
+	"github.com/CortexFoundation/CortexTheseus/core/txpool"
 	"github.com/CortexFoundation/CortexTheseus/core/types"
 	"github.com/CortexFoundation/CortexTheseus/event"
 	"github.com/CortexFoundation/CortexTheseus/log"
@@ -998,9 +999,13 @@ func (w *worker) commitNewWork(interrupt *atomic.Int32, noempty bool, timestamp
 // into the given sealing block. The transaction selection and ordering strategy can
 // be customized with the plugin in the future.
 func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment) error {
+	filter := txpool.PendingFilter{}
+	if w.chainConfig.IsOsaka(env.header.Number, env.header.Time) {
+		filter.GasLimitCap = params.MaxTxGas
+	}
 	// Split the pending transactions into locals and remotes
 	// Fill the block with all available pending transactions.
-	pending := w.ctxc.TxPool().Pending(true)
+	pending := w.ctxc.TxPool().Pending(filter)
 	localTxs, remoteTxs := make(map[common.Address]types.Transactions), pending
 	for _, account := range w.ctxc.TxPool().Locals() {
 		if txs := remoteTxs[account]; len(txs) > 0 {

params/protocol_params.go

@@ -30,6 +30,8 @@ const (
 	MinerGasFloor        uint64 = MinGasLimit
 	MinerGasCeil         uint64 = 160000000
 
+	MaxTxGas uint64 = 30_000_000 // Maximum transaction gas limit after eip-7825.
+
 	MaximumExtraDataSize  uint64 = 32      // Maximum size extra data may be after Genesis.
 	ExpByteGas            uint64 = 10      // Times ceil(log256(exponent)) for the EXP instruction.
 	SloadGas              uint64 = 50      // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added.