@ledgerhq/hw-app-btc 6.11.0 → 6.12.1

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,37 +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-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"}   
-`("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", "");
@@ -502,5 +526,10 @@ ${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32"} | ${true} | ${"ne
 //   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/newops/BtcNew.test.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable prettier/prettier */
 import { openTransportReplayer, RecordStore } from "@ledgerhq/hw-transport-mocker";
 import { TransportReplayer } from "@ledgerhq/hw-transport-mocker/lib/openTransportReplayer";
 import ecc from "tiny-secp256k1";
@@ -10,8 +9,8 @@ import {
   WalletPolicy
 } from "../../src/newops/policy";
 import { PsbtV2 } from "../../src/newops/psbtv2";
-import { AccountType, addressFormatFromDescriptorTemplate, creatDummyXpub, masterFingerprint, runSignTransaction, TestingClient } from "./integrationtools";
-import { CoreTx, p2pkh, p2tr, p2wpkh, p2wpkhTwoInputs, wrappedP2wpkh, wrappedP2wpkhTwoInputs } from "./testtx";
+import { StandardPurpose, addressFormatFromDescriptorTemplate, creatDummyXpub, masterFingerprint, runSignTransaction, TestingClient } from "./integrationtools";
+import { CoreInput, CoreTx, p2pkh, p2tr, p2wpkh, wrappedP2wpkh, wrappedP2wpkhTwoInputs } from "./testtx";
 
 test("getWalletPublicKey p2pkh", async () => {
   await testGetWalletPublicKey("m/44'/1'/0'", "pkh(@0)");
@@ -41,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",
@@ -51,48 +50,64 @@ function testPaths(type: AccountType): {ins: string[], out?: string} {
     basePath + "0/2",
     basePath + "1/2",
   ];
-  return {ins};
+  return { ins };
 }
 
 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(p2wpkhTwoInputs, AccountType.p2wpkh);
+  await runSignTransactionTest(p2wpkh, StandardPurpose.p2wpkh);
 });
 test("Sign p2tr", async () => {
-  await runSignTransactionTest(p2tr, AccountType.p2tr);
+  // This tx uses locktime, so this test verifies that locktime is propagated to/from
+  // the psbt correctly.
+  await runSignTransactionTest(p2tr, StandardPurpose.p2tr);
 });
 
-async function runSignTransactionTest(testTx: CoreTx, accountType: AccountType, changePubkey?: string) {
+test("Sign p2tr with sigHashType", async () => {
+  const testTx = JSON.parse(JSON.stringify(p2tr));
+  testTx.vin.forEach((input: CoreInput, index: number) => {
+    // Test SIGHASH_SINGLE | SIGHASH_ANYONECANPAY, 0x83
+    const sig = input.txinwitness![0] + "83";
+    input.txinwitness = [sig];
+  })
+  const tx = await runSignTransactionNoVerification(testTx, StandardPurpose.p2tr);
+  // The verification of the sighashtype is done in MockClient.signPsbt
+})
+
+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: StandardPurpose, changePubkey?: string): Promise<string> {
   const [client, transport] = await createClient();
   const accountXpub = "tpubDCwYjpDhUdPGP5rS3wgNg13mTrrjBuG8V9VpWbyptX6TRPbNoZVXsoVUSkCjmQ8jJycjuDKBb9eataSymXakTTaGifxR6kmVsfFehH1ZgJT";
   client.mockGetPubkeyResponse(`m/${accountType}/1'/0'`, accountXpub);
   const paths = testPaths(accountType);
   if (changePubkey) {
-    paths.out =  `m/${accountType}/1'/0'` + "/1/3";
+    paths.out = `m/${accountType}/1'/0'` + "/1/3";
     client.mockGetPubkeyResponse(paths.out, creatDummyXpub(Buffer.from(changePubkey, "hex")));
   }
   const tx = await runSignTransaction(testTx, paths, client, transport);
-  expect(tx).toEqual(testTx.hex);
   await transport.close();
+  return tx;
 }
 
-
 async function testGetWalletXpub(path: string, version = 0x043587cf) {
   const [client] = await createClient();
   const expectedXpub = "tpubDCwYjpDhUdPGP5rS3wgNg13mTrrjBuG8V9VpWbyptX6TRPbNoZVXsoVUSkCjmQ8jJycjuDKBb9eataSymXakTTaGifxR6kmVsfFehH1ZgJT";
   client.mockGetPubkeyResponse(path, expectedXpub);
   const btc = new BtcNew(client);
-  const result = await btc.getWalletXpub({path: path, xpubVersion: version});
+  const result = await btc.getWalletXpub({ path: path, xpubVersion: version });
   expect(result).toEqual(expectedXpub);
 }
 async function testGetWalletPublicKey(
@@ -119,7 +134,7 @@ async function testGetWalletPublicKey(
 
   const btcNew = new BtcNew(client);
   const addressFormat = addressFormatFromDescriptorTemplate(expectedDescriptorTemplate);
-  const result = await btcNew.getWalletPublicKey(path, {format: addressFormat});
+  const result = await btcNew.getWalletPublicKey(path, { format: addressFormat });
   verifyGetWalletPublicKeyResult(result, keyXpub, "testaddress");
 
   const resultAccount = await btcNew.getWalletPublicKey(accountPath);
@@ -195,11 +210,23 @@ class MockClient extends TestingClient {
     return masterFingerprint;
   }
   async signPsbt(
-    _psbt: PsbtV2,
+    psbt: PsbtV2,
     _walletPolicy: WalletPolicy,
-    _walletHMAC: Buffer | null
+    _walletHMAC: Buffer | null,
   ): Promise<Map<number, Buffer>> {
-    return this.yieldSigs.splice(0, 1)[0];
+    const sigs = this.yieldSigs.splice(0, 1)[0];
+    const sig0 = sigs.get(0)!;
+    if (sig0.length == 64) {
+      // Taproot may leave out sighash type, which defaults to 0x01 SIGHASH_ALL
+      return sigs;
+    }
+    const sigHashType = sig0.readUInt8(sig0.length - 1);
+    if (sigHashType != 0x01) {
+      for (let i = 0; i < psbt.getGlobalInputCount(); i++) {
+        expect(psbt.getInputSighashType(i)).toEqual(sigHashType);
+      }
+    }
+    return sigs;
   }
   private getWalletAddressKey(
     walletPolicy: WalletPolicy,

package/tests/newops/integrationtools.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable prettier/prettier */
 import Transport from "@ledgerhq/hw-transport";
 import bs58check from "bs58check";
 import Btc from "../../src/Btc";
@@ -10,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},
-  client: TestingClient, 
-  transport: Transport): Promise<string> {
+  testTx: CoreTx,
+  testPaths: { ins: string[]; out?: string },
+  client: TestingClient,
+  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[] = [];
@@ -38,35 +37,61 @@ 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);
+  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))));
-    outputWriter.writeVarSlice(Buffer.from(output.scriptPubKey.hex, "hex"));    
+  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 arg: CreateTransactionArg = {    
+  const outputScriptHex = outputWriter.buffer().toString("hex");
+  let callbacks = "";
+  function logCallback(message: string) {
+    callbacks += new Date().toISOString() + " " + message + "\n";
+  }
+  const arg: CreateTransactionArg = {
     inputs,
     additionals,
     associatedKeysets,
     changePath: testPaths.out,
     outputScriptHex,
     lockTime: testTx.locktime,
-    segwit: accountType != AccountType.p2pkh,    
+    sigHashType,
+    segwit: accountType != StandardPurpose.p2pkh,
+    onDeviceSignatureGranted: () => logCallback("CALLBACK: signature granted"),
+    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";
@@ -74,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) {    
-    return scriptSig.slice(scriptSig.length-33);
+  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) {
-    return scriptSig.slice(1, scriptSig.length-34);
+  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.");
@@ -118,46 +158,47 @@ 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]);
-  xpubDecoded.fill(pubkey33, xpubDecoded.length-33);
+  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, 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.");
   }
   const splitSpentTx = btc.splitTransaction(spentTx, true);
-  const scriptSig = coreInput.scriptSig;
-  let redeemScript;
-  if (scriptSig?.hex && scriptSig.hex.startsWith("160014")) {
-    redeemScript = scriptSig.hex.substring(2);
-  }
-  return [splitSpentTx, coreInput.vout, redeemScript, coreInput.sequence];
+  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[] = [];

package/tests/newops/testtx.ts

@@ -237,61 +237,6 @@ export const p2pkh: CoreTx = {
   "blocktime": 1633611385
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export const p2wpkhTwoInputs = {
-  "txid": "1913b7b5ffdcb5f32b9aca1f5eec2a189e7c66650f82b560eae211265fc995b7",
-  "hash": "c3439dcd3489373c586c7aed48c32f2b5d9c71aad24acd765a61684d98690a3f",
-  "version": 2,
-  "size": 388,
-  "vsize": 226,
-  "weight": 904,
-  "locktime": 0,
-  "vin": [
-    {
-      "txid": "5512d5788d4c26117f093de91223ef384c3fb22799810a92e3304bb6f0819224",
-      "vout": 1,
-      "scriptSig": {
-        "asm": "0014c1ac0d63d0258ea1b6fe90ef72d0c35d8d773dd3",
-        "hex": "160014c1ac0d63d0258ea1b6fe90ef72d0c35d8d773dd3"
-      },
-      "txinwitness": [
-        "30440220543617c5f4504dc29d34d2d06d0d7733dac4ec418b77c67feefb29f3f82ba3d80220690b784c52c3375f4ba9e64cc5c0aeb6a1b9fc6aadda0062905c06ce3bbba57501",
-        "02fb255ed920db5c2f507289202eb60a160e5a067ee7e30199a4ed81b74c22e441"
-      ],
-      "sequence": 4294967295
-    },
-    {
-      "txid": "28ad5054e029252d72da37f13fce66212d7f7763845b4a8c4aaf78e897b2bf9f",
-      "vout": 1,
-      "scriptSig": {
-        "asm": "0014c1ac0d63d0258ea1b6fe90ef72d0c35d8d773dd3",
-        "hex": "160014c1ac0d63d0258ea1b6fe90ef72d0c35d8d773dd3"
-      },
-      "txinwitness": [
-        "3044022049e7f3015a33ccdb015fe3891667564fd37111272df57e58447645c7bad8fed0022074d1e93ba946453896d0f0bc500df3a1e0d5bb5ad10cd9906736d5fbaebadd5801",
-        "02fb255ed920db5c2f507289202eb60a160e5a067ee7e30199a4ed81b74c22e441"
-      ],
-      "sequence": 4294967295
-    }
-  ],
-  "vout": [
-    {
-      "value": 0.01800000,
-      "n": 0,
-      "scriptPubKey": {
-        "asm": "OP_DUP OP_HASH160 f73384bcc3951ab6a75541ff79a9a51f82056ed8 OP_EQUALVERIFY OP_CHECKSIG",
-        "hex": "76a914f73384bcc3951ab6a75541ff79a9a51f82056ed888ac",
-        "address": "n442v1DrXQNim9gjjctKjyGVoe717hNdtG",
-        "type": "pubkeyhash"
-      }
-    }
-  ],
-  "hex": "02000000000102249281f0b64b30e3920a819927b23f4c38ef2312e93d097f11264c8d78d512550100000017160014c1ac0d63d0258ea1b6fe90ef72d0c35d8d773dd3ffffffff9fbfb297e878af4a8c4a5b8463777f2d2166ce3ff137da722d2529e05450ad280100000017160014c1ac0d63d0258ea1b6fe90ef72d0c35d8d773dd3ffffffff0140771b00000000001976a914f73384bcc3951ab6a75541ff79a9a51f82056ed888ac024730440220543617c5f4504dc29d34d2d06d0d7733dac4ec418b77c67feefb29f3f82ba3d80220690b784c52c3375f4ba9e64cc5c0aeb6a1b9fc6aadda0062905c06ce3bbba575012102fb255ed920db5c2f507289202eb60a160e5a067ee7e30199a4ed81b74c22e44102473044022049e7f3015a33ccdb015fe3891667564fd37111272df57e58447645c7bad8fed0022074d1e93ba946453896d0f0bc500df3a1e0d5bb5ad10cd9906736d5fbaebadd58012102fb255ed920db5c2f507289202eb60a160e5a067ee7e30199a4ed81b74c22e44100000000",
-  "blockhash": "00000000025a711e6cd4bce9138dc852232a4494afbf36d8bb80499a786da2a4",
-  "confirmations": 1,
-  "time": 1633944124,
-  "blocktime": 1633944124
-};
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export const wrappedP2wpkhTwoInputs = {
   "txid": "c03119b538c78f56c8ce2e6cc5fc6998d447eeef42e34c12692764a3f1a3da7c",
   "hash": "6b3812304554a6964e43a6971ac533046f4be101e39609f72179856916e20268",