Revert "Restore MSRV to 1.63"

This reverts commit a676d23a54.

LICENSE

@@ -1,5 +1,5 @@
 The Mempool Open Source Project®
-Copyright (c) 2019-2024 Mempool Space K.K. and other shadowy super-coders
+Copyright (c) 2019-2023 Mempool Space K.K. and other shadowy super-coders
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU Affero General Public License as published by the Free
@@ -12,12 +12,10 @@ or any other contributor to The Mempool Open Source Project.
 
 The Mempool Open Source Project®, Mempool Accelerator™, Mempool Enterprise®, 
 Mempool Liquidity™, mempool.space®, Be your own explorer™, Explore the full 
-Bitcoin ecosystem™, Mempool Goggles™, the mempool Logo, the mempool Square Logo, 
-the mempool block visualization Logo, the mempool Blocks Logo, the mempool 
-transaction Logo, the mempool Blocks 3 | 2 Logo, the mempool research Logo, 
-the mempool.space Vertical Logo, and the mempool.space Horizontal Logo are 
-registered trademarks or trademarks of Mempool Space K.K in Japan, 
-the United States, and/or other countries.
+Bitcoin ecosystem™, Mempool Goggles™, the mempool Logo, the mempool Square logo, 
+the mempool Blocks logo, the mempool Blocks 3 | 2 logo, the mempool.space Vertical 
+Logo, and the mempool.space Horizontal logo are registered trademarks or trademarks 
+of Mempool Space K.K in Japan, the United States, and/or other countries.
 
 See our full Trademark Policy and Guidelines for more details, published on 
 <https://mempool.space/trademark-policy>.

backend/mempool-config.sample.json

@@ -28,7 +28,7 @@
     "POOLS_JSON_URL": "https://raw.githubusercontent.com/mempool/mining-pools/master/pools-v2.json",
     "POOLS_JSON_TREE_URL": "https://api.github.com/repos/mempool/mining-pools/git/trees/master",
     "AUDIT": false,
-    "RUST_GBT": true,
+    "RUST_GBT": false,
     "LIMIT_GBT": false,
     "CPFP_INDEXING": false,
     "DISK_CACHE_BLOCK_INTERVAL": 6,

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mempool-backend",
-  "version": "3.0.1",
+  "version": "3.0.0-dev",
   "description": "Bitcoin mempool visualizer and blockchain explorer backend",
   "license": "GNU Affero General Public License v3.0",
   "homepage": "https://mempool.space",
@@ -39,7 +39,7 @@
     "prettier": "./node_modules/.bin/prettier --write \"src/**/*.{js,ts}\""
   },
   "dependencies": {
-    "@babel/core": "^7.25.2",
+    "@babel/core": "^7.24.0",
     "@mempool/electrum-client": "1.1.9",
     "@types/node": "^18.15.3",
     "axios": "~1.7.2",
@@ -47,16 +47,16 @@
     "crypto-js": "~4.2.0",
     "express": "~4.19.2",
     "maxmind": "~4.3.11",
-    "mysql2": "~3.11.0",
+    "mysql2": "~3.10.0",
     "rust-gbt": "file:./rust-gbt",
-    "redis": "^4.7.0",
+    "redis": "^4.6.6",
     "socks-proxy-agent": "~7.0.0",
     "typescript": "~4.9.3",
     "ws": "~8.18.0"
   },
   "devDependencies": {
     "@babel/code-frame": "^7.18.6",
-    "@babel/core": "^7.25.2",
+    "@babel/core": "^7.24.0",
     "@types/compression": "^1.7.2",
     "@types/crypto-js": "^4.1.1",
     "@types/express": "^4.17.17",

backend/src/api/about.routes.ts

@@ -70,7 +70,7 @@ class AboutRoutes {
           res.status(500).end();
         }
       })
