@bitcoinerlab/descriptors 0.3.1 → 1.0.0

package/README.md

@@ -273,15 +273,26 @@ To finalize the `psbt`, you can either call the method `finalizePsbtInput({ inde
 
 This library currently provides integration with Ledger wallets. Support for more devices is planned.
 
-To use a Ledger device for signing, you can import the necessary functions as follows:
+Before we dive in, note that, in addition to the documentation below, it is highly recommended to visit the [Ledger Playground](https://bitcoinerlab.com/guides/ledger-programming) with an interactive code sandbox of this lib interacting with a Ledger device.
+
+To use this library with Ledger devices, you must first install Ledger support:
+
+```bash
+npm install ledger-bitcoin
+```
+
+For Ledger device signing, import the necessary functions as follows:
 
 ```javascript
+import Transport from '@ledgerhq/hw-transport-node-hid'; //or hw-transport-web-hid, for web
+import { AppClient } from 'ledger-bitcoin';
 import { ledger } from '@bitcoinerlab/descriptors';
 ```
 
-You can then use the following code to assert that the Ledger app is running Bitcoin Test version 2.1.0 or higher, and to create a new Ledger client:
+Then, use the following code to assert that the Ledger app is running Bitcoin Test version 2.1.0 or higher, and to create a new Ledger client:
 
 ```javascript
