@kukks/bitcoin-descriptors 3.0.2

package/dist/descriptors.js

@@ -0,0 +1,1033 @@
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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);
+};
+/** Simple memoize: caches results keyed by an optional resolver. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function memoize(fn, resolver) {
+    const cache = new Map();
+    return function (...args) {
+        const key = resolver ? resolver(...args) : String(args[0]);
+        if (cache.has(key))
+            return cache.get(key);
+        const result = fn.apply(this, args);
+        cache.set(key, result);
+        return result;
+    };
+}
+import * as btc from '@scure/btc-signer';
+import { networks, toBtcSignerNetwork } from './networks.js';
+import { varintEncodingLength, decompileScript } from './scriptUtils.js';
+import { hash160, compareBytes, equalBytes, concatBytes } from '@scure/btc-signer/utils.js';
+import { hex } from '@scure/base';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { computeFinalScripts, updatePsbt } from './psbt.js';
+import { DescriptorChecksum } from './checksum.js';
+import { parseKeyExpression as globalParseKeyExpression } from './keyExpressions.js';
+import * as RE from './re.js';
+import { expandMiniscript as globalExpandMiniscript, miniscript2Script, satisfyMiniscript } from './miniscript.js';
+//See "Resource limitations" https://bitcoin.sipa.be/miniscript/
+//https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2019-September/017306.html
+const MAX_SCRIPT_ELEMENT_SIZE = 520;
+const MAX_STANDARD_P2WSH_SCRIPT_SIZE = 3600;
+const MAX_OPS_PER_SCRIPT = 201;
+function countNonPushOnlyOPs(script) {
+    const decompiled = decompileScript(script);
+    if (!decompiled)
+        throw new Error(`Error: cound not decompile ${script}`);
+    return decompiled.filter(op => typeof op === 'number' && op > btc.OP.OP_16)
+        .length;
+}
+function vectorSize(someVector) {
+    const length = someVector.length;
+    return (varintEncodingLength(length) +
+        someVector.reduce((sum, witness) => {
+            return sum + varSliceSize(witness);
+        }, 0));
+}
+function varSliceSize(someScript) {
+    const length = someScript.length;
+    return varintEncodingLength(length) + length;
+}
+/**
+ * Safe p2wsh wrapper: tries btc.p2wsh first, falls back to manual computation
+ * when btc-signer rejects the inner script (e.g. complex miniscript).
+ */
+function safeP2wsh(innerScript, net) {
+    try {
+        return btc.p2wsh({ type: 'unknown', script: innerScript }, net);
+    }
+    catch {
+        // Manual computation: OP_0 <SHA256(script)>
+        const scriptHash = sha256(innerScript);
+        const outputScript = btc.OutScript.encode({
+            type: 'wsh',
+            hash: scriptHash
+        });
+        const address = net
+            ? btc.Address(net).encode({ type: 'wsh', hash: scriptHash })
+            : undefined;
+        return {
+            type: 'wsh',
+            script: outputScript,
+            witnessScript: innerScript,
+            ...(address ? { address } : {})
+        };
+    }
+}
+/**
+ * Safe p2sh wrapper: tries btc.p2sh first, falls back to manual computation
+ * when btc-signer rejects the inner payment.
+ */
+function safeP2sh(innerScript, net) {
+    try {
+        return btc.p2sh({ type: 'unknown', script: innerScript }, net);
+    }
+    catch {
+        // Manual computation: OP_HASH160 <HASH160(script)> OP_EQUAL
+        const scriptHash = hash160(innerScript);
+        const outputScript = btc.OutScript.encode({ type: 'sh', hash: scriptHash });
+        const address = net
+            ? btc.Address(net).encode({ type: 'sh', hash: scriptHash })
+            : undefined;
+        return {
+            type: 'sh',
+            script: outputScript,
+            redeemScript: innerScript,
+            ...(address ? { address } : {})
+        };
+    }
+}
+/**
+ * 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 varintEncodingLength(length) + length;
+}
+/*
+ * Returns a bare descriptor without checksum and particularized for a certain
+ * index (if desc was a range descriptor)
+ * @hidden
+ */
+function evaluate({ descriptor, checksumRequired, index }) {
+    if (!descriptor)
+        throw new Error('You must provide a descriptor.');
+    const mChecksum = descriptor.match(String.raw `(${RE.reChecksum})$`);
+    if (mChecksum === null && checksumRequired === true)
+        throw new Error(`Error: descriptor ${descriptor} has not checksum`);
+    //evaluatedDescriptor: a bare desc without checksum and particularized for a certain
+    //index (if desc was a range descriptor)
+    let evaluatedDescriptor = descriptor;
+    if (mChecksum !== null) {
+        const checksum = mChecksum[0].substring(1); //remove the leading #
+        evaluatedDescriptor = descriptor.substring(0, descriptor.length - mChecksum[0].length);
+        if (checksum !== DescriptorChecksum(evaluatedDescriptor)) {
+            throw new Error(`Error: invalid descriptor checksum for ${descriptor}`);
+        }
+    }
+    if (index !== undefined) {
+        const mWildcard = evaluatedDescriptor.match(/\*/g);
+        if (mWildcard && mWildcard.length > 0) {
+            evaluatedDescriptor = evaluatedDescriptor.replaceAll('*', index.toString());
+        }
+        else
+            throw new Error(`Error: index passed for non-ranged descriptor: ${descriptor}`);
+    }
+    return evaluatedDescriptor;
+}
+// Helper: parse sortedmulti(M, k1, k2,...)
+function parseSortedMulti(inner) {
+    const parts = inner.split(',').map(p => p.trim());
+    if (parts.length < 2)
+        throw new Error(`sortedmulti(): must contain M and at least one key: ${inner}`);
+    const m = Number(parts[0]);
+    if (!Number.isInteger(m) || m < 1 || m > 20)
+        throw new Error(`sortedmulti(): invalid M=${parts[0]}`);
+    const keyExpressions = parts.slice(1);
+    if (keyExpressions.length < m)
+        throw new Error(`sortedmulti(): M cannot exceed number of keys: ${inner}`);
+    if (keyExpressions.length > 20)
+        throw new Error(`sortedmulti(): descriptors support up to 20 keys (per BIP 380/383).`);
+    return { m, keyExpressions };
+}
+/**
+ * Constructs the necessary functions and classes for working with descriptors.
+ *
+ * Notably, it returns the {@link _Internal_.Output | `Output`} class, which
+ * provides methods to create, sign, and finalize PSBTs based on descriptor
+ * expressions.
+ *
+ * The Factory also returns utility methods like `expand` (detailed below)
+ * and `parseKeyExpression` (see {@link ParseKeyExpression}).
+ *
+ * Additionally, for convenience, the function returns `BIP32` and `ECPair`.
+ * These are compatible interfaces for managing BIP32 keys and
+ * public/private key pairs respectively.
+ *
+ * @param {Object} params - An object with `ECPair` and `BIP32` factories.
+ */
+export function DescriptorsFactory({ ECPair, BIP32 }) {
+    var _Output_instances, _Output_payment, _Output_preimages, _Output_signersPubKeys, _Output_miniscript, _Output_witnessScript, _Output_redeemScript, _Output_isSegwit, _Output_isTaproot, _Output_expandedExpression, _Output_expandedMiniscript, _Output_expansionMap, _Output_network, _Output_getTimeConstraints, _Output_assertPsbtInput;
+    /**
+     * Takes a string key expression (xpub, xprv, pubkey or wif) and parses it
+     */
+    const parseKeyExpression = ({ keyExpression, isSegwit, isTaproot, network = networks.bitcoin }) => {
+        return globalParseKeyExpression({
+            keyExpression,
+            network,
+            ...(typeof isSegwit === 'boolean' ? { isSegwit } : {}),
+            ...(typeof isTaproot === 'boolean' ? { isTaproot } : {}),
+            ECPair,
+            BIP32
+        });
+    };
+    /**
+     * Parses and analyzies a descriptor expression and destructures it into
+     * {@link Expansion |its elemental parts}.
+     *
+     * @throws {Error} Throws an error if the descriptor cannot be parsed or does
+     * not conform to the expected format.
+     */
+    function expand({ descriptor, index, checksumRequired = false, network = networks.bitcoin, allowMiniscriptInP2SH = false }) {
+        let expandedExpression;
+        let miniscript;
+        let expansionMap;
+        let isSegwit;
+        let isTaproot;
+        let expandedMiniscript;
+        let payment;
+        let witnessScript;
+        let redeemScript;
+        const isRanged = descriptor.indexOf('*') !== -1;
+        const net = toBtcSignerNetwork(network);
+        if (index !== undefined)
+            if (!Number.isInteger(index) || index < 0)
+                throw new Error(`Error: invalid index ${index}`);
+        const canonicalExpression = evaluate({
+            descriptor,
+            ...(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];
+            if (!matchedAddress)
+                throw new Error(`Error: could not get an address in ${descriptor}`);
+            let output;
+            try {
+                const decoded = btc
+                    .Address(toBtcSignerNetwork(network))
+                    .decode(matchedAddress);
+                output = btc.OutScript.encode(decoded);
+            }
+            catch (e) {
+                void e;
+                throw new Error(`Error: invalid address ${matchedAddress}`);
+            }
+            // Detect output type using OutScript.decode
+            let scriptType;
+            try {
+                const decoded = btc.OutScript.decode(output);
+                scriptType = decoded.type;
+            }
+            catch {
+                throw new Error(`Error: invalid address ${matchedAddress}`);
+            }
+            // For addr() we already have the output script.
+            // We build a minimal P2Ret with the script and address.
+            payment = {
+                type: scriptType,
+                address: matchedAddress,
+                script: output
+            };
+            if (scriptType === 'pkh') {
+                isSegwit = false;
+                isTaproot = false;
+            }
+            else if (scriptType === 'sh') {
+                isSegwit = true; // Assume SH is SH_WPKH
+                isTaproot = false;
+            }
+            else if (scriptType === 'wpkh') {
+                isSegwit = true;
+                isTaproot = false;
+            }
+            else if (scriptType === 'wsh') {
+                isSegwit = true;
+                isTaproot = false;
+            }
+            else if (scriptType === 'tr') {
+                isSegwit = true;
+                isTaproot = true;
+            }
+            else {
+                throw new Error(`Error: invalid address ${matchedAddress}`);
+            }
+        }
+        //pk(KEY)
+        else if (canonicalExpression.match(RE.rePkAnchored)) {
+            isSegwit = false;
+            isTaproot = false;
+            const keyExpression = canonicalExpression.match(RE.reNonSegwitKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `pk(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${descriptor}`);
+            expandedExpression = 'pk(@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 ${descriptor}`);
+                payment = btc.p2pk(pubkey, net);
+            }
+        }
+        //pkh(KEY) - legacy
+        else if (canonicalExpression.match(RE.rePkhAnchored)) {
+            isSegwit = false;
+            isTaproot = false;
+            const keyExpression = canonicalExpression.match(RE.reNonSegwitKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `pkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${descriptor}`);
+            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 ${descriptor}`);
+                payment = btc.p2pkh(pubkey, net);
+            }
+        }
+        //sh(wpkh(KEY)) - nested segwit
+        else if (canonicalExpression.match(RE.reShWpkhAnchored)) {
+            isSegwit = true;
+            isTaproot = false;
+            const keyExpression = canonicalExpression.match(RE.reSegwitKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `sh(wpkh(${keyExpression}))`)
+                throw new Error(`Error: invalid expression ${descriptor}`);
+            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 ${descriptor}`);
+                const wpkhPayment = btc.p2wpkh(pubkey, net);
+                payment = btc.p2sh(wpkhPayment, net);
+                redeemScript = payment.redeemScript ?? wpkhPayment.script;
+                if (!redeemScript)
+                    throw new Error(`Error: could not calculate redeemScript for ${descriptor}`);
+            }
+        }
+        //wpkh(KEY) - native segwit
+        else if (canonicalExpression.match(RE.reWpkhAnchored)) {
+            isSegwit = true;
+            isTaproot = false;
+            const keyExpression = canonicalExpression.match(RE.reSegwitKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `wpkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${descriptor}`);
+            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 ${descriptor}`);
+                payment = btc.p2wpkh(pubkey, net);
+            }
+        }
+        // sortedmulti script expressions
+        // sh(sortedmulti())
+        else if (canonicalExpression.match(RE.reShSortedMultiAnchored)) {
+            isSegwit = false;
+            isTaproot = false;
+            const inner = canonicalExpression.match(RE.reShSortedMultiAnchored)?.[1];
+            if (!inner)
+                throw new Error(`Error extracting sortedmulti() in ${descriptor}`);
+            const { m, keyExpressions } = parseSortedMulti(inner);
+            const pKEs = keyExpressions.map(k => parseKeyExpression({ keyExpression: k, network, isSegwit: false }));
+            const map = {};
+            pKEs.forEach((pke, i) => (map['@' + i] = pke));
+            expansionMap = map;
+            expandedExpression =
+                'sh(sortedmulti(' +
+                    [m, ...Object.keys(expansionMap).map(k => k)].join(',') +
+                    '))';
+            if (!isCanonicalRanged) {
+                const pubkeys = pKEs.map(p => {
+                    if (!p.pubkey)
+                        throw new Error(`Error: key has no pubkey`);
+                    return p.pubkey;
+                });
+                pubkeys.sort((a, b) => compareBytes(a, b));
+                const redeem = btc.p2ms(m, pubkeys, undefined);
+                redeemScript = redeem.script;
+                payment = btc.p2sh(redeem, net);
+            }
+        }
+        // wsh(sortedmulti())
+        else if (canonicalExpression.match(RE.reWshSortedMultiAnchored)) {
+            isSegwit = true;
+            isTaproot = false;
+            const inner = canonicalExpression.match(RE.reWshSortedMultiAnchored)?.[1];
+            if (!inner)
+                throw new Error(`Error extracting sortedmulti() in ${descriptor}`);
+            const { m, keyExpressions } = parseSortedMulti(inner);
+            const pKEs = keyExpressions.map(k => parseKeyExpression({ keyExpression: k, network, isSegwit: true }));
+            const map = {};
+            pKEs.forEach((pke, i) => (map['@' + i] = pke));
+            expansionMap = map;
+            expandedExpression =
+                'wsh(sortedmulti(' +
+                    [m, ...Object.keys(expansionMap).map(k => k)].join(',') +
+                    '))';
+            if (!isCanonicalRanged) {
+                const pubkeys = pKEs.map(p => {
+                    if (!p.pubkey)
+                        throw new Error(`Error: key has no pubkey`);
+                    return p.pubkey;
+                });
+                pubkeys.sort((a, b) => compareBytes(a, b));
+                const redeem = btc.p2ms(m, pubkeys, undefined);
+                witnessScript = redeem.script;
+                payment = btc.p2wsh(redeem, net);
+            }
+        }
+        // sh(wsh(sortedmulti()))
+        else if (canonicalExpression.match(RE.reShWshSortedMultiAnchored)) {
+            isSegwit = true;
+            isTaproot = false;
+            const inner = canonicalExpression.match(RE.reShWshSortedMultiAnchored)?.[1];
+            if (!inner)
+                throw new Error(`Error extracting sortedmulti() in ${descriptor}`);
+            const { m, keyExpressions } = parseSortedMulti(inner);
+            const pKEs = keyExpressions.map(k => parseKeyExpression({ keyExpression: k, network, isSegwit: true }));
+            const map = {};
+            pKEs.forEach((pke, i) => (map['@' + i] = pke));
+            expansionMap = map;
+            expandedExpression =
+                'sh(wsh(sortedmulti(' +
+                    [m, ...Object.keys(expansionMap).map(k => k)].join(',') +
+                    ')))';
+            if (!isCanonicalRanged) {
+                const pubkeys = pKEs.map(p => {
+                    if (!p.pubkey)
+                        throw new Error(`Error: key has no pubkey`);
+                    return p.pubkey;
+                });
+                pubkeys.sort((a, b) => compareBytes(a, b));
+                const redeem = btc.p2ms(m, pubkeys, undefined);
+                const wsh = btc.p2wsh(redeem, net);
+                witnessScript = redeem.script;
+                redeemScript = wsh.script;
+                payment = btc.p2sh(wsh, net);
+            }
+        }
+        //sh(wsh(miniscript))
+        else if (canonicalExpression.match(RE.reShWshMiniscriptAnchored)) {
+            isSegwit = true;
+            isTaproot = false;
+            miniscript = canonicalExpression.match(RE.reShWshMiniscriptAnchored)?.[1];
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${descriptor}`);
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `sh(wsh(${expandedMiniscript}))`;
+            if (!isCanonicalRanged) {
+                const script = 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}`);
+                }
+                const wshPayment = safeP2wsh(script, net);
+                const shPayment = safeP2sh(wshPayment.script, net);
+                payment = shPayment;
+                redeemScript = wshPayment.script;
+                if (!redeemScript)
+                    throw new Error(`Error: could not calculate redeemScript for ${descriptor}`);
+            }
+        }
+        //sh(miniscript)
+        else if (canonicalExpression.match(RE.reShMiniscriptAnchored)) {
+            isSegwit = false;
+            isTaproot = false;
+            miniscript = canonicalExpression.match(RE.reShMiniscriptAnchored)?.[1];
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${descriptor}`);
+            if (allowMiniscriptInP2SH === false &&
+                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 = 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 = safeP2sh(script, net);
+            }
+        }
+        //wsh(miniscript)
+        else if (canonicalExpression.match(RE.reWshMiniscriptAnchored)) {
+            isSegwit = true;
+            isTaproot = false;
+            miniscript = canonicalExpression.match(RE.reWshMiniscriptAnchored)?.[1];
+            if (!miniscript)
+                throw new Error(`Error: could not get miniscript in ${descriptor}`);
+            ({ expandedMiniscript, expansionMap } = expandMiniscript({
+                miniscript,
+                isSegwit,
+                network
+            }));
+            expandedExpression = `wsh(${expandedMiniscript})`;
+            if (!isCanonicalRanged) {
+                const script = 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 = safeP2wsh(script, net);
+            }
+        }
+        //tr(KEY) - taproot
+        else if (canonicalExpression.match(RE.reTrSingleKeyAnchored)) {
+            isSegwit = true;
+            isTaproot = true;
+            const keyExpression = canonicalExpression.match(RE.reTaprootKeyExp)?.[0];
+            if (!keyExpression)
+                throw new Error(`Error: keyExpression could not me extracted`);
+            if (canonicalExpression !== `tr(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${descriptor}`);
+            expandedExpression = 'tr(@0)';
+            const pKE = parseKeyExpression({
+                keyExpression,
+                network,
+                isSegwit,
+                isTaproot
+            });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
+                if (!pubkey)
+                    throw new Error(`Error: could not extract a pubkey from ${descriptor}`);
+                payment = btc.p2tr(pubkey, undefined, net);
+            }
+        }
+        else {
+            throw new Error(`Error: Could not parse descriptor ${descriptor}`);
+        }
+        return {
+            ...(payment !== undefined ? { payment } : {}),
+            ...(expandedExpression !== undefined ? { expandedExpression } : {}),
+            ...(miniscript !== undefined ? { miniscript } : {}),
+            ...(expansionMap !== undefined ? { expansionMap } : {}),
+            ...(isSegwit !== undefined ? { isSegwit } : {}),
+            ...(isTaproot !== undefined ? { isTaproot } : {}),
+            ...(expandedMiniscript !== undefined ? { expandedMiniscript } : {}),
+            ...(redeemScript !== undefined ? { redeemScript } : {}),
+            ...(witnessScript !== undefined ? { witnessScript } : {}),
+            isRanged,
+            canonicalExpression
+        };
+    }
+    /**
+     * Expand a miniscript to a generalized form using variables instead of key
+     * expressions.
+     */
+    function expandMiniscript({ miniscript, isSegwit, network = networks.bitcoin }) {
+        return globalExpandMiniscript({
+            miniscript,
+            isSegwit,
+            isTaproot: false,
+            network,
+            BIP32,
+            ECPair
+        });
+    }
+    /**
+     * The `Output` class is the central component for managing descriptors.
+     */
+    class Output {
+        constructor({ descriptor, index, checksumRequired = false, allowMiniscriptInP2SH = false, network = networks.bitcoin, preimages = [], signersPubKeys }) {
+            _Output_instances.add(this);
+            _Output_payment.set(this, void 0);
+            _Output_preimages.set(this, []);
+            _Output_signersPubKeys.set(this, void 0);
+            _Output_miniscript.set(this, void 0);
+            _Output_witnessScript.set(this, void 0);
+            _Output_redeemScript.set(this, void 0);
+            _Output_isSegwit.set(this, void 0);
+            _Output_isTaproot.set(this, void 0);
+            _Output_expandedExpression.set(this, void 0);
+            _Output_expandedMiniscript.set(this, void 0);
+            _Output_expansionMap.set(this, void 0);
+            _Output_network.set(this, void 0);
+            __classPrivateFieldSet(this, _Output_network, network, "f");
+            __classPrivateFieldSet(this, _Output_preimages, preimages, "f");
+            if (typeof descriptor !== 'string')
+                throw new Error(`Error: invalid descriptor type`);
+            const expandedResult = expand({
+                descriptor,
+                ...(index !== undefined ? { index } : {}),
+                checksumRequired,
+                network,
+                allowMiniscriptInP2SH
+            });
+            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 ${descriptor}`);
+            __classPrivateFieldSet(this, _Output_payment, expandedResult.payment, "f");
+            if (expandedResult.expandedExpression !== undefined)
+                __classPrivateFieldSet(this, _Output_expandedExpression, expandedResult.expandedExpression, "f");
+            if (expandedResult.miniscript !== undefined)
+                __classPrivateFieldSet(this, _Output_miniscript, expandedResult.miniscript, "f");
+            if (expandedResult.expansionMap !== undefined)
+                __classPrivateFieldSet(this, _Output_expansionMap, expandedResult.expansionMap, "f");
+            if (expandedResult.isSegwit !== undefined)
+                __classPrivateFieldSet(this, _Output_isSegwit, expandedResult.isSegwit, "f");
+            if (expandedResult.isTaproot !== undefined)
+                __classPrivateFieldSet(this, _Output_isTaproot, expandedResult.isTaproot, "f");
+            if (expandedResult.expandedMiniscript !== undefined)
+                __classPrivateFieldSet(this, _Output_expandedMiniscript, expandedResult.expandedMiniscript, "f");
+            if (expandedResult.redeemScript !== undefined)
+                __classPrivateFieldSet(this, _Output_redeemScript, expandedResult.redeemScript, "f");
+            if (expandedResult.witnessScript !== undefined)
+                __classPrivateFieldSet(this, _Output_witnessScript, expandedResult.witnessScript, "f");
+            if (signersPubKeys) {
+                __classPrivateFieldSet(this, _Output_signersPubKeys, signersPubKeys, "f");
+            }
+            else {
+                if (__classPrivateFieldGet(this, _Output_expansionMap, "f")) {
+                    __classPrivateFieldSet(this, _Output_signersPubKeys, Object.values(__classPrivateFieldGet(this, _Output_expansionMap, "f")).map(keyInfo => {
+                        const pubkey = keyInfo.pubkey;
+                        if (!pubkey)
+                            throw new Error(`Error: could not extract a pubkey from ${descriptor}`);
+                        return pubkey;
+                    }), "f");
+                }
+                else {
+                    if (!expandedResult.canonicalExpression.match(RE.reAddrAnchored)) {
+                        throw new Error(`Error: expansionMap not available for expression ${descriptor} that is not an address`);
+                    }
+                    __classPrivateFieldSet(this, _Output_signersPubKeys, [this.getScriptPubKey()], "f");
+                }
+            }
+            this.getSequence = memoize(this.getSequence);
+            this.getLockTime = memoize(this.getLockTime);
+            const getSignaturesKey = (signatures) => signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES'
+                ? signatures
+                : signatures
+                    .map(s => `${hex.encode(s.pubkey)}-${hex.encode(s.signature)}`)
+                    .join('|');
+            this.getScriptSatisfaction = memoize(this.getScriptSatisfaction, getSignaturesKey);
+            this.guessOutput = memoize(this.guessOutput);
+            this.inputWeight = memoize(this.inputWeight, (isSegwitTx, signatures) => {
+                const segwitKey = isSegwitTx ? 'segwit' : 'non-segwit';
+                const signaturesKey = getSignaturesKey(signatures);
+                return `${segwitKey}-${signaturesKey}`;
+            });
+            this.outputWeight = memoize(this.outputWeight);
+        }
+        getPayment() {
+            return __classPrivateFieldGet(this, _Output_payment, "f");
+        }
+        getAddress() {
+            if (!__classPrivateFieldGet(this, _Output_payment, "f").address)
+                throw new Error(`Error: could extract an address from the payment`);
+            return __classPrivateFieldGet(this, _Output_payment, "f").address;
+        }
+        getScriptPubKey() {
+            if (!__classPrivateFieldGet(this, _Output_payment, "f").script)
+                throw new Error(`Error: could not extract script from the payment`);
+            return __classPrivateFieldGet(this, _Output_payment, "f").script;
+        }
+        getScriptSatisfaction(signatures) {
+            if (signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES')
+                signatures = __classPrivateFieldGet(this, _Output_signersPubKeys, "f").map(pubkey => ({
+                    pubkey,
+                    signature: new Uint8Array(72)
+                }));
+            const miniscript = __classPrivateFieldGet(this, _Output_miniscript, "f");
+            const expandedMiniscript = __classPrivateFieldGet(this, _Output_expandedMiniscript, "f");
+            const expansionMap = __classPrivateFieldGet(this, _Output_expansionMap, "f");
+            if (miniscript === undefined ||
+                expandedMiniscript === undefined ||
+                expansionMap === undefined)
+                throw new Error(`Error: cannot get satisfaction from not expanded miniscript ${miniscript}`);
+            const scriptSatisfaction = satisfyMiniscript({
+                expandedMiniscript,
+                expansionMap,
+                signatures,
+                preimages: __classPrivateFieldGet(this, _Output_preimages, "f"),
+                timeConstraints: {
+                    nLockTime: this.getLockTime(),
+                    nSequence: this.getSequence()
+                }
+            }).scriptSatisfaction;
+            if (!scriptSatisfaction)
+                throw new Error(`Error: could not produce a valid satisfaction`);
+            return scriptSatisfaction;
+        }
+        getSequence() {
+            return __classPrivateFieldGet(this, _Output_instances, "m", _Output_getTimeConstraints).call(this)?.nSequence;
+        }
+        getLockTime() {
+            return __classPrivateFieldGet(this, _Output_instances, "m", _Output_getTimeConstraints).call(this)?.nLockTime;
+        }
+        getWitnessScript() {
+            return __classPrivateFieldGet(this, _Output_witnessScript, "f");
+        }
+        getRedeemScript() {
+            return __classPrivateFieldGet(this, _Output_redeemScript, "f");
+        }
+        getNetwork() {
+            return __classPrivateFieldGet(this, _Output_network, "f");
+        }
+        isSegwit() {
+            return __classPrivateFieldGet(this, _Output_isSegwit, "f");
+        }
+        isTaproot() {
+            return __classPrivateFieldGet(this, _Output_isTaproot, "f");
+        }
+        guessOutput() {
+            const scriptPubKey = this.getScriptPubKey();
+            let scriptType;
+            try {
+                const decoded = btc.OutScript.decode(scriptPubKey);
+                scriptType = decoded.type;
+            }
+            catch {
+                scriptType = undefined;
+            }
+            const isPKH = scriptType === 'pkh';
+            const isWPKH = scriptType === 'wpkh';
+            const isSH = scriptType === 'sh';
+            const isWSH = scriptType === 'wsh';
+            const isTR = scriptType === 'tr';
+            if ([isPKH, isWPKH, isSH, isWSH, isTR].filter(Boolean).length > 1)
+                throw new Error('Cannot have multiple output types.');
+            return { isPKH, isWPKH, isSH, isWSH, isTR };
+        }
+        inputWeight(isSegwitTx, signatures) {
+            if (this.isSegwit() && !isSegwitTx)
+                throw new Error(`a tx is segwit if at least one input is segwit`);
+            const expansion = this.expand().expandedExpression;
+            const { isPKH, isWPKH, isSH, isTR } = this.guessOutput();
+            const errorMsg = `Input type not implemented. Currently supported: pkh(KEY), wpkh(KEY), tr(KEY), \
+sh(wpkh(KEY)), sh(wsh(MINISCRIPT)), sh(MINISCRIPT), wsh(MINISCRIPT), \
+addr(PKH_ADDRESS), addr(WPKH_ADDRESS), addr(SH_WPKH_ADDRESS), addr(SINGLE_KEY_ADDRESS). \
+expansion=${expansion}, isPKH=${isPKH}, isWPKH=${isWPKH}, isSH=${isSH}, isTR=${isTR}.`;
+            if (!expansion && !isPKH && !isWPKH && !isSH && !isTR)
+                throw new Error(errorMsg);
+            const firstSignature = signatures && typeof signatures[0] === 'object'
+                ? signatures[0]
+                : 'DANGEROUSLY_USE_FAKE_SIGNATURES';
+            if (expansion ? expansion.startsWith('pkh(') : isPKH) {
+                return ((32 + 4 + 4 + 1 + signatureSize(firstSignature) + 34) * 4 +
+                    (isSegwitTx ? 1 : 0));
+            }
+            else if (expansion ? expansion.startsWith('wpkh(') : isWPKH) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return 41 * 4 + (1 + signatureSize(firstSignature) + 34);
+            }
+            else if (expansion ? expansion.startsWith('sh(wpkh(') : isSH) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return 64 * 4 + (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 scriptSatisfaction = this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES');
+                // sh(wsh) input: push of the p2wsh redeemScript (OP_0 <32-byte SHA256(witnessScript)>)
+                const redeemScript = this.getRedeemScript();
+                if (!redeemScript)
+                    throw new Error('sh(wsh) must have redeemScript');
+                const shInput = concatBytes(Uint8Array.from([redeemScript.length]), redeemScript);
+                // witness: satisfaction chunks decompiled from scriptSatisfaction, plus witnessScript
+                const witnessChunks = decompileScript(scriptSatisfaction);
+                if (!witnessChunks)
+                    throw new Error('Could not decompile script satisfaction');
+                const witness = witnessChunks.map(chunk => typeof chunk === 'number' ? new Uint8Array(0) : chunk);
+                witness.push(witnessScript);
+                return 4 * (40 + varSliceSize(shInput)) + vectorSize(witness);
+            }
+            else if (expansion?.startsWith('sh(')) {
+                const redeemScript = this.getRedeemScript();
+                if (!redeemScript)
+                    throw new Error('sh() must provide redeemScript');
+                const scriptSatisfaction = this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES');
+                // sh input: scriptSatisfaction + push of redeemScript
+                const shInput = concatBytes(scriptSatisfaction, Uint8Array.from([
+                    redeemScript.length > 75 ? 0x4c : redeemScript.length
+                ]), ...(redeemScript.length > 75
+                    ? [Uint8Array.from([redeemScript.length])]
+                    : []), redeemScript);
+                return 4 * (40 + varSliceSize(shInput)) + (isSegwitTx ? 1 : 0);
+            }
+            else if (expansion?.startsWith('wsh(')) {
+                const witnessScript = this.getWitnessScript();
+                if (!witnessScript)
+                    throw new Error('wsh must provide witnessScript');
+                const scriptSatisfaction = this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES');
+                // wsh: empty scriptSig, witness = satisfaction chunks + witnessScript
+                const witnessChunks = decompileScript(scriptSatisfaction);
+                if (!witnessChunks)
+                    throw new Error('Could not decompile script satisfaction');
+                const witness = witnessChunks.map(chunk => typeof chunk === 'number' ? new Uint8Array(0) : chunk);
+                witness.push(witnessScript);
+                const emptyInput = new Uint8Array(0);
+                return 4 * (40 + varSliceSize(emptyInput)) + vectorSize(witness);
+            }
+            else if (isTR && (!expansion || expansion === 'tr(@0)')) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return 41 * 4 + (1 + 65);
+            }
+            else {
+                throw new Error(errorMsg);
+            }
+        }
+        outputWeight() {
+            const { isPKH, isWPKH, isSH, isWSH, isTR } = this.guessOutput();
+            const errorMsg = `Output type not implemented. Currently supported: pkh=${isPKH}, wpkh=${isWPKH}, tr=${isTR}, sh=${isSH} and wsh=${isWSH}.`;
+            if (isPKH) {
+                return 34 * 4;
+            }
+            else if (isWPKH) {
+                return 31 * 4;
+            }
+            else if (isSH) {
+                return 32 * 4;
+            }
+            else if (isWSH) {
+                return 43 * 4;
+            }
+            else if (isTR) {
+                return 43 * 4;
+            }
+            else {
+                throw new Error(errorMsg);
+            }
+        }
+        updatePsbtAsInput({ psbt, txHex, txId, value, vout, rbf = true }) {
+            if (txHex === undefined) {
+                console.warn(`Warning: missing txHex may allow fee attacks`);
+            }
+            const isSegwit = this.isSegwit();
+            if (isSegwit === undefined) {
+                throw new Error(`Error: could not determine whether this is a segwit descriptor`);
+            }
+            const isTaproot = this.isTaproot();
+            if (isTaproot === undefined) {
+                throw new Error(`Error: could not determine whether this is a taproot descriptor`);
+            }
+            const index = updatePsbt({
+                psbt,
+                vout,
+                ...(txHex !== undefined ? { txHex } : {}),
+                ...(txId !== undefined ? { txId } : {}),
+                ...(value !== undefined ? { value } : {}),
+                ...(isTaproot
+                    ? {
+                        tapInternalKey: this.getPayment()['tapInternalKey']
+                    }
+                    : {}),
+                sequence: this.getSequence(),
+                locktime: this.getLockTime(),
+                keysInfo: __classPrivateFieldGet(this, _Output_expansionMap, "f") ? Object.values(__classPrivateFieldGet(this, _Output_expansionMap, "f")) : [],
+                scriptPubKey: this.getScriptPubKey(),
+                isSegwit,
+                witnessScript: this.getWitnessScript(),
+                redeemScript: this.getRedeemScript(),
+                rbf
+            });
+            const finalizer = ({ psbt, validate = true }) => this.finalizePsbtInput({ index, psbt, validate });
+            return finalizer;
+        }
+        updatePsbtAsOutput({ psbt, value }) {
+            psbt.addOutput({
+                script: this.getScriptPubKey(),
+                amount: typeof value === 'bigint' ? value : BigInt(value)
+            });
+        }
+        finalizePsbtInput({ index, psbt, validate = true }) {
+            // scure's Transaction handles signature validation internally during finalization.
+            // The validate parameter is kept for API compatibility but signature validation
+            // is delegated to scure's finalizeIdx.
+            void validate;
+            __classPrivateFieldGet(this, _Output_instances, "m", _Output_assertPsbtInput).call(this, { index, psbt });
+            if (!__classPrivateFieldGet(this, _Output_miniscript, "f")) {
+                psbt.finalizeIdx(index);
+            }
+            else {
+                // For miniscript, we need custom finalization:
+                // 1. Extract partialSig from the input
+                const input = psbt.getInput(index);
+                const partialSigs = input.partialSig;
+                if (!partialSigs || partialSigs.length === 0)
+                    throw new Error(`Error: cannot finalize without signatures`);
+                // Convert scure's [Uint8Array, Uint8Array][] to PartialSig[]
+                const signatures = partialSigs.map(([pubkey, signature]) => ({
+                    pubkey,
+                    signature
+                }));
+                // 2. Compute script satisfaction
+                const scriptSatisfaction = this.getScriptSatisfaction(signatures);
+                // 3. Compute final scripts using the locking script
+                const isSegwit = this.isSegwit() ?? false;
+                const redeemScript = this.getRedeemScript();
+                const isP2SH = redeemScript !== undefined;
+                const lockingScript = this.getWitnessScript() ?? redeemScript;
+                if (!lockingScript)
+                    throw new Error(`Error: cannot determine locking script for miniscript finalization`);
+                const { finalScriptSig, finalScriptWitness } = computeFinalScripts(scriptSatisfaction, lockingScript, isSegwit, isP2SH, redeemScript);
+                // 4. Set final scripts on the input
+                const updateFields = {};
+                if (finalScriptSig)
+                    updateFields['finalScriptSig'] = finalScriptSig;
+                if (finalScriptWitness)
+                    updateFields['finalScriptWitness'] = finalScriptWitness;
+                psbt.updateInput(index, updateFields, true);
+            }
+        }
+        expand() {
+            return {
+                ...(__classPrivateFieldGet(this, _Output_expandedExpression, "f") !== undefined
+                    ? { expandedExpression: __classPrivateFieldGet(this, _Output_expandedExpression, "f") }
+                    : {}),
+                ...(__classPrivateFieldGet(this, _Output_miniscript, "f") !== undefined
+                    ? { miniscript: __classPrivateFieldGet(this, _Output_miniscript, "f") }
+                    : {}),
+                ...(__classPrivateFieldGet(this, _Output_expandedMiniscript, "f") !== undefined
+                    ? { expandedMiniscript: __classPrivateFieldGet(this, _Output_expandedMiniscript, "f") }
+                    : {}),
+                ...(__classPrivateFieldGet(this, _Output_expansionMap, "f") !== undefined
+                    ? { expansionMap: __classPrivateFieldGet(this, _Output_expansionMap, "f") }
+                    : {})
+            };
+        }
+    }
+    _Output_payment = new WeakMap(), _Output_preimages = new WeakMap(), _Output_signersPubKeys = new WeakMap(), _Output_miniscript = new WeakMap(), _Output_witnessScript = new WeakMap(), _Output_redeemScript = new WeakMap(), _Output_isSegwit = new WeakMap(), _Output_isTaproot = new WeakMap(), _Output_expandedExpression = new WeakMap(), _Output_expandedMiniscript = new WeakMap(), _Output_expansionMap = new WeakMap(), _Output_network = new WeakMap(), _Output_instances = new WeakSet(), _Output_getTimeConstraints = function _Output_getTimeConstraints() {
+        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");
+        if (miniscript) {
+            if (expandedMiniscript === undefined || expansionMap === undefined)
+                throw new Error(`Error: cannot get time constraints from not expanded miniscript ${miniscript}`);
+            const fakeSignatures = signersPubKeys.map(pubkey => ({
+                pubkey,
+                signature: new Uint8Array(72)
+            }));
+            const { nLockTime, nSequence } = satisfyMiniscript({
+                expandedMiniscript,
+                expansionMap,
+                signatures: fakeSignatures,
+                preimages
+            });
+            return { nLockTime, nSequence };
+        }
+        else
+            return undefined;
+    }, _Output_assertPsbtInput = function _Output_assertPsbtInput({ psbt, index }) {
+        const input = psbt.getInput(index);
+        if (!input)
+            throw new Error(`Error: invalid input`);
+        const inputSequence = input.sequence;
+        const vout = input.index;
+        let scriptPubKey;
+        if (input.witnessUtxo) {
+            scriptPubKey = input.witnessUtxo.script;
+        }
+        else {
+            if (!input.nonWitnessUtxo)
+                throw new Error(`Error: input should have either witnessUtxo or nonWitnessUtxo`);
+            // nonWitnessUtxo is stored as a parsed tx struct by scure
+            const parsedTx = input.nonWitnessUtxo;
+            const out = parsedTx.outputs[vout];
+            if (!out || !out.script)
+                throw new Error(`Error: utxo should exist`);
+            scriptPubKey = out.script;
+        }
+        const locktime = this.getLockTime() || 0;
+        const sequence = this.getSequence();
+        const sequenceNoRBF = sequence !== undefined
+            ? sequence
+            : locktime === 0
+                ? 0xffffffff
+                : 0xfffffffe;
+        const sequenceRBF = sequence !== undefined ? sequence : 0xfffffffd;
+        const eqBufs = (buf1, buf2) => {
+            if (buf1 && buf2)
+                return equalBytes(buf1, buf2);
+            return buf1 === undefined && buf2 === undefined;
+        };
+        if (!equalBytes(scriptPubKey, this.getScriptPubKey()) ||
+            (sequenceRBF !== inputSequence && sequenceNoRBF !== inputSequence) ||
+            locktime !== psbt.lockTime ||
+            !eqBufs(this.getWitnessScript(), input.witnessScript) ||
+            !eqBufs(this.getRedeemScript(), input.redeemScript)) {
+            throw new Error(`Error: cannot finalize psbt index ${index} since it does not correspond to this descriptor`);
+        }
+    };
+    return {
+        Output,
+        parseKeyExpression,
+        expand,
+        ECPair,
+        BIP32
+    };
+}