fix(core/txpool,core/txpool/locals): hold back local resubmits below the gas price floor

A gas schedule fork raises the floor above transactions that were admitted
under the previous tier, and the pool sweeps them out. The local tracker kept
resubmitting them every minute: recheck ignored the result of pool.Add, and the
transactions never went stale because their nonce never advanced, so they
stayed tracked and journalled forever.

Hold back any tracked transaction priced below the current floor, resolved for
the block pending on top of the head exactly as admission validation resolves
it. They stay tracked, so a reorg or a set-head rollback that lowers the floor
picks them up again on the next recheck: the pool does not bring back what it
swept, so the tracker is the only thing that can. Special transactions stay
exempt, as they are during admission.

Resolve the floor through a new TxPool.MinGasPrice, which goes through the
same pendingBlockNumber helper as admission validation and the sweep, so the
tracker and the pool cannot price the same transaction at different heights.

Report the held back transactions through txpool/local/belowfloor, since they
are still counted by txpool/local.

Pin that ErrUnderMinGasPrice is not a temporary reject: the floor only rises as
the chain advances, so retrying cannot help and AddLocal must not track the
transaction, but the error must not be used to drop a tracked one either.

Cover the floor with tests that rewind the head with SetHead across every tier
boundary and cover a head without a block number, the hold-back at exactly the
floor and one wei below it, resumption once the floor drops, and the exemption
special transactions keep.

Author: gzliudan

core/txpool/locals/errors.go

@@ -26,6 +26,12 @@ import (
 // IsTemporaryReject determines whether the given error indicates a temporary
 // reason to reject a transaction from being included in the txpool. The result
 // may change if the txpool's state changes later.
+//
+// ErrUnderMinGasPrice must stay out of this set: the floor only rises as the
+// chain advances, so retrying the same transaction cannot help while it stays
+// where it is. It must not be used to drop a tracked transaction either -- a
+// rollback or a reorg past the fork lowers the floor again, and the local
+// tracker is the only thing that can bring those transactions back.
 func IsTemporaryReject(err error) bool {
 	switch {
 	case errors.Is(err, legacypool.ErrOutOfOrderTxFromDelegated):

core/txpool/locals/errors_test.go

@@ -0,0 +1,41 @@
+// Copyright 2025 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package locals
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/XinFinOrg/XDPoSChain/core/txpool"
+)
+
+// TestIsTemporaryRejectExcludesMinGasPrice pins that a transaction priced below
+// the gas schedule floor is not a temporary reject: the floor only rises as the
+// chain advances, so retrying it cannot help and AddLocal must not track it.
+func TestIsTemporaryRejectExcludesMinGasPrice(t *testing.T) {
+	if IsTemporaryReject(txpool.ErrUnderMinGasPrice) {
+		t.Error("ErrUnderMinGasPrice must not be a temporary reject")
+	}
+	// The pool's own price limit is a node local setting that can change, so it
+	// stays retryable. The contrast is what the assertion above is about.
+	if !IsTemporaryReject(txpool.ErrUnderpriced) {
+		t.Error("ErrUnderpriced must remain a temporary reject")
+	}
+	if IsTemporaryReject(errors.New("unrelated failure")) {
+		t.Error("an unrelated error must not be a temporary reject")
+	}
+}

core/txpool/locals/tx_tracker.go

@@ -35,6 +35,16 @@ import (
 var (
 	recheckInterval = time.Minute
 	localGauge      = metrics.GetOrRegisterGauge("txpool/local", nil)
+
+	// Tracked transactions a gas schedule fork priced out of the pool. They stay
+	// tracked so a rollback past the fork can pick them up again, but recheck
+	// holds them back from resubmission, so they are broken out here.
+	//
+	// Only transactions missing from the pool are counted: a tracked transaction
+	// the pool still has is counted as ok instead. local minus belowfloor is
+	// therefore the tracked transactions the pool holds plus the ones recheck
+	// resubmits this round, not just the latter.
+	belowFloorGauge = metrics.GetOrRegisterGauge("txpool/local/belowfloor", nil)
 )
 
 // TxTracker is a struct used to track priority transactions; it will check from
@@ -152,10 +162,15 @@ func (tracker *TxTracker) recheck(journalCheck bool) []*types.Transaction {
 	defer tracker.mu.Unlock()
 
 	var (
-		numStales = 0
-		numOk     = 0
-		resubmits []*types.Transaction
+		numStales     = 0
+		numOk         = 0
+		numBelowFloor = 0
+		resubmits     []*types.Transaction
 	)
+	// Resolved once: it can only change on a chain head update, and a change
+	// mid-recheck would make the counters below inconsistent.
+	floor := tracker.pool.MinGasPrice()
+
 	for sender, txs := range tracker.byAddr {
 		// Wipe the stales
 		stales := txs.Forward(tracker.pool.Nonce(sender))
@@ -170,6 +185,17 @@ func (tracker *TxTracker) recheck(journalCheck bool) []*types.Transaction {
 				numOk++
 				continue
 			}
+			// A gas schedule fork can raise the floor above transactions that
+			// were admitted under the previous tier. Re-submitting them only
+			// yields ErrUnderMinGasPrice, so hold them back until the floor
+			// drops again: a reorg or a set-head rollback past the fork
+			// reinstates them, and the pool does not bring back what it swept.
+			// They stay tracked, so recheck picks them up again on its own.
+			// Special transactions are exempt, exactly as during admission.
+			if !tx.IsSpecialTransaction() && tx.GasPriceIntCmp(floor) < 0 {
+				numBelowFloor++
+				continue
+			}
 			resubmits = append(resubmits, tx)
 		}
 	}
@@ -197,7 +223,9 @@ func (tracker *TxTracker) recheck(journalCheck bool) []*types.Transaction {
 		}
 	}
 	localGauge.Update(int64(len(tracker.all)))
-	log.Debug("Tx tracker status", "need-resubmit", len(resubmits), "stale", numStales, "ok", numOk)
+	belowFloorGauge.Update(int64(numBelowFloor))
+	log.Debug("Tx tracker status", "need-resubmit", len(resubmits), "stale", numStales,
+		"ok", numOk, "below-floor", numBelowFloor)
 	return resubmits
 }
 

core/txpool/locals/tx_tracker_test.go

@@ -517,3 +517,103 @@ func TestJournalLoadKeepsLastEntryPerNonce(t *testing.T) {
 		t.Fatalf("the entry later in the file must survive the load: %v", replaced.Hash())
 	}
 }
