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

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

@@ -5,6 +5,7 @@
  * @module
  */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { anumber } from '@noble/hashes/utils';
 import {
   bitMask,
   bytesToNumberBE,
@@ -13,14 +14,12 @@ import {
   numberToBytesBE,
   numberToBytesLE,
   validateObject,
-} from './utils.js';
+} from './utils.ts';
 
 // prettier-ignore
 const _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);
 // prettier-ignore
 const _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);
-// prettier-ignore
-const _9n =/* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);
 
 // Calculates a modulo b
 export function mod(a: bigint, b: bigint): bigint {
@@ -30,21 +29,12 @@ export function mod(a: bigint, b: bigint): bigint {
 /**
  * Efficiently raise num to power and do modular division.
  * Unsafe in some contexts: uses ladder, so can expose bigint bits.
- * @todo use field version && remove
+ * TODO: remove.
  * @example
  * pow(2n, 6n, 11n) // 64n % 11n == 9n
  */
 export function pow(num: bigint, power: bigint, modulo: bigint): bigint {
-  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
-  if (modulo <= _0n) throw new Error('invalid modulus');
-  if (modulo === _1n) return _0n;
-  let res = _1n;
-  while (power > _0n) {
-    if (power & _1n) res = (res * num) % modulo;
-    num = (num * num) % modulo;
-    power >>= _1n;
-  }
-  return res;
+  return FpPow(Field(modulo), num, power);
 }
 
 /** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */
@@ -83,138 +73,141 @@ export function invert(number: bigint, modulo: bigint): bigint {
   return mod(x, modulo);
 }
 
