@javakha77/circomlibjs-hinkal-fork 0.0.11 → 0.0.13

package/build/main.cjs

@@ -2,6 +2,27 @@
 
 var ffjavascript = require('ffjavascript');
 var blake1_js = require('@noble/hashes/blake1.js');
+require('ethers');
+var poseidonLite = require('poseidon-lite');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var poseidonLite__namespace = /*#__PURE__*/_interopNamespaceDefault(poseidonLite);
 
 async function buildBabyJub() {
     const bn128 = await ffjavascript.getCurveFromName("bn128", true);
@@ -24948,7 +24969,7 @@ var poseidonConstants = {
  ]
 };
 
-async function buildPoseidon() {
+async function buildPoseidon$1() {
     const bn128 = await ffjavascript.getCurveFromName("bn128", true, buildPoseidonWasm);
 
     const F = bn128.Fr;
@@ -25379,7 +25400,7 @@ function buildPoseidonWasm(module) {
 
 async function buildEddsa() {
   const babyJub = await buildBabyJub();
-  const poseidon = await buildPoseidon();
+  const poseidon = await buildPoseidon$1();
   return new Eddsa(babyJub, poseidon);
 }
 
@@ -25474,7 +25495,274 @@ class Eddsa {
   }
 }
 
+const CIRCOM_P = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+
+// Reduce value into [0, m); handles negative inputs.
+const mod = (value, m = CIRCOM_P) => {
+  const result = value % m;
+  return result >= 0n ? result : result + m;
+};
+
+// Modular inverse via extended Euclidean algorithm (a^-1 mod m).
+const modInverse = (value, m = CIRCOM_P) => {
+  let lm = 1n;
+  let hm = 0n;
+  let low = mod(value, m);
+  let high = m;
+
+  if (low === 0n) throw new Error('Division by zero');
+
+  while (low > 1n) {
+    const remainder = high % low;
+    const quotient = high / low;
+    high = low;
+    low = remainder;
+    const nm = hm - lm * quotient;
+    hm = lm;
+    lm = nm;
+  }
+
+  return lm < 0n ? lm + m : lm;
+};
+
+const P = CIRCOM_P;
+
+// BabyJub base-field arithmetic over CIRCOM_P (same semantics as circomlibjs F).
+const F = {
+  p: P,
+  zero: 0n,
+  one: 1n,
+  e: (v) => mod(BigInt(v)),
+  add: (a, b) => mod(a + b),
+  sub: (a, b) => mod(a - b),
+  mul: (a, b) => mod(a * b),
+  div: (a, b) => {
+    if (b === 0n) throw new Error('Division by zero in BabyJub field');
+    return mod(a * modInverse(b));
+  },
+  toString: (a) => mod(a).toString(),
+};
+
+/**
+ * @typedef {{ X: bigint, Y: bigint, Z: bigint, T: bigint }} ExtPoint
+ */
+
+// Neutral element in extended coordinates (affine identity 0, 1).
+const IDENTITY = { X: F.zero, Y: F.one, Z: F.one, T: F.zero };
+
+// Embed an affine (x, y) point into extended twisted Edwards form.
+const toExtended = (affine) => {
+  const x = F.e(affine[0]);
+  const y = F.e(affine[1]);
+  return { X: x, Y: y, Z: F.one, T: F.mul(x, y) };
+};
+
+// Project an extended point back to affine (x, y) coordinates.
+const toAffine = (point) => {
+  const zInv = modInverse(point.Z);
+  return [F.mul(point.X, zInv), F.mul(point.Y, zInv)];
+};
+
+const A = F.e('168700');
+const D = F.e('168696');
+
+// Add two extended points (add-2008-hwcd; no per-step field inversions).
+const addExtended = (p1, p2) => {
+  const a = F.mul(p1.X, p2.X);
+  const b = F.mul(p1.Y, p2.Y);
+  const c = F.mul(F.mul(p1.T, p2.T), D);
+  const d = F.mul(p1.Z, p2.Z);
+  const e = F.sub(F.mul(F.add(p1.X, p1.Y), F.add(p2.X, p2.Y)), F.add(a, b));
+  const f = F.sub(d, c);
+  const g = F.add(d, c);
+  const h = F.sub(b, F.mul(A, a));
+  return {
+    X: F.mul(e, f),
+    Y: F.mul(g, h),
+    T: F.mul(e, h),
+    Z: F.mul(f, g),
+  };
+};
+
+// Double an extended point (dbl-2008-hwcd; no per-step field inversions).
+const doubleExtended = (p) => {
+  const a = F.mul(p.X, p.X);
+  const b = F.mul(p.Y, p.Y);
+  const c = F.mul(F.mul(p.Z, p.Z), 2n);
+  const d = F.mul(A, a);
+  const e = F.sub(F.mul(F.add(p.X, p.Y), F.add(p.X, p.Y)), F.add(a, b));
+  const g = F.add(d, b);
+  const f = F.sub(g, c);
+  const h = F.sub(d, b);
+  return {
+    X: F.mul(e, f),
+    Y: F.mul(g, h),
+    T: F.mul(e, h),
+    Z: F.mul(f, g),
+  };
+};
+
+// Pure-JS BabyJub curve used on React Native (circomlibjs uses WASM instead).
+class BabyJubRN {
+  static A = A;
+
+  static D = D;
+
+  F = F;
+
+  A = A;
+
+  D = D;
+
+  // Standard BabyJub generator used by EdDSA (matches circomlibjs Base8).
+  Base8 = [
+    F.e('5299619240641551281634865583518297030282874472190772894086521144482721001553'),
+    F.e('16950150798460657717958625567821834550301663161624707787222815936182638968203'),
+  ];
+
+  // Add two affine curve points.
+  addPoint(a, b) {
+    return toAffine(addExtended(toExtended(a), toExtended(b)));
+  }
+
+  // Scalar multiplication: returns e * base (double-and-add in extended coords).
+  mulPointEscalar(base, e) {
+    let res = IDENTITY;
+    let exp = toExtended(base);
+    let rem = BigInt(e);
+
+    while (rem !== 0n) {
+      if (rem % 2n === 1n) res = addExtended(res, exp);
+      exp = doubleExtended(exp);
+      rem /= 2n;
+    }
+
+    return toAffine(res);
+  }
+}
+
+// poseidon-lite exposes `poseidon1`..`poseidon16`; wrap them in a `buildPoseidon`-shaped
+// factory (matching the WASM reference) so callers — and the existing
+// `poseidon.F.toString(...)` pattern — keep working on RN.
+const buildPoseidon = () => {
+  const poseidon = (inputs, initState = 0, nOut = 1) => {
+    const fn = poseidonLite__namespace[`poseidon${inputs.length}`];
+    if (!fn) throw new Error(`Poseidon: arity ${inputs.length} not supported (1..16)`);
+    const formattedInputs = inputs.map((v) => BigInt(v));
+
+    if (nOut > 1) {
+      const results = fn(formattedInputs, nOut);
+      return results.map(v => BigInt(v));
+    }
+
+    const res = fn(formattedInputs);
+    return BigInt(res);
+  };
+  poseidon.F = { toString: (v) => BigInt(v).toString(),
+    e: (v) => BigInt(v),
+    eq: (a, b) => BigInt(a) === BigInt(b)
+   };
+  return poseidon;
+};
+
+class PoseidonHolder {
+  poseidon = undefined;
+
+  async init() {
+    if (this.poseidon) return;
+    this.poseidon = buildPoseidon();
+    return this.poseidon;
+  }
+
+  getPoseidon() {
+    return this.poseidon;
+  }
+}
+
+const PoseidonRN = new PoseidonHolder();
+
+/**
+ * @typedef {(...args: unknown[]) => string} PoseidonHasher
+ */
+
+/* eslint-disable no-bitwise */
+// React Native port of circomlibjs-hinkal-fork/src/eddsa.js (Poseidon EdDSA over BabyJubJub).
+
+const BABYJUB_ORDER = 21888242871839275222246405745257275088614511777268538073601725287587578984328n;
+const SUB_ORDER = BABYJUB_ORDER / 8n;
+
+const leBuff2int = (buff, offset = 0, length = buff.length - offset) => {
+  let result = 0n;
+  for (let i = length - 1; i >= 0; i -= 1) {
+    result = (result << 8n) + BigInt(buff[offset + i]);
+  }
+  return result;
+};
+
+const toRprLE = (buff, offset, value, length) => {
+  let v = mod(value);
+  for (let i = 0; i < length; i += 1) {
+    buff[offset + i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+};
+
+const modSubOrder = (value) => mod(value, SUB_ORDER);
+
+const pruneBuffer = (buff) => {
+  const out = new Uint8Array(buff);
+  out[0] = out[0] & 0xf8;
+  out[31] = out[31] & 0x7f;
+  out[31] = out[31] | 0x40;
+  return out;
+};
+
+/**
+ * @typedef {((inputs: bigint[]) => bigint) & { F: { toString: (v: bigint | number | string) => string } }} PoseidonFn
+ */
+
+class EddsaRN {
+  constructor(babyJub, poseidon) {
+    this.babyJub = babyJub;
+    this.poseidon = poseidon;
+  }
+
+  prv2pub(prv) {
+    const sBuff = pruneBuffer(blake1_js.blake512(prv).slice(0, 32));
+    const s = leBuff2int(sBuff, 0, 32);
+    return this.babyJub.mulPointEscalar(this.babyJub.Base8, s / 8n);
+  }
+
+  signPoseidon(prv, msg) {
+    const sBuff = pruneBuffer(blake1_js.blake512(prv));
+    const s = leBuff2int(sBuff, 0, 32);
+    const A = this.babyJub.mulPointEscalar(this.babyJub.Base8, s / 8n);
+
+    const composeBuff = new Uint8Array(64);
+    composeBuff.set(sBuff.slice(32), 0);
+    toRprLE(composeBuff, 32, msg, 32);
+
+    const rBuff = blake1_js.blake512(composeBuff);
+    const r = modSubOrder(leBuff2int(rBuff, 0, 64));
+    const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
+
+    const hm = this.poseidon([R8[0], R8[1], A[0], A[1], msg]);
+    const hms = mod(BigInt(this.poseidon.F.toString(hm)));
+    const S = modSubOrder(r + modSubOrder(hms * s));
+
+    return { R8, S };
+  }
+}
+
+const buildEddsaRN = async () => {
+  await PoseidonRN.init();
+  return new EddsaRN(new BabyJubRN(), PoseidonRN.getPoseidon());
+};
+
+exports.BabyJubRN = BabyJubRN;
+exports.PoseidonRN = PoseidonRN;
 exports.buildBabyjub = buildBabyJub;
 exports.buildEddsa = buildEddsa;
-exports.buildPoseidon = buildPoseidon;
+exports.buildEddsaRN = buildEddsaRN;
+exports.buildPoseidon = buildPoseidon$1;
 exports.buildPoseidonWasm = buildPoseidonWasm;

package/main.js

@@ -3,3 +3,9 @@ export { default as buildBabyjub } from "./src/babyjub.js";
 export { default as buildEddsa } from "./src/eddsa.js";
 
 export { buildPoseidon, buildPoseidonWasm } from "./src/poseidon_wasm.js";
+
+export { buildEddsaRN } from "./src/EddsaRN.js";
+
+export { BabyJubRN } from "./src/babyjubRN.js";
+
+export { PoseidonRN } from "./src/poseidonRN.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javakha77/circomlibjs-hinkal-fork",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Javascript library to work with circomlib",
   "keywords": [
     "circom",

package/src/poseidonRN.js

@@ -19,7 +19,6 @@ export const buildPoseidon = () => {
     const res = fn(formattedInputs);
     return BigInt(res);
   };
-  
   poseidon.F = { toString: (v) => BigInt(v).toString(),
     e: (v) => BigInt(v),
     eq: (a, b) => BigInt(a) === BigInt(b)

package/src/serialize.utils.js

@@ -1,28 +1,6 @@
 /**
  * @typedef {((key: string, value: any) => any) | null} JsonReplacer
  */
-
-/**
- * Deep-clones a value into plain JSON-serializable data: every `bigint` becomes a decimal string.
- * Use with `res.json(...)` so Express never hits "Do not know how to serialize a BigInt".
- */
-export const toJsonSafe = (value) => {
-    if (typeof value === 'bigint') {
-      return value.toString();
-    }
-    if (value === null || typeof value !== 'object') {
-      return value;
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => toJsonSafe(item));
-    }
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [key, toJsonSafe(nested)]),
-    );
-  };
   
   // Safe JSON.stringify wrapper. Converts BigInt -> string so JSON serialization never throws.
   export const safeJsonStringify = (value, replacer = null, space) =>
@@ -33,17 +11,4 @@ export const toJsonSafe = (value) => {
         return typeof next === 'bigint' ? next.toString() : next;
       },
       space,
-    );
-  
-  export const CustomJSONStringify = (args) => {
-    return JSON.stringify(args, (_, value) => (typeof value === 'bigint' ? `bigint:${value.toString()}` : value));
-  };
-  
-  export const CustomJSONParse = (stringifiedJSON) => {
-    return JSON.parse(stringifiedJSON, (_, value) => {
-      if (typeof value === 'string' && value.startsWith('bigint:')) {
-        return BigInt(value.slice(7));
-      }
-      return value;
-    });
-  };
+    );