@hinkal/common 0.0.116 → 0.0.118

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

@@ -0,0 +1,307 @@
+import { log2 as U, array2buffer as Q, buffer2array as g, buffReverseBits as V } from "./utils.mjs";
+import P from "./bigbuffer.mjs";
+function nn(Z, O) {
+  const l = Z[O], b = Z.Fr, k = l.tm;
+  async function N(i, h, u, c, o, a) {
+    u = u || "affine", c = c || "affine";
+    const w = 14;
+    let s, t, e, S, C, A, m, L;
+    O == "G1" ? (u == "affine" ? (s = l.F.n8 * 2, S = "g1m_batchToJacobian") : s = l.F.n8 * 3, t = l.F.n8 * 3, h && (L = "g1m_fftFinal"), m = "g1m_fftJoin", A = "g1m_fftMix", c == "affine" ? (e = l.F.n8 * 2, C = "g1m_batchToAffine") : e = l.F.n8 * 3) : O == "G2" ? (u == "affine" ? (s = l.F.n8 * 2, S = "g2m_batchToJacobian") : s = l.F.n8 * 3, t = l.F.n8 * 3, h && (L = "g2m_fftFinal"), m = "g2m_fftJoin", A = "g2m_fftMix", c == "affine" ? (e = l.F.n8 * 2, C = "g2m_batchToAffine") : e = l.F.n8 * 3) : O == "Fr" && (s = l.n8, t = l.n8, e = l.n8, h && (L = "frm_fftFinal"), A = "frm_fftMix", m = "frm_fftJoin");
+    let n = !1;
+    Array.isArray(i) ? (i = Q(i, s), n = !0) : i = i.slice(0, i.byteLength);
+    const p = i.byteLength / s, v = U(p);
+    if (1 << v != p)
+      throw new Error("fft must be multiple of 2");
+    if (v == b.s + 1) {
+      let f;
+      return h ? f = await X(i, u, c, o, a) : f = await z(i, u, c, o, a), n ? g(f, e) : f;
+    }
+    let y;
+    h && (y = b.inv(b.e(p)));
+    let I;
+    V(i, s);
+    let E, r = Math.min(1 << w, p), G = p / r;
+    for (; G < k.concurrency && r >= 16; )
+      G *= 2, r /= 2;
+    const J = U(r), _ = [];
+    for (let f = 0; f < G; f++) {
+      o && o.debug(`${a}: fft ${v} mix start: ${f}/${G}`);
+      const d = [];
+      d.push({ cmd: "ALLOC", var: 0, len: t * r });
+      const F = i.slice(r * f * s, r * (f + 1) * s);
+      d.push({ cmd: "SET", var: 0, buff: F }), S && d.push({ cmd: "CALL", fnName: S, params: [{ var: 0 }, { val: r }, { var: 0 }] });
+      for (let j = 1; j <= J; j++)
+        d.push({ cmd: "CALL", fnName: A, params: [{ var: 0 }, { val: r }, { val: j }] });
+      J == v ? (L && (d.push({ cmd: "ALLOCSET", var: 1, buff: y }), d.push({ cmd: "CALL", fnName: L, params: [
+        { var: 0 },
+        { val: r },
+        { var: 1 }
+      ] })), C && d.push({ cmd: "CALL", fnName: C, params: [{ var: 0 }, { val: r }, { var: 0 }] }), d.push({ cmd: "GET", out: 0, var: 0, len: r * e })) : d.push({ cmd: "GET", out: 0, var: 0, len: t * r }), _.push(k.queueAction(d).then((j) => (o && o.debug(`${a}: fft ${v} mix end: ${f}/${G}`), j)));
+    }
+    E = await Promise.all(_);
+    for (let f = 0; f < G; f++)
+      E[f] = E[f][0];
+    for (let f = J + 1; f <= v; f++) {
+      o && o.debug(`${a}: fft  ${v}  join: ${f}/${v}`);
+      const d = 1 << v - f, F = G / d, j = [];
+      for (let $ = 0; $ < d; $++)
+        for (let T = 0; T < F / 2; T++) {
+          const H = b.exp(b.w[f], T * r), K = b.w[f], x = $ * F + T, R = $ * F + T + F / 2, M = [];
+          M.push({ cmd: "ALLOCSET", var: 0, buff: E[x] }), M.push({ cmd: "ALLOCSET", var: 1, buff: E[R] }), M.push({ cmd: "ALLOCSET", var: 2, buff: H }), M.push({ cmd: "ALLOCSET", var: 3, buff: K }), M.push({ cmd: "CALL", fnName: m, params: [
+            { var: 0 },
+            { var: 1 },
+            { val: r },
+            { var: 2 },
+            { var: 3 }
+          ] }), f == v ? (L && (M.push({ cmd: "ALLOCSET", var: 4, buff: y }), M.push({ cmd: "CALL", fnName: L, params: [
+            { var: 0 },
+            { val: r },
+            { var: 4 }
+          ] }), M.push({ cmd: "CALL", fnName: L, params: [
+            { var: 1 },
+            { val: r },
+            { var: 4 }
+          ] })), C && (M.push({ cmd: "CALL", fnName: C, params: [{ var: 0 }, { val: r }, { var: 0 }] }), M.push({ cmd: "CALL", fnName: C, params: [{ var: 1 }, { val: r }, { var: 1 }] })), M.push({ cmd: "GET", out: 0, var: 0, len: r * e }), M.push({ cmd: "GET", out: 1, var: 1, len: r * e })) : (M.push({ cmd: "GET", out: 0, var: 0, len: r * t }), M.push({ cmd: "GET", out: 1, var: 1, len: r * t })), j.push(k.queueAction(M).then((D) => (o && o.debug(`${a}: fft ${v} join  ${f}/${v}  ${$ + 1}/${d} ${T}/${F / 2}`), D)));
+        }
+      const q = await Promise.all(j);
+      for (let $ = 0; $ < d; $++)
+        for (let T = 0; T < F / 2; T++) {
+          const H = $ * F + T, K = $ * F + T + F / 2, x = q.shift();
+          E[H] = x[0], E[K] = x[1];
+        }
+    }
+    if (i instanceof P ? I = new P(p * e) : I = new Uint8Array(p * e), h) {
+      I.set(E[0].slice((r - 1) * e));
+      let f = e;
+      for (let d = G - 1; d > 0; d--)
+        I.set(E[d], f), f += r * e, delete E[d];
+      I.set(E[0].slice(0, (r - 1) * e), f), delete E[0];
+    } else
+      for (let f = 0; f < G; f++)
+        I.set(E[f], r * e * f), delete E[f];
+    return n ? g(I, e) : I;
+  }
+  async function z(i, h, u, c, o) {
+    let a, w;
+    a = i.slice(0, i.byteLength / 2), w = i.slice(i.byteLength / 2, i.byteLength);
+    const s = [];
+    [a, w] = await B(a, w, "fftJoinExt", b.one, b.shift, h, "jacobian", c, o), s.push(N(a, !1, "jacobian", u, c, o)), s.push(N(w, !1, "jacobian", u, c, o));
+    const t = await Promise.all(s);
+    let e;
+    return t[0].byteLength > 1 << 28 ? e = new P(t[0].byteLength * 2) : e = new Uint8Array(t[0].byteLength * 2), e.set(t[0]), e.set(t[1], t[0].byteLength), e;
+  }
+  async function X(i, h, u, c, o) {
+    let a, w;
+    a = i.slice(0, i.byteLength / 2), w = i.slice(i.byteLength / 2, i.byteLength);
+    const s = [];
+    s.push(N(a, !0, h, "jacobian", c, o)), s.push(N(w, !0, h, "jacobian", c, o)), [a, w] = await Promise.all(s);
+    const t = await B(a, w, "fftJoinExtInv", b.one, b.shiftInv, "jacobian", u, c, o);
+    let e;
+    return t[0].byteLength > 1 << 28 ? e = new P(t[0].byteLength * 2) : e = new Uint8Array(t[0].byteLength * 2), e.set(t[0]), e.set(t[1], t[0].byteLength), e;
+  }
+  async function B(i, h, u, c, o, a, w, s, t) {
+    let C, A, m, L, n, p;
+    if (O == "G1")
+      a == "affine" ? (n = l.F.n8 * 2, A = "g1m_batchToJacobian") : n = l.F.n8 * 3, p = l.F.n8 * 3, C = "g1m_" + u, w == "affine" ? (m = "g1m_batchToAffine", L = l.F.n8 * 2) : L = l.F.n8 * 3;
+    else if (O == "G2")
+      a == "affine" ? (n = l.F.n8 * 2, A = "g2m_batchToJacobian") : n = l.F.n8 * 3, C = "g2m_" + u, p = l.F.n8 * 3, w == "affine" ? (m = "g2m_batchToAffine", L = l.F.n8 * 2) : L = l.F.n8 * 3;
+    else if (O == "Fr")
+      n = b.n8, L = b.n8, p = b.n8, C = "frm_" + u;
+    else
+      throw new Error("Invalid group");
+    if (i.byteLength != h.byteLength)
+      throw new Error("Invalid buffer size");
+    const v = Math.floor(i.byteLength / n);
+    if (v != 1 << U(v))
+      throw new Error("Invalid number of points");
+    let y = Math.floor(v / k.concurrency);
+    y < 16 && (y = 16), y > 65536 && (y = 65536);
+    const I = [];
+    for (let _ = 0; _ < v; _ += y) {
+      s && s.debug(`${t}: fftJoinExt Start: ${_}/${v}`);
+      const f = Math.min(v - _, y), d = b.mul(c, b.exp(o, _)), F = [], j = i.slice(_ * n, (_ + f) * n), q = h.slice(_ * n, (_ + f) * n);
+      F.push({ cmd: "ALLOC", var: 0, len: p * f }), F.push({ cmd: "SET", var: 0, buff: j }), F.push({ cmd: "ALLOC", var: 1, len: p * f }), F.push({ cmd: "SET", var: 1, buff: q }), F.push({ cmd: "ALLOCSET", var: 2, buff: d }), F.push({ cmd: "ALLOCSET", var: 3, buff: o }), A && (F.push({ cmd: "CALL", fnName: A, params: [{ var: 0 }, { val: f }, { var: 0 }] }), F.push({ cmd: "CALL", fnName: A, params: [{ var: 1 }, { val: f }, { var: 1 }] })), F.push({ cmd: "CALL", fnName: C, params: [
+        { var: 0 },
+        { var: 1 },
+        { val: f },
+        { var: 2 },
+        { var: 3 },
+        { val: b.s }
+      ] }), m && (F.push({ cmd: "CALL", fnName: m, params: [{ var: 0 }, { val: f }, { var: 0 }] }), F.push({ cmd: "CALL", fnName: m, params: [{ var: 1 }, { val: f }, { var: 1 }] })), F.push({ cmd: "GET", out: 0, var: 0, len: f * L }), F.push({ cmd: "GET", out: 1, var: 1, len: f * L }), I.push(
+        k.queueAction(F).then(($) => (s && s.debug(`${t}: fftJoinExt End: ${_}/${v}`), $))
+      );
+    }
+    const E = await Promise.all(I);
+    let r, G;
+    v * L > 1 << 28 ? (r = new P(v * L), G = new P(v * L)) : (r = new Uint8Array(v * L), G = new Uint8Array(v * L));
+    let J = 0;
+    for (let _ = 0; _ < E.length; _++)
+      r.set(E[_][0], J), G.set(E[_][1], J), J += E[_][0].byteLength;
+    return [r, G];
+  }
+  l.fft = async function(i, h, u, c, o) {
+    return await N(i, !1, h, u, c, o);
+  }, l.ifft = async function(i, h, u, c, o) {
+    return await N(i, !0, h, u, c, o);
+  }, l.lagrangeEvaluations = async function(i, h, u, c, o) {
+    h = h || "affine", u = u || "affine";
+    let a;
+    if (O == "G1")
+      h == "affine" ? a = l.F.n8 * 2 : a = l.F.n8 * 3;
+    else if (O == "G2")
+      h == "affine" ? a = l.F.n8 * 2 : a = l.F.n8 * 3;
+    else if (O == "Fr")
+      a = b.n8;
+    else
+      throw new Error("Invalid group");
+    const w = i.byteLength / a, s = U(w);
+    if (2 ** s * a != i.byteLength)
+      throw c && c.error("lagrangeEvaluations iinvalid input size"), new Error("lagrangeEvaluations invalid Input size");
+    if (s <= b.s)
+      return await l.ifft(i, h, u, c, o);
+    if (s > b.s + 1)
+      throw c && c.error("lagrangeEvaluations input too big"), new Error("lagrangeEvaluations input too big");
+    let t = i.slice(0, i.byteLength / 2), e = i.slice(i.byteLength / 2, i.byteLength);
+    const S = b.exp(b.shift, w / 2), C = b.inv(b.sub(b.one, S));
+    [t, e] = await B(t, e, "prepareLagrangeEvaluation", C, b.shiftInv, h, "jacobian", c, o + " prep");
+    const A = [];
+    A.push(N(t, !0, "jacobian", u, c, o + " t0")), A.push(N(e, !0, "jacobian", u, c, o + " t1")), [t, e] = await Promise.all(A);
+    let m;
+    return t.byteLength > 1 << 28 ? m = new P(t.byteLength * 2) : m = new Uint8Array(t.byteLength * 2), m.set(t), m.set(e, t.byteLength), m;
+  }, l.fftMix = async function(h) {
+    const u = l.F.n8 * 3;
+    let c, o;
+    if (O == "G1")
+      c = "g1m_fftMix", o = "g1m_fftJoin";
+    else if (O == "G2")
+      c = "g2m_fftMix", o = "g2m_fftJoin";
+    else if (O == "Fr")
+      c = "frm_fftMix", o = "frm_fftJoin";
+    else
+      throw new Error("Invalid group");
+    const a = Math.floor(h.byteLength / u), w = U(a);
+    let s = 1 << U(k.concurrency);
+    a <= s * 2 && (s = 1);
+    const t = a / s, e = U(t), S = [];
+    for (let n = 0; n < s; n++) {
+      const p = [], v = h.slice(n * t * u, (n + 1) * t * u);
+      p.push({ cmd: "ALLOCSET", var: 0, buff: v });
+      for (let y = 1; y <= e; y++)
+        p.push({ cmd: "CALL", fnName: c, params: [
+          { var: 0 },
+          { val: t },
+          { val: y }
+        ] });
+      p.push({ cmd: "GET", out: 0, var: 0, len: t * u }), S.push(
+        k.queueAction(p)
+      );
+    }
+    const C = await Promise.all(S), A = [];
+    for (let n = 0; n < C.length; n++)
+      A[n] = C[n][0];
+    for (let n = e + 1; n <= w; n++) {
+      const p = 1 << w - n, v = s / p, y = [];
+      for (let E = 0; E < p; E++)
+        for (let r = 0; r < v / 2; r++) {
+          const G = b.exp(b.w[n], r * t), J = b.w[n], _ = E * v + r, f = E * v + r + v / 2, d = [];
+          d.push({ cmd: "ALLOCSET", var: 0, buff: A[_] }), d.push({ cmd: "ALLOCSET", var: 1, buff: A[f] }), d.push({ cmd: "ALLOCSET", var: 2, buff: G }), d.push({ cmd: "ALLOCSET", var: 3, buff: J }), d.push({ cmd: "CALL", fnName: o, params: [
+            { var: 0 },
+            { var: 1 },
+            { val: t },
+            { var: 2 },
+            { var: 3 }
+          ] }), d.push({ cmd: "GET", out: 0, var: 0, len: t * u }), d.push({ cmd: "GET", out: 1, var: 1, len: t * u }), y.push(k.queueAction(d));
+        }
+      const I = await Promise.all(y);
+      for (let E = 0; E < p; E++)
+        for (let r = 0; r < v / 2; r++) {
+          const G = E * v + r, J = E * v + r + v / 2, _ = I.shift();
+          A[G] = _[0], A[J] = _[1];
+        }
+    }
+    let m;
+    h instanceof P ? m = new P(a * u) : m = new Uint8Array(a * u);
+    let L = 0;
+    for (let n = 0; n < s; n++)
+      m.set(A[n], L), L += A[n].byteLength;
+    return m;
+  }, l.fftJoin = async function(h, u, c, o) {
+    const a = l.F.n8 * 3;
+    let w;
+    if (O == "G1")
+      w = "g1m_fftJoin";
+    else if (O == "G2")
+      w = "g2m_fftJoin";
+    else if (O == "Fr")
+      w = "frm_fftJoin";
+    else
+      throw new Error("Invalid group");
+    if (h.byteLength != u.byteLength)
+      throw new Error("Invalid buffer size");
+    const s = Math.floor(h.byteLength / a);
+    if (s != 1 << U(s))
+      throw new Error("Invalid number of points");
+    let t = 1 << U(k.concurrency);
+    s <= t * 2 && (t = 1);
+    const e = s / t, S = [];
+    for (let n = 0; n < t; n++) {
+      const p = [], v = b.mul(c, b.exp(o, n * e)), y = h.slice(n * e * a, (n + 1) * e * a), I = u.slice(n * e * a, (n + 1) * e * a);
+      p.push({ cmd: "ALLOCSET", var: 0, buff: y }), p.push({ cmd: "ALLOCSET", var: 1, buff: I }), p.push({ cmd: "ALLOCSET", var: 2, buff: v }), p.push({ cmd: "ALLOCSET", var: 3, buff: o }), p.push({ cmd: "CALL", fnName: w, params: [
+        { var: 0 },
+        { var: 1 },
+        { val: e },
+        { var: 2 },
+        { var: 3 }
+      ] }), p.push({ cmd: "GET", out: 0, var: 0, len: e * a }), p.push({ cmd: "GET", out: 1, var: 1, len: e * a }), S.push(
+        k.queueAction(p)
+      );
+    }
+    const C = await Promise.all(S);
+    let A, m;
+    h instanceof P ? (A = new P(s * a), m = new P(s * a)) : (A = new Uint8Array(s * a), m = new Uint8Array(s * a));
+    let L = 0;
+    for (let n = 0; n < C.length; n++)
+      A.set(C[n][0], L), m.set(C[n][1], L), L += C[n][0].byteLength;
+    return [A, m];
+  }, l.fftFinal = async function(h, u) {
+    const c = l.F.n8 * 3, o = l.F.n8 * 2;
+    let a, w;
+    if (O == "G1")
+      a = "g1m_fftFinal", w = "g1m_batchToAffine";
+    else if (O == "G2")
+      a = "g2m_fftFinal", w = "g2m_batchToAffine";
+    else
+      throw new Error("Invalid group");
+    const s = Math.floor(h.byteLength / c);
+    if (s != 1 << U(s))
+      throw new Error("Invalid number of points");
+    const t = Math.floor(s / k.concurrency), e = [];
+    for (let m = 0; m < k.concurrency; m++) {
+      let L;
+      if (m < k.concurrency - 1 ? L = t : L = s - m * t, L == 0)
+        continue;
+      const n = [], p = h.slice(m * t * c, (m * t + L) * c);
+      n.push({ cmd: "ALLOCSET", var: 0, buff: p }), n.push({ cmd: "ALLOCSET", var: 1, buff: u }), n.push({ cmd: "CALL", fnName: a, params: [
+        { var: 0 },
+        { val: L },
+        { var: 1 }
+      ] }), n.push({ cmd: "CALL", fnName: w, params: [
+        { var: 0 },
+        { val: L },
+        { var: 0 }
+      ] }), n.push({ cmd: "GET", out: 0, var: 0, len: L * o }), e.push(
+        k.queueAction(n)
+      );
+    }
+    const S = await Promise.all(e);
+    let C;
+    h instanceof P ? C = new P(s * o) : C = new Uint8Array(s * o);
+    let A = 0;
+    for (let m = S.length - 1; m >= 0; m--)
+      C.set(S[m][0], A), A += S[m][0].byteLength;
+    return C;
+  };
+}
+export {
+  nn as default
+};

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

