@ledgerhq/hw-app-btc 6.2.0 → 6.9.1-6.9.1-taproot.0.0

package/src/Btc.ts

@@ -1,16 +1,17 @@
 import type Transport from "@ledgerhq/hw-transport";
-import { signMessage } from "./signMessage";
-import { getWalletPublicKey } from "./getWalletPublicKey";
-import type { AddressFormat } from "./getWalletPublicKey";
-import { splitTransaction } from "./splitTransaction";
+import semver from "semver";
+import BtcNew from "./BtcNew";
+import BtcOld from "./BtcOld";
+import type { CreateTransactionArg } from "./createTransaction";
+import { getAppAndVersion } from "./getAppAndVersion";
 import { getTrustedInput } from "./getTrustedInput";
 import { getTrustedInputBIP143 } from "./getTrustedInputBIP143";
-import type { Transaction } from "./types";
-import { createTransaction } from "./createTransaction";
-import type { CreateTransactionArg } from "./createTransaction";
-import { signP2SHTransaction } from "./signP2SHTransaction";
-import type { SignP2SHTransactionArg } from "./signP2SHTransaction";
+import type { AddressFormat } from "./getWalletPublicKey";
+import { AppClient } from "./newops/appClient";
 import { serializeTransactionOutputs } from "./serializeTransaction";
