@ledgerhq/coin-bitcoin 0.3.9

package/src/wallet-btc/__tests__/logic.ts

@@ -0,0 +1,29 @@
+import { getCryptoCurrencyById } from "@ledgerhq/coin-framework/currencies/index";
+import { isValidRecipient } from "../../logic";
+import { InvalidAddress } from "@ledgerhq/errors";
+
+describe("Test isValidRecipient", () => {
+  function t(address: string, currencyId: string, expectValid: boolean) {
+    const currency = getCryptoCurrencyById(currencyId);
+    if (expectValid) {
+      return expect(isValidRecipient({ currency, recipient: address })).resolves.toBeNull();
+    } else {
+      return expect(isValidRecipient({ currency, recipient: address })).rejects.toBeInstanceOf(
+        InvalidAddress,
+      );
+    }
+  }
+  test("Fail on non-existing currency", () =>
+    t("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4", "ontology", false));
+  test("Fail on mainnet addr on bitcoin_testnet", () =>
+    t("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4", "bitcoin_testnet", false));
+  test("Success on valid address", () =>
+    t("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4", "bitcoin", true));
+  test("Fail on invalid qtum address", () =>
+    t("xCREYTgvdk3XzFNpdXkj35fZX4hJK2Ckpe", "qtum", false));
+  test("Fail on invalid bch address", () =>
+    t("qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg3", "bitcoin_cash", false));
+  // TODO Enable once fixed in wallet-btc
+  test.skip("Success on valid bch address", () =>
+    t("qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg2", "bitcoin_cash", true));
+});

package/src/wallet-btc/__tests__/utils.test.ts

