@ledgerhq/hw-app-btc 6.11.2 → 6.15.1

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[] = [];