@meteora-ag/cp-amm-sdk 1.0.0-rc.9 → 1.0.1-1.rc-0

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

@@ -1,154 +1,20 @@
 /**
  * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. blake2b for 64-bit, but in JS it is slower.
  * @module
+ * @deprecated
  */
-import { BLAKE, type BlakeOpts, SIGMA } from './_blake.js';
-import { fromBig } from './_u64.js';
-import { byteSwapIfBE, type CHashO, rotr, toBytes, u32, wrapConstructorWithOpts } from './utils.js';
-
-/**
- * Initial state: same as SHA256. First 32 bits of the fractional parts of the square roots
- * of the first 8 primes 2..19.
- */
-// prettier-ignore
-export const B2S_IV: Uint32Array = /* @__PURE__ */ new Uint32Array([
-  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-]);
-
-// prettier-ignore
-type Num4 = { a: number; b: number; c: number; d: number; };
-// prettier-ignore
-type Num16 = {
-  v0: number; v1: number; v2: number; v3: number;
-  v4: number; v5: number; v6: number; v7: number;
-  v8: number; v9: number; v10: number; v11: number;
-  v12: number; v13: number; v14: number; v15: number;
-};
-
-// Mixing function G splitted in two halfs
-export function G1s(a: number, b: number, c: number, d: number, x: number): Num4 {
-  a = (a + b + x) | 0;
-  d = rotr(d ^ a, 16);
-  c = (c + d) | 0;
-  b = rotr(b ^ c, 12);
-  return { a, b, c, d };
-}
-
-export function G2s(a: number, b: number, c: number, d: number, x: number): Num4 {
-  a = (a + b + x) | 0;
-  d = rotr(d ^ a, 8);
-  c = (c + d) | 0;
-  b = rotr(b ^ c, 7);
-  return { a, b, c, d };
-}
-
-// prettier-ignore
-export function compress(s: Uint8Array, offset: number, msg: Uint32Array, rounds: number,
-  v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number,
-  v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number,
-): Num16 {
-  let j = 0;
-  for (let i = 0; i < rounds; i++) {
-    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
-    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
-    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
-    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
-    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
-    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
-    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
-    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
-
-    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
-    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
-    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
-    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
-    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
-    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
-    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
-    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
-  }
-  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
-}
-
-export class BLAKE2s extends BLAKE<BLAKE2s> {
-  // Internal state, same as SHA-256
-  private v0 = B2S_IV[0] | 0;
-  private v1 = B2S_IV[1] | 0;
-  private v2 = B2S_IV[2] | 0;
-  private v3 = B2S_IV[3] | 0;
-  private v4 = B2S_IV[4] | 0;
-  private v5 = B2S_IV[5] | 0;
-  private v6 = B2S_IV[6] | 0;
-  private v7 = B2S_IV[7] | 0;
-
-  constructor(opts: BlakeOpts = {}) {
-    super(64, opts.dkLen === undefined ? 32 : opts.dkLen, opts, 32, 8, 8);
-    const keyLength = opts.key ? opts.key.length : 0;
-    this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
-    if (opts.salt) {
-      const salt = u32(toBytes(opts.salt));
-      this.v4 ^= byteSwapIfBE(salt[0]);
-      this.v5 ^= byteSwapIfBE(salt[1]);
-    }
-    if (opts.personalization) {
-      const pers = u32(toBytes(opts.personalization));
-      this.v6 ^= byteSwapIfBE(pers[0]);
-      this.v7 ^= byteSwapIfBE(pers[1]);
-    }
-    if (opts.key) {
-      // Pad to blockLen and update
-      const tmp = new Uint8Array(this.blockLen);
-      tmp.set(toBytes(opts.key));
-      this.update(tmp);
-    }
-  }
-  protected get(): [number, number, number, number, number, number, number, number] {
-    const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
-    return [v0, v1, v2, v3, v4, v5, v6, v7];
-  }
-  // prettier-ignore
-  protected set(
-    v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number
-  ): void {
-    this.v0 = v0 | 0;
-    this.v1 = v1 | 0;
-    this.v2 = v2 | 0;
-    this.v3 = v3 | 0;
-    this.v4 = v4 | 0;
-    this.v5 = v5 | 0;
-    this.v6 = v6 | 0;
-    this.v7 = v7 | 0;
-  }
-  protected compress(msg: Uint32Array, offset: number, isLast: boolean): void {
-    const { h, l } = fromBig(BigInt(this.length));
-    // prettier-ignore
-    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } =
-      compress(
-        SIGMA, offset, msg, 10,
-        this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7,
-        B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]
-      );
-    this.v0 ^= v0 ^ v8;
-    this.v1 ^= v1 ^ v9;
-    this.v2 ^= v2 ^ v10;
-    this.v3 ^= v3 ^ v11;
-    this.v4 ^= v4 ^ v12;
-    this.v5 ^= v5 ^ v13;
-    this.v6 ^= v6 ^ v14;
-    this.v7 ^= v7 ^ v15;
-  }
-  destroy(): void {
-    this.destroyed = true;
-    this.buffer32.fill(0);
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-  }
-}
-
-/**
- * Blake2s hash function. Focuses on 8-bit to 32-bit platforms. blake2b for 64-bit, but in JS it is slower.
- * @param msg - message that would be hashed
- * @param opts - dkLen output length, key for MAC mode, salt, personalization
- */
-export const blake2s: CHashO = /* @__PURE__ */ wrapConstructorWithOpts<BLAKE2s, BlakeOpts>(
-  (opts) => new BLAKE2s(opts)
-);
+import { G1s as G1s_n, G2s as G2s_n } from './_blake.ts';
+import { SHA256_IV } from './_md.ts';
+import { BLAKE2s as B2S, blake2s as b2s, compress as compress_n } from './blake2.ts';
+/** @deprecated Use import from `noble/hashes/blake2` module */
+export const B2S_IV: Uint32Array = SHA256_IV;
+/** @deprecated Use import from `noble/hashes/blake2` module */
+export const G1s: typeof G1s_n = G1s_n;
+/** @deprecated Use import from `noble/hashes/blake2` module */
+export const G2s: typeof G2s_n = G2s_n;
+/** @deprecated Use import from `noble/hashes/blake2` module */
+export const compress: typeof compress_n = compress_n;
+/** @deprecated Use import from `noble/hashes/blake2` module */
+export const BLAKE2s: typeof B2S = B2S;
+/** @deprecated Use import from `noble/hashes/blake2` module */
+export const blake2s: typeof b2s = b2s;

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

