@bitcoinerlab/descriptors 1.0.2 → 2.0.0

package/dist/ledger.js

@@ -1,31 +1,31 @@
 "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 = exports.importAndValidateLedgerBitcoin = void 0;
+exports.ledgerPolicyFromState = exports.comparePolicies = exports.ledgerPolicyFromStandard = exports.registerLedgerWallet = exports.ledgerPolicyFromOutput = exports.ledgerPolicyFromPsbtInput = exports.getLedgerXpub = exports.getLedgerMasterFingerPrint = exports.assertLedgerApp = exports.importAndValidateLedgerBitcoin = void 0;
+/*
+ * Notes on Ledger implementation:
+ *
+ * Ledger assumes as external all keyRoots that do not have origin information.
+ *
+ * Some known Ledger Limitations (based on my tests as of Febr 2023):
+ *
+ * 1) All keyExpressions must be expanded into @i. In other words,
+ * this template is not valid:
+ * wsh(and_v(v:pk(03ed0b41d808b012b3a77dd7f6a30c4180dfbcab604133d90ce7593ec7f3e4037b),and_v(v:sha256(6c60f404f8167a38fc70eaf8aa17ac351023bef86bcb9d1086a19afe95bd5333),and_v(and_v(v:pk(@0/**),v:pk(@1/**)),older(5)))))
+ * (note the fixed 03ed0b41d808b012b3a77dd7f6a30c4180dfbcab604133d90ce7593ec7f3e4037b pubkey)
+ *
+ * 2) All elements in the keyRoot vector must be xpub-type (no xprv-type, no pubkey-type, ...)
+ *
+ * 3) All originPaths of the expressions in the keyRoot vector must be the same.
+ * On the other hand, an empty originPath is permitted for external keys.
+ *
+ * 4) Since all originPaths must be the same and originPaths for the Ledger are
+ * necessary, a Ledger device can only sign at most 1 key per policy and input.
+ *
+ * All the conditions above are checked in function ledgerPolicyFromOutput.
+ */
+const descriptors_1 = require("./descriptors");
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
 const re_1 = require("./re");
 /**
@@ -49,7 +49,18 @@ const re_1 = require("./re");
 async function importAndValidateLedgerBitcoin(ledgerClient) {
     let ledgerBitcoinModule;
     try {
-        ledgerBitcoinModule = await Promise.resolve().then(() => __importStar(require('ledger-bitcoin')));
+        // Originally, the code used dynamic imports:
+        // ledgerBitcoinModule = await import('ledger-bitcoin');
+        // However, in React Native with the Metro bundler, there's an issue with
+        // recognizing dynamic imports inside try-catch blocks. For details, refer to:
+        // https://github.com/react-native-community/discussions-and-proposals/issues/120
+        // The dynamic import gets transpiled to:
+        // ledgerBitcoinModule = Promise.resolve().then(() => __importStar(require('ledger-bitcoin')));
+        // Metro bundler fails to recognize the above as conditional. Hence, it tries
+        // to require 'ledger-bitcoin' unconditionally, leading to potential errors if
+        // 'ledger-bitcoin' is not installed (given it's an optional peerDependency).
+        // To bypass this, we directly use require:
+        ledgerBitcoinModule = 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.');
@@ -74,6 +85,15 @@ async function ledgerAppInfo(transport) {
     const flags = r.slice(i, (i += flagLength));
     return { name, version, flags, format };
 }
+/**
+ * Verifies if the Ledger device is connected, if the required Bitcoin App is opened,
+ * and if the version of the app meets the minimum requirements.
+ *
+ * @throws Will throw an error if the Ledger device is not connected, the required
+ * Bitcoin App is not opened, or if the version is below the required number.
+ *
+ * @returns Promise<void> - A promise that resolves if all assertions pass, or throws otherwise.
+ */
 async function assertLedgerApp({ transport, name, minVersion }) {
     const { name: openName, version } = await ledgerAppInfo(transport);
     if (openName !== name) {
@@ -114,7 +134,14 @@ function isLedgerStandard({ ledgerTemplate, keyRoots, network = bitcoinjs_lib_1.
         return true;
     return false;
 }
-async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
+/** @hidden */
+async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState, ledgerManager }) {
+    if (ledgerManager && (ledgerClient || ledgerState))
+        throw new Error(`ledgerClient and ledgerState have been deprecated`);
+    if (ledgerManager)
+        ({ ledgerClient, ledgerState } = ledgerManager);
+    if (!ledgerClient || !ledgerState)
+        throw new Error(`Could not retrieve ledgerClient or ledgerState`);
     const { AppClient } = (await importAndValidateLedgerBitcoin(ledgerClient));
     if (!(ledgerClient instanceof AppClient))
         throw new Error(`Error: pass a valid ledgerClient`);
@@ -126,7 +153,14 @@ async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
     return masterFingerprint;
 }
 exports.getLedgerMasterFingerPrint = getLedgerMasterFingerPrint;
-async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
+/** @hidden */
+async function getLedgerXpub({ originPath, ledgerClient, ledgerState, ledgerManager }) {
+    if (ledgerManager && (ledgerClient || ledgerState))
+        throw new Error(`ledgerClient and ledgerState have been deprecated`);
+    if (ledgerManager)
+        ({ ledgerClient, ledgerState } = ledgerManager);
+    if (!ledgerClient || !ledgerState)
+        throw new Error(`Could not retrieve ledgerClient or ledgerState`);
     const { AppClient } = (await importAndValidateLedgerBitcoin(ledgerClient));
     if (!(ledgerClient instanceof AppClient))
         throw new Error(`Error: pass a valid ledgerClient`);
@@ -149,7 +183,151 @@ async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
 }
 exports.getLedgerXpub = getLedgerXpub;
 /**
- * Takes a descriptor and gets its Ledger Wallet Policy, that is, its keyRoots and template.
+ * Checks whether there is a policy in ledgerState that the ledger
+ * could use to sign this psbt input.
+ *
+ * It found return the policy, otherwise, return undefined
+ *
+ * All considerations in the header of this file are applied
+ */
+async function ledgerPolicyFromPsbtInput({ ledgerManager, psbt, index }) {
+    const { ledgerState, ledgerClient, ecc, network } = ledgerManager;
+    const { Output } = (0, descriptors_1.DescriptorsFactory)(ecc);
+    const input = psbt.data.inputs[index];
+    if (!input)
+        throw new Error(`Input numer ${index} not set.`);
+    let scriptPubKey;
+    if (input.nonWitnessUtxo) {
+        const vout = psbt.txInputs[index]?.index;
+        if (vout === undefined)
+            throw new Error(`Could not extract vout from nonWitnessUtxo for input ${index}.`);
+        scriptPubKey = bitcoinjs_lib_1.Transaction.fromBuffer(input.nonWitnessUtxo).outs[vout]
+            ?.script;
+    }
+    else if (input.witnessUtxo) {
+        scriptPubKey = input.witnessUtxo.script;
+    }
+    if (!scriptPubKey)
+        throw new Error(`Could not retrieve scriptPubKey for input ${index}.`);
+    const bip32Derivations = input.bip32Derivation;
+    if (!bip32Derivations || !bip32Derivations.length)
+        throw new Error(`Input ${index} does not contain bip32 derivations.`);
+    const ledgerMasterFingerprint = await getLedgerMasterFingerPrint({
+        ledgerManager
+    });
+    for (const bip32Derivation of bip32Derivations) {
+        //get the keyRoot and keyPath. If it matches one of our policies then
+        //we are still not sure this is the policy that must be used yet
+        //So we must use the template and the keyRoot of each policy and compute the
+        //scriptPubKey:
+        if (Buffer.compare(bip32Derivation.masterFingerprint, ledgerMasterFingerprint) === 0) {
+            // Match /m followed by n consecutive hardened levels and then 2 consecutive unhardened levels:
+            const match = bip32Derivation.path.match(/m((\/\d+['hH])*)(\/\d+\/\d+)?/);
+            const originPath = match ? match[1] : undefined; //n consecutive hardened levels
+            const keyPath = match ? match[3] : undefined; //2 unhardened levels or undefined
+            if (originPath && keyPath) {
+                const [, strChange, strIndex] = keyPath.split('/');
+                if (!strChange || !strIndex)
+                    throw new Error(`keyPath ${keyPath} incorrectly extracted`);
+                const change = parseInt(strChange, 10);
+                const index = parseInt(strIndex, 10);
+                const coinType = network === bitcoinjs_lib_1.networks.bitcoin ? 0 : 1;
+                //standard policy candidate. This policy will be added to the pool
+                //of policies below and check if it produces the correct scriptPubKey
+                let standardPolicy;
+                if (change === 0 || change === 1) {
+                    const standardTemplate = originPath.match(new RegExp(`^/44'/${coinType}'/(\\d+)'$`))
+                        ? 'pkh(@0/**)'
+                        : originPath.match(new RegExp(`^/84'/${coinType}'/(\\d+)'$`))
+                            ? 'wpkh(@0/**)'
+                            : originPath.match(new RegExp(`^/49'/${coinType}'/(\\d+)'$`))
+                                ? 'sh(wpkh(@0/**))'
+                                : originPath.match(new RegExp(`^/86'/${coinType}'/(\\d+)'$`))
+                                    ? 'tr(@0/**)'
+                                    : undefined;
+                    if (standardTemplate) {
+                        const xpub = await getLedgerXpub({
+                            originPath,
+                            ledgerClient,
+                            ledgerState
+                        });
+                        standardPolicy = {
+                            ledgerTemplate: standardTemplate,
+                            keyRoots: [
+                                `[${ledgerMasterFingerprint.toString('hex')}${originPath}]${xpub}`
+                            ]
+                        };
+                    }
+                }
+                const policies = [...(ledgerState.policies || [])];
+                if (standardPolicy)
+                    policies.push(standardPolicy);
+                for (const policy of policies) {
+                    //Build the descriptor from the ledgerTemplate + keyRoots
+                    //then get the scriptPubKey
+                    let descriptor = policy.ledgerTemplate;
+                    // Replace change (making sure the value in the change level for the
+                    // template of the policy meets the change in bip32Derivation):
+                    descriptor = descriptor.replace(/\/\*\*/g, `/<0;1>/*`);
+                    const regExpMN = new RegExp(`/<(\\d+);(\\d+)>`, 'g');
+                    let matchMN;
+                    while (descriptor && (matchMN = regExpMN.exec(descriptor)) !== null) {
+                        const [M, N] = [
+                            parseInt(matchMN[1], 10),
+                            parseInt(matchMN[2], 10)
+                        ];
+                        if (M === change || N === change)
+                            descriptor = descriptor.replace(`/<${M};${N}>`, `/${change}`);
+                        else
+                            descriptor = undefined;
+                    }
+                    if (descriptor) {
+                        // Replace index:
+                        descriptor = descriptor.replace(/\/\*/g, `/${index}`);
+                        // Replace origin in reverse order to prevent
+                        // misreplacements, e.g., @10 being mistaken for @1 and leaving a 0.
+                        for (let i = policy.keyRoots.length - 1; i >= 0; i--) {
+                            const keyRoot = policy.keyRoots[i];
+                            if (!keyRoot)
+                                throw new Error(`keyRoot ${keyRoot} invalidly extracted.`);
+                            const match = keyRoot.match(/\[([^]+)\]/);
+                            const keyRootOrigin = match && match[1];
+                            if (keyRootOrigin) {
+                                const [, ...arrKeyRootOriginPath] = keyRootOrigin.split('/');
+                                const keyRootOriginPath = '/' + arrKeyRootOriginPath.join('/');
+                                //We check all origins to be the same even if they do not
+                                //belong to the ledger (read the header in this file)
+                                if (descriptor && keyRootOriginPath === originPath)
+                                    descriptor = descriptor.replace(new RegExp(`@${i}`, 'g'), keyRoot);
+                                else
+                                    descriptor = undefined;
+                            }
+                            else
+                                descriptor = undefined;
+                        }
+                        //verify the scriptPubKey from the input vs. the one obtained from
+                        //the policy after having filled in the keyPath in the template
+                        if (descriptor) {
+                            const policyScriptPubKey = new Output({
+                                descriptor,
+                                network
+                            }).getScriptPubKey();
+                            if (Buffer.compare(policyScriptPubKey, scriptPubKey) === 0) {
+                                return policy;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return;
+}
+exports.ledgerPolicyFromPsbtInput = ledgerPolicyFromPsbtInput;
+/**
+ * Given an output, it extracts its descriptor and converts it to a Ledger
+ * Wallet Policy, that is, its keyRoots and template.
+ *
  * keyRoots and template follow Ledger's specifications:
  * https://github.com/LedgerHQ/app-bitcoin-new/blob/develop/doc/wallet.md
  *
@@ -173,11 +351,11 @@ exports.getLedgerXpub = getLedgerXpub;
  * This function takes into account all the considerations regarding Ledger
  * policy implementation details expressed in the header of this file.
  */
-async function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState }) {
-    const expandedExpression = descriptor.expand().expandedExpression;
-    const expansionMap = descriptor.expand().expansionMap;
+async function ledgerPolicyFromOutput({ output, ledgerClient, ledgerState }) {
+    const expandedExpression = output.expand().expandedExpression;
+    const expansionMap = output.expand().expansionMap;
     if (!expandedExpression || !expansionMap)
-        throw new Error(`Error: invalid descriptor`);
+        throw new Error(`Error: invalid output`);
     const ledgerMasterFingerprint = await getLedgerMasterFingerPrint({
         ledgerClient,
         ledgerState
@@ -233,34 +411,57 @@ async function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState
     });
     return { ledgerTemplate, keyRoots };
 }
-exports.descriptorToLedgerFormat = descriptorToLedgerFormat;
+exports.ledgerPolicyFromOutput = ledgerPolicyFromOutput;
 /**
- * It registers a policy based on a descriptor. It stores it in ledgerState.
- *
- * If the policy was already registered, it does not register it.
- * If the policy is standard, it does not register it.
- *
+ * To be removed in v3.0 and replaced by a version that does not accept
+ * descriptors
+ * @hidden
  **/
-async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }) {
+async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, ledgerManager, policyName }) {
+    if (typeof descriptor !== 'string' && ledgerManager)
+        throw new Error(`Invalid usage: descriptor must be a string`);
+    if (ledgerManager && (ledgerClient || ledgerState))
+        throw new Error(`Invalid usage: either ledgerManager or ledgerClient + ledgerState`);
+    if (ledgerManager)
+        ({ ledgerClient, ledgerState } = ledgerManager);
+    if (!ledgerClient)
+        throw new Error(`ledgerManager not provided`);
+    if (!ledgerState)
+        throw new Error(`ledgerManager not provided`);
     const { WalletPolicy, AppClient } = (await importAndValidateLedgerBitcoin(ledgerClient));
     if (!(ledgerClient instanceof AppClient))
         throw new Error(`Error: pass a valid ledgerClient`);
-    const result = await descriptorToLedgerFormat({
-        descriptor,
+    let output;
+    if (typeof descriptor === 'string') {
+        if (!ledgerManager)
+            throw new Error(`ledgerManager not provided`);
+        const { Output } = (0, descriptors_1.DescriptorsFactory)(ledgerManager.ecc);
+        output = new Output({
+            descriptor,
+            ...(descriptor.includes('*') ? { index: 0 } : {}),
+            network: ledgerManager.network
+        });
+    }
+    else
+        output = descriptor;
+    if (await ledgerPolicyFromStandard({ output, ledgerClient, ledgerState }))
+        return;
+    const result = await ledgerPolicyFromOutput({
+        output,
         ledgerClient,
         ledgerState
     });
-    if (await ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }))
+    if (await ledgerPolicyFromStandard({ output, ledgerClient, ledgerState }))
         return;
     if (!result)
-        throw new Error(`Error: descriptor does not have a ledger input`);
+        throw new Error(`Error: output does not have a ledger input`);
     const { ledgerTemplate, keyRoots } = result;
     if (!ledgerState.policies)
         ledgerState.policies = [];
     let walletPolicy, policyHmac;
     //Search in ledgerState first
     const policy = await ledgerPolicyFromState({
-        descriptor,
+        output,
         ledgerClient,
         ledgerState
     });
@@ -287,9 +488,9 @@ exports.registerLedgerWallet = registerLedgerWallet;
 /**
  * Retrieve a standard ledger policy or null if it does correspond.
  **/
-async function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }) {
-    const result = await descriptorToLedgerFormat({
-        descriptor,
+async function ledgerPolicyFromStandard({ output, ledgerClient, ledgerState }) {
+    const result = await ledgerPolicyFromOutput({
+        output,
         ledgerClient,
         ledgerState
     });
@@ -299,7 +500,7 @@ async function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState
     if (isLedgerStandard({
         ledgerTemplate,
         keyRoots,
-        network: descriptor.getNetwork()
+        network: output.getNetwork()
     }))
         return { ledgerTemplate, keyRoots };
     return null;
@@ -324,14 +525,14 @@ exports.comparePolicies = comparePolicies;
 /**
  * Retrieve a ledger policy from ledgerState or null if it does not exist yet.
  **/
-async function ledgerPolicyFromState({ descriptor, ledgerClient, ledgerState }) {
-    const result = await descriptorToLedgerFormat({
-        descriptor,
+async function ledgerPolicyFromState({ output, ledgerClient, ledgerState }) {
+    const result = await ledgerPolicyFromOutput({
+        output,
         ledgerClient,
         ledgerState
     });
     if (!result)
-        throw new Error(`Error: descriptor does not have a ledger input`);
+        throw new Error(`Error: output does not have a ledger input`);
     const { ledgerTemplate, keyRoots } = result;
     if (!ledgerState.policies)
         ledgerState.policies = [];

package/dist/scriptExpressions.d.ts

@@ -1,57 +1,102 @@
 import { Network } from 'bitcoinjs-lib';
-import type { LedgerState } from './ledger';
+import type { LedgerState, LedgerManager } from './ledger';
 import type { BIP32Interface } from 'bip32';
 export declare const pkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
     masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
     network?: Network;
     account: number;
     change?: number | undefined;
     index?: number | undefined | '*';
     keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
     isPublic?: boolean;
 }) => string;
 export declare const shWpkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
     masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
     network?: Network;
     account: number;
     change?: number | undefined;
     index?: number | undefined | '*';
     keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
     isPublic?: boolean;
 }) => string;
 export declare const wpkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
     masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
     network?: Network;
     account: number;
     change?: number | undefined;
     index?: number | undefined | '*';
     keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
     isPublic?: boolean;
 }) => string;
-export declare const pkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-    network?: Network;
-    account: number;
-    keyPath?: string;
-    change?: number | undefined;
-    index?: number | undefined | '*';
-}) => Promise<string>;
-export declare const shWpkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-    network?: Network;
-    account: number;
-    keyPath?: string;
-    change?: number | undefined;
-    index?: number | undefined | '*';
-}) => Promise<string>;
-export declare const wpkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-    network?: Network;
-    account: number;
-    keyPath?: string;
-    change?: number | undefined;
-    index?: number | undefined | '*';
-}) => Promise<string>;
+export declare const pkhLedger: {
+    ({ ledgerManager, account, keyPath, change, index }: {
+        ledgerManager: LedgerManager;
+        account: number;
+        keyPath?: string;
+        change?: number | undefined;
+        index?: number | undefined | '*';
+    }): Promise<string>;
+    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
+        ledgerClient: unknown;
+        ledgerState: LedgerState;
+        /** @default networks.bitcoin */
+        network?: Network;
+        account: number;
+        keyPath?: string;
+        change?: number | undefined;
+        index?: number | undefined | '*';
+    }): Promise<string>;
+};
+export declare const shWpkhLedger: {
+    ({ ledgerManager, account, keyPath, change, index }: {
+        ledgerManager: LedgerManager;
+        account: number;
+        keyPath?: string;
+        change?: number | undefined;
+        index?: number | undefined | '*';
+    }): Promise<string>;
+    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
+        ledgerClient: unknown;
+        ledgerState: LedgerState;
+        /** @default networks.bitcoin */
+        network?: Network;
+        account: number;
+        keyPath?: string;
+        change?: number | undefined;
+        index?: number | undefined | '*';
+    }): Promise<string>;
+};
+export declare const wpkhLedger: {
+    ({ ledgerManager, account, keyPath, change, index }: {
+        ledgerManager: LedgerManager;
+        account: number;
+        keyPath?: string;
+        change?: number | undefined;
+        index?: number | undefined | '*';
+    }): Promise<string>;
+    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
+        ledgerClient: unknown;
+        ledgerState: LedgerState;
+        /** @default networks.bitcoin */
+        network?: Network;
+        account: number;
+        keyPath?: string;
+        change?: number | undefined;
+        index?: number | undefined | '*';
+    }): Promise<string>;
+};

