@bitcoinerlab/descriptors 0.2.2 → 0.3.1

package/README.md

@@ -79,8 +79,8 @@ constructor({
               // to denote an arbitrary index.
   index,      // The descriptor's index in the case of a range descriptor
               // (must be an integer >= 0).
-  checksumRequired = false, // Flag indicating if the descriptor is required
-                            // to include a checksum.
+  checksumRequired = false // Optional flag indicating if the descriptor is
+                           // required to include a checksum. Defaults to false.
   allowMiniscriptInP2SH = false, // Flag indicating if this instance can parse
                                  // and generate script satisfactions for
                                  // sh(miniscript) top-level expressions of
@@ -131,6 +131,64 @@ Here, `index` is the `inputIndex` obtained from the `updatePsbt()` method and `p
 
 For further information on using the Descriptor class, refer to the [comprehensive guides](https://bitcoinerlab.com/guides) that offer explanations and playgrounds to help learn the module. Additionally, a [Stack Exchange answer](https://bitcoin.stackexchange.com/a/118036/89665) provides a focused explanation on the constructor, specifically the `signersPubKeys` parameter, and the usage of `updatePsbt`, `finalizePsbt`, `getAddress`, and `getScriptPubKey`.
 
+#### Tip: Parsing descriptors without instantiating a class
+
+`DescriptorsFactory` provides a convenient `expand()` function that allows you to parse a descriptor expression without the need to instantiate the `Descriptor` class. This function can be used as follows:
+
+```javascript
+const { expand } = descriptors.DescriptorsFactory(secp256k1);
+const result = expand({
+  expression: 'sh(wsh(andor(pk(0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2),older(8640),pk([d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*))))',
+  network: networks.testnet, // One of bitcoinjs-lib `networks`
+                             // (https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/src/networks.js)
+                             // or another one with the same interface.
+                             // Optional (defaults to bitcoin mainnet). 
+  allowMiniscriptInP2SH: true, // Optional flag to allow miniscript in P2SH.
+                              // Defaults to false.
+  index, // Optional. The descriptor's index in the case of a range descriptor
+         // (must be an integer >= 0). If not set for ranged descriptors, then 
+         // the function will return an expansionMap with ranged keyPaths and
+         // won't compute Payment or scripts.
+  checksumRequired = false // Optional flag indicating if the descriptor is
+                           // required to include a checksum. Defaults to false.
+});
+```
+
+The `expand()` function returns an object with the following properties:
+
+- `payment: Payment | undefined`: 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: string | undefined`: The expanded descriptor expression.
+- `miniscript: string | undefined`: The extracted miniscript from the expression, if any.
+- `expansionMap: ExpansionMap | undefined`: A map of key expressions in the descriptor to their corresponding expanded keys.
+- `isSegwit: boolean | undefined`: A boolean indicating whether the descriptor represents a SegWit script.
+- `expandedMiniscript: string | undefined`: The expanded miniscript, if any.
+- `redeemScript: Buffer | undefined`: The redeem script for the descriptor, if applicable.
+- `witnessScript: Buffer | undefined`: The witness script for the descriptor, if applicable.
+- `isRanged: boolean` : Whether the expression represents 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.
+
+For the example expression provided, the `expandedExpression` and a portion of the `expansionMap` would be as follows:
+
+```javascript
+// expression: 'sh(wsh(andor(pk(0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2),older(8640),pk([d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*))))'
+
+expandedExpression: 'sh(wsh(andor(pk(@0),older(8640),pk(@1))))',
+expansionMap: {
+  '@0': {
+    keyExpression:
+      '0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2'
+  },
+  '@1': {
+    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 returned: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
+  }
+}
+```
+
 ### keyExpressions and scriptExpressions
 
 This library also includes a set of function helpers that facilitate the generation of the `expression` parameter in the constructor of the `Descriptor` class. These helpers are located under the `scriptExpressions` module, which can be imported using the following statement:

package/dist/descriptors.d.ts

@@ -1,6 +1,6 @@
 import { BIP32API } from 'bip32';
 import { ECPairAPI } from 'ecpair';
-import type { TinySecp256k1Interface, ParseKeyExpression, DescriptorInterfaceConstructor } from './types';
+import type { TinySecp256k1Interface, ParseKeyExpression, Expand, DescriptorInterfaceConstructor } 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).
@@ -10,5 +10,6 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
     Descriptor: DescriptorInterfaceConstructor;
     ECPair: ECPairAPI;
     parseKeyExpression: ParseKeyExpression;
+    expand: Expand;
     BIP32: BIP32API;
 };

