@bitcoinerlab/descriptors 2.0.2 → 2.1.0

package/README.md

@@ -73,11 +73,11 @@ const wpkhOutput = new Output({
 });
 ```
 
-Refer to [the API](https://bitcoinerlab.com/modules/descriptors/api/classes/_Internal_.Output.html#constructor) for the complete list of parameters in the constructor.
+For miniscript-based descriptors, the `signersPubKeys` parameter in the constuctor becomes particularly important. It specifies the spending path of a previous output with multiple spending paths. Detailed information about the constructor parameters, including `signersPubKeys`, can be found in [the API documentation](https://bitcoinerlab.com/modules/descriptors/api/classes/_Internal_.Output.html#constructor) and in [this Stack Exchange answer](https://bitcoin.stackexchange.com/a/118036/89665).
 
 The `Output` class [offers various helpful methods](https://bitcoinerlab.com/modules/descriptors/api/classes/_Internal_.Output.html), 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, `updatePsbtAsInput()` and `updatePsbtAsOutput()`.
 
-The `updatePsbtAsInput()` method is an essential part of the library, responsible for adding an input to the PSBT corresponding to the UTXO  described by the descriptor. Additionally, when the descriptor expresses an absolute time-spending condition, such as "This UTXO can only be spent after block N," `updatePsbtAsInput()` adds timelock information to the PSBT.
+The `updatePsbtAsInput()` method is an essential part of the library, responsible for adding an input to the PSBT corresponding to the UTXO  described by the descriptor. Additionally, when the descriptor expresses an absolute time-spending condition, such as "This UTXO can only be spent after block N", `updatePsbtAsInput()` adds timelock information to the PSBT.
 
 To call `updatePsbtAsInput()`, use the following syntax:
 

package/dist/descriptors.d.ts

@@ -66,23 +66,6 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              * satisfyMiniscript verifies that the time constraints did not change.
              */
             "__#1@#getTimeConstraints"(): TimeConstraints | undefined;
-            /**
-             * Retrieves the byte length of the script satisfaction for a Miniscript-based
-             * descriptor, using only the expression, signers' public keys, and preimages
-             * provided in the constructor.
-             *
-             * Useful in scenarios like coin selection algorithms for transaction creation,
-             * where signatures are not yet available. Since signatures are still to be
-             * computed, the function assigns a standard length of 72 bytes for each
-             * signature. However, note that this may not always be completely accurate,
-             * as approximately 50% of signatures are 71 bytes in length
-             * (source: https://transactionfee.info/charts/bitcoin-script-ecdsa-length/).
-             * The function returns the byte length for a worst-case scenario.
-             *
-             * @returns The byte length of the compiled script satisfaction, or `undefined`
-             *          if this was not a miniscript-based descriptor.
-             */
-            getScriptSatisfactionSize(): number | undefined;
             /**
              * Creates and returns an instance of bitcoinjs-lib
              * [`Payment`](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/payments/index.ts)'s interface with the `scriptPubKey` of this `Output`.
@@ -107,7 +90,7 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              * Important: As mentioned above, note that this function only applies to
              * miniscript descriptors.
              */
-            getScriptSatisfaction(signatures: PartialSig[]): Buffer;
+            getScriptSatisfaction(signatures: PartialSig[] | 'DANGEROUSLY_USE_FAKE_SIGNATURES'): Buffer;
             /**
              * Gets the nSequence required to fulfill this `Output`.
              */
@@ -132,8 +115,40 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
             getNetwork(): Network;
             /**
              * Whether this `Output` is Segwit.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             *
              */
             isSegwit(): boolean | undefined;
+            /**
+             * Returns the tuple: `{ isPKH: boolean; isWPKH: boolean; isSH: boolean; }`
+             * for this Output.
+             */
+            guessOutput(): {
+                isPKH: boolean;
+                isWPKH: boolean;
+                isSH: boolean;
+            };
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * input in a tx.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             */
+            inputWeight(isSegwitTx: boolean, signatures: PartialSig[] | 'DANGEROUSLY_USE_FAKE_SIGNATURES'): number;
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * output in a tx.
+             */
+            outputWeight(): number;
             /** @deprecated - Use updatePsbtAsInput instead
              * @hidden
              */
@@ -274,22 +289,34 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              */
             network?: Network;
             /**
-             * An array of preimages. This info is necessary to finalize Psbts.
+             * An array of preimages if the miniscript-based descriptor uses them.
+             *
+             * This info is necessary to finalize Psbts. Leave it `undefined` if your
+             * miniscript-based descriptor does not use preimages or you don't know
+             * or don't wanto use them.
+             *
+             * You can also leave it `undefined` if only need to generate the
+             * `scriptPubKey` or `address` for a descriptor.
+             *
              * @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).
+             * spending the previous 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).
+             *
              * For more details on using this parameter, refer to [this Stack Exchange
              * answer](https://bitcoin.stackexchange.com/a/118036/89665).
              */
@@ -321,23 +348,6 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              * satisfyMiniscript verifies that the time constraints did not change.
              */
             "__#1@#getTimeConstraints"(): TimeConstraints | undefined;
-            /**
-             * Retrieves the byte length of the script satisfaction for a Miniscript-based
-             * descriptor, using only the expression, signers' public keys, and preimages
-             * provided in the constructor.
-             *
-             * Useful in scenarios like coin selection algorithms for transaction creation,
-             * where signatures are not yet available. Since signatures are still to be
-             * computed, the function assigns a standard length of 72 bytes for each
-             * signature. However, note that this may not always be completely accurate,
-             * as approximately 50% of signatures are 71 bytes in length
-             * (source: https://transactionfee.info/charts/bitcoin-script-ecdsa-length/).
-             * The function returns the byte length for a worst-case scenario.
-             *
-             * @returns The byte length of the compiled script satisfaction, or `undefined`
-             *          if this was not a miniscript-based descriptor.
-             */
-            getScriptSatisfactionSize(): number | undefined;
             /**
              * Creates and returns an instance of bitcoinjs-lib
              * [`Payment`](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/payments/index.ts)'s interface with the `scriptPubKey` of this `Output`.
@@ -362,7 +372,7 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              * Important: As mentioned above, note that this function only applies to
              * miniscript descriptors.
              */
-            getScriptSatisfaction(signatures: PartialSig[]): Buffer;
+            getScriptSatisfaction(signatures: PartialSig[] | 'DANGEROUSLY_USE_FAKE_SIGNATURES'): Buffer;
             /**
              * Gets the nSequence required to fulfill this `Output`.
              */
@@ -387,8 +397,40 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
             getNetwork(): Network;
             /**
              * Whether this `Output` is Segwit.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             *
              */
             isSegwit(): boolean | undefined;
+            /**
+             * Returns the tuple: `{ isPKH: boolean; isWPKH: boolean; isSH: boolean; }`
+             * for this Output.
+             */
+            guessOutput(): {
+                isPKH: boolean;
+                isWPKH: boolean;
+                isSH: boolean;
+            };
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * input in a tx.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             */
+            inputWeight(isSegwitTx: boolean, signatures: PartialSig[] | 'DANGEROUSLY_USE_FAKE_SIGNATURES'): number;
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * output in a tx.
+             */
+            outputWeight(): number;
             /** @deprecated - Use updatePsbtAsInput instead
              * @hidden
              */

package/dist/descriptors.js

@@ -35,9 +35,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DescriptorsFactory = void 0;
+const lodash_memoize_1 = __importDefault(require("lodash.memoize"));
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const varuint_bitcoin_1 = require("varuint-bitcoin");
 const { p2sh, p2wpkh, p2pkh, p2pk, p2wsh, p2tr } = bitcoinjs_lib_1.payments;
 const bip32_1 = require("bip32");
 const ecpair_1 = require("ecpair");
@@ -57,6 +62,28 @@ function countNonPushOnlyOPs(script) {
         throw new Error(`Error: cound not decompile ${script}`);
     return decompile.filter(op => typeof op === 'number' && op > bitcoinjs_lib_1.script.OPS['OP_16']).length;
 }
+function vectorSize(someVector) {
+    const length = someVector.length;
+    return ((0, varuint_bitcoin_1.encodingLength)(length) +
+        someVector.reduce((sum, witness) => {
+            return sum + varSliceSize(witness);
+        }, 0));
+}
+function varSliceSize(someScript) {
+    const length = someScript.length;
+    return (0, varuint_bitcoin_1.encodingLength)(length) + length;
+}
+/**
+ * This function will typically return 73; since it assumes a signature size of
+ * 72 bytes (this is the max size of a DER encoded signature) and it adds 1
+ * extra byte for encoding its length
+ */
+function signatureSize(signature) {
+    const length = signature === 'DANGEROUSLY_USE_FAKE_SIGNATURES'
+        ? 72
+        : signature.signature.length;
+    return (0, varuint_bitcoin_1.encodingLength)(length) + length;
+}
 /*
  * Returns a bare descriptor without checksum and particularized for a certain
  * index (if desc was a range descriptor)
@@ -184,22 +211,28 @@ function DescriptorsFactory(ecc) {
             }
             try {
                 payment = p2pkh({ output, network });
+                isSegwit = false;
             }
             catch (e) { }
             try {
                 payment = p2sh({ output, network });
+                // It assumes that an addr(SH_ADDRESS) is always a add(SH_WPKH) address
+                isSegwit = true;
             }
             catch (e) { }
             try {
                 payment = p2wpkh({ output, network });
+                isSegwit = true;
             }
             catch (e) { }
             try {
                 payment = p2wsh({ output, network });
+                isSegwit = true;
             }
             catch (e) { }
             try {
                 payment = p2tr({ output, network });
+                isSegwit = true;
             }
             catch (e) { }
             if (!payment) {
@@ -480,49 +513,25 @@ function DescriptorsFactory(ecc) {
                     __classPrivateFieldSet(this, _Output_signersPubKeys, [this.getScriptPubKey()], "f");
                 }
             }
-        }
-        /**
-         * Retrieves the byte length of the script satisfaction for a Miniscript-based
-         * descriptor, using only the expression, signers' public keys, and preimages
-         * provided in the constructor.
-         *
-         * Useful in scenarios like coin selection algorithms for transaction creation,
-         * where signatures are not yet available. Since signatures are still to be
-         * computed, the function assigns a standard length of 72 bytes for each
-         * signature. However, note that this may not always be completely accurate,
-         * as approximately 50% of signatures are 71 bytes in length
-         * (source: https://transactionfee.info/charts/bitcoin-script-ecdsa-length/).
-         * The function returns the byte length for a worst-case scenario.
-         *
-         * @returns The byte length of the compiled script satisfaction, or `undefined`
-         *          if this was not a miniscript-based descriptor.
-         */
-        getScriptSatisfactionSize() {
-            const miniscript = __classPrivateFieldGet(this, _Output_miniscript, "f");
-            const preimages = __classPrivateFieldGet(this, _Output_preimages, "f");
-            const expandedMiniscript = __classPrivateFieldGet(this, _Output_expandedMiniscript, "f");
-            const expansionMap = __classPrivateFieldGet(this, _Output_expansionMap, "f");
-            const signersPubKeys = __classPrivateFieldGet(this, _Output_signersPubKeys, "f");
-            //Create a method. solvePreimages to solve them.
-            if (miniscript) {
-                if (expandedMiniscript === undefined || expansionMap === undefined)
-                    throw new Error(`Error: cannot get script satisfactions from not expanded miniscript ${miniscript}`);
-                //We create some fakeSignatures since we may not have them yet.
-                const fakeSignatures = signersPubKeys.map(pubkey => ({
-                    pubkey,
-                    // https://transactionfee.info/charts/bitcoin-script-ecdsa-length/
-                    signature: Buffer.alloc(72, 0)
-                }));
-                const { scriptSatisfaction } = (0, miniscript_1.satisfyMiniscript)({
-                    expandedMiniscript,
-                    expansionMap,
-                    signatures: fakeSignatures,
-                    preimages
-                });
-                return scriptSatisfaction.length;
-            }
-            else
-                return undefined;
+            this.getSequence = (0, lodash_memoize_1.default)(this.getSequence);
+            this.getLockTime = (0, lodash_memoize_1.default)(this.getLockTime);
+            const getSignaturesKey = (signatures) => signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES'
+                ? signatures
+                : signatures
+                    .map(s => `${s.pubkey.toString('hex')}-${s.signature.toString('hex')}`)
+                    .join('|');
+            this.getScriptSatisfaction = (0, lodash_memoize_1.default)(this.getScriptSatisfaction, 
+            // resolver function:
+            getSignaturesKey);
+            this.guessOutput = (0, lodash_memoize_1.default)(this.guessOutput);
+            this.inputWeight = (0, lodash_memoize_1.default)(this.inputWeight, 
+            // resolver function:
+            (isSegwitTx, signatures) => {
+                const segwitKey = isSegwitTx ? 'segwit' : 'non-segwit';
+                const signaturesKey = getSignaturesKey(signatures);
+                return `${segwitKey}-${signaturesKey}`;
+            });
+            this.outputWeight = (0, lodash_memoize_1.default)(this.outputWeight);
         }
         /**
          * Creates and returns an instance of bitcoinjs-lib
@@ -565,8 +574,28 @@ function DescriptorsFactory(ecc) {
          *
          * `signatures` must be passed using this format (pairs of `pubKey/signature`):
          * `interface PartialSig { pubkey: Buffer; signature: Buffer; }`
+         *
+         *  * Alternatively, if you do not have the signatures, you can use the option
+         * `'DANGEROUSLY_USE_FAKE_SIGNATURES'`. This will generate script satisfactions
+         * using 72-byte zero-padded signatures. While this can be useful in
+         * modules like coinselector that require estimating transaction size before
+         * signing, it is critical to understand the risks:
+         * - Using this option generales invalid unlocking scripts.
+         * - It should NEVER be used with real transactions.
+         * - Its primary use is for testing and size estimation purposes only.
+         *
+         * ⚠️ Warning: Misuse of 'DANGEROUSLY_USE_FAKE_SIGNATURES' can lead to security
+         * vulnerabilities, including but not limited to invalid transaction generation.
+         * Ensure you fully understand the implications before use.
+         *
          */
         signatures) {
+            if (signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES')
+                signatures = __classPrivateFieldGet(this, _Output_signersPubKeys, "f").map(pubkey => ({
+                    pubkey,
+                    // https://transactionfee.info/charts/bitcoin-script-ecdsa-length/
+                    signature: Buffer.alloc(72, 0)
+                }));
             const miniscript = __classPrivateFieldGet(this, _Output_miniscript, "f");
             const expandedMiniscript = __classPrivateFieldGet(this, _Output_expandedMiniscript, "f");
             const expansionMap = __classPrivateFieldGet(this, _Output_expansionMap, "f");
@@ -630,10 +659,228 @@ function DescriptorsFactory(ecc) {
         }
         /**
          * Whether this `Output` is Segwit.
+         *
+         * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+         * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+         * (Script Hash-Witness Public Key Hash).
+         * For inputs using arbitrary scripts (not standard addresses),
+         * use a descriptor in the format `sh(MINISCRIPT)`.
+         *
          */
         isSegwit() {
             return __classPrivateFieldGet(this, _Output_isSegwit, "f");
         }
+        /**
+         * Returns the tuple: `{ isPKH: boolean; isWPKH: boolean; isSH: boolean; }`
+         * for this Output.
+         */
+        guessOutput() {
+            function guessSH(output) {
+                try {
+                    bitcoinjs_lib_1.payments.p2sh({ output });
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            function guessWPKH(output) {
+                try {
+                    bitcoinjs_lib_1.payments.p2wpkh({ output });
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            function guessPKH(output) {
+                try {
+                    bitcoinjs_lib_1.payments.p2pkh({ output });
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            const isPKH = guessPKH(this.getScriptPubKey());
+            const isWPKH = guessWPKH(this.getScriptPubKey());
+            const isSH = guessSH(this.getScriptPubKey());
+            if ([isPKH, isWPKH, isSH].filter(Boolean).length > 1)
+                throw new Error('Cannot have multiple output types.');
+            return { isPKH, isWPKH, isSH };
+        }
+        // References for inputWeight & outputWeight:
+        // https://gist.github.com/junderw/b43af3253ea5865ed52cb51c200ac19c
+        // https://bitcoinops.org/en/tools/calc-size/
+        // Look for byteLength: https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/transaction.ts
+        // https://github.com/bitcoinjs/coinselect/blob/master/utils.js
+        /**
+         * Computes the Weight Unit contributions of this Output as if it were the
+         * input in a tx.
+         *
+         * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+         * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+         * (Script Hash-Witness Public Key Hash).
+         * For inputs using arbitrary scripts (not standard addresses),
+         * use a descriptor in the format `sh(MINISCRIPT)`.
+         */
+        inputWeight(
+        /**
+         * Indicates if the transaction is a Segwit transaction.
+         * If a transaction isSegwitTx, a single byte is then also required for
+         * non-witness inputs to encode the length of the empty witness stack:
+         * encodeLength(0) + 0 = 1
+         * Read more:
+         * https://gist.github.com/junderw/b43af3253ea5865ed52cb51c200ac19c?permalink_comment_id=4760512#gistcomment-4760512
+         */
+        isSegwitTx, 
+        /*
+         *  Array of `PartialSig`. Each `PartialSig` includes
+         *  a public key and its corresponding signature. This parameter
+         *  enables the accurate calculation of signature sizes.
+         *  Pass 'DANGEROUSLY_USE_FAKE_SIGNATURES' to assume 72 bytes in length.
+         *  Mainly used for testing.
+         */
+        signatures) {
+            if (this.isSegwit() && !isSegwitTx)
+                throw new Error(`a tx is segwit if at least one input is segwit`);
+            const errorMsg = 'Input type not implemented. Currently supported: pkh(KEY), wpkh(KEY), \
+    sh(wpkh(KEY)), sh(wsh(MINISCRIPT)), sh(MINISCRIPT), wsh(MINISCRIPT), \
+    addr(PKH_ADDRESS), addr(WPKH_ADDRESS), addr(SH_WPKH_ADDRESS).';
+            //expand any miniscript-based descriptor. If not miniscript-based, then it's
+            //an addr() descriptor. For those, we can only guess their type.
+            const expansion = this.expand().expandedExpression;
+            const { isPKH, isWPKH, isSH } = this.guessOutput();
+            if (!expansion && !isPKH && !isWPKH && !isSH)
+                throw new Error(errorMsg);
+            const firstSignature = signatures && typeof signatures[0] === 'object'
+                ? signatures[0]
+                : 'DANGEROUSLY_USE_FAKE_SIGNATURES';
+            if (expansion ? expansion.startsWith('pkh(') : isPKH) {
+                return (
+                // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1) + (sig:73) + (pubkey:34)
+                (32 + 4 + 4 + 1 + signatureSize(firstSignature) + 34) * 4 +
+                    //Segwit:
+                    (isSegwitTx ? 1 : 0));
+            }
+            else if (expansion ? expansion.startsWith('wpkh(') : isWPKH) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return (
+                // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1)
+                41 * 4 +
+                    // Segwit: (push_count:1) + (sig:73) + (pubkey:34)
+                    (1 + signatureSize(firstSignature) + 34));
+            }
+            else if (expansion ? expansion.startsWith('sh(wpkh(') : isSH) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return (
+                // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1) + (p2wpkh:23)
+                //  -> p2wpkh_script: OP_0 OP_PUSH20 <public_key_hash>
+                //  -> p2wpkh: (script_len:1) + (script:22)
+                64 * 4 +
+                    // Segwit: (push_count:1) + (sig:73) + (pubkey:34)
+                    (1 + signatureSize(firstSignature) + 34));
+            }
+            else if (expansion?.startsWith('sh(wsh(')) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                const witnessScript = this.getWitnessScript();
+                if (!witnessScript)
+                    throw new Error('sh(wsh) must provide witnessScript');
+                const payment = bitcoinjs_lib_1.payments.p2sh({
+                    redeem: bitcoinjs_lib_1.payments.p2wsh({
+                        redeem: {
+                            input: this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES'),
+                            output: witnessScript
+                        }
+                    })
+                });
+                if (!payment || !payment.input || !payment.witness)
+                    throw new Error('Could not create payment');
+                return (
+                //Non-segwit
+                4 * (40 + varSliceSize(payment.input)) +
+                    //Segwit
+                    vectorSize(payment.witness));
+            }
+            else if (expansion?.startsWith('sh(')) {
+                const redeemScript = this.getRedeemScript();
+                if (!redeemScript)
+                    throw new Error('sh() must provide redeemScript');
+                const payment = bitcoinjs_lib_1.payments.p2sh({
+                    redeem: {
+                        input: this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES'),
+                        output: redeemScript
+                    }
+                });
+                if (!payment || !payment.input)
+                    throw new Error('Could not create payment');
+                if (payment.witness?.length)
+                    throw new Error('A legacy p2sh payment should not cointain a witness');
+                return (
+                //Non-segwit
+                4 * (40 + varSliceSize(payment.input)) +
+                    //Segwit:
+                    (isSegwitTx ? 1 : 0));
+            }
+            else if (expansion?.startsWith('wsh(')) {
+                const witnessScript = this.getWitnessScript();
+                if (!witnessScript)
+                    throw new Error('wsh must provide witnessScript');
+                const payment = bitcoinjs_lib_1.payments.p2wsh({
+                    redeem: {
+                        input: this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES'),
+                        output: witnessScript
+                    }
+                });
+                if (!payment || !payment.input || !payment.witness)
+                    throw new Error('Could not create payment');
+                return (
+                //Non-segwit
+                4 * (40 + varSliceSize(payment.input)) +
+                    //Segwit
+                    vectorSize(payment.witness));
+            }
+            else {
+                throw new Error(errorMsg);
+            }
+        }
+        /**
+         * Computes the Weight Unit contributions of this Output as if it were the
+         * output in a tx.
+         */
+        outputWeight() {
+            const errorMsg = 'Output type not implemented. Currently supported: pkh(KEY), wpkh(KEY), \
+    sh(ANYTHING), wsh(ANYTHING), addr(PKH_ADDRESS), addr(WPKH_ADDRESS), \
+    addr(SH_WPKH_ADDRESS)';
+            //expand any miniscript-based descriptor. If not miniscript-based, then it's
+            //an addr() descriptor. For those, we can only guess their type.
+            const expansion = this.expand().expandedExpression;
+            const { isPKH, isWPKH, isSH } = this.guessOutput();
+            if (!expansion && !isPKH && !isWPKH && !isSH)
+                throw new Error(errorMsg);
+            if (expansion ? expansion.startsWith('pkh(') : isPKH) {
+                // (p2pkh:26) + (amount:8)
+                return 34 * 4;
+            }
+            else if (expansion ? expansion.startsWith('wpkh(') : isWPKH) {
+                // (p2wpkh:23) + (amount:8)
+                return 31 * 4;
+            }
+            else if (expansion ? expansion.startsWith('sh(') : isSH) {
+                // (p2sh:24) + (amount:8)
+                return 32 * 4;
+            }
+            else if (expansion?.startsWith('wsh(')) {
+                // (p2wsh:35) + (amount:8)
+                return 43 * 4;
+            }
+            else {
+                throw new Error(errorMsg);
+            }
+        }
         /** @deprecated - Use updatePsbtAsInput instead
          * @hidden
          */

package/dist/psbt.js

@@ -1,33 +1,10 @@
 "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.updatePsbt = exports.finalScriptsFuncFactory = void 0;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const varuint = __importStar(require("bip174/src/lib/converter/varint"));
+const varuint_bitcoin_1 = require("varuint-bitcoin");
 function reverseBuffer(buffer) {
     if (buffer.length < 1)
         return buffer;
@@ -48,9 +25,9 @@ function witnessStackToScriptWitness(witness) {
     }
     function writeVarInt(i) {
         const currentLen = buffer.length;
-        const varintLen = varuint.encodingLength(i);
+        const varintLen = (0, varuint_bitcoin_1.encodingLength)(i);
         buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-        varuint.encode(i, buffer, currentLen);
+        (0, varuint_bitcoin_1.encode)(i, buffer, currentLen);
     }
     function writeVarSlice(slice) {
         writeVarInt(slice.length);

package/dist/types.d.ts

@@ -9,13 +9,15 @@ import type { Payment, Network } from 'bitcoinjs-lib';
  */
 export type Preimage = {
     /**
-     * Use same expressions as in miniscript. For example: "sha256(cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204)" or "ripemd160(095ff41131e5946f3c85f79e44adbcf8e27e080e)"
+     * Use same string expressions as in miniscript. For example: "sha256(cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204)" or "ripemd160(095ff41131e5946f3c85f79e44adbcf8e27e080e)"
+     *
      * Accepted functions: sha256, hash256, ripemd160, hash160
+     *
      * Digests must be: 64-character HEX for sha256, hash160 or 30-character HEX for ripemd160 or hash160.
      */
     digest: string;
     /**
-     * Hex encoded preimate. Preimages are always 32 bytes (so, 64 character in hex).
+     * Hex encoded preimage. Preimages are always 32 bytes (so, 64 character in hex).
      */
     preimage: string;
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bitcoinerlab/descriptors",
   "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.",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "author": "Jose-Luis Landabaso",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "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:test": "npm run build:fixtures && tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.test.json --resolveJsonModule",
     "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",
@@ -58,6 +58,7 @@
   "devDependencies": {
     "@bitcoinerlab/configs": "github:bitcoinerlab/configs",
     "@ledgerhq/hw-transport-node-hid": "^6.27.12",
+    "@types/lodash.memoize": "^4.1.9",
     "bip39": "^3.0.4",
     "bip65": "^1.0.3",
     "bip68": "^1.0.4",
@@ -70,6 +71,8 @@
     "@bitcoinerlab/secp256k1": "^1.0.5",
     "bip32": "^4.0.0",
     "bitcoinjs-lib": "^6.1.3",
-    "ecpair": "^2.1.0"
+    "ecpair": "^2.1.0",
+    "lodash.memoize": "^4.1.2",
+    "varuint-bitcoin": "^1.1.2"
   }
 }