circomlibjs-hinkal-fork 0.0.9 → 0.0.11

package/.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

package/build/main.cjs

@@ -1,7 +1,27 @@
 'use strict';
 
 var ffjavascript = require('ffjavascript');
-var createBlakeHash = require('blake-hash');
+var blake1_js = require('@noble/hashes/blake1.js');
+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 +24968,7 @@ var poseidonConstants = {
  ]
 };
 
-async function buildPoseidon() {
+async function buildPoseidon$1() {
     const bn128 = await ffjavascript.getCurveFromName("bn128", true, buildPoseidonWasm);
 
     const F = bn128.Fr;
@@ -25379,7 +25399,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);
 }
 
@@ -25398,9 +25418,7 @@ class Eddsa {
   }
 
   prv2pub(prv) {
-    const sBuff = this.pruneBuffer(
-      createBlakeHash("blake512").update(prv).digest().slice(0, 32),
-    );
+    const sBuff = this.pruneBuffer(blake1_js.blake512(prv).slice(0, 32));
     let s = ffjavascript.utils.leBuff2int(sBuff);
     const A = this.babyJub.mulPointEscalar(
       this.babyJub.Base8,
@@ -25411,9 +25429,7 @@ class Eddsa {
 
   signPoseidon(prv, msg) {
     const F = this.babyJub.F;
-    const sBuff = this.pruneBuffer(
-      createBlakeHash("blake512").update(Buffer.from(prv)).digest(),
-    );
+    const sBuff = this.pruneBuffer(blake1_js.blake512(prv));
     const s = ffjavascript.Scalar.fromRprLE(sBuff, 0, 32);
     const A = this.babyJub.mulPointEscalar(
       this.babyJub.Base8,
@@ -25423,9 +25439,7 @@ class Eddsa {
     const composeBuff = new Uint8Array(32 + msg.length);
     composeBuff.set(sBuff.slice(32), 0);
     F.toRprLE(composeBuff, 32, msg);
-    const rBuff = createBlakeHash("blake512")
-      .update(Buffer.from(composeBuff))
-      .digest();
+    const rBuff = blake1_js.blake512(composeBuff);
     let r = ffjavascript.Scalar.mod(ffjavascript.Scalar.fromRprLE(rBuff, 0, 64), this.babyJub.subOrder);
     const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
 
@@ -25480,7 +25494,286 @@ 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);
+  }
+}
+
+const buildBabyJubRN = () => new BabyJubRN();
+
+const toBigInt = (v) => {
+  switch (typeof v) {
+    case "bigint":
+      return v;
+    case "boolean":
+      return v ? 1n : 0n;
+    case "number":
+      if (!Number.isInteger(v))
+        throw new TypeError(`Poseidon: non-integer Number ${v}`);
+      return BigInt(v);
+    case "string": {
+      try {
+        return BigInt(v.trim());
+      } catch {
+        throw new TypeError(
+          `Poseidon: cannot parse string "${v}" as an integer`,
+        );
+      }
+    }
+    default:
+      throw new TypeError(`Poseidon.F: unsupported value of type ${typeof v}`);
+  }
+};
+
+// 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) => toBigInt(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) => toBigInt(v).toString(),
+    e: (v) => toBigInt(v),
+    eq: (a, b) => toBigInt(a) === toBigInt(b),
+  };
+  return poseidon;
+};
+
+/* 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 () => {
+  return new EddsaRN(buildBabyJubRN(), buildPoseidon());
+};
+
+exports.buildBabyJubRN = buildBabyJubRN;
 exports.buildBabyjub = buildBabyJub;
 exports.buildEddsa = buildEddsa;
-exports.buildPoseidon = buildPoseidon;
+exports.buildEddsaRN = buildEddsaRN;
+exports.buildPoseidon = buildPoseidon$1;
+exports.buildPoseidonRN = buildPoseidon;
 exports.buildPoseidonWasm = buildPoseidonWasm;

package/main.js

@@ -1,7 +1,11 @@
-export {default as buildBabyjub} from "./src/babyjub.js";
+export { default as buildBabyjub } from "./src/babyjub.js";
 
-export {default as buildEddsa} from "./src/eddsa.js";
+export { default as buildEddsa } from "./src/eddsa.js";
 
 export { buildPoseidon, buildPoseidonWasm } from "./src/poseidon_wasm.js";
 
+export { buildEddsaRN } from "./src/EddsaRN.js";
 
+export { buildBabyJubRN } from "./src/babyjubRN.js";
+
+export { buildPoseidon as buildPoseidonRN } from "./src/poseidonRN.js";

package/package.json

@@ -7,7 +7,7 @@
     "import": "./main.js",
     "require": "./build/main.cjs"
   },
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Javascript library to work with circomlib",
   "scripts": {
     "test": "mocha",
@@ -31,7 +31,8 @@
     "rollup": "^4.60.4"
   },
   "dependencies": {
+    "@noble/hashes": "^2.2.0",
     "ffjavascript": "^0.3.0",
-    "blake-hash": "^2.0.0"
+    "poseidon-lite": "^0.3.0"
   }
 }

package/src/EddsaRN.js

@@ -0,0 +1,76 @@
+/* eslint-disable no-bitwise */
+// React Native port of circomlibjs-hinkal-fork/src/eddsa.js (Poseidon EdDSA over BabyJubJub).
+import { blake512 } from '@noble/hashes/blake1.js';
+import { buildBabyJubRN } from './babyjubRN.js';
+import { buildPoseidon as buildPoseidonRN } from './poseidonRN.js';
+import { mod } from './bigint-math.utils.js';
+
+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
+ */
+
+export class EddsaRN {
+  constructor(babyJub, poseidon) {
+    this.babyJub = babyJub;
+    this.poseidon = poseidon;
+  }
+
+  prv2pub(prv) {
+    const sBuff = pruneBuffer(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(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 = 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 };
+  }
+}
+
+export const buildEddsaRN = async () => {
+  return new EddsaRN(buildBabyJubRN(), buildPoseidonRN());
+};

package/src/babyjubRN.js

@@ -0,0 +1,124 @@
+import { CIRCOM_P } from "./protocol.constants.js";
+import { mod, modInverse } from "./bigint-math.utils.js";
+
+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).
+export 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);
+  }
+}
+
+export const buildBabyJubRN = () => new BabyJubRN();