@@ -0,0 +1,257 @@
+import * as bech32 from "bech32";
+import { bech32m } from "../../bech32m";
+
+import * as utils from "../utils";
+import { Currency } from "../crypto/types";
+import cryptoFactory from "../crypto/factory";
+import { DerivationModes } from "../";
+
+function validateAddrs(addresses: string[], currency: Currency, expectedValid: boolean) {
+  addresses.forEach((address: string) => {
+    expect(utils.isValidAddress(address, currency)).toEqual(expectedValid);
+  });
+}
+
+function toBech32(
+  data: Buffer,
+  version: number,
+  prefix: string,
+  //bech32variant: BechLib // FIXME Restore this
+  bech32variant: any,
+): string {
+  const words = bech32.toWords(data);
+  words.unshift(version);
+
+  return bech32variant.encode(prefix, words);
+}
+
+const v0addrEncodedWithBase32 = toBech32(
+  Buffer.from("7777777777777777777777777777777777777777777777777777777777777777", "hex"),
+  0,
+  "bc",
+  bech32,
+);
+const v1addrEncodedWithBase32m = toBech32(
+  Buffer.from("7777777777777777777777777777777777777777777777777777777777777777", "hex"),
+  1,
+  "bc",
+  bech32m,
+);
+const v0addrEncodedWithBase32m = toBech32(
+  Buffer.from("7777777777777777777777777777777777777777777777777777777777777777", "hex"),
+  0,
+  "bc",
+  bech32m,
+);
+const v1addrEncodedWithBase32 = toBech32(
+  Buffer.from("7777777777777777777777777777777777777777777777777777777777777777", "hex"),
+  1,
+  "bc",
+  bech32,
+);
+
+describe("Unit tests for various utils functions", () => {
+  it("Test isValidAddress accepts valid bech32 address", () => {
+    const validMainnetAddresses = [
+      // bech32
+      "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4",
+      v0addrEncodedWithBase32,
+      // bech32m
+      "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y",
+      "BC1SW50QGDZ25J",
+      "bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs",
+      "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqzk5jj0",
+      v1addrEncodedWithBase32m,
+    ];
+    validateAddrs(validMainnetAddresses, "bitcoin", true);
+
+    const validTestnetAddresses = [
+      // bech32
+      "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
+      // bech32m
+      "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
+      "tb1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesf3hn0c",
+    ];
+    validateAddrs(validTestnetAddresses, "bitcoin_testnet", true);
+
+    const invalidMainnetAddresses = [
+      "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqh2y7hd", // Invalid checksum (Bech32 instead of Bech32m)
+      "BC1S0XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ54WELL", // Invalid checksum (Bech32 instead of Bech32m)
+      "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kemeawh", // Invalid checksum (Bech32m instead of Bech32)
+      "bc1p38j9r5y49hruaue7wxjce0updqjuyyx0kh56v8s25huc6995vvpql3jow4", // Invalid character in checksum
+      "BC130XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ7ZWS8R", // Invalid witness version
+      "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v07qwwzcrf", // zero padding of more than 4 bits
+      "bc1pw5dgrnzv", // Invalid program length (1 byte)
+      "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v8n0nx0muaewav253zgeav", // Invalid program length (41 bytes)
+      "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P", // Invalid program length for witness version 0 (per BIP141)
+      "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy", // Testnet addr used on mainnet
+      "bc1gmk9yu", // Empty data section
+      v0addrEncodedWithBase32m, // Version 0 address must be encoded with bech32
+      v1addrEncodedWithBase32, // Version 1 address must be encoded with bech32m
+    ];
+    validateAddrs(invalidMainnetAddresses, "bitcoin", false);
+
+    const invalidTestnetAddresses = [
+      "tc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq5zuyut", // Invalid human-readable part
+      "tb1z0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqglt7rf", // Invalid checksum (Bech32 instead of Bech32m)
+      "tb1q0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq24jc47", // Invalid checksum (Bech32m instead of Bech32)
+      "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq47Zagq", // Mixed case
+      "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vpggkg4j", // Non-zero padding in 8-to-5 conversion
+      "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y", // Mainnet addr used on testnet
+    ];
+    validateAddrs(invalidTestnetAddresses, "bitcoin_testnet", false);
+  });
+
+  it("isValidAddress should default old validation if currency not provided", () => {
+    expect(
+      utils.isValidAddress("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7"),
+    ).toBeTruthy();
+    expect(
+      utils.isValidAddress("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k8"),
+    ).toBeFalsy();
+  });
+
+  it("Test altcoins", () => {
+    validateAddrs(
+      [
+        "1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu",
+        "qqmyc72pkyx8c0ppgeuummq6clzverhxnsk3qh6jcf",
+        "bitcoincash:qqmyc72pkyx8c0ppgeuummq6clzverhxnsk3qh6jcf",
+      ],
+      "bitcoin_cash",
+      true,
+    );
+    validateAddrs(
+      [
+        "bitcoincash:qqmyc72pkyx8c0ppgeuummq6clzverhxnsk3qh6jc1",
+        "1BpEi6DfDAUFd7GtittLSdBeYgvcoaVggu",
+      ],
+      "bitcoin_cash",
+      false,
+    );
+
+    validateAddrs(["bitcoincash:qzl0x0982hy9xrh99wdnejx4eecdn02jv58as5p595"], "bitcoin_cash", true);
+    validateAddrs(["ltc1q3e4eh3lldvx97zg6d74x4ns6v5a4j4hwwqycwv"], "litecoin", true);
+    validateAddrs(["Xh13o3cWixDBYJMGuJmFX17TZb9guXcBik"], "dash", true);
+    validateAddrs(["MFYvHZcZ35typC4k2XyvRVooCDZxnoDS4B"], "qtum", true);
+    validateAddrs(["t1b1Rbw2shhJkP6MCnCyxCPuyFedHrwKty8"], "zcash", true);
+    validateAddrs(["t3PU1j7YW3fJ67jUbkGhSRto8qK2qXCUiW3"], "zcash", true);
+    validateAddrs(["AYRf8r4SJhmfaEwmWvY8ujmrepbrWyenFr"], "bitcoin_gold", true);
+    validateAddrs(["D8cMCRimfjwQ9E8jJvgUswt18WnZbCUAaW"], "dogecoin", true);
+    validateAddrs(["dgb1q7zjgqa23xzf602ljfrc94248a9u27xml08nhct"], "digibyte", true);
+    validateAddrs(["REnTkuvjsmfshAZ3vukYfuS3ZGvfUatqFc"], "komodo", true);
+    validateAddrs(["DQ7F2iTQn6kUpyvietinaC3Cxje2m1ULjS"], "pivx", true);
+    validateAddrs(["zndVnjbrzRxvhPGRea4jgsfSWE1hXFja1dc"], "zencash", true);
+    validateAddrs(["3LQWwDEpgjjQokDusDXtoF9c8on8zr54fT"], "vertcoin", true);
+    validateAddrs(["PCYt39DMYuFqUYkP8w6ubZXJbTTL4c9KAV"], "peercoin", true);
+    validateAddrs(["ETx91CT52eBFYWbe4Yht5BpZNigWg2EkqJ"], "viacoin", true);
+    validateAddrs(["S6NMcEfYbavHrP3Uo1wbEUvKhAbKeMuga8"], "stealthcoin", true);
+    validateAddrs(["Dso59DoPRkfATcZgHGgfh9mpku7taw9srAv"], "decred", true);
+    validateAddrs(["Dcck4QrFF5wuLzQpwxb5evhSRD7ZTsJZwuh"], "decred", true);
+
+    validateAddrs(
+      ["bitcoincash:qzl0x0982hy9xrh99wdnejx4eecdn02jv58as5p599"],
+      "bitcoin_cash",
+      false,
+    );
+    validateAddrs(["ltc1q3e4eh3lldvx97zg6d74x4ns6v5a4j4hwwqycww"], "litecoin", false);
+    validateAddrs(["Xh13o3cWixDBYJMGuJmFX17TZb9guXcBii"], "dash", false);
+    validateAddrs(["MFYvHZcZ35typC4k2XyvRVooCDZxnoDS44"], "qtum", false);
+    validateAddrs(["t1b1Rbw2shhJkP6MCnCyxCPuyFedHrwKtyy"], "zcash", false);
+    validateAddrs(["t3PU1j7YW3fJ67jUbkGySRto8qK2qXCUiW3"], "zcash", false);
+    validateAddrs(["AYRf8r4SJhmfaEwmWvY8ujmrepbrWyenFF"], "bitcoin_gold", false);
+    validateAddrs(["D8cMCRimfjwQ9E8jJvgUswt18WnZbCUAaa"], "dogecoin", false);
+    validateAddrs(["dgb1q7zjgqa23xzf602ljfrc94248a9u27xml08nhcc"], "digibyte", false);
+    validateAddrs(["REnTkuvjsmfshAZ3vukYfuS3ZGvfUatqFF"], "komodo", false);
+    validateAddrs(["DQ7F2iTQn6kUpyvietinaC3Cxje2m1ULjj"], "pivx", false);
+    validateAddrs(["zndVnjbrzRxvhPGRea4jgsfSWE1hXFja1dd"], "zencash", false);
+    validateAddrs(["3LQWwDEpgjjQokDusDXtoF9c8on8zr54ff"], "vertcoin", false);
+    validateAddrs(["PCYt39DMYuFqUYkP8w6ubZXJbTTL4c9KAA"], "peercoin", false);
+    validateAddrs(["ETx91CT52eBFYWbe4Yht5BpZNigWg2Ekqq"], "viacoin", false);
+    validateAddrs(["S6NMcEfYbavHrP3Uo1wbEUvKhAbKeMugaa"], "stealthcoin", false);
+    validateAddrs(["Dso59DoPRkfATcZgHGgff9mpku7taw9srAv"], "decred", false);
+    validateAddrs(["Dcck4QrFF5wuLQzpwxb5evhSRD7ZTsJZwuh"], "decred", false);
+  });
+});
+
+describe("Unit tests for maxTxSize", () => {
+  const btc = cryptoFactory("bitcoin_testnet");
+  it("Empty tx non-segwit", () => {
+    const s = utils.maxTxSizeCeil(0, [], false, btc, DerivationModes.LEGACY);
+    expect(s).toEqual(10);
+  });
+  it("Empty tx segwit", () => {
+    const s = utils.maxTxSizeCeil(0, [], false, btc, DerivationModes.NATIVE_SEGWIT);
+    expect(s).toEqual(11);
+  });
+  it("1 p2wpkh input 1 p2wpkh output", () => {});
+
+  const tr = "tb1pdedptfps5k6hmzars9ks93ejsujh28kw5dhe06gutt9svap40j8qql2dw2";
+  const sh = "2Mv9bnjkBUr1GfCybJc7XmnJ5VG4SAT3shT";
+  const pkh = "mkQiYQGCkCC7Wus3vfhfTDjgJzQK554evn";
+  const wpkh = "tb1qhff3j7euu6t3lv8s5gsy9t5x82wuhfw5z863gj";
+  const p2tr = DerivationModes.TAPROOT;
+  const p2sh = DerivationModes.SEGWIT;
+  const p2pkh = DerivationModes.LEGACY;
+  const p2wpkh = DerivationModes.NATIVE_SEGWIT;
+
+  test.each([
+    // In 148 out 34
+    [0, [], false, p2pkh, 10],
+    [0, [], true, p2pkh, 44],
+    [0, [btc.toOutputScript(pkh)], false, p2pkh, 44],
+    [0, [btc.toOutputScript(pkh)], true, p2pkh, 78],
+    [1, [btc.toOutputScript(pkh)], true, p2pkh, 226],
+    [2, [btc.toOutputScript(pkh)], true, p2pkh, 374],
+    [1, [btc.toOutputScript(wpkh)], true, p2pkh, 223],
+    [1, [btc.toOutputScript(sh)], true, p2pkh, 224],
+    [1, [btc.toOutputScript(tr)], true, p2pkh, 235],
+
+    // In 68 out 31
+    [0, [], false, p2wpkh, 11],
+    [0, [], true, p2wpkh, 42],
+    [1, [], false, p2wpkh, 79],
+    [1, [], true, p2wpkh, 110],
+    [2, [], true, p2wpkh, 178],
+
+    // In 90 out 32, scriptSig 22
+    [0, [], false, p2sh, 11],
+    [0, [], true, p2sh, 43],
+    [1, [], false, p2sh, 101],
+    [1, [btc.toOutputScript(sh)], false, p2sh, 133],
+    [2, [btc.toOutputScript(sh)], false, p2sh, 223],
+
+    // Fixed 10.5 In 57.75 out 43
+    [0, [], false, p2tr, 11],
+    [0, [], true, p2tr, 54],
+    [1, [], true, p2tr, Math.ceil(53.5 + 57.75 * 1)],
+    [2, [], true, p2tr, Math.ceil(53.5 + 57.75 * 2)],
+    [3, [], true, p2tr, Math.ceil(53.5 + 57.75 * 3)],
+
+    // 0xfc=252 inputs
+    [247, [], true, p2tr, Math.ceil(53.5 + 57.75 * 247)],
+    [248, [], true, p2tr, Math.ceil(53.5 + 57.75 * 248)],
+    [249, [], true, p2tr, Math.ceil(53.5 + 57.75 * 249)],
+    [250, [], true, p2tr, Math.ceil(53.5 + 57.75 * 250)],
+    [251, [], true, p2tr, Math.ceil(53.5 + 57.75 * 251)],
+    [252, [], true, p2tr, Math.ceil(53.5 + 57.75 * 252)],
+    // 0xfd=253 inputs will add 2 bytes for >= 0xfd
+    [253, [], true, p2tr, Math.ceil(53.5 + 57.75 * 253 + 2)],
+    [256 * 256 - 1, [], true, p2tr, Math.ceil(53.5 + 57.75 * (256 * 256 - 1) + 2)],
+    // 0xffff inputs will add 4 bytes
+    [256 * 256, [], true, p2tr, Math.ceil(53.5 + 57.75 * (256 * 256) + 4)],
+
+    // test address with witness version 16 and witness program [0x01, 0x02] => tb1sqypqyuzpgh
+    [
+      2,
+      [tr, sh, pkh, wpkh, "tb1sqypqyuzpgh"].map(addr => btc.toOutputScript(addr)),
+      false,
+      p2wpkh,
+      Math.ceil(10.5 + 68 * 2 + 43 + 32 + 34 + 31 + 13),
+    ],
+  ])("%i, %s, %s, %s => %i", (inputCount, outputScripts, useChange, derivationMode, exp) => {
+    const s = utils.maxTxSizeCeil(inputCount, outputScripts, useChange, btc, derivationMode);
+
+    expect(s).toEqual(exp);
+  });
+});

