@hfunlabs/hyperliquid 0.29.1-hfunlabs.1 → 0.30.0-hfunlabs.1

package/src/deps/jsr.io/@noble/hashes/2.0.1/src/_md.ts

@@ -1,156 +0,0 @@
-/**
- * Internal Merkle-Damgard hash utils.
- * @module
- */
-import { abytes, aexists, aoutput, clean, createView, type Hash } from './utils.js';
-
-/** Choice: a ? b : c */
-export function Chi(a: number, b: number, c: number): number {
-  return (a & b) ^ (~a & c);
-}
-
-/** Majority function, true if any two inputs is true. */
-export function Maj(a: number, b: number, c: number): number {
-  return (a & b) ^ (a & c) ^ (b & c);
-}
-
-/**
- * Merkle-Damgard hash construction base class.
- * Could be used to create MD5, RIPEMD, SHA1, SHA2.
- */
-export abstract class HashMD<T extends HashMD<T>> implements Hash<T> {
-  protected abstract process(buf: DataView, offset: number): void;
-  protected abstract get(): number[];
-  protected abstract set(...args: number[]): void;
-  abstract destroy(): void;
-  protected abstract roundClean(): void;
-
-  readonly blockLen: number;
-  readonly outputLen: number;
-  readonly padOffset: number;
-  readonly isLE: boolean;
-
-  // For partial updates less than block size
-  protected buffer: Uint8Array;
-  protected view: DataView;
-  protected finished = false;
-  protected length = 0;
-  protected pos = 0;
-  protected destroyed = false;
-
-  constructor(blockLen: number, outputLen: number, padOffset: number, isLE: boolean) {
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data: Uint8Array): this {
-    aexists(this);
-    abytes(data);
-    const { view, buffer, blockLen } = this;
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      // Fast path: we have at least one block in input, cast it to view and process
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
-    }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out: Uint8Array): void {
-    aexists(this);
-    aoutput(out, this);
-    this.finished = true;
-    // Padding
-    // We can avoid allocation of buffer for padding completely if it
-    // was previously not allocated here. But it won't change performance.
-    const { buffer, view, blockLen, isLE } = this;
-    let { pos } = this;
-    // append the bit '1' to the message
-    buffer[pos++] = 0b10000000;
-    clean(this.buffer.subarray(pos));
-    // we have less than padOffset left in buffer, so we cannot put length in
-    // current block, need process it and pad again
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
-    }
-    // Pad until full block byte with zeros
-    for (let i = pos; i < blockLen; i++) buffer[i] = 0;
-    // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
-    // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
-    // So we just write lowest 64 bits of that value.
-    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT
-    if (len % 4) throw new Error('_sha2: outputLen must be aligned to 32bit');
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length) throw new Error('_sha2: outputLen bigger than state');
-    for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-  }
-  digest(): Uint8Array {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to?: T): T {
-    to ||= new (this.constructor as any)() as T;
-    to.set(...this.get());
-    const { blockLen, buffer, length, finished, destroyed, pos } = this;
-    to.destroyed = destroyed;
-    to.finished = finished;
-    to.length = length;
-    to.pos = pos;
-    if (length % blockLen) to.buffer.set(buffer);
-    return to as unknown as any;
-  }
-  clone(): T {
-    return this._cloneInto();
-  }
-}
-
-/**
- * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
- * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
- */
-
-/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
-export const SHA256_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
-  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
-]);
-
-/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */
-export const SHA224_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
-  0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
-]);
-
-/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */
-export const SHA384_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
-  0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,
-  0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,
-]);
-
-/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
-export const SHA512_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([
-  0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
-  0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
-]);

package/src/deps/jsr.io/@noble/hashes/2.0.1/src/_u64.ts