+// Not all roots are possible! Example which will throw:
+// const NUM =
+// n = 72057594037927816n;
+// Fp = Field(BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'));
+function sqrt3mod4<T>(Fp: IField<T>, n: T) {
+  const p1div4 = (Fp.ORDER + _1n) / _4n;
+  const root = Fp.pow(n, p1div4);
+  // Throw if root^2 != n
+  if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
+  return root;
+}
+
+function sqrt5mod8<T>(Fp: IField<T>, n: T) {
+  const p5div8 = (Fp.ORDER - _5n) / _8n;
+  const n2 = Fp.mul(n, _2n);
+  const v = Fp.pow(n2, p5div8);
+  const nv = Fp.mul(n, v);
+  const i = Fp.mul(Fp.mul(nv, _2n), v);
+  const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+  if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
+  return root;
+}
+
+// TODO: Commented-out for now. Provide test vectors.
+// Tonelli is too slow for extension fields Fp2.
+// That means we can't use sqrt (c1, c2...) even for initialization constants.
+// if (P % _16n === _9n) return sqrt9mod16;
+// // prettier-ignore
+// function sqrt9mod16<T>(Fp: IField<T>, n: T, p7div16?: bigint) {
+//   if (p7div16 === undefined) p7div16 = (Fp.ORDER + BigInt(7)) / _16n;
+//   const c1 = Fp.sqrt(Fp.neg(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F
+//   const c2 = Fp.sqrt(c1);             //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F
+//   const c3 = Fp.sqrt(Fp.neg(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F
+//   const c4 = p7div16;                 //  4. c4 = (q + 7) / 16        # Integer arithmetic
+//   let tv1 = Fp.pow(n, c4);            //  1. tv1 = x^c4
+//   let tv2 = Fp.mul(c1, tv1);          //  2. tv2 = c1 * tv1
+//   const tv3 = Fp.mul(c2, tv1);        //  3. tv3 = c2 * tv1
+//   let tv4 = Fp.mul(c3, tv1);          //  4. tv4 = c3 * tv1
+//   const e1 = Fp.eql(Fp.sqr(tv2), n);  //  5.  e1 = (tv2^2) == x
+//   const e2 = Fp.eql(Fp.sqr(tv3), n);  //  6.  e2 = (tv3^2) == x
+//   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x
+//   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x
+//   const e3 = Fp.eql(Fp.sqr(tv2), n);  //  9.  e3 = (tv2^2) == x
+//   return Fp.cmov(tv1, tv2, e3); // 10.  z = CMOV(tv1, tv2, e3) # Select the sqrt from tv1 and tv2
+// }
+
 /**
  * Tonelli-Shanks square root search algorithm.
  * 1. https://eprint.iacr.org/2012/685.pdf (page 12)
  * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks
- * Will start an infinite loop if field order P is not prime.
  * @param P field order
  * @returns function that takes field Fp (created from P) and number n
  */
 export function tonelliShanks(P: bigint): <T>(Fp: IField<T>, n: T) => T {
-  // Legendre constant: used to calculate Legendre symbol (a | p),
-  // which denotes the value of a^((p-1)/2) (mod p).
-  // (a | p) ≡ 1    if a is a square (mod p)
-  // (a | p) ≡ -1   if a is not a square (mod p)
-  // (a | p) ≡ 0    if a ≡ 0 (mod p)
-  const legendreC = (P - _1n) / _2n;
-
-  let Q: bigint, S: number, Z: bigint;
-  // Step 1: By factoring out powers of 2 from p - 1,
-  // find q and s such that p - 1 = q*(2^s) with q odd
-  for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++);
-
-  // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq
-  for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++) {
-    // Crash instead of infinity loop, we cannot reasonable count until P.
-    if (Z > 1000) throw new Error('Cannot find square root: likely non-prime P');
+  // Initialization (precomputation).
+  if (P < BigInt(3)) throw new Error('sqrt is not defined for small field');
+  // Factor P - 1 = Q * 2^S, where Q is odd
+  let Q = P - _1n;
+  let S = 0;
+  while (Q % _2n === _0n) {
+    Q /= _2n;
+    S++;
   }
 
-  // Fast-path
-  if (S === 1) {
-    const p1div4 = (P + _1n) / _4n;
-    return function tonelliFast<T>(Fp: IField<T>, n: T) {
-      const root = Fp.pow(n, p1div4);
-      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
-      return root;
-    };
+  // Find the first quadratic non-residue Z >= 2
+  let Z = _2n;
+  const _Fp = Field(P);
+  while (FpLegendre(_Fp, Z) === 1) {
+    // Basic primality test for P. After x iterations, chance of
+    // not finding quadratic non-residue is 2^x, so 2^1000.
+    if (Z++ > 1000) throw new Error('Cannot find square root: probably non-prime P');
   }
+  // Fast-path; usually done before Z, but we do "primality test".
+  if (S === 1) return sqrt3mod4;
 
   // Slow-path
+  // TODO: test on Fp2 and others
+  let cc = _Fp.pow(Z, Q); // c = z^Q
   const Q1div2 = (Q + _1n) / _2n;
   return function tonelliSlow<T>(Fp: IField<T>, n: T): T {
-    // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1
-    if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE)) throw new Error('Cannot find square root');
-    let r = S;
-    // TODO: will fail at Fp2/etc
-    let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b
-    let x = Fp.pow(n, Q1div2); // first guess at the square root
-    let b = Fp.pow(n, Q); // first guess at the fudge factor
-
-    while (!Fp.eql(b, Fp.ONE)) {
-      if (Fp.eql(b, Fp.ZERO)) return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)
-      // Find m such b^(2^m)==1
-      let m = 1;
-      for (let t2 = Fp.sqr(b); m < r; m++) {
-        if (Fp.eql(t2, Fp.ONE)) break;
-        t2 = Fp.sqr(t2); // t2 *= t2
+    if (Fp.is0(n)) return n;
+    // Check if n is a quadratic residue using Legendre symbol
+    if (FpLegendre(Fp, n) !== 1) throw new Error('Cannot find square root');
+
+    // Initialize variables for the main loop
+    let M = S;
+    let c = Fp.mul(Fp.ONE, cc); // c = z^Q, move cc from field _Fp into field Fp
+    let t = Fp.pow(n, Q); // t = n^Q, first guess at the fudge factor
+    let R = Fp.pow(n, Q1div2); // R = n^((Q+1)/2), first guess at the square root
+
+    // Main loop
+    // while t != 1
+    while (!Fp.eql(t, Fp.ONE)) {
+      if (Fp.is0(t)) return Fp.ZERO; // if t=0 return R=0
+      let i = 1;
+
+      // Find the smallest i >= 1 such that t^(2^i) ≡ 1 (mod P)
+      let t_tmp = Fp.sqr(t); // t^(2^1)
+      while (!Fp.eql(t_tmp, Fp.ONE)) {
+        i++;
+        t_tmp = Fp.sqr(t_tmp); // t^(2^2)...
+        if (i === M) throw new Error('Cannot find square root');
       }
-      // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow
-      const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)
-      g = Fp.sqr(ge); // g = ge * ge
-      x = Fp.mul(x, ge); // x *= ge
-      b = Fp.mul(b, g); // b *= g
-      r = m;
+
+      // Calculate the exponent for b: 2^(M - i - 1)
+      const exponent = _1n << BigInt(M - i - 1); // bigint is important
+      const b = Fp.pow(c, exponent); // b = 2^(M - i - 1)
+
+      // Update variables
+      M = i;
+      c = Fp.sqr(b); // c = b^2
+      t = Fp.mul(t, c); // t = (t * b^2)
+      R = Fp.mul(R, b); // R = R*b
     }
-    return x;
+    return R;
   };
 }
 
 /**
- * Square root for a finite field. It will try to check if optimizations are applicable and fall back to 4:
+ * Square root for a finite field. Will try optimized versions first:
  *
  * 1. P ≡ 3 (mod 4)
  * 2. P ≡ 5 (mod 8)
- * 3. P ≡ 9 (mod 16)
- * 4. Tonelli-Shanks algorithm
+ * 3. Tonelli-Shanks algorithm
  *
  * Different algorithms can give different roots, it is up to user to decide which one they want.
  * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).
  */
 export function FpSqrt(P: bigint): <T>(Fp: IField<T>, n: T) => T {
-  // P ≡ 3 (mod 4)
-  // √n = n^((P+1)/4)
-  if (P % _4n === _3n) {
-    // Not all roots possible!
-    // const ORDER =
-    //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;
-    // const NUM = 72057594037927816n;
-    const p1div4 = (P + _1n) / _4n;
-    return function sqrt3mod4<T>(Fp: IField<T>, n: T) {
-      const root = Fp.pow(n, p1div4);
-      // Throw if root**2 != n
-      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
-      return root;
-    };
-  }
-
-  // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)
-  if (P % _8n === _5n) {
-    const c1 = (P - _5n) / _8n;
-    return function sqrt5mod8<T>(Fp: IField<T>, n: T) {
-      const n2 = Fp.mul(n, _2n);
-      const v = Fp.pow(n2, c1);
-      const nv = Fp.mul(n, v);
-      const i = Fp.mul(Fp.mul(nv, _2n), v);
-      const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
-      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
-      return root;
-    };
-  }
-
-  // P ≡ 9 (mod 16)
-  if (P % _16n === _9n) {
-    // NOTE: tonelli is too slow for bls-Fp2 calculations even on start
-    // Means we cannot use sqrt for constants at all!
-    //
-    // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F
-    // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F
-    // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F
-    // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic
-    // sqrt = (x) => {
-    //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4
-    //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1
-    //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1
-    //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1
-    //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x
-    //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x
-    //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x
-    //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x
-    //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x
-    //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2
-    // }
-  }
-  // Other cases: Tonelli-Shanks algorithm
+  // P ≡ 3 (mod 4) => √n = n^((P+1)/4)
+  if (P % _4n === _3n) return sqrt3mod4;
+  // P ≡ 5 (mod 8) => Atkin algorithm, page 10 of https://eprint.iacr.org/2012/685.pdf
+  if (P % _8n === _5n) return sqrt5mod8;
+  // P ≡ 9 (mod 16) not implemented, see above
+  // Tonelli-Shanks algorithm
   return tonelliShanks(P);
 }
 
