@meteora-ag/cp-amm-sdk 1.0.1 → 1.0.2

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

@@ -1,189 +0,0 @@
-/**
- * Experimental KDF for AES.
- */
-import { abytes } from './_assert.js';
-import { hkdf } from './hkdf.js';
-import { sha256 } from './sha256.js';
-import { pbkdf2 as _pbkdf2 } from './pbkdf2.js';
-import { scrypt as _scrypt } from './scrypt.js';
-import { bytesToHex, createView, hexToBytes, toBytes } from './utils.js';
-
-// A tiny KDF for various applications like AES key-gen.
-// Uses HKDF in a non-standard way, so it's not "KDF-secure", only "PRF-secure".
-// Which is good enough: assume sha2-256 retained preimage resistance.
-
-const SCRYPT_FACTOR = 2 ** 19;
-const PBKDF2_FACTOR = 2 ** 17;
-
-// Scrypt KDF
-export function scrypt(password: string, salt: string): Uint8Array {
-  return _scrypt(password, salt, { N: SCRYPT_FACTOR, r: 8, p: 1, dkLen: 32 });
-}
-
-// PBKDF2-HMAC-SHA256
-export function pbkdf2(password: string, salt: string): Uint8Array {
-  return _pbkdf2(sha256, password, salt, { c: PBKDF2_FACTOR, dkLen: 32 });
-}
-
-// Combines two 32-byte byte arrays
-function xor32(a: Uint8Array, b: Uint8Array): Uint8Array {
-  abytes(a, 32);
-  abytes(b, 32);
-  const arr = new Uint8Array(32);
-  for (let i = 0; i < 32; i++) {
-    arr[i] = a[i] ^ b[i];
-  }
-  return arr;
-}
-
-function strHasLength(str: string, min: number, max: number): boolean {
-  return typeof str === 'string' && str.length >= min && str.length <= max;
-}
-
-/**
- * Derives main seed. Takes a lot of time. Prefer `eskdf` method instead.
- */
-export function deriveMainSeed(username: string, password: string): Uint8Array {
-  if (!strHasLength(username, 8, 255)) throw new Error('invalid username');
-  if (!strHasLength(password, 8, 255)) throw new Error('invalid password');
-  // Declared like this to throw off minifiers which auto-convert .fromCharCode(1) to actual string.
-  // String with non-ascii may be problematic in some envs
-  const codes = { _1: 1, _2: 2 };
-  const sep = { s: String.fromCharCode(codes._1), p: String.fromCharCode(codes._2) };
-  const scr = scrypt(password + sep.s, username + sep.s);
-  const pbk = pbkdf2(password + sep.p, username + sep.p);
-  const res = xor32(scr, pbk);
-  scr.fill(0);
-  pbk.fill(0);
-  return res;
-}
-
-type AccountID = number | string;
-
-/**
- * Converts protocol & accountId pair to HKDF salt & info params.
- */
-function getSaltInfo(protocol: string, accountId: AccountID = 0) {
-  // Note that length here also repeats two lines below
-  // We do an additional length check here to reduce the scope of DoS attacks
-  if (!(strHasLength(protocol, 3, 15) && /^[a-z0-9]{3,15}$/.test(protocol))) {
-    throw new Error('invalid protocol');
-  }
-
-  // Allow string account ids for some protocols
-  const allowsStr = /^password\d{0,3}|ssh|tor|file$/.test(protocol);
-  let salt: Uint8Array; // Extract salt. Default is undefined.
-  if (typeof accountId === 'string') {
-    if (!allowsStr) throw new Error('accountId must be a number');
-    if (!strHasLength(accountId, 1, 255))
-      throw new Error('accountId must be string of length 1..255');
-    salt = toBytes(accountId);
-  } else if (Number.isSafeInteger(accountId)) {
-    if (accountId < 0 || accountId > 2 ** 32 - 1) throw new Error('invalid accountId');
-    // Convert to Big Endian Uint32
-    salt = new Uint8Array(4);
-    createView(salt).setUint32(0, accountId, false);
-  } else {
-    throw new Error('accountId must be a number' + (allowsStr ? ' or string' : ''));
-  }
-  const info = toBytes(protocol);
-  return { salt, info };
-}
-
-type OptsLength = { keyLength: number };
-type OptsMod = { modulus: bigint };
-type KeyOpts = undefined | OptsLength | OptsMod;
-
-function countBytes(num: bigint): number {
-  if (typeof num !== 'bigint' || num <= BigInt(128)) throw new Error('invalid number');
-  return Math.ceil(num.toString(2).length / 8);
-}
-
-/**
- * Parses keyLength and modulus options to extract length of result key.
- * If modulus is used, adds 64 bits to it as per FIPS 186 B.4.1 to combat modulo bias.
- */
-function getKeyLength(options: KeyOpts): number {
-  if (!options || typeof options !== 'object') return 32;
-  const hasLen = 'keyLength' in options;
-  const hasMod = 'modulus' in options;
-  if (hasLen && hasMod) throw new Error('cannot combine keyLength and modulus options');
-  if (!hasLen && !hasMod) throw new Error('must have either keyLength or modulus option');
-  // FIPS 186 B.4.1 requires at least 64 more bits
-  const l = hasMod ? countBytes(options.modulus) + 8 : options.keyLength;
-  if (!(typeof l === 'number' && l >= 16 && l <= 8192)) throw new Error('invalid keyLength');
-  return l;
-}
-
-/**
- * Converts key to bigint and divides it by modulus. Big Endian.
- * Implements FIPS 186 B.4.1, which removes 0 and modulo bias from output.
- */
-function modReduceKey(key: Uint8Array, modulus: bigint): Uint8Array {
-  const _1 = BigInt(1);
-  const num = BigInt('0x' + bytesToHex(key)); // check for ui8a, then bytesToNumber()
-  const res = (num % (modulus - _1)) + _1; // Remove 0 from output
-  if (res < _1) throw new Error('expected positive number'); // Guard against bad values
-  const len = key.length - 8; // FIPS requires 64 more bits = 8 bytes
-  const hex = res.toString(16).padStart(len * 2, '0'); // numberToHex()
-  const bytes = hexToBytes(hex);
-  if (bytes.length !== len) throw new Error('invalid length of result key');
-  return bytes;
-}
-
-// We are not using classes because constructor cannot be async
-export interface ESKDF {
-  /**
-   * Derives a child key. Child key will not be associated with any
-   * other child key because of properties of underlying KDF.
-   *
-   * @param protocol - 3-15 character protocol name
-   * @param accountId - numeric identifier of account
-   * @param options - `keyLength: 64` or `modulus: 41920438n`
-   * @example deriveChildKey('aes', 0)
-   */
-  deriveChildKey: (protocol: string, accountId: AccountID, options?: KeyOpts) => Uint8Array;
-  /**
-   * Deletes the main seed from eskdf instance
-   */
-  expire: () => void;
-  /**
-   * Account fingerprint
-   */
-  fingerprint: string;
-}
-
-/**
- * ESKDF
- * @param username - username, email, or identifier, min: 8 characters, should have enough entropy
- * @param password - password, min: 8 characters, should have enough entropy
- * @example
- * const kdf = await eskdf('example-university', 'beginning-new-example');
- * const key = kdf.deriveChildKey('aes', 0);
- * console.log(kdf.fingerprint);
- * kdf.expire();
- */
-export async function eskdf(username: string, password: string): Promise<ESKDF> {
-  // We are using closure + object instead of class because
-  // we want to make `seed` non-accessible for any external function.
-  let seed: Uint8Array | undefined = deriveMainSeed(username, password);
-
-  function deriveCK(protocol: string, accountId: AccountID = 0, options?: KeyOpts): Uint8Array {
-    abytes(seed, 32);
-    const { salt, info } = getSaltInfo(protocol, accountId); // validate protocol & accountId
-    const keyLength = getKeyLength(options); // validate options
-    const key = hkdf(sha256, seed!, salt, info, keyLength);
-    // Modulus has already been validated
-    return options && 'modulus' in options ? modReduceKey(key, options.modulus) : key;
-  }
-  function expire() {
-    if (seed) seed.fill(1);
-    seed = undefined;
-  }
-  // prettier-ignore
-  const fingerprint = Array.from(deriveCK('fingerprint', 0))
-    .slice(0, 6)
-    .map((char) => char.toString(16).padStart(2, '0').toUpperCase())
-    .join(':');
-  return Object.freeze({ deriveChildKey: deriveCK, expire, fingerprint });
-}

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

