@bitcoinerlab/descriptors-core 3.1.0

package/dist/tapTree.js

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

@@ -0,0 +1,296 @@
+import type { Payment, ECPairInterfaceLike, BIP32InterfaceLike } from './bitcoinLib';
+import type { Network } from './networks';
+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
+     *
+     * Digest hex lengths by function:
+     * - `sha256`, `hash256`: 64 hex chars (32 bytes)
+     * - `ripemd160`, `hash160`: 40 hex chars (20 bytes)
+     */
+    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;
+};
+/**
+ * Parsed key-expression metadata.
+ *
+ * See {@link KeyExpressionParser}.
+ */
+export type KeyInfo = {
+    /** Original key expression string. */
+    keyExpression: string;
+    /**
+     * Concrete public key when derivable.
+     *
+     * This is usually set unless the key expression is ranged (`*`).
+     * For taproot keys this is x-only (32 bytes).
+     */
+    pubkey?: Uint8Array;
+    /**
+     * bitcoinjs-compatible single-key signer (when derivable from the expression).
+     */
+    ecpair?: ECPairInterfaceLike;
+    /**
+     * bitcoinjs-compatible HD node (when derivable from the expression).
+     */
+    bip32?: BIP32InterfaceLike;
+    /** Raw private key bytes, when available. */
+    privkey?: Uint8Array;
+    /** Parsed extended public key, when present in the expression. */
+    xPub?: string;
+    /** Parsed extended private key, when present in the expression. */
+    xPrv?: string;
+    /** BIP32 master fingerprint, when available. */
+    masterFingerprint?: Uint8Array;
+    /** Path from `masterFingerprint` to the xpub/xprv root. */
+    originPath?: string;
+    /** Path from the xpub/xprv root. */
+    keyPath?: string;
+    /**
+     * Full path from the master.
+     *
+     * Format: `m/val/val/...`, where `val` is an integer and hardened elements
+     * use `'`.
+     */
+    path?: string;
+};
+/**
+ * An `ExpansionMap` contains destructured information of a descriptor 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 `KeyInfo`: `pubkey`, `ecpair`, `bip32`,
+ *      // `privkey`, `xPub`, `xPrv`, `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;
+    /**
+     * Parsed taproot leaf tree for `tr(KEY, TREE)`, if any.
+     *
+     * Shape:
+     * - Branch nodes: `{ left, right }`
+     * - Leaf nodes: `{ expression: string }`
+     *
+     * Example:
+     * ```ts
+     * {
+     *   left: { expression: 'pk(02aa...)' },
+     *   right: {
+     *     left: { expression: 'and_v(v:pk(03bb...),older(12960))' },
+     *     right: { expression: 'pk(02cc...)' }
+     *   }
+     * }
+     * ```
+     */
+    tapTree?: TapTreeNode;
+    /**
+     * Compiled taproot leaf metadata tree for `tr(KEY, TREE)`, if any.
+     *
+     * Same branch/leaf tree shape as `tapTree`, but each leaf is enriched with:
+     * - `expandedExpression`: descriptor-level expanded leaf expression
+     * - optional `expandedMiniscript`: miniscript-expanded leaf
+     * - `expansionMap`: resolved keys for that leaf (`@0`, `@1`, ...)
+     * - `tapScript`: compiled tapscript bytes
+     * - `version`: leaf version (typically tapscript `0xc0`)
+     *
+     * Note: `@i` placeholders are scoped per leaf, since each leaf is expanded
+     * and satisfied independently.
+     *
+     * Example:
+     * ```ts
+     * {
+     *   left: {
+     *     expression: 'pk(02aa...)',
+     *     expandedExpression: 'pk(@0)',
+     *     expandedMiniscript: 'pk(@0)',
+     *     expansionMap: {
+     *       '@0': { pubkey: Uint8Array(32), ... }
+     *     },
+     *     tapScript: Uint8Array(...),
+     *     version: 0xc0
+     *   },
+     *   right: {
+     *     left: {
+     *       expression: 'and_v(v:pk(03bb...),older(12960))',
+     *       expandedExpression: 'and_v(v:pk(@0),older(12960))',
+     *       expansionMap: { '@0': { pubkey: Uint8Array(32), ... } },
+     *       tapScript: Uint8Array(...),
+     *       version: 0xc0
+     *     },
+     *     right: {
+     *       expression: 'pk(02cc...)',
+     *       expandedExpression: 'pk(@0)',
+     *       expansionMap: { '@0': { pubkey: Uint8Array(32), ... } },
+     *       tapScript: Uint8Array(...),
+     *       version: 0xc0
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    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 `KeyInfo`: `pubkey`, `ecpair`, `bip32`,
+ *    // `privkey`, `xPub`, `xPrv`, `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

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

package/package.json

@@ -0,0 +1,148 @@
+{
+  "name": "@bitcoinerlab/descriptors-core",
+  "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, with explicit backend wiring for advanced use cases.",
+  "homepage": "https://github.com/bitcoinerlab/descriptors",
+  "version": "3.1.0",
+  "author": "Jose-Luis Landabaso",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bitcoinerlab/descriptors.git"
+  },
+  "keywords": [
+    "bitcoin",
+    "descriptors",
+    "miniscript",
+    "psbt",
+    "bitcoinjs",
+    "scure",
+    "noble"
+  ],
+  "bugs": {
+    "url": "https://github.com/bitcoinerlab/descriptors/issues"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./bitcoinjs": {
+      "types": "./dist/bitcoinjs.d.ts",
+      "default": "./dist/bitcoinjs.js"
+    },
+    "./scure": {
+      "types": "./dist/scure.d.ts",
+      "default": "./dist/scure.js"
+    }
+  },
+  "prettier": "@bitcoinerlab/configs/prettierConfig.json",
+  "eslintConfig": {
+    "extends": "./node_modules/@bitcoinerlab/configs/eslintConfig"
+  },
+  "jest": {
+    "preset": "@bitcoinerlab/configs",
+    "transform": {
+      "^.+node_modules/(?:@noble|@scure|micro-packed)/.+\\.js$": "<rootDir>/jest-esm-transform.cjs"
+    },
+    "transformIgnorePatterns": [
+      "/node_modules/(?!(@noble|@scure|micro-packed)/)"
+    ]
+  },
+  "scripts": {
+    "webdocs": "typedoc --options ./webtypedoc.json && node ./scripts/postprocess-docs.js ./webdocs",
+    "docs": "typedoc --options ./typedoc.json && node ./scripts/postprocess-docs.js ./docs",
+    "build:src": "tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.src.json",
+    "build:fixtures": "node test/tools/generateBitcoinCoreFixtures.js -i test/fixtures/descriptor_tests.cpp | npx prettier --parser typescript > test/fixtures/bitcoinCore.ts",
+    "build:test": "npm run build:fixtures && tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.test.json --resolveJsonModule",
+    "build": "npm run build:src && npm run build:test",
+    "lint": "./node_modules/@bitcoinerlab/configs/scripts/lint.sh",
+    "ensureTester": "./node_modules/@bitcoinerlab/configs/scripts/ensureTester.sh",
+    "test:integration:soft": "npm run ensureTester && node test/integration/standardOutputs.js && echo \"\n\n\" && node test/integration/miniscript.js && echo \"\n\n\" && node test/integration/sortedmulti.js && echo \"\n\n\" && node test/integration/taproot.js && echo \"\n\n\" && node test/integration/scure.js",
+    "test:integration:ledger": "npm run ensureTester && node test/integration/ledgerTaproot.js && echo \"\n\n\" && node test/integration/ledger.js",
+    "test:unit": "jest",
+    "test:unit:scure": "cross-env BITCOIN_LIB=scure jest",
+    "test:scure-adapter": "node test/scureAdapter.js",
+    "test:integration:soft:scure": "cross-env BITCOIN_LIB=scure bash -c 'npm run test:integration:soft'",
+    "test:integration:ledger:scure": "cross-env BITCOIN_LIB=scure bash -c 'npm run ensureTester && node test/integration/ledgerTaproot.js && echo \"\" && echo \"\" && node test/integration/ledger.js'",
+    "test:matrix": "npm run test:unit && npm run test:unit:scure && npm run test:scure-adapter && npm run test:integration:soft && npm run test:integration:soft:scure",
+    "test": "npm run lint && npm run build && npm run test:matrix",
+    "test:ledger": "npm run lint && npm run build && echo \"\n\n\" && npm run test:integration:ledger:scure && echo \"\n\n\" && npm run test:integration:ledger",
+    "publish:all": "npm publish --access public && npm publish --access public --prefix ./packages/descriptors && npm publish --access public --prefix ./packages/descriptors-scure",
+    "prepublishOnly": "npm run test && echo \"\n\n\" && npm run test:integration:ledger:scure && echo \"\n\n\" && npm run test:integration:ledger"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "bitcoinjs-lib": "^7.0.1",
+    "bip32": "^5.0.1",
+    "ecpair": "^3.0.1",
+    "@noble/curves": "^2.0.1",
+    "@scure/base": "^2.0.0",
+    "@scure/bip32": "^2.0.1",
+    "@scure/btc-signer": "^2.0.1",
+    "@ledgerhq/ledger-bitcoin": "^0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@ledgerhq/ledger-bitcoin": {
+      "optional": true
+    },
+    "bitcoinjs-lib": {
+      "optional": true
+    },
+    "bip32": {
+      "optional": true
+    },
+    "ecpair": {
+      "optional": true
+    },
+    "@scure/btc-signer": {
+      "optional": true
+    },
+    "@scure/base": {
+      "optional": true
+    },
+    "@scure/bip32": {
+      "optional": true
+    },
+    "@noble/curves": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "@bitcoinerlab/configs": "^2.0.0",
+    "@bitcoinerlab/miniscript-policies": "^1.0.0",
+    "@bitcoinerlab/secp256k1": "^1.2.0",
+    "@ledgerhq/hw-transport-node-hid": "^6.30.0",
+    "@ledgerhq/ledger-bitcoin": "^0.3.0",
+    "@noble/curves": "^2.0.1",
+    "@scure/base": "^2.0.0",
+    "@scure/bip32": "^2.0.1",
+    "@scure/bip39": "^2.0.1",
+    "@scure/btc-signer": "^2.0.1",
+    "@types/lodash.memoize": "^4.1.9",
+    "babel-jest": "^30.3.0",
+    "bip32": "^5.0.1",
+    "bip39": "^3.0.4",
+    "bip65": "^1.0.3",
+    "bip68": "^1.0.4",
+    "bitcoinjs-lib": "^7.0.1",
+    "cross-env": "^10.1.0",
+    "ecpair": "^3.0.1",
+    "jest": "^30.3.0",
+    "regtest-client": "^0.2.1",
+    "ts-jest": "^29.4.6",
+    "yargs": "^17.7.2"
+  },
+  "dependencies": {
+    "@bitcoinerlab/miniscript": "^2.0.0",
+    "@noble/hashes": "^2.0.1",
+    "lodash.memoize": "^4.1.2",
+    "uint8array-tools": "^0.0.9",
+    "varuint-bitcoin": "^2.0.0"
+  }
+}