@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/fastfile/src/osfile.mjs

@@ -0,0 +1,229 @@
+import h from "../../../../../../../../_virtual/__vite-browser-external.mjs";
+async function y(p, e, s, t) {
+  if (s = s || 4096 * 64, typeof e != "number" && ["w+", "wx+", "r", "ax+", "a+"].indexOf(e) < 0)
+    throw new Error("Invalid open option");
+  const i = await h.promises.open(p, e), a = await i.stat();
+  return new u(i, a, s, t, p);
+}
+class u {
+  constructor(e, s, t, i, a) {
+    for (this.fileName = a, this.fd = e, this.pos = 0, this.pageSize = i || 256; this.pageSize < s.blksize; )
+      this.pageSize *= 2;
+    this.totalSize = s.size, this.totalPages = Math.floor((s.size - 1) / this.pageSize) + 1, this.maxPagesLoaded = Math.floor(t / this.pageSize) + 1, this.pages = {}, this.pendingLoads = [], this.writing = !1, this.reading = !1, this.avBuffs = [], this.history = {};
+  }
+  _loadPage(e) {
+    const s = this, t = new Promise((i, a) => {
+      s.pendingLoads.push({
+        page: e,
+        resolve: i,
+        reject: a
+      });
+    });
+    return s.__statusPage("After Load request: ", e), t;
+  }
+  __statusPage(e, s) {
+    const t = [], i = this;
+    if (!i.logHistory)
+      return;
+    t.push("==" + e + " " + s);
+    let a = "";
+    for (let o = 0; o < i.pendingLoads.length; o++)
+      i.pendingLoads[o].page == s && (a = a + " " + o);
+    if (a && t.push("Pending loads:" + a), typeof i.pages[s] < "u") {
+      const o = i.pages[s];
+      t.push("Loaded"), t.push("pendingOps: " + o.pendingOps), o.loading && t.push("loading: " + o.loading), o.writing && t.push("writing"), o.dirty && t.push("dirty");
+    }
+    t.push("=="), i.history[s] || (i.history[s] = []), i.history[s].push(t);
+  }
+  __printHistory(e) {
+    const s = this;
+    s.history[e] || console.log("Empty History ", e), console.log("History " + e);
+    for (let t = 0; t < s.history[e].length; t++)
+      for (let i = 0; i < s.history[e][t].length; i++)
+        console.log("-> " + s.history[e][t][i]);
+  }
+  _triggerLoad() {
+    const e = this;
+    if (e.reading || e.pendingLoads.length == 0)
+      return;
+    const s = Object.keys(e.pages), t = [];
+    for (let n = 0; n < s.length; n++) {
+      const r = e.pages[parseInt(s[n])];
+      r.dirty == !1 && r.pendingOps == 0 && !r.writing && !r.loading && t.push(parseInt(s[n]));
+    }
+    let i = e.maxPagesLoaded - s.length;
+    const a = [];
+    for (; e.pendingLoads.length > 0 && (typeof e.pages[e.pendingLoads[0].page] < "u" || i > 0 || t.length > 0); ) {
+      const n = e.pendingLoads.shift();
+      if (typeof e.pages[n.page] < "u") {
+        e.pages[n.page].pendingOps++;
+        const r = t.indexOf(n.page);
+        r >= 0 && t.splice(r, 1), e.pages[n.page].loading ? e.pages[n.page].loading.push(n) : n.resolve(), e.__statusPage("After Load (cached): ", n.page);
+      } else {
+        if (i)
+          i--;
+        else {
+          const r = t.shift();
+          e.__statusPage("Before Unload: ", r), e.avBuffs.unshift(e.pages[r]), delete e.pages[r], e.__statusPage("After Unload: ", r);
+        }
+        n.page >= e.totalPages ? (e.pages[n.page] = o(), n.resolve(), e.__statusPage("After Load (new): ", n.page)) : (e.reading = !0, e.pages[n.page] = o(), e.pages[n.page].loading = [n], a.push(e.fd.read(e.pages[n.page].buff, 0, e.pageSize, n.page * e.pageSize).then((r) => {
+          e.pages[n.page].size = r.bytesRead;
+          const g = e.pages[n.page].loading;
+          delete e.pages[n.page].loading;
+          for (let f = 0; f < g.length; f++)
+            g[f].resolve();
+          return e.__statusPage("After Load (loaded): ", n.page), r;
+        }, (r) => {
+          n.reject(r);
+        })), e.__statusPage("After Load (loading): ", n.page));
+      }
+    }
+    Promise.all(a).then(() => {
+      e.reading = !1, e.pendingLoads.length > 0 && setImmediate(e._triggerLoad.bind(e)), e._tryClose();
+    });
+    function o() {
+      if (e.avBuffs.length > 0) {
+        const n = e.avBuffs.shift();
+        return n.dirty = !1, n.pendingOps = 1, n.size = 0, n;
+      } else
+        return {
+          dirty: !1,
+          buff: new Uint8Array(e.pageSize),
+          pendingOps: 1,
+          size: 0
+        };
+    }
+  }
+  _triggerWrite() {
+    const e = this;
+    if (e.writing)
+      return;
+    const s = Object.keys(e.pages), t = [];
+    for (let i = 0; i < s.length; i++) {
+      const a = e.pages[parseInt(s[i])];
+      a.dirty && (a.dirty = !1, a.writing = !0, e.writing = !0, t.push(e.fd.write(a.buff, 0, a.size, parseInt(s[i]) * e.pageSize).then(() => {
+        a.writing = !1;
+      }, (o) => {
+        console.log("ERROR Writing: " + o), e.error = o, e._tryClose();
+      })));
+    }
+    e.writing && Promise.all(t).then(() => {
+      e.writing = !1, setImmediate(e._triggerWrite.bind(e)), e._tryClose(), e.pendingLoads.length > 0 && setImmediate(e._triggerLoad.bind(e));
+    });
+  }
+  _getDirtyPage() {
+    for (let e in this.pages)
+      if (this.pages[e].dirty)
+        return e;
+    return -1;
+  }
+  async write(e, s) {
+    if (e.byteLength == 0)
+      return;
+    const t = this;
+    if (typeof s > "u" && (s = t.pos), t.pos = s + e.byteLength, t.totalSize < s + e.byteLength && (t.totalSize = s + e.byteLength), t.pendingClose)
+      throw new Error("Writing a closing file");
+    const i = Math.floor(s / t.pageSize), a = Math.floor((s + e.byteLength - 1) / t.pageSize), o = [];
+    for (let f = i; f <= a; f++)
+      o.push(t._loadPage(f));
+    t._triggerLoad();
+    let n = i, r = s % t.pageSize, g = e.byteLength;
+    for (; g > 0; ) {
+      await o[n - i];
+      const f = r + g > t.pageSize ? t.pageSize - r : g, d = e.slice(e.byteLength - g, e.byteLength - g + f);
+      new Uint8Array(t.pages[n].buff.buffer, r, f).set(d), t.pages[n].dirty = !0, t.pages[n].pendingOps--, t.pages[n].size = Math.max(r + f, t.pages[n].size), n >= t.totalPages && (t.totalPages = n + 1), g = g - f, n++, r = 0, t.writing || setImmediate(t._triggerWrite.bind(t));
+    }
+  }
+  async read(e, s) {
+    const t = this;
+    let i = new Uint8Array(e);
+    return await t.readToBuffer(i, 0, e, s), i;
+  }
+  async readToBuffer(e, s, t, i) {
+    if (t == 0)
+      return;
+    const a = this;
+    if (t > a.pageSize * a.maxPagesLoaded * 0.8) {
+      const l = Math.floor(t * 1.1);
+      this.maxPagesLoaded = Math.floor(l / a.pageSize) + 1;
+    }
+    if (typeof i > "u" && (i = a.pos), a.pos = i + t, a.pendingClose)
+      throw new Error("Reading a closing file");
+    const o = Math.floor(i / a.pageSize), n = Math.floor((i + t - 1) / a.pageSize), r = [];
+    for (let l = o; l <= n; l++)
+      r.push(a._loadPage(l));
+    a._triggerLoad();
+    let g = o, f = i % a.pageSize, d = i + t > a.totalSize ? t - (i + t - a.totalSize) : t;
+    for (; d > 0; ) {
+      await r[g - o], a.__statusPage("After Await (read): ", g);
+      const l = f + d > a.pageSize ? a.pageSize - f : d, c = new Uint8Array(a.pages[g].buff.buffer, a.pages[g].buff.byteOffset + f, l);
+      e.set(c, s + t - d), a.pages[g].pendingOps--, a.__statusPage("After Op done: ", g), d = d - l, g++, f = 0, a.pendingLoads.length > 0 && setImmediate(a._triggerLoad.bind(a));
+    }
+    this.pos = i + t;
+  }
+  _tryClose() {
+    const e = this;
+    !e.pendingClose || (e.error && e.pendingCloseReject(e.error), e._getDirtyPage() >= 0 || e.writing || e.reading || e.pendingLoads.length > 0) || e.pendingClose();
+  }
+  close() {
+    const e = this;
+    if (e.pendingClose)
+      throw new Error("Closing the file twice");
+    return new Promise((s, t) => {
+      e.pendingClose = s, e.pendingCloseReject = t, e._tryClose();
+    }).then(() => {
+      e.fd.close();
+    }, (s) => {
+      throw e.fd.close(), s;
+    });
+  }
+  async discard() {
+    await this.close(), await h.promises.unlink(this.fileName);
+  }
+  async writeULE32(e, s) {
+    const t = this, i = new Uint8Array(4);
+    new DataView(i.buffer).setUint32(0, e, !0), await t.write(i, s);
+  }
+  async writeUBE32(e, s) {
+    const t = this, i = new Uint8Array(4);
+    new DataView(i.buffer).setUint32(0, e, !1), await t.write(i, s);
+  }
+  async writeULE64(e, s) {
+    const t = this, i = new Uint8Array(8), a = new DataView(i.buffer);
+    a.setUint32(0, e & 4294967295, !0), a.setUint32(4, Math.floor(e / 4294967296), !0), await t.write(i, s);
+  }
+  async readULE32(e) {
+    const t = await this.read(4, e);
+    return new Uint32Array(t.buffer)[0];
+  }
+  async readUBE32(e) {
+    const t = await this.read(4, e);
+    return new DataView(t.buffer).getUint32(0, !1);
+  }
+  async readULE64(e) {
+    const t = await this.read(8, e), i = new Uint32Array(t.buffer);
+    return i[1] * 4294967296 + i[0];
+  }
+  async readString(e) {
+    const s = this;
+    if (s.pendingClose)
+      throw new Error("Reading a closing file");
+    let t = typeof e > "u" ? s.pos : e, i = Math.floor(t / s.pageSize), a = !1, o = "";
+    for (; !a; ) {
+      let n = s._loadPage(i);
+      s._triggerLoad(), await n, s.__statusPage("After Await (read): ", i);
+      let r = t % s.pageSize;
+      const g = new Uint8Array(
+        s.pages[i].buff.buffer,
+        s.pages[i].buff.byteOffset + r,
+        s.pageSize - r
+      );
+      let f = g.findIndex((d) => d === 0);
+      a = f !== -1, a ? (o += new TextDecoder().decode(g.slice(0, f)), s.pos = i * this.pageSize + r + f + 1) : (o += new TextDecoder().decode(g), s.pos = i * this.pageSize + r + g.length), s.pages[i].pendingOps--, s.__statusPage("After Op done: ", i), t = s.pos, i++, s.pendingLoads.length > 0 && setImmediate(s._triggerLoad.bind(s));
+    }
+    return o;
+  }
+}
+export {
+  y as open
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/main.mjs

@@ -0,0 +1,12 @@
+import * as o from "./src/scalar.mjs";
+import { default as m } from "./src/bn128.mjs";
+import { default as p } from "./src/bls12381.mjs";
+import * as r from "./src/utils.mjs";
+import "./src/curves.mjs";
+const a = o, s = r;
+export {
+  a as Scalar,
+  p as buildBls12381,
+  m as buildBn128,
+  s as utils
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/bigbuffer.mjs

@@ -0,0 +1,40 @@
+class A {
+  constructor(e) {
+    this.buffers = [], this.byteLength = e;
+    for (let s = 0; s < e; s += 1073741824) {
+      const t = Math.min(e - s, 1073741824);
+      this.buffers.push(new Uint8Array(t));
+    }
+  }
+  slice(e, s) {
+    s === void 0 && (s = this.byteLength), e === void 0 && (e = 0);
+    const t = s - e, E = Math.floor(e / 1073741824), f = Math.floor((e + t - 1) / 1073741824);
+    if (E == f || t == 0)
+      return this.buffers[E].slice(e % 1073741824, e % 1073741824 + t);
+    let r, l = E, n = e % 1073741824, i = t;
+    for (; i > 0; ) {
+      const c = n + i > 1073741824 ? 1073741824 - n : i, h = new Uint8Array(this.buffers[l].buffer, this.buffers[l].byteOffset + n, c);
+      if (c == t)
+        return h.slice();
+      r || (t <= 1073741824 ? r = new Uint8Array(t) : r = new A(t)), r.set(h, t - i), i = i - c, l++, n = 0;
+    }
+    return r;
+  }
+  set(e, s) {
+    s === void 0 && (s = 0);
+    const t = e.byteLength;
+    if (t == 0)
+      return;
+    const E = Math.floor(s / 1073741824), f = Math.floor((s + t - 1) / 1073741824);
+    if (E == f)
+      return e instanceof A && e.buffers.length == 1 ? this.buffers[E].set(e.buffers[0], s % 1073741824) : this.buffers[E].set(e, s % 1073741824);
+    let r = E, l = s % 1073741824, n = t;
+    for (; n > 0; ) {
+      const i = l + n > 1073741824 ? 1073741824 - l : n, c = e.slice(t - n, t - n + i);
+      new Uint8Array(this.buffers[r].buffer, this.buffers[r].byteOffset + l, i).set(c), n = n - i, r++, l = 0;
+    }
+  }
+}
+export {
+  A as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/bls12381.mjs

@@ -0,0 +1,29 @@
+import { buildBls12381 as r } from "../../wasmcurves/index.mjs";
+import d from "./engine.mjs";
+import { e as f } from "./scalar.mjs";
+import { ModuleBuilder as u } from "../../wasmbuilder/src/modulebuilder.mjs";
+globalThis.curve_bls12381 = null;
+async function p(a, b) {
+  const e = new u();
+  e.setMemory(25), r(e), b && b(e);
+  const l = {};
+  if (l.code = e.build(), l.pq = e.modules.f1m.pq, l.pr = e.modules.frm.pq, l.pG1gen = e.modules.bls12381.pG1gen, l.pG1zero = e.modules.bls12381.pG1zero, l.pG1b = e.modules.bls12381.pG1b, l.pG2gen = e.modules.bls12381.pG2gen, l.pG2zero = e.modules.bls12381.pG2zero, l.pG2b = e.modules.bls12381.pG2b, l.pOneT = e.modules.bls12381.pOneT, l.prePSize = e.modules.bls12381.prePSize, l.preQSize = e.modules.bls12381.preQSize, l.n8q = 48, l.n8r = 32, l.q = e.modules.bls12381.q, l.r = e.modules.bls12381.r, !a && globalThis.curve_bls12381)
+    return globalThis.curve_bls12381;
+  const o = {
+    name: "bls12381",
+    wasm: l,
+    q: f("1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", 16),
+    r: f("73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", 16),
+    n8q: 48,
+    n8r: 32,
+    cofactorG1: f("0x396c8c005555e1568c00aaab0000aaab", 16),
+    cofactorG2: f("0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5", 16),
+    singleThread: !!a
+  }, s = await d(o);
+  return s.terminate = async function() {
+    o.singleThread || (globalThis.curve_bls12381 = null, await this.tm.terminate());
+  }, a || (globalThis.curve_bls12381 = s), s;
+}
+export {
+  p as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/bn128.mjs

@@ -0,0 +1,28 @@
+import { buildBn128 as m } from "../../wasmcurves/index.mjs";
+import i from "./engine.mjs";
+import { e as l } from "./scalar.mjs";
+import { ModuleBuilder as s } from "../../wasmbuilder/src/modulebuilder.mjs";
+globalThis.curve_bn128 = null;
+async function c(o, u) {
+  const e = new s();
+  e.setMemory(25), m(e), u && u(e);
+  const n = {};
+  if (n.code = e.build(), n.pq = e.modules.f1m.pq, n.pr = e.modules.frm.pq, n.pG1gen = e.modules.bn128.pG1gen, n.pG1zero = e.modules.bn128.pG1zero, n.pG1b = e.modules.bn128.pG1b, n.pG2gen = e.modules.bn128.pG2gen, n.pG2zero = e.modules.bn128.pG2zero, n.pG2b = e.modules.bn128.pG2b, n.pOneT = e.modules.bn128.pOneT, n.prePSize = e.modules.bn128.prePSize, n.preQSize = e.modules.bn128.preQSize, n.n8q = 32, n.n8r = 32, n.q = e.modules.bn128.q, n.r = e.modules.bn128.r, !o && globalThis.curve_bn128)
+    return globalThis.curve_bn128;
+  const b = {
+    name: "bn128",
+    wasm: n,
+    q: l("21888242871839275222246405745257275088696311157297823662689037894645226208583"),
+    r: l("21888242871839275222246405745257275088548364400416034343698204186575808495617"),
+    n8q: 32,
+    n8r: 32,
+    cofactorG2: l("30644e72e131a029b85045b68181585e06ceecda572a2489345f2299c0f9fa8d", 16),
+    singleThread: !!o
+  }, r = await i(b);
+  return r.terminate = async function() {
+    b.singleThread || (globalThis.curve_bn128 = null, await this.tm.terminate());
+  }, o || (globalThis.curve_bn128 = r), r;
+}
+export {
+  c as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/chacha.mjs

@@ -0,0 +1,50 @@
+import { add as n, mul as x } from "./scalar.mjs";
+function f(i, t, h, u, r) {
+  i[t] = i[t] + i[h] >>> 0, i[r] = (i[r] ^ i[t]) >>> 0, i[r] = (i[r] << 16 | i[r] >>> 16 & 65535) >>> 0, i[u] = i[u] + i[r] >>> 0, i[h] = (i[h] ^ i[u]) >>> 0, i[h] = (i[h] << 12 | i[h] >>> 20 & 4095) >>> 0, i[t] = i[t] + i[h] >>> 0, i[r] = (i[r] ^ i[t]) >>> 0, i[r] = (i[r] << 8 | i[r] >>> 24 & 255) >>> 0, i[u] = i[u] + i[r] >>> 0, i[h] = (i[h] ^ i[u]) >>> 0, i[h] = (i[h] << 7 | i[h] >>> 25 & 127) >>> 0;
+}
+function a(i) {
+  f(i, 0, 4, 8, 12), f(i, 1, 5, 9, 13), f(i, 2, 6, 10, 14), f(i, 3, 7, 11, 15), f(i, 0, 5, 10, 15), f(i, 1, 6, 11, 12), f(i, 2, 7, 8, 13), f(i, 3, 4, 9, 14);
+}
+class o {
+  constructor(t) {
+    t = t || [0, 0, 0, 0, 0, 0, 0, 0], this.state = [
+      1634760805,
+      857760878,
+      2036477234,
+      1797285236,
+      t[0],
+      t[1],
+      t[2],
+      t[3],
+      t[4],
+      t[5],
+      t[6],
+      t[7],
+      0,
+      0,
+      0,
+      0
+    ], this.idx = 16, this.buff = new Array(16);
+  }
+  nextU32() {
+    return this.idx == 16 && this.update(), this.buff[this.idx++];
+  }
+  nextU64() {
+    return n(x(this.nextU32(), 4294967296), this.nextU32());
+  }
+  nextBool() {
+    return (this.nextU32() & 1) == 1;
+  }
+  update() {
+    for (let t = 0; t < 16; t++)
+      this.buff[t] = this.state[t];
+    for (let t = 0; t < 10; t++)
+      a(this.buff);
+    for (let t = 0; t < 16; t++)
+      this.buff[t] = this.buff[t] + this.state[t] >>> 0;
+    this.idx = 0, this.state[12] = this.state[12] + 1 >>> 0, this.state[12] == 0 && (this.state[13] = this.state[13] + 1 >>> 0, this.state[13] == 0 && (this.state[14] = this.state[14] + 1 >>> 0, this.state[14] == 0 && (this.state[15] = this.state[15] + 1 >>> 0)));
+  }
+}
+export {
+  o as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/curves.mjs

@@ -0,0 +1,7 @@
+import { e as f } from "./scalar.mjs";
+import "./bn128.mjs";
+import "./bls12381.mjs";
+f("73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", 16);
+f("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+f("1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", 16);
+f("21888242871839275222246405745257275088696311157297823662689037894645226208583");

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/engine.mjs

@@ -0,0 +1,27 @@
+import u from "./wasm_field1.mjs";
+import F from "./wasm_field2.mjs";
+import b from "./wasm_field3.mjs";
+import c from "./wasm_curve.mjs";
+import G from "./threadman.mjs";
+import { e as g } from "./scalar.mjs";
+import w from "./engine_applykey.mjs";
+import y from "./engine_pairing.mjs";
+import d from "./engine_multiexp.mjs";
+import l from "./engine_fft.mjs";
+async function v(t) {
+  const r = await G(t.wasm, t.singleThread), e = {};
+  return e.q = g(t.wasm.q.toString()), e.r = g(t.wasm.r.toString()), e.name = t.name, e.tm = r, e.prePSize = t.wasm.prePSize, e.preQSize = t.wasm.preQSize, e.Fr = new u(r, "frm", t.n8r, t.r), e.F1 = new u(r, "f1m", t.n8q, t.q), e.F2 = new F(r, "f2m", e.F1), e.G1 = new c(r, "g1m", e.F1, t.wasm.pG1gen, t.wasm.pG1b, t.cofactorG1), e.G2 = new c(r, "g2m", e.F2, t.wasm.pG2gen, t.wasm.pG2b, t.cofactorG2), e.F6 = new b(r, "f6m", e.F2), e.F12 = new F(r, "ftm", e.F6), e.Gt = e.F12, w(e, "G1"), w(e, "G2"), w(e, "Fr"), d(e, "G1"), d(e, "G2"), l(e, "G1"), l(e, "G2"), l(e, "Fr"), y(e), e.array2buffer = function(o, n) {
+    const m = new Uint8Array(n * o.length);
+    for (let i = 0; i < o.length; i++)
+      m.set(o[i], i * n);
+    return m;
+  }, e.buffer2array = function(o, n) {
+    const m = o.byteLength / n, i = new Array(m);
+    for (let f = 0; f < m; f++)
+      i[f] = o.slice(f * n, f * n + n);
+    return i;
+  }, e;
+}
+export {
+  v as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/engine_applykey.mjs

@@ -0,0 +1,58 @@
+import K from "./bigbuffer.mjs";
+function w(i, l) {
+  const n = i[l], r = i.Fr, o = i.tm;
+  i[l].batchApplyKey = async function(d, _, h, m, p) {
+    m = m || "affine", p = p || "affine";
+    let c, u, t, A, a;
+    if (l == "G1")
+      m == "jacobian" ? (t = n.F.n8 * 3, c = "g1m_batchApplyKey") : (t = n.F.n8 * 2, c = "g1m_batchApplyKeyMixed"), A = n.F.n8 * 3, p == "jacobian" ? a = n.F.n8 * 3 : (u = "g1m_batchToAffine", a = n.F.n8 * 2);
+    else if (l == "G2")
+      m == "jacobian" ? (t = n.F.n8 * 3, c = "g2m_batchApplyKey") : (t = n.F.n8 * 2, c = "g2m_batchApplyKeyMixed"), A = n.F.n8 * 3, p == "jacobian" ? a = n.F.n8 * 3 : (u = "g2m_batchToAffine", a = n.F.n8 * 2);
+    else if (l == "Fr")
+      c = "frm_batchApplyKey", t = n.n8, A = n.n8, a = n.n8;
+    else
+      throw new Error("Invalid group: " + l);
+    const b = Math.floor(d.byteLength / t), y = Math.floor(b / o.concurrency), C = [];
+    h = r.e(h);
+    let F = r.e(_);
+    for (let e = 0; e < o.concurrency; e++) {
+      let s;
+      if (e < o.concurrency - 1 ? s = y : s = b - e * y, s == 0)
+        continue;
+      const f = [];
+      f.push({
+        cmd: "ALLOCSET",
+        var: 0,
+        buff: d.slice(e * y * t, e * y * t + s * t)
+      }), f.push({ cmd: "ALLOCSET", var: 1, buff: F }), f.push({ cmd: "ALLOCSET", var: 2, buff: h }), f.push({ cmd: "ALLOC", var: 3, len: s * Math.max(A, a) }), f.push({
+        cmd: "CALL",
+        fnName: c,
+        params: [
+          { var: 0 },
+          { val: s },
+          { var: 1 },
+          { var: 2 },
+          { var: 3 }
+        ]
+      }), u && f.push({
+        cmd: "CALL",
+        fnName: u,
+        params: [
+          { var: 3 },
+          { val: s },
+          { var: 3 }
+        ]
+      }), f.push({ cmd: "GET", out: 0, var: 3, len: s * a }), C.push(o.queueAction(f)), F = r.mul(F, r.exp(h, s));
+    }
+    const v = await Promise.all(C);
+    let L;
+    d instanceof K ? L = new K(b * a) : L = new Uint8Array(b * a);
+    let G = 0;
+    for (let e = 0; e < v.length; e++)
+      L.set(v[e][0], G), G += v[e][0].byteLength;
+    return L;
+  };
+}
+export {
+  w as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ffjavascript/src/engine_batchconvert.mjs

@@ -0,0 +1,37 @@
+import h from "./bigbuffer.mjs";
+function m(o, v, t, c) {
+  return async function(a) {
+    const r = Math.floor(a.byteLength / t);
+    if (r * t !== a.byteLength)
+      throw new Error("Invalid buffer size");
+    const i = Math.floor(r / o.concurrency), u = [];
+    for (let e = 0; e < o.concurrency; e++) {
+      let n;
+      if (e < o.concurrency - 1 ? n = i : n = r - e * i, n == 0)
+        continue;
+      const L = [
+        { cmd: "ALLOCSET", var: 0, buff: a.slice(e * i * t, e * i * t + n * t) },
+        { cmd: "ALLOC", var: 1, len: c * n },
+        { cmd: "CALL", fnName: v, params: [
+          { var: 0 },
+          { val: n },
+          { var: 1 }
+        ] },
+        { cmd: "GET", out: 0, var: 1, len: c * n }
+      ];
+      u.push(
+        o.queueAction(L)
+      );
+    }
+    const f = await Promise.all(u);
+    let l;
+    a instanceof h ? l = new h(r * c) : l = new Uint8Array(r * c);
+    let s = 0;
+    for (let e = 0; e < f.length; e++)
+      l.set(f[e][0], s), s += f[e][0].byteLength;
+    return l;
+  };
+}
+export {
+  m as default
+};