@bitcoinerlab/descriptors-core 3.1.0

package/dist/psbt.d.ts

@@ -0,0 +1,40 @@
+import type { TapBip32Derivation, TapLeafScript } from './bip174';
+import type { KeyInfo } from './types';
+import type { FinalScriptsFunc, BitcoinLib, PsbtLike, ScureTransactionLike } from './bitcoinLib';
+import type { Network } from './networks';
+export declare function finalScriptsFuncFactory(scriptSatisfaction: Uint8Array, network: Network, payments: BitcoinLib['payments']): FinalScriptsFunc;
+/**
+ * Important: Read comments on Output.updatePsbtAsInput regarding not passing txHex
+ */
+export declare function addPsbtInput({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, tapLeafScript, tapBip32Derivation, witnessScript, redeemScript, rbf, Transaction }: {
+    psbt: PsbtLike;
+    vout: number;
+    txHex?: string;
+    txId?: string;
+    value?: bigint;
+    sequence: number | undefined;
+    locktime: number | undefined;
+    keysInfo: KeyInfo[];
+    scriptPubKey: Uint8Array;
+    isSegwit: boolean;
+    /** for taproot **/
+    tapInternalKey?: Uint8Array | undefined;
+    /** for taproot script-path **/
+    tapLeafScript?: TapLeafScript[] | undefined;
+    /** for taproot **/
+    tapBip32Derivation?: TapBip32Derivation[] | undefined;
+    witnessScript: Uint8Array | undefined;
+    redeemScript: Uint8Array | undefined;
+    rbf: boolean;
+    Transaction: BitcoinLib['Transaction'];
+}): number;
+/**
+ * Converts a concrete transaction object to this library's internal `PsbtLike`
+ * surface.
+ *
+ * @param psbt - Either a
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | bitcoinjs-lib `Psbt`}
+ * or a {@link https://github.com/paulmillr/scure-btc-signer | `@scure/btc-signer` `Transaction`}.
+ * @returns A `PsbtLike` implementation consumed by internal code.
+ */
+export declare function toPsbt(psbt: PsbtLike | ScureTransactionLike): PsbtLike;

package/dist/psbt.js

