bitcoin-main-lib 0.0.1-security → 7.0.0

package/src/cjs/bufferutils.cjs

@@ -0,0 +1,207 @@
+'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.BufferReader = exports.BufferWriter = exports.varuint = void 0;
+exports.reverseBuffer = reverseBuffer;
+exports.cloneBuffer = cloneBuffer;
+const types = __importStar(require('./types.cjs'));
+const varuint = __importStar(require('varuint-bitcoin'));
+exports.varuint = varuint;
+const v = __importStar(require('valibot'));
+const tools = __importStar(require('uint8array-tools'));
+const MAX_JS_NUMBER = 0x001fffffffffffff;
+// https://github.com/feross/buffer/blob/master/index.js#L1127
+function verifuint(value, max) {
+  if (typeof value !== 'number' && typeof value !== 'bigint')
+    throw new Error('cannot write a non-number as a number');
+  if (value < 0 && value < BigInt(0))
+    throw new Error('specified a negative value for writing an unsigned value');
+  if (value > max && value > BigInt(max))
+    throw new Error('RangeError: value out of range');
+  if (Math.floor(Number(value)) !== Number(value))
+    throw new Error('value has a fractional component');
+}
+/**
+ * Reverses the order of bytes in a buffer.
+ * @param buffer - The buffer to reverse.
+ * @returns A new buffer with the bytes reversed.
+ */
+function reverseBuffer(buffer) {
+  if (buffer.length < 1) return buffer;
+  let j = buffer.length - 1;
+  let tmp = 0;
+  for (let i = 0; i < buffer.length / 2; i++) {
+    tmp = buffer[i];
+    buffer[i] = buffer[j];
+    buffer[j] = tmp;
+    j--;
+  }
+  return buffer;
+}
+function cloneBuffer(buffer) {
+  const clone = new Uint8Array(buffer.length);
+  clone.set(buffer);
+  return clone;
+}
+/**
+ * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
+ */
+class BufferWriter {
+  buffer;
+  offset;
+  static withCapacity(size) {
+    return new BufferWriter(new Uint8Array(size));
+  }
+  constructor(buffer, offset = 0) {
+    this.buffer = buffer;
+    this.offset = offset;
+    v.parse(v.tuple([types.BufferSchema, types.UInt32Schema]), [
+      buffer,
+      offset,
+    ]);
+  }
+  writeUInt8(i) {
+    this.offset = tools.writeUInt8(this.buffer, this.offset, i);
+  }
+  writeInt32(i) {
+    this.offset = tools.writeInt32(this.buffer, this.offset, i, 'LE');
+  }
+  writeInt64(i) {
+    this.offset = tools.writeInt64(this.buffer, this.offset, BigInt(i), 'LE');
+  }
+  writeUInt32(i) {
+    this.offset = tools.writeUInt32(this.buffer, this.offset, i, 'LE');
+  }
+  writeUInt64(i) {
+    this.offset = tools.writeUInt64(this.buffer, this.offset, BigInt(i), 'LE');
+  }
+  writeVarInt(i) {
+    const { bytes } = varuint.encode(i, this.buffer, this.offset);
+    this.offset += bytes;
+  }
+  writeSlice(slice) {
+    if (this.buffer.length < this.offset + slice.length) {
+      throw new Error('Cannot write slice out of bounds');
+    }
+    this.buffer.set(slice, this.offset);
+    this.offset += slice.length;
+  }
+  writeVarSlice(slice) {
+    this.writeVarInt(slice.length);
+    this.writeSlice(slice);
+  }
+  writeVector(vector) {
+    this.writeVarInt(vector.length);
+    vector.forEach(buf => this.writeVarSlice(buf));
+  }
+  end() {
+    if (this.buffer.length === this.offset) {
+      return this.buffer;
+    }
+    throw new Error(`buffer size ${this.buffer.length}, offset ${this.offset}`);
+  }
+}
+exports.BufferWriter = BufferWriter;
+/**
+ * Helper class for reading of bitcoin data types from a buffer.
+ */
+class BufferReader {
+  buffer;
+  offset;
+  constructor(buffer, offset = 0) {
+    this.buffer = buffer;
+    this.offset = offset;
+    v.parse(v.tuple([types.BufferSchema, types.UInt32Schema]), [
+      buffer,
+      offset,
+    ]);
+  }
+  readUInt8() {
+    const result = tools.readUInt8(this.buffer, this.offset);
+    this.offset++;
+    return result;
+  }
+  readInt32() {
+    const result = tools.readInt32(this.buffer, this.offset, 'LE');
+    this.offset += 4;
+    return result;
+  }
+  readUInt32() {
+    const result = tools.readUInt32(this.buffer, this.offset, 'LE');
+    this.offset += 4;
+    return result;
+  }
+  readInt64() {
+    const result = tools.readInt64(this.buffer, this.offset, 'LE');
+    this.offset += 8;
+    return result;
+  }
+  readVarInt() {
+    const { bigintValue, bytes } = varuint.decode(this.buffer, this.offset);
+    this.offset += bytes;
+    return bigintValue;
+  }
+  readSlice(n) {
+    verifuint(n, MAX_JS_NUMBER);
+    const num = Number(n);
+    if (this.buffer.length < this.offset + num) {
+      throw new Error('Cannot read slice out of bounds');
+    }
+    const result = this.buffer.slice(this.offset, this.offset + num);
+    this.offset += num;
+    return result;
+  }
+  readVarSlice() {
+    return this.readSlice(this.readVarInt());
+  }
+  readVector() {
+    const count = this.readVarInt();
+    const vector = [];
+    for (let i = 0; i < count; i++) vector.push(this.readVarSlice());
+    return vector;
+  }
+}
+exports.BufferReader = BufferReader;

