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

package/src/crypto/ff/scalar.ts

@@ -0,0 +1,264 @@
+const hexLen = [0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4];
+
+export const fromString = (s: string, radix?: number): bigint => {
+  if (!radix || radix === 10) {
+    return BigInt(s);
+  } else if (radix === 16) {
+    if (s.slice(0, 2) == '0x') {
+      return BigInt(s);
+    } else {
+      return BigInt('0x' + s);
+    }
+  }
+
+  throw new Error('Unsupported radix');
+};
+
+export const e = fromString;
+
+export const fromArray = (a: Uint8Array, r: number) => {
+  let acc = BigInt(0);
+  const radix = BigInt(r);
+  for (let i = 0; i < a.length; i++) {
+    acc = acc * radix + BigInt(a[i]!);
+  }
+  return acc;
+};
+
+export const bitLength = (a: bigint): number => {
+  const aS = a.toString(16);
+  return (aS.length - 1) * 4 + hexLen[parseInt(aS[0]!, 16)]!;
+};
+
+export const isNegative = (a: bigint): boolean => {
+  return BigInt(a) < BigInt(0);
+};
+
+export const isZero = (a: bigint) => {
+  return a === zero;
+};
+
+export const shiftLeft = (a: bigint, n: bigint): bigint => {
+  return a << n;
+};
+
+export const shiftRight = (a: bigint, n: bigint): bigint => {
+  return a >> n;
+};
+
+export const shl = shiftLeft;
+export const shr = shiftRight;
+
+export const isOdd = (a: bigint): boolean => {
+  return (a & one) == one;
+};
+
+export const naf = (n: bigint): number[] => {
+  let E = n;
+  const res = [];
+  while (E) {
+    if (E & one) {
+      const z = 2 - Number(E % BigInt(4));
+      res.push(z);
+      E = E - BigInt(z);
+    } else {
+      res.push(0);
+    }
+    E = E >> one;
+  }
+  return res;
+};
+
+export const bits = (n: bigint): number[] => {
+  let E = n;
+  const res = [];
+  while (E) {
+    if (E & one) {
+      res.push(1);
+    } else {
+      res.push(0);
+    }
+    E = E >> one;
+  }
+  return res;
+};
+
+export const toNumber = (s: bigint): number => {
+  if (s > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error('Number too big');
+  }
+  return Number(s);
+};
+
+export const toArray = (s: bigint, r: bigint): number[] => {
+  const res = [];
+  let rem = s;
+  const radix = r;
+  while (rem) {
+    res.unshift(Number(rem % radix));
+    rem = rem / radix;
+  }
+  return res;
+};
+
+export const add = (a: bigint, b: bigint): bigint => {
+  return a + b;
+};
+
+export const sub = (a: bigint, b: bigint): bigint => {
+  return a - b;
+};
+
+export const neg = (a: bigint): bigint => {
+  return -a;
+};
+
+export const mul = (a: bigint, b: bigint): bigint => {
+  return a * b;
+};
+
+export const square = (a: bigint): bigint => {
+  return a * a;
+};
+
+export const pow = (a: bigint, b: bigint): bigint => {
+  return a ** b;
+};
+
+export const exp = (a: bigint, b: bigint): bigint => {
+  return a ** b;
+};
+
+export const abs = (a: bigint): bigint => {
+  return a >= 0 ? a : -a;
+};
+
+export const div = (a: bigint, b: bigint): bigint => {
+  return a / b;
+};
+
+export const mod = (a: bigint, b: bigint): bigint => {
+  return a % b;
+};
+
+export const eq = (a: bigint, b: bigint): boolean => {
+  return a === b;
+};
+
+export const neq = (a: bigint, b: bigint): boolean => {
+  return a !== b;
+};
+
+export const lt = (a: bigint, b: bigint): boolean => {
+  return a < b;
+};
+
+export const gt = (a: bigint, b: bigint): boolean => {
+  return a > b;
+};
+
+export const leq = (a: bigint, b: bigint): boolean => {
+  return a <= b;
+};
+
+export const geq = (a: bigint, b: bigint): boolean => {
+  return a >= b;
+};
+
+export const band = (a: bigint, b: bigint): bigint => {
+  return a & b;
+};
+
+export const bor = (a: bigint, b: bigint): bigint => {
+  return a | b;
+};
+
+export const bXor = (a: bigint, b: bigint): bigint => {
+  return a ^ b;
+};
+
+export const land = (a: bigint, b: bigint): bigint => {
+  return a && b;
+};
+
+export const lor = (a: bigint, b: bigint): bigint => {
+  return a || b;
+};
+
+// Returns a buffer with Little Endian Representation
+export const toRprLE = (
+  buff: Uint8Array,
+  o: number,
+  e: bigint,
+  n8: number
+): void => {
+  const s = '0000000' + e.toString(16);
+  const v = new Uint32Array(buff.buffer, buff.byteOffset + o, n8 / 4);
+  const l = (((s.length - 7) * 4 - 1) >> 5) + 1; // Number of 32bit words;
+  for (let i = 0; i < l; i++)
+    v[i] = parseInt(s.substring(s.length - 8 * i - 8, s.length - 8 * i), 16);
+  for (let i = l; i < v.length; i++) v[i] = 0;
+  for (let i = v.length * 4; i < n8; i++)
+    buff[i] = toNumber(band(shiftRight(e, BigInt(i * 8)), BigInt(0xff)));
+};
+
+// Returns a buffer with Big Endian Representation
+export const toRprBE = (
+  buff: Uint8Array,
+  o: number,
+  e: bigint,
+  n8: number
+): void => {
+  const s = '0000000' + e.toString(16);
+  const v = new DataView(buff.buffer, buff.byteOffset + o, n8);
+  const l = (((s.length - 7) * 4 - 1) >> 5) + 1; // Number of 32bit words;
+  for (let i = 0; i < l; i++)
+    v.setUint32(
+      n8 - i * 4 - 4,
+      parseInt(s.substring(s.length - 8 * i - 8, s.length - 8 * i), 16),
+      false
+    );
+
+  // todo: check this
+  for (let i = 0; i < n8 / 4 - l; i++) v.setInt32(0, 0, false);
+};
+
+// Passes a buffer with Little Endian Representation
+export const fromRprLE = (buff: Uint8Array, o: number, n8?: number): bigint => {
+  n8 = n8 || buff.byteLength;
+  o = o || 0;
+  const v = new Uint32Array(buff.buffer, buff.byteOffset + o, n8 / 4);
+  const a = new Array(n8 / 4);
+  v.forEach(
+    (ch, i) => (a[a.length - i - 1] = ch.toString(16).padStart(8, '0'))
+  );
+  return fromString(a.join(''), 16);
+};
+
+// Passes a buffer with Big Endian Representation
+export const fromRprBE = (buff: Uint8Array, o: number, n8: number): bigint => {
+  n8 = n8 || buff.byteLength;
+  o = o || 0;
+  const v = new DataView(buff.buffer, buff.byteOffset + o, n8);
+  const a = new Array(n8 / 4);
+  for (let i = 0; i < n8 / 4; i++) {
+    a[i] = v
+      .getUint32(i * 4, false)
+      .toString(16)
+      .padStart(8, '0');
+  }
+  return fromString(a.join(''), 16);
+};
+
+export const toString = (a: bigint, radix = 10): string => {
+  return a.toString(radix);
+};
+
+export const toLEBuff = (a: bigint): Uint8Array => {
+  const buff = new Uint8Array(Math.floor((bitLength(a) - 1) / 8) + 1);
+  toRprLE(buff, 0, a, buff.byteLength);
+  return buff;
+};
+
+export const zero = BigInt(0);
+export const one = BigInt(1);