@@ -11,34 +11,30 @@
  * * It is still possible to make it faster using: a) loop unrolling b) web workers c) wasm
  * @module
  */
-import { abytes, aexists, anumber, aoutput } from './_assert.js';
-import { BLAKE } from './_blake.js';
-import { fromBig } from './_u64.js';
-import { B2S_IV, compress } from './blake2s.js';
+import { SHA256_IV } from './_md.ts';
+import { fromBig } from './_u64.ts';
+import { BLAKE2, compress } from './blake2.ts';
+// prettier-ignore
 import {
-  byteSwap32,
-  type CHashXO,
-  type HashXOF,
-  type Input,
-  isLE,
-  toBytes,
-  u32,
-  u8,
-  wrapXOFConstructorWithOpts,
-} from './utils.js';
+  abytes, aexists, anumber, aoutput,
+  clean, createXOFer, swap32IfBE, toBytes, u32, u8,
+  type CHashXO, type HashXOF, type Input
+} from './utils.ts';
 
 // Flag bitset
-const enum B3_Flags {
-  CHUNK_START = 1 << 0,
-  CHUNK_END = 1 << 1,
-  PARENT = 1 << 2,
-  ROOT = 1 << 3,
-  KEYED_HASH = 1 << 4,
-  DERIVE_KEY_CONTEXT = 1 << 5,
-  DERIVE_KEY_MATERIAL = 1 << 6,
-}
+const B3_Flags = {
+  CHUNK_START: 0b1,
+  CHUNK_END: 0b10,
+  PARENT: 0b100,
+  ROOT: 0b1000,
+  KEYED_HASH: 0b10000,
+  DERIVE_KEY_CONTEXT: 0b100000,
+  DERIVE_KEY_MATERIAL: 0b1000000,
+} as const;
+
+const B3_IV = SHA256_IV.slice();
 
