Fix: Geth Mempool Reorg Transaction Gapping and Stuck Nonce Stalls

High-frequency algorithmic trading desks, automated MEV bots, and autonomous AI agent swarms running local go-ethereum (Geth) nodes frequently encounter an elusive transaction execution stall: following a minor 1-block or 2-block chain reorganization (reorg), an account’s transactions suddenly stop being mined. The transactions do not revert, nor are they dropped by the network; instead, they sit dormant in the local node’s mempool indefinitely.

This issue originates from a subtle logic race in go-ethereum’s core/txpool/legacypool: when a chain reorg notification arrives via block subscriptions, the reorg loop reconciles transactions from rolled-back blocks alongside newly arrived transactions awaiting processing in dirtyAccounts. A race in promoteExecutables miscalculates the active nonce continuity, tagging valid consecutive transactions as gapped and exiling them to the unexecutable queued container.

If your node has also experienced unhandled nil pointer dereferences during high-volume blob indexing, consult our analysis on Geth BlobPool Cache Nil Pointer Dereference Panic Fix.

Architectural Breakdown: Geth TxPool Reorg Race

In Geth’s legacy pool architecture, transactions for each sender account are split between two distinct data structures:

1. pending list: Continuous sequential transactions starting at the account’s on-chain state nonce, eligible for immediate block inclusion.
2. queued list: Transactions whose nonces are higher than the current executable sequence (gapped transactions) or whose balance is temporarily insufficient.

The Race Condition Mechanism

In core/txpool/legacypool/legacypool.go, the pool maintains a set of dirtyAccounts that require re-evaluation whenever the local chain head moves:

// core/txpool/legacypool/legacypool.go (Reorg processing logic)
func (pool *LegacyPool) reorg(oldHead, newHead *types.Header) {
    // 1. Identify transactions rolled back in the discarded fork
    discarded := pool.chain.GetBlocksSince(oldHead)
    
    // 2. Re-inject discarded transactions back into the pool
    for _, block := range discarded {
        for _, tx := range block.Transactions() {
            pool.insert(tx)
        }
    }
    
    // 3. CRITICAL FLAW: dirtyAccounts re-indexing race
    // If a new tx (e.g. nonce 12) was added while block containing nonce 10 was
    // being rolled back and nonce 11 was re-inserted, promoteExecutables may
    // evaluate the account before the state nonce tracker has updated.
    // Result: Nonce 11 & 12 are flagged as 'gapped' and moved to queued.
    pool.promoteExecutables(pool.dirtyAccounts)
}

Why Gapped Transactions Never Self-Heal

Once transactions enter the queued pool due to a false gapping assessment:

• Geth only re-evaluates queued transactions upon receiving new external transactions for that account, on periodic timeout sweeps (--txpool.prunecycles), or when a new block changes the on-chain nonce.
• Because the trading bot or AI agent believes the transactions are already in flight, it pauses dispatching new actions to prevent nonce collisions.
• The pipeline enters a state of mutual deadlock: the node waits for a new transaction to trigger queue promotion, while the bot waits for the queued transactions to clear.

Step-by-Step Recovery & Mitigation Protocol

To restore normal transaction flow and prevent reorg gapping stalls from paralyzing automated infrastructure, implement this three-part protocol.

1. Diagnose Queued Status via Geth IPC Console

Connect to your local Geth node via Geth console or IPC to inspect the exact state of the sender address:

// Attach to local geth IPC
// geth attach /path/to/geth.ipc

// Check mempool distribution for target account
const account = "0xYourAccountAddressHere".toLowerCase();
const inspect = txpool.inspect;

console.log("Pending:", inspect.pending[account]);
console.log("Queued:", inspect.queued[account]);

// Inspect current on-chain state nonce vs pool pending nonce
const onChainNonce = eth.getTransactionCount(account, "latest");
const pendingNonce = eth.getTransactionCount(account, "pending");

console.log(`On-Chain Nonce: ${onChainNonce} | Pool Pending Nonce: ${pendingNonce}`);

If inspect.queued[account] contains transactions starting with a nonce equal to onChainNonce, the pool has fallen victim to the reorg gapping bug.

2. Force Immediate Nonce Promotion via Replacement Tx

To immediately unstick the account without restarting the node, broadcast an EIP-1559 speedup transaction for the lowest gapped nonce with a 12% higher maxPriorityFeePerGas:

// scripts/unstickGappedTx.ts
import { createWalletClient, http, parseGwei } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';

const client = createWalletClient({
  chain: mainnet,
  transport: http('http://127.0.0.1:8545'),
});

const account = privateKeyToAccount(process.env.OPERATOR_PRIVATE_KEY as `0x${string}`);

async function forcePromote(stuckNonce: number) {
  console.log(`Broadcasting dummy self-transfer for stuck nonce: ${stuckNonce}`);
  
  const hash = await client.sendTransaction({
    account,
    to: account.address,
    value: 0n,
    nonce: stuckNonce,
    maxPriorityFeePerGas: parseGwei('2.5'), // Must be >= 10% higher than stuck tx
    maxFeePerGas: parseGwei('45'),
  });

  console.log(`Replacement tx broadcasted: ${hash}`);
}

// forcePromote(142);

Once the replacement transaction is accepted, Geth’s pool listener will re-index dirtyAccounts and automatically promote the subsequent sequential nonces (143, 144, etc.) from queued to pending.

3. Apply Hardened TxPool Startup Flags

Configure your Geth node to run more aggressive queue promotion cycles and expand pending account slots:

# Optimized Geth txpool configuration for automated traders and node runners
geth \
  --mainnet \
  --http \
  --http.api "eth,net,web3,txpool" \
  --txpool.prunecycles 1m \
  --txpool.accountslots 128 \
  --txpool.accountqueue 256 \
  --txpool.globalqueue 4096 \
  --txpool.lifetime 2h \
  --cache 8192

Production Diagnostic Matrix

Frequently Asked Questions

Q: Does this issue occur on Layer 2 rollups like Arbitrum or Optimism?

L2 rollups typically utilize centralized or sequencer-based transaction pools where blockchain reorganizations are rare or impossible outside of L1 reorgs. However, on Arbitrum Nitro or OP-Stack chains running in decentralized sequencer mode or during L1 batch submission latency, similar mempool gapping bugs can occur.

Q: Why doesn’t increasing the gas price automatically fix a gapped transaction?

A higher gas price only helps if a transaction is executable. In Geth, if a transaction is marked as gapped, the miner/block builder algorithm ignores it entirely regardless of gas fee, because EVM protocol rules forbid mining a transaction when preceding nonces are absent.

Q: Will restarting the Geth node resolve the issue?

Restarting Geth with --txpool.nolocals=false forces Geth to reload state from the latest canonical block header and rebuild the mempool from scratch, which clears the race condition. However, broadcasting a replacement transaction is faster and avoids node downtime.