package/src/cjs/bufferutils.d.ts

@@ -0,0 +1,44 @@
+import * as varuint from 'varuint-bitcoin';
+export { varuint };
+/**
+ * Reverses the order of bytes in a buffer.
+ * @param buffer - The buffer to reverse.
+ * @returns A new buffer with the bytes reversed.
+ */
+export declare function reverseBuffer(buffer: Uint8Array): Uint8Array;
+export declare function cloneBuffer(buffer: Uint8Array): Uint8Array;
+/**
+ * Helper class for serialization of bitcoin data types into a pre-allocated buffer.
+ */
+export declare class BufferWriter {
+    buffer: Uint8Array;
+    offset: number;
+    static withCapacity(size: number): BufferWriter;
+    constructor(buffer: Uint8Array, offset?: number);
+    writeUInt8(i: number): void;
+    writeInt32(i: number): void;
+    writeInt64(i: number | bigint): void;
+    writeUInt32(i: number): void;
+    writeUInt64(i: number | bigint): void;
+    writeVarInt(i: number): void;
+    writeSlice(slice: Uint8Array): void;
+    writeVarSlice(slice: Uint8Array): void;
+    writeVector(vector: Uint8Array[]): void;
+    end(): Uint8Array;
+}
+/**
+ * Helper class for reading of bitcoin data types from a buffer.
+ */
+export declare class BufferReader {
+    buffer: Uint8Array;
+    offset: number;
+    constructor(buffer: Uint8Array, offset?: number);
+    readUInt8(): number;
+    readInt32(): number;
+    readUInt32(): number;
+    readInt64(): bigint;
+    readVarInt(): bigint;
+    readSlice(n: number | bigint): Uint8Array;
+    readVarSlice(): Uint8Array;
+    readVector(): Uint8Array[];
+}

package/src/cjs/crypto.cjs