package/src/wallet-btc/__tests__/wallet.errorpropagation.integration.test.ts

@@ -0,0 +1,37 @@
+import { DerivationModes } from "../types";
+import BitcoinLikeWallet from "../wallet";
+import { getSecp256k1Instance, setSecp256k1Instance } from "../crypto/secp256k1";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+
+jest.setTimeout(180000);
+
+describe("testing resilience of failures", () => {
+  const wallet = new BitcoinLikeWallet();
+  const defaultImpl = getSecp256k1Instance();
+  it("should generate an account", async () => {
+    setSecp256k1Instance({
+      publicKeyTweakAdd: () => {
+        throw new Error("FAILCRYPTO");
+      },
+    });
+    try {
+      await expect(
+        wallet
+          .generateAccount(
+            {
+              xpub: "xpub6CV2NfQJYxHn7MbSQjQip3JMjTZGUbeoKz5xqkBftSZZPc7ssVPdjKrgh6N8U1zoQDxtSo6jLarYAQahpd35SJoUKokfqf1DZgdJWZhSMqP",
+              path: "44'/0'",
+              index: 0,
+              currency: "bitcoin",
+              network: "mainnet",
+              derivationMode: DerivationModes.LEGACY,
+            },
+            getCryptoCurrencyById("bitcoin"),
+          )
+          .then(a => wallet.syncAccount(a)),
+      ).rejects.toEqual(new Error("FAILCRYPTO"));
+    } finally {
+      setSecp256k1Instance(defaultImpl);
+    }
+  });
+});

