@btc-vision/bitcoin 6.3.0

package/src/index.js

@@ -0,0 +1,87 @@
+'use strict';
+var __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              var desc = Object.getOwnPropertyDescriptor(m, k);
+              if (
+                  !desc ||
+                  ('get' in desc
+                      ? !m.__esModule
+                      : desc.writable || desc.configurable)
+              ) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+var __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m)
+            if (
+                p !== 'default' &&
+                !Object.prototype.hasOwnProperty.call(exports, p)
+            )
+                __createBinding(exports, m, p);
+    };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.initEccLib =
+    exports.Transaction =
+    exports.opcodes =
+    exports.Block =
+    exports.script =
+    exports.payments =
+    exports.networks =
+    exports.crypto =
+    exports.address =
+        void 0;
+const address = require('./address');
+exports.address = address;
+const crypto = require('./crypto');
+exports.crypto = crypto;
+const networks = require('./networks');
+exports.networks = networks;
+const payments = require('./payments');
+exports.payments = payments;
+const script = require('./script');
+exports.script = script;
+var block_1 = require('./block');
+Object.defineProperty(exports, 'Block', {
+    enumerable: true,
+    get: function () {
+        return block_1.Block;
+    },
+});
+__exportStar(require('./psbt'), exports);
+/** @hidden */
+var ops_1 = require('./ops');
+Object.defineProperty(exports, 'opcodes', {
+    enumerable: true,
+    get: function () {
+        return ops_1.OPS;
+    },
+});
+var transaction_1 = require('./transaction');
+Object.defineProperty(exports, 'Transaction', {
+    enumerable: true,
+    get: function () {
+        return transaction_1.Transaction;
+    },
+});
+var ecc_lib_1 = require('./ecc_lib');
+Object.defineProperty(exports, 'initEccLib', {
+    enumerable: true,
+    get: function () {
+        return ecc_lib_1.initEccLib;
+    },
+});

package/src/merkle.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/**
+ * Calculates the Merkle root of an array of buffers using a specified digest function.
+ *
+ * @param values - The array of buffers.
+ * @param digestFn - The digest function used to calculate the hash of the concatenated buffers.
+ * @returns The Merkle root as a buffer.
+ * @throws {TypeError} If the values parameter is not an array or the digestFn parameter is not a function.
+ */
+export declare function fastMerkleRoot(values: Buffer[], digestFn: (b: Buffer) => Buffer): Buffer;

package/src/merkle.js

@@ -0,0 +1,30 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.fastMerkleRoot = void 0;
+/**
+ * Calculates the Merkle root of an array of buffers using a specified digest function.
+ *
+ * @param values - The array of buffers.
+ * @param digestFn - The digest function used to calculate the hash of the concatenated buffers.
+ * @returns The Merkle root as a buffer.
+ * @throws {TypeError} If the values parameter is not an array or the digestFn parameter is not a function.
+ */
+function fastMerkleRoot(values, digestFn) {
+    if (!Array.isArray(values)) throw TypeError('Expected values Array');
+    if (typeof digestFn !== 'function')
+        throw TypeError('Expected digest Function');
+    let length = values.length;
+    const results = values.concat();
+    while (length > 1) {
+        let j = 0;
+        for (let i = 0; i < length; i += 2, ++j) {
+            const left = results[i];
+            const right = i + 1 === length ? left : results[i + 1];
+            const data = Buffer.concat([left, right]);
+            results[j] = digestFn(data);
+        }
+        length = j;
+    }
+    return results[0];
+}
+exports.fastMerkleRoot = fastMerkleRoot;

package/src/networks.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents a Bitcoin network configuration，including messagePrefix, bech32, bip32, pubKeyHash, scriptHash, wif.
+ * Support bitcoin、bitcoin testnet and bitcoin regtest.
+ * @packageDocumentation
+ */
+export interface Bip32 {
+    public: number;
+    private: number;
+}
+export interface Network {
+    wif: number;
+    bip32: Bip32;
+    messagePrefix: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+}
+/**
+ * Represents the Bitcoin network configuration.
+ */
+export declare const bitcoin: Network;
+/**
+ * Represents the regtest network configuration.
+ */
+export declare const regtest: Network;
+/**
+ * Represents the testnet network configuration.
+ */
+export declare const testnet: Network;

package/src/networks.js

