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

package/node_modules/@noble/curves/src/abstract/poseidon.ts

@@ -0,0 +1,331 @@
+/**
+ * Implements [Poseidon](https://www.poseidon-hash.info) ZK-friendly hash.
+ *
+ * There are many poseidon variants with different constants.
+ * We don't provide them: you should construct them manually.
+ * Check out [micro-starknet](https://github.com/paulmillr/micro-starknet) package for a proper example.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { FpInvertBatch, FpPow, type IField, validateField } from './modular.ts';
+import { bitGet } from './utils.ts';
+
+// Grain LFSR (Linear-Feedback Shift Register): https://eprint.iacr.org/2009/109.pdf
+function grainLFSR(state: number[]): () => boolean {
+  let pos = 0;
+  if (state.length !== 80) throw new Error('grainLFRS: wrong state length, should be 80 bits');
+  const getBit = (): boolean => {
+    const r = (offset: number) => state[(pos + offset) % 80];
+    const bit = r(62) ^ r(51) ^ r(38) ^ r(23) ^ r(13) ^ r(0);
+    state[pos] = bit;
+    pos = ++pos % 80;
+    return !!bit;
+  };
+  for (let i = 0; i < 160; i++) getBit();
+  return () => {
+    // https://en.wikipedia.org/wiki/Shrinking_generator
+    while (true) {
+      const b1 = getBit();
+      const b2 = getBit();
+      if (!b1) continue;
+      return b2;
+    }
+  };
+}
+
+export type PoseidonBasicOpts = {
+  Fp: IField<bigint>;
+  t: number; // t = rate + capacity
+  roundsFull: number;
+  roundsPartial: number;
+  isSboxInverse?: boolean;
+};
+
+function validateBasicOpts(opts: PoseidonBasicOpts) {
+  const { Fp, roundsFull } = opts;
+  validateField(Fp);
+  for (const i of ['t', 'roundsFull', 'roundsPartial'] as const) {
+    if (typeof opts[i] !== 'number' || !Number.isSafeInteger(opts[i]))
+      throw new Error('invalid number ' + i);
+  }
+  if (opts.isSboxInverse !== undefined && typeof opts.isSboxInverse !== 'boolean')
+    throw new Error(`Poseidon: invalid param isSboxInverse=${opts.isSboxInverse}`);
+  if (roundsFull & 1) throw new Error('roundsFull is not even' + roundsFull);
+}
+
+function poseidonGrain(opts: PoseidonBasicOpts) {
+  validateBasicOpts(opts);
+  const { Fp } = opts;
+  const state = Array(80).fill(1);
+  let pos = 0;
+  const writeBits = (value: bigint, bitCount: number) => {
+    for (let i = bitCount - 1; i >= 0; i--) state[pos++] = Number(bitGet(value, i));
+  };
+  const _0n = BigInt(0);
+  const _1n = BigInt(1);
+  writeBits(_1n, 2); // prime field
+  writeBits(opts.isSboxInverse ? _1n : _0n, 4); // b2..b5
+  writeBits(BigInt(Fp.BITS), 12); // b6..b17
+  writeBits(BigInt(opts.t), 12); // b18..b29
+  writeBits(BigInt(opts.roundsFull), 10); // b30..b39
+  writeBits(BigInt(opts.roundsPartial), 10); // b40..b49
+
+  const getBit = grainLFSR(state);
+  return (count: number, reject: boolean): bigint[] => {
+    const res: bigint[] = [];
+    for (let i = 0; i < count; i++) {
+      while (true) {
+        let num = _0n;
+        for (let i = 0; i < Fp.BITS; i++) {
+          num <<= _1n;
+          if (getBit()) num |= _1n;
+        }
+        if (reject && num >= Fp.ORDER) continue; // rejection sampling
+        res.push(Fp.create(num));
+        break;
+      }
+    }
+    return res;
+  };
+}
+
+export type PoseidonGrainOpts = PoseidonBasicOpts & {
+  sboxPower?: number;
+};
+
+type PoseidonConstants = { mds: bigint[][]; roundConstants: bigint[][] };
+
+// NOTE: this is not standard but used often for constant generation for poseidon
+// (grain LFRS-like structure)
+export function grainGenConstants(opts: PoseidonGrainOpts, skipMDS: number = 0): PoseidonConstants {
+  const { Fp, t, roundsFull, roundsPartial } = opts;
+  const rounds = roundsFull + roundsPartial;
+  const sample = poseidonGrain(opts);
+  const roundConstants: bigint[][] = [];
+  for (let r = 0; r < rounds; r++) roundConstants.push(sample(t, true));
+  if (skipMDS > 0) for (let i = 0; i < skipMDS; i++) sample(2 * t, false);
+  const xs = sample(t, false);
+  const ys = sample(t, false);
+  // Construct MDS Matrix M[i][j] = 1 / (xs[i] + ys[j])
+  const mds: bigint[][] = [];
+  for (let i = 0; i < t; i++) {
+    const row: bigint[] = [];
+    for (let j = 0; j < t; j++) {
+      const xy = Fp.add(xs[i], ys[j]);
+      if (Fp.is0(xy))
+        throw new Error(`Error generating MDS matrix: xs[${i}] + ys[${j}] resulted in zero.`);
+      row.push(xy);
+    }
+    mds.push(FpInvertBatch(Fp, row));
+  }
+
+  return { roundConstants, mds };
+}
+
+export type PoseidonOpts = PoseidonBasicOpts &
+  PoseidonConstants & {
+    sboxPower?: number;
+    reversePartialPowIdx?: boolean; // Hack for stark
+  };
+
+export function validateOpts(opts: PoseidonOpts): Readonly<{
+  rounds: number;
+  sboxFn: (n: bigint) => bigint;
+  roundConstants: bigint[][];
+  mds: bigint[][];
+  Fp: IField<bigint>;
+  t: number;
+  roundsFull: number;
+  roundsPartial: number;
+  sboxPower?: number;
+  reversePartialPowIdx?: boolean; // Hack for stark
+}> {
+  validateBasicOpts(opts);
+  const { Fp, mds, reversePartialPowIdx: rev, roundConstants: rc } = opts;
+  const { roundsFull, roundsPartial, sboxPower, t } = opts;
+
+  // MDS is TxT matrix
+  if (!Array.isArray(mds) || mds.length !== t) throw new Error('Poseidon: invalid MDS matrix');
+  const _mds = mds.map((mdsRow) => {
+    if (!Array.isArray(mdsRow) || mdsRow.length !== t)
+      throw new Error('invalid MDS matrix row: ' + mdsRow);
+    return mdsRow.map((i) => {
+      if (typeof i !== 'bigint') throw new Error('invalid MDS matrix bigint: ' + i);
+      return Fp.create(i);
+    });
+  });
+
+  if (rev !== undefined && typeof rev !== 'boolean')
+    throw new Error('invalid param reversePartialPowIdx=' + rev);
+
+  if (roundsFull & 1) throw new Error('roundsFull is not even' + roundsFull);
+  const rounds = roundsFull + roundsPartial;
+
+  if (!Array.isArray(rc) || rc.length !== rounds)
+    throw new Error('Poseidon: invalid round constants');
+  const roundConstants = rc.map((rc) => {
+    if (!Array.isArray(rc) || rc.length !== t) throw new Error('invalid round constants');
+    return rc.map((i) => {
+      if (typeof i !== 'bigint' || !Fp.isValid(i)) throw new Error('invalid round constant');
+      return Fp.create(i);
+    });
+  });
+
+  if (!sboxPower || ![3, 5, 7, 17].includes(sboxPower)) throw new Error('invalid sboxPower');
+  const _sboxPower = BigInt(sboxPower);
+  let sboxFn = (n: bigint) => FpPow(Fp, n, _sboxPower);
+  // Unwrapped sbox power for common cases (195->142μs)
+  if (sboxPower === 3) sboxFn = (n: bigint) => Fp.mul(Fp.sqrN(n), n);
+  else if (sboxPower === 5) sboxFn = (n: bigint) => Fp.mul(Fp.sqrN(Fp.sqrN(n)), n);
+
+  return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds: _mds });
+}
+
+export function splitConstants(rc: bigint[], t: number): bigint[][] {
+  if (typeof t !== 'number') throw new Error('poseidonSplitConstants: invalid t');
+  if (!Array.isArray(rc) || rc.length % t) throw new Error('poseidonSplitConstants: invalid rc');
+  const res = [];
+  let tmp = [];
+  for (let i = 0; i < rc.length; i++) {
+    tmp.push(rc[i]);
+    if (tmp.length === t) {
+      res.push(tmp);
+      tmp = [];
+    }
+  }
+  return res;
+}
+
+/** Poseidon NTT-friendly hash. */
+export function poseidon(opts: PoseidonOpts): {
+  (values: bigint[]): bigint[];
+  // For verification in tests
+  roundConstants: bigint[][];
+} {
+  const _opts = validateOpts(opts);
+  const { Fp, mds, roundConstants, rounds: totalRounds, roundsPartial, sboxFn, t } = _opts;
+  const halfRoundsFull = _opts.roundsFull / 2;
+  const partialIdx = _opts.reversePartialPowIdx ? t - 1 : 0;
+  const poseidonRound = (values: bigint[], isFull: boolean, idx: number) => {
+    values = values.map((i, j) => Fp.add(i, roundConstants[idx][j]));
+
+    if (isFull) values = values.map((i) => sboxFn(i));
+    else values[partialIdx] = sboxFn(values[partialIdx]);
+    // Matrix multiplication
+    values = mds.map((i) => i.reduce((acc, i, j) => Fp.add(acc, Fp.mulN(i, values[j])), Fp.ZERO));
+    return values;
+  };
+  const poseidonHash = function poseidonHash(values: bigint[]) {
+    if (!Array.isArray(values) || values.length !== t)
+      throw new Error('invalid values, expected array of bigints with length ' + t);
+    values = values.map((i) => {
+      if (typeof i !== 'bigint') throw new Error('invalid bigint=' + i);
+      return Fp.create(i);
+    });
+    let lastRound = 0;
+    // Apply r_f/2 full rounds.
+    for (let i = 0; i < halfRoundsFull; i++) values = poseidonRound(values, true, lastRound++);
+    // Apply r_p partial rounds.
+    for (let i = 0; i < roundsPartial; i++) values = poseidonRound(values, false, lastRound++);
+    // Apply r_f/2 full rounds.
+    for (let i = 0; i < halfRoundsFull; i++) values = poseidonRound(values, true, lastRound++);
+
+    if (lastRound !== totalRounds) throw new Error('invalid number of rounds');
+    return values;
+  };
+  // For verification in tests
+  poseidonHash.roundConstants = roundConstants;
+  return poseidonHash;
+}
+
+export class PoseidonSponge {
+  private Fp: IField<bigint>;
+  readonly rate: number;
+  readonly capacity: number;
+  readonly hash: ReturnType<typeof poseidon>;
+  private state: bigint[]; // [...capacity, ...rate]
+  private pos = 0;
+  private isAbsorbing = true;
+
+  constructor(
+    Fp: IField<bigint>,
+    rate: number,
+    capacity: number,
+    hash: ReturnType<typeof poseidon>
+  ) {
+    this.Fp = Fp;
+    this.hash = hash;
+    this.rate = rate;
+    this.capacity = capacity;
+    this.state = new Array(rate + capacity);
+    this.clean();
+  }
+  private process(): void {
+    this.state = this.hash(this.state);
+  }
+  absorb(input: bigint[]): void {
+    for (const i of input)
+      if (typeof i !== 'bigint' || !this.Fp.isValid(i)) throw new Error('invalid input: ' + i);
+    for (let i = 0; i < input.length; ) {
+      if (!this.isAbsorbing || this.pos === this.rate) {
+        this.process();
+        this.pos = 0;
+        this.isAbsorbing = true;
+      }
+      const chunk = Math.min(this.rate - this.pos, input.length - i);
+      for (let j = 0; j < chunk; j++) {
+        const idx = this.capacity + this.pos++;
+        this.state[idx] = this.Fp.add(this.state[idx], input[i++]);
+      }
+    }
+  }
+  squeeze(count: number): bigint[] {
+    const res: bigint[] = [];
+    while (res.length < count) {
+      if (this.isAbsorbing || this.pos === this.rate) {
+        this.process();
+        this.pos = 0;
+        this.isAbsorbing = false;
+      }
+      const chunk = Math.min(this.rate - this.pos, count - res.length);
+      for (let i = 0; i < chunk; i++) res.push(this.state[this.capacity + this.pos++]);
+    }
+    return res;
+  }
+  clean(): void {
+    this.state.fill(this.Fp.ZERO);
+    this.isAbsorbing = true;
+    this.pos = 0;
+  }
+  clone(): PoseidonSponge {
+    const c = new PoseidonSponge(this.Fp, this.rate, this.capacity, this.hash);
+    c.pos = this.pos;
+    c.state = [...this.state];
+    return c;
+  }
+}
+
+export type PoseidonSpongeOpts = Omit<PoseidonOpts, 't'> & {
+  rate: number;
+  capacity: number;
+};
+
+/**
+ * The method is not defined in spec, but nevertheless used often.
+ * Check carefully for compatibility: there are many edge cases, like absorbing an empty array.
+ * We cross-test against:
+ * - https://github.com/ProvableHQ/snarkVM/tree/staging/algorithms
+ * - https://github.com/arkworks-rs/crypto-primitives/tree/main
+ */
+export function poseidonSponge(opts: PoseidonSpongeOpts): () => PoseidonSponge {
+  for (const i of ['rate', 'capacity'] as const) {
+    if (typeof opts[i] !== 'number' || !Number.isSafeInteger(opts[i]))
+      throw new Error('invalid number ' + i);
+  }
+  const { rate, capacity } = opts;
+  const t = opts.rate + opts.capacity;
+  // Re-use hash instance between multiple instances
+  const hash = poseidon({ ...opts, t });
+  const { Fp } = opts;
+  return () => new PoseidonSponge(Fp, rate, capacity, hash);
+}