@@ -1,89 +0,0 @@
-/**
- * HKDF (RFC 5869): extract + expand in one step.
- * See https://soatok.blog/2021/11/17/understanding-hkdf/.
- * @module
- */
-import { ahash, anumber } from './_assert.js';
-import { hmac } from './hmac.js';
-import { type CHash, type Input, toBytes } from './utils.js';
-
-/**
- * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
- * Arguments position differs from spec (IKM is first one, since it is not optional)
- * @param hash - hash function that would be used (e.g. sha256)
- * @param ikm - input keying material, the initial key
- * @param salt - optional salt value (a non-secret random value)
- */
-export function extract(hash: CHash, ikm: Input, salt?: Input): Uint8Array {
-  ahash(hash);
-  // NOTE: some libraries treat zero-length array as 'not provided';
-  // we don't, since we have undefined as 'not provided'
-  // https://github.com/RustCrypto/KDFs/issues/15
-  if (salt === undefined) salt = new Uint8Array(hash.outputLen);
-  return hmac(hash, toBytes(salt), toBytes(ikm));
-}
-
-const HKDF_COUNTER = /* @__PURE__ */ new Uint8Array([0]);
-const EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array();
-
-/**
- * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
- * @param hash - hash function that would be used (e.g. sha256)
- * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
- * @param info - optional context and application specific information (can be a zero-length string)
- * @param length - length of output keying material in bytes
- */
-export function expand(hash: CHash, prk: Input, info?: Input, length: number = 32): Uint8Array {
-  ahash(hash);
-  anumber(length);
-  if (length > 255 * hash.outputLen) throw new Error('Length should be <= 255*HashLen');
-  const blocks = Math.ceil(length / hash.outputLen);
-  if (info === undefined) info = EMPTY_BUFFER;
-  // first L(ength) octets of T
-  const okm = new Uint8Array(blocks * hash.outputLen);
-  // Re-use HMAC instance between blocks
-  const HMAC = hmac.create(hash, prk);
-  const HMACTmp = HMAC._cloneInto();
-  const T = new Uint8Array(HMAC.outputLen);
-  for (let counter = 0; counter < blocks; counter++) {
-    HKDF_COUNTER[0] = counter + 1;
-    // T(0) = empty string (zero length)
-    // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
-    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)
-      .update(info)
-      .update(HKDF_COUNTER)
-      .digestInto(T);
-    okm.set(T, hash.outputLen * counter);
-    HMAC._cloneInto(HMACTmp);
-  }
-  HMAC.destroy();
-  HMACTmp.destroy();
-  T.fill(0);
-  HKDF_COUNTER.fill(0);
-  return okm.slice(0, length);
-}
-
-/**
- * HKDF (RFC 5869): derive keys from an initial input.
- * Combines hkdf_extract + hkdf_expand in one step
- * @param hash - hash function that would be used (e.g. sha256)
- * @param ikm - input keying material, the initial key
- * @param salt - optional salt value (a non-secret random value)
- * @param info - optional context and application specific information (can be a zero-length string)
- * @param length - length of output keying material in bytes
- * @example
- * import { hkdf } from '@noble/hashes/hkdf';
- * import { sha256 } from '@noble/hashes/sha2';
- * import { randomBytes } from '@noble/hashes/utils';
- * const inputKey = randomBytes(32);
- * const salt = randomBytes(32);
- * const info = 'application-key';
- * const hk1 = hkdf(sha256, inputKey, salt, info, 32);
- */
-export const hkdf = (
-  hash: CHash,
-  ikm: Input,
-  salt: Input | undefined,
-  info: Input | undefined,
-  length: number
-): Uint8Array => expand(hash, extract(hash, ikm, salt), info, length);

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