package/dist/scriptExpressions.js

@@ -11,7 +11,20 @@ function assertStandardKeyPath(keyPath) {
     }
 }
 function standardExpressionsBIP32Maker(purpose, scriptTemplate) {
-    function standardKeyExpressionBIP32({ masterNode, network = bitcoinjs_lib_1.networks.bitcoin, keyPath, account, change, index, isPublic = true }) {
+    /**
+     * Computes the standard descriptor based on given parameters.
+     *
+     * You can define the output location either by:
+     * - Providing the full `keyPath` (e.g., "/0/2").
+     * OR
+     * - Specifying the `change` and `index` values separately (e.g., `{change:0, index:2}`).
+     *
+     * For ranged indexing, the `index` can be set as a wildcard '*'. For example:
+     * - `keyPath="/0/*"`
+     * OR
+     * - `{change:0, index:'*'}`.
+     */
+    function standardScriptExpressionBIP32({ masterNode, network = bitcoinjs_lib_1.networks.bitcoin, keyPath, account, change, index, isPublic = true }) {
         const originPath = `/${purpose}'/${network === bitcoinjs_lib_1.networks.bitcoin ? 0 : 1}'/${account}'`;
         if (keyPath !== undefined)
             assertStandardKeyPath(keyPath);
@@ -25,13 +38,22 @@ function standardExpressionsBIP32Maker(purpose, scriptTemplate) {
         });
         return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
     }
-    return standardKeyExpressionBIP32;
+    return standardScriptExpressionBIP32;
 }
 exports.pkhBIP32 = standardExpressionsBIP32Maker(44, 'pkh(KEYEXPRESSION)');
 exports.shWpkhBIP32 = standardExpressionsBIP32Maker(49, 'sh(wpkh(KEYEXPRESSION))');
 exports.wpkhBIP32 = standardExpressionsBIP32Maker(84, 'wpkh(KEYEXPRESSION)');
 function standardExpressionsLedgerMaker(purpose, scriptTemplate) {
-    async function standardKeyExpressionLedger({ ledgerClient, ledgerState, network = bitcoinjs_lib_1.networks.bitcoin, account, keyPath, change, index }) {
+    /** @hidden */
+    async function standardScriptExpressionLedger({ ledgerClient, ledgerState, ledgerManager, network = bitcoinjs_lib_1.networks.bitcoin, account, keyPath, change, index }) {
+        if (ledgerManager && (ledgerClient || ledgerState))
+            throw new Error(`ledgerClient and ledgerState have been deprecated`);
+        if (ledgerManager && network)
+            throw new Error(`ledgerManager already includes the network object`);
+        if (ledgerManager)
+            ({ ledgerClient, ledgerState, network } = ledgerManager);
+        if (!ledgerClient || !ledgerState)
+            throw new Error(`Could not retrieve ledgerClient or ledgerState`);
         const originPath = `/${purpose}'/${network === bitcoinjs_lib_1.networks.bitcoin ? 0 : 1}'/${account}'`;
         if (keyPath !== undefined)
             assertStandardKeyPath(keyPath);
@@ -45,7 +67,7 @@ function standardExpressionsLedgerMaker(purpose, scriptTemplate) {
         });
         return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
     }
-    return standardKeyExpressionLedger;
+    return standardScriptExpressionLedger;
 }
 exports.pkhLedger = standardExpressionsLedgerMaker(44, 'pkh(KEYEXPRESSION)');
 exports.shWpkhLedger = standardExpressionsLedgerMaker(49, 'sh(wpkh(KEYEXPRESSION))');