package/dist/descriptors.js

@@ -55,7 +55,7 @@ function countNonPushOnlyOPs(script) {
     const decompile = bitcoinjs_lib_1.script.decompile(script);
     if (!decompile)
         throw new Error(`Error: cound not decompile ${script}`);
-    return decompile.filter(op => op > bitcoinjs_lib_1.script.OPS['OP_16']).length;
+    return decompile.filter(op => typeof op === 'number' && op > bitcoinjs_lib_1.script.OPS['OP_16']).length;
 }
 /*
  * Returns a bare descriptor without checksum and particularized for a certain
@@ -75,20 +75,20 @@ function evaluate({ expression, checksumRequired, index }) {
             throw new Error(`Error: invalid descriptor checksum for ${expression}`);
         }
     }
-    const mWildcard = evaluatedExpression.match(/\*/g);
-    if (mWildcard && mWildcard.length > 0) {
-        if (index === undefined)
-            throw new Error(`Error: index was not provided for ranged descriptor`);
-        if (!Number.isInteger(index) || index < 0)
-            throw new Error(`Error: invalid index ${index}`);
-        //From  https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md
-        //To prevent a combinatorial explosion of the search space, if more than
-        //one of the multi() key arguments is a BIP32 wildcard path ending in /* or
-        //*', the multi() expression only matches multisig scripts with the ith
-        //child key from each wildcard path in lockstep, rather than scripts with
-        //any combination of child keys from each wildcard path.
-        //We extend this reasoning for musig for all cases
-        evaluatedExpression = evaluatedExpression.replaceAll('*', index.toString());
+    if (index !== undefined) {
+        const mWildcard = evaluatedExpression.match(/\*/g);
+        if (mWildcard && mWildcard.length > 0) {
+            //From  https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md
+            //To prevent a combinatorial explosion of the search space, if more than
+            //one of the multi() key arguments is a BIP32 wildcard path ending in /* or
+            //*', the multi() expression only matches multisig scripts with the ith
+            //child key from each wildcard path in lockstep, rather than scripts with
+            //any combination of child keys from each wildcard path.
+            //We extend this reasoning for musig for all cases
+            evaluatedExpression = evaluatedExpression.replaceAll('*', index.toString());
+        }
+        else
+            throw new Error(`Error: index passed for non-ranged descriptor: ${expression}`);
     }
     return evaluatedExpression;
 }
