sync txpool update

Author: colinlyguo

Makefile

@@ -46,6 +46,7 @@ test: all
 	# EIP-7702 test
 	cd ${PWD}/core/vm/runtime; go test -v -run=^TestDelegatedAccountAccessCost
 	cd ${PWD}/core/types; go test -v -run=^TestParseDelegation
+	cd ${PWD}/internal/ethapi; go test -v -run=^TestEstimateGas
 
 lint: ## Run linters.
 	$(GORUN) build/ci.go lint

core/blockchain_test.go

@@ -3845,13 +3845,13 @@ func TestEIP7702(t *testing.T) {
 	blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 1, func(i int, b *BlockGen) {
 		b.SetCoinbase(aa)
 		txdata := &types.SetCodeTx{
-			ChainID:               uint256.MustFromBig(gspec.Config.ChainID),
-			Nonce:                 0,
-			To:                    addr1,
-			Gas:                   500000,
-			GasFeeCap:             uint256.MustFromBig(newGwei(5)),
-			GasTipCap:             uint256.NewInt(2),
-			SetCodeAuthorizations: []types.SetCodeAuthorization{auth1, auth2},
+			ChainID:   uint256.MustFromBig(gspec.Config.ChainID),
+			Nonce:     0,
+			To:        addr1,
+			Gas:       500000,
+			GasFeeCap: uint256.MustFromBig(newGwei(5)),
+			GasTipCap: uint256.NewInt(2),
+			AuthList:  []types.SetCodeAuthorization{auth1, auth2},
 		}
 		tx := types.MustSignNewTx(key1, signer, txdata)
 		b.AddTx(tx)

core/state_processor_test.go

@@ -24,6 +24,7 @@ import (
 	"golang.org/x/crypto/sha3"
 
 	"github.com/holiman/uint256"
+
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/common/math"
 	"github.com/scroll-tech/go-ethereum/consensus"
@@ -97,14 +98,14 @@ func TestStateProcessorErrors(t *testing.T) {
 	}
 	var mkSetCodeTx = func(nonce uint64, to common.Address, gasLimit uint64, gasTipCap, gasFeeCap *big.Int, setCodeAuthorizations []types.SetCodeAuthorization) *types.Transaction {
 		tx, err := types.SignTx(types.NewTx(&types.SetCodeTx{
-			ChainID:               uint256.MustFromBig(config.ChainID),
-			Nonce:                 nonce,
-			GasTipCap:             uint256.MustFromBig(gasTipCap),
-			GasFeeCap:             uint256.MustFromBig(gasFeeCap),
-			Gas:                   gasLimit,
-			To:                    to,
-			Value:                 new(uint256.Int),
-			SetCodeAuthorizations: setCodeAuthorizations,
+			ChainID:   uint256.MustFromBig(config.ChainID),
+			Nonce:     nonce,
+			GasTipCap: uint256.MustFromBig(gasTipCap),
+			GasFeeCap: uint256.MustFromBig(gasFeeCap),
+			Gas:       gasLimit,
+			To:        to,
+			Value:     new(uint256.Int),
+			AuthList:  setCodeAuthorizations,
 		}), signer, key1)
 		if err != nil {
 			t.Fatal(err)

core/tx_pool.go

@@ -33,6 +33,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/core/rawdb"
 	"github.com/scroll-tech/go-ethereum/core/state"
 	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto/codehash"
 	"github.com/scroll-tech/go-ethereum/ethdb"
 	"github.com/scroll-tech/go-ethereum/event"
 	"github.com/scroll-tech/go-ethereum/log"
@@ -263,6 +264,20 @@ func (config *TxPoolConfig) sanitize() TxPoolConfig {
 // The pool separates processable transactions (which can be applied to the
 // current state) and future transactions. Transactions move between those
 // two states over time as they are received and processed.
+//
+// In addition to tracking transactions, the pool also tracks a set of pending SetCode
+// authorizations (EIP7702). This helps minimize number of transactions that can be
+// trivially churned in the pool. As a standard rule, any account with a deployed
+// delegation or an in-flight authorization to deploy a delegation will only be allowed a
+// single transaction slot instead of the standard number. This is due to the possibility
+// of the account being sweeped by an unrelated account.
+//
+// Because SetCode transactions can have many authorizations included, we avoid explicitly
+// checking their validity to save the state lookup. So long as the encompassing
+// transaction is valid, the authorization will be accepted and tracked by the pool. In
+// case the pool is tracking a pending / queued transaction from a specific account, it
+// will reject new transactions with delegations from that account with standard in-flight
+// transactions.
 type TxPool struct {
 	config      TxPoolConfig
 	chainconfig *params.ChainConfig
@@ -789,41 +804,41 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {
 		return ErrInsufficientFunds
 	}
-	usedAndLeftSlots := func(addr common.Address) (int, int) {
-		var have int
-		if list := pool.pending[addr]; list != nil {
-			have += list.Len()
-		}
-		if list := pool.queue[addr]; list != nil {
-			have += list.Len()
-		}
-		if pool.currentState.GetCode(addr) != nil {
-			// Allow at most one in-flight tx for delegated accounts.
-			return have, max(0, 1-have)
-		}
-		return have, math.MaxInt
-	}
-	if used, left := usedAndLeftSlots(from); left <= 0 {
-		return fmt.Errorf("%w: pooled %d txs", ErrAccountLimitExceeded, used)
-	}
-	knownConflicts := func(from common.Address, auths []common.Address) []common.Address {
-		var conflicts []common.Address
-		// The transaction sender cannot have an in-flight authorization.
-		if _, ok := pool.all.auths[from]; ok {
-			conflicts = append(conflicts, from)
-		}
-		// Authorities cannot conflict with any pending or queued transactions.
-		for _, addr := range auths {
+	list := pool.pending[from]
+	if list == nil || !list.Overlaps(tx) {
+		usedAndLeftSlots := func(addr common.Address) (int, int) {
+			var have int
 			if list := pool.pending[addr]; list != nil {
-				conflicts = append(conflicts, addr)
-			} else if list := pool.queue[addr]; list != nil {
-				conflicts = append(conflicts, addr)
+				have += list.Len()
 			}
+			if list := pool.queue[addr]; list != nil {
+				have += list.Len()
+			}
+			if pool.currentState.GetKeccakCodeHash(addr) != codehash.EmptyKeccakCodeHash || len(pool.all.auths[addr]) != 0 {
+				// Allow at most one in-flight tx for delegated accounts or those with
+				// a pending authorization.
+				return have, max(0, 1-have)
+			}
+			return have, math.MaxInt
+		}
+		if used, left := usedAndLeftSlots(from); left <= 0 {
+			return fmt.Errorf("%w: pooled %d txs", ErrAccountLimitExceeded, used)
+		}
+		knownConflicts := func(auths []common.Address) []common.Address {
+			var conflicts []common.Address
+			// Authorities cannot conflict with any pending or queued transactions.
+			for _, addr := range auths {
+				if list := pool.pending[addr]; list != nil {
+					conflicts = append(conflicts, addr)
+				} else if list := pool.queue[addr]; list != nil {
+					conflicts = append(conflicts, addr)
+				}
+			}
+			return conflicts
+		}
+		if conflicts := knownConflicts(tx.SetCodeAuthorities()); len(conflicts) > 0 {
+			return fmt.Errorf("%w: authorization conflicts with other known tx", ErrAuthorityReserved)
 		}
-		return conflicts
-	}
-	if conflicts := knownConflicts(from, tx.Authorities()); len(conflicts) > 0 {
-		return fmt.Errorf("%w: authorization conflicts with other known tx", ErrAuthorityReserved)
 	}
 	if tx.Type() == types.SetCodeTxType {
 		if len(tx.SetCodeAuthorizations()) == 0 {
@@ -2018,15 +2033,15 @@ type txLookup struct {
 	locals  map[common.Hash]*types.Transaction
 	remotes map[common.Hash]*types.Transaction
 
-	auths map[common.Address][]*types.Transaction // All accounts with a pooled authorization
+	auths map[common.Address][]common.Hash // All accounts with a pooled authorization
 }
 
 // newTxLookup returns a new txLookup structure.
 func newTxLookup() *txLookup {
 	return &txLookup{
 		locals:  make(map[common.Hash]*types.Transaction),
 		remotes: make(map[common.Hash]*types.Transaction),
-		auths:   make(map[common.Address][]*types.Transaction),
+		auths:   make(map[common.Address][]common.Hash),
 	}
 }
 
@@ -2133,6 +2148,7 @@ func (t *txLookup) Remove(hash common.Hash) {
 	t.lock.Lock()
 	defer t.lock.Unlock()
 
+	t.removeAuthorities(hash)
 	tx, ok := t.locals[hash]
 	if !ok {
 		tx, ok = t.remotes[hash]
@@ -2143,7 +2159,6 @@ func (t *txLookup) Remove(hash common.Hash) {
 	}
 	t.slots -= numSlots(tx)
 	slotsGauge.Update(int64(t.slots))
-	t.removeAuthorities(tx)
 
 	delete(t.locals, hash)
 	delete(t.remotes, hash)
@@ -2181,30 +2196,30 @@ func (t *txLookup) RemotesBelowTip(threshold *big.Int) types.Transactions {
 // addAuthorities tracks the supplied tx in relation to each authority it
 // specifies.
 func (t *txLookup) addAuthorities(tx *types.Transaction) {
-	for _, addr := range tx.Authorities() {
+	for _, addr := range tx.SetCodeAuthorities() {
 		list, ok := t.auths[addr]
 		if !ok {
-			list = []*types.Transaction{}
+			list = []common.Hash{}
 		}
-		if slices.Contains(list, tx) {
+		if slices.Contains(list, tx.Hash()) {
 			// Don't add duplicates.
 			continue
 		}
-		list = append(list, tx)
+		list = append(list, tx.Hash())
 		t.auths[addr] = list
 	}
 }
 
 // removeAuthorities stops tracking the supplied tx in relation to its
 // authorities.
-func (t *txLookup) removeAuthorities(tx *types.Transaction) {
-	for _, addr := range tx.Authorities() {
-		// Remove tx from tracker.
+func (t *txLookup) removeAuthorities(hash common.Hash) {
+	for addr := range t.auths {
 		list := t.auths[addr]
-		if i := slices.Index(list, tx); i >= 0 {
+		// Remove tx from tracker.
+		if i := slices.Index(list, hash); i >= 0 {
 			list = append(list[:i], list[i+1:]...)
 		} else {
-			log.Error("Authority with untracked tx", "addr", addr, "hash", tx.Hash())
+			log.Error("Authority with untracked tx", "addr", addr, "hash", hash)
 		}
 		if len(list) == 0 {
 			// If list is newly empty, delete it entirely.