@@ -0,0 +1,228 @@
+"use strict";
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalScriptsFuncFactory = finalScriptsFuncFactory;
+exports.addPsbtInput = addPsbtInput;
+exports.toPsbt = toPsbt;
+const bitcoinLib_1 = require("./bitcoinLib");
+const uint8array_tools_1 = require("uint8array-tools");
+const bitcoinjs_lib_internals_1 = require("./bitcoinjs-lib-internals");
+function reverseBytes(buffer) {
+    if (buffer.length < 1)
+        return buffer;
+    const copy = Uint8Array.from(buffer);
+    let j = copy.length - 1;
+    let tmp = 0;
+    for (let i = 0; i < copy.length / 2; i++) {
+        tmp = copy[i];
+        copy[i] = copy[j];
+        copy[j] = tmp;
+        j--;
+    }
+    return copy;
+}
+function finalScriptsFuncFactory(scriptSatisfaction, network, payments) {
+    /**
+     * This function must do two things:
+     * 1. Check if the `input` can be finalized. If it can not be finalized, throw.
+     *   ie. `Can not finalize input #${inputIndex}`
+     * 2. Create finalScriptSig and finalScriptWitness.
+     */
+    const finalScriptsFunc = (_index, _input, lockingScript /*witnessScript or redeemScript*/, isSegwit, isP2SH, _isP2WSH) => {
+        let finalScriptWitness;
+        let finalScriptSig;
+        //p2wsh
+        if (isSegwit && !isP2SH) {
+            const payment = payments.p2wsh({
+                redeem: { input: scriptSatisfaction, output: lockingScript },
+                network
+            });
+            if (!payment.witness)
+                throw new Error(`Error: p2wsh failed producing a witness`);
+            finalScriptWitness = (0, bitcoinjs_lib_internals_1.witnessStackToScriptWitness)(payment.witness);
+        }
+        //p2sh-p2wsh
+        else if (isSegwit && isP2SH) {
+            const payment = payments.p2sh({
+                redeem: payments.p2wsh({
+                    redeem: { input: scriptSatisfaction, output: lockingScript },
+                    network
+                }),
+                network
+            });
+            if (!payment.witness)
+                throw new Error(`Error: p2sh-p2wsh failed producing a witness`);
+            finalScriptWitness = (0, bitcoinjs_lib_internals_1.witnessStackToScriptWitness)(payment.witness);
+            finalScriptSig = payment.input;
+        }
+        //p2sh
+        else {
+            finalScriptSig = payments.p2sh({
+                redeem: { input: scriptSatisfaction, output: lockingScript },
+                network
+            }).input;
+        }
+        return {
+            finalScriptWitness,
+            finalScriptSig
+        };
+    };
+    return finalScriptsFunc;
+}
+/**
+ * Important: Read comments on Output.updatePsbtAsInput regarding not passing txHex
+ */
+function addPsbtInput({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, tapLeafScript, tapBip32Derivation, witnessScript, redeemScript, rbf, Transaction }) {
+    if (value !== undefined && typeof value !== 'bigint')
+        throw new Error(`Error: value must be a bigint`);
+    if (value !== undefined && value < 0n)
+        throw new Error(`Error: value must be >= 0n`);
+    let normalizedValue = value;
+    //Some data-sanity checks:
+    if (sequence !== undefined && rbf && sequence > 0xfffffffd)
+        throw new Error(`Error: incompatible sequence and rbf settings`);
+    if (!isSegwit && txHex === undefined)
+        throw new Error(`Error: txHex is mandatory for Non-Segwit inputs`);
+    if (isSegwit &&
+        txHex === undefined &&
+        (txId === undefined || value === undefined))
+        throw new Error(`Error: pass txHex or txId+value for Segwit inputs`);
+    if (txHex !== undefined) {
+        const tx = Transaction.fromHex(txHex);
+        const out = tx.outs[vout];
+        if (!out)
+            throw new Error(`Error: tx ${txHex} does not have vout ${vout}`);
+        const outputScript = out.script;
+        if (!outputScript)
+            throw new Error(`Error: could not extract outputScript for txHex ${txHex} and vout ${vout}`);
+        if ((0, uint8array_tools_1.compare)(outputScript, scriptPubKey) !== 0)
+            throw new Error(`Error: txHex ${txHex} for vout ${vout} does not correspond to scriptPubKey ${scriptPubKey}`);
+        if (txId !== undefined) {
+            if (tx.getId() !== txId)
+                throw new Error(`Error: txId for ${txHex} and vout ${vout} does not correspond to ${txId}`);
+        }
+        else {
+            txId = tx.getId();
+        }
+        if (normalizedValue !== undefined) {
+            if (out.value !== normalizedValue)
+                throw new Error(`Error: value for ${txHex} and vout ${vout} does not correspond to ${value}`);
+        }
+        else {
+            normalizedValue = out.value;
+        }
+    }
+    if (txId === undefined || normalizedValue === undefined)
+        throw new Error(`Error: txHex+vout required. Alternatively, but ONLY for Segwit inputs, txId+value can also be passed.`);
+    if (locktime) {
+        if (psbt.locktime && psbt.locktime !== locktime)
+            throw new Error(`Error: transaction locktime was already set with a different value: ${locktime} != ${psbt.locktime}`);
+        // nLockTime only works if at least one of the transaction inputs has an
+        // nSequence value that is below 0xffffffff. Let's make sure that at least
+        // this input's sequence < 0xffffffff
+        if (sequence === undefined) {
+            //NOTE: if sequence is undefined, bitcoinjs-lib uses 0xffffffff as default
+            sequence = rbf ? 0xfffffffd : 0xfffffffe;
+        }
+        else if (sequence > 0xfffffffe) {
+            throw new Error(`Error: incompatible sequence: ${sequence} and locktime: ${locktime}`);
+        }
+        if (sequence === undefined && rbf)
+            sequence = 0xfffffffd;
+        psbt.setLocktime(locktime);
+    }
+    else {
+        if (sequence === undefined) {
+            if (rbf)
+                sequence = 0xfffffffd;
+            else
+                sequence = 0xffffffff;
+        }
+    }
+    const input = {
+        hash: reverseBytes((0, uint8array_tools_1.fromHex)(txId)),
+        index: vout
+    };
+    if (txHex !== undefined) {
+        input.nonWitnessUtxo = Transaction.fromHex(txHex).toBuffer();
+    }
+    if (tapInternalKey) {
+        //Taproot
+        const fallbackTapBip32Derivation = keysInfo
+            .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && 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,
+                leafHashes: []
+            };
+        });
+        const resolvedTapBip32Derivation = tapBip32Derivation || fallbackTapBip32Derivation;
+        if (resolvedTapBip32Derivation.length)
+            input.tapBip32Derivation = resolvedTapBip32Derivation;
+        input.tapInternalKey = tapInternalKey;
+        if (tapLeafScript && tapLeafScript.length > 0)
+            input.tapLeafScript = tapLeafScript;
+    }
+    else {
+        const bip32Derivation = keysInfo
+            .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && 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) {
+        //There's no need to put both witnessUtxo and nonWitnessUtxo
+        input.witnessUtxo = { script: scriptPubKey, value: normalizedValue };
+    }
+    if (sequence !== undefined)
+        input.sequence = sequence;
+    if (witnessScript)
+        input.witnessScript = witnessScript;
+    if (redeemScript)
+        input.redeemScript = redeemScript;
+    psbt.addInput(input);
+    return psbt.data.inputs.length - 1;
+}
+// ─── Type Guards and Converters ─────────────────────────────────────
+/**
+ * Converts a concrete transaction object to this library's internal `PsbtLike`
+ * surface.
+ *
+ * @param psbt - Either a
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | bitcoinjs-lib `Psbt`}
+ * or a {@link https://github.com/paulmillr/scure-btc-signer | `@scure/btc-signer` `Transaction`}.
+ * @returns A `PsbtLike` implementation consumed by internal code.
+ */
+function toPsbt(psbt) {
+    if ((0, bitcoinLib_1.isScureTransaction)(psbt)) {
+        // Dynamically import scure adapter only when needed
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { wrapScureTransaction } = require('./adapters/scure');
+            return wrapScureTransaction(psbt);
+        }
+        catch (error) {
+            throw new Error('Failed to load @scure/btc-signer adapter. ' +
+                'Make sure @scure/btc-signer is installed as a peer dependency. ' +
+                'Original error: ' +
+                (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    // Already a bitcoinjs-lib compatible Psbt
+    return psbt;
+}

package/dist/re.d.ts

@@ -0,0 +1,31 @@
+export declare const reOriginPath: string;
+export declare const reMasterFingerprint: string;
+export declare const reOrigin: string;
+export declare const reChecksum: string;
+export declare const reNonSegwitPubKey: string;
+export declare const reSegwitPubKey: string;
+export declare const reTaprootPubKey: string;
+export declare const reWIF: string;
+export declare const reXpub: string;
+export declare const reXprv: string;
+export declare const rePath: string;
+export declare const reXpubKey: string;
+export declare const reXprvKey: string;
+export declare const reNonSegwitKeyExp: string;
+export declare const reSegwitKeyExp: string;
+export declare const reTaprootKeyExp: string;
+export declare const reNonSegwitSortedMulti: string;
+export declare const reSegwitSortedMulti: string;
+export declare const anchorStartAndEnd: (re: string) => string;
+export declare const rePkAnchored: string;
+export declare const reAddrAnchored: string;
+export declare const rePkhAnchored: string;
+export declare const reWpkhAnchored: string;
+export declare const reShWpkhAnchored: string;
+export declare const reTrSingleKeyAnchored: string;
+export declare const reShSortedMultiAnchored: string;
+export declare const reWshSortedMultiAnchored: string;
+export declare const reShWshSortedMultiAnchored: string;
+export declare const reShMiniscriptAnchored: string;
+export declare const reShWshMiniscriptAnchored: string;
+export declare const reWshMiniscriptAnchored: string;

package/dist/re.js

@@ -0,0 +1,79 @@
+"use strict";
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reWshMiniscriptAnchored = exports.reShWshMiniscriptAnchored = exports.reShMiniscriptAnchored = exports.reShWshSortedMultiAnchored = exports.reWshSortedMultiAnchored = exports.reShSortedMultiAnchored = exports.reTrSingleKeyAnchored = exports.reShWpkhAnchored = exports.reWpkhAnchored = exports.rePkhAnchored = exports.reAddrAnchored = exports.rePkAnchored = exports.anchorStartAndEnd = exports.reSegwitSortedMulti = exports.reNonSegwitSortedMulti = exports.reTaprootKeyExp = exports.reSegwitKeyExp = exports.reNonSegwitKeyExp = exports.reXprvKey = exports.reXpubKey = exports.rePath = exports.reXprv = exports.reXpub = exports.reWIF = exports.reTaprootPubKey = exports.reSegwitPubKey = exports.reNonSegwitPubKey = exports.reChecksum = exports.reOrigin = exports.reMasterFingerprint = exports.reOriginPath = void 0;
+const checksum_1 = require("./checksum");
+//Regular expressions cheat sheet:
+//https://www.keycdn.com/support/regex-cheat-sheet
+//hardened characters
+const reHardened = String.raw `(['hH])`;
+//a level is a series of integers followed (optional) by a hardener char
+const reLevel = String.raw `(\d+${reHardened}?)`;
+//a path component is a level followed by a slash "/" char
+const rePathComponent = String.raw `(${reLevel}\/)`;
+//A path formed by a series of path components that can be hardened: /2'/23H/23
+exports.reOriginPath = String.raw `(\/${rePathComponent}*${reLevel})`; //The "*" means: "match 0 or more of the previous"
+//an origin is something like this: [d34db33f/44'/0'/0'] where the path is optional. The fingerPrint is 8 chars hex
+exports.reMasterFingerprint = String.raw `[0-9a-fA-F]{8}`;
+exports.reOrigin = String.raw `(\[${exports.reMasterFingerprint}(${exports.reOriginPath})?\])`;
+exports.reChecksum = String.raw `(#[${checksum_1.CHECKSUM_CHARSET}]{8})`;
+//Something like this: 0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2
+//as explained here: github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md#reference
+const reCompressedPubKey = String.raw `((02|03)[0-9a-fA-F]{64})`;
+const reUncompressedPubKey = String.raw `(04[0-9a-fA-F]{128})`;
+const reXOnlyPubKey = String.raw `([0-9a-fA-F]{64})`;
+exports.reNonSegwitPubKey = String.raw `(${reCompressedPubKey}|${reUncompressedPubKey})`;
+exports.reSegwitPubKey = String.raw `(${reCompressedPubKey})`;
+exports.reTaprootPubKey = String.raw `(${reCompressedPubKey}|${reXOnlyPubKey})`;
+//https://learnmeabitcoin.com/technical/wif
+//5, K, L for mainnet, 5: uncompressed, {K, L}: compressed
+//c, 9, testnet, c: compressed, 9: uncompressed
+exports.reWIF = String.raw `([5KLc9][1-9A-HJ-NP-Za-km-z]{50,51})`;
+//x for mainnet, t for testnet
+exports.reXpub = String.raw `([xXtT]pub[1-9A-HJ-NP-Za-km-z]{79,108})`;
+exports.reXprv = String.raw `([xXtT]prv[1-9A-HJ-NP-Za-km-z]{79,108})`;
+//reRangeLevel is like reLevel but using a wildcard "*"
+const reRangeLevel = String.raw `(\*(${reHardened})?)`;
+//A path can be finished with stuff like this: /23 or /23h or /* or /*'
+exports.rePath = String.raw `(\/(${rePathComponent})*(${reRangeLevel}|${reLevel}))`;
+//rePath is optional (note the "zero"): Followed by zero or more /NUM or /NUM' path elements to indicate unhardened or hardened derivation steps between the fingerprint and the key or xpub/xprv root that follows
+exports.reXpubKey = String.raw `(${exports.reXpub})(${exports.rePath})?`;
+exports.reXprvKey = String.raw `(${exports.reXprv})(${exports.rePath})?`;
+//actualKey is the keyExpression without optional origin
+const reNonSegwitActualKey = String.raw `(${exports.reXpubKey}|${exports.reXprvKey}|${exports.reNonSegwitPubKey}|${exports.reWIF})`;
+const reSegwitActualKey = String.raw `(${exports.reXpubKey}|${exports.reXprvKey}|${exports.reSegwitPubKey}|${exports.reWIF})`;
+const reTaprootActualKey = String.raw `(${exports.reXpubKey}|${exports.reXprvKey}|${exports.reTaprootPubKey}|${exports.reWIF})`;
+//reOrigin is optional: Optionally, key origin information, consisting of:
+//Matches a key expression: wif, xpub, xprv or pubkey:
+exports.reNonSegwitKeyExp = String.raw `(${exports.reOrigin})?(${reNonSegwitActualKey})`;
+exports.reSegwitKeyExp = String.raw `(${exports.reOrigin})?(${reSegwitActualKey})`;
+exports.reTaprootKeyExp = String.raw `(${exports.reOrigin})?(${reTaprootActualKey})`;
+const rePk = String.raw `pk\((.*?)\)`; //Matches anything. We assert later in the code that the pubkey is valid.
+const reAddr = String.raw `addr\((.*?)\)`; //Matches anything. We assert later in the code that the address is valid.
+const rePkh = String.raw `pkh\(${exports.reNonSegwitKeyExp}\)`;
+const reWpkh = String.raw `wpkh\(${exports.reSegwitKeyExp}\)`;
+const reShWpkh = String.raw `sh\(wpkh\(${exports.reSegwitKeyExp}\)\)`;
+const reTrSingleKey = String.raw `tr\(${exports.reTaprootKeyExp}\)`; // TODO: tr(KEY,TREE) not yet supported. TrSingleKey used for tr(KEY)
+exports.reNonSegwitSortedMulti = String.raw `sortedmulti\(((?:1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20)(?:,${exports.reNonSegwitKeyExp})+)\)`;
+exports.reSegwitSortedMulti = String.raw `sortedmulti\(((?:1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20)(?:,${exports.reSegwitKeyExp})+)\)`;
+const reMiniscript = String.raw `(.*?)`; //Matches anything. We assert later in the code that miniscripts are valid and sane.
+//RegExp makers:
+const makeReSh = (re) => String.raw `sh\(${re}\)`;
+const makeReWsh = (re) => String.raw `wsh\(${re}\)`;
+const makeReShWsh = (re) => makeReSh(makeReWsh(re));
+const anchorStartAndEnd = (re) => String.raw `^${re}$`; //starts and finishes like re (not composable)
+exports.anchorStartAndEnd = anchorStartAndEnd;
+const composeChecksum = (re) => String.raw `${re}(${exports.reChecksum})?`; //it's optional (note the "?")
+exports.rePkAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(rePk));
+exports.reAddrAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reAddr));
+exports.rePkhAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(rePkh));
+exports.reWpkhAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reWpkh));
+exports.reShWpkhAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reShWpkh));
+exports.reTrSingleKeyAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reTrSingleKey));
+exports.reShSortedMultiAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReSh(exports.reNonSegwitSortedMulti)));
+exports.reWshSortedMultiAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReWsh(exports.reSegwitSortedMulti)));
+exports.reShWshSortedMultiAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReShWsh(exports.reSegwitSortedMulti)));
+exports.reShMiniscriptAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReSh(reMiniscript)));
+exports.reShWshMiniscriptAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReShWsh(reMiniscript)));
+exports.reWshMiniscriptAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReWsh(reMiniscript)));

