@hinkal/common 0.0.115 → 0.0.117

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

@@ -0,0 +1,1240 @@
+import { Provider as ot, ForkEvent as lt } from "../../abstract-provider/lib.esm/index.mjs";
+import { Base58 as M } from "../../basex/lib.esm/index.mjs";
+import { hexConcat as R, arrayify as $, concat as A, hexZeroPad as F, hexlify as x, hexValue as at, hexDataLength as W, hexDataSlice as v, isHexString as L } from "../../bytes/lib.esm/index.mjs";
+import { namehash as U, dnsEncode as ut } from "../../hash/lib.esm/namehash.mjs";
+import { getNetwork as ct } from "../../networks/lib.esm/index.mjs";
+import { defineReadOnly as w, getStatic as ht, resolveProperties as E } from "../../properties/lib.esm/index.mjs";
+import { sha256 as j } from "../../sha2/lib.esm/sha2.mjs";
+import { toUtf8Bytes as dt, toUtf8String as et } from "../../strings/lib.esm/utf8.mjs";
+import { fetchJson as rt, poll as S } from "../../web/lib.esm/index.mjs";
+import G from "../../../bech32/index.mjs";
+import { Logger as h } from "../../logger/lib.esm/index.mjs";
+import { version as ft } from "./_version.mjs";
+import { Formatter as H } from "./formatter.mjs";
+import { BigNumber as k } from "../../bignumber/lib.esm/bignumber.mjs";
+import { HashZero as mt } from "../../constants/lib.esm/hashes.mjs";
+import { encode as pt } from "../../base64/lib.esm/base64.mjs";
+var a = function(o, t, e, r) {
+  function i(n) {
+    return n instanceof e ? n : new e(function(s) {
+      s(n);
+    });
+  }
+  return new (e || (e = Promise))(function(n, s) {
+    function l(m) {
+      try {
+        d(r.next(m));
+      } catch (g) {
+        s(g);
+      }
+    }
+    function c(m) {
+      try {
+        d(r.throw(m));
+      } catch (g) {
+        s(g);
+      }
+    }
+    function d(m) {
+      m.done ? n(m.value) : i(m.value).then(l, c);
+    }
+    d((r = r.apply(o, t || [])).next());
+  });
+};
+const u = new h(ft), gt = 10;
+function J(o) {
+  return o == null ? "null" : (W(o) !== 32 && u.throwArgumentError("invalid topic", "topic", o), o.toLowerCase());
+}
+function K(o) {
+  for (o = o.slice(); o.length > 0 && o[o.length - 1] == null; )
+    o.pop();
+  return o.map((t) => {
+    if (Array.isArray(t)) {
+      const e = {};
+      t.forEach((i) => {
+        e[J(i)] = !0;
+      });
+      const r = Object.keys(e);
+      return r.sort(), r.join("|");
+    } else
+      return J(t);
+  }).join("&");
+}
+function _t(o) {
+  return o === "" ? [] : o.split(/&/g).map((t) => {
+    if (t === "")
+      return [];
+    const e = t.split("|").map((r) => r === "null" ? null : r);
+    return e.length === 1 ? e[0] : e;
+  });
+}
+function T(o) {
+  if (typeof o == "string") {
+    if (o = o.toLowerCase(), W(o) === 32)
+      return "tx:" + o;
+    if (o.indexOf(":") === -1)
+      return o;
+  } else {
+    if (Array.isArray(o))
+      return "filter:*:" + K(o);
+    if (lt.isForkEvent(o))
+      throw u.warn("not implemented"), new Error("not implemented");
+    if (o && typeof o == "object")
+      return "filter:" + (o.address || "*") + ":" + K(o.topics || []);
+  }
+  throw new Error("invalid event - " + o);
+}
+function I() {
+  return (/* @__PURE__ */ new Date()).getTime();
+}
+function Q(o) {
+  return new Promise((t) => {
+    setTimeout(t, o);
+  });
+}
+const kt = ["block", "network", "pending", "poll"];
+class bt {
+  constructor(t, e, r) {
+    w(this, "tag", t), w(this, "listener", e), w(this, "once", r), this._lastBlockNumber = -2, this._inflight = !1;
+  }
+  get event() {
+    switch (this.type) {
+      case "tx":
+        return this.hash;
+      case "filter":
+        return this.filter;
+    }
+    return this.tag;
+  }
+  get type() {
+    return this.tag.split(":")[0];
+  }
+  get hash() {
+    const t = this.tag.split(":");
+    return t[0] !== "tx" ? null : t[1];
+  }
+  get filter() {
+    const t = this.tag.split(":");
+    if (t[0] !== "filter")
+      return null;
+    const e = t[1], r = _t(t[2]), i = {};
+    return r.length > 0 && (i.topics = r), e && e !== "*" && (i.address = e), i;
+  }
+  pollable() {
+    return this.tag.indexOf(":") >= 0 || kt.indexOf(this.tag) >= 0;
+  }
+}
+const yt = {
+  0: { symbol: "btc", p2pkh: 0, p2sh: 5, prefix: "bc" },
+  2: { symbol: "ltc", p2pkh: 48, p2sh: 50, prefix: "ltc" },
+  3: { symbol: "doge", p2pkh: 30, p2sh: 22 },
+  60: { symbol: "eth", ilk: "eth" },
+  61: { symbol: "etc", ilk: "eth" },
+  700: { symbol: "xdai", ilk: "eth" }
+};
+function V(o) {
+  return F(k.from(o).toHexString(), 32);
+}
+function Z(o) {
+  return M.encode(A([o, v(j(j(o)), 0, 4)]));
+}
+const it = new RegExp("^(ipfs)://(.*)$", "i"), z = [
+  new RegExp("^(https)://(.*)$", "i"),
+  new RegExp("^(data):(.*)$", "i"),
+  it,
+  new RegExp("^eip155:[0-9]+/(erc[0-9]+):(.*)$", "i")
+];
+function D(o, t) {
+  try {
+    return et(O(o, t));
+  } catch {
+  }
+  return null;
+}
+function O(o, t) {
+  if (o === "0x")
+    return null;
+  const e = k.from(v(o, t, t + 32)).toNumber(), r = k.from(v(o, e, e + 32)).toNumber();
+  return v(o, e + 32, e + 32 + r);
+}
+function X(o) {
+  return o.match(/^ipfs:\/\/ipfs\//i) ? o = o.substring(12) : o.match(/^ipfs:\/\//i) ? o = o.substring(7) : u.throwArgumentError("unsupported IPFS format", "link", o), `https://gateway.ipfs.io/ipfs/${o}`;
+}
+function Y(o) {
+  const t = $(o);
+  if (t.length > 32)
+    throw new Error("internal; should not happen");
+  const e = new Uint8Array(32);
+  return e.set(t, 32 - t.length), e;
+}
+function vt(o) {
+  if (o.length % 32 === 0)
+    return o;
+  const t = new Uint8Array(Math.ceil(o.length / 32) * 32);
+  return t.set(o), t;
+}
+function nt(o) {
+  const t = [];
+  let e = 0;
+  for (let r = 0; r < o.length; r++)
+    t.push(null), e += 32;
+  for (let r = 0; r < o.length; r++) {
+    const i = $(o[r]);
+    t[r] = Y(e), t.push(Y(i.length)), t.push(vt(i)), e += 32 + Math.ceil(i.length / 32) * 32;
+  }
+  return R(t);
+}
+class tt {
+  // The resolvedAddress is only for creating a ReverseLookup resolver
+  constructor(t, e, r, i) {
+    w(this, "provider", t), w(this, "name", r), w(this, "address", t.formatter.address(e)), w(this, "_resolvedAddress", i);
+  }
+  supportsWildcard() {
+    return this._supportsEip2544 || (this._supportsEip2544 = this.provider.call({
+      to: this.address,
+      data: "0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000"
+    }).then((t) => k.from(t).eq(1)).catch((t) => {
+      if (t.code === h.errors.CALL_EXCEPTION)
+        return !1;
+      throw this._supportsEip2544 = null, t;
+    })), this._supportsEip2544;
+  }
+  _fetch(t, e) {
+    return a(this, void 0, void 0, function* () {
+      const r = {
+        to: this.address,
+        ccipReadEnabled: !0,
+        data: R([t, U(this.name), e || "0x"])
+      };
+      let i = !1;
+      (yield this.supportsWildcard()) && (i = !0, r.data = R(["0x9061b923", nt([ut(this.name), r.data])]));
+      try {
+        let n = yield this.provider.call(r);
+        return $(n).length % 32 === 4 && u.throwError("resolver threw error", h.errors.CALL_EXCEPTION, {
+          transaction: r,
+          data: n
+        }), i && (n = O(n, 0)), n;
+      } catch (n) {
+        if (n.code === h.errors.CALL_EXCEPTION)
+          return null;
+        throw n;
+      }
+    });
+  }
+  _fetchBytes(t, e) {
+    return a(this, void 0, void 0, function* () {
+      const r = yield this._fetch(t, e);
+      return r != null ? O(r, 0) : null;
+    });
+  }
+  _getAddress(t, e) {
+    const r = yt[String(t)];
+    if (r == null && u.throwError(`unsupported coin type: ${t}`, h.errors.UNSUPPORTED_OPERATION, {
+      operation: `getAddress(${t})`
+    }), r.ilk === "eth")
+      return this.provider.formatter.address(e);
+    const i = $(e);
+    if (r.p2pkh != null) {
+      const n = e.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);
+      if (n) {
+        const s = parseInt(n[1], 16);
+        if (n[2].length === s * 2 && s >= 1 && s <= 75)
+          return Z(A([[r.p2pkh], "0x" + n[2]]));
+      }
+    }
+    if (r.p2sh != null) {
+      const n = e.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/);
+      if (n) {
+        const s = parseInt(n[1], 16);
+        if (n[2].length === s * 2 && s >= 1 && s <= 75)
+          return Z(A([[r.p2sh], "0x" + n[2]]));
+      }
+    }
+    if (r.prefix != null) {
+      const n = i[1];
+      let s = i[0];
+      if (s === 0 ? n !== 20 && n !== 32 && (s = -1) : s = -1, s >= 0 && i.length === 2 + n && n >= 1 && n <= 75) {
+        const l = G.toWords(i.slice(2));
+        return l.unshift(s), G.encode(r.prefix, l);
+      }
+    }
+    return null;
+  }
+  getAddress(t) {
+    return a(this, void 0, void 0, function* () {
+      if (t == null && (t = 60), t === 60)
+        try {
+          const i = yield this._fetch("0x3b3b57de");
+          return i === "0x" || i === mt ? null : this.provider.formatter.callAddress(i);
+        } catch (i) {
+          if (i.code === h.errors.CALL_EXCEPTION)
+            return null;
+          throw i;
+        }
+      const e = yield this._fetchBytes("0xf1cb7e06", V(t));
+      if (e == null || e === "0x")
+        return null;
+      const r = this._getAddress(t, e);
+      return r == null && u.throwError("invalid or unsupported coin data", h.errors.UNSUPPORTED_OPERATION, {
+        operation: `getAddress(${t})`,
+        coinType: t,
+        data: e
+      }), r;
+    });
+  }
+  getAvatar() {
+    return a(this, void 0, void 0, function* () {
+      const t = [{ type: "name", content: this.name }];
+      try {
+        const e = yield this.getText("avatar");
+        if (e == null)
+          return null;
+        for (let r = 0; r < z.length; r++) {
+          const i = e.match(z[r]);
+          if (i == null)
+            continue;
+          const n = i[1].toLowerCase();
+          switch (n) {
+            case "https":
+              return t.push({ type: "url", content: e }), { linkage: t, url: e };
+            case "data":
+              return t.push({ type: "data", content: e }), { linkage: t, url: e };
+            case "ipfs":
+              return t.push({ type: "ipfs", content: e }), { linkage: t, url: X(e) };
+            case "erc721":
+            case "erc1155": {
+              const s = n === "erc721" ? "0xc87b56dd" : "0x0e89341c";
+              t.push({ type: n, content: e });
+              const l = this._resolvedAddress || (yield this.getAddress()), c = (i[2] || "").split("/");
+              if (c.length !== 2)
+                return null;
+              const d = yield this.provider.formatter.address(c[0]), m = F(k.from(c[1]).toHexString(), 32);
+              if (n === "erc721") {
+                const b = this.provider.formatter.callAddress(yield this.provider.call({
+                  to: d,
+                  data: R(["0x6352211e", m])
+                }));
+                if (l !== b)
+                  return null;
+                t.push({ type: "owner", content: b });
+              } else if (n === "erc1155") {
+                const b = k.from(yield this.provider.call({
+                  to: d,
+                  data: R(["0x00fdd58e", F(l, 32), m])
+                }));
+                if (b.isZero())
+                  return null;
+                t.push({ type: "balance", content: b.toString() });
+              }
+              const g = {
+                to: this.provider.formatter.address(c[0]),
+                data: R([s, m])
+              };
+              let f = D(yield this.provider.call(g), 0);
+              if (f == null)
+                return null;
+              t.push({ type: "metadata-url-base", content: f }), n === "erc1155" && (f = f.replace("{id}", m.substring(2)), t.push({ type: "metadata-url-expanded", content: f })), f.match(/^ipfs:/i) && (f = X(f)), t.push({ type: "metadata-url", content: f });
+              const _ = yield rt(f);
+              if (!_)
+                return null;
+              t.push({ type: "metadata", content: JSON.stringify(_) });
+              let p = _.image;
+              if (typeof p != "string")
+                return null;
+              if (!p.match(/^(https:\/\/|data:)/i)) {
+                if (p.match(it) == null)
+                  return null;
+                t.push({ type: "url-ipfs", content: p }), p = X(p);
+              }
+              return t.push({ type: "url", content: p }), { linkage: t, url: p };
+            }
+          }
+        }
+      } catch {
+      }
+      return null;
+    });
+  }
+  getContentHash() {
+    return a(this, void 0, void 0, function* () {
+      const t = yield this._fetchBytes("0xbc1c58d1");
+      if (t == null || t === "0x")
+        return null;
+      const e = t.match(/^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
+      if (e) {
+        const s = parseInt(e[3], 16);
+        if (e[4].length === s * 2)
+          return "ipfs://" + M.encode("0x" + e[1]);
+      }
+      const r = t.match(/^0xe5010172(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
+      if (r) {
+        const s = parseInt(r[3], 16);
+        if (r[4].length === s * 2)
+          return "ipns://" + M.encode("0x" + r[1]);
+      }
+      const i = t.match(/^0xe40101fa011b20([0-9a-f]*)$/);
+      if (i && i[1].length === 32 * 2)
+        return "bzz://" + i[1];
+      const n = t.match(/^0x90b2c605([0-9a-f]*)$/);
+      if (n && n[1].length === 34 * 2) {
+        const s = { "=": "", "+": "-", "/": "_" };
+        return "sia://" + pt("0x" + n[1]).replace(/[=+\/]/g, (c) => s[c]);
+      }
+      return u.throwError("invalid or unsupported content hash data", h.errors.UNSUPPORTED_OPERATION, {
+        operation: "getContentHash()",
+        data: t
+      });
+    });
+  }
+  getText(t) {
+    return a(this, void 0, void 0, function* () {
+      let e = dt(t);
+      e = A([V(64), V(e.length), e]), e.length % 32 !== 0 && (e = A([e, F("0x", 32 - t.length % 32)]));
+      const r = yield this._fetchBytes("0x59d1d43c", x(e));
+      return r == null || r === "0x" ? null : et(r);
+    });
+  }
+}
+let q = null, Et = 1;
+class $t extends ot {
+  /**
+   *  ready
+   *
+   *  A Promise<Network> that resolves only once the provider is ready.
+   *
+   *  Sub-classes that call the super with a network without a chainId
+   *  MUST set this. Standard named networks have a known chainId.
+   *
+   */
+  constructor(t) {
+    if (super(), this._events = [], this._emitted = { block: -2 }, this.disableCcipRead = !1, this.formatter = new.target.getFormatter(), w(this, "anyNetwork", t === "any"), this.anyNetwork && (t = this.detectNetwork()), t instanceof Promise)
+      this._networkPromise = t, t.catch((e) => {
+      }), this._ready().catch((e) => {
+      });
+    else {
+      const e = ht(new.target, "getNetwork")(t);
+      e ? (w(this, "_network", e), this.emit("network", e, null)) : u.throwArgumentError("invalid network", "network", t);
+    }
+    this._maxInternalBlockNumber = -1024, this._lastBlockNumber = -2, this._maxFilterBlockRange = 10, this._pollingInterval = 4e3, this._fastQueryDate = 0;
+  }
+  _ready() {
+    return a(this, void 0, void 0, function* () {
+      if (this._network == null) {
+        let t = null;
+        if (this._networkPromise)
+          try {
+            t = yield this._networkPromise;
+          } catch {
+          }
+        t == null && (t = yield this.detectNetwork()), t || u.throwError("no network detected", h.errors.UNKNOWN_ERROR, {}), this._network == null && (this.anyNetwork ? this._network = t : w(this, "_network", t), this.emit("network", t, null));
+      }
+      return this._network;
+    });
+  }
+  // This will always return the most recently established network.
+  // For "any", this can change (a "network" event is emitted before
+  // any change is reflected); otherwise this cannot change
+  get ready() {
+    return S(() => this._ready().then((t) => t, (t) => {
+      if (!(t.code === h.errors.NETWORK_ERROR && t.event === "noNetwork"))
+        throw t;
+    }));
+  }
+  // @TODO: Remove this and just create a singleton formatter
+  static getFormatter() {
+    return q == null && (q = new H()), q;
+  }
+  // @TODO: Remove this and just use getNetwork
+  static getNetwork(t) {
+    return ct(t ?? "homestead");
+  }
+  ccipReadFetch(t, e, r) {
+    return a(this, void 0, void 0, function* () {
+      if (this.disableCcipRead || r.length === 0)
+        return null;
+      const i = t.to.toLowerCase(), n = e.toLowerCase(), s = [];
+      for (let l = 0; l < r.length; l++) {
+        const c = r[l], d = c.replace("{sender}", i).replace("{data}", n), m = c.indexOf("{data}") >= 0 ? null : JSON.stringify({ data: n, sender: i }), g = yield rt({ url: d, errorPassThrough: !0 }, m, (_, p) => (_.status = p.statusCode, _));
+        if (g.data)
+          return g.data;
+        const f = g.message || "unknown error";
+        if (g.status >= 400 && g.status < 500)
+          return u.throwError(`response not found during CCIP fetch: ${f}`, h.errors.SERVER_ERROR, { url: c, errorMessage: f });
+        s.push(f);
+      }
+      return u.throwError(`error encountered during CCIP fetch: ${s.map((l) => JSON.stringify(l)).join(", ")}`, h.errors.SERVER_ERROR, {
+        urls: r,
+        errorMessages: s
+      });
+    });
+  }
+  // Fetches the blockNumber, but will reuse any result that is less
+  // than maxAge old or has been requested since the last request
+  _getInternalBlockNumber(t) {
+    return a(this, void 0, void 0, function* () {
+      if (yield this._ready(), t > 0)
+        for (; this._internalBlockNumber; ) {
+          const i = this._internalBlockNumber;
+          try {
+            const n = yield i;
+            if (I() - n.respTime <= t)
+              return n.blockNumber;
+            break;
+          } catch {
+            if (this._internalBlockNumber === i)
+              break;
+          }
+        }
+      const e = I(), r = E({
+        blockNumber: this.perform("getBlockNumber", {}),
+        networkError: this.getNetwork().then((i) => null, (i) => i)
+      }).then(({ blockNumber: i, networkError: n }) => {
+        if (n)
+          throw this._internalBlockNumber === r && (this._internalBlockNumber = null), n;
+        const s = I();
+        return i = k.from(i).toNumber(), i < this._maxInternalBlockNumber && (i = this._maxInternalBlockNumber), this._maxInternalBlockNumber = i, this._setFastBlockNumber(i), { blockNumber: i, reqTime: e, respTime: s };
+      });
+      return this._internalBlockNumber = r, r.catch((i) => {
+        this._internalBlockNumber === r && (this._internalBlockNumber = null);
+      }), (yield r).blockNumber;
+    });
+  }
+  poll() {
+    return a(this, void 0, void 0, function* () {
+      const t = Et++, e = [];
+      let r = null;
+      try {
+        r = yield this._getInternalBlockNumber(100 + this.pollingInterval / 2);
+      } catch (i) {
+        this.emit("error", i);
+        return;
+      }
+      if (this._setFastBlockNumber(r), this.emit("poll", t, r), r === this._lastBlockNumber) {
+        this.emit("didPoll", t);
+        return;
+      }
+      if (this._emitted.block === -2 && (this._emitted.block = r - 1), Math.abs(this._emitted.block - r) > 1e3)
+        u.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${r})`), this.emit("error", u.makeError("network block skew detected", h.errors.NETWORK_ERROR, {
+          blockNumber: r,
+          event: "blockSkew",
+          previousBlockNumber: this._emitted.block
+        })), this.emit("block", r);
+      else
+        for (let i = this._emitted.block + 1; i <= r; i++)
+          this.emit("block", i);
+      this._emitted.block !== r && (this._emitted.block = r, Object.keys(this._emitted).forEach((i) => {
+        if (i === "block")
+          return;
+        const n = this._emitted[i];
+        n !== "pending" && r - n > 12 && delete this._emitted[i];
+      })), this._lastBlockNumber === -2 && (this._lastBlockNumber = r - 1), this._events.forEach((i) => {
+        switch (i.type) {
+          case "tx": {
+            const n = i.hash;
+            let s = this.getTransactionReceipt(n).then((l) => (!l || l.blockNumber == null || (this._emitted["t:" + n] = l.blockNumber, this.emit(n, l)), null)).catch((l) => {
+              this.emit("error", l);
+            });
+            e.push(s);
+            break;
+          }
+          case "filter": {
+            if (!i._inflight) {
+              i._inflight = !0, i._lastBlockNumber === -2 && (i._lastBlockNumber = r - 1);
+              const n = i.filter;
+              n.fromBlock = i._lastBlockNumber + 1, n.toBlock = r;
+              const s = n.toBlock - this._maxFilterBlockRange;
+              s > n.fromBlock && (n.fromBlock = s), n.fromBlock < 0 && (n.fromBlock = 0);
+              const l = this.getLogs(n).then((c) => {
+                i._inflight = !1, c.length !== 0 && c.forEach((d) => {
+                  d.blockNumber > i._lastBlockNumber && (i._lastBlockNumber = d.blockNumber), this._emitted["b:" + d.blockHash] = d.blockNumber, this._emitted["t:" + d.transactionHash] = d.blockNumber, this.emit(n, d);
+                });
+              }).catch((c) => {
+                this.emit("error", c), i._inflight = !1;
+              });
+              e.push(l);
+            }
+            break;
+          }
+        }
+      }), this._lastBlockNumber = r, Promise.all(e).then(() => {
+        this.emit("didPoll", t);
+      }).catch((i) => {
+        this.emit("error", i);
+      });
+    });
+  }
+  // Deprecated; do not use this
+  resetEventsBlock(t) {
+    this._lastBlockNumber = t - 1, this.polling && this.poll();
+  }
+  get network() {
+    return this._network;
+  }
+  // This method should query the network if the underlying network
+  // can change, such as when connected to a JSON-RPC backend
+  detectNetwork() {
+    return a(this, void 0, void 0, function* () {
+      return u.throwError("provider does not support network detection", h.errors.UNSUPPORTED_OPERATION, {
+        operation: "provider.detectNetwork"
+      });
+    });
+  }
+  getNetwork() {
+    return a(this, void 0, void 0, function* () {
+      const t = yield this._ready(), e = yield this.detectNetwork();
+      if (t.chainId !== e.chainId) {
+        if (this.anyNetwork)
+          return this._network = e, this._lastBlockNumber = -2, this._fastBlockNumber = null, this._fastBlockNumberPromise = null, this._fastQueryDate = 0, this._emitted.block = -2, this._maxInternalBlockNumber = -1024, this._internalBlockNumber = null, this.emit("network", e, t), yield Q(0), this._network;
+        const r = u.makeError("underlying network changed", h.errors.NETWORK_ERROR, {
+          event: "changed",
+          network: t,
+          detectedNetwork: e
+        });
+        throw this.emit("error", r), r;
+      }
+      return t;
+    });
+  }
+  get blockNumber() {
+    return this._getInternalBlockNumber(100 + this.pollingInterval / 2).then((t) => {
+      this._setFastBlockNumber(t);
+    }, (t) => {
+    }), this._fastBlockNumber != null ? this._fastBlockNumber : -1;
+  }
+  get polling() {
+    return this._poller != null;
+  }
+  set polling(t) {
+    t && !this._poller ? (this._poller = setInterval(() => {
+      this.poll();
+    }, this.pollingInterval), this._bootstrapPoll || (this._bootstrapPoll = setTimeout(() => {
+      this.poll(), this._bootstrapPoll = setTimeout(() => {
+        this._poller || this.poll(), this._bootstrapPoll = null;
+      }, this.pollingInterval);
+    }, 0))) : !t && this._poller && (clearInterval(this._poller), this._poller = null);
+  }
+  get pollingInterval() {
+    return this._pollingInterval;
+  }
+  set pollingInterval(t) {
+    if (typeof t != "number" || t <= 0 || parseInt(String(t)) != t)
+      throw new Error("invalid polling interval");
+    this._pollingInterval = t, this._poller && (clearInterval(this._poller), this._poller = setInterval(() => {
+      this.poll();
+    }, this._pollingInterval));
+  }
+  _getFastBlockNumber() {
+    const t = I();
+    return t - this._fastQueryDate > 2 * this._pollingInterval && (this._fastQueryDate = t, this._fastBlockNumberPromise = this.getBlockNumber().then((e) => ((this._fastBlockNumber == null || e > this._fastBlockNumber) && (this._fastBlockNumber = e), this._fastBlockNumber))), this._fastBlockNumberPromise;
+  }
+  _setFastBlockNumber(t) {
+    this._fastBlockNumber != null && t < this._fastBlockNumber || (this._fastQueryDate = I(), (this._fastBlockNumber == null || t > this._fastBlockNumber) && (this._fastBlockNumber = t, this._fastBlockNumberPromise = Promise.resolve(t)));
+  }
+  waitForTransaction(t, e, r) {
+    return a(this, void 0, void 0, function* () {
+      return this._waitForTransaction(t, e ?? 1, r || 0, null);
+    });
+  }
+  _waitForTransaction(t, e, r, i) {
+    return a(this, void 0, void 0, function* () {
+      const n = yield this.getTransactionReceipt(t);
+      return (n ? n.confirmations : 0) >= e ? n : new Promise((s, l) => {
+        const c = [];
+        let d = !1;
+        const m = function() {
+          return d ? !0 : (d = !0, c.forEach((f) => {
+            f();
+          }), !1);
+        }, g = (f) => {
+          f.confirmations < e || m() || s(f);
+        };
+        if (this.on(t, g), c.push(() => {
+          this.removeListener(t, g);
+        }), i) {
+          let f = i.startBlock, _ = null;
+          const p = (b) => a(this, void 0, void 0, function* () {
+            d || (yield Q(1e3), this.getTransactionCount(i.from).then((C) => a(this, void 0, void 0, function* () {
+              if (!d) {
+                if (C <= i.nonce)
+                  f = b;
+                else {
+                  {
+                    const N = yield this.getTransaction(t);
+                    if (N && N.blockNumber != null)
+                      return;
+                  }
+                  for (_ == null && (_ = f - 3, _ < i.startBlock && (_ = i.startBlock)); _ <= b; ) {
+                    if (d)
+                      return;
+                    const N = yield this.getBlockWithTransactions(_);
+                    for (let B = 0; B < N.transactions.length; B++) {
+                      const y = N.transactions[B];
+                      if (y.hash === t)
+                        return;
+                      if (y.from === i.from && y.nonce === i.nonce) {
+                        if (d)
+                          return;
+                        const st = yield this.waitForTransaction(y.hash, e);
+                        if (m())
+                          return;
+                        let P = "replaced";
+                        y.data === i.data && y.to === i.to && y.value.eq(i.value) ? P = "repriced" : y.data === "0x" && y.from === y.to && y.value.isZero() && (P = "cancelled"), l(u.makeError("transaction was replaced", h.errors.TRANSACTION_REPLACED, {
+                          cancelled: P === "replaced" || P === "cancelled",
+                          reason: P,
+                          replacement: this._wrapTransaction(y),
+                          hash: t,
+                          receipt: st
+                        }));
+                        return;
+                      }
+                    }
+                    _++;
+                  }
+                }
+                d || this.once("block", p);
+              }
+            }), (C) => {
+              d || this.once("block", p);
+            }));
+          });
+          if (d)
+            return;
+          this.once("block", p), c.push(() => {
+            this.removeListener("block", p);
+          });
+        }
+        if (typeof r == "number" && r > 0) {
+          const f = setTimeout(() => {
+            m() || l(u.makeError("timeout exceeded", h.errors.TIMEOUT, { timeout: r }));
+          }, r);
+          f.unref && f.unref(), c.push(() => {
+            clearTimeout(f);
+          });
+        }
+      });
+    });
+  }
+  getBlockNumber() {
+    return a(this, void 0, void 0, function* () {
+      return this._getInternalBlockNumber(0);
+    });
+  }
+  getGasPrice() {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const t = yield this.perform("getGasPrice", {});
+      try {
+        return k.from(t);
+      } catch (e) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "getGasPrice",
+          result: t,
+          error: e
+        });
+      }
+    });
+  }
+  getBalance(t, e) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const r = yield E({
+        address: this._getAddress(t),
+        blockTag: this._getBlockTag(e)
+      }), i = yield this.perform("getBalance", r);
+      try {
+        return k.from(i);
+      } catch (n) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "getBalance",
+          params: r,
+          result: i,
+          error: n
+        });
+      }
+    });
+  }
+  getTransactionCount(t, e) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const r = yield E({
+        address: this._getAddress(t),
+        blockTag: this._getBlockTag(e)
+      }), i = yield this.perform("getTransactionCount", r);
+      try {
+        return k.from(i).toNumber();
+      } catch (n) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "getTransactionCount",
+          params: r,
+          result: i,
+          error: n
+        });
+      }
+    });
+  }
+  getCode(t, e) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const r = yield E({
+        address: this._getAddress(t),
+        blockTag: this._getBlockTag(e)
+      }), i = yield this.perform("getCode", r);
+      try {
+        return x(i);
+      } catch (n) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "getCode",
+          params: r,
+          result: i,
+          error: n
+        });
+      }
+    });
+  }
+  getStorageAt(t, e, r) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const i = yield E({
+        address: this._getAddress(t),
+        blockTag: this._getBlockTag(r),
+        position: Promise.resolve(e).then((s) => at(s))
+      }), n = yield this.perform("getStorageAt", i);
+      try {
+        return x(n);
+      } catch (s) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "getStorageAt",
+          params: i,
+          result: n,
+          error: s
+        });
+      }
+    });
+  }
+  // This should be called by any subclass wrapping a TransactionResponse
+  _wrapTransaction(t, e, r) {
+    if (e != null && W(e) !== 32)
+      throw new Error("invalid response - sendTransaction");
+    const i = t;
+    return e != null && t.hash !== e && u.throwError("Transaction hash mismatch from Provider.sendTransaction.", h.errors.UNKNOWN_ERROR, { expectedHash: t.hash, returnedHash: e }), i.wait = (n, s) => a(this, void 0, void 0, function* () {
+      n == null && (n = 1), s == null && (s = 0);
+      let l;
+      n !== 0 && r != null && (l = {
+        data: t.data,
+        from: t.from,
+        nonce: t.nonce,
+        to: t.to,
+        value: t.value,
+        startBlock: r
+      });
+      const c = yield this._waitForTransaction(t.hash, n, s, l);
+      return c == null && n === 0 ? null : (this._emitted["t:" + t.hash] = c.blockNumber, c.status === 0 && u.throwError("transaction failed", h.errors.CALL_EXCEPTION, {
+        transactionHash: t.hash,
+        transaction: t,
+        receipt: c
+      }), c);
+    }), i;
+  }
+  sendTransaction(t) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const e = yield Promise.resolve(t).then((n) => x(n)), r = this.formatter.transaction(t);
+      r.confirmations == null && (r.confirmations = 0);
+      const i = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
+      try {
+        const n = yield this.perform("sendTransaction", { signedTransaction: e });
+        return this._wrapTransaction(r, n, i);
+      } catch (n) {
+        throw n.transaction = r, n.transactionHash = r.hash, n;
+      }
+    });
+  }
+  _getTransactionRequest(t) {
+    return a(this, void 0, void 0, function* () {
+      const e = yield t, r = {};
+      return ["from", "to"].forEach((i) => {
+        e[i] != null && (r[i] = Promise.resolve(e[i]).then((n) => n ? this._getAddress(n) : null));
+      }), ["gasLimit", "gasPrice", "maxFeePerGas", "maxPriorityFeePerGas", "value"].forEach((i) => {
+        e[i] != null && (r[i] = Promise.resolve(e[i]).then((n) => n ? k.from(n) : null));
+      }), ["type"].forEach((i) => {
+        e[i] != null && (r[i] = Promise.resolve(e[i]).then((n) => n ?? null));
+      }), e.accessList && (r.accessList = this.formatter.accessList(e.accessList)), ["data"].forEach((i) => {
+        e[i] != null && (r[i] = Promise.resolve(e[i]).then((n) => n ? x(n) : null));
+      }), this.formatter.transactionRequest(yield E(r));
+    });
+  }
+  _getFilter(t) {
+    return a(this, void 0, void 0, function* () {
+      t = yield t;
+      const e = {};
+      return t.address != null && (e.address = this._getAddress(t.address)), ["blockHash", "topics"].forEach((r) => {
+        t[r] != null && (e[r] = t[r]);
+      }), ["fromBlock", "toBlock"].forEach((r) => {
+        t[r] != null && (e[r] = this._getBlockTag(t[r]));
+      }), this.formatter.filter(yield E(e));
+    });
+  }
+  _call(t, e, r) {
+    return a(this, void 0, void 0, function* () {
+      r >= gt && u.throwError("CCIP read exceeded maximum redirections", h.errors.SERVER_ERROR, {
+        redirects: r,
+        transaction: t
+      });
+      const i = t.to, n = yield this.perform("call", { transaction: t, blockTag: e });
+      if (r >= 0 && e === "latest" && i != null && n.substring(0, 10) === "0x556f1830" && W(n) % 32 === 4)
+        try {
+          const s = v(n, 4), l = v(s, 0, 32);
+          k.from(l).eq(i) || u.throwError("CCIP Read sender did not match", h.errors.CALL_EXCEPTION, {
+            name: "OffchainLookup",
+            signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+            transaction: t,
+            data: n
+          });
+          const c = [], d = k.from(v(s, 32, 64)).toNumber(), m = k.from(v(s, d, d + 32)).toNumber(), g = v(s, d + 32);
+          for (let N = 0; N < m; N++) {
+            const B = D(g, N * 32);
+            B == null && u.throwError("CCIP Read contained corrupt URL string", h.errors.CALL_EXCEPTION, {
+              name: "OffchainLookup",
+              signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+              transaction: t,
+              data: n
+            }), c.push(B);
+          }
+          const f = O(s, 64);
+          k.from(v(s, 100, 128)).isZero() || u.throwError("CCIP Read callback selector included junk", h.errors.CALL_EXCEPTION, {
+            name: "OffchainLookup",
+            signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+            transaction: t,
+            data: n
+          });
+          const _ = v(s, 96, 100), p = O(s, 128), b = yield this.ccipReadFetch(t, f, c);
+          b == null && u.throwError("CCIP Read disabled or provided no URLs", h.errors.CALL_EXCEPTION, {
+            name: "OffchainLookup",
+            signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
+            transaction: t,
+            data: n
+          });
+          const C = {
+            to: i,
+            data: R([_, nt([b, p])])
+          };
+          return this._call(C, e, r + 1);
+        } catch (s) {
+          if (s.code === h.errors.SERVER_ERROR)
+            throw s;
+        }
+      try {
+        return x(n);
+      } catch (s) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "call",
+          params: { transaction: t, blockTag: e },
+          result: n,
+          error: s
+        });
+      }
+    });
+  }
+  call(t, e) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const r = yield E({
+        transaction: this._getTransactionRequest(t),
+        blockTag: this._getBlockTag(e),
+        ccipReadEnabled: Promise.resolve(t.ccipReadEnabled)
+      });
+      return this._call(r.transaction, r.blockTag, r.ccipReadEnabled ? 0 : -1);
+    });
+  }
+  estimateGas(t) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const e = yield E({
+        transaction: this._getTransactionRequest(t)
+      }), r = yield this.perform("estimateGas", e);
+      try {
+        return k.from(r);
+      } catch (i) {
+        return u.throwError("bad result from backend", h.errors.SERVER_ERROR, {
+          method: "estimateGas",
+          params: e,
+          result: r,
+          error: i
+        });
+      }
+    });
+  }
+  _getAddress(t) {
+    return a(this, void 0, void 0, function* () {
+      t = yield t, typeof t != "string" && u.throwArgumentError("invalid address or ENS name", "name", t);
+      const e = yield this.resolveName(t);
+      return e == null && u.throwError("ENS name not configured", h.errors.UNSUPPORTED_OPERATION, {
+        operation: `resolveName(${JSON.stringify(t)})`
+      }), e;
+    });
+  }
+  _getBlock(t, e) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork(), t = yield t;
+      let r = -128;
+      const i = {
+        includeTransactions: !!e
+      };
+      if (L(t, 32))
+        i.blockHash = t;
+      else
+        try {
+          i.blockTag = yield this._getBlockTag(t), L(i.blockTag) && (r = parseInt(i.blockTag.substring(2), 16));
+        } catch {
+          u.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", t);
+        }
+      return S(() => a(this, void 0, void 0, function* () {
+        const n = yield this.perform("getBlock", i);
+        if (n == null)
+          return i.blockHash != null && this._emitted["b:" + i.blockHash] == null || i.blockTag != null && r > this._emitted.block ? null : void 0;
+        if (e) {
+          let s = null;
+          for (let c = 0; c < n.transactions.length; c++) {
+            const d = n.transactions[c];
+            if (d.blockNumber == null)
+              d.confirmations = 0;
+            else if (d.confirmations == null) {
+              s == null && (s = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval));
+              let m = s - d.blockNumber + 1;
+              m <= 0 && (m = 1), d.confirmations = m;
+            }
+          }
+          const l = this.formatter.blockWithTransactions(n);
+          return l.transactions = l.transactions.map((c) => this._wrapTransaction(c)), l;
+        }
+        return this.formatter.block(n);
+      }), { oncePoll: this });
+    });
+  }
+  getBlock(t) {
+    return this._getBlock(t, !1);
+  }
+  getBlockWithTransactions(t) {
+    return this._getBlock(t, !0);
+  }
+  getTransaction(t) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork(), t = yield t;
+      const e = { transactionHash: this.formatter.hash(t, !0) };
+      return S(() => a(this, void 0, void 0, function* () {
+        const r = yield this.perform("getTransaction", e);
+        if (r == null)
+          return this._emitted["t:" + t] == null ? null : void 0;
+        const i = this.formatter.transactionResponse(r);
+        if (i.blockNumber == null)
+          i.confirmations = 0;
+        else if (i.confirmations == null) {
+          let s = (yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval)) - i.blockNumber + 1;
+          s <= 0 && (s = 1), i.confirmations = s;
+        }
+        return this._wrapTransaction(i);
+      }), { oncePoll: this });
+    });
+  }
+  getTransactionReceipt(t) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork(), t = yield t;
+      const e = { transactionHash: this.formatter.hash(t, !0) };
+      return S(() => a(this, void 0, void 0, function* () {
+        const r = yield this.perform("getTransactionReceipt", e);
+        if (r == null)
+          return this._emitted["t:" + t] == null ? null : void 0;
+        if (r.blockHash == null)
+          return;
+        const i = this.formatter.receipt(r);
+        if (i.blockNumber == null)
+          i.confirmations = 0;
+        else if (i.confirmations == null) {
+          let s = (yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval)) - i.blockNumber + 1;
+          s <= 0 && (s = 1), i.confirmations = s;
+        }
+        return i;
+      }), { oncePoll: this });
+    });
+  }
+  getLogs(t) {
+    return a(this, void 0, void 0, function* () {
+      yield this.getNetwork();
+      const e = yield E({ filter: this._getFilter(t) }), r = yield this.perform("getLogs", e);
+      return r.forEach((i) => {
+        i.removed == null && (i.removed = !1);
+      }), H.arrayOf(this.formatter.filterLog.bind(this.formatter))(r);
+    });
+  }
+  getEtherPrice() {
+    return a(this, void 0, void 0, function* () {
+      return yield this.getNetwork(), this.perform("getEtherPrice", {});
+    });
+  }
+  _getBlockTag(t) {
+    return a(this, void 0, void 0, function* () {
+      if (t = yield t, typeof t == "number" && t < 0) {
+        t % 1 && u.throwArgumentError("invalid BlockTag", "blockTag", t);
+        let e = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
+        return e += t, e < 0 && (e = 0), this.formatter.blockTag(e);
+      }
+      return this.formatter.blockTag(t);
+    });
+  }
+  getResolver(t) {
+    return a(this, void 0, void 0, function* () {
+      let e = t;
+      for (; ; ) {
+        if (e === "" || e === "." || t !== "eth" && e === "eth")
+          return null;
+        const r = yield this._getResolver(e, "getResolver");
+        if (r != null) {
+          const i = new tt(this, r, t);
+          return e !== t && !(yield i.supportsWildcard()) ? null : i;
+        }
+        e = e.split(".").slice(1).join(".");
+      }
+    });
+  }
+  _getResolver(t, e) {
+    return a(this, void 0, void 0, function* () {
+      e == null && (e = "ENS");
+      const r = yield this.getNetwork();
+      r.ensAddress || u.throwError("network does not support ENS", h.errors.UNSUPPORTED_OPERATION, { operation: e, network: r.name });
+      try {
+        const i = yield this.call({
+          to: r.ensAddress,
+          data: "0x0178b8bf" + U(t).substring(2)
+        });
+        return this.formatter.callAddress(i);
+      } catch {
+      }
+      return null;
+    });
+  }
+  resolveName(t) {
+    return a(this, void 0, void 0, function* () {
+      t = yield t;
+      try {
+        return Promise.resolve(this.formatter.address(t));
+      } catch (r) {
+        if (L(t))
+          throw r;
+      }
+      typeof t != "string" && u.throwArgumentError("invalid ENS name", "name", t);
+      const e = yield this.getResolver(t);
+      return e ? yield e.getAddress() : null;
+    });
+  }
+  lookupAddress(t) {
+    return a(this, void 0, void 0, function* () {
+      t = yield t, t = this.formatter.address(t);
+      const e = t.substring(2).toLowerCase() + ".addr.reverse", r = yield this._getResolver(e, "lookupAddress");
+      if (r == null)
+        return null;
+      const i = D(yield this.call({
+        to: r,
+        data: "0x691f3431" + U(e).substring(2)
+      }), 0);
+      return (yield this.resolveName(i)) != t ? null : i;
+    });
+  }
+  getAvatar(t) {
+    return a(this, void 0, void 0, function* () {
+      let e = null;
+      if (L(t)) {
+        const n = this.formatter.address(t).substring(2).toLowerCase() + ".addr.reverse", s = yield this._getResolver(n, "getAvatar");
+        if (!s)
+          return null;
+        e = new tt(this, s, n);
+        try {
+          const l = yield e.getAvatar();
+          if (l)
+            return l.url;
+        } catch (l) {
+          if (l.code !== h.errors.CALL_EXCEPTION)
+            throw l;
+        }
+        try {
+          const l = D(yield this.call({
+            to: s,
+            data: "0x691f3431" + U(n).substring(2)
+          }), 0);
+          e = yield this.getResolver(l);
+        } catch (l) {
+          if (l.code !== h.errors.CALL_EXCEPTION)
+            throw l;
+          return null;
+        }
+      } else if (e = yield this.getResolver(t), !e)
+        return null;
+      const r = yield e.getAvatar();
+      return r == null ? null : r.url;
+    });
+  }
+  perform(t, e) {
+    return u.throwError(t + " not implemented", h.errors.NOT_IMPLEMENTED, { operation: t });
+  }
+  _startEvent(t) {
+    this.polling = this._events.filter((e) => e.pollable()).length > 0;
+  }
+  _stopEvent(t) {
+    this.polling = this._events.filter((e) => e.pollable()).length > 0;
+  }
+  _addEventListener(t, e, r) {
+    const i = new bt(T(t), e, r);
+    return this._events.push(i), this._startEvent(i), this;
+  }
+  on(t, e) {
+    return this._addEventListener(t, e, !1);
+  }
+  once(t, e) {
+    return this._addEventListener(t, e, !0);
+  }
+  emit(t, ...e) {
+    let r = !1, i = [], n = T(t);
+    return this._events = this._events.filter((s) => s.tag !== n ? !0 : (setTimeout(() => {
+      s.listener.apply(this, e);
+    }, 0), r = !0, s.once ? (i.push(s), !1) : !0)), i.forEach((s) => {
+      this._stopEvent(s);
+    }), r;
+  }
+  listenerCount(t) {
+    if (!t)
+      return this._events.length;
+    let e = T(t);
+    return this._events.filter((r) => r.tag === e).length;
+  }
+  listeners(t) {
+    if (t == null)
+      return this._events.map((r) => r.listener);
+    let e = T(t);
+    return this._events.filter((r) => r.tag === e).map((r) => r.listener);
+  }
+  off(t, e) {
+    if (e == null)
+      return this.removeAllListeners(t);
+    const r = [];
+    let i = !1, n = T(t);
+    return this._events = this._events.filter((s) => s.tag !== n || s.listener != e || i ? !0 : (i = !0, r.push(s), !1)), r.forEach((s) => {
+      this._stopEvent(s);
+    }), this;
+  }
+  removeAllListeners(t) {
+    let e = [];
+    if (t == null)
+      e = this._events, this._events = [];
+    else {
+      const r = T(t);
+      this._events = this._events.filter((i) => i.tag !== r ? !0 : (e.push(i), !1));
+    }
+    return e.forEach((r) => {
+      this._stopEvent(r);
+    }), this;
+  }
+}
+export {
+  $t as BaseProvider,
+  bt as Event,
+  tt as Resolver
+};