@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/ens-normalize/decoder.mjs

@@ -0,0 +1,177 @@
+function N(e, t) {
+  t == null && (t = 1);
+  const r = [], l = r.forEach, n = function(u, a) {
+    l.call(u, function(o) {
+      a > 0 && Array.isArray(o) ? n(o, a - 1) : r.push(o);
+    });
+  };
+  return n(e, t), r;
+}
+function R(e) {
+  const t = {};
+  for (let r = 0; r < e.length; r++) {
+    const l = e[r];
+    t[l[0]] = l[1];
+  }
+  return t;
+}
+function S(e) {
+  let t = 0;
+  function r() {
+    return e[t++] << 8 | e[t++];
+  }
+  let l = r(), n = 1, u = [0, 1];
+  for (let f = 1; f < l; f++)
+    u.push(n += r());
+  let a = r(), o = t;
+  t += a;
+  let h = 0, i = 0;
+  function m() {
+    return h == 0 && (i = i << 8 | e[t++], h = 8), i >> --h & 1;
+  }
+  const w = 31, y = Math.pow(2, w), c = y >>> 1, F = c >> 1, A = y - 1;
+  let s = 0;
+  for (let f = 0; f < w; f++)
+    s = s << 1 | m();
+  let E = [], v = 0, g = y;
+  for (; ; ) {
+    let f = Math.floor(((s - v + 1) * n - 1) / g), p = 0, b = l;
+    for (; b - p > 1; ) {
+      let M = p + b >>> 1;
+      f < u[M] ? b = M : p = M;
+    }
+    if (p == 0)
+      break;
+    E.push(p);
+    let d = v + Math.floor(g * u[p] / n), _ = v + Math.floor(g * u[p + 1] / n) - 1;
+    for (; !((d ^ _) & c); )
+      s = s << 1 & A | m(), d = d << 1 & A, _ = _ << 1 & A | 1;
+    for (; d & ~_ & F; )
+      s = s & c | s << 1 & A >>> 1 | m(), d = d << 1 ^ c, _ = (_ ^ c) << 1 | c | 1;
+    v = d, g = 1 + _ - d;
+  }
+  let k = l - 4;
+  return E.map((f) => {
+    switch (f - k) {
+      case 3:
+        return k + 65792 + (e[o++] << 16 | e[o++] << 8 | e[o++]);
+      case 2:
+        return k + 256 + (e[o++] << 8 | e[o++]);
+      case 1:
+        return k + e[o++];
+      default:
+        return f - 1;
+    }
+  });
+}
+function D(e) {
+  let t = 0;
+  return () => e[t++];
+}
+function q(e) {
+  return D(S(e));
+}
+function H(e) {
+  return e & 1 ? ~e >> 1 : e >> 1;
+}
+function K(e, t) {
+  let r = Array(e);
+  for (let l = 0; l < e; l++)
+    r[l] = 1 + t();
+  return r;
+}
+function z(e, t) {
+  let r = Array(e);
+  for (let l = 0, n = -1; l < e; l++)
+    r[l] = n += 1 + t();
+  return r;
+}
+function Q(e, t) {
+  let r = Array(e);
+  for (let l = 0, n = 0; l < e; l++)
+    r[l] = n += H(t());
+  return r;
+}
+function L(e, t) {
+  let r = z(e(), e), l = e(), n = z(l, e), u = K(l, e);
+  for (let a = 0; a < l; a++)
+    for (let o = 0; o < u[a]; o++)
+      r.push(n[a] + o);
+  return t ? r.map((a) => t[a]) : r;
+}
+function B(e) {
+  let t = [];
+  for (; ; ) {
+    let r = e();
+    if (r == 0)
+      break;
+    t.push(U(r, e));
+  }
+  for (; ; ) {
+    let r = e() - 1;
+    if (r < 0)
+      break;
+    t.push(X(r, e));
+  }
+  return R(N(t));
+}
+function T(e) {
+  let t = [];
+  for (; ; ) {
+    let r = e();
+    if (r == 0)
+      break;
+    t.push(r);
+  }
+  return t;
+}
+function j(e, t, r) {
+  let l = Array(e).fill(void 0).map(() => []);
+  for (let n = 0; n < t; n++)
+    Q(e, r).forEach((u, a) => l[a].push(u));
+  return l;
+}
+function U(e, t) {
+  let r = 1 + t(), l = t(), n = T(t), u = j(n.length, 1 + e, t);
+  return N(u.map((a, o) => {
+    const h = a[0], i = a.slice(1);
+    return Array(n[o]).fill(void 0).map((m, w) => {
+      let y = w * l;
+      return [h + w * r, i.map((c) => c + y)];
+    });
+  }));
+}
+function X(e, t) {
+  let r = 1 + t();
+  return j(r, 1 + e, t).map((n) => [n[0], n.slice(1)]);
+}
+function C(e) {
+  let t = L(e).sort((l, n) => l - n);
+  return r();
+  function r() {
+    let l = [];
+    for (; ; ) {
+      let i = L(e, t);
+      if (i.length == 0)
+        break;
+      l.push({ set: new Set(i), node: r() });
+    }
+    l.sort((i, m) => m.set.size - i.set.size);
+    let n = e(), u = n % 3;
+    n = n / 3 | 0;
+    let a = !!(n & 1);
+    n >>= 1;
+    let o = n == 1, h = n == 2;
+    return { branches: l, valid: u, fe0f: a, save: o, check: h };
+  }
+}
+export {
+  S as decode_arithmetic,
+  q as read_compressed_payload,
+  C as read_emoji_trie,
+  B as read_mapped_map,
+  L as read_member_array,
+  D as read_payload,
+  T as read_zero_terminated_array,
+  H as signed
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/ens-normalize/include.mjs

@@ -0,0 +1,8 @@
+import { read_compressed_payload as A } from "./decoder.mjs";
+import { decode as g } from "../../../base64/lib.esm/base64.mjs";
+function w() {
+  return A(g("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"));
+}
+export {
+  w as getData
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/ens-normalize/lib.mjs

@@ -0,0 +1,74 @@
+import { toUtf8CodePoints as _ } from "../../../strings/lib.esm/utf8.mjs";
+import { getData as w } from "./include.mjs";
+import { read_member_array as p, read_mapped_map as v, read_emoji_trie as E } from "./decoder.mjs";
+const a = w(), x = new Set(p(a)), g = new Set(p(a)), F = v(a), b = E(a), c = 45, u = 95;
+function h(t) {
+  return _(t);
+}
+function D(t) {
+  return t.filter((n) => n != 65039);
+}
+function d(t) {
+  for (let n of t.split(".")) {
+    let r = h(n);
+    try {
+      for (let e = r.lastIndexOf(u) - 1; e >= 0; e--)
+        if (r[e] !== u)
+          throw new Error("underscore only allowed at start");
+      if (r.length >= 4 && r.every((e) => e < 128) && r[2] === c && r[3] === c)
+        throw new Error("invalid label extension");
+    } catch (e) {
+      throw new Error(`Invalid label "${n}": ${e.message}`);
+    }
+  }
+  return t;
+}
+function j(t) {
+  return d(O(t, D));
+}
+function O(t, n) {
+  let r = h(t).reverse(), e = [];
+  for (; r.length; ) {
+    let l = C(r);
+    if (l) {
+      e.push(...n(l));
+      continue;
+    }
+    let o = r.pop();
+    if (x.has(o)) {
+      e.push(o);
+      continue;
+    }
+    if (g.has(o))
+      continue;
+    let s = F[o];
+    if (s) {
+      e.push(...s);
+      continue;
+    }
+    throw new Error(`Disallowed codepoint: 0x${o.toString(16).toUpperCase()}`);
+  }
+  return d(k(String.fromCodePoint(...e)));
+}
+function k(t) {
+  return t.normalize("NFC");
+}
+function C(t, n) {
+  var r;
+  let e = b, l, o, s = [], i = t.length;
+  for (n && (n.length = 0); i; ) {
+    let f = t[--i];
+    if (e = (r = e.branches.find((m) => m.set.has(f))) === null || r === void 0 ? void 0 : r.node, !e)
+      break;
+    if (e.save)
+      o = f;
+    else if (e.check && f === o)
+      break;
+    s.push(f), e.fe0f && (s.push(65039), i > 0 && t[i - 1] == 65039 && i--), e.valid && (l = s.slice(), e.valid == 2 && l.splice(1, 1), n && n.push(...t.slice(i).reverse()), t.length = i);
+  }
+  return l;
+}
+export {
+  j as ens_normalize,
+  d as ens_normalize_post_check
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/id.mjs

@@ -0,0 +1,8 @@
+import { keccak256 as o } from "../../keccak256/lib.esm/index.mjs";
+import { toUtf8Bytes as r } from "../../strings/lib.esm/utf8.mjs";
+function i(t) {
+  return o(r(t));
+}
+export {
+  i as id
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/index.mjs

@@ -0,0 +1,14 @@
+import { id as o } from "./id.mjs";
+import { dnsEncode as s, ensNormalize as d, isValidName as m, namehash as n } from "./namehash.mjs";
+import { hashMessage as t, messagePrefix as f } from "./message.mjs";
+import { TypedDataEncoder as x } from "./typed-data.mjs";
+export {
+  x as _TypedDataEncoder,
+  s as dnsEncode,
+  d as ensNormalize,
+  t as hashMessage,
+  o as id,
+  m as isValidName,
+  f as messagePrefix,
+  n as namehash
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/message.mjs

@@ -0,0 +1,16 @@
+import { concat as o } from "../../bytes/lib.esm/index.mjs";
+import { keccak256 as n } from "../../keccak256/lib.esm/index.mjs";
+import { toUtf8Bytes as r } from "../../strings/lib.esm/utf8.mjs";
+const i = `Ethereum Signed Message:
+`;
+function p(t) {
+  return typeof t == "string" && (t = r(t)), n(o([
+    r(i),
+    r(String(t.length)),
+    t
+  ]));
+}
+export {
+  p as hashMessage,
+  i as messagePrefix
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/namehash.mjs

@@ -0,0 +1,56 @@
+import { concat as c, hexlify as f } from "../../bytes/lib.esm/index.mjs";
+import { toUtf8Bytes as a, toUtf8String as h } from "../../strings/lib.esm/utf8.mjs";
+import { keccak256 as s } from "../../keccak256/lib.esm/index.mjs";
+import { Logger as p } from "../../logger/lib.esm/index.mjs";
+import { version as u } from "./_version.mjs";
+import { ens_normalize as g } from "./ens-normalize/lib.mjs";
+const d = new p(u), m = new Uint8Array(32);
+m.fill(0);
+function l(n) {
+  if (n.length === 0)
+    throw new Error("invalid ENS name; empty component");
+  return n;
+}
+function i(n) {
+  const t = a(g(n)), e = [];
+  if (n.length === 0)
+    return e;
+  let o = 0;
+  for (let r = 0; r < t.length; r++)
+    t[r] === 46 && (e.push(l(t.slice(o, r))), o = r + 1);
+  if (o >= t.length)
+    throw new Error("invalid ENS name; empty component");
+  return e.push(l(t.slice(o))), e;
+}
+function U(n) {
+  return i(n).map((t) => h(t)).join(".");
+}
+function b(n) {
+  try {
+    return i(n).length !== 0;
+  } catch {
+  }
+  return !1;
+}
+function k(n) {
+  typeof n != "string" && d.throwArgumentError("invalid ENS name; not a string", "name", n);
+  let t = m;
+  const e = i(n);
+  for (; e.length; )
+    t = s(c([t, s(e.pop())]));
+  return f(t);
+}
+function A(n) {
+  return f(c(i(n).map((t) => {
+    if (t.length > 63)
+      throw new Error("invalid DNS encoded entry; length exceeds 63 bytes");
+    const e = new Uint8Array(t.length + 1);
+    return e.set(t, 1), e[0] = e.length - 1, e;
+  }))) + "00";
+}
+export {
+  A as dnsEncode,
+  U as ensNormalize,
+  b as isValidName,
+  k as namehash
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hash/lib.esm/typed-data.mjs

@@ -0,0 +1,298 @@
+import { getAddress as I } from "../../address/lib.esm/index.mjs";
+import { hexZeroPad as w, hexConcat as l, isHexString as A, hexlify as v, arrayify as E } from "../../bytes/lib.esm/index.mjs";
+import { keccak256 as d } from "../../keccak256/lib.esm/index.mjs";
+import { defineReadOnly as p, deepCopy as T, shallowCopy as C } from "../../properties/lib.esm/index.mjs";
+import { Logger as _ } from "../../logger/lib.esm/index.mjs";
+import { version as P } from "./_version.mjs";
+import { id as k } from "./id.mjs";
+import { BigNumber as g } from "../../bignumber/lib.esm/bignumber.mjs";
+var L = function(a, r, t, e) {
+  function o(s) {
+    return s instanceof t ? s : new t(function(c) {
+      c(s);
+    });
+  }
+  return new (t || (t = Promise))(function(s, c) {
+    function n(h) {
+      try {
+        f(e.next(h));
+      } catch (y) {
+        c(y);
+      }
+    }
+    function i(h) {
+      try {
+        f(e.throw(h));
+      } catch (y) {
+        c(y);
+      }
+    }
+    function f(h) {
+      h.done ? s(h.value) : o(h.value).then(n, i);
+    }
+    f((e = e.apply(a, r || [])).next());
+  });
+};
+const u = new _(P), N = new Uint8Array(32);
+N.fill(0);
+const D = g.from(-1), j = g.from(0), J = g.from(1), F = g.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+function H(a) {
+  const r = E(a), t = r.length % 32;
+  return t ? l([r, N.slice(t)]) : v(r);
+}
+const U = w(J.toHexString(), 32), B = w(j.toHexString(), 32), S = {
+  name: "string",
+  version: "string",
+  chainId: "uint256",
+  verifyingContract: "address",
+  salt: "bytes32"
+}, b = [
+  "name",
+  "version",
+  "chainId",
+  "verifyingContract",
+  "salt"
+];
+function $(a) {
+  return function(r) {
+    return typeof r != "string" && u.throwArgumentError(`invalid domain value for ${JSON.stringify(a)}`, `domain.${a}`, r), r;
+  };
+}
+const R = {
+  name: $("name"),
+  version: $("version"),
+  chainId: function(a) {
+    try {
+      return g.from(a).toString();
+    } catch {
+    }
+    return u.throwArgumentError('invalid domain value for "chainId"', "domain.chainId", a);
+  },
+  verifyingContract: function(a) {
+    try {
+      return I(a).toLowerCase();
+    } catch {
+    }
+    return u.throwArgumentError('invalid domain value "verifyingContract"', "domain.verifyingContract", a);
+  },
+  salt: function(a) {
+    try {
+      const r = E(a);
+      if (r.length !== 32)
+        throw new Error("bad length");
+      return v(r);
+    } catch {
+    }
+    return u.throwArgumentError('invalid domain value "salt"', "domain.salt", a);
+  }
+};
+function x(a) {
+  {
+    const r = a.match(/^(u?)int(\d*)$/);
+    if (r) {
+      const t = r[1] === "", e = parseInt(r[2] || "256");
+      (e % 8 !== 0 || e > 256 || r[2] && r[2] !== String(e)) && u.throwArgumentError("invalid numeric width", "type", a);
+      const o = F.mask(t ? e - 1 : e), s = t ? o.add(J).mul(D) : j;
+      return function(c) {
+        const n = g.from(c);
+        return (n.lt(s) || n.gt(o)) && u.throwArgumentError(`value out-of-bounds for ${a}`, "value", c), w(n.toTwos(256).toHexString(), 32);
+      };
+    }
+  }
+  {
+    const r = a.match(/^bytes(\d+)$/);
+    if (r) {
+      const t = parseInt(r[1]);
+      return (t === 0 || t > 32 || r[1] !== String(t)) && u.throwArgumentError("invalid bytes width", "type", a), function(e) {
+        return E(e).length !== t && u.throwArgumentError(`invalid length for ${a}`, "value", e), H(e);
+      };
+    }
+  }
+  switch (a) {
+    case "address":
+      return function(r) {
+        return w(I(r), 32);
+      };
+    case "bool":
+      return function(r) {
+        return r ? U : B;
+      };
+    case "bytes":
+      return function(r) {
+        return d(r);
+      };
+    case "string":
+      return function(r) {
+        return k(r);
+      };
+  }
+  return null;
+}
+function O(a, r) {
+  return `${a}(${r.map(({ name: t, type: e }) => e + " " + t).join(",")})`;
+}
+class m {
+  constructor(r) {
+    p(this, "types", Object.freeze(T(r))), p(this, "_encoderCache", {}), p(this, "_types", {});
+    const t = {}, e = {}, o = {};
+    Object.keys(r).forEach((n) => {
+      t[n] = {}, e[n] = [], o[n] = {};
+    });
+    for (const n in r) {
+      const i = {};
+      r[n].forEach((f) => {
+        i[f.name] && u.throwArgumentError(`duplicate variable name ${JSON.stringify(f.name)} in ${JSON.stringify(n)}`, "types", r), i[f.name] = !0;
+        const h = f.type.match(/^([^\x5b]*)(\x5b|$)/)[1];
+        h === n && u.throwArgumentError(`circular type reference to ${JSON.stringify(h)}`, "types", r), !x(h) && (e[h] || u.throwArgumentError(`unknown type ${JSON.stringify(h)}`, "types", r), e[h].push(n), t[n][h] = !0);
+      });
+    }
+    const s = Object.keys(e).filter((n) => e[n].length === 0);
+    s.length === 0 ? u.throwArgumentError("missing primary type", "types", r) : s.length > 1 && u.throwArgumentError(`ambiguous primary types or unused types: ${s.map((n) => JSON.stringify(n)).join(", ")}`, "types", r), p(this, "primaryType", s[0]);
+    function c(n, i) {
+      i[n] && u.throwArgumentError(`circular type reference to ${JSON.stringify(n)}`, "types", r), i[n] = !0, Object.keys(t[n]).forEach((f) => {
+        e[f] && (c(f, i), Object.keys(i).forEach((h) => {
+          o[h][f] = !0;
+        }));
+      }), delete i[n];
+    }
+    c(this.primaryType, {});
+    for (const n in o) {
+      const i = Object.keys(o[n]);
+      i.sort(), this._types[n] = O(n, r[n]) + i.map((f) => O(f, r[f])).join("");
+    }
+  }
+  getEncoder(r) {
+    let t = this._encoderCache[r];
+    return t || (t = this._encoderCache[r] = this._getEncoder(r)), t;
+  }
+  _getEncoder(r) {
+    {
+      const o = x(r);
+      if (o)
+        return o;
+    }
+    const t = r.match(/^(.*)(\x5b(\d*)\x5d)$/);
+    if (t) {
+      const o = t[1], s = this.getEncoder(o), c = parseInt(t[3]);
+      return (n) => {
+        c >= 0 && n.length !== c && u.throwArgumentError("array length mismatch; expected length ${ arrayLength }", "value", n);
+        let i = n.map(s);
+        return this._types[o] && (i = i.map(d)), d(l(i));
+      };
+    }
+    const e = this.types[r];
+    if (e) {
+      const o = k(this._types[r]);
+      return (s) => {
+        const c = e.map(({ name: n, type: i }) => {
+          const f = this.getEncoder(i)(s[n]);
+          return this._types[i] ? d(f) : f;
+        });
+        return c.unshift(o), l(c);
+      };
+    }
+    return u.throwArgumentError(`unknown type: ${r}`, "type", r);
+  }
+  encodeType(r) {
+    const t = this._types[r];
+    return t || u.throwArgumentError(`unknown type: ${JSON.stringify(r)}`, "name", r), t;
+  }
+  encodeData(r, t) {
+    return this.getEncoder(r)(t);
+  }
+  hashStruct(r, t) {
+    return d(this.encodeData(r, t));
+  }
+  encode(r) {
+    return this.encodeData(this.primaryType, r);
+  }
+  hash(r) {
+    return this.hashStruct(this.primaryType, r);
+  }
+  _visit(r, t, e) {
+    if (x(r))
+      return e(r, t);
+    const o = r.match(/^(.*)(\x5b(\d*)\x5d)$/);
+    if (o) {
+      const c = o[1], n = parseInt(o[3]);
+      return n >= 0 && t.length !== n && u.throwArgumentError("array length mismatch; expected length ${ arrayLength }", "value", t), t.map((i) => this._visit(c, i, e));
+    }
+    const s = this.types[r];
+    return s ? s.reduce((c, { name: n, type: i }) => (c[n] = this._visit(i, t[n], e), c), {}) : u.throwArgumentError(`unknown type: ${r}`, "type", r);
+  }
+  visit(r, t) {
+    return this._visit(this.primaryType, r, t);
+  }
+  static from(r) {
+    return new m(r);
+  }
+  static getPrimaryType(r) {
+    return m.from(r).primaryType;
+  }
+  static hashStruct(r, t, e) {
+    return m.from(t).hashStruct(r, e);
+  }
+  static hashDomain(r) {
+    const t = [];
+    for (const e in r) {
+      const o = S[e];
+      o || u.throwArgumentError(`invalid typed-data domain key: ${JSON.stringify(e)}`, "domain", r), t.push({ name: e, type: o });
+    }
+    return t.sort((e, o) => b.indexOf(e.name) - b.indexOf(o.name)), m.hashStruct("EIP712Domain", { EIP712Domain: t }, r);
+  }
+  static encode(r, t, e) {
+    return l([
+      "0x1901",
+      m.hashDomain(r),
+      m.from(t).hash(e)
+    ]);
+  }
+  static hash(r, t, e) {
+    return d(m.encode(r, t, e));
+  }
+  // Replaces all address types with ENS names with their looked up address
+  static resolveNames(r, t, e, o) {
+    return L(this, void 0, void 0, function* () {
+      r = C(r);
+      const s = {};
+      r.verifyingContract && !A(r.verifyingContract, 20) && (s[r.verifyingContract] = "0x");
+      const c = m.from(t);
+      c.visit(e, (n, i) => (n === "address" && !A(i, 20) && (s[i] = "0x"), i));
+      for (const n in s)
+        s[n] = yield o(n);
+      return r.verifyingContract && s[r.verifyingContract] && (r.verifyingContract = s[r.verifyingContract]), e = c.visit(e, (n, i) => n === "address" && s[i] ? s[i] : i), { domain: r, value: e };
+    });
+  }
+  static getPayload(r, t, e) {
+    m.hashDomain(r);
+    const o = {}, s = [];
+    b.forEach((i) => {
+      const f = r[i];
+      f != null && (o[i] = R[i](f), s.push({ name: i, type: S[i] }));
+    });
+    const c = m.from(t), n = C(t);
+    return n.EIP712Domain ? u.throwArgumentError("types must not contain EIP712Domain type", "types.EIP712Domain", t) : n.EIP712Domain = s, c.encode(e), {
+      types: n,
+      domain: o,
+      primaryType: c.primaryType,
+      message: c.visit(e, (i, f) => {
+        if (i.match(/^bytes(\d*)/))
+          return v(E(f));
+        if (i.match(/^u?int/))
+          return g.from(f).toString();
+        switch (i) {
+          case "address":
+            return f.toLowerCase();
+          case "bool":
+            return !!f;
+          case "string":
+            return typeof f != "string" && u.throwArgumentError("invalid string", "value", f), f;
+        }
+        return u.throwArgumentError("unsupported type", "type", i);
+      })
+    };
+  }
+}
+export {
+  m as TypedDataEncoder
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/hdnode/lib.esm/_version.mjs

@@ -0,0 +1,4 @@
+const o = "hdnode/5.7.0";
+export {
+  o as version
+};