@bitcoinerlab/descriptors 3.0.6 → 3.1.1

package/dist/psbt.js

@@ -1,193 +0,0 @@
-"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;
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-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) {
-    const finalScriptsFunc = (_index, _input, lockingScript /*witnessScript or redeemScript*/, isSegwit, isP2SH, _isP2WSH) => {
-        let finalScriptWitness;
-        let finalScriptSig;
-        //p2wsh
-        if (isSegwit && !isP2SH) {
-            const payment = bitcoinjs_lib_1.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 = bitcoinjs_lib_1.payments.p2sh({
-                redeem: bitcoinjs_lib_1.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 = bitcoinjs_lib_1.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 }) {
-    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 = bitcoinjs_lib_1.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 = bitcoinjs_lib_1.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;
-}

package/dist/re.d.ts

@@ -1,31 +0,0 @@
-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

@@ -1,79 +0,0 @@
-"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

@@ -1,25 +0,0 @@
-import type { Network } from 'bitcoinjs-lib';
-export declare const MAX_SCRIPT_ELEMENT_SIZE = 520;
-export declare const MAX_STANDARD_P2WSH_SCRIPT_SIZE = 3600;
-export declare function assertScriptNonPushOnlyOpsLimit({ script }: {
-    script: Uint8Array;
-}): 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 }: {
-    scriptSatisfaction: Uint8Array;
-    redeemScript: Uint8Array;
-    network: Network;
-}): void;

package/dist/resourceLimits.js

@@ -1,89 +0,0 @@
-"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;
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const { p2sh } = bitcoinjs_lib_1.payments;
-// 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 countNonPushOnlyOPs(script) {
-    const chunks = bitcoinjs_lib_1.script.decompile(script);
-    if (!chunks)
-        throw new Error(`Error: could not decompile ${script}`);
-    return bitcoinjs_lib_1.script.countNonPushOnlyOPs(chunks);
-}
-function assertScriptNonPushOnlyOpsLimit({ script }) {
-    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}`);
-}
-/**
- * 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 }) {
-    const scriptSig = p2sh({
-        redeem: { input: scriptSatisfaction, output: redeemScript, network },
-        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

@@ -1,95 +0,0 @@
-import { Network } from 'bitcoinjs-lib';
-import type { LedgerManager } from './ledger';
-import type { BIP32Interface } from 'bip32';
-/** @function */
-export declare const pkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
-    masterNode: BIP32Interface;
-    /** @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: BIP32Interface;
-    /** @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: BIP32Interface;
-    /** @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: BIP32Interface;
-    /** @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>;

package/dist/scriptExpressions.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trLedger = exports.wpkhLedger = exports.shWpkhLedger = exports.pkhLedger = exports.trBIP32 = exports.wpkhBIP32 = exports.shWpkhBIP32 = exports.pkhBIP32 = void 0;
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const keyExpressions_1 = require("./keyExpressions");
-const networkUtils_1 = require("./networkUtils");
-function assertStandardKeyPath(keyPath) {
-    // Regular expression to match "/change/index" or "/change/*" format
-    const regex = /^\/[01]\/(\d+|\*)$/;
-    if (!regex.test(keyPath)) {
-        throw new Error("Error: Key path must be in the format '/change/index', where change is either 0 or 1 and index is a non-negative integer.");
-    }
-}
-function standardExpressionsBIP32Maker(purpose, scriptTemplate) {
-    /**
-     * Computes the standard descriptor based on given parameters.
-     *
-     * You can define the output location either by:
-     * - Providing the full `keyPath` (e.g., "/0/2").
-     * OR
-     * - Specifying the `change` and `index` values separately (e.g., `{change:0, index:2}`).
-     *
-     * For ranged indexing, the `index` can be set as a wildcard '*'. For example:
-     * - `keyPath="/0/*"`
-     * OR
-     * - `{change:0, index:'*'}`.
-     */
-    function standardScriptExpressionBIP32({ masterNode, network = bitcoinjs_lib_1.networks.bitcoin, keyPath, account, change, index, isPublic = true }) {
-        const originPath = `/${purpose}'/${(0, networkUtils_1.coinTypeFromNetwork)(network)}'/${account}'`;
-        if (keyPath !== undefined)
-            assertStandardKeyPath(keyPath);
-        const keyExpression = (0, keyExpressions_1.keyExpressionBIP32)({
-            masterNode,
-            originPath,
-            keyPath,
-            change,
-            index,
-            isPublic
-        });
-        return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
-    }
-    return standardScriptExpressionBIP32;
-}
-/** @function */
-exports.pkhBIP32 = standardExpressionsBIP32Maker(44, 'pkh(KEYEXPRESSION)');
-/** @function */
-exports.shWpkhBIP32 = standardExpressionsBIP32Maker(49, 'sh(wpkh(KEYEXPRESSION))');
-/** @function */
-exports.wpkhBIP32 = standardExpressionsBIP32Maker(84, 'wpkh(KEYEXPRESSION)');
-/** @function */
-exports.trBIP32 = standardExpressionsBIP32Maker(86, 'tr(KEYEXPRESSION)');
-function standardExpressionsLedgerMaker(purpose, scriptTemplate) {
-    /**
-     * Computes the standard descriptor based on given parameters.
-     *
-     * You can define the output location either by:
-     * - Providing the full `keyPath` (e.g., "/0/2").
-     * OR
-     * - Specifying the `change` and `index` values separately (e.g., `{change:0, index:2}`).
-     *
-     * For ranged indexing, the `index` can be set as a wildcard '*'. For example:
-     * - `keyPath="/0/*"`
-     * OR
-     * - `{change:0, index:'*'}`.
-     */
-    async function standardScriptExpressionLedger({ ledgerManager, account, keyPath, change, index }) {
-        const { network } = ledgerManager;
-        const originPath = `/${purpose}'/${(0, networkUtils_1.coinTypeFromNetwork)(network)}'/${account}'`;
-        if (keyPath !== undefined)
-            assertStandardKeyPath(keyPath);
-        const keyExpression = await (0, keyExpressions_1.keyExpressionLedger)({
-            ledgerManager,
-            originPath,
-            keyPath,
-            change,
-            index
-        });
-        return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
-    }
-    return standardScriptExpressionLedger;
-}
-/** @function */
-exports.pkhLedger = standardExpressionsLedgerMaker(44, 'pkh(KEYEXPRESSION)');
-/** @function */
-exports.shWpkhLedger = standardExpressionsLedgerMaker(49, 'sh(wpkh(KEYEXPRESSION))');
-/** @function */
-exports.wpkhLedger = standardExpressionsLedgerMaker(84, 'wpkh(KEYEXPRESSION)');
-/** @function */
-exports.trLedger = standardExpressionsLedgerMaker(86, 'tr(KEYEXPRESSION)');