@@ -258,7 +251,6 @@ export interface IField<T> {
   // NOTE: sgn0 is 'negative in LE', which is same as odd. And negative in LE is kinda strange definition anyway.
   isOdd?(num: T): boolean; // Odd instead of even since we have it for Fp2
   // legendre?(num: T): T;
-  pow(lhs: T, power: bigint): T;
   invertBatch: (lst: T[]) => T[];
   toBytes(num: T): Uint8Array;
   fromBytes(bytes: Uint8Array): T;
@@ -291,17 +283,15 @@ export function validateField<T>(field: IField<T>): IField<T> {
  * Same as `pow` but for Fp: non-constant-time.
  * Unsafe in some contexts: uses ladder, so can expose bigint bits.
  */
-export function FpPow<T>(f: IField<T>, num: T, power: bigint): T {
-  // Should have same speed as pow for bigints
-  // TODO: benchmark!
+export function FpPow<T>(Fp: IField<T>, num: T, power: bigint): T {
   if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
-  if (power === _0n) return f.ONE;
+  if (power === _0n) return Fp.ONE;
   if (power === _1n) return num;
-  let p = f.ONE;
+  let p = Fp.ONE;
   let d = num;
   while (power > _0n) {
-    if (power & _1n) p = f.mul(p, d);
-    d = f.sqr(d);
+    if (power & _1n) p = Fp.mul(p, d);
+    d = Fp.sqr(d);
     power >>= _1n;
   }
   return p;
@@ -309,49 +299,58 @@ export function FpPow<T>(f: IField<T>, num: T, power: bigint): T {
 
 /**
  * Efficiently invert an array of Field elements.
- * `inv(0)` will return `undefined` here: make sure to throw an error.
+ * Exception-free. Will return `undefined` for 0 elements.
+ * @param passZero map 0 to 0 (instead of undefined)
  */
-export function FpInvertBatch<T>(f: IField<T>, nums: T[]): T[] {
-  const tmp = new Array(nums.length);
+export function FpInvertBatch<T>(Fp: IField<T>, nums: T[], passZero = false): T[] {
+  const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);
   // Walk from first to last, multiply them by each other MOD p
-  const lastMultiplied = nums.reduce((acc, num, i) => {
-    if (f.is0(num)) return acc;
-    tmp[i] = acc;
-    return f.mul(acc, num);
-  }, f.ONE);
+  const multipliedAcc = nums.reduce((acc, num, i) => {
+    if (Fp.is0(num)) return acc;
+    inverted[i] = acc;
+    return Fp.mul(acc, num);
+  }, Fp.ONE);
   // Invert last element
-  const inverted = f.inv(lastMultiplied);
+  const invertedAcc = Fp.inv(multipliedAcc);
   // Walk from last to first, multiply them by inverted each other MOD p
   nums.reduceRight((acc, num, i) => {
-    if (f.is0(num)) return acc;
-    tmp[i] = f.mul(acc, tmp[i]);
-    return f.mul(acc, num);
-  }, inverted);
-  return tmp;
+    if (Fp.is0(num)) return acc;
+    inverted[i] = Fp.mul(acc, inverted[i]);
+    return Fp.mul(acc, num);
+  }, invertedAcc);
+  return inverted;
 }
 
-export function FpDiv<T>(f: IField<T>, lhs: T, rhs: T | bigint): T {
-  return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));
+// TODO: remove
+export function FpDiv<T>(Fp: IField<T>, lhs: T, rhs: T | bigint): T {
+  return Fp.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, Fp.ORDER) : Fp.inv(rhs));
 }
 
 /**
  * Legendre symbol.
+ * Legendre constant is used to calculate Legendre symbol (a | p)
+ * which denotes the value of a^((p-1)/2) (mod p).
+ *
  * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue
  * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue
  * * (a | p) ≡ 0    if a ≡ 0 (mod p)
  */