@@ -1,92 +0,0 @@
-/**
- * HMAC: RFC2104 message authentication code.
- * @module
- */
-import { abytes, aexists, ahash } from './_assert.js';
-import { Hash, toBytes, type CHash, type Input } from './utils.js';
-
-export class HMAC<T extends Hash<T>> extends Hash<HMAC<T>> {
-  oHash: T;
-  iHash: T;
-  blockLen: number;
-  outputLen: number;
-  private finished = false;
-  private destroyed = false;
-
-  constructor(hash: CHash, _key: Input) {
-    super();
-    ahash(hash);
-    const key = toBytes(_key);
-    this.iHash = hash.create() as T;
-    if (typeof this.iHash.update !== 'function')
-      throw new Error('Expected instance of class which extends utils.Hash');
-    this.blockLen = this.iHash.blockLen;
-    this.outputLen = this.iHash.outputLen;
-    const blockLen = this.blockLen;
-    const pad = new Uint8Array(blockLen);
-    // blockLen can be bigger than outputLen
-    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-    for (let i = 0; i < pad.length; i++) pad[i] ^= 0x36;
-    this.iHash.update(pad);
-    // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
-    this.oHash = hash.create() as T;
-    // Undo internal XOR && apply outer XOR
-    for (let i = 0; i < pad.length; i++) pad[i] ^= 0x36 ^ 0x5c;
-    this.oHash.update(pad);
-    pad.fill(0);
-  }
-  update(buf: Input): this {
-    aexists(this);
-    this.iHash.update(buf);
-    return this;
-  }
-  digestInto(out: Uint8Array): void {
-    aexists(this);
-    abytes(out, this.outputLen);
-    this.finished = true;
-    this.iHash.digestInto(out);
-    this.oHash.update(out);
-    this.oHash.digestInto(out);
-    this.destroy();
-  }
-  digest(): Uint8Array {
-    const out = new Uint8Array(this.oHash.outputLen);
-    this.digestInto(out);
-    return out;
-  }
-  _cloneInto(to?: HMAC<T>): HMAC<T> {
-    // Create new instance without calling constructor since key already in state and we don't know it.
-    to ||= Object.create(Object.getPrototypeOf(this), {});
-    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-    to = to as this;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    to.blockLen = blockLen;
-    to.outputLen = outputLen;
-    to.oHash = oHash._cloneInto(to.oHash);
-    to.iHash = iHash._cloneInto(to.iHash);
-    return to;
-  }
-  destroy(): void {
-    this.destroyed = true;
-    this.oHash.destroy();
-    this.iHash.destroy();
-  }
-}
-
-/**
- * HMAC: RFC2104 message authentication code.
- * @param hash - function that would be used e.g. sha256
- * @param key - message key
- * @param message - message data
- * @example
- * import { hmac } from '@noble/hashes/hmac';
- * import { sha256 } from '@noble/hashes/sha2';
- * const mac1 = hmac(sha256, 'key', 'message');
- */
-export const hmac: {
-  (hash: CHash, key: Input, message: Input): Uint8Array;
-  create(hash: CHash, key: Input): HMAC<any>;
-} = (hash: CHash, key: Input, message: Input): Uint8Array =>
-  new HMAC<any>(hash, key).update(message).digest();
-hmac.create = (hash: CHash, key: Input) => new HMAC<any>(hash, key);

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