+import type { SignP2SHTransactionArg } from "./signP2SHTransaction";
+import { splitTransaction } from "./splitTransaction";
+import type { Transaction } from "./types";
 export type { AddressFormat };
 /**
  * Bitcoin API.
@@ -45,7 +46,7 @@ export default class Btc {
    *
    * - verify (boolean) will ask user to confirm the address on the device
    *
-   * - format ("legacy" | "p2sh" | "bech32" | "cashaddr") to use different bitcoin address formatter.
+   * - format ("legacy" | "p2sh" | "bech32" | "bech32m" | "cashaddr") to use different bitcoin address formatter.
    *
    * NB The normal usage is to use:
    *
@@ -85,8 +86,9 @@ export default class Btc {
     } else {
       options = opts || {};
     }
-
-    return getWalletPublicKey(this.transport, { ...options, path });
+    return this.getCorrectImpl().then((impl) => {
+      return impl.getWalletPublicKey(path, options);
+    });
   }
 
   /**
@@ -106,10 +108,7 @@ export default class Btc {
     r: string;
     s: string;
   }> {
-    return signMessage(this.transport, {
-      path,
-      messageHex,
-    });
+    return this.old().signMessageNew(path, messageHex);
   }
 
   /**
@@ -150,8 +149,9 @@ export default class Btc {
         "@ledgerhq/hw-app-btc: createPaymentTransactionNew multi argument signature is deprecated. please switch to named parameters."
       );
     }
-
-    return createTransaction(this.transport, arg);
+    return this.getCorrectImpl().then((impl) => {
+      return impl.createPaymentTransactionNew(arg);
+    });
   }
 
   /**
@@ -174,13 +174,7 @@ export default class Btc {
   }).then(result => ...);
    */
   signP2SHTransaction(arg: SignP2SHTransactionArg): Promise<string[]> {
-    if (arguments.length > 1) {
-      console.warn(
-        "@ledgerhq/hw-app-btc: signP2SHTransaction multi argument signature is deprecated. please switch to named parameters."
-      );
-    }
-
-    return signP2SHTransaction(this.transport, arg);
+    return this.old().signP2SHTransaction(arg);
   }
 
   /**
@@ -238,4 +232,27 @@ export default class Btc {
       additionals
     );
   }
+
+  private async getCorrectImpl(): Promise<BtcOld | BtcNew> {
+    const isNewApp = await this.useNewApp();
+    if (isNewApp) {
+      return this.new();
+    } else {
+      return this.old();
+    }
+  }
+  private old(): BtcOld {
+    return new BtcOld(this.transport);
+  }
+  private new(): BtcNew {
+    return new BtcNew(new AppClient(this.transport));
+  }
+  private async useNewApp(): Promise<boolean> {
+    const a = await getAppAndVersion(this.transport);
+    const isNewApp = semver.major(a.version) >= 2;
+    if ((a.name == "Bitcoin" || a.name == "Bitcoin Test") && isNewApp) {
+      return true;
+    }
+    return false;
+  }
 }

package/src/BtcNew.ts

@@ -0,0 +1,326 @@
+import { crypto } from "bitcoinjs-lib";
+import { getXpubComponents, pathStringToArray, pubkeyFromXpub } from "./bip32";
+import { BufferReader } from "./buffertools";
+import type { CreateTransactionArg } from "./createTransaction";
+import type { AddressFormat } from "./getWalletPublicKey";
+import { hashPublicKey } from "./hashPublicKey";
+import { AppClient as Client } from "./newops/appClient";
+import { createKey, 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";
+import { pointCompress } from "tiny-secp256k1";
+
+export default class BtcNew {
+  constructor(private client: Client) {}
+
+  async getWalletPublicKey(
+    path: string,
+    opts?: {
+      verify?: boolean;
+      format?: AddressFormat;
+    }
+  ): Promise<{
+    publicKey: string;
+    bitcoinAddress: string;
+    chainCode: string;
+  }> {
+    const pathElements: number[] = pathStringToArray(path);
+    const xpub = await this.client.getPubkey(false, pathElements);
+
+    const display = opts?.verify ?? false;
+
+    const address = await this.getWalletAddress(
+      pathElements,
+      accountTypeFrom(opts?.format ?? "legacy"),
+      display
+    );
+    const components = getXpubComponents(xpub);
+    const uncompressedPubkey = Buffer.from(
+      pointCompress(components.pubkey, false)
+    );
+    return {
+      publicKey: uncompressedPubkey.toString("hex"),
+      bitcoinAddress: address,
+      chainCode: components.chaincode.toString("hex"),
+    };
+  }
+
+  /**
+   * Get an address for the specified path.
+   *
+   * If display is true, we must get the address from the device, which would require
+   * us to determine WalletPolicy. This requires two *extra* queries to the device, one
+   * for the account xpub and one for master key fingerprint.
+   *
+   * If display is false we *could* generate the address ourselves, but chose to
+   * get it from the device to save development time. However, it shouldn't take
+   * more than a few hours to implement local address generation.
+   *
+   * Moreover, if the path is not for a leaf, ie accountPath+/X/Y, there is no
+   * way to get the address from the device. In this case we have to create it
+   * ourselves, but we don't at this time, and instead return an empty ("") address.
+   */
+  private async getWalletAddress(
+    pathElements: number[],
+    accountType: AccountType,
+    display: boolean
+  ): Promise<string> {
+    const accountPathLength = this.accountPathLength(pathElements);
+    if (accountPathLength + 2 != pathElements.length) {
+      return "";
+    }
+    const accountPath = pathElements.slice(0, accountPathLength);
+    const accountXpub = await this.client.getPubkey(false, accountPath);
+    const masterFingerprint = await this.client.getMasterFingerprint();
+    const policy = new WalletPolicy(
+      accountType,
+      createKey(masterFingerprint, accountPath, accountXpub)
+    );
+    const changeAndIndex = pathElements.slice(-2, pathElements.length);
+    return this.client.getWalletAddress(
+      policy,
+      Buffer.alloc(32, 0),
+      changeAndIndex[0],
+      changeAndIndex[1],
+      display
+    );
+  }
+
+  private accountPathLength(pathElements: number[]): number {
+    for (let i = pathElements.length - 1; i >= 0; i--) {
+      if (pathElements[i] >= 0x80000000) {
+        return i + 1;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * To sign a transaction involving standard (P2PKH) inputs, call createTransaction with the following parameters
+   * @param inputs is an array of [ transaction, output_index, optional redeem script, optional sequence ] where
+   *
+   * * transaction is the previously computed transaction object for this UTXO
+   * * output_index is the output in the transaction used as input for this UTXO (counting from 0)
+   * * redeem script is the optional redeem script to use when consuming a Segregated Witness input
+   * * sequence is the sequence number to use for this input (when using RBF), or non present
+   * @param associatedKeysets is an array of BIP 32 paths pointing to the path to the private key used for each UTXO
+   * @param changePath is an optional BIP 32 path pointing to the path to the public key used to compute the change address
+   * @param outputScriptHex is the hexadecimal serialized outputs of the transaction to sign, including leading vararg voutCount
+   * @param lockTime is the optional lockTime of the transaction to sign, or default (0)
+   * @param sigHashType is the hash type of the transaction to sign, or default (all)
+   * @param segwit is an optional boolean indicating wether to use segwit or not. This includes wrapped segwit.
+   * @param initialTimestamp is an optional timestamp of the function call to use for coins that necessitate timestamps only, (not the one that the tx will include)
+   * @param additionals list of additionnal options
+   * 
+   * - "bech32" for spending native segwit outputs
+   * - "bech32m" for spending segwit v1+ outptus
+   * - "abc" for bch
+   * - "gold" for btg
+   * - "bipxxx" for using BIPxxx
+   * - "sapling" to indicate a zec transaction is supporting sapling (to be set over block 419200)
+   * @param expiryHeight is an optional Buffer for zec overwinter / sapling Txs
+   * @param useTrustedInputForSegwit trust inputs for segwit transactions. If app version >= 1.4.0 this should be true.
+   * @return the signed transaction ready to be broadcast
+   * @example
+  btc.createTransaction({
+   inputs: [ [tx1, 1] ],
+   associatedKeysets: ["0'/0/0"],
+   outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
+  }).then(res => ...);
+   */
+  async createPaymentTransactionNew(
+    arg: CreateTransactionArg
+  ): Promise<string> {
+    if (arg.inputs.length == 0) {
+      throw Error("No inputs");
+    }
+    const psbt = new PsbtV2();
+
+    const accountType = accountTypeFromArg(arg);
+
+    psbt.setGlobalTxVersion(2);
+    if (arg.lockTime) {
+      psbt.setGlobalFallbackLocktime(arg.lockTime);
+    }
+    psbt.setGlobalInputCount(arg.inputs.length);
+    psbt.setGlobalPsbtVersion(2);
+    psbt.setGlobalTxVersion(2);
+
+    const masterFp = await this.client.getMasterFingerprint();
+    let accountXpub = "";
+    let accountPath: number[] = [];
+    for (let i = 0; i < arg.inputs.length; i++) {
+      const pathElems: number[] = pathStringToArray(arg.associatedKeysets[i]);
+      if (accountXpub == "") {
+        // We assume all inputs belong to the same account so we set
+        // the account xpub and path based on the first input.
+        accountPath = pathElems.slice(0, -2);
+        accountXpub = await this.client.getPubkey(false, accountPath);
+      }
+      await this.setInput(
+        psbt,
+        i,
+        arg.inputs[i],
+        pathElems,
+        accountType,
+        masterFp
+      );
+    }
+
+    const outputsConcat = Buffer.from(arg.outputScriptHex, "hex");
+    const outputsBufferReader = new BufferReader(outputsConcat);
+    const outputCount = outputsBufferReader.readVarInt();
+    psbt.setGlobalOutputCount(outputCount);
+    for (let i = 0; i < outputCount; i++) {
+      const amount = Number(outputsBufferReader.readUInt64());
+      const outputScript = outputsBufferReader.readVarSlice();
+
+      // The wallet always places the change output last.
+      // But we won't know if we're paying to ourselves, because
+      // we'd have one output at index <outputCount-1 for ourselves
+      // and one change output.
+      const isChange = arg.changePath && i == outputCount - 1;
+      if (isChange) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const changePath = pathStringToArray(arg.changePath!);
+        const xpubBase58 = await this.client.getPubkey(false, changePath);
+        const pubkey = pubkeyFromXpub(xpubBase58);
+
+        if (accountType == AccountType.p2pkh) {
+          psbt.setOutputBip32Derivation(i, pubkey, masterFp, changePath);
+        } else if (accountType == AccountType.p2wpkh) {
+          psbt.setOutputBip32Derivation(i, pubkey, masterFp, changePath);
+        } else if (accountType == AccountType.p2wpkhWrapped) {
+          const redeemScript = this.createRedeemScript(pubkey);
+          psbt.setOutputRedeemScript(i, redeemScript);
+          psbt.setOutputBip32Derivation(i, pubkey, masterFp, changePath);
+        } else if (accountType == AccountType.p2tr) {
+          psbt.setOutputTapBip32Derivation(i, pubkey, [], masterFp, changePath);
+        }
+      }
+      psbt.setOutputAmount(i, amount);
+      psbt.setOutputScript(i, outputScript);
+    }
+
+    const key = createKey(masterFp, accountPath, accountXpub);
+    const p = new WalletPolicy(accountType, key);
+    return await this.signPsbt(psbt, p);
+  }
+
+  private async setInput(
+    psbt: PsbtV2,
+    i: number,
+    input: [
+      Transaction,
+      number,
+      string | null | undefined,
+      number | null | undefined
+    ],
+    pathElements: number[],
+    accountType: AccountType,
+    masterFP: Buffer
+  ): Promise<void> {
+    const inputTx = input[0];
+    const spentOutputIndex = input[1];
+    const redeemScript = input[2];
+    const sequence = input[3];
+    if (sequence) {
+      psbt.setInputSequence(i, sequence);
+    }
+    const inputTxBuffer = serializeTransaction(inputTx, true);
+    const inputTxid = crypto.hash256(inputTxBuffer);
+    const xpubBase58 = await this.client.getPubkey(false, pathElements);
+
+    const pubkey = pubkeyFromXpub(xpubBase58);
+    if (!inputTx.outputs)
+      throw Error("Missing outputs array in transaction to sign");
+    const spentOutput = inputTx.outputs[spentOutputIndex];
+
+    if (accountType == AccountType.p2pkh) {
+      psbt.setInputNonWitnessUtxo(i, inputTxBuffer);
+      psbt.setInputBip32Derivation(i, pubkey, masterFP, pathElements);
+    } else if (accountType == AccountType.p2wpkh) {
+      psbt.setInputNonWitnessUtxo(i, inputTxBuffer);
+      psbt.setInputBip32Derivation(i, pubkey, masterFP, pathElements);
+      psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.script);
+    } else if (accountType == AccountType.p2wpkhWrapped) {
+      psbt.setInputNonWitnessUtxo(i, inputTxBuffer);
+      psbt.setInputBip32Derivation(i, pubkey, masterFP, pathElements);
+      if (!redeemScript) {
+        throw new Error("Missing redeemScript for p2wpkhWrapped input");
+      }
+      const expectedRedeemScript = this.createRedeemScript(pubkey);
+      if (redeemScript != expectedRedeemScript.toString("hex")) {
+        throw new Error("Unexpected redeemScript");
+      }
+      psbt.setInputRedeemScript(i, expectedRedeemScript);
+      psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.script);
+    } else if (accountType == AccountType.p2tr) {
+      psbt.setInputTapBip32Derivation(i, pubkey, [], masterFP, pathElements);
+      psbt.setInputWitnessUtxo(i, spentOutput.amount, spentOutput.script);
+    }
+
+    psbt.setInputPreviousTxId(i, inputTxid);
+    psbt.setInputOutputIndex(i, spentOutputIndex);
+  }
+
+  private async signPsbt(
+    psbt: PsbtV2,
+    walletPolicy: WalletPolicy
+  ): Promise<string> {
+    const sigs: Map<number, Buffer> = await this.client.signPsbt(
+      psbt,
+      walletPolicy,
+      Buffer.alloc(32, 0)
+    );
+    sigs.forEach((v, k) => {
+      // Note: Looking at BIP32 derivation does not work in the generic case.
+      // some inputs might not have a BIP32-derived pubkey.
+      const pubkeys = psbt.getInputKeyDatas(k, psbtIn.BIP32_DERIVATION);
+      let pubkey;
+      if (pubkeys.length != 1) {
+        pubkey = psbt.getInputKeyDatas(k, psbtIn.TAP_BIP32_DERIVATION);
+        if (pubkey.length == 0) {
+          throw Error(`Missing pubkey derivation for input ${k}`);
+        }
+        psbt.setInputTapKeySig(k, v);
+      } else {
+        pubkey = pubkeys[0];
+        psbt.setInputPartialSig(k, pubkey, v);
+      }
+    });
+    finalize(psbt);
+    const serializedTx = extract(psbt);
+    return serializedTx.toString("hex");
+  }
+
+  private createRedeemScript(pubkey: Buffer): Buffer {
+    const pubkeyHash = hashPublicKey(pubkey);
+    return Buffer.concat([Buffer.from("0014", "hex"), pubkeyHash]);
+  }
+}
+
+enum AccountType {
+  p2pkh = "pkh(@0)",
+  p2wpkh = "wpkh(@0)",
+  p2wpkhWrapped = "sh(wpkh(@0))",
+  p2tr = "tr(@0)",
+}
+
+function accountTypeFrom(addressFormat: AddressFormat): AccountType {
+  if (addressFormat == "legacy") return AccountType.p2pkh;
+  if (addressFormat == "p2sh") return AccountType.p2wpkhWrapped;
+  if (addressFormat == "bech32") return AccountType.p2wpkh;
+  if (addressFormat == "bech32m") return AccountType.p2tr;
+  throw new Error("Unsupported address format " + addressFormat);
+}
+
+function accountTypeFromArg(arg: CreateTransactionArg): AccountType {
+  if (arg.additionals.includes("bech32m")) return AccountType.p2tr;
+  if (arg.additionals.includes("bech32")) return AccountType.p2wpkh;
+  if (arg.segwit) return AccountType.p2wpkhWrapped;
+  return AccountType.p2pkh;
+}

