@bitcoinerlab/descriptors 2.3.6 → 3.0.0

package/dist/multipath.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMultipathDescriptor = resolveMultipathDescriptor;
+/**
+ * Replaces the receive/change shorthand `/**` with its canonical multipath
+ * representation `/<0;1>/*`.
+ */
+function expandReceiveChangeShorthand(descriptor) {
+    return descriptor.replace(/\/\*\*/g, '/<0;1>/*');
+}
+/**
+ * Parses a multipath tuple body from `<...>`.
+ *
+ * This implementation intentionally accepts only decimal numbers (no hardened
+ * suffixes) and enforces strict left-to-right increase as a safety feature to
+ * catch likely human errors such as `<1;0>`.
+ */
+function parseMultipathTuple(tupleBody) {
+    const parts = tupleBody.split(';');
+    if (parts.length < 2)
+        throw new Error(`Error: multipath tuple must contain at least 2 values, got <${tupleBody}>`);
+    const values = parts.map(part => {
+        if (!/^(0|[1-9]\d*)$/.test(part))
+            throw new Error(`Error: multipath tuple values must be decimal numbers, got <${tupleBody}>`);
+        const value = Number(part);
+        if (!Number.isSafeInteger(value))
+            throw new Error(`Error: multipath tuple value overflow, got <${tupleBody}>`);
+        return value;
+    });
+    for (let i = 1; i < values.length; i++) {
+        const prev = values[i - 1];
+        const current = values[i];
+        if (prev === undefined || current === undefined)
+            throw new Error(`Error: invalid multipath tuple <${tupleBody}>`);
+        if (current <= prev)
+            throw new Error(`Error: multipath tuple values must be strictly increasing from left to right, got <${tupleBody}>`);
+    }
+    return values;
+}
+/**
+ * Resolves all multipath tuple segments (for example `/<0;1>/*`) in lockstep
+ * using the provided `change` value.
+ *
+ * - `/**` is first canonicalized to `/<0;1>/*`.
+ * - All tuples in the descriptor must have the same cardinality.
+ * - Tuple values must be strictly increasing decimal numbers.
+ * - `change` must match one of the values in each tuple.
+ */
+function resolveMultipathDescriptor({ descriptor, change }) {
+    const canonicalDescriptor = expandReceiveChangeShorthand(descriptor);
+    const tupleMatches = Array.from(canonicalDescriptor.matchAll(/\/<([^<>]+)>/g), match => ({
+        token: match[0],
+        tupleBody: match[1],
+        values: parseMultipathTuple(match[1])
+    }));
+    if (tupleMatches.length === 0)
+        return canonicalDescriptor;
+    if (change === undefined)
+        throw new Error(`Error: change was not provided for multipath descriptor`);
+    if (!Number.isInteger(change) || change < 0)
+        throw new Error(`Error: invalid change ${change}`);
+    const tupleSize = tupleMatches[0]?.values.length;
+    if (!tupleSize)
+        throw new Error(`Error: invalid multipath tuple`);
+    for (const tupleMatch of tupleMatches) {
+        if (tupleMatch.values.length !== tupleSize)
+            throw new Error(`Error: all multipath tuples must have the same number of options`);
+    }
+    let resolvedDescriptor = canonicalDescriptor;
+    for (const tupleMatch of tupleMatches) {
+        if (!tupleMatch.values.includes(change))
+            throw new Error(`Error: change ${change} not found in multipath tuple <${tupleMatch.tupleBody}>`);
+        resolvedDescriptor = resolvedDescriptor.replaceAll(tupleMatch.token, `/${change}`);
+    }
+    return resolvedDescriptor;
+}

package/dist/networkUtils.d.ts

@@ -0,0 +1,3 @@
+import type { Network } from 'bitcoinjs-lib';
+export declare function isBitcoinMainnet(network: Network): boolean;
+export declare function coinTypeFromNetwork(network: Network): 0 | 1;

