@ledgerhq/hw-app-btc 9.0.1-nightly.0 → 9.1.0-next.0

package/src/Btc.ts

@@ -1,9 +1,7 @@
 import type Transport from "@ledgerhq/hw-transport";
-import { pathStringToArray } from "./bip32";
-import BtcNew, { canSupportApp } from "./BtcNew";
+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 { AddressFormat } from "./getWalletPublicKey";
@@ -13,32 +11,51 @@ import type { SignP2SHTransactionArg } from "./signP2SHTransaction";
 import { splitTransaction } from "./splitTransaction";
 import type { Transaction } from "./types";
 export type { AddressFormat };
+import { signP2SHTransaction } from "./signP2SHTransaction";
+import { signMessage } from "./signMessage";
+import { checkIsBtcLegacy, getAppAndVersion } from "./getAppAndVersion";
+
 /**
  * Bitcoin API.
  *
  * @example
  * import Btc from "@ledgerhq/hw-app-btc";
- * const btc = new Btc(transport)
+ * const btc = new Btc({ transport, currency: "bitcoin" });
  */
 
 export default class Btc {
-  transport: Transport;
+  private _transport: Transport;
+  private _impl: BtcOld | BtcNew;
 
-  constructor(transport: Transport, scrambleKey = "BTC") {
-    this.transport = transport;
-    transport.decorateAppAPIMethods(
+  constructor({
+    transport,
+    scrambleKey = "BTC",
+    currency = "bitcoin",
+  }: {
+    transport: Transport;
+    scrambleKey?: string;
+    currency?: string;
+  }) {
+    this._transport = transport;
+    this._transport.decorateAppAPIMethods(
       this,
       [
         "getWalletXpub",
         "getWalletPublicKey",
         "signP2SHTransaction",
-        "signMessageNew",
-        "createPaymentTransactionNew",
+        "signMessage",
+        "createPaymentTransaction",
         "getTrustedInput",
         "getTrustedInputBIP143",
       ],
       scrambleKey
     );
+    // new APDU (nano app API) for bitcoin and old APDU for altcoin
+    if (currency === "bitcoin" || currency === "bitcoin_testnet") {
+      this._impl = new BtcNew(new AppClient(this._transport));
+    } else {
+      this._impl = new BtcOld(this._transport);
+    }
   }
 
   /**
@@ -49,7 +66,9 @@ export default class Btc {
    * @returns XPUB of the account
    */
   getWalletXpub(arg: { path: string; xpubVersion: number }): Promise<string> {
-    return this.getCorrectImpl().then((impl) => impl.getWalletXpub(arg));
+    return this.changeImplIfNecessary().then((impl) => {
+      return impl.getWalletXpub(arg);
+    });
   }
 
   /**
@@ -98,83 +117,21 @@ export default class Btc {
     } else {
       options = opts || {};
     }
-    return this.getCorrectImpl().then((impl) => {
-      /**
-       * Definition: A "normal path" is a prefix of a standard path where all
-       * the hardened steps of the standard path are included. For example, the
-       * paths m/44'/1'/17' and m/44'/1'/17'/1 are normal paths, but m/44'/1'
-       * is not. m/'199/1'/17'/0/1 is not a normal path either.
-       *
-       * There's a compatiblity issue between old and new app: When exporting
-       * the key of a non-normal path with verify=false, the new app would
-       * return an error, whereas the old app would return the key.
-       *
-       * See
-       * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/bitcoin.md#get_extended_pubkey
-       *
-       * If format bech32m is used, we'll not use old, because it doesn't
-       * support it.
-       *
-       * When to use new (given the app supports it)
-       *   * format is bech32m or
-       *   * path is normal or
-       *   * verify is true
-       *
-       * Otherwise use old.
-       */
-      if (
-        impl instanceof BtcNew &&
-        options.format != "bech32m" &&
-        (!options.verify || options.verify == false) &&
-        !isPathNormal(path)
-      ) {
-        console.warn(`WARNING: Using deprecated device protocol to get the public key because
-        
-        * a non-standard path is requested, and
-        * verify flag is false
-        
-        The new protocol only allows export of non-standard paths if the 
-        verify flag is true. Standard paths are (currently):
-
-        M/44'/(1|0)'/X'
-        M/49'/(1|0)'/X'
-        M/84'/(1|0)'/X'
-        M/86'/(1|0)'/X'
-        M/48'/(1|0)'/X'/Y'
-
-        followed by "", "(0|1)", or "(0|1)/b", where a and b are 
-        non-hardened. For example, the following paths are standard
-        
-        M/48'/1'/99'/7'
-        M/86'/1'/99'/0
-        M/48'/0'/99'/7'/1/17
-
-        The following paths are non-standard
-
-        M/48'/0'/99'           // Not deepest hardened path
-        M/48'/0'/99'/7'/1/17/2 // Too many non-hardened derivation steps
-        M/199'/0'/1'/0/88      // Not a known purpose 199
-        M/86'/1'/99'/2         // Change path item must be 0 or 1
-
-        This compatibility safeguard will be removed in the future.
-        Please consider calling Btc.getWalletXpub() instead.`);
-        return this.old().getWalletPublicKey(path, options);
-      } else {
-        return impl.getWalletPublicKey(path, options);
-      }
+    return this.changeImplIfNecessary().then((impl) => {
+      return impl.getWalletPublicKey(path, options);
     });
   }
 
   /**
    * 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) {
+   btc.signMessage("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(
+  signMessage(
     path: string,
     messageHex: string
   ): Promise<{
@@ -182,7 +139,10 @@ export default class Btc {
     r: string;
     s: string;
   }> {
-    return this.old().signMessageNew(path, messageHex);
+    return signMessage(this._transport, {
+      path,
+      messageHex,
+    });
   }
 
   /**
@@ -218,14 +178,14 @@ export default class Btc {
    outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
   }).then(res => ...);
    */
-  createPaymentTransactionNew(arg: CreateTransactionArg): Promise<string> {
+  createPaymentTransaction(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."
+      throw new Error(
+        "@ledgerhq/hw-app-btc: createPaymentTransaction multi argument signature is deprecated. please switch to named parameters."
       );
     }
-    return this.getCorrectImpl().then((impl) => {
-      return impl.createPaymentTransactionNew(arg);
+    return this.changeImplIfNecessary().then((impl) => {
+      return impl.createPaymentTransaction(arg);
     });
   }
 
@@ -249,7 +209,7 @@ export default class Btc {
   }).then(result => ...);
    */
   signP2SHTransaction(arg: SignP2SHTransactionArg): Promise<string[]> {
-    return this.old().signP2SHTransaction(arg);
+    return signP2SHTransaction(this._transport, arg);
   }
 
   /**
@@ -288,7 +248,7 @@ export default class Btc {
     additionals: Array<string> = []
   ): Promise<string> {
     return getTrustedInput(
-      this.transport,
+      this._transport,
       indexLookup,
       transaction,
       additionals
@@ -301,73 +261,21 @@ export default class Btc {
     additionals: Array<string> = []
   ): string {
     return getTrustedInputBIP143(
-      this.transport,
+      this._transport,
       indexLookup,
       transaction,
       additionals
     );
   }
 
-  // cache the underlying implementation (only once)
-  private _lazyImpl: BtcOld | BtcNew | null = null;
-  private async getCorrectImpl(): Promise<BtcOld | BtcNew> {
-    const { _lazyImpl } = this;
-    if (_lazyImpl) return _lazyImpl;
-    const impl = await this.inferCorrectImpl();
-    this._lazyImpl = impl;
-    return impl;
-  }
-
-  private async inferCorrectImpl(): Promise<BtcOld | BtcNew> {
-    const appAndVersion = await getAppAndVersion(this.transport);
-    const canUseNewImplementation = canSupportApp(appAndVersion);
-    if (!canUseNewImplementation) {
-      return this.old();
-    } else {
-      return this.new();
+  async changeImplIfNecessary(): Promise<BtcOld | BtcNew> {
+    const appAndVersion = await getAppAndVersion(this._transport);
+    if (appAndVersion.name === "Exchange" && this._impl instanceof BtcNew) {
+      const isBtcLegacy = await checkIsBtcLegacy(this._transport);
+      if (isBtcLegacy) {
+        this._impl = new BtcOld(this._transport);
+      }
     }
+    return this._impl;
   }
-
-  protected old(): BtcOld {
-    return new BtcOld(this.transport);
-  }
-
-  protected new(): BtcNew {
-    return new BtcNew(new AppClient(this.transport));
-  }
-}
-
-function isPathNormal(path: string): boolean {
-  //path is not deepest hardened node of a standard path or deeper, use BtcOld
-  const h = 0x80000000;
-  const pathElems = pathStringToArray(path);
-
-  const hard = (n: number) => n >= h;
-  const soft = (n: number | undefined) => !n || n < h;
-  const change = (n: number | undefined) => !n || n == 0 || n == 1;
-
-  if (
-    pathElems.length >= 3 &&
-    pathElems.length <= 5 &&
-    [44 + h, 49 + h, 84 + h, 86 + h].some((v) => v == pathElems[0]) &&
-    [0 + h, 1 + h].some((v) => v == pathElems[1]) &&
-    hard(pathElems[2]) &&
-    change(pathElems[3]) &&
-    soft(pathElems[4])
-  ) {
-    return true;
-  }
-  if (
-    pathElems.length >= 4 &&
-    pathElems.length <= 6 &&
-    48 + h == pathElems[0] &&
-    [0 + h, 1 + h].some((v) => v == pathElems[1]) &&
-    hard(pathElems[2]) &&
-    hard(pathElems[3]) &&
-    change(pathElems[4]) &&
-    soft(pathElems[5])
-  ) {
-    return true;
-  }
-  return false;
 }

package/src/BtcNew.ts

@@ -1,5 +1,4 @@
 import { crypto } from "bitcoinjs-lib";
-import semver from "semver";
 import { pointCompress } from "tiny-secp256k1";
 import {
   getXpubComponents,
@@ -10,7 +9,6 @@ import {
 } from "./bip32";
 import { BufferReader } from "./buffertools";
 import type { CreateTransactionArg } from "./createTransaction";
-import { AppAndVersion } from "./getAppAndVersion";
 import type { AddressFormat } from "./getWalletPublicKey";
 import {
   AccountType,
@@ -32,15 +30,6 @@ import { psbtIn, PsbtV2 } from "./newops/psbtv2";
 import { serializeTransaction } from "./serializeTransaction";
 import type { Transaction } from "./types";
 
-const newSupportedApps = ["Bitcoin", "Bitcoin Test"];
-
-export function canSupportApp(appAndVersion: AppAndVersion): boolean {
-  return (
-    newSupportedApps.includes(appAndVersion.name) &&
-    semver.major(appAndVersion.version) >= 2
-  );
-}
-
 /**
  * This class implements the same interface as BtcOld (formerly
  * named Btc), but interacts with Bitcoin hardware app version 2+
@@ -123,6 +112,9 @@ export default class BtcNew {
     bitcoinAddress: string;
     chainCode: string;
   }> {
+    if (!isPathNormal(path)) {
+      throw Error(`non-standard path: ${path}`);
+    }
     const pathElements: number[] = pathStringToArray(path);
     const xpub = await this.client.getExtendedPubkey(false, pathElements);
 
@@ -185,16 +177,14 @@ export default class BtcNew {
   }
 
   /**
-   * Build and sign a transaction. See Btc.createPaymentTransactionNew for
+   * Build and sign a transaction. See Btc.createPaymentTransaction for
    * details on how to use this method.
    *
    * This method will convert the legacy arguments, CreateTransactionArg, into
    * a psbt which is finally signed and finalized, and the extracted fully signed
    * transaction is returned.
    */
-  async createPaymentTransactionNew(
-    arg: CreateTransactionArg
-  ): Promise<string> {
+  async createPaymentTransaction(arg: CreateTransactionArg): Promise<string> {
     const inputCount = arg.inputs.length;
     if (inputCount == 0) {
       throw Error("No inputs");
@@ -453,3 +443,58 @@ function accountTypeFromArg(
   if (arg.segwit) return new p2wpkhWrapped(psbt, masterFp);
   return new p2pkh(psbt, masterFp);
 }
+
+/*
+  The new protocol only allows standard path.
+  Standard paths are (currently):
+  M/44'/(1|0)'/X'
+  M/49'/(1|0)'/X'
+  M/84'/(1|0)'/X'
+  M/86'/(1|0)'/X'
+  M/48'/(1|0)'/X'/Y'
+  followed by "", "(0|1)", or "(0|1)/b", where a and b are 
+  non-hardened. For example, the following paths are standard
+  M/48'/1'/99'/7'
+  M/86'/1'/99'/0
+  M/48'/0'/99'/7'/1/17
+  The following paths are non-standard
+  M/48'/0'/99'           // Not deepest hardened path
+  M/48'/0'/99'/7'/1/17/2 // Too many non-hardened derivation steps
+  M/199'/0'/1'/0/88      // Not a known purpose 199
+  M/86'/1'/99'/2         // Change path item must be 0 or 1
+*/
+function isPathNormal(path: string): boolean {
+  //path is not deepest hardened node of a standard path or deeper, use BtcOld
+  const h = 0x80000000; //HARDENED from bip32
+  const pathElems = pathStringToArray(path);
+
+  const hard = (n: number) => n >= h;
+  const soft = (n: number | undefined) => n === undefined || n < h;
+  const change = (n: number | undefined) =>
+    n === undefined || n === 0 || n === 1;
+
+  if (
+    pathElems.length >= 3 &&
+    pathElems.length <= 5 &&
+    [44 + h, 49 + h, 84 + h, 86 + h].some((v) => v == pathElems[0]) &&
+    [0 + h, 1 + h].some((v) => v == pathElems[1]) &&
+    hard(pathElems[2]) &&
+    change(pathElems[3]) &&
+    soft(pathElems[4])
+  ) {
+    return true;
+  }
+  if (
+    pathElems.length >= 4 &&
+    pathElems.length <= 6 &&
+    48 + h == pathElems[0] &&
+    [0 + h, 1 + h].some((v) => v == pathElems[1]) &&
+    hard(pathElems[2]) &&
+    hard(pathElems[3]) &&
+    change(pathElems[4]) &&
+    soft(pathElems[5])
+  ) {
+    return true;
+  }
+  return false;
+}

package/src/BtcOld.ts

@@ -6,9 +6,6 @@ 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";
 import { pathArrayToString, pathStringToArray } from "./bip32";
 export type { AddressFormat };
 
@@ -17,7 +14,7 @@ export type { AddressFormat };
  *
  * @example
  * import Btc from "@ledgerhq/hw-app-btc";
- * const btc = new Btc(transport)
+ * const btc = new Btc({ transport, currency: "zcash" });
  */
 
 export default class BtcOld {
@@ -99,29 +96,6 @@ export default class BtcOld {
     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
@@ -154,43 +128,14 @@ export default class BtcOld {
    outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
   }).then(res => ...);
    */
-  createPaymentTransactionNew(arg: CreateTransactionArg): Promise<string> {
+  createPaymentTransaction(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."
+      throw new Error(
+        "@ledgerhq/hw-app-btc: createPaymentTransaction 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);
-  }
 }
 
 function makeFingerprint(compressedPubKey) {

package/src/getAppAndVersion.ts

@@ -26,3 +26,15 @@ export const getAppAndVersion = async (
     flags,
   };
 };
+
+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);
+  } catch (e: unknown) {
+    return false;
+  }
+  return true;
+};