package/dist/resourceLimits.d.ts

@@ -0,0 +1,28 @@
+import type { BitcoinLib } from './bitcoinLib';
+import type { Network } from './networks';
+export declare const MAX_SCRIPT_ELEMENT_SIZE = 520;
+export declare const MAX_STANDARD_P2WSH_SCRIPT_SIZE = 3600;
+export declare function assertScriptNonPushOnlyOpsLimit({ script, scriptLib }: {
+    script: Uint8Array;
+    scriptLib: BitcoinLib['script'];
+}): void;
+/**
+ * Enforces consensus stack resource limits.
+ */
+export declare function assertConsensusStackResourceLimits({ stackItems, stackLabel, stackItemLabel }: {
+    stackItems: Uint8Array[];
+    stackLabel?: string;
+    stackItemLabel?: string;
+}): void;
+export declare function assertWitnessV0SatisfactionResourceLimits({ stackItems }: {
+    stackItems: Uint8Array[];
+}): void;
+export declare function assertTaprootScriptPathSatisfactionResourceLimits({ stackItems }: {
+    stackItems: Uint8Array[];
+}): void;
+export declare function assertP2shScriptSigStandardSize({ scriptSatisfaction, redeemScript, network, payments }: {
+    scriptSatisfaction: Uint8Array;
+    redeemScript: Uint8Array;
+    network: Network;
+    payments: BitcoinLib['payments'];
+}): void;

