@bitcoinerlab/descriptors-core 3.1.0

package/dist/scriptExpressions.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trLedger = exports.wpkhLedger = exports.shWpkhLedger = exports.pkhLedger = exports.trBIP32 = exports.wpkhBIP32 = exports.shWpkhBIP32 = exports.pkhBIP32 = void 0;
+const keyExpressions_1 = require("./keyExpressions");
+const networkUtils_1 = require("./networkUtils");
+const networks_1 = require("./networks");
+function assertStandardKeyPath(keyPath) {
+    // Regular expression to match "/change/index" or "/change/*" format
+    const regex = /^\/[01]\/(\d+|\*)$/;
+    if (!regex.test(keyPath)) {
+        throw new Error("Error: Key path must be in the format '/change/index', where change is either 0 or 1 and index is a non-negative integer.");
+    }
+}
+function standardExpressionsBIP32Maker(purpose, scriptTemplate) {
+    /**
+     * 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:'*'}`.
+     *
+     * @param {Object} params - The parameters object.
+     * @param {BIP32InterfaceLike | ScureHDKeyLike} params.masterNode - Root HD node.
+     * Pass a bitcoinjs {@link https://github.com/bitcoinjs/bip32 | `BIP32`} node
+     * or a scure {@link https://github.com/paulmillr/scure-bip32 | `HDKey`}.
+     * @param {number} params.account - BIP32 account index.
+     * @param {number} [params.change] - Branch index (0 receive / 1 change).
+     * @param {number | '*'} [params.index] - Address index or wildcard for ranged descriptors.
+     * @param {string} [params.keyPath] - Full path suffix (`/change/index`) alternative.
+     */
+    function standardScriptExpressionBIP32({ masterNode, network = networks_1.networks.bitcoin, keyPath, account, change, index, isPublic = true }) {
+        const originPath = `/${purpose}'/${(0, networkUtils_1.coinTypeFromNetwork)(network)}'/${account}'`;
+        if (keyPath !== undefined)
+            assertStandardKeyPath(keyPath);
+        const keyExpression = (0, keyExpressions_1.keyExpressionBIP32)({
+            masterNode,
+            originPath,
+            keyPath,
+            change,
+            index,
+            isPublic
+        });
+        return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
+    }
+    return standardScriptExpressionBIP32;
+}
+/** @function */
+exports.pkhBIP32 = standardExpressionsBIP32Maker(44, 'pkh(KEYEXPRESSION)');
+/** @function */
+exports.shWpkhBIP32 = standardExpressionsBIP32Maker(49, 'sh(wpkh(KEYEXPRESSION))');
+/** @function */
+exports.wpkhBIP32 = standardExpressionsBIP32Maker(84, 'wpkh(KEYEXPRESSION)');
+/** @function */
+exports.trBIP32 = standardExpressionsBIP32Maker(86, 'tr(KEYEXPRESSION)');
+function standardExpressionsLedgerMaker(purpose, scriptTemplate) {
+    /**
+     * 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:'*'}`.
+     */
+    async function standardScriptExpressionLedger({ ledgerManager, account, keyPath, change, index }) {
+        const { network } = ledgerManager;
+        const originPath = `/${purpose}'/${(0, networkUtils_1.coinTypeFromNetwork)(network)}'/${account}'`;
+        if (keyPath !== undefined)
+            assertStandardKeyPath(keyPath);
+        const keyExpression = await (0, keyExpressions_1.keyExpressionLedger)({
+            ledgerManager,
+            originPath,
+            keyPath,
+            change,
+            index
+        });
+        return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
+    }
+    return standardScriptExpressionLedger;
+}
+/** @function */
+exports.pkhLedger = standardExpressionsLedgerMaker(44, 'pkh(KEYEXPRESSION)');
+/** @function */
+exports.shWpkhLedger = standardExpressionsLedgerMaker(49, 'sh(wpkh(KEYEXPRESSION))');
+/** @function */
+exports.wpkhLedger = standardExpressionsLedgerMaker(84, 'wpkh(KEYEXPRESSION)');
+/** @function */
+exports.trLedger = standardExpressionsLedgerMaker(86, 'tr(KEYEXPRESSION)');

package/dist/scure.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Separate entry point for the @scure/btc-signer adapter.
+ */
+export { createScureLib } from './adapters/scure';

