@bitcoinerlab/descriptors 0.2.1 → 0.3.0

package/dist/descriptors.js

@@ -95,7 +95,6 @@ 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).
- * @returns {Object} an object containing functions, `parse` and `checksum`.
  * @namespace
  */
 function DescriptorsFactory(ecc) {
@@ -115,6 +114,264 @@ function DescriptorsFactory(ecc) {
             BIP32
         });
     };
+    /**
+     * 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.
+     *
+     * @throws {Error} Throws an error if the descriptor cannot be parsed or does not conform to the expected format.
+     */
+    const expand = ({ expression, loggedExpression, //this is the expression that will be used for logging error messages
+    network = bitcoinjs_lib_1.networks.bitcoin, allowMiniscriptInP2SH = false }) => {
+        //remove the checksum before proceeding:
+        expression = expression.replace(new RegExp(RE.reChecksum + '$'), '');
+        let expandedExpression;
+        let miniscript;
+        let expansionMap;
+        let isSegwit;
+        let expandedMiniscript;
+        let payment;
+        let witnessScript;
+        let redeemScript;
+        const isRanged = expression.indexOf('*') !== -1;
+        if (!loggedExpression)
+            loggedExpression = expression;
+        //addr(ADDR)
+        if (expression.match(RE.reAddrAnchored)) {
+            if (isRanged)
+                throw new Error(`Error: addr() cannot be ranged`);
+            const matchedAddress = expression.match(RE.reAddrAnchored)?.[1]; //[1]-> whatever is found addr(->HERE<-)
+            if (!matchedAddress)
+                throw new Error(`Error: could not get an address in ${loggedExpression}`);
+            let output;
+            try {
+                output = bitcoinjs_lib_1.address.toOutputScript(matchedAddress, network);
+            }
+            catch (e) {
+                throw new Error(`Error: invalid address ${matchedAddress}`);
+            }
+            try {
+                payment = p2pkh({ output, network });
+            }
+            catch (e) { }
+            try {
+                payment = p2sh({ output, network });
+            }
+            catch (e) { }
+            try {
+                payment = p2wpkh({ output, network });
+            }
+            catch (e) { }
+            try {
+                payment = p2wsh({ output, network });
+            }
+            catch (e) { }
+            try {
+                payment = p2tr({ output, network });
+            }
+            catch (e) { }
+            if (!payment) {
+                throw new Error(`Error: invalid address ${matchedAddress}`);
+            }
+        }
+        //pk(KEY)
+        else if (expression.match(RE.rePkAnchored)) {
+            isSegwit = false;
+            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (expression !== `pk(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            expandedExpression = 'pk(@0)';
+            expansionMap = {
+                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
+            };
+            if (!isRanged) {
+                const pubkey = expansionMap['@0'].pubkey;
+                //Note there exists no address for p2pk, but we can still use the script
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                payment = p2pk({ pubkey, network });
+            }
+        }
+        //pkh(KEY) - legacy
+        else if (expression.match(RE.rePkhAnchored)) {
+            isSegwit = false;
+            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (expression !== `pkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            expandedExpression = 'pkh(@0)';
+            expansionMap = {
+                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
+            };
+            if (!isRanged) {
+                const pubkey = expansionMap['@0'].pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                payment = p2pkh({ pubkey, network });
+            }
+        }
+        //sh(wpkh(KEY)) - nested segwit
+        else if (expression.match(RE.reShWpkhAnchored)) {
+            isSegwit = true;
+            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (expression !== `sh(wpkh(${keyExpression}))`)
+                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            expandedExpression = 'sh(wpkh(@0))';
+            expansionMap = {
+                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
+            };
+            if (!isRanged) {
+                const pubkey = expansionMap['@0'].pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                payment = p2sh({ redeem: p2wpkh({ pubkey, network }), network });
+                redeemScript = payment.redeem?.output;
+                if (!redeemScript)
+                    throw new Error(`Error: could not calculate redeemScript for ${loggedExpression}`);
+            }
+        }
+        //wpkh(KEY) - native segwit
+        else if (expression.match(RE.reWpkhAnchored)) {
+            isSegwit = true;
+            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (expression !== `wpkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            expandedExpression = 'wpkh(@0)';
+            expansionMap = {
+                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
+            };
+            if (!isRanged) {
+                const pubkey = expansionMap['@0'].pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                payment = p2wpkh({ pubkey, network });
+            }
+        }
+        //sh(wsh(miniscript))
+        else if (expression.match(RE.reShWshMiniscriptAnchored)) {
+            isSegwit = true;
+            miniscript = expression.match(RE.reShWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(wsh(->HERE<-))
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${loggedExpression}`);
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `sh(wsh(${expandedMiniscript}))`;
+            if (!isRanged) {
+                const script = (0, miniscript_1.miniscript2Script)({ expandedMiniscript, expansionMap });
+                witnessScript = script;
+                if (script.byteLength > MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
+                    throw new Error(`Error: script is too large, ${script.byteLength} bytes is larger than ${MAX_STANDARD_P2WSH_SCRIPT_SIZE} bytes`);
+                }
+                const nonPushOnlyOps = countNonPushOnlyOPs(script);
+                if (nonPushOnlyOps > MAX_OPS_PER_SCRIPT) {
+                    throw new Error(`Error: too many non-push ops, ${nonPushOnlyOps} non-push ops is larger than ${MAX_OPS_PER_SCRIPT}`);
+                }
+                payment = p2sh({
+                    redeem: p2wsh({ redeem: { output: script, network }, network }),
+                    network
+                });
+                redeemScript = payment.redeem?.output;
+                if (!redeemScript)
+                    throw new Error(`Error: could not calculate redeemScript for ${loggedExpression}`);
+            }
+        }
+        //sh(miniscript)
+        else if (expression.match(RE.reShMiniscriptAnchored)) {
+            //isSegwit false because we know it's a P2SH of a miniscript and not a
+            //P2SH that embeds a witness payment.
+            isSegwit = false;
+            miniscript = expression.match(RE.reShMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(->HERE<-)
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${loggedExpression}`);
+            if (allowMiniscriptInP2SH === false &&
+                //These top-level expressions within sh are allowed within sh.
+                //They can be parsed with miniscript2Script, but first we must make sure
+                //that other expressions are not accepted (unless forced with allowMiniscriptInP2SH).
+                miniscript.search(/^(pk\(|pkh\(|wpkh\(|combo\(|multi\(|sortedmulti\(|multi_a\(|sortedmulti_a\()/) !== 0) {
+                throw new Error(`Error: Miniscript expressions can only be used in wsh`);
+            }
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `sh(${expandedMiniscript})`;
+            if (!isRanged) {
+                const script = (0, miniscript_1.miniscript2Script)({ expandedMiniscript, expansionMap });
+                redeemScript = script;
+                if (script.byteLength > MAX_SCRIPT_ELEMENT_SIZE) {
+                    throw new Error(`Error: P2SH script is too large, ${script.byteLength} bytes is larger than ${MAX_SCRIPT_ELEMENT_SIZE} bytes`);
+                }
+                const nonPushOnlyOps = countNonPushOnlyOPs(script);
+                if (nonPushOnlyOps > MAX_OPS_PER_SCRIPT) {
+                    throw new Error(`Error: too many non-push ops, ${nonPushOnlyOps} non-push ops is larger than ${MAX_OPS_PER_SCRIPT}`);
+                }
+                payment = p2sh({ redeem: { output: script, network }, network });
+            }
+        }
+        //wsh(miniscript)
+        else if (expression.match(RE.reWshMiniscriptAnchored)) {
+            isSegwit = true;
+            miniscript = expression.match(RE.reWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found wsh(->HERE<-)
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${loggedExpression}`);
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `wsh(${expandedMiniscript})`;
+            if (!isRanged) {
+                const script = (0, miniscript_1.miniscript2Script)({ expandedMiniscript, expansionMap });
+                witnessScript = script;
+                if (script.byteLength > MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
+                    throw new Error(`Error: script is too large, ${script.byteLength} bytes is larger than ${MAX_STANDARD_P2WSH_SCRIPT_SIZE} bytes`);
+                }
+                const nonPushOnlyOps = countNonPushOnlyOPs(script);
+                if (nonPushOnlyOps > MAX_OPS_PER_SCRIPT) {
+                    throw new Error(`Error: too many non-push ops, ${nonPushOnlyOps} non-push ops is larger than ${MAX_OPS_PER_SCRIPT}`);
+                }
+                payment = p2wsh({ redeem: { output: script, network }, network });
+            }
+        }
+        else {
+            throw new Error(`Error: Could not parse descriptor ${loggedExpression}`);
+        }
+        return {
+            ...(payment !== undefined ? { payment } : {}),
+            ...(expandedExpression !== undefined ? { expandedExpression } : {}),
+            ...(miniscript !== undefined ? { miniscript } : {}),
+            ...(expansionMap !== undefined ? { expansionMap } : {}),
+            ...(isSegwit !== undefined ? { isSegwit } : {}),
+            ...(expandedMiniscript !== undefined ? { expandedMiniscript } : {}),
+            ...(redeemScript !== undefined ? { redeemScript } : {}),
+            ...(witnessScript !== undefined ? { witnessScript } : {})
+        };
+    };
     /**
      * Expand a miniscript to a generalized form using variables instead of key
      * expressions. Variables will be of this form: @0, @1, ...
@@ -133,17 +390,18 @@ function DescriptorsFactory(ecc) {
     }
     class Descriptor {
         /**
-         * @param {Object} params
+         * @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 {string} params.descriptor - The descriptor.
          * @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).
          *
-         * @see {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/src/payments/index.d.ts}
          * @throws {Error} - when descriptor is invalid
          */
         constructor({ expression, index, checksumRequired = false, allowMiniscriptInP2SH = false, network = bitcoinjs_lib_1.networks.bitcoin, preimages = [], signersPubKeys }) {
-            var _a, _b, _c, _d, _e, _f;
             _Descriptor_instances.add(this);
             _Descriptor_payment.set(this, void 0);
             _Descriptor_preimages.set(this, []);
@@ -169,242 +427,40 @@ function DescriptorsFactory(ecc) {
                 ...(index !== undefined ? { index } : {}),
                 checksumRequired
             });
-            //addr(ADDR)
-            if (evaluatedExpression.match(RE.reAddrAnchored)) {
-                const matchedAddress = evaluatedExpression.match(RE.reAddrAnchored)?.[1]; //[1]-> whatever is found addr(->HERE<-)
-                if (!matchedAddress)
-                    throw new Error(`Error: could not get an address in ${evaluatedExpression}`);
-                let output;
-                let payment;
-                try {
-                    output = bitcoinjs_lib_1.address.toOutputScript(matchedAddress, network);
-                }
-                catch (e) {
-                    throw new Error(`Error: invalid address ${matchedAddress}`);
-                }
-                try {
-                    payment = p2pkh({ output, network });
-                }
-                catch (e) { }
-                try {
-                    payment = p2sh({ output, network });
-                }
-                catch (e) { }
-                try {
-                    payment = p2wpkh({ output, network });
-                }
-                catch (e) { }
-                try {
-                    payment = p2wsh({ output, network });
-                }
-                catch (e) { }
-                try {
-                    payment = p2tr({ output, network });
-                }
-                catch (e) { }
-                if (!payment) {
-                    throw new Error(`Error: invalid address ${matchedAddress}`);
-                }
-                __classPrivateFieldSet(this, _Descriptor_payment, payment, "f");
-            }
-            //pk(KEY)
-            else if (evaluatedExpression.match(RE.rePkAnchored)) {
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, false, "f");
-                const keyExpression = evaluatedExpression.match(RE.reKeyExp)?.[0];
-                if (!keyExpression)
-                    throw new Error(`Error: keyExpression could not me extracted`);
-                if (evaluatedExpression !== `pk(${keyExpression})`)
-                    throw new Error(`Error: invalid expression ${expression}`);
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, 'pk(@0)', "f");
-                __classPrivateFieldSet(this, _Descriptor_expansionMap, {
-                    '@0': parseKeyExpression({
-                        keyExpression,
-                        network,
-                        isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f")
-                    })
-                }, "f");
-                const pubkey = __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")['@0'].pubkey;
-                //Note there exists no address for p2pk, but we can still use the script
-                __classPrivateFieldSet(this, _Descriptor_payment, p2pk({ pubkey, network }), "f");
-            }
-            //pkh(KEY) - legacy
-            else if (evaluatedExpression.match(RE.rePkhAnchored)) {
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, false, "f");
-                const keyExpression = evaluatedExpression.match(RE.reKeyExp)?.[0];
-                if (!keyExpression)
-                    throw new Error(`Error: keyExpression could not me extracted`);
-                if (evaluatedExpression !== `pkh(${keyExpression})`)
-                    throw new Error(`Error: invalid expression ${expression}`);
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, 'pkh(@0)', "f");
-                __classPrivateFieldSet(this, _Descriptor_expansionMap, {
-                    '@0': parseKeyExpression({
-                        keyExpression,
-                        network,
-                        isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f")
-                    })
-                }, "f");
-                const pubkey = __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")['@0'].pubkey;
-                __classPrivateFieldSet(this, _Descriptor_payment, p2pkh({ pubkey, network }), "f");
-            }
-            //sh(wpkh(KEY)) - nested segwit
-            else if (evaluatedExpression.match(RE.reShWpkhAnchored)) {
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, true, "f");
-                const keyExpression = evaluatedExpression.match(RE.reKeyExp)?.[0];
-                if (!keyExpression)
-                    throw new Error(`Error: keyExpression could not me extracted`);
-                if (evaluatedExpression !== `sh(wpkh(${keyExpression}))`)
-                    throw new Error(`Error: invalid expression ${expression}`);
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, 'sh(wpkh(@0))', "f");
-                __classPrivateFieldSet(this, _Descriptor_expansionMap, {
-                    '@0': parseKeyExpression({
-                        keyExpression,
-                        network,
-                        isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f")
-                    })
-                }, "f");
-                const pubkey = __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")['@0'].pubkey;
-                __classPrivateFieldSet(this, _Descriptor_payment, p2sh({ redeem: p2wpkh({ pubkey, network }), network }), "f");
-                const redeemScript = __classPrivateFieldGet(this, _Descriptor_payment, "f").redeem?.output;
-                if (!redeemScript)
-                    throw new Error(`Error: could not calculate redeemScript for ${expression}`);
-                __classPrivateFieldSet(this, _Descriptor_redeemScript, redeemScript, "f");
-            }
-            //wpkh(KEY) - native segwit
-            else if (evaluatedExpression.match(RE.reWpkhAnchored)) {
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, true, "f");
-                const keyExpression = evaluatedExpression.match(RE.reKeyExp)?.[0];
-                if (!keyExpression)
-                    throw new Error(`Error: keyExpression could not me extracted`);
-                if (evaluatedExpression !== `wpkh(${keyExpression})`)
-                    throw new Error(`Error: invalid expression ${expression}`);
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, 'wpkh(@0)', "f");
-                __classPrivateFieldSet(this, _Descriptor_expansionMap, {
-                    '@0': parseKeyExpression({
-                        keyExpression,
-                        network,
-                        isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f")
-                    })
-                }, "f");
-                const pubkey = __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")['@0'].pubkey;
-                __classPrivateFieldSet(this, _Descriptor_payment, p2wpkh({ pubkey, network }), "f");
-            }
-            //sh(wsh(miniscript))
-            else if (evaluatedExpression.match(RE.reShWshMiniscriptAnchored)) {
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, true, "f");
-                const miniscript = evaluatedExpression.match(RE.reShWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(wsh(->HERE<-))
-                if (!miniscript)
-                    throw new Error(`Error: could not get miniscript in ${evaluatedExpression}`);
-                __classPrivateFieldSet(this, _Descriptor_miniscript, miniscript, "f");
-                (_a = this, _b = this, {
-                    expandedMiniscript: ({ set value(_g) { __classPrivateFieldSet(_a, _Descriptor_expandedMiniscript, _g, "f"); } }).value,
-                    expansionMap: ({ set value(_g) { __classPrivateFieldSet(_b, _Descriptor_expansionMap, _g, "f"); } }).value
-                } = expandMiniscript({
-                    miniscript,
-                    isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f"),
-                    network
-                }));
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, `sh(wsh(${__classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f")}))`, "f");
-                const script = (0, miniscript_1.miniscript2Script)({
-                    expandedMiniscript: __classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f"),
-                    expansionMap: __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")
-                });
-                __classPrivateFieldSet(this, _Descriptor_witnessScript, script, "f");
-                if (script.byteLength > MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
-                    throw new Error(`Error: script is too large, ${script.byteLength} bytes is larger than ${MAX_STANDARD_P2WSH_SCRIPT_SIZE} bytes`);
-                }
-                const nonPushOnlyOps = countNonPushOnlyOPs(script);
-                if (nonPushOnlyOps > MAX_OPS_PER_SCRIPT) {
-                    throw new Error(`Error: too many non-push ops, ${nonPushOnlyOps} non-push ops is larger than ${MAX_OPS_PER_SCRIPT}`);
-                }
-                __classPrivateFieldSet(this, _Descriptor_payment, p2sh({
-                    redeem: p2wsh({ redeem: { output: script, network }, network }),
-                    network
-                }), "f");
-                const redeemScript = __classPrivateFieldGet(this, _Descriptor_payment, "f").redeem?.output;
-                if (!redeemScript)
-                    throw new Error(`Error: could not calculate redeemScript for ${expression}`);
-                __classPrivateFieldSet(this, _Descriptor_redeemScript, redeemScript, "f");
-            }
-            //sh(miniscript)
-            else if (evaluatedExpression.match(RE.reShMiniscriptAnchored)) {
-                //isSegwit false because we know it's a P2SH of a miniscript and not a
-                //P2SH that embeds a witness payment.
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, false, "f");
-                const miniscript = evaluatedExpression.match(RE.reShMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(->HERE<-)
-                if (!miniscript)
-                    throw new Error(`Error: could not get miniscript in ${evaluatedExpression}`);
-                if (allowMiniscriptInP2SH === false &&
-                    //These top-level expressions within sh are allowed within sh.
-                    //They can be parsed with miniscript2Script, but first we must make sure
-                    //that other expressions are not accepted (unless forced with allowMiniscriptInP2SH).
-                    miniscript.search(/^(pk\(|pkh\(|wpkh\(|combo\(|multi\(|sortedmulti\(|multi_a\(|sortedmulti_a\()/) !== 0) {
-                    throw new Error(`Error: Miniscript expressions can only be used in wsh`);
-                }
-                __classPrivateFieldSet(this, _Descriptor_miniscript, miniscript, "f");
-                (_c = this, _d = this, {
-                    expandedMiniscript: ({ set value(_g) { __classPrivateFieldSet(_c, _Descriptor_expandedMiniscript, _g, "f"); } }).value,
-                    expansionMap: ({ set value(_g) { __classPrivateFieldSet(_d, _Descriptor_expansionMap, _g, "f"); } }).value
-                } = expandMiniscript({
-                    miniscript,
-                    isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f"),
-                    network
-                }));
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, `sh(${__classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f")})`, "f");
-                const script = (0, miniscript_1.miniscript2Script)({
-                    expandedMiniscript: __classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f"),
-                    expansionMap: __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")
-                });
-                __classPrivateFieldSet(this, _Descriptor_redeemScript, script, "f");
-                if (script.byteLength > MAX_SCRIPT_ELEMENT_SIZE) {
-                    throw new Error(`Error: P2SH script is too large, ${script.byteLength} bytes is larger than ${MAX_SCRIPT_ELEMENT_SIZE} bytes`);
-                }
-                const nonPushOnlyOps = countNonPushOnlyOPs(script);
-                if (nonPushOnlyOps > MAX_OPS_PER_SCRIPT) {
-                    throw new Error(`Error: too many non-push ops, ${nonPushOnlyOps} non-push ops is larger than ${MAX_OPS_PER_SCRIPT}`);
-                }
-                __classPrivateFieldSet(this, _Descriptor_payment, p2sh({ redeem: { output: script, network }, network }), "f");
-                if (Buffer.compare(script, this.getRedeemScript()) !== 0)
-                    throw new Error(`Error: redeemScript was not correctly set to the payment in expression ${expression}`);
-            }
-            //wsh(miniscript)
-            else if (evaluatedExpression.match(RE.reWshMiniscriptAnchored)) {
-                __classPrivateFieldSet(this, _Descriptor_isSegwit, true, "f");
-                const miniscript = evaluatedExpression.match(RE.reWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found wsh(->HERE<-)
-                if (!miniscript)
-                    throw new Error(`Error: could not get miniscript in ${evaluatedExpression}`);
-                __classPrivateFieldSet(this, _Descriptor_miniscript, miniscript, "f");
-                (_e = this, _f = this, {
-                    expandedMiniscript: ({ set value(_g) { __classPrivateFieldSet(_e, _Descriptor_expandedMiniscript, _g, "f"); } }).value,
-                    expansionMap: ({ set value(_g) { __classPrivateFieldSet(_f, _Descriptor_expansionMap, _g, "f"); } }).value
-                } = expandMiniscript({
-                    miniscript,
-                    isSegwit: __classPrivateFieldGet(this, _Descriptor_isSegwit, "f"),
-                    network
-                }));
-                __classPrivateFieldSet(this, _Descriptor_expandedExpression, `wsh(${__classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f")})`, "f");
-                const script = (0, miniscript_1.miniscript2Script)({
-                    expandedMiniscript: __classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f"),
-                    expansionMap: __classPrivateFieldGet(this, _Descriptor_expansionMap, "f")
-                });
-                __classPrivateFieldSet(this, _Descriptor_witnessScript, script, "f");
-                if (script.byteLength > MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
-                    throw new Error(`Error: script is too large, ${script.byteLength} bytes is larger than ${MAX_STANDARD_P2WSH_SCRIPT_SIZE} bytes`);
-                }
-                const nonPushOnlyOps = countNonPushOnlyOPs(script);
-                if (nonPushOnlyOps > MAX_OPS_PER_SCRIPT) {
-                    throw new Error(`Error: too many non-push ops, ${nonPushOnlyOps} non-push ops is larger than ${MAX_OPS_PER_SCRIPT}`);
-                }
-                __classPrivateFieldSet(this, _Descriptor_payment, p2wsh({ redeem: { output: script, network }, network }), "f");
-            }
-            else {
-                throw new Error(`Error: Could not parse descriptor ${expression}`);
-            }
+            const expandedResult = expand({
+                expression: evaluatedExpression,
+                loggedExpression: expression,
+                network,
+                allowMiniscriptInP2SH
+            });
+            if (!expandedResult.payment)
+                throw new Error(`Error: could not extract a payment from ${expression}`);
+            __classPrivateFieldSet(this, _Descriptor_payment, expandedResult.payment, "f");
+            if (expandedResult.expandedExpression !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_expandedExpression, expandedResult.expandedExpression, "f");
+            if (expandedResult.miniscript !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_miniscript, expandedResult.miniscript, "f");
+            if (expandedResult.expansionMap !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_expansionMap, expandedResult.expansionMap, "f");
+            if (expandedResult.isSegwit !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_isSegwit, expandedResult.isSegwit, "f");
+            if (expandedResult.expandedMiniscript !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_expandedMiniscript, expandedResult.expandedMiniscript, "f");
+            if (expandedResult.redeemScript !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_redeemScript, expandedResult.redeemScript, "f");
+            if (expandedResult.witnessScript !== undefined)
+                __classPrivateFieldSet(this, _Descriptor_witnessScript, expandedResult.witnessScript, "f");
             if (signersPubKeys) {
                 __classPrivateFieldSet(this, _Descriptor_signersPubKeys, signersPubKeys, "f");
             }
             else {
                 if (__classPrivateFieldGet(this, _Descriptor_expansionMap, "f")) {
-                    __classPrivateFieldSet(this, _Descriptor_signersPubKeys, Object.values(__classPrivateFieldGet(this, _Descriptor_expansionMap, "f")).map(keyInfo => keyInfo.pubkey), "f");
+                    __classPrivateFieldSet(this, _Descriptor_signersPubKeys, Object.values(__classPrivateFieldGet(this, _Descriptor_expansionMap, "f")).map(keyInfo => {
+                        const pubkey = keyInfo.pubkey;
+                        if (!pubkey)
+                            throw new Error(`Error: could not extract a pubkey from ${expression}`);
+                        return pubkey;
+                    }), "f");
                 }
                 else {
                     //We should only miss expansionMap in addr() expressions:
@@ -418,6 +474,9 @@ function DescriptorsFactory(ecc) {
         getPayment() {
             return __classPrivateFieldGet(this, _Descriptor_payment, "f");
         }
+        /**
+         * Returns the Bitcoin Address
+         */
         getAddress() {
             if (!__classPrivateFieldGet(this, _Descriptor_payment, "f").address)
                 throw new Error(`Error: could extract an address from the payment`);
@@ -428,6 +487,11 @@ function DescriptorsFactory(ecc) {
                 throw new Error(`Error: could extract output.script from the payment`);
             return __classPrivateFieldGet(this, _Descriptor_payment, "f").output;
         }
+        /**
+         * 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) {
             const miniscript = __classPrivateFieldGet(this, _Descriptor_miniscript, "f");
             const expandedMiniscript = __classPrivateFieldGet(this, _Descriptor_expandedMiniscript, "f");
@@ -622,6 +686,6 @@ function DescriptorsFactory(ecc) {
             throw new Error(`Error: cannot finalize psbt index ${index} since it does not correspond to this descriptor`);
         }
     };
-    return { Descriptor, parseKeyExpression, ECPair, BIP32 };
+    return { Descriptor, parseKeyExpression, expand, ECPair, BIP32 };
 }
 exports.DescriptorsFactory = DescriptorsFactory;

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/keyExpressions.d.ts

@@ -3,7 +3,7 @@ import type { ECPairAPI } from 'ecpair';
 import type { BIP32API, BIP32Interface } from 'bip32';
 import type { KeyInfo } from './types';
 import { LedgerState } from './ledger';
-import type { AppClient } from '@bitcoinerlab/ledger';
+import type { AppClient } from 'ledger-bitcoin';
 export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network }: {
     keyExpression: string;
     network?: Network;