package/src/BtcOld.ts

@@ -0,0 +1,156 @@
+import type Transport from "@ledgerhq/hw-transport";
+import type { CreateTransactionArg } from "./createTransaction";
+import { createTransaction } from "./createTransaction";
+import type { AddressFormat } from "./getWalletPublicKey";
+import { getWalletPublicKey } from "./getWalletPublicKey";
+import { signMessage } from "./signMessage";
+import type { SignP2SHTransactionArg } from "./signP2SHTransaction";
+import { signP2SHTransaction } from "./signP2SHTransaction";
+export type { AddressFormat };
+/**
+ * Bitcoin API.
+ *
+ * @example
+ * import Btc from "@ledgerhq/hw-app-btc";
+ * const btc = new Btc(transport)
+ */
+
+export default class BtcOld {
+  transport: Transport;
+
+  constructor(transport: Transport) {
+    this.transport = transport;
+  }
+
+  /**
+   * @param path a BIP 32 path
+   * @param options an object with optional these fields:
+   *
+   * - verify (boolean) will ask user to confirm the address on the device
+   *
+   * - format ("legacy" | "p2sh" | "bech32" | "cashaddr") to use different bitcoin address formatter.
+   *
+   * NB The normal usage is to use:
+   *
+   * - legacy format with 44' paths
+   *
+   * - p2sh format with 49' paths
+   *
+   * - bech32 format with 173' paths
+   *
+   * - cashaddr in case of Bitcoin Cash
+   *
+   * @example
+   * btc.getWalletPublicKey("44'/0'/0'/0/0").then(o => o.bitcoinAddress)
+   * btc.getWalletPublicKey("49'/0'/0'/0/0", { format: "p2sh" }).then(o => o.bitcoinAddress)
+   */
+  getWalletPublicKey(
+    path: string,
+    opts?: {
+      verify?: boolean;
+      format?: AddressFormat;
+    }
+  ): Promise<{
+    publicKey: string;
+    bitcoinAddress: string;
+    chainCode: string;
+  }> {
+    if (opts?.format === "bech32m") {
+      throw new Error("Unsupported address format bech32m");
+    }
+    return getWalletPublicKey(this.transport, { ...opts, path });
+  }
+
+  /**
+   * You can sign a message according to the Bitcoin Signature format and retrieve v, r, s given the message and the BIP 32 path of the account to sign.
+   * @example
+   btc.signMessageNew_async("44'/60'/0'/0'/0", Buffer.from("test").toString("hex")).then(function(result) {
+     var v = result['v'] + 27 + 4;
+     var signature = Buffer.from(v.toString(16) + result['r'] + result['s'], 'hex').toString('base64');
+     console.log("Signature : " + signature);
+   }).catch(function(ex) {console.log(ex);});
+   */
+  signMessageNew(
+    path: string,
+    messageHex: string
+  ): Promise<{
+    v: number;
+    r: string;
+    s: string;
+  }> {
+    return signMessage(this.transport, {
+      path,
+      messageHex,
+    });
+  }
+
+  /**
+   * To sign a transaction involving standard (P2PKH) inputs, call createTransaction with the following parameters
+   * @param inputs is an array of [ transaction, output_index, optional redeem script, optional sequence ] where
+   *
+   * * transaction is the previously computed transaction object for this UTXO
+   * * output_index is the output in the transaction used as input for this UTXO (counting from 0)
+   * * redeem script is the optional redeem script to use when consuming a Segregated Witness input
+   * * sequence is the sequence number to use for this input (when using RBF), or non present
+   * @param associatedKeysets is an array of BIP 32 paths pointing to the path to the private key used for each UTXO
+   * @param changePath is an optional BIP 32 path pointing to the path to the public key used to compute the change address
+   * @param outputScriptHex is the hexadecimal serialized outputs of the transaction to sign
+   * @param lockTime is the optional lockTime of the transaction to sign, or default (0)
+   * @param sigHashType is the hash type of the transaction to sign, or default (all)
+   * @param segwit is an optional boolean indicating wether to use segwit or not
+   * @param initialTimestamp is an optional timestamp of the function call to use for coins that necessitate timestamps only, (not the one that the tx will include)
+   * @param additionals list of additionnal options
+   *
+   * - "bech32" for spending native segwit outputs
+   * - "abc" for bch
+   * - "gold" for btg
+   * - "bipxxx" for using BIPxxx
+   * - "sapling" to indicate a zec transaction is supporting sapling (to be set over block 419200)
+   * @param expiryHeight is an optional Buffer for zec overwinter / sapling Txs
+   * @param useTrustedInputForSegwit trust inputs for segwit transactions
+   * @return the signed transaction ready to be broadcast
+   * @example
+  btc.createTransaction({
+   inputs: [ [tx1, 1] ],
+   associatedKeysets: ["0'/0/0"],
+   outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
+  }).then(res => ...);
+   */
+  createPaymentTransactionNew(arg: CreateTransactionArg): Promise<string> {
+    if (arguments.length > 1) {
+      console.warn(
+        "@ledgerhq/hw-app-btc: createPaymentTransactionNew multi argument signature is deprecated. please switch to named parameters."
+      );
+    }
+    return createTransaction(this.transport, arg);
+  }
+
+  /**
+   * To obtain the signature of multisignature (P2SH) inputs, call signP2SHTransaction_async with the folowing parameters
+   * @param inputs is an array of [ transaction, output_index, redeem script, optional sequence ] where
+   * * transaction is the previously computed transaction object for this UTXO
+   * * output_index is the output in the transaction used as input for this UTXO (counting from 0)
+   * * redeem script is the mandatory redeem script associated to the current P2SH input
+   * * sequence is the sequence number to use for this input (when using RBF), or non present
+   * @param associatedKeysets is an array of BIP 32 paths pointing to the path to the private key used for each UTXO
+   * @param outputScriptHex is the hexadecimal serialized outputs of the transaction to sign
+   * @param lockTime is the optional lockTime of the transaction to sign, or default (0)
+   * @param sigHashType is the hash type of the transaction to sign, or default (all)
+   * @return the signed transaction ready to be broadcast
+   * @example
+  btc.signP2SHTransaction({
+  inputs: [ [tx, 1, "52210289b4a3ad52a919abd2bdd6920d8a6879b1e788c38aa76f0440a6f32a9f1996d02103a3393b1439d1693b063482c04bd40142db97bdf139eedd1b51ffb7070a37eac321030b9a409a1e476b0d5d17b804fcdb81cf30f9b99c6f3ae1178206e08bc500639853ae"] ],
+  associatedKeysets: ["0'/0/0"],
+  outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
+  }).then(result => ...);
+   */
+  signP2SHTransaction(arg: SignP2SHTransactionArg): Promise<string[]> {
+    if (arguments.length > 1) {
+      console.warn(
+        "@ledgerhq/hw-app-btc: signP2SHTransaction multi argument signature is deprecated. please switch to named parameters."
+      );
+    }
+
+    return signP2SHTransaction(this.transport, arg);
+  }
+}

