@bitcoinerlab/descriptors-core 3.1.0

package/dist/bitcoinjs-lib-internals.js

@@ -0,0 +1,60 @@
+"use strict";
+/*
+ * 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.tapleafHash = tapleafHash;
+exports.tapTweakHash = tapTweakHash;
+exports.witnessStackToScriptWitness = witnessStackToScriptWitness;
+exports.isTaprootInput = isTaprootInput;
+const varuint_bitcoin_1 = require("varuint-bitcoin");
+const uint8array_tools_1 = require("uint8array-tools");
+const crypto_1 = require("./crypto");
+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 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 (0, crypto_1.taggedHash)('TapLeaf', (0, uint8array_tools_1.concat)([Uint8Array.from([version]), serializeScript(leaf.output)]));
+}
+function tapTweakHash(pubKey, h) {
+    return (0, crypto_1.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)));
+}

package/dist/bitcoinjs.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Separate entry point for the bitcoinjs-lib adapter.
+ *
+ * Usage:
+ *   import { createBitcoinjsLib } from '@bitcoinerlab/descriptors/bitcoinjs';
+ *   import { DescriptorsFactory } from '@bitcoinerlab/descriptors';
+ *   import * as ecc from '@bitcoinerlab/secp256k1';
+ *
+ *   const lib = createBitcoinjsLib(ecc);
+ *   const { Output } = DescriptorsFactory(lib);
+ */
+export { createBitcoinjsLib } from './adapters/bitcoinjs';

package/dist/bitcoinjs.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBitcoinjsLib = void 0;
+/**
+ * Separate entry point for the bitcoinjs-lib adapter.
+ *
+ * Usage:
+ *   import { createBitcoinjsLib } from '@bitcoinerlab/descriptors/bitcoinjs';
+ *   import { DescriptorsFactory } from '@bitcoinerlab/descriptors';
+ *   import * as ecc from '@bitcoinerlab/secp256k1';
+ *
+ *   const lib = createBitcoinjsLib(ecc);
+ *   const { Output } = DescriptorsFactory(lib);
+ */
+var bitcoinjs_1 = require("./adapters/bitcoinjs");
+Object.defineProperty(exports, "createBitcoinjsLib", { enumerable: true, get: function () { return bitcoinjs_1.createBitcoinjsLib; } });

package/dist/checksum.d.ts

@@ -0,0 +1,6 @@
+export declare const CHECKSUM_CHARSET: string;
+/**
+ * Implements the Bitcoin descriptor's checksum algorithm described in
+ * {@link https://github.com/bitcoin/bitcoin/blob/master/src/script/descriptor.cpp}
+ */
+export declare const DescriptorChecksum: (span: string) => string;

package/dist/checksum.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptorChecksum = exports.CHECKSUM_CHARSET = void 0;
+// Converted to Javascript by Jose-Luis Landabaso, 2023 - https://bitcoinerlab.com
+// Source: https://github.com/bitcoin/bitcoin/blob/master/src/script/descriptor.cpp
+// Distributed under the MIT software license
+const PolyMod = (c, val) => {
+    const c0 = c >> 35n;
+    c = ((c & 0x7ffffffffn) << 5n) ^ val;
+    if (c0 & 1n)
+        c ^= 0xf5dee51989n;
+    if (c0 & 2n)
+        c ^= 0xa9fdca3312n;
+    if (c0 & 4n)
+        c ^= 0x1bab10e32dn;
+    if (c0 & 8n)
+        c ^= 0x3706b1677an;
+    if (c0 & 16n)
+        c ^= 0x644d626ffdn;
+    return c;
+};
+exports.CHECKSUM_CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+/**
+ * Implements the Bitcoin descriptor's checksum algorithm described in
+ * {@link https://github.com/bitcoin/bitcoin/blob/master/src/script/descriptor.cpp}
+ */
+const DescriptorChecksum = (span) => {
+    const INPUT_CHARSET = '0123456789()[],\'/*abcdefgh@:$%{}IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~ijklmnopqrstuvwxyzABCDEFGH`#"\\ ';
+    let c = 1n;
+    let cls = 0n;
+    let clscount = 0n;
+    for (const ch of span) {
+        const pos = BigInt(INPUT_CHARSET.indexOf(ch));
+        if (pos === -1n)
+            return '';
+        c = PolyMod(c, pos & 31n);
+        cls = cls * 3n + (pos >> 5n);
+        if (++clscount === 3n) {
+            c = PolyMod(c, cls);
+            cls = 0n;
+            clscount = 0n;
+        }
+    }
+    if (clscount > 0n)
+        c = PolyMod(c, cls);
+    for (let j = 0; j < 8; ++j)
+        c = PolyMod(c, 0n);
+    c ^= 1n;
+    let ret = '';
+    for (let j = 0; j < 8; ++j) {
+        const index = (c >> (5n * (7n - BigInt(j)))) & 31n;
+        if (index < 0 || index > Number.MAX_SAFE_INTEGER)
+            throw new Error(`Error: could not compute checksum, invalid index ${index}`);
+        ret += exports.CHECKSUM_CHARSET[Number(index)];
+    }
+    return ret;
+};
+exports.DescriptorChecksum = DescriptorChecksum;