@@ -0,0 +1,122 @@
+import { log2 as k } from "./utils.mjs";
+const w = [
+  1,
+  1,
+  1,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  13,
+  14,
+  15,
+  16,
+  16,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17,
+  17
+];
+function U(L, C) {
+  const n = L[C], S = n.tm;
+  async function b(h, o, s, t, f) {
+    if (!(h instanceof Uint8Array))
+      throw t && t.error(`${f} _multiExpChunk buffBases is not Uint8Array`), new Error(`${f} _multiExpChunk buffBases is not Uint8Array`);
+    if (!(o instanceof Uint8Array))
+      throw t && t.error(`${f} _multiExpChunk buffScalars is not Uint8Array`), new Error(`${f} _multiExpChunk buffScalars is not Uint8Array`);
+    s = s || "affine";
+    let _, E;
+    if (C == "G1")
+      s == "affine" ? (E = "g1m_multiexpAffine_chunk", _ = n.F.n8 * 2) : (E = "g1m_multiexp_chunk", _ = n.F.n8 * 3);
+    else if (C == "G2")
+      s == "affine" ? (E = "g2m_multiexpAffine_chunk", _ = n.F.n8 * 2) : (E = "g2m_multiexp_chunk", _ = n.F.n8 * 3);
+    else
+      throw new Error("Invalid group");
+    const i = Math.floor(h.byteLength / _);
+    if (i == 0)
+      return n.zero;
+    const e = Math.floor(o.byteLength / i);
+    if (e * i != o.byteLength)
+      throw new Error("Scalar size does not match");
+    const l = w[k(i)], A = Math.floor((e * 8 - 1) / l) + 1, d = [];
+    for (let a = 0; a < A; a++) {
+      const m = [
+        { cmd: "ALLOCSET", var: 0, buff: h },
+        { cmd: "ALLOCSET", var: 1, buff: o },
+        { cmd: "ALLOC", var: 2, len: n.F.n8 * 3 },
+        { cmd: "CALL", fnName: E, params: [
+          { var: 0 },
+          { var: 1 },
+          { val: e },
+          { val: i },
+          { val: a * l },
+          { val: Math.min(e * 8 - a * l, l) },
+          { var: 2 }
+        ] },
+        { cmd: "GET", out: 0, var: 2, len: n.F.n8 * 3 }
+      ];
+      d.push(
+        n.tm.queueAction(m)
+      );
+    }
+    const u = await Promise.all(d);
+    let c = n.zero;
+    for (let a = u.length - 1; a >= 0; a--) {
+      if (!n.isZero(c))
+        for (let m = 0; m < l; m++)
+          c = n.double(c);
+      c = n.add(c, u[a][0]);
+    }
+    return c;
+  }
+  async function p(h, o, s, t, f) {
+    let i;
+    if (C == "G1")
+      s == "affine" ? i = n.F.n8 * 2 : i = n.F.n8 * 3;
+    else if (C == "G2")
+      s == "affine" ? i = n.F.n8 * 2 : i = n.F.n8 * 3;
+    else
+      throw new Error("Invalid group");
+    const e = Math.floor(h.byteLength / i), l = Math.floor(o.byteLength / e);
+    if (l * e != o.byteLength)
+      throw new Error("Scalar size does not match");
+    const A = w[k(e)], d = Math.floor((l * 8 - 1) / A) + 1;
+    let u;
+    u = Math.floor(e / (S.concurrency / d)), u > 4194304 && (u = 4194304), u < 1024 && (u = 1024);
+    const c = [];
+    for (let r = 0; r < e; r += u) {
+      t && t.debug(`Multiexp start: ${f}: ${r}/${e}`);
+      const M = Math.min(e - r, u), v = h.slice(r * i, (r + M) * i), x = o.slice(r * l, (r + M) * l);
+      c.push(b(v, x, s, t, f).then((I) => (t && t.debug(`Multiexp end: ${f}: ${r}/${e}`), I)));
+    }
+    const a = await Promise.all(c);
+    let m = n.zero;
+    for (let r = a.length - 1; r >= 0; r--)
+      m = n.add(m, a[r]);
+    return m;
+  }
+  n.multiExp = async function(o, s, t, f) {
+    return await p(o, s, "jacobian", t, f);
+  }, n.multiExpAffine = async function(o, s, t, f) {
+    return await p(o, s, "affine", t, f);
+  };
+}
+export {
+  U as default
+};

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