package/dist/networkUtils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBitcoinMainnet = isBitcoinMainnet;
+exports.coinTypeFromNetwork = coinTypeFromNetwork;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+function isBitcoinMainnet(network) {
+    return (network.bech32 === bitcoinjs_lib_1.networks.bitcoin.bech32 &&
+        network.bip32.public === bitcoinjs_lib_1.networks.bitcoin.bip32.public &&
+        network.bip32.private === bitcoinjs_lib_1.networks.bitcoin.bip32.private &&
+        network.pubKeyHash === bitcoinjs_lib_1.networks.bitcoin.pubKeyHash &&
+        network.scriptHash === bitcoinjs_lib_1.networks.bitcoin.scriptHash &&
+        network.wif === bitcoinjs_lib_1.networks.bitcoin.wif);
+}
+function coinTypeFromNetwork(network) {
+    return isBitcoinMainnet(network) ? 0 : 1;
+}

package/dist/parseUtils.d.ts

@@ -0,0 +1,7 @@
+export declare function splitTopLevelComma({ expression, onError }: {
+    expression: string;
+    onError: (expression: string) => Error;
+}): {
+    left: string;
+    right: string;
+} | null;

package/dist/parseUtils.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitTopLevelComma = splitTopLevelComma;
+function splitTopLevelComma({ expression, onError }) {
+    let braceDepth = 0;
+    let parenDepth = 0;
+    let commaIndex = -1;
+    for (let i = 0; i < expression.length; i++) {
+        const char = expression[i];
+        if (!char)
+            continue;
+        if (char === '{') {
+            braceDepth++;
+        }
+        else if (char === '}') {
+            if (braceDepth === 0)
+                throw onError(expression);
+            braceDepth--;
+        }
+        else if (char === '(') {
+            //Track miniscript argument lists so we don't split on commas inside them.
+            parenDepth++;
+        }
+        else if (char === ')') {
+            if (parenDepth === 0)
+                throw onError(expression);
+            parenDepth--;
+        }
+        else if (char === ',') {
+            if (braceDepth === 0 && parenDepth === 0) {
+                if (commaIndex !== -1)
+                    throw onError(expression);
+                commaIndex = i;
+            }
+        }
+    }
+    if (braceDepth !== 0 || parenDepth !== 0)
+        throw onError(expression);
+    if (commaIndex === -1)
+        return null;
+    const left = expression.slice(0, commaIndex).trim();
+    const right = expression.slice(commaIndex + 1).trim();
+    if (!left || !right)
+        throw onError(expression);
+    return { left, right };
+}

package/dist/psbt.d.ts

@@ -1,40 +1,44 @@
-import type { PsbtInput } from 'bip174/src/lib/interfaces';
+import type { PsbtInput, TapBip32Derivation, TapLeafScript } from 'bip174';
 import type { KeyInfo } from './types';
 import { Network, Psbt } from 'bitcoinjs-lib';
 /**
  * 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 the finalScriptSig and finalScriptWitness Buffers.
+ * 2. Create finalScriptSig and finalScriptWitness.
  */
 type FinalScriptsFunc = (inputIndex: number, // Which input is it?
 input: PsbtInput, // The PSBT input contents
-script: Buffer, // The "meaningful" locking script Buffer (redeemScript for P2SH etc.)
+script: Uint8Array, // The "meaningful" locking script (redeemScript for P2SH etc.)
 isSegwit: boolean, // Is it segwit?
 isP2SH: boolean, // Is it P2SH?
 isP2WSH: boolean) => {
-    finalScriptSig: Buffer | undefined;
-    finalScriptWitness: Buffer | undefined;
+    finalScriptSig: Uint8Array | undefined;
+    finalScriptWitness: Uint8Array | undefined;
 };
-export declare function finalScriptsFuncFactory(scriptSatisfaction: Buffer, network: Network): FinalScriptsFunc;
+export declare function finalScriptsFuncFactory(scriptSatisfaction: Uint8Array, network: Network): FinalScriptsFunc;
 /**
- * Important: Read comments on descriptor.updatePsbt regarding not passing txHex
+ * Important: Read comments on Output.updatePsbtAsInput regarding not passing txHex
  */
