@hinkal/common 0.0.116 → 0.0.118

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

@@ -0,0 +1,535 @@
+import { Interface as A, Indexed as F } from "../../abi/lib.esm/interface.mjs";
+import { Provider as j } from "../../abstract-provider/lib.esm/index.mjs";
+import { Signer as N, VoidSigner as q } from "../../abstract-signer/lib.esm/index.mjs";
+import { getAddress as T, getContractAddress as O } from "../../address/lib.esm/index.mjs";
+import { isHexString as U, isBytes as z, hexlify as b, concat as H, arrayify as $ } from "../../bytes/lib.esm/index.mjs";
+import { defineReadOnly as l, getStatic as _, shallowCopy as E, deepCopy as D, resolveProperties as P } from "../../properties/lib.esm/index.mjs";
+import { accessListify as J } from "../../transactions/lib.esm/index.mjs";
+import { Logger as h } from "../../logger/lib.esm/index.mjs";
+import { version as M } from "./_version.mjs";
+import { BigNumber as p } from "../../bignumber/lib.esm/bignumber.mjs";
+import { checkResultErrors as V } from "../../abi/lib.esm/coders/abstract-coder.mjs";
+var g = function(s, e, t, r) {
+  function n(c) {
+    return c instanceof t ? c : new t(function(i) {
+      i(c);
+    });
+  }
+  return new (t || (t = Promise))(function(c, i) {
+    function o(f) {
+      try {
+        d(r.next(f));
+      } catch (v) {
+        i(v);
+      }
+    }
+    function a(f) {
+      try {
+        d(r.throw(f));
+      } catch (v) {
+        i(v);
+      }
+    }
+    function d(f) {
+      f.done ? c(f.value) : n(f.value).then(o, a);
+    }
+    d((r = r.apply(s, e || [])).next());
+  });
+};
+const u = new h(M), W = {
+  chainId: !0,
+  data: !0,
+  from: !0,
+  gasLimit: !0,
+  gasPrice: !0,
+  nonce: !0,
+  to: !0,
+  value: !0,
+  type: !0,
+  accessList: !0,
+  maxFeePerGas: !0,
+  maxPriorityFeePerGas: !0,
+  customData: !0,
+  ccipReadEnabled: !0
+};
+function w(s, e) {
+  return g(this, void 0, void 0, function* () {
+    const t = yield e;
+    typeof t != "string" && u.throwArgumentError("invalid address or ENS name", "name", t);
+    try {
+      return T(t);
+    } catch {
+    }
+    s || u.throwError("a provider or signer is needed to resolve ENS names", h.errors.UNSUPPORTED_OPERATION, {
+      operation: "resolveName"
+    });
+    const r = yield s.resolveName(t);
+    return r == null && u.throwArgumentError("resolver or addr is not configured for ENS name", "name", t), r;
+  });
+}
+function m(s, e, t) {
+  return g(this, void 0, void 0, function* () {
+    return Array.isArray(t) ? yield Promise.all(t.map((r, n) => m(s, Array.isArray(e) ? e[n] : e[r.name], r))) : t.type === "address" ? yield w(s, e) : t.type === "tuple" ? yield m(s, e, t.components) : t.baseType === "array" ? Array.isArray(e) ? yield Promise.all(e.map((r) => m(s, r, t.arrayChildren))) : Promise.reject(u.makeError("invalid value for array", h.errors.INVALID_ARGUMENT, {
+      argument: "value",
+      value: e
+    })) : e;
+  });
+}
+function R(s, e, t) {
+  return g(this, void 0, void 0, function* () {
+    let r = {};
+    t.length === e.inputs.length + 1 && typeof t[t.length - 1] == "object" && (r = E(t.pop())), u.checkArgumentCount(t.length, e.inputs.length, "passed to contract"), s.signer ? r.from ? r.from = P({
+      override: w(s.signer, r.from),
+      signer: s.signer.getAddress()
+    }).then((d) => g(this, void 0, void 0, function* () {
+      return T(d.signer) !== d.override && u.throwError("Contract with a Signer cannot override from", h.errors.UNSUPPORTED_OPERATION, {
+        operation: "overrides.from"
+      }), d.override;
+    })) : r.from = s.signer.getAddress() : r.from && (r.from = w(s.provider, r.from));
+    const n = yield P({
+      args: m(s.signer || s.provider, t, e.inputs),
+      address: s.resolvedAddress,
+      overrides: P(r) || {}
+    }), c = s.interface.encodeFunctionData(e, n.args), i = {
+      data: c,
+      to: n.address
+    }, o = n.overrides;
+    if (o.nonce != null && (i.nonce = p.from(o.nonce).toNumber()), o.gasLimit != null && (i.gasLimit = p.from(o.gasLimit)), o.gasPrice != null && (i.gasPrice = p.from(o.gasPrice)), o.maxFeePerGas != null && (i.maxFeePerGas = p.from(o.maxFeePerGas)), o.maxPriorityFeePerGas != null && (i.maxPriorityFeePerGas = p.from(o.maxPriorityFeePerGas)), o.from != null && (i.from = o.from), o.type != null && (i.type = o.type), o.accessList != null && (i.accessList = J(o.accessList)), i.gasLimit == null && e.gas != null) {
+      let d = 21e3;
+      const f = $(c);
+      for (let v = 0; v < f.length; v++)
+        d += 4, f[v] && (d += 64);
+      i.gasLimit = p.from(e.gas).add(d);
+    }
+    if (o.value) {
+      const d = p.from(o.value);
+      !d.isZero() && !e.payable && u.throwError("non-payable method cannot override value", h.errors.UNSUPPORTED_OPERATION, {
+        operation: "overrides.value",
+        value: r.value
+      }), i.value = d;
+    }
+    o.customData && (i.customData = E(o.customData)), o.ccipReadEnabled && (i.ccipReadEnabled = !!o.ccipReadEnabled), delete r.nonce, delete r.gasLimit, delete r.gasPrice, delete r.from, delete r.value, delete r.type, delete r.accessList, delete r.maxFeePerGas, delete r.maxPriorityFeePerGas, delete r.customData, delete r.ccipReadEnabled;
+    const a = Object.keys(r).filter((d) => r[d] != null);
+    return a.length && u.throwError(`cannot override ${a.map((d) => JSON.stringify(d)).join(",")}`, h.errors.UNSUPPORTED_OPERATION, {
+      operation: "overrides",
+      overrides: a
+    }), i;
+  });
+}
+function Z(s, e) {
+  return function(...t) {
+    return R(s, e, t);
+  };
+}
+function B(s, e) {
+  const t = s.signer || s.provider;
+  return function(...r) {
+    return g(this, void 0, void 0, function* () {
+      t || u.throwError("estimate require a provider or signer", h.errors.UNSUPPORTED_OPERATION, {
+        operation: "estimateGas"
+      });
+      const n = yield R(s, e, r);
+      return yield t.estimateGas(n);
+    });
+  };
+}
+function I(s, e) {
+  const t = e.wait.bind(e);
+  e.wait = (r) => t(r).then((n) => (n.events = n.logs.map((c) => {
+    let i = D(c), o = null;
+    try {
+      o = s.interface.parseLog(c);
+    } catch {
+    }
+    return o && (i.args = o.args, i.decode = (a, d) => s.interface.decodeEventLog(o.eventFragment, a, d), i.event = o.name, i.eventSignature = o.signature), i.removeListener = () => s.provider, i.getBlock = () => s.provider.getBlock(n.blockHash), i.getTransaction = () => s.provider.getTransaction(n.transactionHash), i.getTransactionReceipt = () => Promise.resolve(n), i;
+  }), n));
+}
+function G(s, e, t) {
+  const r = s.signer || s.provider;
+  return function(...n) {
+    return g(this, void 0, void 0, function* () {
+      let c;
+      if (n.length === e.inputs.length + 1 && typeof n[n.length - 1] == "object") {
+        const a = E(n.pop());
+        a.blockTag != null && (c = yield a.blockTag), delete a.blockTag, n.push(a);
+      }
+      s.deployTransaction != null && (yield s._deployed(c));
+      const i = yield R(s, e, n), o = yield r.call(i, c);
+      try {
+        let a = s.interface.decodeFunctionResult(e, o);
+        return t && e.outputs.length === 1 && (a = a[0]), a;
+      } catch (a) {
+        throw a.code === h.errors.CALL_EXCEPTION && (a.address = s.address, a.args = n, a.transaction = i), a;
+      }
+    });
+  };
+}
+function K(s, e) {
+  return function(...t) {
+    return g(this, void 0, void 0, function* () {
+      s.signer || u.throwError("sending a transaction requires a signer", h.errors.UNSUPPORTED_OPERATION, {
+        operation: "sendTransaction"
+      }), s.deployTransaction != null && (yield s._deployed());
+      const r = yield R(s, e, t), n = yield s.signer.sendTransaction(r);
+      return I(s, n), n;
+    });
+  };
+}
+function S(s, e, t) {
+  return e.constant ? G(s, e, t) : K(s, e);
+}
+function k(s) {
+  return s.address && (s.topics == null || s.topics.length === 0) ? "*" : (s.address || "*") + "@" + (s.topics ? s.topics.map((e) => Array.isArray(e) ? e.join("|") : e).join(":") : "");
+}
+class y {
+  constructor(e, t) {
+    l(this, "tag", e), l(this, "filter", t), this._listeners = [];
+  }
+  addListener(e, t) {
+    this._listeners.push({ listener: e, once: t });
+  }
+  removeListener(e) {
+    let t = !1;
+    this._listeners = this._listeners.filter((r) => t || r.listener !== e ? !0 : (t = !0, !1));
+  }
+  removeAllListeners() {
+    this._listeners = [];
+  }
+  listeners() {
+    return this._listeners.map((e) => e.listener);
+  }
+  listenerCount() {
+    return this._listeners.length;
+  }
+  run(e) {
+    const t = this.listenerCount();
+    return this._listeners = this._listeners.filter((r) => {
+      const n = e.slice();
+      return setTimeout(() => {
+        r.listener.apply(this, n);
+      }, 0), !r.once;
+    }), t;
+  }
+  prepareEvent(e) {
+  }
+  // Returns the array that will be applied to an emit
+  getEmit(e) {
+    return [e];
+  }
+}
+class X extends y {
+  constructor() {
+    super("error", null);
+  }
+}
+class L extends y {
+  constructor(e, t, r, n) {
+    const c = {
+      address: e
+    };
+    let i = t.getEventTopic(r);
+    n ? (i !== n[0] && u.throwArgumentError("topic mismatch", "topics", n), c.topics = n.slice()) : c.topics = [i], super(k(c), c), l(this, "address", e), l(this, "interface", t), l(this, "fragment", r);
+  }
+  prepareEvent(e) {
+    super.prepareEvent(e), e.event = this.fragment.name, e.eventSignature = this.fragment.format(), e.decode = (t, r) => this.interface.decodeEventLog(this.fragment, t, r);
+    try {
+      e.args = this.interface.decodeEventLog(this.fragment, e.data, e.topics);
+    } catch (t) {
+      e.args = null, e.decodeError = t;
+    }
+  }
+  getEmit(e) {
+    const t = V(e.args);
+    if (t.length)
+      throw t[0].error;
+    const r = (e.args || []).slice();
+    return r.push(e), r;
+  }
+}
+class x extends y {
+  constructor(e, t) {
+    super("*", { address: e }), l(this, "address", e), l(this, "interface", t);
+  }
+  prepareEvent(e) {
+    super.prepareEvent(e);
+    try {
+      const t = this.interface.parseLog(e);
+      e.event = t.name, e.eventSignature = t.signature, e.decode = (r, n) => this.interface.decodeEventLog(t.eventFragment, r, n), e.args = t.args;
+    } catch {
+    }
+  }
+}
+class Q {
+  constructor(e, t, r) {
+    l(this, "interface", _(new.target, "getInterface")(t)), r == null ? (l(this, "provider", null), l(this, "signer", null)) : N.isSigner(r) ? (l(this, "provider", r.provider || null), l(this, "signer", r)) : j.isProvider(r) ? (l(this, "provider", r), l(this, "signer", null)) : u.throwArgumentError("invalid signer or provider", "signerOrProvider", r), l(this, "callStatic", {}), l(this, "estimateGas", {}), l(this, "functions", {}), l(this, "populateTransaction", {}), l(this, "filters", {});
+    {
+      const i = {};
+      Object.keys(this.interface.events).forEach((o) => {
+        const a = this.interface.events[o];
+        l(this.filters, o, (...d) => ({
+          address: this.address,
+          topics: this.interface.encodeFilterTopics(a, d)
+        })), i[a.name] || (i[a.name] = []), i[a.name].push(o);
+      }), Object.keys(i).forEach((o) => {
+        const a = i[o];
+        a.length === 1 ? l(this.filters, o, this.filters[a[0]]) : u.warn(`Duplicate definition of ${o} (${a.join(", ")})`);
+      });
+    }
+    if (l(this, "_runningEvents", {}), l(this, "_wrappedEmits", {}), e == null && u.throwArgumentError("invalid contract address or ENS name", "addressOrName", e), l(this, "address", e), this.provider)
+      l(this, "resolvedAddress", w(this.provider, e));
+    else
+      try {
+        l(this, "resolvedAddress", Promise.resolve(T(e)));
+      } catch {
+        u.throwError("provider is required to use ENS name as contract address", h.errors.UNSUPPORTED_OPERATION, {
+          operation: "new Contract"
+        });
+      }
+    this.resolvedAddress.catch((i) => {
+    });
+    const n = {}, c = {};
+    Object.keys(this.interface.functions).forEach((i) => {
+      const o = this.interface.functions[i];
+      if (c[i]) {
+        u.warn(`Duplicate ABI entry for ${JSON.stringify(i)}`);
+        return;
+      }
+      c[i] = !0;
+      {
+        const a = o.name;
+        n[`%${a}`] || (n[`%${a}`] = []), n[`%${a}`].push(i);
+      }
+      this[i] == null && l(this, i, S(this, o, !0)), this.functions[i] == null && l(this.functions, i, S(this, o, !1)), this.callStatic[i] == null && l(this.callStatic, i, G(this, o, !0)), this.populateTransaction[i] == null && l(this.populateTransaction, i, Z(this, o)), this.estimateGas[i] == null && l(this.estimateGas, i, B(this, o));
+    }), Object.keys(n).forEach((i) => {
+      const o = n[i];
+      if (o.length > 1)
+        return;
+      i = i.substring(1);
+      const a = o[0];
+      try {
+        this[i] == null && l(this, i, this[a]);
+      } catch {
+      }
+      this.functions[i] == null && l(this.functions, i, this.functions[a]), this.callStatic[i] == null && l(this.callStatic, i, this.callStatic[a]), this.populateTransaction[i] == null && l(this.populateTransaction, i, this.populateTransaction[a]), this.estimateGas[i] == null && l(this.estimateGas, i, this.estimateGas[a]);
+    });
+  }
+  static getContractAddress(e) {
+    return O(e);
+  }
+  static getInterface(e) {
+    return A.isInterface(e) ? e : new A(e);
+  }
+  // @TODO: Allow timeout?
+  deployed() {
+    return this._deployed();
+  }
+  _deployed(e) {
+    return this._deployedPromise || (this.deployTransaction ? this._deployedPromise = this.deployTransaction.wait().then(() => this) : this._deployedPromise = this.provider.getCode(this.address, e).then((t) => (t === "0x" && u.throwError("contract not deployed", h.errors.UNSUPPORTED_OPERATION, {
+      contractAddress: this.address,
+      operation: "getDeployed"
+    }), this))), this._deployedPromise;
+  }
+  // @TODO:
+  // estimateFallback(overrides?: TransactionRequest): Promise<BigNumber>
+  // @TODO:
+  // estimateDeploy(bytecode: string, ...args): Promise<BigNumber>
+  fallback(e) {
+    this.signer || u.throwError("sending a transactions require a signer", h.errors.UNSUPPORTED_OPERATION, { operation: "sendTransaction(fallback)" });
+    const t = E(e || {});
+    return ["from", "to"].forEach(function(r) {
+      t[r] != null && u.throwError("cannot override " + r, h.errors.UNSUPPORTED_OPERATION, { operation: r });
+    }), t.to = this.resolvedAddress, this.deployed().then(() => this.signer.sendTransaction(t));
+  }
+  // Reconnect to a different signer or provider
+  connect(e) {
+    typeof e == "string" && (e = new q(e, this.provider));
+    const t = new this.constructor(this.address, this.interface, e);
+    return this.deployTransaction && l(t, "deployTransaction", this.deployTransaction), t;
+  }
+  // Re-attach to a different on-chain instance of this contract
+  attach(e) {
+    return new this.constructor(e, this.interface, this.signer || this.provider);
+  }
+  static isIndexed(e) {
+    return F.isIndexed(e);
+  }
+  _normalizeRunningEvent(e) {
+    return this._runningEvents[e.tag] ? this._runningEvents[e.tag] : e;
+  }
+  _getRunningEvent(e) {
+    if (typeof e == "string") {
+      if (e === "error")
+        return this._normalizeRunningEvent(new X());
+      if (e === "event")
+        return this._normalizeRunningEvent(new y("event", null));
+      if (e === "*")
+        return this._normalizeRunningEvent(new x(this.address, this.interface));
+      const t = this.interface.getEvent(e);
+      return this._normalizeRunningEvent(new L(this.address, this.interface, t));
+    }
+    if (e.topics && e.topics.length > 0) {
+      try {
+        const r = e.topics[0];
+        if (typeof r != "string")
+          throw new Error("invalid topic");
+        const n = this.interface.getEvent(r);
+        return this._normalizeRunningEvent(new L(this.address, this.interface, n, e.topics));
+      } catch {
+      }
+      const t = {
+        address: this.address,
+        topics: e.topics
+      };
+      return this._normalizeRunningEvent(new y(k(t), t));
+    }
+    return this._normalizeRunningEvent(new x(this.address, this.interface));
+  }
+  _checkRunningEvents(e) {
+    if (e.listenerCount() === 0) {
+      delete this._runningEvents[e.tag];
+      const t = this._wrappedEmits[e.tag];
+      t && e.filter && (this.provider.off(e.filter, t), delete this._wrappedEmits[e.tag]);
+    }
+  }
+  // Subclasses can override this to gracefully recover
+  // from parse errors if they wish
+  _wrapEvent(e, t, r) {
+    const n = D(t);
+    return n.removeListener = () => {
+      r && (e.removeListener(r), this._checkRunningEvents(e));
+    }, n.getBlock = () => this.provider.getBlock(t.blockHash), n.getTransaction = () => this.provider.getTransaction(t.transactionHash), n.getTransactionReceipt = () => this.provider.getTransactionReceipt(t.transactionHash), e.prepareEvent(n), n;
+  }
+  _addEventListener(e, t, r) {
+    if (this.provider || u.throwError("events require a provider or a signer with a provider", h.errors.UNSUPPORTED_OPERATION, { operation: "once" }), e.addListener(t, r), this._runningEvents[e.tag] = e, !this._wrappedEmits[e.tag]) {
+      const n = (c) => {
+        let i = this._wrapEvent(e, c, t);
+        if (i.decodeError == null)
+          try {
+            const o = e.getEmit(i);
+            this.emit(e.filter, ...o);
+          } catch (o) {
+            i.decodeError = o.error;
+          }
+        e.filter != null && this.emit("event", i), i.decodeError != null && this.emit("error", i.decodeError, i);
+      };
+      this._wrappedEmits[e.tag] = n, e.filter != null && this.provider.on(e.filter, n);
+    }
+  }
+  queryFilter(e, t, r) {
+    const n = this._getRunningEvent(e), c = E(n.filter);
+    return typeof t == "string" && U(t, 32) ? (r != null && u.throwArgumentError("cannot specify toBlock with blockhash", "toBlock", r), c.blockHash = t) : (c.fromBlock = t ?? 0, c.toBlock = r ?? "latest"), this.provider.getLogs(c).then((i) => i.map((o) => this._wrapEvent(n, o, null)));
+  }
+  on(e, t) {
+    return this._addEventListener(this._getRunningEvent(e), t, !1), this;
+  }
+  once(e, t) {
+    return this._addEventListener(this._getRunningEvent(e), t, !0), this;
+  }
+  emit(e, ...t) {
+    if (!this.provider)
+      return !1;
+    const r = this._getRunningEvent(e), n = r.run(t) > 0;
+    return this._checkRunningEvents(r), n;
+  }
+  listenerCount(e) {
+    return this.provider ? e == null ? Object.keys(this._runningEvents).reduce((t, r) => t + this._runningEvents[r].listenerCount(), 0) : this._getRunningEvent(e).listenerCount() : 0;
+  }
+  listeners(e) {
+    if (!this.provider)
+      return [];
+    if (e == null) {
+      const t = [];
+      for (let r in this._runningEvents)
+        this._runningEvents[r].listeners().forEach((n) => {
+          t.push(n);
+        });
+      return t;
+    }
+    return this._getRunningEvent(e).listeners();
+  }
+  removeAllListeners(e) {
+    if (!this.provider)
+      return this;
+    if (e == null) {
+      for (const r in this._runningEvents) {
+        const n = this._runningEvents[r];
+        n.removeAllListeners(), this._checkRunningEvents(n);
+      }
+      return this;
+    }
+    const t = this._getRunningEvent(e);
+    return t.removeAllListeners(), this._checkRunningEvents(t), this;
+  }
+  off(e, t) {
+    if (!this.provider)
+      return this;
+    const r = this._getRunningEvent(e);
+    return r.removeListener(t), this._checkRunningEvents(r), this;
+  }
+  removeListener(e, t) {
+    return this.off(e, t);
+  }
+}
+class C extends Q {
+}
+class ue {
+  constructor(e, t, r) {
+    let n = null;
+    typeof t == "string" ? n = t : z(t) ? n = b(t) : t && typeof t.object == "string" ? n = t.object : n = "!", n.substring(0, 2) !== "0x" && (n = "0x" + n), (!U(n) || n.length % 2) && u.throwArgumentError("invalid bytecode", "bytecode", t), r && !N.isSigner(r) && u.throwArgumentError("invalid signer", "signer", r), l(this, "bytecode", n), l(this, "interface", _(new.target, "getInterface")(e)), l(this, "signer", r || null);
+  }
+  // @TODO: Future; rename to populateTransaction?
+  getDeployTransaction(...e) {
+    let t = {};
+    if (e.length === this.interface.deploy.inputs.length + 1 && typeof e[e.length - 1] == "object") {
+      t = E(e.pop());
+      for (const r in t)
+        if (!W[r])
+          throw new Error("unknown transaction override " + r);
+    }
+    return ["data", "from", "to"].forEach((r) => {
+      t[r] != null && u.throwError("cannot override " + r, h.errors.UNSUPPORTED_OPERATION, { operation: r });
+    }), t.value && !p.from(t.value).isZero() && !this.interface.deploy.payable && u.throwError("non-payable constructor cannot override value", h.errors.UNSUPPORTED_OPERATION, {
+      operation: "overrides.value",
+      value: t.value
+    }), u.checkArgumentCount(e.length, this.interface.deploy.inputs.length, " in Contract constructor"), t.data = b(H([
+      this.bytecode,
+      this.interface.encodeDeploy(e)
+    ])), t;
+  }
+  deploy(...e) {
+    return g(this, void 0, void 0, function* () {
+      let t = {};
+      e.length === this.interface.deploy.inputs.length + 1 && (t = e.pop()), u.checkArgumentCount(e.length, this.interface.deploy.inputs.length, " in Contract constructor");
+      const r = yield m(this.signer, e, this.interface.deploy.inputs);
+      r.push(t);
+      const n = this.getDeployTransaction(...r), c = yield this.signer.sendTransaction(n), i = _(this.constructor, "getContractAddress")(c), o = _(this.constructor, "getContract")(i, this.interface, this.signer);
+      return I(o, c), l(o, "deployTransaction", c), o;
+    });
+  }
+  attach(e) {
+    return this.constructor.getContract(e, this.interface, this.signer);
+  }
+  connect(e) {
+    return new this.constructor(this.interface, this.bytecode, e);
+  }
+  static fromSolidity(e, t) {
+    e == null && u.throwError("missing compiler output", h.errors.MISSING_ARGUMENT, { argument: "compilerOutput" }), typeof e == "string" && (e = JSON.parse(e));
+    const r = e.abi;
+    let n = null;
+    return e.bytecode ? n = e.bytecode : e.evm && e.evm.bytecode && (n = e.evm.bytecode), new this(r, n, t);
+  }
+  static getInterface(e) {
+    return C.getInterface(e);
+  }
+  static getContractAddress(e) {
+    return O(e);
+  }
+  static getContract(e, t, r) {
+    return new C(e, t, r);
+  }
+}
+export {
+  Q as BaseContract,
+  C as Contract,
+  ue as ContractFactory
+};

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

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