@ledgerhq/hw-app-btc 6.12.0 → 6.17.0

package/tests/Btc.test.ts

@@ -106,14 +106,24 @@ ascii(1NjiCsVBuKDT62LmaUd7WZZZBK2gPAkisb)
 8bd937d416de7020952cc8e2c99ce9ac7e01265e31ceb8e47bf9c37f46f8abbd
 */
   /*eslint-disable */
-  const pubkeyParent = "045d4a72237572a91e13818fa38cedabe6174569cc9a319012f75150d5c0a0639d54eafd13a68d079b7a67764800c6a981825ef52384f08c3925109188ab21bc09";
-  const addrParent = Buffer.from("1NjiCsVBuKDT62LmaUd7WZZZBK2gPAkisb", "ascii").toString("hex");
-  const ccParent = "8bd937d416de7020952cc8e2c99ce9ac7e01265e31ceb8e47bf9c37f46f8abbd";
+  const pubkeyParent =
+    "045d4a72237572a91e13818fa38cedabe6174569cc9a319012f75150d5c0a0639d54eafd13a68d079b7a67764800c6a981825ef52384f08c3925109188ab21bc09";
+  const addrParent = Buffer.from(
+    "1NjiCsVBuKDT62LmaUd7WZZZBK2gPAkisb",
+    "ascii"
+  ).toString("hex");
+  const ccParent =
+    "8bd937d416de7020952cc8e2c99ce9ac7e01265e31ceb8e47bf9c37f46f8abbd";
   const responseParent = `41${pubkeyParent}22${addrParent}${ccParent}`;
 