@@ -1,33 +0,0 @@
-/**
- * Audited & minimal JS implementation of hash functions, MACs and KDFs. Check out individual modules.
- * @module
- * @example
-```js
-import {
-  sha256, sha384, sha512, sha224, sha512_256, sha512_384
-} from '@noble/hashes/sha2';
-import {
-  sha3_224, sha3_256, sha3_384, sha3_512,
-  keccak_224, keccak_256, keccak_384, keccak_512,
-  shake128, shake256
-} from '@noble/hashes/sha3';
-import {
-  cshake128, cshake256,
-  turboshake128, turboshake256,
-  kmac128, kmac256,
-  tuplehash256, parallelhash256,
-  k12, m14, keccakprg
-} from '@noble/hashes/sha3-addons';
-import { ripemd160 } from '@noble/hashes/ripemd160';
-import { blake3 } from '@noble/hashes/blake3';
-import { blake2b } from '@noble/hashes/blake2b';
-import { blake2s } from '@noble/hashes/blake2s';
-import { hmac } from '@noble/hashes/hmac';
-import { hkdf } from '@noble/hashes/hkdf';
-import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2';
-import { scrypt, scryptAsync } from '@noble/hashes/scrypt';
-import { sha1 } from '@noble/hashes/sha1'; // legacy
-import * as utils from '@noble/hashes/utils';
-```
- */
-throw new Error('root module cannot be imported: import submodules instead. Check out README');

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