-export function FpLegendre(order: bigint): <T>(f: IField<T>, x: T) => T {
-  const legendreConst = (order - _1n) / _2n; // Integer arithmetic
-  return <T>(f: IField<T>, x: T): T => f.pow(x, legendreConst);
+export function FpLegendre<T>(Fp: IField<T>, n: T): -1 | 0 | 1 {
+  // We can use 3rd argument as optional cache of this value
+  // but seems unneeded for now. The operation is very fast.
+  const p1mod2 = (Fp.ORDER - _1n) / _2n;
+  const powered = Fp.pow(n, p1mod2);
+  const yes = Fp.eql(powered, Fp.ONE);
+  const zero = Fp.eql(powered, Fp.ZERO);
+  const no = Fp.eql(powered, Fp.neg(Fp.ONE));
+  if (!yes && !zero && !no) throw new Error('invalid Legendre symbol result');
+  return yes ? 1 : zero ? 0 : -1;
 }
 
 // This function returns True whenever the value x is a square in the field F.
-export function FpIsSquare<T>(f: IField<T>): (x: T) => boolean {
-  const legendre = FpLegendre(f.ORDER);
-  return (x: T): boolean => {
-    const p = legendre(f, x);
-    return f.eql(p, f.ZERO) || f.eql(p, f.ONE);
-  };
+export function FpIsSquare<T>(Fp: IField<T>, n: T): boolean {
+  const l = FpLegendre(Fp, n);
+  return l === 1;
 }
 
 // CURVE.n lengths
@@ -363,6 +362,7 @@ export function nLength(
   nByteLength: number;
 } {
   // Bit size, byte size of CURVE.n
+  if (nBitLength !== undefined) anumber(nBitLength);
   const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
   const nByteLength = Math.ceil(_nBitLength / 8);
   return { nBitLength: _nBitLength, nByteLength };
@@ -433,16 +433,17 @@ export function Field(
         if (!sqrtP) sqrtP = FpSqrt(ORDER);
         return sqrtP(f, n);
       }),
-    invertBatch: (lst) => FpInvertBatch(f, lst),
-    // TODO: do we really need constant cmov?
-    // We don't have const-time bigints anyway, so probably will be not very useful
-    cmov: (a, b, c) => (c ? b : a),
     toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),
     fromBytes: (bytes) => {
       if (bytes.length !== BYTES)
         throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);
       return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
     },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (lst) => FpInvertBatch(f, lst),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (a, b, c) => (c ? b : a),
   } as FpField);
   return Object.freeze(f);
 }

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

