Prune RBF-replaced pending txs from history

A replaced/evicted unconfirmed tx lingered forever as a phantom pending
receive (signetfaucet fee-bumps its batch payout every few minutes, so
History grew a new copy per bump). The poll now status-checks pending
txs — via /tx/:txid, since /tx/:txid/status answers 200 confirmed:false
for txids the node no longer knows — drops the vanished ones, and
re-fetches their addresses' coins and history, which _reconcileHeld
skips when the replacement pays identical amounts.

Co-Authored-By: Claude Fable 5 <[email protected]>

1 files changed, 44 insertions, 0 deletions

diff --git a/src/wallet.js b/src/wallet.js
index a5d7b6e..93f5c39 100644
--- a/src/wallet.js
+++ b/src/wallet.js
@@ -476,6 +476,9 @@ export class Wallet {
       // would otherwise never reconcile without a full rescan).
       if (await this._reconcileHeld()) changed = true;
 
+      // Drop pending txs the mempool no longer knows (RBF-replaced/evicted).
+      if (await this._pruneReplaced()) changed = true;
+
       if (changed) {
         this.utxos.sort((x, y) => y.value - x.value);
         this._sortTxs();
@@ -774,6 +777,47 @@ export class Wallet {
     return s;
   }
 
+  // Unconfirmed txs the mempool no longer knows were RBF-replaced or evicted —
+  // e.g. a faucet fee-bumping its batched payout mints a new txid each round.
+  // The utxo reconcile follows the replacement (address utxos are re-fetched),
+  // but without this every replaced version lingers in History as a phantom
+  // pending receive. Only a definitive 404 prunes; transient errors keep the
+  // tx for the next poll, and a fresh tx gets a grace period in case the
+  // polled explorer hasn't indexed our own broadcast yet.
+  async _pruneReplaced() {
+    const stale = this.txs.filter((t) => !t.confirmed && Date.now() - (t.firstSeen || 0) > 60_000);
+    let changed = false;
+    for (const t of stale) {
+      let status;
+      try { status = await this.api.txStatus(t.txid); } catch { continue; }
+      if (status !== null) continue;
+      this.txs = this.txs.filter((x) => x.txid !== t.txid);
+      changed = true;
+      // A replacement often pays the same address the same amount, which
+      // _reconcileHeld skips as "unchanged" — so the dead outpoints (and the
+      // missing replacement tx) must be re-fetched here explicitly.
+      const addrs = [...new Set(this.utxos.filter((u) => u.txid === t.txid).map((u) => u.address))];
+      for (const address of addrs) {
+        const p = this.addrMap.get(address);
+        if (!p) continue;
+        try {
+          const us = await this.api.addressUtxos(address);
+          this.utxos = this.utxos.filter((u) => u.address !== address);
+          for (const u of us) {
+            this.utxos.push({ txid: u.txid, vout: u.vout, value: u.value, address, chain: p.chain, index: p.index, confirmed: !!u.status.confirmed });
+          }
+          const list = await this.api.addressTxs(address);
+          for (const tx of list) {
+            const summary = this._txSummary(tx);
+            const at = this.txs.findIndex((x) => x.txid === tx.txid);
+            if (at >= 0) this.txs[at] = summary; else this.txs.push(summary);
+          }
+        } catch {}
+      }
+    }
+    return changed;
+  }
+
   _sortTxs() {
     this.txs.sort((a, b) => {
       if (a.confirmed !== b.confirmed) return a.confirmed ? 1 : -1; // pending first