-  const pubkeyAcc = "04250dfdfb84c1efd160ed0e10ebac845d0e4b04277174630ba56de96bbd3afb21fc6c04ce0d5a0cbd784fdabc99d16269c27cf3842fe8440f1f21b8af900f0eaa";
-  const addrAcc = Buffer.from("16Y97ByhyboePhTYMMmFj1tq5Cy1bDq8jT", "ascii").toString("hex");
-  const ccAcc = "c071c6f2d05cbc9ea9a04951b238086ce1608cf00020c3cab85b36aac5fdd591";
+  const pubkeyAcc =
+    "04250dfdfb84c1efd160ed0e10ebac845d0e4b04277174630ba56de96bbd3afb21fc6c04ce0d5a0cbd784fdabc99d16269c27cf3842fe8440f1f21b8af900f0eaa";
+  const addrAcc = Buffer.from(
+    "16Y97ByhyboePhTYMMmFj1tq5Cy1bDq8jT",
+    "ascii"
+  ).toString("hex");
+  const ccAcc =
+    "c071c6f2d05cbc9ea9a04951b238086ce1608cf00020c3cab85b36aac5fdd591";
   /*eslint-enable */
   const responseAcc = `41${pubkeyAcc}22${addrAcc}${ccAcc}`;
   const transport = await openTransportReplayer(
@@ -123,7 +133,7 @@ ascii(1NjiCsVBuKDT62LmaUd7WZZZBK2gPAkisb)
     => e040000009028000002c80000000
     <= ${responseParent}9000
     => e04000000d038000002c8000000080000011
-    <= ${responseAcc}9000  
+    <= ${responseAcc}9000
     `)
   );
   const btc = new Btc(transport);
@@ -430,7 +440,7 @@ test("signMessage", async () => {
 function testBackend(s: string): any {
   return async () => {
     return { publicKey: s, bitcoinAddress: "", chainCode: "" };
-  }
+  };
 }
 
 class TestBtc extends Btc {
@@ -461,43 +471,51 @@ class TestBtc extends Btc {
 // });
 
 test.each`
-app          | ver          | path             | format       | display | exp
-${"Bitcoin"} | ${"1.99.99"} | ${"m/44'/0'/1'"} | ${"bech32m"} | ${false} | ${""}
-${"Bitcoin"} | ${"1.99.99"} | ${"m/44'/0'"} | ${"bech32m"} | ${false} | ${""}
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'"} | ${"bech32m"} | ${false} | ${"new"}
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32m"} | ${false} | ${"new"}
-${"Bitcoin"} | ${"2.0.0-beta"} | ${"m/84'/1'/0'"} | ${"bech32"} | ${false} | ${"new"}
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'"} | ${"bech32"} | ${false} | ${"new"}
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32"} | ${undefined} | ${"old"}   
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32"} | ${true} | ${"new"}   
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/0/0"} | ${"bech32"} | ${false} | ${"new"}   
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/1/0"} | ${"bech32"} | ${false} | ${"new"}   
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/1/0"} | ${"legacy"} | ${false} | ${"new"}   
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/1/0"} | ${"p2sh"} | ${false} | ${"new"}   
-${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/2/0"} | ${"bech32"} | ${false} | ${"old"}
-`("dispatch $app $ver $path $format $display to $exp", async ({ app, ver, path, format, display, exp }) => {
-  const appName = Buffer.of(app.length)
-    .toString("hex")
-    .concat(Buffer.from(app, "ascii").toString("hex"));
-  const appVersion = Buffer.of(ver.length)
-    .toString("hex")
-    .concat(Buffer.from(ver, "ascii").toString("hex"));
-  const resp = `01${appName}${appVersion}01029000`;
-  const tr = await openTransportReplayer(RecordStore.fromString(`=> b001000000\n <= ${resp}`));
-  const btc = new TestBtc(tr);
-  try {
-    const key = await btc.getWalletPublicKey(path, { format: format, verify: display });
-    if (exp === "") {
-      expect(1).toEqual(0); // Allways fail. Don't know how to do that properly
-    }
-    expect(key.publicKey).toEqual(exp);
-  } catch (e: any) {
-    if (exp != "") {
-      throw e;
+  app          | ver               | path                 | format       | display      | exp
+  ${"Bitcoin"} | ${"1.99.99"}      | ${"m/44'/0'/1'"}     | ${"bech32m"} | ${false}     | ${""}
+  ${"Bitcoin"} | ${"1.99.99"}      | ${"m/44'/0'"}        | ${"bech32m"} | ${false}     | ${""}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'"}     | ${"bech32m"} | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"}        | ${"bech32m"} | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-beta"}   | ${"m/84'/1'/0'"}     | ${"bech32"}  | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'"}     | ${"bech32"}  | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"}        | ${"bech32"}  | ${undefined} | ${"old"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"}        | ${"bech32"}  | ${true}      | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/0/0"} | ${"bech32"}  | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/1/0"} | ${"bech32"}  | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/1/0"} | ${"legacy"}  | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/1/0"} | ${"p2sh"}    | ${false}     | ${"new"}
+  ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/2/0"} | ${"bech32"}  | ${false}     | ${"old"}
+`(
+  "dispatch $app $ver $path $format $display to $exp",
+  async ({ app, ver, path, format, display, exp }) => {
+    const appName = Buffer.from([app.length])
+      .toString("hex")
+      .concat(Buffer.from(app, "ascii").toString("hex"));
+    const appVersion = Buffer.from([ver.length])
+      .toString("hex")
+      .concat(Buffer.from(ver, "ascii").toString("hex"));
+    const resp = `01${appName}${appVersion}01029000`;
+    const tr = await openTransportReplayer(
+      RecordStore.fromString(`=> b001000000\n <= ${resp}`)
+    );
+    const btc = new TestBtc(tr);
+    try {
+      const key = await btc.getWalletPublicKey(path, {
+        format: format,
+        verify: display,
+      });
+      if (exp === "") {
+        expect(1).toEqual(0); // Allways fail. Don't know how to do that properly
+      }
+      expect(key.publicKey).toEqual(exp);
+    } catch (e: any) {
+      if (exp != "") {
+        throw e;
+      }
+      expect(exp).toEqual("");
     }
-    expect(exp).toEqual("");
   }
-})
+);
 
 // test("getWalletPublicKey compatibility for internal hardened keys", async () => {
 //   await testDispatch("Bitcoin", "1.99.99", "m/44'/0'/1'", "bech32m", "");
@@ -508,5 +526,10 @@ ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'/2/0"} | ${"bech32"} | ${false}
 //   await testDispatch("Bitcoin", "2.0.0-alpha1", "m/44'/0'", "bech32", "old");
 // });
 
