@meteora-ag/cp-amm-sdk 1.0.1 → 1.0.2

package/node_modules/@solana/web3.js/node_modules/@noble/curves/src/abstract/montgomery.ts

@@ -1,196 +0,0 @@
-/**
- * Montgomery curve methods. It's not really whole montgomery curve,
- * just bunch of very specific methods for X25519 / X448 from
- * [RFC 7748](https://www.rfc-editor.org/rfc/rfc7748)
- * @module
- */
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { mod, pow } from './modular.js';
-import {
-  aInRange,
-  bytesToNumberLE,
-  ensureBytes,
-  numberToBytesLE,
-  validateObject,
-} from './utils.js';
-
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-type Hex = string | Uint8Array;
-
-export type CurveType = {
-  P: bigint; // finite field prime
-  nByteLength: number;
-  adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array;
-  domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array;
-  a: bigint;
-  montgomeryBits: number;
-  powPminus2?: (x: bigint) => bigint;
-  xyToU?: (x: bigint, y: bigint) => bigint;
-  Gu: bigint;
-  randomBytes?: (bytesLength?: number) => Uint8Array;
-};
-
-export type CurveFn = {
-  scalarMult: (scalar: Hex, u: Hex) => Uint8Array;
-  scalarMultBase: (scalar: Hex) => Uint8Array;
-  getSharedSecret: (privateKeyA: Hex, publicKeyB: Hex) => Uint8Array;
-  getPublicKey: (privateKey: Hex) => Uint8Array;
-  utils: { randomPrivateKey: () => Uint8Array };
-  GuBytes: Uint8Array;
-};
-
-function validateOpts(curve: CurveType) {
-  validateObject(
-    curve,
-    {
-      a: 'bigint',
-    },
-    {
-      montgomeryBits: 'isSafeInteger',
-      nByteLength: 'isSafeInteger',
-      adjustScalarBytes: 'function',
-      domain: 'function',
-      powPminus2: 'function',
-      Gu: 'bigint',
-    }
-  );
-  // Set defaults
-  return Object.freeze({ ...curve } as const);
-}
-
-// Uses only one coordinate instead of two
-export function montgomery(curveDef: CurveType): CurveFn {
-  const CURVE = validateOpts(curveDef);
-  const { P } = CURVE;
-  const modP = (n: bigint) => mod(n, P);
-  const montgomeryBits = CURVE.montgomeryBits;
-  const montgomeryBytes = Math.ceil(montgomeryBits / 8);
-  const fieldLen = CURVE.nByteLength;
-  const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes: Uint8Array) => bytes);
-  const powPminus2 = CURVE.powPminus2 || ((x: bigint) => pow(x, P - BigInt(2), P));
-
-  // cswap from RFC7748. But it is not from RFC7748!
-  /*
-    cswap(swap, x_2, x_3):
-         dummy = mask(swap) AND (x_2 XOR x_3)
-         x_2 = x_2 XOR dummy
-         x_3 = x_3 XOR dummy
-         Return (x_2, x_3)
-  Where mask(swap) is the all-1 or all-0 word of the same length as x_2
-   and x_3, computed, e.g., as mask(swap) = 0 - swap.
-  */
-  function cswap(swap: bigint, x_2: bigint, x_3: bigint): [bigint, bigint] {
-    const dummy = modP(swap * (x_2 - x_3));
-    x_2 = modP(x_2 - dummy);
-    x_3 = modP(x_3 + dummy);
-    return [x_2, x_3];
-  }
-
-  // x25519 from 4
-  // The constant a24 is (486662 - 2) / 4 = 121665 for curve25519/X25519
-  const a24 = (CURVE.a - BigInt(2)) / BigInt(4);
-  /**
-   *
-   * @param pointU u coordinate (x) on Montgomery Curve 25519
-   * @param scalar by which the point would be multiplied
-   * @returns new Point on Montgomery curve
-   */
-  function montgomeryLadder(u: bigint, scalar: bigint): bigint {
-    aInRange('u', u, _0n, P);
-    aInRange('scalar', scalar, _0n, P);
-    // Section 5: Implementations MUST accept non-canonical values and process them as
-    // if they had been reduced modulo the field prime.
-    const k = scalar;
-    const x_1 = u;
-    let x_2 = _1n;
-    let z_2 = _0n;
-    let x_3 = u;
-    let z_3 = _1n;
-    let swap = _0n;
-    let sw: [bigint, bigint];
-    for (let t = BigInt(montgomeryBits - 1); t >= _0n; t--) {
-      const k_t = (k >> t) & _1n;
-      swap ^= k_t;
-      sw = cswap(swap, x_2, x_3);
-      x_2 = sw[0];
-      x_3 = sw[1];
-      sw = cswap(swap, z_2, z_3);
-      z_2 = sw[0];
-      z_3 = sw[1];
-      swap = k_t;
-
-      const A = x_2 + z_2;
-      const AA = modP(A * A);
-      const B = x_2 - z_2;
-      const BB = modP(B * B);
-      const E = AA - BB;
-      const C = x_3 + z_3;
-      const D = x_3 - z_3;
-      const DA = modP(D * A);
-      const CB = modP(C * B);
-      const dacb = DA + CB;
-      const da_cb = DA - CB;
-      x_3 = modP(dacb * dacb);
-      z_3 = modP(x_1 * modP(da_cb * da_cb));
-      x_2 = modP(AA * BB);
-      z_2 = modP(E * (AA + modP(a24 * E)));
-    }
-    // (x_2, x_3) = cswap(swap, x_2, x_3)
-    sw = cswap(swap, x_2, x_3);
-    x_2 = sw[0];
-    x_3 = sw[1];
-    // (z_2, z_3) = cswap(swap, z_2, z_3)
-    sw = cswap(swap, z_2, z_3);
-    z_2 = sw[0];
-    z_3 = sw[1];
-    // z_2^(p - 2)
-    const z2 = powPminus2(z_2);
-    // Return x_2 * (z_2^(p - 2))
-    return modP(x_2 * z2);
-  }
-
-  function encodeUCoordinate(u: bigint): Uint8Array {
-    return numberToBytesLE(modP(u), montgomeryBytes);
-  }
-
-  function decodeUCoordinate(uEnc: Hex): bigint {
-    // Section 5: When receiving such an array, implementations of X25519
-    // MUST mask the most significant bit in the final byte.
-    const u = ensureBytes('u coordinate', uEnc, montgomeryBytes);
-    if (fieldLen === 32) u[31] &= 127; // 0b0111_1111
-    return bytesToNumberLE(u);
-  }
-  function decodeScalar(n: Hex): bigint {
-    const bytes = ensureBytes('scalar', n);
-    const len = bytes.length;
-    if (len !== montgomeryBytes && len !== fieldLen) {
-      let valid = '' + montgomeryBytes + ' or ' + fieldLen;
-      throw new Error('invalid scalar, expected ' + valid + ' bytes, got ' + len);
-    }
-    return bytesToNumberLE(adjustScalarBytes(bytes));
-  }
-  function scalarMult(scalar: Hex, u: Hex): Uint8Array {
-    const pointU = decodeUCoordinate(u);
-    const _scalar = decodeScalar(scalar);
-    const pu = montgomeryLadder(pointU, _scalar);
-    // The result was not contributory
-    // https://cr.yp.to/ecdh.html#validate
-    if (pu === _0n) throw new Error('invalid private or public key received');
-    return encodeUCoordinate(pu);
-  }
-  // Computes public key from private. By doing scalar multiplication of base point.
-  const GuBytes = encodeUCoordinate(CURVE.Gu);
-  function scalarMultBase(scalar: Hex): Uint8Array {
-    return scalarMult(scalar, GuBytes);
-  }
-
-  return {
-    scalarMult,
-    scalarMultBase,
-    getSharedSecret: (privateKey: Hex, publicKey: Hex) => scalarMult(privateKey, publicKey),
-    getPublicKey: (privateKey: Hex): Uint8Array => scalarMultBase(privateKey),
-    utils: { randomPrivateKey: () => CURVE.randomBytes!(CURVE.nByteLength) },
-    GuBytes: GuBytes,
-  };
-}

package/node_modules/@solana/web3.js/node_modules/@noble/curves/src/abstract/poseidon.ts

@@ -1,136 +0,0 @@
-/**
- * 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 { FpPow, type IField, validateField } from './modular.js';
-
-export type PoseidonOpts = {
-  Fp: IField<bigint>;
-  t: number;
-  roundsFull: number;
-  roundsPartial: number;
-  sboxPower?: number;
-  reversePartialPowIdx?: boolean; // Hack for stark
-  mds: bigint[][];
-  roundConstants: bigint[][];
-};
-
-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
-}> {
-  const { Fp, mds, reversePartialPowIdx: rev, roundConstants: rc } = opts;
-  const { roundsFull, roundsPartial, sboxPower, t } = 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);
-  }
-
-  // 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].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;
-}