@hinkal/common 0.0.115 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/providers/lib.esm/fallback-provider.mjs

@@ -0,0 +1,341 @@
+import { Provider as I } from "../../abstract-provider/lib.esm/index.mjs";
+import { isHexString as b } from "../../bytes/lib.esm/index.mjs";
+import { shallowCopy as T, defineReadOnly as A, deepCopy as P } from "../../properties/lib.esm/index.mjs";
+import { poll as j } from "../../web/lib.esm/index.mjs";
+import { BaseProvider as q } from "./base-provider.mjs";
+import { isCommunityResource as _ } from "./formatter.mjs";
+import { Logger as g } from "../../logger/lib.esm/index.mjs";
+import { version as F } from "./_version.mjs";
+import { shuffled as L } from "../../random/lib.esm/shuffle.mjs";
+import { BigNumber as z } from "../../bignumber/lib.esm/bignumber.mjs";
+var C = function(n, i, r, e) {
+  function t(l) {
+    return l instanceof r ? l : new r(function(s) {
+      s(l);
+    });
+  }
+  return new (r || (r = Promise))(function(l, s) {
+    function d(c) {
+      try {
+        a(e.next(c));
+      } catch (m) {
+        s(m);
+      }
+    }
+    function u(c) {
+      try {
+        a(e.throw(c));
+      } catch (m) {
+        s(m);
+      }
+    }
+    function a(c) {
+      c.done ? l(c.value) : t(c.value).then(d, u);
+    }
+    a((e = e.apply(n, i || [])).next());
+  });
+};
+const p = new g(F);
+function E() {
+  return (/* @__PURE__ */ new Date()).getTime();
+}
+function O(n) {
+  let i = null;
+  for (let r = 0; r < n.length; r++) {
+    const e = n[r];
+    if (e == null)
+      return null;
+    i ? i.name === e.name && i.chainId === e.chainId && (i.ensAddress === e.ensAddress || i.ensAddress == null && e.ensAddress == null) || p.throwArgumentError("provider mismatch", "networks", n) : i = e;
+  }
+  return i;
+}
+function S(n, i) {
+  n = n.slice().sort();
+  const r = Math.floor(n.length / 2);
+  if (n.length % 2)
+    return n[r];
+  const e = n[r - 1], t = n[r];
+  return i != null && Math.abs(e - t) > i ? null : (e + t) / 2;
+}
+function k(n) {
+  if (n === null)
+    return "null";
+  if (typeof n == "number" || typeof n == "boolean")
+    return JSON.stringify(n);
+  if (typeof n == "string")
+    return n;
+  if (z.isBigNumber(n))
+    return n.toString();
+  if (Array.isArray(n))
+    return JSON.stringify(n.map((i) => k(i)));
+  if (typeof n == "object") {
+    const i = Object.keys(n);
+    return i.sort(), "{" + i.map((r) => {
+      let e = n[r];
+      return typeof e == "function" ? e = "[function]" : e = k(e), JSON.stringify(r) + ":" + e;
+    }).join(",") + "}";
+  }
+  throw new Error("unknown value type: " + typeof n);
+}
+let D = 1;
+function v(n) {
+  let i = null, r = null, e = new Promise((s) => {
+    i = function() {
+      r && (clearTimeout(r), r = null), s();
+    }, r = setTimeout(i, n);
+  });
+  const t = (s) => (e = e.then(s), e);
+  function l() {
+    return e;
+  }
+  return { cancel: i, getPromise: l, wait: t };
+}
+const M = [
+  g.errors.CALL_EXCEPTION,
+  g.errors.INSUFFICIENT_FUNDS,
+  g.errors.NONCE_EXPIRED,
+  g.errors.REPLACEMENT_UNDERPRICED,
+  g.errors.UNPREDICTABLE_GAS_LIMIT
+], G = [
+  "address",
+  "args",
+  "errorArgs",
+  "errorSignature",
+  "method",
+  "transaction"
+];
+function N(n, i) {
+  const r = {
+    weight: n.weight
+  };
+  return Object.defineProperty(r, "provider", { get: () => n.provider }), n.start && (r.start = n.start), i && (r.duration = i - n.start), n.done && (n.error ? r.error = n.error : r.result = n.result || null), r;
+}
+function U(n, i) {
+  return function(r) {
+    const e = {};
+    r.forEach((l) => {
+      const s = n(l.result);
+      e[s] || (e[s] = { count: 0, result: l.result }), e[s].count++;
+    });
+    const t = Object.keys(e);
+    for (let l = 0; l < t.length; l++) {
+      const s = e[t[l]];
+      if (s.count >= i)
+        return s.result;
+    }
+  };
+}
+function H(n, i, r) {
+  let e = k;
+  switch (i) {
+    case "getBlockNumber":
+      return function(t) {
+        const l = t.map((d) => d.result);
+        let s = S(t.map((d) => d.result), 2);
+        if (s != null)
+          return s = Math.ceil(s), l.indexOf(s + 1) >= 0 && s++, s >= n._highestBlockNumber && (n._highestBlockNumber = s), n._highestBlockNumber;
+      };
+    case "getGasPrice":
+      return function(t) {
+        const l = t.map((s) => s.result);
+        return l.sort(), l[Math.floor(l.length / 2)];
+      };
+    case "getEtherPrice":
+      return function(t) {
+        return S(t.map((l) => l.result));
+      };
+    case "getBalance":
+    case "getTransactionCount":
+    case "getCode":
+    case "getStorageAt":
+    case "call":
+    case "estimateGas":
+    case "getLogs":
+      break;
+    case "getTransaction":
+    case "getTransactionReceipt":
+      e = function(t) {
+        return t == null ? null : (t = T(t), t.confirmations = -1, k(t));
+      };
+      break;
+    case "getBlock":
+      r.includeTransactions ? e = function(t) {
+        return t == null ? null : (t = T(t), t.transactions = t.transactions.map((l) => (l = T(l), l.confirmations = -1, l)), k(t));
+      } : e = function(t) {
+        return t == null ? null : k(t);
+      };
+      break;
+    default:
+      throw new Error("unknown method: " + i);
+  }
+  return U(e, n.quorum);
+}
+function y(n, i) {
+  return C(this, void 0, void 0, function* () {
+    const r = n.provider;
+    return r.blockNumber != null && r.blockNumber >= i || i === -1 ? r : j(() => new Promise((e, t) => {
+      setTimeout(function() {
+        return r.blockNumber >= i ? e(r) : n.cancelled ? e(null) : e(void 0);
+      }, 0);
+    }), { oncePoll: r });
+  });
+}
+function J(n, i, r, e) {
+  return C(this, void 0, void 0, function* () {
+    let t = n.provider;
+    switch (r) {
+      case "getBlockNumber":
+      case "getGasPrice":
+        return t[r]();
+      case "getEtherPrice":
+        if (t.getEtherPrice)
+          return t.getEtherPrice();
+        break;
+      case "getBalance":
+      case "getTransactionCount":
+      case "getCode":
+        return e.blockTag && b(e.blockTag) && (t = yield y(n, i)), t[r](e.address, e.blockTag || "latest");
+      case "getStorageAt":
+        return e.blockTag && b(e.blockTag) && (t = yield y(n, i)), t.getStorageAt(e.address, e.position, e.blockTag || "latest");
+      case "getBlock":
+        return e.blockTag && b(e.blockTag) && (t = yield y(n, i)), t[e.includeTransactions ? "getBlockWithTransactions" : "getBlock"](e.blockTag || e.blockHash);
+      case "call":
+      case "estimateGas":
+        return e.blockTag && b(e.blockTag) && (t = yield y(n, i)), r === "call" && e.blockTag ? t[r](e.transaction, e.blockTag) : t[r](e.transaction);
+      case "getTransaction":
+      case "getTransactionReceipt":
+        return t[r](e.transactionHash);
+      case "getLogs": {
+        let l = e.filter;
+        return (l.fromBlock && b(l.fromBlock) || l.toBlock && b(l.toBlock)) && (t = yield y(n, i)), t.getLogs(l);
+      }
+    }
+    return p.throwError("unknown method error", g.errors.UNKNOWN_ERROR, {
+      method: r,
+      params: e
+    });
+  });
+}
+class te extends q {
+  constructor(i, r) {
+    i.length === 0 && p.throwArgumentError("missing providers", "providers", i);
+    const e = i.map((s, d) => {
+      if (I.isProvider(s)) {
+        const c = _(s) ? 2e3 : 750;
+        return Object.freeze({ provider: s, weight: 1, stallTimeout: c, priority: 1 });
+      }
+      const u = T(s);
+      u.priority == null && (u.priority = 1), u.stallTimeout == null && (u.stallTimeout = _(s) ? 2e3 : 750), u.weight == null && (u.weight = 1);
+      const a = u.weight;
+      return (a % 1 || a > 512 || a < 1) && p.throwArgumentError("invalid weight; must be integer in [1, 512]", `providers[${d}].weight`, a), Object.freeze(u);
+    }), t = e.reduce((s, d) => s + d.weight, 0);
+    r == null ? r = t / 2 : r > t && p.throwArgumentError("quorum will always fail; larger than total weight", "quorum", r);
+    let l = O(e.map((s) => s.provider.network));
+    l == null && (l = new Promise((s, d) => {
+      setTimeout(() => {
+        this.detectNetwork().then(s, d);
+      }, 0);
+    })), super(l), A(this, "providerConfigs", Object.freeze(e)), A(this, "quorum", r), this._highestBlockNumber = -1;
+  }
+  detectNetwork() {
+    return C(this, void 0, void 0, function* () {
+      const i = yield Promise.all(this.providerConfigs.map((r) => r.provider.getNetwork()));
+      return O(i);
+    });
+  }
+  perform(i, r) {
+    return C(this, void 0, void 0, function* () {
+      if (i === "sendTransaction") {
+        const u = yield Promise.all(this.providerConfigs.map((a) => a.provider.sendTransaction(r.signedTransaction).then((c) => c.hash, (c) => c)));
+        for (let a = 0; a < u.length; a++) {
+          const c = u[a];
+          if (typeof c == "string")
+            return c;
+        }
+        throw u[0];
+      }
+      this._highestBlockNumber === -1 && i !== "getBlockNumber" && (yield this.getBlockNumber());
+      const e = H(this, i, r), t = L(this.providerConfigs.map(T));
+      t.sort((u, a) => u.priority - a.priority);
+      const l = this._highestBlockNumber;
+      let s = 0, d = !0;
+      for (; ; ) {
+        const u = E();
+        let a = t.filter((o) => o.runner && u - o.start < o.stallTimeout).reduce((o, f) => o + f.weight, 0);
+        for (; a < this.quorum && s < t.length; ) {
+          const o = t[s++], f = D++;
+          o.start = E(), o.staller = v(o.stallTimeout), o.staller.wait(() => {
+            o.staller = null;
+          }), o.runner = J(o, l, i, r).then((h) => {
+            o.done = !0, o.result = h, this.listenerCount("debug") && this.emit("debug", {
+              action: "request",
+              rid: f,
+              backend: N(o, E()),
+              request: { method: i, params: P(r) },
+              provider: this
+            });
+          }, (h) => {
+            o.done = !0, o.error = h, this.listenerCount("debug") && this.emit("debug", {
+              action: "request",
+              rid: f,
+              backend: N(o, E()),
+              request: { method: i, params: P(r) },
+              provider: this
+            });
+          }), this.listenerCount("debug") && this.emit("debug", {
+            action: "request",
+            rid: f,
+            backend: N(o, null),
+            request: { method: i, params: P(r) },
+            provider: this
+          }), a += o.weight;
+        }
+        const c = [];
+        t.forEach((o) => {
+          o.done || !o.runner || (c.push(o.runner), o.staller && c.push(o.staller.getPromise()));
+        }), c.length && (yield Promise.race(c));
+        const m = t.filter((o) => o.done && o.error == null);
+        if (m.length >= this.quorum) {
+          const o = e(m);
+          if (o !== void 0)
+            return t.forEach((f) => {
+              f.staller && f.staller.cancel(), f.cancelled = !0;
+            }), o;
+          d || (yield v(100).getPromise()), d = !1;
+        }
+        const B = t.reduce((o, f) => {
+          if (!f.done || f.error == null)
+            return o;
+          const h = f.error.code;
+          return M.indexOf(h) >= 0 && (o[h] || (o[h] = { error: f.error, weight: 0 }), o[h].weight += f.weight), o;
+        }, {});
+        if (Object.keys(B).forEach((o) => {
+          const f = B[o];
+          if (f.weight < this.quorum)
+            return;
+          t.forEach((w) => {
+            w.staller && w.staller.cancel(), w.cancelled = !0;
+          });
+          const h = f.error, R = {};
+          G.forEach((w) => {
+            h[w] != null && (R[w] = h[w]);
+          }), p.throwError(h.reason || h.message, o, R);
+        }), t.filter((o) => !o.done).length === 0)
+          break;
+      }
+      return t.forEach((u) => {
+        u.staller && u.staller.cancel(), u.cancelled = !0;
+      }), p.throwError("failed to meet quorum", g.errors.SERVER_ERROR, {
+        method: i,
+        params: r,
+        //results: configs.map((c) => c.result),
+        //errors: configs.map((c) => c.error),
+        results: t.map((u) => N(u)),
+        provider: this
+      });
+    });
+  }
+}
+export {
+  te as FallbackProvider
+};

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

