@nihilium/client-sdk 0.1.1 → 0.2.0

package/dist/index-DFD-0QrS-CQSN52v_.js

@@ -0,0 +1,1552 @@
+import { B as St } from "./types-C-XvYweP.js";
+import { C as tt, I as O, L as R, a as et, P as I, S as Ut, d as P, h as z, $ as nt, G as vt } from "./index-3PKMWW6b.js";
+/**
+ * @module @zk-kit/utils
+ * @version 1.2.1
+ * @file Essential zero-knowledge utility library for JavaScript developers.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
+*/
+function Et(t) {
+  return I.Buffer.isBuffer(t);
+}
+function Pt(t, e) {
+  if (!Et(t))
+    throw new TypeError(`Parameter '${e}' is not a Buffer instance`);
+}
+function Kt(t) {
+  if (t <= 0)
+    throw Error(`size ${t} is too small, need at least 1`);
+  return crypto.getRandomValues(new Uint8Array(t));
+}
+var $t = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  getRandomValues: Kt
+});
+/**
+ * @module @zk-kit/utils
+ * @version 1.2.1
+ * @file Essential zero-knowledge utility library for JavaScript developers.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
+*/
+const Ot = [
+  "number",
+  "string",
+  "function",
+  "Array",
+  "Uint8Array",
+  "Buffer",
+  "object",
+  "bigint",
+  "stringified-bigint",
+  "hexadecimal",
+  "bignumber",
+  "bignumberish"
+];
+function bt(t) {
+  return typeof t == "number";
+}
+function N(t) {
+  return typeof t == "string";
+}
+function Rt(t) {
+  return typeof t == "function";
+}
+function X(t) {
+  return typeof t == "object";
+}
+function pt(t) {
+  return X(t) && Array.isArray(t);
+}
+function J(t) {
+  return t instanceof Uint8Array;
+}
+function W(t) {
+  return I.Buffer.isBuffer(t);
+}
+function F(t) {
+  return typeof t == "bigint";
+}
+function Y(t) {
+  if (!N(t))
+    return !1;
+  try {
+    return BigInt(t), !0;
+  } catch {
+    return !1;
+  }
+}
+function yt(t, e = !0) {
+  return N(t) ? e ? /^(0x|0X)[0-9a-fA-F]+$/.test(t) : /^[0-9a-fA-F]+$/.test(t) : !1;
+}
+function j(t) {
+  return F(t) || Y(t);
+}
+function Q(t) {
+  return bt(t) || F(t) || Y(t) || yt(t) || W(t) || J(t);
+}
+function zt(t, e) {
+  switch (e) {
+    case "number":
+      return bt(t);
+    case "string":
+      return N(t);
+    case "function":
+      return Rt(t);
+    case "Array":
+      return pt(t);
+    case "Uint8Array":
+      return J(t);
+    case "Buffer":
+      return W(t);
+    case "object":
+      return X(t);
+    case "bigint":
+      return F(t);
+    case "stringified-bigint":
+      return Y(t);
+    case "hexadecimal":
+      return yt(t);
+    case "bignumber":
+      return j(t);
+    case "bignumberish":
+      return Q(t);
+    default:
+      return !1;
+  }
+}
+function xt(t) {
+  return Ot.includes(t);
+}
+/**
+ * @module @zk-kit/utils
+ * @version 1.2.1
+ * @file Essential zero-knowledge utility library for JavaScript developers.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
+*/
+function jt(t, e) {
+  if (!F(t))
+    throw new TypeError(`Parameter '${e}' is not a bigint, received type: ${typeof t}`);
+}
+function _t(t, e) {
+  if (!Q(t))
+    throw new TypeError(`Parameter '${e}' is not a bignumber-ish`);
+}
+function H(t, e, r) {
+  for (const n of r)
+    if (!xt(n))
+      throw new Error(`Type '${n}' is not supported`);
+  for (const n of r)
+    if (zt(t, n))
+      return;
+  throw new TypeError(`Parameter '${e}' is none of the following types: ${r.join(", ")}`);
+}
+/**
+ * @module @zk-kit/utils
+ * @version 1.2.1
+ * @file Essential zero-knowledge utility library for JavaScript developers.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
+*/
+function Ft(t) {
+  jt(t, "value");
+  let e = t.toString(16);
+  return e.length % 2 !== 0 && (e = `0${e}`), e;
+}
+function Ht(t) {
+  return H(t, "value", ["Buffer", "Uint8Array"]), BigInt(`0x${I.Buffer.from(t).toString("hex")}`);
+}
+function K(t) {
+  return H(t, "value", ["Buffer", "Uint8Array"]), BigInt(`0x${I.Buffer.from(t).reverse().toString("hex")}`);
+}
+function wt(t) {
+  return Ht(t);
+}
+function T(t, e) {
+  const r = Ft(t), n = Math.ceil(r.length / 2);
+  if (e < n)
+    throw Error(`Size ${e} is too small, need at least ${n} bytes`);
+  const b = I.Buffer.alloc(e, 0);
+  return I.Buffer.from(r, "hex").reverse().copy(b, 0), b;
+}
+function dt(t) {
+  return _t(t, "value"), W(t) || J(t) ? wt(t) : BigInt(t);
+}
+/**
+ * @module @zk-kit/utils
+ * @version 1.2.1
+ * @file Essential zero-knowledge utility library for JavaScript developers.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
+*/
+function Tt(t) {
+  return !t;
+}
+function rt(t, e) {
+  return t >> e;
+}
+function Ct(t, e) {
+  return t * e;
+}
+function Dt(t) {
+  const e = [];
+  let r = t;
+  for (; r; )
+    r & BigInt(1) ? e.push(1) : e.push(0), r >>= BigInt(1);
+  return e;
+}
+/**
+ * @module @zk-kit/utils
+ * @version 1.2.1
+ * @file Essential zero-knowledge utility library for JavaScript developers.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
+*/
+class Lt {
+  constructor(e) {
+    this.one = 1n, this.zero = 0n, this._order = e, this._half = e >> this.one, this._negone = this._order - this.one;
+  }
+  /**
+   * Ensures a given result falls within the field by applying modular reduction.
+   * This method also handles negative inputs, correctly mapping them into the field.
+   * @param res The result to be normalized to the field.
+   * @returns The equivalent value within the field.
+   */
+  e(e) {
+    return e %= this._order, e < 0 ? e + this._order : e;
+  }
+  /**
+   * Performs modular multiplication of two bigint values within the field.
+   * @param a The first value.
+   * @param b The second value.
+   * @returns The product of 'a' and 'b' modulo the field's order.
+   */
+  mul(e, r) {
+    return e * r % this._order;
+  }
+  /**
+   * Subtracts one bigint from another under modulus.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The value from which to subtract.
+   * @param b The value to be subtracted.
+   * @returns The difference of 'a' and 'b' modulo the field's order.
+   */
+  sub(e, r) {
+    return e >= r ? e - r : this._order - r + e;
+  }
+  /**
+   * Adds two bigint values together under modulus.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The first value.
+   * @param b The second value.
+   * @returns The sum of 'a' and 'b' modulo the field's order.
+   */
+  add(e, r) {
+    const n = e + r;
+    return n >= this._order ? n - this._order : n;
+  }
+  /**
+   * Computes the multiplicative inverse of a given value within the field.
+   * This method uses the Extended Euclidean Algorithm to find the inverse,
+   * ensuring the result is always a positive value less than the field's order.
+   * If the input value is zero, which has no inverse, an error is thrown.
+   * @param a The value for which to compute the inverse.
+   * @returns The multiplicative inverse of 'a' modulo the field's order.
+   * @throws if 'a' is zero.
+   */
+  inv(e) {
+    if (e === this.zero)
+      throw new Error("Zero has no inverse");
+    let r = this.zero, n = this._order, b = this.one, h = e % this._order;
+    for (; h; ) {
+      const f = n / h;
+      [r, b] = [b, r - f * b], [n, h] = [h, n - f * h];
+    }
+    return r < this.zero && (r += this._order), r;
+  }
+  /**
+   * Divides one bigint by another within the field by multiplying the first value
+   * by the multiplicative inverse of the second.
+   * @param a The dividend.
+   * @param b The divisor.
+   * @returns The result of the division of 'a' by 'b' modulo the field's order.
+   */
+  div(e, r) {
+    return this.mul(e, this.inv(r));
+  }
+  /**
+   * Checks if two bigint values are equal within the context of the field.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The first value to compare.
+   * @param b The second value to compare.
+   * @returns True if 'a' equals 'b', false otherwise.
+   */
+  eq(e, r) {
+    return e === r;
+  }
+  /**
+   * Squares a bigint value within the field.
+   * This is a specific case of multiplication where the value is multiplied by itself,
+   * optimized for performance where applicable.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The value to square.
+   * @returns The square of 'a' modulo the field's order.
+   */
+  square(e) {
+    return e * e % this._order;
+  }
+  /**
+   * Compares two bigint values to determine if the first is less than the second,
+   * taking into account the field's order for modular comparison.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The first value to compare.
+   * @param b The second value to compare.
+   * @returns True if 'a' is less than 'b', false otherwise.
+   */
+  lt(e, r) {
+    const n = e > this._half ? e - this._order : e, b = r > this._half ? r - this._order : r;
+    return n < b;
+  }
+  /**
+   * Compares two bigint values to determine if the first is greater than or equal to the second,
+   * considering the field's modular context.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The first value to compare.
+   * @param b The second value to compare.
+   * @returns True if 'a' is greater than or equal to 'b', false otherwise.
+   */
+  geq(e, r) {
+    const n = e > this._half ? e - this._order : e, b = r > this._half ? r - this._order : r;
+    return n >= b;
+  }
+  /**
+   * Computes the negation of a bigint value within the field.
+   * The result is the modular additive inverse that, when added to the original value,
+   * yields zero in the field's modulus.
+   * It ensures the result is within the field if and only if the input values are within the field.
+   * @param a The value to negate.
+   * @returns The negation of 'a' modulo the field's order.
+   */
+  neg(e) {
+    return e && this._order - e;
+  }
+  /**
+   * Checks if a bigint value is zero within the context of the field.
+   * @param a The value to check.
+   * @returns True if 'a' is zero, false otherwise.
+   */
+  isZero(e) {
+    return e === this.zero;
+  }
+  /**
+   * Raises a base to an exponent within the field, efficiently computing
+   * scalar exponentiation using the square-and-multiply algorithm.
+   * Supports both positive and negative exponents through the use of the `inv` method for negatives.
+   * @param base The base to be exponentiated.
+   * @param e The exponent.
+   * @returns The result of raising 'base' to the power 'e' modulo the field's order.
+   */
+  pow(e, r) {
+    if (Tt(r))
+      return this.one;
+    r < 0n && (e = this.inv(e), r = -r);
+    const n = Dt(r);
+    if (n.length === 0)
+      return this.one;
+    let b = e;
+    for (let h = n.length - 2; h >= 0; h -= 1)
+      b = this.square(b), n[h] && (b = this.mul(b, e));
+    return b;
+  }
+}
+var it = Ut(), C, ot;
+function kt() {
+  if (ot) return C;
+  ot = 1;
+  const t = "Input must be an string, Buffer or Uint8Array";
+  function e(f) {
+    let a;
+    if (f instanceof Uint8Array)
+      a = f;
+    else if (typeof f == "string")
+      a = new TextEncoder().encode(f);
+    else
+      throw new Error(t);
+    return a;
+  }
+  function r(f) {
+    return Array.prototype.map.call(f, function(a) {
+      return (a < 16 ? "0" : "") + a.toString(16);
+    }).join("");
+  }
+  function n(f) {
+    return (4294967296 + f).toString(16).substring(1);
+  }
+  function b(f, a, u) {
+    let d = `
+` + f + " = ";
+    for (let g = 0; g < a.length; g += 2) {
+      if (u === 32)
+        d += n(a[g]).toUpperCase(), d += " ", d += n(a[g + 1]).toUpperCase();
+      else if (u === 64)
+        d += n(a[g + 1]).toUpperCase(), d += n(a[g]).toUpperCase();
+      else throw new Error("Invalid size " + u);
+      g % 6 === 4 ? d += `
+` + new Array(f.length + 4).join(" ") : g < a.length - 2 && (d += " ");
+    }
+    console.log(d);
+  }
+  function h(f, a, u) {
+    let d = (/* @__PURE__ */ new Date()).getTime();
+    const g = new Uint8Array(a);
+    for (let w = 0; w < a; w++)
+      g[w] = w % 256;
+    const c = (/* @__PURE__ */ new Date()).getTime();
+    console.log("Generated random input in " + (c - d) + "ms"), d = c;
+    for (let w = 0; w < u; w++) {
+      const B = f(g), l = (/* @__PURE__ */ new Date()).getTime(), y = l - d;
+      d = l, console.log("Hashed in " + y + "ms: " + B.substring(0, 20) + "..."), console.log(
+        Math.round(a / (1 << 20) / (y / 1e3) * 100) / 100 + " MB PER SECOND"
+      );
+    }
+  }
+  return C = {
+    normalizeInput: e,
+    toHex: r,
+    debugPrint: b,
+    testSpeed: h
+  }, C;
+}
+var D, st;
+function Mt() {
+  if (st) return D;
+  st = 1;
+  const t = kt();
+  function e(i, p, o) {
+    const _ = i[p] + i[o];
+    let k = i[p + 1] + i[o + 1];
+    _ >= 4294967296 && k++, i[p] = _, i[p + 1] = k;
+  }
+  function r(i, p, o, _) {
+    let k = i[p] + o;
+    o < 0 && (k += 4294967296);
+    let m = i[p + 1] + _;
+    k >= 4294967296 && m++, i[p] = k, i[p + 1] = m;
+  }
+  function n(i, p) {
+    return i[p] ^ i[p + 1] << 8 ^ i[p + 2] << 16 ^ i[p + 3] << 24;
+  }
+  function b(i, p, o, _, k, m) {
+    const Bt = d[k], mt = d[k + 1], It = d[m], At = d[m + 1];
+    e(u, i, p), r(u, i, Bt, mt);
+    let A = u[_] ^ u[i], S = u[_ + 1] ^ u[i + 1];
+    u[_] = S, u[_ + 1] = A, e(u, o, _), A = u[p] ^ u[o], S = u[p + 1] ^ u[o + 1], u[p] = A >>> 24 ^ S << 8, u[p + 1] = S >>> 24 ^ A << 8, e(u, i, p), r(u, i, It, At), A = u[_] ^ u[i], S = u[_ + 1] ^ u[i + 1], u[_] = A >>> 16 ^ S << 16, u[_ + 1] = S >>> 16 ^ A << 16, e(u, o, _), A = u[p] ^ u[o], S = u[p + 1] ^ u[o + 1], u[p] = S >>> 31 ^ A << 1, u[p + 1] = A >>> 31 ^ S << 1;
+  }
+  const h = new Uint32Array([
+    4089235720,
+    1779033703,
+    2227873595,
+    3144134277,
+    4271175723,
+    1013904242,
+    1595750129,
+    2773480762,
+    2917565137,
+    1359893119,
+    725511199,
+    2600822924,
+    4215389547,
+    528734635,
+    327033209,
+    1541459225
+  ]), f = [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    14,
+    10,
+    4,
+    8,
+    9,
+    15,
+    13,
+    6,
+    1,
+    12,
+    0,
+    2,
+    11,
+    7,
+    5,
+    3,
+    11,
+    8,
+    12,
+    0,
+    5,
+    2,
+    15,
+    13,
+    10,
+    14,
+    3,
+    6,
+    7,
+    1,
+    9,
+    4,
+    7,
+    9,
+    3,
+    1,
+    13,
+    12,
+    11,
+    14,
+    2,
+    6,
+    5,
+    10,
+    4,
+    0,
+    15,
+    8,
+    9,
+    0,
+    5,
+    7,
+    2,
+    4,
+    10,
+    15,
+    14,
+    1,
+    11,
+    12,
+    6,
+    8,
+    3,
+    13,
+    2,
+    12,
+    6,
+    10,
+    0,
+    11,
+    8,
+    3,
+    4,
+    13,
+    7,
+    5,
+    15,
+    14,
+    1,
+    9,
+    12,
+    5,
+    1,
+    15,
+    14,
+    13,
+    4,
+    10,
+    0,
+    7,
+    6,
+    3,
+    9,
+    2,
+    8,
+    11,
+    13,
+    11,
+    7,
+    14,
+    12,
+    1,
+    3,
+    9,
+    5,
+    0,
+    15,
+    4,
+    8,
+    6,
+    2,
+    10,
+    6,
+    15,
+    14,
+    9,
+    11,
+    3,
+    0,
+    8,
+    12,
+    2,
+    13,
+    7,
+    1,
+    4,
+    10,
+    5,
+    10,
+    2,
+    8,
+    4,
+    7,
+    6,
+    1,
+    5,
+    15,
+    11,
+    9,
+    14,
+    3,
+    12,
+    13,
+    0,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    14,
+    10,
+    4,
+    8,
+    9,
+    15,
+    13,
+    6,
+    1,
+    12,
+    0,
+    2,
+    11,
+    7,
+    5,
+    3
+  ], a = new Uint8Array(
+    f.map(function(i) {
+      return i * 2;
+    })
+  ), u = new Uint32Array(32), d = new Uint32Array(32);
+  function g(i, p) {
+    let o = 0;
+    for (o = 0; o < 16; o++)
+      u[o] = i.h[o], u[o + 16] = h[o];
+    for (u[24] = u[24] ^ i.t, u[25] = u[25] ^ i.t / 4294967296, p && (u[28] = ~u[28], u[29] = ~u[29]), o = 0; o < 32; o++)
+      d[o] = n(i.b, 4 * o);
+    for (o = 0; o < 12; o++)
+      b(0, 8, 16, 24, a[o * 16 + 0], a[o * 16 + 1]), b(2, 10, 18, 26, a[o * 16 + 2], a[o * 16 + 3]), b(4, 12, 20, 28, a[o * 16 + 4], a[o * 16 + 5]), b(6, 14, 22, 30, a[o * 16 + 6], a[o * 16 + 7]), b(0, 10, 20, 30, a[o * 16 + 8], a[o * 16 + 9]), b(2, 12, 22, 24, a[o * 16 + 10], a[o * 16 + 11]), b(4, 14, 16, 26, a[o * 16 + 12], a[o * 16 + 13]), b(6, 8, 18, 28, a[o * 16 + 14], a[o * 16 + 15]);
+    for (o = 0; o < 16; o++)
+      i.h[o] = i.h[o] ^ u[o] ^ u[o + 16];
+  }
+  const c = new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    //  0: outlen, keylen, fanout, depth
+    0,
+    0,
+    0,
+    0,
+    //  4: leaf length, sequential mode
+    0,
+    0,
+    0,
+    0,
+    //  8: node offset
+    0,
+    0,
+    0,
+    0,
+    // 12: node offset
+    0,
+    0,
+    0,
+    0,
+    // 16: node depth, inner length, rfu
+    0,
+    0,
+    0,
+    0,
+    // 20: rfu
+    0,
+    0,
+    0,
+    0,
+    // 24: rfu
+    0,
+    0,
+    0,
+    0,
+    // 28: rfu
+    0,
+    0,
+    0,
+    0,
+    // 32: salt
+    0,
+    0,
+    0,
+    0,
+    // 36: salt
+    0,
+    0,
+    0,
+    0,
+    // 40: salt
+    0,
+    0,
+    0,
+    0,
+    // 44: salt
+    0,
+    0,
+    0,
+    0,
+    // 48: personal
+    0,
+    0,
+    0,
+    0,
+    // 52: personal
+    0,
+    0,
+    0,
+    0,
+    // 56: personal
+    0,
+    0,
+    0,
+    0
+    // 60: personal
+  ]);
+  function w(i, p, o, _) {
+    if (i === 0 || i > 64)
+      throw new Error("Illegal output length, expected 0 < length <= 64");
+    if (p && p.length > 64)
+      throw new Error("Illegal key, expected Uint8Array with 0 < length <= 64");
+    if (o && o.length !== 16)
+      throw new Error("Illegal salt, expected Uint8Array with length is 16");
+    if (_ && _.length !== 16)
+      throw new Error("Illegal personal, expected Uint8Array with length is 16");
+    const k = {
+      b: new Uint8Array(128),
+      h: new Uint32Array(16),
+      t: 0,
+      // input count
+      c: 0,
+      // pointer within buffer
+      outlen: i
+      // output length in bytes
+    };
+    c.fill(0), c[0] = i, p && (c[1] = p.length), c[2] = 1, c[3] = 1, o && c.set(o, 32), _ && c.set(_, 48);
+    for (let m = 0; m < 16; m++)
+      k.h[m] = h[m] ^ n(c, m * 4);
+    return p && (B(k, p), k.c = 128), k;
+  }
+  function B(i, p) {
+    for (let o = 0; o < p.length; o++)
+      i.c === 128 && (i.t += i.c, g(i, !1), i.c = 0), i.b[i.c++] = p[o];
+  }
+  function l(i) {
+    for (i.t += i.c; i.c < 128; )
+      i.b[i.c++] = 0;
+    g(i, !0);
+    const p = new Uint8Array(i.outlen);
+    for (let o = 0; o < i.outlen; o++)
+      p[o] = i.h[o >> 2] >> 8 * (o & 3);
+    return p;
+  }
+  function y(i, p, o, _, k) {
+    o = o || 64, i = t.normalizeInput(i), _ && (_ = t.normalizeInput(_)), k && (k = t.normalizeInput(k));
+    const m = w(o, p, _, k);
+    return B(m, i), l(m);
+  }
+  function s(i, p, o, _, k) {
+    const m = y(i, p, o, _, k);
+    return t.toHex(m);
+  }
+  return D = {
+    blake2b: y,
+    blake2bHex: s,
+    blake2bInit: w,
+    blake2bUpdate: B,
+    blake2bFinal: l
+  }, D;
+}
+var L, ut;
+function qt() {
+  if (ut) return L;
+  ut = 1;
+  const t = kt();
+  function e(l, y) {
+    return l[y] ^ l[y + 1] << 8 ^ l[y + 2] << 16 ^ l[y + 3] << 24;
+  }
+  function r(l, y, s, i, p, o) {
+    f[l] = f[l] + f[y] + p, f[i] = n(f[i] ^ f[l], 16), f[s] = f[s] + f[i], f[y] = n(f[y] ^ f[s], 12), f[l] = f[l] + f[y] + o, f[i] = n(f[i] ^ f[l], 8), f[s] = f[s] + f[i], f[y] = n(f[y] ^ f[s], 7);
+  }
+  function n(l, y) {
+    return l >>> y ^ l << 32 - y;
+  }
+  const b = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]), h = new Uint8Array([
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    14,
+    10,
+    4,
+    8,
+    9,
+    15,
+    13,
+    6,
+    1,
+    12,
+    0,
+    2,
+    11,
+    7,
+    5,
+    3,
+    11,
+    8,
+    12,
+    0,
+    5,
+    2,
+    15,
+    13,
+    10,
+    14,
+    3,
+    6,
+    7,
+    1,
+    9,
+    4,
+    7,
+    9,
+    3,
+    1,
+    13,
+    12,
+    11,
+    14,
+    2,
+    6,
+    5,
+    10,
+    4,
+    0,
+    15,
+    8,
+    9,
+    0,
+    5,
+    7,
+    2,
+    4,
+    10,
+    15,
+    14,
+    1,
+    11,
+    12,
+    6,
+    8,
+    3,
+    13,
+    2,
+    12,
+    6,
+    10,
+    0,
+    11,
+    8,
+    3,
+    4,
+    13,
+    7,
+    5,
+    15,
+    14,
+    1,
+    9,
+    12,
+    5,
+    1,
+    15,
+    14,
+    13,
+    4,
+    10,
+    0,
+    7,
+    6,
+    3,
+    9,
+    2,
+    8,
+    11,
+    13,
+    11,
+    7,
+    14,
+    12,
+    1,
+    3,
+    9,
+    5,
+    0,
+    15,
+    4,
+    8,
+    6,
+    2,
+    10,
+    6,
+    15,
+    14,
+    9,
+    11,
+    3,
+    0,
+    8,
+    12,
+    2,
+    13,
+    7,
+    1,
+    4,
+    10,
+    5,
+    10,
+    2,
+    8,
+    4,
+    7,
+    6,
+    1,
+    5,
+    15,
+    11,
+    9,
+    14,
+    3,
+    12,
+    13,
+    0
+  ]), f = new Uint32Array(16), a = new Uint32Array(16);
+  function u(l, y) {
+    let s = 0;
+    for (s = 0; s < 8; s++)
+      f[s] = l.h[s], f[s + 8] = b[s];
+    for (f[12] ^= l.t, f[13] ^= l.t / 4294967296, y && (f[14] = ~f[14]), s = 0; s < 16; s++)
+      a[s] = e(l.b, 4 * s);
+    for (s = 0; s < 10; s++)
+      r(0, 4, 8, 12, a[h[s * 16 + 0]], a[h[s * 16 + 1]]), r(1, 5, 9, 13, a[h[s * 16 + 2]], a[h[s * 16 + 3]]), r(2, 6, 10, 14, a[h[s * 16 + 4]], a[h[s * 16 + 5]]), r(3, 7, 11, 15, a[h[s * 16 + 6]], a[h[s * 16 + 7]]), r(0, 5, 10, 15, a[h[s * 16 + 8]], a[h[s * 16 + 9]]), r(1, 6, 11, 12, a[h[s * 16 + 10]], a[h[s * 16 + 11]]), r(2, 7, 8, 13, a[h[s * 16 + 12]], a[h[s * 16 + 13]]), r(3, 4, 9, 14, a[h[s * 16 + 14]], a[h[s * 16 + 15]]);
+    for (s = 0; s < 8; s++)
+      l.h[s] ^= f[s] ^ f[s + 8];
+  }
+  function d(l, y) {
+    if (!(l > 0 && l <= 32))
+      throw new Error("Incorrect output length, should be in [1, 32]");
+    const s = y ? y.length : 0;
+    if (y && !(s > 0 && s <= 32))
+      throw new Error("Incorrect key length, should be in [1, 32]");
+    const i = {
+      h: new Uint32Array(b),
+      // hash state
+      b: new Uint8Array(64),
+      // input block
+      c: 0,
+      // pointer within block
+      t: 0,
+      // input count
+      outlen: l
+      // output length in bytes
+    };
+    return i.h[0] ^= 16842752 ^ s << 8 ^ l, s > 0 && (g(i, y), i.c = 64), i;
+  }
+  function g(l, y) {
+    for (let s = 0; s < y.length; s++)
+      l.c === 64 && (l.t += l.c, u(l, !1), l.c = 0), l.b[l.c++] = y[s];
+  }
+  function c(l) {
+    for (l.t += l.c; l.c < 64; )
+      l.b[l.c++] = 0;
+    u(l, !0);
+    const y = new Uint8Array(l.outlen);
+    for (let s = 0; s < l.outlen; s++)
+      y[s] = l.h[s >> 2] >> 8 * (s & 3) & 255;
+    return y;
+  }
+  function w(l, y, s) {
+    s = s || 32, l = t.normalizeInput(l);
+    const i = d(s, y);
+    return g(i, l), c(i);
+  }
+  function B(l, y, s) {
+    const i = w(l, y, s);
+    return t.toHex(i);
+  }
+  return L = {
+    blake2s: w,
+    blake2sHex: B,
+    blake2sInit: d,
+    blake2sUpdate: g,
+    blake2sFinal: c
+  }, L;
+}
+var M, at;
+function Gt() {
+  if (at) return M;
+  at = 1;
+  const t = Mt(), e = qt();
+  return M = {
+    blake2b: t.blake2b,
+    blake2bHex: t.blake2bHex,
+    blake2bInit: t.blake2bInit,
+    blake2bUpdate: t.blake2bUpdate,
+    blake2bFinal: t.blake2bFinal,
+    blake2s: e.blake2s,
+    blake2sHex: e.blake2sHex,
+    blake2sInit: e.blake2sInit,
+    blake2sUpdate: e.blake2sUpdate,
+    blake2sFinal: e.blake2sFinal
+  }, M;
+}
+var q = Gt();
+/**
+ * @module @zk-kit/eddsa-poseidon
+ * @version 1.1.0
+ * @file A JavaScript EdDSA library for secure signing and verification using Poseidon the Baby Jubjub elliptic curve.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/eddsa-poseidon}
+*/
+const Vt = I.Buffer.from([1]), Zt = I.Buffer.from([129]), U = [
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+  [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+  [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
+  [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
+  [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
+  [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9],
+  [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11],
+  [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10],
+  [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5],
+  [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0],
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+  [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+  [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
+  [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
+  [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
+  [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9]
+], E = [
+  608135816,
+  2242054355,
+  320440878,
+  57701188,
+  2752067618,
+  698298832,
+  137296536,
+  3964562569,
+  1160258022,
+  953160567,
+  3193202383,
+  887688300,
+  3232508343,
+  3380367581,
+  1065670069,
+  3041331479,
+  2450970073,
+  2306472731,
+  3509652390,
+  2564797868,
+  805139163,
+  3491422135,
+  3101798381,
+  1780907670,
+  3128725573,
+  4046225305,
+  614570311,
+  3012652279,
+  134345442,
+  2240740374,
+  1667834072,
+  1901547113
+], G = I.Buffer.from([
+  128,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0
+]);
+function x(t, e, r, n) {
+  let b = t[e * 2] ^ t[r * 2], h = t[e * 2 + 1] ^ t[r * 2 + 1];
+  n >= 32 && (h ^= b, b ^= h, h ^= b, n -= 32), n === 0 ? (t[e * 2] = b >>> 0, t[e * 2 + 1] = h >>> 0) : (t[e * 2] = (b >>> n | h << 32 - n) >>> 0, t[e * 2 + 1] = (h >>> n | b << 32 - n) >>> 0);
+}
+function v(t, e, r, n, b, h, f, a) {
+  let u;
+  u = t[n * 2 + 1] + ((e[U[r][a] * 2 + 1] ^ E[U[r][a + 1] * 2 + 1]) >>> 0) + t[b * 2 + 1], t[n * 2] = t[n * 2] + ((e[U[r][a] * 2] ^ E[U[r][a + 1] * 2]) >>> 0) + t[b * 2] + ~~(u / 4294967296) >>> 0, t[n * 2 + 1] = u >>> 0, x(t, f, n, 32), u = t[h * 2 + 1] + t[f * 2 + 1], t[h * 2] = t[h * 2] + t[f * 2] + ~~(u / 4294967296) >>> 0, t[h * 2 + 1] = u >>> 0, x(t, b, h, 25), u = t[n * 2 + 1] + ((e[U[r][a + 1] * 2 + 1] ^ E[U[r][a] * 2 + 1]) >>> 0) + t[b * 2 + 1], t[n * 2] = t[n * 2] + ((e[U[r][a + 1] * 2] ^ E[U[r][a] * 2]) >>> 0) + t[b * 2] + ~~(u / 4294967296) >>> 0, t[n * 2 + 1] = u >>> 0, x(t, f, n, 16), u = t[h * 2 + 1] + t[f * 2 + 1], t[h * 2] = t[h * 2] + t[f * 2] + ~~(u / 4294967296) >>> 0, t[h * 2 + 1] = u >>> 0, x(t, b, h, 11);
+}
+function lt(t) {
+  for (let e = 0; e < t.length && !(t[e] < 4294967296); e += 1)
+    t[e] -= 4294967296, t[e + 1] += 1;
+}
+class Nt {
+  /**
+   * Initializes a new Blake-512 hash instance with the default parameters.
+   */
+  constructor() {
+    this._h = [
+      1779033703,
+      4089235720,
+      3144134277,
+      2227873595,
+      1013904242,
+      4271175723,
+      2773480762,
+      1595750129,
+      1359893119,
+      2917565137,
+      2600822924,
+      725511199,
+      528734635,
+      4215389547,
+      1541459225,
+      327033209
+    ], this._s = [0, 0, 0, 0, 0, 0, 0, 0], this._block = I.Buffer.alloc(128), this._blockOffset = 0, this._length = [0, 0, 0, 0], this._nullt = !1, this._zo = Vt, this._oo = Zt;
+  }
+  /**
+   * The core compression function for Blake-512. It transforms the internal
+   * state based on the input block and the current hash parameters.
+   */
+  _compress() {
+    const e = new Array(32), r = new Array(32);
+    let n;
+    for (n = 0; n < 32; n += 1)
+      r[n] = this._block.readUInt32BE(n * 4);
+    for (n = 0; n < 16; n += 1)
+      e[n] = this._h[n] >>> 0;
+    for (n = 16; n < 24; n += 1)
+      e[n] = (this._s[n - 16] ^ E[n - 16]) >>> 0;
+    for (n = 24; n < 32; n += 1)
+      e[n] = E[n - 16];
+    for (this._nullt || (e[24] = (e[24] ^ this._length[1]) >>> 0, e[25] = (e[25] ^ this._length[0]) >>> 0, e[26] = (e[26] ^ this._length[1]) >>> 0, e[27] = (e[27] ^ this._length[0]) >>> 0, e[28] = (e[28] ^ this._length[3]) >>> 0, e[29] = (e[29] ^ this._length[2]) >>> 0, e[30] = (e[30] ^ this._length[3]) >>> 0, e[31] = (e[31] ^ this._length[2]) >>> 0), n = 0; n < 16; n += 1)
+      v(e, r, n, 0, 4, 8, 12, 0), v(e, r, n, 1, 5, 9, 13, 2), v(e, r, n, 2, 6, 10, 14, 4), v(e, r, n, 3, 7, 11, 15, 6), v(e, r, n, 0, 5, 10, 15, 8), v(e, r, n, 1, 6, 11, 12, 10), v(e, r, n, 2, 7, 8, 13, 12), v(e, r, n, 3, 4, 9, 14, 14);
+    for (n = 0; n < 16; n += 1)
+      this._h[n % 8 * 2] = (this._h[n % 8 * 2] ^ e[n * 2]) >>> 0, this._h[n % 8 * 2 + 1] = (this._h[n % 8 * 2 + 1] ^ e[n * 2 + 1]) >>> 0;
+    for (n = 0; n < 8; n += 1)
+      this._h[n * 2] = (this._h[n * 2] ^ this._s[n % 4 * 2]) >>> 0, this._h[n * 2 + 1] = (this._h[n * 2 + 1] ^ this._s[n % 4 * 2 + 1]) >>> 0;
+  }
+  /**
+   * Adds padding to the message as per the Blake-512 specification, ensuring
+   * the message length is a multiple of the block size.
+   */
+  _padding() {
+    const e = this._length.slice();
+    e[0] += this._blockOffset * 8, lt(e);
+    const r = I.Buffer.alloc(16);
+    for (let n = 0; n < 4; n += 1)
+      r.writeUInt32BE(e[3 - n], n * 4);
+    this._blockOffset === 111 ? (this._length[0] -= 8, this.update(this._oo)) : (this._blockOffset < 111 ? (this._blockOffset === 0 && (this._nullt = !0), this._length[0] -= (111 - this._blockOffset) * 8, this.update(G.subarray(0, 111 - this._blockOffset))) : (this._length[0] -= (128 - this._blockOffset) * 8, this.update(G.subarray(0, 128 - this._blockOffset)), this._length[0] -= 111 * 8, this.update(G.subarray(1, 112)), this._nullt = !0), this.update(this._zo), this._length[0] -= 8), this._length[0] -= 128, this.update(r);
+  }
+  /**
+   * Completes the hash computation and returns the final hash value.
+   * This method applies the necessary padding, performs the final compression,
+   * and returns the hash output.
+   * @returns The Blake-512 hash of the input data.
+   */
+  digest() {
+    this._padding();
+    const e = I.Buffer.alloc(64);
+    for (let r = 0; r < 16; r += 1)
+      e.writeUInt32BE(this._h[r], r * 4);
+    return e;
+  }
+  /**
+   * Updates the hash with new data. This method can be called multiple
+   * times to incrementally add data to the hash computation.
+   * @param data The data to add to the hash.
+   * @returns This instance, to allow method chaining.
+   */
+  update(e) {
+    const r = this._block;
+    let n = 0;
+    for (; this._blockOffset + e.length - n >= r.length; ) {
+      for (let b = this._blockOffset; b < r.length; )
+        r[b++] = e[n++];
+      this._length[0] += r.length * 8, lt(this._length), this._compress(), this._blockOffset = 0;
+    }
+    for (; n < e.length; )
+      r[this._blockOffset++] = e[n++];
+    return this;
+  }
+}
+class Xt {
+  /**
+   * Constructor of the Blake2b engine
+   * @param outlen The fixed output length of the generated hash
+   * @param key Optional key parameter if keyed hashes are required
+   * @returns This instance, to allow method chaining.
+   */
+  constructor(e = 64, r) {
+    if (this.key = null, this.outlen = 64, r && (this.key = r), e <= 0 || e > 64)
+      throw new Error("Illegal output length, expected 0 < length <= 64");
+    this.outlen = e, this.context = q.blake2bInit(this.outlen, r);
+  }
+  /**
+   * Updates the hash with new data. This method can be called multiple
+   * times to incrementally add data to the hash computation.
+   * @param input The data to add to the hash.
+   * @returns The instance, to allow method chaining.
+   */
+  update(e) {
+    return q.blake2bUpdate(this.context, e), this;
+  }
+  /**
+   * Completes the hash computation and returns the final hash value.
+   * This method applies the necessary padding, performs the final compression,
+   * and returns the output.
+   * @returns The Blake2b hash of the input data.
+   */
+  digest() {
+    return St.from(q.blake2bFinal(this.context));
+  }
+}
+function ft(t) {
+  return t[0] &= 248, t[31] &= 127, t[31] |= 64, t;
+}
+function Z(t) {
+  return pt(t) && t.length === 2 && j(t[0]) && j(t[1]);
+}
+function ct(t) {
+  return X(t) && Object.prototype.hasOwnProperty.call(t, "R8") && Object.prototype.hasOwnProperty.call(t, "S") && Z(t.R8) && j(t.S);
+}
+function ht(t) {
+  return H(t, "privateKey", ["Buffer", "Uint8Array", "string"]), I.Buffer.from(t);
+}
+function gt(t) {
+  return H(t, "message", ["bignumberish", "string"]), Q(t) ? dt(t) : wt(I.Buffer.from(t));
+}
+function V(t, e) {
+  let r;
+  switch (e) {
+    case $.BLAKE1: {
+      r = new Nt();
+      break;
+    }
+    case $.BLAKE2b: {
+      r = new Xt();
+      break;
+    }
+    default:
+      throw new Error("Unsupported algorithm. Cannot hash input.");
+  }
+  return r.update(I.Buffer.from(t)), r.digest();
+}
+var $;
+(function(t) {
+  t.BLAKE1 = "blake-1", t.BLAKE2b = "blake-2b";
+})($ || ($ = {}));
+const Jt = (t) => {
+  const e = (g) => {
+    g = ht(g);
+    let c = V(g, t);
+    return c = c.slice(0, 32), c = ft(c), rt(K(c), BigInt(3)) % R;
+  };
+  function r(g) {
+    const c = e(g);
+    return P(z, c);
+  }
+  function n(g, c) {
+    g = ht(g), c = gt(c);
+    const w = V(g, t), B = ft(w.slice(0, 32)), l = K(B), y = P(z, rt(l, BigInt(3))), s = T(c, 32), i = V(I.Buffer.concat([w.slice(32, 64), s]), t), p = new Lt(R), o = p.e(K(i)), _ = P(z, o), k = it.poseidon5([_[0], _[1], y[0], y[1], c]), m = p.add(o, p.mul(k, l));
+    return { R8: _, S: m };
+  }
+  function b(g, c, w) {
+    if (!Z(w) || !ct(c) || !O(c.R8) || !O(w) || BigInt(c.S) >= R)
+      return !1;
+    g = gt(g);
+    const B = {
+      R8: [BigInt(c.R8[0]), BigInt(c.R8[1])],
+      S: BigInt(c.S)
+    }, l = [BigInt(w[0]), BigInt(w[1])], y = it.poseidon5([c.R8[0], c.R8[1], w[0], w[1], g]), s = P(z, BigInt(c.S));
+    let i = P(l, Ct(y, BigInt(8)));
+    return i = vt(B.R8, i), nt.eq(s[0], i[0]) && nt.eq(s[1], i[1]);
+  }
+  function h(g) {
+    if (!Z(g) || !O(g))
+      throw new Error("Invalid public key");
+    const c = [BigInt(g[0]), BigInt(g[1])];
+    return et(c);
+  }
+  function f(g) {
+    _t(g, "publicKey");
+    const c = tt(dt(g));
+    if (c === null)
+      throw new Error("Invalid public key");
+    return c;
+  }
+  function a(g) {
+    if (!ct(g) || !O(g.R8) || BigInt(g.S) >= R)
+      throw new Error("Invalid signature");
+    const c = {
+      R8: g.R8.map((l) => BigInt(l)),
+      S: BigInt(g.S)
+    }, w = et(c.R8), B = I.Buffer.alloc(64);
+    return B.set(T(w, 32), 0), B.set(T(c.S, 32), 32), B;
+  }
+  function u(g) {
+    if (Pt(g, "packedSignature"), g.length !== 64)
+      throw new Error("Packed signature must be 64 bytes");
+    const c = g.subarray(0, 32), w = g.subarray(32, 64), B = tt(K(c));
+    if (B === null)
+      throw new Error(`Invalid packed signature point ${w.toString("hex")}.`);
+    return {
+      R8: B,
+      S: K(w)
+    };
+  }
+  class d {
+    /**
+     * Initializes a new instance, deriving necessary cryptographic parameters from the provided private key.
+     * If the private key is not passed as a parameter, a random 32-byte hexadecimal key is generated.
+     *
+     * The private key must be an instance of Buffer, Uint8Array or a string. The input will be used to
+     * generate entropy and there is no limit in size.
+     * The string is used as a set of raw bytes (in UTF-8) and is typically used to pass passwords or secret messages.
+     * If you want to pass a bigint, a number or a hexadecimal, be sure to convert them to one of the supported types first.
+     * The 'conversions' module in @zk-kit/utils provides a set of functions that may be useful in case you need to convert types.
+     *
+     * @param privateKey The private key used for signing and public key derivation.
+     */
+    constructor(c = $t.getRandomValues(32)) {
+      this.privateKey = c, this.secretScalar = e(c), this.publicKey = r(c), this.packedPublicKey = h(this.publicKey);
+    }
+    /**
+     * Signs a given message using the private key and returns the signature.
+     * @param message The message to be signed.
+     * @returns The signature of the message.
+     */
+    signMessage(c) {
+      return n(this.privateKey, c);
+    }
+    /**
+     * Verifies a signature against a message and the public key stored in this instance.
+     * @param message The message whose signature is to be verified.
+     * @param signature The signature to be verified.
+     * @returns True if the signature is valid for the message and public key, false otherwise.
+     */
+    verifySignature(c, w) {
+      return b(c, w, this.publicKey);
+    }
+  }
+  return {
+    deriveSecretScalar: e,
+    derivePublicKey: r,
+    signMessage: n,
+    verifySignature: b,
+    packPublicKey: h,
+    unpackPublicKey: f,
+    packSignature: a,
+    unpackSignature: u,
+    EdDSAPoseidon: d
+  };
+}, { EdDSAPoseidon: Qt, derivePublicKey: te, deriveSecretScalar: ee, packPublicKey: ne, packSignature: re, signMessage: ie, unpackPublicKey: oe, unpackSignature: se, verifySignature: ue } = Jt($.BLAKE1);
+export {
+  Qt as EdDSAPoseidon,
+  te as derivePublicKey,
+  ee as deriveSecretScalar,
+  ne as packPublicKey,
+  re as packSignature,
+  ie as signMessage,
+  oe as unpackPublicKey,
+  se as unpackSignature,
+  ue as verifySignature
+};