+
+func TestRecheckHoldsBackBelowFloorTransactions(t *testing.T) {
+	// Push the gas tier fork past the test chain so the floor resolves to the
+	// baseline tier: params.TestChainConfig schedules Gas50x at block 0, which
+	// would put the floor at 50x from genesis on. The field cannot be cleared
+	// instead, CheckConfigForkOrder requires it. Gas2500xBlock stays nil, which
+	// CheckConfigForkOrder accepts; the assignment states it explicitly.
+	cfg := *params.TestChainConfig
+	cfg.Gas50xBlock = big.NewInt(1000)
+	cfg.Gas2500xBlock = nil
+
+	env := newTestEnvWithConfig(t, 1, 0, "", &cfg)
+	defer env.close()
+
+	floor := big.NewInt(common.DefaultMinGasPrice)
+	nonce := env.nonce()
+	mk := func(n uint64, gasPrice *big.Int) *types.Transaction {
+		tx, _ := types.SignTx(types.NewTransaction(n, common.Address{0x00}, big.NewInt(1000), params.TxGas, gasPrice, nil), env.signer, key)
+		return tx
+	}
+	// Priced at the floor and one wei below it: the comparison is
+	// GasPriceIntCmp(floor) < 0, so only the latter is held back.
+	atFloor := mk(nonce, floor)
+	belowFloor := mk(nonce+1, new(big.Int).Sub(floor, big.NewInt(1)))
+
+	env.tracker.TrackAll([]*types.Transaction{atFloor, belowFloor})
+
+	resubmits := env.tracker.recheck(false)
+	if len(resubmits) != 1 || resubmits[0].Hash() != atFloor.Hash() {
+		t.Fatalf("unexpected transactions to resubmit: %v", resubmits)
+	}
+	// Held back, not dropped: it stays tracked so a lower floor picks it up.
+	if len(env.tracker.all) != 2 {
+		t.Fatalf("below-floor transaction must stay tracked, got %d", len(env.tracker.all))
+	}
+}
+
+func TestRecheckResumesAfterFloorDrops(t *testing.T) {
+	cfg := *params.TestChainConfig
+	cfg.Gas50xBlock = big.NewInt(5)
+
+	env := newTestEnvWithConfig(t, 10, 0, "", &cfg)
+	defer env.close()
+
+	// head=10, so the floor resolves at block 11: the 50x tier is active and a
+	// baseline-priced transaction is held back.
+	tx, _ := types.SignTx(types.NewTransaction(
+		env.nonce(), common.Address{0x00}, big.NewInt(1000), params.TxGas,
+		big.NewInt(common.DefaultMinGasPrice), nil), env.signer, key)
+
+	env.tracker.Track(tx)
+	if resubmits := env.tracker.recheck(false); len(resubmits) != 0 {
+		t.Fatalf("transaction below the floor must not be resubmitted: %v", resubmits)
+	}
+	if len(env.tracker.all) != 1 {
+		t.Fatalf("transaction below the floor must stay tracked, got %d", len(env.tracker.all))
+	}
+
+	// Roll the head back before the fork: the floor drops to the baseline tier,
+	// which is exactly the transaction's price, so it is let through. recheck
+	// only filters on Forward(pool.Nonce(sender)), which leaves nonce 10 alone
+	// now that the state nonce has fallen back to 3.
+	if err := env.chain.SetHead(3); err != nil {
+		t.Fatalf("failed to roll back the chain: %v", err)
+	}
+	if err := env.pool.Sync(); err != nil {
+		t.Fatalf("failed to sync the txpool: %v", err)
+	}
+
+	resubmits := env.tracker.recheck(false)
+	if len(resubmits) != 1 || resubmits[0].Hash() != tx.Hash() {
+		t.Fatalf("transaction must be resubmitted once the floor drops: %v", resubmits)
+	}
+}
+
+// TestRecheckResubmitsSpecialTransactionBelowFloor pins the exemption that keeps
+// recheck aligned with admission: special transactions are not priced against
+// the floor there either, so a gas tier fork must not strand the ones submitted
+// locally, which is what the tracker exists to guard.
+func TestRecheckResubmitsSpecialTransactionBelowFloor(t *testing.T) {
+	cfg := *params.TestChainConfig
+	cfg.Gas50xBlock = big.NewInt(5)
+
+	env := newTestEnvWithConfig(t, 10, 0, "", &cfg)
+	defer env.close()
+
+	// head=10, so the floor resolves at block 11 on the 50x tier. The
+	// transaction is priced at the baseline tier, which a plain transaction
+	// would be held back for.
+	tx, _ := types.SignTx(types.NewTransaction(
+		env.nonce(), common.BlockSignersBinary, big.NewInt(0), params.TxGas,
+		big.NewInt(common.DefaultMinGasPrice), nil), env.signer, key)
+
+	env.tracker.Track(tx)
+
+	resubmits := env.tracker.recheck(false)
+	if len(resubmits) != 1 || resubmits[0].Hash() != tx.Hash() {
+		t.Fatalf("special transaction below the floor must still be resubmitted: %v", resubmits)
+	}
+}

