@bitcoinerlab/descriptors 3.0.6 → 3.1.1

package/dist/tapTree.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_TAPTREE_DEPTH = void 0;
-exports.assertTapTreeDepth = assertTapTreeDepth;
-exports.collectTapTreeLeaves = collectTapTreeLeaves;
-exports.selectTapLeafCandidates = selectTapLeafCandidates;
-exports.parseTapTreeExpression = parseTapTreeExpression;
-const bitcoinjs_lib_internals_1 = require("./bitcoinjs-lib-internals");
-const uint8array_tools_1 = require("uint8array-tools");
-const parseUtils_1 = require("./parseUtils");
-// See BIP341 control block limits and Sipa's Miniscript "Resource limitations":
-// https://bitcoin.sipa.be/miniscript/
-// Taproot script path depth is encoded in the control block as 32-byte hashes,
-// with consensus max depth 128.
-exports.MAX_TAPTREE_DEPTH = 128;
-function tapTreeMaxDepth(tapTree, depth = 0) {
-    if ('expression' in tapTree)
-        return depth;
-    return Math.max(tapTreeMaxDepth(tapTree.left, depth + 1), tapTreeMaxDepth(tapTree.right, depth + 1));
-}
-function assertTapTreeDepth(tapTree) {
-    const maxDepth = tapTreeMaxDepth(tapTree);
-    if (maxDepth > exports.MAX_TAPTREE_DEPTH)
-        throw new Error(`Error: taproot tree depth is too large, ${maxDepth} is larger than ${exports.MAX_TAPTREE_DEPTH}`);
-}
-/**
- * Collects taproot leaf metadata with depth from a tree.
- * Traversal is left-first, following the order of `{left,right}` in the
- * expression so tie-breaks are deterministic.
- *
- * Example tree:
- * ```
- * {pk(A),{pk(B),pk(C)}}
- * ```
- * Visual shape:
- * ```
- *         root
- *        /    \
- *     pk(A)  branch
- *            /   \
- *         pk(B) pk(C)
- * ```
- * Collected leaves with depth:
- * ```
- * [
- *   { leaf: pk(A), depth: 1 },
- *   { leaf: pk(B), depth: 2 },
- *   { leaf: pk(C), depth: 2 }
- * ]
- * ```
- */
-function collectTapTreeLeaves(tapTreeInfo) {
-    const leaves = [];
-    const walk = (node, depth) => {
-        if ('expression' in node) {
-            leaves.push({ leaf: node, depth });
-            return;
-        }
-        walk(node.left, depth + 1);
-        walk(node.right, depth + 1);
-    };
-    walk(tapTreeInfo, 0);
-    return leaves;
-}
-function computeTapLeafHash(leaf) {
-    return (0, bitcoinjs_lib_internals_1.tapleafHash)({ output: leaf.tapScript, version: leaf.version });
-}
-function normalizeExpressionForMatch(expression) {
-    return expression.replace(/\s+/g, '');
-}
-/**
- * Resolves taproot leaf candidates based on an optional selector.
- *
- * If `tapLeaf` is undefined, all leaves are returned for auto-selection.
- * If `tapLeaf` is bytes, it is treated as a tapleaf hash and must match
- * exactly one leaf.
- * If `tapLeaf` is a string, it is treated as a raw taproot leaf expression
- * (not expanded). Matching is whitespace-insensitive. If the expression appears
- * more than once, this function throws an error.
- *
- * Example:
- * ```
- * const candidates = selectTapLeafCandidates({ tapTreeInfo, tapLeaf });
- * // tapLeaf can be undefined, bytes (tapleaf hash) or a leaf expression:
- * // f.ex.: 'pk(03bb...)'
- * ```
- */
-function selectTapLeafCandidates({ tapTreeInfo, tapLeaf }) {
-    const leaves = collectTapTreeLeaves(tapTreeInfo).map(({ leaf, depth }) => ({
-        leaf,
-        depth,
-        tapLeafHash: computeTapLeafHash(leaf)
-    }));
-    if (tapLeaf === undefined)
-        return leaves;
-    if (tapLeaf instanceof Uint8Array) {
-        const match = leaves.find(entry => (0, uint8array_tools_1.compare)(entry.tapLeafHash, tapLeaf) === 0);
-        if (!match)
-            throw new Error(`Error: tapleaf hash not found in tapTreeInfo`);
-        return [match];
-    }
-    const normalizedSelector = normalizeExpressionForMatch(tapLeaf);
-    const matches = leaves.filter(entry => normalizeExpressionForMatch(entry.leaf.expression) === normalizedSelector);
-    if (matches.length === 0)
-        throw new Error(`Error: taproot leaf expression not found in tapTreeInfo: ${tapLeaf}`);
-    if (matches.length > 1)
-        throw new Error(`Error: taproot leaf expression is ambiguous in tapTreeInfo: ${tapLeaf}`);
-    return matches;
-}
-function tapTreeError(expression) {
-    return new Error(`Error: invalid taproot tree expression: ${expression}`);
-}
-/**
- * Splits the inner tree expression of a branch into left/right parts.
- * The input must be the contents inside `{}` (no outer braces).
- * Example: `pk(@0),{pk(@1),pk(@2)}` => left: `pk(@0)`, right: `{pk(@1),pk(@2)}`.
- */
-function splitTapTreeExpression(expression) {
-    const result = (0, parseUtils_1.splitTopLevelComma)({ expression, onError: tapTreeError });
-    if (!result)
-        throw tapTreeError(expression);
-    return result;
-}
-/**
- * Parses a single taproot tree node expression.
- *
- * Note: the field name is intentionally generic (`expression`) because taproot
- * leaves can contain either miniscript fragments (e.g. `pk(...)`) or
- * descriptor-level script expressions (e.g. `sortedmulti_a(...)`).
- * Examples:
- * - `pk(@0)` => { expression: 'pk(@0)' }
- * - `{pk(@0),pk(@1)}` => { left: { expression: 'pk(@0)' }, right: { expression: 'pk(@1)' } }
- * - `{pk(@0),{pk(@1),pk(@2)}}` =>
- *   {
- *     left: { expression: 'pk(@0)' },
- *     right: { left: { expression: 'pk(@1)' }, right: { expression: 'pk(@2)' } }
- *   }
- */
-function parseTapTreeNode(expression) {
-    const trimmedExpression = expression.trim();
-    if (!trimmedExpression)
-        throw tapTreeError(expression);
-    if (trimmedExpression.startsWith('{')) {
-        if (!trimmedExpression.endsWith('}'))
-            throw tapTreeError(expression);
-        const inner = trimmedExpression.slice(1, -1).trim();
-        if (!inner)
-            throw tapTreeError(expression);
-        const { left, right } = splitTapTreeExpression(inner);
-        return {
-            left: parseTapTreeNode(left),
-            right: parseTapTreeNode(right)
-        };
-    }
-    if (trimmedExpression.includes('{') || trimmedExpression.includes('}'))
-        throw tapTreeError(expression);
-    return { expression: trimmedExpression };
-}
-function parseTapTreeExpression(expression) {
-    const trimmed = expression.trim();
-    if (!trimmed)
-        throw tapTreeError(expression);
-    const tapTree = parseTapTreeNode(trimmed);
-    assertTapTreeDepth(tapTree);
-    return tapTree;
-}