@@ -0,0 +1,71 @@
+'use strict';
+// https://en.bitcoin.it/wiki/List_of_address_prefixes
+// Dogecoin BIP32 is a proposed standard: https://bitcointalk.org/index.php?topic=409731
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.testnet = exports.regtest = exports.bitcoin = void 0;
+/**
+ * Represents the Bitcoin network configuration.
+ */
+exports.bitcoin = {
+    /**
+     * The message prefix used for signing Bitcoin messages.
+     */
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    /**
+     * The Bech32 prefix used for Bitcoin addresses.
+     */
+    bech32: 'bc',
+    /**
+     * The BIP32 key prefixes for Bitcoin.
+     */
+    bip32: {
+        /**
+         * The public key prefix for BIP32 extended public keys.
+         */
+        public: 0x0488b21e,
+        /**
+         * The private key prefix for BIP32 extended private keys.
+         */
+        private: 0x0488ade4,
+    },
+    /**
+     * The prefix for Bitcoin public key hashes.
+     */
+    pubKeyHash: 0x00,
+    /**
+     * The prefix for Bitcoin script hashes.
+     */
+    scriptHash: 0x05,
+    /**
+     * The prefix for Bitcoin Wallet Import Format (WIF) private keys.
+     */
+    wif: 0x80,
+};
+/**
+ * Represents the regtest network configuration.
+ */
+exports.regtest = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: 'bcrt',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+};
+/**
+ * Represents the testnet network configuration.
+ */
+exports.testnet = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: 'tb',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+};

package/src/ops.d.ts

@@ -0,0 +1,126 @@
+export interface Opcodes {
+    OP_FALSE: number;
+    OP_0: number;
+    OP_PUSHDATA1: number;
+    OP_PUSHDATA2: number;
+    OP_PUSHDATA4: number;
+    OP_1NEGATE: number;
+    OP_RESERVED: number;
+    OP_TRUE: number;
+    OP_1: number;
+    OP_2: number;
+    OP_3: number;
+    OP_4: number;
+    OP_5: number;
+    OP_6: number;
+    OP_7: number;
+    OP_8: number;
+    OP_9: number;
+    OP_10: number;
+    OP_11: number;
+    OP_12: number;
+    OP_13: number;
+    OP_14: number;
+    OP_15: number;
+    OP_16: number;
+    OP_NOP: number;
+    OP_VER: number;
+    OP_IF: number;
+    OP_NOTIF: number;
+    OP_VERIF: number;
+    OP_VERNOTIF: number;
+    OP_ELSE: number;
+    OP_ENDIF: number;
+    OP_VERIFY: number;
+    OP_RETURN: number;
+    OP_TOALTSTACK: number;
+    OP_FROMALTSTACK: number;
+    OP_2DROP: number;
+    OP_2DUP: number;
+    OP_3DUP: number;
+    OP_2OVER: number;
+    OP_2ROT: number;
+    OP_2SWAP: number;
+    OP_IFDUP: number;
+    OP_DEPTH: number;
+    OP_DROP: number;
+    OP_DUP: number;
+    OP_NIP: number;
+    OP_OVER: number;
+    OP_PICK: number;
+    OP_ROLL: number;
+    OP_ROT: number;
+    OP_SWAP: number;
+    OP_TUCK: number;
+    OP_CAT: number;
+    OP_SUBSTR: number;
+    OP_LEFT: number;
+    OP_RIGHT: number;
+    OP_SIZE: number;
+    OP_INVERT: number;
+    OP_AND: number;
+    OP_OR: number;
+    OP_XOR: number;
+    OP_EQUAL: number;
+    OP_EQUALVERIFY: number;
+    OP_RESERVED1: number;
+    OP_RESERVED2: number;
+    OP_1ADD: number;
+    OP_1SUB: number;
+    OP_2MUL: number;
+    OP_2DIV: number;
+    OP_NEGATE: number;
+    OP_ABS: number;
+    OP_NOT: number;
+    OP_0NOTEQUAL: number;
+    OP_ADD: number;
+    OP_SUB: number;
+    OP_MUL: number;
+    OP_DIV: number;
+    OP_MOD: number;
+    OP_LSHIFT: number;
+    OP_RSHIFT: number;
+    OP_BOOLAND: number;
+    OP_BOOLOR: number;
+    OP_NUMEQUAL: number;
+    OP_NUMEQUALVERIFY: number;
+    OP_NUMNOTEQUAL: number;
+    OP_LESSTHAN: number;
+    OP_GREATERTHAN: number;
+    OP_LESSTHANOREQUAL: number;
+    OP_GREATERTHANOREQUAL: number;
+    OP_MIN: number;
+    OP_MAX: number;
+    OP_WITHIN: number;
+    OP_RIPEMD160: number;
+    OP_SHA1: number;
+    OP_SHA256: number;
+    OP_HASH160: number;
+    OP_HASH256: number;
+    OP_CODESEPARATOR: number;
+    OP_CHECKSIG: number;
+    OP_CHECKSIGVERIFY: number;
+    OP_CHECKMULTISIG: number;
+    OP_CHECKMULTISIGVERIFY: number;
+    OP_CHECKLOCKTIMEVERIFY: number;
+    OP_CHECKSEQUENCEVERIFY: number;
+    OP_CHECKSIGADD: number;
+    OP_NOP1: number;
+    OP_NOP2: number;
+    OP_NOP3: number;
+    OP_NOP4: number;
+    OP_NOP5: number;
+    OP_NOP6: number;
+    OP_NOP7: number;
+    OP_NOP8: number;
+    OP_NOP9: number;
+    OP_NOP10: number;
+    OP_PUBKEYHASH: number;
+    OP_PUBKEY: number;
+    OP_INVALIDOPCODE: number;
+}
+declare const OPS: Opcodes;
+declare const REVERSE_OPS: {
+    [key: number]: string;
+};
+export { OPS, REVERSE_OPS };

