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

package/src/newops/policy.ts

@@ -3,11 +3,7 @@ import { pathArrayToString } from "../bip32";
 import { BufferWriter } from "../buffertools";
 import { hashLeaf, Merkle } from "./merkle";
 
-export type DefaultDescriptorTemplate =
-  | "pkh(@0)"
-  | "sh(wpkh(@0))"
-  | "wpkh(@0)"
-  | "tr(@0)";
+export type DefaultDescriptorTemplate = "pkh(@0)" | "sh(wpkh(@0))" | "wpkh(@0)" | "tr(@0)";
 
 /**
  * The Bitcon hardware app uses a descriptors-like thing to describe
@@ -34,10 +30,10 @@ export class WalletPolicy {
   }
 
   serialize(): Buffer {
-    const keyBuffers = this.keys.map((k) => {
+    const keyBuffers = this.keys.map(k => {
       return Buffer.from(k, "ascii");
     });
-    const m = new Merkle(keyBuffers.map((k) => hashLeaf(k)));
+    const m = new Merkle(keyBuffers.map(k => hashLeaf(k)));
 
     const buf = new BufferWriter();
     buf.writeUInt8(0x01); // wallet type (policy map)
@@ -48,13 +44,7 @@ export class WalletPolicy {
   }
 }
 
-export function createKey(
-  masterFingerprint: Buffer,
-  path: number[],
-  xpub: string
-): string {
+export function createKey(masterFingerprint: Buffer, path: number[], xpub: string): string {
   const accountPath = pathArrayToString(path);
-  return `[${masterFingerprint.toString("hex")}${accountPath.substring(
-    1
-  )}]${xpub}/**`;
+  return `[${masterFingerprint.toString("hex")}${accountPath.substring(1)}]${xpub}/**`;
 }

package/src/newops/psbtFinalizer.ts

@@ -26,9 +26,7 @@ export function finalize(psbt: PsbtV2): void {
     }
     if (legacyPubkeys.length > 0) {
       if (legacyPubkeys.length > 1) {
-        throw Error(
-          `Expected exactly one signature, got ${legacyPubkeys.length}`
-        );
+        throw Error(`Expected exactly one signature, got ${legacyPubkeys.length}`);
       }
       if (taprootSig) {
         throw Error("Both taproot and non-taproot signatures present.");
@@ -38,8 +36,7 @@ export function finalize(psbt: PsbtV2): void {
       const redeemScript = psbt.getInputRedeemScript(i);
       const isWrappedSegwit = !!redeemScript;
       const signature = psbt.getInputPartialSig(i, legacyPubkeys[0]);
-      if (!signature)
-        throw new Error("Expected partial signature for input " + i);
+      if (!signature) throw new Error("Expected partial signature for input " + i);
       if (isSegwitV0) {
         const witnessBuf = new BufferWriter();
         witnessBuf.writeVarInt(2);
@@ -50,9 +47,7 @@ export function finalize(psbt: PsbtV2): void {
         psbt.setInputFinalScriptwitness(i, witnessBuf.buffer());
         if (isWrappedSegwit) {
           if (!redeemScript || redeemScript.length == 0) {
-            throw new Error(
-              "Expected non-empty redeemscript. Can't finalize intput " + i
-            );
+            throw new Error("Expected non-empty redeemscript. Can't finalize intput " + i);
           }
           const scriptSigBuf = new BufferWriter();
           // Push redeemScript length

package/src/newops/psbtv2.ts

@@ -1,11 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import {
-  BufferReader,
-  BufferWriter,
-  unsafeFrom64bitLE,
-  unsafeTo64bitLE,
-} from "../buffertools";
+import { BufferReader, BufferWriter, unsafeFrom64bitLE, unsafeTo64bitLE } from "../buffertools";
 
 export enum psbtGlobal {
   TX_VERSION = 0x02,
@@ -75,9 +70,7 @@ export class PsbtV2 {
     this.setGlobal(psbtGlobal.FALLBACK_LOCKTIME, uint32LE(locktime));
   }
   getGlobalFallbackLocktime(): number | undefined {
-    return this.getGlobalOptional(psbtGlobal.FALLBACK_LOCKTIME)?.readUInt32LE(
-      0
-    );
+    return this.getGlobalOptional(psbtGlobal.FALLBACK_LOCKTIME)?.readUInt32LE(0);
   }
   setGlobalInputCount(inputCount: number) {
     this.setGlobal(psbtGlobal.INPUT_COUNT, varint(inputCount));
@@ -110,19 +103,13 @@ export class PsbtV2 {
   getInputNonWitnessUtxo(inputIndex: number): Buffer | undefined {
     return this.getInputOptional(inputIndex, psbtIn.NON_WITNESS_UTXO, b());
   }
-  setInputWitnessUtxo(
-    inputIndex: number,
-    amount: Buffer,
-    scriptPubKey: Buffer
-  ) {
+  setInputWitnessUtxo(inputIndex: number, amount: Buffer, scriptPubKey: Buffer) {
     const buf = new BufferWriter();
     buf.writeSlice(amount);
     buf.writeVarSlice(scriptPubKey);
     this.setInput(inputIndex, psbtIn.WITNESS_UTXO, b(), buf.buffer());
   }
-  getInputWitnessUtxo(
-    inputIndex: number
-  ): { amount: Buffer; scriptPubKey: Buffer } | undefined {
+  getInputWitnessUtxo(inputIndex: number): { amount: Buffer; scriptPubKey: Buffer } | undefined {
     const utxo = this.getInputOptional(inputIndex, psbtIn.WITNESS_UTXO, b());
     if (!utxo) return undefined;
     const buf = new BufferReader(utxo);
@@ -152,26 +139,21 @@ export class PsbtV2 {
     inputIndex: number,
     pubkey: Buffer,
     masterFingerprint: Buffer,
-    path: number[]
+    path: number[],
   ) {
-    if (pubkey.length != 33)
-      throw new Error("Invalid pubkey length: " + pubkey.length);
+    if (pubkey.length != 33) throw new Error("Invalid pubkey length: " + pubkey.length);
     this.setInput(
       inputIndex,
       psbtIn.BIP32_DERIVATION,
       pubkey,
-      this.encodeBip32Derivation(masterFingerprint, path)
+      this.encodeBip32Derivation(masterFingerprint, path),
     );
   }
   getInputBip32Derivation(
     inputIndex: number,
-    pubkey: Buffer
+    pubkey: Buffer,
   ): { masterFingerprint: Buffer; path: number[] } | undefined {
-    const buf = this.getInputOptional(
-      inputIndex,
-      psbtIn.BIP32_DERIVATION,
-      pubkey
-    );
+    const buf = this.getInputOptional(inputIndex, psbtIn.BIP32_DERIVATION, pubkey);
     if (!buf) return undefined;
     return this.decodeBip32Derivation(buf);
   }
@@ -203,11 +185,7 @@ export class PsbtV2 {
     this.setInput(inputIndex, psbtIn.SEQUENCE, b(), uint32LE(sequence));
   }
   getInputSequence(inputIndex: number): number {
-    return (
-      this.getInputOptional(inputIndex, psbtIn.SEQUENCE, b())?.readUInt32LE(
-        0
-      ) ?? 0xffffffff
-    );
+    return this.getInputOptional(inputIndex, psbtIn.SEQUENCE, b())?.readUInt32LE(0) ?? 0xffffffff;
   }
   setInputTapKeySig(inputIndex: number, sig: Buffer) {
     this.setInput(inputIndex, psbtIn.TAP_KEY_SIG, b(), sig);
@@ -220,16 +198,15 @@ export class PsbtV2 {
     pubkey: Buffer,
     hashes: Buffer[],
     masterFingerprint: Buffer,
-    path: number[]
+    path: number[],
   ) {
-    if (pubkey.length != 32)
-      throw new Error("Invalid pubkey length: " + pubkey.length);
+    if (pubkey.length != 32) throw new Error("Invalid pubkey length: " + pubkey.length);
     const buf = this.encodeTapBip32Derivation(hashes, masterFingerprint, path);
     this.setInput(inputIndex, psbtIn.TAP_BIP32_DERIVATION, pubkey, buf);
   }
   getInputTapBip32Derivation(
     inputIndex: number,
-    pubkey: Buffer
+    pubkey: Buffer,
   ): { hashes: Buffer[]; masterFingerprint: Buffer; path: number[] } {
     const buf = this.getInput(inputIndex, psbtIn.TAP_BIP32_DERIVATION, pubkey);
     return this.decodeTapBip32Derivation(buf);
@@ -248,18 +225,18 @@ export class PsbtV2 {
     outputIndex: number,
     pubkey: Buffer,
     masterFingerprint: Buffer,
-    path: number[]
+    path: number[],
   ) {
     this.setOutput(
       outputIndex,
       psbtOut.BIP_32_DERIVATION,
       pubkey,
-      this.encodeBip32Derivation(masterFingerprint, path)
+      this.encodeBip32Derivation(masterFingerprint, path),
     );
   }
   getOutputBip32Derivation(
     outputIndex: number,
-    pubkey: Buffer
+    pubkey: Buffer,
   ): { masterFingerprint: Buffer; path: number[] } {
     const buf = this.getOutput(outputIndex, psbtOut.BIP_32_DERIVATION, pubkey);
     return this.decodeBip32Derivation(buf);
@@ -282,20 +259,16 @@ export class PsbtV2 {
     pubkey: Buffer,
     hashes: Buffer[],
     fingerprint: Buffer,
-    path: number[]
+    path: number[],
   ) {
     const buf = this.encodeTapBip32Derivation(hashes, fingerprint, path);
     this.setOutput(outputIndex, psbtOut.TAP_BIP32_DERIVATION, pubkey, buf);
   }
   getOutputTapBip32Derivation(
     outputIndex: number,
-    pubkey: Buffer
+    pubkey: Buffer,
   ): { hashes: Buffer[]; masterFingerprint: Buffer; path: number[] } {
-    const buf = this.getOutput(
-      outputIndex,
-      psbtOut.TAP_BIP32_DERIVATION,
-      pubkey
-    );
+    const buf = this.getOutput(outputIndex, psbtOut.TAP_BIP32_DERIVATION, pubkey);
     return this.decodeTapBip32Derivation(buf);
   }
 
@@ -327,10 +300,10 @@ export class PsbtV2 {
     const buf = new BufferWriter();
     buf.writeSlice(Buffer.from([0x70, 0x73, 0x62, 0x74, 0xff]));
     serializeMap(buf, this.globalMap);
-    this.inputMaps.forEach((map) => {
+    this.inputMaps.forEach(map => {
       serializeMap(buf, map);
     });
-    this.outputMaps.forEach((map) => {
+    this.outputMaps.forEach(map => {
       serializeMap(buf, map);
     });
     return buf.buffer();
@@ -372,7 +345,7 @@ export class PsbtV2 {
   }
   private isKeyType(hexKey: string, keyTypes: KeyType[]): boolean {
     const keyType = Buffer.from(hexKey.substring(0, 2), "hex").readUInt8(0);
-    return keyTypes.some((k) => k == keyType);
+    return keyTypes.some(k => k == keyType);
   }
   private setGlobal(keyType: KeyType, value: Buffer) {
     const key = new Key(keyType, Buffer.from([]));
@@ -384,39 +357,22 @@ export class PsbtV2 {
   private getGlobalOptional(keyType: KeyType): Buffer | undefined {
     return get(this.globalMap, keyType, b(), true);
   }
-  private setInput(
-    index: number,
-    keyType: KeyType,
-    keyData: Buffer,
-    value: Buffer
-  ) {
+  private setInput(index: number, keyType: KeyType, keyData: Buffer, value: Buffer) {
     set(this.getMap(index, this.inputMaps), keyType, keyData, value);
   }
   private getInput(index: number, keyType: KeyType, keyData: Buffer): Buffer {
     return get(this.inputMaps[index], keyType, keyData, false)!;
   }
-  private getInputOptional(
-    index: number,
-    keyType: KeyType,
-    keyData: Buffer
-  ): Buffer | undefined {
+  private getInputOptional(index: number, keyType: KeyType, keyData: Buffer): Buffer | undefined {
     return get(this.inputMaps[index], keyType, keyData, true);
   }
-  private setOutput(
-    index: number,
-    keyType: KeyType,
-    keyData: Buffer,
-    value: Buffer
-  ) {
+  private setOutput(index: number, keyType: KeyType, keyData: Buffer, value: Buffer) {
     set(this.getMap(index, this.outputMaps), keyType, keyData, value);
   }
   private getOutput(index: number, keyType: KeyType, keyData: Buffer): Buffer {
     return get(this.outputMaps[index], keyType, keyData, false)!;
   }
-  private getMap(
-    index: number,
-    maps: Map<string, Buffer>[]
-  ): Map<string, Buffer> {
+  private getMap(index: number, maps: Map<string, Buffer>[]): Map<string, Buffer> {
     if (maps[index]) {
       return maps[index];
     }
@@ -434,13 +390,9 @@ export class PsbtV2 {
     const buf = new BufferReader(buffer);
     return this.readBip32Derivation(buf);
   }
-  private writeBip32Derivation(
-    buf: BufferWriter,
-    masterFingerprint: Buffer,
-    path: number[]
-  ) {
+  private writeBip32Derivation(buf: BufferWriter, masterFingerprint: Buffer, path: number[]) {
     buf.writeSlice(masterFingerprint);
-    path.forEach((element) => {
+    path.forEach(element => {
       buf.writeUInt32(element);
     });
   }
@@ -458,11 +410,11 @@ export class PsbtV2 {
   private encodeTapBip32Derivation(
     hashes: Buffer[],
     masterFingerprint: Buffer,
-    path: number[]
+    path: number[],
   ): Buffer {
     const buf = new BufferWriter();
     buf.writeVarInt(hashes.length);
-    hashes.forEach((h) => {
+    hashes.forEach(h => {
       buf.writeSlice(h);
     });
     this.writeBip32Derivation(buf, masterFingerprint, path);
@@ -487,7 +439,7 @@ function get(
   map: Map<string, Buffer>,
   keyType: KeyType,
   keyData: Buffer,
-  acceptUndefined: boolean
+  acceptUndefined: boolean,
 ): Buffer | undefined {
   if (!map) throw Error("No such map");
   const key = new Key(keyType, keyData);
@@ -551,12 +503,7 @@ function serializeMap(buf: BufferWriter, map: Map<string, Buffer>) {
 function b(): Buffer {
   return Buffer.from([]);
 }
-function set(
-  map: Map<string, Buffer>,
-  keyType: KeyType,
-  keyData: Buffer,
-  value: Buffer
-) {
+function set(map: Map<string, Buffer>, keyType: KeyType, keyData: Buffer, value: Buffer) {
   const key = new Key(keyType, keyData);
   map.set(key.toString(), value);
 }

package/src/serializeTransaction.ts

@@ -11,7 +11,7 @@ export function serializeTransactionOutputs({ outputs }: Transaction): Buffer {
 
   if (typeof outputs !== "undefined") {
     outputBuffer = Buffer.concat([outputBuffer, createVarint(outputs.length)]);
-    outputs.forEach((output) => {
+    outputs.forEach(output => {
       outputBuffer = Buffer.concat([
         outputBuffer,
         output.amount,
@@ -27,15 +27,14 @@ export function serializeTransaction(
   transaction: Transaction,
   skipWitness: boolean,
   timestamp?: Buffer,
-  additionals: string[] = []
+  additionals: string[] = [],
 ) {
   const isDecred = additionals.includes("decred");
   const isZcash = additionals.includes("zcash");
   const isBech32 = additionals.includes("bech32");
   let inputBuffer = Buffer.alloc(0);
-  const useWitness =
-    typeof transaction["witness"] != "undefined" && !skipWitness;
-  transaction.inputs.forEach((input) => {
+  const useWitness = typeof transaction["witness"] != "undefined" && !skipWitness;
+  transaction.inputs.forEach(input => {
     inputBuffer =
       isDecred || isBech32
         ? Buffer.concat([
@@ -54,10 +53,7 @@ export function serializeTransaction(
   });
   let outputBuffer = serializeTransactionOutputs(transaction);
 
-  if (
-    typeof transaction.outputs !== "undefined" &&
-    typeof transaction.locktime !== "undefined"
-  ) {
+  if (typeof transaction.outputs !== "undefined" && typeof transaction.locktime !== "undefined") {
     outputBuffer = Buffer.concat([
       outputBuffer,
       (useWitness && transaction.witness) || Buffer.alloc(0),

package/src/signMessage.ts

@@ -9,7 +9,7 @@ export async function signMessage(
   }: {
     path: string;
     messageHex: string;
-  }
+  },
 ): Promise<{
   v: number;
   r: string;
@@ -21,16 +21,10 @@ export async function signMessage(
 
   while (offset !== message.length) {
     const maxChunkSize =
-      offset === 0
-        ? MAX_SCRIPT_BLOCK - 1 - paths.length * 4 - 4
-        : MAX_SCRIPT_BLOCK;
+      offset === 0 ? MAX_SCRIPT_BLOCK - 1 - paths.length * 4 - 4 : MAX_SCRIPT_BLOCK;
     const chunkSize =
-      offset + maxChunkSize > message.length
-        ? message.length - offset
-        : maxChunkSize;
-    const buffer = Buffer.alloc(
-      offset === 0 ? 1 + paths.length * 4 + 2 + chunkSize : chunkSize
-    );
+      offset + maxChunkSize > message.length ? message.length - offset : maxChunkSize;
+    const buffer = Buffer.alloc(offset === 0 ? 1 + paths.length * 4 + 2 + chunkSize : chunkSize);
 
     if (offset === 0) {
       buffer[0] = paths.length;
@@ -38,12 +32,7 @@ export async function signMessage(
         buffer.writeUInt32BE(element, 1 + 4 * index);
       });
       buffer.writeUInt16BE(message.length, 1 + 4 * paths.length);
-      message.copy(
-        buffer,
-        1 + 4 * paths.length + 2,
-        offset,
-        offset + chunkSize
-      );
+      message.copy(buffer, 1 + 4 * paths.length + 2, offset, offset + chunkSize);
     } else {
       message.copy(buffer, 0, offset, offset + chunkSize);
     }

package/src/signP2SHTransaction.ts

@@ -5,12 +5,7 @@ import { getTrustedInputBIP143 } from "./getTrustedInputBIP143";
 import { signTransaction } from "./signTransaction";
 import { hashOutputFull } from "./finalizeInput";
 import type { TransactionOutput, Transaction, TrustedInput } from "./types";
-import {
-  DEFAULT_LOCKTIME,
-  DEFAULT_VERSION,
-  DEFAULT_SEQUENCE,
-  SIGHASH_ALL,
-} from "./constants";
+import { DEFAULT_LOCKTIME, DEFAULT_VERSION, DEFAULT_SEQUENCE, SIGHASH_ALL } from "./constants";
 const defaultArg = {
   lockTime: DEFAULT_LOCKTIME,
   sigHashType: SIGHASH_ALL,
@@ -22,9 +17,7 @@ const defaultArg = {
  *
  */
 export type SignP2SHTransactionArg = {
-  inputs: Array<
-    [Transaction, number, string | null | undefined, number | null | undefined]
-  >;
+  inputs: Array<[Transaction, number, string | null | undefined, number | null | undefined]>;
   associatedKeysets: string[];
   outputScriptHex: string;
   lockTime?: number;
@@ -32,10 +25,7 @@ export type SignP2SHTransactionArg = {
   segwit?: boolean;
   transactionVersion?: number;
 };
-export async function signP2SHTransaction(
-  transport: Transport,
-  arg: SignP2SHTransactionArg
-) {
+export async function signP2SHTransaction(transport: Transport, arg: SignP2SHTransactionArg) {
   const {
     inputs,
     associatedKeysets,
@@ -65,17 +55,11 @@ export async function signP2SHTransaction(
 
   for (const input of inputs) {
     if (!resuming) {
-      const trustedInput = await getTrustedInputCall(
-        transport,
-        input[1],
-        input[0]
-      );
+      const trustedInput = await getTrustedInputCall(transport, input[1], input[0]);
       const sequence = Buffer.alloc(4);
       sequence.writeUInt32LE(
-        input.length >= 4 && typeof input[3] === "number"
-          ? input[3]
-          : DEFAULT_SEQUENCE,
-        0
+        input.length >= 4 && typeof input[3] === "number" ? input[3] : DEFAULT_SEQUENCE,
+        0,
       );
       trustedInputs.push({
         trustedInput: false,
@@ -101,7 +85,7 @@ export async function signP2SHTransaction(
       inputs[i].length >= 4 && typeof inputs[i][3] === "number"
         ? (inputs[i][3] as number)
         : DEFAULT_SEQUENCE,
-      0
+      0,
     );
     targetTransaction.inputs.push({
       script: nullScript,
@@ -116,7 +100,7 @@ export async function signP2SHTransaction(
       true,
       targetTransaction,
       trustedInputs,
-      true
+      true,
     );
     await hashOutputFull(transport, outputScript);
   }
@@ -141,23 +125,16 @@ export async function signP2SHTransaction(
       !segwit && firstRun,
       pseudoTX,
       pseudoTrustedInputs,
-      segwit
+      segwit,
     );
 
     if (!segwit) {
       await hashOutputFull(transport, outputScript);
     }
 
-    const signature = await signTransaction(
-      transport,
-      associatedKeysets[i],
-      lockTime,
-      sigHashType
-    );
+    const signature = await signTransaction(transport, associatedKeysets[i], lockTime, sigHashType);
     signatures.push(
-      segwit
-        ? signature.toString("hex")
-        : signature.slice(0, signature.length - 1).toString("hex")
+      segwit ? signature.toString("hex") : signature.slice(0, signature.length - 1).toString("hex"),
     );
     targetTransaction.inputs[i].script = nullScript;
 

package/src/signTransaction.ts

@@ -6,7 +6,7 @@ export function signTransaction(
   lockTime: number,
   sigHashType: number,
   expiryHeight?: Buffer,
-  additionals: Array<string> = []
+  additionals: Array<string> = [],
 ): Promise<Buffer> {
   const isDecred = additionals.includes("decred");
   const pathsBuffer = bip32asBuffer(path);
@@ -19,18 +19,13 @@ export function signTransaction(
         expiryHeight || Buffer.from([0x00, 0x00, 0x00, 0x00]),
         Buffer.from([sigHashType]),
       ])
-    : Buffer.concat([
-        pathsBuffer,
-        Buffer.from([0x00]),
-        lockTimeBuffer,
-        Buffer.from([sigHashType]),
-      ]);
+    : Buffer.concat([pathsBuffer, Buffer.from([0x00]), lockTimeBuffer, Buffer.from([sigHashType])]);
 
   if (expiryHeight && !isDecred) {
     buffer = Buffer.concat([buffer, expiryHeight]);
   }
 
-  return transport.send(0xe0, 0x48, 0x00, 0x00, buffer).then((result) => {
+  return transport.send(0xe0, 0x48, 0x00, 0x00, buffer).then(result => {
     if (result.length > 0) {
       result[0] = 0x30;
       return result.slice(0, result.length - 2);

package/src/splitTransaction.ts

@@ -7,7 +7,7 @@ export function splitTransaction(
   isSegwitSupported: boolean | null | undefined = false,
   hasTimestamp = false,
   hasExtraData = false,
-  additionals: Array<string> = []
+  additionals: Array<string> = [],
 ): Transaction {
   const inputs: TransactionInput[] = [];
   const outputs: TransactionOutput[] = [];
@@ -27,8 +27,7 @@ export function splitTransaction(
     version.equals(Buffer.from([0x03, 0x00, 0x00, 0x80])) ||
     version.equals(Buffer.from([0x04, 0x00, 0x00, 0x80])) ||
     version.equals(Buffer.from([0x05, 0x00, 0x00, 0x80]));
-  const isZcashv5 =
-    isZcash && version.equals(Buffer.from([0x05, 0x00, 0x00, 0x80]));
+  const isZcashv5 = isZcash && version.equals(Buffer.from([0x05, 0x00, 0x00, 0x80]));
   offset += 4;
   if (
     !hasTimestamp &&
@@ -162,9 +161,6 @@ export function splitTransaction(
     nExpiryHeight,
     extraData,
   };
-  log(
-    "btc",
-    `splitTransaction ${transactionHex}:\n${formatTransactionDebug(t)}`
-  );
+  log("btc", `splitTransaction ${transactionHex}:\n${formatTransactionDebug(t)}`);
   return t;
 }

package/src/startUntrustedHashTransactionInput.ts

@@ -9,7 +9,7 @@ export function startUntrustedHashTransactionInputRaw(
   transactionData: Buffer,
   bip143 = false,
   overwinter = false,
-  additionals: Array<string> = []
+  additionals: Array<string> = [],
 ): Promise<Buffer> {
   const p2 = additionals.includes("cashaddr")
     ? 0x03
@@ -25,7 +25,7 @@ export function startUntrustedHashTransactionInputRaw(
     0x44,
     firstRound ? 0x00 : 0x80,
     newTransaction ? p2 : 0x80,
-    transactionData
+    transactionData,
   );
 }
 export async function startUntrustedHashTransactionInput(
@@ -39,7 +39,7 @@ export async function startUntrustedHashTransactionInput(
   bip143 = false,
   overwinter = false,
   additionals: Array<string> = [],
-  useTrustedInputForSegwit = false
+  useTrustedInputForSegwit = false,
 ): Promise<any> {
   let data = Buffer.concat([
     transaction.version,
@@ -54,7 +54,7 @@ export async function startUntrustedHashTransactionInput(
     data,
     bip143,
     overwinter,
-    additionals
+    additionals,
   );
   let i = 0;
   const isDecred = additionals.includes("decred");
@@ -90,7 +90,7 @@ export async function startUntrustedHashTransactionInput(
       data,
       bip143,
       overwinter,
-      additionals
+      additionals,
     );
     const scriptBlocks: Buffer[] = [];
     let offset = 0;
@@ -108,10 +108,7 @@ export async function startUntrustedHashTransactionInput(
           scriptBlocks.push(input.script.slice(offset, offset + blockSize));
         } else {
           scriptBlocks.push(
-            Buffer.concat([
-              input.script.slice(offset, offset + blockSize),
-              input.sequence,
-            ])
+            Buffer.concat([input.script.slice(offset, offset + blockSize), input.sequence]),
           );
         }
 
@@ -127,7 +124,7 @@ export async function startUntrustedHashTransactionInput(
         scriptBlock,
         bip143,
         overwinter,
-        additionals
+        additionals,
       );
     }