@interest-protocol/vortex-sdk 0.0.1-alpha.0 → 1.1.0

package/src/crypto/ff/f1field.ts

@@ -0,0 +1,464 @@
+import * as Scalar from './scalar';
+import { getRandomBytes } from './random';
+
+export class F1Field {
+  type: string;
+  one: bigint;
+  zero: bigint;
+  p: bigint;
+  m: bigint;
+  negOne: bigint;
+  two: bigint;
+  half: bigint;
+  bitLength: number;
+  mask: bigint;
+  n64: number;
+  n32: number;
+  n8: number;
+  R: bigint;
+  s: number;
+  shift: bigint;
+  Ri: bigint;
+  nqr: bigint;
+  t: bigint;
+  nqr_to_t: bigint;
+  k: bigint;
+
+  constructor(p: bigint) {
+    this.type = 'F1';
+    this.one = BigInt(1);
+    this.zero = BigInt(0);
+    this.p = BigInt(p);
+    this.m = Scalar.one;
+    this.negOne = this.p - this.one;
+    this.two = BigInt(2);
+    this.half = this.p >> this.one;
+    this.bitLength = Scalar.bitLength(this.p);
+    this.mask = (this.one << BigInt(this.bitLength)) - this.one;
+
+    this.n64 = Math.floor((this.bitLength - 1) / 64) + 1;
+    this.n32 = this.n64 * 2;
+    this.n8 = this.n64 * 8;
+    this.R = this.e(this.one << BigInt(this.n64 * 64));
+    this.Ri = this.inv(this.R);
+
+    const e = this.negOne >> this.one;
+    this.nqr = this.two;
+    let r = this.pow(this.nqr, e);
+    while (!this.eq(r, this.negOne)) {
+      this.nqr = this.nqr + this.one;
+      r = this.pow(this.nqr, e);
+    }
+
+    this.s = 0;
+    this.t = this.negOne;
+
+    while ((this.t & this.one) == this.zero) {
+      this.s = this.s + 1;
+      this.t = this.t >> this.one;
+    }
+
+    this.nqr_to_t = this.pow(this.nqr, this.t);
+
+    // eslint-disable-next-line @cspell/spellchecker
+    tonelliShanks(this);
+
+    this.shift = this.square(this.nqr);
+    this.k = this.exp(this.nqr, BigInt(2 ** this.s));
+  }
+
+  e(a: string | bigint, b: bigint | undefined = undefined): bigint {
+    let res!: bigint;
+    if (!b) {
+      res = BigInt(a);
+    } else if (b == BigInt(16)) {
+      res = BigInt('0x' + a);
+    }
+    if (res < 0) {
+      let nRes = -res;
+      if (nRes >= this.p) nRes = nRes % this.p;
+      return this.p - nRes;
+    } else {
+      return res >= this.p ? res % this.p : res;
+    }
+  }
+
+  add(a: bigint, b: bigint): bigint {
+    const res = a + b;
+    return res >= this.p ? res - this.p : res;
+  }
+
+  sub(a: bigint, b: bigint): bigint {
+    return a >= b ? a - b : this.p - b + a;
+  }
+
+  neg(a: bigint): bigint {
+    return a ? this.p - a : a;
+  }
+
+  double(a: bigint): bigint {
+    return this.add(a, a);
+  }
+
+  mul(a: bigint, b: bigint): bigint {
+    return (a * b) % this.p;
+  }
+
+  mulScalar(base: bigint, s: bigint) {
+    return (base * this.e(s)) % this.p;
+  }
+
+  square(a: bigint): bigint {
+    return (a * a) % this.p;
+  }
+
+  eq(a: bigint, b: bigint): boolean {
+    return a == b;
+  }
+
+  neq(a: bigint, b: bigint): boolean {
+    return a != b;
+  }
+
+  lt(a: bigint, b: bigint): boolean {
+    const aa = a > this.half ? a - this.p : a;
+    const bb = b > this.half ? b - this.p : b;
+    return aa < bb;
+  }
+
+  gt(a: bigint, b: bigint): boolean {
+    const aa = a > this.half ? a - this.p : a;
+    const bb = b > this.half ? b - this.p : b;
+    return aa > bb;
+  }
+
+  leq(a: bigint, b: bigint): boolean {
+    const aa = a > this.half ? a - this.p : a;
+    const bb = b > this.half ? b - this.p : b;
+    return aa <= bb;
+  }
+
+  geq(a: bigint, b: bigint): boolean {
+    const aa = a > this.half ? a - this.p : a;
+    const bb = b > this.half ? b - this.p : b;
+    return aa >= bb;
+  }
+
+  div(a: bigint, b: bigint): bigint {
+    return this.mul(a, this.inv(b));
+  }
+
+  iDiv(a: bigint, b: bigint): bigint {
+    if (!b) throw new Error('Division by zero');
+    return a / b;
+  }
+
+  inv(a: bigint) {
+    if (!a) throw new Error('Division by zero');
+
+    let t = this.zero;
+    let r = this.p;
+    let newt = this.one;
+    let newR = a % this.p;
+    while (newR) {
+      const q = r / newR;
+      [t, newt] = [newt, t - q * newt];
+      [r, newR] = [newR, r - q * newR];
+    }
+    if (t < this.zero) t += this.p;
+    return t;
+  }
+
+  mod(a: bigint, b: bigint): bigint {
+    return a % b;
+  }
+
+  pow(b: bigint, e: bigint): bigint {
+    return exp(this, b, e);
+  }
+
+  exp(b: bigint, e: bigint): bigint {
+    return exp(this, b, BigInt(e));
+  }
+
+  band(a: bigint, b: bigint): bigint {
+    const res = a & b & this.mask;
+    return res >= this.p ? res - this.p : res;
+  }
+
+  bor(a: bigint, b: bigint): bigint {
+    const res = (a | b) & this.mask;
+    return res >= this.p ? res - this.p : res;
+  }
+
+  bXor(a: bigint, b: bigint): bigint {
+    const res = (a ^ b) & this.mask;
+    return res >= this.p ? res - this.p : res;
+  }
+
+  bNot(a: bigint): bigint {
+    const res = a ^ this.mask;
+    return res >= this.p ? res - this.p : res;
+  }
+
+  shl(a: bigint, b: bigint): bigint {
+    if (Number(b) < this.bitLength) {
+      const res = (a << b) & this.mask;
+      return res >= this.p ? res - this.p : res;
+    } else {
+      const nb = this.p - b;
+      if (Number(nb) < this.bitLength) {
+        return a >> nb;
+      } else {
+        return this.zero;
+      }
+    }
+  }
+
+  shr(a: bigint, b: bigint): bigint {
+    if (Number(b) < this.bitLength) {
+      return a >> b;
+    } else {
+      const nb = this.p - b;
+      if (Number(nb) < this.bitLength) {
+        const res = (a << nb) & this.mask;
+        return res >= this.p ? res - this.p : res;
+      } else {
+        return Scalar.zero;
+      }
+    }
+  }
+
+  land(a: bigint, b: bigint): bigint {
+    return a && b ? this.one : this.zero;
+  }
+
+  lor(a: bigint, b: bigint): bigint {
+    return a || b ? this.one : this.zero;
+  }
+
+  sqrt_old(n: bigint): bigint | null {
+    if (n == this.zero) return this.zero;
+
+    // Test that have solution
+    const res = this.pow(n, this.negOne >> this.one);
+    if (res != this.one) return null;
+
+    let m = this.s;
+    let c = this.nqr_to_t;
+    let t = this.pow(n, this.t);
+    let r = this.pow(n, this.add(this.t, this.one) >> this.one);
+
+    while (t != this.one) {
+      let sq = this.square(t);
+      let i = 1;
+      while (sq != this.one) {
+        i++;
+        sq = this.square(sq);
+      }
+
+      // b = c ^ m-i-1
+      let b = c;
+      for (let j = 0; j < m - i - 1; j++) b = this.square(b);
+
+      m = i;
+      c = this.square(b);
+      t = this.mul(t, c);
+      r = this.mul(r, b);
+    }
+
+    if (r > this.p >> this.one) {
+      r = this.neg(r);
+    }
+
+    return r;
+  }
+
+  normalize(a: bigint): bigint {
+    if (a < 0) {
+      let na = -a;
+      if (na >= this.p) na = na % this.p;
+      return this.p - na;
+    } else {
+      return a >= this.p ? a % this.p : a;
+    }
+  }
+
+  random(): bigint {
+    const nBytes = (this.bitLength * 2) / 8;
+    let res = this.zero;
+    for (let i = 0; i < nBytes; i++) {
+      res = (res << BigInt(8)) + BigInt(getRandomBytes(1)[0]!);
+    }
+    return res % this.p;
+  }
+
+  toString(a: bigint, base = 10) {
+    base = base || 10;
+    let vs;
+    if (a > this.half && base == 10) {
+      const v = this.p - a;
+      vs = '-' + v.toString(base);
+    } else {
+      vs = a.toString(base);
+    }
+    return vs;
+  }
+
+  isZero(a: bigint) {
+    return a == this.zero;
+  }
+
+  // Returns a buffer with Little Endian Representation
+  toRprLE(buff: Uint8Array, o: number, e: bigint) {
+    Scalar.toRprLE(buff, o, e, this.n64 * 8);
+  }
+
+  // Returns a buffer with Big Endian Representation
+  toRprBE(buff: Uint8Array, o: number, e: bigint) {
+    Scalar.toRprBE(buff, o, e, this.n64 * 8);
+  }
+
+  // Returns a buffer with Big Endian Montgomery Representation
+  toRprBEM(buff: Uint8Array, o: number, e: bigint) {
+    return this.toRprBE(buff, o, this.mul(this.R, e));
+  }
+
+  toRprLEM(buff: Uint8Array, o: number, e: bigint) {
+    return this.toRprLE(buff, o, this.mul(this.R, e));
+  }
+
+  // Passes a buffer with Little Endian Representation
+  fromRprLE(buff: Uint8Array, o: number) {
+    return Scalar.fromRprLE(buff, o, this.n8);
+  }
+
+  // Passes a buffer with Big Endian Representation
+  fromRprBE(buff: Uint8Array, o: number) {
+    return Scalar.fromRprBE(buff, o, this.n8);
+  }
+
+  fromRprLEM(buff: Uint8Array, o: number) {
+    return this.mul(this.fromRprLE(buff, o), this.Ri);
+  }
+
+  fromRprBEM(buff: Uint8Array, o: number) {
+    return this.mul(this.fromRprBE(buff, o), this.Ri);
+  }
+
+  toObject(a: bigint): bigint {
+    return a;
+  }
+
+  sqrt(a: bigint): bigint | null {
+    throw new Error('Not implemented sqrt for F1' + a);
+  }
+
+  sqrt_e1!: bigint;
+  sqrt_q!: bigint;
+  sqrt_s!: bigint;
+  sqrt_t!: bigint;
+  sqrt_z!: bigint;
+  sqrt_tm1d2!: bigint;
+}
+
+// eslint-disable-next-line @cspell/spellchecker
+function tonelliShanks(F: F1Field) {
+  F.sqrt_q = Scalar.pow(F.p, F.m);
+
+  F.sqrt_s = Scalar.zero;
+  F.sqrt_t = Scalar.sub(F.sqrt_q, Scalar.one);
+
+  while (!Scalar.isOdd(F.sqrt_t)) {
+    F.sqrt_s = F.sqrt_s + Scalar.one;
+    F.sqrt_t = Scalar.div(F.sqrt_t, 2n);
+  }
+
+  let c0 = F.one;
+
+  while (F.eq(c0, F.one)) {
+    const c = F.random();
+    F.sqrt_z = F.pow(c, F.sqrt_t);
+    c0 = F.pow(F.sqrt_z, 2n ** (F.sqrt_s - Scalar.one));
+  }
+
+  F.sqrt_tm1d2 = Scalar.div(Scalar.sub(F.sqrt_t, Scalar.one), 2n);
+
+  F.sqrt = (a: bigint): bigint | null => {
+    if (F.isZero(a)) return F.zero;
+    let w = F.pow(a, F.sqrt_tm1d2);
+    const a0 = F.pow(F.mul(F.square(w), a), 2n ** (F.sqrt_s - Scalar.one));
+    if (F.eq(a0, F.negOne)) return null;
+
+    let v = F.sqrt_s;
+    let x = F.mul(a, w);
+    let b = F.mul(x, w);
+    let z = F.sqrt_z;
+    while (!F.eq(b, F.one)) {
+      let b2k = F.square(b);
+      let k = Scalar.one;
+      while (!F.eq(b2k, F.one)) {
+        b2k = F.square(b2k);
+        k++;
+      }
+
+      w = z;
+      for (let i = 0; i < v - k - Scalar.one; i++) {
+        w = F.square(w);
+      }
+      z = F.square(w);
+      b = F.mul(b, z);
+      x = F.mul(x, w);
+      v = k;
+    }
+    return F.geq(x, F.zero) ? x : F.neg(x);
+  };
+}
+
+export function mulScalar(F: F1Field, base: bigint, e: bigint): bigint {
+  let res;
+
+  if (Scalar.isZero(e)) return F.zero;
+
+  const n = Scalar.naf(e);
+
+  if (n[n.length - 1] == 1) {
+    res = base;
+  } else if (n[n.length - 1] == -1) {
+    res = F.neg(base);
+  } else {
+    throw new Error('invalid NAF');
+  }
+
+  for (let i = n.length - 2; i >= 0; i--) {
+    res = F.double(res);
+
+    if (n[i] == 1) {
+      res = F.add(res, base);
+    } else if (n[i] == -1) {
+      res = F.sub(res, base);
+    }
+  }
+
+  return res;
+}
+
+export function exp(F: F1Field, base: bigint, e: bigint) {
+  if (Scalar.isZero(e)) return F.one;
+
+  const n = Scalar.bits(e);
+
+  if (n.length == 0) return F.one;
+
+  let res = base;
+
+  for (let i = n.length - 2; i >= 0; i--) {
+    res = F.square(res);
+
+    if (n[i]) {
+      res = F.mul(res, base);
+    }
+  }
+
+  return res;
+}