@@ -1,120 +0,0 @@
-/**
- * PBKDF (RFC 2898). Can be used to create a key from password and salt.
- * @module
- */
-import { ahash, anumber } from './_assert.js';
-import { hmac } from './hmac.js';
-import {
-  asyncLoop,
-  checkOpts,
-  createView,
-  Hash,
-  toBytes,
-  type CHash,
-  type Input,
-} from './utils.js';
-
-export type Pbkdf2Opt = {
-  c: number; // Iterations
-  dkLen?: number; // Desired key length in bytes (Intended output length in octets of the derived key
-  asyncTick?: number; // Maximum time in ms for which async function can block execution
-};
-// Common prologue and epilogue for sync/async functions
-function pbkdf2Init(hash: CHash, _password: Input, _salt: Input, _opts: Pbkdf2Opt) {
-  ahash(hash);
-  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
-  const { c, dkLen, asyncTick } = opts;
-  anumber(c);
-  anumber(dkLen);
-  anumber(asyncTick);
-  if (c < 1) throw new Error('PBKDF2: iterations (c) should be >= 1');
-  const password = toBytes(_password);
-  const salt = toBytes(_salt);
-  // DK = PBKDF2(PRF, Password, Salt, c, dkLen);
-  const DK = new Uint8Array(dkLen);
-  // U1 = PRF(Password, Salt + INT_32_BE(i))
-  const PRF = hmac.create(hash, password);
-  const PRFSalt = PRF._cloneInto().update(salt);
-  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
-}
-
-function pbkdf2Output<T extends Hash<T>>(
-  PRF: Hash<T>,
-  PRFSalt: Hash<T>,
-  DK: Uint8Array,
-  prfW: Hash<T>,
-  u: Uint8Array
-) {
-  PRF.destroy();
-  PRFSalt.destroy();
-  if (prfW) prfW.destroy();
-  u.fill(0);
-  return DK;
-}
-
-/**
- * PBKDF2-HMAC: RFC 2898 key derivation function
- * @param hash - hash function that would be used e.g. sha256
- * @param password - password from which a derived key is generated
- * @param salt - cryptographic salt
- * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
- * @example
- * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: 2 ** 18 });
- */
-export function pbkdf2(hash: CHash, password: Input, salt: Input, opts: Pbkdf2Opt): Uint8Array {
-  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
-  let prfW: any; // Working copy
-  const arr = new Uint8Array(4);
-  const view = createView(arr);
-  const u = new Uint8Array(PRF.outputLen);
-  // DK = T1 + T2 + ⋯ + Tdklen/hlen
-  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-    // Ti = F(Password, Salt, c, i)
-    const Ti = DK.subarray(pos, pos + PRF.outputLen);
-    view.setInt32(0, ti, false);
-    // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
-    // U1 = PRF(Password, Salt + INT_32_BE(i))
-    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-    Ti.set(u.subarray(0, Ti.length));
-    for (let ui = 1; ui < c; ui++) {
-      // Uc = PRF(Password, Uc−1)
-      PRF._cloneInto(prfW).update(u).digestInto(u);
-      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
-    }
-  }
-  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}
-
-/**
- * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
- * @example
- * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
- */
-export async function pbkdf2Async(
-  hash: CHash,
-  password: Input,
-  salt: Input,
-  opts: Pbkdf2Opt
-): Promise<Uint8Array> {
-  const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
-  let prfW: any; // Working copy
-  const arr = new Uint8Array(4);
-  const view = createView(arr);
-  const u = new Uint8Array(PRF.outputLen);
-  // DK = T1 + T2 + ⋯ + Tdklen/hlen
-  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-    // Ti = F(Password, Salt, c, i)
-    const Ti = DK.subarray(pos, pos + PRF.outputLen);
-    view.setInt32(0, ti, false);
-    // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
-    // U1 = PRF(Password, Salt + INT_32_BE(i))
-    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-    Ti.set(u.subarray(0, Ti.length));
-    await asyncLoop(c - 1, asyncTick, () => {
-      // Uc = PRF(Password, Uc−1)
-      PRF._cloneInto(prfW).update(u).digestInto(u);
-      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
-    });
-  }
-  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}

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