-      .get(config.MEMPOOL.API_URL_PREFIX + 'services/account/images/:username/:md5', async (req, res) => {
+      .get(config.MEMPOOL.API_URL_PREFIX + 'services/account/images/:username', async (req, res) => {
         const url = `${config.MEMPOOL_SERVICES.API}/${req.originalUrl.replace('/api/v1/services/', '')}`;
         try {
           const response = await axios.get(url, { responseType: 'stream', timeout: 10000 });

backend/src/api/acceleration/acceleration.ts

@@ -1,14 +1,15 @@
 import logger from '../../logger';
 import { MempoolTransactionExtended } from '../../mempool.interfaces';
-import { GraphTx, getSameBlockRelatives, initializeRelatives, makeBlockTemplate, mempoolComparator, removeAncestors, setAncestorScores } from '../mini-miner';
+import { IEsploraApi } from '../bitcoin/esplora-api.interface';
 
 const BLOCK_WEIGHT_UNITS = 4_000_000;
+const BLOCK_SIGOPS = 80_000;
 const MAX_RELATIVE_GRAPH_SIZE = 200;
 const BID_BOOST_WINDOW = 40_000;
 const BID_BOOST_MIN_OFFSET = 10_000;
 const BID_BOOST_MAX_OFFSET = 400_000;
 
-export type Acceleration = {
+type Acceleration = {
   txid: string;
   max_bid: number;
 };
@@ -27,6 +28,31 @@ export interface AccelerationInfo {
   cost: number; // additional cost to accelerate ((cost + txSummary.effectiveFee) / txSummary.effectiveVsize) >= targetFeeRate
 }
 
+interface GraphTx {
+  txid: string;
+  vsize: number;
+  weight: number;
+  fees: {
+    base: number; // in sats
+  };
+  depends: string[];
+  spentby: string[];
+}
+
+interface MempoolTx extends GraphTx {
+  ancestorcount: number;
+  ancestorsize: number;
+  fees: { // in sats
+    base: number;
+    ancestor: number;
+  };
+
+  ancestors: Map<string, MempoolTx>,
+  ancestorRate: number;
+  individualRate: number;
+  score: number;
+}
+
 class AccelerationCosts {
   /**
    * Takes a list of accelerations and verbose block data
@@ -35,7 +61,7 @@ class AccelerationCosts {
    * @param accelerationsx
    * @param verboseBlock
    */
-  public calculateBoostRate(accelerations: Acceleration[], blockTxs: MempoolTransactionExtended[]): number {
+  public calculateBoostRate(accelerations: Acceleration[], blockTxs: IEsploraApi.Transaction[]): number {
     // Run GBT ourselves to calculate accurate effective fee rates
     // the list of transactions comes from a mined block, so we already know everything fits within consensus limits
     const template = makeBlockTemplate(blockTxs, accelerations, 1, Infinity, Infinity);
@@ -144,28 +170,108 @@ class AccelerationCosts {
   /**
    * Takes an accelerated mined txid and a target rate
    * Returns the total vsize, fees and acceleration cost (in sats) of the tx and all same-block ancestors
-   *
-   * @param txid
-   * @param medianFeeRate
+   * 
+   * @param txid 
+   * @param medianFeeRate 
    */
   public getAccelerationInfo(tx: MempoolTransactionExtended, targetFeeRate: number, transactions: MempoolTransactionExtended[]): AccelerationInfo {
     // Get same-block transaction ancestors
-    const allRelatives = getSameBlockRelatives(tx, transactions);
-    const relativesMap = initializeRelatives(allRelatives);
-    const rootTx = relativesMap.get(tx.txid) as GraphTx;
+    const allRelatives = this.getSameBlockRelatives(tx, transactions);
+    const relativesMap = this.initializeRelatives(allRelatives);
+    const rootTx = relativesMap.get(tx.txid) as MempoolTx;
 
     // Calculate cost to boost
     return this.calculateAccelerationAncestors(rootTx, relativesMap, targetFeeRate);
   }
 
+  /**
+   * Takes a raw transaction, and builds a graph of same-block relatives,
+   * and returns as a MempoolTx
+   * 
+   * @param tx 
+   */
+  private getSameBlockRelatives(tx: MempoolTransactionExtended, transactions: MempoolTransactionExtended[]): Map<string, GraphTx> {
+    const blockTxs = new Map<string, MempoolTransactionExtended>(); // map of txs in this block
+    const spendMap = new Map<string, string>(); // map of outpoints to spending txids
+    for (const tx of transactions) {
+      blockTxs.set(tx.txid, tx);
+      for (const vin of tx.vin) {
+        spendMap.set(`${vin.txid}:${vin.vout}`, tx.txid);
+      }
+    }
+
+    const relatives: Map<string, GraphTx> = new Map();
+    const stack: string[] = [tx.txid];
+
+    // build set of same-block ancestors
+    while (stack.length > 0) {
+      const nextTxid = stack.pop();
+      const nextTx = nextTxid ? blockTxs.get(nextTxid) : null;
+      if (!nextTx || relatives.has(nextTx.txid)) {
+        continue;
+      }
+
+      const mempoolTx = this.convertToGraphTx(nextTx);
+
+      mempoolTx.fees.base = nextTx.fee || 0;
+      mempoolTx.depends = nextTx.vin.map(vin => vin.txid).filter(inTxid => inTxid && blockTxs.has(inTxid)) as string[];
+      mempoolTx.spentby = nextTx.vout.map((vout, index) => spendMap.get(`${nextTx.txid}:${index}`)).filter(outTxid => outTxid && blockTxs.has(outTxid)) as string[];
+
+      for (const txid of [...mempoolTx.depends, ...mempoolTx.spentby]) {
+        if (txid) {
+          stack.push(txid);
+        }
+      }
+
+      relatives.set(mempoolTx.txid, mempoolTx);
+    }
+
+    return relatives;
+  }
+
+  /**
+   * Takes a raw transaction and converts it to MempoolTx format
+   * fee and ancestor data is initialized with dummy/null values
+   * 
+   * @param tx 
+   */
+  private convertToGraphTx(tx: MempoolTransactionExtended): GraphTx {
+    return {
+      txid: tx.txid,
+      vsize: Math.ceil(tx.weight / 4),
+      weight: tx.weight,
+      fees: {
+        base: 0, // dummy
+      },
+      depends: [], // dummy
+      spentby: [], //dummy
+    };
+  }
+
+  private convertGraphToMempoolTx(tx: GraphTx): MempoolTx {
+    return {
+      ...tx,
+      fees: {
+        base: tx.fees.base,
+        ancestor: tx.fees.base,
+      },
+      ancestorcount: 1,
+      ancestorsize: Math.ceil(tx.weight / 4),
+      ancestors: new Map<string, MempoolTx>(),
+      ancestorRate: 0,
+      individualRate: 0,
+      score: 0,
+    };
+  }
+
   /**
    * Given a root transaction, a list of in-mempool ancestors, and a target fee rate,
    * Calculate the minimum set of transactions to fee-bump, their total vsize + fees
-   *
+   * 
    * @param tx
    * @param ancestors
    */
-  private calculateAccelerationAncestors(tx: GraphTx, relatives: Map<string, GraphTx>, targetFeeRate: number): AccelerationInfo {
+  private calculateAccelerationAncestors(tx: MempoolTx, relatives: Map<string, MempoolTx>, targetFeeRate: number): AccelerationInfo {
     // add root tx to the ancestor map
     relatives.set(tx.txid, tx);
 
@@ -177,12 +283,12 @@ class AccelerationCosts {
     });
 
     // Initialize individual & ancestor fee rates
-    relatives.forEach(entry => setAncestorScores(entry));
+    relatives.forEach(entry => this.setAncestorScores(entry));
 
     // Sort by descending ancestor score
-    let sortedRelatives = Array.from(relatives.values()).sort(mempoolComparator);
+    let sortedRelatives = Array.from(relatives.values()).sort(this.mempoolComparator);
 
-    let includedInCluster: Map<string, GraphTx> | null = null;
+    let includedInCluster: Map<string, MempoolTx> | null = null;
 
     // While highest score >= targetFeeRate
     let maxIterations = MAX_RELATIVE_GRAPH_SIZE;
@@ -191,17 +297,17 @@ class AccelerationCosts {
       // Grab the highest scoring entry
       const best = sortedRelatives.shift();
       if (best) {
-        const cluster = new Map<string, GraphTx>(best.ancestors?.entries() || []);
+        const cluster = new Map<string, MempoolTx>(best.ancestors?.entries() || []);
         if (best.ancestors.has(tx.txid)) {
           includedInCluster = cluster;
         }
         cluster.set(best.txid, best);
         // Remove this cluster (it already pays over the target rate, so doesn't need to be boosted)
         // and update scores, ancestor totals and dependencies for the survivors
-        removeAncestors(cluster, relatives);
+        this.removeAncestors(cluster, relatives);
 
         // re-sort
-        sortedRelatives = Array.from(relatives.values()).sort(mempoolComparator);
+        sortedRelatives = Array.from(relatives.values()).sort(this.mempoolComparator);
       }
     }
 
@@ -239,6 +345,394 @@ class AccelerationCosts {
       nextBlockFee: Math.ceil(tx.ancestorsize * targetFeeRate),
     };
   }
+
+  /**
+   * Recursively traverses an in-mempool dependency graph, and sets a Map of in-mempool ancestors
+   * for each transaction.
+   * 
+   * @param tx 
+   * @param all 
+   */
+  private setAncestors(tx: MempoolTx, all: Map<string, MempoolTx>, visited: Map<string, Map<string, MempoolTx>>, depth: number = 0): Map<string, MempoolTx> {
+    // sanity check for infinite recursion / too many ancestors (should never happen)
+    if (depth >= 100) {
+      logger.warn('acceleration dependency calculation failed: setAncestors reached depth of 100, unable to proceed', `Accelerator`);
+      throw new Error('invalid_tx_dependencies');
+    }
+    
+    // initialize the ancestor map for this tx
+    tx.ancestors = new Map<string, MempoolTx>();
+    tx.depends.forEach(parentId => {
+      const parent = all.get(parentId);
+      if (parent) {
+        // add the parent
+        tx.ancestors?.set(parentId, parent);
+        // check for a cached copy of this parent's ancestors
+        let ancestors = visited.get(parent.txid);
+        if (!ancestors) {
+          // recursively fetch the parent's ancestors
+          ancestors = this.setAncestors(parent, all, visited, depth + 1);
+        }
+        // and add to this tx's map
+        ancestors.forEach((ancestor, ancestorId) => {
+          tx.ancestors?.set(ancestorId, ancestor);
+        });
+      }
+    });
+    visited.set(tx.txid, tx.ancestors);
+
+    return tx.ancestors;
+  }
+
+  /**
+   * Efficiently sets a Map of in-mempool ancestors for each member of an expanded relative graph
+   * by running setAncestors on each leaf, and caching intermediate results.
+   * then initializes ancestor data for each transaction
+   * 
+   * @param all 
+   */
+  private initializeRelatives(all: Map<string, GraphTx>): Map<string, MempoolTx> {
+    const mempoolTxs = new Map<string, MempoolTx>();
+    all.forEach(entry => {
+      mempoolTxs.set(entry.txid, this.convertGraphToMempoolTx(entry));
+    });
+    const visited: Map<string, Map<string, MempoolTx>> = new Map();
+    const leaves: MempoolTx[] = Array.from(mempoolTxs.values()).filter(entry => entry.spentby.length === 0);
+    for (const leaf of leaves) {
+      this.setAncestors(leaf, mempoolTxs, visited);
+    }
+    mempoolTxs.forEach(entry => {
+      entry.ancestors?.forEach(ancestor => {
+        entry.ancestorcount++;
+        entry.ancestorsize += ancestor.vsize;
+        entry.fees.ancestor += ancestor.fees.base;
+      });
+      this.setAncestorScores(entry);
+    });
+    return mempoolTxs;
+  }
+
+  /**
+   * Remove a cluster of transactions from an in-mempool dependency graph
+   * and update the survivors' scores and ancestors
+   * 
+   * @param cluster 
+   * @param ancestors 
+   */
+  private removeAncestors(cluster: Map<string, MempoolTx>, all: Map<string, MempoolTx>): void {
+    // remove
+    cluster.forEach(tx => {
+      all.delete(tx.txid);
+    });
+
+    // update survivors
+    all.forEach(tx => {
+      cluster.forEach(remove => {
+        if (tx.ancestors?.has(remove.txid)) {
+          // remove as dependency
+          tx.ancestors.delete(remove.txid);
+          tx.depends = tx.depends.filter(parent => parent !== remove.txid);
+          // update ancestor sizes and fees
+          tx.ancestorsize -= remove.vsize;
+          tx.fees.ancestor -= remove.fees.base;
+        }
+      });
+      // recalculate fee rates
+      this.setAncestorScores(tx);
+    });
+  }
+
+  /**
+   * Take a mempool transaction, and set the fee rates and ancestor score
+   * 
+   * @param tx 
+   */
+  private setAncestorScores(tx: MempoolTx): void {
+    tx.individualRate = tx.fees.base / tx.vsize;
+    tx.ancestorRate = tx.fees.ancestor / tx.ancestorsize;
+    tx.score = Math.min(tx.individualRate, tx.ancestorRate);
+  }
+
+  // Sort by descending score
+  private mempoolComparator(a, b): number {
+    return b.score - a.score;
+  }
 }
 
-export default new AccelerationCosts;
+export default new AccelerationCosts;
+
+interface TemplateTransaction {
+  txid: string;
+  order: number;
+  weight: number;
+  adjustedVsize: number; // sigop-adjusted vsize, rounded up to the nearest integer
+  sigops: number;
+  fee: number;
+  feeDelta: number;
+  ancestors: string[];
+  cluster: string[];
+  effectiveFeePerVsize: number;
+}
+
+interface MinerTransaction extends TemplateTransaction {
+  inputs: string[];
+  feePerVsize: number;
+  relativesSet: boolean;
+  ancestorMap: Map<string, MinerTransaction>;
+  children: Set<MinerTransaction>;
+  ancestorFee: number;
+  ancestorVsize: number;
+  ancestorSigops: number;
+  score: number;
+  used: boolean;
+  modified: boolean;
+  dependencyRate: number;
+}
+
+/*
+* Build a block using an approximation of the transaction selection algorithm from Bitcoin Core
+* (see BlockAssembler in https://github.com/bitcoin/bitcoin/blob/master/src/node/miner.cpp)
+*/
+export function makeBlockTemplate(candidates: IEsploraApi.Transaction[], accelerations: Acceleration[], maxBlocks: number = 8, weightLimit: number = BLOCK_WEIGHT_UNITS, sigopLimit: number = BLOCK_SIGOPS): TemplateTransaction[] {
+  const auditPool: Map<string, MinerTransaction> = new Map();
+  const mempoolArray: MinerTransaction[] = [];
+  
+  candidates.forEach(tx => {
+    // initializing everything up front helps V8 optimize property access later
+    const adjustedVsize = Math.ceil(Math.max(tx.weight / 4, 5 * (tx.sigops || 0)));
+    const feePerVsize = (tx.fee / adjustedVsize);
+    auditPool.set(tx.txid, {
+      txid: tx.txid,
+      order: txidToOrdering(tx.txid),
+      fee: tx.fee,
+      feeDelta: 0,
+      weight: tx.weight,
+      adjustedVsize,
+      feePerVsize: feePerVsize,
+      effectiveFeePerVsize: feePerVsize,
+      dependencyRate: feePerVsize,
+      sigops: tx.sigops || 0,
+      inputs: (tx.vin?.map(vin => vin.txid) || []) as string[],
+      relativesSet: false,
+      ancestors: [],
+      cluster: [],
+      ancestorMap: new Map<string, MinerTransaction>(),
+      children: new Set<MinerTransaction>(),
+      ancestorFee: 0,
+      ancestorVsize: 0,
+      ancestorSigops: 0,
+      score: 0,
+      used: false,
+      modified: false,
+    });
+    mempoolArray.push(auditPool.get(tx.txid) as MinerTransaction);
+  });
+
+  // set accelerated effective fee
+  for (const acceleration of accelerations) {
+    const tx = auditPool.get(acceleration.txid);
+    if (tx) {
+      tx.feeDelta = acceleration.max_bid;
+      tx.feePerVsize = ((tx.fee + tx.feeDelta) / tx.adjustedVsize);
+      tx.effectiveFeePerVsize = tx.feePerVsize;
+      tx.dependencyRate = tx.feePerVsize;
+    }
+  }
+
+  // Build relatives graph & calculate ancestor scores
+  for (const tx of mempoolArray) {
+    if (!tx.relativesSet) {
+      setRelatives(tx, auditPool);
+    }
+  }
+
+  // Sort by descending ancestor score
+  mempoolArray.sort(priorityComparator);
+
+  // Build blocks by greedily choosing the highest feerate package
+  // (i.e. the package rooted in the transaction with the best ancestor score)
+  const blocks: number[][] = [];
+  let blockWeight = 0;
+  let blockSigops = 0;
+  const transactions: MinerTransaction[] = [];
+  let modified: MinerTransaction[] = [];
+  const overflow: MinerTransaction[] = [];
+  let failures = 0;
+  while (mempoolArray.length || modified.length) {
+    // skip invalid transactions
+    while (mempoolArray[0].used || mempoolArray[0].modified) {
+      mempoolArray.shift();
+    }
+
+    // Select best next package
+    let nextTx;
+    const nextPoolTx = mempoolArray[0];
+    const nextModifiedTx = modified[0];
+    if (nextPoolTx && (!nextModifiedTx || (nextPoolTx.score || 0) > (nextModifiedTx.score || 0))) {
+      nextTx = nextPoolTx;
+      mempoolArray.shift();
+    } else {
+      modified.shift();
+      if (nextModifiedTx) {
+        nextTx = nextModifiedTx;
+      }
+    }
+
+    if (nextTx && !nextTx?.used) {
+      // Check if the package fits into this block
+      if (blocks.length >= (maxBlocks - 1) || ((blockWeight + (4 * nextTx.ancestorVsize) < weightLimit) && (blockSigops + nextTx.ancestorSigops <= sigopLimit))) {
+        const ancestors: MinerTransaction[] = Array.from(nextTx.ancestorMap.values());
+        // sort ancestors by dependency graph (equivalent to sorting by ascending ancestor count)
+        const sortedTxSet = [...ancestors.sort((a, b) => { return (a.ancestorMap.size || 0) - (b.ancestorMap.size || 0); }), nextTx];
+        const clusterTxids = sortedTxSet.map(tx => tx.txid);
+        const effectiveFeeRate = Math.min(nextTx.dependencyRate || Infinity, nextTx.ancestorFee / nextTx.ancestorVsize);
+        const used: MinerTransaction[] = [];
+        while (sortedTxSet.length) {
+          const ancestor = sortedTxSet.pop();
+          if (!ancestor) {
+            continue;
+          }
+          ancestor.used = true;
+          ancestor.usedBy = nextTx.txid;
+          // update this tx with effective fee rate & relatives data
+          if (ancestor.effectiveFeePerVsize !== effectiveFeeRate) {
+            ancestor.effectiveFeePerVsize = effectiveFeeRate;
+          }
+          ancestor.cluster = clusterTxids;
+          transactions.push(ancestor);
+          blockWeight += ancestor.weight;
+          blockSigops += ancestor.sigops;
+          used.push(ancestor);
+        }
+
+        // remove these as valid package ancestors for any descendants remaining in the mempool
+        if (used.length) {
+          used.forEach(tx => {
+            modified = updateDescendants(tx, auditPool, modified, effectiveFeeRate);
+          });
+        }
+
+        failures = 0;
+      } else {
+        // hold this package in an overflow list while we check for smaller options
+        overflow.push(nextTx);
+        failures++;
+      }
+    }
+
+    // this block is full
+    const exceededPackageTries = failures > 1000 && blockWeight > (weightLimit - 4000);
+    const queueEmpty = !mempoolArray.length && !modified.length;
+
+    if (exceededPackageTries || queueEmpty) {
+      break;
+    }
+  }
+
+  for (const tx of transactions) {
+    tx.ancestors = Object.values(tx.ancestorMap);
+  }
+
+  return transactions;
+}
+
+// traverse in-mempool ancestors
+// recursion unavoidable, but should be limited to depth < 25 by mempool policy
+function setRelatives(
+  tx: MinerTransaction,
+  mempool: Map<string, MinerTransaction>,
+): void {
+  for (const parent of tx.inputs) {
+    const parentTx = mempool.get(parent);
+    if (parentTx && !tx.ancestorMap?.has(parent)) {
+      tx.ancestorMap.set(parent, parentTx);
+      parentTx.children.add(tx);
+      // visit each node only once
+      if (!parentTx.relativesSet) {
+        setRelatives(parentTx, mempool);
+      }
+      parentTx.ancestorMap.forEach((ancestor) => {
+        tx.ancestorMap.set(ancestor.txid, ancestor);
+      });
+    }
+  };
+  tx.ancestorFee = (tx.fee + tx.feeDelta);
+  tx.ancestorVsize = tx.adjustedVsize || 0;
+  tx.ancestorSigops = tx.sigops || 0;
+  tx.ancestorMap.forEach((ancestor) => {
+    tx.ancestorFee += (ancestor.fee + ancestor.feeDelta);
+    tx.ancestorVsize += ancestor.adjustedVsize;
+    tx.ancestorSigops += ancestor.sigops;
+  });
+  tx.score = tx.ancestorFee / tx.ancestorVsize;
+  tx.relativesSet = true;
+}
+
+// iterate over remaining descendants, removing the root as a valid ancestor & updating the ancestor score
+// avoids recursion to limit call stack depth
+function updateDescendants(
+  rootTx: MinerTransaction,
+  mempool: Map<string, MinerTransaction>,
+  modified: MinerTransaction[],
+  clusterRate: number,
+): MinerTransaction[] {
+  const descendantSet: Set<MinerTransaction> = new Set();
+  // stack of nodes left to visit
+  const descendants: MinerTransaction[] = [];
+  let descendantTx: MinerTransaction | undefined;
+  rootTx.children.forEach(childTx => {
+    if (!descendantSet.has(childTx)) {
+      descendants.push(childTx);
+      descendantSet.add(childTx);
+    }
+  });
+  while (descendants.length) {
+    descendantTx = descendants.pop();
+    if (descendantTx && descendantTx.ancestorMap && descendantTx.ancestorMap.has(rootTx.txid)) {
+      // remove tx as ancestor
+      descendantTx.ancestorMap.delete(rootTx.txid);
+      descendantTx.ancestorFee -= (rootTx.fee + rootTx.feeDelta);
+      descendantTx.ancestorVsize -= rootTx.adjustedVsize;
+      descendantTx.ancestorSigops -= rootTx.sigops;
+      descendantTx.score = descendantTx.ancestorFee / descendantTx.ancestorVsize;
+      descendantTx.dependencyRate = descendantTx.dependencyRate ? Math.min(descendantTx.dependencyRate, clusterRate) : clusterRate;
+
+      if (!descendantTx.modified) {
+        descendantTx.modified = true;
+        modified.push(descendantTx);
+      }
+
+      // add this node's children to the stack
+      descendantTx.children.forEach(childTx => {
+        // visit each node only once
+        if (!descendantSet.has(childTx)) {
+          descendants.push(childTx);
+          descendantSet.add(childTx);
+        }
+      });
+    }
+  }
+  // return new, resorted modified list
+  return modified.sort(priorityComparator);
+}
+
+// Used to sort an array of MinerTransactions by descending ancestor score
+function priorityComparator(a: MinerTransaction, b: MinerTransaction): number {
+  if (b.score === a.score) {
+    // tie-break by txid for stability
+    return a.order - b.order;
+  } else {
+    return b.score - a.score;
+  }
+}
+
+// returns the most significant 4 bytes of the txid as an integer
+function txidToOrdering(txid: string): number {
+  return parseInt(
+    txid.substring(62, 64) +
+      txid.substring(60, 62) +
+      txid.substring(58, 60) +
+      txid.substring(56, 58),
+    16
+  );
+}

backend/src/api/audit.ts

@@ -6,22 +6,20 @@ import rbfCache from './rbf-cache';
 const PROPAGATION_MARGIN = 180; // in seconds, time since a transaction is first seen after which it is assumed to have propagated to all miners
 
 class Audit {
-  auditBlock(height: number, transactions: MempoolTransactionExtended[], projectedBlocks: MempoolBlockWithTransactions[], mempool: { [txId: string]: MempoolTransactionExtended })
-   : { unseen: string[], censored: string[], added: string[], prioritized: string[], fresh: string[], sigop: string[], fullrbf: string[], accelerated: string[], score: number, similarity: number } {
+  auditBlock(transactions: MempoolTransactionExtended[], projectedBlocks: MempoolBlockWithTransactions[], mempool: { [txId: string]: MempoolTransactionExtended }, useAccelerations: boolean = false)
+   : { censored: string[], added: string[], prioritized: string[], fresh: string[], sigop: string[], fullrbf: string[], accelerated: string[], score: number, similarity: number } {
     if (!projectedBlocks?.[0]?.transactionIds || !mempool) {
-      return { unseen: [], censored: [], added: [], prioritized: [], fresh: [], sigop: [], fullrbf: [], accelerated: [], score: 1, similarity: 1 };
+      return { censored: [], added: [], prioritized: [], fresh: [], sigop: [], fullrbf: [], accelerated: [], score: 1, similarity: 1 };
     }
 
     const matches: string[] = []; // present in both mined block and template
     const added: string[] = []; // present in mined block, not in template
-    const unseen: string[] = []; // present in the mined block, not in our mempool
-    const prioritized: string[] = []; // higher in the block than would be expected by in-band feerate alone
+    const prioritized: string[] = [] // present in the mined block, not in the template, but further down in the mempool
     const fresh: string[] = []; // missing, but firstSeen or lastBoosted within PROPAGATION_MARGIN
     const rbf: string[] = []; // either missing or present, and either part of a full-rbf replacement, or a conflict with the mined block
     const accelerated: string[] = []; // prioritized by the mempool accelerator
     const isCensored = {}; // missing, without excuse
     const isDisplaced = {};
-    const isAccelerated = {};
     let displacedWeight = 0;
     let matchedWeight = 0;
     let projectedWeight = 0;
@@ -34,7 +32,6 @@ class Audit {
       inBlock[tx.txid] = tx;
       if (mempool[tx.txid] && mempool[tx.txid].acceleration) {
         accelerated.push(tx.txid);
-        isAccelerated[tx.txid] = true;
       }
     }
     // coinbase is always expected
@@ -116,16 +113,11 @@ class Audit {
       } else {
         if (rbfCache.has(tx.txid)) {
           rbf.push(tx.txid);
-          if (!mempool[tx.txid] && !rbfCache.getReplacedBy(tx.txid)) {
-            unseen.push(tx.txid);
-          }
-        } else {
+        } else if (!isDisplaced[tx.txid]) {
           if (mempool[tx.txid]) {
-            if (isDisplaced[tx.txid]) {
-              added.push(tx.txid);
-            }
+            prioritized.push(tx.txid);
           } else {
-            unseen.push(tx.txid);
+            added.push(tx.txid);
           }
         }
         overflowWeight += tx.weight;
@@ -133,24 +125,6 @@ class Audit {
       totalWeight += tx.weight;
     }
 
-
-    // identify "prioritized" transactions
-    let lastEffectiveRate = 0;
-    // Iterate over the mined template from bottom to top (excluding the coinbase)
-    // Transactions should appear in ascending order of mining priority.
-    for (let i = transactions.length - 1; i > 0; i--) {
-      const blockTx = transactions[i];
-      // If a tx has a lower in-band effective fee rate than the previous tx,
-      // it must have been prioritized out-of-band (in order to have a higher mining priority)
-      // so exclude from the analysis.
-      if ((blockTx.effectiveFeePerVsize || 0) < lastEffectiveRate) {
-        prioritized.push(blockTx.txid);
-        // accelerated txs may or may not have their prioritized fee rate applied, so don't use them as a reference
-      } else if (!isAccelerated[blockTx.txid]) {
-        lastEffectiveRate = blockTx.effectiveFeePerVsize || 0;
-      }
-    }
-
     // transactions missing from near the end of our template are probably not being censored
     let overflowWeightRemaining = overflowWeight - (config.MEMPOOL.BLOCK_WEIGHT_UNITS - totalWeight);
     let maxOverflowRate = 0;
@@ -191,7 +165,6 @@ class Audit {
     const similarity = projectedWeight ? matchedWeight / projectedWeight : 1;
 
     return {
-      unseen,
       censored: Object.keys(isCensored),
       added,
       prioritized,

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

@@ -19,7 +19,7 @@ import bitcoinClient from './bitcoin-client';
 import difficultyAdjustment from '../difficulty-adjustment';
 import transactionRepository from '../../repositories/TransactionRepository';
 import rbfCache from '../rbf-cache';
-import { calculateMempoolTxCpfp } from '../cpfp';
+import { calculateCpfp } from '../cpfp';
 
 class BitcoinRoutes {
   public initRoutes(app: Application) {
@@ -160,17 +160,15 @@ class BitcoinRoutes {
           descendants: tx.descendants || null,
           effectiveFeePerVsize: tx.effectiveFeePerVsize || null,
           sigops: tx.sigops,
-          fee: tx.fee,
           adjustedVsize: tx.adjustedVsize,
           acceleration: tx.acceleration,
           acceleratedBy: tx.acceleratedBy || undefined,
           acceleratedAt: tx.acceleratedAt || undefined,
-          feeDelta: tx.feeDelta || undefined,
         });
         return;
       }
 
-      const cpfpInfo = calculateMempoolTxCpfp(tx, mempool.getMempool());
+      const cpfpInfo = calculateCpfp(tx, mempool.getMempool());
 
       res.json(cpfpInfo);
       return;

backend/src/api/blocks.ts

@@ -30,10 +30,6 @@ import redisCache from './redis-cache';
 import rbfCache from './rbf-cache';
 import { calcBitsDifference } from './difficulty-adjustment';
 import AccelerationRepository from '../repositories/AccelerationRepository';
-import { calculateFastBlockCpfp, calculateGoodBlockCpfp } from './cpfp';
-import mempool from './mempool';
-import CpfpRepository from '../repositories/CpfpRepository';
-import accelerationApi from './services/acceleration';
 
 class Blocks {
   private blocks: BlockExtended[] = [];
@@ -440,7 +436,7 @@ class Blocks {
 
 
         if (config.MEMPOOL.BACKEND === 'esplora') {
-          const txs = (await bitcoinApi.$getTxsForBlock(block.hash)).map(tx => transactionUtils.extendMempoolTransaction(tx));
+          const txs = (await bitcoinApi.$getTxsForBlock(block.hash)).map(tx => transactionUtils.extendTransaction(tx));
           const cpfpSummary = await this.$indexCPFP(block.hash, block.height, txs);
           if (cpfpSummary) {
             await this.$getStrippedBlockTransactions(block.hash, true, true, cpfpSummary, block.height); // This will index the block summary
@@ -571,11 +567,8 @@ class Blocks {
     const blockchainInfo = await bitcoinClient.getBlockchainInfo();
     const currentBlockHeight = blockchainInfo.blocks;
 
-    const targetSummaryVersion: number = 1;
-    const targetTemplateVersion: number = 1;
-
-    const unclassifiedBlocksList = await BlocksSummariesRepository.$getSummariesBelowVersion(targetSummaryVersion);
-    const unclassifiedTemplatesList = await BlocksSummariesRepository.$getTemplatesBelowVersion(targetTemplateVersion);
+    const unclassifiedBlocksList = await BlocksSummariesRepository.$getSummariesWithVersion(0);
+    const unclassifiedTemplatesList = await BlocksSummariesRepository.$getTemplatesWithVersion(0);
 
     // nothing to do
     if (!unclassifiedBlocksList?.length && !unclassifiedTemplatesList?.length) {
@@ -608,24 +601,16 @@ class Blocks {
 
     for (let height = currentBlockHeight; height >= 0; height--) {
       try {
-        let txs: MempoolTransactionExtended[] | null = null;
+        let txs: TransactionExtended[] | null = null;
         if (unclassifiedBlocks[height]) {
           const blockHash = unclassifiedBlocks[height];
           // fetch transactions
-          txs = (await bitcoinApi.$getTxsForBlock(blockHash)).map(tx => transactionUtils.extendMempoolTransaction(tx)) || [];
+          txs = (await bitcoinApi.$getTxsForBlock(blockHash)).map(tx => transactionUtils.extendTransaction(tx)) || [];
           // add CPFP
-          const cpfpSummary = calculateGoodBlockCpfp(height, txs, []);
+          const cpfpSummary = Common.calculateCpfp(height, txs, true);
           // classify
           const { transactions: classifiedTxs } = this.summarizeBlockTransactions(blockHash, cpfpSummary.transactions);
-          await BlocksSummariesRepository.$saveTransactions(height, blockHash, classifiedTxs, 2);
-          if (unclassifiedBlocks[height].version < 2 && targetSummaryVersion === 2) {
-            const cpfpClusters = await CpfpRepository.$getClustersAt(height);
-            if (!cpfpRepository.compareClusters(cpfpClusters, cpfpSummary.clusters)) {
-              // CPFP clusters changed - update the compact_cpfp tables
-              await CpfpRepository.$deleteClustersAt(height);
-              await this.$saveCpfp(blockHash, height, cpfpSummary);
-            }
-          }
+          await BlocksSummariesRepository.$saveTransactions(height, blockHash, classifiedTxs, 1);
           await Common.sleep$(250);
         }
         if (unclassifiedTemplates[height]) {
@@ -651,7 +636,7 @@ class Blocks {
               }
               templateTxs.push(tx || templateTx);
             }
-            const cpfpSummary = calculateGoodBlockCpfp(height, templateTxs?.filter(tx => tx['effectiveFeePerVsize'] != null) as MempoolTransactionExtended[], []);
+            const cpfpSummary = Common.calculateCpfp(height, templateTxs?.filter(tx => tx['effectiveFeePerVsize'] != null) as TransactionExtended[], true);
             // classify
             const { transactions: classifiedTxs } = this.summarizeBlockTransactions(blockHash, cpfpSummary.transactions);
             const classifiedTxMap: { [txid: string]: TransactionClassified } = {};
@@ -905,12 +890,7 @@ class Blocks {
         }
       }
 
-      let accelerations = Object.values(mempool.getAccelerations());
-      if (accelerations?.length > 0) {
-        const pool = await this.$findBlockMiner(transactionUtils.stripCoinbaseTransaction(transactions[0]));
-        accelerations = accelerations.filter(a => a.pools.includes(pool.uniqueId));
-      }
-      const cpfpSummary: CpfpSummary = calculateGoodBlockCpfp(block.height, transactions, accelerations.map(a => ({ txid: a.txid, max_bid: a.feeDelta })));
+      const cpfpSummary: CpfpSummary = Common.calculateCpfp(block.height, transactions);
       const blockExtended: BlockExtended = await this.$getBlockExtended(block, cpfpSummary.transactions);
       const blockSummary: BlockSummary = this.summarizeBlockTransactions(block.id, cpfpSummary.transactions);
       this.updateTimerProgress(timer, `got block data for ${this.currentBlockHeight}`);
@@ -933,12 +913,12 @@ class Blocks {
               const newBlock = await this.$indexBlock(lastBlock.height - i);
               this.blocks.push(newBlock);
               this.updateTimerProgress(timer, `reindexed block`);
-              let newCpfpSummary;
+              let cpfpSummary;
               if (config.MEMPOOL.CPFP_INDEXING) {
-                newCpfpSummary = await this.$indexCPFP(newBlock.id, lastBlock.height - i);
+                cpfpSummary = await this.$indexCPFP(newBlock.id, lastBlock.height - i);
                 this.updateTimerProgress(timer, `reindexed block cpfp`);
               }
-              await this.$getStrippedBlockTransactions(newBlock.id, true, true, newCpfpSummary, newBlock.height);
+              await this.$getStrippedBlockTransactions(newBlock.id, true, true, cpfpSummary, newBlock.height);
               this.updateTimerProgress(timer, `reindexed block summary`);
             }
             await mining.$indexDifficultyAdjustments();
@@ -987,7 +967,7 @@ class Blocks {
 
       // start async callbacks
       this.updateTimerProgress(timer, `starting async callbacks for ${this.currentBlockHeight}`);
-      const callbackPromises = this.newAsyncBlockCallbacks.map((cb) => cb(blockExtended, txIds, cpfpSummary.transactions));
+      const callbackPromises = this.newAsyncBlockCallbacks.map((cb) => cb(blockExtended, txIds, transactions));
 
       if (block.height % 2016 === 0) {
         if (Common.indexingEnabled()) {
@@ -1169,7 +1149,7 @@ class Blocks {
         transactions: cpfpSummary.transactions.map(tx => {
           let flags: number = 0;
           try {
-            flags = Common.getTransactionFlags(tx);
+            flags = tx.flags || Common.getTransactionFlags(tx);
           } catch (e) {
             logger.warn('Failed to classify transaction: ' + (e instanceof Error ? e.message : e));
           }
@@ -1184,7 +1164,7 @@ class Blocks {
           };
         }),
       };
-      summaryVersion = cpfpSummary.version;
+      summaryVersion = 1;
     } else {
       if (config.MEMPOOL.BACKEND === 'esplora') {
         const txs = (await bitcoinApi.$getTxsForBlock(hash)).map(tx => transactionUtils.extendTransaction(tx));
@@ -1403,11 +1383,11 @@ class Blocks {
     return this.currentBlockHeight;
   }
 
-  public async $indexCPFP(hash: string, height: number, txs?: MempoolTransactionExtended[]): Promise<CpfpSummary | null> {
+  public async $indexCPFP(hash: string, height: number, txs?: TransactionExtended[]): Promise<CpfpSummary | null> {
     let transactions = txs;
     if (!transactions) {
       if (config.MEMPOOL.BACKEND === 'esplora') {
-        transactions = (await bitcoinApi.$getTxsForBlock(hash)).map(tx => transactionUtils.extendMempoolTransaction(tx));
+        transactions = (await bitcoinApi.$getTxsForBlock(hash)).map(tx => transactionUtils.extendTransaction(tx));
       }
       if (!transactions) {
         const block = await bitcoinClient.getBlock(hash, 2);
@@ -1419,7 +1399,7 @@ class Blocks {
     }
 
     if (transactions?.length != null) {
-      const summary = calculateFastBlockCpfp(height, transactions);
+      const summary = Common.calculateCpfp(height, transactions as TransactionExtended[]);
 
       await this.$saveCpfp(hash, height, summary);
 

backend/src/api/common.ts

@@ -1,6 +1,6 @@
 import * as bitcoinjs from 'bitcoinjs-lib';
 import { Request } from 'express';
-import { EffectiveFeeStats, MempoolBlockWithTransactions, TransactionExtended, MempoolTransactionExtended, TransactionStripped, WorkingEffectiveFeeStats, TransactionClassified, TransactionFlags } from '../mempool.interfaces';
+import { CpfpInfo, CpfpSummary, CpfpCluster, EffectiveFeeStats, MempoolBlockWithTransactions, TransactionExtended, MempoolTransactionExtended, TransactionStripped, WorkingEffectiveFeeStats, TransactionClassified, TransactionFlags } from '../mempool.interfaces';
 import config from '../config';
 import { NodeSocket } from '../repositories/NodesSocketsRepository';
 import { isIP } from 'net';
@@ -419,15 +419,12 @@ export class Common {
     let flags = tx.flags ? BigInt(tx.flags) : 0n;
 
     // Update variable flags (CPFP, RBF)
-    flags &= ~TransactionFlags.cpfp_child;
     if (tx.ancestors?.length) {
       flags |= TransactionFlags.cpfp_child;
     }
-    flags &= ~TransactionFlags.cpfp_parent;
     if (tx.descendants?.length) {
       flags |= TransactionFlags.cpfp_parent;
     }
-    flags &= ~TransactionFlags.replacement;
     if (tx.replacement) {
       flags |= TransactionFlags.replacement;
     }
@@ -809,6 +806,96 @@ export class Common {
     }
   }
 
+  static calculateCpfp(height: number, transactions: TransactionExtended[], saveRelatives: boolean = false): CpfpSummary {
+    const clusters: CpfpCluster[] = []; // list of all cpfp clusters in this block
+    const clusterMap: { [txid: string]: CpfpCluster } = {}; // map transactions to their cpfp cluster
+    let clusterTxs: TransactionExtended[] = []; // working list of elements of the current cluster
+    let ancestors: { [txid: string]: boolean } = {}; // working set of ancestors of the current cluster root
+    const txMap: { [txid: string]: TransactionExtended } = {};
+    // initialize the txMap
+    for (const tx of transactions) {
+      txMap[tx.txid] = tx;
+    }
+    // reverse pass to identify CPFP clusters
+    for (let i = transactions.length - 1; i >= 0; i--) {
+      const tx = transactions[i];
+      if (!ancestors[tx.txid]) {
+        let totalFee = 0;
+        let totalVSize = 0;
+        clusterTxs.forEach(tx => {
+          totalFee += tx?.fee || 0;
+          totalVSize += (tx.weight / 4);
+        });
+        const effectiveFeePerVsize = totalFee / totalVSize;
+        let cluster: CpfpCluster;
+        if (clusterTxs.length > 1) {
+          cluster = {
+            root: clusterTxs[0].txid,
+            height,
+            txs: clusterTxs.map(tx => { return { txid: tx.txid, weight: tx.weight, fee: tx.fee || 0 }; }),
+            effectiveFeePerVsize,
+          };
+          clusters.push(cluster);
+        }
+        clusterTxs.forEach(tx => {
+          txMap[tx.txid].effectiveFeePerVsize = effectiveFeePerVsize;
+          if (cluster) {
+            clusterMap[tx.txid] = cluster;
+          }
+        });
+        // reset working vars
+        clusterTxs = [];
+        ancestors = {};
+      }
+      clusterTxs.push(tx);
+      tx.vin.forEach(vin => {
+        ancestors[vin.txid] = true;
+      });
+    }
+    // forward pass to enforce ancestor rate caps
+    for (const tx of transactions) {
+      let minAncestorRate = tx.effectiveFeePerVsize;
+      for (const vin of tx.vin) {
+        if (txMap[vin.txid]?.effectiveFeePerVsize) {
+          minAncestorRate = Math.min(minAncestorRate, txMap[vin.txid].effectiveFeePerVsize);
+        }
+      }
+      // check rounded values to skip cases with almost identical fees
+      const roundedMinAncestorRate = Math.ceil(minAncestorRate);
+      const roundedEffectiveFeeRate = Math.floor(tx.effectiveFeePerVsize);
+      if (roundedMinAncestorRate < roundedEffectiveFeeRate) {
+        tx.effectiveFeePerVsize = minAncestorRate;
+        if (!clusterMap[tx.txid]) {
+          // add a single-tx cluster to record the dependent rate
+          const cluster = {
+            root: tx.txid,
+            height,
+            txs: [{ txid: tx.txid, weight: tx.weight, fee: tx.fee || 0 }],
+            effectiveFeePerVsize: minAncestorRate,
+          };
+          clusterMap[tx.txid] = cluster;
+          clusters.push(cluster);
+        } else {
+          // update the existing cluster with the dependent rate
+          clusterMap[tx.txid].effectiveFeePerVsize = minAncestorRate;
+        }
+      }
+    }
+    if (saveRelatives) {
+      for (const cluster of clusters) {
+        cluster.txs.forEach((member, index) => {
+          txMap[member.txid].descendants = cluster.txs.slice(0, index).reverse();
+          txMap[member.txid].ancestors = cluster.txs.slice(index + 1).reverse();
+          txMap[member.txid].effectiveFeePerVsize = cluster.effectiveFeePerVsize;
+        });
+      }
+    }
+    return {
+      transactions,
+      clusters,
+    };
+  }
+
   static calcEffectiveFeeStatistics(transactions: { weight: number, fee: number, effectiveFeePerVsize?: number, txid: string, acceleration?: boolean }[]): EffectiveFeeStats {
     const sortedTxs = transactions.map(tx => { return { txid: tx.txid, weight: tx.weight, rate: tx.effectiveFeePerVsize || ((tx.fee || 0) / (tx.weight / 4)) }; }).sort((a, b) => a.rate - b.rate);
 

backend/src/api/cpfp.ts

@@ -1,174 +1,29 @@
-import { Ancestor, CpfpCluster, CpfpInfo, CpfpSummary, MempoolTransactionExtended, TransactionExtended } from '../mempool.interfaces';
-import { GraphTx, convertToGraphTx, expandRelativesGraph, initializeRelatives, makeBlockTemplate, mempoolComparator, removeAncestors, setAncestorScores } from './mini-miner';
+import { CpfpInfo, MempoolTransactionExtended } from '../mempool.interfaces';
 import memPool from './mempool';
-import { Acceleration } from './acceleration/acceleration';
 
 const CPFP_UPDATE_INTERVAL = 60_000; // update CPFP info at most once per 60s per transaction
-const MAX_CLUSTER_ITERATIONS = 100;
+const MAX_GRAPH_SIZE = 50; // the maximum number of in-mempool relatives to consider
 
-export function calculateFastBlockCpfp(height: number, transactions: MempoolTransactionExtended[], saveRelatives: boolean = false): CpfpSummary {
-  const clusters: CpfpCluster[] = []; // list of all cpfp clusters in this block
-  const clusterMap: { [txid: string]: CpfpCluster } = {}; // map transactions to their cpfp cluster
-  let clusterTxs: TransactionExtended[] = []; // working list of elements of the current cluster
-  let ancestors: { [txid: string]: boolean } = {}; // working set of ancestors of the current cluster root
-  const txMap: { [txid: string]: TransactionExtended } = {};
-  // initialize the txMap
-  for (const tx of transactions) {
-    txMap[tx.txid] = tx;
-  }
-  // reverse pass to identify CPFP clusters
-  for (let i = transactions.length - 1; i >= 0; i--) {
-    const tx = transactions[i];
-    if (!ancestors[tx.txid]) {
-      let totalFee = 0;
-      let totalVSize = 0;
-      clusterTxs.forEach(tx => {
-        totalFee += tx?.fee || 0;
-        totalVSize += (tx.weight / 4);
-      });
-      const effectiveFeePerVsize = totalFee / totalVSize;
-      let cluster: CpfpCluster;
-      if (clusterTxs.length > 1) {
-        cluster = {
-          root: clusterTxs[0].txid,
-          height,
-          txs: clusterTxs.map(tx => { return { txid: tx.txid, weight: tx.weight, fee: tx.fee || 0 }; }),
-          effectiveFeePerVsize,
-        };
-        clusters.push(cluster);
-      }
-      clusterTxs.forEach(tx => {
-        txMap[tx.txid].effectiveFeePerVsize = effectiveFeePerVsize;
-        if (cluster) {
-          clusterMap[tx.txid] = cluster;
-        }
-      });
-      // reset working vars
-      clusterTxs = [];
-      ancestors = {};
-    }
-    clusterTxs.push(tx);
-    tx.vin.forEach(vin => {
-      ancestors[vin.txid] = true;
-    });
-  }
-  // forward pass to enforce ancestor rate caps
-  for (const tx of transactions) {
-    let minAncestorRate = tx.effectiveFeePerVsize;
-    for (const vin of tx.vin) {
-      if (txMap[vin.txid]?.effectiveFeePerVsize) {
-        minAncestorRate = Math.min(minAncestorRate, txMap[vin.txid].effectiveFeePerVsize);
-      }
-    }
-    // check rounded values to skip cases with almost identical fees
-    const roundedMinAncestorRate = Math.ceil(minAncestorRate);
-    const roundedEffectiveFeeRate = Math.floor(tx.effectiveFeePerVsize);
-    if (roundedMinAncestorRate < roundedEffectiveFeeRate) {
-      tx.effectiveFeePerVsize = minAncestorRate;
-      if (!clusterMap[tx.txid]) {
-        // add a single-tx cluster to record the dependent rate
-        const cluster = {
-          root: tx.txid,
-          height,
-          txs: [{ txid: tx.txid, weight: tx.weight, fee: tx.fee || 0 }],
-          effectiveFeePerVsize: minAncestorRate,
-        };
-        clusterMap[tx.txid] = cluster;
-        clusters.push(cluster);
-      } else {
-        // update the existing cluster with the dependent rate
-        clusterMap[tx.txid].effectiveFeePerVsize = minAncestorRate;
-      }
-    }
-  }
-  if (saveRelatives) {
-    for (const cluster of clusters) {
-      cluster.txs.forEach((member, index) => {
-        txMap[member.txid].descendants = cluster.txs.slice(0, index).reverse();
-        txMap[member.txid].ancestors = cluster.txs.slice(index + 1).reverse();
-        txMap[member.txid].effectiveFeePerVsize = cluster.effectiveFeePerVsize;
-      });
-    }
-  }
-  return {
-    transactions,
-    clusters,
-    version: 1,
-  };
-}
-
-export function calculateGoodBlockCpfp(height: number, transactions: MempoolTransactionExtended[], accelerations: Acceleration[]): CpfpSummary {
-  const txMap: { [txid: string]: MempoolTransactionExtended } = {};
-  for (const tx of transactions) {
-    txMap[tx.txid] = tx;
-  }
-  const template = makeBlockTemplate(transactions, accelerations, 1, Infinity, Infinity);
-  const clusters = new Map<string, string[]>();
-  for (const tx of template) {
-    const cluster = tx.cluster || [];
-    const root = cluster.length ? cluster[cluster.length - 1] : null;
-    if (cluster.length > 1 && root && !clusters.has(root)) {
-      clusters.set(root, cluster);
-    }
-    txMap[tx.txid].effectiveFeePerVsize = tx.effectiveFeePerVsize;
-  }
-
-  const clusterArray: CpfpCluster[] = [];
-
-  for (const cluster of clusters.values()) {
-    for (const txid of cluster) {
-      const mempoolTx = txMap[txid];
-      if (mempoolTx) {
-        const ancestors: Ancestor[] = [];
-        const descendants: Ancestor[] = [];
-        let matched = false;
-        cluster.forEach(relativeTxid => {
-          if (relativeTxid === txid) {
-            matched = true;
-          } else {
-            const relative = {
-              txid: relativeTxid,
-              fee: txMap[relativeTxid].fee,
-              weight: (txMap[relativeTxid].adjustedVsize * 4) || txMap[relativeTxid].weight,
-            };
-            if (matched) {
-              descendants.push(relative);
-            } else {
-              ancestors.push(relative);
-            }
-          }
-        });
-        if (mempoolTx.ancestors?.length !== ancestors.length || mempoolTx.descendants?.length !== descendants.length) {
-          mempoolTx.cpfpDirty = true;
-        }
-        Object.assign(mempoolTx, { ancestors, descendants, bestDescendant: null, cpfpChecked: true });
-      }
-    }
-    const root = cluster[cluster.length - 1];
-    clusterArray.push({
-      root: root,
-      height,
-      txs: cluster.reverse().map(txid => ({
-        txid,
-        fee: txMap[txid].fee,
-        weight: (txMap[txid].adjustedVsize * 4) || txMap[txid].weight,
-      })),
-      effectiveFeePerVsize: txMap[root].effectiveFeePerVsize,
-    });
-  }
-
-  return {
-    transactions: transactions.map(tx => txMap[tx.txid]),
-    clusters: clusterArray,
-    version: 2,
+interface GraphTx extends MempoolTransactionExtended {
+  depends: string[];
+  spentby: string[];
+  ancestorMap: Map<string, GraphTx>;
+  fees: {
+    base: number;
+    ancestor: number;
   };
+  ancestorcount: number;
+  ancestorsize: number;
+  ancestorRate: number;
+  individualRate: number;
+  score: number;
 }
 
 /**
  * Takes a mempool transaction and a copy of the current mempool, and calculates the CPFP data for
  * that transaction (and all others in the same cluster)
  */
-export function calculateMempoolTxCpfp(tx: MempoolTransactionExtended, mempool: { [txid: string]: MempoolTransactionExtended }): CpfpInfo {
+export function calculateCpfp(tx: MempoolTransactionExtended, mempool: { [txid: string]: MempoolTransactionExtended }): CpfpInfo {
   if (tx.cpfpUpdated && Date.now() < (tx.cpfpUpdated + CPFP_UPDATE_INTERVAL)) {
     tx.cpfpDirty = false;
     return {
@@ -177,31 +32,30 @@ export function calculateMempoolTxCpfp(tx: MempoolTransactionExtended, mempool:
       descendants: tx.descendants || [],
       effectiveFeePerVsize: tx.effectiveFeePerVsize || tx.adjustedFeePerVsize || tx.feePerVsize,
       sigops: tx.sigops,
-      fee: tx.fee,
       adjustedVsize: tx.adjustedVsize,
       acceleration: tx.acceleration
     };
   }
 
   const ancestorMap = new Map<string, GraphTx>();
-  const graphTx = convertToGraphTx(tx, memPool.getSpendMap());
+  const graphTx = mempoolToGraphTx(tx);
   ancestorMap.set(tx.txid, graphTx);
 
-  const allRelatives = expandRelativesGraph(mempool, ancestorMap, memPool.getSpendMap());
+  const allRelatives = expandRelativesGraph(mempool, ancestorMap);
   const relativesMap = initializeRelatives(allRelatives);
   const cluster = calculateCpfpCluster(tx.txid, relativesMap);
 
   let totalVsize = 0;
   let totalFee = 0;
   for (const tx of cluster.values()) {
-    totalVsize += tx.vsize;
-    totalFee += tx.fees.base;
+    totalVsize += tx.adjustedVsize;
+    totalFee += tx.fee;
   }
   const effectiveFeePerVsize = totalFee / totalVsize;
   for (const tx of cluster.values()) {
     mempool[tx.txid].effectiveFeePerVsize = effectiveFeePerVsize;
-    mempool[tx.txid].ancestors = Array.from(tx.ancestors.values()).map(tx => ({ txid: tx.txid, weight: tx.weight, fee: tx.fees.base }));
-    mempool[tx.txid].descendants = Array.from(cluster.values()).filter(entry => entry.txid !== tx.txid && !tx.ancestors.has(entry.txid)).map(tx => ({ txid: tx.txid, weight: tx.weight, fee: tx.fees.base }));
+    mempool[tx.txid].ancestors = Array.from(tx.ancestorMap.values()).map(tx => ({ txid: tx.txid, weight: tx.weight, fee: tx.fee }));
+    mempool[tx.txid].descendants = Array.from(cluster.values()).filter(entry => entry.txid !== tx.txid && !tx.ancestorMap.has(entry.txid)).map(tx => ({ txid: tx.txid, weight: tx.weight, fee: tx.fee }));
     mempool[tx.txid].bestDescendant = null;
     mempool[tx.txid].cpfpChecked = true;
     mempool[tx.txid].cpfpDirty = true;
@@ -216,12 +70,88 @@ export function calculateMempoolTxCpfp(tx: MempoolTransactionExtended, mempool:
     descendants: tx.descendants || [],
     effectiveFeePerVsize: tx.effectiveFeePerVsize || tx.adjustedFeePerVsize || tx.feePerVsize,
     sigops: tx.sigops,
-    fee: tx.fee,
     adjustedVsize: tx.adjustedVsize,
     acceleration: tx.acceleration
   };
 }
 
+function mempoolToGraphTx(tx: MempoolTransactionExtended): GraphTx {
+  return {
+    ...tx,
+    depends: tx.vin.map(v => v.txid),
+    spentby: tx.vout.map((v, i) => memPool.getFromSpendMap(tx.txid, i)).map(tx => tx?.txid).filter(txid => txid != null) as string[],
+    ancestorMap: new Map(),
+    fees: {
+      base: tx.fee,
+      ancestor: tx.fee,
+    },
+    ancestorcount: 1,
+    ancestorsize: tx.adjustedVsize,
+    ancestorRate: 0,
+    individualRate: 0,
+    score: 0,
+  };
+}
+
+/**
+ * Takes a map of transaction ancestors, and expands it into a full graph of up to MAX_GRAPH_SIZE in-mempool relatives
+ */
+function expandRelativesGraph(mempool: { [txid: string]: MempoolTransactionExtended }, ancestors: Map<string, GraphTx>): Map<string, GraphTx> {
+  const relatives: Map<string, GraphTx> = new Map();
+  const stack: GraphTx[] = Array.from(ancestors.values());
+  while (stack.length > 0) {
+    if (relatives.size > MAX_GRAPH_SIZE) {
+      return relatives;
+    }
+
+    const nextTx = stack.pop();
+    if (!nextTx) {
+      continue;
+    }
+    relatives.set(nextTx.txid, nextTx);
+
+    for (const relativeTxid of [...nextTx.depends, ...nextTx.spentby]) {
+      if (relatives.has(relativeTxid)) {
+        // already processed this tx
+        continue;
+      }
+      let mempoolTx = ancestors.get(relativeTxid);
+      if (!mempoolTx && mempool[relativeTxid]) {
+        mempoolTx = mempoolToGraphTx(mempool[relativeTxid]);
+      }
+      if (mempoolTx) {
+        stack.push(mempoolTx);
+      }
+    }
+  }
+
+  return relatives;
+}
+
+ /**
+   * Efficiently sets a Map of in-mempool ancestors for each member of an expanded relative graph
+   * by running setAncestors on each leaf, and caching intermediate results.
+   * then initializes ancestor data for each transaction
+   * 
+   * @param all 
+   */
+ function initializeRelatives(mempoolTxs: Map<string, GraphTx>): Map<string, GraphTx> {
+  const visited: Map<string, Map<string, GraphTx>> = new Map();
+  const leaves: GraphTx[] = Array.from(mempoolTxs.values()).filter(entry => entry.spentby.length === 0);
+  for (const leaf of leaves) {
+    setAncestors(leaf, mempoolTxs, visited);
+  }
+  mempoolTxs.forEach(entry => {
+    entry.ancestorMap?.forEach(ancestor => {
+      entry.ancestorcount++;
+      entry.ancestorsize += ancestor.adjustedVsize;
+      entry.fees.ancestor += ancestor.fees.base;
+    });
+    setAncestorScores(entry);
+  });
+  return mempoolTxs;
+}
+
 /**
    * Given a root transaction and a list of in-mempool ancestors,
    * Calculate the CPFP cluster
@@ -242,10 +172,10 @@ function calculateCpfpCluster(txid: string, graph: Map<string, GraphTx>): Map<st
   let sortedRelatives = Array.from(graph.values()).sort(mempoolComparator);
 
   // Iterate until we reach a cluster that includes our target tx
-  let maxIterations = MAX_CLUSTER_ITERATIONS;
+  let maxIterations = MAX_GRAPH_SIZE;
   let best = sortedRelatives.shift();
-  let bestCluster = new Map<string, GraphTx>(best?.ancestors?.entries() || []);
-  while (sortedRelatives.length && best && (best.txid !== tx.txid && !best.ancestors.has(tx.txid)) && maxIterations > 0) {
+  let bestCluster = new Map<string, GraphTx>(best?.ancestorMap?.entries() || []);
+  while (sortedRelatives.length && best && (best.txid !== tx.txid && !best.ancestorMap.has(tx.txid)) && maxIterations > 0) {
     maxIterations--;
     if ((best && best.txid === tx.txid) || (bestCluster && bestCluster.has(tx.txid))) {
       break;
@@ -260,7 +190,7 @@ function calculateCpfpCluster(txid: string, graph: Map<string, GraphTx>): Map<st
       // Grab the next highest scoring entry
       best = sortedRelatives.shift();
       if (best) {
-        bestCluster = new Map<string, GraphTx>(best?.ancestors?.entries() || []);
+        bestCluster = new Map<string, GraphTx>(best?.ancestorMap?.entries() || []);
         bestCluster.set(best?.txid, best);
       }
     }
@@ -269,4 +199,88 @@ function calculateCpfpCluster(txid: string, graph: Map<string, GraphTx>): Map<st
   bestCluster.set(tx.txid, tx);
 
   return bestCluster;
+}
+
+ /**
+   * Remove a cluster of transactions from an in-mempool dependency graph
+   * and update the survivors' scores and ancestors
+   * 
+   * @param cluster 
+   * @param ancestors 
+   */
+ function removeAncestors(cluster: Map<string, GraphTx>, all: Map<string, GraphTx>): void {
+  // remove
+  cluster.forEach(tx => {
+    all.delete(tx.txid);
+  });
+
+  // update survivors
+  all.forEach(tx => {
+    cluster.forEach(remove => {
+      if (tx.ancestorMap?.has(remove.txid)) {
+        // remove as dependency
+        tx.ancestorMap.delete(remove.txid);
+        tx.depends = tx.depends.filter(parent => parent !== remove.txid);
+        // update ancestor sizes and fees
+        tx.ancestorsize -= remove.adjustedVsize;
+        tx.fees.ancestor -= remove.fees.base;
+      }
+    });
+    // recalculate fee rates
+    setAncestorScores(tx);
+  });
+}
+
+/**
+   * Recursively traverses an in-mempool dependency graph, and sets a Map of in-mempool ancestors
+   * for each transaction.
+   * 
+   * @param tx 
+   * @param all 
+   */
+function setAncestors(tx: GraphTx, all: Map<string, GraphTx>, visited: Map<string, Map<string, GraphTx>>, depth: number = 0): Map<string, GraphTx> {
+  // sanity check for infinite recursion / too many ancestors (should never happen)
+  if (depth > MAX_GRAPH_SIZE) {
+    return tx.ancestorMap;
+  }
+  
+  // initialize the ancestor map for this tx
+  tx.ancestorMap = new Map<string, GraphTx>();
+  tx.depends.forEach(parentId => {
+    const parent = all.get(parentId);
+    if (parent) {
+      // add the parent
+      tx.ancestorMap?.set(parentId, parent);
+      // check for a cached copy of this parent's ancestors
+      let ancestors = visited.get(parent.txid);
+      if (!ancestors) {
+        // recursively fetch the parent's ancestors
+        ancestors = setAncestors(parent, all, visited, depth + 1);
+      }
+      // and add to this tx's map
+      ancestors.forEach((ancestor, ancestorId) => {
+        tx.ancestorMap?.set(ancestorId, ancestor);
+      });
+    }
+  });
+  visited.set(tx.txid, tx.ancestorMap);
+
+  return tx.ancestorMap;
+}
+
+/**
+   * Take a mempool transaction, and set the fee rates and ancestor score
+   * 
+   * @param tx 
+   */
+function setAncestorScores(tx: GraphTx): GraphTx {
+  tx.individualRate = (tx.fees.base * 100_000_000) / tx.adjustedVsize;
+  tx.ancestorRate = (tx.fees.ancestor * 100_000_000) / tx.ancestorsize;
+  tx.score = Math.min(tx.individualRate, tx.ancestorRate);
+  return tx;
+}
+
+// Sort by descending score
+function mempoolComparator(a: GraphTx, b: GraphTx): number {
+  return b.score - a.score;
 }

backend/src/api/database-migration.ts

@@ -7,7 +7,7 @@ import cpfpRepository from '../repositories/CpfpRepository';
 import { RowDataPacket } from 'mysql2';
 
 class DatabaseMigration {
-  private static currentVersion = 81;
+  private static currentVersion = 80;
   private queryTimeout = 3600_000;
   private statisticsAddedIndexed = false;
   private uniqueLogs: string[] = [];
@@ -653,11 +653,9 @@ class DatabaseMigration {
       await this.$executeQuery('ALTER TABLE `prices` ADD `TRY` float DEFAULT "-1"');
       await this.$executeQuery('ALTER TABLE `prices` ADD `ZAR` float DEFAULT "-1"');
 
-      if (isBitcoin === true) {
-        await this.$executeQuery('TRUNCATE hashrates');
-        await this.$executeQuery('TRUNCATE difficulty_adjustments');
-        await this.$executeQuery(`UPDATE state SET string = NULL WHERE name = 'pools_json_sha'`);
-      }
+      await this.$executeQuery('TRUNCATE hashrates');
+      await this.$executeQuery('TRUNCATE difficulty_adjustments');
+      await this.$executeQuery(`UPDATE state SET string = NULL WHERE name = 'pools_json_sha'`);
 
       await this.updateToSchemaVersion(75);
     }
@@ -693,13 +691,6 @@ class DatabaseMigration {
       await this.$executeQuery('ALTER TABLE `blocks` ADD coinbase_addresses JSON DEFAULT NULL');
       await this.updateToSchemaVersion(80);
     }
-
-    if (databaseSchemaVersion < 81 && isBitcoin === true) {
-      await this.$executeQuery('ALTER TABLE `blocks_audits` ADD version INT NOT NULL DEFAULT 0');
-      await this.$executeQuery('ALTER TABLE `blocks_audits` ADD INDEX `version` (`version`)');
-      await this.$executeQuery('ALTER TABLE `blocks_audits` ADD unseen_txs JSON DEFAULT "[]"');
-      await this.updateToSchemaVersion(81);
-    }
   }
 
   /**

backend/src/api/mempool-blocks.ts

@@ -453,7 +453,6 @@ class MempoolBlocks {
             mempoolTx.acceleration = true;
             mempoolTx.acceleratedBy = isAcceleratedBy[txid] || acceleration?.pools;
             mempoolTx.acceleratedAt = acceleration?.added;
-            mempoolTx.feeDelta = acceleration?.feeDelta;
             for (const ancestor of mempoolTx.ancestors || []) {
               if (!mempool[ancestor.txid].acceleration) {
                 mempool[ancestor.txid].cpfpDirty = true;
@@ -461,7 +460,6 @@ class MempoolBlocks {
               mempool[ancestor.txid].acceleration = true;
               mempool[ancestor.txid].acceleratedBy = mempoolTx.acceleratedBy;
               mempool[ancestor.txid].acceleratedAt = mempoolTx.acceleratedAt;
-              mempool[ancestor.txid].feeDelta = mempoolTx.feeDelta;
               isAcceleratedBy[ancestor.txid] = mempoolTx.acceleratedBy;
             }
           } else {

backend/src/api/mempool.ts

@@ -396,6 +396,10 @@ class Mempool {
   }
 
   public $updateAccelerations(newAccelerations: Acceleration[]): string[] {
+    if (!config.MEMPOOL_SERVICES.ACCELERATIONS) {
+      return [];
+    }
+
     try {
       const changed: string[] = [];
 

backend/src/api/mini-miner.ts

@@ -1,515 +0,0 @@
-import { Acceleration } from './acceleration/acceleration';
-import { MempoolTransactionExtended } from '../mempool.interfaces';
-import logger from '../logger';
-
-const BLOCK_WEIGHT_UNITS = 4_000_000;
-const BLOCK_SIGOPS = 80_000;
-const MAX_RELATIVE_GRAPH_SIZE = 100;
-
-export interface GraphTx {
-  txid: string;
-  vsize: number;
-  weight: number;
-  depends: string[];
-  spentby: string[];
-
-  ancestorcount: number;
-  ancestorsize: number;
-  fees: { // in sats
-    base: number;
-    ancestor: number;
-  };
-
-  ancestors: Map<string, GraphTx>,
-  ancestorRate: number;
-  individualRate: number;
-  score: number;
-}
-
-interface TemplateTransaction {
-  txid: string;
-  order: number;
-  weight: number;
-  adjustedVsize: number; // sigop-adjusted vsize, rounded up to the nearest integer
-  sigops: number;
-  fee: number;
-  feeDelta: number;
-  ancestors: string[];
-  cluster: string[];
-  effectiveFeePerVsize: number;
-}
-
-interface MinerTransaction extends TemplateTransaction {
-  inputs: string[];
-  feePerVsize: number;
-  relativesSet: boolean;
-  ancestorMap: Map<string, MinerTransaction>;
-  children: Set<MinerTransaction>;
-  ancestorFee: number;
-  ancestorVsize: number;
-  ancestorSigops: number;
-  score: number;
-  used: boolean;
-  modified: boolean;
-  dependencyRate: number;
-}
-
-/**
- * Takes a raw transaction, and builds a graph of same-block relatives,
- * and returns as a GraphTx
- *
- * @param tx
- */
-export function getSameBlockRelatives(tx: MempoolTransactionExtended, transactions: MempoolTransactionExtended[]): Map<string, GraphTx> {
-  const blockTxs = new Map<string, MempoolTransactionExtended>(); // map of txs in this block
-  const spendMap = new Map<string, string>(); // map of outpoints to spending txids
-  for (const tx of transactions) {
-    blockTxs.set(tx.txid, tx);
-    for (const vin of tx.vin) {
-      spendMap.set(`${vin.txid}:${vin.vout}`, tx.txid);
-    }
-  }
-
-  const relatives: Map<string, GraphTx> = new Map();
-  const stack: string[] = [tx.txid];
-
-  // build set of same-block ancestors
-  while (stack.length > 0) {
-    const nextTxid = stack.pop();
-    const nextTx = nextTxid ? blockTxs.get(nextTxid) : null;
-    if (!nextTx || relatives.has(nextTx.txid)) {
-      continue;
-    }
-
-    const mempoolTx = convertToGraphTx(nextTx, spendMap);
-
-    for (const txid of [...mempoolTx.depends, ...mempoolTx.spentby]) {
-      if (txid) {
-        stack.push(txid);
-      }
-    }
-
-    relatives.set(mempoolTx.txid, mempoolTx);
-  }
-
-  return relatives;
-}
-
-/**
- * Takes a raw transaction and converts it to GraphTx format
- * fee and ancestor data is initialized with dummy/null values
- *
- * @param tx
- */
-export function convertToGraphTx(tx: MempoolTransactionExtended, spendMap?: Map<string, MempoolTransactionExtended | string>): GraphTx {
-  return {
-    txid: tx.txid,
-    vsize: Math.max(tx.sigops * 5, Math.ceil(tx.weight / 4)),
-    weight: tx.weight,
-    fees: {
-      base: tx.fee || 0,
-      ancestor: tx.fee || 0,
-    },
-    depends: (tx.vin.map(vin => vin.txid).filter(depend => depend) as string[]),
-    spentby: spendMap ? (tx.vout.map((vout, index) => { const spend = spendMap.get(`${tx.txid}:${index}`); return (spend?.['txid'] || spend); }).filter(spent => spent) as string[]) : [],
-
-    ancestorcount: 1,
-    ancestorsize: Math.max(tx.sigops * 5, Math.ceil(tx.weight / 4)),
-    ancestors: new Map<string, GraphTx>(),
-    ancestorRate: 0,
-    individualRate: 0,
-    score: 0,
-  };
-}
-
-/**
- * Takes a map of transaction ancestors, and expands it into a full graph of up to MAX_GRAPH_SIZE in-mempool relatives
- */
-export function expandRelativesGraph(mempool: { [txid: string]: MempoolTransactionExtended }, ancestors: Map<string, GraphTx>, spendMap: Map<string, MempoolTransactionExtended>): Map<string, GraphTx> {
-  const relatives: Map<string, GraphTx> = new Map();
-  const stack: GraphTx[] = Array.from(ancestors.values());
-  while (stack.length > 0) {
-    if (relatives.size > MAX_RELATIVE_GRAPH_SIZE) {
-      return relatives;
-    }
-
-    const nextTx = stack.pop();
-    if (!nextTx) {
-      continue;
-    }
-    relatives.set(nextTx.txid, nextTx);
-
-    for (const relativeTxid of [...nextTx.depends, ...nextTx.spentby]) {
-      if (relatives.has(relativeTxid)) {
-        // already processed this tx
-        continue;
-      }
-      let ancestorTx = ancestors.get(relativeTxid);
-      if (!ancestorTx && relativeTxid in mempool) {
-        const mempoolTx = mempool[relativeTxid];
-        ancestorTx = convertToGraphTx(mempoolTx, spendMap);
-      }
-      if (ancestorTx) {
-        stack.push(ancestorTx);
-      }
-    }
-  }
-
-  return relatives;
-}
-
-/**
- * Recursively traverses an in-mempool dependency graph, and sets a Map of in-mempool ancestors
- * for each transaction.
- *
- * @param tx
- * @param all
- */
-function setAncestors(tx: GraphTx, all: Map<string, GraphTx>, visited: Map<string, Map<string, GraphTx>>, depth: number = 0): Map<string, GraphTx> {
-  // sanity check for infinite recursion / too many ancestors (should never happen)
-  if (depth > MAX_RELATIVE_GRAPH_SIZE) {
-    logger.warn('cpfp dependency calculation failed: setAncestors reached depth of 100, unable to proceed');
-    return tx.ancestors;
-  }
-
-  // initialize the ancestor map for this tx
-  tx.ancestors = new Map<string, GraphTx>();
-  tx.depends.forEach(parentId => {
-    const parent = all.get(parentId);
-    if (parent) {
-      // add the parent
-      tx.ancestors?.set(parentId, parent);
-      // check for a cached copy of this parent's ancestors
-      let ancestors = visited.get(parent.txid);
-      if (!ancestors) {
-        // recursively fetch the parent's ancestors
-        ancestors = setAncestors(parent, all, visited, depth + 1);
-      }
-      // and add to this tx's map
-      ancestors.forEach((ancestor, ancestorId) => {
-        tx.ancestors?.set(ancestorId, ancestor);
-      });
-    }
-  });
-  visited.set(tx.txid, tx.ancestors);
-
-  return tx.ancestors;
-}
-
-/**
-   * Efficiently sets a Map of in-mempool ancestors for each member of an expanded relative graph
-   * by running setAncestors on each leaf, and caching intermediate results.
-   * then initializes ancestor data for each transaction
-   *
-   * @param all
-   */
-export function initializeRelatives(mempoolTxs: Map<string, GraphTx>): Map<string, GraphTx> {
-  const visited: Map<string, Map<string, GraphTx>> = new Map();
-  const leaves: GraphTx[] = Array.from(mempoolTxs.values()).filter(entry => entry.spentby.length === 0);
-  for (const leaf of leaves) {
-    setAncestors(leaf, mempoolTxs, visited);
-  }
-  mempoolTxs.forEach(entry => {
-    entry.ancestors?.forEach(ancestor => {
-      entry.ancestorcount++;
-      entry.ancestorsize += ancestor.vsize;
-      entry.fees.ancestor += ancestor.fees.base;
-    });
-    setAncestorScores(entry);
-  });
-  return mempoolTxs;
-}
-
-/**
- * Remove a cluster of transactions from an in-mempool dependency graph
- * and update the survivors' scores and ancestors
- *
- * @param cluster
- * @param ancestors
- */
-export function removeAncestors(cluster: Map<string, GraphTx>, all: Map<string, GraphTx>): void {
-  // remove
-  cluster.forEach(tx => {
-    all.delete(tx.txid);
-  });
-
-  // update survivors
-  all.forEach(tx => {
-    cluster.forEach(remove => {
-      if (tx.ancestors?.has(remove.txid)) {
-        // remove as dependency
-        tx.ancestors.delete(remove.txid);
-        tx.depends = tx.depends.filter(parent => parent !== remove.txid);
-        // update ancestor sizes and fees
-        tx.ancestorsize -= remove.vsize;
-        tx.fees.ancestor -= remove.fees.base;
-      }
-    });
-    // recalculate fee rates
-    setAncestorScores(tx);
-  });
-}
-
-/**
- * Take a mempool transaction, and set the fee rates and ancestor score
- *
- * @param tx
- */
-export function setAncestorScores(tx: GraphTx): void {
-  tx.individualRate = tx.fees.base / tx.vsize;
-  tx.ancestorRate = tx.fees.ancestor / tx.ancestorsize;
-  tx.score = Math.min(tx.individualRate, tx.ancestorRate);
-}
-
-// Sort by descending score
-export function mempoolComparator(a: GraphTx, b: GraphTx): number {
-  return b.score - a.score;
-}
-
-/*
-* Build a block using an approximation of the transaction selection algorithm from Bitcoin Core
-* (see BlockAssembler in https://github.com/bitcoin/bitcoin/blob/master/src/node/miner.cpp)
-*/
-export function makeBlockTemplate(candidates: MempoolTransactionExtended[], accelerations: Acceleration[], maxBlocks: number = 8, weightLimit: number = BLOCK_WEIGHT_UNITS, sigopLimit: number = BLOCK_SIGOPS): TemplateTransaction[] {
-  const auditPool: Map<string, MinerTransaction> = new Map();
-  const mempoolArray: MinerTransaction[] = [];
-
-  candidates.forEach(tx => {
-    // initializing everything up front helps V8 optimize property access later
-    const adjustedVsize = Math.ceil(Math.max(tx.weight / 4, 5 * (tx.sigops || 0)));
-    const feePerVsize = (tx.fee / adjustedVsize);
-    auditPool.set(tx.txid, {
-      txid: tx.txid,
-      order: txidToOrdering(tx.txid),
-      fee: tx.fee,
-      feeDelta: 0,
-      weight: tx.weight,
-      adjustedVsize,
-      feePerVsize: feePerVsize,
-      effectiveFeePerVsize: feePerVsize,
-      dependencyRate: feePerVsize,
-      sigops: tx.sigops || 0,
-      inputs: (tx.vin?.map(vin => vin.txid) || []) as string[],
-      relativesSet: false,
-      ancestors: [],
-      cluster: [],
-      ancestorMap: new Map<string, MinerTransaction>(),
-      children: new Set<MinerTransaction>(),
-      ancestorFee: 0,
-      ancestorVsize: 0,
-      ancestorSigops: 0,
-      score: 0,
-      used: false,
-      modified: false,
-    });
-    mempoolArray.push(auditPool.get(tx.txid) as MinerTransaction);
-  });
-
-  // set accelerated effective fee
-  for (const acceleration of accelerations) {
-    const tx = auditPool.get(acceleration.txid);
-    if (tx) {
-      tx.feeDelta = acceleration.max_bid;
-      tx.feePerVsize = ((tx.fee + tx.feeDelta) / tx.adjustedVsize);
-      tx.effectiveFeePerVsize = tx.feePerVsize;
-      tx.dependencyRate = tx.feePerVsize;
-    }
-  }
-
-  // Build relatives graph & calculate ancestor scores
-  for (const tx of mempoolArray) {
-    if (!tx.relativesSet) {
-      setRelatives(tx, auditPool);
-    }
-  }
-
-  // Sort by descending ancestor score
-  mempoolArray.sort(priorityComparator);
-
-  // Build blocks by greedily choosing the highest feerate package
-  // (i.e. the package rooted in the transaction with the best ancestor score)
-  const blocks: number[][] = [];
-  let blockWeight = 0;
-  let blockSigops = 0;
-  const transactions: MinerTransaction[] = [];
-  let modified: MinerTransaction[] = [];
-  const overflow: MinerTransaction[] = [];
-  let failures = 0;
-  while (mempoolArray.length || modified.length) {
-    // skip invalid transactions
-    while (mempoolArray[0]?.used || mempoolArray[0]?.modified) {
-      mempoolArray.shift();
-    }
-
-    // Select best next package
-    let nextTx;
-    const nextPoolTx = mempoolArray[0];
-    const nextModifiedTx = modified[0];
-    if (nextPoolTx && (!nextModifiedTx || (nextPoolTx.score || 0) > (nextModifiedTx.score || 0))) {
-      nextTx = nextPoolTx;
-      mempoolArray.shift();
-    } else {
-      modified.shift();
-      if (nextModifiedTx) {
-        nextTx = nextModifiedTx;
-      }
-    }
-
-    if (nextTx && !nextTx?.used) {
-      // Check if the package fits into this block
-      if (blocks.length >= (maxBlocks - 1) || ((blockWeight + (4 * nextTx.ancestorVsize) < weightLimit) && (blockSigops + nextTx.ancestorSigops <= sigopLimit))) {
-        const ancestors: MinerTransaction[] = Array.from(nextTx.ancestorMap.values());
-        // sort ancestors by dependency graph (equivalent to sorting by ascending ancestor count)
-        const sortedTxSet = [...ancestors.sort((a, b) => { return (a.ancestorMap.size || 0) - (b.ancestorMap.size || 0); }), nextTx];
-        const clusterTxids = sortedTxSet.map(tx => tx.txid);
-        const effectiveFeeRate = Math.min(nextTx.dependencyRate || Infinity, nextTx.ancestorFee / nextTx.ancestorVsize);
-        const used: MinerTransaction[] = [];
-        while (sortedTxSet.length) {
-          const ancestor = sortedTxSet.pop();
-          if (!ancestor) {
-            continue;
-          }
-          ancestor.used = true;
-          ancestor.usedBy = nextTx.txid;
-          // update this tx with effective fee rate & relatives data
-          if (ancestor.effectiveFeePerVsize !== effectiveFeeRate) {
-            ancestor.effectiveFeePerVsize = effectiveFeeRate;
-          }
-          ancestor.cluster = clusterTxids;
-          transactions.push(ancestor);
-          blockWeight += ancestor.weight;
-          blockSigops += ancestor.sigops;
-          used.push(ancestor);
-        }
-
-        // remove these as valid package ancestors for any descendants remaining in the mempool
-        if (used.length) {
-          used.forEach(tx => {
-            modified = updateDescendants(tx, auditPool, modified, effectiveFeeRate);
-          });
-        }
-
-        failures = 0;
-      } else {
-        // hold this package in an overflow list while we check for smaller options
-        overflow.push(nextTx);
-        failures++;
-      }
-    }
-
-    // this block is full
-    const exceededPackageTries = failures > 1000 && blockWeight > (weightLimit - 4000);
-    const queueEmpty = !mempoolArray.length && !modified.length;
-
-    if (exceededPackageTries || queueEmpty) {
-      break;
-    }
-  }
-
-  for (const tx of transactions) {
-    tx.ancestors = Object.values(tx.ancestorMap);
-  }
-
-  return transactions;
-}
-
-// traverse in-mempool ancestors
-// recursion unavoidable, but should be limited to depth < 25 by mempool policy
-function setRelatives(
-  tx: MinerTransaction,
-  mempool: Map<string, MinerTransaction>,
-): void {
-  for (const parent of tx.inputs) {
-    const parentTx = mempool.get(parent);
-    if (parentTx && !tx.ancestorMap?.has(parent)) {
-      tx.ancestorMap.set(parent, parentTx);
-      parentTx.children.add(tx);
-      // visit each node only once
-      if (!parentTx.relativesSet) {
-        setRelatives(parentTx, mempool);
-      }
-      parentTx.ancestorMap.forEach((ancestor) => {
-        tx.ancestorMap.set(ancestor.txid, ancestor);
-      });
-    }
-  };
-  tx.ancestorFee = (tx.fee + tx.feeDelta);
-  tx.ancestorVsize = tx.adjustedVsize || 0;
-  tx.ancestorSigops = tx.sigops || 0;
-  tx.ancestorMap.forEach((ancestor) => {
-    tx.ancestorFee += (ancestor.fee + ancestor.feeDelta);
-    tx.ancestorVsize += ancestor.adjustedVsize;
-    tx.ancestorSigops += ancestor.sigops;
-  });
-  tx.score = tx.ancestorFee / tx.ancestorVsize;
-  tx.relativesSet = true;
-}
-
-// iterate over remaining descendants, removing the root as a valid ancestor & updating the ancestor score
-// avoids recursion to limit call stack depth
-function updateDescendants(
-  rootTx: MinerTransaction,
-  mempool: Map<string, MinerTransaction>,
-  modified: MinerTransaction[],
-  clusterRate: number,
-): MinerTransaction[] {
-  const descendantSet: Set<MinerTransaction> = new Set();
-  // stack of nodes left to visit
-  const descendants: MinerTransaction[] = [];
-  let descendantTx: MinerTransaction | undefined;
-  rootTx.children.forEach(childTx => {
-    if (!descendantSet.has(childTx)) {
-      descendants.push(childTx);
-      descendantSet.add(childTx);
-    }
-  });
-  while (descendants.length) {
-    descendantTx = descendants.pop();
-    if (descendantTx && descendantTx.ancestorMap && descendantTx.ancestorMap.has(rootTx.txid)) {
-      // remove tx as ancestor
-      descendantTx.ancestorMap.delete(rootTx.txid);
-      descendantTx.ancestorFee -= (rootTx.fee + rootTx.feeDelta);
-      descendantTx.ancestorVsize -= rootTx.adjustedVsize;
-      descendantTx.ancestorSigops -= rootTx.sigops;
-      descendantTx.score = descendantTx.ancestorFee / descendantTx.ancestorVsize;
-      descendantTx.dependencyRate = descendantTx.dependencyRate ? Math.min(descendantTx.dependencyRate, clusterRate) : clusterRate;
-
-      if (!descendantTx.modified) {
-        descendantTx.modified = true;
-        modified.push(descendantTx);
-      }
-
-      // add this node's children to the stack
-      descendantTx.children.forEach(childTx => {
-        // visit each node only once
-        if (!descendantSet.has(childTx)) {
-          descendants.push(childTx);
-          descendantSet.add(childTx);
-        }
-      });
-    }
-  }
-  // return new, resorted modified list
-  return modified.sort(priorityComparator);
-}
-
-// Used to sort an array of MinerTransactions by descending ancestor score
-function priorityComparator(a: MinerTransaction, b: MinerTransaction): number {
-  if (b.score === a.score) {
-    // tie-break by txid for stability
-    return a.order - b.order;
-  } else {
-    return b.score - a.score;
-  }
-}
-
-// returns the most significant 4 bytes of the txid as an integer
-function txidToOrdering(txid: string): number {
-  return parseInt(
-    txid.substring(62, 64) +
-      txid.substring(60, 62) +
-      txid.substring(58, 60) +
-      txid.substring(56, 58),
-    16
-  );
-}

backend/src/api/mining/mining-routes.ts

@@ -9,7 +9,6 @@ import bitcoinClient from '../bitcoin/bitcoin-client';
 import mining from "./mining";
 import PricesRepository from '../../repositories/PricesRepository';
 import AccelerationRepository from '../../repositories/AccelerationRepository';
-import accelerationApi from '../services/acceleration';
 
 class MiningRoutes {
   public initRoutes(app: Application) {
@@ -42,8 +41,6 @@ class MiningRoutes {
       .get(config.MEMPOOL.API_URL_PREFIX + 'accelerations/block/:height', this.$getAccelerationsByHeight)
       .get(config.MEMPOOL.API_URL_PREFIX + 'accelerations/recent/:interval', this.$getRecentAccelerations)
       .get(config.MEMPOOL.API_URL_PREFIX + 'accelerations/total', this.$getAccelerationTotals)
-      .get(config.MEMPOOL.API_URL_PREFIX + 'accelerations', this.$getActiveAccelerations)
-      .post(config.MEMPOOL.API_URL_PREFIX + 'acceleration/request/:txid', this.$requestAcceleration)
     ;
   }
 
@@ -448,33 +445,6 @@ class MiningRoutes {
       res.status(500).send(e instanceof Error ? e.message : e);
     }
   }
-
-  private async $getActiveAccelerations(req: Request, res: Response): Promise<void> {
-    try {
-      res.header('Pragma', 'public');
-      res.header('Cache-control', 'public');
-      res.setHeader('Expires', new Date(Date.now() + 1000 * 60).toUTCString());
-      if (!config.MEMPOOL_SERVICES.ACCELERATIONS || ['testnet', 'signet', 'liquidtestnet', 'liquid'].includes(config.MEMPOOL.NETWORK)) {
-        res.status(400).send('Acceleration data is not available.');
-        return;
-      }
-      res.status(200).send(accelerationApi.accelerations || []);
-    } catch (e) {
-      res.status(500).send(e instanceof Error ? e.message : e);
-    }
-  }
-
-  private async $requestAcceleration(req: Request, res: Response): Promise<void> {
-    res.setHeader('Pragma', 'no-cache');
-    res.setHeader('Cache-control', 'private, no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0');
-    res.setHeader('expires', -1);
-    try {
-      accelerationApi.accelerationRequested(req.params.txid);
-      res.status(200).send();
-    } catch (e) {
-      res.status(500).send(e instanceof Error ? e.message : e);
-    }
-  }
 }
 
 export default new MiningRoutes();

backend/src/api/services/acceleration.ts

@@ -1,10 +1,8 @@
 import config from '../../config';
 import logger from '../../logger';
-import { BlockExtended } from '../../mempool.interfaces';
+import { BlockExtended, PoolTag } from '../../mempool.interfaces';
 import axios from 'axios';
 
-type MyAccelerationStatus = 'requested' | 'accelerating' | 'done';
-
 export interface Acceleration {
   txid: string,
   added: number,
@@ -37,91 +35,18 @@ export interface AccelerationHistory {
 };
 
 class AccelerationApi {
-  private onDemandPollingEnabled = !config.MEMPOOL_SERVICES.ACCELERATIONS;
-  private apiPath = config.MEMPOOL.OFFICIAL ? (config.MEMPOOL_SERVICES.API + '/accelerator/accelerations') : (config.EXTERNAL_DATA_SERVER.MEMPOOL_API + '/accelerations');
-  private _accelerations: Acceleration[] | null = null;
-  private lastPoll = 0;
-  private forcePoll = false;
-  private myAccelerations: Record<string, { status: MyAccelerationStatus, added: number, acceleration?: Acceleration }> = {};
-
-  public get accelerations(): Acceleration[] | null {
-    return this._accelerations;
-  }
-
-  public countMyAccelerationsWithStatus(filter: MyAccelerationStatus): number {
-    return Object.values(this.myAccelerations).reduce((count, {status}) => { return count + (status === filter ? 1 : 0); }, 0);
-  }
-
-  public accelerationRequested(txid: string): void {
-    if (this.onDemandPollingEnabled) {
-      this.myAccelerations[txid] = { status: 'requested', added: Date.now() };
-    }
-  }
-
-  public accelerationConfirmed(): void {
-    this.forcePoll = true;
-  }
-
-  private async $fetchAccelerations(): Promise<Acceleration[] | null> {
-    try {
-      const response = await axios.get(this.apiPath, { responseType: 'json', timeout: 10000 });
-      return response?.data || [];
-    } catch (e) {
-      logger.warn('Failed to fetch current accelerations from the mempool services backend: ' + (e instanceof Error ? e.message : e));
-      return null;
-    }
-  }
-
-  public async $updateAccelerations(): Promise<Acceleration[] | null> {
-    if (!this.onDemandPollingEnabled) {
-      const accelerations = await this.$fetchAccelerations();
-      if (accelerations) {
-        this._accelerations = accelerations;
-        return this._accelerations;
+  public async $fetchAccelerations(): Promise<Acceleration[] | null> {
+    if (config.MEMPOOL_SERVICES.ACCELERATIONS) {
+      try {
+        const response = await axios.get(`${config.MEMPOOL_SERVICES.API}/accelerator/accelerations`, { responseType: 'json', timeout: 10000 });
+        return response.data as Acceleration[];
+      } catch (e) {
+        logger.warn('Failed to fetch current accelerations from the mempool services backend: ' + (e instanceof Error ? e.message : e));
+        return null;
       }
     } else {
-      return this.$updateAccelerationsOnDemand();
+      return [];
     }
-    return null;
-  }
-
-  private async $updateAccelerationsOnDemand(): Promise<Acceleration[] | null> {
-    const shouldUpdate = this.forcePoll
-      || this.countMyAccelerationsWithStatus('requested') > 0
-      || (this.countMyAccelerationsWithStatus('accelerating') > 0 && this.lastPoll < (Date.now() - (10 * 60 * 1000)));
-
-    // update accelerations if necessary
-    if (shouldUpdate) {
-      const accelerations = await this.$fetchAccelerations();
-      this.lastPoll = Date.now();
-      this.forcePoll = false;
-      if (accelerations) {
-        const latestAccelerations: Record<string, Acceleration> = {};
-        // set relevant accelerations to 'accelerating'
-        for (const acc of accelerations) {
-          if (this.myAccelerations[acc.txid]) {
-            latestAccelerations[acc.txid] = acc;
-            this.myAccelerations[acc.txid] = { status: 'accelerating', added: Date.now(), acceleration: acc };
-          }
-        }
-        // txs that are no longer accelerating are either confirmed or canceled, so mark for expiry
-        for (const [txid, { status, acceleration }] of Object.entries(this.myAccelerations)) {
-          if (status === 'accelerating' && !latestAccelerations[txid]) {
-            this.myAccelerations[txid] = { status: 'done', added: Date.now(), acceleration };
-          }
-        }
-      }
-    }
-
-    // clear expired accelerations (confirmed / failed / not accepted) after 10 minutes
-    for (const [txid, { status, added }] of Object.entries(this.myAccelerations)) {
-      if (['requested', 'done'].includes(status) && added < (Date.now() - (1000 * 60 * 10))) {
-        delete this.myAccelerations[txid];
-      }
-    }
-
-    this._accelerations = Object.values(this.myAccelerations).map(({ acceleration }) => acceleration).filter(acc => acc) as Acceleration[];
-    return this._accelerations;
   }
 
   public async $fetchAccelerationHistory(page?: number, status?: string): Promise<AccelerationHistory[] | null> {

backend/src/api/transaction-utils.ts

@@ -103,7 +103,7 @@ class TransactionUtils {
     }
     const feePerVbytes = (transaction.fee || 0) / (transaction.weight / 4);
     const transactionExtended: TransactionExtended = Object.assign({
-      vsize: transaction.weight / 4,
+      vsize: Math.round(transaction.weight / 4),
       feePerVsize: feePerVbytes,
       effectiveFeePerVsize: feePerVbytes,
     }, transaction);
@@ -123,7 +123,7 @@ class TransactionUtils {
     const adjustedFeePerVsize = (transaction.fee || 0) / adjustedVsize;
     const transactionExtended: MempoolTransactionExtended = Object.assign(transaction, {
       order: this.txidToOrdering(transaction.txid),
-      vsize,
+      vsize: Math.round(transaction.weight / 4),
       adjustedVsize,
       sigops,
       feePerVsize: feePerVbytes,

backend/src/api/websocket-handler.ts

@@ -3,7 +3,7 @@ import * as WebSocket from 'ws';
 import {
   BlockExtended, TransactionExtended, MempoolTransactionExtended, WebsocketResponse,
   OptimizedStatistic, ILoadingIndicators, GbtCandidates, TxTrackingInfo,
-  MempoolDelta, MempoolDeltaTxids
+  MempoolBlockDelta, MempoolDelta, MempoolDeltaTxids
 } from '../mempool.interfaces';
 import blocks from './blocks';
 import memPool from './mempool';
@@ -33,7 +33,7 @@ interface AddressTransactions {
   removed: MempoolTransactionExtended[],
 }
 import bitcoinSecondClient from './bitcoin/bitcoin-second-client';
-import { calculateMempoolTxCpfp } from './cpfp';
+import { calculateCpfp } from './cpfp';
 
 // valid 'want' subscriptions
 const wantable = [
@@ -538,9 +538,9 @@ class WebsocketHandler {
     }
 
     if (config.MEMPOOL.RUST_GBT) {
-      await mempoolBlocks.$rustUpdateBlockTemplates(transactionIds, newMempool, added, removed, candidates, true);
+      await mempoolBlocks.$rustUpdateBlockTemplates(transactionIds, newMempool, added, removed, candidates, config.MEMPOOL_SERVICES.ACCELERATIONS);
     } else {
-      await mempoolBlocks.$updateBlockTemplates(transactionIds, newMempool, added, removed, candidates, accelerationDelta, true, true);
+      await mempoolBlocks.$updateBlockTemplates(transactionIds, newMempool, added, removed, candidates, accelerationDelta, true, config.MEMPOOL_SERVICES.ACCELERATIONS);
     }
 
     const mBlocks = mempoolBlocks.getMempoolBlocks();
@@ -823,12 +823,11 @@ class WebsocketHandler {
               accelerated: mempoolTx.acceleration || undefined,
               acceleratedBy: mempoolTx.acceleratedBy || undefined,
               acceleratedAt: mempoolTx.acceleratedAt || undefined,
-              feeDelta: mempoolTx.feeDelta || undefined,
             },
             accelerationPositions: memPool.getAccelerationPositions(mempoolTx.txid),
           };
           if (!mempoolTx.cpfpChecked && !mempoolTx.acceleration) {
-            calculateMempoolTxCpfp(mempoolTx, newMempool);
+            calculateCpfp(mempoolTx, newMempool);
           }
           if (mempoolTx.cpfpDirty) {
             positionData['cpfp'] = {
@@ -865,10 +864,9 @@ class WebsocketHandler {
               accelerated: mempoolTx.acceleration || undefined,
               acceleratedBy: mempoolTx.acceleratedBy || undefined,
               acceleratedAt: mempoolTx.acceleratedAt || undefined,
-              feeDelta: mempoolTx.feeDelta || undefined,
             };
             if (!mempoolTx.cpfpChecked) {
-              calculateMempoolTxCpfp(mempoolTx, newMempool);
+              calculateCpfp(mempoolTx, newMempool);
             }
             if (mempoolTx.cpfpDirty) {
               txInfo.cpfp = {
@@ -933,8 +931,6 @@ class WebsocketHandler {
       throw new Error('No WebSocket.Server have been set');
     }
 
-    const blockTransactions = structuredClone(transactions);
-
     this.printLogs();
     await statistics.runStatistics();
 
@@ -944,7 +940,7 @@ class WebsocketHandler {
     let transactionIds: string[] = (memPool.limitGBT) ? Object.keys(candidates?.txs || {}) : Object.keys(_memPool);
 
     const accelerations = Object.values(mempool.getAccelerations());
-    await accelerationRepository.$indexAccelerationsForBlock(block, accelerations, structuredClone(transactions));
+    await accelerationRepository.$indexAccelerationsForBlock(block, accelerations, transactions);
 
     const rbfTransactions = Common.findMinedRbfTransactions(transactions, memPool.getSpendMap());
     memPool.handleMinedRbfTransactions(rbfTransactions);
@@ -953,18 +949,22 @@ class WebsocketHandler {
     if (config.MEMPOOL.AUDIT && memPool.isInSync()) {
       let projectedBlocks;
       const auditMempool = _memPool;
-      const isAccelerated = accelerationApi.isAcceleratedBlock(block, Object.values(mempool.getAccelerations()));
+      const isAccelerated = config.MEMPOOL_SERVICES.ACCELERATIONS && accelerationApi.isAcceleratedBlock(block, Object.values(mempool.getAccelerations()));
 
-      if (config.MEMPOOL.RUST_GBT) {
-        const added = memPool.limitGBT ? (candidates?.added || []) : [];
-        const removed = memPool.limitGBT ? (candidates?.removed || []) : [];
-        projectedBlocks = await mempoolBlocks.$rustUpdateBlockTemplates(transactionIds, auditMempool, added, removed, candidates, isAccelerated, block.extras.pool.id);
+      if ((config.MEMPOOL_SERVICES.ACCELERATIONS)) {
+        if (config.MEMPOOL.RUST_GBT) {
+          const added = memPool.limitGBT ? (candidates?.added || []) : [];
+          const removed = memPool.limitGBT ? (candidates?.removed || []) : [];
+          projectedBlocks = await mempoolBlocks.$rustUpdateBlockTemplates(transactionIds, auditMempool, added, removed, candidates, isAccelerated, block.extras.pool.id);
+        } else {
+          projectedBlocks = await mempoolBlocks.$makeBlockTemplates(transactionIds, auditMempool, candidates, false, isAccelerated, block.extras.pool.id);
+        }
       } else {
-        projectedBlocks = await mempoolBlocks.$makeBlockTemplates(transactionIds, auditMempool, candidates, false, isAccelerated, block.extras.pool.id);
+        projectedBlocks = mempoolBlocks.getMempoolBlocksWithTransactions();
       }
 
       if (Common.indexingEnabled()) {
-        const { unseen, censored, added, prioritized, fresh, sigop, fullrbf, accelerated, score, similarity } = Audit.auditBlock(block.height, blockTransactions, projectedBlocks, auditMempool);
+        const { censored, added, prioritized, fresh, sigop, fullrbf, accelerated, score, similarity } = Audit.auditBlock(transactions, projectedBlocks, auditMempool);
         const matchRate = Math.round(score * 100 * 100) / 100;
 
         const stripped = projectedBlocks[0]?.transactions ? projectedBlocks[0].transactions : [];
@@ -986,11 +986,9 @@ class WebsocketHandler {
         });
 
         BlocksAuditsRepository.$saveAudit({
-          version: 1,
           time: block.timestamp,
           height: block.height,
           hash: block.id,
-          unseenTxs: unseen,
           addedTxs: added,
           prioritizedTxs: prioritized,
           missingTxs: censored,
@@ -1042,7 +1040,7 @@ class WebsocketHandler {
       const removed = memPool.limitGBT ? (candidates?.removed || []) : transactions;
       await mempoolBlocks.$rustUpdateBlockTemplates(transactionIds, _memPool, added, removed, candidates, true);
     } else {
-      await mempoolBlocks.$makeBlockTemplates(transactionIds, _memPool, candidates, true, true);
+      await mempoolBlocks.$makeBlockTemplates(transactionIds, _memPool, candidates, true, config.MEMPOOL_SERVICES.ACCELERATIONS);
     }
     const mBlocks = mempoolBlocks.getMempoolBlocks();
     const mBlockDeltas = mempoolBlocks.getMempoolBlockDeltas();
@@ -1144,7 +1142,6 @@ class WebsocketHandler {
                 accelerated: mempoolTx.acceleration || undefined,
                 acceleratedBy: mempoolTx.acceleratedBy || undefined,
                 acceleratedAt: mempoolTx.acceleratedAt || undefined,
-                feeDelta: mempoolTx.feeDelta || undefined,
               },
               accelerationPositions: memPool.getAccelerationPositions(mempoolTx.txid),
             });
@@ -1167,7 +1164,6 @@ class WebsocketHandler {
                 accelerated: mempoolTx.acceleration || undefined,
                 acceleratedBy: mempoolTx.acceleratedBy || undefined,
                 acceleratedAt: mempoolTx.acceleratedAt || undefined,
-                feeDelta: mempoolTx.feeDelta || undefined,
               };
             }
           }

backend/src/config.ts

@@ -193,7 +193,7 @@ const defaults: IConfig = {
     'POOLS_JSON_URL': 'https://raw.githubusercontent.com/mempool/mining-pools/master/pools-v2.json',
     'POOLS_JSON_TREE_URL': 'https://api.github.com/repos/mempool/mining-pools/git/trees/master',
     'AUDIT': false,
-    'RUST_GBT': true,
+    'RUST_GBT': false,
     'LIMIT_GBT': false,
     'CPFP_INDEXING': false,
     'MAX_BLOCKS_BULK_QUERY': 0,

backend/src/index.ts

@@ -229,7 +229,7 @@ class Server {
       const newMempool = await bitcoinApi.$getRawMempool();
       const minFeeMempool = memPool.limitGBT ? await bitcoinSecondClient.getRawMemPool() : null;
       const minFeeTip = memPool.limitGBT ? await bitcoinSecondClient.getBlockCount() : -1;
-      const newAccelerations = await accelerationApi.$updateAccelerations();
+      const newAccelerations = await accelerationApi.$fetchAccelerations();
       const numHandledBlocks = await blocks.$updateBlocks();
       const pollRate = config.MEMPOOL.POLL_RATE_MS * (indexer.indexerIsRunning() ? 10 : 1);
       if (numHandledBlocks === 0) {

backend/src/indexer.ts

@@ -10,7 +10,6 @@ import config from './config';
 import auditReplicator from './replication/AuditReplication';
 import statisticsReplicator from './replication/StatisticsReplication';
 import AccelerationRepository from './repositories/AccelerationRepository';
-import BlocksAuditsRepository from './repositories/BlocksAuditsRepository';
 
 export interface CoreIndex {
   name: string;
@@ -193,7 +192,6 @@ class Indexer {
       await auditReplicator.$sync();
       await statisticsReplicator.$sync();
       await AccelerationRepository.$indexPastAccelerations();
-      await BlocksAuditsRepository.$migrateAuditsV0toV1();
       // do not wait for classify blocks to finish
       blocks.$classifyBlocks();
     } catch (e) {

backend/src/mempool.interfaces.ts

@@ -29,11 +29,9 @@ export interface PoolStats extends PoolInfo {
 }
 
 export interface BlockAudit {
-  version: number,
   time: number,
   height: number,
   hash: string,
-  unseenTxs: string[],
   missingTxs: string[],
   freshTxs: string[],
   sigopTxs: string[],
@@ -128,7 +126,6 @@ export interface TransactionExtended extends IEsploraApi.Transaction {
   acceleration?: boolean;
   acceleratedBy?: number[];
   acceleratedAt?: number;
-  feeDelta?: number;
   replacement?: boolean;
   uid?: number;
   flags?: number;
@@ -226,7 +223,6 @@ export interface CpfpInfo {
   sigops?: number;
   adjustedVsize?: number,
   acceleration?: boolean,
-  fee?: number;
 }
 
 export interface TransactionStripped {
@@ -385,9 +381,8 @@ export interface CpfpCluster {
 }
 
 export interface CpfpSummary {
-  transactions: MempoolTransactionExtended[];
+  transactions: TransactionExtended[];
   clusters: CpfpCluster[];
-  version: number;
 }
 
 export interface Statistic {
@@ -453,7 +448,7 @@ export interface OptimizedStatistic {
 
 export interface TxTrackingInfo {
   replacedBy?: string,
-  position?: { block: number, vsize: number, accelerated?: boolean, acceleratedBy?: number[], acceleratedAt?: number, feeDelta?: number },
+  position?: { block: number, vsize: number, accelerated?: boolean, acceleratedBy?: number[], acceleratedAt?: number },
   cpfp?: {
     ancestors?: Ancestor[],
     bestDescendant?: Ancestor | null,
@@ -466,7 +461,6 @@ export interface TxTrackingInfo {
   accelerated?: boolean,
   acceleratedBy?: number[],
   acceleratedAt?: number,
-  feeDelta?: number,
   confirmed?: boolean
 }
 

backend/src/replication/AuditReplication.ts

@@ -31,11 +31,11 @@ class AuditReplication {
     const missingAudits = await this.$getMissingAuditBlocks();
 
     logger.debug(`Fetching missing audit data for ${missingAudits.length} blocks from trusted servers`, 'Replication');
-
+    
     let totalSynced = 0;
     let totalMissed = 0;
     let loggerTimer = Date.now();
-    // process missing audits in batches of BATCH_SIZE
+    // process missing audits in batches of 
     for (let i = 0; i < missingAudits.length; i += BATCH_SIZE) {
       const slice = missingAudits.slice(i, i + BATCH_SIZE);
       const results = await Promise.all(slice.map(hash => this.$syncAudit(hash)));
@@ -109,11 +109,9 @@ class AuditReplication {
       version: 1,
     });
     await blocksAuditsRepository.$saveAudit({
-      version: auditSummary.version || 0,
       hash: blockHash,
       height: auditSummary.height,
       time: auditSummary.timestamp || auditSummary.time,
-      unseenTxs: auditSummary.unseenTxs || [],
       missingTxs: auditSummary.missingTxs || [],
       addedTxs: auditSummary.addedTxs || [],
       prioritizedTxs: auditSummary.prioritizedTxs || [],

backend/src/repositories/AccelerationRepository.ts

@@ -1,4 +1,4 @@
-import { AccelerationInfo } from '../api/acceleration/acceleration';
+import { AccelerationInfo, makeBlockTemplate } from '../api/acceleration/acceleration';
 import { RowDataPacket } from 'mysql2';
 import DB from '../database';
 import logger from '../logger';
@@ -11,7 +11,6 @@ import accelerationCosts from '../api/acceleration/acceleration';
 import bitcoinApi from '../api/bitcoin/bitcoin-api-factory';
 import transactionUtils from '../api/transaction-utils';
 import { BlockExtended, MempoolTransactionExtended } from '../mempool.interfaces';
-import { makeBlockTemplate } from '../api/mini-miner';
 
 export interface PublicAcceleration {
   txid: string,
@@ -192,7 +191,6 @@ class AccelerationRepository {
     }
   }
 
-  // modifies block transactions
   public async $indexAccelerationsForBlock(block: BlockExtended, accelerations: Acceleration[], transactions: MempoolTransactionExtended[]): Promise<void> {
     const blockTxs: { [txid: string]: MempoolTransactionExtended } = {};
     for (const tx of transactions) {
@@ -214,15 +212,6 @@ class AccelerationRepository {
         this.$saveAcceleration(accelerationInfo, block, block.extras.pool.id, successfulAccelerations);
       }
     }
-    let anyConfirmed = false;
-    for (const acc of accelerations) {
-      if (blockTxs[acc.txid]) {
-        anyConfirmed = true;
-      }
-    }
-    if (anyConfirmed) {
-      accelerationApi.accelerationConfirmed();
-    }
     const lastSyncedHeight = await this.$getLastSyncedHeight();
     // if we've missed any blocks, let the indexer catch up from the last synced height on the next run
     if (block.height === lastSyncedHeight + 1) {

backend/src/repositories/BlocksAuditsRepository.ts

@@ -1,24 +1,13 @@
+import blocks from '../api/blocks';
 import DB from '../database';
 import logger from '../logger';
-import bitcoinApi from '../api/bitcoin/bitcoin-api-factory';
-import { BlockAudit, AuditScore, TransactionAudit, TransactionStripped } from '../mempool.interfaces';
-
-interface MigrationAudit {
-  version: number,
-  height: number,
-  id: string,
-  timestamp: number,
-  prioritizedTxs: string[],
-  acceleratedTxs: string[],
-  template: TransactionStripped[],
-  transactions: TransactionStripped[],
-}
+import { BlockAudit, AuditScore, TransactionAudit } from '../mempool.interfaces';
 
 class BlocksAuditRepositories {
   public async $saveAudit(audit: BlockAudit): Promise<void> {
     try {
-      await DB.query(`INSERT INTO blocks_audits(version, time, height, hash, unseen_txs, missing_txs, added_txs, prioritized_txs, fresh_txs, sigop_txs, fullrbf_txs, accelerated_txs, match_rate, expected_fees, expected_weight)
-        VALUE (?, FROM_UNIXTIME(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [audit.version, audit.time, audit.height, audit.hash, JSON.stringify(audit.unseenTxs), JSON.stringify(audit.missingTxs),
+      await DB.query(`INSERT INTO blocks_audits(time, height, hash, missing_txs, added_txs, prioritized_txs, fresh_txs, sigop_txs, fullrbf_txs, accelerated_txs, match_rate, expected_fees, expected_weight)
+        VALUE (FROM_UNIXTIME(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [audit.time, audit.height, audit.hash, JSON.stringify(audit.missingTxs),
           JSON.stringify(audit.addedTxs), JSON.stringify(audit.prioritizedTxs), JSON.stringify(audit.freshTxs), JSON.stringify(audit.sigopTxs), JSON.stringify(audit.fullrbfTxs), JSON.stringify(audit.acceleratedTxs), audit.matchRate, audit.expectedFees, audit.expectedWeight]);
     } catch (e: any) {
       if (e.errno === 1062) { // ER_DUP_ENTRY - This scenario is possible upon node backend restart
@@ -73,30 +62,24 @@ class BlocksAuditRepositories {
   public async $getBlockAudit(hash: string): Promise<BlockAudit | null> {
     try {
       const [rows]: any[] = await DB.query(
-        `SELECT
-          blocks_audits.version,
-          blocks_audits.height,
-          blocks_audits.hash as id,
-          UNIX_TIMESTAMP(blocks_audits.time) as timestamp,
-          template,
-          unseen_txs as unseenTxs,
-          missing_txs as missingTxs,
-          added_txs as addedTxs,
-          prioritized_txs as prioritizedTxs,
-          fresh_txs as freshTxs,
-          sigop_txs as sigopTxs,
-          fullrbf_txs as fullrbfTxs,
-          accelerated_txs as acceleratedTxs,
-          match_rate as matchRate,
-          expected_fees as expectedFees,
-          expected_weight as expectedWeight
+        `SELECT blocks_audits.height, blocks_audits.hash as id, UNIX_TIMESTAMP(blocks_audits.time) as timestamp,
+        template,
+        missing_txs as missingTxs,
+        added_txs as addedTxs,
+        prioritized_txs as prioritizedTxs,
+        fresh_txs as freshTxs,
+        sigop_txs as sigopTxs,
+        fullrbf_txs as fullrbfTxs,
+        accelerated_txs as acceleratedTxs,
+        match_rate as matchRate,
+        expected_fees as expectedFees,
+        expected_weight as expectedWeight
         FROM blocks_audits
         JOIN blocks_templates ON blocks_templates.id = blocks_audits.hash
         WHERE blocks_audits.hash = ?
       `, [hash]);
       
       if (rows.length) {
-        rows[0].unseenTxs = JSON.parse(rows[0].unseenTxs);
         rows[0].missingTxs = JSON.parse(rows[0].missingTxs);
         rows[0].addedTxs = JSON.parse(rows[0].addedTxs);
         rows[0].prioritizedTxs = JSON.parse(rows[0].prioritizedTxs);
@@ -118,7 +101,7 @@ class BlocksAuditRepositories {
   public async $getBlockTxAudit(hash: string, txid: string): Promise<TransactionAudit | null> {
     try {
       const blockAudit = await this.$getBlockAudit(hash);
-
+      
       if (blockAudit) {
         const isAdded = blockAudit.addedTxs.includes(txid);
         const isPrioritized = blockAudit.prioritizedTxs.includes(txid);
@@ -132,17 +115,16 @@ class BlocksAuditRepositories {
             firstSeen = tx.time;
           }
         });
-        const wasSeen = blockAudit.version === 1 ? !blockAudit.unseenTxs.includes(txid) : (isExpected || isPrioritized || isAccelerated);
 
         return {
-          seen: wasSeen,
+          seen: isExpected || isPrioritized || isAccelerated,
           expected: isExpected,
-          added: isAdded && (blockAudit.version === 0 || !wasSeen),
+          added: isAdded,
           prioritized: isPrioritized,
           conflict: isConflict,
           accelerated: isAccelerated,
           firstSeen,
-        };
+        }
       }
       return null;
     } catch (e: any) {
@@ -204,96 +186,6 @@ class BlocksAuditRepositories {
       throw e;
     }
   }
-
-  /**
-   * [INDEXING] Migrate audits from v0 to v1
-   */
-  public async $migrateAuditsV0toV1(): Promise<void> {
-    try {
-      let done = false;
-      let processed = 0;
-      let lastHeight;
-      while (!done) {
-        const [toMigrate]: MigrationAudit[][] = await DB.query(
-          `SELECT
-            blocks_audits.height as height,
-            blocks_audits.hash as id,
-            UNIX_TIMESTAMP(blocks_audits.time) as timestamp,
-            blocks_summaries.transactions as transactions,
-            blocks_templates.template as template,
-            blocks_audits.prioritized_txs as prioritizedTxs,
-            blocks_audits.accelerated_txs as acceleratedTxs
-          FROM blocks_audits
-          JOIN blocks_summaries ON blocks_summaries.id = blocks_audits.hash
-          JOIN blocks_templates ON blocks_templates.id = blocks_audits.hash
-          WHERE blocks_audits.version = 0
-          AND blocks_summaries.version = 2
-          ORDER BY blocks_audits.height DESC
-          LIMIT 100
-        `) as any[];
-
-        if (toMigrate.length <= 0 || lastHeight === toMigrate[0].height) {
-          done = true;
-          break;
-        }
-        lastHeight = toMigrate[0].height;
-
-        logger.info(`migrating ${toMigrate.length} audits to version 1`);
-
-        for (const audit of toMigrate) {
-          // unpack JSON-serialized transaction lists
-          audit.transactions = JSON.parse((audit.transactions as any as string) || '[]');
-          audit.template = JSON.parse((audit.template as any as string) || '[]');
-
-          // we know transactions in the template, or marked "prioritized" or "accelerated"
-          // were seen in our mempool before the block was mined.
-          const isSeen = new Set<string>();
-          for (const tx of audit.template) {
-            isSeen.add(tx.txid);
-          }
-          for (const txid of audit.prioritizedTxs) {
-            isSeen.add(txid);
-          }
-          for (const txid of audit.acceleratedTxs) {
-            isSeen.add(txid);
-          }
-          const unseenTxs = audit.transactions.slice(0).map(tx => tx.txid).filter(txid => !isSeen.has(txid));
-
-          // identify "prioritized" transactions
-          const prioritizedTxs: string[] = [];
-          let lastEffectiveRate = 0;
-          // Iterate over the mined template from bottom to top (excluding the coinbase)
-          // Transactions should appear in ascending order of mining priority.
-          for (let i = audit.transactions.length - 1; i > 0; i--) {
-            const blockTx = audit.transactions[i];
-            // If a tx has a lower in-band effective fee rate than the previous tx,
-            // it must have been prioritized out-of-band (in order to have a higher mining priority)
-            // so exclude from the analysis.
-            if ((blockTx.rate || 0) < lastEffectiveRate) {
-              prioritizedTxs.push(blockTx.txid);
-            } else {
-              lastEffectiveRate = blockTx.rate || 0;
-            }
-          }
-
-          // Update audit in the database
-          await DB.query(`
-            UPDATE blocks_audits SET
-              version = ?,
-              unseen_txs = ?,
-              prioritized_txs = ?
-            WHERE hash = ?
-          `, [1, JSON.stringify(unseenTxs), JSON.stringify(prioritizedTxs), audit.id]);
-        }
-
-        processed += toMigrate.length;
-      }
-
-      logger.info(`migrated ${processed} audits to version 1`);
-    } catch (e: any) {
-      logger.err(`Error while migrating audits from v0 to v1. Will try again later. Reason: ` + (e instanceof Error ? e.message : e));
-    }
-  }
 }
 
 export default new BlocksAuditRepositories();

backend/src/repositories/BlocksSummariesRepository.ts

@@ -114,43 +114,6 @@ class BlocksSummariesRepository {
     return [];
   }
 
-  public async $getSummariesBelowVersion(version: number): Promise<{ height: number, id: string, version: number }[]> {
-    try {
-      const [rows]: any[] = await DB.query(`
-        SELECT
-          height,
-          id,
-          version
-        FROM blocks_summaries
-        WHERE version < ?
-        ORDER BY height DESC;`, [version]);
-      return rows;
-    } catch (e) {
-      logger.err(`Cannot get block summaries below version. Reason: ` + (e instanceof Error ? e.message : e));
-    }
-
-    return [];
-  }
-
-  public async $getTemplatesBelowVersion(version: number): Promise<{ height: number, id: string, version: number }[]> {
-    try {
-      const [rows]: any[] = await DB.query(`
-        SELECT
-          blocks_summaries.height as height,
-          blocks_templates.id as id,
-          blocks_templates.version as version
-        FROM blocks_templates
-        JOIN blocks_summaries ON blocks_templates.id = blocks_summaries.id
-        WHERE blocks_templates.version < ?
-        ORDER BY height DESC;`, [version]);
-      return rows;
-    } catch (e) {
-      logger.err(`Cannot get block summaries below version. Reason: ` + (e instanceof Error ? e.message : e));
-    }
-
-    return [];
-  }
-
   /**
    * Get the fee percentiles if the block has already been indexed, [] otherwise
    * 

backend/src/repositories/CpfpRepository.ts

@@ -91,26 +91,6 @@ class CpfpRepository {
     return;
   }
 
-  public async $getClustersAt(height: number): Promise<CpfpCluster[]> {
-    const [clusterRows]: any = await DB.query(
-      `
-        SELECT *
-        FROM compact_cpfp_clusters
-        WHERE height = ?
-      `,
-      [height]
-    );
-    return clusterRows.map(cluster => {
-      if (cluster?.txs) {
-        cluster.effectiveFeePerVsize = cluster.fee_rate;
-        cluster.txs = this.unpack(cluster.txs);
-        return cluster;
-      } else {
-        return null;
-      }
-    }).filter(cluster => cluster !== null);
-  }
-
   public async $deleteClustersFrom(height: number): Promise<void> {
     logger.info(`Delete newer cpfp clusters from height ${height} from the database`);
     try {
@@ -142,37 +122,6 @@ class CpfpRepository {
     }
   }
 
-  public async $deleteClustersAt(height: number): Promise<void> {
-    logger.info(`Delete cpfp clusters at height ${height} from the database`);
-    try {
-      const [rows] = await DB.query(
-        `
-          SELECT txs, height, root from compact_cpfp_clusters
-          WHERE height = ?
-        `,
-        [height]
-      ) as RowDataPacket[][];
-      if (rows?.length) {
-        for (const clusterToDelete of rows) {
-          const txs = this.unpack(clusterToDelete?.txs);
-          for (const tx of txs) {
-            await transactionRepository.$removeTransaction(tx.txid);
-          }
-        }
-      }
-      await DB.query(
-        `
-          DELETE from compact_cpfp_clusters
-          WHERE height = ?
-        `,
-        [height]
-      );
-    } catch (e: any) {
-      logger.err(`Cannot delete cpfp clusters from db. Reason: ` + (e instanceof Error ? e.message : e));
-      throw e;
-    }
-  }
-
   // insert a dummy row to mark that we've indexed as far as this block
   public async $insertProgressMarker(height: number): Promise<void> {
     try {
@@ -241,32 +190,6 @@ class CpfpRepository {
       return [];
     }
   }
-
-  // returns `true` if two sets of CPFP clusters are deeply identical
-  public compareClusters(clustersA: CpfpCluster[], clustersB: CpfpCluster[]): boolean {
-    if (clustersA.length !== clustersB.length) {
-      return false;
-    }
-
-    clustersA = clustersA.sort((a,b) => a.root.localeCompare(b.root));
-    clustersB = clustersB.sort((a,b) => a.root.localeCompare(b.root));
-
-    for (let i = 0; i < clustersA.length; i++) {
-      if (clustersA[i].root !== clustersB[i].root) {
-        return false;
-      }
-      if (clustersA[i].txs.length !== clustersB[i].txs.length) {
-        return false;
-      }
-      for (let j = 0; j < clustersA[i].txs.length; j++) {
-        if (clustersA[i].txs[j].txid !== clustersB[i].txs[j].txid) {
-          return false;
-        }
-      }
-    }
-
-    return true;
-  }
 }
 
 export default new CpfpRepository();

docker/backend/start.sh

@@ -30,7 +30,7 @@ __MEMPOOL_AUTOMATIC_POOLS_UPDATE__=${MEMPOOL_AUTOMATIC_POOLS_UPDATE:=false}
 __MEMPOOL_POOLS_JSON_URL__=${MEMPOOL_POOLS_JSON_URL:=https://raw.githubusercontent.com/mempool/mining-pools/master/pools-v2.json}
 __MEMPOOL_POOLS_JSON_TREE_URL__=${MEMPOOL_POOLS_JSON_TREE_URL:=https://api.github.com/repos/mempool/mining-pools/git/trees/master}
 __MEMPOOL_AUDIT__=${MEMPOOL_AUDIT:=false}
-__MEMPOOL_RUST_GBT__=${MEMPOOL_RUST_GBT:=true}
+__MEMPOOL_RUST_GBT__=${MEMPOOL_RUST_GBT:=false}
 __MEMPOOL_LIMIT_GBT__=${MEMPOOL_LIMIT_GBT:=false}
 __MEMPOOL_CPFP_INDEXING__=${MEMPOOL_CPFP_INDEXING:=false}
 __MEMPOOL_MAX_BLOCKS_BULK_QUERY__=${MEMPOOL_MAX_BLOCKS_BULK_QUERY:=0}
@@ -144,7 +144,7 @@ __REPLICATION_STATISTICS_START_TIME__=${REPLICATION_STATISTICS_START_TIME:=14819
 __REPLICATION_SERVERS__=${REPLICATION_SERVERS:=[]}
 
 # MEMPOOL_SERVICES
-__MEMPOOL_SERVICES_API__=${MEMPOOL_SERVICES_API:="https://mempool.space/api/v1/services"}
+__MEMPOOL_SERVICES_API__=${MEMPOOL_SERVICES_API:=""}
 __MEMPOOL_SERVICES_ACCELERATIONS__=${MEMPOOL_SERVICES_ACCELERATIONS:=false}
 
 # REDIS

docker/frontend/entrypoint.sh

@@ -40,8 +40,7 @@ __MAINNET_BLOCK_AUDIT_START_HEIGHT__=${MAINNET_BLOCK_AUDIT_START_HEIGHT:=0}
 __TESTNET_BLOCK_AUDIT_START_HEIGHT__=${TESTNET_BLOCK_AUDIT_START_HEIGHT:=0}
 __SIGNET_BLOCK_AUDIT_START_HEIGHT__=${SIGNET_BLOCK_AUDIT_START_HEIGHT:=0}
 __ACCELERATOR__=${ACCELERATOR:=false}
-__ACCELERATOR_BUTTON__=${ACCELERATOR_BUTTON:=true}
-__SERVICES_API__=${SERVICES_API:=https://mempool.space/api/v1/services}
+__SERVICES_API__=${SERVICES_API:=false}
 __PUBLIC_ACCELERATIONS__=${PUBLIC_ACCELERATIONS:=false}
 __HISTORICAL_PRICE__=${HISTORICAL_PRICE:=true}
 __ADDITIONAL_CURRENCIES__=${ADDITIONAL_CURRENCIES:=false}
@@ -71,7 +70,6 @@ export __MAINNET_BLOCK_AUDIT_START_HEIGHT__
 export __TESTNET_BLOCK_AUDIT_START_HEIGHT__
 export __SIGNET_BLOCK_AUDIT_START_HEIGHT__
 export __ACCELERATOR__
-export __ACCELERATOR_BUTTON__
 export __SERVICES_API__
 export __PUBLIC_ACCELERATIONS__
 export __HISTORICAL_PRICE__

frontend/angular.json

@@ -54,10 +54,6 @@
             "translation": "src/locale/messages.fr.xlf",
             "baseHref": "/fr/"
           },
-          "hr": {
-            "translation": "src/locale/messages.hr.xlf",
-            "baseHref": "/hr/"
-          },
           "ja": {
             "translation": "src/locale/messages.ja.xlf",
             "baseHref": "/ja/"

frontend/cypress/e2e/mainnet/mainnet.spec.ts

@@ -543,7 +543,16 @@ describe('Mainnet', () => {
           }
         });
 
-        cy.get('.alert-replaced').should('be.visible');
+        cy.get('.alert').should('be.visible');
+        cy.get('.alert').invoke('css', 'width').then((alertWidth) => {
+          cy.get('.container-xl > :nth-child(3)').invoke('css', 'width').should('equal', alertWidth);
+        });
+
+        cy.get('.btn-warning').then(getRectangle).then((rectA) => {
+          cy.get('.alert').then(getRectangle).then((rectB) => {
+            expect(areOverlapping(rectA, rectB), 'Confirmations box and RBF alert are overlapping').to.be.false;
+          });
+        });
       });
 
       it('shows RBF transactions properly (desktop)', () => {

frontend/cypress/fixtures/mainnet_mempoolInfo.json

@@ -750,7 +750,7 @@
     },
     "backendInfo": {
       "hostname": "node205.tk7.mempool.space",
-      "version": "3.0.0",
+      "version": "3.0.0-dev",
       "gitCommit": "abbc8a134",
       "lightning": false
     },

frontend/mempool-frontend-config.sample.json

@@ -25,7 +25,6 @@
   "HISTORICAL_PRICE": true,
   "ADDITIONAL_CURRENCIES": false,
   "ACCELERATOR": false,
-  "ACCELERATOR_BUTTON": true,
   "PUBLIC_ACCELERATIONS": false,
   "SERVICES_API": "https://mempool.space/api/v1/services"
 }

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "mempool-frontend",
-  "version": "3.0.1",
+  "version": "3.0.0-dev",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "mempool-frontend",
-      "version": "3.0.0",
+      "version": "3.0.0-dev",
       "license": "GNU Affero General Public License v3.0",
       "dependencies": {
         "@angular-devkit/build-angular": "^17.3.1",

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mempool-frontend",
-  "version": "3.0.1",
+  "version": "3.0.0-dev",
   "description": "Bitcoin mempool visualizer and blockchain explorer backend",
   "license": "GNU Affero General Public License v3.0",
   "homepage": "https://mempool.space",

frontend/src/app/app-routing.module.ts

@@ -9,7 +9,6 @@ import { StatusViewComponent } from './components/status-view/status-view.compon
 import { AddressGroupComponent } from './components/address-group/address-group.component';
 import { TrackerComponent } from './components/tracker/tracker.component';
 import { AccelerateCheckout } from './components/accelerate-checkout/accelerate-checkout.component';
-import { TrackerGuard } from './route-guards';
 
 const browserWindow = window || {};
 // @ts-ignore
@@ -141,17 +140,16 @@ let routes: Routes = [
     loadChildren: () => import('./bitcoin-graphs.module').then(m => m.BitcoinGraphsModule),
     data: { preload: true },
   },
-  {
-    path: 'tx',
-    canMatch: [TrackerGuard],
-    runGuardsAndResolvers: 'always',
-    loadChildren: () => import('./components/tracker/tracker.module').then(m => m.TrackerModule),
-  },
   {
     path: '',
     loadChildren: () => import('./master-page.module').then(m => m.MasterPageModule),
     data: { preload: true },
   },
+  {
+    path: 'tracker',
+    data: { networkSpecific: true },
+    loadChildren: () => import('./components/tracker/tracker.module').then(m => m.TrackerModule),
+  },
   {
     path: 'wallet',
     children: [],
@@ -215,6 +213,10 @@ let routes: Routes = [
     loadChildren: () => import('./bitcoin-graphs.module').then(m => m.BitcoinGraphsModule),
     data: { preload: true },
   },
+  {
+    path: '**',
+    redirectTo: ''
+  },
 ];
 
 if (browserWindowEnv && browserWindowEnv.BASE_MODULE === 'liquid') {
@@ -299,16 +301,13 @@ if (browserWindowEnv && browserWindowEnv.BASE_MODULE === 'liquid') {
       loadChildren: () => import('./liquid/liquid-graphs.module').then(m => m.LiquidGraphsModule),
       data: { preload: true },
     },
+    {
+      path: '**',
+      redirectTo: ''
+    },
   ];
 }
 
-if (!window['isMempoolSpaceBuild']) {
-  routes.push({
-    path: '**',
-    redirectTo: ''
-  });
-}
-
 @NgModule({
   imports: [RouterModule.forRoot(routes, {
     initialNavigation: 'enabledBlocking',

frontend/src/app/app.constants.ts

@@ -151,7 +151,7 @@ export const languages: Language[] = [
    { code: 'fr', name: 'Français' },        // French
 // { code: 'gl', name: 'Galego' },          // Galician
    { code: 'ko', name: '한국어' },          // Korean
-   { code: 'hr', name: 'Hrvatski' },        // Croatian
+// { code: 'hr', name: 'Hrvatski' },        // Croatian
 // { code: 'id', name: 'Bahasa Indonesia' },// Indonesian
    { code: 'hi', name: 'हिन्दी' },             // Hindi
    { code: 'ne', name: 'नेपाली' },            // Nepalese

frontend/src/app/components/about/about.component.html

@@ -53,7 +53,7 @@
         <span>Spiral</span>
       </a>
       <a href="https://foundrydigital.com/" target="_blank" title="Foundry">
-        <svg xmlns="http://www.w3.org/2000/svg" id="b" data-name="Layer 2" style="zoom: 1;" width="32" height="76" viewBox="0 0 32 76" class="image">
+        <svg xmlns="http://www.w3.org/2000/svg" id="b" data-name="Layer 2" style="zoom: 1;" width="32" height="76" viewBox="0 0 32 76">
           <defs>
             <style>
               .d {
@@ -125,9 +125,7 @@
         <span>Blockstream</span>
       </a>
       <a href="https://unchained.com/" target="_blank" title="Unchained">
-        <svg id="Layer_1" width="78" height="78" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 156.68 156.68" class="image">
-          <defs><style>.cls-unchained-1{fill:#fff;}</style></defs><path class="cls-unchained-1" d="m78.34,0C35.07,0,0,35.07,0,78.34s35.07,78.34,78.34,78.34,78.34-35.07,78.34-78.34S121.6,0,78.34,0ZM20.23,109.5c-4.99-9.28-7.81-19.89-7.81-31.16C12.42,41.93,41.93,12.42,78.34,12.42c33.15,0,60.58,24.46,65.23,56.32h-37.48c-45.29,0-71.19,20.05-85.85,40.76Zm58.11,34.76c-12.42,0-24.04-3.44-33.96-9.41,3.94-8.85,9.11-18.7,15.84-28.9,20.99-31.8,52.2-31.19,76.49-31.19h7.45c.06,1.18.1,2.38.1,3.58,0,36.41-29.51,65.92-65.92,65.92Z"/><path class="cls-unchained-1" d="m91.98,42.4l-3.62-1.18c-3.94-1.29-7.03-4.38-8.32-8.32l-1.18-3.63c-.13-.39-.68-.39-.81,0l-1.18,3.63c-1.29,3.94-4.38,7.03-8.32,8.32l-3.62,1.18c-.39.13-.39.68,0,.81l3.62,1.18c3.94,1.29,7.03,4.38,8.32,8.32l1.18,3.63c.13.39.68.39.81,0l1.18-3.63c1.29-3.94,4.38-7.03,8.32-8.32l3.62-1.18c.39-.13.39-.68,0-.81Z"/>
-        </svg>
+        <svg id="Layer_1" width="78" height="78" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 156.68 156.68"><defs><style>.cls-unchained-1{fill:#fff;}</style></defs><path class="cls-unchained-1" d="m78.34,0C35.07,0,0,35.07,0,78.34s35.07,78.34,78.34,78.34,78.34-35.07,78.34-78.34S121.6,0,78.34,0ZM20.23,109.5c-4.99-9.28-7.81-19.89-7.81-31.16C12.42,41.93,41.93,12.42,78.34,12.42c33.15,0,60.58,24.46,65.23,56.32h-37.48c-45.29,0-71.19,20.05-85.85,40.76Zm58.11,34.76c-12.42,0-24.04-3.44-33.96-9.41,3.94-8.85,9.11-18.7,15.84-28.9,20.99-31.8,52.2-31.19,76.49-31.19h7.45c.06,1.18.1,2.38.1,3.58,0,36.41-29.51,65.92-65.92,65.92Z"/><path class="cls-unchained-1" d="m91.98,42.4l-3.62-1.18c-3.94-1.29-7.03-4.38-8.32-8.32l-1.18-3.63c-.13-.39-.68-.39-.81,0l-1.18,3.63c-1.29,3.94-4.38,7.03-8.32,8.32l-3.62,1.18c-.39.13-.39.68,0,.81l3.62,1.18c3.94,1.29,7.03,4.38,8.32,8.32l1.18,3.63c.13.39.68.39.81,0l1.18-3.63c1.29-3.94,4.38-7.03,8.32-8.32l3.62-1.18c.39-.13.39-.68,0-.81Z"/></svg>
         <span>Unchained</span>
       </a>
       <a href="https://gemini.com/" target="_blank" title="Gemini">
@@ -152,7 +150,7 @@
         <span>Bull Bitcoin</span>
       </a>
       <a href="https://exodus.com/" target="_blank" title="Exodus">
-        <svg width="80" height="80" viewBox="0 0 500 500" fill="none" xmlns="http://www.w3.org/2000/svg" class="image">
+        <svg width="80" height="80" viewBox="0 0 500 500" fill="none" xmlns="http://www.w3.org/2000/svg">
           <circle cx="250" cy="250" r="250" fill="#1F2033"/>
           <g clip-path="url(#clip0_2_14)">
             <path d="M411.042 178.303L271.79 87V138.048L361.121 196.097L350.612 229.351H271.79V271.648H350.612L361.121 304.903L271.79 362.952V414L411.042 322.989L388.271 250.646L411.042 178.303Z" fill="url(#paint0_linear_2_14)"/>
@@ -437,7 +435,7 @@
       Trademark Notice<br>
     </div>
     <p>
-      The Mempool Open Source Project&reg;, Mempool Accelerator&trade;, Mempool Enterprise&reg;, Mempool Liquidity&trade;, mempool.space&reg;, Be your own explorer&trade;, Explore the full Bitcoin ecosystem&reg;, Mempool Goggles&trade;, the mempool Logo, the mempool Square Logo, the mempool block visualization Logo, the mempool Blocks Logo, the mempool transaction Logo, the mempool Blocks 3 | 2 Logo, the mempool research Logo, the mempool.space Vertical Logo, and the mempool.space Horizontal Logo are either registered trademarks or trademarks of Mempool Space K.K in Japan, the United States, and/or other countries.
+      The Mempool Open Source Project&reg;, Mempool Accelerator&trade;, Mempool Enterprise&reg;, Mempool Liquidity&trade;, mempool.space&reg;, Be your own explorer&trade;, Explore the full Bitcoin ecosystem&reg;, Mempool Goggles&trade;, the mempool logo, the mempool Square logo, the mempool Blocks logo, the mempool Blocks 3 | 2 logo, the mempool.space Vertical Logo, and the mempool.space Horizontal logo are either registered trademarks or trademarks of Mempool Space K.K in Japan, the United States, and/or other countries.
     </p>
     <p>
       While our software is available under an open source software license, the copyright license does not include an implied right or license to use our trademarks. See our <a href="https://mempool.space/trademark-policy">Trademark Policy and Guidelines</a> for more details, published on &lt;https://mempool.space/trademark-policy&gt;.

frontend/src/app/components/about/about.component.scss

@@ -13,6 +13,8 @@
 
   .image.not-rounded {
     border-radius: 0;
+    width: 60px;
+    height: 60px;
   }
 
   .intro {
@@ -156,8 +158,9 @@
           margin: 40px 29px 10px;
           &.image.coldcard {
             border-radius: 0;
-            height: auto;
-            margin: 20px 29px 20px;
+            width: auto;
+            max-height: 50px;
+            margin: 40px 29px 14px 29px;
           }
         }
       }

frontend/src/app/components/accelerate-checkout/accelerate-checkout.component.html

@@ -389,30 +389,16 @@
                   </div>
                 }
               </div>
-              @if (canPayWithCashapp || canPayWithApplePay || canPayWithGooglePay) {
+              @if (canPayWithCashapp) {
                 <div class="col-sm text-center flex-grow-0  d-flex flex-column justify-content-center align-items-center">
                   <p class="text-nowrap">&mdash;<span i18n="or">OR</span>&mdash;</p>
                 </div>
               }
             }
-            @if (canPayWithCashapp || canPayWithApplePay || canPayWithGooglePay) {
+            @if (canPayWithCashapp) {
               <div class="col-sm text-center d-flex flex-column justify-content-center align-items-center">
                 <p><ng-container i18n="transaction.pay|Pay button label">Pay</ng-container>&nbsp;<app-fiat [value]="cost"></app-fiat> with</p>
-                @if (canPayWithCashapp) {
-                  <img class="paymentMethod mx-2" style="width: 200px" src="/resources/cash-app.svg" height=55 (click)="moveToStep('cashapp')">
-                }
-                @if (canPayWithApplePay) {
-                  @if (canPayWithCashapp) { <span class="mt-1 mb-1"></span> }
-                  <div class="paymentMethod mx-2" style="width: 200px; height: 55px" (click)="moveToStep('applepay')">
-                    <img src="/resources/apple-pay.png" height=37>
-                  </div>
-                }
-                @if (canPayWithGooglePay) {
-                  @if (canPayWithCashapp || canPayWithApplePay) { <span class="mt-1 mb-1"></span> }
-                  <div class="paymentMethod mx-2" style="width: 200px; height: 55px" (click)="moveToStep('googlepay')">
-                    <img src="/resources/google-pay.png" height=37>
-                  </div>
-                }
+                <img class="paymentMethod mx-2" src="/resources/cash-app.svg" height=55 (click)="moveToStep('cashapp')">
               </div>
             }
           </div>
@@ -435,9 +421,9 @@
         <button type="button" class="mt-1 btn btn-secondary btn-sm rounded-pill align-self-center" style="width: 200px" (click)="moveToStep('summary')" i18n="go-back">Go back</button>
       </div>
     </div>
-  } @else if (step === 'cashapp' || step === 'applepay' || step === 'googlepay') {
+  } @else if (step === 'cashapp') {
     <!-- Show checkout page -->
-    <div class="row mb-md-1 text-center" id="confirm-title">
+    <div class="row mb-md-1 text-center">
       <div class="col-sm" id="confirm-payment-title">
         <h1 style="font-size: larger;"><ng-content select="[slot='checkout-title']"></ng-content><span class="default-slot" i18n="accelerator.confirm-your-payment">Confirm your payment</span></h1>
       </div>
@@ -451,7 +437,7 @@
       </div>
     </div>
 
-    @if (step === 'cashapp' && !loadingCashapp || step === 'applepay' && !loadingApplePay || step === 'googlepay' && !loadingGooglePay) {
+    @if (!loadingCashapp) {
       <div class="row text-center mt-1">
         <div class="col-sm">
           <div class="form-group w-100">
@@ -470,14 +456,8 @@
     <div class="row text-center mt-1">
       <div class="col-sm">
         <div class="form-group w-100">
-          @if (step === 'applepay') {
-            <div id="apple-pay-button" class="apple-pay-button apple-pay-button-black" style="height: 50px"  [style]="loadingApplePay ? 'opacity: 0; width: 0px; height: 0px; pointer-events: none;' : ''"></div>
-          } @else if (step === 'cashapp') {          
-            <div id="cash-app-pay" class="d-inline-block" style="height: 50px" [style]="loadingCashapp ? 'opacity: 0; width: 0px; height: 0px; pointer-events: none;' : ''"></div>
-          } @else if (step === 'googlepay') {
-            <div id="google-pay-button" class="d-inline-block" style="height: 50px" [style]="loadingGooglePay ? 'opacity: 0; width: 0px; height: 0px; pointer-events: none;' : ''"></div>
-          }
-          @if (loadingCashapp || loadingApplePay || loadingGooglePay) {
+          <div id="cash-app-pay" class="d-inline-block" [style]="loadingCashapp ? 'opacity: 0; width: 0px; height: 0px; pointer-events: none;' : ''"></div>
+          @if (loadingCashapp) {
           <div display="d-flex flex-row justify-content-center">
             <span i18n="accelerator.loading-payment-method">Loading payment method...</span>
             <div class="ml-2 spinner-border text-light" style="width: 25px; height: 25px"></div>
@@ -525,7 +505,7 @@
       <div class="col-sm">
         <div class="d-flex flex-row flex-column justify-content-center align-items-center">
           <span i18n="accelerator.confirming-acceleration-with-miners">Confirming your acceleration with our mining pool partners...</span>
-          @if (timeSincePaid > 30000) {
+          @if (timeSincePaid > 20000) {
             <span i18n="accelerator.confirming-acceleration-with-miners">...sorry, this is taking longer than expected...</span>
           }
           <div class="m-2 spinner-border text-light" style="width: 25px; height: 25px"></div>
@@ -569,7 +549,7 @@
   <button type="button" *ngIf="advancedEnabled" class="btn btn-sm btn-outline-info btn-small-height ml-2" (click)="moveToStep('quote')" i18n="accelerator.customize">customize</button>
 </ng-template>
 
-<ng-template id="accelerate-to" #accelerateTo let-x i18n="accelerator.accelerate-to-x">Accelerate to ~{{ x | number : '1.0-0' }} sat/vB</ng-template>
+<ng-template #accelerateTo let-x i18n="accelerator.accelerate-to-x">Accelerate to ~{{ x | number : '1.0-0' }} sat/vB</ng-template>
 
 <ng-template #accelerateButton>
   <div class="position-relative">

frontend/src/app/components/accelerate-checkout/accelerate-checkout.component.scss

@@ -11,7 +11,8 @@
 .paymentMethod {
   padding: 10px;
   background-color: var(--secondary);
-  border-radius: 10px;
+  border-radius: 15px;
+  border: 2px solid var(--bg);
   cursor: pointer;
 }
 
@@ -201,19 +202,4 @@
 
 .btn-error-wrapper {
   height: 26px;
-}
-
-.apple-pay-button {
-    display: inline-block;
-    -webkit-appearance: -apple-pay-button;
-    -apple-pay-button-type: plain; /* Use any supported button type. */
-}
-.apple-pay-button-black {
-    -apple-pay-button-style: black;
-}
-.apple-pay-button-white {
-    -apple-pay-button-style: white;
-}
-.apple-pay-button-white-with-line {
-    -apple-pay-button-style: white-outline;
 }

frontend/src/app/components/accelerate-checkout/accelerate-checkout.component.ts

@@ -1,8 +1,7 @@
-/* eslint-disable no-console */
 import { Component, OnInit, OnDestroy, Output, EventEmitter, Input, ChangeDetectorRef, SimpleChanges, HostListener } from '@angular/core';
 import { Subscription, tap, of, catchError, Observable, switchMap } from 'rxjs';
 import { ServicesApiServices } from '../../services/services-api.service';
-import { md5, insecureRandomUUID } from '../../shared/common.utils';
+import { nextRoundNumber } from '../../shared/common.utils';
 import { StateService } from '../../services/state.service';
 import { AudioService } from '../../services/audio.service';
 import { ETA, EtaService } from '../../services/eta.service';
@@ -10,10 +9,8 @@ import { Transaction } from '../../interfaces/electrs.interface';
 import { MiningStats } from '../../services/mining.service';
 import { IAuth, AuthServiceMempool } from '../../services/auth.service';
 import { EnterpriseService } from '../../services/enterprise.service';
-import { ApiService } from '../../services/api.service';
-import { isDevMode } from '@angular/core';
 
-export type PaymentMethod = 'balance' | 'bitcoin' | 'cashapp' | 'applePay' | 'googlePay';
+export type PaymentMethod = 'balance' | 'bitcoin' | 'cashapp';
 
 export type AccelerationEstimate = {
   hasAccess: boolean;
@@ -26,7 +23,7 @@ export type AccelerationEstimate = {
   mempoolBaseFee: number;
   vsizeFee: number;
   pools: number[];
-  availablePaymentMethods: Record<PaymentMethod, {min: number, max: number}>;
+  availablePaymentMethods: {[method: string]: {min: number, max: number}};
   unavailable?: boolean;
   options: { // recommended bid options
     fee: number; // recommended userBid in sats
@@ -49,7 +46,7 @@ export const MIN_BID_RATIO = 1;
 export const DEFAULT_BID_RATIO = 2;
 export const MAX_BID_RATIO = 4;
 
-type CheckoutStep = 'quote' | 'summary' | 'checkout' | 'cashapp' | 'applepay' | 'googlepay' | 'processing' | 'paid' | 'success';
+type CheckoutStep = 'quote' | 'summary' | 'checkout' | 'cashapp' | 'processing' | 'paid' | 'success';
 
 @Component({
   selector: 'app-accelerate-checkout',
@@ -63,8 +60,6 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   @Input() eta: ETA;
   @Input() scrollEvent: boolean;
   @Input() cashappEnabled: boolean = true;
-  @Input() applePayEnabled: boolean = false;
-  @Input() googlePayEnabled: boolean = true;
   @Input() advancedEnabled: boolean = false;
   @Input() forceMobile: boolean = false;
   @Input() showDetails: boolean = false;
@@ -83,22 +78,17 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   timePaid: number = 0; // time acceleration requested
   math = Math;
   isMobile: boolean = window.innerWidth <= 767.98;
-  isProdDomain = ['mempool.space',
-    'mempool-staging.va1.mempool.space',
-    'mempool-staging.fmt.mempool.space',
-    'mempool-staging.fra.mempool.space',
-    'mempool-staging.tk7.mempool.space',
-    'mempool-staging.sg1.mempool.space'
-   ].indexOf(document.location.hostname) > -1;
 
   private _step: CheckoutStep = 'summary';
   simpleMode: boolean = true;
+  paymentMethod: 'cashapp' | 'btcpay';
   timeoutTimer: any;
 
   authSubscription$: Subscription;
   auth: IAuth | null = null;
 
   // accelerator stuff
+  square: { appId: string, locationId: string};
   accelerationUUID: string;
   accelerationSubscription: Subscription;
   difficultySubscription: Subscription;
@@ -119,22 +109,20 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
 
   // square
   loadingCashapp = false;
-  loadingApplePay = false;
-  loadingGooglePay = false;
+  cashappError = false;
+  cashappSubmit: any;
   payments: any;
   cashAppPay: any;
-  applePay: any;
-  googlePay: any;
+  cashAppSubscription: Subscription;
   conversionsSubscription: Subscription;
-  conversions: Record<string, number>;
-
+  conversions: any;
+  
   // btcpay
   loadingBtcpayInvoice = false;
   invoice = undefined;
 
   constructor(
     public stateService: StateService,
-    private apiService: ApiService,
     private servicesApiService: ServicesApiServices,
     private etaService: EtaService,
     private audioService: AudioService,
@@ -142,16 +130,10 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
     private authService: AuthServiceMempool,
     private enterpriseService: EnterpriseService,
   ) {
-    this.accelerationUUID = insecureRandomUUID();
-
-    // Check if Apple Pay available
-    // https://developer.apple.com/documentation/apple_pay_on_the_web/apple_pay_js_api/checking_for_apple_pay_availability#overview
-    if (window['ApplePaySession']) {
-      this.applePayEnabled = true;
-    }
+    this.accelerationUUID = window.crypto.randomUUID();
   }
 
-  ngOnInit(): void {
+  ngOnInit() {
     this.authSubscription$ = this.authService.getAuth$().subscribe((auth) => {
       if (this.auth?.user?.userId !== auth?.user?.userId) {
         this.auth = auth;
@@ -176,6 +158,13 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
       this.moveToStep('summary');
     }
 
+    this.servicesApiService.setupSquare$().subscribe(ids => {
+      this.square = {
+        appId: ids.squareAppId,
+        locationId: ids.squareLocationId
+      };
+    });
+
     this.conversionsSubscription = this.stateService.conversions$.subscribe(
       async (conversions) => {
         this.conversions = conversions;
@@ -183,7 +172,7 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
     );
   }
 
-  ngOnDestroy(): void {
+  ngOnDestroy() {
     if (this.estimateSubscription) {
       this.estimateSubscription.unsubscribe();
     }
@@ -203,7 +192,7 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
     }
   }
 
-  moveToStep(step: CheckoutStep): void {
+  moveToStep(step: CheckoutStep) {
     this._step = step;
     if (this.timeoutTimer) {
       clearTimeout(this.timeoutTimer);
@@ -212,7 +201,6 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
       this.fetchEstimate();
     }
     if (this._step === 'checkout') {
-      this.insertSquare();
       this.enterpriseService.goal(8);
     }
     if (this._step === 'checkout' && this.canPayWithBitcoin) {
@@ -222,23 +210,15 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
       this.requestBTCPayInvoice();
     } else if (this._step === 'cashapp' && this.cashappEnabled) {
       this.loadingCashapp = true;
+      this.insertSquare();
       this.setupSquare();
-      this.scrollToElementWithTimeout('confirm-title', 'center', 100);
-    } else if (this._step === 'applepay' && this.applePayEnabled) {
-      this.loadingApplePay = true;
-      this.setupSquare();
-      this.scrollToElementWithTimeout('confirm-title', 'center', 100);
-    } else if (this._step === 'googlepay' && this.googlePayEnabled) {
-      this.loadingGooglePay = true;
-      this.setupSquare();
-      this.scrollToElementWithTimeout('confirm-title', 'center', 100);
     } else if (this._step === 'paid') {
       this.timePaid = Date.now();
       this.timeoutTimer = setTimeout(() => {
         if (this.step === 'paid') {
           this.accelerateError = 'internal_server_error';
         }
-      }, 120000);
+      }, 120000)
     }
     this.hasDetails.emit(this._step === 'quote');
   }
@@ -249,14 +229,14 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   }
 
   /**
-   * Scroll to element id with or without setTimeout
-   */
+  * Scroll to element id with or without setTimeout
+  */
   scrollToElementWithTimeout(id: string, position: ScrollLogicalPosition, timeout: number = 1000): void {
     setTimeout(() => {
       this.scrollToElement(id, position);
     }, timeout);
   }
-  scrollToElement(id: string, position: ScrollLogicalPosition): void {
+  scrollToElement(id: string, position: ScrollLogicalPosition) {
     const acceleratePreviewAnchor = document.getElementById(id);
     if (acceleratePreviewAnchor) {
       this.cd.markForCheck();
@@ -271,7 +251,7 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   /**
    * Accelerator
    */
-  fetchEstimate(): void {
+  fetchEstimate() {
     if (this.estimateSubscription) {
       this.estimateSubscription.unsubscribe();
     }
@@ -335,7 +315,7 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
         }
       }),
 
-      catchError(() => {
+      catchError((response) => {
         this.estimate = undefined;
         this.quoteError = `cannot_accelerate_tx`;
         this.estimateSubscription.unsubscribe();
@@ -390,11 +370,10 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
       this.accelerationUUID
     ).subscribe({
       next: () => {
-        this.apiService.logAccelerationRequest$(this.tx.txid).subscribe();
         this.audioService.playSound('ascend-chime-cartoon');
         this.showSuccess = true;
         this.estimateSubscription.unsubscribe();
-        this.moveToStep('paid');
+        this.moveToStep('paid')
       },
       error: (response) => {
         this.accelerateError = response.error;
@@ -406,248 +385,57 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
    * Square
    */
   insertSquare(): void {
-    if (!this.isProdDomain && !isDevMode()) {
-      return;
-    }
-    if (window['Square']) {
+    //@ts-ignore
+    if (window.Square) {
       return;
     }
     let statsUrl = 'https://sandbox.web.squarecdn.com/v1/square.js';
-    if (this.isProdDomain) {
-      statsUrl = '/square/v1/square.js';
+    if (document.location.hostname === 'mempool-staging.fmt.mempool.space' ||
+        document.location.hostname === 'mempool-staging.va1.mempool.space' ||
+        document.location.hostname === 'mempool-staging.fra.mempool.space' ||
+        document.location.hostname === 'mempool-staging.tk7.mempool.space' ||
+        document.location.hostname === 'mempool.space') {
+      statsUrl = 'https://web.squarecdn.com/v1/square.js';
     }
 
-    (function(): void {
+    (function() {
       const d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
+      // @ts-ignore
       g.type='text/javascript'; g.src=statsUrl; s.parentNode.insertBefore(g, s);
     })();
   }
-  setupSquare(): void {
-    if (!this.isProdDomain && !isDevMode()) {
-      return;
-    }
-    const init = (): void => {
+  setupSquare() {
+    const init = () => {
       this.initSquare();
     };
 
-    if (!window['Square']) {
-      console.debug('Square.js failed to load properly. Retrying.');
-      setTimeout(this.setupSquare.bind(this), 100);
+    //@ts-ignore
+    if (!window.Square) {
+      console.debug('Square.js failed to load properly. Retrying in 1 second.');
+      setTimeout(init, 1000);
     } else {
       init();
     }
   }
   async initSquare(): Promise<void> {
     try {
-      this.servicesApiService.setupSquare$().subscribe({
-        next: async (ids) => {
-          this.payments = window['Square'].payments(ids.squareAppId, ids.squareLocationId);
-          const urlParams = new URLSearchParams(window.location.search);
-          if (this._step === 'cashapp' || urlParams.get('cash_request_id')) {
-            await this.requestCashAppPayment();
-          } else if (this._step === 'applepay') {
-            await this.requestApplePayPayment();
-          } else if (this._step === 'googlepay') {
-            await this.requestGooglePayPayment();
-          }
-        },
-        error: () => {
-          console.debug('Error loading Square Payments');
-          this.accelerateError = 'cannot_setup_square';
-        }
-      });
+      //@ts-ignore
+      this.payments = window.Square.payments(this.square.appId, this.square.locationId)
+      await this.requestCashAppPayment();
     } catch (e) {
       console.debug('Error loading Square Payments', e);
-      this.accelerateError = 'cannot_setup_square';
+      this.cashappError = true;
+      return;
     }
   }
-
-  /**
-   * APPLE PAY
-   */
-  async requestApplePayPayment(): Promise<void> {
+  async requestCashAppPayment() {
+    if (this.cashAppSubscription) {
+      this.cashAppSubscription.unsubscribe();
+    }
     if (this.conversionsSubscription) {
       this.conversionsSubscription.unsubscribe();
     }
-
-    this.conversionsSubscription = this.stateService.conversions$.subscribe(
-      async (conversions) => {
-        this.conversions = conversions;
-        if (this.applePay) {
-          this.applePay.destroy();
-        }
-
-        const costUSD = this.cost / 100_000_000 * conversions.USD;
-        const paymentRequest = this.payments.paymentRequest({
-          countryCode: 'US',
-          currencyCode: 'USD',
-          total: {
-            amount: costUSD.toFixed(2),
-            label: 'Total',
-          },
-        });
-
-        try {
-          this.applePay = await this.payments.applePay(paymentRequest);
-          const applePayButton = document.getElementById('apple-pay-button');
-          if (!applePayButton) {
-            console.error(`Unable to find apple pay button id='apple-pay-button'`);
-            // Try again
-            setTimeout(this.requestApplePayPayment.bind(this), 500);
-            return;
-          }
-          this.loadingApplePay = false;
-          applePayButton.addEventListener('click', async event => {
-            event.preventDefault();
-            const tokenResult = await this.applePay.tokenize();
-            if (tokenResult?.status === 'OK') {
-              const card = tokenResult.details?.card;
-              if (!card || !card.brand || !card.expMonth || !card.expYear || !card.last4) {
-                console.error(`Cannot retreive payment card details`);
-                this.accelerateError = 'apple_pay_no_card_details';
-                return;
-              }
-              const cardTag = md5(`${card.brand}${card.expMonth}${card.expYear}${card.last4}`.toLowerCase());
-              this.servicesApiService.accelerateWithApplePay$(
-                this.tx.txid,
-                tokenResult.token,
-                cardTag,
-                `accelerator-${this.tx.txid.substring(0, 15)}-${Math.round(new Date().getTime() / 1000)}`,
-                this.accelerationUUID
-              ).subscribe({
-                next: () => {
-                  this.apiService.logAccelerationRequest$(this.tx.txid).subscribe();
-                  this.audioService.playSound('ascend-chime-cartoon');
-                  if (this.applePay) {
-                    this.applePay.destroy();
-                  }
-                  setTimeout(() => {
-                    this.moveToStep('paid');
-                  }, 1000);
-                },
-                error: (response) => {
-                  this.accelerateError = response.error;
-                  if (!(response.status === 403 && response.error === 'not_available')) {
-                    setTimeout(() => {
-                      // Reset everything by reloading the page :D, can be improved
-                      const urlParams = new URLSearchParams(window.location.search);
-                      window.location.assign(window.location.toString().replace(`?cash_request_id=${urlParams.get('cash_request_id')}`, ``));
-                    }, 3000);
-                  }
-                }
-              });
-            } else {
-              let errorMessage = `Tokenization failed with status: ${tokenResult.status}`;
-              if (tokenResult.errors) {
-                errorMessage += ` and errors: ${JSON.stringify(
-                  tokenResult.errors,
-                )}`;
-              }
-              throw new Error(errorMessage);
-            }
-          });
-        } catch (e) {
-          console.error(e);
-        }
-      }
-    );
-  }
-
-  /**
-   * GOOGLE PAY
-   */
-  async requestGooglePayPayment(): Promise<void> {
-    if (this.conversionsSubscription) {
-      this.conversionsSubscription.unsubscribe();
-    }
-
-    this.conversionsSubscription = this.stateService.conversions$.subscribe(
-      async (conversions) => {
-        this.conversions = conversions;
-        if (this.googlePay) {
-          this.googlePay.destroy();
-        }
-
-        const costUSD = this.cost / 100_000_000 * conversions.USD;
-        const paymentRequest = this.payments.paymentRequest({
-          countryCode: 'US',
-          currencyCode: 'USD',
-          total: {
-            amount: costUSD.toFixed(2),
-            label: 'Total'
-          }
-        });
-        this.googlePay = await this.payments.googlePay(paymentRequest , {
-          referenceId: `accelerator-${this.tx.txid.substring(0, 15)}-${Math.round(new Date().getTime() / 1000)}`,
-        });
-
-        await this.googlePay.attach(`#google-pay-button`, {
-          buttonType: 'pay',
-          buttonSizeMode: 'fill',
-        });
-        this.loadingGooglePay = false;
-
-        document.getElementById('google-pay-button').addEventListener('click', async event => {
-          event.preventDefault();
-          const tokenResult = await this.googlePay.tokenize();
-          if (tokenResult?.status === 'OK') {
-            const card = tokenResult.details?.card;
-            if (!card || !card.brand || !card.expMonth || !card.expYear || !card.last4) {
-              console.error(`Cannot retreive payment card details`);
-              this.accelerateError = 'apple_pay_no_card_details';
-              return;
-            }
-            const cardTag = md5(`${card.brand}${card.expMonth}${card.expYear}${card.last4}`.toLowerCase());
-            this.servicesApiService.accelerateWithGooglePay$(
-              this.tx.txid,
-              tokenResult.token,
-              cardTag,
-              `accelerator-${this.tx.txid.substring(0, 15)}-${Math.round(new Date().getTime() / 1000)}`,
-              this.accelerationUUID
-            ).subscribe({
-              next: () => {
-                this.apiService.logAccelerationRequest$(this.tx.txid).subscribe();
-                this.audioService.playSound('ascend-chime-cartoon');
-                if (this.googlePay) {
-                  this.googlePay.destroy();
-                }
-                setTimeout(() => {
-                  this.moveToStep('paid');
-                }, 1000);
-              },
-              error: (response) => {
-                this.accelerateError = response.error;
-                if (!(response.status === 403 && response.error === 'not_available')) {
-                  setTimeout(() => {
-                    // Reset everything by reloading the page :D, can be improved
-                    const urlParams = new URLSearchParams(window.location.search);
-                    window.location.assign(window.location.toString().replace(`?cash_request_id=${urlParams.get('cash_request_id')}`, ``));
-                  }, 3000);
-                }
-              }
-            });
-          } else {
-            let errorMessage = `Tokenization failed with status: ${tokenResult.status}`;
-            if (tokenResult.errors) {
-              errorMessage += ` and errors: ${JSON.stringify(
-                tokenResult.errors,
-              )}`;
-            }
-            throw new Error(errorMessage);
-          }
-        });
-      }
-    );
-  }
-
-  /**
-   * CASHAPP
-   */
-  async requestCashAppPayment(): Promise<void> {
-    if (this.conversionsSubscription) {
-      this.conversionsSubscription.unsubscribe();
-    }
-
+    
     this.conversionsSubscription = this.stateService.conversions$.subscribe(
       async (conversions) => {
         this.conversions = conversions;
@@ -661,37 +449,41 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
           countryCode: 'US',
           currencyCode: 'USD',
           total: {
-            amount: costUSD.toFixed(2),
+            amount: costUSD.toString(),
             label: 'Total',
             pending: true,
-            productUrl: `${redirectHostname}/tx/${this.tx.txid}`,
-          }
+            productUrl: `${redirectHostname}/tracker/${this.tx.txid}`,
+          },
+          button: { shape: 'semiround', size: 'small', theme: 'light'}
         });
         this.cashAppPay = await this.payments.cashAppPay(paymentRequest, {
-          redirectURL: `${redirectHostname}/tx/${this.tx.txid}`,
-          referenceId: `accelerator-${this.tx.txid.substring(0, 15)}-${Math.round(new Date().getTime() / 1000)}`
+          redirectURL: `${redirectHostname}/tracker/${this.tx.txid}`,
+          referenceId: `accelerator-${this.tx.txid.substring(0, 15)}-${Math.round(new Date().getTime() / 1000)}`,
+          button: { shape: 'semiround', size: 'small', theme: 'light'}
         });
 
-        await this.cashAppPay.attach(`#cash-app-pay`, { theme: 'dark' });
+        if (this.step === 'cashapp') {
+          await this.cashAppPay.attach(`#cash-app-pay`, { theme: 'light', size: 'small', shape: 'semiround' })
+        }
         this.loadingCashapp = false;
 
-        this.cashAppPay.addEventListener('ontokenization', event => {
+        const that = this;
+        this.cashAppPay.addEventListener('ontokenization', function (event) {
           const { tokenResult, error } = event.detail;
           if (error) {
             this.accelerateError = error;
           } else if (tokenResult.status === 'OK') {
-            this.servicesApiService.accelerateWithCashApp$(
-              this.tx.txid,
+            that.servicesApiService.accelerateWithCashApp$(
+              that.tx.txid,
               tokenResult.token,
               tokenResult.details.cashAppPay.cashtag,
               tokenResult.details.cashAppPay.referenceId,
-              this.accelerationUUID
+              that.accelerationUUID
             ).subscribe({
               next: () => {
-                this.apiService.logAccelerationRequest$(this.tx.txid).subscribe();
-                this.audioService.playSound('ascend-chime-cartoon');
-                if (this.cashAppPay) {
-                  this.cashAppPay.destroy();
+                that.audioService.playSound('ascend-chime-cartoon');
+                if (that.cashAppPay) {
+                  that.cashAppPay.destroy();
                 }
                 setTimeout(() => {
                   this.moveToStep('paid');
@@ -702,7 +494,7 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
                 }, 1000);
               },
               error: (response) => {
-                this.accelerateError = response.error;
+                that.accelerateError = response.error;
                 if (!(response.status === 403 && response.error === 'not_available')) {
                   setTimeout(() => {
                     // Reset everything by reloading the page :D, can be improved
@@ -721,7 +513,7 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   /**
    * BTCPay
    */
-  async requestBTCPayInvoice(): Promise<void> {
+  async requestBTCPayInvoice() {
     this.servicesApiService.generateBTCPayAcceleratorInvoice$(this.tx.txid, this.userBid).pipe(
       switchMap(response => {
         return this.servicesApiService.retreiveInvoice$(response.btcpayInvoiceId);
@@ -738,10 +530,9 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   }
 
   bitcoinPaymentCompleted(): void {
-    this.apiService.logAccelerationRequest$(this.tx.txid).subscribe();
     this.audioService.playSound('ascend-chime-cartoon');
     this.estimateSubscription.unsubscribe();
-    this.moveToStep('paid');
+    this.moveToStep('paid')
   }
 
   isLoggedIn(): boolean {
@@ -751,61 +542,47 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
   /**
    * UI events
    */
-  selectedOptionChanged(event): void {
+  selectedOptionChanged(event) {
     this.selectedOption = event.target.id;
   }
 
-  get step(): CheckoutStep {
+  get step() {
     return this._step;
   }
 
-  get paymentMethods(): PaymentMethod[] {
-    return Object.keys(this.estimate?.availablePaymentMethods || {}) as PaymentMethod[];
+  get paymentMethods() {
+    return Object.keys(this.estimate?.availablePaymentMethods || {});
   }
 
-  get couldPayWithBitcoin(): boolean {
+  get couldPayWithBitcoin() {
     return !!this.estimate?.availablePaymentMethods?.bitcoin;
   }
 
-  get couldPayWithCashapp(): boolean {
+  get couldPayWithCashapp() {
     if (!this.cashappEnabled) {
       return false;
     }
     return !!this.estimate?.availablePaymentMethods?.cashapp;
   }
 
-  get couldPayWithApplePay(): boolean {
-    if (!this.applePayEnabled) {
-      return false;
-    }
-    return !!this.estimate?.availablePaymentMethods?.applePay;
-  }
-
-  get couldPayWithGooglePay(): boolean {
-    if (!this.googlePayEnabled) {
-      return false;
-    }
-    return !!this.estimate?.availablePaymentMethods?.googlePay;
-  }
-
-  get couldPayWithBalance(): boolean {
+  get couldPayWithBalance() {
     if (!this.hasAccessToBalanceMode) {
       return false;
     }
     return !!this.estimate?.availablePaymentMethods?.balance;
   }
 
-  get couldPay(): boolean {
-    return this.couldPayWithBalance || this.couldPayWithBitcoin || this.couldPayWithCashapp || this.couldPayWithApplePay || this.couldPayWithGooglePay;
+  get couldPay() {
+    return this.couldPayWithBalance || this.couldPayWithBitcoin || this.couldPayWithCashapp;
   }
 
-  get canPayWithBitcoin(): boolean {
+  get canPayWithBitcoin() {
     const paymentMethod = this.estimate?.availablePaymentMethods?.bitcoin;
     return paymentMethod && this.cost >= paymentMethod.min && this.cost <= paymentMethod.max;
   }
 
-  get canPayWithCashapp(): boolean {
-    if (!this.cashappEnabled || !this.conversions || (!this.isProdDomain && !isDevMode())) {
+  get canPayWithCashapp() {
+    if (!this.cashappEnabled || !this.conversions) {
       return false;
     }
 
@@ -816,43 +593,11 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
         return true;
       }
     }
-
+    
     return false;
   }
 
-  get canPayWithApplePay(): boolean {
-    if (!this.applePayEnabled || !this.conversions || (!this.isProdDomain && !isDevMode())) {
-      return false;
-    }
-
-    const paymentMethod = this.estimate?.availablePaymentMethods?.applePay;
-    if (paymentMethod) {
-      const costUSD = (this.cost / 100_000_000 * this.conversions.USD);
-      if (costUSD >= paymentMethod.min && costUSD <= paymentMethod.max) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  get canPayWithGooglePay(): boolean {
-    if (!this.googlePayEnabled || !this.conversions || (!this.isProdDomain && !isDevMode())) {
-      return false;
-    }
-
-    const paymentMethod = this.estimate?.availablePaymentMethods?.googlePay;
-    if (paymentMethod) {
-      const costUSD = (this.cost / 100_000_000 * this.conversions.USD);
-      if (costUSD >= paymentMethod.min && costUSD <= paymentMethod.max) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  get canPayWithBalance(): boolean {
+  get canPayWithBalance() {
     if (!this.hasAccessToBalanceMode) {
       return false;
     }
@@ -860,11 +605,11 @@ export class AccelerateCheckout implements OnInit, OnDestroy {
     return paymentMethod && this.cost >= paymentMethod.min && this.cost <= paymentMethod.max && this.cost <= this.estimate?.userBalance;
   }
 
-  get canPay(): boolean {
-    return this.canPayWithBalance || this.canPayWithBitcoin || this.canPayWithCashapp || this.canPayWithApplePay || this.canPayWithGooglePay;
+  get canPay() {
+    return this.canPayWithBalance || this.canPayWithBitcoin || this.canPayWithCashapp;
   }
 
-  get hasAccessToBalanceMode(): boolean {
+  get hasAccessToBalanceMode() {
     return this.isLoggedIn() && this.estimate?.hasAccess;
   }
 

frontend/src/app/components/acceleration-timeline/acceleration-timeline-tooltip.component.html

@@ -1,62 +0,0 @@
-<div
-  #tooltip
-  *ngIf="accelerationInfo && tooltipPosition !== null"
-  class="acceleration-tooltip"
-  [style.left]="tooltipPosition.x + 'px'"
-  [style.top]="tooltipPosition.y + 'px'"
->
-  <table>
-    <tbody>
-      <tr>
-        <td class="label" i18n="transaction.status|Transaction Status">Status</td>
-        <td class="value">
-          @if (accelerationInfo.status === 'seen') {
-          <span class="badge badge-primary" i18n="transaction.first-seen|Transaction first seen">First seen</span>
-          } @else if (accelerationInfo.status === 'accelerated') {
-          <span class="badge badge-accelerated" i18n="transaction.audit.accelerated">Accelerated</span>
-          } @else if (accelerationInfo.status === 'mined') {
-          <span class="badge badge-success" i18n="transaction.rbf.mined">Mined</span>
-          }
-        </td>
-      </tr>
-      <tr *ngIf="accelerationInfo.fee">
-        <td class="label" i18n="transaction.fee|Transaction fee">Fee</td>
-        <td class="value">{{ accelerationInfo.fee | number }} <span class="symbol" i18n="shared.sat|sat">sat</span></td>
-      </tr>
-      <tr *ngIf="accelerationInfo.bidBoost >= 0 || accelerationInfo.feeDelta">
-        <td class="label" i18n="transaction.out-of-band-fees">Out-of-band fees</td>
-        @if (accelerationInfo.status === 'accelerated') {
-          <td class="value oobFees">{{ accelerationInfo.feeDelta | number }} <span class="symbol" i18n="shared.sat|sat">sat</span></td>
-        } @else {
-          <td class="value oobFees">{{ accelerationInfo.bidBoost | number }} <span class="symbol" i18n="shared.sat|sat">sat</span></td>
-        }
-      </tr>
-      <tr *ngIf="accelerationInfo.fee && accelerationInfo.weight">
-        @if (accelerationInfo.status === 'seen') {
-          <td class="label" i18n="transaction.fee-rate|Transaction fee rate">Fee rate</td>
-          <td class="value"><app-fee-rate [fee]="accelerationInfo.fee" [weight]="accelerationInfo.weight"></app-fee-rate></td>
-        } @else if (accelerationInfo.status === 'accelerated' || accelerationInfo.status === 'mined') {
-          <td class="label" i18n="transaction.accelerated-fee-rate|Accelerated transaction fee rate">Accelerated fee rate</td>
-          @if (accelerationInfo.status === 'accelerated') {
-            <td class="value oobFees"><app-fee-rate [fee]="accelerationInfo.fee + (accelerationInfo.feeDelta || 0)" [weight]="accelerationInfo.weight"></app-fee-rate></td>
-          } @else {
-            <td class="value oobFees"><app-fee-rate [fee]="accelerationInfo.fee + (accelerationInfo.bidBoost || 0)" [weight]="accelerationInfo.weight"></app-fee-rate></td>
-          }
-        }
-      </tr>
-      <tr *ngIf="['accelerated', 'mined'].includes(accelerationInfo.status) && hasPoolsData()">
-        <td class="label" i18n="transaction.accelerated-by-hashrate|Accelerated to hashrate">Accelerated by</td>
-        <td class="value" *ngIf="accelerationInfo.pools">
-          <ng-container *ngFor="let pool of accelerationInfo.pools">
-            <img *ngIf="accelerationInfo.poolsData[pool]" 
-              class="pool-logo" 
-              [style.opacity]="accelerationInfo?.minedByPoolUniqueId && pool !== accelerationInfo?.minedByPoolUniqueId ? '0.3' : '1'"
-              [src]="'/resources/mining-pools/' + accelerationInfo.poolsData[pool].slug + '.svg'" 
-              onError="this.src = '/resources/mining-pools/default.svg'" 
-              [alt]="'Logo of ' + pool.name + ' mining pool'">
-          </ng-container>
-        </td>
-      </tr>
-    </tbody>
-  </table>
-</div>

frontend/src/app/components/acceleration-timeline/acceleration-timeline-tooltip.component.scss

@@ -1,39 +0,0 @@
-.acceleration-tooltip {
-  position: fixed;
-  z-index: 3;
-  background: color-mix(in srgb, var(--active-bg) 95%, transparent);
-  border-radius: 4px;
-  box-shadow: 1px 1px 10px rgba(0,0,0,0.5);
-  color: var(--tooltip-grey);
-  display: flex;
-  flex-direction: column;
-  justify-content: space-between;
-  padding: 10px 15px;
-  text-align: left;
-  pointer-events: none;
-
-  .badge.badge-accelerated {
-    background-color: var(--tertiary);
-    color: white;
-  }
-
-  .value {
-    text-align: end;
-  }
-
-  .label {
-    padding-right: 30px;
-  }
-
-  .pool-logo {
-    width: 22px;
-    height: 22px;
-    position: relative;
-    top: -1px;
-    margin-right: 3px;
-  }
-
-  .oobFees {
-    color: #905cf4;
-  }
-}

frontend/src/app/components/acceleration-timeline/acceleration-timeline-tooltip.component.ts

@@ -1,38 +0,0 @@
-import { Component, ElementRef, ViewChild, Input, OnChanges } from '@angular/core';
-
-@Component({
-  selector: 'app-acceleration-timeline-tooltip',
-  templateUrl: './acceleration-timeline-tooltip.component.html',
-  styleUrls: ['./acceleration-timeline-tooltip.component.scss'],
-})
-export class AccelerationTimelineTooltipComponent implements OnChanges {
-  @Input() accelerationInfo: any;
-  @Input() cursorPosition: { x: number, y: number };
-
-  tooltipPosition: any = null;
-
-  @ViewChild('tooltip') tooltipElement: ElementRef<HTMLCanvasElement>;
-
-  constructor() {}
-
-  ngOnChanges(changes): void {
-    if (changes.cursorPosition && changes.cursorPosition.currentValue) {
-      let x = Math.max(10, changes.cursorPosition.currentValue.x - 50);
-      let y = changes.cursorPosition.currentValue.y + 20;
-      if (this.tooltipElement) {
-        const elementBounds = this.tooltipElement.nativeElement.getBoundingClientRect();
-        if ((x + elementBounds.width) > (window.innerWidth - 10)) {
-          x = Math.max(0, window.innerWidth - elementBounds.width - 10);
-        }
-        if (y + elementBounds.height > (window.innerHeight - 20)) {
-          y = y - elementBounds.height - 20;
-        }
-      }
-      this.tooltipPosition = { x, y };
-    }
-  }
-
-  hasPoolsData(): boolean {
-    return Object.keys(this.accelerationInfo.poolsData).length > 0;
-  }
-}

frontend/src/app/components/acceleration-timeline/acceleration-timeline.component.html

@@ -26,7 +26,7 @@
         <div class="node" [id]="'confirmed'">
           <div class="acc-to-confirmed left go-faster"></div>
           <div class="shape-border waiting">
-            <div class="shape"></div>
+            <div class="shape animate"></div>
           </div>
           <div class="status"><span class="badge badge-waiting" i18n="transaction.rbf.mined">Mined</span></div>
         </div>
@@ -58,7 +58,7 @@
       <div class="nodes">
         <div class="node" [id]="'first-seen'">
           <div class="seen-to-acc right"></div>
-          <div class="shape-border hovering" (pointerover)="onHover($event, 'seen');" (pointerout)="onBlur($event);">
+          <div class="shape-border">
             <div class="shape"></div>
           </div>
           <div class="status"><span class="badge badge-primary" i18n="transaction.first-seen|Transaction first seen">First seen</span></div>
@@ -80,7 +80,7 @@
           } @else {
           <div class="seen-to-acc right"></div>
           }
-          <div  class="shape-border hovering" (pointerover)="onHover($event, 'accelerated');" (pointerout)="onBlur($event);">
+          <div  class="shape-border">
             <div class="shape"></div>
             @if (!tx.status.confirmed) {
             <div class="connector down loading"></div>
@@ -89,14 +89,14 @@
           @if (tx.status.confirmed) {
             <div class="status"><span class="badge badge-accelerated" i18n="transaction.audit.accelerated">Accelerated</span></div>
           }
-          <div class="time" [class.no-margin]="!tx.status.confirmed" [class.offset-left]="!tx.status.confirmed">
+          <div class="time offset-left" [class.no-margin]="!tx.status.confirmed">
             @if (!tx.status.confirmed) {
             <span i18n="transaction.audit.accelerated">Accelerated</span>{{ "" }} 
             }
             @if (useAbsoluteTime) {
             <span>{{ acceleratedAt * 1000 | date }}</span>
             } @else {
-            <app-time kind="since" [time]="acceleratedAt" [lowercaseStart]="!tx.status.confirmed"></app-time>
+            <app-time kind="since" [time]="acceleratedAt" [lowercaseStart]="true"></app-time>
             }
           </div>
         </div>
@@ -113,10 +113,7 @@
           } @else {
           <div class="seen-to-acc left"></div>
           }
-          <div class="shape-border" 
-              [ngClass]="{'waiting': !tx.status.confirmed, 'hovering': tx.status.confirmed}"
-              (pointerover)="onHover($event, tx.status.confirmed ? 'mined' : null)" 
-              (pointerout)="onBlur($event);">
+          <div class="shape-border" [class.waiting]="!tx.status.confirmed">
             <div class="shape"></div>
           </div>
           @if (tx.status.confirmed) {
@@ -133,10 +130,4 @@
       </div>
     </div>
   </div>
-
-  <app-acceleration-timeline-tooltip
-  [accelerationInfo]="hoverInfo"
-  [cursorPosition]="tooltipPosition"
-></app-acceleration-timeline-tooltip>
-
 </div>

frontend/src/app/components/acceleration-timeline/acceleration-timeline.component.scss

@@ -152,16 +152,9 @@
         margin-bottom: -8px;
         transform: translateY(-50%);
         border-radius: 50%;
+        cursor: pointer;
         padding: 4px;
         background: transparent;
-        transition: background-color 300ms, padding 300ms;
-
-        &.hovering {
-          cursor: pointer;
-          &:hover {
-            padding: 0px;
-          }
-        }
     
         .shape {
           position: relative;

frontend/src/app/components/acceleration-timeline/acceleration-timeline.component.ts

@@ -1,8 +1,6 @@
-import { Component, Input, OnInit, OnChanges, HostListener } from '@angular/core';
+import { Component, Input, OnInit, OnChanges } from '@angular/core';
 import { ETA } from '../../services/eta.service';
 import { Transaction } from '../../interfaces/electrs.interface';
-import { Acceleration, SinglePoolStats } from '../../interfaces/node-api.interface';
-import { MiningService } from '../../services/mining.service';
 
 @Component({
   selector: 'app-acceleration-timeline',
@@ -12,7 +10,6 @@ import { MiningService } from '../../services/mining.service';
 export class AccelerationTimelineComponent implements OnInit, OnChanges {
   @Input() transactionTime: number;
   @Input() tx: Transaction;
-  @Input() accelerationInfo: Acceleration;
   @Input() eta: ETA;
   // A mined transaction has standard ETA and accelerated ETA undefined
   // A transaction in mempool has either standardETA defined (if accelerated) or acceleratedETA defined (if not accelerated yet)
@@ -25,25 +22,13 @@ export class AccelerationTimelineComponent implements OnInit, OnChanges {
   useAbsoluteTime: boolean = false;
   interval: number;
 
-  tooltipPosition = null;
-  hoverInfo: any = null;
-  poolsData: { [id: number]: SinglePoolStats } = {};
-
-  constructor(
-    private miningService: MiningService,
-  ) {}
+  constructor() {}
 
   ngOnInit(): void {
     this.acceleratedAt = this.tx.acceleratedAt ?? new Date().getTime() / 1000;
     this.now = Math.floor(new Date().getTime() / 1000);
     this.useAbsoluteTime = this.tx.status.block_time < this.now - 7 * 24 * 3600;
 
-    this.miningService.getPools().subscribe(pools => {
-      for (const pool of pools) {
-        this.poolsData[pool.unique_id] = pool;
-      }
-    });
-
     this.interval = window.setInterval(() => {
       this.now = Math.floor(new Date().getTime() / 1000);
       this.useAbsoluteTime = this.tx.status.block_time < this.now - 7 * 24 * 3600;
@@ -67,42 +52,4 @@ export class AccelerationTimelineComponent implements OnInit, OnChanges {
   ngOnDestroy(): void {
     clearInterval(this.interval);
   }
-  
-  onHover(event, status: string): void {
-    if (status === 'seen') {
-      this.hoverInfo = {
-        status,
-        fee: this.tx.fee,
-        weight: this.tx.weight
-      };
-    } else if (status === 'accelerated') {
-      this.hoverInfo = {
-        status,
-        fee: this.accelerationInfo?.effectiveFee || this.tx.fee,
-        weight: this.tx.weight,
-        feeDelta: this.accelerationInfo?.feeDelta || this.tx.feeDelta,
-        pools: this.tx.acceleratedBy || this.accelerationInfo?.pools,
-        poolsData: this.poolsData
-      };
-    } else if (status === 'mined') {
-      this.hoverInfo = {
-        status,
-        fee: this.accelerationInfo?.effectiveFee,
-        weight: this.tx.weight,
-        bidBoost: this.accelerationInfo?.bidBoost,
-        minedByPoolUniqueId: this.accelerationInfo?.minedByPoolUniqueId,
-        pools: this.tx.acceleratedBy || this.accelerationInfo?.pools,
-        poolsData: this.poolsData
-      };
-    }
-  }
-
-  onBlur(event): void {
-    this.hoverInfo = null;
-  }
-
-  @HostListener('pointermove', ['$event'])
-  onPointerMove(event) {
-    this.tooltipPosition = { x: event.clientX, y: event.clientY };
-  }
 }

frontend/src/app/components/acceleration/acceleration-fees-graph/acceleration-fees-graph.component.ts

@@ -23,7 +23,7 @@ import { RelativeUrlPipe } from '../../../shared/pipes/relative-url/relative-url
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/acceleration/accelerations-list/accelerations-list.component.html

@@ -4,8 +4,8 @@
 
   <div class="clearfix"></div>
 
-  <div class="acceleration-list">
-    <table *ngIf="nonEmptyAccelerations; else noData" class="table table-borderless table-fixed">
+  <div class="acceleration-list" *ngIf="accelerationList$ | async as accelerations">
+    <table *ngIf="!accelerations || accelerations.length; else noData" class="table table-borderless table-fixed">
       <thead>
         <th class="txid text-left" i18n="dashboard.latest-transactions.txid">TXID</th>
         <ng-container *ngIf="pending">
@@ -16,12 +16,11 @@
         <ng-container *ngIf="!pending">
           <th class="fee text-right" i18n="transaction.bid-boost|Bid Boost">Bid Boost</th>
           <th class="block text-right" i18n="shared.block-title">Block</th>
-          <th class="pool text-right" i18n="mining.pool-name" *ngIf="!this.widget">Pool</th>
           <th class="status text-right" i18n="transaction.status|Transaction Status">Status</th>
           <th class="date text-right" i18n="accelerator.requested" *ngIf="!this.widget">Requested</th>
         </ng-container>
       </thead>
-      <tbody *ngIf="accelerationList$ | async as accelerations; else skeleton" [style]="isLoading ? 'opacity: 0.75' : ''">
+      <tbody *ngIf="accelerations; else skeleton" [style]="isLoading ? 'opacity: 0.75' : ''">
         <tr *ngFor="let acceleration of accelerations; let i= index;">
           <td class="txid text-left">
             <a [routerLink]="['/tx' | relativeUrl, acceleration.txid]">
@@ -50,21 +49,10 @@
               <a *ngIf="acceleration.blockHeight" [routerLink]="['/block' | relativeUrl, acceleration.blockHeight]">{{ acceleration.blockHeight }}</a>
               <span *ngIf="!acceleration.blockHeight">~</span>
             </td>
-            <td class="pool text-right" *ngIf="!this.widget">
-              @if (acceleration.minedByPoolUniqueId && pools[acceleration.minedByPoolUniqueId]) {
-                <a placement="bottom" [routerLink]="['/mining/pool' | relativeUrl, pools[acceleration.minedByPoolUniqueId].slug]" class="badge" style="color: #FFF;padding:0;">
-                  <img class="pool-logo" [src]="'/resources/mining-pools/' + pools[acceleration.minedByPoolUniqueId].slug + '.svg'" onError="this.src = '/resources/mining-pools/default.svg'" [alt]="'Logo of ' + pools[acceleration.minedByPoolUniqueId].name + ' mining pool'">
-                  {{ pools[acceleration.minedByPoolUniqueId].name }}
-                </a>
-              } @else {
-                ~
-              }
-            </td>
             <td class="status text-right">
               <span *ngIf="acceleration.status === 'accelerating'" class="badge badge-warning" i18n="accelerator.pending">Pending</span>
-              <span *ngIf="acceleration.status.includes('completed') && acceleration.minedByPoolUniqueId && pools[acceleration.minedByPoolUniqueId]" class="badge badge-success"><ng-container i18n="accelerator.completed">Completed</ng-container><span *ngIf="acceleration.status === 'completed_provisional'">&nbsp;⌛</span></span>
-              <span *ngIf="acceleration.status.includes('completed') && (!acceleration.minedByPoolUniqueId || !pools[acceleration.minedByPoolUniqueId])" class="badge badge-success"><ng-container i18n="transaction.rbf.mined">Mined</ng-container><span *ngIf="acceleration.status === 'completed_provisional'">&nbsp;⌛</span></span>
-              <span *ngIf="acceleration.status.includes('failed')" class="badge badge-danger"><ng-container i18n="accelerator.canceled">Failed</ng-container><span *ngIf="acceleration.status === 'failed_provisional'">&nbsp;⌛</span></span>
+              <span *ngIf="acceleration.status.includes('completed')" class="badge badge-success" i18n="">Completed <span *ngIf="acceleration.status === 'completed_provisional'">🔄</span></span>
+              <span *ngIf="acceleration.status.includes('failed')" class="badge badge-danger" i18n="accelerator.canceled">Failed <span *ngIf="acceleration.status === 'failed_provisional'">🔄</span></span>
             </td>
             <td class="date text-right" *ngIf="!this.widget">
               <app-time kind="since" [time]="acceleration.added" [fastRender]="true" [showTooltip]="true"></app-time>
@@ -73,47 +61,22 @@
         </tr>
       </tbody>
       <ng-template #skeleton>
-        @if (!pending) {
-          <tbody>
-            <tr *ngFor="let item of skeletonLines">
-              <td class="txid text-left">
-                <span class="skeleton-loader" style="max-width: 200px"></span>
-              </td>
-              <td class="fee text-right">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="block text-right">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="pool text-right" *ngIf="!this.widget">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="status text-right">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="date text-right" *ngIf="!this.widget">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-            </tr>
-          </tbody>
-        } @else {
-          <tbody>
-            <tr *ngFor="let item of skeletonLines">
-              <td class="txid text-left">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="fee-rate text-right">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="bid text-right">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-              <td class="time text-right">
-                <span class="skeleton-loader" style="max-width: 100px"></span>
-              </td>
-            </tr>
-          </tbody>
-        }
+        <tbody>
+          <tr *ngFor="let item of skeletonLines">
+            <td class="txid text-left">
+              <span class="skeleton-loader" style="max-width: 75px"></span>
+            </td>
+            <td class="fee text-right">
+              <span class="skeleton-loader" style="max-width: 75px"></span>
+            </td>
+            <td class="fee-delta text-right">
+              <span class="skeleton-loader" style="max-width: 75px"></span>
+            </td>
+            <td class="status text-right">
+              <span class="skeleton-loader" style="max-width: 75px"></span>
+            </td>
+          </tr>
+        </tbody>
       </ng-template>
     </table>
 

frontend/src/app/components/acceleration/accelerations-list/accelerations-list.component.scss

@@ -12,7 +12,7 @@
   padding-bottom: 0px;
 }
 .container-xl.legacy {
-  max-width: 1200px;
+  max-width: 1140px;
 }
 .container-xl.widget-container {
   min-height: 335px;
@@ -72,25 +72,9 @@ tr, td, th {
 
 .block {
   width: 15%;
-  @media (max-width: 900px) {
-    display: none;
-  }
-}
-
-.pool {
-  width: 15%;
-  
   @media (max-width: 700px) {
     display: none;
   }
-
-  .pool-logo {
-    width: 18px;
-    height: 18px;
-    position: relative;
-    top: -1px;
-    margin-right: 2px;
-  }
 }
 
 .status {

frontend/src/app/components/acceleration/accelerations-list/accelerations-list.component.ts

@@ -1,12 +1,11 @@
 import { Component, OnInit, ChangeDetectionStrategy, Input, ChangeDetectorRef, OnDestroy, Inject, LOCALE_ID } from '@angular/core';
 import { BehaviorSubject, Observable, Subscription, catchError, filter, of, switchMap, tap, throttleTime } from 'rxjs';
-import { Acceleration, BlockExtended, SinglePoolStats } from '../../../interfaces/node-api.interface';
+import { Acceleration, BlockExtended } from '../../../interfaces/node-api.interface';
 import { StateService } from '../../../services/state.service';
 import { WebsocketService } from '../../../services/websocket.service';
 import { ServicesApiServices } from '../../../services/services-api.service';
 import { SeoService } from '../../../services/seo.service';
 import { ActivatedRoute, Router } from '@angular/router';
-import { MiningService } from '../../../services/mining.service';
 
 @Component({
   selector: 'app-accelerations-list',
@@ -31,14 +30,11 @@ export class AccelerationsListComponent implements OnInit, OnDestroy {
   keyNavigationSubscription: Subscription;
   dir: 'rtl' | 'ltr' = 'ltr';
   paramSubscription: Subscription;
-  pools: { [id: number]: SinglePoolStats } = {};
-  nonEmptyAccelerations: boolean = true;
 
   constructor(
     private servicesApiService: ServicesApiServices,
     private websocketService: WebsocketService,
     public stateService: StateService,
-    private miningService: MiningService,
     private cd: ChangeDetectorRef,
     private seoService: SeoService,
     private route: ActivatedRoute,
@@ -51,12 +47,6 @@ export class AccelerationsListComponent implements OnInit, OnDestroy {
   }
 
   ngOnInit(): void {
-    this.miningService.getPools().subscribe(pools => {
-      for (const pool of pools) {
-        this.pools[pool.unique_id] = pool;
-      }
-    });
-
     if (!this.widget) {
       this.websocketService.want(['blocks']);
       this.seoService.setTitle($localize`:@@02573b6980a2d611b4361a2595a4447e390058cd:Accelerations`);
@@ -116,7 +106,6 @@ export class AccelerationsListComponent implements OnInit, OnDestroy {
             for (const acc of accelerations) {
               acc.boost = acc.boostCost != null ? acc.boostCost : acc.bidBoost;
             }
-            this.nonEmptyAccelerations = accelerations.length > 0;
             if (this.widget) {
               return of(accelerations.slice(0, 6));
             } else {

frontend/src/app/components/acceleration/active-acceleration-box/active-acceleration-box.component.html

@@ -1,7 +1,7 @@
 @if (chartOnly) {
   <ng-container *ngTemplateOutlet="pieChart"></ng-container>
 } @else {
-<table style="width: 100%;">
+<table>
   <tbody>
     <tr>
       <td class="td-width field-label" [class]="chartPositionLeft ? 'chart-left' : ''" i18n="transaction.accelerated-to-feerate|Accelerated to feerate">Accelerated to</td>
@@ -11,9 +11,9 @@
       <td class="field-value" [class]="chartPositionLeft ? 'chart-left' : ''">
         <div class="effective-fee-container">
           @if (accelerationInfo?.acceleratedFeeRate && (!tx.effectiveFeePerVsize || accelerationInfo.acceleratedFeeRate >= tx.effectiveFeePerVsize)) {
-            <app-fee-rate class="oobFees" [fee]="accelerationInfo.acceleratedFeeRate"></app-fee-rate>
+            <app-fee-rate [fee]="accelerationInfo.acceleratedFeeRate"></app-fee-rate>
           } @else {
-            <app-fee-rate class="oobFees" [fee]="tx.effectiveFeePerVsize"></app-fee-rate>
+            <app-fee-rate [fee]="tx.effectiveFeePerVsize"></app-fee-rate>
           }
         </div>
       </td>

frontend/src/app/components/acceleration/active-acceleration-box/active-acceleration-box.component.scss

@@ -61,8 +61,4 @@
   & > div, & > div > svg {
     overflow: visible !important;
   }
-}
-
-.oobFees {
-  color: #905cf4;
 }

frontend/src/app/components/acceleration/active-acceleration-box/active-acceleration-box.component.ts

@@ -67,17 +67,12 @@ export class ActiveAccelerationBox implements OnChanges {
 
     const acceleratingPools = (poolList || []).filter(id => pools[id]).sort((a,b) => pools[a].lastEstimatedHashrate - pools[b].lastEstimatedHashrate);
     const totalAcceleratedHashrate = acceleratingPools.reduce((total, pool) => total + pools[pool].lastEstimatedHashrate, 0);
-    // Find the first pool with at least 1% of the total network hashrate
-    const firstSignificantPool = acceleratingPools.findIndex(pool => pools[pool].lastEstimatedHashrate > this.miningStats.lastEstimatedHashrate / 100);
-    const numSignificantPools = acceleratingPools.length - firstSignificantPool;
     acceleratingPools.forEach((poolId, index) => {
       const pool = pools[poolId];
       const poolShare = ((pool.lastEstimatedHashrate / this.miningStats.lastEstimatedHashrate) * 100).toFixed(1);
       data.push(getDataItem(
         pool.lastEstimatedHashrate,
-        index >= firstSignificantPool
-          ? toRGB(lighten({ r: 147, g: 57, b: 244 }, 1 - (index - firstSignificantPool) / (numSignificantPools - 1)))
-          : 'white',
+        toRGB(lighten({ r: 147, g: 57, b: 244 }, index * .08)),
         `<b style="color: white">${pool.name} (${poolShare}%)</b>`,
         true,
       ) as PieSeriesOption);

frontend/src/app/components/acceleration/sparkles/acceleration-sparkles.component.html

@@ -1,5 +0,0 @@
-<div class="sparkles" #sparkleAnchor>
-  <div *ngFor="let sparkle of sparkles" class="sparkle" [style]="sparkle.style">
-    <span class="inner-sparkle" [style]="sparkle.rotation">+</span>
-  </div>
-</div>

frontend/src/app/components/acceleration/sparkles/acceleration-sparkles.component.scss

@@ -1,45 +0,0 @@
-.sparkles {
-  position: absolute;
-  top: var(--block-size);
-  height: 50px;
-  right: 0;
-}
-
-.sparkle {
-  position: absolute;
-  color: rgba(152, 88, 255, 0.75);
-  opacity: 0;
-  transform: scale(0.8) rotate(0deg);
-  animation: pop ease 2000ms forwards, sparkle ease 500ms infinite;
-}
-
-.inner-sparkle {
-  display: block;
-}
-
-@keyframes pop {
-  0% {
-    transform: scale(0.8) rotate(0deg);
-    opacity: 0;
-  }
-  20% {
-    transform: scale(1) rotate(72deg);
-    opacity: 1;
-  }
-  100% {
-    transform: scale(0) rotate(360deg);
-    opacity: 0;
-  }
-}
-
-@keyframes sparkle {
-  0% {
-    color: rgba(152, 88, 255, 0.75);
-  }
-  50% {
-    color: rgba(198, 162, 255, 0.75);
-  }
-  100% {
-    color: rgba(152, 88, 255, 0.75);
-  }
-}

frontend/src/app/components/acceleration/sparkles/acceleration-sparkles.component.ts

@@ -1,73 +0,0 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Input, OnChanges, SimpleChanges, ViewChild } from '@angular/core';
-
-@Component({
-  selector: 'app-acceleration-sparkles',
-  templateUrl: './acceleration-sparkles.component.html',
-  styleUrls: ['./acceleration-sparkles.component.scss'],
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class AccelerationSparklesComponent implements OnChanges {
-  @Input() arrow: ElementRef<HTMLDivElement>;
-  @Input() run: boolean = false;
-
-  @ViewChild('sparkleAnchor')
-  sparkleAnchor: ElementRef<HTMLDivElement>;
-
-  constructor(
-    private cd: ChangeDetectorRef,
-  ) {}
-
-  endTimeout: any;
-  lastSparkle: number = 0;
-  sparkleWidth: number = 0;
-  sparkles: any[] = [];
-
-  ngOnChanges(changes: SimpleChanges): void {
-    if (changes.run) {
-      if (this.endTimeout) {
-        clearTimeout(this.endTimeout);
-        this.endTimeout = null;
-      }
-      if (this.run) {
-        this.doSparkle();
-      } else {
-        this.endTimeout = setTimeout(() => {
-          this.sparkles = [];
-        }, 2000);
-      }
-    }
-  }
-
-  doSparkle(): void {
-    if (this.run) {
-      const now = performance.now();
-      if (now - this.lastSparkle > 20) {
-        this.lastSparkle = now;
-        if (this.arrow?.nativeElement && this.sparkleAnchor?.nativeElement) {
-          const anchor = this.sparkleAnchor.nativeElement.getBoundingClientRect().right;
-          const right = this.arrow.nativeElement.getBoundingClientRect().right;
-          const dx = (anchor - right) + 30;
-          const numSparkles = Math.ceil(Math.random() * 3);
-          for (let i = 0; i < numSparkles; i++) {
-            this.sparkles.push({
-              style: {
-                right: (dx + (Math.random() * 10)) + 'px',
-                top: (15 + (Math.random() * 30)) + 'px',
-              },
-              rotation: {
-                transform: `rotate(${Math.random() * 360}deg)`,
-              }
-            });
-          }
-          while (this.sparkles.length > 200) {
-            this.sparkles.shift();
-          }
-          this.cd.markForCheck();
-        }
-      }
-      requestAnimationFrame(() => {
-        this.doSparkle();
-      });
-    }
-  }
-}

frontend/src/app/components/address-graph/address-graph.component.ts

@@ -30,7 +30,7 @@ const periodSeconds = {
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/address/address.component.html

@@ -201,7 +201,7 @@
         <span i18n="address.error.loading-address-data">Error loading address data.</span>
         <br>
         <ng-container i18n="Electrum server limit exceeded error">
-          <i>There are too many transactions on this address, more than your backend can handle. See more on <a href="/docs/faq#address-lookup-issues">setting up a stronger backend</a>.</i>
+          <i>There many transactions on this address, more than your backend can handle. See more on <a href="/docs/faq#address-lookup-issues">setting up a stronger backend</a>.</i>
           <br><br>
           Consider viewing this address on the official Mempool website instead:
         </ng-container>
@@ -249,7 +249,7 @@
 </ng-template>
 
 <ng-template #pendingBalanceRow>
-  <td i18n="accelerator.pending-state" class="font-italic">Pending</td>
+  <td i18n="address.unconfirmed-balance" class="font-italic">Unconfirmed balance</td>
   <td *ngIf="mempoolStats.funded_txo_sum !== undefined; else confidentialTd" class="font-italic wrap-cell"><app-amount [satoshis]="mempoolStats.balance" [noFiat]="true" [addPlus]="true"></app-amount> <span class="fiat"><app-fiat [value]="mempoolStats.balance"></app-fiat></span></td>
 </ng-template>
 
@@ -259,7 +259,7 @@
 </ng-template>
 
 <ng-template #pendingUtxoRow>
-  <td i18n="address.pending-utxos" class="font-italic">Pending UTXOs</td>
+  <td i18n="address.unconfirmed-utxos" class="font-italic">Unconfirmed UTXOs</td>
   <td class="font-italic wrap-cell">{{ mempoolStats.utxos > 0 ? '+' : ''}}{{ mempoolStats.utxos }}</td>
 </ng-template>
 

frontend/src/app/components/bitcoin-invoice/bitcoin-invoice.component.ts

@@ -3,7 +3,7 @@ import { FormBuilder, FormGroup } from '@angular/forms';
 import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
 import { ActivatedRoute } from '@angular/router';
 import { Subscription, of, timer } from 'rxjs';
-import { filter, repeat, retry, switchMap, take, tap } from 'rxjs/operators';
+import { retry, switchMap, tap } from 'rxjs/operators';
 import { ServicesApiServices } from '../../services/services-api.service';
 
 @Component({
@@ -73,11 +73,11 @@ export class BitcoinInvoiceComponent implements OnInit, OnChanges, OnDestroy {
       this.paymentStatus = 4;
     }
     this.paymentStatusSubscription = this.apiService.getPaymentStatus$(this.invoice.btcpayInvoiceId).pipe(
-      retry({ delay: () => timer(2000)}),
-      repeat({delay: 2000}),
-      filter((response) => response.status !== 204 && response.status !== 404),
-      take(1),
-    ).subscribe(() => {
+      retry({ delay: () => timer(2000)})
+    ).subscribe((response) => {
+      if (response.status === 204 || response.status === 404) {
+        return;
+      }
       this.paymentStatus = 3;
       this.completed.emit();
     });

frontend/src/app/components/block-fee-rates-graph/block-fee-rates-graph.component.ts

@@ -23,7 +23,7 @@ import { ActivatedRoute, Router } from '@angular/router';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/block-fees-graph/block-fees-graph.component.ts

@@ -23,7 +23,7 @@ import { StateService } from '../../services/state.service';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/block-fees-subsidy-graph/block-fees-subsidy-graph.component.ts

@@ -24,7 +24,7 @@ import { RelativeUrlPipe } from '../../shared/pipes/relative-url/relative-url.pi
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/block-filters/block-filters.component.html

@@ -1,5 +1,6 @@
 <div class="block-filters" [class.filters-active]="activeFilters.length > 0" [class.any-mode]="filterMode === 'or'" [class.menu-open]="menuOpen" [class.small]="cssWidth < 500" [class.vsmall]="cssWidth < 400" [class.tiny]="cssWidth < 200">
-  <a *ngIf="menuOpen" [routerLink]="['/docs/faq' | relativeUrl]" fragment="how-do-mempool-goggles-work" class="info-badges float-right" i18n-ngbTooltip="Mempool Goggles&trade; tooltip" ngbTooltip="select filter categories to highlight matching transactions">
+  <a *ngIf="menuOpen" [routerLink]="['/docs/faq' | relativeUrl]" fragment="how-do-mempool-goggles-work" class="info-badges" i18n-ngbTooltip="Mempool Goggles&trade; tooltip" ngbTooltip="select filter categories to highlight matching transactions">
+    <span class="badge badge-pill badge-warning beta" i18n="beta">beta</span>
     <fa-icon [icon]="['fas', 'info-circle']" [fixedWidth]="true" size="lg"></fa-icon>
   </a>
   <div class="filter-bar">

frontend/src/app/components/block-filters/block-filters.component.scss

@@ -24,6 +24,7 @@
     display: flex;
     flex-direction: row;
     align-items: center;
+    float: right;
 
     &:hover, &:active {
       text-decoration: none;

frontend/src/app/components/block-health-graph/block-health-graph.component.ts

@@ -21,7 +21,7 @@ import { StateService } from '../../services/state.service';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/block-overview-graph/block-overview-graph.component.html

@@ -2,12 +2,10 @@
 <div class="graph-alignment" [class.grid-align]="!autofit" [style.gridTemplateColumns]="'repeat(auto-fit, ' + resolution + 'px)'">
   <div class="block-overview-graph">
     <canvas *browserOnly class="block-overview-canvas" [class.clickable]="!!hoverTx" #blockCanvas></canvas>
-    @if (!disableSpinner) {
-      <div class="loader-wrapper" [class.hidden]="!isLoading && !unavailable">
-        <div *ngIf="!unavailable" class="spinner-border ml-3 loading" role="status"></div>
-        <div *ngIf="!isLoading && unavailable" class="ml-3" i18n="block.not-available">not available</div>
-      </div>
-    }
+    <div class="loader-wrapper" [class.hidden]="(!isLoading || disableSpinner) && !unavailable">
+      <div *ngIf="!unavailable" class="spinner-border ml-3 loading" role="status"></div>
+      <div *ngIf="!isLoading && unavailable" class="ml-3" i18n="block.not-available">not available</div>
+    </div>
     <app-block-overview-tooltip
       [tx]="selectedTx || hoverTx"
       [cursorPosition]="tooltipPosition"

frontend/src/app/components/block-overview-graph/block-overview-graph.component.ts

@@ -18,7 +18,6 @@ const unmatchedAuditColors = {
   censored: setOpacity(defaultAuditColors.censored, unmatchedOpacity),
   missing: setOpacity(defaultAuditColors.missing, unmatchedOpacity),
   added: setOpacity(defaultAuditColors.added, unmatchedOpacity),
-  added_prioritized: setOpacity(defaultAuditColors.added_prioritized, unmatchedOpacity),
   prioritized: setOpacity(defaultAuditColors.prioritized, unmatchedOpacity),
   accelerated: setOpacity(defaultAuditColors.accelerated, unmatchedOpacity),
 };
@@ -26,7 +25,6 @@ const unmatchedContrastAuditColors = {
   censored: setOpacity(contrastAuditColors.censored, unmatchedOpacity),
   missing: setOpacity(contrastAuditColors.missing, unmatchedOpacity),
   added: setOpacity(contrastAuditColors.added, unmatchedOpacity),
-  added_prioritized: setOpacity(contrastAuditColors.added_prioritized, unmatchedOpacity),
   prioritized: setOpacity(contrastAuditColors.prioritized, unmatchedOpacity),
   accelerated: setOpacity(contrastAuditColors.accelerated, unmatchedOpacity),
 };

frontend/src/app/components/block-overview-graph/tx-view.ts

@@ -33,7 +33,7 @@ export default class TxView implements TransactionStripped {
   flags: number;
   bigintFlags?: bigint | null = 0b00000100_00000000_00000000_00000000n;
   time?: number;
-  status?: 'found' | 'missing' | 'sigop' | 'fresh' | 'freshcpfp' | 'added' | 'added_prioritized' | 'prioritized' | 'censored' | 'selected' | 'rbf' | 'accelerated';
+  status?: 'found' | 'missing' | 'sigop' | 'fresh' | 'freshcpfp' | 'added' | 'prioritized' | 'censored' | 'selected' | 'rbf' | 'accelerated';
   context?: 'projected' | 'actual';
   scene?: BlockScene;
 

frontend/src/app/components/block-overview-graph/utils.ts

@@ -71,7 +71,6 @@ export const defaultAuditColors = {
   censored: hexToColor('f344df'),
   missing: darken(desaturate(hexToColor('f344df'), 0.3), 0.7),
   added: hexToColor('0099ff'),
-  added_prioritized: darken(desaturate(hexToColor('0099ff'), 0.15), 0.85),
   prioritized: darken(desaturate(hexToColor('0099ff'), 0.3), 0.7),
   accelerated: hexToColor('8f5ff6'),
 };
@@ -102,7 +101,6 @@ export const contrastAuditColors = {
   censored: hexToColor('ffa8ff'),
   missing: darken(desaturate(hexToColor('ffa8ff'), 0.3), 0.7),
   added: hexToColor('00bb98'),
-  added_prioritized: darken(desaturate(hexToColor('00bb98'), 0.15), 0.85),
   prioritized: darken(desaturate(hexToColor('00bb98'), 0.3), 0.7),
   accelerated: hexToColor('8f5ff6'),
 };
@@ -138,8 +136,6 @@ export function defaultColorFunction(
       return auditColors.missing;
     case 'added':
       return auditColors.added;
-    case 'added_prioritized':
-      return auditColors.added_prioritized;
     case 'prioritized':
       return auditColors.prioritized;
     case 'selected':

frontend/src/app/components/block-overview-tooltip/block-overview-tooltip.component.html

@@ -51,7 +51,7 @@
       <tr *ngIf="hasEffectiveRate && effectiveRate != null">
         <td *ngIf="!this.acceleration" class="label" i18n="transaction.effective-fee-rate|Effective transaction fee rate">Effective fee rate</td>
         <td *ngIf="this.acceleration" class="label" i18n="transaction.accelerated-fee-rate|Accelerated transaction fee rate">Accelerated fee rate</td>
-        <td class="value" [class.oobFees]="this.acceleration">
+        <td class="value">
           <app-fee-rate [fee]="effectiveRate"></app-fee-rate>
         </td>
       </tr>
@@ -75,10 +75,6 @@
             <span *ngSwitchCase="'freshcpfp'" class="badge badge-warning" i18n="transaction.audit.recently-cpfped">Recently CPFP'd</span>
             <span *ngSwitchCase="'added'" class="badge badge-warning" i18n="tx-features.tag.added|Added">Added</span>
             <span *ngSwitchCase="'prioritized'" class="badge badge-warning" i18n="tx-features.tag.prioritized|Prioritized">Prioritized</span>
-            <ng-container *ngSwitchCase="'added_prioritized'">
-              <span class="badge badge-warning" i18n="tx-features.tag.added|Added">Added</span>
-              <span class="badge badge-warning ml-1" i18n="tx-features.tag.prioritized|Prioritized">Prioritized</span>
-            </ng-container>
             <span *ngSwitchCase="'selected'" class="badge badge-warning" i18n="transaction.audit.marginal">Marginal fee rate</span>
             <span *ngSwitchCase="'rbf'" class="badge badge-warning" i18n="tx-features.tag.conflict|Conflict">Conflict</span>
             <span *ngSwitchCase="'accelerated'" class="badge badge-accelerated" i18n="transaction.audit.accelerated">Accelerated</span>

frontend/src/app/components/block-overview-tooltip/block-overview-tooltip.component.scss

@@ -27,9 +27,6 @@ th, td {
     width: 70%;
     text-align: end;
   }
-  &.oobFees {
-    color: #905cf4;
-  }
 }
 
 .badge.badge-accelerated {

frontend/src/app/components/block-overview-tooltip/block-overview-tooltip.component.ts

@@ -68,7 +68,7 @@ export class BlockOverviewTooltipComponent implements OnChanges {
       this.effectiveRate = this.tx.rate;
       const txFlags = BigInt(this.tx.flags) || 0n;
       this.acceleration = this.tx.acc || (txFlags & TransactionFlags.acceleration);
-      this.hasEffectiveRate = this.tx.acc || !(Math.abs((this.fee / this.vsize) - this.effectiveRate) <= 0.1 && Math.abs((this.fee / Math.ceil(this.vsize)) - this.effectiveRate) <= 0.1)
+      this.hasEffectiveRate = this.tx.acc || Math.abs((this.fee / this.vsize) - this.effectiveRate) > 0.05
         || (txFlags && (txFlags & (TransactionFlags.cpfp_child | TransactionFlags.cpfp_parent)) > 0n);
       this.filters = this.tx.flags ? toFilters(txFlags).filter(f => f.tooltip) : [];
       this.activeFilters = {}

frontend/src/app/components/block-rewards-graph/block-rewards-graph.component.ts

@@ -23,7 +23,7 @@ import { StateService } from '../../services/state.service';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/block-sizes-weights-graph/block-sizes-weights-graph.component.ts

@@ -21,7 +21,7 @@ import { StateService } from '../../services/state.service';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/block/block.component.ts

@@ -521,7 +521,6 @@ export class BlockComponent implements OnInit, OnDestroy {
     if (transactions && blockAudit) {
       const inTemplate = {};
       const inBlock = {};
-      const isUnseen = {};
       const isAdded = {};
       const isPrioritized = {};
       const isCensored = {};
@@ -544,9 +543,6 @@ export class BlockComponent implements OnInit, OnDestroy {
         for (const tx of transactions) {
           inBlock[tx.txid] = true;
         }
-        for (const txid of blockAudit.unseenTxs || []) {
-          isUnseen[txid] = true;
-        }
         for (const txid of blockAudit.addedTxs) {
           isAdded[txid] = true;
         }
@@ -596,27 +592,18 @@ export class BlockComponent implements OnInit, OnDestroy {
             tx.status = 'accelerated';
           }
         }
-        let anySeen = false;
-        for (let index = transactions.length - 1; index >= 0; index--) {
-          const tx = transactions[index];
+        for (const [index, tx] of transactions.entries()) {
           tx.context = 'actual';
           if (index === 0) {
             tx.status = null;
-          } else if (isPrioritized[tx.txid]) {
-            if (isAdded[tx.txid] || (blockAudit.version > 0 && isUnseen[tx.txid])) {
-              tx.status = 'added_prioritized';
-            } else {
-              tx.status = 'prioritized';
-            }
-          } else if (isAdded[tx.txid] && (blockAudit.version === 0 || isUnseen[tx.txid])) {
+          } else if (isAdded[tx.txid]) {
             tx.status = 'added';
+          } else if (isPrioritized[tx.txid]) {
+            tx.status = 'prioritized';
           } else if (inTemplate[tx.txid]) {
-            anySeen = true;
             tx.status = 'found';
           } else if (isRbf[tx.txid]) {
             tx.status = 'rbf';
-          } else if (isUnseen[tx.txid] && anySeen) {
-            tx.status = 'added';
           } else {
             tx.status = 'selected';
             isSelected[tx.txid] = true;

frontend/src/app/components/difficulty-adjustments-table/difficulty-adjustments-table.components.ts

@@ -15,7 +15,7 @@ import { StateService } from '../../services/state.service';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
 })

frontend/src/app/components/hashrate-chart/hashrate-chart.component.ts

@@ -23,7 +23,7 @@ import { seoDescriptionNetwork } from '../../shared/common.utils';
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/hashrates-chart-pools/hashrate-chart-pools.component.scss

@@ -59,7 +59,7 @@
   position: absolute;
   top: 50%;
   left: calc(50% - 15px);
-  z-index: 99;
+  z-index: 100;
 }
 .loadingGraphs.widget {
   top: 75%;

frontend/src/app/components/hashrates-chart-pools/hashrate-chart-pools.component.ts

@@ -28,7 +28,7 @@ interface Hashrate {
       position: absolute;
       top: 50%;
       left: calc(50% - 15px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/incoming-transactions-graph/incoming-transactions-graph.component.ts

@@ -17,7 +17,7 @@ const OUTLIERS_MEDIAN_MULTIPLIER = 4;
       position: absolute;
       top: 50%;
       left: calc(50% - 16px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/lbtc-pegs-graph/lbtc-pegs-graph.component.ts

@@ -11,7 +11,7 @@ import { StateService } from '../../services/state.service';
       position: absolute;
       top: 50%;
       left: calc(50% - 16px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   templateUrl: './lbtc-pegs-graph.component.html',

frontend/src/app/components/liquid-master-page/liquid-master-page.component.html

@@ -52,7 +52,7 @@
       <a [href]="env.MEMPOOL_WEBSITE_URL + urlLanguage + (networkPaths['mainnet'] || '')" ngbDropdownItem class="mainnet"><app-svg-images name="bitcoin" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Mainnet</a>
       <a [href]="env.MEMPOOL_WEBSITE_URL + urlLanguage + (networkPaths['signet'] || '/signet')" ngbDropdownItem *ngIf="env.SIGNET_ENABLED" class="signet"><app-svg-images name="signet" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Signet</a>
       <a [href]="env.MEMPOOL_WEBSITE_URL + urlLanguage + (networkPaths['testnet'] || '/testnet')" ngbDropdownItem *ngIf="env.TESTNET_ENABLED" class="testnet"><app-svg-images name="testnet" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Testnet3</a>
-      <a [href]="env.MEMPOOL_WEBSITE_URL + urlLanguage + (networkPaths['testnet4'] || '/testnet4')" ngbDropdownItem *ngIf="env.TESTNET4_ENABLED" class="testnet"><app-svg-images name="testnet4" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Testnet4</a>
+      <a [href]="env.MEMPOOL_WEBSITE_URL + urlLanguage + (networkPaths['testnet4'] || '/testnet4')" ngbDropdownItem *ngIf="env.TESTNET4_ENABLED" class="testnet"><app-svg-images name="testnet4" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Testnet4 <span class="badge badge-pill badge-warning beta-network" i18n="beta">beta</span></a>
       <h6 class="dropdown-header" i18n="master-page.layer2-networks-header">Layer 2 Networks</h6>
       <a ngbDropdownItem class="liquid mr-1" [class.active]="network.val === 'liquid'" [routerLink]="networkPaths['liquid'] || '/'"><app-svg-images name="liquid" width="22" height="22" viewBox="0 0 125 125" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Liquid</a>
       <a ngbDropdownItem *ngIf="env.LIQUID_TESTNET_ENABLED" class="liquidtestnet" [class.active]="network.val === 'liquidtestnet'" [routerLink]="networkPaths['liquidtestnet'] || '/testnet'"><app-svg-images name="liquidtestnet" width="22" height="22" viewBox="0 0 125 125" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Liquid Testnet</a>

frontend/src/app/components/liquid-reserves-audit/reserves-ratio/reserves-ratio.component.scss

@@ -2,5 +2,5 @@
   position: absolute;
   top: 50%;
   left: calc(50% - 16px);
-  z-index: 99;
+  z-index: 100;
 }

frontend/src/app/components/loading-indicator/loading-indicator.component.scss

@@ -1,7 +1,7 @@
 .sticky-loading {
   position: absolute;
   right: 10px;
-  z-index: 99;
+  z-index: 100;
   font-size: 14px;
   @media (width >= 992px) {
     left: 32px;

frontend/src/app/components/master-page/master-page.component.html

@@ -70,7 +70,7 @@
       <a ngbDropdownItem *ngIf="env.MAINNET_ENABLED" class="mainnet" [routerLink]="networkPaths['mainnet'] || '/'"><app-svg-images name="bitcoin" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Mainnet</a>
       <a ngbDropdownItem *ngIf="env.SIGNET_ENABLED" class="signet" [class.active]="network.val === 'signet'" [routerLink]="networkPaths['signet'] || '/signet'"><app-svg-images name="signet" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Signet</a>
       <a ngbDropdownItem *ngIf="env.TESTNET_ENABLED" class="testnet" [class.active]="network.val === 'testnet'" [routerLink]="networkPaths['testnet'] || '/testnet'"><app-svg-images name="testnet" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Testnet3</a>
-      <a ngbDropdownItem *ngIf="env.TESTNET4_ENABLED" class="testnet4" [class.active]="network.val === 'testnet4'" [routerLink]="networkPaths['testnet4'] || '/testnet4'"><app-svg-images name="testnet4" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Testnet4</a>
+      <a ngbDropdownItem *ngIf="env.TESTNET4_ENABLED" class="testnet4" [class.active]="network.val === 'testnet4'" [routerLink]="networkPaths['testnet4'] || '/testnet4'"><app-svg-images name="testnet4" width="22" height="22" viewBox="0 0 65 65" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Testnet4 <span class="badge badge-pill badge-warning beta-network" i18n="beta">beta</span></a>
       <a [href]="env.LIQUID_WEBSITE_URL + urlLanguage + (networkPaths['liquid'] || '')" ngbDropdownItem *ngIf="env.LIQUID_ENABLED" class="liquid" [class.active]="network.val === 'liquid'"><app-svg-images name="liquid" width="22" height="22" viewBox="0 0 125 125" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Liquid</a>
       <a [href]="env.LIQUID_WEBSITE_URL + urlLanguage  + (networkPaths['liquidtestnet'] || '/testnet')" ngbDropdownItem *ngIf="env.LIQUID_TESTNET_ENABLED" class="liquidtestnet" [class.active]="network.val === 'liquid'"><app-svg-images name="liquidtestnet" width="22" height="22" viewBox="0 0 125 125" style="width: 25px; height: 25px;" class="mainnet mr-1"></app-svg-images> Liquid Testnet</a>
     </div>

frontend/src/app/components/mempool-blocks/mempool-blocks.component.html

@@ -51,8 +51,7 @@
         </div>
       </ng-template>
     </div>
-    <app-acceleration-sparkles [style]="{ position: 'absolute', right: 0}" [arrow]="arrowElement" [run]="acceleratingArrow"></app-acceleration-sparkles>
-    <div *ngIf="arrowVisible" #arrowUp id="arrow-up" [ngStyle]="{'right': rightPosition + (blockWidth * 0.3) + containerOffset + 'px', transition: transition }" [class.blink]="txPosition?.accelerated"></div>
+    <div *ngIf="arrowVisible" id="arrow-up" [ngStyle]="{'right': rightPosition + (blockWidth * 0.3) + containerOffset + 'px', transition: transition }" [class.blink]="txPosition?.accelerated"></div>
   </div>
 </ng-container>
 

frontend/src/app/components/mempool-blocks/mempool-blocks.component.ts

@@ -1,4 +1,4 @@
-import { Component, OnInit, OnDestroy, ChangeDetectionStrategy, ChangeDetectorRef, HostListener, Input, OnChanges, SimpleChanges, Output, EventEmitter, ViewChild, ElementRef } from '@angular/core';
+import { Component, OnInit, OnDestroy, ChangeDetectionStrategy, ChangeDetectorRef, HostListener, Input, OnChanges, SimpleChanges, Output, EventEmitter } from '@angular/core';
 import { Subscription, Observable, of, combineLatest } from 'rxjs';
 import { MempoolBlock } from '../../interfaces/websocket.interface';
 import { StateService } from '../../services/state.service';
@@ -77,9 +77,6 @@ export class MempoolBlocksComponent implements OnInit, OnChanges, OnDestroy {
   maxArrowPosition = 0;
   rightPosition = 0;
   transition = 'background 2s, right 2s, transform 1s';
-  @ViewChild('arrowUp')
-  arrowElement: ElementRef<HTMLDivElement>;
-  acceleratingArrow: boolean = false;
 
   markIndex: number;
   txPosition: MempoolPosition;
@@ -204,7 +201,6 @@ export class MempoolBlocksComponent implements OnInit, OnChanges, OnDestroy {
 
     this.markBlocksSubscription = this.stateService.markBlock$
       .subscribe((state) => {
-        const oldTxPosition = this.txPosition;
         this.markIndex = undefined;
         this.txPosition = undefined;
         this.txFeePerVSize = undefined;
@@ -213,12 +209,6 @@ export class MempoolBlocksComponent implements OnInit, OnChanges, OnDestroy {
         }
         if (state.mempoolPosition) {
           this.txPosition = state.mempoolPosition;
-          if (this.txPosition.accelerated && !oldTxPosition?.accelerated) {
-            this.acceleratingArrow = true;
-            setTimeout(() => {
-              this.acceleratingArrow = false;
-            }, 2000);
-          }
         }
         if (state.txFeePerVSize) {
           this.txFeePerVSize = state.txFeePerVSize;

frontend/src/app/components/mempool-graph/mempool-graph.component.ts

@@ -18,7 +18,7 @@ import { download, formatterXAxis, formatterXAxisLabel } from '../../shared/grap
       position: absolute;
       top: 50%;
       left: calc(50% - 16px);
-      z-index: 99;
+      z-index: 100;
     }
   `],
   changeDetection: ChangeDetectionStrategy.OnPush,

frontend/src/app/components/pool-ranking/pool-ranking.component.scss

@@ -60,7 +60,7 @@
   position: absolute;
   top: 50%;
   left: calc(50% - 15px);
-  z-index: 99;
+  z-index: 100;
 }
 
 .pool-distribution {

frontend/src/app/components/pool/pool.component.scss

@@ -167,7 +167,7 @@ div.scrollable {
 .loadingGraphs {
   position: absolute;
   left: calc(50% - 15px);
-  z-index: 99;
+  z-index: 100;
   top: 475px;
   @media (max-width: 992px) {
     top: 600px;

frontend/src/app/components/privacy-policy/privacy-policy.component.html

@@ -5,7 +5,7 @@
     <br><br>
 
     <h2>Privacy Policy</h2>
-    <h6>Updated: July 31, 2024</h6>
+    <h6>Updated: July 10, 2024</h6>
 
     <br><br>
 
@@ -27,7 +27,7 @@
 
       <br>
 
-      <h4>USING THIS WEBSITE</h4>
+      <h4>General</h4>
 
       <p *ngIf="officialMempoolSpace">Out of respect for the Bitcoin community, this Website does not use any third-party analytics, third-party trackers, or third-party cookies, and we do not share any private user data with third-parties. Additionally, to mitigate the risk of surveillance by malicious third-parties, we self-host this Website on our own hardware and network infrastructure, so there are no "hosting companies" or "cloud providers" involved with the operation of this Website.</p>
 
@@ -35,7 +35,7 @@
 
       <ul>
 
-        <li>We use basic webserver logging (nginx) for sysadmin purposes, which collects your IP address along with the requests you make. These logs are deleted after 10 days, and we do not share this data with any third-party.</li>
+        <li>We use basic webserver logging (nginx) for sysadmin purposes, which collects your IP address along with the requests you make. These logs are deleted after 10 days, and we do not share this data with any third-party. To conceal your IP address from our webserver logs, we recommend that you use Tor Browser with our Tor v3 hidden service onion hostname.</li>
 
         <br>
 
@@ -49,7 +49,7 @@
 
       <p *ngIf="officialMempoolSpace">If you use Mempool Accelerator&trade; your acceleration request will be sent to us and relayed to Mempool's mining pool partners. We will store the TXID of the transactions you accelerate with us. We share this information with our mining pool partners, and publicly display accelerated transaction details on our website and APIs. No personal information or account identifiers will be shared with any third party including mining pool partners.</p>
 
-      <p *ngIf="!officialMempoolSpace">When using Mempool Accelerator&trade; the mempool.space privacy policy will apply: <a href="https://mempool.space/privacy-policy">https://mempool.space/privacy-policy</a>.</p>
+      <p *ngIf="!officialMempoolSpace">If you click the accelerate button on a transaction you will load acceleration pricing information from Mempool. If you make an acceleration request, the TXID and your maximum bid will be sent to Mempool who will store and share this information with their mining pool partners, and publicly display accelerated transaction details on mempool.space and via Mempool's APIs. No personal information or account identifiers will be shared with any third party including mining pool partners.</p>
 
       <br>
       
@@ -74,38 +74,22 @@
         <br>
 
       </ng-container>  
-      
-      <ng-container *ngIf="officialMempoolSpace">    
-        
+
       <h4>PAYMENTS AND DONATIONS</h4>
 
-        <p>If you make any payment to Mempool or donation to The Mempool Open Source Project&reg;, we may collect the following:</p>
+      <p>If you make any payment to Mempool or donation to The Mempool Open Source Project&reg;, we may collect the following:</p>
 
-        <ul>
+      <ul>
 
-          <li>Your e-mail address and/or country; we may use this information to manage your user account, for billing purposes, or to update you about our services. We will not share this with any third-party, except as necessary for our fiat payment processor.</li>
+        <li>Your e-mail address and/or country; we may use this information to manage your user account, for billing purposes, or to update you about our services. We will not share this with any third-party, except as necessary for our fiat payment processor.</li>
 
-          <li>If you make a payment using Bitcoin, we will process your payment using our self-hosted BTCPay Server instance. We will not share your payment details with any third-party. For payments made over the Lightning network, we may utilize third party LSPs / lightning liquidity providers.</li>
+        <li>If you make a payment using Bitcoin, we will process your payment using our self-hosted BTCPay Server instance. We will not share your payment details with any third-party. For payments made over the Lightning network, we may utilize third party LSPs / lightning liquidity providers.</li>
 
-          <li>If you make a payment using Fiat we will collect your payment details. We will share your payment details with our fiat payment processor Square (Block, Inc.) - Please see "Information we collect about customers" on Square's website at https://squareup.com/us/en/legal/general/privacy.</li>
+        <li>If you make a payment using Fiat we will collect your payment details. We will share your payment details with our fiat payment processor Square (Block, Inc.),. - Please see "Information we collect about customers" on Square's website at https://squareup.com/us/en/legal/general/privacy.</li>
 
-        </ul>
+      </ul>
 
-        <br>
-
-      </ng-container> 
-
-      <ng-container *ngIf="officialMempoolSpace">
-
-        <h4>DATA RETENTION AND ACCOUNT INACTIVITY</h4>
-        
-        <p>We aim to retain your data only as long as necessary:</p>
-        <ul>
-          <li>An account is considered inactive if all of the following conditions are met: a) No login activity within the past 6 months, b) No active subscriptions associated with the account, c) No Mempool Accelerator™ Pro account credit</li>
-          <li>If an account meets the criteria for inactivity as defined above, we will automatically delete the associated account data after a period of 6 months of continuous inactivity, except in the case of payment disputes or account irregularities.</li>
-        </ul>
-
-      </ng-container>
+      <br>
 
       <p>EOF</p>
 

frontend/src/app/components/search-form/search-form.component.ts

@@ -303,6 +303,7 @@ export class SearchFormComponent implements OnInit {
           (error) => { console.log(error); this.isSearching = false; }
         );
       } else {
+        this.searchResults.searchButtonClick();
         this.isSearching = false;
       }
     }

frontend/src/app/components/start/start.component.ts

@@ -234,7 +234,7 @@ export class StartComponent implements OnInit, AfterViewChecked, OnDestroy {
     this.minScrollWidth = 40 + (8 * this.blockWidth) + (this.pageWidth * 2);
 
     if (firstVisibleBlock != null) {
-      this.scrollToBlock(firstVisibleBlock, offset + (this.isMobile ? this.blockWidth : 0));
+      this.scrollToBlock(firstVisibleBlock, offset);
     } else {
       this.updatePages();
     }

frontend/src/app/components/tracker/tracker.component.html

@@ -46,7 +46,7 @@
       @if (replaced) {
         <div class="alert-replaced" role="alert">
           <span i18n="transaction.rbf.replacement|RBF replacement">This transaction has been replaced by:</span>
-          <app-truncate [text]="latestReplacement" [lastChars]="12" [link]="['/tx/' | relativeUrl, latestReplacement]" [queryParams]="{mode: 'status'}"></app-truncate>
+          <app-truncate [text]="latestReplacement" [lastChars]="12" [link]="['/tracker/' | relativeUrl, latestReplacement]"></app-truncate>
         </div>
       } @else {
         <div class="tracker-bar">
@@ -61,7 +61,7 @@
               @if (transactionTime > 0) {
                 <i><app-time kind="since" [time]="transactionTime" [fastRender]="true" [showTooltip]="true"></app-time></i>
               } @else {
-                <span class="skeleton-loader" style="max-width: 200px;"></span>
+                <span class="skeleton-loader" style="max-width: 50%;"></span>
               }
             </div>
           </div>
@@ -78,7 +78,7 @@
                 </span>
               </ng-container>
               <ng-template #etaSkeleton>
-                <span class="skeleton-loader" style="max-width: 200px;"></span>
+                <span class="skeleton-loader"></span>
               </ng-template>
             </div>
           </div>
@@ -118,7 +118,7 @@
         </div>
         <span class="explainer">&nbsp;</span>
       } @else {
-        @if (tx && !tx.status?.confirmed && showAccelerationSummary) {
+        @if (!tx.status?.confirmed && showAccelerationSummary) {
           <ng-container *ngIf="(ETA$ | async) as eta;">
             <app-accelerate-checkout
               *ngIf="(da$ | async) as da;"
@@ -135,7 +135,7 @@
             ></app-accelerate-checkout>
           </ng-container>
         }
-        <div class="status-panel d-flex flex-column h-100 w-100 justify-content-center align-items-center" [class.small-status]="tx && !tx.status?.confirmed && showAccelerationSummary">
+        <div class="status-panel d-flex flex-column h-100 w-100 justify-content-center align-items-center" [class.small-status]="!tx.status?.confirmed && showAccelerationSummary">
           @if (tx?.acceleration && !tx.status?.confirmed) {
             <div class="progress-icon">
               <fa-icon [icon]="['fas', 'wand-magic-sparkles']" [fixedWidth]="true"></fa-icon>
@@ -185,11 +185,7 @@
       }
     </div>
 
-    <div class="footer-link"
-      [routerLink]="['/tx' | relativeUrl, tx?.txid || txId]"
-      [queryParams]="{ mode: 'details' }"
-      queryParamsHandling="merge"
-    >
+    <div class="footer-link" [routerLink]="['/tx' | relativeUrl, tx?.txid]">
       <span><ng-container i18n="accelerator.show-more-details">See more details</ng-container>&nbsp;<fa-icon [icon]="['fas', 'arrow-alt-circle-right']"></fa-icon></span>
     </div>
   </div>

frontend/src/app/components/tracker/tracker.component.scss

@@ -49,7 +49,7 @@
   position: relative;
   background: var(--nav-bg);
   box-shadow: 0 -5px 15px #000;
-  z-index: 99;
+  z-index: 100;
   align-items: center;
   justify-content: space-between;
 

frontend/src/app/components/tracker/tracker.component.ts

@@ -31,8 +31,6 @@ import { TrackerStage } from './tracker-bar.component';
 import { MiningService, MiningStats } from '../../services/mining.service';
 import { ETA, EtaService } from '../../services/eta.service';
 import { getTransactionFlags, getUnacceleratedFeeRate } from '../../shared/transaction.utils';
-import { RelativeUrlPipe } from '../../shared/pipes/relative-url/relative-url.pipe';
-
 
 interface Pool {
   id: number;
@@ -142,7 +140,6 @@ export class TrackerComponent implements OnInit, OnDestroy {
     private priceService: PriceService,
     private enterpriseService: EnterpriseService,
     private miningService: MiningService,
-    private router: Router,
     private cd: ChangeDetectorRef,
     private zone: NgZone,
     @Inject(ZONE_SERVICE) private zoneService: any,
@@ -293,7 +290,7 @@ export class TrackerComponent implements OnInit, OnDestroy {
       })
     ).subscribe((accelerationHistory) => {
       for (const acceleration of accelerationHistory) {
-        if (acceleration.txid === this.txId && (acceleration.status === 'completed' || acceleration.status === 'completed_provisional') && acceleration.pools.includes(acceleration.minedByPoolUniqueId)) {
+        if (acceleration.txid === this.txId && (acceleration.status === 'completed' || acceleration.status === 'completed_provisional')) {
           const boostCost = acceleration.boostCost || acceleration.bidBoost;
           acceleration.acceleratedFeeRate = Math.max(acceleration.effectiveFee, acceleration.effectiveFee + boostCost) / acceleration.effectiveVsize;
           acceleration.boost = boostCost;

frontend/src/app/components/trademark-policy/trademark-policy.component.html

@@ -8,7 +8,7 @@
   <div *ngIf="officialMempoolSpace">
     <h2>Trademark Policy and Guidelines</h2>
     <h5>The Mempool Open Source Project &reg;</h5>
-    <h6>Updated: August 19, 2024</h6>
+    <h6>Updated: July 3, 2024</h6>
     <br>
 
     <div class="text-left">
@@ -100,26 +100,11 @@
             <p>The Mempool Accelerator Logo</p>
             <br><br>
 
-            <img src="/resources/mempool-research.png" style="width: 500px; max-width: 80%">
-            <br><br>
-            <p>The mempool research Logo</p>
-            <br><br>
-
             <app-svg-images name="goggles" height="96px"></app-svg-images>
             <br><br>
             <p>The Mempool Goggles Logo</p>
             <br><br>
 
-            <img src="/resources/mempool-transaction.png" style="width: 500px; max-width: 80%">
-            <br><br>
-            <p>The mempool transaction Logo</p>
-            <br><br>
-
-            <img src="/resources/mempool-block-visualization.png" style="width: 500px; max-width: 80%">
-            <br><br>
-            <p>The mempool block visualization Logo</p>
-            <br><br>
-
             <img src="/resources/mempool-blocks-2-3-logo.jpeg" style="width: 500px; max-width: 80%">
             <br><br>
             <p>The mempool Blocks Logo</p>