[SharovBot] fix(txpool): inject mined-tx senders into state diff to evict stale pending txns (AuRa/Gnosis)

[Giulio2002]

[SharovBot]

This is the AuRa stale-pending fix (first half of the split requested by @yperbasis on #19393). The zombie-queued fix (second half) was addressed in #19449 (merged).

Implements the EL-level fix suggested by @yperbasis: make the execution layer emit state-diff UPSERT entries for system-transaction senders so the txpool evicts stale pending transactions naturally.

Root Cause

In exec3_serial.go, the block-end stateWriter is constructed with a nil accumulator:

stateWriter := state.NewWriter(se.doms.AsPutDel(se.applyTx), nil, txTask.TxNum)

This means that engine.Finalize / engine.FinalizeAndAssemble — which execute AuRa system calls (validator rewards, bridge calls, etc.) — write account changes to the DB but do not emit UPSERT entries into the accumulator. The accumulator batch is what gets forwarded to the txpool as stateChanges, so the txpool never learns that those senders' nonces advanced.

As a result:

1. The sender's nonce is mined to N+1 on-chain by a system tx
2. The sender does not appear in stateChanges.ChangeBatch
3. onSenderStateChange is never called for them
4. Their pooled pending transactions (nonce ≤ N) remain in the pending pool forever
5. Block builders attempt to include these, receive nonce too low, and produce empty or near-empty blocks

Observed on Gnosis Chain validator nodes.

Fix

Store the block accumulator on serialExecutor and pass it to the block-end stateWriter:

// exec3_serial.go — block loop, per block:
se.accumulator = accumulator          // set alongside StartChange

// block-end stateWriter (was: nil accumulator):
stateWriter := state.NewWriter(se.doms.AsPutDel(se.applyTx), se.accumulator, txTask.TxNum)

Now UpdateAccountData → ChangeAccount calls during Finalize emit UPSERT entries into the batch. The txpool receives the correct stateChanges and onSenderStateChange fires for system-tx senders, evicting stale pending transactions.

Changes

• execution/stagedsync/exec3_serial.go: add accumulator field to serialExecutor; set it per block; pass it to the block-end stateWriter
• txnprovider/txpool/pool.go: no txpool changes (previous workaround removed)
• txnprovider/txpool/pool_test.go: TestStalePendingEvictionViaMineNonce regression test

Testing

go test ./txnprovider/txpool/... -run TestStalePendingEvictionViaMineNonce -v  # PASS
go test ./txnprovider/txpool/... -count=1                                       # all PASS
go test ./execution/stagedsync/... -count=1                                     # all PASS

Related

• Closes (together with [SharovBot] fix(txpool): evict zombie queued txns exceeding MaxNonceGap #19449): [SharovBot] fix(txpool): comprehensive stale tx eviction for pending and queued sub-pools #19393
• Cherry-pick to release/3.3 will follow after merge

[yperbasis]

I'd prefer this to be fixed differently, namely for the the execution layer to emit state-diff UPSERT entries with the nonce changes for system transactions.

[Giulio2002]

[SharovBot]

Done, @yperbasis — updated to fix this at the execution layer as you suggested.

Root cause: in exec3_serial.go, the block-end stateWriter was constructed with nil accumulator:

stateWriter := state.NewWriter(se.doms.AsPutDel(se.applyTx), nil, txTask.TxNum)

This meant that engine.Finalize/engine.FinalizeAndAssemble (where AuRa system calls run) wrote account changes to the DB but never emitted them into the accumulator batch that gets forwarded to the txpool.

Fix: store the accumulator on serialExecutor and pass it to the block-end stateWriter so UpdateAccountData → ChangeAccount calls during Finalize emit the correct UPSERT entries.

The txpool workaround (ensureMinedSendersInStateDiff) has been removed entirely.

[yperbasis]

Did you check exec3_parallel?

[Giulio2002]

[SharovBot]

Yes, @yperbasis — applied the same fix to exec3_parallel.go. Both state.NewBufferedWriter(pe.rs, nil) calls at the block finalizer (lines 698 and 1562) now pass the accumulator instead of nil.

Added accumulator *shards.Accumulator field to parallelExecutor, stored at the top of pe.exec(), and referenced as pe.accumulator in blockExecutor.nextResult() (which doesn't have the parameter in scope directly).

Also fixed the lint error: added defer tx.Rollback() in the test's writeAccount helper.