@bitcoinerlab/descriptors 3.0.5 → 3.1.0

package/dist/index.d.ts

@@ -1,21 +0,0 @@
-export type { Expansion, ExpansionMap, KeyExpressionParser, KeyInfo, Preimage, TimeConstraints } from './types';
-export { DescriptorsFactory, OutputInstance, OutputConstructor } from './descriptors';
-export { DescriptorChecksum as checksum } from './checksum';
-import * as signers from './signers';
-export { signers };
-export { keyExpressionBIP32, keyExpressionLedger } from './keyExpressions';
-import * as scriptExpressions from './scriptExpressions';
-export { scriptExpressions };
-import { LedgerState, getLedgerMasterFingerPrint, getLedgerXpub, registerLedgerWallet, assertLedgerApp, LedgerManager } from './ledger';
-/** @namespace */
-export declare const ledger: {
-    /** @function */
-    getLedgerMasterFingerPrint: typeof getLedgerMasterFingerPrint;
-    /** @function */
-    getLedgerXpub: typeof getLedgerXpub;
-    /** @function */
-    registerLedgerWallet: typeof registerLedgerWallet;
-    /** @function */
-    assertLedgerApp: typeof assertLedgerApp;
-};
-export type { LedgerState, LedgerManager };

package/dist/index.js

@@ -1,85 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ledger = exports.scriptExpressions = exports.keyExpressionLedger = exports.keyExpressionBIP32 = exports.signers = exports.checksum = exports.DescriptorsFactory = void 0;
-// Some dependencies (like hash-base) assume process.version exists.
-// In React Native / Hermes, process is defined but version is not.
-// Note: we only polyfill if process already exists but is incomplete.
-// The user is responsible for providing the process polyfill; this is just
-// a small patch for environments (like Hermes) with partial implementations.
-//
-// More information: https://github.com/browserify/hash-base/issues/21#issuecomment-3476608003
-const g = typeof globalThis !== 'undefined'
-    ? globalThis
-    : typeof global !== 'undefined'
-        ? global
-        : {};
-if (typeof g.process !== 'undefined' &&
-    typeof g.process.version === 'undefined') {
-    const isDev = g['__DEV__'] === true ||
-        g.process?.env?.['NODE_ENV'] === 'development';
-    if (isDev) {
-        //only WARN while developing
-        console.warn(`[bitcoinerlab/descriptors] Polyfilled process.version (missing in this non-Node environment).
-Learn more: https://github.com/bitcoinerlab/descriptors/blob/main/src/index.ts#L4`);
-    }
-    // @ts-expect-error Polyfill for environments missing process.version
-    global.process.version = '';
-}
-var descriptors_1 = require("./descriptors");
-Object.defineProperty(exports, "DescriptorsFactory", { enumerable: true, get: function () { return descriptors_1.DescriptorsFactory; } });
-var checksum_1 = require("./checksum");
-Object.defineProperty(exports, "checksum", { enumerable: true, get: function () { return checksum_1.DescriptorChecksum; } });
-const signers = __importStar(require("./signers"));
-exports.signers = signers;
-var keyExpressions_1 = require("./keyExpressions");
-Object.defineProperty(exports, "keyExpressionBIP32", { enumerable: true, get: function () { return keyExpressions_1.keyExpressionBIP32; } });
-Object.defineProperty(exports, "keyExpressionLedger", { enumerable: true, get: function () { return keyExpressions_1.keyExpressionLedger; } });
-const scriptExpressions = __importStar(require("./scriptExpressions"));
-exports.scriptExpressions = scriptExpressions;
-const ledger_1 = require("./ledger");
-/** @namespace */
-exports.ledger = {
-    /** @function */
-    getLedgerMasterFingerPrint: ledger_1.getLedgerMasterFingerPrint,
-    /** @function */
-    getLedgerXpub: ledger_1.getLedgerXpub,
-    /** @function */
-    registerLedgerWallet: ledger_1.registerLedgerWallet,
-    /** @function */
-    assertLedgerApp: ledger_1.assertLedgerApp
-};

