@nihilium/client-sdk 0.1.1 → 0.1.2

package/dist/index-DFD-0QrS-DqRwsoRk-DaSQ-uF-.js

@@ -0,0 +1,1551 @@
+import { Z as tt, j as O, V as R, X as et, b as I, q as vt, W as x, z, c as nt, e as Ut, B as St } from "./index-78RSe_cY.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 xt(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 Pt = /* @__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 gt(t) {
+  return typeof t == "number";
+}
+function X(t) {
+  return typeof t == "string";
+}
+function Rt(t) {
+  return typeof t == "function";
+}
+function G(t) {
+  return typeof t == "object";
+}
+function dt(t) {
+  return G(t) && Array.isArray(t);
+}
+function N(t) {
+  return t instanceof Uint8Array;
+}
+function Q(t) {
+  return I.Buffer.isBuffer(t);
+}
+function H(t) {
+  return typeof t == "bigint";
+}
+function Y(t) {
+  if (!X(t))
+    return !1;
+  try {
+    return BigInt(t), !0;
+  } catch {
+    return !1;
+  }
+}
+function pt(t, e = !0) {
+  return X(t) ? e ? /^(0x|0X)[0-9a-fA-F]+$/.test(t) : /^[0-9a-fA-F]+$/.test(t) : !1;
+}
+function j(t) {
+  return H(t) || Y(t);
+}
+function J(t) {
+  return gt(t) || H(t) || Y(t) || pt(t) || Q(t) || N(t);
+}
+function zt(t, e) {
+  switch (e) {
+    case "number":
+      return gt(t);
+    case "string":
+      return X(t);
+    case "function":
+      return Rt(t);
+    case "Array":
+      return dt(t);
+    case "Uint8Array":
+      return N(t);
+    case "Buffer":
+      return Q(t);
+    case "object":
+      return G(t);
+    case "bigint":
+      return H(t);
+    case "stringified-bigint":
+      return Y(t);
+    case "hexadecimal":
+      return pt(t);
+    case "bignumber":
+      return j(t);
+    case "bignumberish":
+      return J(t);
+    default:
+      return !1;
+  }
+}
+function $t(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 (!H(t))
+    throw new TypeError(`Parameter '${e}' is not a bigint, received type: ${typeof t}`);
+}
+function wt(t, e) {
+  if (!J(t))
+    throw new TypeError(`Parameter '${e}' is not a bignumber-ish`);
+}
+function F(t, e, r) {
+  for (const n of r)
+    if (!$t(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 Ht(t) {
+  jt(t, "value");
+  let e = t.toString(16);
+  return e.length % 2 !== 0 && (e = `0${e}`), e;
+}
+function Ft(t) {
+  return F(t, "value", ["Buffer", "Uint8Array"]), BigInt(`0x${I.Buffer.from(t).toString("hex")}`);
+}
+function K(t) {
+  return F(t, "value", ["Buffer", "Uint8Array"]), BigInt(`0x${I.Buffer.from(t).reverse().toString("hex")}`);
+}
+function yt(t) {
+  return Ft(t);
+}
+function T(t, e) {
+  const r = Ht(t), n = Math.ceil(r.length / 2);
+  if (e < n)
+    throw Error(`Size ${e} is too small, need at least ${n} bytes`);
+  const g = I.Buffer.alloc(e, 0);
+  return I.Buffer.from(r, "hex").reverse().copy(g, 0), g;
+}
+function kt(t) {
+  return wt(t, "value"), Q(t) || N(t) ? yt(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 qt(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 Mt {
+  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, g = this.one, h = e % this._order;
+    for (; h; ) {
+      const f = n / h;
+      [r, g] = [g, r - f * g], [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, g = r > this._half ? r - this._order : r;
+    return n < g;
+  }
+  /**
+   * 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, g = r > this._half ? r - this._order : r;
+    return n >= g;
+  }
+  /**
+   * 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 g = e;
+    for (let h = n.length - 2; h >= 0; h -= 1)
+      g = this.square(g), n[h] && (g = this.mul(g, e));
+    return g;
+  }
+}
+var it = vt(), q, ot;
+function _t() {
+  if (ot) return q;
+  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 g(f, a, u) {
+    let k = `
+` + f + " = ";
+    for (let b = 0; b < a.length; b += 2) {
+      if (u === 32)
+        k += n(a[b]).toUpperCase(), k += " ", k += n(a[b + 1]).toUpperCase();
+      else if (u === 64)
+        k += n(a[b + 1]).toUpperCase(), k += n(a[b]).toUpperCase();
+      else throw new Error("Invalid size " + u);
+      b % 6 === 4 ? k += `
+` + new Array(f.length + 4).join(" ") : b < a.length - 2 && (k += " ");
+    }
+    console.log(k);
+  }
+  function h(f, a, u) {
+    let k = (/* @__PURE__ */ new Date()).getTime();
+    const b = new Uint8Array(a);
+    for (let y = 0; y < a; y++)
+      b[y] = y % 256;
+    const l = (/* @__PURE__ */ new Date()).getTime();
+    console.log("Generated random input in " + (l - k) + "ms"), k = l;
+    for (let y = 0; y < u; y++) {
+      const B = f(b), c = (/* @__PURE__ */ new Date()).getTime(), p = c - k;
+      k = c, console.log("Hashed in " + p + "ms: " + B.substring(0, 20) + "..."), console.log(
+        Math.round(a / (1 << 20) / (p / 1e3) * 100) / 100 + " MB PER SECOND"
+      );
+    }
+  }
+  return q = {
+    normalizeInput: e,
+    toHex: r,
+    debugPrint: g,
+    testSpeed: h
+  }, q;
+}
+var D, st;
+function Ct() {
+  if (st) return D;
+  st = 1;
+  const t = _t();
+  function e(i, d, o) {
+    const w = i[d] + i[o];
+    let _ = i[d + 1] + i[o + 1];
+    w >= 4294967296 && _++, i[d] = w, i[d + 1] = _;
+  }
+  function r(i, d, o, w) {
+    let _ = i[d] + o;
+    o < 0 && (_ += 4294967296);
+    let m = i[d + 1] + w;
+    _ >= 4294967296 && m++, i[d] = _, i[d + 1] = m;
+  }
+  function n(i, d) {
+    return i[d] ^ i[d + 1] << 8 ^ i[d + 2] << 16 ^ i[d + 3] << 24;
+  }
+  function g(i, d, o, w, _, m) {
+    const Bt = k[_], mt = k[_ + 1], It = k[m], At = k[m + 1];
+    e(u, i, d), r(u, i, Bt, mt);
+    let A = u[w] ^ u[i], v = u[w + 1] ^ u[i + 1];
+    u[w] = v, u[w + 1] = A, e(u, o, w), A = u[d] ^ u[o], v = u[d + 1] ^ u[o + 1], u[d] = A >>> 24 ^ v << 8, u[d + 1] = v >>> 24 ^ A << 8, e(u, i, d), r(u, i, It, At), A = u[w] ^ u[i], v = u[w + 1] ^ u[i + 1], u[w] = A >>> 16 ^ v << 16, u[w + 1] = v >>> 16 ^ A << 16, e(u, o, w), A = u[d] ^ u[o], v = u[d + 1] ^ u[o + 1], u[d] = v >>> 31 ^ A << 1, u[d + 1] = A >>> 31 ^ v << 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), k = new Uint32Array(32);
+  function b(i, d) {
+    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, d && (u[28] = ~u[28], u[29] = ~u[29]), o = 0; o < 32; o++)
+      k[o] = n(i.b, 4 * o);
+    for (o = 0; o < 12; o++)
+      g(0, 8, 16, 24, a[o * 16 + 0], a[o * 16 + 1]), g(2, 10, 18, 26, a[o * 16 + 2], a[o * 16 + 3]), g(4, 12, 20, 28, a[o * 16 + 4], a[o * 16 + 5]), g(6, 14, 22, 30, a[o * 16 + 6], a[o * 16 + 7]), g(0, 10, 20, 30, a[o * 16 + 8], a[o * 16 + 9]), g(2, 12, 22, 24, a[o * 16 + 10], a[o * 16 + 11]), g(4, 14, 16, 26, a[o * 16 + 12], a[o * 16 + 13]), g(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 l = 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 y(i, d, o, w) {
+    if (i === 0 || i > 64)
+      throw new Error("Illegal output length, expected 0 < length <= 64");
+    if (d && d.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 (w && w.length !== 16)
+      throw new Error("Illegal personal, expected Uint8Array with length is 16");
+    const _ = {
+      b: new Uint8Array(128),
+      h: new Uint32Array(16),
+      t: 0,
+      // input count
+      c: 0,
+      // pointer within buffer
+      outlen: i
+      // output length in bytes
+    };
+    l.fill(0), l[0] = i, d && (l[1] = d.length), l[2] = 1, l[3] = 1, o && l.set(o, 32), w && l.set(w, 48);
+    for (let m = 0; m < 16; m++)
+      _.h[m] = h[m] ^ n(l, m * 4);
+    return d && (B(_, d), _.c = 128), _;
+  }
+  function B(i, d) {
+    for (let o = 0; o < d.length; o++)
+      i.c === 128 && (i.t += i.c, b(i, !1), i.c = 0), i.b[i.c++] = d[o];
+  }
+  function c(i) {
+    for (i.t += i.c; i.c < 128; )
+      i.b[i.c++] = 0;
+    b(i, !0);
+    const d = new Uint8Array(i.outlen);
+    for (let o = 0; o < i.outlen; o++)
+      d[o] = i.h[o >> 2] >> 8 * (o & 3);
+    return d;
+  }
+  function p(i, d, o, w, _) {
+    o = o || 64, i = t.normalizeInput(i), w && (w = t.normalizeInput(w)), _ && (_ = t.normalizeInput(_));
+    const m = y(o, d, w, _);
+    return B(m, i), c(m);
+  }
+  function s(i, d, o, w, _) {
+    const m = p(i, d, o, w, _);
+    return t.toHex(m);
+  }
+  return D = {
+    blake2b: p,
+    blake2bHex: s,
+    blake2bInit: y,
+    blake2bUpdate: B,
+    blake2bFinal: c
+  }, D;
+}
+var M, ut;
+function Lt() {
+  if (ut) return M;
+  ut = 1;
+  const t = _t();
+  function e(c, p) {
+    return c[p] ^ c[p + 1] << 8 ^ c[p + 2] << 16 ^ c[p + 3] << 24;
+  }
+  function r(c, p, s, i, d, o) {
+    f[c] = f[c] + f[p] + d, f[i] = n(f[i] ^ f[c], 16), f[s] = f[s] + f[i], f[p] = n(f[p] ^ f[s], 12), f[c] = f[c] + f[p] + o, f[i] = n(f[i] ^ f[c], 8), f[s] = f[s] + f[i], f[p] = n(f[p] ^ f[s], 7);
+  }
+  function n(c, p) {
+    return c >>> p ^ c << 32 - p;
+  }
+  const g = 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(c, p) {
+    let s = 0;
+    for (s = 0; s < 8; s++)
+      f[s] = c.h[s], f[s + 8] = g[s];
+    for (f[12] ^= c.t, f[13] ^= c.t / 4294967296, p && (f[14] = ~f[14]), s = 0; s < 16; s++)
+      a[s] = e(c.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++)
+      c.h[s] ^= f[s] ^ f[s + 8];
+  }
+  function k(c, p) {
+    if (!(c > 0 && c <= 32))
+      throw new Error("Incorrect output length, should be in [1, 32]");
+    const s = p ? p.length : 0;
+    if (p && !(s > 0 && s <= 32))
+      throw new Error("Incorrect key length, should be in [1, 32]");
+    const i = {
+      h: new Uint32Array(g),
+      // hash state
+      b: new Uint8Array(64),
+      // input block
+      c: 0,
+      // pointer within block
+      t: 0,
+      // input count
+      outlen: c
+      // output length in bytes
+    };
+    return i.h[0] ^= 16842752 ^ s << 8 ^ c, s > 0 && (b(i, p), i.c = 64), i;
+  }
+  function b(c, p) {
+    for (let s = 0; s < p.length; s++)
+      c.c === 64 && (c.t += c.c, u(c, !1), c.c = 0), c.b[c.c++] = p[s];
+  }
+  function l(c) {
+    for (c.t += c.c; c.c < 64; )
+      c.b[c.c++] = 0;
+    u(c, !0);
+    const p = new Uint8Array(c.outlen);
+    for (let s = 0; s < c.outlen; s++)
+      p[s] = c.h[s >> 2] >> 8 * (s & 3) & 255;
+    return p;
+  }
+  function y(c, p, s) {
+    s = s || 32, c = t.normalizeInput(c);
+    const i = k(s, p);
+    return b(i, c), l(i);
+  }
+  function B(c, p, s) {
+    const i = y(c, p, s);
+    return t.toHex(i);
+  }
+  return M = {
+    blake2s: y,
+    blake2sHex: B,
+    blake2sInit: k,
+    blake2sUpdate: b,
+    blake2sFinal: l
+  }, M;
+}
+var C, at;
+function Vt() {
+  if (at) return C;
+  at = 1;
+  const t = Ct(), e = Lt();
+  return C = {
+    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
+  }, C;
+}
+var L = Vt();
+/**
+ * @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 Zt = I.Buffer.from([1]), Wt = 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
+], V = 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 $(t, e, r, n) {
+  let g = t[e * 2] ^ t[r * 2], h = t[e * 2 + 1] ^ t[r * 2 + 1];
+  n >= 32 && (h ^= g, g ^= h, h ^= g, n -= 32), n === 0 ? (t[e * 2] = g >>> 0, t[e * 2 + 1] = h >>> 0) : (t[e * 2] = (g >>> n | h << 32 - n) >>> 0, t[e * 2 + 1] = (h >>> n | g << 32 - n) >>> 0);
+}
+function S(t, e, r, n, g, 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[g * 2 + 1], t[n * 2] = t[n * 2] + ((e[U[r][a] * 2] ^ E[U[r][a + 1] * 2]) >>> 0) + t[g * 2] + ~~(u / 4294967296) >>> 0, t[n * 2 + 1] = u >>> 0, $(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, $(t, g, h, 25), u = t[n * 2 + 1] + ((e[U[r][a + 1] * 2 + 1] ^ E[U[r][a] * 2 + 1]) >>> 0) + t[g * 2 + 1], t[n * 2] = t[n * 2] + ((e[U[r][a + 1] * 2] ^ E[U[r][a] * 2]) >>> 0) + t[g * 2] + ~~(u / 4294967296) >>> 0, t[n * 2 + 1] = u >>> 0, $(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, $(t, g, h, 11);
+}
+function ct(t) {
+  for (let e = 0; e < t.length && !(t[e] < 4294967296); e += 1)
+    t[e] -= 4294967296, t[e + 1] += 1;
+}
+class Xt {
+  /**
+   * 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 = Zt, this._oo = Wt;
+  }
+  /**
+   * 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)
+      S(e, r, n, 0, 4, 8, 12, 0), S(e, r, n, 1, 5, 9, 13, 2), S(e, r, n, 2, 6, 10, 14, 4), S(e, r, n, 3, 7, 11, 15, 6), S(e, r, n, 0, 5, 10, 15, 8), S(e, r, n, 1, 6, 11, 12, 10), S(e, r, n, 2, 7, 8, 13, 12), S(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, ct(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(V.subarray(0, 111 - this._blockOffset))) : (this._length[0] -= (128 - this._blockOffset) * 8, this.update(V.subarray(0, 128 - this._blockOffset)), this._length[0] -= 111 * 8, this.update(V.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 g = this._blockOffset; g < r.length; )
+        r[g++] = e[n++];
+      this._length[0] += r.length * 8, ct(this._length), this._compress(), this._blockOffset = 0;
+    }
+    for (; n < e.length; )
+      r[this._blockOffset++] = e[n++];
+    return this;
+  }
+}
+class Gt {
+  /**
+   * 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 = L.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 L.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(L.blake2bFinal(this.context));
+  }
+}
+function ft(t) {
+  return t[0] &= 248, t[31] &= 127, t[31] |= 64, t;
+}
+function W(t) {
+  return dt(t) && t.length === 2 && j(t[0]) && j(t[1]);
+}
+function lt(t) {
+  return G(t) && Object.prototype.hasOwnProperty.call(t, "R8") && Object.prototype.hasOwnProperty.call(t, "S") && W(t.R8) && j(t.S);
+}
+function ht(t) {
+  return F(t, "privateKey", ["Buffer", "Uint8Array", "string"]), I.Buffer.from(t);
+}
+function bt(t) {
+  return F(t, "message", ["bignumberish", "string"]), J(t) ? kt(t) : yt(I.Buffer.from(t));
+}
+function Z(t, e) {
+  let r;
+  switch (e) {
+    case P.BLAKE1: {
+      r = new Xt();
+      break;
+    }
+    case P.BLAKE2b: {
+      r = new Gt();
+      break;
+    }
+    default:
+      throw new Error("Unsupported algorithm. Cannot hash input.");
+  }
+  return r.update(I.Buffer.from(t)), r.digest();
+}
+var P;
+(function(t) {
+  t.BLAKE1 = "blake-1", t.BLAKE2b = "blake-2b";
+})(P || (P = {}));
+const Nt = (t) => {
+  const e = (b) => {
+    b = ht(b);
+    let l = Z(b, t);
+    return l = l.slice(0, 32), l = ft(l), rt(K(l), BigInt(3)) % R;
+  };
+  function r(b) {
+    const l = e(b);
+    return x(z, l);
+  }
+  function n(b, l) {
+    b = ht(b), l = bt(l);
+    const y = Z(b, t), B = ft(y.slice(0, 32)), c = K(B), p = x(z, rt(c, BigInt(3))), s = T(l, 32), i = Z(I.Buffer.concat([y.slice(32, 64), s]), t), d = new Mt(R), o = d.e(K(i)), w = x(z, o), _ = it.poseidon5([w[0], w[1], p[0], p[1], l]), m = d.add(o, d.mul(_, c));
+    return { R8: w, S: m };
+  }
+  function g(b, l, y) {
+    if (!W(y) || !lt(l) || !O(l.R8) || !O(y) || BigInt(l.S) >= R)
+      return !1;
+    b = bt(b);
+    const B = {
+      R8: [BigInt(l.R8[0]), BigInt(l.R8[1])],
+      S: BigInt(l.S)
+    }, c = [BigInt(y[0]), BigInt(y[1])], p = it.poseidon5([l.R8[0], l.R8[1], y[0], y[1], b]), s = x(z, BigInt(l.S));
+    let i = x(c, qt(p, BigInt(8)));
+    return i = Ut(B.R8, i), nt.eq(s[0], i[0]) && nt.eq(s[1], i[1]);
+  }
+  function h(b) {
+    if (!W(b) || !O(b))
+      throw new Error("Invalid public key");
+    const l = [BigInt(b[0]), BigInt(b[1])];
+    return et(l);
+  }
+  function f(b) {
+    wt(b, "publicKey");
+    const l = tt(kt(b));
+    if (l === null)
+      throw new Error("Invalid public key");
+    return l;
+  }
+  function a(b) {
+    if (!lt(b) || !O(b.R8) || BigInt(b.S) >= R)
+      throw new Error("Invalid signature");
+    const l = {
+      R8: b.R8.map((c) => BigInt(c)),
+      S: BigInt(b.S)
+    }, y = et(l.R8), B = I.Buffer.alloc(64);
+    return B.set(T(y, 32), 0), B.set(T(l.S, 32), 32), B;
+  }
+  function u(b) {
+    if (xt(b, "packedSignature"), b.length !== 64)
+      throw new Error("Packed signature must be 64 bytes");
+    const l = b.subarray(0, 32), y = b.subarray(32, 64), B = tt(K(l));
+    if (B === null)
+      throw new Error(`Invalid packed signature point ${y.toString("hex")}.`);
+    return {
+      R8: B,
+      S: K(y)
+    };
+  }
+  class k {
+    /**
+     * 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(l = Pt.getRandomValues(32)) {
+      this.privateKey = l, this.secretScalar = e(l), this.publicKey = r(l), 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(l) {
+      return n(this.privateKey, l);
+    }
+    /**
+     * 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(l, y) {
+      return g(l, y, this.publicKey);
+    }
+  }
+  return {
+    deriveSecretScalar: e,
+    derivePublicKey: r,
+    signMessage: n,
+    verifySignature: g,
+    packPublicKey: h,
+    unpackPublicKey: f,
+    packSignature: a,
+    unpackSignature: u,
+    EdDSAPoseidon: k
+  };
+}, { EdDSAPoseidon: Yt, derivePublicKey: Jt, deriveSecretScalar: te, packPublicKey: ee, packSignature: ne, signMessage: re, unpackPublicKey: ie, unpackSignature: oe, verifySignature: se } = Nt(P.BLAKE1);
+export {
+  Yt as EdDSAPoseidon,
+  Jt as derivePublicKey,
+  te as deriveSecretScalar,
+  ee as packPublicKey,
+  ne as packSignature,
+  re as signMessage,
+  ie as unpackPublicKey,
+  oe as unpackSignature,
+  se as verifySignature
+};