@meteora-ag/cp-amm-sdk 1.0.4 → 1.0.5

package/node_modules/@noble/hashes/src/sha3.ts

@@ -1,258 +0,0 @@
-/**
- * SHA3 (keccak) hash function, based on a new "Sponge function" design.
- * Different from older hashes, the internal state is bigger than output size.
- *
- * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
- * [Website](https://keccak.team/keccak.html),
- * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
- *
- * Check out `sha3-addons` module for cSHAKE, k12, and others.
- * @module
- */
-import { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.ts';
-// prettier-ignore
-import {
-  abytes, aexists, anumber, aoutput,
-  clean, createHasher, createXOFer, Hash,
-  swap32IfBE,
-  toBytes, u32,
-  type CHash, type CHashXO, type HashXOF, type Input
-} from './utils.ts';
-
-// No __PURE__ annotations in sha3 header:
-// EVERYTHING is in fact used on every export.
-// Various per round constants calculations
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _7n = BigInt(7);
-const _256n = BigInt(256);
-const _0x71n = BigInt(0x71);
-const SHA3_PI: number[] = [];
-const SHA3_ROTL: number[] = [];
-const _SHA3_IOTA: bigint[] = [];
-for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
-  // Pi
-  [x, y] = [y, (2 * x + 3 * y) % 5];
-  SHA3_PI.push(2 * (5 * y + x));
-  // Rotational
-  SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
-  // Iota
-  let t = _0n;
-  for (let j = 0; j < 7; j++) {
-    R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
-    if (R & _2n) t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
-  }
-  _SHA3_IOTA.push(t);
-}
-const IOTAS = split(_SHA3_IOTA, true);
-const SHA3_IOTA_H = IOTAS[0];
-const SHA3_IOTA_L = IOTAS[1];
-
-// Left rotation (without 0, 32, 64)
-const rotlH = (h: number, l: number, s: number) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
-const rotlL = (h: number, l: number, s: number) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
-
-/** `keccakf1600` internal function, additionally allows to adjust round count. */
-export function keccakP(s: Uint32Array, rounds: number = 24): void {
-  const B = new Uint32Array(5 * 2);
-  // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
-  for (let round = 24 - rounds; round < 24; round++) {
-    // Theta θ
-    for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-    for (let x = 0; x < 10; x += 2) {
-      const idx1 = (x + 8) % 10;
-      const idx0 = (x + 2) % 10;
-      const B0 = B[idx0];
-      const B1 = B[idx0 + 1];
-      const Th = rotlH(B0, B1, 1) ^ B[idx1];
-      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-      for (let y = 0; y < 50; y += 10) {
-        s[x + y] ^= Th;
-        s[x + y + 1] ^= Tl;
-      }
-    }
-    // Rho (ρ) and Pi (π)
-    let curH = s[2];
-    let curL = s[3];
-    for (let t = 0; t < 24; t++) {
-      const shift = SHA3_ROTL[t];
-      const Th = rotlH(curH, curL, shift);
-      const Tl = rotlL(curH, curL, shift);
-      const PI = SHA3_PI[t];
-      curH = s[PI];
-      curL = s[PI + 1];
-      s[PI] = Th;
-      s[PI + 1] = Tl;
-    }
-    // Chi (χ)
-    for (let y = 0; y < 50; y += 10) {
-      for (let x = 0; x < 10; x++) B[x] = s[y + x];
-      for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
-    }
-    // Iota (ι)
-    s[0] ^= SHA3_IOTA_H[round];
-    s[1] ^= SHA3_IOTA_L[round];
-  }
-  clean(B);
-}
-
-/** Keccak sponge function. */
-export class Keccak extends Hash<Keccak> implements HashXOF<Keccak> {
-  protected state: Uint8Array;
-  protected pos = 0;
-  protected posOut = 0;
-  protected finished = false;
-  protected state32: Uint32Array;
-  protected destroyed = false;
-
-  public blockLen: number;
-  public suffix: number;
-  public outputLen: number;
-  protected enableXOF = false;
-  protected rounds: number;
-
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(
-    blockLen: number,
-    suffix: number,
-    outputLen: number,
-    enableXOF = false,
-    rounds: number = 24
-  ) {
-    super();
-    this.blockLen = blockLen;
-    this.suffix = suffix;
-    this.outputLen = outputLen;
-    this.enableXOF = enableXOF;
-    this.rounds = rounds;
-    // Can be passed from user as dkLen
-    anumber(outputLen);
-    // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
-    // 0 < blockLen < 200
-    if (!(0 < blockLen && blockLen < 200))
-      throw new Error('only keccak-f1600 function is supported');
-    this.state = new Uint8Array(200);
-    this.state32 = u32(this.state);
-  }
-  clone(): Keccak {
-    return this._cloneInto();
-  }
-  protected keccak(): void {
-    swap32IfBE(this.state32);
-    keccakP(this.state32, this.rounds);
-    swap32IfBE(this.state32);
-    this.posOut = 0;
-    this.pos = 0;
-  }
-  update(data: Input): this {
-    aexists(this);
-    data = toBytes(data);
-    abytes(data);
-    const { blockLen, state } = this;
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
-      if (this.pos === blockLen) this.keccak();
-    }
-    return this;
-  }
-  protected finish(): void {
-    if (this.finished) return;
-    this.finished = true;
-    const { state, suffix, pos, blockLen } = this;
-    // Do the padding
-    state[pos] ^= suffix;
-    if ((suffix & 0x80) !== 0 && pos === blockLen - 1) this.keccak();
-    state[blockLen - 1] ^= 0x80;
-    this.keccak();
-  }
-  protected writeInto(out: Uint8Array): Uint8Array {
-    aexists(this, false);
-    abytes(out);
-    this.finish();
-    const bufferOut = this.state;
-    const { blockLen } = this;
-    for (let pos = 0, len = out.length; pos < len; ) {
-      if (this.posOut >= blockLen) this.keccak();
-      const take = Math.min(blockLen - this.posOut, len - pos);
-      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-      this.posOut += take;
-      pos += take;
-    }
-    return out;
-  }
-  xofInto(out: Uint8Array): Uint8Array {
-    // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
-    if (!this.enableXOF) throw new Error('XOF is not possible for this instance');
-    return this.writeInto(out);
-  }
-  xof(bytes: number): Uint8Array {
-    anumber(bytes);
-    return this.xofInto(new Uint8Array(bytes));
-  }
-  digestInto(out: Uint8Array): Uint8Array {
-    aoutput(out, this);
-    if (this.finished) throw new Error('digest() was already called');
-    this.writeInto(out);
-    this.destroy();
-    return out;
-  }
-  digest(): Uint8Array {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-  destroy(): void {
-    this.destroyed = true;
-    clean(this.state);
-  }
-  _cloneInto(to?: Keccak): Keccak {
-    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-    to ||= new Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
-    to.state32.set(this.state32);
-    to.pos = this.pos;
-    to.posOut = this.posOut;
-    to.finished = this.finished;
-    to.rounds = rounds;
-    // Suffix can change in cSHAKE
-    to.suffix = suffix;
-    to.outputLen = outputLen;
-    to.enableXOF = enableXOF;
-    to.destroyed = this.destroyed;
-    return to;
-  }
-}
-
-const gen = (suffix: number, blockLen: number, outputLen: number) =>
-  createHasher(() => new Keccak(blockLen, suffix, outputLen));
-
-/** SHA3-224 hash function. */
-export const sha3_224: CHash = /* @__PURE__ */ (() => gen(0x06, 144, 224 / 8))();
-/** SHA3-256 hash function. Different from keccak-256. */
-export const sha3_256: CHash = /* @__PURE__ */ (() => gen(0x06, 136, 256 / 8))();
-/** SHA3-384 hash function. */
-export const sha3_384: CHash = /* @__PURE__ */ (() => gen(0x06, 104, 384 / 8))();
-/** SHA3-512 hash function. */
-export const sha3_512: CHash = /* @__PURE__ */ (() => gen(0x06, 72, 512 / 8))();
-
-/** keccak-224 hash function. */
-export const keccak_224: CHash = /* @__PURE__ */ (() => gen(0x01, 144, 224 / 8))();
-/** keccak-256 hash function. Different from SHA3-256. */
-export const keccak_256: CHash = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();
-/** keccak-384 hash function. */
-export const keccak_384: CHash = /* @__PURE__ */ (() => gen(0x01, 104, 384 / 8))();
-/** keccak-512 hash function. */
-export const keccak_512: CHash = /* @__PURE__ */ (() => gen(0x01, 72, 512 / 8))();
-
-export type ShakeOpts = { dkLen?: number };
-
-const genShake = (suffix: number, blockLen: number, outputLen: number) =>
-  createXOFer<HashXOF<Keccak>, ShakeOpts>(
-    (opts: ShakeOpts = {}) =>
-      new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true)
-  );
-
-/** SHAKE128 XOF with 128-bit security. */
-export const shake128: CHashXO = /* @__PURE__ */ (() => genShake(0x1f, 168, 128 / 8))();
-/** SHAKE256 XOF with 256-bit security. */
-export const shake256: CHashXO = /* @__PURE__ */ (() => genShake(0x1f, 136, 256 / 8))();