@@ -0,0 +1,302 @@
+import { getAddress as w, getContractAddress as N } from "../../address/lib.esm/index.mjs";
+import { isHexString as a, hexDataSlice as y, hexValue as m, hexDataLength as k, hexZeroPad as x } from "../../bytes/lib.esm/index.mjs";
+import { shallowCopy as L } from "../../properties/lib.esm/index.mjs";
+import { accessListify as A, parse as I } from "../../transactions/lib.esm/index.mjs";
+import { Logger as P } from "../../logger/lib.esm/index.mjs";
+import { version as E } from "./_version.mjs";
+import { BigNumber as u } from "../../bignumber/lib.esm/bignumber.mjs";
+import { AddressZero as H } from "../../constants/lib.esm/addresses.mjs";
+const h = new P(E);
+class t {
+  constructor() {
+    this.formats = this.getDefaultFormats();
+  }
+  getDefaultFormats() {
+    const l = {}, e = this.address.bind(this), s = this.bigNumber.bind(this), n = this.blockTag.bind(this), r = this.data.bind(this), o = this.hash.bind(this), f = this.hex.bind(this), i = this.number.bind(this), d = this.type.bind(this), b = (p) => this.data(p, !0);
+    return l.transaction = {
+      hash: o,
+      type: d,
+      accessList: t.allowNull(this.accessList.bind(this), null),
+      blockHash: t.allowNull(o, null),
+      blockNumber: t.allowNull(i, null),
+      transactionIndex: t.allowNull(i, null),
+      confirmations: t.allowNull(i, null),
+      from: e,
+      // either (gasPrice) or (maxPriorityFeePerGas + maxFeePerGas)
+      // must be set
+      gasPrice: t.allowNull(s),
+      maxPriorityFeePerGas: t.allowNull(s),
+      maxFeePerGas: t.allowNull(s),
+      gasLimit: s,
+      to: t.allowNull(e, null),
+      value: s,
+      nonce: i,
+      data: r,
+      r: t.allowNull(this.uint256),
+      s: t.allowNull(this.uint256),
+      v: t.allowNull(i),
+      creates: t.allowNull(e, null),
+      raw: t.allowNull(r)
+    }, l.transactionRequest = {
+      from: t.allowNull(e),
+      nonce: t.allowNull(i),
+      gasLimit: t.allowNull(s),
+      gasPrice: t.allowNull(s),
+      maxPriorityFeePerGas: t.allowNull(s),
+      maxFeePerGas: t.allowNull(s),
+      to: t.allowNull(e),
+      value: t.allowNull(s),
+      data: t.allowNull(b),
+      type: t.allowNull(i),
+      accessList: t.allowNull(this.accessList.bind(this), null)
+    }, l.receiptLog = {
+      transactionIndex: i,
+      blockNumber: i,
+      transactionHash: o,
+      address: e,
+      topics: t.arrayOf(o),
+      data: r,
+      logIndex: i,
+      blockHash: o
+    }, l.receipt = {
+      to: t.allowNull(this.address, null),
+      from: t.allowNull(this.address, null),
+      contractAddress: t.allowNull(e, null),
+      transactionIndex: i,
+      // should be allowNull(hash), but broken-EIP-658 support is handled in receipt
+      root: t.allowNull(f),
+      gasUsed: s,
+      logsBloom: t.allowNull(r),
+      blockHash: o,
+      transactionHash: o,
+      logs: t.arrayOf(this.receiptLog.bind(this)),
+      blockNumber: i,
+      confirmations: t.allowNull(i, null),
+      cumulativeGasUsed: s,
+      effectiveGasPrice: t.allowNull(s),
+      status: t.allowNull(i),
+      type: d
+    }, l.block = {
+      hash: t.allowNull(o),
+      parentHash: o,
+      number: i,
+      timestamp: i,
+      nonce: t.allowNull(f),
+      difficulty: this.difficulty.bind(this),
+      gasLimit: s,
+      gasUsed: s,
+      miner: t.allowNull(e),
+      extraData: r,
+      transactions: t.allowNull(t.arrayOf(o)),
+      baseFeePerGas: t.allowNull(s)
+    }, l.blockWithTransactions = L(l.block), l.blockWithTransactions.transactions = t.allowNull(t.arrayOf(this.transactionResponse.bind(this))), l.filter = {
+      fromBlock: t.allowNull(n, void 0),
+      toBlock: t.allowNull(n, void 0),
+      blockHash: t.allowNull(o, void 0),
+      address: t.allowNull(e, void 0),
+      topics: t.allowNull(this.topics.bind(this), void 0)
+    }, l.filterLog = {
+      blockNumber: t.allowNull(i),
+      blockHash: t.allowNull(o),
+      transactionIndex: i,
+      removed: t.allowNull(this.boolean.bind(this)),
+      address: e,
+      data: t.allowFalsish(r, "0x"),
+      topics: t.arrayOf(o),
+      transactionHash: o,
+      logIndex: i
+    }, l;
+  }
+  accessList(l) {
+    return A(l || []);
+  }
+  // Requires a BigNumberish that is within the IEEE754 safe integer range; returns a number
+  // Strict! Used on input.
+  number(l) {
+    return l === "0x" ? 0 : u.from(l).toNumber();
+  }
+  type(l) {
+    return l === "0x" || l == null ? 0 : u.from(l).toNumber();
+  }
+  // Strict! Used on input.
+  bigNumber(l) {
+    return u.from(l);
+  }
+  // Requires a boolean, "true" or  "false"; returns a boolean
+  boolean(l) {
+    if (typeof l == "boolean")
+      return l;
+    if (typeof l == "string") {
+      if (l = l.toLowerCase(), l === "true")
+        return !0;
+      if (l === "false")
+        return !1;
+    }
+    throw new Error("invalid boolean - " + l);
+  }
+  hex(l, e) {
+    return typeof l == "string" && (!e && l.substring(0, 2) !== "0x" && (l = "0x" + l), a(l)) ? l.toLowerCase() : h.throwArgumentError("invalid hash", "value", l);
+  }
+  data(l, e) {
+    const s = this.hex(l, e);
+    if (s.length % 2 !== 0)
+      throw new Error("invalid data; odd-length - " + l);
+    return s;
+  }
+  // Requires an address
+  // Strict! Used on input.
+  address(l) {
+    return w(l);
+  }
+  callAddress(l) {
+    if (!a(l, 32))
+      return null;
+    const e = w(y(l, 12));
+    return e === H ? null : e;
+  }
+  contractAddress(l) {
+    return N(l);
+  }
+  // Strict! Used on input.
+  blockTag(l) {
+    if (l == null)
+      return "latest";
+    if (l === "earliest")
+      return "0x0";
+    switch (l) {
+      case "earliest":
+        return "0x0";
+      case "latest":
+      case "pending":
+      case "safe":
+      case "finalized":
+        return l;
+    }
+    if (typeof l == "number" || a(l))
+      return m(l);
+    throw new Error("invalid blockTag");
+  }
+  // Requires a hash, optionally requires 0x prefix; returns prefixed lowercase hash.
+  hash(l, e) {
+    const s = this.hex(l, e);
+    return k(s) !== 32 ? h.throwArgumentError("invalid hash", "value", l) : s;
+  }
+  // Returns the difficulty as a number, or if too large (i.e. PoA network) null
+  difficulty(l) {
+    if (l == null)
+      return null;
+    const e = u.from(l);
+    try {
+      return e.toNumber();
+    } catch {
+    }
+    return null;
+  }
+  uint256(l) {
+    if (!a(l))
+      throw new Error("invalid uint256");
+    return x(l, 32);
+  }
+  _block(l, e) {
+    l.author != null && l.miner == null && (l.miner = l.author);
+    const s = l._difficulty != null ? l._difficulty : l.difficulty, n = t.check(e, l);
+    return n._difficulty = s == null ? null : u.from(s), n;
+  }
+  block(l) {
+    return this._block(l, this.formats.block);
+  }
+  blockWithTransactions(l) {
+    return this._block(l, this.formats.blockWithTransactions);
+  }
+  // Strict! Used on input.
+  transactionRequest(l) {
+    return t.check(this.formats.transactionRequest, l);
+  }
+  transactionResponse(l) {
+    l.gas != null && l.gasLimit == null && (l.gasLimit = l.gas), l.to && u.from(l.to).isZero() && (l.to = "0x0000000000000000000000000000000000000000"), l.input != null && l.data == null && (l.data = l.input), l.to == null && l.creates == null && (l.creates = this.contractAddress(l)), (l.type === 1 || l.type === 2) && l.accessList == null && (l.accessList = []);
+    const e = t.check(this.formats.transaction, l);
+    if (l.chainId != null) {
+      let s = l.chainId;
+      a(s) && (s = u.from(s).toNumber()), e.chainId = s;
+    } else {
+      let s = l.networkId;
+      s == null && e.v == null && (s = l.chainId), a(s) && (s = u.from(s).toNumber()), typeof s != "number" && e.v != null && (s = (e.v - 35) / 2, s < 0 && (s = 0), s = parseInt(s)), typeof s != "number" && (s = 0), e.chainId = s;
+    }
+    return e.blockHash && e.blockHash.replace(/0/g, "") === "x" && (e.blockHash = null), e;
+  }
+  transaction(l) {
+    return I(l);
+  }
+  receiptLog(l) {
+    return t.check(this.formats.receiptLog, l);
+  }
+  receipt(l) {
+    const e = t.check(this.formats.receipt, l);
+    if (e.root != null)
+      if (e.root.length <= 4) {
+        const s = u.from(e.root).toNumber();
+        s === 0 || s === 1 ? (e.status != null && e.status !== s && h.throwArgumentError("alt-root-status/status mismatch", "value", { root: e.root, status: e.status }), e.status = s, delete e.root) : h.throwArgumentError("invalid alt-root-status", "value.root", e.root);
+      } else
+        e.root.length !== 66 && h.throwArgumentError("invalid root hash", "value.root", e.root);
+    return e.status != null && (e.byzantium = !0), e;
+  }
+  topics(l) {
+    return Array.isArray(l) ? l.map((e) => this.topics(e)) : l != null ? this.hash(l, !0) : null;
+  }
+  filter(l) {
+    return t.check(this.formats.filter, l);
+  }
+  filterLog(l) {
+    return t.check(this.formats.filterLog, l);
+  }
+  static check(l, e) {
+    const s = {};
+    for (const n in l)
+      try {
+        const r = l[n](e[n]);
+        r !== void 0 && (s[n] = r);
+      } catch (r) {
+        throw r.checkKey = n, r.checkValue = e[n], r;
+      }
+    return s;
+  }
+  // if value is null-ish, nullValue is returned
+  static allowNull(l, e) {
+    return function(s) {
+      return s == null ? e : l(s);
+    };
+  }
+  // If value is false-ish, replaceValue is returned
+  static allowFalsish(l, e) {
+    return function(s) {
+      return s ? l(s) : e;
+    };
+  }
+  // Requires an Array satisfying check
+  static arrayOf(l) {
+    return function(e) {
+      if (!Array.isArray(e))
+        throw new Error("not an array");
+      const s = [];
+      return e.forEach(function(n) {
+        s.push(l(n));
+      }), s;
+    };
+  }
+}
+function R(c) {
+  return c && typeof c.isCommunityResource == "function";
+}
+function U(c) {
+  return R(c) && c.isCommunityResource();
+}
+let g = !1;
+function Z() {
+  g || (g = !0, console.log("========= NOTICE ========="), console.log("Request-Rate Exceeded  (this message will not be repeated)"), console.log(""), console.log("The default API keys for each service are provided as a highly-throttled,"), console.log("community resource for low-traffic projects and early prototyping."), console.log(""), console.log("While your application will continue to function, we highly recommended"), console.log("signing up for your own API keys to improve performance, increase your"), console.log("request rate/limit and enable other perks, such as metrics and advanced APIs."), console.log(""), console.log("For more details: https://docs.ethers.io/api-keys/"), console.log("=========================="));
+}
+export {
+  t as Formatter,
+  R as isCommunityResourcable,
+  U as isCommunityResource,
+  Z as showThrottleMessage
+};