-async function testDispatch(name: string, version: string, path: string, addressFormat: AddressFormat | undefined, exp: string): Promise<void> {
-}
+async function testDispatch(
+  name: string,
+  version: string,
+  path: string,
+  addressFormat: AddressFormat | undefined,
+  exp: string
+): Promise<void> {}

package/tests/buffertools.test.ts

@@ -0,0 +1,25 @@
+import { BufferReader, BufferWriter } from "../src/buffertools"
+
+function run(n: number, expectedHex: string) {
+  const w = new BufferWriter();
+  w.writeUInt64(n)
+  expect(w.buffer()).toEqual(Buffer.from(expectedHex, "hex"));
+  const r = new BufferReader(w.buffer());
+  expect(r.readUInt64()).toEqual(n);
+}
+
+test("Test 64 bit numbers", () => {
+  run(0, "0000000000000000");
+  run(1, "0100000000000000");
+  run(0xffffffff,   "ffffffff00000000");
+  run(0x0100000000, "0000000001000000");
+  run(0x010203040506, "0605040302010000");
+  run(Number.MAX_SAFE_INTEGER, "FFFFFFFFFFFF1F00");
+})
+
+test("Too big 64 bit number", () => {
+  const w = new BufferWriter();
+  expect(() => w.writeUInt64(Number.MAX_SAFE_INTEGER+1)).toThrow();
+  const r = new BufferReader(Buffer.from("FFFFFFFFFFFF2000", "hex"))
+  expect(() => r.readUInt64()).toThrow();
+})

package/tests/newops/BtcNew.test.ts

@@ -9,6 +9,7 @@ import {
   WalletPolicy
 } from "../../src/newops/policy";
 import { PsbtV2 } from "../../src/newops/psbtv2";
+import { splitTransaction } from "../../src/splitTransaction";
 import { StandardPurpose, addressFormatFromDescriptorTemplate, creatDummyXpub, masterFingerprint, runSignTransaction, TestingClient } from "./integrationtools";
 import { CoreInput, CoreTx, p2pkh, p2tr, p2wpkh, wrappedP2wpkh, wrappedP2wpkhTwoInputs } from "./testtx";
 
@@ -83,6 +84,18 @@ test("Sign p2tr with sigHashType", async () => {
   // The verification of the sighashtype is done in MockClient.signPsbt
 })
 
