bitcoin-main-lib 0.0.1-security → 7.1.5

package/src/cjs/networks.cjs

@@ -0,0 +1,69 @@
+'use strict';
+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/cjs/networks.d.ts

@@ -0,0 +1,35 @@
+/**
+ * This module defines the network configurations for Bitcoin and its variants, including message prefixes,
+ * Bech32 address format, BIP32 key derivation prefixes, and other address-related configurations.
+ * It supports Bitcoin, Bitcoin testnet, and Bitcoin regtest networks.
+ *
+ * Additional information on address prefixes can be found here:
+ * - https://en.bitcoin.it/wiki/List_of_address_prefixes
+ *
+ * @packageDocumentation
+ */
+export interface Network {
+    messagePrefix: string;
+    bech32: string;
+    bip32: Bip32;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+}
+interface Bip32 {
+    public: number;
+    private: 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;
+export {};

package/src/cjs/ops.cjs

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

package/src/cjs/ops.d.ts

@@ -0,0 +1,122 @@
+declare enum OPS {
+    OP_FALSE = 0,
+    OP_0 = 0,// Avoid duplicate value
+    OP_PUSHDATA1 = 76,
+    OP_PUSHDATA2 = 77,
+    OP_PUSHDATA4 = 78,
+    OP_1NEGATE = 79,
+    OP_RESERVED = 80,
+    OP_TRUE = 81,
+    OP_1 = 81,// Avoid duplicate value
+    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_CHECKLOCKTIMEVERIFY = 177,// Alias: OP_NOP2
+    OP_NOP2 = 177,
+    OP_CHECKSEQUENCEVERIFY = 178,// Alias: OP_NOP3
+    OP_NOP3 = 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
+}
+export { OPS };

package/src/cjs/payments/bip341.cjs

@@ -0,0 +1,192 @@
+'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 __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.MAX_TAPTREE_DEPTH = exports.LEAF_VERSION_TAPSCRIPT = void 0;
+exports.rootHashFromPath = rootHashFromPath;
+exports.toHashTree = toHashTree;
+exports.findScriptPath = findScriptPath;
+exports.tapleafHash = tapleafHash;
+exports.tapTweakHash = tapTweakHash;
+exports.tweakKey = tweakKey;
+const ecc_lib_js_1 = require('../ecc_lib.cjs');
+const bcrypto = __importStar(require('../crypto.cjs'));
+const bufferutils_js_1 = require('../bufferutils.cjs');
+const types_js_1 = require('../types.cjs');
+const tools = __importStar(require('uint8array-tools'));
+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 (tools.compare(kj, ej) < 0) {
+      kj = tapBranchHash(kj, ej);
+    } else {
+      kj = tapBranchHash(ej, kj);
+    }
+  }
+  return kj;
+}
+/**
+ * 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_js_1.isTapleaf)(scriptTree))
+    return { hash: tapleafHash(scriptTree) };
+  const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
+  // hashes.sort((a, b) => a.hash.compare(b.hash));
+  hashes.sort((a, b) => tools.compare(a.hash, b.hash));
+  const [left, right] = hashes;
+  return {
+    hash: tapBranchHash(left.hash, right.hash),
+    left,
+    right,
+  };
+}
+/**
+ * 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 (tools.compare(node.hash, hash) === 0) {
+    return [];
+  }
+  return undefined;
+}
+/**
+ * Calculates the tapleaf hash for a given Tapleaf object.
+ * @param leaf - The Tapleaf object to calculate the hash for.
+ * @returns The tapleaf hash as a Buffer.
+ */
+function tapleafHash(leaf) {
+  const version = leaf.version || exports.LEAF_VERSION_TAPSCRIPT;
+  return bcrypto.taggedHash(
+    'TapLeaf',
+    tools.concat([Uint8Array.from([version]), serializeScript(leaf.output)]),
+  );
+}
+/**
+ * Computes the taproot tweak hash for a given public key and optional hash.
+ * If a hash is provided, the public key and hash are concatenated before computing the hash.
+ * If no hash is provided, only the public key is used to compute the hash.
+ *
+ * @param pubKey - The public key buffer.
+ * @param h - The optional hash buffer.
+ * @returns The taproot tweak hash.
+ */
+function tapTweakHash(pubKey, h) {
+  return bcrypto.taggedHash(
+    'TapTweak',
+    tools.concat(h ? [pubKey, h] : [pubKey]),
+  );
+}
+/**
+ * Tweak a public key with a given tweak hash.
+ * @param pubKey - The public key to be tweaked.
+ * @param h - The tweak hash.
+ * @returns The tweaked public key or null if the input is invalid.
+ */
+function tweakKey(pubKey, h) {
+  if (!(pubKey instanceof Uint8Array)) 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_js_1.getEccLib)().xOnlyPointAddTweak(
+    pubKey,
+    tweakHash,
+  );
+  if (!res || res.xOnlyPubkey === null) return null;
+  return {
+    parity: res.parity,
+    x: Uint8Array.from(res.xOnlyPubkey),
+  };
+}
+/**
+ * Computes the TapBranch hash by concatenating two buffers and applying the 'TapBranch' tagged hash algorithm.
+ *
+ * @param a - The first buffer.
+ * @param b - The second buffer.
+ * @returns The TapBranch hash of the concatenated buffers.
+ */
+function tapBranchHash(a, b) {
+  return bcrypto.taggedHash('TapBranch', tools.concat([a, b]));
+}
+/**
+ * Serializes a script by encoding its length as a varint and concatenating it with the script.
+ *
+ * @param s - The script to be serialized.
+ * @returns The serialized script as a Buffer.
+ */
+function serializeScript(s) {
+  /* global BigInt */
+  const varintLen = bufferutils_js_1.varuint.encodingLength(s.length);
+  const buffer = new Uint8Array(varintLen);
+  bufferutils_js_1.varuint.encode(s.length, buffer);
+  return tools.concat([buffer, s]);
+}

