@bitcoinerlab/descriptors 1.0.1 → 1.1.1

package/README.md

@@ -106,7 +106,7 @@ constructor({
                  // of tx size (if more than one path is available).
                  // For more details on using this parameter, refer to this
                  // Stack Exchange answer: https://bitcoin.stackexchange.com/a/118036/89665
-}: DescriptorInfo);
+});
 ```
 
 The `Descriptor` class offers various helpful methods, including `getAddress()`, which returns the address associated with the descriptor, `getScriptPubKey()`, which returns the scriptPubKey for the descriptor, `expand()`, which decomposes a descriptor into its elemental parts, `updatePsbt()` and `finalizePsbt()`.

package/dist/descriptors.d.ts

@@ -1,15 +1,149 @@
+/// <reference types="node" />
+import { Network, Payment, Psbt } from 'bitcoinjs-lib';
+import type { PartialSig } from 'bip174/src/lib/interfaces';
 import { BIP32API } from 'bip32';
 import { ECPairAPI } from 'ecpair';
-import type { TinySecp256k1Interface, ParseKeyExpression, Expand, DescriptorInterfaceConstructor } from './types';
+import type { TinySecp256k1Interface, Preimage, TimeConstraints, ExpansionMap, Expand, ParseKeyExpression } from './types';
 /**
  * Builds the functions needed to operate with descriptors using an external elliptic curve (ecc) library.
  * @param {Object} ecc - an object containing elliptic curve operations, such as [tiny-secp256k1](https://github.com/bitcoinjs/tiny-secp256k1) or [@bitcoinerlab/secp256k1](https://github.com/bitcoinerlab/secp256k1).
- * @namespace
  */
 export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
-    Descriptor: DescriptorInterfaceConstructor;
-    ECPair: ECPairAPI;
+    Descriptor: {
+        new ({ expression, index, checksumRequired, allowMiniscriptInP2SH, network, preimages, signersPubKeys }: {
+            /**
+             * The descriptor string in ASCII format. It may include a "*" to denote an arbitrary index.
+             */
+            expression: string;
+            /**
+             * The descriptor's index in the case of a range descriptor (must be an integer >=0).
+             */
+            index?: number;
+            /**
+             * A flag indicating whether the descriptor is required to include a checksum.
+             * @defaultValue false
+             */
+            checksumRequired?: boolean;
+            /**
+             * A flag indicating whether this instance can parse and generate script satisfactions for sh(miniscript) top-level expressions of miniscripts. This is not recommended.
+             * @defaultValue false
+             */
+            allowMiniscriptInP2SH?: boolean;
+            /**
+             * One of bitcoinjs-lib [`networks`](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/src/networks.js) (or another one following the same interface).
+             * @defaultValue networks.bitcoin
+             */
+            network?: Network;
+            /**
+             * An array of preimages. This info is necessary to finalize Psbts.
+             * @defaultValue `[]`
+             */
+            preimages?: Preimage[];
+            /**
+             * An array of the public keys used for signing the transaction when spending the output associated with this descriptor. This parameter is only used if the descriptor object is being used to finalize a transaction. It is necessary to specify the spending path when working with miniscript-based expressions that have multiple spending paths. Set this parameter to an array containing the public keys involved in the desired spending path. Leave it `undefined` if you only need to generate the `scriptPubKey` or `address` for a descriptor, or if all the public keys involved in the descriptor will sign the transaction. In the latter case, the satisfier will automatically choose the most optimal spending path (if more than one is available).
+             */
+            signersPubKeys?: Buffer[];
+        }): {
+            readonly "__#1@#payment": Payment;
+            readonly "__#1@#preimages": Preimage[];
+            readonly "__#1@#signersPubKeys": Buffer[];
+            readonly "__#1@#miniscript"?: string;
+            readonly "__#1@#witnessScript"?: Buffer;
+            readonly "__#1@#redeemScript"?: Buffer;
+            readonly "__#1@#isSegwit"?: boolean;
+            readonly "__#1@#expandedExpression"?: string;
+            readonly "__#1@#expandedMiniscript"?: string;
+            readonly "__#1@#expansionMap"?: ExpansionMap;
+            readonly "__#1@#network": Network;
+            /**
+             * Gets the TimeConstraints (nSequence and nLockTime) of the miniscript
+             * descriptor as passed in the constructor, just using the expression,
+             * the signersPubKeys and preimages.
+             *
+             * We just need to know which will be the signatures that will be
+             * used (signersPubKeys) but final signatures are not necessary for
+             * obtaning nLockTime and nSequence.
+             *
+             * Remember: nSequence and nLockTime are part of the hash that is signed.
+             * Thus, they must not change after computing the signatures.
+             * When running getScriptSatisfaction, using the final signatures,
+             * satisfyMiniscript verifies that the time constraints did not change.
+             */
+            "__#1@#getTimeConstraints"(): TimeConstraints | undefined;
+            getPayment(): Payment;
+            /**
+             * Returns the Bitcoin Address
+             */
+            getAddress(): string;
+            getScriptPubKey(): Buffer;
+            /**
+             * Returns the compiled script satisfaction
+             * @param {PartialSig[]} signatures An array of signatures using this format: `interface PartialSig { pubkey: Buffer; signature: Buffer; }`
+             * @returns {Buffer}
+             */
+            getScriptSatisfaction(signatures: PartialSig[]): Buffer;
+            getSequence(): number | undefined;
+            getLockTime(): number | undefined;
+            getWitnessScript(): Buffer | undefined;
+            getRedeemScript(): Buffer | undefined;
+            getNetwork(): Network;
+            isSegwit(): boolean | undefined;
+            /**
+             * Updates a Psbt where the descriptor describes an utxo.
+             * The txHex (nonWitnessUtxo) and vout of the utxo must be passed.
+             *
+             * updatePsbt adds an input to the psbt and updates the tx locktime if needed.
+             * It also adds a new input to the Psbt based on txHex
+             * It returns the number of the input that is added.
+             * psbt and vout are mandatory. Also pass txHex.
+             *
+             * The following is not recommended but, alternatively, ONLY for Segwit inputs,
+             * you can pass txId and value, instead of txHex.
+             * If you do so, it is your responsibility to make sure that `value` is
+             * correct to avoid possible fee vulnerability attacks:
+             * https://github.com/bitcoinjs/bitcoinjs-lib/issues/1625
+             * Note that HW wallets require the full txHex also for Segwit anyways:
+             * https://blog.trezor.io/details-of-firmware-updates-for-trezor-one-version-1-9-1-and-trezor-model-t-version-2-3-1-1eba8f60f2dd
+             *
+             * In doubt, simply pass txHex (and you can skip passing txId and value) and
+             * you shall be fine.
+             */
+            updatePsbt({ psbt, txHex, txId, value, vout }: {
+                psbt: Psbt;
+                txHex?: string;
+                txId?: string;
+                value?: number;
+                vout: number;
+            }): number;
+            "__#1@#assertPsbtInput"({ psbt, index }: {
+                psbt: Psbt;
+                index: number;
+            }): void;
+            finalizePsbtInput({ index, psbt, validate }: {
+                index: number;
+                psbt: Psbt;
+                validate?: boolean | undefined;
+            }): void;
+            expand(): {
+                expansionMap?: ExpansionMap;
+                expandedMiniscript?: string;
+                miniscript?: string;
+                expandedExpression?: string;
+            };
+        };
+    };
     parseKeyExpression: ParseKeyExpression;
     expand: Expand;
+    ECPair: ECPairAPI;
     BIP32: BIP32API;
 };
+/**
+ * The {@link DescriptorsFactory | `DescriptorsFactory`} function internally creates and returns the {@link _Internal_.Descriptor | `Descriptor`} class.
+ * This class is specialized for the provided `TinySecp256k1Interface`.
+ * Use `DescriptorInstance` to declare instances for this class: `const: DescriptorInstance = new Descriptor();`
+ *
+ * See the {@link _Internal_.Descriptor | documentation for the internal Descriptor class} for a complete list of available methods.
+ */
+type DescriptorConstructor = ReturnType<typeof DescriptorsFactory>['Descriptor'];
+type DescriptorInstance = InstanceType<DescriptorConstructor>;
+export { DescriptorInstance, DescriptorConstructor };

package/dist/descriptors.js

@@ -95,14 +95,13 @@ function evaluate({ expression, checksumRequired, index }) {
 /**
  * Builds the functions needed to operate with descriptors using an external elliptic curve (ecc) library.
  * @param {Object} ecc - an object containing elliptic curve operations, such as [tiny-secp256k1](https://github.com/bitcoinjs/tiny-secp256k1) or [@bitcoinerlab/secp256k1](https://github.com/bitcoinerlab/secp256k1).
- * @namespace
  */
 function DescriptorsFactory(ecc) {
     var _Descriptor_instances, _Descriptor_payment, _Descriptor_preimages, _Descriptor_signersPubKeys, _Descriptor_miniscript, _Descriptor_witnessScript, _Descriptor_redeemScript, _Descriptor_isSegwit, _Descriptor_expandedExpression, _Descriptor_expandedMiniscript, _Descriptor_expansionMap, _Descriptor_network, _Descriptor_getTimeConstraints, _Descriptor_assertPsbtInput;
     const BIP32 = (0, bip32_1.BIP32Factory)(ecc);
     const ECPair = (0, ecpair_1.ECPairFactory)(ecc);
     const signatureValidator = (pubkey, msghash, signature) => ECPair.fromPublicKey(pubkey).verify(msghash, signature);
-    /*
+    /**
      * Takes a string key expression (xpub, xprv, pubkey or wif) and parses it
      */
     const parseKeyExpression = ({ keyExpression, isSegwit, network = bitcoinjs_lib_1.networks.bitcoin }) => {
@@ -117,27 +116,6 @@ function DescriptorsFactory(ecc) {
     /**
      * Takes a descriptor (expression) and expands it to its corresponding Bitcoin script and other relevant details.
      *
-     * @param {Object} params The parameters for the function.
-     * @param {string} params.expression The descriptor expression to be expanded.
-     * @param {string} [params.loggedExpression] The descriptor expression used for logging error messages. If not provided, defaults to the original expression.
-     * @param {Object} [params.network=networks.bitcoin] The Bitcoin network to use. If not provided, defaults to Bitcoin mainnet.
-     * @param {boolean} [params.allowMiniscriptInP2SH=false] Flag to allow miniscript in P2SH. If not provided, defaults to false.
-     *
-     * @returns {Object} An object containing various details about the expanded descriptor:
-     *     - payment: The corresponding [bitcoinjs-lib Payment](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/payments/index.ts) for the provided expression, if applicable.
-     *     - expandedExpression: The expanded descriptor expression.
-     *     - miniscript: The extracted miniscript from the expression, if any.
-     *     - expansionMap: A map of key expressions in the descriptor to their corresponding expanded keys.
-     *     - isSegwit: A boolean indicating whether the descriptor represents a SegWit script.
-     *     - expandedMiniscript: The expanded miniscript, if any.
-     *     - redeemScript: The redeem script for the descriptor, if applicable.
-     *     - witnessScript: The witness script for the descriptor, if applicable.
-     *     - isRanged: Whether this expression representas a ranged-descriptor
-     *     - canonicalExpression: This is the preferred or authoritative
-     *     representation of the descriptor expression. It standardizes the
-     *     descriptor by replacing indexes on wildcards and eliminating checksums.
-     *     This helps ensure consistency and facilitates efficient interpretation and handling by systems or software.
-     *
      * @throws {Error} Throws an error if the descriptor cannot be parsed or does not conform to the expected format.
      */
     const expand = ({ expression, index, checksumRequired = false, network = bitcoinjs_lib_1.networks.bitcoin, allowMiniscriptInP2SH = false }) => {
@@ -399,15 +377,7 @@ function DescriptorsFactory(ecc) {
     }
     class Descriptor {
         /**
-         * @param {DescriptorInfo} params
-         * @param {string} params.expression - The descriptor string in ASCII format. It may include a "*" to denote an arbitrary index.
-         * @param {number} params.index - The descriptor's index in the case of a range descriptor (must be an interger >=0).
-         * @param {boolean} [params.checksumRequired=false] - A flag indicating whether the descriptor is required to include a checksum.
-         * @param {boolean} [params.allowMiniscriptInP2SH=false] - A flag indicating whether this instance can parse and generate script satisfactions for sh(miniscript) top-level expressions of miniscripts. This is not recommended.
-         * @param {object} [params.network=networks.bitcoin] One of bitcoinjs-lib [`networks`](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/src/networks.js) (or another one following the same interface).
-         * @param {Preimage[]} [params.preimages=[]] An array of preimages. This info is necessary to finalize Psbts.
-         * @param {Buffer[]} [params.signersPubKeys] (Optional): An array of the public keys used for signing the transaction when spending the output associated with this descriptor. This parameter is only used if the descriptor object is being used to finalize a transaction. It is necessary to specify the spending path when working with miniscript-based expressions that have multiple spending paths. Set this parameter to an array containing the public keys involved in the desired spending path. Leave it `undefined` if you only need to generate the `scriptPubKey` or `address` for a descriptor, or if all the public keys involved in the descriptor will sign the transaction. In the latter case, the satisfier will automatically choose the most optimal spending path (if more than one is available).
-         *
+         * @param options
          * @throws {Error} - when descriptor is invalid
          */
         constructor({ expression, index, checksumRequired = false, allowMiniscriptInP2SH = false, network = bitcoinjs_lib_1.networks.bitcoin, preimages = [], signersPubKeys }) {

package/dist/index.d.ts

@@ -1,13 +1,13 @@
+export type { KeyInfo, Expansion } from './types';
 import type { Psbt } from 'bitcoinjs-lib';
-import type { DescriptorInterface } from './types';
-export { DescriptorInterface, DescriptorInterfaceConstructor, ParseKeyExpression } from './types';
-export { DescriptorsFactory } from './descriptors';
+import type { DescriptorInstance } from './descriptors';
+export { DescriptorsFactory, DescriptorInstance, DescriptorConstructor } from './descriptors';
 export { DescriptorChecksum as checksum } from './checksum';
 import * as signers from './signers';
 export { signers };
 export declare function finalizePsbt({ psbt, descriptors, validate }: {
     psbt: Psbt;
-    descriptors: DescriptorInterface[];
+    descriptors: DescriptorInstance[];
     validate?: boolean | undefined;
 }): void;
 export { keyExpressionBIP32, keyExpressionLedger } from './keyExpressions';

package/dist/index.js

@@ -26,7 +26,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ledger = exports.scriptExpressions = exports.keyExpressionLedger = exports.keyExpressionBIP32 = exports.finalizePsbt = exports.signers = exports.checksum = exports.DescriptorsFactory = void 0;
-var types_1 = require("./types");
 var descriptors_1 = require("./descriptors");
 Object.defineProperty(exports, "DescriptorsFactory", { enumerable: true, get: function () { return descriptors_1.DescriptorsFactory; } });
 var checksum_1 = require("./checksum");

package/dist/keyExpressions.d.ts

@@ -3,9 +3,17 @@ import type { ECPairAPI } from 'ecpair';
 import type { BIP32API, BIP32Interface } from 'bip32';
 import type { KeyInfo } from './types';
 import { LedgerState } from './ledger';
+/**
+ * Parses a key expression (xpub, xprv, pubkey or wif) into KeyInfo
+ */
 export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network }: {
     keyExpression: string;
     network?: Network;
+    /**
+     * Indicates if this is a SegWit key expression. When set, further checks
+     * ensure the public key (if present in the expression) is compressed
+     * (33 bytes).
+     */
     isSegwit?: boolean;
     ECPair: ECPairAPI;
     BIP32: BIP32API;

package/dist/keyExpressions.js

@@ -43,7 +43,7 @@ const derivePath = (node, path) => {
     }
     return node.derivePath(parsedPath);
 };
-/*
+/**
  * Parses a key expression (xpub, xprv, pubkey or wif) into KeyInfo
  */
 function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network = bitcoinjs_lib_1.networks.bitcoin }) {

package/dist/ledger.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { DescriptorInterface } from './types';
+import type { DescriptorInstance } from './descriptors';
 /**
  * Dynamically imports the 'ledger-bitcoin' module and, if provided, checks if `ledgerClient` is an instance of `AppClient`.
  *
@@ -7,7 +7,7 @@ import type { DescriptorInterface } from './types';
  * @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.
+ * @returns {Promise<unknown>} Returns a promise that resolves with the entire '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 ledger-bitcoin as dependency
  *
  * @example
  *
@@ -18,7 +18,7 @@ import type { DescriptorInterface } from './types';
  *   })
  *   .catch((error) => console.error(error));
  */
-export declare function importAndValidateLedgerBitcoin(ledgerClient?: unknown): Promise<typeof import("ledger-bitcoin")>;
+export declare function importAndValidateLedgerBitcoin(ledgerClient?: unknown): Promise<unknown>;
 export declare function assertLedgerApp({ transport, name, minVersion }: {
     transport: any;
     name: string;
@@ -73,7 +73,7 @@ export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }:
  * policy implementation details expressed in the header of this file.
  */
 export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState }: {
-    descriptor: DescriptorInterface;
+    descriptor: DescriptorInstance;
     ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<{
@@ -88,7 +88,7 @@ export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, led
  *
  **/
 export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }: {
-    descriptor: DescriptorInterface;
+    descriptor: DescriptorInstance;
     ledgerClient: unknown;
     ledgerState: LedgerState;
     policyName: string;
@@ -97,7 +97,7 @@ export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerS
  * Retrieve a standard ledger policy or null if it does correspond.
  **/
 export declare function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }: {
-    descriptor: DescriptorInterface;
+    descriptor: DescriptorInstance;
     ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<LedgerPolicy | null>;
@@ -106,7 +106,7 @@ export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPo
  * Retrieve a ledger policy from ledgerState or null if it does not exist yet.
  **/
 export declare function ledgerPolicyFromState({ descriptor, ledgerClient, ledgerState }: {
-    descriptor: DescriptorInterface;
+    descriptor: DescriptorInstance;
     ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<LedgerPolicy | null>;

package/dist/ledger.js

@@ -1,29 +1,6 @@
 "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;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
@@ -35,7 +12,7 @@ const re_1 = require("./re");
  * @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.
+ * @returns {Promise<unknown>} Returns a promise that resolves with the entire '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 ledger-bitcoin as dependency
  *
  * @example
  *
@@ -49,7 +26,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.');
@@ -115,7 +103,7 @@ function isLedgerStandard({ ledgerTemplate, keyRoots, network = bitcoinjs_lib_1.
     return false;
 }
 async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
-    const { AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    const { AppClient } = (await importAndValidateLedgerBitcoin(ledgerClient));
     if (!(ledgerClient instanceof AppClient))
         throw new Error(`Error: pass a valid ledgerClient`);
     let masterFingerprint = ledgerState.masterFingerprint;
@@ -127,7 +115,7 @@ async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
 }
 exports.getLedgerMasterFingerPrint = getLedgerMasterFingerPrint;
 async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
-    const { AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    const { AppClient } = (await importAndValidateLedgerBitcoin(ledgerClient));
     if (!(ledgerClient instanceof AppClient))
         throw new Error(`Error: pass a valid ledgerClient`);
     if (!ledgerState.xpubs)
@@ -242,7 +230,7 @@ exports.descriptorToLedgerFormat = descriptorToLedgerFormat;
  *
  **/
 async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }) {
-    const { WalletPolicy, AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    const { WalletPolicy, AppClient } = (await importAndValidateLedgerBitcoin(ledgerClient));
     if (!(ledgerClient instanceof AppClient))
         throw new Error(`Error: pass a valid ledgerClient`);
     const result = await descriptorToLedgerFormat({

package/dist/signers.d.ts

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

package/dist/signers.js

@@ -27,7 +27,7 @@ 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);
+    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)({
@@ -68,7 +68,7 @@ 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);
+    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 = [];

package/dist/types.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="node" />
 import type { ECPairInterface } from 'ecpair';
 import type { BIP32Interface } from 'bip32';
-import type { Network, Payment, Psbt } from 'bitcoinjs-lib';
-import type { PartialSig } from 'bip174/src/lib/interfaces';
+import type { Payment, Network } from 'bitcoinjs-lib';
 /**
  * Preimage
  * @alias Preimage
@@ -37,37 +36,12 @@ export type KeyInfo = {
 export type ExpansionMap = {
     [key: string]: KeyInfo;
 };
-export interface ParseKeyExpression {
-    (params: {
-        keyExpression: string;
-        isSegwit?: boolean;
-        network?: Network;
-    }): KeyInfo;
-}
-export interface Expand {
-    (params: {
-        expression: string;
-        index?: number;
-        checksumRequired?: boolean;
-        network?: Network;
-        allowMiniscriptInP2SH?: boolean;
-    }): {
-        payment?: Payment;
-        expandedExpression?: string;
-        miniscript?: string;
-        expansionMap?: ExpansionMap;
-        isSegwit?: boolean;
-        expandedMiniscript?: string;
-        redeemScript?: Buffer;
-        witnessScript?: Buffer;
-        isRanged: boolean;
-        canonicalExpression: string;
-    };
-}
+/** @ignore */
 interface XOnlyPointAddTweakResult {
     parity: 1 | 0;
     xOnlyPubkey: Uint8Array;
 }
+/** @ignore */
 export interface TinySecp256k1Interface {
     isPoint(p: Uint8Array): boolean;
     pointCompress(p: Uint8Array, compressed?: boolean): Uint8Array;
@@ -82,52 +56,93 @@ export interface TinySecp256k1Interface {
     xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
     privateNegate(d: Uint8Array): Uint8Array;
 }
+export type Expansion = {
+    /**
+     * The corresponding [bitcoinjs-lib Payment](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/payments/index.ts) for the provided expression, if applicable.
+     */
+    payment?: Payment;
+    /**
+     * The expanded descriptor expression.
+     */
+    expandedExpression?: string;
+    /**
+     * The extracted miniscript from the expression, if any.
+     */
+    miniscript?: string;
+    /**
+     * A map of key expressions in the descriptor to their corresponding expanded keys.
+     */
+    expansionMap?: ExpansionMap;
+    /**
+     * A boolean indicating whether the descriptor represents a SegWit script.
+     */
+    isSegwit?: boolean;
+    /**
+     * The expanded miniscript, if any.
+     */
+    expandedMiniscript?: string;
+    /**
+     * The redeem script for the descriptor, if applicable.
+     */
+    redeemScript?: Buffer;
+    /**
+     * The witness script for the descriptor, if applicable.
+     */
+    witnessScript?: Buffer;
+    /**
+     * Whether this expression represents a ranged-descriptor.
+     */
+    isRanged: boolean;
+    /**
+     * This is the preferred or authoritative representation of the descriptor expression.
+     */
+    canonicalExpression: string;
+};
 /**
- * DescriptorInfo
- * What defines a Descriptor. This is the type needed in the constructor.
- * @alias DescriptorInfo
- * @memberof Descriptor
+ * The {@link DescriptorsFactory | `DescriptorsFactory`} function creates and returns an implementation of the `Expand` interface.
+ * This returned implementation is tailored for the provided `TinySecp256k1Interface`.
  */
-export type DescriptorInfo = {
-    expression: string;
-    index?: number;
-    checksumRequired?: boolean;
-    allowMiniscriptInP2SH?: boolean;
-    network?: Network;
-    preimages?: Preimage[];
-    signersPubKeys?: Buffer[];
-};
-export interface DescriptorInterface {
-    getPayment(): Payment;
-    getAddress(): string;
-    getScriptPubKey(): Buffer;
-    getScriptSatisfaction(signatures: PartialSig[]): Buffer;
-    getSequence(): number | undefined;
-    getLockTime(): number | undefined;
-    getWitnessScript(): Buffer | undefined;
-    getRedeemScript(): Buffer | undefined;
-    getNetwork(): Network;
-    isSegwit(): boolean | undefined;
-    updatePsbt({ psbt, vout, txHex, txId, value }: {
-        psbt: Psbt;
-        vout: number;
-        txHex?: string;
-        txId?: string;
-        value?: number;
-    }): number;
-    finalizePsbtInput({ index, psbt, validate }: {
-        index: number;
-        psbt: Psbt;
-        validate?: boolean | undefined;
-    }): void;
-    expand(): {
-        expandedExpression?: string;
-        miniscript?: string;
-        expandedMiniscript?: string;
-        expansionMap?: ExpansionMap;
-    };
+export interface Expand {
+    (params: {
+        /**
+         * The descriptor expression to be expanded.
+         */
+        expression: string;
+        /**
+         * The descriptor index, if ranged.
+         */
+        index?: number;
+        /**
+         * A flag indicating whether the descriptor is required to include a checksum.
+         * @defaultValue false
+         */
+        checksumRequired?: boolean;
+        /**
+         * The Bitcoin network to use.
+         * @defaultValue `networks.bitcoin`
+         */
+        network?: Network;
+        /**
+         * Flag to allow miniscript in P2SH.
+         * @defaultValue false
+         */
+        allowMiniscriptInP2SH?: boolean;
+    }): Expansion;
 }
-export interface DescriptorInterfaceConstructor {
-    new (args: DescriptorInfo): DescriptorInterface;
+/**
+ * The {@link DescriptorsFactory | `DescriptorsFactory`} function creates and returns an implementation of the `ParseKeyExpression` interface.
+ * This returned implementation is tailored for the provided `TinySecp256k1Interface`.
+ */
+export interface ParseKeyExpression {
+    (params: {
+        keyExpression: string;
+        /**
+         * Indicates if this is a SegWit key expression. When set, further checks
+         * ensure the public key (if present in the expression) is compressed
+         * (33 bytes).
+         */
+        isSegwit?: boolean;
+        network?: Network;
+    }): KeyInfo;
 }
 export {};

package/package.json

@@ -1,39 +1,10 @@
 {
   "name": "@bitcoinerlab/descriptors",
-  "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "1.0.1",
   "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",
-  "scripts": {
-    "build": "npx tsc",
-    "prepublishOnly": "npm run build && npm test && echo \"\\n\\n\" && npm run test:integration:ledger",
-    "docs": "jsdoc -c jsdoc.json",
-    "regtest-docker": "docker ps | grep bitcoinerlab/tester > /dev/null || (docker pull bitcoinerlab/tester && docker run -d -p 8080:8080 -p 60401:60401 -p 3002:3002 bitcoinerlab/tester && sleep 5)",
-    "test:integration:soft": "npm run regtest-docker && npx ts-node test/integration/standardOutputs.ts && echo \"\\n\\n\" && npx ts-node test/integration/miniscript.ts",
-    "test:integration:ledger": "npm run regtest-docker && npx ts-node test/integration/ledger.ts",
-    "test:unit": "npm run build && node test/tools/generateBitcoinCoreFixtures.js && jest",
-    "test": "npm run lint && npm run lint:test && npm run test:unit && npm run test:integration:soft",
-    "lint": "eslint --ignore-path .gitignore --ext .js,.ts src/",
-    "lint:test": "eslint --ignore-path .gitignore --ext .js,.ts test/"
-  },
-  "COMMENT_babel": "Babel plugins are are only needed for the jest testing environment. Jest needs to use commonjs. Also, jest cannot handle ESM converted code, since it uses 'import.meta.url'. See src/bindings.js. babel-plugin-transform-import-meta fixes it.",
-  "babel": {
-    "env": {
-      "test": {
-        "plugins": [
-          "@babel/plugin-transform-modules-commonjs",
-          "babel-plugin-transform-import-meta"
-        ]
-      }
-    }
-  },
-  "jest": {
-    "testPathIgnorePatterns": [
-      "example/",
-      "dist/"
-    ]
-  },
+  "homepage": "https://github.com/bitcoinerlab/descriptors",
+  "version": "1.1.1",
+  "author": "Jose-Luis Landabaso",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bitcoinerlab/descriptors.git"
@@ -44,11 +15,34 @@
     "bitcoinjs",
     "miniscript"
   ],
-  "author": "Jose-Luis Landabaso",
-  "license": "MIT",
   "bugs": {
     "url": "https://github.com/bitcoinerlab/descriptors/issues"
   },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "prettier": "@bitcoinerlab/configs/prettierConfig.json",
+  "eslintConfig": {
+    "extends": "./node_modules/@bitcoinerlab/configs/eslintConfig"
+  },
+  "jest": {
+    "preset": "@bitcoinerlab/configs"
+  },
+  "scripts": {
+    "webdocs": "typedoc --options ./node_modules/@bitcoinerlab/configs/webtypedoc.json",
+    "docs": "typedoc --options ./node_modules/@bitcoinerlab/configs/typedoc.json",
+    "build:src": "tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.src.json",
+    "build:fixtures": "node test/tools/generateBitcoinCoreFixtures.js -i test/fixtures/descriptor_tests.cpp | npx prettier --parser typescript > test/fixtures/bitcoinCore.ts",
+    "build:test": "npm run build:fixtures && tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.test.json",
+    "build": "npm run build:src && npm run build:test",
+    "lint": "eslint --ignore-path .gitignore --ext .ts src/ test/",
+    "ensureTester": "./node_modules/@bitcoinerlab/configs/scripts/ensureTester.sh",
+    "test:integration:soft": "npm run ensureTester && node test/integration/standardOutputs.js && echo \"\\n\\n\" && node test/integration/miniscript.js",
+    "test:integration:ledger": "npm run ensureTester && node test/integration/ledger.js",
+    "test:unit": "jest",
+    "test": "npm run lint && npm run build && npm run test:unit && npm run test:integration:soft",
+    "testledger": "npm run lint && npm run build && npm run test:integration:ledger",
+    "prepublishOnly": "npm run test && echo \"\\n\\n\" && npm run test:integration:ledger"
+  },
   "files": [
     "dist"
   ],
@@ -61,27 +55,14 @@
     }
   },
   "devDependencies": {
-    "@babel/plugin-transform-modules-commonjs": "^7.20.11",
+    "@bitcoinerlab/configs": "github:bitcoinerlab/configs",
     "@ledgerhq/hw-transport-node-hid": "^6.27.12",
-    "@typescript-eslint/eslint-plugin": "^5.60.1",
-    "@typescript-eslint/parser": "^5.60.1",
-    "babel-plugin-transform-import-meta": "^2.2.0",
-    "better-docs": "^2.7.2",
     "bip39": "^3.0.4",
     "bip65": "^1.0.3",
     "bip68": "^1.0.4",
-    "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-jest": "^27.2.1",
-    "eslint-plugin-prettier": "^4.2.1",
-    "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",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "5.0"
+    "yargs": "^17.7.2"
   },
   "dependencies": {
     "@bitcoinerlab/miniscript": "^1.2.1",