package/node_modules/@noble/hashes/src/sha512.ts

@@ -1,34 +0,0 @@
-/**
- * SHA2-512 a.k.a. sha512 and sha384. It is slower than sha256 in js because u64 operations are slow.
- *
- * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
- * [the paper on truncated SHA512/256](https://eprint.iacr.org/2010/548.pdf).
- * @module
- * @deprecated
- */
-import {
-  SHA384 as SHA384n,
-  sha384 as sha384n,
-  sha512_224 as sha512_224n,
-  SHA512_224 as SHA512_224n,
-  sha512_256 as sha512_256n,
-  SHA512_256 as SHA512_256n,
-  SHA512 as SHA512n,
-  sha512 as sha512n,
-} from './sha2.ts';
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const SHA512: typeof SHA512n = SHA512n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const sha512: typeof sha512n = sha512n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const SHA384: typeof SHA384n = SHA384n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const sha384: typeof sha384n = sha384n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const SHA512_224: typeof SHA512_224n = SHA512_224n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const sha512_224: typeof sha512_224n = sha512_224n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const SHA512_256: typeof SHA512_256n = SHA512_256n;
-/** @deprecated Use import from `noble/hashes/sha2` module */
-export const sha512_256: typeof sha512_256n = sha512_256n;

package/node_modules/@noble/hashes/src/utils.ts