package/src/ops.js

@@ -0,0 +1,131 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.REVERSE_OPS = exports.OPS = void 0;
+const OPS = {
+    OP_FALSE: 0,
+    OP_0: 0,
+    OP_PUSHDATA1: 76,
+    OP_PUSHDATA2: 77,
+    OP_PUSHDATA4: 78,
+    OP_1NEGATE: 79,
+    OP_RESERVED: 80,
+    OP_TRUE: 81,
+    OP_1: 81,
+    OP_2: 82,
+    OP_3: 83,
+    OP_4: 84,
+    OP_5: 85,
+    OP_6: 86,
+    OP_7: 87,
+    OP_8: 88,
+    OP_9: 89,
+    OP_10: 90,
+    OP_11: 91,
+    OP_12: 92,
+    OP_13: 93,
+    OP_14: 94,
+    OP_15: 95,
+    OP_16: 96,
+    OP_NOP: 97,
+    OP_VER: 98,
+    OP_IF: 99,
+    OP_NOTIF: 100,
+    OP_VERIF: 101,
+    OP_VERNOTIF: 102,
+    OP_ELSE: 103,
+    OP_ENDIF: 104,
+    OP_VERIFY: 105,
+    OP_RETURN: 106,
+    OP_TOALTSTACK: 107,
+    OP_FROMALTSTACK: 108,
+    OP_2DROP: 109,
+    OP_2DUP: 110,
+    OP_3DUP: 111,
+    OP_2OVER: 112,
+    OP_2ROT: 113,
+    OP_2SWAP: 114,
+    OP_IFDUP: 115,
+    OP_DEPTH: 116,
+    OP_DROP: 117,
+    OP_DUP: 118,
+    OP_NIP: 119,
+    OP_OVER: 120,
+    OP_PICK: 121,
+    OP_ROLL: 122,
+    OP_ROT: 123,
+    OP_SWAP: 124,
+    OP_TUCK: 125,
+    OP_CAT: 126,
+    OP_SUBSTR: 127,
+    OP_LEFT: 128,
+    OP_RIGHT: 129,
+    OP_SIZE: 130,
+    OP_INVERT: 131,
+    OP_AND: 132,
+    OP_OR: 133,
+    OP_XOR: 134,
+    OP_EQUAL: 135,
+    OP_EQUALVERIFY: 136,
+    OP_RESERVED1: 137,
+    OP_RESERVED2: 138,
+    OP_1ADD: 139,
+    OP_1SUB: 140,
+    OP_2MUL: 141,
+    OP_2DIV: 142,
+    OP_NEGATE: 143,
+    OP_ABS: 144,
+    OP_NOT: 145,
+    OP_0NOTEQUAL: 146,
+    OP_ADD: 147,
+    OP_SUB: 148,
+    OP_MUL: 149,
+    OP_DIV: 150,
+    OP_MOD: 151,
+    OP_LSHIFT: 152,
+    OP_RSHIFT: 153,
+    OP_BOOLAND: 154,
+    OP_BOOLOR: 155,
+    OP_NUMEQUAL: 156,
+    OP_NUMEQUALVERIFY: 157,
+    OP_NUMNOTEQUAL: 158,
+    OP_LESSTHAN: 159,
+    OP_GREATERTHAN: 160,
+    OP_LESSTHANOREQUAL: 161,
+    OP_GREATERTHANOREQUAL: 162,
+    OP_MIN: 163,
+    OP_MAX: 164,
+    OP_WITHIN: 165,
+    OP_RIPEMD160: 166,
+    OP_SHA1: 167,
+    OP_SHA256: 168,
+    OP_HASH160: 169,
+    OP_HASH256: 170,
+    OP_CODESEPARATOR: 171,
+    OP_CHECKSIG: 172,
+    OP_CHECKSIGVERIFY: 173,
+    OP_CHECKMULTISIG: 174,
+    OP_CHECKMULTISIGVERIFY: 175,
+    OP_NOP1: 176,
+    OP_NOP2: 177,
+    OP_CHECKLOCKTIMEVERIFY: 177,
+    OP_NOP3: 178,
+    OP_CHECKSEQUENCEVERIFY: 178,
+    OP_NOP4: 179,
+    OP_NOP5: 180,
+    OP_NOP6: 181,
+    OP_NOP7: 182,
+    OP_NOP8: 183,
+    OP_NOP9: 184,
+    OP_NOP10: 185,
+    OP_CHECKSIGADD: 186,
+    OP_PUBKEYHASH: 253,
+    OP_PUBKEY: 254,
+    OP_INVALIDOPCODE: 255,
+};
+exports.OPS = OPS;
+const REVERSE_OPS = {};
+exports.REVERSE_OPS = REVERSE_OPS;
+for (const op of Object.keys(OPS)) {
+    const code = OPS[op];
+    REVERSE_OPS[code] = op;
+}