@@ -1,91 +0,0 @@
-/**
- * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
- * @todo re-check https://issues.chromium.org/issues/42212588
- * @module
- */
-const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-const _32n = /* @__PURE__ */ BigInt(32);
-
-function fromBig(
-  n: bigint,
-  le = false
-): {
-  h: number;
-  l: number;
-} {
-  if (le) return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
-  return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
-}
-
-function split(lst: bigint[], le = false): Uint32Array[] {
-  const len = lst.length;
-  let Ah = new Uint32Array(len);
-  let Al = new Uint32Array(len);
-  for (let i = 0; i < len; i++) {
-    const { h, l } = fromBig(lst[i], le);
-    [Ah[i], Al[i]] = [h, l];
-  }
-  return [Ah, Al];
-}
-
-const toBig = (h: number, l: number): bigint => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
-// for Shift in [0, 32)
-const shrSH = (h: number, _l: number, s: number): number => h >>> s;
-const shrSL = (h: number, l: number, s: number): number => (h << (32 - s)) | (l >>> s);
-// Right rotate for Shift in [1, 32)
-const rotrSH = (h: number, l: number, s: number): number => (h >>> s) | (l << (32 - s));
-const rotrSL = (h: number, l: number, s: number): number => (h << (32 - s)) | (l >>> s);
-// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
-const rotrBH = (h: number, l: number, s: number): number => (h << (64 - s)) | (l >>> (s - 32));
-const rotrBL = (h: number, l: number, s: number): number => (h >>> (s - 32)) | (l << (64 - s));
-// Right rotate for shift===32 (just swaps l&h)
-const rotr32H = (_h: number, l: number): number => l;
-const rotr32L = (h: number, _l: number): number => h;
-// Left rotate for Shift in [1, 32)
-const rotlSH = (h: number, l: number, s: number): number => (h << s) | (l >>> (32 - s));
-const rotlSL = (h: number, l: number, s: number): number => (l << s) | (h >>> (32 - s));
-// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
-const rotlBH = (h: number, l: number, s: number): number => (l << (s - 32)) | (h >>> (64 - s));
-const rotlBL = (h: number, l: number, s: number): number => (h << (s - 32)) | (l >>> (64 - s));
-
-// JS uses 32-bit signed integers for bitwise operations which means we cannot
-// simple take carry out of low bit sum by shift, we need to use division.
-function add(
-  Ah: number,
-  Al: number,
-  Bh: number,
-  Bl: number
-): {
-  h: number;
-  l: number;
-} {
-  const l = (Al >>> 0) + (Bl >>> 0);
-  return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
-}
-// Addition with more than 2 elements
-const add3L = (Al: number, Bl: number, Cl: number): number => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
-const add3H = (low: number, Ah: number, Bh: number, Ch: number): number =>
-  (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
-const add4L = (Al: number, Bl: number, Cl: number, Dl: number): number =>
-  (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
-const add4H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number): number =>
-  (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
-const add5L = (Al: number, Bl: number, Cl: number, Dl: number, El: number): number =>
-  (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
-const add5H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number): number =>
-  (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
-
-// prettier-ignore
-export {
-  add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig
-};
-// prettier-ignore
-const u64: { fromBig: typeof fromBig; split: typeof split; toBig: (h: number, l: number) => bigint; shrSH: (h: number, _l: number, s: number) => number; shrSL: (h: number, l: number, s: number) => number; rotrSH: (h: number, l: number, s: number) => number; rotrSL: (h: number, l: number, s: number) => number; rotrBH: (h: number, l: number, s: number) => number; rotrBL: (h: number, l: number, s: number) => number; rotr32H: (_h: number, l: number) => number; rotr32L: (h: number, _l: number) => number; rotlSH: (h: number, l: number, s: number) => number; rotlSL: (h: number, l: number, s: number) => number; rotlBH: (h: number, l: number, s: number) => number; rotlBL: (h: number, l: number, s: number) => number; add: typeof add; add3L: (Al: number, Bl: number, Cl: number) => number; add3H: (low: number, Ah: number, Bh: number, Ch: number) => number; add4L: (Al: number, Bl: number, Cl: number, Dl: number) => number; add4H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number) => number; add5H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) => number; add5L: (Al: number, Bl: number, Cl: number, Dl: number, El: number) => number; } = {
-  fromBig, split, toBig,
-  shrSH, shrSL,
-  rotrSH, rotrSL, rotrBH, rotrBL,
-  rotr32H, rotr32L,
-  rotlSH, rotlSL, rotlBH, rotlBL,
-  add, add3L, add3H, add4L, add4H, add5H, add5L,
-};
-export default u64;

package/src/deps/jsr.io/@noble/hashes/2.0.1/src/hmac.ts

@@ -1,94 +0,0 @@
-/**
- * HMAC: RFC2104 message authentication code.
- * @module
- */
-import { abytes, aexists, ahash, clean, type CHash, type Hash } from './utils.js';
-
-/** Internal class for HMAC. */
-export class _HMAC<T extends Hash<T>> implements Hash<_HMAC<T>> {
-  oHash: T;
-  iHash: T;
-  blockLen: number;
-  outputLen: number;
-  private finished = false;
-  private destroyed = false;
-
-  constructor(hash: CHash, key: Uint8Array) {
-    ahash(hash);
-    abytes(key, undefined, '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);
-    clean(pad);
-  }
-  update(buf: Uint8Array): this {
-    aexists(this);
-    this.iHash.update(buf);
-    return this;
-  }
-  digestInto(out: Uint8Array): void {
-    aexists(this);
-    abytes(out, this.outputLen, 'output');
-    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;
-  }
-  clone(): _HMAC<T> {
-    return this._cloneInto();
-  }
-  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: Uint8Array, message: Uint8Array): Uint8Array;
-  create(hash: CHash, key: Uint8Array): _HMAC<any>;
-} = (hash: CHash, key: Uint8Array, message: Uint8Array): Uint8Array =>
-  new _HMAC<any>(hash, key).update(message).digest();
-hmac.create = (hash: CHash, key: Uint8Array) => new _HMAC<any>(hash, key);