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

package/node_modules/@noble/hashes/README.md

@@ -8,7 +8,7 @@ Audited & minimal JS implementation of hash functions, MACs and KDFs.
 - 🔍 Reliable: chained / sliding window / DoS tests and fuzzing ensure correctness
 - 🔁 No unrolled loops: makes it easier to verify and reduces source code size up to 5x
 - 🦘 Includes SHA, RIPEMD, BLAKE, HMAC, HKDF, PBKDF, Scrypt, Argon2 & KangarooTwelve
-- 🪶 47KB for everything, 5KB (2.5KB gzipped) for single-hash build
+- 🪶 48KB for everything, 4.8KB (2.36KB gzipped) for single-hash build
 
 Take a glance at [GitHub Discussions](https://github.com/paulmillr/noble-hashes/discussions) for questions and support.
 The library's initial development was funded by [Ethereum Foundation](https://ethereum.org/).
@@ -36,7 +36,7 @@ The library's initial development was funded by [Ethereum Foundation](https://et
 
 > `deno add jsr:@noble/hashes`
 
-> `deno doc jsr:@noble/hashes`  # command-line documentation
+> `deno doc jsr:@noble/hashes` # command-line documentation
 
 We support all major platforms and runtimes.
 For React Native, you may need a [polyfill for getRandomValues](https://github.com/LinusU/react-native-get-random-values).
@@ -44,72 +44,53 @@ A standalone file [noble-hashes.js](https://github.com/paulmillr/noble-hashes/re
 
 ```js
 // import * from '@noble/hashes'; // Error: use sub-imports, to ensure small app size
-import { sha256 } from '@noble/hashes/sha2'; // ECMAScript modules (ESM) and Common.js
-// u8a is accepted
-console.log(sha256(new Uint8Array([1, 2, 3]))); // Uint8Array(32) [3, 144, 88, 198, 242...]
-// strings are also accepted and auto-encoded into u8a
-console.log(sha256('abc')); // == sha256(new TextEncoder().encode('abc'))
+import { sha256 } from '@noble/hashes/sha2.js'; // ESM & Common.js
+sha256(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // returns Uint8Array
+
+// Available modules
+import { sha256, sha384, sha512, sha224, sha512_224, sha512_256 } from '@noble/hashes/sha2.js';
+import { sha3_256, sha3_512, keccak_256, keccak_512, shake128, shake256 } from '@noble/hashes/sha3.js';
+import { cshake256, turboshake256, kmac256, tuplehash256, k12, m14, keccakprg } from '@noble/hashes/sha3-addons.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { blake256, blake512 } from '@noble/hashes/blake1.js';
+import { sha1, md5, ripemd160 } from '@noble/hashes/legacy.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
+import { argon2d, argon2i, argon2id } from '@noble/hashes/argon2.js';
+import * as utils from '@noble/hashes/utils'; // bytesToHex, bytesToUtf8, concatBytes...
 ```
 
-- [Implementations](#implementations)
-  - [sha2: sha256, sha384, sha512](#sha2-sha256-sha384-sha512-and-others)
-  - [sha3: FIPS, SHAKE, Keccak](#sha3-fips-shake-keccak)
-  - [sha3-addons: cSHAKE, KMAC, K12, M14, TurboSHAKE](#sha3-addons-cshake-kmac-k12-m14-turboshake)
-  - [ripemd160](#ripemd160) | [blake, blake2b, blake2s, blake3](#blake-blake2b-blake2s-blake3) | [sha1: legacy hash](#sha1-legacy-hash)
-  - MACs: [hmac](#hmac) (also sha3-addons [kmac](#sha3-addons-cshake-kmac-k12-m14-turboshake), blake3 [key mode](#blake2b-blake2s-blake3))
-  - KDFs: [hkdf](#hkdf) | [pbkdf2](#pbkdf2) | [scrypt](#scrypt) | [argon2](#argon2)
-  - [utils](#utils)
-  - [All available imports](#all-available-imports)
+- [sha2: sha256, sha384, sha512](#sha2-sha256-sha384-sha512-and-others)
+- [sha3: FIPS, SHAKE, Keccak](#sha3-fips-shake-keccak)
+- [sha3-addons: cSHAKE, KMAC, K12, M14, TurboSHAKE](#sha3-addons-cshake-kmac-k12-m14-turboshake)
+- [blake, blake2, blake3](#blake-blake2-blake3) | [legacy: sha1, md5, ripemd160](#legacy-sha1-md5-ripemd160)
+- MACs: [hmac](#hmac) | [sha3-addons kmac](#sha3-addons-cshake-kmac-k12-m14-turboshake) | [blake3 key mode](#blake2b-blake2s-blake3)
+- KDFs: [hkdf](#hkdf) | [pbkdf2](#pbkdf2) | [scrypt](#scrypt) | [argon2](#argon2)
+- [utils](#utils)
 - [Security](#security) | [Speed](#speed) | [Contributing & testing](#contributing--testing) | [License](#license)
 
-
 ### Implementations
 
-```ts
-// function hash(message: Uint8Array | string): Uint8Array;
-hash(new Uint8Array([1, 3]));
-hash('string'); // == hash(new TextEncoder().encode('string'));
-// prettier-ignore
-hash.create().update(new Uint8Array([1, 3])).digest();
-```
-
 Hash functions:
 
-- receive & return `Uint8Array`
-- may receive `string` **(not hex)**, which is automatically utf8-encoded to `Uint8Array`
+- `sha256()`: receive & return `Uint8Array`
+- `sha256.create().update(a).update(b).digest()`: support partial updates
+- `blake3.create({ context: 'e', dkLen: 32 })`: sometimes have options
 - support little-endian architecture; also experimentally big-endian
 - can hash up to 4GB per chunk, with any amount of chunks
-- can be constructed via `hash.create()` method
-    - the result is `Hash` subclass instance, which has `update()` and `digest()` methods
-    - `digest()` finalizes the hash and makes it no longer usable
-- some of them can receive `options`:
-    - second argument to hash function: `blake3('abc', { key: 'd', dkLen: 32 })`
-    - first argument to class initializer: `blake3.create({ context: 'e', dkLen: 32 })`
 
 #### sha2: sha256, sha384, sha512 and others
 
 ```typescript
-import { sha256, sha384, sha512, sha224, sha512_256, sha512_384 } from '@noble/hashes/sha2';
-// also available as aliases:
-// import ... from '@noble/hashes/sha256'
-// import ... from '@noble/hashes/sha512'
-
-// Variant A:
-const h1a = sha256('abc');
-
-// Variant B:
-const h1b = sha256
-  .create()
-  .update(Uint8Array.from([1, 2, 3]))
-  .digest();
-
-for (let hash of [sha384, sha512, sha224, sha512_256, sha512_384]) {
-  const res1 = hash('abc');
-  const res2 = hash
-    .create()
-    .update('def')
-    .update(Uint8Array.from([1, 2, 3]))
-    .digest();
+import { sha224, sha256, sha384, sha512, sha512_224, sha512_256 } from '@noble/hashes/sha2.js';
+const res = sha256(Uint8Array.from([0xbc])); // basic
+for (let hash of [sha256, sha384, sha512, sha224, sha512_224, sha512_256]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
 }
 ```
 
@@ -119,20 +100,21 @@ See [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
 #### sha3: FIPS, SHAKE, Keccak
 
 ```typescript
-// prettier-ignore
 import {
-  sha3_224, sha3_256, sha3_384, sha3_512,
   keccak_224, keccak_256, keccak_384, keccak_512,
+  sha3_224, sha3_256, sha3_384, sha3_512,
   shake128, shake256,
-} from '@noble/hashes/sha3';
-const h5a = sha3_256('abc');
-const h5b = sha3_256
-  .create()
-  .update(Uint8Array.from([1, 2, 3]))
-  .digest();
-const h6a = keccak_256('abc');
-const h7a = shake128('abc', { dkLen: 512 });
-const h7b = shake256('abc', { dkLen: 512 });
+} from '@noble/hashes/sha3.js';
+for (let hash of [
+  sha3_224, sha3_256, sha3_384, sha3_512,
+  keccak_224, keccak_256, keccak_384, keccak_512,
+]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
+const shka = shake128(Uint8Array.from([0x10]), { dkLen: 512 });
+const shkb = shake256(Uint8Array.from([0x30]), { dkLen: 512 });
 ```
 
 See [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
@@ -143,26 +125,30 @@ Check out [the differences between SHA-3 and Keccak](https://crypto.stackexchang
 #### sha3-addons: cSHAKE, KMAC, K12, M14, TurboSHAKE
 
 ```typescript
-// prettier-ignore
 import {
   cshake128, cshake256,
-  turboshake128, turboshake256,
+  k12,
+  keccakprg,
   kmac128, kmac256,
-  tuplehash256, parallelhash256,
-  k12, m14, keccakprg
-} from '@noble/hashes/sha3-addons';
-const h7c = cshake128('abc', { personalization: 'def' });
-const h7d = cshake256('abc', { personalization: 'def' });
-const h7e = kmac128('key', 'message');
-const h7f = kmac256('key', 'message');
-const h7h = k12('abc');
-const h7g = m14('abc');
-const h7t1 = turboshake128('abc');
-const h7t2 = turboshake256('def', { D: 0x05 });
-const h7i = tuplehash256(['ab', 'c']); // tuplehash(['ab', 'c']) !== tuplehash(['a', 'bc']) !== tuplehash(['abc'])
-// Same as k12/blake3, but without reduced number of rounds. Doesn't speedup anything due lack of SIMD and threading,
-// added for compatibility.
-const h7j = parallelhash256('abc', { blockLen: 8 });
+  m14,
+  parallelhash256,
+  tuplehash256,
+  turboshake128, turboshake256
+} from '@noble/hashes/sha3-addons.js';
+const data = Uint8Array.from([0x10, 0x20, 0x30]);
+const ec1 = cshake128(data, { personalization: 'def' });
+const ec2 = cshake256(data, { personalization: 'def' });
+const et1 = turboshake128(data);
+const et2 = turboshake256(data, { D: 0x05 });
+ // tuplehash(['ab', 'c']) !== tuplehash(['a', 'bc']) !== tuplehash([data])
+const et3 = tuplehash256([utf8ToBytes('ab'), utf8ToBytes('c')]);
+// Not parallel in JS (similar to blake3 / k12), added for compat
+const ep1 = parallelhash256(data, { blockLen: 8 });
+const kk = Uint8Array.from([0xca]);
+const ek10 = kmac128(kk, data);
+const ek11 = kmac256(kk, data);
+const ek12 = k12(data);
+const ek13 = m14(data);
 // pseudo-random generator, first argument is capacity. XKCP recommends 254 bits capacity for 128-bit security strength.
 // * with a capacity of 254 bits.
 const p = keccakprg(254);
@@ -178,75 +164,71 @@ const rand1b = p.fetch(1);
   - TurboSHAKE
 - [KeccakPRG](https://keccak.team/files/CSF-0.1.pdf): Pseudo-random generator based on Keccak
 
-#### ripemd160
+#### blake, blake2, blake3
 
 ```typescript
-import { ripemd160 } from '@noble/hashes/ripemd160';
-// function ripemd160(data: Uint8Array): Uint8Array;
-const hash8 = ripemd160('abc');
-const hash9 = ripemd160
-  .create()
-  .update(Uint8Array.from([1, 2, 3]))
-  .digest();
-```
-
-See [RFC 2286](https://datatracker.ietf.org/doc/html/rfc2286),
-[Website](https://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
-
-#### blake, blake2b, blake2s, blake3
+import { blake224, blake256, blake384, blake512 } from '@noble/hashes/blake1.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+
+for (let hash of [
+  blake224, blake256, blake384, blake512,
+  blake2b, blake2s, blake3
+]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
 
-```typescript
-import { blake224, blake256, blake384, blake512 } from '@noble/hashes/blake1';
-import { blake2b } from '@noble/hashes/blake2b';
-import { blake2s } from '@noble/hashes/blake2s';
-import { blake3 } from '@noble/hashes/blake3';
-
-const h_b1_224 = blake224('abc');
-const h_b1_256 = blake256('abc');
-const h_b1_384 = blake384('abc');
-const h_b1_512 = blake512('abc');
-
-const h10a = blake2s('abc');
-const b2params = { key: new Uint8Array([1]), personalization: t, salt: t, dkLen: 32 };
-const h10b = blake2s('abc', b2params);
-const h10c = blake2s
-  .create(b2params)
-  .update(Uint8Array.from([1, 2, 3]))
-  .digest();
-
-// All params are optional
-const h11 = blake3('abc', { dkLen: 256 });
-const h11_mac = blake3('abc', { key: new Uint8Array(32) });
-const h11_kdf = blake3('abc', { context: 'application name' });
+// blake2 advanced usage
+const ab = Uint8Array.from([0x01]);
+blake2s(ab);
+blake2s(ab, { key: new Uint8Array(32) });
+blake2s(ab, { personalization: 'pers1234' });
+blake2s(ab, { salt: 'salt1234' });
+blake2b(ab);
+blake2b(ab, { key: new Uint8Array(64) });
+blake2b(ab, { personalization: 'pers1234pers1234' });
+blake2b(ab, { salt: 'salt1234salt1234' });
+
+// blake3 advanced usage
+blake3(ab);
+blake3(ab, { dkLen: 256 });
+blake3(ab, { key: new Uint8Array(32) });
+blake3(ab, { context: 'application-name' });
 ```
 
-* Blake1 is legacy hash, one of SHA3 proposals. It is rarely used anywhere. See [pdf](https://www.aumasson.jp/blake/blake.pdf).
-* Blake2 is popular fast hash. blake2b focuses on 64-bit platforms while blake2s is for 8-bit to 32-bit ones. See  [RFC 7693](https://datatracker.ietf.org/doc/html/rfc7693), [Website](https://www.blake2.net)
-* Blake3 is faster, reduced-round blake2. See [Website & specs](https://blake3.io)
-
-#### sha1: legacy hash
+- Blake1 is legacy hash, one of SHA3 proposals. It is rarely used anywhere. See [pdf](https://www.aumasson.jp/blake/blake.pdf).
+- Blake2 is popular fast hash. blake2b focuses on 64-bit platforms while blake2s is for 8-bit to 32-bit ones. See [RFC 7693](https://datatracker.ietf.org/doc/html/rfc7693), [Website](https://www.blake2.net)
+- Blake3 is faster, reduced-round blake2. See [Website & specs](https://blake3.io)
 
-SHA1 was cryptographically broken, however, it was not broken for cases like HMAC.
+#### legacy: sha1, md5, ripemd160
 
-See [RFC4226 B.2](https://datatracker.ietf.org/doc/html/rfc4226#appendix-B.2).
+SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
+Don't use them in a new protocol. What "weak" means:
 
-Don't use it for a new protocol.
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://datatracker.ietf.org/doc/html/rfc6151
 
 ```typescript
-import { sha1 } from '@noble/hashes/sha1';
-const h12 = sha1('def');
+import { md5, ripemd160, sha1 } from '@noble/hashes/legacy.js';
+for (let hash of [md5, ripemd160, sha1]) {
+  const arr = Uint8Array.from([0x10, 0x20, 0x30]);
+  const a = hash(arr);
+  const b = hash.create().update(arr).digest();
+}
 ```
 
 #### hmac
 
 ```typescript
-import { hmac } from '@noble/hashes/hmac';
-import { sha256 } from '@noble/hashes/sha2';
-const mac1 = hmac(sha256, 'key', 'message');
-const mac2 = hmac
-  .create(sha256, Uint8Array.from([1, 2, 3]))
-  .update(Uint8Array.from([4, 5, 6]))
-  .digest();
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const key = new Uint8Array(32).fill(1);
+const msg = new Uint8Array(32).fill(2);
+const mac1 = hmac(sha256, key, msg);
+const mac2 = hmac.create(sha256, key).update(msg).digest();
 ```
 
 Matches [RFC 2104](https://datatracker.ietf.org/doc/html/rfc2104).
@@ -254,19 +236,19 @@ Matches [RFC 2104](https://datatracker.ietf.org/doc/html/rfc2104).
 #### hkdf
 
 ```typescript
-import { hkdf } from '@noble/hashes/hkdf';
-import { sha256 } from '@noble/hashes/sha2';
-import { randomBytes } from '@noble/hashes/utils';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { randomBytes } from '@noble/hashes/utils.js';
+import { sha256 } from '@noble/hashes/sha2.js';
 const inputKey = randomBytes(32);
 const salt = randomBytes(32);
 const info = 'application-key';
 const hk1 = hkdf(sha256, inputKey, salt, info, 32);
 
 // == same as
-import * as hkdf from '@noble/hashes/hkdf';
-import { sha256 } from '@noble/hashes/sha2';
-const prk = hkdf.extract(sha256, inputKey, salt);
-const hk2 = hkdf.expand(sha256, prk, info, dkLen);
+import { extract, expand } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+const prk = extract(sha256, inputKey, salt);
+const hk2 = expand(sha256, prk, info, 32);
 ```
 
 Matches [RFC 5869](https://datatracker.ietf.org/doc/html/rfc5869).
@@ -274,8 +256,8 @@ Matches [RFC 5869](https://datatracker.ietf.org/doc/html/rfc5869).
 #### pbkdf2
 
 ```typescript
-import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2';
-import { sha256 } from '@noble/hashes/sha2';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { sha256 } from '@noble/hashes/sha2.js';
 const pbkey1 = pbkdf2(sha256, 'password', 'salt', { c: 32, dkLen: 32 });
 const pbkey2 = await pbkdf2Async(sha256, 'password', 'salt', { c: 32, dkLen: 32 });
 const pbkey3 = await pbkdf2Async(sha256, Uint8Array.from([1, 2, 3]), Uint8Array.from([4, 5, 6]), {
@@ -289,7 +271,7 @@ Matches [RFC 2898](https://datatracker.ietf.org/doc/html/rfc2898).
 #### scrypt
 
 ```typescript
-import { scrypt, scryptAsync } from '@noble/hashes/scrypt';
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
 const scr1 = scrypt('password', 'salt', { N: 2 ** 16, r: 8, p: 1, dkLen: 32 });
 const scr2 = await scryptAsync('password', 'salt', { N: 2 ** 16, r: 8, p: 1, dkLen: 32 });
 const scr3 = await scryptAsync(Uint8Array.from([1, 2, 3]), Uint8Array.from([4, 5, 6]), {
@@ -313,19 +295,19 @@ Conforms to [RFC 7914](https://datatracker.ietf.org/doc/html/rfc7914),
 - `onProgress` can be used with async version of the function to report progress to a user.
 - `maxmem` prevents DoS and is limited to `1GB + 1KB` (`2**30 + 2**10`), but can be adjusted using formula: `N * r * p * 128 + (128 * r * p)`
 
-Time it takes to derive Scrypt key under different values of N (2**N) on Apple M2 (mobile phones can be 1x-4x slower):
+Time it takes to derive Scrypt key under different values of N (2\*\*N) on Apple M4 (mobile phones can be 1x-4x slower):
 
-| N pow  | Time  |
-|----|-------|
-| 16 | 0.17s |
-| 17 | 0.35s |
-| 18 | 0.7s  |
-| 19 | 1.4s  |
-| 20 | 2.9s  |
-| 21 | 5.6s  |
-| 22 | 11s   |
-| 23 | 26s   |
-| 24 | 56s   |
+| N pow | Time | RAM   |
+| ----- | ---- | ----- |
+| 16    | 0.1s | 64MB  |
+| 17    | 0.2s | 128MB |
+| 18    | 0.4s | 256MB |
+| 19    | 0.8s | 512MB |
+| 20    | 1.5s | 1GB   |
+| 21    | 3.1s | 2GB   |
+| 22    | 6.2s | 4GB   |
+| 23    | 13s  | 8GB   |
+| 24    | 27s  | 16GB  |
 
 > [!NOTE]
 > We support N larger than `2**20` where available, however,
@@ -333,12 +315,11 @@ Time it takes to derive Scrypt key under different values of N (2**N) on Apple M
 > When using such N, you'll need to manually adjust `maxmem`, using formula above.
 > Other JS implementations don't support large N-s.
 
-
 #### argon2
 
 ```ts
-import { argon2d, argon2i, argon2id } from '@noble/hashes/argon2';
-const result = argon2id('password', 'saltsalt', { t: 2, m: 65536, p: 1, maxmem: 2 ** 32 - 1 });
+import { argon2d, argon2i, argon2id } from '@noble/hashes/argon2.js';
+const arg1 = argon2id('password', 'saltsalt', { t: 2, m: 65536, p: 1, maxmem: 2 ** 32 - 1 });
 ```
 
 Argon2 [RFC 9106](https://datatracker.ietf.org/doc/html/rfc9106) implementation.
@@ -358,40 +339,6 @@ console.log(toHex(randomBytes(32)));
 - `bytesToHex` will convert `Uint8Array` to a hex string
 - `randomBytes(bytes)` will produce cryptographically secure random `Uint8Array` of length `bytes`
 
-#### All available imports
-
-```js
-import { sha256, sha384, sha512, sha224, sha512_256, sha512_384 } from '@noble/hashes/sha2';
-// prettier-ignore
-import {
-  sha3_224, sha3_256, sha3_384, sha3_512,
-  keccak_224, keccak_256, keccak_384, keccak_512,
-  shake128, shake256
-} from '@noble/hashes/sha3';
-// prettier-ignore
-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
-
-// small utility method that converts bytes to hex
-import { bytesToHex as toHex } from '@noble/hashes/utils';
-console.log(toHex(sha256('abc'))); // ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
-```
-
 ## Security
 
 The library has been independently audited:
@@ -403,19 +350,19 @@ The library has been independently audited:
   - The audit has been funded by [Ethereum Foundation](https://ethereum.org/en/) with help of [Nomic Labs](https://nomiclabs.io)
 
 It is tested against property-based, cross-library and Wycheproof vectors,
-and has fuzzing by [Guido Vranken's cryptofuzz](https://github.com/guidovranken/cryptofuzz).
+and is being fuzzed in [the separate repo](https://github.com/paulmillr/fuzzing).
 
 If you see anything unusual: investigate and report.
 
 ### Constant-timeness
 
-_JIT-compiler_ and _Garbage Collector_ make "constant time" extremely hard to
-achieve [timing attack](https://en.wikipedia.org/wiki/Timing_attack) resistance
+We're targetting algorithmic constant time. _JIT-compiler_ and _Garbage Collector_ make "constant time"
+extremely hard to achieve [timing attack](https://en.wikipedia.org/wiki/Timing_attack) resistance
 in a scripting language. Which means _any other JS library can't have
 constant-timeness_. Even statically typed Rust, a language without GC,
 [makes it harder to achieve constant-time](https://www.chosenplaintext.ca/open-source/rust-timing-shield/security)
 for some cases. If your goal is absolute security, don't use any JS lib — including bindings to native ones.
-Use low-level libraries & languages. Nonetheless we're targetting algorithmic constant time.
+Use low-level libraries & languages.
 
 ### Memory dumping
 
@@ -439,16 +386,20 @@ can read application memory, you are doomed in any case:
 
 ### Supply chain security
 
-- **Commits** are signed with PGP keys, to prevent forgery. Make sure to verify commit signatures.
+- **Commits** are signed with PGP keys, to prevent forgery. Make sure to verify commit signatures
 - **Releases** are transparent and built on GitHub CI. Make sure to verify [provenance](https://docs.npmjs.com/generating-provenance-statements) logs
+  - Use GitHub CLI to verify single-file builds:
+    `gh attestation verify --owner paulmillr noble-hashes.js`
 - **Rare releasing** is followed to ensure less re-audit need for end-users
-- **Dependencies** are minimized and locked-down:
-  - If your app has 500 dependencies, any dep could get hacked and you'll be downloading
-    malware with every install. We make sure to use as few dependencies as possible
-  - We prevent automatic dependency updates by locking-down version ranges. Every update is checked with `npm-diff`
-- **Dev Dependencies** are only used if you want to contribute to the repo. They are disabled for end-users:
-  - scure-base, scure-bip32, scure-bip39, micro-bmark and micro-should are developed by the same author and follow identical security practices
-  - prettier (linter), fast-check (property-based testing) and typescript are used for code quality, vector generation and ts compilation. The packages are big, which makes it hard to audit their source code thoroughly and fully
+- **Dependencies** are minimized and locked-down: any dependency could get hacked and users will be downloading malware with every install.
+  - We make sure to use as few dependencies as possible
+  - Automatic dep updates are prevented by locking-down version ranges; diffs are checked with `npm-diff`
+- **Dev Dependencies** are disabled for end-users; they are only used to develop / build the source code
+
+For this package, there are 0 dependencies; and a few dev dependencies:
+
+- micro-bmark, micro-should and jsbt are used for benchmarking / testing / build tooling and developed by the same author
+- prettier, fast-check and typescript are used for code quality / test generation / ts compilation. It's hard to audit their source code thoroughly and fully because of their size
 
 ### Randomness
 
@@ -471,69 +422,65 @@ Australian ASD prohibits SHA256 and similar hashes [after 2030](https://www.cybe
 
 ## Speed
 
-    npm run bench
+```sh
+npm run bench:install && npm run bench
+```
 
-Benchmarks measured on Apple M2 with node v22.
+Benchmarks measured on Apple M4.
 
 ```
-32B
-sha256 x 1,377,410 ops/sec @ 726ns/op
-sha384 x 518,403 ops/sec @ 1μs/op
-sha512 x 518,941 ops/sec @ 1μs/op
-sha3_256 x 188,608 ops/sec @ 5μs/op
-sha3_512 x 190,114 ops/sec @ 5μs/op
-k12 x 324,254 ops/sec @ 3μs/op
-m14 x 286,204 ops/sec @ 3μs/op
-blake2b x 352,236 ops/sec @ 2μs/op
-blake2s x 586,510 ops/sec @ 1μs/op
-blake3 x 681,198 ops/sec @ 1μs/op
-ripemd160 x 1,275,510 ops/sec @ 784ns/op
-
-1MB
-sha256 x 197 ops/sec @ 5ms/op
-sha384 x 86 ops/sec @ 11ms/op
-sha512 x 86 ops/sec @ 11ms/op
-sha3_256 x 25 ops/sec @ 39ms/op
-sha3_512 x 13 ops/sec @ 74ms/op
-k12 x 58 ops/sec @ 17ms/op
-m14 x 41 ops/sec @ 24ms/op
-blake2b x 50 ops/sec @ 19ms/op
-blake2s x 44 ops/sec @ 22ms/op
-blake3 x 57 ops/sec @ 17ms/op
-ripemd160 x 193 ops/sec @ 5ms/op
+# 32B
+sha256 x 1,968,503 ops/sec @ 508ns/op
+sha512 x 740,740 ops/sec @ 1μs/op
+sha3_256 x 287,686 ops/sec @ 3μs/op
+sha3_512 x 288,267 ops/sec @ 3μs/op
+k12 x 476,190 ops/sec @ 2μs/op
+m14 x 423,190 ops/sec @ 2μs/op
+blake2b x 464,252 ops/sec @ 2μs/op
+blake2s x 766,871 ops/sec @ 1μs/op
+blake3 x 879,507 ops/sec @ 1μs/op
+
+# 1MB
+sha256 x 331 ops/sec @ 3ms/op
+sha512 x 129 ops/sec @ 7ms/op
+sha3_256 x 38 ops/sec @ 25ms/op
+sha3_512 x 20 ops/sec @ 47ms/op
+k12 x 88 ops/sec @ 11ms/op
+m14 x 62 ops/sec @ 15ms/op
+blake2b x 69 ops/sec @ 14ms/op
+blake2s x 57 ops/sec @ 17ms/op
+blake3 x 72 ops/sec @ 13ms/op
 
 # MAC
-hmac(sha256) x 404,203 ops/sec @ 2μs/op
-hmac(sha512) x 137,136 ops/sec @ 7μs/op
-kmac256 x 58,799 ops/sec @ 17μs/op
-blake3(key) x 619,962 ops/sec @ 1μs/op
+hmac(sha256) x 599,880 ops/sec @ 1μs/op
+hmac(sha512) x 197,122 ops/sec @ 5μs/op
+kmac256 x 87,981 ops/sec @ 11μs/op
+blake3(key) x 796,812 ops/sec @ 1μs/op
 
 # KDF
-hkdf(sha256) x 180,538 ops/sec @ 5μs/op
-blake3(context) x 336,247 ops/sec @ 2μs/op
-pbkdf2(sha256, c: 2 ** 18) x 3 ops/sec @ 292ms/op
-pbkdf2(sha512, c: 2 ** 18) x 1 ops/sec @ 920ms/op
-scrypt(n: 2 ** 18, r: 8, p: 1) x 1 ops/sec @ 605ms/op
-argon2id(t: 1, m: 256MB) x 0 ops/sec @ 4021ms/op
+hkdf(sha256) x 259,942 ops/sec @ 3μs/op
+blake3(context) x 424,808 ops/sec @ 2μs/op
+pbkdf2(sha256, c: 2 ** 18) x 5 ops/sec @ 197ms/op
+pbkdf2(sha512, c: 2 ** 18) x 1 ops/sec @ 630ms/op
+scrypt(n: 2 ** 18, r: 8, p: 1) x 2 ops/sec @ 400ms/op
+argon2id(t: 1, m: 256MB) 2881ms
 ```
 
 Compare to native node.js implementation that uses C bindings instead of pure-js code:
 
 ```
-SHA256 32B node x 1,302,083 ops/sec @ 768ns/op
-SHA384 32B node x 975,609 ops/sec @ 1μs/op
-SHA512 32B node x 983,284 ops/sec @ 1μs/op
-SHA3-256 32B node x 910,746 ops/sec @ 1μs/op
-# keccak, k12, m14 are not implemented
-BLAKE2b 32B node x 967,117 ops/sec @ 1μs/op
-BLAKE2s 32B node x 1,055,966 ops/sec @ 947ns/op
-# BLAKE3 is not implemented
-RIPEMD160 32B node x 1,002,004 ops/sec @ 998ns/op
-HMAC-SHA256 32B node x 919,963 ops/sec @ 1μs/op
-HKDF-SHA256 32 node x 369,276 ops/sec @ 2μs/op
-PBKDF2-HMAC-SHA256 262144 node x 25 ops/sec @ 39ms/op
-PBKDF2-HMAC-SHA512 262144 node x 7 ops/sec @ 132ms/op
-Scrypt r: 8, p: 1, n: 262144 node x 1 ops/sec @ 523ms/op
+# native (node) 32B
+sha256 x 2,267,573 ops/sec
+sha512 x 983,284 ops/sec
+sha3_256 x 1,522,070 ops/sec
+blake2b x 1,512,859 ops/sec
+blake2s x 1,821,493 ops/sec
+hmac(sha256) x 1,085,776 ops/sec
+hkdf(sha256) x 312,109 ops/sec
+# native (node) KDF
+pbkdf2(sha256, c: 2 ** 18) x 5 ops/sec @ 197ms/op
+pbkdf2(sha512, c: 2 ** 18) x 1 ops/sec @ 630ms/op
+scrypt(n: 2 ** 18, r: 8, p: 1) x 2 ops/sec @ 378ms/op
 ```
 
 It is possible to [make this library 4x+ faster](./benchmark/README.md) by
@@ -549,18 +496,20 @@ The current performance is good enough when compared to other projects; SHA256 t
 
 `test/misc` directory contains implementations of loop unrolling and md5.
 
-* `npm install && npm run build && npm test` will build the code and run tests.
-* `npm run lint` / `npm run format` will run linter / fix linter issues.
-* `npm run bench` will run benchmarks, which may need their deps first (`npm run bench:install`)
-* `cd build && npm install && npm run build:release` will build single file
-* There is **additional** 20-min DoS test `npm run test:dos` and 2-hour "big" multicore test `npm run test:big`.
-See [our approach to testing](./test/README.md)
+- `npm install && npm run build && npm test` will build the code and run tests.
+- `npm run lint` / `npm run format` will run linter / fix linter issues.
+- `npm run bench` will run benchmarks, which may need their deps first (`npm run bench:install`)
+- `npm run build:release` will build single file
+- There is **additional** 20-min DoS test `npm run test:dos` and 2-hour "big" multicore test `npm run test:big`.
+  See [our approach to testing](./test/README.md)
 
-Check out [github.com/paulmillr/guidelines](https://github.com/paulmillr/guidelines)
-for general coding practices and rules.
+Additional resources:
 
-See [paulmillr.com/noble](https://paulmillr.com/noble/)
-for useful resources, articles, documentation and demos
+- NTT hashes are outside of scope of the library. You can view some of them in different repos:
+    - [Pedersen in micro-zk-proofs](https://github.com/paulmillr/micro-zk-proofs/blob/1ed5ce1253583b2e540eef7f3477fb52bf5344ff/src/pedersen.ts)
+    - [Poseidon in noble-curves](https://github.com/paulmillr/noble-curves/blob/3d124dd3ecec8b6634cc0b2ba1c183aded5304f9/src/abstract/poseidon.ts)
+- Check out [guidelines](https://github.com/paulmillr/guidelines) for coding practices
+- See [paulmillr.com/noble](https://paulmillr.com/noble/) for useful resources, articles, documentation and demos
 related to the library.
 
 ## License