@ledgerhq/hw-app-btc 6.11.1 → 6.15.0

package/tests/newops/BtcNew.test.ts

@@ -9,7 +9,8 @@ import {
   WalletPolicy
 } from "../../src/newops/policy";
 import { PsbtV2 } from "../../src/newops/psbtv2";
-import { AccountType, addressFormatFromDescriptorTemplate, creatDummyXpub, masterFingerprint, runSignTransaction, TestingClient } from "./integrationtools";
+import { splitTransaction } from "../../src/splitTransaction";
+import { StandardPurpose, addressFormatFromDescriptorTemplate, creatDummyXpub, masterFingerprint, runSignTransaction, TestingClient } from "./integrationtools";
 import { CoreInput, CoreTx, p2pkh, p2tr, p2wpkh, wrappedP2wpkh, wrappedP2wpkhTwoInputs } from "./testtx";
 
 test("getWalletPublicKey p2pkh", async () => {
@@ -40,7 +41,7 @@ test("getWalletXpub normal path", async () => {
   await testGetWalletXpub("m/44'/0'/0'");
 });
 
-function testPaths(type: AccountType): { ins: string[], out?: string } {
+function testPaths(type: StandardPurpose): { ins: string[], out?: string } {
   const basePath = `m/${type}/1'/0'/`;
   const ins = [
     basePath + "0/0",
@@ -55,21 +56,21 @@ function testPaths(type: AccountType): { ins: string[], out?: string } {
 
 test("Sign p2pkh", async () => {
   const changePubkey = "037ed58c914720772c59f7a1e7e76fba0ef95d7c5667119798586301519b9ad2cf";
-  await runSignTransactionTest(p2pkh, AccountType.p2pkh, changePubkey);
+  await runSignTransactionTest(p2pkh, StandardPurpose.p2pkh, changePubkey);
 });
 test("Sign p2wpkh wrapped", async () => {
   let changePubkey = "03efc6b990c1626d08bd176aab0e545a4f55c627c7ddee878d12bbbc46a126177a";
-  await runSignTransactionTest(wrappedP2wpkh, AccountType.p2wpkhInP2sh, changePubkey);
+  await runSignTransactionTest(wrappedP2wpkh, StandardPurpose.p2wpkhInP2sh, changePubkey);
   changePubkey = "031175a985c56e310ce3496a819229b427a2172920fd20b5972dda62758c6def09";
-  await runSignTransactionTest(wrappedP2wpkhTwoInputs, AccountType.p2wpkhInP2sh, changePubkey);
+  await runSignTransactionTest(wrappedP2wpkhTwoInputs, StandardPurpose.p2wpkhInP2sh, changePubkey);
 });
 test("Sign p2wpkh", async () => {
-  await runSignTransactionTest(p2wpkh, AccountType.p2wpkh);
+  await runSignTransactionTest(p2wpkh, StandardPurpose.p2wpkh);
 });
 test("Sign p2tr", async () => {
   // This tx uses locktime, so this test verifies that locktime is propagated to/from
   // the psbt correctly.
-  await runSignTransactionTest(p2tr, AccountType.p2tr);
+  await runSignTransactionTest(p2tr, StandardPurpose.p2tr);
 });
 
 test("Sign p2tr with sigHashType", async () => {
@@ -79,16 +80,28 @@ test("Sign p2tr with sigHashType", async () => {
     const sig = input.txinwitness![0] + "83";
     input.txinwitness = [sig];
   })
-  const tx = await runSignTransactionNoVerification(testTx, AccountType.p2tr);
+  const tx = await runSignTransactionNoVerification(testTx, StandardPurpose.p2tr);
   // The verification of the sighashtype is done in MockClient.signPsbt
 })
 
-async function runSignTransactionTest(testTx: CoreTx, accountType: AccountType, changePubkey?: string) {
+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);
 }
 
-async function runSignTransactionNoVerification(testTx: CoreTx, accountType: AccountType, changePubkey?: string): Promise<string> {
+async function runSignTransactionNoVerification(testTx: CoreTx, accountType: StandardPurpose, changePubkey?: string): Promise<string> {
   const [client, transport] = await createClient();
   const accountXpub = "tpubDCwYjpDhUdPGP5rS3wgNg13mTrrjBuG8V9VpWbyptX6TRPbNoZVXsoVUSkCjmQ8jJycjuDKBb9eataSymXakTTaGifxR6kmVsfFehH1ZgJT";
   client.mockGetPubkeyResponse(`m/${accountType}/1'/0'`, accountXpub);

package/tests/newops/integrationtools.ts

@@ -9,26 +9,26 @@ 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);
   const accountType = getAccountType(testTx.vin[0], btc);
   const additionals: string[] = [];
-  if (accountType == AccountType.p2wpkh) {
+  if (accountType == StandardPurpose.p2wpkh) {
     additionals.push("bech32");
   }
-  if (accountType == AccountType.p2tr) {
+  if (accountType == StandardPurpose.p2tr) {
     additionals.push("bech32m");
   }
   const associatedKeysets: string[] = [];
@@ -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(
+      BigInt(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,
@@ -68,21 +76,22 @@ export async function runSignTransaction(
     outputScriptHex,
     lockTime: testTx.locktime,
     sigHashType,
-    segwit: accountType != AccountType.p2pkh,
+    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";
@@ -90,42 +99,57 @@ export function addressFormatFromDescriptorTemplate(descTemp: DefaultDescriptorT
   throw new Error();
 }
 
-export enum AccountType {
+export enum StandardPurpose {
   p2tr = "86'",
   p2wpkh = "84'",
   p2wpkhInP2sh = "49'",
-  p2pkh = "44'"
+  p2pkh = "44'",
 }
 
-function getPubkey(inputIndex: number, accountType: AccountType, 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 == AccountType.p2pkh) {
+  if (accountType == StandardPurpose.p2pkh) {
     return scriptSig.slice(scriptSig.length - 33);
   }
-  if (accountType == AccountType.p2tr) {
+  if (accountType == StandardPurpose.p2tr) {
     return spentTx.outputs![spentOutputIndex].script.slice(2, 34); // 32 bytes x-only pubkey
   }
-  if (accountType == AccountType.p2wpkh || accountType == AccountType.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: AccountType): Buffer {
+function getSignature(
+  testTxInput: CoreInput,
+  accountType: StandardPurpose
+): Buffer {
   const scriptSig = Buffer.from(testTxInput.scriptSig.hex, "hex");
-  if (accountType == AccountType.p2pkh) {
+  if (accountType == StandardPurpose.p2pkh) {
     return scriptSig.slice(1, scriptSig.length - 34);
   }
-  if (accountType == AccountType.p2tr) {
+  if (accountType == StandardPurpose.p2tr) {
     return Buffer.from(testTxInput.txinwitness![0], "hex");
   }
-  if (accountType == AccountType.p2wpkh || accountType == AccountType.p2wpkhInP2sh) {
+  if (
+    accountType == StandardPurpose.p2wpkh ||
+    accountType == StandardPurpose.p2wpkhInP2sh
+  ) {
     return Buffer.from(testTxInput.txinwitness![0], "hex");
   }
   throw new Error();
 }
 
-function getAccountType(coreInput: CoreInput, btc: Btc): AccountType {
+function getAccountType(coreInput: CoreInput, btc: Btc): StandardPurpose {
   const spentTx = spentTxs[coreInput.txid];
   if (!spentTx) {
     throw new Error("Spent tx " + coreInput.txid + " unavailable.");
@@ -134,25 +158,31 @@ function getAccountType(coreInput: CoreInput, btc: Btc): AccountType {
   const spentOutput = splitSpentTx.outputs![coreInput.vout];
   const script = spentOutput.script;
   if (script.length == 34 && script[0] == 0x51) {
-    return AccountType.p2tr;
+    return StandardPurpose.p2tr;
   }
   if (script.length == 22 && script[0] == 0x00) {
-    return AccountType.p2wpkh;
+    return StandardPurpose.p2wpkh;
   }
   if (script.length == 23) {
-    return AccountType.p2wpkhInP2sh;
+    return StandardPurpose.p2wpkhInP2sh;
   }
-  return AccountType.p2pkh;
+  return StandardPurpose.p2pkh;
 }
 
 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[] = [];