package/dist/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function sha256(data: Uint8Array): Uint8Array;
+export declare function hash160(data: Uint8Array): Uint8Array;
+export declare function taggedHash(tag: string, data: Uint8Array): Uint8Array;

package/dist/crypto.js

@@ -0,0 +1,79 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+// https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/crypto.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.hash160 = hash160;
+exports.taggedHash = taggedHash;
+const legacy_js_1 = require("@noble/hashes/legacy.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const uint8array_tools_1 = require("uint8array-tools");
+const TAGGED_HASH_PREFIXES = {
+    'BIP0340/challenge': Uint8Array.from([
+        123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130,
+        210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124,
+        123, 181, 45, 122, 159, 239, 88, 50, 62, 177, 191, 122, 64, 125, 179, 130,
+        210, 243, 242, 216, 27, 177, 34, 79, 73, 254, 81, 143, 109, 72, 211, 124
+    ]),
+    'BIP0340/aux': Uint8Array.from([
+        241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160,
+        105, 38, 88, 57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144,
+        241, 239, 78, 94, 192, 99, 202, 218, 109, 148, 202, 250, 157, 152, 126, 160,
+        105, 38, 88, 57, 236, 193, 31, 151, 45, 119, 165, 46, 216, 193, 204, 144
+    ]),
+    'BIP0340/nonce': Uint8Array.from([
+        7, 73, 119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244,
+        52, 215, 62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47, 7, 73,
+        119, 52, 167, 155, 203, 53, 91, 155, 140, 125, 3, 79, 18, 28, 244, 52, 215,
+        62, 247, 45, 218, 25, 135, 0, 97, 251, 82, 191, 235, 47
+    ]),
+    TapLeaf: Uint8Array.from([
+        174, 234, 143, 220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211,
+        95, 28, 181, 64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238, 174, 234, 143,
+        220, 66, 8, 152, 49, 5, 115, 75, 88, 8, 29, 30, 38, 56, 211, 95, 28, 181,
+        64, 8, 212, 211, 87, 202, 3, 190, 120, 233, 238
+    ]),
+    TapBranch: Uint8Array.from([
+        25, 65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247,
+        33, 111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21, 25,
+        65, 161, 242, 229, 110, 185, 95, 162, 169, 241, 148, 190, 92, 1, 247, 33,
+        111, 51, 237, 130, 176, 145, 70, 52, 144, 208, 91, 245, 22, 160, 21
+    ]),
+    TapSighash: Uint8Array.from([
+        244, 10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61,
+        149, 253, 102, 163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49, 244,
+        10, 72, 223, 75, 42, 112, 200, 180, 146, 75, 242, 101, 70, 97, 237, 61, 149,
+        253, 102, 163, 19, 235, 135, 35, 117, 151, 198, 40, 228, 160, 49
+    ]),
+    TapTweak: Uint8Array.from([
+        232, 15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66,
+        156, 188, 235, 21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233, 232,
+        15, 225, 99, 156, 156, 160, 80, 227, 175, 27, 57, 193, 67, 198, 62, 66, 156,
+        188, 235, 21, 217, 64, 251, 181, 197, 161, 244, 175, 87, 197, 233
+    ]),
+    'KeyAgg list': Uint8Array.from([
+        72, 28, 151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126,
+        215, 49, 156, 89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240, 72, 28,
+        151, 28, 60, 11, 70, 215, 240, 178, 117, 174, 89, 141, 78, 44, 126, 215, 49,
+        156, 89, 74, 92, 110, 199, 158, 160, 212, 153, 2, 148, 240
+    ]),
+    'KeyAgg coefficient': Uint8Array.from([
+        191, 201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100,
+        130, 78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129, 191,
+        201, 4, 3, 77, 28, 136, 232, 200, 14, 34, 229, 61, 36, 86, 109, 100, 130,
+        78, 214, 66, 114, 129, 192, 145, 0, 249, 77, 205, 82, 201, 129
+    ])
+};
+function sha256(data) {
+    return (0, sha2_js_1.sha256)(data);
+}
+function hash160(data) {
+    return (0, legacy_js_1.ripemd160)(sha256(data));
+}
+function taggedHash(tag, data) {
+    const prefix = TAGGED_HASH_PREFIXES[tag];
+    if (!prefix)
+        throw new Error(`Error: unsupported tagged hash prefix ${tag}`);
+    return sha256((0, uint8array_tools_1.concat)([prefix, data]));
+}