@@ -114,6 +114,273 @@ 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.
+     *     - 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 }) => {
+        let expandedExpression;
+        let miniscript;
+        let expansionMap;
+        let isSegwit;
+        let expandedMiniscript;
+        let payment;
+        let witnessScript;
+        let redeemScript;
+        const isRanged = expression.indexOf('*') !== -1;
+        if (index !== undefined)
+            if (!Number.isInteger(index) || index < 0)
+                throw new Error(`Error: invalid index ${index}`);
+        //Verify and remove checksum (if exists) and
+        //particularize range descriptor for index (if desc is range descriptor)
+        const canonicalExpression = evaluate({
+            expression,
+            ...(index !== undefined ? { index } : {}),
+            checksumRequired
+        });
+        const isCanonicalRanged = canonicalExpression.indexOf('*') !== -1;
+        //addr(ADDR)
+        if (canonicalExpression.match(RE.reAddrAnchored)) {
+            if (isRanged)
+                throw new Error(`Error: addr() cannot be ranged`);
+            const matchedAddress = canonicalExpression.match(RE.reAddrAnchored)?.[1]; //[1]-> whatever is found addr(->HERE<-)
+            if (!matchedAddress)
+                throw new Error(`Error: could not get an address in ${expression}`);
+            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 (canonicalExpression.match(RE.rePkAnchored)) {
+            isSegwit = false;
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `pk(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${expression}`);
+            expandedExpression = 'pk(@0)';
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.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 ${expression}`);
+                payment = p2pk({ pubkey, network });
+            }
+        }
+        //pkh(KEY) - legacy
+        else if (canonicalExpression.match(RE.rePkhAnchored)) {
+            isSegwit = false;
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `pkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${expression}`);
+            expandedExpression = 'pkh(@0)';
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
+                payment = p2pkh({ pubkey, network });
+            }
+        }
+        //sh(wpkh(KEY)) - nested segwit
+        else if (canonicalExpression.match(RE.reShWpkhAnchored)) {
+            isSegwit = true;
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `sh(wpkh(${keyExpression}))`)
+                throw new Error(`Error: invalid expression ${expression}`);
+            expandedExpression = 'sh(wpkh(@0))';
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
+                payment = p2sh({ redeem: p2wpkh({ pubkey, network }), network });
+                redeemScript = payment.redeem?.output;
+                if (!redeemScript)
+                    throw new Error(`Error: could not calculate redeemScript for ${expression}`);
+            }
+        }
+        //wpkh(KEY) - native segwit
+        else if (canonicalExpression.match(RE.reWpkhAnchored)) {
+            isSegwit = true;
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `wpkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${expression}`);
+            expandedExpression = 'wpkh(@0)';
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
+                payment = p2wpkh({ pubkey, network });
+            }
+        }
+        //sh(wsh(miniscript))
+        else if (canonicalExpression.match(RE.reShWshMiniscriptAnchored)) {
+            isSegwit = true;
+            miniscript = canonicalExpression.match(RE.reShWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(wsh(->HERE<-))
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${expression}`);
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `sh(wsh(${expandedMiniscript}))`;
+            if (!isCanonicalRanged) {
+                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 ${expression}`);
+            }
+        }
+        //sh(miniscript)
+        else if (canonicalExpression.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 = canonicalExpression.match(RE.reShMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(->HERE<-)
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${expression}`);
+            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 (!isCanonicalRanged) {
+                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 (canonicalExpression.match(RE.reWshMiniscriptAnchored)) {
+            isSegwit = true;
+            miniscript = canonicalExpression.match(RE.reWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found wsh(->HERE<-)
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${expression}`);
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `wsh(${expandedMiniscript})`;
+            if (!isCanonicalRanged) {
+                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 ${expression}`);
+        }
+        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 } : {}),
+            isRanged,
+            canonicalExpression
+        };
+    };
     /**
      * Expand a miniscript to a generalized form using variables instead of key
      * expressions. Variables will be of this form: @0, @1, ...
@@ -144,7 +411,6 @@ function DescriptorsFactory(ecc) {
          * @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, []);
@@ -163,253 +429,47 @@ function DescriptorsFactory(ecc) {
             __classPrivateFieldSet(this, _Descriptor_preimages, preimages, "f");
             if (typeof expression !== 'string')
                 throw new Error(`Error: invalid descriptor type`);
-            //Verify and remove checksum (if exists) and
-            //particularize range descriptor for index (if desc is range descriptor)
-            const evaluatedExpression = evaluate({
+            const expandedResult = expand({
                 expression,
                 ...(index !== undefined ? { index } : {}),
-                checksumRequired
+                checksumRequired,
+                network,
+                allowMiniscriptInP2SH
             });
-            //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}`);
-            }
+            if (expandedResult.isRanged && index === undefined)
+                throw new Error(`Error: index was not provided for ranged descriptor`);
+            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:
-                    if (!evaluatedExpression.match(RE.reAddrAnchored)) {
+                    if (!expandedResult.canonicalExpression.match(RE.reAddrAnchored)) {
                         throw new Error(`Error: expansionMap not available for expression ${expression} that is not an address`);
                     }
                     __classPrivateFieldSet(this, _Descriptor_signersPubKeys, [this.getScriptPubKey()], "f");
@@ -631,6 +691,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/keyExpressions.js

@@ -44,17 +44,17 @@ const derivePath = (node, path) => {
     return node.derivePath(parsedPath);
 };
 /*
- * Takes a key expression (xpub, xprv, pubkey or wif) and returns a pubkey in
- * binary format
+ * Parses a key expression (xpub, xprv, pubkey or wif) into KeyInfo
  */
 function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network = bitcoinjs_lib_1.networks.bitcoin }) {
-    let pubkey;
+    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;
     //Validate the keyExpression:
     const keyExpressions = keyExpression.match(RE.reKeyExp);
     if (keyExpressions === null || keyExpressions[0] !== keyExpression) {
@@ -115,7 +115,8 @@ function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network =
             if (!keyPath)
                 throw new Error(`Error: could not extract a path`);
             //fromBase58 and derivePath will throw if xPub or path are not valid
-            pubkey = derivePath(bip32, keyPath).publicKey;
+            if (!isRanged)
+                pubkey = derivePath(bip32, keyPath).publicKey;
         }
         else {
             pubkey = bip32.publicKey;
@@ -134,7 +135,8 @@ function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network =
             if (!keyPath)
                 throw new Error(`Error: could not extract a path`);
             //fromBase58 and derivePath will throw if xPrv or path are not valid
-            pubkey = derivePath(bip32, keyPath).publicKey;
+            if (!isRanged)
+                pubkey = derivePath(bip32, keyPath).publicKey;
         }
         else {
             pubkey = bip32.publicKey;
@@ -143,12 +145,12 @@ function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network =
     else {
         throw new Error(`Error: could not get pubkey for keyExpression ${keyExpression}`);
     }
-    if (masterFingerprint && (originPath || keyPath)) {
-        path = 'm' + originPath + keyPath;
+    if (originPath || keyPath) {
+        path = `m${originPath ?? ''}${keyPath ?? ''}`;
     }
     return {
-        pubkey,
         keyExpression,
+        ...(pubkey !== undefined ? { pubkey } : {}),
         ...(ecpair !== undefined ? { ecpair } : {}),
         ...(bip32 !== undefined ? { bip32 } : {}),
         ...(masterFingerprint !== undefined ? { masterFingerprint } : {}),

package/dist/miniscript.js

@@ -51,8 +51,11 @@ function expandMiniscript({ miniscript, isSegwit, network = bitcoinjs_lib_1.netw
         return key;
     });
     //Do some assertions. Miniscript must not have duplicate keys, also all
-    //keyExpressions must produce a valid pubkey
-    const pubkeysHex = Object.values(expansionMap).map(keyInfo => {
+    //keyExpressions must produce a valid pubkey (unless it's ranged and we want
+    //to expand a generalized form, then we don't check)
+    const pubkeysHex = Object.values(expansionMap)
+        .filter(keyInfo => keyInfo.keyExpression.indexOf('*') === -1)
+        .map(keyInfo => {
         if (!keyInfo.pubkey)
             throw new Error(`Error: keyExpression ${keyInfo.keyExpression} does not have a pubkey`);
         return keyInfo.pubkey.toString('hex');
@@ -133,7 +136,7 @@ function satisfyMiniscript({ expandedMiniscript, expansionMap, signatures = [],
     const expandedSignatureMap = {};
     signatures.forEach(signature => {
         const pubkeyHex = signature.pubkey.toString('hex');
-        const keyExpression = Object.keys(expansionMap).find(k => expansionMap[k]?.pubkey.toString('hex') === pubkeyHex);
+        const keyExpression = Object.keys(expansionMap).find(k => expansionMap[k]?.pubkey?.toString('hex') === pubkeyHex);
         expandedSignatureMap['<sig(' + keyExpression + ')>'] =
             '<' + signature.signature.toString('hex') + '>';
     });

package/dist/psbt.js

@@ -168,11 +168,16 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
     }
     const bip32Derivation = keysInfo
         .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && keyInfo.path)
-        .map((keyInfo) => ({
-        masterFingerprint: keyInfo.masterFingerprint,
-        pubkey: keyInfo.pubkey,
-        path: keyInfo.path
-    }));
+        .map((keyInfo) => {
+        const pubkey = keyInfo.pubkey;
+        if (!pubkey)
+            throw new Error(`key ${keyInfo.keyExpression} missing pubkey`);
+        return {
+            masterFingerprint: keyInfo.masterFingerprint,
+            pubkey,
+            path: keyInfo.path
+        };
+    });
     if (bip32Derivation.length)
         input.bip32Derivation = bip32Derivation;
     if (isSegwit && txHex !== undefined) {

package/dist/types.d.ts

@@ -26,7 +26,7 @@ export type TimeConstraints = {
 };
 export type KeyInfo = {
     keyExpression: string;
-    pubkey: Buffer;
+    pubkey?: Buffer;
     ecpair?: ECPairInterface;
     bip32?: BIP32Interface;
     masterFingerprint?: Buffer;
@@ -44,6 +44,26 @@ export interface ParseKeyExpression {
         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;
+    };
+}
 interface XOnlyPointAddTweakResult {
     parity: 1 | 0;
     xOnlyPubkey: Uint8Array;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitcoinerlab/descriptors",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "0.2.2",
+  "version": "0.3.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",
@@ -64,8 +64,8 @@
   "devDependencies": {
     "@babel/plugin-transform-modules-commonjs": "^7.20.11",
     "@ledgerhq/hw-transport-node-hid": "^6.27.12",
-    "@typescript-eslint/eslint-plugin": "^5.53.0",
-    "@typescript-eslint/parser": "^5.53.0",
+    "@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",
@@ -78,8 +78,9 @@
     "jest": "^29.4.3",
     "jsdoc": "^3.6.11",
     "path": "^0.12.7",
-    "prettier": "^2.8.4",
+    "prettier": "^2.8.8",
     "regtest-client": "^0.2.0",
-    "ts-node-dev": "^2.0.0"
+    "ts-node-dev": "^2.0.0",
+    "typescript": "5.0"
   }
 }