-const SIGMA: Uint8Array = /* @__PURE__ */ (() => {
+const B3_SIGMA: Uint8Array = /* @__PURE__ */ (() => {
   const Id = Array.from({ length: 16 }, (_, i) => i);
   const permute = (arr: number[]) =>
     [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
@@ -57,12 +53,12 @@ const SIGMA: Uint8Array = /* @__PURE__ */ (() => {
 export type Blake3Opts = { dkLen?: number; key?: Input; context?: Input };
 
 /** Blake3 hash. Can be used as MAC and KDF. */
-export class BLAKE3 extends BLAKE<BLAKE3> implements HashXOF<BLAKE3> {
-  private IV: Uint32Array;
-  private flags = 0 | 0;
-  private state: Uint32Array;
+export class BLAKE3 extends BLAKE2<BLAKE3> implements HashXOF<BLAKE3> {
   private chunkPos = 0; // Position of current block in chunk
   private chunksDone = 0; // How many chunks we already have
+  private flags = 0 | 0;
+  private IV: Uint32Array;
+  private state: Uint32Array;
   private stack: Uint32Array[] = [];
   // Output
   private posOut = 0;
@@ -72,26 +68,26 @@ export class BLAKE3 extends BLAKE<BLAKE3> implements HashXOF<BLAKE3> {
   private enableXOF = true;
 
   constructor(opts: Blake3Opts = {}, flags = 0) {
-    super(64, opts.dkLen === undefined ? 32 : opts.dkLen, {}, Number.MAX_SAFE_INTEGER, 0, 0);
-    this.outputLen = opts.dkLen === undefined ? 32 : opts.dkLen;
-    anumber(this.outputLen);
-    if (opts.key !== undefined && opts.context !== undefined)
-      throw new Error('Blake3: only key or context can be specified at same time');
-    else if (opts.key !== undefined) {
-      const key = toBytes(opts.key).slice();
-      if (key.length !== 32) throw new Error('Blake3: key should be 32 byte');
-      this.IV = u32(key);
-      if (!isLE) byteSwap32(this.IV);
+    super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
+    const { key, context } = opts;
+    const hasContext = context !== undefined;
+    if (key !== undefined) {
+      if (hasContext) throw new Error('Only "key" or "context" can be specified at same time');
+      const k = toBytes(key).slice();
+      abytes(k, 32);
+      this.IV = u32(k);
+      swap32IfBE(this.IV);
       this.flags = flags | B3_Flags.KEYED_HASH;
-    } else if (opts.context !== undefined) {
-      const context_key = new BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT)
-        .update(opts.context)
+    } else if (hasContext) {
+      const ctx = toBytes(context);
+      const contextKey = new BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT)
+        .update(ctx)
         .digest();
-      this.IV = u32(context_key);
-      if (!isLE) byteSwap32(this.IV);
+      this.IV = u32(contextKey);
+      swap32IfBE(this.IV);
       this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
     } else {
-      this.IV = B2S_IV.slice();
+      this.IV = B3_IV.slice();
       this.flags = flags;
     }
     this.state = this.IV.slice();
@@ -108,9 +104,9 @@ export class BLAKE3 extends BLAKE<BLAKE3> implements HashXOF<BLAKE3> {
     // prettier-ignore
     const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } =
       compress(
-        SIGMA, bufPos, buf, 7,
+        B3_SIGMA, bufPos, buf, 7,
         s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
-        B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], h, l, pos, flags
+        B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags
       );
     s[0] = v0 ^ v8;
     s[1] = v1 ^ v9;
@@ -171,23 +167,20 @@ export class BLAKE3 extends BLAKE<BLAKE3> implements HashXOF<BLAKE3> {
   }
   destroy(): void {
     this.destroyed = true;
-    this.state.fill(0);
-    this.buffer32.fill(0);
-    this.IV.fill(0);
-    this.bufferOut32.fill(0);
-    for (let i of this.stack) i.fill(0);
+    clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+    clean(...this.stack);
   }
   // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
   private b2CompressOut() {
     const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
     const { h, l } = fromBig(BigInt(this.chunkOut++));
-    if (!isLE) byteSwap32(buffer32);
+    swap32IfBE(buffer32);
     // prettier-ignore
     const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } =
       compress(
-        SIGMA, 0, buffer32, 7,
+        B3_SIGMA, 0, buffer32, 7,
         s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
-        B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l, h, pos, flags
+        B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags
       );
     out32[0] = v0 ^ v8;
     out32[1] = v1 ^ v9;
@@ -205,24 +198,22 @@ export class BLAKE3 extends BLAKE<BLAKE3> implements HashXOF<BLAKE3> {
     out32[13] = s[5] ^ v13;
     out32[14] = s[6] ^ v14;
     out32[15] = s[7] ^ v15;
-    if (!isLE) {
-      byteSwap32(buffer32);
-      byteSwap32(out32);
-    }
+    swap32IfBE(buffer32);
+    swap32IfBE(out32);
     this.posOut = 0;
   }
   protected finish(): void {
     if (this.finished) return;
     this.finished = true;
     // Padding
-    this.buffer.fill(0, this.pos);
+    clean(this.buffer.subarray(this.pos));
     // Process last chunk
     let flags = this.flags | B3_Flags.ROOT;
     if (this.stack.length) {
       flags |= B3_Flags.PARENT;
-      if (!isLE) byteSwap32(this.buffer32);
+      swap32IfBE(this.buffer32);
       this.compress(this.buffer32, 0, true);
-      if (!isLE) byteSwap32(this.buffer32);
+      swap32IfBE(this.buffer32);
       this.chunksDone = 0;
       this.pos = this.blockLen;
     } else {
@@ -276,6 +267,6 @@ export class BLAKE3 extends BLAKE<BLAKE3> implements HashXOF<BLAKE3> {
  * const mac = blake3(data, { key: new Uint8Array(32) });
  * const kdf = blake3(data, { context: 'application name' });
  */
-export const blake3: CHashXO = /* @__PURE__ */ wrapXOFConstructorWithOpts<BLAKE3, Blake3Opts>(
+export const blake3: CHashXO = /* @__PURE__ */ createXOFer<BLAKE3, Blake3Opts>(
   (opts) => new BLAKE3(opts)
 );

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

@@ -1,12 +1,11 @@
 /**
  * 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';
+import { hkdf } from './hkdf.ts';
+import { pbkdf2 as _pbkdf2 } from './pbkdf2.ts';
+import { scrypt as _scrypt } from './scrypt.ts';
+import { sha256 } from './sha256.ts';
+import { abytes, bytesToHex, clean, createView, hexToBytes, kdfInputToBytes } from './utils.ts';
 
 // 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".
@@ -53,8 +52,7 @@ export function deriveMainSeed(username: string, password: string): Uint8Array {
   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);
+  clean(scr, pbk);
   return res;
 }
 
@@ -77,16 +75,16 @@ function getSaltInfo(protocol: string, accountId: AccountID = 0) {
     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);
+    salt = kdfInputToBytes(accountId);
   } else if (Number.isSafeInteger(accountId)) {
-    if (accountId < 0 || accountId > 2 ** 32 - 1) throw new Error('invalid accountId');
+    if (accountId < 0 || accountId > Math.pow(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);
+  const info = kdfInputToBytes(protocol);
   return { salt, info };
 }
 

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

@@ -3,9 +3,8 @@
  * 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';
+import { hmac } from './hmac.ts';
+import { ahash, anumber, type CHash, clean, type Input, toBytes } from './utils.ts';
 
 /**
  * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
@@ -23,8 +22,8 @@ export function extract(hash: CHash, ikm: Input, salt?: Input): Uint8Array {
   return hmac(hash, toBytes(salt), toBytes(ikm));
 }
 
-const HKDF_COUNTER = /* @__PURE__ */ new Uint8Array([0]);
-const EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array();
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.from([0]);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
 
 /**
  * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
@@ -36,11 +35,12 @@ const EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array();
 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);
+  const olen = hash.outputLen;
+  if (length > 255 * olen) throw new Error('Length should be <= 255*HashLen');
+  const blocks = Math.ceil(length / olen);
   if (info === undefined) info = EMPTY_BUFFER;
   // first L(ength) octets of T
-  const okm = new Uint8Array(blocks * hash.outputLen);
+  const okm = new Uint8Array(blocks * olen);
   // Re-use HMAC instance between blocks
   const HMAC = hmac.create(hash, prk);
   const HMACTmp = HMAC._cloneInto();
@@ -53,13 +53,12 @@ export function expand(hash: CHash, prk: Input, info?: Input, length: number = 3
       .update(info)
       .update(HKDF_COUNTER)
       .digestInto(T);
-    okm.set(T, hash.outputLen * counter);
+    okm.set(T, olen * counter);
     HMAC._cloneInto(HMACTmp);
   }
   HMAC.destroy();
   HMACTmp.destroy();
-  T.fill(0);
-  HKDF_COUNTER.fill(0);
+  clean(T, HKDF_COUNTER);
   return okm.slice(0, length);
 }
 

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

@@ -2,8 +2,7 @@
  * HMAC: RFC2104 message authentication code.
  * @module
  */
-import { abytes, aexists, ahash } from './_assert.js';
-import { Hash, toBytes, type CHash, type Input } from './utils.js';
+import { abytes, aexists, ahash, clean, Hash, toBytes, type CHash, type Input } from './utils.ts';
 
 export class HMAC<T extends Hash<T>> extends Hash<HMAC<T>> {
   oHash: T;
@@ -33,7 +32,7 @@ export class HMAC<T extends Hash<T>> extends Hash<HMAC<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);
+    clean(pad);
   }
   update(buf: Input): this {
     aexists(this);
@@ -67,6 +66,9 @@ export class HMAC<T extends Hash<T>> extends Hash<HMAC<T>> {
     to.iHash = iHash._cloneInto(to.iHash);
     return to;
   }
+  clone(): HMAC<T> {
+    return this._cloneInto();
+  }
   destroy(): void {
     this.destroyed = true;
     this.oHash.destroy();

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

@@ -4,7 +4,7 @@
  * @example
 ```js
 import {
-  sha256, sha384, sha512, sha224, sha512_256, sha512_384
+  sha256, sha384, sha512, sha224, sha512_224, sha512_256
 } from '@noble/hashes/sha2';
 import {
   sha3_224, sha3_256, sha3_384, sha3_512,
@@ -18,15 +18,13 @@ import {
   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 { blake2b, blake2s } from '@noble/hashes/blake2';
 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 { md5, ripemd160, sha1 } from '@noble/hashes/legacy';
 import * as utils from '@noble/hashes/utils';
 ```
  */