@ledgerhq/hw-app-btc 10.0.4 → 10.0.5-next.0

package/src/getAppAndVersion.ts

@@ -7,9 +7,7 @@ export type AppAndVersion = {
   flags: number | Buffer;
 };
 
-export const getAppAndVersion = async (
-  transport: Transport
-): Promise<AppAndVersion> => {
+export const getAppAndVersion = async (transport: Transport): Promise<AppAndVersion> => {
   const r = await transport.send(0xb0, 0x01, 0x00, 0x00);
   let i = 0;
   const format = r[i++];
@@ -27,9 +25,7 @@ export const getAppAndVersion = async (
   };
 };
 
-export const checkIsBtcLegacy = async (
-  transport: Transport
-): Promise<boolean> => {
+export const checkIsBtcLegacy = async (transport: Transport): Promise<boolean> => {
   try {
     // Call old btc API, it will throw an exception with new btc app. It is a workaround to differentiate new/old btc nano app
     await transport.send(0xe0, 0xc4, 0, 0);

package/src/getTrustedInput.ts

@@ -6,7 +6,7 @@ import { createVarint } from "./varint";
 export async function getTrustedInputRaw(
   transport: Transport,
   transactionData: Buffer,
-  indexLookup?: number | null | undefined
+  indexLookup?: number | null | undefined,
 ): Promise<string> {
   let data;
   let firstRound = false;
@@ -20,13 +20,7 @@ export async function getTrustedInputRaw(
     data = transactionData;
   }
 
-  const trustedInput = await transport.send(
-    0xe0,
-    0x42,
-    firstRound ? 0x00 : 0x80,
-    0x00,
-    data
-  );
+  const trustedInput = await transport.send(0xe0, 0x42, firstRound ? 0x00 : 0x80, 0x00, data);
   const res = trustedInput.slice(0, trustedInput.length - 2).toString("hex");
   return res;
 }
@@ -34,10 +28,9 @@ export async function getTrustedInput(
   transport: Transport,
   indexLookup: number,
   transaction: Transaction,
-  additionals: Array<string> = []
+  additionals: Array<string> = [],
 ): Promise<string> {
-  const { version, inputs, outputs, locktime, nExpiryHeight, extraData } =
-    transaction;
+  const { version, inputs, outputs, locktime, nExpiryHeight, extraData } = transaction;
 
   if (!outputs || !locktime) {
     throw new Error("getTrustedInput: locktime & outputs is expected");
@@ -53,16 +46,12 @@ export async function getTrustedInput(
 
     while (offset !== script.length) {
       const blockSize =
-        script.length - offset > MAX_SCRIPT_BLOCK
-          ? MAX_SCRIPT_BLOCK
-          : script.length - offset;
+        script.length - offset > MAX_SCRIPT_BLOCK ? MAX_SCRIPT_BLOCK : script.length - offset;
 
       if (offset + blockSize !== script.length) {
         scriptBlocks.push(script.slice(offset, offset + blockSize));
       } else {
-        scriptBlocks.push(
-          Buffer.concat([script.slice(offset, offset + blockSize), seq])
-        );
+        scriptBlocks.push(Buffer.concat([script.slice(offset, offset + blockSize), seq]));
       }
 
       offset += blockSize;
@@ -83,8 +72,7 @@ export async function getTrustedInput(
     return res;
   };
 
-  const processWholeScriptBlock = (block) =>
-    getTrustedInputRaw(transport, block);
+  const processWholeScriptBlock = block => getTrustedInputRaw(transport, block);
 
   await getTrustedInputRaw(
     transport,
@@ -94,16 +82,12 @@ export async function getTrustedInput(
       transaction.nVersionGroupId || Buffer.alloc(0),
       createVarint(inputs.length),
     ]),
-    indexLookup
+    indexLookup,
   );
 
   for (const input of inputs) {
-    const isXSTV2 =
-      isXST &&
-      Buffer.compare(version, Buffer.from([0x02, 0x00, 0x00, 0x00])) === 0;
-    const treeField = isDecred
-      ? input.tree || Buffer.from([0x00])
-      : Buffer.alloc(0);
+    const isXSTV2 = isXST && Buffer.compare(version, Buffer.from([0x02, 0x00, 0x00, 0x00])) === 0;
+    const treeField = isDecred ? input.tree || Buffer.from([0x00]) : Buffer.alloc(0);
     const data = Buffer.concat([
       input.prevout,
       treeField,
@@ -147,14 +131,10 @@ export async function getTrustedInput(
 
   if (endData.length) {
     const data = Buffer.concat(endData);
-    extraPart = isDecred
-      ? data
-      : Buffer.concat([createVarint(data.length), data]);
+    extraPart = isDecred ? data : Buffer.concat([createVarint(data.length), data]);
   }
 
-  const res = await processScriptBlocks(
-    Buffer.concat([locktime, extraPart || Buffer.alloc(0)])
-  );
+  const res = await processScriptBlocks(Buffer.concat([locktime, extraPart || Buffer.alloc(0)]));
   invariant(res, "missing result in processScriptBlocks");
   return res;
 }

package/src/getTrustedInputBIP143.ts

@@ -6,7 +6,7 @@ export function getTrustedInputBIP143(
   transport: Transport,
   indexLookup: number,
   transaction: Transaction,
-  additionals: Array<string> = []
+  additionals: Array<string> = [],
 ): string {
   if (!transaction) {
     throw new Error("getTrustedInputBIP143: missing tx");
@@ -19,9 +19,7 @@ export function getTrustedInputBIP143(
   }
 
   let hash = shajs("sha256")
-    .update(
-      shajs("sha256").update(serializeTransaction(transaction, true)).digest()
-    )
+    .update(shajs("sha256").update(serializeTransaction(transaction, true)).digest())
     .digest();
   const data = Buffer.alloc(4);
   data.writeUInt32LE(indexLookup, 0);

package/src/getWalletPublicKey.ts

@@ -4,12 +4,7 @@ import { bip32asBuffer } from "./bip32";
 /**
  * address format is one of legacy | p2sh | bech32 | cashaddr
  */
-export type AddressFormat =
-  | "legacy"
-  | "p2sh"
-  | "bech32"
-  | "bech32m"
-  | "cashaddr";
+export type AddressFormat = "legacy" | "p2sh" | "bech32" | "bech32m" | "cashaddr";
 const addressFormatMap = {
   legacy: 0,
   p2sh: 1,
@@ -22,7 +17,7 @@ export async function getWalletPublicKey(
     path: string;
     verify?: boolean;
     format?: AddressFormat;
-  }
+  },
 ): Promise<{
   publicKey: string;
   bitcoinAddress: string;
@@ -49,10 +44,7 @@ export async function getWalletPublicKey(
     .slice(1 + publicKeyLength + 1, 1 + publicKeyLength + 1 + addressLength)
     .toString("ascii");
   const chainCode = response
-    .slice(
-      1 + publicKeyLength + 1 + addressLength,
-      1 + publicKeyLength + 1 + addressLength + 32
-    )
+    .slice(1 + publicKeyLength + 1 + addressLength, 1 + publicKeyLength + 1 + addressLength + 32)
     .toString("hex");
   return {
     publicKey,

package/src/newops/accounttype.ts

@@ -1,14 +1,7 @@
 import { crypto } from "bitcoinjs-lib";
 import { pointAddScalar } from "tiny-secp256k1";
 import { BufferWriter } from "../buffertools";
-import {
-  HASH_SIZE,
-  OP_CHECKSIG,
-  OP_DUP,
-  OP_EQUAL,
-  OP_EQUALVERIFY,
-  OP_HASH160,
-} from "../constants";
+import { HASH_SIZE, OP_CHECKSIG, OP_DUP, OP_EQUAL, OP_EQUALVERIFY, OP_HASH160 } from "../constants";
 import { hashPublicKey } from "../hashPublicKey";
 import { DefaultDescriptorTemplate } from "./policy";
 import { PsbtV2 } from "./psbtv2";
@@ -51,7 +44,7 @@ export interface AccountType {
     inputTx: Buffer | undefined,
     spentOutput: SpentOutput,
     pubkeys: Buffer[],
-    pathElems: number[][]
+    pathElems: number[][],
   ): void;
 
   /**
@@ -63,12 +56,7 @@ export interface AccountType {
    * @param pubkeys The 33 byte ecdsa compressed public keys involved in this output
    * @param paths The paths corresponding to the pubkeys, in same order.
    */
-  setOwnOutput(
-    i: number,
-    cond: SpendingCondition,
-    pubkeys: Buffer[],
-    paths: number[][]
-  ): void;
+  setOwnOutput(i: number, cond: SpendingCondition, pubkeys: Buffer[], paths: number[][]): void;
 
   /**
    * Returns the descriptor template for this account type. Currently only
@@ -105,7 +93,7 @@ abstract class SingleKeyAccount extends BaseAccount {
     inputTx: Buffer | undefined,
     spentOutput: SpentOutput,
     pubkeys: Buffer[],
-    pathElems: number[][]
+    pathElems: number[][],
   ) {
     if (pubkeys.length != 1) {
       throw new Error("Expected single key, got " + pubkeys.length);
@@ -120,15 +108,10 @@ abstract class SingleKeyAccount extends BaseAccount {
     inputTx: Buffer | undefined,
     spentOutput: SpentOutput,
     pubkey: Buffer,
-    path: number[]
+    path: number[],
   );
 
-  setOwnOutput(
-    i: number,
-    cond: SpendingCondition,
-    pubkeys: Buffer[],
-    paths: number[][]
-  ) {
+  setOwnOutput(i: number, cond: SpendingCondition, pubkeys: Buffer[], paths: number[][]) {
     if (pubkeys.length != 1) {
       throw new Error("Expected single key, got " + pubkeys.length);
     }
@@ -141,7 +124,7 @@ abstract class SingleKeyAccount extends BaseAccount {
     i: number,
     cond: SpendingCondition,
     pubkey: Buffer,
-    path: number[]
+    path: number[],
   );
 }
 
@@ -160,7 +143,7 @@ export class p2pkh extends SingleKeyAccount {
     inputTx: Buffer | undefined,
     _spentOutput: SpentOutput,
     pubkey: Buffer,
-    path: number[]
+    path: number[],
   ) {
     if (!inputTx) {
       throw new Error("Full input base transaction required");
@@ -169,12 +152,7 @@ export class p2pkh extends SingleKeyAccount {
     this.psbt.setInputBip32Derivation(i, pubkey, this.masterFp, path);
   }
 
-  setSingleKeyOutput(
-    i: number,
-    cond: SpendingCondition,
-    pubkey: Buffer,
-    path: number[]
-  ) {
+  setSingleKeyOutput(i: number, cond: SpendingCondition, pubkey: Buffer, path: number[]) {
     this.psbt.setOutputBip32Derivation(i, pubkey, this.masterFp, path);
   }
 
@@ -198,23 +176,14 @@ export class p2tr extends SingleKeyAccount {
     _inputTx: Buffer | undefined,
     spentOutput: SpentOutput,
     pubkey: Buffer,
-    path: number[]
+    path: number[],
   ) {
     const xonly = pubkey.slice(1);
     this.psbt.setInputTapBip32Derivation(i, xonly, [], this.masterFp, path);
-    this.psbt.setInputWitnessUtxo(
-      i,
-      spentOutput.amount,
-      spentOutput.cond.scriptPubKey
-    );
+    this.psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.cond.scriptPubKey);
   }
 
-  setSingleKeyOutput(
-    i: number,
-    cond: SpendingCondition,
-    pubkey: Buffer,
-    path: number[]
-  ) {
+  setSingleKeyOutput(i: number, cond: SpendingCondition, pubkey: Buffer, path: number[]) {
     const xonly = pubkey.slice(1);
     this.psbt.setOutputTapBip32Derivation(i, xonly, [], this.masterFp, path);
   }
@@ -251,10 +220,7 @@ export class p2tr extends SingleKeyAccount {
     // the first byte, which represent the oddness/evenness. In schnorr all
     // pubkeys are even.
     // https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki#public-key-conversion
-    const evenEcdsaPubkey = Buffer.concat([
-      Buffer.from([0x02]),
-      internalPubkey,
-    ]);
+    const evenEcdsaPubkey = Buffer.concat([Buffer.from([0x02]), internalPubkey]);
     const tweak = this.hashTapTweak(internalPubkey);
 
     // Q = P + int(hash_TapTweak(bytes(P)))G
@@ -282,7 +248,7 @@ export class p2wpkhWrapped extends SingleKeyAccount {
     inputTx: Buffer | undefined,
     spentOutput: SpentOutput,
     pubkey: Buffer,
-    path: number[]
+    path: number[],
   ) {
     if (!inputTx) {
       throw new Error("Full input base transaction required");
@@ -292,30 +258,18 @@ export class p2wpkhWrapped extends SingleKeyAccount {
 
     const userSuppliedRedeemScript = spentOutput.cond.redeemScript;
     const expectedRedeemScript = this.createRedeemScript(pubkey);
-    if (
-      userSuppliedRedeemScript &&
-      !expectedRedeemScript.equals(userSuppliedRedeemScript)
-    ) {
+    if (userSuppliedRedeemScript && !expectedRedeemScript.equals(userSuppliedRedeemScript)) {
       // At what point might a user set the redeemScript on its own?
       throw new Error(`User-supplied redeemScript ${userSuppliedRedeemScript.toString(
-        "hex"
+        "hex",
       )} doesn't
        match expected ${expectedRedeemScript.toString("hex")} for input ${i}`);
     }
     this.psbt.setInputRedeemScript(i, expectedRedeemScript);
-    this.psbt.setInputWitnessUtxo(
-      i,
-      spentOutput.amount,
-      spentOutput.cond.scriptPubKey
-    );
+    this.psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.cond.scriptPubKey);
   }
 
-  setSingleKeyOutput(
-    i: number,
-    cond: SpendingCondition,
-    pubkey: Buffer,
-    path: number[]
-  ) {
+  setSingleKeyOutput(i: number, cond: SpendingCondition, pubkey: Buffer, path: number[]) {
     this.psbt.setOutputRedeemScript(i, cond.redeemScript!);
     this.psbt.setOutputBip32Derivation(i, pubkey, this.masterFp, path);
   }
@@ -344,26 +298,17 @@ export class p2wpkh extends SingleKeyAccount {
     inputTx: Buffer | undefined,
     spentOutput: SpentOutput,
     pubkey: Buffer,
-    path: number[]
+    path: number[],
   ) {
     if (!inputTx) {
       throw new Error("Full input base transaction required");
     }
     this.psbt.setInputNonWitnessUtxo(i, inputTx);
     this.psbt.setInputBip32Derivation(i, pubkey, this.masterFp, path);
-    this.psbt.setInputWitnessUtxo(
-      i,
-      spentOutput.amount,
-      spentOutput.cond.scriptPubKey
-    );
+    this.psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.cond.scriptPubKey);
   }
 
-  setSingleKeyOutput(
-    i: number,
-    cond: SpendingCondition,
-    pubkey: Buffer,
-    path: number[]
-  ) {
+  setSingleKeyOutput(i: number, cond: SpendingCondition, pubkey: Buffer, path: number[]) {
     this.psbt.setOutputBip32Derivation(i, pubkey, this.masterFp, path);
   }
 

package/src/newops/appClient.ts

@@ -38,16 +38,9 @@ export class AppClient {
   private async makeRequest(
     ins: BitcoinIns,
     data: Buffer,
-    cci?: ClientCommandInterpreter
+    cci?: ClientCommandInterpreter,
   ): Promise<Buffer> {
-    let response: Buffer = await this.transport.send(
-      CLA_BTC,
-      ins,
-      0,
-      0,
-      data,
-      [0x9000, 0xe000]
-    );
+    let response: Buffer = await this.transport.send(CLA_BTC, ins, 0, 0, data, [0x9000, 0xe000]);
     while (response.readUInt16BE(response.length - 2) === 0xe000) {
       if (!cci) {
         throw new Error("Unexpected SW_INTERRUPTED_EXECUTION");
@@ -62,25 +55,19 @@ export class AppClient {
         0,
         0,
         commandResponse,
-        [0x9000, 0xe000]
+        [0x9000, 0xe000],
       );
     }
     return response.slice(0, -2); // drop the status word (can only be 0x9000 at this point)
   }
 
-  async getExtendedPubkey(
-    display: boolean,
-    pathElements: number[]
-  ): Promise<string> {
+  async getExtendedPubkey(display: boolean, pathElements: number[]): Promise<string> {
     if (pathElements.length > 6) {
       throw new Error("Path too long. At most 6 levels allowed.");
     }
     const response = await this.makeRequest(
       BitcoinIns.GET_PUBKEY,
-      Buffer.concat([
-        Buffer.from(display ? [1] : [0]),
-        pathElementsToBuffer(pathElements),
-      ])
+      Buffer.concat([Buffer.from(display ? [1] : [0]), pathElementsToBuffer(pathElements)]),
     );
     return response.toString("ascii");
   }
@@ -90,10 +77,9 @@ export class AppClient {
     walletHMAC: Buffer | null,
     change: number,
     addressIndex: number,
-    display: boolean
+    display: boolean,
   ): Promise<string> {
-    if (change !== 0 && change !== 1)
-      throw new Error("Change can only be 0 or 1");
+    if (change !== 0 && change !== 1) throw new Error("Change can only be 0 or 1");
     if (addressIndex < 0 || !Number.isInteger(addressIndex))
       throw new Error("Invalid address index");
 
@@ -102,9 +88,7 @@ export class AppClient {
     }
 
     const clientInterpreter = new ClientCommandInterpreter(() => {});
-    clientInterpreter.addKnownList(
-      walletPolicy.keys.map((k) => Buffer.from(k, "ascii"))
-    );
+    clientInterpreter.addKnownList(walletPolicy.keys.map(k => Buffer.from(k, "ascii")));
     clientInterpreter.addKnownPreimage(walletPolicy.serialize());
 
     const addressIndexBuffer = Buffer.alloc(4);
@@ -119,7 +103,7 @@ export class AppClient {
         Buffer.from([change]),
         addressIndexBuffer,
       ]),
-      clientInterpreter
+      clientInterpreter,
     );
 
     return response.toString("ascii");
@@ -129,7 +113,7 @@ export class AppClient {
     psbt: PsbtV2,
     walletPolicy: WalletPolicy,
     walletHMAC: Buffer | null,
-    progressCallback: () => void
+    progressCallback: () => void,
   ): Promise<Map<number, Buffer>> {
     const merkelizedPsbt = new MerkelizedPsbt(psbt);
 
@@ -140,9 +124,7 @@ export class AppClient {
     const clientInterpreter = new ClientCommandInterpreter(progressCallback);
 
     // prepare ClientCommandInterpreter
-    clientInterpreter.addKnownList(
-      walletPolicy.keys.map((k) => Buffer.from(k, "ascii"))
-    );
+    clientInterpreter.addKnownList(walletPolicy.keys.map(k => Buffer.from(k, "ascii")));
     clientInterpreter.addKnownPreimage(walletPolicy.serialize());
 
     clientInterpreter.addKnownMapping(merkelizedPsbt.globalMerkleMap);
@@ -155,11 +137,11 @@ export class AppClient {
 
     clientInterpreter.addKnownList(merkelizedPsbt.inputMapCommitments);
     const inputMapsRoot = new Merkle(
-      merkelizedPsbt.inputMapCommitments.map((m) => hashLeaf(m))
+      merkelizedPsbt.inputMapCommitments.map(m => hashLeaf(m)),
     ).getRoot();
     clientInterpreter.addKnownList(merkelizedPsbt.outputMapCommitments);
     const outputMapsRoot = new Merkle(
-      merkelizedPsbt.outputMapCommitments.map((m) => hashLeaf(m))
+      merkelizedPsbt.outputMapCommitments.map(m => hashLeaf(m)),
     ).getRoot();
 
     await this.makeRequest(
@@ -173,7 +155,7 @@ export class AppClient {
         walletPolicy.getWalletId(),
         walletHMAC || Buffer.alloc(32, 0),
       ]),
-      clientInterpreter
+      clientInterpreter,
     );
 
     const yielded = clientInterpreter.getYielded();
@@ -204,16 +186,12 @@ export class AppClient {
     }
 
     clientInterpreter.addKnownList(chunks);
-    const chunksRoot = new Merkle(chunks.map((m) => hashLeaf(m))).getRoot();
+    const chunksRoot = new Merkle(chunks.map(m => hashLeaf(m))).getRoot();
 
     const response = await this.makeRequest(
       BitcoinIns.SIGN_MESSAGE,
-      Buffer.concat([
-        pathElementsToBuffer(pathElements),
-        createVarint(message.length),
-        chunksRoot,
-      ]),
-      clientInterpreter
+      Buffer.concat([pathElementsToBuffer(pathElements), createVarint(message.length), chunksRoot]),
+      clientInterpreter,
     );
 
     return response.toString("base64");

package/src/newops/clientCommands.ts

@@ -121,9 +121,7 @@ export class GetMerkleLeafProofCommand extends ClientCommand {
       tree_size = reqBuf.readVarInt();
       leaf_index = reqBuf.readVarInt();
     } catch (e: any) {
-      throw new Error(
-        "Invalid request, couldn't parse tree_size or leaf_index"
-      );
+      throw new Error("Invalid request, couldn't parse tree_size or leaf_index");
     }
 
     const mt = this.known_trees.get(hash_hex);
@@ -136,17 +134,12 @@ export class GetMerkleLeafProofCommand extends ClientCommand {
     }
 
     if (this.queue.length != 0) {
-      throw Error(
-        "This command should not execute when the queue is not empty."
-      );
+      throw Error("This command should not execute when the queue is not empty.");
     }
 
     const proof = mt.getProof(leaf_index);
 
-    const n_response_elements = Math.min(
-      Math.floor((255 - 32 - 1 - 1) / 32),
-      proof.length
-    );
+    const n_response_elements = Math.min(Math.floor((255 - 32 - 1 - 1) / 32), proof.length);
     const n_leftover_elements = proof.length - n_response_elements;
 
     // Add to the queue any proof elements that do not fit the response
@@ -196,9 +189,7 @@ export class GetMerkleLeafIndexCommand extends ClientCommand {
 
     const mt = this.known_trees.get(root_hash_hex);
     if (!mt) {
-      throw Error(
-        `Requested Merkle leaf index for unknown root: ${root_hash_hex}`
-      );
+      throw Error(`Requested Merkle leaf index for unknown root: ${root_hash_hex}`);
     }
 
     let leaf_index = 0;
@@ -235,9 +226,9 @@ export class GetMoreElementsCommand extends ClientCommand {
 
     // all elements should have the same length
     const element_len = this.queue[0].length;
-    if (this.queue.some((el) => el.length != element_len)) {
+    if (this.queue.some(el => el.length != element_len)) {
       throw new Error(
-        "The queue contains elements with different byte length, which is not expected"
+        "The queue contains elements with different byte length, which is not expected",
       );
     }
 
@@ -309,7 +300,7 @@ export class ClientCommandInterpreter {
       const preimage = Buffer.concat([Buffer.from([0]), el]);
       this.addKnownPreimage(preimage);
     }
-    const mt = new Merkle(elements.map((el) => hashLeaf(el)));
+    const mt = new Merkle(elements.map(el => hashLeaf(el)));
     this.roots.set(mt.getRoot().toString("hex"), mt);
   }
 

package/src/newops/merkelizedPsbt.ts

@@ -24,22 +24,14 @@ export class MerkelizedPsbt extends PsbtV2 {
     this.globalMerkleMap = MerkelizedPsbt.createMerkleMap(this.globalMap);
 
     for (let i = 0; i < this.getGlobalInputCount(); i++) {
-      this.inputMerkleMaps.push(
-        MerkelizedPsbt.createMerkleMap(this.inputMaps[i])
-      );
+      this.inputMerkleMaps.push(MerkelizedPsbt.createMerkleMap(this.inputMaps[i]));
     }
-    this.inputMapCommitments = [...this.inputMerkleMaps.values()].map((v) =>
-      v.commitment()
-    );
+    this.inputMapCommitments = [...this.inputMerkleMaps.values()].map(v => v.commitment());
 
     for (let i = 0; i < this.getGlobalOutputCount(); i++) {
-      this.outputMerkleMaps.push(
-        MerkelizedPsbt.createMerkleMap(this.outputMaps[i])
-      );
+      this.outputMerkleMaps.push(MerkelizedPsbt.createMerkleMap(this.outputMaps[i]));
     }
-    this.outputMapCommitments = [...this.outputMerkleMaps.values()].map((v) =>
-      v.commitment()
-    );
+    this.outputMapCommitments = [...this.outputMerkleMaps.values()].map(v => v.commitment());
   }
   // These public functions are for MerkelizedPsbt.
   getGlobalSize(): number {
@@ -51,14 +43,14 @@ export class MerkelizedPsbt extends PsbtV2 {
 
   private static createMerkleMap(map: Map<string, Buffer>): MerkleMap {
     const sortedKeysStrings = [...map.keys()].sort();
-    const values = sortedKeysStrings.map((k) => {
+    const values = sortedKeysStrings.map(k => {
       const v = map.get(k);
       if (!v) {
         throw new Error("No value for key " + k);
       }
       return v;
     });
-    const sortedKeys = sortedKeysStrings.map((k) => Buffer.from(k, "hex"));
+    const sortedKeys = sortedKeysStrings.map(k => Buffer.from(k, "hex"));
 
     const merkleMap = new MerkleMap(sortedKeys, values);
     return merkleMap;

package/src/newops/merkle.ts

@@ -10,10 +10,7 @@ export class Merkle {
   private rootNode: Node;
   private leafNodes: Node[];
   private h: (buf: Buffer) => Buffer;
-  constructor(
-    leaves: Buffer[],
-    hasher: (buf: Buffer) => Buffer = crypto.sha256
-  ) {
+  constructor(leaves: Buffer[], hasher: (buf: Buffer) => Buffer = crypto.sha256) {
     this.leaves = leaves;
     this.h = hasher;
     const nodes = this.calculateRoot(leaves);
@@ -68,16 +65,12 @@ export class Merkle {
 
 export function hashLeaf(
   buf: Buffer,
-  hashFunction: (buf: Buffer) => Buffer = crypto.sha256
+  hashFunction: (buf: Buffer) => Buffer = crypto.sha256,
 ): Buffer {
   return hashConcat(Buffer.from([0]), buf, hashFunction);
 }
 
-function hashConcat(
-  bufA: Buffer,
-  bufB: Buffer,
-  hashFunction: (buf: Buffer) => Buffer
-): Buffer {
+function hashConcat(bufA: Buffer, bufB: Buffer, hashFunction: (buf: Buffer) => Buffer): Buffer {
   return hashFunction(Buffer.concat([bufA, bufB]));
 }
 

package/src/newops/merkleMap.ts

@@ -33,9 +33,9 @@ export class MerkleMap {
     }
 
     this.keys = keys;
-    this.keysTree = new Merkle(keys.map((k) => hashLeaf(k)));
+    this.keysTree = new Merkle(keys.map(k => hashLeaf(k)));
     this.values = values;
-    this.valuesTree = new Merkle(values.map((v) => hashLeaf(v)));
+    this.valuesTree = new Merkle(values.map(v => hashLeaf(v)));
   }
 
   commitment(): Buffer {