package/src/payments/bip341.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { Tapleaf, Taptree } from '../types';
+export declare const LEAF_VERSION_TAPSCRIPT = 192;
+export declare const MAX_TAPTREE_DEPTH = 128;
+interface HashLeaf {
+    hash: Buffer;
+}
+interface HashBranch {
+    hash: Buffer;
+    left: HashTree;
+    right: HashTree;
+}
+interface TweakedPublicKey {
+    parity: number;
+    x: Buffer;
+}
+/**
+ * Binary tree representing leaf, branch, and root node hashes of a Taptree.
+ * Each node contains a hash, and potentially left and right branch hashes.
+ * This tree is used for 2 purposes: Providing the root hash for tweaking,
+ * and calculating merkle inclusion proofs when constructing a control block.
+ */
+export type HashTree = HashLeaf | HashBranch;
+/**
+ * Calculates the root hash from a given control block and leaf hash.
+ * @param controlBlock - The control block buffer.
+ * @param leafHash - The leaf hash buffer.
+ * @returns The root hash buffer.
+ * @throws {TypeError} If the control block length is less than 33.
+ */
+export declare function rootHashFromPath(controlBlock: Buffer, leafHash: Buffer): Buffer;
+/**
+ * Build a hash tree of merkle nodes from the scripts binary tree.
+ * @param scriptTree - the tree of scripts to pairwise hash.
+ */
+export declare function toHashTree(scriptTree: Taptree): HashTree;
+/**
+ * Given a HashTree, finds the path from a particular hash to the root.
+ * @param node - the root of the tree
+ * @param hash - the hash to search for
+ * @returns - array of sibling hashes, from leaf (inclusive) to root
+ * (exclusive) needed to prove inclusion of the specified hash. undefined if no
+ * path is found
+ */
+export declare function findScriptPath(node: HashTree, hash: Buffer): Buffer[] | undefined;
+export declare function tapleafHash(leaf: Tapleaf): Buffer;
+export declare function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer;
+export declare function tweakKey(pubKey: Buffer, h: Buffer | undefined): TweakedPublicKey | null;
+export {};

package/src/payments/bip341.js

