core: miner: apply envelope amount limit to miner and block processor

Author: txhsl

core/error.go

@@ -59,6 +59,10 @@ var (
 	// by a transaction is higher than what's left in the block.
 	ErrGasLimitReached = errors.New("gas limit reached")
 
+	// ErrEnvelopeNumberLimitReached is returned if the number of envelope transactions
+	// in the block has reached the limit and is going to break the limit.
+	ErrEnvelopeNumberLimitReached = errors.New("envelope number limit reached")
+
 	// ErrInsufficientFundsForTransfer is returned if the transaction sender doesn't
 	// have enough funds for transfer(topmost call only).
 	ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer")

core/state_processor.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/antimev"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc"
@@ -60,22 +61,24 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen
 // transactions failed to execute due to insufficient gas it will return an error.
 func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {
 	var (
-		receipts    types.Receipts
-		usedGas     = new(uint64)
-		header      = block.Header()
-		blockHash   = block.Hash()
-		blockNumber = block.Number()
-		allLogs     []*types.Log
-		gp          = new(GasPool).AddGas(block.GasLimit())
+		receipts      types.Receipts
+		usedGas       = new(uint64)
+		envelopeCount = uint64(0)
+		header        = block.Header()
+		blockHash     = block.Hash()
+		blockNumber   = block.Number()
+		allLogs       []*types.Log
+		gp            = new(GasPool).AddGas(block.GasLimit())
 	)
 	// Mutate the block and state according to any hard-fork specs
 	if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
 		misc.ApplyDAOHardFork(statedb)
 	}
 	var (
-		context = NewEVMBlockContext(header, p.bc, nil)
-		vmenv   = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
-		signer  = types.MakeSigner(p.config, header.Number, header.Time)
+		context             = NewEVMBlockContext(header, p.bc, nil)
+		vmenv               = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
+		signer              = types.MakeSigner(p.config, header.Number, header.Time)
+		envelopeNumberLimit = statedb.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMaxEnvelopesPerBlockStateHash()).Big().Uint64()
 	)
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb)
@@ -88,6 +91,14 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	}
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
+		// Check against envelope number policy
+		if p.bc.chainConfig.IsNeoXAMEV(blockNumber) && antimev.IsEnvelope(tx) {
+			if envelopeCount >= envelopeNumberLimit {
+				return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w, envelope limit %v", i, tx.Hash().Hex(),
+					ErrEnvelopeNumberLimitReached, envelopeNumberLimit)
+			}
+			envelopeCount++
+		}
 		msg, err := TransactionToMessage(tx, signer, header.BaseFee)
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)

core/systemcontracts/contracts.go

@@ -25,6 +25,7 @@ const blackListSlotIndex = 1
 const minGasTipCapSlotIndex = 2
 const baseFeeSlotIndex = 3
 const envelopeFeeSlotIndex = 5
+const maxEnvelopesPerBlockSlotIndex = 6
 const maxEnvelopeGasLimitSlotIndex = 7
 
 // A set of genesis contract hashes.
@@ -104,6 +105,13 @@ func GetEnvelopeFeeStateHash() common.Hash {
 	return common.BytesToHash([]byte{envelopeFeeSlotIndex})
 }
 
+// GetMaxEnvelopesPerBlockStateHash computes and returns the storage key
+// of maxEnvelopesPerBlock in policy contract, for reading corresponding
+// values from statedb.
+func GetMaxEnvelopesPerBlockStateHash() common.Hash {
+	return common.BytesToHash([]byte{maxEnvelopesPerBlockSlotIndex})
+}
+
 // GetMaxEnvelopeGasLimitStateHash computes and returns the storage key
 // of maxEnvelopeGasLimit in policy contract, for reading corresponding
 // values from statedb.

miner/worker.go

@@ -24,12 +24,14 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/ethereum/go-ethereum/antimev"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
 	"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/systemcontracts"
 	"github.com/ethereum/go-ethereum/core/txpool"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -86,6 +88,7 @@ type environment struct {
 	signer   types.Signer
 	state    *state.StateDB // apply state changes here
 	tcount   int            // tx count in cycle
+	ecount   int            // envelope tx count in cycle
 	gasPool  *core.GasPool  // available gas used to pack transactions
 	coinbase common.Address
 
@@ -102,6 +105,7 @@ func (env *environment) copy() *environment {
 		signer:   env.signer,
 		state:    env.state.Copy(),
 		tcount:   env.tcount,
+		ecount:   env.ecount,
 		coinbase: env.coinbase,
 		header:   types.CopyHeader(env.header),
 		receipts: copyReceipts(env.receipts),
@@ -744,6 +748,7 @@ func (w *worker) makeEnv(parent *types.Header, header *types.Header, coinbase co
 	}
 	// Keep track of transactions which return errors so they can be removed
 	env.tcount = 0
+	env.ecount = 0
 	return env, nil
 }
 
@@ -892,6 +897,17 @@ func (w *worker) commitTransactions(env *environment, plainTxs, blobTxs *transac
 			txs.Pop()
 			continue
 		}
+		// Check whether the tx is an Envelope. If it is an Envelope and
+		// policy doesn't allow any more Envelopes in this block, ignore.
+		if w.chainConfig.IsNeoXAMEV(env.header.Number) && antimev.IsEnvelope(tx) {
+			envelopNumberLimit := env.state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMaxEnvelopesPerBlockStateHash()).Big()
+			if new(big.Int).SetUint64(uint64(env.ecount)).Cmp(envelopNumberLimit) >= 0 {
+				log.Trace("Ignoring envelope transaction more than limit", "hash", ltx.Hash, "limit", envelopNumberLimit)
+				txs.Pop()
+				continue
+			}
+			env.ecount++
+		}
 		// Start executing the transaction
 		env.state.SetTxContext(tx.Hash(), env.tcount)