@@ -1,109 +0,0 @@
-/**
- * RIPEMD-160 legacy hash function.
- * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
- * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
- * @module
- */
-import { HashMD } from './_md.js';
-import { rotl, wrapConstructor, type CHash } from './utils.js';
-
-const Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
-const Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
-const Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
-let idxL = [Id];
-let idxR = [Pi];
-for (let i = 0; i < 4; i++) for (let j of [idxL, idxR]) j.push(j[i].map((k) => Rho[k]));
-
-const shifts = /* @__PURE__ */ [
-  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
-  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
-  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
-  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
-  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],
-].map((i) => new Uint8Array(i));
-const shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
-const shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
-const Kl = /* @__PURE__ */ new Uint32Array([
-  0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
-]);
-const Kr = /* @__PURE__ */ new Uint32Array([
-  0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
-]);
-// It's called f() in spec.
-function f(group: number, x: number, y: number, z: number): number {
-  if (group === 0) return x ^ y ^ z;
-  else if (group === 1) return (x & y) | (~x & z);
-  else if (group === 2) return (x | ~y) ^ z;
-  else if (group === 3) return (x & z) | (y & ~z);
-  else return x ^ (y | ~z);
-}
-// Temporary buffer, not used to store anything between runs
-const R_BUF = /* @__PURE__ */ new Uint32Array(16);
-export class RIPEMD160 extends HashMD<RIPEMD160> {
-  private h0 = 0x67452301 | 0;
-  private h1 = 0xefcdab89 | 0;
-  private h2 = 0x98badcfe | 0;
-  private h3 = 0x10325476 | 0;
-  private h4 = 0xc3d2e1f0 | 0;
-
-  constructor() {
-    super(64, 20, 8, true);
-  }
-  protected get(): [number, number, number, number, number] {
-    const { h0, h1, h2, h3, h4 } = this;
-    return [h0, h1, h2, h3, h4];
-  }
-  protected set(h0: number, h1: number, h2: number, h3: number, h4: number): void {
-    this.h0 = h0 | 0;
-    this.h1 = h1 | 0;
-    this.h2 = h2 | 0;
-    this.h3 = h3 | 0;
-    this.h4 = h4 | 0;
-  }
-  protected process(view: DataView, offset: number): void {
-    for (let i = 0; i < 16; i++, offset += 4) R_BUF[i] = view.getUint32(offset, true);
-    // prettier-ignore
-    let al = this.h0 | 0, ar = al,
-        bl = this.h1 | 0, br = bl,
-        cl = this.h2 | 0, cr = cl,
-        dl = this.h3 | 0, dr = dl,
-        el = this.h4 | 0, er = el;
-
-    // Instead of iterating 0 to 80, we split it into 5 groups
-    // And use the groups in constants, functions, etc. Much simpler
-    for (let group = 0; group < 5; group++) {
-      const rGroup = 4 - group;
-      const hbl = Kl[group], hbr = Kr[group]; // prettier-ignore
-      const rl = idxL[group], rr = idxR[group]; // prettier-ignore
-      const sl = shiftsL[group], sr = shiftsR[group]; // prettier-ignore
-      for (let i = 0; i < 16; i++) {
-        const tl = (rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el) | 0;
-        al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
-      }
-      // 2 loops are 10% faster
-      for (let i = 0; i < 16; i++) {
-        const tr = (rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er) | 0;
-        ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore
-      }
-    }
-    // Add the compressed chunk to the current hash value
-    this.set(
-      (this.h1 + cl + dr) | 0,
-      (this.h2 + dl + er) | 0,
-      (this.h3 + el + ar) | 0,
-      (this.h4 + al + br) | 0,
-      (this.h0 + bl + cr) | 0
-    );
-  }
-  protected roundClean(): void {
-    R_BUF.fill(0);
-  }
-  destroy(): void {
-    this.destroyed = true;
-    this.buffer.fill(0);
-    this.set(0, 0, 0, 0, 0);
-  }
-}
-
-/** RIPEMD-160 - a legacy hash function from 1990s. */
-export const ripemd160: CHash = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());