package/src/bip32.ts

@@ -1,6 +1,7 @@
 import bippath from "bip32-path";
-export function bip32asBuffer(path: string): Buffer {
-  const paths = !path ? [] : bippath.fromString(path).toPathArray();
+import bs58check from "bs58check";
+
+export function pathElementsToBuffer(paths: number[]): Buffer {
   const buffer = Buffer.alloc(1 + paths.length * 4);
   buffer[0] = paths.length;
   paths.forEach((element, index) => {
@@ -8,3 +9,34 @@ export function bip32asBuffer(path: string): Buffer {
   });
   return buffer;
 }
+
+export function bip32asBuffer(path: string): Buffer {
+  const pathElements = !path ? [] : pathStringToArray(path);
+  return pathElementsToBuffer(pathElements);
+}
+
+export function pathArrayToString(pathElements: number[]): string {
+  // Limitation: bippath can't handle and empty path. It shouldn't affect us
+  // right now, but might in the future.
+  // TODO: Fix support for empty path.
+  return bippath.fromPathArray(pathElements).toString();
+}
+
+export function pathStringToArray(path: string): number[] {
+  return bippath.fromString(path).toPathArray();
+}
+
+export function pubkeyFromXpub(xpub: string): Buffer {
+  const xpubBuf = bs58check.decode(xpub);
+  return xpubBuf.slice(xpubBuf.length - 33);
+}
+
+export function getXpubComponents(
+  xpub: string
+): { chaincode: Buffer; pubkey: Buffer } {
+  const xpubBuf = bs58check.decode(xpub);
+  return {
+    chaincode: xpubBuf.slice(13, 13 + 32),
+    pubkey: xpubBuf.slice(xpubBuf.length - 33),
+  };
+}