@@ -1,395 +0,0 @@
-/**
- * Utilities for hex, bytes, CSPRNG.
- * @module
- */
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-
-// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
-// node.js versions earlier than v19 don't declare it in global scope.
-// For node.js, package.json#exports field mapping rewrites import
-// from `crypto` to `cryptoNode`, which imports native module.
-// Makes the utils un-importable in browsers without a bundler.
-// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-import { crypto } from '@noble/hashes/crypto';
-
-/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
-export function isBytes(a: unknown): a is Uint8Array {
-  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
-}
-
-/** Asserts something is positive integer. */
-export function anumber(n: number): void {
-  if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);
-}
-
-/** Asserts something is Uint8Array. */
-export function abytes(b: Uint8Array | undefined, ...lengths: number[]): void {
-  if (!isBytes(b)) throw new Error('Uint8Array expected');
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
-}
-
-/** Asserts something is hash */
-export function ahash(h: IHash): void {
-  if (typeof h !== 'function' || typeof h.create !== 'function')
-    throw new Error('Hash should be wrapped by utils.createHasher');
-  anumber(h.outputLen);
-  anumber(h.blockLen);
-}
-
-/** Asserts a hash instance has not been destroyed / finished */
-export function aexists(instance: any, checkFinished = true): void {
-  if (instance.destroyed) throw new Error('Hash instance has been destroyed');
-  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');
-}
-
-/** Asserts output is properly-sized byte array */
-export function aoutput(out: any, instance: any): void {
-  abytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error('digestInto() expects output buffer of length at least ' + min);
-  }
-}
-
-/** Generic type encompassing 8/16/32-byte arrays - but not 64-byte. */
-// prettier-ignore
-export type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |
-  Uint16Array | Int16Array | Uint32Array | Int32Array;
-
-/** Cast u8 / u16 / u32 to u8. */
-export function u8(arr: TypedArray): Uint8Array {
-  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-
-/** Cast u8 / u16 / u32 to u32. */
-export function u32(arr: TypedArray): Uint32Array {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-
-/** Zeroize a byte array. Warning: JS provides no guarantees. */
-export function clean(...arrays: TypedArray[]): void {
-  for (let i = 0; i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-
-/** Create DataView of an array for easy byte-level manipulation. */
-export function createView(arr: TypedArray): DataView {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-
-/** The rotate right (circular right shift) operation for uint32 */
-export function rotr(word: number, shift: number): number {
-  return (word << (32 - shift)) | (word >>> shift);
-}
-
-/** The rotate left (circular left shift) operation for uint32 */
-export function rotl(word: number, shift: number): number {
-  return (word << shift) | ((word >>> (32 - shift)) >>> 0);
-}
-
-/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
-export const isLE: boolean = /* @__PURE__ */ (() =>
-  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
-
-/** The byte swap operation for uint32 */
-export function byteSwap(word: number): number {
-  return (
-    ((word << 24) & 0xff000000) |
-    ((word << 8) & 0xff0000) |
-    ((word >>> 8) & 0xff00) |
-    ((word >>> 24) & 0xff)
-  );
-}
-/** Conditionally byte swap if on a big-endian platform */
-export const swap8IfBE: (n: number) => number = isLE
-  ? (n: number) => n
-  : (n: number) => byteSwap(n);
-
-/** @deprecated */
-export const byteSwapIfBE: typeof swap8IfBE = swap8IfBE;
-/** In place byte swap for Uint32Array */
-export function byteSwap32(arr: Uint32Array): Uint32Array {
-  for (let i = 0; i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
-}
-
-export const swap32IfBE: (u: Uint32Array) => Uint32Array = isLE
-  ? (u: Uint32Array) => u
-  : byteSwap32;
-
-// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
-const hasHexBuiltin: boolean = /* @__PURE__ */ (() =>
-  // @ts-ignore
-  typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
-
-// Array where index 0xf0 (240) is mapped to string 'f0'
-const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
-  i.toString(16).padStart(2, '0')
-);
-
-/**
- * Convert byte array to hex string. Uses built-in function, when available.
- * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
- */
-export function bytesToHex(bytes: Uint8Array): string {
-  abytes(bytes);
-  // @ts-ignore
-  if (hasHexBuiltin) return bytes.toHex();
-  // pre-caching improves the speed 6x
-  let hex = '';
-  for (let i = 0; i < bytes.length; i++) {
-    hex += hexes[bytes[i]];
-  }
-  return hex;
-}
-
-// We use optimized technique to convert hex string to byte array
-const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;
-function asciiToBase16(ch: number): number | undefined {
-  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48
-  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)
-  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)
-  return;
-}
-
-/**
- * Convert hex string to byte array. Uses built-in function, when available.
- * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
- */
-export function hexToBytes(hex: string): Uint8Array {
-  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
-  // @ts-ignore
-  if (hasHexBuiltin) return Uint8Array.fromHex(hex);
-  const hl = hex.length;
-  const al = hl / 2;
-  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);
-  const array = new Uint8Array(al);
-  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-    const n1 = asciiToBase16(hex.charCodeAt(hi));
-    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-    if (n1 === undefined || n2 === undefined) {
-      const char = hex[hi] + hex[hi + 1];
-      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-    }
-    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
-  }
-  return array;
-}
-
-/**
- * There is no setImmediate in browser and setTimeout is slow.
- * Call of async fn will return Promise, which will be fullfiled only on
- * next scheduler queue processing step and this is exactly what we need.
- */
-export const nextTick = async (): Promise<void> => {};
-
-/** Returns control to thread each 'tick' ms to avoid blocking. */
-export async function asyncLoop(
-  iters: number,
-  tick: number,
-  cb: (i: number) => void
-): Promise<void> {
-  let ts = Date.now();
-  for (let i = 0; i < iters; i++) {
-    cb(i);
-    // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
-    const diff = Date.now() - ts;
-    if (diff >= 0 && diff < tick) continue;
-    await nextTick();
-    ts += diff;
-  }
-}
-
-// Global symbols, but ts doesn't see them: https://github.com/microsoft/TypeScript/issues/31535
-declare const TextEncoder: any;
-declare const TextDecoder: any;
-
-/**
- * Converts string to bytes using UTF8 encoding.
- * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
- */
-export function utf8ToBytes(str: string): Uint8Array {
-  if (typeof str !== 'string') throw new Error('string expected');
-  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
-}
-
-/**
- * Converts bytes to string using UTF8 encoding.
- * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
- */
-export function bytesToUtf8(bytes: Uint8Array): string {
-  return new TextDecoder().decode(bytes);
-}
-
-/** Accepted input of hash functions. Strings are converted to byte arrays. */
-export type Input = string | Uint8Array;
-/**
- * Normalizes (non-hex) string or Uint8Array to Uint8Array.
- * Warning: when Uint8Array is passed, it would NOT get copied.
- * Keep in mind for future mutable operations.
- */
-export function toBytes(data: Input): Uint8Array {
-  if (typeof data === 'string') data = utf8ToBytes(data);
-  abytes(data);
-  return data;
-}
-
-/** KDFs can accept string or Uint8Array for user convenience. */
-export type KDFInput = string | Uint8Array;
-/**
- * Helper for KDFs: consumes uint8array or string.
- * When string is passed, does utf8 decoding, using TextDecoder.
- */
-export function kdfInputToBytes(data: KDFInput): Uint8Array {
-  if (typeof data === 'string') data = utf8ToBytes(data);
-  abytes(data);
-  return data;
-}
-
-/** Copies several Uint8Arrays into one. */
-export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
-  let sum = 0;
-  for (let i = 0; i < arrays.length; i++) {
-    const a = arrays[i];
-    abytes(a);
-    sum += a.length;
-  }
-  const res = new Uint8Array(sum);
-  for (let i = 0, pad = 0; i < arrays.length; i++) {
-    const a = arrays[i];
-    res.set(a, pad);
-    pad += a.length;
-  }
-  return res;
-}
-
-type EmptyObj = {};
-export function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(
-  defaults: T1,
-  opts?: T2
-): T1 & T2 {
-  if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
-    throw new Error('options should be object or undefined');
-  const merged = Object.assign(defaults, opts);
-  return merged as T1 & T2;
-}
-
-/** Hash interface. */
-export type IHash = {
-  (data: Uint8Array): Uint8Array;
-  blockLen: number;
-  outputLen: number;
-  create: any;
-};
-
-/** For runtime check if class implements interface */
-export abstract class Hash<T extends Hash<T>> {
-  abstract blockLen: number; // Bytes per block
-  abstract outputLen: number; // Bytes in output
-  abstract update(buf: Input): this;
-  // Writes digest into buf
-  abstract digestInto(buf: Uint8Array): void;
-  abstract digest(): Uint8Array;
-  /**
-   * Resets internal state. Makes Hash instance unusable.
-   * Reset is impossible for keyed hashes if key is consumed into state. If digest is not consumed
-   * by user, they will need to manually call `destroy()` when zeroing is necessary.
-   */
-  abstract destroy(): void;
-  /**
-   * Clones hash instance. Unsafe: doesn't check whether `to` is valid. Can be used as `clone()`
-   * when no options are passed.
-   * Reasons to use `_cloneInto` instead of clone: 1) performance 2) reuse instance => all internal
-   * buffers are overwritten => causes buffer overwrite which is used for digest in some cases.
-   * There are no guarantees for clean-up because it's impossible in JS.
-   */
-  abstract _cloneInto(to?: T): T;
-  // Safe version that clones internal state
-  abstract clone(): T;
-}
-
-/**
- * XOF: streaming API to read digest in chunks.
- * Same as 'squeeze' in keccak/k12 and 'seek' in blake3, but more generic name.
- * When hash used in XOF mode it is up to user to call '.destroy' afterwards, since we cannot
- * destroy state, next call can require more bytes.
- */
-export type HashXOF<T extends Hash<T>> = Hash<T> & {
-  xof(bytes: number): Uint8Array; // Read 'bytes' bytes from digest stream
-  xofInto(buf: Uint8Array): Uint8Array; // read buf.length bytes from digest stream into buf
-};
-
-/** Hash function */
-export type CHash = ReturnType<typeof createHasher>;
-/** Hash function with output */
-export type CHashO = ReturnType<typeof createOptHasher>;
-/** XOF with output */
-export type CHashXO = ReturnType<typeof createXOFer>;
-
-/** Wraps hash function, creating an interface on top of it */
-export function createHasher<T extends Hash<T>>(
-  hashCons: () => Hash<T>
-): {
-  (msg: Input): Uint8Array;
-  outputLen: number;
-  blockLen: number;
-  create(): Hash<T>;
-} {
-  const hashC = (msg: Input): Uint8Array => hashCons().update(toBytes(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-
-export function createOptHasher<H extends Hash<H>, T extends Object>(
-  hashCons: (opts?: T) => Hash<H>
-): {
-  (msg: Input, opts?: T): Uint8Array;
-  outputLen: number;
-  blockLen: number;
-  create(opts?: T): Hash<H>;
-} {
-  const hashC = (msg: Input, opts?: T): Uint8Array => hashCons(opts).update(toBytes(msg)).digest();
-  const tmp = hashCons({} as T);
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = (opts?: T) => hashCons(opts);
-  return hashC;
-}
-
-export function createXOFer<H extends HashXOF<H>, T extends Object>(
-  hashCons: (opts?: T) => HashXOF<H>
-): {
-  (msg: Input, opts?: T): Uint8Array;
-  outputLen: number;
-  blockLen: number;
-  create(opts?: T): HashXOF<H>;
-} {
-  const hashC = (msg: Input, opts?: T): Uint8Array => hashCons(opts).update(toBytes(msg)).digest();
-  const tmp = hashCons({} as T);
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = (opts?: T) => hashCons(opts);
-  return hashC;
-}
-export const wrapConstructor: typeof createHasher = createHasher;
-export const wrapConstructorWithOpts: typeof createOptHasher = createOptHasher;
-export const wrapXOFConstructorWithOpts: typeof createXOFer = createXOFer;
-
-/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
-export function randomBytes(bytesLength = 32): Uint8Array {
-  if (crypto && typeof crypto.getRandomValues === 'function') {
-    return crypto.getRandomValues(new Uint8Array(bytesLength));
-  }
-  // Legacy Node.js compatibility
-  if (crypto && typeof crypto.randomBytes === 'function') {
-    return Uint8Array.from(crypto.randomBytes(bytesLength));
-  }
-  throw new Error('crypto.getRandomValues must be defined');
-}