@@ -0,0 +1,70 @@
+function u(t) {
+  const n = t.tm;
+  t.pairing = function(a, s) {
+    n.startSyncOp();
+    const e = n.allocBuff(t.G1.toJacobian(a)), m = n.allocBuff(t.G2.toJacobian(s)), o = n.alloc(t.Gt.n8);
+    n.instance.exports[t.name + "_pairing"](e, m, o);
+    const c = n.getBuff(o, t.Gt.n8);
+    return n.endSyncOp(), c;
+  }, t.pairingEq = async function() {
+    let a, s;
+    arguments.length % 2 == 1 ? (a = arguments[arguments.length - 1], s = (arguments.length - 1) / 2) : (a = t.Gt.one, s = arguments.length / 2);
+    const e = [];
+    for (let r = 0; r < s; r++) {
+      const i = [], f = t.G1.toJacobian(arguments[r * 2]);
+      i.push({ cmd: "ALLOCSET", var: 0, buff: f }), i.push({ cmd: "ALLOC", var: 1, len: t.prePSize });
+      const h = t.G2.toJacobian(arguments[r * 2 + 1]);
+      i.push({ cmd: "ALLOCSET", var: 2, buff: h }), i.push({ cmd: "ALLOC", var: 3, len: t.preQSize }), i.push({ cmd: "ALLOC", var: 4, len: t.Gt.n8 }), i.push({ cmd: "CALL", fnName: t.name + "_prepareG1", params: [
+        { var: 0 },
+        { var: 1 }
+      ] }), i.push({ cmd: "CALL", fnName: t.name + "_prepareG2", params: [
+        { var: 2 },
+        { var: 3 }
+      ] }), i.push({ cmd: "CALL", fnName: t.name + "_millerLoop", params: [
+        { var: 1 },
+        { var: 3 },
+        { var: 4 }
+      ] }), i.push({ cmd: "GET", out: 0, var: 4, len: t.Gt.n8 }), e.push(
+        n.queueAction(i)
+      );
+    }
+    const m = await Promise.all(e);
+    n.startSyncOp();
+    const o = n.alloc(t.Gt.n8);
+    n.instance.exports.ftm_one(o);
+    for (let r = 0; r < m.length; r++) {
+      const i = n.allocBuff(m[r][0]);
+      n.instance.exports.ftm_mul(o, i, o);
+    }
+    n.instance.exports[t.name + "_finalExponentiation"](o, o);
+    const c = n.allocBuff(a), l = !!n.instance.exports.ftm_eq(o, c);
+    return n.endSyncOp(), l;
+  }, t.prepareG1 = function(p) {
+    this.tm.startSyncOp();
+    const a = this.tm.allocBuff(p), s = this.tm.alloc(this.prePSize);
+    this.tm.instance.exports[this.name + "_prepareG1"](a, s);
+    const e = this.tm.getBuff(s, this.prePSize);
+    return this.tm.endSyncOp(), e;
+  }, t.prepareG2 = function(p) {
+    this.tm.startSyncOp();
+    const a = this.tm.allocBuff(p), s = this.tm.alloc(this.preQSize);
+    this.tm.instance.exports[this.name + "_prepareG2"](a, s);
+    const e = this.tm.getBuff(s, this.preQSize);
+    return this.tm.endSyncOp(), e;
+  }, t.millerLoop = function(p, a) {
+    this.tm.startSyncOp();
+    const s = this.tm.allocBuff(p), e = this.tm.allocBuff(a), m = this.tm.alloc(this.Gt.n8);
+    this.tm.instance.exports[this.name + "_millerLoop"](s, e, m);
+    const o = this.tm.getBuff(m, this.Gt.n8);
+    return this.tm.endSyncOp(), o;
+  }, t.finalExponentiation = function(p) {
+    this.tm.startSyncOp();
+    const a = this.tm.allocBuff(p), s = this.tm.alloc(this.Gt.n8);
+    this.tm.instance.exports[this.name + "_finalExponentiation"](a, s);
+    const e = this.tm.getBuff(s, this.Gt.n8);
+    return this.tm.endSyncOp(), e;
+  };
+}
+export {
+  u as default
+};