+const transport = await Transport.create();
 //Throws if not running Bitcoin Test >= 2.1.0
 await ledger.assertLedgerApp({
   transport,
@@ -289,12 +300,12 @@ await ledger.assertLedgerApp({
   minVersion: '2.1.0'
 });
 
-const ledgerClient = new ledger.AppClient(transport);
+const ledgerClient = new AppClient(transport);
 ```
 
 Here, `transport` is an instance of a Transport object that allows communication with Ledger devices. You can use any of the transports [provided by Ledger](https://github.com/LedgerHQ/ledger-live#libs---libraries).
 
-To register the policies of non-standard descriptors on the Ledger device, you can use the following code:
+To register the policies of non-standard descriptors on the Ledger device, use the following code:
 
 ```javascript
 await ledger.registerLedgerWallet({
@@ -307,7 +318,7 @@ await ledger.registerLedgerWallet({
 
 This code will auto-skip the policy registration process if it already exists. Please refer to [Ledger documentation](https://github.com/LedgerHQ/app-bitcoin-new/blob/develop/doc/wallet.md) to learn more about their Wallet Policies registration procedures.
 
-Finally, `ledgerState` is an object used to store information related to Ledger devices. Although Ledger devices themselves are stateless, this object can be used to store information such as xpubs, master fingerprints, and wallet policies. You can pass an initially empty object that will be updated with more information as it is used. The object can be serialized and stored.
+Finally, `ledgerState` is an object used to store information related to Ledger devices. Although Ledger devices themselves are stateless, this object can be used to store information such as xpubs, master fingerprints, and wallet policies. You can pass an initially empty object that will be updated with more information as it is used. The object can be serialized and stored for future use.
 
 <a name="documentation"></a>
 

package/dist/index.d.ts

@@ -13,13 +13,11 @@ export declare function finalizePsbt({ psbt, descriptors, validate }: {
 export { keyExpressionBIP32, keyExpressionLedger } from './keyExpressions';
 import * as scriptExpressions from './scriptExpressions';
 export { scriptExpressions };
-import { AppClient } from 'ledger-bitcoin';
 import { LedgerState, getLedgerMasterFingerPrint, getLedgerXpub, registerLedgerWallet, assertLedgerApp } from './ledger';
 export declare const ledger: {
     getLedgerMasterFingerPrint: typeof getLedgerMasterFingerPrint;
     getLedgerXpub: typeof getLedgerXpub;
     registerLedgerWallet: typeof registerLedgerWallet;
     assertLedgerApp: typeof assertLedgerApp;
-    AppClient: typeof AppClient;
 };
 export type { LedgerState };

package/dist/index.js

@@ -42,12 +42,10 @@ Object.defineProperty(exports, "keyExpressionBIP32", { enumerable: true, get: fu
 Object.defineProperty(exports, "keyExpressionLedger", { enumerable: true, get: function () { return keyExpressions_1.keyExpressionLedger; } });
 const scriptExpressions = __importStar(require("./scriptExpressions"));
 exports.scriptExpressions = scriptExpressions;
-const ledger_bitcoin_1 = require("ledger-bitcoin");
 const ledger_1 = require("./ledger");
 exports.ledger = {
     getLedgerMasterFingerPrint: ledger_1.getLedgerMasterFingerPrint,
     getLedgerXpub: ledger_1.getLedgerXpub,
     registerLedgerWallet: ledger_1.registerLedgerWallet,
-    assertLedgerApp: ledger_1.assertLedgerApp,
-    AppClient: ledger_bitcoin_1.AppClient
+    assertLedgerApp: ledger_1.assertLedgerApp
 };

package/dist/keyExpressions.d.ts

@@ -3,7 +3,6 @@ import type { ECPairAPI } from 'ecpair';
 import type { BIP32API, BIP32Interface } from 'bip32';
 import type { KeyInfo } from './types';
 import { LedgerState } from './ledger';
-import type { AppClient } from 'ledger-bitcoin';
 export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network }: {
     keyExpression: string;
     network?: Network;
@@ -12,7 +11,7 @@ export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BI
     BIP32: BIP32API;
 }): KeyInfo;
 export declare function keyExpressionLedger({ ledgerClient, ledgerState, originPath, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     originPath: string;
     change?: number | undefined;

package/dist/ledger.d.ts

@@ -1,6 +1,24 @@
 /// <reference types="node" />
 import type { DescriptorInterface } from './types';
-import { AppClient } from 'ledger-bitcoin';
+/**
+ * Dynamically imports the 'ledger-bitcoin' module and, if provided, checks if `ledgerClient` is an instance of `AppClient`.
+ *
+ * @async
+ * @param {unknown} ledgerClient - An optional parameter that, if provided, is checked to see if it's an instance of `AppClient`.
+ * @throws {Error} Throws an error if `ledgerClient` is provided but is not an instance of `AppClient`.
+ * @throws {Error} Throws an error if the 'ledger-bitcoin' module cannot be imported. This typically indicates that the 'ledger-bitcoin' peer dependency is not installed.
+ * @returns {Promise<any>} Returns a promise that resolves with the entire 'ledger-bitcoin' module if it can be successfully imported.
+ *
+ * @example
+ *
+ * importAndValidateLedgerBitcoin(ledgerClient)
+ *   .then((module) => {
+ *     const { AppClient, PsbtV2, DefaultWalletPolicy, WalletPolicy, DefaultDescriptorTemplate, PartialSignature } = module;
+ *     // Use the imported objects...
+ *   })
+ *   .catch((error) => console.error(error));
+ */
+export declare function importAndValidateLedgerBitcoin(ledgerClient?: unknown): Promise<typeof import("ledger-bitcoin")>;
 export declare function assertLedgerApp({ transport, name, minVersion }: {
     transport: any;
     name: string;
@@ -21,12 +39,12 @@ export type LedgerState = {
     };
 };
 export declare function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<Buffer>;
 export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }: {
     originPath: string;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<string>;
 /**
@@ -56,7 +74,7 @@ export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }:
  */
 export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<{
     ledgerTemplate: string;
@@ -71,7 +89,7 @@ export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, led
  **/
 export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     policyName: string;
 }): Promise<void>;
@@ -80,7 +98,7 @@ export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerS
  **/
 export declare function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<LedgerPolicy | null>;
 export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPolicy): boolean;
@@ -89,6 +107,6 @@ export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPo
  **/
 export declare function ledgerPolicyFromState({ descriptor, ledgerClient, ledgerState }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<LedgerPolicy | null>;

package/dist/ledger.js

@@ -1,11 +1,66 @@
 "use strict";
 // Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
 // Distributed under the MIT software license
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ledgerPolicyFromState = exports.comparePolicies = exports.ledgerPolicyFromStandard = exports.registerLedgerWallet = exports.descriptorToLedgerFormat = exports.getLedgerXpub = exports.getLedgerMasterFingerPrint = exports.assertLedgerApp = void 0;
-const ledger_bitcoin_1 = require("ledger-bitcoin");
+exports.ledgerPolicyFromState = exports.comparePolicies = exports.ledgerPolicyFromStandard = exports.registerLedgerWallet = exports.descriptorToLedgerFormat = exports.getLedgerXpub = exports.getLedgerMasterFingerPrint = exports.assertLedgerApp = exports.importAndValidateLedgerBitcoin = void 0;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
 const re_1 = require("./re");
+/**
+ * Dynamically imports the 'ledger-bitcoin' module and, if provided, checks if `ledgerClient` is an instance of `AppClient`.
+ *
+ * @async
+ * @param {unknown} ledgerClient - An optional parameter that, if provided, is checked to see if it's an instance of `AppClient`.
+ * @throws {Error} Throws an error if `ledgerClient` is provided but is not an instance of `AppClient`.
+ * @throws {Error} Throws an error if the 'ledger-bitcoin' module cannot be imported. This typically indicates that the 'ledger-bitcoin' peer dependency is not installed.
+ * @returns {Promise<any>} Returns a promise that resolves with the entire 'ledger-bitcoin' module if it can be successfully imported.
+ *
+ * @example
+ *
+ * importAndValidateLedgerBitcoin(ledgerClient)
+ *   .then((module) => {
+ *     const { AppClient, PsbtV2, DefaultWalletPolicy, WalletPolicy, DefaultDescriptorTemplate, PartialSignature } = module;
+ *     // Use the imported objects...
+ *   })
+ *   .catch((error) => console.error(error));
+ */
+async function importAndValidateLedgerBitcoin(ledgerClient) {
+    let ledgerBitcoinModule;
+    try {
+        ledgerBitcoinModule = await Promise.resolve().then(() => __importStar(require('ledger-bitcoin')));
+    }
+    catch (error) {
+        throw new Error('Could not import "ledger-bitcoin". This is a peer dependency and needs to be installed explicitly. Please run "npm install ledger-bitcoin" to use Ledger Hardware Wallet functionality.');
+    }
+    const { AppClient } = ledgerBitcoinModule;
+    if (ledgerClient !== undefined && !(ledgerClient instanceof AppClient)) {
+        throw new Error('Error: invalid AppClient instance');
+    }
+    return ledgerBitcoinModule;
+}
+exports.importAndValidateLedgerBitcoin = importAndValidateLedgerBitcoin;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function ledgerAppInfo(transport) {
     const r = await transport.send(0xb0, 0x01, 0x00, 0x00);
@@ -60,6 +115,9 @@ function isLedgerStandard({ ledgerTemplate, keyRoots, network = bitcoinjs_lib_1.
     return false;
 }
 async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
+    const { AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     let masterFingerprint = ledgerState.masterFingerprint;
     if (!masterFingerprint) {
         masterFingerprint = Buffer.from(await ledgerClient.getMasterFingerprint(), 'hex');
@@ -69,6 +127,9 @@ async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
 }
 exports.getLedgerMasterFingerPrint = getLedgerMasterFingerPrint;
 async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
+    const { AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     if (!ledgerState.xpubs)
         ledgerState.xpubs = {};
     let xpub = ledgerState.xpubs[originPath];
@@ -80,6 +141,8 @@ async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
         catch (err) {
             xpub = await ledgerClient.getExtendedPubkey(`m${originPath}`, true);
         }
+        if (typeof xpub !== 'string')
+            throw new Error(`Error: ledgerClient did not return a valid xpub`);
         ledgerState.xpubs[originPath] = xpub;
     }
     return xpub;
@@ -179,6 +242,9 @@ exports.descriptorToLedgerFormat = descriptorToLedgerFormat;
  *
  **/
 async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }) {
+    const { WalletPolicy, AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     const result = await descriptorToLedgerFormat({
         descriptor,
         ledgerClient,
@@ -204,7 +270,7 @@ async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, pol
         //It already existed. No need to register it again.
     }
     else {
-        walletPolicy = new ledger_bitcoin_1.WalletPolicy(policyName, ledgerTemplate, keyRoots);
+        walletPolicy = new WalletPolicy(policyName, ledgerTemplate, keyRoots);
         let policyId;
         [policyId, policyHmac] = await ledgerClient.registerWallet(walletPolicy);
         const policy = {

package/dist/scriptExpressions.d.ts

@@ -1,4 +1,3 @@
-import type { AppClient } from 'ledger-bitcoin';
 import { Network } from 'bitcoinjs-lib';
 import type { LedgerState } from './ledger';
 import type { BIP32Interface } from 'bip32';
@@ -30,7 +29,7 @@ export declare const wpkhBIP32: ({ masterNode, network, keyPath, account, change
     isPublic?: boolean;
 }) => string;
 export declare const pkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     network?: Network;
     account: number;
@@ -39,7 +38,7 @@ export declare const pkhLedger: ({ ledgerClient, ledgerState, network, account,
     index?: number | undefined | '*';
 }) => Promise<string>;
 export declare const shWpkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     network?: Network;
     account: number;
@@ -48,7 +47,7 @@ export declare const shWpkhLedger: ({ ledgerClient, ledgerState, network, accoun
     index?: number | undefined | '*';
 }) => Promise<string>;
 export declare const wpkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     network?: Network;
     account: number;

package/dist/signers.d.ts

@@ -1,7 +1,6 @@
 import type { Psbt } from 'bitcoinjs-lib';
 import type { ECPairInterface } from 'ecpair';
 import type { BIP32Interface } from 'bip32';
-import { AppClient } from 'ledger-bitcoin';
 import type { DescriptorInterface } from './types';
 import { LedgerState } from './ledger';
 export declare function signInputECPair({ psbt, index, ecpair }: {
@@ -26,12 +25,12 @@ export declare function signInputLedger({ psbt, index, descriptor, ledgerClient,
     psbt: Psbt;
     index: number;
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<void>;
 export declare function signLedger({ psbt, descriptors, ledgerClient, ledgerState }: {
     psbt: Psbt;
     descriptors: DescriptorInterface[];
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<void>;

package/dist/signers.js

@@ -3,7 +3,6 @@
 // Distributed under the MIT software license
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signLedger = exports.signInputLedger = exports.signBIP32 = exports.signInputBIP32 = exports.signECPair = exports.signInputECPair = void 0;
-const ledger_bitcoin_1 = require("ledger-bitcoin");
 const ledger_1 = require("./ledger");
 function signInputECPair({ psbt, index, ecpair }) {
     psbt.signInput(index, ecpair);
@@ -28,6 +27,9 @@ const ledgerSignaturesForInputIndex = (index, ledgerSignatures) => ledgerSignatu
     signature: partialSignature.signature
 }));
 async function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerState }) {
+    const { PsbtV2, DefaultWalletPolicy, WalletPolicy, AppClient } = await (0, ledger_1.importAndValidateLedgerBitcoin)(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     const result = await (0, ledger_1.descriptorToLedgerFormat)({
         descriptor,
         ledgerClient,
@@ -43,7 +45,7 @@ async function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerSt
         ledgerState
     });
     if (standardPolicy) {
-        ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), new ledger_bitcoin_1.DefaultWalletPolicy(ledgerTemplate, keyRoots[0]), null);
+        ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), new DefaultWalletPolicy(ledgerTemplate, keyRoots[0]), null);
     }
     else {
         const policy = await (0, ledger_1.ledgerPolicyFromState)({
@@ -53,8 +55,8 @@ async function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerSt
         });
         if (!policy || !policy.policyName || !policy.policyHmac)
             throw new Error(`Error: the descriptor's policy is not registered`);
-        const walletPolicy = new ledger_bitcoin_1.WalletPolicy(policy.policyName, ledgerTemplate, keyRoots);
-        ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), walletPolicy, policy.policyHmac);
+        const walletPolicy = new WalletPolicy(policy.policyName, ledgerTemplate, keyRoots);
+        ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), walletPolicy, policy.policyHmac);
     }
     //Add the signatures to the Psbt object using PartialSig format:
     psbt.updateInput(index, {
@@ -66,6 +68,9 @@ exports.signInputLedger = signInputLedger;
 //it clusters together wallet policy types before signing
 //it throws if it cannot sign any input.
 async function signLedger({ psbt, descriptors, ledgerClient, ledgerState }) {
+    const { PsbtV2, DefaultWalletPolicy, WalletPolicy, AppClient } = await (0, ledger_1.importAndValidateLedgerBitcoin)(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     const ledgerPolicies = [];
     for (const descriptor of descriptors) {
         const policy = (await (0, ledger_1.ledgerPolicyFromState)({
@@ -95,12 +100,12 @@ async function signLedger({ psbt, descriptors, ledgerClient, ledgerState }) {
             uniquePolicy.policyHmac &&
             uniquePolicy.policyId) {
             //non-standard policy
-            const walletPolicy = new ledger_bitcoin_1.WalletPolicy(uniquePolicy.policyName, uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots);
-            ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), walletPolicy, uniquePolicy.policyHmac);
+            const walletPolicy = new WalletPolicy(uniquePolicy.policyName, uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots);
+            ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), walletPolicy, uniquePolicy.policyHmac);
         }
         else {
             //standard policy
-            ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), new ledger_bitcoin_1.DefaultWalletPolicy(uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots[0]), null);
+            ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), new DefaultWalletPolicy(uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots[0]), null);
         }
         for (const [index, ,] of ledgerSignatures) {
             psbt.updateInput(index, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitcoinerlab/descriptors",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "0.3.1",
+  "version": "1.0.0",
   "description": "This library parses and creates Bitcoin Miniscript Descriptors and generates Partially Signed Bitcoin Transactions (PSBTs). It provides PSBT finalizers and signers for single-signature, BIP32 and Hardware Wallets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,14 +52,20 @@
   "files": [
     "dist"
   ],
-  "COMMENT wrt ledger-bitcoin below": "ledger-bitcoin is installed using an alias. This package can be replaced with the official `ledger-bitcoin` npm package once [this PR](https://github.com/LedgerHQ/app-bitcoin-new/pull/147) is published to npm (likely in version > 0.2.1)",
   "dependencies": {
     "@bitcoinerlab/miniscript": "^1.2.1",
     "@bitcoinerlab/secp256k1": "^1.0.2",
     "bip32": "^3.1.0",
     "bitcoinjs-lib": "^6.1.0",
-    "ecpair": "^2.1.0",
-    "ledger-bitcoin": "npm:@bitcoinerlab/ledger@^0.2.0"
+    "ecpair": "^2.1.0"
+  },
+  "peerDependencies": {
+    "ledger-bitcoin": "^0.2.2"
+  },
+  "peerDependenciesMeta": {
+    "ledger-bitcoin": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@babel/plugin-transform-modules-commonjs": "^7.20.11",
@@ -77,6 +83,7 @@
     "fs": "^0.0.1-security",
     "jest": "^29.4.3",
     "jsdoc": "^3.6.11",
+    "ledger-bitcoin": "^0.2.2",
     "path": "^0.12.7",
     "prettier": "^2.8.8",
     "regtest-client": "^0.2.0",

package/README.draft.md

@@ -1,84 +0,0 @@
-A JavaScript library for parsing and signing Bitcoin descriptors, including those based on the Miniscript language.
-
-Key features:
-It allows signing using Hierarchical Deterministic keeps (those that use word mnemonics) and also Hardware Wallets (the Ledger wallet so far; more are comming).
-It integrates miniscript, making it super easy to program advanced transactions. For example, timelock-based vaults, multisigs vaults or inheritance are now a breeze.
-Dessigned to be used with psbt (Partially Signed Bitcion transactions) so that it can be used in mkuti-party scenarios.
-Can be used with Typescript and Javascript.
-Integrates with the bitcoinjs-lib family of modules.
-
-Usage:
-
-Installation:
-npm install @bitcoinerlab/descriptors
-
-Usage:
-
-This section describes how to use this library, starting from a very easy transaction and ends up using a smart contract that only allows spending a transaction after a certain time, providing a certain secret (a preimage) and can only be unlocked by co-signing with a Ledger wallet and a Software Wallet.
-
-We will show examples that have been run on the testnet network. We share the mnemonic we used so that you can replicate the transactions: . You won't be able to spend the transactions again but you will be able to replicate everything.
-
-```
-MNEMONIC: "drum turtle globe inherit autumn flavor slice illness sniff distance carbon elder"
-```
-
-TIP: you can use https://iancoleman.io/bip39/ to verify some of the steps below.
-
-Simple case using standard transactions:
-
-Let's start with an easy case. Let's send some sats from a Bitcoin Legacy address to a Segwit one.
-
-We are ready to use the library. Here we skip all initialization. You will be able to see the complete code on a shared repository with the tests.
-
-Examples are written using Javascript. If you want to use Typescript (recommended), please take a look to the test/integration folder for some advanced use use cases.
-Please, note that the code below is just for explanation purposes. When writting code for production you must assert all intermediate steps.
-
-```javascript
-//NETWORK is set to testnet
-const masterNode = BIP32.fromSeed(mnemonicToSeedSync(MNEMONIC), NETWORK);
-const descriptorLegacy = pkhBIP32({ masterNode, network: NETWORK, account: 0, change: 0, index: 1 });
-
-console.log(descriptorLegacy.getAddress()); //moovc1JqGrz4v6FA2U8ks8ZqjSwjv3yRKQ
-```
-
-So we sent some sats (`1679037`) to that address above. Those sats were sent in `TX_ID = "ee02b5a12c2f22e892bed376781fc9ed435f0d192a1b67ca47a7190804d8e868"`. [See it here](https://blockstream.info/testnet/tx/ee02b5a12c2f22e892bed376781fc9ed435f0d192a1b67ca47a7190804d8e868).
-
-Now let's spend them. We will send all the funds, except for a fee to our first internal address (change 1) in account 0 of the P2WPKH (Segwit) wallet:
-
-<!--https://coinfaucet.eu/en/btc-testnet/-->
-
-```javascript
-const TX_ID = "ee02b5a12c2f22e892bed376781fc9ed435f0d192a1b67ca47a7190804d8e868";
-const FEE = 100;
-
-//Define the Segwit descriptor where we will receive the sats:
-const descriptorSegwit = wpkhBIP32({ masterNode, network: NETWORK, account: 0, change: 1, index: 0 });
-
-//Get some info from the network about the Legacy utxo we will spend from:
-const txHex = await (await fetch(`https://blockstream.info/testnet/api/tx/${TX_ID}/hex`)).text();
-const txOuts = (await (await fetch(`https://blockstream.info/testnet/api/tx/${TX_ID}`)).json()).vout;
-const vout = txOuts.findIndex(txOut => txOut.scriptpubkey === descriptorLegacy.getScriptPubKey());
-const initialValue = txOut[vout].value; //1679037, as mentioned above
-
-//Create a transaction (Partially Signed Bitcoin Transaction) now:
-const psbt = new Psbt({network: NETWORK});
-//Update the transaction with the Legacy descriptor input:
-const legacyInputNumber = descriptorLegacy.updatePsbt({ psbt, vout, txHex });
-//Now add the Segwit address as the new output. Let's give some FEE to the miners
-psbt.addOutput({ address: descriptorSegwit.getAddress(), value: initialValue - FEE});
-
-//Sign the transaction, finalize it and submit it to the miners:
-signBIP32({ psbt, masterNode });
-descriptorLegacy.finalizePsbtInput({psbt, index: legacyInputNumber});
-const spendTx = psbt.extractTransaction();
-console.log(spendTx.getId()); //
-await fetch('https://blockstream.info/testnet/api/tx', {
-  method: 'POST',
-  body: spendTx.toHex()
-});
-```
-We have sent the 1679037 - 100 to ourselves in just a few lines.
-Easy! See the tx here: ....
-This has only started. Let's do really cool stuff now.
-
-