package/dist/keyExpressions.d.ts

@@ -1,83 +0,0 @@
-import { Network } from 'bitcoinjs-lib';
-import type { ECPairAPI } from 'ecpair';
-import type { BIP32API, BIP32Interface } from 'bip32';
-import type { KeyInfo } from './types';
-import { LedgerManager } from './ledger';
-/**
- * Parses a key expression (xpub, xprv, pubkey or wif) into {@link KeyInfo | `KeyInfo`}.
- *
- * For example, given this `keyExpression`: `"[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*"`, this is its parsed result:
- *
- * ```javascript
- *  {
- *    keyExpression:
- *      "[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*",
- *    keyPath: '/1/2/3/4/*',
- *    originPath: "/49'/0'/0'",
- *    path: "m/49'/0'/0'/1/2/3/4/*",
- *    // Other relevant properties of the type `KeyInfo`: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
- *  }
- * ```
- */
-export declare function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32, network }: {
-    keyExpression: string;
-    /** @default networks.bitcoin */
-    network?: Network;
-    /**
-     * Indicates if this key expression belongs to a a SegWit output. When set,
-     * further checks are done to ensure the public key (if present in the
-     * expression) is compressed (33 bytes).
-     */
-    isSegwit?: boolean;
-    /**
-     * Indicates if this key expression belongs to a Taproot output. For Taproot,
-     * the key must be represented as an x-only public key (32 bytes).
-     * If a 33-byte compressed pubkey is derived, it is converted to its x-only
-     * representation.
-     */
-    isTaproot?: boolean;
-    ECPair: ECPairAPI;
-    BIP32: BIP32API;
-}): KeyInfo;
-/**
- * Constructs a key expression string for a Ledger device from the provided
- * components.
- *
- * This function assists in crafting key expressions tailored for Ledger
- * hardware wallets. It fetches the master fingerprint and xpub for a
- * specified origin path and then combines them with the input parameters.
- *
- * For detailed understanding and examples of terms like `originPath`,
- * `change`, and `keyPath`, refer to the documentation of
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}, which consists
- * of the reverse procedure.
- *
- * @returns {string} - The formed key expression for the Ledger device.
- */
-export declare function keyExpressionLedger({ ledgerManager, originPath, keyPath, change, index }: {
-    ledgerManager: LedgerManager;
-    originPath: string;
-    change?: number | undefined;
-    index?: number | undefined | '*';
-    keyPath?: string | undefined;
-}): Promise<string>;
-/**
- * Constructs a key expression string from its constituent components.
- *
- * This function essentially performs the reverse operation of
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}. For detailed
- * explanations and examples of the terms used here, refer to
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
- */
-export declare function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic }: {
-    masterNode: BIP32Interface;
-    originPath: string;
-    change?: number | undefined;
-    index?: number | undefined | '*';
-    keyPath?: string | undefined;
-    /**
-     * Compute an xpub or xprv
-     * @default true
-     */
-    isPublic?: boolean;
-}): string;

package/dist/keyExpressions.js