package/src/crypto/ff/utils.ts

@@ -0,0 +1,121 @@
+import * as Scalar from './scalar';
+import { fromBase64 } from '@mysten/sui/utils';
+export function unStringifyBigInts(o: unknown): unknown {
+  if (Array.isArray(o)) {
+    return o.map(unStringifyBigInts);
+  } else if (typeof o == 'object') {
+    const res: { [k: string]: unknown } = {};
+    for (const [key, val] of Object.entries(
+      o as unknown as { [k: string]: unknown }
+    )) {
+      res[key] = unStringifyBigInts(val);
+    }
+    return res;
+  }
+  // base64 decode
+  const byteArray = Uint8Array.from(atob(o as string), (c: any) =>
+    c.charCodeAt(0)
+  );
+  const hex = [...byteArray]
+    .map((x) => x.toString(16).padStart(2, '0'))
+    .join('');
+  return BigInt(`0x${hex}`);
+}
+
+export function beBuff2int(buff: Uint8Array) {
+  let res = BigInt(0);
+  let i = buff.length;
+  let offset = 0;
+  const buffV = new DataView(buff.buffer, buff.byteOffset, buff.byteLength);
+  while (i > 0) {
+    if (i >= 4) {
+      i -= 4;
+      res += BigInt(buffV.getUint32(i)) << BigInt(offset * 8);
+      offset += 4;
+    } else if (i >= 2) {
+      i -= 2;
+      res += BigInt(buffV.getUint16(i)) << BigInt(offset * 8);
+      offset += 2;
+    } else {
+      i -= 1;
+      res += BigInt(buffV.getUint8(i)) << BigInt(offset * 8);
+      offset += 1;
+    }
+  }
+  return res;
+}
+
+export function beInt2Buff(n: bigint, len: number) {
+  let r = n;
+  const buff = new Uint8Array(len);
+  const buffV = new DataView(buff.buffer);
+  let o = len;
+  while (o > 0) {
+    if (o - 4 >= 0) {
+      o -= 4;
+      buffV.setUint32(o, Number(r & BigInt(0xffffffff)));
+      r = r >> BigInt(32);
+    } else if (o - 2 >= 0) {
+      o -= 2;
+      buffV.setUint16(o, Number(r & BigInt(0xffff)));
+      r = r >> BigInt(16);
+    } else {
+      o -= 1;
+      buffV.setUint8(o, Number(r & BigInt(0xff)));
+      r = r >> BigInt(8);
+    }
+  }
+  if (r) {
+    throw new Error('Number does not fit in this length');
+  }
+  return buff;
+}
+
+export function leBuff2int(buff: Uint8Array) {
+  let res = BigInt(0);
+  let i = 0;
+  const buffV = new DataView(buff.buffer, buff.byteOffset, buff.byteLength);
+  while (i < buff.length) {
+    if (i + 4 <= buff.length) {
+      res += BigInt(buffV.getUint32(i, true)) << BigInt(i * 8);
+      i += 4;
+    } else if (i + 2 <= buff.length) {
+      res += BigInt(buffV.getUint16(i, true)) << BigInt(i * 8);
+      i += 2;
+    } else {
+      res += BigInt(buffV.getUint8(i)) << BigInt(i * 8);
+      i += 1;
+    }
+  }
+  return res;
+}
+
+export function leInt2Buff(n: bigint, len: number) {
+  let r = n;
+  if (typeof len === 'undefined') {
+    len = Math.floor((Scalar.bitLength(n) - 1) / 8) + 1;
+    if (len == 0) len = 1;
+  }
+  const buff = new Uint8Array(len);
+  const buffV = new DataView(buff.buffer);
+  let o = 0;
+  while (o < len) {
+    if (o + 4 <= len) {
+      buffV.setUint32(o, Number(r & BigInt(0xffffffff)), true);
+      o += 4;
+      r = r >> BigInt(32);
+    } else if (o + 2 <= len) {
+      buffV.setUint16(o, Number(r & BigInt(0xffff)), true);
+      o += 2;
+      r = r >> BigInt(16);
+    } else {
+      buffV.setUint8(o, Number(r & BigInt(0xff)));
+      o += 1;
+      r = r >> BigInt(8);
+    }
+  }
+  if (r) {
+    throw new Error('Number does not fit in this length');
+  }
+  return buff;
+}

package/src/crypto/index.ts

@@ -0,0 +1,8 @@
+import { poseidon, OPT } from './poseidon';
+
+export const poseidon1 = (x: bigint) => poseidon.hash([x]);
+export const poseidon2 = (x: bigint, y: bigint) => poseidon.hash([x, y]);
+export const poseidon3 = (x: bigint, y: bigint, z: bigint) =>
+  poseidon.hash([x, y, z]);
+
+export { OPT };

package/src/crypto/poseidon/index.ts

@@ -0,0 +1 @@
+export * from './poseidon-opt';