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

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

@@ -10,19 +10,20 @@
  * * KeccakPRG: Pseudo-random generator based on Keccak [(pdf)](https://keccak.team/files/CSF-0.1.pdf)
  * @module
  */
-import { anumber } from './_assert.js';
-import { Keccak, type ShakeOpts } from './sha3.js';
+import { Keccak, type ShakeOpts } from './sha3.ts';
 import {
+  abytes,
+  anumber,
   type CHashO,
   type CHashXO,
+  createOptHasher,
+  createXOFer,
   Hash,
   type HashXOF,
   type Input,
   toBytes,
   u32,
-  wrapConstructorWithOpts,
-  wrapXOFConstructorWithOpts,
-} from './utils.js';
+} from './utils.ts';
 
 // cSHAKE && KMAC (NIST SP800-185)
 const _8n = BigInt(8);
@@ -52,7 +53,10 @@ function chooseLen(opts: ShakeOpts, outputLen: number): number {
   return opts.dkLen === undefined ? outputLen : opts.dkLen;
 }
 
-const toBytesOptional = (buf?: Input) => (buf !== undefined ? toBytes(buf) : new Uint8Array([]));
+const abytesOrZero = (buf?: Input) => {
+  if (buf === undefined) return Uint8Array.of();
+  return toBytes(buf);
+};
 // NOTE: second modulo is necessary since we don't need to add padding if current element takes whole block
 const getPadding = (len: number, block: number) => new Uint8Array((block - (len % block)) % block);
 export type cShakeOpts = ShakeOpts & { personalization?: Input; NISTfn?: Input };