package/dist/scure.js

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScureLib = void 0;
+/**
+ * Separate entry point for the @scure/btc-signer adapter.
+ */
+var scure_1 = require("./adapters/scure");
+Object.defineProperty(exports, "createScureLib", { enumerable: true, get: function () { return scure_1.createScureLib; } });

package/dist/signers.d.ts

@@ -0,0 +1,161 @@
+import { type ScureTransactionLike, type ECPairInterfaceLike, type BIP32InterfaceLike, type ScureHDKeyLike, type PsbtLike } from './bitcoinLib';
+import { LedgerManager } from './ledger';
+/**
+ * Signs a specific input of a transaction with a bitcoinjs-lib `ECPair` signer.
+ *
+ * It detects Taproot inputs and applies key tweaking when needed before
+ * signing.
+ *
+ * For `@scure/btc-signer` transactions and raw private keys, use
+ * {@link signInputPrivKey}.
+ *
+ * @see https://github.com/bitcoinjs/bitcoinjs-lib/pull/2137#issuecomment-2713264848
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - A bitcoinjs-lib
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}.
+ * @param {number} params.index - The input index to sign
+ * @param {ECPairInterfaceLike} params.ecpair - A bitcoinjs
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ */
+export declare function signInputECPair({ psbt, index, ecpair }: {
+    psbt: PsbtLike;
+    index: number;
+    ecpair: ECPairInterfaceLike;
+}): void;
+/**
+ * Signs all inputs of a transaction with a bitcoinjs-lib `ECPair` signer.
+ *
+ * For each input, it detects Taproot and applies key tweaking when needed
+ * before signing.
+ *
+ * For `@scure/btc-signer` transactions and raw private keys, use
+ * {@link signPrivKey}.
+ *
+ * @see https://github.com/bitcoinjs/bitcoinjs-lib/pull/2137#issuecomment-2713264848
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - A bitcoinjs-lib
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}.
+ * @param {ECPairInterfaceLike} params.ecpair - A bitcoinjs
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ */
+export declare function signECPair({ psbt, ecpair }: {
+    psbt: PsbtLike;
+    ecpair: ECPairInterfaceLike;
+}): void;
+/**
+ * Signs one input of a `@scure/btc-signer` transaction with a raw private key.
+ *
+ * This helper is intended for scure users that work directly with a `Uint8Array`
+ * private key and may not use bitcoinjs-lib `ECPair` types.
+ *
+ * If you are signing a bitcoinjs-lib PSBT input, use {@link signInputECPair}
+ * and pass a bitcoinjs
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ *
+ * @param {Object} params - The parameters object
+ * @param {ScureTransactionLike} params.psbt - A scure
+ * {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {number} params.index - The input index to sign
+ * @param {Uint8Array} params.privKey - The secp256k1 private key (32 bytes)
+ * @throws If `psbt` is not a scure transaction
+ */
+export declare function signInputPrivKey({ psbt, index, privKey }: {
+    psbt: ScureTransactionLike;
+    index: number;
+    privKey: Uint8Array;
+}): void;
+/**
+ * Signs all inputs of a `@scure/btc-signer` transaction with a raw private key.
+ *
+ * This helper is intended for scure users that work directly with a `Uint8Array`
+ * private key and may not use bitcoinjs-lib `ECPair` types.
+ *
+ * If you are signing a bitcoinjs-lib PSBT, use {@link signECPair} and pass a
+ * bitcoinjs {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ *
+ * @param {Object} params - The parameters object
+ * @param {ScureTransactionLike} params.psbt - A scure
+ * {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {Uint8Array} params.privKey - The secp256k1 private key (32 bytes)
+ * @throws If `psbt` is not a scure transaction
+ */
+export declare function signPrivKey({ psbt, privKey }: {
+    psbt: ScureTransactionLike;
+    privKey: Uint8Array;
+}): void;
+/**
+ * Signs one input of a transaction using an HD node.
+ * Supports both bitcoinjs PSBT and scure Transaction inputs; bitcoinjs calls
+ * also apply the local HD-signing compatibility patch before signing.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike | ScureTransactionLike} params.psbt - Pass a
+ * bitcoinjs-lib {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}
+ * or a scure {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {number} params.index - The input index to sign
+ * @param {BIP32InterfaceLike | ScureHDKeyLike} params.node - Pass a bitcoinjs
+ * {@link https://github.com/bitcoinjs/bip32 | `BIP32`} node or a scure
+ * {@link https://github.com/paulmillr/scure-bip32 | `HDKey`} node.
+ */
+export declare function signInputBIP32({ psbt, index, node }: {
+    psbt: PsbtLike | ScureTransactionLike;
+    index: number;
+    node: BIP32InterfaceLike | ScureHDKeyLike;
+}): void;
+/**
+ * Signs all signable inputs of a transaction using an HD node.
+ * Supports both bitcoinjs PSBT and scure Transaction inputs; bitcoinjs calls
+ * also apply the local HD-signing compatibility patch before signing.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike | ScureTransactionLike} params.psbt - Pass a
+ * bitcoinjs-lib {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}
+ * or a scure {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {BIP32InterfaceLike | ScureHDKeyLike} params.masterNode - Pass a
+ * bitcoinjs {@link https://github.com/bitcoinjs/bip32 | `BIP32`} node or a
+ * scure {@link https://github.com/paulmillr/scure-bip32 | `HDKey`} node.
+ */
+export declare function signBIP32({ psbt, masterNode }: {
+    psbt: PsbtLike | ScureTransactionLike;
+    masterNode: BIP32InterfaceLike | ScureHDKeyLike;
+}): 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.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike | ScureTransactionLike} params.psbt - Pass a bitcoinjs-lib
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}
+ * or a scure {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {number} params.index - The input index to sign.
+ * @param {LedgerManager} params.ledgerManager - Ledger client/state manager.
+ */
+export declare function signInputLedger({ psbt, index, ledgerManager }: {
+    psbt: PsbtLike | ScureTransactionLike;
+    index: number;
+    ledgerManager: LedgerManager;
+}): 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.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike | ScureTransactionLike} params.psbt - Pass a bitcoinjs-lib
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}
+ * or a scure {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {LedgerManager} params.ledgerManager - Ledger client/state manager.
+ */
+export declare function signLedger({ psbt, ledgerManager }: {
+    psbt: PsbtLike | ScureTransactionLike;
+    ledgerManager: LedgerManager;
+}): Promise<void>;

package/dist/signers.js

@@ -0,0 +1,324 @@
+"use strict";
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signInputECPair = signInputECPair;
+exports.signECPair = signECPair;
+exports.signInputPrivKey = signInputPrivKey;
+exports.signPrivKey = signPrivKey;
+exports.signInputBIP32 = signInputBIP32;
+exports.signBIP32 = signBIP32;
+exports.signInputLedger = signInputLedger;
+exports.signLedger = signLedger;
+const bitcoinLib_1 = require("./bitcoinLib");
+const psbt_1 = require("./psbt");
+const keyInterfaces_1 = require("./keyInterfaces");
+const bitcoinjs_lib_internals_1 = require("./bitcoinjs-lib-internals");
+const ledger_1 = require("./ledger");
+/**
+ * This applies a bitcoinjs-lib speciffic patch.
+ * This won't be run if using the scure lib
+ */
+function ensureBitcoinjsHdPatch(psbt) {
+    let BitcoinjsPsbt;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        ({ Psbt: BitcoinjsPsbt } = require('bitcoinjs-lib'));
+    }
+    catch (error) {
+        void error;
+        return;
+    }
+    if (!BitcoinjsPsbt || !(psbt instanceof BitcoinjsPsbt))
+        return;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { applyPR2137 } = require('./adapters/applyPR2137');
+    applyPR2137(psbt);
+}
+function signInputSingleKey({ psbt, index, ecpair }) {
+    //psbt.signInput(index, ecpair); <- Replaced for the code below
+    //that can handle taproot inputs automatically.
+    //See https://github.com/bitcoinjs/bitcoinjs-lib/pull/2137#issuecomment-2713264848
+    const input = psbt.data.inputs[index];
+    if (!input)
+        throw new Error('Invalid index');
+    if ((0, bitcoinjs_lib_internals_1.isTaprootInput)(input)) {
+        // If script-path (tapLeafScript present) -> DO NOT TWEAK
+        if (input.tapLeafScript && input.tapLeafScript.length > 0)
+            psbt.signInput(index, ecpair);
+        else {
+            const hash = (0, bitcoinjs_lib_internals_1.tapTweakHash)(ecpair.publicKey.slice(1, 33), undefined);
+            const tweakedEcpair = ecpair.tweak(hash);
+            psbt.signInput(index, tweakedEcpair);
+        }
+    }
+    else
+        psbt.signInput(index, ecpair);
+}
+function signSingleKey({ psbt, ecpair }) {
+    let signedAny = false;
+    for (let index = 0; index < psbt.data.inputs.length; index++) {
+        try {
+            signInputSingleKey({ psbt, index, ecpair });
+            signedAny = true;
+        }
+        catch (err) {
+            void err;
+        }
+    }
+    if (!signedAny)
+        throw new Error('No inputs were signed');
+}
+/**
+ * Signs a specific input of a transaction with a bitcoinjs-lib `ECPair` signer.
+ *
+ * It detects Taproot inputs and applies key tweaking when needed before
+ * signing.
+ *
+ * For `@scure/btc-signer` transactions and raw private keys, use
+ * {@link signInputPrivKey}.
+ *
+ * @see https://github.com/bitcoinjs/bitcoinjs-lib/pull/2137#issuecomment-2713264848
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - A bitcoinjs-lib
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}.
+ * @param {number} params.index - The input index to sign
+ * @param {ECPairInterfaceLike} params.ecpair - A bitcoinjs
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ */
+function signInputECPair({ psbt, index, ecpair }) {
+    if ((0, bitcoinLib_1.isScureTransaction)(psbt))
+        throw new Error('Error: signInputECPair is only supported with bitcoinjs-lib PSBTs. ' +
+            'Use signInputPrivKey for @scure/btc-signer transactions.');
+    signInputSingleKey({ psbt, index, ecpair });
+}
+/**
+ * Signs all inputs of a transaction with a bitcoinjs-lib `ECPair` signer.
+ *
+ * For each input, it detects Taproot and applies key tweaking when needed
+ * before signing.
+ *
+ * For `@scure/btc-signer` transactions and raw private keys, use
+ * {@link signPrivKey}.
+ *
+ * @see https://github.com/bitcoinjs/bitcoinjs-lib/pull/2137#issuecomment-2713264848
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - A bitcoinjs-lib
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}.
+ * @param {ECPairInterfaceLike} params.ecpair - A bitcoinjs
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ */
+function signECPair({ psbt, ecpair }) {
+    if ((0, bitcoinLib_1.isScureTransaction)(psbt))
+        throw new Error('Error: signECPair is only supported with bitcoinjs-lib PSBTs. ' +
+            'Use signPrivKey for @scure/btc-signer transactions.');
+    signSingleKey({ psbt, ecpair });
+}
+/**
+ * Signs one input of a `@scure/btc-signer` transaction with a raw private key.
+ *
+ * This helper is intended for scure users that work directly with a `Uint8Array`
+ * private key and may not use bitcoinjs-lib `ECPair` types.
+ *
+ * If you are signing a bitcoinjs-lib PSBT input, use {@link signInputECPair}
+ * and pass a bitcoinjs
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ *
+ * @param {Object} params - The parameters object
+ * @param {ScureTransactionLike} params.psbt - A scure
+ * {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {number} params.index - The input index to sign
+ * @param {Uint8Array} params.privKey - The secp256k1 private key (32 bytes)
+ * @throws If `psbt` is not a scure transaction
+ */
+function signInputPrivKey({ psbt, index, privKey }) {
+    if (!(0, bitcoinLib_1.isScureTransaction)(psbt)) {
+        throw new Error('Error: signInputPrivKey is only supported with @scure/btc-signer transactions. ' +
+            'Use signInputECPair for bitcoinjs-lib PSBTs.');
+    }
+    signInputSingleKey({
+        psbt: (0, psbt_1.toPsbt)(psbt),
+        index,
+        ecpair: (0, keyInterfaces_1.toECPairInterface)(privKey)
+    });
+}
+/**
+ * Signs all inputs of a `@scure/btc-signer` transaction with a raw private key.
+ *
+ * This helper is intended for scure users that work directly with a `Uint8Array`
+ * private key and may not use bitcoinjs-lib `ECPair` types.
+ *
+ * If you are signing a bitcoinjs-lib PSBT, use {@link signECPair} and pass a
+ * bitcoinjs {@link https://github.com/bitcoinjs/ecpair | `ECPair`} signer.
+ *
+ * @param {Object} params - The parameters object
+ * @param {ScureTransactionLike} params.psbt - A scure
+ * {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {Uint8Array} params.privKey - The secp256k1 private key (32 bytes)
+ * @throws If `psbt` is not a scure transaction
+ */
+function signPrivKey({ psbt, privKey }) {
+    if (!(0, bitcoinLib_1.isScureTransaction)(psbt)) {
+        throw new Error('Error: signPrivKey is only supported with @scure/btc-signer transactions. ' +
+            'Use signECPair for bitcoinjs-lib PSBTs.');
+    }
+    signSingleKey({ psbt: (0, psbt_1.toPsbt)(psbt), ecpair: (0, keyInterfaces_1.toECPairInterface)(privKey) });
+}
+/**
+ * Signs one input of a transaction using an HD node.
+ * Supports both bitcoinjs PSBT and scure Transaction inputs; bitcoinjs calls
+ * also apply the local HD-signing compatibility patch before signing.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike | ScureTransactionLike} params.psbt - Pass a
+ * bitcoinjs-lib {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}
+ * or a scure {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {number} params.index - The input index to sign
+ * @param {BIP32InterfaceLike | ScureHDKeyLike} params.node - Pass a bitcoinjs
+ * {@link https://github.com/bitcoinjs/bip32 | `BIP32`} node or a scure
+ * {@link https://github.com/paulmillr/scure-bip32 | `HDKey`} node.
+ */
+function signInputBIP32({ psbt, index, node }) {
+    node = (0, keyInterfaces_1.toBIP32Interface)(node);
+    psbt = (0, psbt_1.toPsbt)(psbt);
+    ensureBitcoinjsHdPatch(psbt);
+    psbt.signInputHD(index, node);
+}
+/**
+ * Signs all signable inputs of a transaction using an HD node.
+ * Supports both bitcoinjs PSBT and scure Transaction inputs; bitcoinjs calls
+ * also apply the local HD-signing compatibility patch before signing.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike | ScureTransactionLike} params.psbt - Pass a
+ * bitcoinjs-lib {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | `Psbt`}
+ * or a scure {@link https://github.com/paulmillr/scure-btc-signer | `Transaction`}.
+ * @param {BIP32InterfaceLike | ScureHDKeyLike} params.masterNode - Pass a
+ * bitcoinjs {@link https://github.com/bitcoinjs/bip32 | `BIP32`} node or a
+ * scure {@link https://github.com/paulmillr/scure-bip32 | `HDKey`} node.
+ */
+function signBIP32({ psbt, masterNode }) {
+    masterNode = (0, keyInterfaces_1.toBIP32Interface)(masterNode);
+    psbt = (0, psbt_1.toPsbt)(psbt);
+    ensureBitcoinjsHdPatch(psbt);
+    psbt.signAllInputsHD(masterNode);
+}
+const ledgerSignaturesForInputIndex = (index, ledgerSignatures) => ledgerSignatures
+    .filter(([i]) => i === index)
+    .map(([_i, partialSignature]) => partialSignature);
+function addLedgerSignaturesToInput({ psbt, index, ledgerSignatures }) {
+    const input = psbt.data.inputs[index];
+    if (!input)
+        throw new Error(`Error: input ${index} not available`);
+    const signatures = ledgerSignaturesForInputIndex(index, ledgerSignatures);
+    if (signatures.length === 0)
+        throw new Error(`Error: no ledger signatures found for input ${index}`);
+    if ((0, bitcoinjs_lib_internals_1.isTaprootInput)(input)) {
+        // Ledger returns per-input signatures as [pubkey, signature, tapleafHash?].
+        // For taproot we must map them to PSBT taproot fields (not partialSig):
+        // - signatures with tapleafHash -> tapScriptSig[] (script-path)
+        // - signature without tapleafHash -> tapKeySig (key-path)
+        // A taproot input may contain script-path signatures, key-path signature,
+        // or both in edge cases; each must be written to its corresponding field.
+        const tapScriptSig = signatures
+            .filter((sig) => sig.tapleafHash)
+            .map((sig) => ({
+            pubkey: sig.pubkey,
+            signature: sig.signature,
+            leafHash: sig.tapleafHash
+        }));
+        const tapKeySigs = signatures.filter((sig) => !sig.tapleafHash);
+        if (tapScriptSig.length > 0) {
+            psbt.updateInput(index, { tapScriptSig });
+        }
+        if (tapKeySigs.length > 1)
+            throw new Error(`Error: expected at most one tapKeySig for input ${index}`);
+        const tapKeySig = tapKeySigs[0]?.signature;
+        if (tapKeySig) {
+            psbt.updateInput(index, { tapKeySig });
+        }
+        if (tapScriptSig.length === 0 && !tapKeySig)
+            throw new Error(`Error: no valid taproot ledger signatures found for input ${index}`);
+    }
+    else {
+        const partialSig = signatures.map((sig) => ({
+            pubkey: sig.pubkey,
+            signature: sig.signature
+        }));
+        psbt.updateInput(index, { partialSig });
+    }
+}
+async function signInputLedger({ psbt, index, ledgerManager }) {
+    psbt = (0, psbt_1.toPsbt)(psbt);
+    const { ledgerClient } = ledgerManager;
+    const { DefaultWalletPolicy, WalletPolicy, AppClient } = (await (0, ledger_1.importAndValidateLedgerBitcoin)(ledgerClient));
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
+    const policy = await (0, ledger_1.ledgerPolicyFromPsbtInput)({
+        psbt,
+        index,
+        ledgerManager
+    });
+    if (!policy)
+        throw new Error(`Error: the ledger cannot sign this pstb input`);
+    let ledgerSignatures;
+    if (policy.policyName && policy.policyHmac && policy.policyId) {
+        //non-standard policy
+        const walletPolicy = new WalletPolicy(policy.policyName, policy.ledgerTemplate, policy.keyRoots);
+        const walletHmac = policy.policyHmac;
+        ledgerSignatures = await ledgerClient.signPsbt(psbt.toBase64(), walletPolicy, walletHmac);
+    }
+    else {
+        //standard policy
+        ledgerSignatures = await ledgerClient.signPsbt(psbt.toBase64(), new DefaultWalletPolicy(policy.ledgerTemplate, policy.keyRoots[0]), null);
+    }
+    addLedgerSignaturesToInput({ psbt, index, ledgerSignatures });
+}
+async function signLedger({ psbt, ledgerManager }) {
+    psbt = (0, psbt_1.toPsbt)(psbt);
+    const { ledgerClient } = ledgerManager;
+    const { DefaultWalletPolicy, WalletPolicy, AppClient } = (await (0, ledger_1.importAndValidateLedgerBitcoin)(ledgerClient));
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
+    const ledgerPolicies = [];
+    for (let index = 0; index < psbt.data.inputs.length; index++) {
+        const policy = await (0, ledger_1.ledgerPolicyFromPsbtInput)({
+            psbt,
+            index,
+            ledgerManager
+        });
+        if (policy)
+            ledgerPolicies.push(policy);
+    }
+    if (ledgerPolicies.length === 0)
+        throw new Error(`Error: there are no inputs which could be signed`);
+    //cluster unique LedgerPolicies
+    const uniquePolicies = [];
+    for (const policy of ledgerPolicies) {
+        if (!uniquePolicies.find((uniquePolicy) => (0, ledger_1.comparePolicies)(uniquePolicy, policy)))
+            uniquePolicies.push(policy);
+    }
+    for (const uniquePolicy of uniquePolicies) {
+        let ledgerSignatures;
+        if (uniquePolicy.policyName &&
+            uniquePolicy.policyHmac &&
+            uniquePolicy.policyId) {
+            //non-standard policy
+            const walletPolicy = new WalletPolicy(uniquePolicy.policyName, uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots);
+            const walletHmac = uniquePolicy.policyHmac;
+            ledgerSignatures = await ledgerClient.signPsbt(psbt.toBase64(), walletPolicy, walletHmac);
+        }
+        else {
+            //standard policy
+            ledgerSignatures = await ledgerClient.signPsbt(psbt.toBase64(), new DefaultWalletPolicy(uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots[0]), null);
+        }
+        const signedIndexes = [
+            ...new Set(ledgerSignatures.map(([index]) => index))
+        ];
+        for (const index of signedIndexes) {
+            addLedgerSignaturesToInput({ psbt, index, ledgerSignatures });
+        }
+    }
+}