@@ -1,248 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseKeyExpression = parseKeyExpression;
-exports.keyExpressionLedger = keyExpressionLedger;
-exports.keyExpressionBIP32 = keyExpressionBIP32;
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const ledger_1 = require("./ledger");
-const uint8array_tools_1 = require("uint8array-tools");
-const RE = __importStar(require("./re"));
-const derivePath = (node, path) => {
-    if (typeof path !== 'string') {
-        throw new Error(`Error: invalid derivation path ${path}`);
-    }
-    const parsedPath = path.replaceAll('H', "'").replaceAll('h', "'").slice(1);
-    const splitPath = parsedPath.split('/');
-    for (const element of splitPath) {
-        const unhardened = element.endsWith("'") ? element.slice(0, -1) : element;
-        if (!Number.isInteger(Number(unhardened)) ||
-            Number(unhardened) >= 0x80000000)
-            throw new Error(`Error: BIP 32 path element overflow`);
-    }
-    return node.derivePath(parsedPath);
-};
-/**
- * Parses a key expression (xpub, xprv, pubkey or wif) into {@link KeyInfo | `KeyInfo`}.
- *
- * For example, given this `keyExpression`: `"[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*"`, this is its parsed result:
- *
- * ```javascript
- *  {
- *    keyExpression:
- *      "[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*",
- *    keyPath: '/1/2/3/4/*',
- *    originPath: "/49'/0'/0'",
- *    path: "m/49'/0'/0'/1/2/3/4/*",
- *    // Other relevant properties of the type `KeyInfo`: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
- *  }
- * ```
- */
-function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32, network = bitcoinjs_lib_1.networks.bitcoin }) {
-    if (isTaproot && isSegwit !== true)
-        throw new Error(`Error: taproot key expressions require isSegwit`);
-    let pubkey; //won't be computed for ranged keyExpressions
-    let ecpair;
-    let bip32;
-    let masterFingerprint;
-    let originPath;
-    let keyPath;
-    let path;
-    const isRanged = keyExpression.indexOf('*') !== -1;
-    const reKeyExp = isTaproot
-        ? RE.reTaprootKeyExp
-        : isSegwit
-            ? RE.reSegwitKeyExp
-            : RE.reNonSegwitKeyExp;
-    const rePubKey = isTaproot
-        ? RE.reTaprootPubKey
-        : isSegwit
-            ? RE.reSegwitPubKey
-            : RE.reNonSegwitPubKey;
-    //Validate the keyExpression:
-    const keyExpressions = keyExpression.match(reKeyExp);
-    if (keyExpressions === null || keyExpressions[0] !== keyExpression) {
-        throw new Error(`Error: expected a keyExpression but got ${keyExpression}`);
-    }
-    const reOriginAnchoredStart = RegExp(String.raw `^(${RE.reOrigin})?`); //starts with ^origin
-    const mOrigin = keyExpression.match(reOriginAnchoredStart);
-    if (mOrigin) {
-        const bareOrigin = mOrigin[0].replace(/[[\]]/g, ''); //strip the "[" and "]" in [origin]
-        const reMasterFingerprintAnchoredStart = String.raw `^(${RE.reMasterFingerprint})`;
-        const mMasterFingerprint = bareOrigin.match(reMasterFingerprintAnchoredStart);
-        const masterFingerprintHex = mMasterFingerprint
-            ? mMasterFingerprint[0]
-            : '';
-        originPath = bareOrigin.replace(masterFingerprintHex, '');
-        if (masterFingerprintHex.length > 0) {
-            if (masterFingerprintHex.length !== 8)
-                throw new Error(`Error: masterFingerprint ${masterFingerprintHex} invalid for keyExpression: ${keyExpression}`);
-            masterFingerprint = (0, uint8array_tools_1.fromHex)(masterFingerprintHex);
-        }
-    }
-    //Remove the origin (if it exists) and store result in actualKey
-    const actualKey = keyExpression.replace(reOriginAnchoredStart, '');
-    let mPubKey, mWIF, mXpubKey, mXprvKey;
-    //match pubkey:
-    if ((mPubKey = actualKey.match(RE.anchorStartAndEnd(rePubKey))) !== null) {
-        pubkey = (0, uint8array_tools_1.fromHex)(mPubKey[0]);
-        if (isTaproot && pubkey.length === 32)
-            //convert the xonly point to a compressed point assuming even parity
-            pubkey = (0, uint8array_tools_1.concat)([Uint8Array.from([0x02]), pubkey]);
-        ecpair = ECPair.fromPublicKey(pubkey, { network });
-        //Validate the pubkey (compressed or uncompressed)
-        if (!ECPair.isPoint(pubkey) ||
-            !(pubkey.length === 33 || pubkey.length === 65)) {
-            throw new Error(`Error: invalid pubkey`);
-        }
-        //Do an extra check in case we know this pubkey refers to a segwit input
-        //Taproot x-only keys are converted to 33-byte compressed form above.
-        if (typeof isSegwit === 'boolean' &&
-            isSegwit &&
-            pubkey.length !== 33 //Inside wpkh and wsh, only compressed public keys are permitted.
-        ) {
-            throw new Error(`Error: invalid pubkey`);
-        }
-        //match WIF:
-    }
-    else if ((mWIF = actualKey.match(RE.anchorStartAndEnd(RE.reWIF))) !== null) {
-        ecpair = ECPair.fromWIF(mWIF[0], network);
-        //fromWIF will throw if the wif is not valid
-        pubkey = ecpair.publicKey;
-        //match xpub:
-    }
-    else if ((mXpubKey = actualKey.match(RE.anchorStartAndEnd(RE.reXpubKey))) !== null) {
-        const xPubKey = mXpubKey[0];
-        const xPub = xPubKey.match(RE.reXpub)?.[0];
-        if (!xPub)
-            throw new Error(`Error: xpub could not be matched`);
-        bip32 = BIP32.fromBase58(xPub, network);
-        const mPath = xPubKey.match(RE.rePath);
-        if (mPath !== null) {
-            keyPath = xPubKey.match(RE.rePath)?.[0];
-            if (!keyPath)
-                throw new Error(`Error: could not extract a path`);
-            //fromBase58 and derivePath will throw if xPub or path are not valid
-            if (!isRanged)
-                pubkey = derivePath(bip32, keyPath).publicKey;
-        }
-        else {
-            pubkey = bip32.publicKey;
-        }
-        //match xprv:
-    }
-    else if ((mXprvKey = actualKey.match(RE.anchorStartAndEnd(RE.reXprvKey))) !== null) {
-        const xPrvKey = mXprvKey[0];
-        const xPrv = xPrvKey.match(RE.reXprv)?.[0];
-        if (!xPrv)
-            throw new Error(`Error: xprv could not be matched`);
-        bip32 = BIP32.fromBase58(xPrv, network);
-        const mPath = xPrvKey.match(RE.rePath);
-        if (mPath !== null) {
-            keyPath = xPrvKey.match(RE.rePath)?.[0];
-            if (!keyPath)
-                throw new Error(`Error: could not extract a path`);
-            //fromBase58 and derivePath will throw if xPrv or path are not valid
-            if (!isRanged)
-                pubkey = derivePath(bip32, keyPath).publicKey;
-        }
-        else {
-            pubkey = bip32.publicKey;
-        }
-    }
-    else {
-        throw new Error(`Error: could not get pubkey for keyExpression ${keyExpression}`);
-    }
-    if (originPath || keyPath) {
-        path = `m${originPath ?? ''}${keyPath ?? ''}`;
-    }
-    if (pubkey !== undefined && isTaproot && pubkey.length === 33)
-        // If we get a 33-byte compressed key, drop the first byte.
-        pubkey = pubkey.slice(1, 33);
-    return {
-        keyExpression,
-        ...(pubkey !== undefined ? { pubkey } : {}),
-        ...(ecpair !== undefined ? { ecpair } : {}),
-        ...(bip32 !== undefined ? { bip32 } : {}),
-        ...(masterFingerprint !== undefined ? { masterFingerprint } : {}),
-        ...(originPath !== undefined && originPath !== '' ? { originPath } : {}),
-        ...(keyPath !== undefined && keyPath !== '' ? { keyPath } : {}),
-        ...(path !== undefined ? { path } : {})
-    };
-}
-function assertChangeIndexKeyPath({ change, index, keyPath }) {
-    if (!((change === undefined && index === undefined) ||
-        (change !== undefined && index !== undefined)))
-        throw new Error(`Error: Pass change and index or neither`);
-    if ((change !== undefined) === (keyPath !== undefined))
-        throw new Error(`Error: Pass either change and index or a keyPath`);
-}
-/** @hidden */
-async function keyExpressionLedger({ ledgerManager, originPath, keyPath, change, index }) {
-    assertChangeIndexKeyPath({ change, index, keyPath });
-    const masterFingerprint = await (0, ledger_1.getLedgerMasterFingerPrint)({
-        ledgerManager
-    });
-    const origin = `[${(0, uint8array_tools_1.toHex)(masterFingerprint)}${originPath}]`;
-    const xpub = await (0, ledger_1.getLedgerXpub)({ originPath, ledgerManager });
-    const keyRoot = `${origin}${xpub}`;
-    if (keyPath !== undefined)
-        return `${keyRoot}${keyPath}`;
-    else
-        return `${keyRoot}/${change}/${index}`;
-}
-/**
- * Constructs a key expression string from its constituent components.
- *
- * This function essentially performs the reverse operation of
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}. For detailed
- * explanations and examples of the terms used here, refer to
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
- */
-function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic = true }) {
-    assertChangeIndexKeyPath({ change, index, keyPath });
-    const masterFingerprint = masterNode.fingerprint;
-    const origin = `[${(0, uint8array_tools_1.toHex)(masterFingerprint)}${originPath}]`;
-    const xpub = isPublic
-        ? masterNode.derivePath(`m${originPath}`).neutered().toBase58().toString()
-        : masterNode.derivePath(`m${originPath}`).toBase58().toString();
-    const keyRoot = `${origin}${xpub}`;
-    if (keyPath !== undefined)
-        return `${keyRoot}${keyPath}`;
-    else
-        return `${keyRoot}/${change}/${index}`;
-}