+test("Sign p2tr sequence 0", async() => {
+  const testTx = JSON.parse(JSON.stringify(p2tr));
+  testTx.vin.forEach((input: CoreInput, index: number) => {
+    input.sequence = 0;
+  })
+  const tx = await runSignTransactionNoVerification(testTx, StandardPurpose.p2tr);
+  const txObj = splitTransaction(tx, true);
+  txObj.inputs.forEach((input, index) => {
+    expect(input.sequence.toString("hex")).toEqual("00000000");
+  })
+})
+
 async function runSignTransactionTest(testTx: CoreTx, accountType: StandardPurpose, changePubkey?: string) {
   const tx = await runSignTransactionNoVerification(testTx, accountType, changePubkey);
   expect(tx).toEqual(testTx.hex);

package/tests/newops/integrationtools.ts

@@ -9,17 +9,17 @@ import { AddressFormat } from "../../src/getWalletPublicKey";
 import { AppClient } from "../../src/newops/appClient";
 import {
   DefaultDescriptorTemplate,
-  WalletPolicy
+  WalletPolicy,
 } from "../../src/newops/policy";
 import { Transaction } from "../../src/types";
 import { CoreInput, CoreTx, spentTxs } from "./testtx";
 
-
 export async function runSignTransaction(
   testTx: CoreTx,
-  testPaths: { ins: string[], out?: string },
+  testPaths: { ins: string[]; out?: string },
   client: TestingClient,
-  transport: Transport): Promise<string> {
+  transport: Transport
+): Promise<string> {
   const btcNew = new BtcNew(client);
   // btc is needed to perform some functions like splitTransaction.
   const btc = new Btc(transport);
@@ -37,30 +37,38 @@ export async function runSignTransaction(
     const path = testPaths.ins[index];
     associatedKeysets.push(path);
     const inputData = createInput(input, btc);
-    const pubkey = getPubkey(index, accountType, testTx, inputData[0], inputData[1]);
+    const pubkey = getPubkey(
+      index,
+      accountType,
+      testTx,
+      inputData[0],
+      inputData[1]
+    );
     const mockXpub = creatDummyXpub(pubkey);
     client.mockGetPubkeyResponse(path, mockXpub);
     yieldSigs.set(index, getSignature(input, accountType));
     return inputData;
   });
   const sig0 = yieldSigs.get(0)!;
-  let sigHashType: number | undefined = sig0.readUInt8(sig0.length - 1)
+  let sigHashType: number | undefined = sig0.readUInt8(sig0.length - 1);
   if (sigHashType == 0x01) {
     sigHashType = undefined;
   }
   client.mockSignPsbt(yieldSigs);
   const outputWriter = new BufferWriter();
   outputWriter.writeVarInt(testTx.vout.length);
-  testTx.vout.forEach(output => {
-    outputWriter.writeUInt64(BigInt(Number.parseFloat((output.value * 100000000).toFixed(8))));
+  testTx.vout.forEach((output) => {
+    outputWriter.writeUInt64(
+      Number.parseFloat((output.value * 100000000).toFixed(8))
+    );
     outputWriter.writeVarSlice(Buffer.from(output.scriptPubKey.hex, "hex"));
   });
-  const outputScriptHex = outputWriter.buffer().toString("hex");  
+  const outputScriptHex = outputWriter.buffer().toString("hex");
   let callbacks = "";
   function logCallback(message: string) {
     callbacks += new Date().toISOString() + " " + message + "\n";
   }
-  const arg: CreateTransactionArg = {    
+  const arg: CreateTransactionArg = {
     inputs,
     additionals,
     associatedKeysets,
@@ -70,19 +78,20 @@ export async function runSignTransaction(
     sigHashType,
     segwit: accountType != StandardPurpose.p2pkh,
     onDeviceSignatureGranted: () => logCallback("CALLBACK: signature granted"),
-    onDeviceSignatureRequested: () => logCallback("CALLBACK: signature requested"),
-    onDeviceStreaming: (arg) => logCallback("CALLBACK: " + JSON.stringify(arg))
+    onDeviceSignatureRequested: () =>
+      logCallback("CALLBACK: signature requested"),
+    onDeviceStreaming: (arg) => logCallback("CALLBACK: " + JSON.stringify(arg)),
   };
   logCallback("Start createPaymentTransactionNew");
   const tx = await btcNew.createPaymentTransactionNew(arg);
   logCallback("Done createPaymentTransactionNew");
   // console.log(callbacks);
   return tx;
-};
-
-
+}
 
-export function addressFormatFromDescriptorTemplate(descTemp: DefaultDescriptorTemplate): AddressFormat {
+export function addressFormatFromDescriptorTemplate(
+  descTemp: DefaultDescriptorTemplate
+): AddressFormat {
   if (descTemp == "tr(@0)") return "bech32m";
   if (descTemp == "pkh(@0)") return "legacy";
   if (descTemp == "wpkh(@0)") return "bech32";
@@ -94,10 +103,16 @@ export enum StandardPurpose {
   p2tr = "86'",
   p2wpkh = "84'",
   p2wpkhInP2sh = "49'",
-  p2pkh = "44'"
+  p2pkh = "44'",
 }
 
-function getPubkey(inputIndex: number, accountType: StandardPurpose, testTx: CoreTx, spentTx: Transaction, spentOutputIndex: number): Buffer {
+function getPubkey(
+  inputIndex: number,
+  accountType: StandardPurpose,
+  testTx: CoreTx,
+  spentTx: Transaction,
+  spentOutputIndex: number
+): Buffer {
   const scriptSig = Buffer.from(testTx.vin[inputIndex].scriptSig.hex, "hex");
   if (accountType == StandardPurpose.p2pkh) {
     return scriptSig.slice(scriptSig.length - 33);
@@ -105,13 +120,19 @@ function getPubkey(inputIndex: number, accountType: StandardPurpose, testTx: Cor
   if (accountType == StandardPurpose.p2tr) {
     return spentTx.outputs![spentOutputIndex].script.slice(2, 34); // 32 bytes x-only pubkey
   }
-  if (accountType == StandardPurpose.p2wpkh || accountType == StandardPurpose.p2wpkhInP2sh) {
+  if (
+    accountType == StandardPurpose.p2wpkh ||
+    accountType == StandardPurpose.p2wpkhInP2sh
+  ) {
     return Buffer.from(testTx.vin[inputIndex].txinwitness![1], "hex");
   }
   throw new Error();
 }
 
-function getSignature(testTxInput: CoreInput, accountType: StandardPurpose): Buffer {
+function getSignature(
+  testTxInput: CoreInput,
+  accountType: StandardPurpose
+): Buffer {
   const scriptSig = Buffer.from(testTxInput.scriptSig.hex, "hex");
   if (accountType == StandardPurpose.p2pkh) {
     return scriptSig.slice(1, scriptSig.length - 34);
@@ -119,7 +140,10 @@ function getSignature(testTxInput: CoreInput, accountType: StandardPurpose): Buf
   if (accountType == StandardPurpose.p2tr) {
     return Buffer.from(testTxInput.txinwitness![0], "hex");
   }
-  if (accountType == StandardPurpose.p2wpkh || accountType == StandardPurpose.p2wpkhInP2sh) {
+  if (
+    accountType == StandardPurpose.p2wpkh ||
+    accountType == StandardPurpose.p2wpkhInP2sh
+  ) {
     return Buffer.from(testTxInput.txinwitness![0], "hex");
   }
   throw new Error();
@@ -146,13 +170,19 @@ function getAccountType(coreInput: CoreInput, btc: Btc): StandardPurpose {
 }
 
 export function creatDummyXpub(pubkey: Buffer): string {
-  const xpubDecoded = bs58check.decode("tpubDHcN44A4UHqdHJZwBxgTbu8Cy87ZrZkN8tQnmJGhcijHqe4rztuvGcD4wo36XSviLmiqL5fUbDnekYaQ7LzAnaqauBb9RsyahsTTFHdeJGd");
-  const pubkey33 = pubkey.length == 33 ? pubkey : Buffer.concat([Buffer.of(2), pubkey]);
+  const xpubDecoded = bs58check.decode(
+    "tpubDHcN44A4UHqdHJZwBxgTbu8Cy87ZrZkN8tQnmJGhcijHqe4rztuvGcD4wo36XSviLmiqL5fUbDnekYaQ7LzAnaqauBb9RsyahsTTFHdeJGd"
+  );
+  const pubkey33 =
+    pubkey.length == 33 ? pubkey : Buffer.concat([Buffer.from([2]), pubkey]);
   xpubDecoded.fill(pubkey33, xpubDecoded.length - 33);
   return bs58check.encode(xpubDecoded);
 }
 
-function createInput(coreInput: CoreInput, btc: Btc): [Transaction, number, string | null, number] {
+function createInput(
+  coreInput: CoreInput,
+  btc: Btc
+): [Transaction, number, string | null, number] {
   const spentTx = spentTxs[coreInput.txid];
   if (!spentTx) {
     throw new Error("Spent tx " + coreInput.txid + " unavailable.");
@@ -161,14 +191,14 @@ function createInput(coreInput: CoreInput, btc: Btc): [Transaction, number, stri
   return [splitSpentTx, coreInput.vout, null, coreInput.sequence];
 }
 
-export const masterFingerprint = Buffer.of(1, 2, 3, 4);
+export const masterFingerprint = Buffer.from([1, 2, 3, 4]);
 export class TestingClient extends AppClient {
-  mockGetPubkeyResponse(_pathElements: string, _response: string): void { };
+  mockGetPubkeyResponse(_pathElements: string, _response: string): void {}
   mockGetWalletAddressResponse(
     _walletPolicy: WalletPolicy,
     _change: number,
     _addressIndex: number,
     _response: string
-  ): void { };
-  mockSignPsbt(_yieldSigs: Map<number, Buffer>): void { };
+  ): void {}
+  mockSignPsbt(_yieldSigs: Map<number, Buffer>): void {}
 }

package/tests/newops/merkle.test.ts

@@ -3,7 +3,7 @@ function testHasher(buf: Buffer): Buffer {
   return Buffer.from(buf);
 }
 function leaf(n: number) {
-  return Buffer.of(0, n);
+  return Buffer.from([0, n]);
 }
 function merkleOf(count: number): Merkle {
   const leaves: Buffer[] = [];