package/node_modules/{@solana/web3.js/node_modules/@noble → @noble}/curves/src/abstract/tower.ts

@@ -10,9 +10,9 @@
  * @module
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import * as mod from './modular.js';
-import { bitLen, bitMask, concatBytes, notImplemented } from './utils.js';
-import type { ProjConstructor, ProjPointType } from './weierstrass.js';
+import * as mod from './modular.ts';
+import { bitLen, bitMask, concatBytes, notImplemented } from './utils.ts';
+import type { ProjConstructor, ProjPointType } from './weierstrass.ts';
 
 // Be friendly to bad ECMAScript parsers by not using bigint literals
 // prettier-ignore
@@ -88,7 +88,7 @@ export function psiFrobenius(
   PSI2_X: Fp2;
   PSI2_Y: Fp2;
 } {
-  // Ψ endomorphism
+  // GLV endomorphism Ψ(P)
   const PSI_X = Fp2.pow(base, (Fp.ORDER - _1n) / _3n); // u^((p-1)/3)
   const PSI_Y = Fp2.pow(base, (Fp.ORDER - _1n) / _2n); // u^((p-1)/2)
   function psi(x: Fp2, y: Fp2): [Fp2, Fp2] {
@@ -167,7 +167,6 @@ export function tower12(opts: Tower12Opts): {
   // Fp
   const Fp = mod.Field(ORDER);
   const FpNONRESIDUE = Fp.create(opts.NONRESIDUE || BigInt(-1));
-  const FpLegendre = mod.FpLegendre(ORDER);
   const Fpdiv2 = Fp.div(Fp.ONE, _2n); // 1/2
 
   // Fp2
@@ -265,14 +264,14 @@ export function tower12(opts: Tower12Opts): {
       const { c0, c1 } = num;
       if (Fp.is0(c1)) {
         // if c0 is quadratic residue
-        if (Fp.eql(FpLegendre(Fp, c0), Fp.ONE)) return Fp2.create({ c0: Fp.sqrt(c0), c1: Fp.ZERO });
+        if (mod.FpLegendre(Fp, c0) === 1) return Fp2.create({ c0: Fp.sqrt(c0), c1: Fp.ZERO });
         else return Fp2.create({ c0: Fp.ZERO, c1: Fp.sqrt(Fp.div(c0, FpNONRESIDUE)) });
       }
       const a = Fp.sqrt(Fp.sub(Fp.sqr(c0), Fp.mul(Fp.sqr(c1), FpNONRESIDUE)));
       let d = Fp.mul(Fp.add(a, c0), Fpdiv2);
-      const legendre = FpLegendre(Fp, d);
+      const legendre = mod.FpLegendre(Fp, d);
       // -1, Quadratic non residue
-      if (!Fp.is0(legendre) && !Fp.eql(legendre, Fp.ONE)) d = Fp.sub(d, a);
+      if (legendre === -1) d = Fp.sub(d, a);
       const a0 = Fp.sqrt(d);
       const candidateSqrt = Fp2.create({ c0: a0, c1: Fp.div(Fp.mul(c1, Fpdiv2), a0) });
       if (!Fp2.eql(Fp2.sqr(candidateSqrt), num)) throw new Error('Cannot find square root');
@@ -540,9 +539,9 @@ export function tower12(opts: Tower12Opts): {
   const Fp12: mod.IField<Fp12> & Fp12Utils = {
     ORDER: Fp2.ORDER, // TODO: unused, but need to verify
     isLE: Fp6.isLE,
-    BITS: 2 * Fp2.BITS,
-    BYTES: 2 * Fp2.BYTES,
-    MASK: bitMask(2 * Fp2.BITS),
+    BITS: 2 * Fp6.BITS,
+    BYTES: 2 * Fp6.BYTES,
+    MASK: bitMask(2 * Fp6.BITS),
     ZERO: { c0: Fp6.ZERO, c1: Fp6.ZERO },
     ONE: { c0: Fp6.ONE, c1: Fp6.ZERO },
     create: (num) => num,

package/node_modules/{@solana/web3.js/node_modules/@noble → @noble}/curves/src/abstract/utils.ts

@@ -10,7 +10,6 @@
 // won't be included into their bundle.
 const _0n = /* @__PURE__ */ BigInt(0);
 const _1n = /* @__PURE__ */ BigInt(1);
-const _2n = /* @__PURE__ */ BigInt(2);
 export type Hex = Uint8Array | string; // hex strings are accepted for simplicity
 export type PrivKey = Hex | bigint; // bigints are accepted to ease learning curve
 export type CHash = {
@@ -33,15 +32,35 @@ export function abool(title: string, value: boolean): void {
   if (typeof value !== 'boolean') throw new Error(title + ' boolean expected, got ' + value);
 }
 
+// Used in weierstrass, der
+export function numberToHexUnpadded(num: number | bigint): string {
+  const hex = num.toString(16);
+  return hex.length & 1 ? '0' + hex : hex;
+}
+
+export function hexToNumber(hex: string): bigint {
+  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
+  return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian
+}
+
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin: boolean =
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function';
+
 // Array where index 0xf0 (240) is mapped to string 'f0'
 const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
   i.toString(16).padStart(2, '0')
 );
+
 /**
+ * Convert byte array to hex string. Uses built-in function, when available.
  * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
  */
 export function bytesToHex(bytes: Uint8Array): string {
   abytes(bytes);
+  // @ts-ignore
+  if (hasHexBuiltin) return bytes.toHex();
   // pre-caching improves the speed 6x
   let hex = '';
   for (let i = 0; i < bytes.length; i++) {
@@ -50,16 +69,6 @@ export function bytesToHex(bytes: Uint8Array): string {
   return hex;
 }
 
-export function numberToHexUnpadded(num: number | bigint): string {
-  const hex = num.toString(16);
-  return hex.length & 1 ? '0' + hex : hex;
-}
-
-export function hexToNumber(hex: string): bigint {
-  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
-  return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian
-}
-
 // We use optimized technique to convert hex string to byte array
 const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;
 function asciiToBase16(ch: number): number | undefined {
@@ -70,10 +79,13 @@ function asciiToBase16(ch: number): number | undefined {
 }
 
 /**
+ * Convert hex string to byte array. Uses built-in function, when available.
  * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
  */
 export function hexToBytes(hex: string): Uint8Array {
   if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
+  // @ts-ignore
+  if (hasHexBuiltin) return Uint8Array.fromHex(hex);
   const hl = hex.length;
   const al = hl / 2;
   if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);
@@ -206,6 +218,7 @@ export function aInRange(title: string, n: bigint, min: bigint, max: bigint): vo
 /**
  * Calculates amount of bits in a bigint.
  * Same as `n.toString(2).length`
+ * TODO: merge with nLength in modular
  */
 export function bitLen(n: bigint): number {
   let len;
@@ -233,12 +246,12 @@ export function bitSet(n: bigint, pos: number, value: boolean): bigint {
  * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
  * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
  */
-export const bitMask = (n: number): bigint => (_2n << BigInt(n - 1)) - _1n;
+export const bitMask = (n: number): bigint => (_1n << BigInt(n)) - _1n;
 
 // DRBG
 
-const u8n = (data?: any) => new Uint8Array(data); // creates Uint8Array
-const u8fr = (arr: any) => Uint8Array.from(arr); // another shortcut
+const u8n = (len: number) => new Uint8Array(len); // creates Uint8Array
+const u8fr = (arr: ArrayLike<number>) => Uint8Array.from(arr); // another shortcut
 type Pred<T> = (v: Uint8Array) => T | undefined;
 /**
  * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
@@ -265,7 +278,7 @@ export function createHmacDrbg<T>(
     i = 0;
   };
   const h = (...b: Uint8Array[]) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)
-  const reseed = (seed = u8n()) => {
+  const reseed = (seed = u8n(0)) => {
     // HMAC-DRBG reseed() function. Steps D-G
     k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)
     v = h(); // v = hmac(k || v)