package/dist/resourceLimits.js

@@ -0,0 +1,84 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_STANDARD_P2WSH_SCRIPT_SIZE = exports.MAX_SCRIPT_ELEMENT_SIZE = void 0;
+exports.assertScriptNonPushOnlyOpsLimit = assertScriptNonPushOnlyOpsLimit;
+exports.assertConsensusStackResourceLimits = assertConsensusStackResourceLimits;
+exports.assertWitnessV0SatisfactionResourceLimits = assertWitnessV0SatisfactionResourceLimits;
+exports.assertTaprootScriptPathSatisfactionResourceLimits = assertTaprootScriptPathSatisfactionResourceLimits;
+exports.assertP2shScriptSigStandardSize = assertP2shScriptSigStandardSize;
+// See Sipa's Miniscript "Resource limitations":
+// https://bitcoin.sipa.be/miniscript/
+// and Bitcoin Core policy/consensus constants.
+//https://github.com/bitcoin/bitcoin/blob/master/src/policy/policy.h
+// Consensus: max number of elements in initial stack (and stack+altstack after
+// each opcode execution).
+const MAX_STACK_SIZE = 1000;
+// Consensus: max size for any stack element is 520 bytes.
+// This is a per-element limit, not a full script-size limit.
+// In legacy P2SH, redeemScript is pushed as a stack element,
+// ( this is why we typically say that the redeemScript cannot be larger than 520 ).
+// But the same per-element rule applies to other stack items as well.
+exports.MAX_SCRIPT_ELEMENT_SIZE = 520;
+// Standardness policy limits.
+// See Sipa's Miniscript "Resource limitations":
+// https://bitcoin.sipa.be/miniscript/
+// and Bitcoin Core policy/consensus constants.
+//https://github.com/bitcoin/bitcoin/blob/master/src/policy/policy.h
+exports.MAX_STANDARD_P2WSH_SCRIPT_SIZE = 3600;
+const MAX_STANDARD_P2WSH_STACK_ITEMS = 100;
+const MAX_OPS_PER_SCRIPT = 201;
+const MAX_STANDARD_SCRIPTSIG_SIZE = 1650;
+const MAX_STANDARD_P2WSH_STACK_ITEM_SIZE = 80;
+const MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE = 80;
+function assertScriptNonPushOnlyOpsLimit({ script, scriptLib }) {
+    const chunks = scriptLib.decompile(script);
+    if (!chunks)
+        throw new Error(`Error: could not decompile ${script}`);
+    const nonPushOnlyOps = scriptLib.countNonPushOnlyOPs(chunks);
+    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}`);
+}
+/**
+ * Enforces consensus stack resource limits.
+ */
+function assertConsensusStackResourceLimits({ stackItems, stackLabel = 'stack', stackItemLabel = 'stack item' }) {
+    if (stackItems.length > MAX_STACK_SIZE)
+        throw new Error(`Error: ${stackLabel} has too many items, ${stackItems.length} is larger than ${MAX_STACK_SIZE}`);
+    for (const stackItem of stackItems) {
+        if (stackItem.length > exports.MAX_SCRIPT_ELEMENT_SIZE)
+            throw new Error(`Error: ${stackItemLabel} is too large, ${stackItem.length} bytes is larger than ${exports.MAX_SCRIPT_ELEMENT_SIZE} bytes`);
+    }
+}
+function assertWitnessV0SatisfactionResourceLimits({ stackItems }) {
+    assertConsensusStackResourceLimits({ stackItems });
+    if (stackItems.length > MAX_STANDARD_P2WSH_STACK_ITEMS)
+        throw new Error(`Error: witness stack has too many items, ${stackItems.length} is larger than ${MAX_STANDARD_P2WSH_STACK_ITEMS}`);
+    for (const stackItem of stackItems) {
+        if (stackItem.length > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
+            throw new Error(`Error: witness stack item exceeds standard policy, ${stackItem.length} bytes is larger than ${MAX_STANDARD_P2WSH_STACK_ITEM_SIZE} bytes`);
+    }
+}
+function assertTaprootScriptPathSatisfactionResourceLimits({ stackItems }) {
+    assertConsensusStackResourceLimits({
+        stackItems,
+        stackLabel: 'taproot script-path stack',
+        stackItemLabel: 'taproot script-path stack item'
+    });
+    // Standardness policy for tapscript (leaf version 0xc0): <= 80 bytes.
+    for (const stackItem of stackItems) {
+        if (stackItem.length > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE)
+            throw new Error(`Error: taproot script-path stack item exceeds standard policy, ${stackItem.length} bytes is larger than ${MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE} bytes`);
+    }
+}
+function assertP2shScriptSigStandardSize({ scriptSatisfaction, redeemScript, network, payments }) {
+    const scriptSig = payments.p2sh({
+        redeem: { input: scriptSatisfaction, output: redeemScript },
+        network
+    }).input;
+    if (!scriptSig)
+        throw new Error(`Error: could not build scriptSig from satisfaction`);
+    if (scriptSig.length > MAX_STANDARD_SCRIPTSIG_SIZE)
+        throw new Error(`Error: scriptSig is too large, ${scriptSig.length} bytes is larger than ${MAX_STANDARD_SCRIPTSIG_SIZE} bytes`);
+}

package/dist/scriptExpressions.d.ts

@@ -0,0 +1,95 @@
+import type { BIP32InterfaceLike, ScureHDKeyLike } from './bitcoinLib';
+import type { LedgerManager } from './ledger';
+import { type Network } from './networks';
+/** @function */
+export declare const pkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32InterfaceLike | ScureHDKeyLike;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const shWpkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32InterfaceLike | ScureHDKeyLike;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const wpkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32InterfaceLike | ScureHDKeyLike;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const trBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32InterfaceLike | ScureHDKeyLike;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const pkhLedger: ({ ledgerManager, account, keyPath, change, index }: {
+    ledgerManager: LedgerManager;
+    account: number;
+    keyPath?: string;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+}) => Promise<string>;
+/** @function */
+export declare const shWpkhLedger: ({ ledgerManager, account, keyPath, change, index }: {
+    ledgerManager: LedgerManager;
+    account: number;
+    keyPath?: string;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+}) => Promise<string>;
+/** @function */
+export declare const wpkhLedger: ({ ledgerManager, account, keyPath, change, index }: {
+    ledgerManager: LedgerManager;
+    account: number;
+    keyPath?: string;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+}) => Promise<string>;
+/** @function */
+export declare const trLedger: ({ ledgerManager, account, keyPath, change, index }: {
+    ledgerManager: LedgerManager;
+    account: number;
+    keyPath?: string;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+}) => Promise<string>;