package/dist/types.d.ts

@@ -1,238 +0,0 @@
-import type { ECPairInterface } from 'ecpair';
-import type { BIP32Interface } from 'bip32';
-import type { Payment, Network } from 'bitcoinjs-lib';
-import type { TapTreeNode, TapTreeInfoNode } from './tapTree';
-/**
- * Preimage
- * Preimage material used by descriptor outputs that include hashlocks.
- */
-export type Preimage = {
-    /**
-     * Use same string expressions as in miniscript. For example: "sha256(cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204)" or "ripemd160(095ff41131e5946f3c85f79e44adbcf8e27e080e)"
-     *
-     * Accepted functions: sha256, hash256, ripemd160, hash160
-     *
-     * Digests must be: 64-character HEX for sha256, hash160 or 30-character HEX for ripemd160 or hash160.
-     */
-    digest: string;
-    /**
-     * Hex encoded preimage. Preimages are always 32 bytes (so, 64 character in hex).
-     */
-    preimage: string;
-};
-export type TimeConstraints = {
-    nLockTime: number | undefined;
-    nSequence: number | undefined;
-};
-/**
- * See {@link KeyExpressionParser}.
- */
-export type KeyInfo = {
-    keyExpression: string;
-    pubkey?: Uint8Array;
-    ecpair?: ECPairInterface;
-    bip32?: BIP32Interface;
-    masterFingerprint?: Uint8Array;
-    originPath?: string;
-    keyPath?: string;
-    path?: string;
-};
-/**
- * An `ExpansionMap` contains destructured information of a descritptor expression.
- *
- * For example, this descriptor `sh(wsh(andor(pk(0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2),older(8640),pk([d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*))))` has the following
- * `expandedExpression`: `sh(wsh(andor(pk(@0),older(8640),pk(@1))))`
- *
- * `key`'s are set using this format: `@i`, where `i` is an integer starting from `0` assigned by parsing and retrieving keys from the descriptor from left to right.
- *
- * For the given example, the `ExpansionMap` is:
- *
- * ```javascript
- *  {
- *    '@0': {
- *      keyExpression:
- *      '0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2'
- *    },
- *    '@1': {
- *      keyExpression:
- *        "[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*",
- *      keyPath: '/1/2/3/4/*',
- *      originPath: "/49'/0'/0'",
- *      path: "m/49'/0'/0'/1/2/3/4/*",
- *      // Other relevant properties of the type `KeyInfo`: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
- *    }
- *  }
- *```
- *
- *
- */
-export type ExpansionMap = {
-    [key: string]: KeyInfo;
-};
-/** @ignore */
-interface XOnlyPointAddTweakResult {
-    parity: 1 | 0;
-    xOnlyPubkey: Uint8Array;
-}
-/** @ignore */
-export interface TinySecp256k1Interface {
-    isPoint(p: Uint8Array): boolean;
-    pointCompress(p: Uint8Array, compressed?: boolean): Uint8Array;
-    isPrivate(d: Uint8Array): boolean;
-    pointFromScalar(d: Uint8Array, compressed?: boolean): Uint8Array | null;
-    pointAddScalar(p: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array | null;
-    privateAdd(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;
-    sign(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
-    signSchnorr?(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
-    verify(h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean;
-    verifySchnorr?(h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean;
-    xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
-    isXOnlyPoint(p: Uint8Array): boolean;
-    privateNegate(d: Uint8Array): Uint8Array;
-}
-/**
- * `DescriptorsFactory` creates and returns the {@link DescriptorsFactory | `expand()`}
- * function that parses a descriptor expression and destructures it
- * into its elemental parts. `Expansion` is the type that `expand()` returns.
- */
-export type Expansion = {
-    /**
-     * The corresponding [bitcoinjs-lib Payment](https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/payments/index.ts) for the provided expression, if applicable.
-     */
-    payment?: Payment;
-    /**
-     * The expanded descriptor expression.
-     * See {@link ExpansionMap ExpansionMap} for a detailed explanation.
-     */
-    expandedExpression?: string;
-    /**
-     * The extracted miniscript from the expression, if any.
-     */
-    miniscript?: string;
-    /**
-     * A map of key expressions in the descriptor to their corresponding expanded keys.
-     * See {@link ExpansionMap ExpansionMap} for a detailed explanation.
-     */
-    expansionMap?: ExpansionMap;
-    /**
-     * A boolean indicating whether the descriptor uses SegWit.
-     */
-    isSegwit?: boolean;
-    /**
-     * A boolean indicating whether the descriptor uses Taproot.
-     */
-    isTaproot?: boolean;
-    /**
-     * The expanded miniscript, if any.
-     * It corresponds to the `expandedExpression` without the top-level script
-     * expression.
-     */
-    expandedMiniscript?: string;
-    /**
-     * The taproot tree expression, if any. Only defined for `tr(KEY, TREE)`.
-     * Example: `{pk(02aa...),{pk(03bb...),pk(02cc...)}}`.
-     */
-    tapTreeExpression?: string;
-    /**
-     * The parsed taproot tree, if any. Only defined for `tr(KEY, TREE)`.
-     * Example:
-     * ```
-     * {
-     *   left: { expression: 'pk(02aa...)' },
-     *   right: {
-     *     left: { expression: 'pk(03bb...)' },
-     *     right: { expression: 'pk(02cc...)' }
-     *   }
-     * }
-     * ```
-     */
-    tapTree?: TapTreeNode;
-    /**
-     * The compiled taproot tree metadata, if any. Only defined for `tr(KEY, TREE)`.
-     * Same as tapTree, but each leaf includes:
-     * - `expandedExpression`: descriptor-level expanded leaf expression
-     * - optional `expandedMiniscript`: miniscript-expanded leaf (when applicable)
-     * - key expansion map
-     * - compiled tapscript (`tapScript`)
-     * - leaf version.
-     *
-     * Note: `@i` placeholders are scoped per leaf, since each leaf is expanded
-     * and satisfied independently.
-     *
-     * Example:
-     * ```
-     * {
-     *   left: {
-     *     expression: 'pk(02aa...)',
-     *     expandedExpression: 'pk(@0)',
-     *     expandedMiniscript: 'pk(@0)',
-     *     expansionMap: ExpansionMap;
-     *     tapScript: Uint8Array;
-     *     version: number;
-     *   },
-     *   right: ....
-     */
-    tapTreeInfo?: TapTreeInfoNode;
-    /**
-     * The redeem script for the descriptor, if applicable.
-     */
-    redeemScript?: Uint8Array;
-    /**
-     * The witness script for the descriptor, if applicable.
-     */
-    witnessScript?: Uint8Array;
-    /**
-     * Whether the descriptor is a ranged-descriptor.
-     */
-    isRanged: boolean;
-    /**
-     * This is the preferred or authoritative representation of an output
-     * descriptor expression.
-     * It removes the checksum and, if it is a ranged-descriptor, it
-     * particularizes it to its index.
-     */
-    canonicalExpression: string;
-};
-/**
- * The {@link DescriptorsFactory | `DescriptorsFactory`} function creates and
- * returns the `parseKeyExpression` function, which is an implementation of this
- * interface.
- *
- * It parses and destructures a key expression string (xpub, xprv, pubkey or
- * wif) into {@link KeyInfo | `KeyInfo`}.
- *
- * For example, given this `keyExpression`: `[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*`, this is the parsed result:
- *
- * ```javascript
- *  {
- *    keyExpression:
- *      "[d34db33f/49'/0'/0']tpubDCdxmvzJ5QBjTN8oCjjyT2V58AyZvA1fkmCeZRC75QMoaHcVP2m45Bv3hmnR7ttAwkb2UNYyoXdHVt4gwBqRrJqLUU2JrM43HippxiWpHra/1/2/3/4/*",
- *    keyPath: '/1/2/3/4/*',
- *    originPath: "/49'/0'/0'",
- *    path: "m/49'/0'/0'/1/2/3/4/*",
- *    // Other relevant properties of the type `KeyInfo`: `pubkey`, `ecpair` & `bip32` interfaces, `masterFingerprint`, etc.
- *  }
- * ```
- *
- * See {@link KeyInfo} for the complete list of elements retrieved by this function.
- */
-export interface KeyExpressionParser {
-    (params: {
-        keyExpression: string;
-        /**
-         * Indicates if this key expression belongs to a a SegWit output. When set,
-         * further checks are done to ensure the public key (if present in the
-         * expression) is compressed (33 bytes).
-         */
-        isSegwit?: boolean;
-        /**
-         * Indicates if this key expression belongs to a Taproot output.
-         * For Taproot, the key must be represented as an x-only public key
-         * (32 bytes). If a 33-byte compressed pubkey is derived, it is converted to
-         * its x-only representation.
-         */
-        isTaproot?: boolean;
-        network?: Network;
-    }): KeyInfo;
-}
-export {};

package/dist/types.js

@@ -1,4 +0,0 @@
-"use strict";
-// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
-// Distributed under the MIT software license
-Object.defineProperty(exports, "__esModule", { value: true });