@@ -0,0 +1,197 @@
+'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.TAGGED_HASH_PREFIXES =
+  exports.TAGS =
+  exports.sha1 =
+  exports.sha256 =
+  exports.ripemd160 =
+    void 0;
+exports.hash160 = hash160;
+exports.hash256 = hash256;
+exports.taggedHash = taggedHash;
+/**
+ * A module for hashing functions.
+ * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ *
+ * @packageDocumentation
+ */
+const ripemd160_1 = require('@noble/hashes/ripemd160');
+Object.defineProperty(exports, 'ripemd160', {
+  enumerable: true,
+  get: function () {
+    return ripemd160_1.ripemd160;
+  },
+});
+const sha256_1 = require('@noble/hashes/sha256');
+Object.defineProperty(exports, 'sha256', {
+  enumerable: true,
+  get: function () {
+    return sha256_1.sha256;
+  },
+});
+const tools = __importStar(require('uint8array-tools'));
+var sha1_1 = require('@noble/hashes/sha1');
+Object.defineProperty(exports, 'sha1', {
+  enumerable: true,
+  get: function () {
+    return sha1_1.sha1;
+  },
+});
+/**
+ * Computes the HASH160 (RIPEMD-160 after SHA-256) of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The HASH160 of the input buffer.
+ */
+function hash160(buffer) {
+  return (0, ripemd160_1.ripemd160)((0, sha256_1.sha256)(buffer));
+}
+/**
+ * Computes the double SHA-256 hash of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The double SHA-256 hash of the input buffer.
+ */
+function hash256(buffer) {
+  return (0, sha256_1.sha256)((0, sha256_1.sha256)(buffer));
+}
+exports.TAGS = [
+  'BIP0340/challenge',
+  'BIP0340/aux',
+  'BIP0340/nonce',
+  'TapLeaf',
+  'TapBranch',
+  'TapSighash',
+  'TapTweak',
+  'KeyAgg list',
+  'KeyAgg coefficient',
+];
+/**
+ * A collection of tagged hash prefixes used in various BIP (Bitcoin Improvement Proposals)
+ * and Taproot-related operations. Each prefix is represented as a `Uint8Array`.
+ *
+ * @constant
+ * @type {TaggedHashPrefixes}
+ *
+ * @property {'BIP0340/challenge'} - Prefix for BIP0340 challenge.
+ * @property {'BIP0340/aux'} - Prefix for BIP0340 auxiliary data.
+ * @property {'BIP0340/nonce'} - Prefix for BIP0340 nonce.
+ * @property {TapLeaf} - Prefix for Taproot leaf.
+ * @property {TapBranch} - Prefix for Taproot branch.
+ * @property {TapSighash} - Prefix for Taproot sighash.
+ * @property {TapTweak} - Prefix for Taproot tweak.
+ * @property {'KeyAgg list'} - Prefix for key aggregation list.
+ * @property {'KeyAgg coefficient'} - Prefix for key aggregation coefficient.
+ */
+exports.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,
+  ]),
+};
+/**
+ * Computes a tagged hash using the specified prefix and data.
+ *
+ * @param prefix - The prefix to use for the tagged hash. This should be one of the values from the `TaggedHashPrefix` enum.
+ * @param data - The data to hash, provided as a `Uint8Array`.
+ * @returns The resulting tagged hash as a `Uint8Array`.
+ */
+function taggedHash(prefix, data) {
+  return (0, sha256_1.sha256)(
+    tools.concat([exports.TAGGED_HASH_PREFIXES[prefix], data]),
+  );
+}

package/src/cjs/crypto.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A module for hashing functions.
+ * include ripemd160、sha1、sha256、hash160、hash256、taggedHash
+ *
+ * @packageDocumentation
+ */
+import { ripemd160 } from '@noble/hashes/ripemd160';
+import { sha256 } from '@noble/hashes/sha256';
+export { ripemd160, sha256 };
+export { sha1 } from '@noble/hashes/sha1';
+/**
+ * Computes the HASH160 (RIPEMD-160 after SHA-256) of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The HASH160 of the input buffer.
+ */
+export declare function hash160(buffer: Uint8Array): Uint8Array;
+/**
+ * Computes the double SHA-256 hash of the given buffer.
+ *
+ * @param buffer - The input data to be hashed.
+ * @returns The double SHA-256 hash of the input buffer.
+ */
+export declare function hash256(buffer: Uint8Array): Uint8Array;
+export declare const TAGS: readonly ["BIP0340/challenge", "BIP0340/aux", "BIP0340/nonce", "TapLeaf", "TapBranch", "TapSighash", "TapTweak", "KeyAgg list", "KeyAgg coefficient"];
+export type TaggedHashPrefix = (typeof TAGS)[number];
+type TaggedHashPrefixes = {
+    [key in TaggedHashPrefix]: Uint8Array;
+};
+/**
+ * A collection of tagged hash prefixes used in various BIP (Bitcoin Improvement Proposals)
+ * and Taproot-related operations. Each prefix is represented as a `Uint8Array`.
+ *
+ * @constant
+ * @type {TaggedHashPrefixes}
+ *
+ * @property {'BIP0340/challenge'} - Prefix for BIP0340 challenge.
+ * @property {'BIP0340/aux'} - Prefix for BIP0340 auxiliary data.
+ * @property {'BIP0340/nonce'} - Prefix for BIP0340 nonce.
+ * @property {TapLeaf} - Prefix for Taproot leaf.
+ * @property {TapBranch} - Prefix for Taproot branch.
+ * @property {TapSighash} - Prefix for Taproot sighash.
+ * @property {TapTweak} - Prefix for Taproot tweak.
+ * @property {'KeyAgg list'} - Prefix for key aggregation list.
+ * @property {'KeyAgg coefficient'} - Prefix for key aggregation coefficient.
+ */
+export declare const TAGGED_HASH_PREFIXES: TaggedHashPrefixes;
+/**
+ * Computes a tagged hash using the specified prefix and data.
+ *
+ * @param prefix - The prefix to use for the tagged hash. This should be one of the values from the `TaggedHashPrefix` enum.
+ * @param data - The data to hash, provided as a `Uint8Array`.
+ * @returns The resulting tagged hash as a `Uint8Array`.
+ */
+export declare function taggedHash(prefix: TaggedHashPrefix, data: Uint8Array): Uint8Array;