package/src/wallet-btc/__tests__/wallet.estimateMaxSpendable.integration.test.ts

@@ -0,0 +1,51 @@
+import { DerivationModes } from "../types";
+import BitcoinLikeWallet from "../wallet";
+import * as utils from "../utils";
+import { Account } from "../account";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+
+describe("testing estimateMaxSpendable", () => {
+  const wallet = new BitcoinLikeWallet();
+  let account: Account;
+  it("should generate an account", async () => {
+    account = await wallet.generateAccount(
+      {
+        xpub: "xpub6CV2NfQJYxHn7MbSQjQip3JMjTZGUbeoKz5xqkBftSZZPc7ssVPdjKrgh6N8U1zoQDxtSo6jLarYAQahpd35SJoUKokfqf1DZgdJWZhSMqP",
+        path: "44'/0'",
+        index: 0,
+        currency: "bitcoin",
+        network: "mainnet",
+        derivationMode: DerivationModes.LEGACY,
+      },
+      getCryptoCurrencyById("bitcoin"),
+    );
+
+    expect(account.xpub.xpub).toEqual(
+      "xpub6CV2NfQJYxHn7MbSQjQip3JMjTZGUbeoKz5xqkBftSZZPc7ssVPdjKrgh6N8U1zoQDxtSo6jLarYAQahpd35SJoUKokfqf1DZgdJWZhSMqP",
+    );
+  });
+
+  it("should estimate max spendable correctly", async () => {
+    await wallet.syncAccount(account);
+    let maxSpendable = await wallet.estimateAccountMaxSpendable(account, 0, []);
+    const balance = 109088;
+    expect(maxSpendable.toNumber()).toEqual(balance);
+    const maxSpendableExcludeUtxo = await wallet.estimateAccountMaxSpendable(account, 0, [
+      {
+        hash: "f80246be50064bb254d2cad82fb0d4ce7768582b99c113694e72411f8032fd7a",
+        outputIndex: 0,
+      },
+    ]);
+    expect(maxSpendableExcludeUtxo.toNumber()).toEqual(balance - 1000);
+    let feesPerByte = 100;
+    maxSpendable = await wallet.estimateAccountMaxSpendable(account, feesPerByte, []);
+    expect(maxSpendable.toNumber()).toEqual(
+      balance -
+        feesPerByte *
+          utils.maxTxSizeCeil(2, [], true, account.xpub.crypto, account.xpub.derivationMode),
+    );
+    feesPerByte = 10000;
+    maxSpendable = await wallet.estimateAccountMaxSpendable(account, feesPerByte, []);
+    expect(maxSpendable.toNumber()).toEqual(0);
+  }, 120000);
+});

