fix(eth): clear the wrapped mempool on alt-cache read-path eviction

GetTransaction's read-path staleness eviction called RemoveTransaction, which
clears only the alternative-provider cache, whereas every reconcile/RBF eviction
routes through removeMempoolTx and its removeTransactionFromMempool delegate that
also clears the wrapped Blockbook mempool's per-address index. The gap was masked
because the caller (EthereumRPC.GetTransaction) then queries the primary RPC and,
on a null result, cleans the mempool itself - but when that primary
eth_getTransactionByHash call errors instead of returning null, it returns early
without cleanup, leaving the expired private tx listed as pending for the address
until the 10-minute mempool sweep.

Route the read-path eviction through removeMempoolTx like the others. Safe from
re-entrancy: GetTransaction holds no mempool lock when calling the provider, and
MempoolEthereumType.RemoveTransactionFromMempool takes only its own mutex.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: pragmaxim

bchain/coins/eth/alternativesendtx.go

@@ -427,11 +427,13 @@ func (p *AlternativeSendTxProvider) GetTransaction(txid string) (*bchain.RpcTran
 	if found {
 		if time.Unix(int64(storedTx.time), 0).Before(time.Now().Add(-p.mempoolTxsTimeout)) {
 			// the same staleness timeout the reconcile loop applies, just reached on the read path
-			// first; record it so the timeout counter and residence histogram do not undercount
-			// entries read after expiry but before the next reconcile cycle evicts them - but only
-			// if this read is the one that removed the entry, so a concurrent reconcile eviction of
-			// the same expired tx does not also count it.
-			if p.RemoveTransaction(txid) {
+			// first; route it through removeMempoolTx (not RemoveTransaction) so the wrapped
+			// Blockbook mempool's per-address index is cleared too - otherwise, when the caller's
+			// own primary-RPC lookup errors instead of returning null, the expired private tx keeps
+			// being listed as pending for the address until the 10-minute mempool sweep. Record the
+			// exit only if this read is the one that removed the entry, so a concurrent reconcile
+			// eviction of the same expired tx does not also count it.
+			if p.removeMempoolTx(txid) {
 				p.observeMempoolReconciliation("timeout")
 				p.observeMempoolTxResidence("timeout", storedTx.time)
 			}

bchain/coins/eth/alternativesendtx_test.go

@@ -1401,3 +1401,35 @@ func TestAlternativeSendTxProviderHandleMempoolTransactionSkipsStaleFetchBack(t
 		t.Fatal("newer replacement was evicted by a stale older-generation fetch-back")
 	}
 }
+
+// TestAlternativeSendTxProviderGetTransactionTimeoutCleansWrappedMempool verifies the read-path
+// staleness eviction routes through the removeTransactionFromMempool delegate (which clears the
+// wrapped Blockbook mempool's address index), not the cache-only RemoveTransaction. Before the fix
+// an expired private tx lingered in the wrapped mempool whenever the caller's own primary-RPC
+// lookup errored instead of returning null (finding #3).
+func TestAlternativeSendTxProviderGetTransactionTimeoutCleansWrappedMempool(t *testing.T) {
+	var removed string
+	provider := &AlternativeSendTxProvider{
+		fetchMempoolTx:    true,
+		mempoolTxsTimeout: time.Minute,
+		mempoolTxs: map[string]storedTx{
+			testAlternativeTxID: {
+				tx:   &bchain.RpcTransaction{Hash: testAlternativeTxID, From: "0x2222222222222222222222222222222222222222", AccountNonce: "0x1"},
+				time: uint32(time.Now().Add(-2 * time.Minute).Unix()), // already past mempoolTxsTimeout
+			},
+		},
+		metrics: newReconcileTestMetrics(),
+	}
+	// stands in for EthereumRPC.removeTransactionFromMempool, which clears b.Mempool too
+	provider.removeTransactionFromMempool = func(txid string) { removed = txid; provider.RemoveTransaction(txid) }
+
+	if _, found := provider.GetTransaction(testAlternativeTxID); found {
+		t.Fatal("expired tx returned as found")
+	}
+	if removed != testAlternativeTxID {
+		t.Fatalf("removeTransactionFromMempool delegate not invoked on read-path timeout; removed=%q, want %q", removed, testAlternativeTxID)
+	}
+	if _, found := provider.mempoolTxs[testAlternativeTxID]; found {
+		t.Fatal("expired tx remained in provider cache")
+	}
+}