package/src/cjs/ecc_lib.cjs

@@ -0,0 +1,156 @@
+'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.initEccLib = initEccLib;
+exports.getEccLib = getEccLib;
+const tools = __importStar(require('uint8array-tools'));
+const _ECCLIB_CACHE = {};
+/**
+ * Initializes the ECC library with the provided instance.
+ * If `eccLib` is `undefined`, the library will be cleared.
+ * If `eccLib` is a new instance, it will be verified before setting it as the active library.
+ *
+ * @param eccLib The instance of the ECC library to initialize.
+ * @param opts Extra initialization options. Use {DANGER_DO_NOT_VERIFY_ECCLIB:true} if ecc verification should not be executed. Not recommended!
+ */
+function initEccLib(eccLib, opts) {
+  if (!eccLib) {
+    // allow clearing the library
+    _ECCLIB_CACHE.eccLib = eccLib;
+  } else if (eccLib !== _ECCLIB_CACHE.eccLib) {
+    if (!opts?.DANGER_DO_NOT_VERIFY_ECCLIB)
+      // new instance, verify it
+      verifyEcc(eccLib);
+    _ECCLIB_CACHE.eccLib = eccLib;
+  }
+}
+/**
+ * Retrieves the ECC Library instance.
+ * Throws an error if the ECC Library is not provided.
+ * You must call initEccLib() with a valid TinySecp256k1Interface instance before calling this function.
+ * @returns The ECC Library instance.
+ * @throws Error if the ECC Library is not provided.
+ */
+function getEccLib() {
+  if (!_ECCLIB_CACHE.eccLib)
+    throw new Error(
+      'No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance',
+    );
+  return _ECCLIB_CACHE.eccLib;
+}
+const h = hex => tools.fromHex(hex);
+/**
+ * Verifies the ECC functionality.
+ *
+ * @param ecc - The TinySecp256k1Interface object.
+ */
+function verifyEcc(ecc) {
+  assert(typeof ecc.isXOnlyPoint === 'function');
+  assert(
+    ecc.isXOnlyPoint(
+      h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    ),
+  );
+  assert(
+    ecc.isXOnlyPoint(
+      h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e'),
+    ),
+  );
+  assert(
+    ecc.isXOnlyPoint(
+      h('f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9'),
+    ),
+  );
+  assert(
+    ecc.isXOnlyPoint(
+      h('0000000000000000000000000000000000000000000000000000000000000001'),
+    ),
+  );
+  assert(
+    !ecc.isXOnlyPoint(
+      h('0000000000000000000000000000000000000000000000000000000000000000'),
+    ),
+  );
+  assert(
+    !ecc.isXOnlyPoint(
+      h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
+    ),
+  );
+  assert(typeof ecc.xOnlyPointAddTweak === 'function');
+  tweakAddVectors.forEach(t => {
+    const r = ecc.xOnlyPointAddTweak(h(t.pubkey), h(t.tweak));
+    if (t.result === null) {
+      assert(r === null);
+    } else {
+      assert(r !== null);
+      assert(r.parity === t.parity);
+      assert(tools.compare(r.xOnlyPubkey, h(t.result)) === 0);
+    }
+  });
+}
+function assert(bool) {
+  if (!bool) throw new Error('ecc library invalid');
+}
+const tweakAddVectors = [
+  {
+    pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+    tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+    parity: -1,
+    result: null,
+  },
+  {
+    pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
+    tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
+    parity: 1,
+    result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
+  },
+  {
+    pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
+    tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
+    parity: 0,
+    result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
+  },
+];

package/src/cjs/ecc_lib.d.ts

@@ -0,0 +1,20 @@
+import { TinySecp256k1Interface } from './types.js';
+/**
+ * Initializes the ECC library with the provided instance.
+ * If `eccLib` is `undefined`, the library will be cleared.
+ * If `eccLib` is a new instance, it will be verified before setting it as the active library.
+ *
+ * @param eccLib The instance of the ECC library to initialize.
+ * @param opts Extra initialization options. Use {DANGER_DO_NOT_VERIFY_ECCLIB:true} if ecc verification should not be executed. Not recommended!
+ */
+export declare function initEccLib(eccLib: TinySecp256k1Interface | undefined, opts?: {
+    DANGER_DO_NOT_VERIFY_ECCLIB: boolean;
+}): void;
+/**
+ * Retrieves the ECC Library instance.
+ * Throws an error if the ECC Library is not provided.
+ * You must call initEccLib() with a valid TinySecp256k1Interface instance before calling this function.
+ * @returns The ECC Library instance.
+ * @throws Error if the ECC Library is not provided.
+ */
+export declare function getEccLib(): TinySecp256k1Interface;