@bitcoinerlab/descriptors 3.0.5 → 3.0.6

package/dist/bitcoinjs-lib-internals.d.ts

@@ -1,10 +1,10 @@
-import type * as Bip341 from 'bitcoinjs-lib/src/cjs/payments/bip341';
-import type * as Bip371 from 'bitcoinjs-lib/src/cjs/psbt/bip371';
-import type * as PsbtUtils from 'bitcoinjs-lib/src/cjs/psbt/psbtutils';
-export declare const findScriptPath: typeof Bip341.findScriptPath;
-export declare const tapleafHash: typeof Bip341.tapleafHash;
-export declare const tapTweakHash: typeof Bip341.tapTweakHash;
-export declare const toHashTree: typeof Bip341.toHashTree;
-export declare const tweakKey: typeof Bip341.tweakKey;
-export declare const witnessStackToScriptWitness: typeof PsbtUtils.witnessStackToScriptWitness;
-export declare const isTaprootInput: typeof Bip371.isTaprootInput;
+import type { PsbtInput } from 'bip174';
+type Tapleaf = {
+    output: Uint8Array;
+    version?: number;
+};
+export declare function tapleafHash(leaf: Tapleaf): Uint8Array;
+export declare function tapTweakHash(pubKey: Uint8Array, h?: Uint8Array): Uint8Array;
+export declare function witnessStackToScriptWitness(witness: Uint8Array[]): Uint8Array;
+export declare function isTaprootInput(input: PsbtInput | undefined): boolean;
+export {};

package/dist/bitcoinjs-lib-internals.js