package/src/crypto/ff/index.ts

@@ -0,0 +1,6 @@
+import * as utils from './utils';
+import * as Scalar from './scalar';
+import { F1Field } from './f1field';
+import { getRandomBytes } from './random';
+
+export { utils, Scalar, F1Field, getRandomBytes };

package/src/crypto/ff/random.ts

@@ -0,0 +1,32 @@
+/**
+ * Type definition for the browser crypto object.
+ */
+type BrowserCrypto = {
+  crypto?: { getRandomValues?: (arg0: Uint8Array) => void };
+};
+
+// Type declaration for Node.js require (used in Node.js environment fallback)
+declare const require: (module: string) => any;
+
+export function getRandomBytes(length: number): Uint8Array {
+  if (length <= 0) {
+    throw new Error('Length must be greater than 0');
+  }
+  const global = globalThis as BrowserCrypto;
+  if (global.crypto?.getRandomValues) {
+    const randomValues = new Uint8Array(length);
+    global.crypto.getRandomValues(randomValues);
+    return randomValues;
+  }
+  // eslint-disable-next-line no-unused-labels
+  NODE: {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const crypto = require('crypto');
+    return crypto.randomBytes(length);
+  }
+
+  throw new Error(
+    'Random byte generation is not supported in this environment'
+  );
+}

package/src/crypto/ff/readme.md

@@ -0,0 +1,8 @@
+# Copyright
+
+```
+    Copyright 2018 0kims association.
+
+    Files in this folder is a part of ffjavascript library rewritten by Typescript.
+    Original implementation is written here https://github.com/iden3/ffjavascript.
+```