bitcoin-main-lib 0.0.1-security → 7.0.6

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 {};

package/src/cjs/payments/embed.cjs

@@ -0,0 +1,97 @@
+'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.p2data = p2data;
+const networks_js_1 = require('../networks.cjs');
+const bscript = __importStar(require('../script.cjs'));
+const types_js_1 = require('../types.cjs');
+const lazy = __importStar(require('./lazy.cjs'));
+const v = __importStar(require('valibot'));
+const OPS = bscript.OPS;
+// output: OP_RETURN ...
+/**
+ * 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.
+ */
+function p2data(a, opts) {
+  if (!a.data && !a.output) throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  v.parse(
+    v.partial(
+      v.object({
+        network: v.object({}),
+        output: types_js_1.BufferSchema,
+        data: v.array(types_js_1.BufferSchema),
+      }),
+    ),
+    a,
+  );
+  const network = a.network || networks_js_1.bitcoin;
+  const o = { name: 'embed', network };
+  lazy.prop(o, 'output', () => {
+    if (!a.data) return;
+    return bscript.compile([OPS.OP_RETURN].concat(a.data));
+  });
+  lazy.prop(o, 'data', () => {
+    if (!a.output) return;
+    return bscript.decompile(a.output).slice(1);
+  });
+  // extended validation
+  if (opts.validate) {
+    if (a.output) {
+      const chunks = bscript.decompile(a.output);
+      if (chunks[0] !== OPS.OP_RETURN) throw new TypeError('Output is invalid');
+      if (!chunks.slice(1).every(chunk => v.is(types_js_1.BufferSchema, chunk)))
+        throw new TypeError('Output is invalid');
+      if (a.data && !(0, types_js_1.stacksEqual)(a.data, o.data))
+        throw new TypeError('Data mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}

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

@@ -0,0 +1,9 @@
+import { Payment, PaymentOpts } from './index.js';
+/**
+ * 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;

package/src/cjs/payments/index.cjs

@@ -0,0 +1,69 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2tr =
+  exports.p2wsh =
+  exports.p2wpkh =
+  exports.p2sh =
+  exports.p2pkh =
+  exports.p2pk =
+  exports.p2ms =
+  exports.embed =
+    void 0;
+const embed_js_1 = require('./embed.cjs');
+Object.defineProperty(exports, 'embed', {
+  enumerable: true,
+  get: function () {
+    return embed_js_1.p2data;
+  },
+});
+const p2ms_js_1 = require('./p2ms.cjs');
+Object.defineProperty(exports, 'p2ms', {
+  enumerable: true,
+  get: function () {
+    return p2ms_js_1.p2ms;
+  },
+});
+const p2pk_js_1 = require('./p2pk.cjs');
+Object.defineProperty(exports, 'p2pk', {
+  enumerable: true,
+  get: function () {
+    return p2pk_js_1.p2pk;
+  },
+});
+const p2pkh_js_1 = require('./p2pkh.cjs');
+Object.defineProperty(exports, 'p2pkh', {
+  enumerable: true,
+  get: function () {
+    return p2pkh_js_1.p2pkh;
+  },
+});
+const p2sh_js_1 = require('./p2sh.cjs');
+Object.defineProperty(exports, 'p2sh', {
+  enumerable: true,
+  get: function () {
+    return p2sh_js_1.p2sh;
+  },
+});
+const p2wpkh_js_1 = require('./p2wpkh.cjs');
+Object.defineProperty(exports, 'p2wpkh', {
+  enumerable: true,
+  get: function () {
+    return p2wpkh_js_1.p2wpkh;
+  },
+});
+const p2wsh_js_1 = require('./p2wsh.cjs');
+Object.defineProperty(exports, 'p2wsh', {
+  enumerable: true,
+  get: function () {
+    return p2wsh_js_1.p2wsh;
+  },
+});
+const p2tr_js_1 = require('./p2tr.cjs');
+Object.defineProperty(exports, 'p2tr', {
+  enumerable: true,
+  get: function () {
+    return p2tr_js_1.p2tr;
+  },
+});
+// TODO
+// witness commitment

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

@@ -0,0 +1,55 @@
+/**
+ * Provides functionality for creating and managing Bitcoin payment objects.
+ *
+ * This module supports multiple Bitcoin address types for payments, including:
+ * - P2PKH (Pay-to-PubKey-Hash)
+ * - P2SH (Pay-to-Script-Hash)
+ * - P2WPKH (Pay-to-Witness-PubKey-Hash)
+ * - P2WSH (Pay-to-Witness-Script-Hash)
+ * - P2TR (Taproot)
+ *
+ * The `Payment` interface defines the structure of a payment object used for constructing various
+ * payment types, with fields for signatures, public keys, redeem scripts, and more.
+ *
+ * @packageDocumentation
+ */
+import { Network } from '../networks.js';
+import { Taptree } from '../types.js';
+import { p2data as embed } from './embed.js';
+import { p2ms } from './p2ms.js';
+import { p2pk } from './p2pk.js';
+import { p2pkh } from './p2pkh.js';
+import { p2sh } from './p2sh.js';
+import { p2wpkh } from './p2wpkh.js';
+import { p2wsh } from './p2wsh.js';
+import { p2tr } from './p2tr.js';
+export interface Payment {
+    name?: string;
+    network?: Network;
+    output?: Uint8Array;
+    data?: Uint8Array[];
+    m?: number;
+    n?: number;
+    pubkeys?: Uint8Array[];
+    input?: Uint8Array;
+    signatures?: Uint8Array[];
+    internalPubkey?: Uint8Array;
+    pubkey?: Uint8Array;
+    signature?: Uint8Array;
+    address?: string;
+    hash?: Uint8Array;
+    redeem?: Payment;
+    redeemVersion?: number;
+    scriptTree?: Taptree;
+    witness?: Uint8Array[];
+}
+export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
+export type PaymentFunction = () => Payment;
+export interface PaymentOpts {
+    validate?: boolean;
+    allowIncomplete?: boolean;
+}
+export type StackElement = Uint8Array | number;
+export type Stack = StackElement[];
+export type StackFunction = () => Stack;
+export { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh, p2tr };

package/src/cjs/payments/lazy.cjs

@@ -0,0 +1,31 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.prop = prop;
+exports.value = value;
+function prop(object, name, f) {
+  Object.defineProperty(object, name, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const _value = f.call(this);
+      this[name] = _value;
+      return _value;
+    },
+    set(_value) {
+      Object.defineProperty(this, name, {
+        configurable: true,
+        enumerable: true,
+        value: _value,
+        writable: true,
+      });
+    },
+  });
+}
+function value(f) {
+  let _value;
+  return () => {
+    if (_value !== undefined) return _value;
+    _value = f();
+    return _value;
+  };
+}

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

@@ -0,0 +1,2 @@
+export declare function prop(object: object, name: string, f: () => any): void;
+export declare function value<T>(f: () => T): () => T;