-export declare function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, witnessScript, redeemScript, rbf }: {
+export declare function addPsbtInput({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, tapLeafScript, tapBip32Derivation, witnessScript, redeemScript, rbf }: {
     psbt: Psbt;
     vout: number;
     txHex?: string;
     txId?: string;
-    value?: number;
+    value?: bigint;
     sequence: number | undefined;
     locktime: number | undefined;
     keysInfo: KeyInfo[];
-    scriptPubKey: Buffer;
+    scriptPubKey: Uint8Array;
     isSegwit: boolean;
     /** for taproot **/
-    tapInternalKey?: Buffer | undefined;
-    witnessScript: Buffer | undefined;
-    redeemScript: Buffer | undefined;
+    tapInternalKey?: Uint8Array | undefined;
+    /** for taproot script-path **/
+    tapLeafScript?: TapLeafScript[] | undefined;
+    /** for taproot **/
+    tapBip32Derivation?: TapBip32Derivation[] | undefined;
+    witnessScript: Uint8Array | undefined;
+    redeemScript: Uint8Array | undefined;
     rbf: boolean;
 }): number;
 export {};

package/dist/psbt.js

@@ -3,43 +3,23 @@
 // Distributed under the MIT software license
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.finalScriptsFuncFactory = finalScriptsFuncFactory;
-exports.updatePsbt = updatePsbt;
+exports.addPsbtInput = addPsbtInput;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const varuint_bitcoin_1 = require("varuint-bitcoin");
-function reverseBuffer(buffer) {
+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;
-    let j = buffer.length - 1;
+    const copy = Uint8Array.from(buffer);
+    let j = copy.length - 1;
     let tmp = 0;
-    for (let i = 0; i < buffer.length / 2; i++) {
-        tmp = buffer[i];
-        buffer[i] = buffer[j];
-        buffer[j] = tmp;
+    for (let i = 0; i < copy.length / 2; i++) {
+        tmp = copy[i];
+        copy[i] = copy[j];
+        copy[j] = tmp;
         j--;
     }
-    return buffer;
-}
-function witnessStackToScriptWitness(witness) {
-    let buffer = Buffer.allocUnsafe(0);
-    function writeSlice(slice) {
-        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
-    }
-    function writeVarInt(i) {
-        const currentLen = buffer.length;
-        const varintLen = (0, varuint_bitcoin_1.encodingLength)(i);
-        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-        (0, varuint_bitcoin_1.encode)(i, buffer, currentLen);
-    }
-    function writeVarSlice(slice) {
-        writeVarInt(slice.length);
-        writeSlice(slice);
-    }
-    function writeVector(vector) {
-        writeVarInt(vector.length);
-        vector.forEach(writeVarSlice);
-    }
-    writeVector(witness);
-    return buffer;
+    return copy;
 }
 function finalScriptsFuncFactory(scriptSatisfaction, network) {
     const finalScriptsFunc = (_index, _input, lockingScript /*witnessScript or redeemScript*/, isSegwit, isP2SH, _isP2WSH) => {
@@ -53,7 +33,7 @@ function finalScriptsFuncFactory(scriptSatisfaction, network) {
             });
             if (!payment.witness)
                 throw new Error(`Error: p2wsh failed producing a witness`);
-            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+            finalScriptWitness = (0, bitcoinjs_lib_internals_1.witnessStackToScriptWitness)(payment.witness);
         }
         //p2sh-p2wsh
         else if (isSegwit && isP2SH) {
@@ -66,7 +46,7 @@ function finalScriptsFuncFactory(scriptSatisfaction, network) {
             });
             if (!payment.witness)
                 throw new Error(`Error: p2sh-p2wsh failed producing a witness`);
-            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+            finalScriptWitness = (0, bitcoinjs_lib_internals_1.witnessStackToScriptWitness)(payment.witness);
             finalScriptSig = payment.input;
         }
         //p2sh
@@ -84,9 +64,14 @@ function finalScriptsFuncFactory(scriptSatisfaction, network) {
     return finalScriptsFunc;
 }
 /**
- * Important: Read comments on descriptor.updatePsbt regarding not passing txHex
+ * Important: Read comments on Output.updatePsbtAsInput regarding not passing txHex
  */
-function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, witnessScript, redeemScript, rbf }) {
+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`);
@@ -104,7 +89,7 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
         const outputScript = out.script;
         if (!outputScript)
             throw new Error(`Error: could not extract outputScript for txHex ${txHex} and vout ${vout}`);
-        if (Buffer.compare(outputScript, scriptPubKey) !== 0)
+        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)
@@ -113,15 +98,15 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
         else {
             txId = tx.getId();
         }
-        if (value !== undefined) {
-            if (out.value !== value)
+        if (normalizedValue !== undefined) {
+            if (out.value !== normalizedValue)
                 throw new Error(`Error: value for ${txHex} and vout ${vout} does not correspond to ${value}`);
         }
         else {
-            value = out.value;
+            normalizedValue = out.value;
         }
     }
-    if (txId === undefined || !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)
@@ -149,7 +134,7 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
         }
     }
     const input = {
-        hash: reverseBuffer(Buffer.from(txId, 'hex')),
+        hash: reverseBytes((0, uint8array_tools_1.fromHex)(txId)),
         index: vout
     };
     if (txHex !== undefined) {
@@ -157,7 +142,7 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
     }
     if (tapInternalKey) {
         //Taproot
-        const tapBip32Derivation = keysInfo
+        const fallbackTapBip32Derivation = keysInfo
             .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && keyInfo.path)
             .map((keyInfo) => {
             const pubkey = keyInfo.pubkey;
@@ -167,16 +152,15 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
                 masterFingerprint: keyInfo.masterFingerprint,
                 pubkey,
                 path: keyInfo.path,
-                leafHashes: [] // TODO: Empty array for tr(KEY) taproot key spend - this is the only type currently supported
+                leafHashes: []
             };
         });
-        if (tapBip32Derivation.length)
-            input.tapBip32Derivation = tapBip32Derivation;
+        const resolvedTapBip32Derivation = tapBip32Derivation || fallbackTapBip32Derivation;
+        if (resolvedTapBip32Derivation.length)
+            input.tapBip32Derivation = resolvedTapBip32Derivation;
         input.tapInternalKey = tapInternalKey;
-        //TODO: currently only single-key taproot supported.
-        //https://github.com/bitcoinjs/bitcoinjs-lib/blob/6ba8bb3ce20ba533eeaba6939cfc2891576d9969/test/integration/taproot.spec.ts#L243
-        if (tapBip32Derivation.length > 1)
-            throw new Error('Only single key taproot inputs are currently supported');
+        if (tapLeafScript && tapLeafScript.length > 0)
+            input.tapLeafScript = tapLeafScript;
     }
     else {
         const bip32Derivation = keysInfo
@@ -196,7 +180,7 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
     }
     if (isSegwit && txHex !== undefined) {
         //There's no need to put both witnessUtxo and nonWitnessUtxo
-        input.witnessUtxo = { script: scriptPubKey, value };
+        input.witnessUtxo = { script: scriptPubKey, value: normalizedValue };
     }
     if (sequence !== undefined)
         input.sequence = sequence;

package/dist/resourceLimits.d.ts

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

@@ -0,0 +1,89 @@
+"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,5 +1,5 @@
 import { Network } from 'bitcoinjs-lib';
-import type { LedgerState, LedgerManager } from './ledger';
+import type { LedgerManager } from './ledger';
 import type { BIP32Interface } from 'bip32';
 /** @function */
 export declare const pkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
@@ -62,82 +62,34 @@ export declare const trBIP32: ({ masterNode, network, keyPath, account, change,
     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>;
-    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-        ledgerClient: unknown;
-        ledgerState: LedgerState;
-        /** @default networks.bitcoin */
-        network?: Network;
-        account: number;
-        keyPath?: string;
-        change?: number | undefined;
-        index?: number | undefined | "*";
-    }): Promise<string>;
-};
+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>;
-    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-        ledgerClient: unknown;
-        ledgerState: LedgerState;
-        /** @default networks.bitcoin */
-        network?: Network;
-        account: number;
-        keyPath?: string;
-        change?: number | undefined;
-        index?: number | undefined | "*";
-    }): Promise<string>;
-};
+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>;
-    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-        ledgerClient: unknown;
-        ledgerState: LedgerState;
-        /** @default networks.bitcoin */
-        network?: Network;
-        account: number;
-        keyPath?: string;
-        change?: number | undefined;
-        index?: number | undefined | "*";
-    }): Promise<string>;
-};
+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>;
-    ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-        ledgerClient: unknown;
-        ledgerState: LedgerState;
-        /** @default networks.bitcoin */
-        network?: Network;
-        account: number;
-        keyPath?: string;
-        change?: number | undefined;
-        index?: number | undefined | "*";
-    }): Promise<string>;
-};
+export declare const trLedger: ({ ledgerManager, account, keyPath, change, index }: {
+    ledgerManager: LedgerManager;
+    account: number;
+    keyPath?: string;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+}) => Promise<string>;