package/dist/signers.d.ts

@@ -1,8 +1,8 @@
 import type { Psbt } from 'bitcoinjs-lib';
 import type { ECPairInterface } from 'ecpair';
 import type { BIP32Interface } from 'bip32';
-import type { DescriptorInterface } from './types';
-import { LedgerState } from './ledger';
+import type { DescriptorInstance } from './descriptors';
+import { LedgerState, LedgerManager } from './ledger';
 export declare function signInputECPair({ psbt, index, ecpair }: {
     psbt: Psbt;
     index: number;
@@ -21,16 +21,49 @@ export declare function signBIP32({ psbt, masterNode }: {
     psbt: Psbt;
     masterNode: BIP32Interface;
 }): void;
+/**
+ * Signs an input of the `psbt` where the keys are controlled by a Ledger
+ * device.
+ *
+ * The function will throw an error if it's unable to sign the input.
+ */
+export declare function signInputLedger({ psbt, index, ledgerManager }: {
+    psbt: Psbt;
+    index: number;
+    ledgerManager: LedgerManager;
+}): Promise<void>;
+/**
+ * @deprecated
+ * @hidden
+ */
 export declare function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerState }: {
     psbt: Psbt;
     index: number;
-    descriptor: DescriptorInterface;
+    descriptor: DescriptorInstance;
     ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<void>;
+/**
+ * Signs the inputs of the `psbt` where the keys are controlled by a Ledger
+ * device.
+ *
+ * `signLedger` can sign multiple inputs of the same wallet policy in a single
+ * pass by grouping inputs by their wallet policy type before the signing
+ * process.
+ *
+ * The function will throw an error if it's unable to sign any input.
+ */
+export declare function signLedger({ psbt, ledgerManager }: {
+    psbt: Psbt;
+    ledgerManager: LedgerManager;
+}): Promise<void>;
+/**
+ * @deprecated
+ * @hidden
+ */
 export declare function signLedger({ psbt, descriptors, ledgerClient, ledgerState }: {
     psbt: Psbt;
-    descriptors: DescriptorInterface[];
+    descriptors: DescriptorInstance[];
     ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<void>;