package/dist/ledger.d.ts

@@ -1,167 +0,0 @@
-import { OutputInstance } from './descriptors';
-import { Network, Psbt } from 'bitcoinjs-lib';
-import type { TinySecp256k1Interface } from './types';
-/**
- * Dynamically imports the '@ledgerhq/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 '@ledgerhq/ledger-bitcoin' module cannot be imported. This typically indicates that the '@ledgerhq/ledger-bitcoin' peer dependency is not installed.
- * @returns {Promise<unknown>} Returns a promise that resolves with the entire '@ledgerhq/ledger-bitcoin' module if it can be successfully imported. We force it to return an unknown type so that the declaration of this function won't break projects that don't use @ledgerhq/ledger-bitcoin as dependency
- *
- * @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<unknown>;
-/**
- * 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.
- */
-export declare function assertLedgerApp({ transport, name, minVersion }: {
-    /**
-     * Connection transport with the Ledger device.
-     * One of these: https://github.com/LedgerHQ/ledger-live#libs---libraries
-     */
-    transport: any;
-    /**
-     * The name of the Bitcoin App. "Bitcoin" for mainnet or "Bitcoin Test" for testnet.
-     */
-    name: string;
-    /**
-     * The minimum acceptable version of the Bitcoin App in semver format (major.minor.patch).
-     */
-    minVersion: string;
-}): Promise<void>;
-export type LedgerPolicy = {
-    policyName?: string;
-    ledgerTemplate: string;
-    keyRoots: string[];
-    policyId?: Uint8Array;
-    policyHmac?: Uint8Array;
-};
-/**
- * Ledger devices operate in a state-less manner. Therefore, policy information
- * needs to be maintained in a separate data structure, `ledgerState`. For optimization,
- * `ledgerState` also stores cached xpubs and the masterFingerprint.
- */
-export type LedgerState = {
-    masterFingerprint?: Uint8Array;
-    policies?: LedgerPolicy[];
-    xpubs?: {
-        [key: string]: string;
-    };
-};
-export type LedgerManager = {
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-    ecc: TinySecp256k1Interface;
-    network: Network;
-};
-/**
- * Retrieves the masterFingerPrint of a Ledger device
- */
-export declare function getLedgerMasterFingerPrint({ ledgerManager }: {
-    ledgerManager: LedgerManager;
-}): Promise<Uint8Array>;
-/**
- * Retrieves the xpub of a certain originPath of a Ledger device
- */
-export declare function getLedgerXpub({ originPath, ledgerManager }: {
-    originPath: string;
-    ledgerManager: LedgerManager;
-}): Promise<string>;
-/**
- * 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
- */
-export declare function ledgerPolicyFromPsbtInput({ ledgerManager, psbt, index }: {
-    ledgerManager: LedgerManager;
-    psbt: Psbt;
-    index: number;
-}): Promise<LedgerPolicy | undefined>;
-/**
- * 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
- *
- * keyRoots and template are a generalization of a descriptor and serve to
- * describe internal and external addresses and any index.
- *
- * So, this function starts from a descriptor and obtains generalized Ledger
- * wallet policy.
- *
- * keyRoots is an array of strings, encoding xpub-type key expressions up to the origin.
- * F.ex.: [76223a6e/48'/1'/0'/2']tpubDE7NQymr4AFtewpAsWtnreyq9ghkzQBXpCZjWLFVRAvnbf7vya2eMTvT2fPapNqL8SuVvLQdbUbMfWLVDCZKnsEBqp6UK93QEzL8Ck23AwF
- *
- * Template encodes the descriptor script expression, where its key
- * expressions are represented using variables for each keyRoot and finished with "/**"
- * (for change 1 or 0 and any index). F.ex.:
- * wsh(sortedmulti(2,@0/**,@1/**)), where @0 corresponds the first element in the keyRoots array.
- *
- * If this descriptor does not contain any key that can be signed with the ledger
- * (non-matching masterFingerprint), then this function returns null.
- *
- * This function takes into account all the considerations regarding Ledger
- * policy implementation details expressed in the header of this file.
- */
-export declare function ledgerPolicyFromOutput({ output, ledgerManager }: {
-    output: OutputInstance;
-    ledgerManager: LedgerManager;
-}): Promise<{
-    ledgerTemplate: string;
-    keyRoots: string[];
-} | null>;
-/**
- * Registers a policy based on a provided descriptor.
- *
- * This function will:
- * 1. Store the policy in `ledgerState` inside the `ledgerManager`.
- * 2. Avoid re-registering if the policy was previously registered.
- * 3. Skip registration if the policy is considered "standard".
- *
- * It's important to understand the nature of the Ledger Policy being registered:
- * - While a descriptor might point to a specific output index of a particular change address,
- *   the corresponding Ledger Policy abstracts this and represents potential outputs for
- *   all addresses (both external and internal).
- * - This means that the registered Ledger Policy is a generalized version of the descriptor,
- *   not assuming specific values for the keyPath.
- */
-export declare function registerLedgerWallet({ descriptor, ledgerManager, policyName }: {
-    descriptor: string;
-    ledgerManager: LedgerManager;
-    /** The Name we want to assign to this specific policy */
-    policyName: string;
-}): Promise<void>;
-/**
- * Retrieve a standard ledger policy or null if it does correspond.
- **/
-export declare function ledgerPolicyFromStandard({ output, ledgerManager }: {
-    output: OutputInstance;
-    ledgerManager: LedgerManager;
-}): Promise<LedgerPolicy | null>;
-export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPolicy): boolean;
-/**
- * Retrieve a ledger policy from ledgerState or null if it does not exist yet.
- **/
-export declare function ledgerPolicyFromState({ output, ledgerManager }: {
-    output: OutputInstance;
-    ledgerManager: LedgerManager;
-}): Promise<LedgerPolicy | null>;