@ledgerhq/hw-app-btc 10.16.0-nightly.20260116024452 → 10.16.0-nightly.20260116124336

package/src/BtcNew.ts

@@ -1,11 +1,5 @@
 import { crypto } from "bitcoinjs-lib";
 import { secp256k1 } from "@noble/curves/secp256k1";
-
-// Replacement for pointCompress from tiny-secp256k1
-function pointCompress(point: Uint8Array, compressed = true): Uint8Array {
-  const p = secp256k1.ProjectivePoint.fromHex(point);
-  return p.toRawBytes(compressed);
-}
 import {
   getXpubComponents,
   hardenedPathOf,
@@ -13,7 +7,7 @@ import {
   pathStringToArray,
   pubkeyFromXpub,
 } from "./bip32";
-import { BufferReader } from "./buffertools";
+import { BufferReader, psbtIn, PsbtV2 } from "@ledgerhq/psbtv2";
 import type { CreateTransactionArg } from "./createTransaction";
 import type { AddressFormat } from "./getWalletPublicKey";
 import {
@@ -28,10 +22,15 @@ import { AppClient as Client } from "./newops/appClient";
 import { createKey, DefaultDescriptorTemplate, WalletPolicy } from "./newops/policy";
 import { extract } from "./newops/psbtExtractor";
 import { finalize } from "./newops/psbtFinalizer";
-import { psbtIn, PsbtV2 } from "./newops/psbtv2";
 import { serializeTransaction } from "./serializeTransaction";
 import type { Transaction } from "./types";
 
+// Replacement for pointCompress from tiny-secp256k1
+function pointCompress(point: Uint8Array, compressed = true): Uint8Array {
+  const p = secp256k1.ProjectivePoint.fromHex(point);
+  return p.toRawBytes(compressed);
+}
+
 /**
  * @class BtcNew
  * @description This class implements the same interface as BtcOld (formerly
@@ -282,7 +281,7 @@ export default class BtcNew {
     const progressCallback = () => {
       if (!firstSigned) {
         firstSigned = true;
-        arg.onDeviceSignatureGranted && arg.onDeviceSignatureGranted();
+        if (arg.onDeviceSignatureGranted) arg.onDeviceSignatureGranted();
       }
       progress();
     };
@@ -293,6 +292,481 @@ export default class BtcNew {
     return serializedTx.toString("hex");
   }
 
+  /**
+   * Signs a PSBT buffer using the Bitcoin app (new protocol).
+   *
+   * - If the PSBT is v2, it is deserialized directly.
+   * - If the PSBT is v0, it is converted to v2 internally.
+   * - The account type (legacy, wrapped segwit, native segwit, taproot) is
+   *   inferred from PSBT data when possible, or from the provided options.
+   *
+   * Note: All internal inputs (inputs that can be signed by the device) must
+   * belong to the same account and use the same account type. Mixed input types
+   * or inputs from different accounts are not supported and will throw an error.
+   *
+   * @param psbtBuffer - Raw PSBT buffer (v0 or v2) to be signed.
+   * @param options - Optional signing configuration.
+   * @param options.finalizePsbt - Whether to finalize the PSBT after signing
+   *   (default: true). If true, the returned `tx` is a fully signed
+   *   transaction ready for broadcast.
+   * @param options.accountPath - BIP32 account path (for example,
+   *   "m/84'/0'/0'") used when BIP32 derivation information is missing from
+   *   the PSBT. Required if the PSBT does not contain BIP32 derivation data.
+   * @param options.addressFormat - Explicit address format to use when the
+   *   account type cannot be inferred from the PSBT ("legacy", "p2sh",
+   *   "bech32", or "bech32m").
+   * @param options.onDeviceSignatureRequested - Callback when signature is about to be requested from device.
+   * @param options.onDeviceSignatureGranted - Callback when the first signature is granted by device.
+   * @param options.onDeviceStreaming - Callback to track signing progress with index and total.
+   *
+   * @returns An object containing:
+   * - `psbt`: a non-finalized PSBT buffer including signatures.
+   * - `tx`: the fully signed transaction hex string (if `finalizePsbt` is
+   *   true), or the hex of the transaction that would be extracted after
+   *   finalization.
+   */
+  async signPsbtBuffer(
+    psbtBuffer: Buffer,
+    options?: {
+      finalizePsbt?: boolean;
+      accountPath?: string;
+      addressFormat?: AddressFormat;
+      onDeviceSignatureRequested?: () => void;
+      onDeviceSignatureGranted?: () => void;
+      onDeviceStreaming?: (arg: { progress: number; total: number; index: number }) => void;
+    },
+  ) {
+    const psbt = this.deserializePsbt(psbtBuffer);
+    const inputCount = psbt.getGlobalInputCount();
+
+    if (inputCount === 0) {
+      throw new Error("No inputs in PSBT");
+    }
+
+    const masterFp = await this.client.getMasterFingerprint();
+    const { accountPath, detectedScriptType, internalInputIndices } = this.analyzeAllInputs(
+      psbt,
+      inputCount,
+      masterFp,
+      options?.accountPath,
+    );
+
+    const accountXpub = await this.client.getExtendedPubkey(false, accountPath);
+    const referenceInputIndex = internalInputIndices.length > 0 ? internalInputIndices[0] : 0;
+
+    const accountType = this.determineAccountType(
+      psbt,
+      referenceInputIndex,
+      masterFp,
+      detectedScriptType,
+      accountPath,
+      options?.addressFormat,
+    );
+
+    const walletPolicy = this.createWalletPolicy(masterFp, accountPath, accountXpub, accountType);
+    const progressCallback = this.createProgressCallback(inputCount, options);
+
+    await this.signPsbt(psbt, walletPolicy, progressCallback);
+
+    return this.finalizePsbtAndExtract(psbt, options?.finalizePsbt);
+  }
+
+  private deserializePsbt(psbtBuffer: Buffer): PsbtV2 {
+    const psbtVersion = PsbtV2.getPsbtVersionNumber(psbtBuffer);
+    const psbt = psbtVersion === 2 ? new PsbtV2() : PsbtV2.fromV0(psbtBuffer, true);
+
+    if (psbtVersion === 2) {
+      psbt.deserialize(psbtBuffer);
+    }
+
+    return psbt;
+  }
+
+  private analyzeAllInputs(
+    psbt: PsbtV2,
+    inputCount: number,
+    masterFp: Buffer,
+    accountPathOption?: string,
+  ): {
+    accountPath: number[];
+    detectedScriptType: string | undefined;
+    internalInputIndices: number[];
+  } {
+    const internalInputIndices: number[] = [];
+    let accountPath: number[] = [];
+    let detectedScriptType: string | undefined;
+
+    for (let i = 0; i < inputCount; i++) {
+      const inputInfo = this.analyzeInput(psbt, i, masterFp);
+
+      if (!inputInfo.isInternal) {
+        continue;
+      }
+
+      internalInputIndices.push(i);
+      this.validateAccountPathConsistency(accountPath, inputInfo.accountPath, i);
+
+      if (accountPath.length === 0) {
+        accountPath = inputInfo.accountPath;
+      }
+
+      this.validateScriptTypeConsistency(detectedScriptType, inputInfo.scriptType, i);
+
+      if (!detectedScriptType) {
+        detectedScriptType = inputInfo.scriptType;
+      }
+    }
+
+    if (internalInputIndices.length === 0) {
+      accountPath = this.resolveAccountPathFromOptions(accountPathOption);
+    }
+
+    return { accountPath, detectedScriptType, internalInputIndices };
+  }
+
+  private validateAccountPathConsistency(
+    accountPath: number[],
+    newAccountPath: number[],
+    inputIndex: number,
+  ): void {
+    if (accountPath.length > 0 && !this.arePathsEqual(accountPath, newAccountPath)) {
+      throw new Error(
+        `Mixed accounts detected in PSBT. Input ${inputIndex} uses account path ` +
+          `${pathArrayToString(newAccountPath)} but expected ` +
+          `${pathArrayToString(accountPath)}. All internal inputs must belong to the same account.`,
+      );
+    }
+  }
+
+  private validateScriptTypeConsistency(
+    detectedScriptType: string | undefined,
+    newScriptType: string | undefined,
+    inputIndex: number,
+  ): void {
+    if (detectedScriptType && newScriptType && detectedScriptType !== newScriptType) {
+      throw new Error(
+        `Mixed input types detected in PSBT. Input ${inputIndex} uses ${newScriptType} ` +
+          `but expected ${detectedScriptType}. All internal inputs must use the same script type.`,
+      );
+    }
+  }
+
+  private resolveAccountPathFromOptions(accountPathOption?: string): number[] {
+    if (!accountPathOption) {
+      throw new Error(
+        "No internal inputs found in PSBT (no BIP32 derivation matching device fingerprint) " +
+          "and no account path provided in options. Please provide accountPath in options " +
+          "(e.g., \"m/84'/0'/0'\" for native segwit)",
+      );
+    }
+    return pathStringToArray(accountPathOption);
+  }
+
+  private createWalletPolicy(
+    masterFp: Buffer,
+    accountPath: number[],
+    accountXpub: string,
+    accountType: AccountType,
+  ): WalletPolicy {
+    const key = createKey(masterFp, accountPath, accountXpub);
+    return new WalletPolicy(accountType.getDescriptorTemplate(), key);
+  }
+
+  private createProgressCallback(
+    inputCount: number,
+    options?: {
+      onDeviceSignatureRequested?: () => void;
+      onDeviceSignatureGranted?: () => void;
+      onDeviceStreaming?: (arg: { progress: number; total: number; index: number }) => void;
+    },
+  ): () => void {
+    let notifyCount = 0;
+    let firstSigned = false;
+
+    const progress = () => {
+      if (!options?.onDeviceStreaming) return;
+      options.onDeviceStreaming({
+        total: 2 * inputCount,
+        index: notifyCount,
+        progress: ++notifyCount / (2 * inputCount),
+      });
+    };
+
+    if (options?.onDeviceSignatureRequested) options.onDeviceSignatureRequested();
+
+    return () => {
+      if (!firstSigned) {
+        firstSigned = true;
+        if (options?.onDeviceSignatureGranted) options.onDeviceSignatureGranted();
+      }
+      progress();
+    };
+  }
+
+  private finalizePsbtAndExtract(
+    psbt: PsbtV2,
+    shouldFinalize?: boolean,
+  ): { psbt: Buffer; tx: string } {
+    if (shouldFinalize ?? true) {
+      finalize(psbt);
+    }
+    const serializedTx = extract(psbt);
+
+    return {
+      psbt: psbt.serialize(),
+      tx: serializedTx.toString("hex"),
+    };
+  }
+
+  /**
+   * Analyzes a single input to determine if it's internal (can be signed by the device)
+   * and extracts its account path and script type.
+   */
+  private analyzeInput(
+    psbt: PsbtV2,
+    inputIndex: number,
+    masterFp: Buffer,
+  ): {
+    isInternal: boolean;
+    accountPath: number[];
+    scriptType: string | undefined;
+  } {
+    const derivationResult = this.checkBip32Derivation(psbt, inputIndex, masterFp);
+    const scriptType = this.determineInputScriptType(psbt, inputIndex);
+
+    return {
+      isInternal: derivationResult.isInternal,
+      accountPath: derivationResult.accountPath,
+      scriptType,
+    };
+  }
+
+  private checkBip32Derivation(
+    psbt: PsbtV2,
+    inputIndex: number,
+    masterFp: Buffer,
+  ): { isInternal: boolean; accountPath: number[] } {
+    // Check standard BIP32 derivation
+    const standardResult = this.checkStandardBip32Derivation(psbt, inputIndex, masterFp);
+    if (standardResult.isInternal) {
+      return standardResult;
+    }
+
+    // Check TAP_BIP32_DERIVATION for taproot inputs
+    return this.checkTaprootBip32Derivation(psbt, inputIndex, masterFp);
+  }
+
+  private checkStandardBip32Derivation(
+    psbt: PsbtV2,
+    inputIndex: number,
+    masterFp: Buffer,
+  ): { isInternal: boolean; accountPath: number[] } {
+    const keyDatas = psbt.getInputKeyDatas(inputIndex, psbtIn.BIP32_DERIVATION);
+
+    for (const pubkey of keyDatas) {
+      const derivationInfo = psbt.getInputBip32Derivation(inputIndex, pubkey);
+      if (derivationInfo?.masterFingerprint.equals(masterFp)) {
+        return this.extractAccountPath(derivationInfo.path);
+      }
+    }
+
+    return { isInternal: false, accountPath: [] };
+  }
+
+  private checkTaprootBip32Derivation(
+    psbt: PsbtV2,
+    inputIndex: number,
+    masterFp: Buffer,
+  ): { isInternal: boolean; accountPath: number[] } {
+    const tapKeyDatas = psbt.getInputKeyDatas(inputIndex, psbtIn.TAP_BIP32_DERIVATION);
+
+    for (const pubkey of tapKeyDatas) {
+      const derivationInfo = psbt.getInputTapBip32Derivation(inputIndex, pubkey);
+      if (derivationInfo?.masterFingerprint.equals(masterFp)) {
+        return this.extractAccountPath(derivationInfo.path);
+      }
+    }
+
+    return { isInternal: false, accountPath: [] };
+  }
+
+  private extractAccountPath(fullPath: number[]): { isInternal: true; accountPath: number[] } {
+    // Extract account path (full path minus last 2 elements for change/index)
+    const accountPath = fullPath.length >= 2 ? fullPath.slice(0, -2) : [];
+    return { isInternal: true, accountPath };
+  }
+
+  private determineInputScriptType(psbt: PsbtV2, inputIndex: number): string | undefined {
+    const witnessUtxo = psbt.getInputWitnessUtxo(inputIndex);
+    if (witnessUtxo) {
+      return this.detectScriptType(witnessUtxo.scriptPubKey);
+    }
+
+    const redeemScript = psbt.getInputRedeemScript(inputIndex);
+    if (redeemScript) {
+      return "p2sh-p2wpkh";
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Detects the script type from a scriptPubKey.
+   */
+  private detectScriptType(scriptPubKey: Buffer): string | undefined {
+    if (scriptPubKey.length === 22 && scriptPubKey[0] === 0x00 && scriptPubKey[1] === 0x14) {
+      return "p2wpkh";
+    }
+    if (scriptPubKey.length === 34 && scriptPubKey[0] === 0x51 && scriptPubKey[1] === 0x20) {
+      return "p2tr";
+    }
+    if (scriptPubKey.length === 23 && scriptPubKey[0] === 0xa9 && scriptPubKey[22] === 0x87) {
+      return "p2sh";
+    }
+    if (scriptPubKey.length === 25 && scriptPubKey[0] === 0x76 && scriptPubKey[1] === 0xa9) {
+      return "p2pkh";
+    }
+    return undefined;
+  }
+
+  /**
+   * Compares two derivation paths for equality.
+   */
+  private arePathsEqual(path1: number[], path2: number[]): boolean {
+    if (path1.length !== path2.length) return false;
+    return path1.every((elem, idx) => elem === path2[idx]);
+  }
+
+  /**
+   * Determines the account type based on detected script type, account path, or options.
+   */
+  private determineAccountType(
+    psbt: PsbtV2,
+    inputIndex: number,
+    masterFp: Buffer,
+    detectedScriptType: string | undefined,
+    accountPath: number[],
+    addressFormat?: AddressFormat,
+  ): AccountType {
+    // Use detected script type if available
+    if (detectedScriptType) {
+      return this.createAccountTypeFromScriptType(detectedScriptType, psbt, masterFp);
+    }
+
+    // Fall back to witness UTXO analysis
+    const witnessUtxoType = this.determineAccountTypeFromWitnessUtxo(psbt, inputIndex, masterFp);
+    if (witnessUtxoType) {
+      return witnessUtxoType;
+    }
+
+    // Try redeem script
+    if (psbt.getInputRedeemScript(inputIndex)) {
+      return new p2wpkhWrapped(psbt, masterFp);
+    }
+
+    // Use address format option
+    if (addressFormat) {
+      return this.createAccountTypeFromAddressFormat(addressFormat, psbt, masterFp);
+    }
+
+    // Infer from account path purpose
+    const purposeBasedType = this.determineAccountTypeFromPurpose(accountPath, psbt, masterFp);
+    if (purposeBasedType) {
+      return purposeBasedType;
+    }
+
+    // Default to native segwit
+    return new p2wpkh(psbt, masterFp);
+  }
+
+  private createAccountTypeFromScriptType(
+    scriptType: string,
+    psbt: PsbtV2,
+    masterFp: Buffer,
+  ): AccountType {
+    switch (scriptType) {
+      case "p2wpkh":
+        return new p2wpkh(psbt, masterFp);
+      case "p2tr":
+        return new p2tr(psbt, masterFp);
+      case "p2sh":
+      case "p2sh-p2wpkh":
+        return new p2wpkhWrapped(psbt, masterFp);
+      case "p2pkh":
+        return new p2pkh(psbt, masterFp);
+      default:
+        return new p2wpkh(psbt, masterFp);
+    }
+  }
+
+  private determineAccountTypeFromWitnessUtxo(
+    psbt: PsbtV2,
+    inputIndex: number,
+    masterFp: Buffer,
+  ): AccountType | null {
+    const witnessUtxo = psbt.getInputWitnessUtxo(inputIndex);
+    if (!witnessUtxo) {
+      return null;
+    }
+
+    const scriptPubKey = witnessUtxo.scriptPubKey;
+
+    if (scriptPubKey.length === 22 && scriptPubKey[0] === 0x00 && scriptPubKey[1] === 0x14) {
+      return new p2wpkh(psbt, masterFp);
+    }
+    if (scriptPubKey.length === 34 && scriptPubKey[0] === 0x51 && scriptPubKey[1] === 0x20) {
+      return new p2tr(psbt, masterFp);
+    }
+    if (scriptPubKey.length === 23 && scriptPubKey[0] === 0xa9 && scriptPubKey[22] === 0x87) {
+      return new p2wpkhWrapped(psbt, masterFp);
+    }
+    if (scriptPubKey.length === 25 && scriptPubKey[0] === 0x76 && scriptPubKey[1] === 0xa9) {
+      return new p2pkh(psbt, masterFp);
+    }
+
+    throw new Error(`Unsupported script type: ${scriptPubKey.toString("hex")}`);
+  }
+
+  private createAccountTypeFromAddressFormat(
+    addressFormat: AddressFormat,
+    psbt: PsbtV2,
+    masterFp: Buffer,
+  ): AccountType {
+    const descrTemplate = descrTemplFrom(addressFormat);
+
+    if (descrTemplate === "pkh(@0)") return new p2pkh(psbt, masterFp);
+    if (descrTemplate === "wpkh(@0)") return new p2wpkh(psbt, masterFp);
+    if (descrTemplate === "sh(wpkh(@0))") return new p2wpkhWrapped(psbt, masterFp);
+    if (descrTemplate === "tr(@0)") return new p2tr(psbt, masterFp);
+
+    throw new Error(`Unsupported descriptor template: ${descrTemplate}`);
+  }
+
+  private determineAccountTypeFromPurpose(
+    accountPath: number[],
+    psbt: PsbtV2,
+    masterFp: Buffer,
+  ): AccountType | null {
+    if (accountPath.length < 1) {
+      return null;
+    }
+
+    const purpose = accountPath[0] - 0x80000000;
+
+    switch (purpose) {
+      case 44:
+        return new p2pkh(psbt, masterFp);
+      case 49:
+        return new p2wpkhWrapped(psbt, masterFp);
+      case 84:
+        return new p2wpkh(psbt, masterFp);
+      case 86:
+        return new p2tr(psbt, masterFp);
+      default:
+        return null;
+    }
+  }
+
   /**
    * Signs an arbitrary hex-formatted message with the private key at
    * the provided derivation path according to the Bitcoin Signature format

package/src/createTransaction.ts

@@ -202,8 +202,6 @@ export async function createTransaction(
     version: defaultVersion,
     timestamp: Buffer.alloc(0),
   };
-  const getTrustedInputCall =
-    useBip143 && !useTrustedInputForSegwit ? getTrustedInputBIP143 : getTrustedInput;
   const outputScript = Buffer.from(outputScriptHex, "hex");
   notify(0, 0);
   // first pass on inputs to get trusted inputs
@@ -212,7 +210,10 @@ export async function createTransaction(
       if (isZcash) {
         input[0].consensusBranchId = getZcashBranchId(input[4]);
       }
-      const trustedInput = await getTrustedInputCall(transport, input[1], input[0], additionals);
+      const trustedInput =
+        useBip143 && !useTrustedInputForSegwit
+          ? getTrustedInputBIP143(input[1], input[0], additionals)
+          : await getTrustedInput(transport, input[1], input[0], additionals);
       log("hw", "got trustedInput=" + trustedInput);
       const sequence = Buffer.alloc(4);
       sequence.writeUInt32LE(

package/src/getTrustedInputBIP143.ts

@@ -1,9 +1,7 @@
-import Transport from "@ledgerhq/hw-transport";
 import { sha256 } from "@noble/hashes/sha256";
 import type { Transaction } from "./types";
 import { serializeTransaction } from "./serializeTransaction";
 export function getTrustedInputBIP143(
-  transport: Transport,
   indexLookup: number,
   transaction: Transaction,
   additionals: Array<string> = [],

package/src/newops/accounttype.ts

@@ -1,5 +1,9 @@
 import { crypto } from "bitcoinjs-lib";
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { BufferWriter, PsbtV2 } from "@ledgerhq/psbtv2";
+import { HASH_SIZE, OP_CHECKSIG, OP_DUP, OP_EQUAL, OP_EQUALVERIFY, OP_HASH160 } from "../constants";
+import { hashPublicKey } from "../hashPublicKey";
+import { DefaultDescriptorTemplate } from "./policy";
 
 // Helper function to convert bytes to bigint for scalar operations
 function bytesToBigInt(bytes: Uint8Array): bigint {
@@ -20,11 +24,6 @@ function pointAddScalar(point: Uint8Array, scalar: Uint8Array): Uint8Array | nul
     return null;
   }
 }
-import { BufferWriter } from "../buffertools";
-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";
 
 export type SpendingCondition = {
   scriptPubKey: Buffer;
@@ -175,7 +174,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);
   }
 
@@ -186,7 +185,7 @@ export class p2pkh extends SingleKeyAccount {
 
 export class p2tr extends SingleKeyAccount {
   singleKeyCondition(pubkey: Buffer): SpendingCondition {
-    const xonlyPubkey = pubkey.slice(1); // x-only pubkey
+    const xonlyPubkey = pubkey.subarray(1); // x-only pubkey
     const buf = new BufferWriter();
     const outputKey = this.getTaprootOutputKey(xonlyPubkey);
     buf.writeSlice(Buffer.from([0x51, 32])); // push1, pubkeylen
@@ -201,13 +200,13 @@ export class p2tr extends SingleKeyAccount {
     pubkey: Buffer,
     path: number[],
   ) {
-    const xonly = pubkey.slice(1);
+    const xonly = pubkey.subarray(1);
     this.psbt.setInputTapBip32Derivation(i, xonly, [], this.masterFp, path);
     this.psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.cond.scriptPubKey);
   }
 
-  setSingleKeyOutput(i: number, cond: SpendingCondition, pubkey: Buffer, path: number[]) {
-    const xonly = pubkey.slice(1);
+  setSingleKeyOutput(i: number, _cond: SpendingCondition, pubkey: Buffer, path: number[]) {
+    const xonly = pubkey.subarray(1);
     this.psbt.setOutputTapBip32Derivation(i, xonly, [], this.masterFp, path);
   }
 
@@ -251,7 +250,7 @@ export class p2tr extends SingleKeyAccount {
     if (!tweakedKey) throw new Error("Point addition failed");
     const outputEcdsaKey = Buffer.from(tweakedKey);
     // Convert to schnorr.
-    const outputSchnorrKey = outputEcdsaKey.slice(1);
+    const outputSchnorrKey = outputEcdsaKey.subarray(1);
     // Create address
     return outputSchnorrKey;
   }
@@ -295,7 +294,7 @@ export class p2wpkhWrapped extends SingleKeyAccount {
   }
 
   setSingleKeyOutput(i: number, cond: SpendingCondition, pubkey: Buffer, path: number[]) {
-    this.psbt.setOutputRedeemScript(i, cond.redeemScript!);
+    if (cond.redeemScript) this.psbt.setOutputRedeemScript(i, cond.redeemScript);
     this.psbt.setOutputBip32Derivation(i, pubkey, this.masterFp, path);
   }
 

package/src/newops/appClient.ts

@@ -1,6 +1,6 @@
 import Transport from "@ledgerhq/hw-transport";
 import { pathElementsToBuffer } from "../bip32";
-import { PsbtV2 } from "./psbtv2";
+import { PsbtV2 } from "@ledgerhq/psbtv2";
 import { MerkelizedPsbt } from "./merkelizedPsbt";
 import { ClientCommandInterpreter } from "./clientCommands";
 import { WalletPolicy } from "./policy";

package/src/newops/clientCommands.ts

@@ -1,5 +1,5 @@
 import { crypto } from "bitcoinjs-lib";
-import { BufferReader } from "../buffertools";
+import { BufferReader } from "@ledgerhq/psbtv2";
 import { createVarint } from "../varint";
 import { hashLeaf, Merkle } from "./merkle";
 import { MerkleMap } from "./merkleMap";

package/src/newops/merkelizedPsbt.ts

@@ -1,5 +1,5 @@
 import { MerkleMap } from "./merkleMap";
-import { PsbtV2 } from "./psbtv2";
+import { PsbtV2 } from "@ledgerhq/psbtv2";
 
 /**
  * This class merkelizes a PSBTv2, by merkelizing the different

package/src/newops/policy.ts

@@ -1,6 +1,6 @@
 import { crypto } from "bitcoinjs-lib";
 import { pathArrayToString } from "../bip32";
-import { BufferWriter } from "../buffertools";
+import { BufferWriter } from "@ledgerhq/psbtv2";
 import { hashLeaf, Merkle } from "./merkle";
 
 export type DefaultDescriptorTemplate = "pkh(@0)" | "sh(wpkh(@0))" | "wpkh(@0)" | "tr(@0)";

package/src/newops/psbtExtractor.ts

@@ -1,5 +1,4 @@
-import { BufferWriter } from "../buffertools";
-import { PsbtV2 } from "./psbtv2";
+import { BufferWriter, PsbtV2 } from "@ledgerhq/psbtv2";
 
 /**
  * This implements the "Transaction Extractor" role of BIP370 (PSBTv2

package/src/newops/psbtFinalizer.ts

@@ -1,5 +1,4 @@
-import { BufferWriter } from "../buffertools";
-import { psbtIn, PsbtV2 } from "./psbtv2";
+import { BufferWriter, psbtIn, PsbtV2 } from "@ledgerhq/psbtv2";
 
 /**
  * This roughly implements the "input finalizer" role of BIP370 (PSBTv2