@hinkal/common 0.0.116 → 0.0.117

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

@@ -0,0 +1,204 @@
+import { Base58 as I } from "../../basex/lib.esm/index.mjs";
+import { hexlify as h, hexDataSlice as C, concat as E, hexZeroPad as D, arrayify as m } from "../../bytes/lib.esm/index.mjs";
+import { toUtf8Bytes as b, UnicodeNormalizationForm as k } from "../../strings/lib.esm/utf8.mjs";
+import { defineReadOnly as c } from "../../properties/lib.esm/index.mjs";
+import { SigningKey as A } from "../../signing-key/lib.esm/index.mjs";
+import { ripemd160 as R, sha256 as w, computeHmac as B } from "../../sha2/lib.esm/sha2.mjs";
+import { SupportedAlgorithm as S } from "../../sha2/lib.esm/types.mjs";
+import { computeAddress as L } from "../../transactions/lib.esm/index.mjs";
+import { wordlists as M } from "../../wordlists/lib.esm/wordlists.mjs";
+import { Logger as P } from "../../logger/lib.esm/index.mjs";
+import { version as W } from "./_version.mjs";
+import { BigNumber as T } from "../../bignumber/lib.esm/bignumber.mjs";
+import { pbkdf2 as $ } from "../../pbkdf2/lib.esm/pbkdf2.mjs";
+const v = new P(W), j = T.from("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), N = b("Bitcoin seed"), y = 2147483648;
+function U(n) {
+  return (1 << n) - 1 << 8 - n;
+}
+function G(n) {
+  return (1 << n) - 1;
+}
+function K(n) {
+  return D(h(n), 32);
+}
+function F(n) {
+  return I.encode(E([n, C(w(w(n)), 0, 4)]));
+}
+function x(n) {
+  if (n == null)
+    return M.en;
+  if (typeof n == "string") {
+    const t = M[n];
+    return t == null && v.throwArgumentError("unknown locale", "wordlist", n), t;
+  }
+  return n;
+}
+const g = {}, oe = "m/44'/60'/0'/0/0";
+class p {
+  /**
+   *  This constructor should not be called directly.
+   *
+   *  Please use:
+   *   - fromMnemonic
+   *   - fromSeed
+   */
+  constructor(t, e, i, r, s, o, l, f) {
+    if (t !== g)
+      throw new Error("HDNode constructor cannot be called directly");
+    if (e) {
+      const a = new A(e);
+      c(this, "privateKey", a.privateKey), c(this, "publicKey", a.compressedPublicKey);
+    } else
+      c(this, "privateKey", null), c(this, "publicKey", h(i));
+    c(this, "parentFingerprint", r), c(this, "fingerprint", C(R(w(this.publicKey)), 0, 4)), c(this, "address", L(this.publicKey)), c(this, "chainCode", s), c(this, "index", o), c(this, "depth", l), f == null ? (c(this, "mnemonic", null), c(this, "path", null)) : typeof f == "string" ? (c(this, "mnemonic", null), c(this, "path", f)) : (c(this, "mnemonic", f), c(this, "path", f.path));
+  }
+  get extendedKey() {
+    if (this.depth >= 256)
+      throw new Error("Depth too large!");
+    return F(E([
+      this.privateKey != null ? "0x0488ADE4" : "0x0488B21E",
+      h(this.depth),
+      this.parentFingerprint,
+      D(h(this.index), 4),
+      this.chainCode,
+      this.privateKey != null ? E(["0x00", this.privateKey]) : this.publicKey
+    ]));
+  }
+  neuter() {
+    return new p(g, null, this.publicKey, this.parentFingerprint, this.chainCode, this.index, this.depth, this.path);
+  }
+  _derive(t) {
+    if (t > 4294967295)
+      throw new Error("invalid index - " + String(t));
+    let e = this.path;
+    e && (e += "/" + (t & ~y));
+    const i = new Uint8Array(37);
+    if (t & y) {
+      if (!this.privateKey)
+        throw new Error("cannot derive child of neutered node");
+      i.set(m(this.privateKey), 1), e && (e += "'");
+    } else
+      i.set(m(this.publicKey));
+    for (let u = 24; u >= 0; u -= 8)
+      i[33 + (u >> 3)] = t >> 24 - u & 255;
+    const r = m(B(S.sha512, this.chainCode, i)), s = r.slice(0, 32), o = r.slice(32);
+    let l = null, f = null;
+    this.privateKey ? l = K(T.from(s).add(this.privateKey).mod(j)) : f = new A(h(s))._addPoint(this.publicKey);
+    let a = e;
+    const d = this.mnemonic;
+    return d && (a = Object.freeze({
+      phrase: d.phrase,
+      path: e,
+      locale: d.locale || "en"
+    })), new p(g, l, f, this.fingerprint, K(o), t, this.depth + 1, a);
+  }
+  derivePath(t) {
+    const e = t.split("/");
+    if (e.length === 0 || e[0] === "m" && this.depth !== 0)
+      throw new Error("invalid path - " + t);
+    e[0] === "m" && e.shift();
+    let i = this;
+    for (let r = 0; r < e.length; r++) {
+      const s = e[r];
+      if (s.match(/^[0-9]+'$/)) {
+        const o = parseInt(s.substring(0, s.length - 1));
+        if (o >= y)
+          throw new Error("invalid path index - " + s);
+        i = i._derive(y + o);
+      } else if (s.match(/^[0-9]+$/)) {
+        const o = parseInt(s);
+        if (o >= y)
+          throw new Error("invalid path index - " + s);
+        i = i._derive(o);
+      } else
+        throw new Error("invalid path component - " + s);
+    }
+    return i;
+  }
+  static _fromSeed(t, e) {
+    const i = m(t);
+    if (i.length < 16 || i.length > 64)
+      throw new Error("invalid seed");
+    const r = m(B(S.sha512, N, i));
+    return new p(g, K(r.slice(0, 32)), null, "0x00000000", K(r.slice(32)), 0, 0, e);
+  }
+  static fromMnemonic(t, e, i) {
+    return i = x(i), t = Z(z(t, i), i), p._fromSeed(V(t, e), {
+      phrase: t,
+      path: "m",
+      locale: i.locale
+    });
+  }
+  static fromSeed(t) {
+    return p._fromSeed(t, null);
+  }
+  static fromExtendedKey(t) {
+    const e = I.decode(t);
+    (e.length !== 82 || F(e.slice(0, 78)) !== t) && v.throwArgumentError("invalid extended key", "extendedKey", "[REDACTED]");
+    const i = e[4], r = h(e.slice(5, 9)), s = parseInt(h(e.slice(9, 13)).substring(2), 16), o = h(e.slice(13, 45)), l = e.slice(45, 78);
+    switch (h(e.slice(0, 4))) {
+      case "0x0488b21e":
+      case "0x043587cf":
+        return new p(g, null, h(l), r, o, s, i, null);
+      case "0x0488ade4":
+      case "0x04358394 ":
+        if (l[0] !== 0)
+          break;
+        return new p(g, h(l.slice(1)), null, r, o, s, i, null);
+    }
+    return v.throwArgumentError("invalid extended key", "extendedKey", "[REDACTED]");
+  }
+}
+function V(n, t) {
+  t || (t = "");
+  const e = b("mnemonic" + t, k.NFKD);
+  return $(b(n, k.NFKD), e, 2048, 64, "sha512");
+}
+function z(n, t) {
+  t = x(t), v.checkNormalize();
+  const e = t.split(n);
+  if (e.length % 3 !== 0)
+    throw new Error("invalid mnemonic");
+  const i = m(new Uint8Array(Math.ceil(11 * e.length / 8)));
+  let r = 0;
+  for (let a = 0; a < e.length; a++) {
+    let d = t.getWordIndex(e[a].normalize("NFKD"));
+    if (d === -1)
+      throw new Error("invalid mnemonic");
+    for (let u = 0; u < 11; u++)
+      d & 1 << 10 - u && (i[r >> 3] |= 1 << 7 - r % 8), r++;
+  }
+  const s = 32 * e.length / 3, o = e.length / 3, l = U(o);
+  if ((m(w(i.slice(0, s / 8)))[0] & l) !== (i[i.length - 1] & l))
+    throw new Error("invalid checksum");
+  return h(i.slice(0, s / 8));
+}
+function Z(n, t) {
+  if (t = x(t), n = m(n), n.length % 4 !== 0 || n.length < 16 || n.length > 32)
+    throw new Error("invalid entropy");
+  const e = [0];
+  let i = 11;
+  for (let o = 0; o < n.length; o++)
+    i > 8 ? (e[e.length - 1] <<= 8, e[e.length - 1] |= n[o], i -= 8) : (e[e.length - 1] <<= i, e[e.length - 1] |= n[o] >> 8 - i, e.push(n[o] & G(8 - i)), i += 3);
+  const r = n.length / 4, s = m(w(n))[0] & U(r);
+  return e[e.length - 1] <<= r, e[e.length - 1] |= s >> 8 - r, t.join(e.map((o) => t.getWord(o)));
+}
+function se(n, t) {
+  try {
+    return z(n, t), !0;
+  } catch {
+  }
+  return !1;
+}
+function ce(n) {
+  return (typeof n != "number" || n < 0 || n >= y || n % 1) && v.throwArgumentError("invalid account index", "index", n), `m/44'/60'/${n}'/0/0`;
+}
+export {
+  p as HDNode,
+  oe as defaultPath,
+  Z as entropyToMnemonic,
+  ce as getAccountPath,
+  se as isValidMnemonic,
+  z as mnemonicToEntropy,
+  V as mnemonicToSeed
+};

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

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

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/json-wallets/lib.esm/crowdsale.mjs

@@ -0,0 +1,36 @@
+import i from "../../../aes-js/index.mjs";
+import { getAddress as u } from "../../address/lib.esm/index.mjs";
+import { arrayify as d } from "../../bytes/lib.esm/index.mjs";
+import { keccak256 as A } from "../../keccak256/lib.esm/index.mjs";
+import { toUtf8Bytes as C } from "../../strings/lib.esm/utf8.mjs";
+import { Description as w } from "../../properties/lib.esm/index.mjs";
+import { Logger as k } from "../../logger/lib.esm/index.mjs";
+import { version as v } from "./_version.mjs";
+import { getPassword as x, searchPath as a, looseArrayify as b } from "./utils.mjs";
+import { pbkdf2 as O } from "../../pbkdf2/lib.esm/pbkdf2.mjs";
+const S = new k(v);
+class B extends w {
+  isCrowdsaleAccount(e) {
+    return !!(e && e._isCrowdsaleAccount);
+  }
+}
+function U(t, e) {
+  const s = JSON.parse(t);
+  e = x(e);
+  const m = u(a(s, "ethaddr")), r = b(a(s, "encseed"));
+  (!r || r.length % 16 !== 0) && S.throwArgumentError("invalid encseed", "json", t);
+  const p = d(O(e, e, 2e3, 32, "sha256")).slice(0, 16), f = r.slice(0, 16), l = r.slice(16), y = new i.ModeOfOperation.cbc(p, f), c = i.padding.pkcs7.strip(d(y.decrypt(l)));
+  let n = "";
+  for (let o = 0; o < c.length; o++)
+    n += String.fromCharCode(c[o]);
+  const g = C(n), h = A(g);
+  return new B({
+    _isCrowdsaleAccount: !0,
+    address: m,
+    privateKey: h
+  });
+}
+export {
+  B as CrowdsaleAccount,
+  U as decrypt
+};

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

@@ -0,0 +1,31 @@
+import { decrypt as i } from "./crowdsale.mjs";
+import { isCrowdsaleWallet as o, isKeystoreWallet as y } from "./inspect.mjs";
+import { getJsonWalletAddress as J } from "./inspect.mjs";
+import { decrypt as c, decryptSync as d } from "./keystore.mjs";
+import { encrypt as W } from "./keystore.mjs";
+function m(e, r, t) {
+  if (o(e)) {
+    t && t(0);
+    const n = i(e, r);
+    return t && t(1), Promise.resolve(n);
+  }
+  return y(e) ? c(e, r, t) : Promise.reject(new Error("invalid JSON wallet"));
+}
+function u(e, r) {
+  if (o(e))
+    return i(e, r);
+  if (y(e))
+    return d(e, r);
+  throw new Error("invalid JSON wallet");
+}
+export {
+  i as decryptCrowdsale,
+  m as decryptJsonWallet,
+  u as decryptJsonWalletSync,
+  c as decryptKeystore,
+  d as decryptKeystoreSync,
+  W as encryptKeystore,
+  J as getJsonWalletAddress,
+  o as isCrowdsaleWallet,
+  y as isKeystoreWallet
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/json-wallets/lib.esm/inspect.mjs

@@ -0,0 +1,39 @@
+import { getAddress as t } from "../../address/lib.esm/index.mjs";
+function a(e) {
+  let r = null;
+  try {
+    r = JSON.parse(e);
+  } catch {
+    return !1;
+  }
+  return r.encseed && r.ethaddr;
+}
+function l(e) {
+  let r = null;
+  try {
+    r = JSON.parse(e);
+  } catch {
+    return !1;
+  }
+  return !(!r.version || parseInt(r.version) !== r.version || parseInt(r.version) !== 3);
+}
+function u(e) {
+  if (a(e))
+    try {
+      return t(JSON.parse(e).ethaddr);
+    } catch {
+      return null;
+    }
+  if (l(e))
+    try {
+      return t(JSON.parse(e).address);
+    } catch {
+      return null;
+    }
+  return null;
+}
+export {
+  u as getJsonWalletAddress,
+  a as isCrowdsaleWallet,
+  l as isKeystoreWallet
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/json-wallets/lib.esm/keystore.mjs

@@ -0,0 +1,207 @@
+import w from "../../../aes-js/index.mjs";
+import T from "../../../scrypt-js/scrypt.mjs";
+import { getAddress as L } from "../../address/lib.esm/index.mjs";
+import { arrayify as y, concat as P, hexlify as v } from "../../bytes/lib.esm/index.mjs";
+import { HDNode as S, defaultPath as M, mnemonicToEntropy as W, entropyToMnemonic as X } from "../../hdnode/lib.esm/index.mjs";
+import { keccak256 as D } from "../../keccak256/lib.esm/index.mjs";
+import { Description as ee } from "../../properties/lib.esm/index.mjs";
+import { computeAddress as R } from "../../transactions/lib.esm/index.mjs";
+import { getPassword as B, uuidV4 as re, zpad as K, looseArrayify as g, searchPath as p } from "./utils.mjs";
+import { Logger as O } from "../../logger/lib.esm/index.mjs";
+import { version as te } from "./_version.mjs";
+import { randomBytes as A } from "../../random/lib.esm/random.mjs";
+import { pbkdf2 as ne } from "../../pbkdf2/lib.esm/pbkdf2.mjs";
+var oe = function(e, t, r, n) {
+  function m(u) {
+    return u instanceof r ? u : new r(function(s) {
+      s(u);
+    });
+  }
+  return new (r || (r = Promise))(function(u, s) {
+    function d(c) {
+      try {
+        o(n.next(c));
+      } catch (a) {
+        s(a);
+      }
+    }
+    function f(c) {
+      try {
+        o(n.throw(c));
+      } catch (a) {
+        s(a);
+      }
+    }
+    function o(c) {
+      c.done ? u(c.value) : m(c.value).then(d, f);
+    }
+    o((n = n.apply(e, t || [])).next());
+  });
+};
+const N = new O(te);
+function U(e) {
+  return e != null && e.mnemonic && e.mnemonic.phrase;
+}
+class ce extends ee {
+  isKeystoreAccount(t) {
+    return !!(t && t._isKeystoreAccount);
+  }
+}
+function se(e, t, r) {
+  if (p(e, "crypto/cipher") === "aes-128-ctr") {
+    const m = g(p(e, "crypto/cipherparams/iv")), u = new w.Counter(m), s = new w.ModeOfOperation.ctr(t, u);
+    return y(s.decrypt(r));
+  }
+  return null;
+}
+function F(e, t) {
+  const r = g(p(e, "crypto/ciphertext"));
+  if (v(D(P([t.slice(16, 32), r]))).substring(2) !== p(e, "crypto/mac").toLowerCase())
+    throw new Error("invalid password");
+  const m = se(e, t.slice(0, 16), r);
+  m || N.throwError("unsupported cipher", O.errors.UNSUPPORTED_OPERATION, {
+    operation: "decrypt"
+  });
+  const u = t.slice(32, 64), s = R(m);
+  if (e.address) {
+    let f = e.address.toLowerCase();
+    if (f.substring(0, 2) !== "0x" && (f = "0x" + f), L(f) !== s)
+      throw new Error("address mismatch");
+  }
+  const d = {
+    _isKeystoreAccount: !0,
+    address: s,
+    privateKey: v(m)
+  };
+  if (p(e, "x-ethers/version") === "0.1") {
+    const f = g(p(e, "x-ethers/mnemonicCiphertext")), o = g(p(e, "x-ethers/mnemonicCounter")), c = new w.Counter(o), a = new w.ModeOfOperation.ctr(u, c), l = p(e, "x-ethers/path") || M, C = p(e, "x-ethers/locale") || "en", x = y(a.decrypt(f));
+    try {
+      const h = X(x, C), i = S.fromMnemonic(h, null, C).derivePath(l);
+      if (i.privateKey != d.privateKey)
+        throw new Error("mnemonic mismatch");
+      d.mnemonic = i.mnemonic;
+    } catch (h) {
+      if (h.code !== O.errors.INVALID_ARGUMENT || h.argument !== "wordlist")
+        throw h;
+    }
+  }
+  return new ce(d);
+}
+function J(e, t, r, n, m) {
+  return y(ne(e, t, r, n, m));
+}
+function ie(e, t, r, n, m) {
+  return Promise.resolve(J(e, t, r, n, m));
+}
+function j(e, t, r, n, m) {
+  const u = B(t), s = p(e, "crypto/kdf");
+  if (s && typeof s == "string") {
+    const d = function(f, o) {
+      return N.throwArgumentError("invalid key-derivation function parameters", f, o);
+    };
+    if (s.toLowerCase() === "scrypt") {
+      const f = g(p(e, "crypto/kdfparams/salt")), o = parseInt(p(e, "crypto/kdfparams/n")), c = parseInt(p(e, "crypto/kdfparams/r")), a = parseInt(p(e, "crypto/kdfparams/p"));
+      (!o || !c || !a) && d("kdf", s), o & o - 1 && d("N", o);
+      const l = parseInt(p(e, "crypto/kdfparams/dklen"));
+      return l !== 32 && d("dklen", l), n(u, f, o, c, a, 64, m);
+    } else if (s.toLowerCase() === "pbkdf2") {
+      const f = g(p(e, "crypto/kdfparams/salt"));
+      let o = null;
+      const c = p(e, "crypto/kdfparams/prf");
+      c === "hmac-sha256" ? o = "sha256" : c === "hmac-sha512" ? o = "sha512" : d("prf", c);
+      const a = parseInt(p(e, "crypto/kdfparams/c")), l = parseInt(p(e, "crypto/kdfparams/dklen"));
+      return l !== 32 && d("dklen", l), r(u, f, a, l, o);
+    }
+  }
+  return N.throwArgumentError("unsupported key-derivation function", "kdf", s);
+}
+function ge(e, t) {
+  const r = JSON.parse(e), n = j(r, t, J, T.syncScrypt);
+  return F(r, n);
+}
+function xe(e, t, r) {
+  return oe(this, void 0, void 0, function* () {
+    const n = JSON.parse(e), m = yield j(n, t, ie, T.scrypt, r);
+    return F(n, m);
+  });
+}
+function Ke(e, t, r, n) {
+  try {
+    if (L(e.address) !== R(e.privateKey))
+      throw new Error("address/privateKey mismatch");
+    if (U(e)) {
+      const i = e.mnemonic;
+      if (S.fromMnemonic(i.phrase, null, i.locale).derivePath(i.path || M).privateKey != e.privateKey)
+        throw new Error("mnemonic mismatch");
+    }
+  } catch (i) {
+    return Promise.reject(i);
+  }
+  typeof r == "function" && !n && (n = r, r = {}), r || (r = {});
+  const m = y(e.privateKey), u = B(t);
+  let s = null, d = null, f = null;
+  if (U(e)) {
+    const i = e.mnemonic;
+    s = y(W(i.phrase, i.locale || "en")), d = i.path || M, f = i.locale || "en";
+  }
+  let o = r.client;
+  o || (o = "ethers.js");
+  let c = null;
+  r.salt ? c = y(r.salt) : c = A(32);
+  let a = null;
+  if (r.iv) {
+    if (a = y(r.iv), a.length !== 16)
+      throw new Error("invalid iv");
+  } else
+    a = A(16);
+  let l = null;
+  if (r.uuid) {
+    if (l = y(r.uuid), l.length !== 16)
+      throw new Error("invalid uuid");
+  } else
+    l = A(16);
+  let C = 1 << 17, x = 8, h = 1;
+  return r.scrypt && (r.scrypt.N && (C = r.scrypt.N), r.scrypt.r && (x = r.scrypt.r), r.scrypt.p && (h = r.scrypt.p)), T.scrypt(u, c, C, x, h, 64, n).then((i) => {
+    i = y(i);
+    const b = i.slice(0, 16), H = i.slice(16, 32), V = i.slice(32, 64), z = new w.Counter(a), G = new w.ModeOfOperation.ctr(b, z), I = y(G.encrypt(m)), Y = D(P([H, I])), E = {
+      address: e.address.substring(2).toLowerCase(),
+      id: re(l),
+      version: 3,
+      crypto: {
+        cipher: "aes-128-ctr",
+        cipherparams: {
+          iv: v(a).substring(2)
+        },
+        ciphertext: v(I).substring(2),
+        kdf: "scrypt",
+        kdfparams: {
+          salt: v(c).substring(2),
+          n: C,
+          dklen: 32,
+          p: h,
+          r: x
+        },
+        mac: Y.substring(2)
+      }
+    };
+    if (s) {
+      const _ = A(16), Z = new w.Counter(_), $ = new w.ModeOfOperation.ctr(V, Z), q = y($.encrypt(s)), k = /* @__PURE__ */ new Date(), Q = k.getUTCFullYear() + "-" + K(k.getUTCMonth() + 1, 2) + "-" + K(k.getUTCDate(), 2) + "T" + K(k.getUTCHours(), 2) + "-" + K(k.getUTCMinutes(), 2) + "-" + K(k.getUTCSeconds(), 2) + ".0Z";
+      E["x-ethers"] = {
+        client: o,
+        gethFilename: "UTC--" + Q + "--" + E.address,
+        mnemonicCounter: v(_).substring(2),
+        mnemonicCiphertext: v(q).substring(2),
+        path: d,
+        locale: f,
+        version: "0.1"
+      };
+    }
+    return JSON.stringify(E);
+  });
+}
+export {
+  ce as KeystoreAccount,
+  xe as decrypt,
+  ge as decryptSync,
+  Ke as encrypt
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/json-wallets/lib.esm/utils.mjs

@@ -0,0 +1,48 @@
+import { arrayify as s, hexlify as u } from "../../bytes/lib.esm/index.mjs";
+import { toUtf8Bytes as c, UnicodeNormalizationForm as l } from "../../strings/lib.esm/utf8.mjs";
+function b(t) {
+  return typeof t == "string" && t.substring(0, 2) !== "0x" && (t = "0x" + t), s(t);
+}
+function m(t, r) {
+  for (t = String(t); t.length < r; )
+    t = "0" + t;
+  return t;
+}
+function a(t) {
+  return typeof t == "string" ? c(t, l.NFKC) : s(t);
+}
+function p(t, r) {
+  let n = t;
+  const e = r.toLowerCase().split("/");
+  for (let i = 0; i < e.length; i++) {
+    let o = null;
+    for (const f in n)
+      if (f.toLowerCase() === e[i]) {
+        o = n[f];
+        break;
+      }
+    if (o === null)
+      return null;
+    n = o;
+  }
+  return n;
+}
+function h(t) {
+  const r = s(t);
+  r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128;
+  const n = u(r);
+  return [
+    n.substring(2, 10),
+    n.substring(10, 14),
+    n.substring(14, 18),
+    n.substring(18, 22),
+    n.substring(22, 34)
+  ].join("-");
+}
+export {
+  a as getPassword,
+  b as looseArrayify,
+  p as searchPath,
+  h as uuidV4,
+  m as zpad
+};

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

@@ -0,0 +1,8 @@
+import o from "../../../js-sha3/src/sha3.mjs";
+import { arrayify as a } from "../../bytes/lib.esm/index.mjs";
+function e(r) {
+  return "0x" + o.keccak_256(a(r));
+}
+export {
+  e as keccak256
+};

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

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