@@ -1,50 +1,60 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-require-imports */
 /*
- * bitcoinjs-lib v7 does not export all the taproot/psbt helpers we need from
- * its top-level API, so this module centralizes only the required deep imports.
+ * Reimplements a small subset of bitcoinjs-lib internal helpers.
+ * Keep this module free of deep imports (for example `bitcoinjs-lib/src/*`)
+ * so it works consistently across Node.js, browser bundlers (including
+ * CodeSandbox), and React Native/Metro.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTaprootInput = exports.witnessStackToScriptWitness = exports.tweakKey = exports.toHashTree = exports.tapTweakHash = exports.tapleafHash = exports.findScriptPath = void 0;
-function resolveAbsoluteCjsPath(relativePath) {
-    try {
-        const entryPoint = require.resolve('bitcoinjs-lib');
-        const root = entryPoint.replace(/src[\\/]+cjs[\\/]+index\.cjs$/, '');
-        if (root === entryPoint)
-            return undefined;
-        return `${root}src/cjs/${relativePath}.cjs`;
-    }
-    catch (_err) {
-        void _err;
-        return undefined;
-    }
+exports.tapleafHash = tapleafHash;
+exports.tapTweakHash = tapTweakHash;
+exports.witnessStackToScriptWitness = witnessStackToScriptWitness;
+exports.isTaprootInput = isTaprootInput;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const varuint_bitcoin_1 = require("varuint-bitcoin");
+const uint8array_tools_1 = require("uint8array-tools");
+const TAPROOT_LEAF_VERSION_TAPSCRIPT = 0xc0;
+const OP_1 = 0x51;
+const PUSH_DATA_32 = 0x20;
+function serializeScript(script) {
+    const { buffer: encodedLength } = (0, varuint_bitcoin_1.encode)(script.length);
+    return (0, uint8array_tools_1.concat)([encodedLength, script]);
 }
-function requireBitcoinJsInternal(relativePath) {
-    const candidatePaths = [
-        `bitcoinjs-lib/src/${relativePath}`,
-        `bitcoinjs-lib/src/cjs/${relativePath}.cjs`
-    ];
-    const absoluteCjsPath = resolveAbsoluteCjsPath(relativePath);
-    if (absoluteCjsPath)
-        candidatePaths.push(absoluteCjsPath);
-    let lastError;
-    for (const modulePath of candidatePaths) {
-        try {
-            return require(modulePath);
-        }
-        catch (err) {
-            lastError = err;
-        }
-    }
-    throw lastError;
+function isP2TRScript(script) {
+    return (script instanceof Uint8Array &&
+        script.length === 34 &&
+        script[0] === OP_1 &&
+        script[1] === PUSH_DATA_32);
+}
+function tapleafHash(leaf) {
+    const version = leaf.version || TAPROOT_LEAF_VERSION_TAPSCRIPT;
+    return bitcoinjs_lib_1.crypto.taggedHash('TapLeaf', (0, uint8array_tools_1.concat)([Uint8Array.from([version]), serializeScript(leaf.output)]));
+}
+function tapTweakHash(pubKey, h) {
+    return bitcoinjs_lib_1.crypto.taggedHash('TapTweak', (0, uint8array_tools_1.concat)(h ? [pubKey, h] : [pubKey]));
+}
+function witnessStackToScriptWitness(witness) {
+    let buffer = new Uint8Array(0);
+    const writeSlice = (slice) => {
+        buffer = (0, uint8array_tools_1.concat)([buffer, slice]);
+    };
+    const writeVarInt = (value) => {
+        const { buffer: encoded } = (0, varuint_bitcoin_1.encode)(value);
+        writeSlice(encoded);
+    };
+    const writeVarSlice = (slice) => {
+        writeVarInt(slice.length);
+        writeSlice(slice);
+    };
+    writeVarInt(witness.length);
+    witness.forEach(writeVarSlice);
+    return buffer;
+}
+function isTaprootInput(input) {
+    return (!!input &&
+        !!(input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length > 0) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length > 0) ||
+            isP2TRScript(input.witnessUtxo?.script)));
 }
-const bip341 = requireBitcoinJsInternal('payments/bip341');
-const bip371 = requireBitcoinJsInternal('psbt/bip371');
-const psbtUtils = requireBitcoinJsInternal('psbt/psbtutils');
-exports.findScriptPath = bip341.findScriptPath;
-exports.tapleafHash = bip341.tapleafHash;
-exports.tapTweakHash = bip341.tapTweakHash;
-exports.toHashTree = bip341.toHashTree;
-exports.tweakKey = bip341.tweakKey;
-exports.witnessStackToScriptWitness = psbtUtils.witnessStackToScriptWitness;
-exports.isTaprootInput = bip371.isTaprootInput;

package/dist/keyExpressions.d.ts

@@ -49,7 +49,7 @@ export declare function parseKeyExpression({ keyExpression, isSegwit, isTaproot,
  *
  * For detailed understanding and examples of terms like `originPath`,
  * `change`, and `keyPath`, refer to the documentation of
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}, which consists
+ * {@link KeyExpressionParser}, which consists
  * of the reverse procedure.
  *
  * @returns {string} - The formed key expression for the Ledger device.
@@ -65,9 +65,9 @@ export declare function keyExpressionLedger({ ledgerManager, originPath, keyPath
  * Constructs a key expression string from its constituent components.
  *
  * This function essentially performs the reverse operation of
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}. For detailed
+ * {@link KeyExpressionParser}. For detailed
  * explanations and examples of the terms used here, refer to
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
+ * {@link KeyExpressionParser}.
  */
 export declare function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic }: {
     masterNode: BIP32Interface;

package/dist/keyExpressions.js

@@ -211,7 +211,6 @@ function assertChangeIndexKeyPath({ change, index, keyPath }) {
     if ((change !== undefined) === (keyPath !== undefined))
         throw new Error(`Error: Pass either change and index or a keyPath`);
 }
-/** @hidden */
 async function keyExpressionLedger({ ledgerManager, originPath, keyPath, change, index }) {
     assertChangeIndexKeyPath({ change, index, keyPath });
     const masterFingerprint = await (0, ledger_1.getLedgerMasterFingerPrint)({
@@ -229,9 +228,9 @@ async function keyExpressionLedger({ ledgerManager, originPath, keyPath, change,
  * Constructs a key expression string from its constituent components.
  *
  * This function essentially performs the reverse operation of
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}. For detailed
+ * {@link KeyExpressionParser}. For detailed
  * explanations and examples of the terms used here, refer to
- * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
+ * {@link KeyExpressionParser}.
  */
 function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic = true }) {
     assertChangeIndexKeyPath({ change, index, keyPath });

package/dist/stackResourceLimits.d.ts

@@ -0,0 +1,17 @@
+export declare const MAX_STACK_SIZE = 1000;
+export declare const MAX_SCRIPT_ELEMENT_SIZE = 520;
+export declare function assertConsensusStackResourceLimits({ stackItems, stackLabel, stackItemLabel }: {
+    stackItems: Uint8Array[];
+    stackLabel?: string;
+    stackItemLabel?: string;
+}): void;
+export declare function assertStandardPolicyStackItemCountLimit({ stackItems, maxStackItems, stackLabel }: {
+    stackItems: Uint8Array[];
+    maxStackItems: number;
+    stackLabel: string;
+}): void;
+export declare function assertStandardPolicyStackItemSizeLimit({ stackItems, maxStackItemSize, stackItemLabel }: {
+    stackItems: Uint8Array[];
+    maxStackItemSize: number;
+    stackItemLabel: string;
+}): void;

package/dist/stackResourceLimits.js

@@ -0,0 +1,35 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SCRIPT_ELEMENT_SIZE = exports.MAX_STACK_SIZE = void 0;
+exports.assertConsensusStackResourceLimits = assertConsensusStackResourceLimits;
+exports.assertStandardPolicyStackItemCountLimit = assertStandardPolicyStackItemCountLimit;
+exports.assertStandardPolicyStackItemSizeLimit = assertStandardPolicyStackItemSizeLimit;
+// See Sipa's Miniscript "Resource limitations":
+// https://bitcoin.sipa.be/miniscript/
+// and Bitcoin Core policy/consensus constants.
+// Consensus: max number of elements in initial stack (and stack+altstack after
+// each opcode execution).
+exports.MAX_STACK_SIZE = 1000;
+// Consensus: max size for any pushed stack element. This is an element limit,
+// not a full script-size limit.
+exports.MAX_SCRIPT_ELEMENT_SIZE = 520;
+function assertConsensusStackResourceLimits({ stackItems, stackLabel = 'stack', stackItemLabel = 'stack item' }) {
+    if (stackItems.length > exports.MAX_STACK_SIZE)
+        throw new Error(`Error: ${stackLabel} has too many items, ${stackItems.length} is larger than ${exports.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 assertStandardPolicyStackItemCountLimit({ stackItems, maxStackItems, stackLabel }) {
+    if (stackItems.length > maxStackItems)
+        throw new Error(`Error: ${stackLabel} has too many items, ${stackItems.length} is larger than ${maxStackItems}`);
+}
+function assertStandardPolicyStackItemSizeLimit({ stackItems, maxStackItemSize, stackItemLabel }) {
+    for (const stackItem of stackItems) {
+        if (stackItem.length > maxStackItemSize)
+            throw new Error(`Error: ${stackItemLabel} exceeds standard policy, ${stackItem.length} bytes is larger than ${maxStackItemSize} bytes`);
+    }
+}

package/dist/tapMiniscript.d.ts

@@ -2,9 +2,13 @@ import { Network } from 'bitcoinjs-lib';
 import type { BIP32API } from 'bip32';
 import type { ECPairAPI } from 'ecpair';
 import type { PartialSig, TapBip32Derivation } from 'bip174';
-import type { Taptree } from 'bitcoinjs-lib/src/cjs/types';
 import type { ExpansionMap, KeyInfo, Preimage, TimeConstraints } from './types';
 import type { TapLeafInfo, TapTreeInfoNode, TapTreeNode } from './tapTree';
+type BitcoinJsTapleaf = {
+    output: Uint8Array;
+    version?: number;
+};
+type Taptree = [Taptree | BitcoinJsTapleaf, Taptree | BitcoinJsTapleaf] | BitcoinJsTapleaf;
 export type TapLeafExpansionOverride = {
     expandedExpression: string;
     expansionMap: ExpansionMap;
@@ -102,7 +106,7 @@ export declare function tapTreeInfoToScriptTree(tapTreeInfo: TapTreeInfoNode): T
  * - Leaves are returned in deterministic left-first order.
  * - One metadata entry is returned per leaf.
  * - `controlBlock.length === 33 + 32 * depth`.
- * - Throws if internal key is invalid or merkle path cannot be found.
+ * - Throws if internal key is invalid or control block cannot be derived.
  *
  * Typical usage:
  * - Convert this metadata into PSBT `tapLeafScript[]` entries
@@ -213,3 +217,4 @@ export declare function satisfyTapTree({ tapTreeInfo, signatures, preimages, tap
     tapLeaf?: Uint8Array | string;
     timeConstraints?: TimeConstraints;
 }): TaprootLeafSatisfaction;
+export {};

package/dist/tapMiniscript.js

@@ -19,6 +19,7 @@ const miniscript_1 = require("./miniscript");
 const tapTree_1 = require("./tapTree");
 const resourceLimits_1 = require("./resourceLimits");
 const TAPROOT_LEAF_VERSION_TAPSCRIPT = 0xc0;
+const { p2tr } = bitcoinjs_lib_1.payments;
 function expandTaprootMiniscript({ miniscript, network = bitcoinjs_lib_1.networks.bitcoin, BIP32, ECPair }) {
     return (0, miniscript_1.expandMiniscript)({
         miniscript,
@@ -173,7 +174,7 @@ function tapTreeInfoToScriptTree(tapTreeInfo) {
  * - Leaves are returned in deterministic left-first order.
  * - One metadata entry is returned per leaf.
  * - `controlBlock.length === 33 + 32 * depth`.
- * - Throws if internal key is invalid or merkle path cannot be found.
+ * - Throws if internal key is invalid or control block cannot be derived.
  *
  * Typical usage:
  * - Convert this metadata into PSBT `tapLeafScript[]` entries
@@ -182,10 +183,6 @@ function tapTreeInfoToScriptTree(tapTreeInfo) {
 function buildTaprootLeafPsbtMetadata({ tapTreeInfo, internalPubkey }) {
     const normalizedInternalPubkey = normalizeTaprootPubkey(internalPubkey);
     const scriptTree = tapTreeInfoToScriptTree(tapTreeInfo);
-    const hashTree = (0, bitcoinjs_lib_internals_1.toHashTree)(scriptTree);
-    const tweaked = (0, bitcoinjs_lib_internals_1.tweakKey)(normalizedInternalPubkey, hashTree.hash);
-    if (!tweaked)
-        throw new Error(`Error: invalid taproot internal pubkey`);
     return (0, tapTree_1.collectTapTreeLeaves)(tapTreeInfo).map(({ leaf, depth }) => {
         if (depth > tapTree_1.MAX_TAPTREE_DEPTH)
             throw new Error(`Error: taproot tree depth is too large, ${depth} is larger than ${tapTree_1.MAX_TAPTREE_DEPTH}`);
@@ -193,19 +190,17 @@ function buildTaprootLeafPsbtMetadata({ tapTreeInfo, internalPubkey }) {
             output: leaf.tapScript,
             version: leaf.version
         });
-        const merklePath = (0, bitcoinjs_lib_internals_1.findScriptPath)(hashTree, tapLeafHash);
-        if (!merklePath)
+        const payment = p2tr({
+            internalPubkey: normalizedInternalPubkey,
+            scriptTree,
+            redeem: {
+                output: leaf.tapScript,
+                redeemVersion: leaf.version
+            }
+        });
+        const controlBlock = payment.witness?.[1];
+        if (!controlBlock)
             throw new Error(`Error: could not build controlBlock for taproot leaf ${leaf.expression}`);
-        // controlBlock[0] packs:
-        // - leaf version (high bits), and
-        // - parity of the tweaked output key Q = P + t*G (low bit).
-        // `normalizedInternalPubkey` is x-only P, so parity is not encoded there.
-        // BIP341 requires carrying Q parity in controlBlock[0].
-        const controlBlock = (0, uint8array_tools_1.concat)([
-            Uint8Array.from([leaf.version | tweaked.parity]),
-            normalizedInternalPubkey,
-            ...merklePath
-        ]);
         return { leaf, depth, tapLeafHash, controlBlock };
     });
 }

package/dist/tapTree.js

@@ -5,7 +5,6 @@ exports.assertTapTreeDepth = assertTapTreeDepth;
 exports.collectTapTreeLeaves = collectTapTreeLeaves;
 exports.selectTapLeafCandidates = selectTapLeafCandidates;
 exports.parseTapTreeExpression = parseTapTreeExpression;
-// NOTE: This uses an internal bitcoinjs-lib module. Consider adding a local wrapper.
 const bitcoinjs_lib_internals_1 = require("./bitcoinjs-lib-internals");
 const uint8array_tools_1 = require("uint8array-tools");
 const parseUtils_1 = require("./parseUtils");

package/dist/types.d.ts

@@ -4,7 +4,7 @@ import type { Payment, Network } from 'bitcoinjs-lib';
 import type { TapTreeNode, TapTreeInfoNode } from './tapTree';
 /**
  * Preimage
- * See {@link Output}
+ * Preimage material used by descriptor outputs that include hashlocks.
  */
 export type Preimage = {
     /**
@@ -25,7 +25,7 @@ export type TimeConstraints = {
     nSequence: number | undefined;
 };
 /**
- * See {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
+ * See {@link KeyExpressionParser}.
  */
 export type KeyInfo = {
     keyExpression: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bitcoinerlab/descriptors",
   "description": "This library parses and creates Bitcoin Miniscript Descriptors and generates Partially Signed Bitcoin Transactions (PSBTs). It provides PSBT finalizers and signers for single-signature, BIP32 and Hardware Wallets.",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "3.0.5",
+  "version": "3.0.6",
   "author": "Jose-Luis Landabaso",
   "license": "MIT",
   "repository": {