core/txpool/txpool.go

@@ -437,6 +437,24 @@ func (p *TxPool) Nonce(addr common.Address) uint64 {
 	return p.state.GetNonce(addr)
 }
 
+// MinGasPrice returns the gas price floor the pool enforces on the transactions
+// it admits. A pooled transaction can only be included from the next block
+// onwards, so the floor is resolved at the height of the block pending on top
+// of the current head, the height admission validation prices a transaction at.
+//
+// The head here is the chain's, which advances on block insertion, while
+// admission resolves it against the subpool's, which follows on head events.
+// The two drift for as long as a head event is in flight, so a floor read in
+// that window can differ from the one admission applies. It self-corrects on
+// the next recheck, whose period is orders of magnitude longer than the window.
+func (p *TxPool) MinGasPrice() *big.Int {
+	var number *big.Int
+	if head := p.chain.CurrentBlock(); head != nil {
+		number = head.Number
+	}
+	return params.GetMinGasPrice(pendingBlockNumber(number), p.chain.Config())
+}
+
 // Stats retrieves the current pool stats, namely the number of pending and the
 // number of queued (non-executable) transactions.
 func (p *TxPool) Stats() (int, int) {

core/txpool/txpool_local_test.go

@@ -337,3 +337,36 @@ func TestAddLocalTemporaryRejectWithoutTrackerReturnsError(t *testing.T) {
 		t.Fatalf("unexpected call order: have %v", events)
 	}
 }
+
+// TestAddLocalDoesNotTrackMinGasPriceRejectedTx checks that a local transaction
+// the pool rejects for being priced below the gas schedule floor is not tracked:
+// the floor only rises as the chain advances, so re-submitting the very same
+// transaction could never succeed. The error is still surfaced to the caller.
+func TestAddLocalDoesNotTrackMinGasPriceRejectedTx(t *testing.T) {
+	events := []string{}
+	tracker := &testLocalTracker{events: &events}
+	subpool := &testSubPool{
+		events:  &events,
+		addErrs: []error{ErrUnderMinGasPrice},
+	}
+
+	pool, err := New(0, testChain{}, []SubPool{subpool})
+	if err != nil {
+		t.Fatalf("failed to create txpool: %v", err)
+	}
+	defer pool.Close()
+
+	pool.SetLocalTracker(tracker)
+
+	tx := types.NewTransaction(0, common.Address{0x1}, big.NewInt(1), 21000, big.NewInt(1), nil)
+	err = pool.AddLocal(tx, true)
+	if !errors.Is(err, ErrUnderMinGasPrice) {
+		t.Fatalf("unexpected error: have %v, want %v", err, ErrUnderMinGasPrice)
+	}
+	if len(tracker.tracked) != 0 {
+		t.Fatalf("tracker must not receive a tx rejected by the gas price floor: %v", tracker.tracked)
+	}
+	if !reflect.DeepEqual(events, []string{"add"}) {
+		t.Fatalf("unexpected call order: have %v", events)
+	}
+}