@ledgerhq/coin-tester-bitcoin 1.1.0 → 1.2.0-nightly.20251107095716

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-tester-bitcoin",
-  "version": "1.1.0",
+  "version": "1.2.0-nightly.20251107095716",
   "description": "Ledger BTC Coin Tester",
   "main": "src/scenarii.test.ts",
   "keywords": [
@@ -48,15 +48,15 @@
     "bignumber.js": "^9.1.2",
     "bitcoin-core": "^5.0.0",
     "docker-compose": "^1.1.0",
-    "@ledgerhq/coin-bitcoin": "^0.24.0",
-    "@ledgerhq/coin-framework": "^6.8.0",
-    "@ledgerhq/coin-tester": "^0.11.0",
+    "@ledgerhq/coin-bitcoin": "^0.25.0-nightly.20251107095716",
+    "@ledgerhq/coin-framework": "^6.9.0-nightly.20251107095716",
+    "@ledgerhq/coin-tester": "^0.12.0-nightly.20251107095716",
     "@ledgerhq/live-config": "^3.2.0",
+    "@ledgerhq/cryptoassets": "^13.33.0-nightly.20251107095716",
     "@ledgerhq/live-network": "^2.1.0",
-    "@ledgerhq/cryptoassets": "^13.32.0",
-    "@ledgerhq/types-cryptoassets": "^7.30.0",
     "@ledgerhq/hw-app-btc": "^10.12.0",
-    "@ledgerhq/types-live": "^6.88.0"
+    "@ledgerhq/types-cryptoassets": "^7.30.0",
+    "@ledgerhq/types-live": "^6.89.0-nightly.20251107095716"
   },
   "devDependencies": {
     "@types/jest": "^29.5.10",

package/src/helpers.ts

@@ -15,7 +15,6 @@ export async function loadWallet(name: string): Promise<void> {
     console.log(`✅ Wallet "${name}" created and loaded:`, res);
 
     // Optionally verify that the wallet is accessible
-    await client.getBalance({ minconf: 0 });
     return;
   } catch (error: any) {
     const message = error?.message || "Unknown error";
@@ -249,113 +248,66 @@ export const sendRaw = async (recipientAddress: string, amount: number, sequence
   }
 };
 
-export const sendToReplaceCurrentTx = async (recipientAddress: string, amount: number) => {
-  if (!recipientAddress || amount <= 0) {
-    console.error("Invalid parameters: Provide a valid address and positive amount.");
-    return;
-  }
-
-  console.log(
-    `Sending replaceable transaction to ${recipientAddress} with amount ${amount} BTC...`,
-  );
-
-  try {
-    // Step 1: Get an unspent UTXO
-    const unspent = await client.listUnspent({
-      query_options: { minimumSumAmount: amount },
-    });
-
-    if (!unspent.length) {
-      console.error("No suitable UTXOs available.");
-      return;
-    }
-
-    const utxo = unspent[0];
+export async function sendTransaction(
+  recipientAddress: string,
+  amount: number,
+  rbf: boolean = true,
+): Promise<string> {
+  // Send an RBF-enabled transaction
+  const txid = await client.sendToAddress(recipientAddress, amount, "", "", rbf);
+
+  // Log details
+  const mempoolEntry = await client.getMempoolEntry(txid);
+  console.log("BIP125 replaceable:", mempoolEntry["bip125-replaceable"]);
+  return txid;
+}
 
-    // Step 2: Create the replaceable transaction (RBF enabled)
-    const rawTx1 = await client.createRawTransaction({
-      inputs: [
-        {
-          txid: utxo.txid,
-          vout: utxo.vout,
-          sequence: 4294967293, // RBF enabled
-        },
-      ],
-      outputs: {
-        [recipientAddress]: amount,
-      },
-    });
+export async function replaceTransaction(
+  originalTxid: string,
+  newRecipientAddress: string,
+  feeBumpPercent: number = 0.1, // 10% bump
+): Promise<string> {
+  const rawTx = await client.getRawTransaction(originalTxid, true);
+  const input = rawTx.vin[0];
+  const originalOutputValue = rawTx.vout[0].value;
 
-    // Step 3: Fund & Sign the transaction
-    const fundedTx1 = await client.fundRawTransaction({
-      hexstring: rawTx1,
-      options: { feeRate: 0.0004 }, // Increase fee rate
-    });
-    const signedTx1 = await client.signRawTransactionWithWallet({
-      hexstring: fundedTx1.hex,
-    });
+  // Try to estimate the original feerate
+  let originalFeerate = 0.00001; // fallback (BTC/vB)
+  let vsize = 200; // default guess
 
-    // Step 4: Broadcast the transaction
-    const txId1 = await client.sendRawTransaction({ hexstring: signedTx1.hex });
-    console.log(`Transaction sent (TXID: ${txId1}), waiting before replacing...`);
-    console.log(`If you need to, make a tx that sends funds to ${recipientAddress}`);
-  } catch (error: any) {
-    console.error("Error in sendReplaceableTransaction:", error.message);
+  try {
+    const entry = await client.getMempoolEntry(originalTxid);
+    originalFeerate = entry.fees.base / entry.vsize;
+    vsize = entry.vsize;
+  } catch {
+    console.warn("⚠️ Could not get mempool entry, using fallback feerate.");
   }
-};
 
-export const sendReplaceableTransaction = async (recipientAddress: string, amount: number) => {
-  if (!recipientAddress || amount <= 0) {
-    console.error("Invalid parameters: Provide a valid address and positive amount.");
-    return;
-  }
+  const newFeerate = originalFeerate * (1 + feeBumpPercent);
+  const estimatedFee = newFeerate * vsize;
 
-  console.log(
-    `Sending replaceable transaction to ${recipientAddress} with amount ${amount} BTC...`,
-  );
+  // Adjust amount by the new fee
+  const adjustedAmount = Number(originalOutputValue - estimatedFee).toFixed(8);
 
-  try {
-    // Step 1: Get an unspent UTXO
-    const unspent = await client.listUnspent({
-      query_options: { minimumSumAmount: amount },
-    });
+  if (Number(adjustedAmount) <= 0) {
+    throw new Error(`❌ Adjusted amount <= 0 (fee too large)`);
+  }
 
-    if (!unspent.length) {
-      console.error("No suitable UTXOs available.");
-      return;
-    }
+  const newRawTx = await client.createRawTransaction([{ txid: input.txid, vout: input.vout }], {
+    [newRecipientAddress]: adjustedAmount,
+  });
 
-    const utxo = unspent[0];
+  const signed = await client.signRawTransactionWithWallet(newRawTx);
 
-    // Step 2: Create the first replaceable transaction (RBF enabled)
-    const rawTx1 = await client.createRawTransaction({
-      inputs: [
-        {
-          txid: utxo.txid,
-          vout: utxo.vout,
-          sequence: 4294967293, // RBF enabled
-        },
-      ],
-      outputs: {
-        [recipientAddress]: amount,
-      },
-    });
+  const replacementTxid = await client.sendRawTransaction(signed.hex, 0);
+  console.log(`✅ Replaced TX: ${originalTxid} → ${replacementTxid}`);
 
-    // Step 3: Fund & Sign the first transaction
-    const fundedTx1 = await client.fundRawTransaction({
-      hexstring: rawTx1,
-      options: { feeRate: 0.0002 }, // Increase fee rate
-    });
-    const signedTx1 = await client.signRawTransactionWithWallet({
-      hexstring: fundedTx1.hex,
-    });
+  return replacementTxid;
+}
 
-    // Step 4: Broadcast the first transaction
-    const txId1 = await client.sendRawTransaction({ hexstring: signedTx1.hex });
-    console.log(`First transaction sent (TXID: ${txId1}), waiting before replacing...`);
-  } catch (error: any) {
-    console.error("Error in sendReplaceableTransaction:", error.message);
-  }
+export const getRawMempool = async () => {
+  const mempool = await client.getRawMempool();
+  return mempool;
 };
 
 /*Available commands:

package/src/scenarii/bitcoin.ts

@@ -10,10 +10,17 @@ import { SignerContext } from "@ledgerhq/coin-bitcoin/signer";
 import { BitcoinConfigInfo, setCoinConfig } from "@ledgerhq/coin-bitcoin/config";
 import { BigNumber } from "bignumber.js";
 import { defaultNanoApp } from "../constants";
-import { loadWallet, mineToWalletAddress, sendTo } from "../helpers";
+import {
+  loadWallet,
+  mineToWalletAddress,
+  sendTo,
+  sendTransaction,
+  replaceTransaction,
+  getRawMempool,
+} from "../helpers";
 import { makeAccount } from "../fixtures";
 import { killAtlas, spawnAtlas } from "../atlas";
-import { findNewUtxo, waitForExplorerSync } from "../utils";
+import { findNewUtxo, waitForExplorerSync, waitForTxInMempool } from "../utils";
 import {
   assertCommonTxProperties,
   assertUtxoExcluded,
@@ -213,6 +220,46 @@ const makeScenarioTransactions = (): BitcoinScenarioTransaction[] => {
   ];
 };
 
+// TODO: RBF and CTFP scenarios are not supported on Ledger Live yet That is why they are made using regtest for now
+// TODO: once RBF and CTFP are supported natively in Ledger Live, we can move these scenarios to use bitcoin module instead of regtest helpers
+const makeInternalScenarioTransactions = async () => {
+  const scenarioReplaceBtcTransaction: BitcoinScenarioTransaction = {
+    name: "Send Replace BTC transaction",
+    expect: async (previousAccount, currentAccount) => {
+      const txId = await sendTransaction((currentAccount as BitcoinAccount).freshAddress, 0.003);
+      // Waiting a bit before replacing...
+      await waitForTxInMempool(txId, 10000); // waits up to 10s
+
+      const replacementTxid = await replaceTransaction(
+        txId,
+        (currentAccount as BitcoinAccount).freshAddress,
+      );
+      const mempool = await getRawMempool();
+      expect(mempool.includes(txId)).toBe(false);
+      expect(mempool.includes(replacementTxid)).toBe(true);
+    },
+  };
+  const scenarioCancelBtcTransaction: BitcoinScenarioTransaction = {
+    name: "Send Cancel BTC transaction",
+    expect: async (previousAccount, currentAccount) => {
+      await mineToWalletAddress("2");
+      const txId = await sendTransaction("bcrt1qajglhjtctn88f5l6rajzz52fy78fhxspjajjwz", 0.003);
+      // Waiting a bit before replacing...
+      await waitForTxInMempool(txId, 10000); // waits up to 10s
+
+      const replacementTxid = await replaceTransaction(
+        txId,
+        (currentAccount as BitcoinAccount).freshAddress,
+      );
+      const mempool = await getRawMempool();
+      expect(mempool.includes(txId)).toBe(false);
+      expect(mempool.includes(replacementTxid)).toBe(true);
+    },
+  };
+
+  return [scenarioReplaceBtcTransaction, scenarioCancelBtcTransaction];
+};
+
 export const scenarioBitcoin: Scenario<BtcTransaction, BitcoinAccount> = {
   name: "Ledger Live Basic Bitcoin Transactions",
   setup: async () => {
@@ -282,6 +329,7 @@ export const scenarioBitcoin: Scenario<BtcTransaction, BitcoinAccount> = {
     };
   },
   getTransactions: () => makeScenarioTransactions(),
+  getInternalTransactions: () => makeInternalScenarioTransactions(),
   beforeAll: async account => {
     firstUtxoHash = (account as BitcoinAccount).bitcoinResources.utxos[0].hash;
     firstUtxoOutputIndex = (account as BitcoinAccount).bitcoinResources.utxos[0].outputIndex;
@@ -291,6 +339,10 @@ export const scenarioBitcoin: Scenario<BtcTransaction, BitcoinAccount> = {
   afterEach: async () => {
     // Mine 2 blocks after each transaction to confirm it
     await mineToWalletAddress("2");
+    await waitForExplorerSync();
+  },
+  afterAll: async account => {
+    expect(account.operations.length).toBeGreaterThanOrEqual(14);
   },
   beforeEach: async () => {
     // Make sure explorer is in sync before each transaction

package/src/scenarii.test.ts

@@ -5,7 +5,7 @@ import { scenarioBitcoin } from "./scenarii/bitcoin";
 import { killAtlas } from "./atlas";
 
 global.console = console;
-jest.setTimeout(300_000);
+jest.setTimeout(500_000);
 
 describe("Bitcoin Deterministic Tester", () => {
   it("scenario Bitcoin", async () => {

package/src/utils.ts

@@ -1,11 +1,21 @@
 import { BitcoinAccount } from "@ledgerhq/coin-bitcoin/lib/types";
-import { getCurrentBlock } from "./helpers";
+import { getCurrentBlock, getRawMempool } from "./helpers";
 import network from "@ledgerhq/live-network/network";
 
-function sleep(ms: number) {
+export function sleep(ms: number) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+export async function waitForTxInMempool(txId: string, timeout = 10000) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    const mempool = await getRawMempool();
+    if (mempool.includes(txId)) return true;
+    await sleep(500);
+  }
+  throw new Error(`Transaction ${txId} not found in mempool after ${timeout}ms`);
+}
+
 export async function waitForExplorerSync(
   url: string = "http://localhost:9876/blockchain/v4/btc_regtest/block/current",
   pollInterval: number = 2000,