cache, serve & display more comprehensive RBF info

backend/src/api/bitcoin/bitcoin.routes.ts

@@ -18,6 +18,7 @@ import blocks from '../blocks';
 import bitcoinClient from './bitcoin-client';
 import difficultyAdjustment from '../difficulty-adjustment';
 import transactionRepository from '../../repositories/TransactionRepository';
+import rbfCache from '../rbf-cache';
 
 class BitcoinRoutes {
   public initRoutes(app: Application) {
@@ -31,6 +32,8 @@ class BitcoinRoutes {
       .get(config.MEMPOOL.API_URL_PREFIX + 'backend-info', this.getBackendInfo)
       .get(config.MEMPOOL.API_URL_PREFIX + 'init-data', this.getInitData)
       .get(config.MEMPOOL.API_URL_PREFIX + 'validate-address/:address', this.validateAddress)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'tx/:txId/replaces', this.getRbfHistory)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'tx/:txId/cached', this.getCachedTx)
       .post(config.MEMPOOL.API_URL_PREFIX + 'tx/push', this.$postTransactionForm)
       .get(config.MEMPOOL.API_URL_PREFIX + 'donations', async (req, res) => {
         try {
@@ -589,6 +592,28 @@ class BitcoinRoutes {
     }
   }
 
+  private async getRbfHistory(req: Request, res: Response) {
+    try {
+      const result = rbfCache.getReplaces(req.params.txId);
+      res.json(result?.txids || []);
+    } catch (e) {
+      res.status(500).send(e instanceof Error ? e.message : e);
+    }
+  }
+
+  private async getCachedTx(req: Request, res: Response) {
+    try {
+      const result = rbfCache.getTx(req.params.txId);
+      if (result) {
+        res.json(result);
+      } else {
+        res.status(404).send('not found');
+      }
+    } catch (e) {
+      res.status(500).send(e instanceof Error ? e.message : e);
+    }
+  }
+
   private async getTransactionOutspends(req: Request, res: Response) {
     try {
       const result = await bitcoinApi.$getOutspends(req.params.txId);

backend/src/api/common.ts

@@ -51,8 +51,6 @@ export class Common {
   static findRbfTransactions(added: TransactionExtended[], deleted: TransactionExtended[]): { [txid: string]: TransactionExtended } {
     const matches: { [txid: string]: TransactionExtended } = {};
     deleted
-      // The replaced tx must have at least one input with nSequence < maxint-1 (That’s the opt-in)
-      .filter((tx) => tx.vin.some((vin) => vin.sequence < 0xfffffffe))
       .forEach((deletedTx) => {
         const foundMatches = added.find((addedTx) => {
           // The new tx must, absolutely speaking, pay at least as much fee as the replaced tx.

backend/src/api/mempool.ts

@@ -210,7 +210,7 @@ class Mempool {
     for (const rbfTransaction in rbfTransactions) {
       if (this.mempoolCache[rbfTransaction]) {
         // Store replaced transactions
-        rbfCache.add(rbfTransaction, rbfTransactions[rbfTransaction].txid);
+        rbfCache.add(this.mempoolCache[rbfTransaction], rbfTransactions[rbfTransaction].txid);
         // Erase the replaced transactions from the local mempool
         delete this.mempoolCache[rbfTransaction];
       }

backend/src/api/rbf-cache.ts

@@ -1,31 +1,64 @@
+import { TransactionExtended } from "../mempool.interfaces";
+
 export interface CachedRbf {
   txid: string;
   expires: Date;
 }
 
+export interface CachedRbfs {
+  txids: string[];
+  expires: Date;
+}
+
 class RbfCache {
-  private cache: { [txid: string]: CachedRbf; } = {};
+  private replacedby: { [txid: string]: CachedRbf; } = {};
+  private replaces: { [txid: string]: CachedRbfs } = {};
+  private txs: { [txid: string]: TransactionExtended } = {};
 
   constructor() {
     setInterval(this.cleanup.bind(this), 1000 * 60 * 60);
   }
 
-  public add(replacedTxId: string, newTxId: string): void {
-    this.cache[replacedTxId] = {
-      expires: new Date(Date.now() + 1000 * 604800), // 1 week
+  public add(replacedTx: TransactionExtended, newTxId: string): void {
+    const expiry = new Date(Date.now() + 1000 * 604800); // 1 week
+    this.replacedby[replacedTx.txid] = {
+      expires: expiry,
       txid: newTxId,
     };
+    this.txs[replacedTx.txid] = replacedTx;
+    if (!this.replaces[newTxId]) {
+      this.replaces[newTxId] = {
+        txids: [],
+        expires: expiry,
+      };
+    }
+    this.replaces[newTxId].txids.push(replacedTx.txid);
+    this.replaces[newTxId].expires = expiry;
   }
 
-  public get(txId: string): CachedRbf | undefined {
-    return this.cache[txId];
+  public getReplacedBy(txId: string): CachedRbf | undefined {
+    return this.replacedby[txId];
+  }
+
+  public getReplaces(txId: string): CachedRbfs | undefined {
+    return this.replaces[txId];
+  }
+
+  public getTx(txId: string): TransactionExtended | undefined {
+    return this.txs[txId];
   }
 
   private cleanup(): void {
     const currentDate = new Date();
-    for (const c in this.cache) {
-      if (this.cache[c].expires < currentDate) {
-        delete this.cache[c];
+    for (const c in this.replacedby) {
+      if (this.replacedby[c].expires < currentDate) {
+        delete this.replacedby[c];
+        delete this.txs[c];
+      }
+    }
+    for (const c in this.replaces) {
+      if (this.replaces[c].expires < currentDate) {
+        delete this.replaces[c];
       }
     }
   }

backend/src/api/websocket-handler.ts

@@ -58,7 +58,7 @@ class WebsocketHandler {
               client['track-tx'] = parsedMessage['track-tx'];
               // Client is telling the transaction wasn't found
               if (parsedMessage['watch-mempool']) {
-                const rbfCacheTx = rbfCache.get(client['track-tx']);
+                const rbfCacheTx = rbfCache.getReplacedBy(client['track-tx']);
                 if (rbfCacheTx) {
                   response['txReplaced'] = {
                     txid: rbfCacheTx.txid,