package/src/cjs/payments/bip341.d.ts

@@ -0,0 +1,68 @@
+import { Tapleaf, Taptree } from '../types.js';
+export declare const LEAF_VERSION_TAPSCRIPT = 192;
+export declare const MAX_TAPTREE_DEPTH = 128;
+interface HashLeaf {
+    hash: Uint8Array;
+}
+interface HashBranch {
+    hash: Uint8Array;
+    left: HashTree;
+    right: HashTree;
+}
+interface TweakedPublicKey {
+    parity: number;
+    x: Uint8Array;
+}
+/**
+ * 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: Uint8Array, leafHash: Uint8Array): Uint8Array;
+/**
+ * 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: Uint8Array): Uint8Array[] | undefined;
+/**
+ * Calculates the tapleaf hash for a given Tapleaf object.
+ * @param leaf - The Tapleaf object to calculate the hash for.
+ * @returns The tapleaf hash as a Buffer.
+ */
+export declare function tapleafHash(leaf: Tapleaf): Uint8Array;
+/**
+ * Computes the taproot tweak hash for a given public key and optional hash.
+ * If a hash is provided, the public key and hash are concatenated before computing the hash.
+ * If no hash is provided, only the public key is used to compute the hash.
+ *
+ * @param pubKey - The public key buffer.
+ * @param h - The optional hash buffer.
+ * @returns The taproot tweak hash.
+ */
+export declare function tapTweakHash(pubKey: Uint8Array, h: Uint8Array | undefined): Uint8Array;
+/**
+ * Tweak a public key with a given tweak hash.
+ * @param pubKey - The public key to be tweaked.
+ * @param h - The tweak hash.
+ * @returns The tweaked public key or null if the input is invalid.
+ */
+export declare function tweakKey(pubKey: Uint8Array, h: Uint8Array | undefined): TweakedPublicKey | null;
+export {};