@@ -63,9 +67,9 @@ function cshakePers(hash: Keccak, opts: cShakeOpts = {}): Keccak {
   // Encode and pad inplace to avoid unneccesary memory copies/slices (so we don't need to zero them later)
   // bytepad(encode_string(N) || encode_string(S), 168)
   const blockLenBytes = leftEncode(hash.blockLen);
-  const fn = toBytesOptional(opts.NISTfn);
+  const fn = abytesOrZero(opts.NISTfn);
   const fnLen = leftEncode(_8n * BigInt(fn.length)); // length in bits
-  const pers = toBytesOptional(opts.personalization);
+  const pers = abytesOrZero(opts.personalization);
   const persLen = leftEncode(_8n * BigInt(pers.length)); // length in bits
   if (!fn.length && !pers.length) return hash;
   hash.suffix = 0x04;
@@ -76,7 +80,7 @@ function cshakePers(hash: Keccak, opts: cShakeOpts = {}): Keccak {
 }
 
 const gencShake = (suffix: number, blockLen: number, outputLen: number) =>
-  wrapXOFConstructorWithOpts<Keccak, cShakeOpts>((opts: cShakeOpts = {}) =>
+  createXOFer<Keccak, cShakeOpts>((opts: cShakeOpts = {}) =>
     cshakePers(new Keccak(blockLen, suffix, chooseLen(opts, outputLen), true), opts)
   );
 
@@ -109,6 +113,7 @@ export class KMAC extends Keccak implements HashXOF<KMAC> {
     super(blockLen, 0x1f, outputLen, enableXOF);
     cshakePers(this, { NISTfn: 'KMAC', personalization: opts.personalization });
     key = toBytes(key);
+    abytes(key);
     // 1. newX = bytepad(encode_string(K), 168) || X || right_encode(L).
     const blockLenBytes = leftEncode(this.blockLen);
     const keyLen = leftEncode(_8n * BigInt(key.length));
@@ -170,6 +175,7 @@ export class TupleHash extends Keccak implements HashXOF<TupleHash> {
     // Change update after cshake processed
     this.update = (data: Input) => {
       data = toBytes(data);
+      abytes(data);
       super.update(leftEncode(_8n * BigInt(data.length)));
       super.update(data);
       return this;
@@ -214,18 +220,20 @@ type ParallelOpts = cShakeOpts & { blockLen?: number };
 
 export class ParallelHash extends Keccak implements HashXOF<ParallelHash> {
   private leafHash?: Hash<Keccak>;
+  protected leafCons: () => Hash<Keccak>;
   private chunkPos = 0; // Position of current block in chunk
   private chunksDone = 0; // How many chunks we already have
   private chunkLen: number;
   constructor(
     blockLen: number,
     outputLen: number,
-    protected leafCons: () => Hash<Keccak>,
+    leafCons: () => Hash<Keccak>,
     enableXOF: boolean,
     opts: ParallelOpts = {}
   ) {
     super(blockLen, 0x1f, outputLen, enableXOF);
     cshakePers(this, { NISTfn: 'ParallelHash', personalization: opts.personalization });
+    this.leafCons = leafCons;
     let { blockLen: B } = opts;
     B ||= 8;
     anumber(B);
@@ -234,6 +242,7 @@ export class ParallelHash extends Keccak implements HashXOF<ParallelHash> {
     // Change update after cshake processed
     this.update = (data: Input) => {
       data = toBytes(data);
+      abytes(data);
       const { chunkLen, leafCons } = this;
       for (let pos = 0, len = data.length; pos < len; ) {
         if (this.chunkPos == chunkLen || !this.leafHash) {
@@ -315,7 +324,7 @@ export type TurboshakeOpts = ShakeOpts & {
 };
 
 const genTurboshake = (blockLen: number, outputLen: number) =>
-  wrapXOFConstructorWithOpts<HashXOF<Keccak>, TurboshakeOpts>((opts: TurboshakeOpts = {}) => {
+  createXOFer<HashXOF<Keccak>, TurboshakeOpts>((opts: TurboshakeOpts = {}) => {
     const D = opts.D === undefined ? 0x1f : opts.D;
     // Section 2.1 of https://datatracker.ietf.org/doc/draft-irtf-cfrg-kangarootwelve/
     if (!Number.isSafeInteger(D) || D < 0x01 || D > 0x7f)
@@ -339,34 +348,36 @@ function rightEncodeK12(n: number | bigint): Uint8Array {
 }
 
 export type KangarooOpts = { dkLen?: number; personalization?: Input };
-const EMPTY = new Uint8Array([]);
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
 
 export class KangarooTwelve extends Keccak implements HashXOF<KangarooTwelve> {
   readonly chunkLen = 8192;
   private leafHash?: Keccak;
+  protected leafLen: number;
   private personalization: Uint8Array;
   private chunkPos = 0; // Position of current block in chunk
   private chunksDone = 0; // How many chunks we already have
   constructor(
     blockLen: number,
-    protected leafLen: number,
+    leafLen: number,
     outputLen: number,
     rounds: number,
     opts: KangarooOpts
   ) {
     super(blockLen, 0x07, outputLen, true, rounds);
-    const { personalization } = opts;
-    this.personalization = toBytesOptional(personalization);
+    this.leafLen = leafLen;
+    this.personalization = abytesOrZero(opts.personalization);
   }
   update(data: Input): this {
     data = toBytes(data);
+    abytes(data);
     const { chunkLen, blockLen, leafLen, rounds } = this;
     for (let pos = 0, len = data.length; pos < len; ) {
       if (this.chunkPos == chunkLen) {
         if (this.leafHash) super.update(this.leafHash.digest());
         else {
           this.suffix = 0x06; // Its safe to change suffix here since its used only in digest()
-          super.update(new Uint8Array([3, 0, 0, 0, 0, 0, 0, 0]));
+          super.update(Uint8Array.from([3, 0, 0, 0, 0, 0, 0, 0]));
         }
         this.leafHash = new Keccak(blockLen, 0x0b, leafLen, false, rounds);
         this.chunksDone++;
@@ -389,7 +400,7 @@ export class KangarooTwelve extends Keccak implements HashXOF<KangarooTwelve> {
     if (this.leafHash) {
       super.update(this.leafHash.digest());
       super.update(rightEncodeK12(this.chunksDone));
-      super.update(new Uint8Array([0xff, 0xff]));
+      super.update(Uint8Array.from([0xff, 0xff]));
     }
     super.finish.call(this);
   }
@@ -397,7 +408,7 @@ export class KangarooTwelve extends Keccak implements HashXOF<KangarooTwelve> {
     super.destroy.call(this);
     if (this.leafHash) this.leafHash.destroy();
     // We cannot zero personalization buffer since it is user provided and we don't want to mutate user input
-    this.personalization = EMPTY;
+    this.personalization = EMPTY_BUFFER;
   }
   _cloneInto(to?: KangarooTwelve): KangarooTwelve {
     const { blockLen, leafLen, leafHash, outputLen, rounds } = this;
@@ -416,12 +427,12 @@ export class KangarooTwelve extends Keccak implements HashXOF<KangarooTwelve> {
 }
 /** KangarooTwelve: reduced 12-round keccak. */
 export const k12: CHashO = /* @__PURE__ */ (() =>
-  wrapConstructorWithOpts<KangarooTwelve, KangarooOpts>(
+  createOptHasher<KangarooTwelve, KangarooOpts>(
     (opts: KangarooOpts = {}) => new KangarooTwelve(168, 32, chooseLen(opts, 32), 12, opts)
   ))();
 /** MarsupilamiFourteen: reduced 14-round keccak. */
 export const m14: CHashO = /* @__PURE__ */ (() =>
-  wrapConstructorWithOpts<KangarooTwelve, KangarooOpts>(
+  createOptHasher<KangarooTwelve, KangarooOpts>(
     (opts: KangarooOpts = {}) => new KangarooTwelve(136, 64, chooseLen(opts, 64), 14, opts)
   ))();
 
@@ -434,7 +445,7 @@ export class KeccakPRG extends Keccak {
     anumber(capacity);
     // Rho should be full bytes
     if (capacity < 0 || capacity > 1600 - 10 || (1600 - capacity - 2) % 8)
-      throw new Error('KeccakPRG: Invalid capacity');
+      throw new Error('invalid capacity');
     // blockLen = rho in bytes
     super((1600 - capacity - 2) / 8, 0, 0, true);
     this.rate = 1600 - capacity;
@@ -458,14 +469,14 @@ export class KeccakPRG extends Keccak {
   }
   protected finish(): void {}
   digestInto(_out: Uint8Array): Uint8Array {
-    throw new Error('KeccakPRG: digest is not allowed, please use .fetch instead.');
+    throw new Error('digest is not allowed, use .fetch instead');
   }
   fetch(bytes: number): Uint8Array {
     return this.xof(bytes);
   }
   // Ensure irreversibility (even if state leaked previous outputs cannot be computed)
   forget(): void {
-    if (this.rate < 1600 / 2 + 1) throw new Error('KeccakPRG: rate too low to use forget');
+    if (this.rate < 1600 / 2 + 1) throw new Error('rate is too low to use .forget()');
     this.keccak();
     for (let i = 0; i < this.blockLen; i++) this.state[i] = 0;
     this.pos = this.blockLen;

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

@@ -9,32 +9,28 @@
  * Check out `sha3-addons` module for cSHAKE, k12, and others.
  * @module
  */
-import { abytes, aexists, anumber, aoutput } from './_assert.js';
-import { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';
+import { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.ts';
+// prettier-ignore
 import {
-  byteSwap32,
-  Hash,
-  isLE,
-  toBytes,
-  u32,
-  wrapConstructor,
-  wrapXOFConstructorWithOpts,
-  type CHash,
-  type CHashXO,
-  type HashXOF,
-  type Input,
-} from './utils.js';
+  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[] = [];
-const _0n = /* @__PURE__ */ BigInt(0);
-const _1n = /* @__PURE__ */ BigInt(1);
-const _2n = /* @__PURE__ */ BigInt(2);
-const _7n = /* @__PURE__ */ BigInt(7);
-const _256n = /* @__PURE__ */ BigInt(256);
-const _0x71n = /* @__PURE__ */ BigInt(0x71);
 for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
   // Pi
   [x, y] = [y, (2 * x + 3 * y) % 5];
@@ -49,7 +45,9 @@ for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
   }
   _SHA3_IOTA.push(t);
 }
-const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
+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));
@@ -96,7 +94,7 @@ export function keccakP(s: Uint32Array, rounds: number = 24): void {
     s[0] ^= SHA3_IOTA_H[round];
     s[1] ^= SHA3_IOTA_L[round];
   }
-  B.fill(0);
+  clean(B);
 }
 
 /** Keccak sponge function. */
@@ -107,35 +105,51 @@ export class Keccak extends Hash<Keccak> implements HashXOF<Keccak> {
   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(
-    public blockLen: number,
-    public suffix: number,
-    public outputLen: number,
-    protected enableXOF = false,
-    protected rounds: number = 24
+    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 >= this.blockLen || this.blockLen >= 200)
-      throw new Error('Sha3 supports only keccak-f1600 function');
+    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 {
-    if (!isLE) byteSwap32(this.state32);
+    swap32IfBE(this.state32);
     keccakP(this.state32, this.rounds);
-    if (!isLE) byteSwap32(this.state32);
+    swap32IfBE(this.state32);
     this.posOut = 0;
     this.pos = 0;
   }
   update(data: Input): this {
     aexists(this);
-    const { blockLen, state } = 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);
@@ -190,7 +204,7 @@ export class Keccak extends Hash<Keccak> implements HashXOF<Keccak> {
   }
   destroy(): void {
     this.destroyed = true;
-    this.state.fill(0);
+    clean(this.state);
   }
   _cloneInto(to?: Keccak): Keccak {
     const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
@@ -210,35 +224,35 @@ export class Keccak extends Hash<Keccak> implements HashXOF<Keccak> {
 }
 
 const gen = (suffix: number, blockLen: number, outputLen: number) =>
-  wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+  createHasher(() => new Keccak(blockLen, suffix, outputLen));
 
 /** SHA3-224 hash function. */
-export const sha3_224: CHash = /* @__PURE__ */ gen(0x06, 144, 224 / 8);
+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);
+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);
+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);
+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);
+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);
+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);
+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 const keccak_512: CHash = /* @__PURE__ */ (() => gen(0x01, 72, 512 / 8))();
 
 export type ShakeOpts = { dkLen?: number };
 
 const genShake = (suffix: number, blockLen: number, outputLen: number) =>
-  wrapXOFConstructorWithOpts<HashXOF<Keccak>, ShakeOpts>(
+  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);
+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);
+export const shake256: CHashXO = /* @__PURE__ */ (() => genShake(0x1f, 136, 256 / 8))();