@ledgerhq/hw-app-btc 6.11.1 → 6.11.2

package/src/newops/clientCommands.ts

@@ -1,4 +1,5 @@
 import { crypto } from "bitcoinjs-lib";
+import { BufferReader } from "../buffertools";
 import { createVarint } from "../varint";
 import { hashLeaf, Merkle } from "./merkle";
 import { MerkleMap } from "./merkleMap";
@@ -106,19 +107,24 @@ export class GetMerkleLeafProofCommand extends ClientCommand {
   execute(request: Buffer): Buffer {
     const req = request.subarray(1);
 
-    if (req.length != 32 + 4 + 4) {
-      throw new Error("Invalid request, unexpected trailing data");
+    if (req.length < 32 + 1 + 1) {
+      throw new Error("Invalid request, expected at least 34 bytes");
     }
 
-    // read the hash
-    const hash = Buffer.alloc(32);
-    for (let i = 0; i < 32; i++) {
-      hash[i] = req.readUInt8(i);
-    }
+    const reqBuf = new BufferReader(req);
+    const hash = reqBuf.readSlice(32);
     const hash_hex = hash.toString("hex");
 
-    const tree_size = req.readUInt32BE(32);
-    const leaf_index = req.readUInt32BE(32 + 4);
+    let tree_size;
+    let leaf_index;
+    try {
+      tree_size = reqBuf.readVarInt();
+      leaf_index = reqBuf.readVarInt();
+    } catch (e: any) {
+      throw new Error(
+        "Invalid request, couldn't parse tree_size or leaf_index"
+      );
+    }
 
     const mt = this.known_trees.get(hash_hex);
     if (!mt) {

package/tests/Btc.test.ts

@@ -469,6 +469,11 @@ ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32m"} | ${false} | ${"
 ${"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")

package/tests/newops/BtcNew.test.ts

@@ -9,7 +9,7 @@ import {
   WalletPolicy
 } from "../../src/newops/policy";
 import { PsbtV2 } from "../../src/newops/psbtv2";
-import { AccountType, addressFormatFromDescriptorTemplate, creatDummyXpub, masterFingerprint, runSignTransaction, TestingClient } from "./integrationtools";
+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 +40,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 +55,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 +79,16 @@ 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) {
+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

@@ -25,10 +25,10 @@ export async function runSignTransaction(
   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[] = [];
@@ -68,7 +68,7 @@ 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))
@@ -90,42 +90,42 @@ export function addressFormatFromDescriptorTemplate(descTemp: DefaultDescriptorT
   throw new Error();
 }
 
-export enum AccountType {
+export enum StandardPurpose {
   p2tr = "86'",
   p2wpkh = "84'",
   p2wpkhInP2sh = "49'",
   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,15 +134,15 @@ 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 {