@@ -0,0 +1,165 @@
+/**
+ * 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 } from './modular.ts';
+import {
+  aInRange,
+  bytesToNumberLE,
+  ensureBytes,
+  numberToBytesLE,
+  validateObject,
+} from './utils.ts';
+
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+type Hex = string | Uint8Array;
+
+export type CurveType = {
+  P: bigint; // finite field prime
+  type: 'x25519' | 'x448';
+  adjustScalarBytes: (bytes: Uint8Array) => Uint8Array;
+  powPminus2: (x: bigint) => 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, {
+    adjustScalarBytes: 'function',
+    powPminus2: 'function',
+  });
+  return Object.freeze({ ...curve } as const);
+}
+
+export function montgomery(curveDef: CurveType): CurveFn {
+  const CURVE = validateOpts(curveDef);
+  const { P, type, adjustScalarBytes, powPminus2 } = CURVE;
+  const is25519 = type === 'x25519';
+  if (!is25519 && type !== 'x448') throw new Error('invalid type');
+
+  const montgomeryBits = is25519 ? 255 : 448;
+  const fieldLen = is25519 ? 32 : 56;
+  const Gu = is25519 ? BigInt(9) : BigInt(5);
+  // RFC 7748 #5:
+  // The constant a24 is (486662 - 2) / 4 = 121665 for curve25519/X25519 and
+  // (156326 - 2) / 4 = 39081 for curve448/X448
+  // const a = is25519 ? 156326n : 486662n;
+  const a24 = is25519 ? BigInt(121665) : BigInt(39081);
+  // RFC: x25519 "the resulting integer is of the form 2^254 plus
+  // eight times a value between 0 and 2^251 - 1 (inclusive)"
+  // x448: "2^447 plus four times a value between 0 and 2^445 - 1 (inclusive)"
+  const minScalar = is25519 ? _2n ** BigInt(254) : _2n ** BigInt(447);
+  const maxAdded = is25519
+    ? BigInt(8) * _2n ** BigInt(251) - _1n
+    : BigInt(4) * _2n ** BigInt(445) - _1n;
+  const maxScalar = minScalar + maxAdded + _1n; // (inclusive)
+  const modP = (n: bigint) => mod(n, P);
+  const GuBytes = encodeU(Gu);
+  function encodeU(u: bigint): Uint8Array {
+    return numberToBytesLE(modP(u), fieldLen);
+  }
+  function decodeU(u: Hex): bigint {
+    const _u = ensureBytes('u coordinate', u, fieldLen);
+    // RFC: When receiving such an array, implementations of X25519
+    // (but not X448) MUST mask the most significant bit in the final byte.
+    if (is25519) _u[31] &= 127; // 0b0111_1111
+    // RFC: Implementations MUST accept non-canonical values and process them as
+    // if they had been reduced modulo the field prime.  The non-canonical
+    // values are 2^255 - 19 through 2^255 - 1 for X25519 and 2^448 - 2^224
+    // - 1 through 2^448 - 1 for X448.
+    return modP(bytesToNumberLE(_u));
+  }
+  function decodeScalar(scalar: Hex): bigint {
+    return bytesToNumberLE(adjustScalarBytes(ensureBytes('scalar', scalar, fieldLen)));
+  }
+  function scalarMult(scalar: Hex, u: Hex): Uint8Array {
+    const pu = montgomeryLadder(decodeU(u), decodeScalar(scalar));
+    // Some public keys are useless, of low-order. Curve author doesn't think
+    // it needs to be validated, but we do it nonetheless.
+    // https://cr.yp.to/ecdh.html#validate
+    if (pu === _0n) throw new Error('invalid private or public key received');
+    return encodeU(pu);
+  }
+  // Computes public key from private. By doing scalar multiplication of base point.
+  function scalarMultBase(scalar: Hex): Uint8Array {
+    return scalarMult(scalar, GuBytes);
+  }
+
+  // cswap from RFC7748 "example code"
+  function cswap(swap: bigint, x_2: bigint, x_3: bigint): { x_2: bigint; x_3: bigint } {
+    // dummy = mask(swap) AND (x_2 XOR 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.
+    const dummy = modP(swap * (x_2 - x_3));
+    x_2 = modP(x_2 - dummy); // x_2 = x_2 XOR dummy
+    x_3 = modP(x_3 + dummy); // x_3 = x_3 XOR dummy
+    return { x_2, x_3 };
+  }
+
+  /**
+   * Montgomery x-only multiplication ladder.
+   * @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, minScalar, maxScalar);
+    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;
+    for (let t = BigInt(montgomeryBits - 1); t >= _0n; t--) {
+      const k_t = (k >> t) & _1n;
+      swap ^= k_t;
+      ({ x_2, x_3 } = cswap(swap, x_2, x_3));
+      ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+      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));
+    ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+    const z2 = powPminus2(z_2); // `Fp.pow(x, P - _2n)` is much slower equivalent
+    return modP(x_2 * z2); // Return x_2 * (z_2^(p - 2))
+  }
+
+  return {
+    scalarMult,
+    scalarMultBase,
+    getSharedSecret: (privateKey: Hex, publicKey: Hex) => scalarMult(privateKey, publicKey),
+    getPublicKey: (privateKey: Hex): Uint8Array => scalarMultBase(privateKey),
+    utils: { randomPrivateKey: () => CURVE.randomBytes!(fieldLen) },
+    GuBytes: GuBytes.slice(),
+  };
+}