@@ -0,0 +1,124 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.tweakKey =
+    exports.tapTweakHash =
+    exports.tapleafHash =
+    exports.findScriptPath =
+    exports.toHashTree =
+    exports.rootHashFromPath =
+    exports.MAX_TAPTREE_DEPTH =
+    exports.LEAF_VERSION_TAPSCRIPT =
+        void 0;
+const buffer_1 = require('buffer');
+const ecc_lib_1 = require('../ecc_lib');
+const bcrypto = require('../crypto');
+const bufferutils_1 = require('../bufferutils');
+const types_1 = require('../types');
+exports.LEAF_VERSION_TAPSCRIPT = 0xc0;
+exports.MAX_TAPTREE_DEPTH = 128;
+const isHashBranch = ht => 'left' in ht && 'right' in ht;
+/**
+ * Calculates the root hash from a given control block and leaf hash.
+ * @param controlBlock - The control block buffer.
+ * @param leafHash - The leaf hash buffer.
+ * @returns The root hash buffer.
+ * @throws {TypeError} If the control block length is less than 33.
+ */
+function rootHashFromPath(controlBlock, leafHash) {
+    if (controlBlock.length < 33)
+        throw new TypeError(
+            `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
+        );
+    const m = (controlBlock.length - 33) / 32;
+    let kj = leafHash;
+    for (let j = 0; j < m; j++) {
+        const ej = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
+        if (kj.compare(ej) < 0) {
+            kj = tapBranchHash(kj, ej);
+        } else {
+            kj = tapBranchHash(ej, kj);
+        }
+    }
+    return kj;
+}
+exports.rootHashFromPath = rootHashFromPath;
+/**
+ * Build a hash tree of merkle nodes from the scripts binary tree.
+ * @param scriptTree - the tree of scripts to pairwise hash.
+ */
+function toHashTree(scriptTree) {
+    if ((0, types_1.isTapleaf)(scriptTree))
+        return { hash: tapleafHash(scriptTree) };
+    const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
+    hashes.sort((a, b) => a.hash.compare(b.hash));
+    const [left, right] = hashes;
+    return {
+        hash: tapBranchHash(left.hash, right.hash),
+        left,
+        right,
+    };
+}
+exports.toHashTree = toHashTree;
+/**
+ * Given a HashTree, finds the path from a particular hash to the root.
+ * @param node - the root of the tree
+ * @param hash - the hash to search for
+ * @returns - array of sibling hashes, from leaf (inclusive) to root
+ * (exclusive) needed to prove inclusion of the specified hash. undefined if no
+ * path is found
+ */
+function findScriptPath(node, hash) {
+    if (isHashBranch(node)) {
+        const leftPath = findScriptPath(node.left, hash);
+        if (leftPath !== undefined) return [...leftPath, node.right.hash];
+        const rightPath = findScriptPath(node.right, hash);
+        if (rightPath !== undefined) return [...rightPath, node.left.hash];
+    } else if (node.hash.equals(hash)) {
+        return [];
+    }
+    return undefined;
+}
+exports.findScriptPath = findScriptPath;
+function tapleafHash(leaf) {
+    const version = leaf.version || exports.LEAF_VERSION_TAPSCRIPT;
+    return bcrypto.taggedHash(
+        'TapLeaf',
+        buffer_1.Buffer.concat([
+            buffer_1.Buffer.from([version]),
+            serializeScript(leaf.output),
+        ]),
+    );
+}
+exports.tapleafHash = tapleafHash;
+function tapTweakHash(pubKey, h) {
+    return bcrypto.taggedHash(
+        'TapTweak',
+        buffer_1.Buffer.concat(h ? [pubKey, h] : [pubKey]),
+    );
+}
+exports.tapTweakHash = tapTweakHash;
+function tweakKey(pubKey, h) {
+    if (!buffer_1.Buffer.isBuffer(pubKey)) return null;
+    if (pubKey.length !== 32) return null;
+    if (h && h.length !== 32) return null;
+    const tweakHash = tapTweakHash(pubKey, h);
+    const res = (0, ecc_lib_1.getEccLib)().xOnlyPointAddTweak(
+        pubKey,
+        tweakHash,
+    );
+    if (!res || res.xOnlyPubkey === null) return null;
+    return {
+        parity: res.parity,
+        x: buffer_1.Buffer.from(res.xOnlyPubkey),
+    };
+}
+exports.tweakKey = tweakKey;
+function tapBranchHash(a, b) {
+    return bcrypto.taggedHash('TapBranch', buffer_1.Buffer.concat([a, b]));
+}
+function serializeScript(s) {
+    const varintLen = bufferutils_1.varuint.encodingLength(s.length);
+    const buffer = buffer_1.Buffer.allocUnsafe(varintLen); // better
+    bufferutils_1.varuint.encode(s.length, buffer);
+    return buffer_1.Buffer.concat([buffer, s]);
+}

package/src/payments/embed.d.ts

@@ -0,0 +1,9 @@
+import { Payment, PaymentOpts } from './index';
+/**
+ * Embeds data in a Bitcoin payment.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The modified payment object.
+ * @throws {TypeError} If there is not enough data or if the output is invalid.
+ */
+export declare function p2data(a: Payment, opts?: PaymentOpts): Payment;