package/src/bigint-math.utils.js

@@ -0,0 +1,29 @@
+import { CIRCOM_P } from "./protocol.constants.js";
+
+// Reduce value into [0, m); handles negative inputs.
+export 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).
+export 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;
+};

package/src/eddsa.js

@@ -1,7 +1,7 @@
 import { Scalar, utils } from "ffjavascript";
 import buildBabyJub from "./babyjub.js";
 import { buildPoseidon } from "./poseidon_wasm.js";
-import createBlakeHash from "blake-hash";
+import { blake512 } from "@noble/hashes/blake1.js";
 
 export default async function buildEddsa() {
   const babyJub = await buildBabyJub("bn128");
@@ -24,9 +24,7 @@ class Eddsa {
   }
 
   prv2pub(prv) {
-    const sBuff = this.pruneBuffer(
-      createBlakeHash("blake512").update(prv).digest().slice(0, 32),
-    );
+    const sBuff = this.pruneBuffer(blake512(prv).slice(0, 32));
     let s = utils.leBuff2int(sBuff);
     const A = this.babyJub.mulPointEscalar(
       this.babyJub.Base8,
@@ -37,9 +35,7 @@ class Eddsa {
 
   signPoseidon(prv, msg) {
     const F = this.babyJub.F;
-    const sBuff = this.pruneBuffer(
-      createBlakeHash("blake512").update(Buffer.from(prv)).digest(),
-    );
+    const sBuff = this.pruneBuffer(blake512(prv));
     const s = Scalar.fromRprLE(sBuff, 0, 32);
     const A = this.babyJub.mulPointEscalar(
       this.babyJub.Base8,
@@ -49,9 +45,7 @@ class Eddsa {
     const composeBuff = new Uint8Array(32 + msg.length);
     composeBuff.set(sBuff.slice(32), 0);
     F.toRprLE(composeBuff, 32, msg);
-    const rBuff = createBlakeHash("blake512")
-      .update(Buffer.from(composeBuff))
-      .digest();
+    const rBuff = blake512(composeBuff);
     let r = Scalar.mod(Scalar.fromRprLE(rBuff, 0, 64), this.babyJub.subOrder);
     const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
 

package/src/poseidonRN.js

@@ -0,0 +1,51 @@
+import * as poseidonLite from "poseidon-lite";
+
+const toBigInt = (v) => {
+  switch (typeof v) {
+    case "bigint":
+      return v;
+    case "boolean":
+      return v ? 1n : 0n;
+    case "number":
+      if (!Number.isInteger(v))
+        throw new TypeError(`Poseidon: non-integer Number ${v}`);
+      return BigInt(v);
+    case "string": {
+      try {
+        return BigInt(v.trim());
+      } catch {
+        throw new TypeError(
+          `Poseidon: cannot parse string "${v}" as an integer`,
+        );
+      }
+    }
+    default:
+      throw new TypeError(`Poseidon.F: unsupported value of type ${typeof v}`);
+  }
+};
+
+// 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.
+export const buildPoseidon = () => {
+  const poseidon = (inputs, initState = 0, nOut = 1) => {
+    const fn = poseidonLite[`poseidon${inputs.length}`];
+    if (!fn)
+      throw new Error(`Poseidon: arity ${inputs.length} not supported (1..16)`);
+    const formattedInputs = inputs.map((v) => toBigInt(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) => toBigInt(v).toString(),
+    e: (v) => toBigInt(v),
+    eq: (a, b) => toBigInt(a) === toBigInt(b),
+  };
+  return poseidon;
+};

package/src/protocol.constants.js

@@ -0,0 +1,2 @@
+export const CIRCOM_P =
+  21888242871839275222246405745257275088548364400416034343698204186575808495617n;