package/src/wallet-btc/__tests__/wallet.explorer.integration.test.ts

@@ -0,0 +1,40 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import BitcoinLikeExplorer from "../explorer";
+
+describe("Integration tests for bitcoin v4 explorer api", () => {
+  it("Test API for btc", async () => {
+    const explorer = new BitcoinLikeExplorer({
+      cryptoCurrency: getCryptoCurrencyById("bitcoin"),
+    });
+    const params = {
+      batch_size: 10000,
+    };
+    const txs = await explorer.fetchTxs(
+      {
+        account: 0,
+        index: 0,
+        address: "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+      },
+      params,
+    );
+    expect(txs.length).toBeGreaterThan(10);
+
+    const fees = await explorer.getFees();
+    expect(Object.keys(fees).length).toBeGreaterThan(3);
+
+    const block = await explorer.getBlockByHeight(10000);
+    expect(block?.hash).toEqual("0000000099c744455f58e6c6e98b671e1bf7f37346bfd4cf5d0274ad8ee660cb");
+    expect(block?.height).toEqual(10000);
+
+    const currentBlock = await explorer.getCurrentBlock();
+    expect(currentBlock?.height).toBeGreaterThan(10000);
+    expect(currentBlock?.hash.startsWith("0000")).toBeTruthy();
+
+    const hex = await explorer.getTxHex(
+      "8bae12b5f4c088d940733dcd1455efc6a3a69cf9340e17a981286d3778615684",
+    );
+    expect(hex).toEqual(
+      "0100000001c858ba5f607d762fe5be1dfe97ddc121827895c2562c4348d69d02b91dbb408e010000008b4830450220446df4e6b875af246800c8c976de7cd6d7d95016c4a8f7bcdbba81679cbda242022100c1ccfacfeb5e83087894aa8d9e37b11f5c054a75d030d5bfd94d17c5bc953d4a0141045901f6367ea950a5665335065342b952c5d5d60607b3cdc6c69a03df1a6b915aa02eb5e07095a2548a98dcdd84d875c6a3e130bafadfd45e694a3474e71405a4ffffffff020000000000000000156a13636861726c6579206c6f766573206865696469400d0300000000001976a914b8268ce4d481413c4e848ff353cd16104291c45b88ac00000000",
+    );
+  }, 60000);
+});

package/src/wallet-btc/__tests__/wallet.explorer.unit.test.ts

@@ -0,0 +1,192 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import BitcoinLikeExplorer from "../explorer";
+import network from "@ledgerhq/live-network/network";
+
+jest.mock("@ledgerhq/live-network/network");
+
+describe("BitcoinApi", () => {
+  let explorer: BitcoinLikeExplorer;
+  beforeEach(() => {
+    explorer = new BitcoinLikeExplorer({
+      cryptoCurrency: getCryptoCurrencyById("bitcoin"),
+    });
+  });
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("fetchTxs unit test", () => {
+    beforeEach(() => {
+      // @ts-expect-error method is mocked
+      network.mockResolvedValue({
+        data: {
+          data: [
+            {
+              id: "e50d0ca77b4584a9feca88886e174f2863252e3488185826b6b7a3c25c9de659",
+              hash: "e50d0ca77b4584a9feca88886e174f2863252e3488185826b6b7a3c25c9de659",
+              received_at: "2023-05-03T08:17:57Z",
+              lock_time: 0,
+              fees: "21304",
+              inputs: [
+                {
+                  output_hash: "214d4ee98c074bf4bc6e91c669f02a581d9a6d5a5e9476b05a3fccde508dfdfc",
+                  output_index: 17,
+                  input_index: 0,
+                  value: "130000",
+                  address: "bc1p4hdgsumm299ncy53g5xxlexsex0qqj0sl0flr5hp7d5q6xskw7rqq3srjc",
+                  script_signature: "",
+                  txinwitness: [
+                    "bf23e6252bdaf8c15da8a5c5338b58a4747fd27fd37c2cb50efb8b76c58f7517047f4cda36befe2ee4d3c643e14ecf40e11602b9cfdb991f925b514e7ef001e8",
+                  ],
+                  sequence: 4294967293,
+                },
+              ],
+              outputs: [
+                {
+                  output_index: 0,
+                  value: "30000",
+                  address: "bc1pd85hsqr75rg6fwwd8kmftd3tv26tgp3spkfmn4uga6t5xsv2talqmzqt0h",
+                  script_hex:
+                    "512069e978007ea0d1a4b9cd3db695b62b62b4b406300d93b9d788ee9743418a5f7e",
+                },
+                {
+                  output_index: 1,
+                  value: "78696",
+                  address: "bc1p4hdgsumm299ncy53g5xxlexsex0qqj0sl0flr5hp7d5q6xskw7rqq3srjc",
+                  script_hex:
+                    "5120adda88737b514b3c1291450c6fe4d0c99e0049f0fbd3f1d2e1f3680d1a167786",
+                },
+              ],
+              block: {
+                hash: "0000000000000000000059c005bc8689ef7c4935034c201f94a0ef54d60b8aac",
+                height: 788060,
+                time: "2023-05-03T08:17:57Z",
+              },
+              confirmations: 920,
+            },
+            {
+              id: "c842f547338a6c0e9c27ddd2b6afc5944c6b9401926579ad7897257ad7cd3c80",
+              hash: "c842f547338a6c0e9c27ddd2b6afc5944c6b9401926579ad7897257ad7cd3c80",
+              received_at: "2023-05-03T08:17:57Z",
+              lock_time: 0,
+              fees: "25208",
+              inputs: [
+                {
+                  output_hash: "e50d0ca77b4584a9feca88886e174f2863252e3488185826b6b7a3c25c9de659",
+                  output_index: 0,
+                  input_index: 0,
+                  value: "30000",
+                  address: "bc1pd85hsqr75rg6fwwd8kmftd3tv26tgp3spkfmn4uga6t5xsv2talqmzqt0h",
+                  script_signature: "",
+                  txinwitness: [
+                    "ca817c52fdb82530b15e3f35ca336257f69f649ca1b987aefe445d9ec2004e0dd475725b3d1c3496a5d82c4cc3af0119f94e3400d165c271b60865a05faea1e0",
+                    "20117f692257b2331233b5705ce9c682be8719ff1b2b64cbca290bd6faeb54423eac0619f5aee08701750063036f7264010118746578742f706c61696e3b636861727365743d7574662d3800357b2270223a226272632d3230222c226f70223a226d696e74222c227469636b223a2276646278222c22616d74223a2231303030227d68",
+                    "c1117f692257b2331233b5705ce9c682be8719ff1b2b64cbca290bd6faeb54423e",
+                  ],
+                  sequence: 4294967293,
+                },
+              ],
+              outputs: [
+                {
+                  output_index: 0,
+                  value: "546",
+                  address: "bc1p4hdgsumm299ncy53g5xxlexsex0qqj0sl0flr5hp7d5q6xskw7rqq3srjc",
+                  script_hex:
+                    "5120adda88737b514b3c1291450c6fe4d0c99e0049f0fbd3f1d2e1f3680d1a167786",
+                },
+                {
+                  output_index: 1,
+                  value: "4246",
+                  address: "bc1qrgt98epetd665p3the4qtsd7m30jdrte5g20k0",
+                  script_hex: "00141a1653e4395b75aa062bbe6a05c1bedc5f268d79",
+                },
+              ],
+              block: {
+                hash: "0000000000000000000059c005bc8689ef7c4935034c201f94a0ef54d60b8aac",
+                height: 788060,
+                time: "2023-05-03T08:17:57Z",
+              },
+              confirmations: 920,
+            },
+          ],
+          token: null,
+        },
+      });
+    });
+    it("fetchTxs api should return 2 transactions from explorer by using /address/${address.address}/txs endpoint", async () => {
+      const params = {
+        batch_size: 10000,
+      };
+      const txs = await explorer.fetchTxs(
+        {
+          account: 0,
+          index: 0,
+          address: "bc1pd85hsqr75rg6fwwd8kmftd3tv26tgp3spkfmn4uga6t5xsv2talqmzqt0h",
+        },
+        params,
+      );
+      expect(txs.length).toEqual(2);
+      expect(txs[0].inputs.length).toEqual(1);
+      expect(txs[0].outputs.length).toEqual(2);
+    });
+  });
+
+  describe("getFees unit test", () => {
+    beforeEach(() => {
+      // @ts-expect-error method is mocked
+      network.mockResolvedValue({
+        data: {
+          "2": 555985,
+          "4": 504992,
+          "6": 479059,
+          last_updated: 1683675584,
+        },
+      });
+    });
+    it("getFees api should return 3 fees(slow, median and fast) by using /fees endpoint", async () => {
+      const fees = await explorer.getFees();
+      expect(Object.keys(fees).length).toBeGreaterThan(3);
+      expect(fees["2"]).toEqual(555985);
+    });
+  });
+
+  describe("getCurrentBlock unit test", () => {
+    beforeEach(() => {
+      // @ts-expect-error method is mocked
+      network.mockResolvedValue({
+        data: {
+          hash: "00000000000000000003cbb024a4051d02e15df7c6c205493e23fa0c91ac6d03",
+          height: 788997,
+          time: "2023-05-09T23:20:52Z",
+          txs: ["f3a2aebc6cf6f27a04d95809a97b78e78a47b100672612eac07f17dd5ff56474"],
+        },
+      });
+    });
+    it("getCurrentBlock api should return block height and hash by using /block/current endpoint", async () => {
+      const currentBlock = await explorer.getCurrentBlock();
+      expect(currentBlock?.height).toEqual(788997);
+      expect(currentBlock?.hash).toEqual(
+        "00000000000000000003cbb024a4051d02e15df7c6c205493e23fa0c91ac6d03",
+      );
+    });
+  });
+
+  describe("broadcast unit test", () => {
+    beforeEach(() => {
+      // @ts-expect-error method is mocked
+      network.mockResolvedValue({
+        data: {
+          result: "f3a2aebc6cf6f27a04d95809a97b78e78a47b100672612eac07f17dd5ff56474",
+        },
+      });
+    });
+    it("broadcast api should return transaction hash by using /tx/send endpoint", async () => {
+      const tx = await explorer.broadcast(
+        "02000000000101f3a2aebc6cf6f27a04d95809a97b78e78a47b100672612eac07f17dd5ff564740000000000ffffffff02a0860100000000001600141a1653e4395b75aa062bbe6a05c1bedc5f268d790000000000000",
+      );
+      expect(tx.data.result).toEqual(
+        "f3a2aebc6cf6f27a04d95809a97b78e78a47b100672612eac07f17dd5ff56474",
+      );
+    });
+  });
+});