@pufferfinance/puffer-sdk 1.23.1 → 1.24.0

package/dist/createWalletClient-CYva1_XM.js

@@ -0,0 +1,3262 @@
+import { B as ut, C as jn, D as Hn, E as Wn, F as Gn, G as Q, J as D, K as W, L as _, M as Ne, N as Re, O as We, P as Vn, h as F, Q as Mt, R as H, S as ie, m as Jn, V as fe, H as re, W as Zn, U as ke, X as dt, Y as ft, Z as lt, _ as pt, $ as ht, a0 as mt, a1 as gt, a2 as bt, a3 as yt, a4 as wt, a5 as vt, a6 as Pe, T as Tt, a7 as At, a8 as xt, a9 as Se, aa as Be, ab as Ct, ac as Et, ad as kt, ae as It, af as Nt, ag as Kn, ah as Qn, ai as Rt, aj as Xn, ak as ce, al as Pt, am as Lt, g as C, r as U, an as ve, ao as St, ap as Yn, aq as Ge, ar as Ve, as as er, at as tr, au as Je, av as Ut, aw as nr, l as Ze, ax as rr, ay as sr, az as ar, aA as Te, aB as $e, aC as or, aD as jt, aE as Ht, aF as ir, aG as cr, aH as ur, aI as dr, aJ as fr, aK as Ke, aL as Qe, aM as ze, aN as X, aO as ee, aP as M, aQ as ae, aR as Wt, aS as lr, aT as pr, aU as Bt, aV as Gt, aW as hr, k as Vt, j as Xe, aX as mr, aY as gr, aZ as Z, a_ as br, a$ as yr, b0 as wr, b1 as vr, b2 as Ye, b3 as Jt, b4 as et, w as Tr, s as Ar, b5 as Zt, b6 as Kt, b7 as Qt, b8 as xr, b9 as Cr, ba as Er, a as kr, bb as Ae, bc as Ir, bd as Nr, e as Rr, c as Pr, be as ue, bf as Sr, bg as Br, d as $r } from "./writeContract-QAArm5iD.js";
+import { n as R, c as Y, B as $, h as j, x as be, y as zr, z as Xt, A as De, L as Dr, D as ye, i as Yt, b as oe, a as Fr, F as q, s as se, t as G, G as we, I as en, J as _r, K as Fe, e as qr, M as tn, T as nn, N as Or, O as rn, P as Mr, Q as Lr, U as Ur, R as jr, S as Hr, W as sn, X as Wr, Y as Gr } from "./constants-BweLzNUt.js";
+import { l as an } from "./localBatchGatewayRequest-CCdxn5t3.js";
+import { secp256k1 as Vr } from "./secp256k1-DGP4Y7VW.js";
+function $t(e) {
+  let t;
+  if (typeof e == "string")
+    t = ut(e);
+  else {
+    const n = jn(e), r = e.length;
+    for (let s = 0; s < r; s++) {
+      const a = e[s];
+      if (!Hn(a)) {
+        t = ut(a, n);
+        break;
+      }
+    }
+  }
+  if (!t)
+    throw new Wn({ signature: e });
+  return t;
+}
+function Jr(e, t) {
+  if (Dt(e) > t)
+    throw new ns({
+      givenSize: Dt(e),
+      maxSize: t
+    });
+}
+const L = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102
+};
+function zt(e) {
+  if (e >= L.zero && e <= L.nine)
+    return e - L.zero;
+  if (e >= L.A && e <= L.F)
+    return e - (L.A - 10);
+  if (e >= L.a && e <= L.f)
+    return e - (L.a - 10);
+}
+function Zr(e, t = {}) {
+  const { dir: n, size: r = 32 } = t;
+  if (r === 0)
+    return e;
+  if (e.length > r)
+    throw new rs({
+      size: e.length,
+      targetSize: r,
+      type: "Bytes"
+    });
+  const s = new Uint8Array(r);
+  for (let a = 0; a < r; a++) {
+    const o = n === "right";
+    s[o ? a : r - a - 1] = e[o ? a : e.length - a - 1];
+  }
+  return s;
+}
+const Kr = /* @__PURE__ */ new TextEncoder();
+function Qr(e) {
+  return e instanceof Uint8Array ? e : typeof e == "string" ? Yr(e) : Xr(e);
+}
+function Xr(e) {
+  return e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+function Yr(e, t = {}) {
+  const { size: n } = t;
+  let r = e;
+  n && (Gn(e, n), r = Q(e, n));
+  let s = r.slice(2);
+  s.length % 2 && (s = `0${s}`);
+  const a = s.length / 2, o = new Uint8Array(a);
+  for (let i = 0, u = 0; i < a; i++) {
+    const c = zt(s.charCodeAt(u++)), d = zt(s.charCodeAt(u++));
+    if (c === void 0 || d === void 0)
+      throw new D(`Invalid byte sequence ("${s[u - 2]}${s[u - 1]}" in "${s}").`);
+    o[i] = c * 16 + d;
+  }
+  return o;
+}
+function es(e, t = {}) {
+  const { size: n } = t, r = Kr.encode(e);
+  return typeof n == "number" ? (Jr(r, n), ts(r, n)) : r;
+}
+function ts(e, t) {
+  return Zr(e, { dir: "right", size: t });
+}
+function Dt(e) {
+  return e.length;
+}
+class ns extends D {
+  constructor({ givenSize: t, maxSize: n }) {
+    super(`Size cannot exceed \`${n}\` bytes. Given size: \`${t}\` bytes.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.SizeOverflowError"
+    });
+  }
+}
+class rs extends D {
+  constructor({ size: t, targetSize: n, type: r }) {
+    super(`${r.charAt(0).toUpperCase()}${r.slice(1).toLowerCase()} size (\`${t}\`) exceeds padding size (\`${n}\`).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Bytes.SizeExceedsPaddingSizeError"
+    });
+  }
+}
+const on = "0x5792579257925792579257925792579257925792579257925792579257925792", cn = R(0, {
+  size: 32
+});
+async function ss(e, t) {
+  const { account: n = e.account, capabilities: r, chain: s = e.chain, experimental_fallback: a, experimental_fallbackDelay: o = 32, forceAtomic: i = !1, id: u, version: c = "2.0.0" } = t, d = n ? _(n) : null, l = t.calls.map((p) => {
+    const f = p, h = f.abi ? W({
+      abi: f.abi,
+      functionName: f.functionName,
+      args: f.args
+    }) : f.data;
+    return {
+      data: f.dataSuffix && h ? Y([h, f.dataSuffix]) : h,
+      to: f.to,
+      value: f.value ? R(f.value) : void 0
+    };
+  });
+  try {
+    const p = await e.request({
+      method: "wallet_sendCalls",
+      params: [
+        {
+          atomicRequired: i,
+          calls: l,
+          capabilities: r,
+          chainId: R(s.id),
+          from: d == null ? void 0 : d.address,
+          id: u,
+          version: c
+        }
+      ]
+    }, { retryCount: 0 });
+    return typeof p == "string" ? { id: p } : p;
+  } catch (p) {
+    const f = p;
+    if (a && (f.name === "MethodNotFoundRpcError" || f.name === "MethodNotSupportedRpcError" || f.name === "UnknownRpcError" || f.details.toLowerCase().includes("does not exist / is not available") || f.details.toLowerCase().includes("missing or invalid. request()") || f.details.toLowerCase().includes("did not match any variant of untagged enum") || f.details.toLowerCase().includes("account upgraded to unsupported contract") || f.details.toLowerCase().includes("eip-7702 not supported") || f.details.toLowerCase().includes("unsupported wc_ method"))) {
+      if (r && Object.values(r).some((b) => !b.optional)) {
+        const b = "non-optional `capabilities` are not supported on fallback to `eth_sendTransaction`.";
+        throw new Ne(new $(b, {
+          details: b
+        }));
+      }
+      if (i && l.length > 1) {
+        const m = "`forceAtomic` is not supported on fallback to `eth_sendTransaction`.";
+        throw new Re(new $(m, {
+          details: m
+        }));
+      }
+      const h = [];
+      for (const m of l) {
+        const b = We(e, {
+          account: d,
+          chain: s,
+          data: m.data,
+          to: m.to,
+          value: m.value ? j(m.value) : void 0
+        });
+        h.push(b), o > 0 && await new Promise((w) => setTimeout(w, o));
+      }
+      const g = await Promise.allSettled(h);
+      if (g.every((m) => m.status === "rejected"))
+        throw g[0].reason;
+      const y = g.map((m) => m.status === "fulfilled" ? m.value : cn);
+      return {
+        id: Y([
+          ...y,
+          R(s.id, { size: 32 }),
+          on
+        ])
+      };
+    }
+    throw Vn(p, {
+      ...t,
+      account: d,
+      chain: t.chain
+    });
+  }
+}
+async function un(e, t) {
+  async function n(d) {
+    if (d.endsWith(on.slice(2))) {
+      const p = Xt(De(d, -64, -32)), f = De(d, 0, -64).slice(2).match(/.{1,64}/g), h = await Promise.all(f.map((y) => cn.slice(2) !== y ? e.request({
+        method: "eth_getTransactionReceipt",
+        params: [`0x${y}`]
+      }, { dedupe: !0 }) : void 0)), g = h.some((y) => y === null) ? 100 : h.every((y) => (y == null ? void 0 : y.status) === "0x1") ? 200 : h.every((y) => (y == null ? void 0 : y.status) === "0x0") ? 500 : 600;
+      return {
+        atomic: !1,
+        chainId: be(p),
+        receipts: h.filter(Boolean),
+        status: g,
+        version: "2.0.0"
+      };
+    }
+    return e.request({
+      method: "wallet_getCallsStatus",
+      params: [d]
+    });
+  }
+  const { atomic: r = !1, chainId: s, receipts: a, version: o = "2.0.0", ...i } = await n(t.id), [u, c] = (() => {
+    const d = i.status;
+    return d >= 100 && d < 200 ? ["pending", d] : d >= 200 && d < 300 ? ["success", d] : d >= 300 && d < 700 ? ["failure", d] : d === "CONFIRMED" ? ["success", 200] : d === "PENDING" ? ["pending", 100] : [void 0, d];
+  })();
+  return {
+    ...i,
+    atomic: r,
+    // @ts-expect-error: for backwards compatibility
+    chainId: s ? be(s) : void 0,
+    receipts: (a == null ? void 0 : a.map((d) => ({
+      ...d,
+      blockNumber: j(d.blockNumber),
+      gasUsed: j(d.gasUsed),
+      status: zr[d.status]
+    }))) ?? [],
+    statusCode: c,
+    status: u,
+    version: o
+  };
+}
+async function as(e, t) {
+  const { id: n, pollingInterval: r = e.pollingInterval, status: s = ({ statusCode: p }) => p >= 200, timeout: a = 6e4 } = t, o = F(["waitForCallsStatus", e.uid, n]), { promise: i, resolve: u, reject: c } = Mt();
+  let d;
+  const l = H(o, { resolve: u, reject: c }, (p) => {
+    const f = ie(async () => {
+      const h = (g) => {
+        clearTimeout(d), f(), g(), l();
+      };
+      try {
+        const g = await un(e, { id: n });
+        if (!s(g))
+          return;
+        h(() => p.resolve(g));
+      } catch (g) {
+        h(() => p.reject(g));
+      }
+    }, {
+      interval: r,
+      emitOnBegin: !0
+    });
+    return f;
+  });
+  return d = a ? setTimeout(() => {
+    l(), clearTimeout(d), c(new os({ id: n }));
+  }, a) : void 0, await i;
+}
+class os extends $ {
+  constructor({ id: t }) {
+    super(`Timed out while waiting for call bundle with id "${t}" to be confirmed.`, { name: "WaitForCallsStatusTimeoutError" });
+  }
+}
+const _e = 256;
+let le = _e, pe;
+function dn(e = 11) {
+  if (!pe || le + e > _e * 2) {
+    pe = "", le = 0;
+    for (let t = 0; t < _e; t++)
+      pe += (256 + Math.random() * 256 | 0).toString(16).substring(1);
+  }
+  return pe.substring(le, le++ + e);
+}
+function fn(e) {
+  const { batch: t, chain: n, ccipRead: r, key: s = "base", name: a = "Base Client", type: o = "base" } = e, i = e.experimental_blockTag ?? (typeof (n == null ? void 0 : n.experimental_preconfirmationTime) == "number" ? "pending" : void 0), u = (n == null ? void 0 : n.blockTime) ?? 12e3, c = Math.min(Math.max(Math.floor(u / 2), 500), 4e3), d = e.pollingInterval ?? c, l = e.cacheTime ?? d, p = e.account ? _(e.account) : void 0, { config: f, request: h, value: g } = e.transport({
+    chain: n,
+    pollingInterval: d
+  }), y = { ...f, ...g }, m = {
+    account: p,
+    batch: t,
+    cacheTime: l,
+    ccipRead: r,
+    chain: n,
+    key: s,
+    name: a,
+    pollingInterval: d,
+    request: h,
+    transport: y,
+    type: o,
+    uid: dn(),
+    ...i ? { experimental_blockTag: i } : {}
+  };
+  function b(w) {
+    return (x) => {
+      const T = x(w);
+      for (const v in m)
+        delete T[v];
+      const k = { ...w, ...T };
+      return Object.assign(k, { extend: b(k) });
+    };
+  }
+  return Object.assign(m, { extend: b(m) });
+}
+const he = /* @__PURE__ */ new Dr(8192);
+function is(e, { enabled: t = !0, id: n }) {
+  if (!t || !n)
+    return e();
+  if (he.get(n))
+    return he.get(n);
+  const r = e().finally(() => he.delete(n));
+  return he.set(n, r), r;
+}
+function qe(e, { delay: t = 100, retryCount: n = 2, shouldRetry: r = () => !0 } = {}) {
+  return new Promise((s, a) => {
+    const o = async ({ count: i = 0 } = {}) => {
+      const u = async ({ error: c }) => {
+        const d = typeof t == "function" ? t({ count: i, error: c }) : t;
+        d && await Jn(d), o({ count: i + 1 });
+      };
+      try {
+        const c = await e();
+        s(c);
+      } catch (c) {
+        if (i < n && await r({ count: i, error: c }))
+          return u({ error: c });
+        a(c);
+      }
+    };
+    o();
+  });
+}
+function cs(e, t = {}) {
+  return async (n, r = {}) => {
+    var l;
+    const { dedupe: s = !1, methods: a, retryDelay: o = 150, retryCount: i = 3, uid: u } = {
+      ...t,
+      ...r
+    }, { method: c } = n;
+    if ((l = a == null ? void 0 : a.exclude) != null && l.includes(c))
+      throw new fe(new Error("method not supported"), {
+        method: c
+      });
+    if (a != null && a.include && !a.include.includes(c))
+      throw new fe(new Error("method not supported"), {
+        method: c
+      });
+    const d = s ? ye(`${u}.${F(n)}`) : void 0;
+    return is(() => qe(async () => {
+      try {
+        return await e(n);
+      } catch (p) {
+        const f = p;
+        switch (f.code) {
+          // -32700
+          case It.code:
+            throw new It(f);
+          // -32600
+          case kt.code:
+            throw new kt(f);
+          // -32601
+          case Et.code:
+            throw new Et(f, { method: n.method });
+          // -32602
+          case Ct.code:
+            throw new Ct(f);
+          // -32603
+          case Be.code:
+            throw new Be(f);
+          // -32000
+          case Se.code:
+            throw new Se(f);
+          // -32001
+          case xt.code:
+            throw new xt(f);
+          // -32002
+          case At.code:
+            throw new At(f);
+          // -32003
+          case Tt.code:
+            throw new Tt(f);
+          // -32004
+          case fe.code:
+            throw new fe(f, {
+              method: n.method
+            });
+          // -32005
+          case Pe.code:
+            throw new Pe(f);
+          // -32006
+          case vt.code:
+            throw new vt(f);
+          // 4001
+          case ke.code:
+            throw new ke(f);
+          // 4100
+          case wt.code:
+            throw new wt(f);
+          // 4200
+          case yt.code:
+            throw new yt(f);
+          // 4900
+          case bt.code:
+            throw new bt(f);
+          // 4901
+          case gt.code:
+            throw new gt(f);
+          // 4902
+          case mt.code:
+            throw new mt(f);
+          // 5700
+          case Ne.code:
+            throw new Ne(f);
+          // 5710
+          case ht.code:
+            throw new ht(f);
+          // 5720
+          case pt.code:
+            throw new pt(f);
+          // 5730
+          case lt.code:
+            throw new lt(f);
+          // 5740
+          case ft.code:
+            throw new ft(f);
+          // 5750
+          case dt.code:
+            throw new dt(f);
+          // 5760
+          case Re.code:
+            throw new Re(f);
+          // CAIP-25: User Rejected Error
+          // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
+          case 5e3:
+            throw new ke(f);
+          default:
+            throw p instanceof $ ? p : new Zn(f);
+        }
+      }
+    }, {
+      delay: ({ count: p, error: f }) => {
+        var h;
+        if (f && f instanceof re) {
+          const g = (h = f == null ? void 0 : f.headers) == null ? void 0 : h.get("Retry-After");
+          if (g != null && g.match(/\d/))
+            return Number.parseInt(g) * 1e3;
+        }
+        return ~~(1 << p) * o;
+      },
+      retryCount: i,
+      shouldRetry: ({ error: p }) => us(p)
+    }), { enabled: s, id: d });
+  };
+}
+function us(e) {
+  return "code" in e && typeof e.code == "number" ? e.code === -1 || e.code === Pe.code || e.code === Be.code : e instanceof re && e.status ? e.status === 403 || e.status === 408 || e.status === 413 || e.status === 429 || e.status === 500 || e.status === 502 || e.status === 503 || e.status === 504 : !0;
+}
+function ds({ key: e, methods: t, name: n, request: r, retryCount: s = 3, retryDelay: a = 150, timeout: o, type: i }, u) {
+  const c = dn();
+  return {
+    config: {
+      key: e,
+      methods: t,
+      name: n,
+      request: r,
+      retryCount: s,
+      retryDelay: a,
+      timeout: o,
+      type: i
+    },
+    request: cs(r, { methods: t, retryCount: s, retryDelay: a, uid: c }),
+    value: u
+  };
+}
+class fs extends $ {
+  constructor() {
+    super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
+      docsPath: "/docs/clients/intro",
+      name: "UrlRequiredError"
+    });
+  }
+}
+function ls(e, { errorInstance: t = new Error("timed out"), timeout: n, signal: r }) {
+  return new Promise((s, a) => {
+    (async () => {
+      let o;
+      try {
+        const i = new AbortController();
+        n > 0 && (o = setTimeout(() => {
+          r && i.abort();
+        }, n)), s(await e({ signal: (i == null ? void 0 : i.signal) || null }));
+      } catch (i) {
+        (i == null ? void 0 : i.name) === "AbortError" && a(t), a(i);
+      } finally {
+        clearTimeout(o);
+      }
+    })();
+  });
+}
+function ps() {
+  return {
+    current: 0,
+    take() {
+      return this.current++;
+    },
+    reset() {
+      this.current = 0;
+    }
+  };
+}
+const Ft = /* @__PURE__ */ ps();
+function hs(e, t = {}) {
+  return {
+    async request(n) {
+      var l;
+      const { body: r, onRequest: s = t.onRequest, onResponse: a = t.onResponse, timeout: o = t.timeout ?? 1e4 } = n, i = {
+        ...t.fetchOptions ?? {},
+        ...n.fetchOptions ?? {}
+      }, { headers: u, method: c, signal: d } = i;
+      try {
+        const p = await ls(async ({ signal: h }) => {
+          const g = {
+            ...i,
+            body: Array.isArray(r) ? F(r.map((w) => ({
+              jsonrpc: "2.0",
+              id: w.id ?? Ft.take(),
+              ...w
+            }))) : F({
+              jsonrpc: "2.0",
+              id: r.id ?? Ft.take(),
+              ...r
+            }),
+            headers: {
+              "Content-Type": "application/json",
+              ...u
+            },
+            method: c || "POST",
+            signal: d || (o > 0 ? h : null)
+          }, y = new Request(e, g), m = await (s == null ? void 0 : s(y, g)) ?? { ...g, url: e };
+          return await fetch(m.url ?? e, m);
+        }, {
+          errorInstance: new Nt({ body: r, url: e }),
+          timeout: o,
+          signal: !0
+        });
+        a && await a(p);
+        let f;
+        if ((l = p.headers.get("Content-Type")) != null && l.startsWith("application/json"))
+          f = await p.json();
+        else {
+          f = await p.text();
+          try {
+            f = JSON.parse(f || "{}");
+          } catch (h) {
+            if (p.ok)
+              throw h;
+            f = { error: f };
+          }
+        }
+        if (!p.ok)
+          throw new re({
+            body: r,
+            details: F(f.error) || p.statusText,
+            headers: p.headers,
+            status: p.status,
+            url: e
+          });
+        return f;
+      } catch (p) {
+        throw p instanceof re || p instanceof Nt ? p : new re({
+          body: r,
+          cause: p,
+          url: e
+        });
+      }
+    }
+  };
+}
+function go(e, t = {}) {
+  const { batch: n, fetchOptions: r, key: s = "http", methods: a, name: o = "HTTP JSON-RPC", onFetchRequest: i, onFetchResponse: u, retryDelay: c, raw: d } = t;
+  return ({ chain: l, retryCount: p, timeout: f }) => {
+    const { batchSize: h = 1e3, wait: g = 0 } = typeof n == "object" ? n : {}, y = t.retryCount ?? p, m = f ?? t.timeout ?? 1e4, b = e || (l == null ? void 0 : l.rpcUrls.default.http[0]);
+    if (!b)
+      throw new fs();
+    const w = hs(b, {
+      fetchOptions: r,
+      onRequest: i,
+      onResponse: u,
+      timeout: m
+    });
+    return ds({
+      key: s,
+      methods: a,
+      name: o,
+      async request({ method: x, params: T }) {
+        const k = { method: x, params: T }, { schedule: v } = Kn({
+          id: b,
+          wait: g,
+          shouldSplitBatch(E) {
+            return E.length > h;
+          },
+          fn: (E) => w.request({
+            body: E
+          }),
+          sort: (E, P) => E.id - P.id
+        }), I = async (E) => n ? v(E) : [
+          await w.request({
+            body: E
+          })
+        ], [{ error: N, result: B }] = await I(k);
+        if (d)
+          return { error: N, result: B };
+        if (N)
+          throw new Qn({
+            body: k,
+            error: N,
+            url: b
+          });
+        return B;
+      },
+      retryCount: y,
+      retryDelay: c,
+      timeout: m,
+      type: "http"
+    }, {
+      fetchOptions: r,
+      url: b
+    });
+  };
+}
+function tt(e, t) {
+  var r, s, a, o, i, u;
+  if (!(e instanceof $))
+    return !1;
+  const n = e.walk((c) => c instanceof Rt);
+  return n instanceof Rt ? !!(((r = n.data) == null ? void 0 : r.errorName) === "ResolverNotFound" || ((s = n.data) == null ? void 0 : s.errorName) === "ResolverWildcardNotSupported" || ((a = n.data) == null ? void 0 : a.errorName) === "ResolverNotContract" || ((o = n.data) == null ? void 0 : o.errorName) === "ResolverError" || ((i = n.data) == null ? void 0 : i.errorName) === "HttpError" || (u = n.reason) != null && u.includes("Wildcard on non-extended resolvers is not supported") || t === "reverse" && n.reason === Xn[50]) : !1;
+}
+function ln(e) {
+  if (e.length !== 66 || e.indexOf("[") !== 0 || e.indexOf("]") !== 65)
+    return null;
+  const t = `0x${e.slice(1, 65)}`;
+  return Yt(t) ? t : null;
+}
+function me(e) {
+  let t = new Uint8Array(32).fill(0);
+  if (!e)
+    return oe(t);
+  const n = e.split(".");
+  for (let r = n.length - 1; r >= 0; r -= 1) {
+    const s = ln(n[r]), a = s ? Fr(s) : q(se(n[r]), "bytes");
+    t = q(Y([t, a]), "bytes");
+  }
+  return oe(t);
+}
+function ms(e) {
+  return `[${e.slice(2)}]`;
+}
+function gs(e) {
+  const t = new Uint8Array(32).fill(0);
+  return e ? ln(e) || q(se(e)) : oe(t);
+}
+function xe(e) {
+  const t = e.replace(/^\.|\.$/gm, "");
+  if (t.length === 0)
+    return new Uint8Array(1);
+  const n = new Uint8Array(se(t).byteLength + 2);
+  let r = 0;
+  const s = t.split(".");
+  for (let a = 0; a < s.length; a++) {
+    let o = se(s[a]);
+    o.byteLength > 255 && (o = se(ms(gs(s[a])))), n[r] = o.length, n.set(o, r + 1), r += o.length + 1;
+  }
+  return n.byteLength !== r + 1 ? n.slice(0, r + 1) : n;
+}
+async function bs(e, t) {
+  const { blockNumber: n, blockTag: r, coinType: s, name: a, gatewayUrls: o, strict: i } = t, { chain: u } = e, c = (() => {
+    if (t.universalResolverAddress)
+      return t.universalResolverAddress;
+    if (!u)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    return ce({
+      blockNumber: n,
+      chain: u,
+      contract: "ensUniversalResolver"
+    });
+  })(), d = u == null ? void 0 : u.ensTlds;
+  if (d && !d.some((l) => a.endsWith(l)))
+    return null;
+  try {
+    const l = W({
+      abi: Pt,
+      functionName: "addr",
+      ...s != null ? { args: [me(a), BigInt(s)] } : { args: [me(a)] }
+    }), p = {
+      address: c,
+      abi: Lt,
+      functionName: "resolve",
+      args: [
+        G(xe(a)),
+        l,
+        o ?? [an]
+      ],
+      blockNumber: n,
+      blockTag: r
+    }, h = await C(e, U, "readContract")(p);
+    if (h[0] === "0x")
+      return null;
+    const g = ve({
+      abi: Pt,
+      args: s != null ? [me(a), BigInt(s)] : void 0,
+      functionName: "addr",
+      data: h[0]
+    });
+    return g === "0x" || Xt(g) === "0x00" ? null : g;
+  } catch (l) {
+    if (i)
+      throw l;
+    if (tt(l, "resolve"))
+      return null;
+    throw l;
+  }
+}
+class ys extends $ {
+  constructor({ data: t }) {
+    super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
+      metaMessages: [
+        "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
+        "",
+        `Provided data: ${JSON.stringify(t)}`
+      ],
+      name: "EnsAvatarInvalidMetadataError"
+    });
+  }
+}
+class ne extends $ {
+  constructor({ reason: t }) {
+    super(`ENS NFT avatar URI is invalid. ${t}`, {
+      name: "EnsAvatarInvalidNftUriError"
+    });
+  }
+}
+class nt extends $ {
+  constructor({ uri: t }) {
+    super(`Unable to resolve ENS avatar URI "${t}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
+  }
+}
+class ws extends $ {
+  constructor({ namespace: t }) {
+    super(`ENS NFT avatar namespace "${t}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
+  }
+}
+const vs = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/, Ts = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/, As = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/, xs = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
+async function Cs(e) {
+  try {
+    const t = await fetch(e, { method: "HEAD" });
+    if (t.status === 200) {
+      const n = t.headers.get("content-type");
+      return n == null ? void 0 : n.startsWith("image/");
+    }
+    return !1;
+  } catch (t) {
+    return typeof t == "object" && typeof t.response < "u" || !globalThis.hasOwnProperty("Image") ? !1 : new Promise((n) => {
+      const r = new Image();
+      r.onload = () => {
+        n(!0);
+      }, r.onerror = () => {
+        n(!1);
+      }, r.src = e;
+    });
+  }
+}
+function _t(e, t) {
+  return e ? e.endsWith("/") ? e.slice(0, -1) : e : t;
+}
+function pn({ uri: e, gatewayUrls: t }) {
+  const n = As.test(e);
+  if (n)
+    return { uri: e, isOnChain: !0, isEncoded: n };
+  const r = _t(t == null ? void 0 : t.ipfs, "https://ipfs.io"), s = _t(t == null ? void 0 : t.arweave, "https://arweave.net"), a = e.match(vs), { protocol: o, subpath: i, target: u, subtarget: c = "" } = (a == null ? void 0 : a.groups) || {}, d = o === "ipns:/" || i === "ipns/", l = o === "ipfs:/" || i === "ipfs/" || Ts.test(e);
+  if (e.startsWith("http") && !d && !l) {
+    let f = e;
+    return t != null && t.arweave && (f = e.replace(/https:\/\/arweave.net/g, t == null ? void 0 : t.arweave)), { uri: f, isOnChain: !1, isEncoded: !1 };
+  }
+  if ((d || l) && u)
+    return {
+      uri: `${r}/${d ? "ipns" : "ipfs"}/${u}${c}`,
+      isOnChain: !1,
+      isEncoded: !1
+    };
+  if (o === "ar:/" && u)
+    return {
+      uri: `${s}/${u}${c || ""}`,
+      isOnChain: !1,
+      isEncoded: !1
+    };
+  let p = e.replace(xs, "");
+  if (p.startsWith("<svg") && (p = `data:image/svg+xml;base64,${btoa(p)}`), p.startsWith("data:") || p.startsWith("{"))
+    return {
+      uri: p,
+      isOnChain: !0,
+      isEncoded: !1
+    };
+  throw new nt({ uri: e });
+}
+function hn(e) {
+  if (typeof e != "object" || !("image" in e) && !("image_url" in e) && !("image_data" in e))
+    throw new ys({ data: e });
+  return e.image || e.image_url || e.image_data;
+}
+async function Es({ gatewayUrls: e, uri: t }) {
+  try {
+    const n = await fetch(t).then((s) => s.json());
+    return await rt({
+      gatewayUrls: e,
+      uri: hn(n)
+    });
+  } catch {
+    throw new nt({ uri: t });
+  }
+}
+async function rt({ gatewayUrls: e, uri: t }) {
+  const { uri: n, isOnChain: r } = pn({ uri: t, gatewayUrls: e });
+  if (r || await Cs(n))
+    return n;
+  throw new nt({ uri: t });
+}
+function ks(e) {
+  let t = e;
+  t.startsWith("did:nft:") && (t = t.replace("did:nft:", "").replace(/_/g, "/"));
+  const [n, r, s] = t.split("/"), [a, o] = n.split(":"), [i, u] = r.split(":");
+  if (!a || a.toLowerCase() !== "eip155")
+    throw new ne({ reason: "Only EIP-155 supported" });
+  if (!o)
+    throw new ne({ reason: "Chain ID not found" });
+  if (!u)
+    throw new ne({
+      reason: "Contract address not found"
+    });
+  if (!s)
+    throw new ne({ reason: "Token ID not found" });
+  if (!i)
+    throw new ne({ reason: "ERC namespace not found" });
+  return {
+    chainID: Number.parseInt(o),
+    namespace: i.toLowerCase(),
+    contractAddress: u,
+    tokenID: s
+  };
+}
+async function Is(e, { nft: t }) {
+  if (t.namespace === "erc721")
+    return U(e, {
+      address: t.contractAddress,
+      abi: [
+        {
+          name: "tokenURI",
+          type: "function",
+          stateMutability: "view",
+          inputs: [{ name: "tokenId", type: "uint256" }],
+          outputs: [{ name: "", type: "string" }]
+        }
+      ],
+      functionName: "tokenURI",
+      args: [BigInt(t.tokenID)]
+    });
+  if (t.namespace === "erc1155")
+    return U(e, {
+      address: t.contractAddress,
+      abi: [
+        {
+          name: "uri",
+          type: "function",
+          stateMutability: "view",
+          inputs: [{ name: "_id", type: "uint256" }],
+          outputs: [{ name: "", type: "string" }]
+        }
+      ],
+      functionName: "uri",
+      args: [BigInt(t.tokenID)]
+    });
+  throw new ws({ namespace: t.namespace });
+}
+async function Ns(e, { gatewayUrls: t, record: n }) {
+  return /eip155:/i.test(n) ? Rs(e, { gatewayUrls: t, record: n }) : rt({ uri: n, gatewayUrls: t });
+}
+async function Rs(e, { gatewayUrls: t, record: n }) {
+  const r = ks(n), s = await Is(e, { nft: r }), { uri: a, isOnChain: o, isEncoded: i } = pn({ uri: s, gatewayUrls: t });
+  if (o && (a.includes("data:application/json;base64,") || a.startsWith("{"))) {
+    const c = i ? (
+      // if it is encoded, decode it
+      atob(a.replace("data:application/json;base64,", ""))
+    ) : (
+      // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
+      a
+    ), d = JSON.parse(c);
+    return rt({ uri: hn(d), gatewayUrls: t });
+  }
+  let u = r.tokenID;
+  return r.namespace === "erc1155" && (u = u.replace("0x", "").padStart(64, "0")), Es({
+    gatewayUrls: t,
+    uri: a.replace(/(?:0x)?{id}/, u)
+  });
+}
+async function mn(e, t) {
+  const { blockNumber: n, blockTag: r, key: s, name: a, gatewayUrls: o, strict: i } = t, { chain: u } = e, c = (() => {
+    if (t.universalResolverAddress)
+      return t.universalResolverAddress;
+    if (!u)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    return ce({
+      blockNumber: n,
+      chain: u,
+      contract: "ensUniversalResolver"
+    });
+  })(), d = u == null ? void 0 : u.ensTlds;
+  if (d && !d.some((l) => a.endsWith(l)))
+    return null;
+  try {
+    const l = {
+      address: c,
+      abi: Lt,
+      functionName: "resolve",
+      args: [
+        G(xe(a)),
+        W({
+          abi: St,
+          functionName: "text",
+          args: [me(a), s]
+        }),
+        o ?? [an]
+      ],
+      blockNumber: n,
+      blockTag: r
+    }, f = await C(e, U, "readContract")(l);
+    if (f[0] === "0x")
+      return null;
+    const h = ve({
+      abi: St,
+      functionName: "text",
+      data: f[0]
+    });
+    return h === "" ? null : h;
+  } catch (l) {
+    if (i)
+      throw l;
+    if (tt(l, "resolve"))
+      return null;
+    throw l;
+  }
+}
+async function Ps(e, { blockNumber: t, blockTag: n, assetGatewayUrls: r, name: s, gatewayUrls: a, strict: o, universalResolverAddress: i }) {
+  const u = await C(e, mn, "getEnsText")({
+    blockNumber: t,
+    blockTag: n,
+    key: "avatar",
+    name: s,
+    universalResolverAddress: i,
+    gatewayUrls: a,
+    strict: o
+  });
+  if (!u)
+    return null;
+  try {
+    return await Ns(e, {
+      record: u,
+      gatewayUrls: r
+    });
+  } catch {
+    return null;
+  }
+}
+async function Ss(e, { address: t, blockNumber: n, blockTag: r, gatewayUrls: s, strict: a, universalResolverAddress: o }) {
+  let i = o;
+  if (!i) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    i = ce({
+      blockNumber: n,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  const u = `${t.toLowerCase().substring(2)}.addr.reverse`;
+  try {
+    const c = {
+      address: i,
+      abi: Yn,
+      functionName: "reverse",
+      args: [G(xe(u))],
+      blockNumber: n,
+      blockTag: r
+    }, d = C(e, U, "readContract"), [l, p] = s ? await d({
+      ...c,
+      args: [...c.args, s]
+    }) : await d(c);
+    return t.toLowerCase() !== p.toLowerCase() ? null : l;
+  } catch (c) {
+    if (a)
+      throw c;
+    if (tt(c, "reverse"))
+      return null;
+    throw c;
+  }
+}
+async function Bs(e, t) {
+  const { blockNumber: n, blockTag: r, name: s } = t, { chain: a } = e, o = (() => {
+    if (t.universalResolverAddress)
+      return t.universalResolverAddress;
+    if (!a)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    return ce({
+      blockNumber: n,
+      chain: a,
+      contract: "ensUniversalResolver"
+    });
+  })(), i = a == null ? void 0 : a.ensTlds;
+  if (i && !i.some((c) => s.endsWith(c)))
+    throw new Error(`${s} is not a valid ENS TLD (${i == null ? void 0 : i.join(", ")}) for chain "${a.name}" (id: ${a.id}).`);
+  const [u] = await C(e, U, "readContract")({
+    address: o,
+    abi: [
+      {
+        inputs: [{ type: "bytes" }],
+        name: "findResolver",
+        outputs: [{ type: "address" }, { type: "bytes32" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ],
+    functionName: "findResolver",
+    args: [G(xe(s))],
+    blockNumber: n,
+    blockTag: r
+  });
+  return u;
+}
+async function gn(e, t) {
+  var y, m, b;
+  const { account: n = e.account, blockNumber: r, blockTag: s = "latest", blobs: a, data: o, gas: i, gasPrice: u, maxFeePerBlobGas: c, maxFeePerGas: d, maxPriorityFeePerGas: l, to: p, value: f, ...h } = t, g = n ? _(n) : void 0;
+  try {
+    Ge(t);
+    const x = (typeof r == "bigint" ? R(r) : void 0) || s, T = (b = (m = (y = e.chain) == null ? void 0 : y.formatters) == null ? void 0 : m.transactionRequest) == null ? void 0 : b.format, v = (T || Ve)({
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...er(h, { format: T }),
+      from: g == null ? void 0 : g.address,
+      blobs: a,
+      data: o,
+      gas: i,
+      gasPrice: u,
+      maxFeePerBlobGas: c,
+      maxFeePerGas: d,
+      maxPriorityFeePerGas: l,
+      to: p,
+      value: f
+    }), I = await e.request({
+      method: "eth_createAccessList",
+      params: [v, x]
+    });
+    return {
+      accessList: I.accessList,
+      gasUsed: BigInt(I.gasUsed)
+    };
+  } catch (w) {
+    throw tr(w, {
+      ...t,
+      account: g,
+      chain: e.chain
+    });
+  }
+}
+async function $s(e) {
+  const t = Je(e, {
+    method: "eth_newBlockFilter"
+  }), n = await e.request({
+    method: "eth_newBlockFilter"
+  });
+  return { id: n, request: t(n), type: "block" };
+}
+async function bn(e, { address: t, args: n, event: r, events: s, fromBlock: a, strict: o, toBlock: i } = {}) {
+  const u = s ?? (r ? [r] : void 0), c = Je(e, {
+    method: "eth_newFilter"
+  });
+  let d = [];
+  u && (d = [u.flatMap((f) => Ut({
+    abi: [f],
+    eventName: f.name,
+    args: n
+  }))], r && (d = d[0]));
+  const l = await e.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address: t,
+        fromBlock: typeof a == "bigint" ? R(a) : a,
+        toBlock: typeof i == "bigint" ? R(i) : i,
+        ...d.length ? { topics: d } : {}
+      }
+    ]
+  });
+  return {
+    abi: u,
+    args: n,
+    eventName: r ? r.name : void 0,
+    fromBlock: a,
+    id: l,
+    request: c(l),
+    strict: !!o,
+    toBlock: i,
+    type: "event"
+  };
+}
+async function yn(e) {
+  const t = Je(e, {
+    method: "eth_newPendingTransactionFilter"
+  }), n = await e.request({
+    method: "eth_newPendingTransactionFilter"
+  });
+  return { id: n, request: t(n), type: "transaction" };
+}
+async function zs(e) {
+  const t = await e.request({
+    method: "eth_blobBaseFee"
+  });
+  return BigInt(t);
+}
+async function Ds(e, { blockHash: t, blockNumber: n, blockTag: r = "latest" } = {}) {
+  const s = n !== void 0 ? R(n) : void 0;
+  let a;
+  return t ? a = await e.request({
+    method: "eth_getBlockTransactionCountByHash",
+    params: [t]
+  }, { dedupe: !0 }) : a = await e.request({
+    method: "eth_getBlockTransactionCountByNumber",
+    params: [s || r]
+  }, { dedupe: !!s }), be(a);
+}
+async function qt(e, { address: t, blockNumber: n, blockTag: r = "latest" }) {
+  const s = n !== void 0 ? R(n) : void 0, a = await e.request({
+    method: "eth_getCode",
+    params: [t, s || r]
+  }, { dedupe: !!s });
+  if (a !== "0x")
+    return a;
+}
+class Fs extends $ {
+  constructor({ address: t }) {
+    super(`No EIP-712 domain found on contract "${t}".`, {
+      metaMessages: [
+        "Ensure that:",
+        `- The contract is deployed at the address "${t}".`,
+        "- `eip712Domain()` function exists on the contract.",
+        "- `eip712Domain()` function matches signature to ERC-5267 specification."
+      ],
+      name: "Eip712DomainNotFoundError"
+    });
+  }
+}
+async function _s(e, t) {
+  const { address: n, factory: r, factoryData: s } = t;
+  try {
+    const [a, o, i, u, c, d, l] = await C(e, U, "readContract")({
+      abi: qs,
+      address: n,
+      functionName: "eip712Domain",
+      factory: r,
+      factoryData: s
+    });
+    return {
+      domain: {
+        name: o,
+        version: i,
+        chainId: Number(u),
+        verifyingContract: c,
+        salt: d
+      },
+      extensions: l,
+      fields: a
+    };
+  } catch (a) {
+    const o = a;
+    throw o.name === "ContractFunctionExecutionError" && o.cause.name === "ContractFunctionZeroDataError" ? new Fs({ address: n }) : o;
+  }
+}
+const qs = [
+  {
+    inputs: [],
+    name: "eip712Domain",
+    outputs: [
+      { name: "fields", type: "bytes1" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" },
+      { name: "extensions", type: "uint256[]" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function Os(e) {
+  var t;
+  return {
+    baseFeePerGas: e.baseFeePerGas.map((n) => BigInt(n)),
+    gasUsedRatio: e.gasUsedRatio,
+    oldestBlock: BigInt(e.oldestBlock),
+    reward: (t = e.reward) == null ? void 0 : t.map((n) => n.map((r) => BigInt(r)))
+  };
+}
+async function Ms(e, { blockCount: t, blockNumber: n, blockTag: r = "latest", rewardPercentiles: s }) {
+  const a = typeof n == "bigint" ? R(n) : void 0, o = await e.request({
+    method: "eth_feeHistory",
+    params: [
+      R(t),
+      a || r,
+      s
+    ]
+  }, { dedupe: !!a });
+  return Os(o);
+}
+async function Ls(e, { filter: t }) {
+  const n = t.strict ?? !1, s = (await t.request({
+    method: "eth_getFilterLogs",
+    params: [t.id]
+  })).map((a) => we(a));
+  return t.abi ? nr({
+    abi: t.abi,
+    logs: s,
+    strict: n
+  }) : s;
+}
+class Us extends $ {
+  constructor({ domain: t }) {
+    super(`Invalid domain "${F(t)}".`, {
+      metaMessages: ["Must be a valid EIP-712 domain."]
+    });
+  }
+}
+class js extends $ {
+  constructor({ primaryType: t, types: n }) {
+    super(`Invalid primary type \`${t}\` must be one of \`${JSON.stringify(Object.keys(n))}\`.`, {
+      docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
+      metaMessages: ["Check that the primary type is a key in `types`."]
+    });
+  }
+}
+class Hs extends $ {
+  constructor({ type: t }) {
+    super(`Struct type "${t}" is invalid.`, {
+      metaMessages: ["Struct type must not be a Solidity type."],
+      name: "InvalidStructTypeError"
+    });
+  }
+}
+function Ws(e) {
+  const { domain: t = {}, message: n, primaryType: r } = e, s = {
+    EIP712Domain: Cn({ domain: t }),
+    ...e.types
+  };
+  xn({
+    domain: t,
+    message: n,
+    primaryType: r,
+    types: s
+  });
+  const a = ["0x1901"];
+  return t && a.push(Gs({
+    domain: t,
+    types: s
+  })), r !== "EIP712Domain" && a.push(wn({
+    data: n,
+    primaryType: r,
+    types: s
+  })), q(Y(a));
+}
+function Gs({ domain: e, types: t }) {
+  return wn({
+    data: e,
+    primaryType: "EIP712Domain",
+    types: t
+  });
+}
+function wn({ data: e, primaryType: t, types: n }) {
+  const r = vn({
+    data: e,
+    primaryType: t,
+    types: n
+  });
+  return q(r);
+}
+function vn({ data: e, primaryType: t, types: n }) {
+  const r = [{ type: "bytes32" }], s = [Vs({ primaryType: t, types: n })];
+  for (const a of n[t]) {
+    const [o, i] = An({
+      types: n,
+      name: a.name,
+      type: a.type,
+      value: e[a.name]
+    });
+    r.push(o), s.push(i);
+  }
+  return Ze(r, s);
+}
+function Vs({ primaryType: e, types: t }) {
+  const n = G(Js({ primaryType: e, types: t }));
+  return q(n);
+}
+function Js({ primaryType: e, types: t }) {
+  let n = "";
+  const r = Tn({ primaryType: e, types: t });
+  r.delete(e);
+  const s = [e, ...Array.from(r).sort()];
+  for (const a of s)
+    n += `${a}(${t[a].map(({ name: o, type: i }) => `${i} ${o}`).join(",")})`;
+  return n;
+}
+function Tn({ primaryType: e, types: t }, n = /* @__PURE__ */ new Set()) {
+  const r = e.match(/^\w*/u), s = r == null ? void 0 : r[0];
+  if (n.has(s) || t[s] === void 0)
+    return n;
+  n.add(s);
+  for (const a of t[s])
+    Tn({ primaryType: a.type, types: t }, n);
+  return n;
+}
+function An({ types: e, name: t, type: n, value: r }) {
+  if (e[n] !== void 0)
+    return [
+      { type: "bytes32" },
+      q(vn({ data: r, primaryType: n, types: e }))
+    ];
+  if (n === "bytes")
+    return r = `0x${(r.length % 2 ? "0" : "") + r.slice(2)}`, [{ type: "bytes32" }, q(r)];
+  if (n === "string")
+    return [{ type: "bytes32" }, q(G(r))];
+  if (n.lastIndexOf("]") === n.length - 1) {
+    const s = n.slice(0, n.lastIndexOf("[")), a = r.map((o) => An({
+      name: t,
+      type: s,
+      types: e,
+      value: o
+    }));
+    return [
+      { type: "bytes32" },
+      q(Ze(a.map(([o]) => o), a.map(([, o]) => o)))
+    ];
+  }
+  return [{ type: n }, r];
+}
+function Zs(e) {
+  const { domain: t, message: n, primaryType: r, types: s } = e, a = (u, c) => {
+    const d = { ...c };
+    for (const l of u) {
+      const { name: p, type: f } = l;
+      f === "address" && (d[p] = d[p].toLowerCase());
+    }
+    return d;
+  }, o = s.EIP712Domain ? t ? a(s.EIP712Domain, t) : {} : {}, i = (() => {
+    if (r !== "EIP712Domain")
+      return a(s[r], n);
+  })();
+  return F({ domain: o, message: i, primaryType: r, types: s });
+}
+function xn(e) {
+  const { domain: t, message: n, primaryType: r, types: s } = e, a = (o, i) => {
+    for (const u of o) {
+      const { name: c, type: d } = u, l = i[c], p = d.match(rr);
+      if (p && (typeof l == "number" || typeof l == "bigint")) {
+        const [g, y, m] = p;
+        R(l, {
+          signed: y === "int",
+          size: Number.parseInt(m) / 8
+        });
+      }
+      if (d === "address" && typeof l == "string" && !en(l))
+        throw new _r({ address: l });
+      const f = d.match(sr);
+      if (f) {
+        const [g, y] = f;
+        if (y && Fe(l) !== Number.parseInt(y))
+          throw new ar({
+            expectedSize: Number.parseInt(y),
+            givenSize: Fe(l)
+          });
+      }
+      const h = s[d];
+      h && (Ks(d), a(h, l));
+    }
+  };
+  if (s.EIP712Domain && t) {
+    if (typeof t != "object")
+      throw new Us({ domain: t });
+    a(s.EIP712Domain, t);
+  }
+  if (r !== "EIP712Domain")
+    if (s[r])
+      a(s[r], n);
+    else
+      throw new js({ primaryType: r, types: s });
+}
+function Cn({ domain: e }) {
+  return [
+    typeof (e == null ? void 0 : e.name) == "string" && { name: "name", type: "string" },
+    (e == null ? void 0 : e.version) && { name: "version", type: "string" },
+    (typeof (e == null ? void 0 : e.chainId) == "number" || typeof (e == null ? void 0 : e.chainId) == "bigint") && {
+      name: "chainId",
+      type: "uint256"
+    },
+    (e == null ? void 0 : e.verifyingContract) && {
+      name: "verifyingContract",
+      type: "address"
+    },
+    (e == null ? void 0 : e.salt) && { name: "salt", type: "bytes32" }
+  ].filter(Boolean);
+}
+function Ks(e) {
+  if (e === "address" || e === "bool" || e === "string" || e.startsWith("bytes") || e.startsWith("uint") || e.startsWith("int"))
+    throw new Hs({ type: e });
+}
+const Qs = `Ethereum Signed Message:
+`;
+function Xs(e) {
+  const t = typeof e == "string" ? ye(e) : typeof e.raw == "string" ? e.raw : oe(e.raw), n = ye(`${Qs}${Fe(t)}`);
+  return Y([n, t]);
+}
+function En(e, t) {
+  return q(Xs(e), t);
+}
+const kn = "0x6492649264926492649264926492649264926492649264926492649264926492";
+function Ys(e) {
+  return De(e, -32) === kn;
+}
+function ea(e) {
+  const { address: t, data: n, signature: r, to: s = "hex" } = e, a = qr([
+    Ze([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [t, n, r]),
+    kn
+  ]);
+  return s === "hex" ? a : tn(a);
+}
+function ta(e) {
+  return e.map((t) => ({
+    ...t,
+    value: BigInt(t.value)
+  }));
+}
+function na(e) {
+  return {
+    ...e,
+    balance: e.balance ? BigInt(e.balance) : void 0,
+    nonce: e.nonce ? be(e.nonce) : void 0,
+    storageProof: e.storageProof ? ta(e.storageProof) : void 0
+  };
+}
+async function ra(e, { address: t, blockNumber: n, blockTag: r, storageKeys: s }) {
+  const a = r ?? "latest", o = n !== void 0 ? R(n) : void 0, i = await e.request({
+    method: "eth_getProof",
+    params: [t, s, o || a]
+  });
+  return na(i);
+}
+async function sa(e, { address: t, blockNumber: n, blockTag: r = "latest", slot: s }) {
+  const a = n !== void 0 ? R(n) : void 0;
+  return await e.request({
+    method: "eth_getStorageAt",
+    params: [t, s, a || r]
+  });
+}
+async function st(e, { blockHash: t, blockNumber: n, blockTag: r, hash: s, index: a }) {
+  var d, l, p;
+  const o = r || "latest", i = n !== void 0 ? R(n) : void 0;
+  let u = null;
+  if (s ? u = await e.request({
+    method: "eth_getTransactionByHash",
+    params: [s]
+  }, { dedupe: !0 }) : t ? u = await e.request({
+    method: "eth_getTransactionByBlockHashAndIndex",
+    params: [t, R(a)]
+  }, { dedupe: !0 }) : u = await e.request({
+    method: "eth_getTransactionByBlockNumberAndIndex",
+    params: [i || o, R(a)]
+  }, { dedupe: !!i }), !u)
+    throw new nn({
+      blockHash: t,
+      blockNumber: n,
+      blockTag: o,
+      hash: s,
+      index: a
+    });
+  return (((p = (l = (d = e.chain) == null ? void 0 : d.formatters) == null ? void 0 : l.transaction) == null ? void 0 : p.format) || Or)(u);
+}
+async function aa(e, { hash: t, transactionReceipt: n }) {
+  const [r, s] = await Promise.all([
+    C(e, Te, "getBlockNumber")({}),
+    t ? C(e, st, "getTransaction")({ hash: t }) : void 0
+  ]), a = (n == null ? void 0 : n.blockNumber) || (s == null ? void 0 : s.blockNumber);
+  return a ? r - a + 1n : 0n;
+}
+async function ge(e, { hash: t }) {
+  var s, a, o;
+  const n = await e.request({
+    method: "eth_getTransactionReceipt",
+    params: [t]
+  }, { dedupe: !0 });
+  if (!n)
+    throw new rn({ hash: t });
+  return (((o = (a = (s = e.chain) == null ? void 0 : s.formatters) == null ? void 0 : a.transactionReceipt) == null ? void 0 : o.format) || Mr)(n);
+}
+async function oa(e, t) {
+  var m;
+  const { account: n, allowFailure: r = !0, batchSize: s, blockNumber: a, blockTag: o, multicallAddress: i, stateOverride: u } = t, c = t.contracts, d = s ?? (typeof ((m = e.batch) == null ? void 0 : m.multicall) == "object" && e.batch.multicall.batchSize || 1024);
+  let l = i;
+  if (!l) {
+    if (!e.chain)
+      throw new Error("client chain not configured. multicallAddress is required.");
+    l = ce({
+      blockNumber: a,
+      chain: e.chain,
+      contract: "multicall3"
+    });
+  }
+  const p = [[]];
+  let f = 0, h = 0;
+  for (let b = 0; b < c.length; b++) {
+    const { abi: w, address: x, args: T, functionName: k } = c[b];
+    try {
+      const v = W({ abi: w, args: T, functionName: k });
+      h += (v.length - 2) / 2, // Check if batching is enabled.
+      d > 0 && // Check if the current size of the batch exceeds the size limit.
+      h > d && // Check if the current chunk is not already empty.
+      p[f].length > 0 && (f++, h = (v.length - 2) / 2, p[f] = []), p[f] = [
+        ...p[f],
+        {
+          allowFailure: !0,
+          callData: v,
+          target: x
+        }
+      ];
+    } catch (v) {
+      const I = $e(v, {
+        abi: w,
+        address: x,
+        args: T,
+        docsPath: "/docs/contract/multicall",
+        functionName: k,
+        sender: n
+      });
+      if (!r)
+        throw I;
+      p[f] = [
+        ...p[f],
+        {
+          allowFailure: !0,
+          callData: "0x",
+          target: x
+        }
+      ];
+    }
+  }
+  const g = await Promise.allSettled(p.map((b) => C(e, U, "readContract")({
+    abi: or,
+    account: n,
+    address: l,
+    args: [b],
+    blockNumber: a,
+    blockTag: o,
+    functionName: "aggregate3",
+    stateOverride: u
+  }))), y = [];
+  for (let b = 0; b < g.length; b++) {
+    const w = g[b];
+    if (w.status === "rejected") {
+      if (!r)
+        throw w.reason;
+      for (let T = 0; T < p[b].length; T++)
+        y.push({
+          status: "failure",
+          error: w.reason,
+          result: void 0
+        });
+      continue;
+    }
+    const x = w.value;
+    for (let T = 0; T < x.length; T++) {
+      const { returnData: k, success: v } = x[T], { callData: I } = p[b][T], { abi: N, address: B, functionName: E, args: P } = c[y.length];
+      try {
+        if (I === "0x")
+          throw new jt();
+        if (!v)
+          throw new Ht({ data: k });
+        const S = ve({
+          abi: N,
+          args: P,
+          data: k,
+          functionName: E
+        });
+        y.push(r ? { result: S, status: "success" } : S);
+      } catch (S) {
+        const V = $e(S, {
+          abi: N,
+          address: B,
+          args: P,
+          docsPath: "/docs/contract/multicall",
+          functionName: E
+        });
+        if (!r)
+          throw V;
+        y.push({ error: V, result: void 0, status: "failure" });
+      }
+    }
+  }
+  if (y.length !== c.length)
+    throw new $("multicall results mismatch");
+  return y;
+}
+async function Oe(e, t) {
+  const { blockNumber: n, blockTag: r = e.experimental_blockTag ?? "latest", blocks: s, returnFullTransactions: a, traceTransfers: o, validation: i } = t;
+  try {
+    const u = [];
+    for (const p of s) {
+      const f = p.blockOverrides ? ir(p.blockOverrides) : void 0, h = p.calls.map((y) => {
+        const m = y, b = m.account ? _(m.account) : void 0, w = m.abi ? W(m) : m.data, x = {
+          ...m,
+          data: m.dataSuffix ? Y([w || "0x", m.dataSuffix]) : w,
+          from: m.from ?? (b == null ? void 0 : b.address)
+        };
+        return Ge(x), Ve(x);
+      }), g = p.stateOverrides ? cr(p.stateOverrides) : void 0;
+      u.push({
+        blockOverrides: f,
+        calls: h,
+        stateOverrides: g
+      });
+    }
+    const d = (typeof n == "bigint" ? R(n) : void 0) || r;
+    return (await e.request({
+      method: "eth_simulateV1",
+      params: [
+        { blockStateCalls: u, returnFullTransactions: a, traceTransfers: o, validation: i },
+        d
+      ]
+    })).map((p, f) => ({
+      ...Lr(p),
+      calls: p.calls.map((h, g) => {
+        var B, E;
+        const { abi: y, args: m, functionName: b, to: w } = s[f].calls[g], x = ((B = h.error) == null ? void 0 : B.data) ?? h.returnData, T = BigInt(h.gasUsed), k = (E = h.logs) == null ? void 0 : E.map((P) => we(P)), v = h.status === "0x1" ? "success" : "failure", I = y && v === "success" && x !== "0x" ? ve({
+          abi: y,
+          data: x,
+          functionName: b
+        }) : null, N = (() => {
+          var S;
+          if (v === "success")
+            return;
+          let P;
+          if (((S = h.error) == null ? void 0 : S.data) === "0x" ? P = new jt() : h.error && (P = new Ht(h.error)), !!P)
+            return $e(P, {
+              abi: y ?? [],
+              address: w ?? "0x",
+              args: m,
+              functionName: b ?? "<unknown>"
+            });
+        })();
+        return {
+          data: x,
+          gasUsed: T,
+          logs: k,
+          status: v,
+          ...v === "success" ? {
+            result: I
+          } : {
+            error: N
+          }
+        };
+      })
+    }));
+  } catch (u) {
+    const c = u, d = ur(c, {});
+    throw d instanceof Ur ? c : d;
+  }
+}
+function In(e, t = {}) {
+  const { as: n = typeof e == "string" ? "Hex" : "Bytes" } = t, r = jr(Qr(e));
+  return n === "Bytes" ? r : dr(r);
+}
+class ia extends Map {
+  constructor(t) {
+    super(), Object.defineProperty(this, "maxSize", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.maxSize = t;
+  }
+  get(t) {
+    const n = super.get(t);
+    return super.has(t) && n !== void 0 && (this.delete(t), super.set(t, n)), n;
+  }
+  set(t, n) {
+    if (super.set(t, n), this.maxSize && this.size > this.maxSize) {
+      const r = this.keys().next().value;
+      r && this.delete(r);
+    }
+    return this;
+  }
+}
+const ca = {
+  checksum: /* @__PURE__ */ new ia(8192)
+}, Ie = ca.checksum, ua = /^0x[a-fA-F0-9]{40}$/;
+function Ce(e, t = {}) {
+  const { strict: n = !0 } = t;
+  if (!ua.test(e))
+    throw new Ot({
+      address: e,
+      cause: new fa()
+    });
+  if (n) {
+    if (e.toLowerCase() === e)
+      return;
+    if (da(e) !== e)
+      throw new Ot({
+        address: e,
+        cause: new la()
+      });
+  }
+}
+function da(e) {
+  if (Ie.has(e))
+    return Ie.get(e);
+  Ce(e, { strict: !1 });
+  const t = e.substring(2).toLowerCase(), n = In(es(t), { as: "Bytes" }), r = t.split("");
+  for (let a = 0; a < 40; a += 2)
+    n[a >> 1] >> 4 >= 8 && r[a] && (r[a] = r[a].toUpperCase()), (n[a >> 1] & 15) >= 8 && r[a + 1] && (r[a + 1] = r[a + 1].toUpperCase());
+  const s = `0x${r.join("")}`;
+  return Ie.set(e, s), s;
+}
+function Me(e, t = {}) {
+  const { strict: n = !0 } = t ?? {};
+  try {
+    return Ce(e, { strict: n }), !0;
+  } catch {
+    return !1;
+  }
+}
+class Ot extends D {
+  constructor({ address: t, cause: n }) {
+    super(`Address "${t}" is invalid.`, {
+      cause: n
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Address.InvalidAddressError"
+    });
+  }
+}
+class fa extends D {
+  constructor() {
+    super("Address is not a 20 byte (40 hexadecimal character) value."), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Address.InvalidInputError"
+    });
+  }
+}
+class la extends D {
+  constructor() {
+    super("Address does not match its checksum counterpart."), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "Address.InvalidChecksumError"
+    });
+  }
+}
+function Le(e) {
+  let t = !0, n = "", r = 0, s = "", a = !1;
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o];
+    if (["(", ")", ","].includes(i) && (t = !0), i === "(" && r++, i === ")" && r--, !!t) {
+      if (r === 0) {
+        if (i === " " && ["event", "function", "error", ""].includes(s))
+          s = "";
+        else if (s += i, i === ")") {
+          a = !0;
+          break;
+        }
+        continue;
+      }
+      if (i === " ") {
+        e[o - 1] !== "," && n !== "," && n !== ",(" && (n = "", t = !1);
+        continue;
+      }
+      s += i, n += i;
+    }
+  }
+  if (!a)
+    throw new D("Unable to normalize signature.");
+  return s;
+}
+function Ue(e, t) {
+  const n = typeof e, r = t.type;
+  switch (r) {
+    case "address":
+      return Me(e, { strict: !1 });
+    case "bool":
+      return n === "boolean";
+    case "function":
+      return n === "string";
+    case "string":
+      return n === "string";
+    default:
+      return r === "tuple" && "components" in t ? Object.values(t.components).every((s, a) => Ue(Object.values(e)[a], s)) : /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(r) ? n === "number" || n === "bigint" : /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(r) ? n === "string" || e instanceof Uint8Array : /[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(r) ? Array.isArray(e) && e.every((s) => Ue(s, {
+        ...t,
+        // Pop off `[]` or `[M]` from end of type
+        type: r.replace(/(\[[0-9]{0,}\])$/, "")
+      })) : !1;
+  }
+}
+function Nn(e, t, n) {
+  for (const r in e) {
+    const s = e[r], a = t[r];
+    if (s.type === "tuple" && a.type === "tuple" && "components" in s && "components" in a)
+      return Nn(s.components, a.components, n[r]);
+    const o = [s.type, a.type];
+    if (o.includes("address") && o.includes("bytes20") ? !0 : o.includes("address") && o.includes("string") ? Me(n[r], {
+      strict: !1
+    }) : o.includes("address") && o.includes("bytes") ? Me(n[r], {
+      strict: !1
+    }) : !1)
+      return o;
+  }
+}
+function Rn(e, t = {}) {
+  const { prepare: n = !0 } = t, r = Array.isArray(e) || typeof e == "string" ? $t(e) : e;
+  return {
+    ...r,
+    ...n ? { hash: K(r) } : {}
+  };
+}
+function pa(e, t, n) {
+  const { args: r = [], prepare: s = !0 } = n ?? {}, a = fr(t, { strict: !1 }), o = e.filter((c) => a ? c.type === "function" || c.type === "error" ? Pn(c) === Ke(t, 0, 4) : c.type === "event" ? K(c) === t : !1 : "name" in c && c.name === t);
+  if (o.length === 0)
+    throw new je({ name: t });
+  if (o.length === 1)
+    return {
+      ...o[0],
+      ...s ? { hash: K(o[0]) } : {}
+    };
+  let i;
+  for (const c of o) {
+    if (!("inputs" in c))
+      continue;
+    if (!r || r.length === 0) {
+      if (!c.inputs || c.inputs.length === 0)
+        return {
+          ...c,
+          ...s ? { hash: K(c) } : {}
+        };
+      continue;
+    }
+    if (!c.inputs || c.inputs.length === 0 || c.inputs.length !== r.length)
+      continue;
+    if (r.every((l, p) => {
+      const f = "inputs" in c && c.inputs[p];
+      return f ? Ue(l, f) : !1;
+    })) {
+      if (i && "inputs" in i && i.inputs) {
+        const l = Nn(c.inputs, i.inputs, r);
+        if (l)
+          throw new ma({
+            abiItem: c,
+            type: l[0]
+          }, {
+            abiItem: i,
+            type: l[1]
+          });
+      }
+      i = c;
+    }
+  }
+  const u = (() => {
+    if (i)
+      return i;
+    const [c, ...d] = o;
+    return { ...c, overloads: d };
+  })();
+  if (!u)
+    throw new je({ name: t });
+  return {
+    ...u,
+    ...s ? { hash: K(u) } : {}
+  };
+}
+function Pn(e) {
+  return Ke(K(e), 0, 4);
+}
+function ha(e) {
+  const t = typeof e == "string" ? e : ze(e);
+  return Le(t);
+}
+function K(e) {
+  return typeof e != "string" && "hash" in e && e.hash ? e.hash : In(Qe(ha(e)));
+}
+class ma extends D {
+  constructor(t, n) {
+    super("Found ambiguous types in overloaded ABI Items.", {
+      metaMessages: [
+        // TODO: abitype to add support for signature-formatted ABI items.
+        `\`${t.type}\` in \`${Le(ze(t.abiItem))}\`, and`,
+        `\`${n.type}\` in \`${Le(ze(n.abiItem))}\``,
+        "",
+        "These types encode differently and cannot be distinguished at runtime.",
+        "Remove one of the ambiguous items in the ABI."
+      ]
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiItem.AmbiguityError"
+    });
+  }
+}
+class je extends D {
+  constructor({ name: t, data: n, type: r = "item" }) {
+    const s = t ? ` with name "${t}"` : n ? ` with data "${n}"` : "";
+    super(`ABI ${r}${s} not found.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiItem.NotFoundError"
+    });
+  }
+}
+const ga = /^(.*)\[([0-9]*)\]$/, ba = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/, Sn = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+function ya({ checksumAddress: e, parameters: t, values: n }) {
+  const r = [];
+  for (let s = 0; s < t.length; s++)
+    r.push(at({
+      checksumAddress: e,
+      parameter: t[s],
+      value: n[s]
+    }));
+  return r;
+}
+function at({ checksumAddress: e = !1, parameter: t, value: n }) {
+  const r = t, s = ka(r.type);
+  if (s) {
+    const [a, o] = s;
+    return va(n, {
+      checksumAddress: e,
+      length: a,
+      parameter: {
+        ...r,
+        type: o
+      }
+    });
+  }
+  if (r.type === "tuple")
+    return Ea(n, {
+      checksumAddress: e,
+      parameter: r
+    });
+  if (r.type === "address")
+    return wa(n, {
+      checksum: e
+    });
+  if (r.type === "bool")
+    return Aa(n);
+  if (r.type.startsWith("uint") || r.type.startsWith("int")) {
+    const a = r.type.startsWith("int"), [, , o = "256"] = Sn.exec(r.type) ?? [];
+    return xa(n, {
+      signed: a,
+      size: Number(o)
+    });
+  }
+  if (r.type.startsWith("bytes"))
+    return Ta(n, { type: r.type });
+  if (r.type === "string")
+    return Ca(n);
+  throw new Dn(r.type);
+}
+function ot(e) {
+  let t = 0;
+  for (let a = 0; a < e.length; a++) {
+    const { dynamic: o, encoded: i } = e[a];
+    o ? t += 32 : t += X(i);
+  }
+  const n = [], r = [];
+  let s = 0;
+  for (let a = 0; a < e.length; a++) {
+    const { dynamic: o, encoded: i } = e[a];
+    o ? (n.push(ee(t + s, { size: 32 })), r.push(i), s += X(i)) : n.push(i);
+  }
+  return M(...n, ...r);
+}
+function wa(e, t) {
+  const { checksum: n = !1 } = t;
+  return Ce(e, { strict: n }), {
+    dynamic: !1,
+    encoded: ae(e.toLowerCase())
+  };
+}
+function va(e, t) {
+  const { checksumAddress: n, length: r, parameter: s } = t, a = r === null;
+  if (!Array.isArray(e))
+    throw new Na(e);
+  if (!a && e.length !== r)
+    throw new Ia({
+      expectedLength: r,
+      givenLength: e.length,
+      type: `${s.type}[${r}]`
+    });
+  let o = !1;
+  const i = [];
+  for (let u = 0; u < e.length; u++) {
+    const c = at({
+      checksumAddress: n,
+      parameter: s,
+      value: e[u]
+    });
+    c.dynamic && (o = !0), i.push(c);
+  }
+  if (a || o) {
+    const u = ot(i);
+    if (a) {
+      const c = ee(i.length, { size: 32 });
+      return {
+        dynamic: !0,
+        encoded: i.length > 0 ? M(c, u) : c
+      };
+    }
+    if (o)
+      return { dynamic: !0, encoded: u };
+  }
+  return {
+    dynamic: !1,
+    encoded: M(...i.map(({ encoded: u }) => u))
+  };
+}
+function Ta(e, { type: t }) {
+  const [, n] = t.split("bytes"), r = X(e);
+  if (!n) {
+    let s = e;
+    return r % 32 !== 0 && (s = Q(s, Math.ceil((e.length - 2) / 2 / 32) * 32)), {
+      dynamic: !0,
+      encoded: M(ae(ee(r, { size: 32 })), s)
+    };
+  }
+  if (r !== Number.parseInt(n))
+    throw new $n({
+      expectedSize: Number.parseInt(n),
+      value: e
+    });
+  return { dynamic: !1, encoded: Q(e) };
+}
+function Aa(e) {
+  if (typeof e != "boolean")
+    throw new D(`Invalid boolean value: "${e}" (type: ${typeof e}). Expected: \`true\` or \`false\`.`);
+  return { dynamic: !1, encoded: ae(Wt(e)) };
+}
+function xa(e, { signed: t, size: n }) {
+  if (typeof n == "number") {
+    const r = 2n ** (BigInt(n) - (t ? 1n : 0n)) - 1n, s = t ? -r - 1n : 0n;
+    if (e > r || e < s)
+      throw new lr({
+        max: r.toString(),
+        min: s.toString(),
+        signed: t,
+        size: n / 8,
+        value: e.toString()
+      });
+  }
+  return {
+    dynamic: !1,
+    encoded: ee(e, {
+      size: 32,
+      signed: t
+    })
+  };
+}
+function Ca(e) {
+  const t = Qe(e), n = Math.ceil(X(t) / 32), r = [];
+  for (let s = 0; s < n; s++)
+    r.push(Q(Ke(t, s * 32, (s + 1) * 32)));
+  return {
+    dynamic: !0,
+    encoded: M(Q(ee(X(t), { size: 32 })), ...r)
+  };
+}
+function Ea(e, t) {
+  const { checksumAddress: n, parameter: r } = t;
+  let s = !1;
+  const a = [];
+  for (let o = 0; o < r.components.length; o++) {
+    const i = r.components[o], u = Array.isArray(e) ? o : i.name, c = at({
+      checksumAddress: n,
+      parameter: i,
+      value: e[u]
+    });
+    a.push(c), c.dynamic && (s = !0);
+  }
+  return {
+    dynamic: s,
+    encoded: s ? ot(a) : M(...a.map(({ encoded: o }) => o))
+  };
+}
+function ka(e) {
+  const t = e.match(/^(.*)\[(\d+)?\]$/);
+  return t ? (
+    // Return `null` if the array is dynamic.
+    [t[2] ? Number(t[2]) : null, t[1]]
+  ) : void 0;
+}
+function Bn(e, t, n) {
+  const { checksumAddress: r = !1 } = {};
+  if (e.length !== t.length)
+    throw new zn({
+      expectedLength: e.length,
+      givenLength: t.length
+    });
+  const s = ya({
+    checksumAddress: r,
+    parameters: e,
+    values: t
+  }), a = ot(s);
+  return a.length === 0 ? "0x" : a;
+}
+function He(e, t) {
+  if (e.length !== t.length)
+    throw new zn({
+      expectedLength: e.length,
+      givenLength: t.length
+    });
+  const n = [];
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r], a = t[r];
+    n.push(He.encode(s, a));
+  }
+  return M(...n);
+}
+(function(e) {
+  function t(n, r, s = !1) {
+    if (n === "address") {
+      const u = r;
+      return Ce(u), ae(u.toLowerCase(), s ? 32 : 0);
+    }
+    if (n === "string")
+      return Qe(r);
+    if (n === "bytes")
+      return r;
+    if (n === "bool")
+      return ae(Wt(r), s ? 32 : 1);
+    const a = n.match(Sn);
+    if (a) {
+      const [u, c, d = "256"] = a, l = Number.parseInt(d) / 8;
+      return ee(r, {
+        size: s ? 32 : l,
+        signed: c === "int"
+      });
+    }
+    const o = n.match(ba);
+    if (o) {
+      const [u, c] = o;
+      if (Number.parseInt(c) !== (r.length - 2) / 2)
+        throw new $n({
+          expectedSize: Number.parseInt(c),
+          value: r
+        });
+      return Q(r, s ? 32 : 0);
+    }
+    const i = n.match(ga);
+    if (i && Array.isArray(r)) {
+      const [u, c] = i, d = [];
+      for (let l = 0; l < r.length; l++)
+        d.push(t(c, r[l], !0));
+      return d.length === 0 ? "0x" : M(...d);
+    }
+    throw new Dn(n);
+  }
+  e.encode = t;
+})(He || (He = {}));
+class Ia extends D {
+  constructor({ expectedLength: t, givenLength: n, type: r }) {
+    super(`Array length mismatch for type \`${r}\`. Expected: \`${t}\`. Given: \`${n}\`.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiParameters.ArrayLengthMismatchError"
+    });
+  }
+}
+class $n extends D {
+  constructor({ expectedSize: t, value: n }) {
+    super(`Size of bytes "${n}" (bytes${X(n)}) does not match expected size (bytes${t}).`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiParameters.BytesSizeMismatchError"
+    });
+  }
+}
+class zn extends D {
+  constructor({ expectedLength: t, givenLength: n }) {
+    super([
+      "ABI encoding parameters/values length mismatch.",
+      `Expected length (parameters): ${t}`,
+      `Given length (values): ${n}`
+    ].join(`
+`)), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiParameters.LengthMismatchError"
+    });
+  }
+}
+class Na extends D {
+  constructor(t) {
+    super(`Value \`${t}\` is not a valid array.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiParameters.InvalidArrayError"
+    });
+  }
+}
+class Dn extends D {
+  constructor(t) {
+    super(`Type \`${t}\` is not a valid ABI Type.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "AbiParameters.InvalidTypeError"
+    });
+  }
+}
+function Ra(e, t) {
+  var s;
+  const { bytecode: n, args: r } = t;
+  return M(n, (s = e.inputs) != null && s.length && (r != null && r.length) ? Bn(e.inputs, r) : "0x");
+}
+function Pa(e) {
+  return Rn(e);
+}
+function Sa(e, ...t) {
+  const { overloads: n } = e, r = n ? Ba([e, ...n], e.name, {
+    args: t[0]
+  }) : e, s = $a(r), a = t.length > 0 ? Bn(r.inputs, t[0]) : void 0;
+  return a ? M(s, a) : s;
+}
+function J(e, t = {}) {
+  return Rn(e, t);
+}
+function Ba(e, t, n) {
+  const r = pa(e, t, n);
+  if (r.type !== "function")
+    throw new je({ name: t, type: "function" });
+  return r;
+}
+function $a(e) {
+  return Pn(e);
+}
+const za = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", O = "0x0000000000000000000000000000000000000000", Da = "0x6080604052348015600e575f80fd5b5061016d8061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063f8b2cb4f1461002d575b5f80fd5b610047600480360381019061004291906100db565b61005d565b604051610054919061011e565b60405180910390f35b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100aa82610081565b9050919050565b6100ba816100a0565b81146100c4575f80fd5b50565b5f813590506100d5816100b1565b92915050565b5f602082840312156100f0576100ef61007d565b5b5f6100fd848285016100c7565b91505092915050565b5f819050919050565b61011881610106565b82525050565b5f6020820190506101315f83018461010f565b9291505056fea26469706673582212203b9fe929fe995c7cf9887f0bdba8a36dd78e8b73f149b17d2d9ad7cd09d2dc6264736f6c634300081a0033";
+async function Fa(e, t) {
+  const { blockNumber: n, blockTag: r, calls: s, stateOverrides: a, traceAssetChanges: o, traceTransfers: i, validation: u } = t, c = t.account ? _(t.account) : void 0;
+  if (o && !c)
+    throw new $("`account` is required when `traceAssetChanges` is true");
+  const d = c ? Ra(Pa("constructor(bytes, bytes)"), {
+    bytecode: pr,
+    args: [
+      Da,
+      Sa(J("function getBalance(address)"), [c.address])
+    ]
+  }) : void 0, l = o ? await Promise.all(t.calls.map(async (A) => {
+    if (!A.data && !A.abi)
+      return;
+    const { accessList: z } = await gn(e, {
+      account: c.address,
+      ...A,
+      data: A.abi ? W(A) : A.data
+    });
+    return z.map(({ address: te, storageKeys: de }) => de.length > 0 ? te : null);
+  })).then((A) => A.flat().filter(Boolean)) : [], p = await Oe(e, {
+    blockNumber: n,
+    blockTag: r,
+    blocks: [
+      ...o ? [
+        // ETH pre balances
+        {
+          calls: [{ data: d }],
+          stateOverrides: a
+        },
+        // Asset pre balances
+        {
+          calls: l.map((A, z) => ({
+            abi: [
+              J("function balanceOf(address) returns (uint256)")
+            ],
+            functionName: "balanceOf",
+            args: [c.address],
+            to: A,
+            from: O,
+            nonce: z
+          })),
+          stateOverrides: [
+            {
+              address: O,
+              nonce: 0
+            }
+          ]
+        }
+      ] : [],
+      {
+        calls: [...s, {}].map((A) => ({
+          ...A,
+          from: c == null ? void 0 : c.address
+        })),
+        stateOverrides: a
+      },
+      ...o ? [
+        // ETH post balances
+        {
+          calls: [{ data: d }]
+        },
+        // Asset post balances
+        {
+          calls: l.map((A, z) => ({
+            abi: [
+              J("function balanceOf(address) returns (uint256)")
+            ],
+            functionName: "balanceOf",
+            args: [c.address],
+            to: A,
+            from: O,
+            nonce: z
+          })),
+          stateOverrides: [
+            {
+              address: O,
+              nonce: 0
+            }
+          ]
+        },
+        // Decimals
+        {
+          calls: l.map((A, z) => ({
+            to: A,
+            abi: [
+              J("function decimals() returns (uint256)")
+            ],
+            functionName: "decimals",
+            from: O,
+            nonce: z
+          })),
+          stateOverrides: [
+            {
+              address: O,
+              nonce: 0
+            }
+          ]
+        },
+        // Token URI
+        {
+          calls: l.map((A, z) => ({
+            to: A,
+            abi: [
+              J("function tokenURI(uint256) returns (string)")
+            ],
+            functionName: "tokenURI",
+            args: [0n],
+            from: O,
+            nonce: z
+          })),
+          stateOverrides: [
+            {
+              address: O,
+              nonce: 0
+            }
+          ]
+        },
+        // Symbols
+        {
+          calls: l.map((A, z) => ({
+            to: A,
+            abi: [J("function symbol() returns (string)")],
+            functionName: "symbol",
+            from: O,
+            nonce: z
+          })),
+          stateOverrides: [
+            {
+              address: O,
+              nonce: 0
+            }
+          ]
+        }
+      ] : []
+    ],
+    traceTransfers: i,
+    validation: u
+  }), f = o ? p[2] : p[0], [h, g, , y, m, b, w, x] = o ? p : [], { calls: T, ...k } = f, v = T.slice(0, -1) ?? [], I = (h == null ? void 0 : h.calls) ?? [], N = (g == null ? void 0 : g.calls) ?? [], B = [...I, ...N].map((A) => A.status === "success" ? j(A.data) : null), E = (y == null ? void 0 : y.calls) ?? [], P = (m == null ? void 0 : m.calls) ?? [], S = [...E, ...P].map((A) => A.status === "success" ? j(A.data) : null), V = ((b == null ? void 0 : b.calls) ?? []).map((A) => A.status === "success" ? A.result : null), qn = ((x == null ? void 0 : x.calls) ?? []).map((A) => A.status === "success" ? A.result : null), On = ((w == null ? void 0 : w.calls) ?? []).map((A) => A.status === "success" ? A.result : null), Ee = [];
+  for (const [A, z] of S.entries()) {
+    const te = B[A];
+    if (typeof z != "bigint" || typeof te != "bigint")
+      continue;
+    const de = V[A - 1], Mn = qn[A - 1], Ln = On[A - 1], ct = A === 0 ? {
+      address: za,
+      decimals: 18,
+      symbol: "ETH"
+    } : {
+      address: l[A - 1],
+      decimals: Ln || de ? Number(de ?? 1) : void 0,
+      symbol: Mn ?? void 0
+    };
+    Ee.some((Un) => Un.token.address === ct.address) || Ee.push({
+      token: ct,
+      value: {
+        pre: te,
+        post: z,
+        diff: z - te
+      }
+    });
+  }
+  return {
+    assetChanges: Ee,
+    block: k,
+    results: v
+  };
+}
+function _a({ r: e, s: t, to: n = "hex", v: r, yParity: s }) {
+  const a = (() => {
+    if (s === 0 || s === 1)
+      return s;
+    if (r && (r === 27n || r === 28n || r >= 35n))
+      return r % 2n === 0n ? 1 : 0;
+    throw new Error("Invalid `v` or `yParity` value");
+  })(), o = `0x${new Vr.Signature(j(e), j(t)).toCompactHex()}${a === 0 ? "1b" : "1c"}`;
+  return n === "hex" ? o : tn(o);
+}
+async function it(e, t) {
+  var l, p, f;
+  const { address: n, factory: r, factoryData: s, hash: a, signature: o, universalSignatureVerifierAddress: i = (f = (p = (l = e.chain) == null ? void 0 : l.contracts) == null ? void 0 : p.universalSignatureVerifier) == null ? void 0 : f.address, ...u } = t, c = Yt(o) ? o : typeof o == "object" && "r" in o && "s" in o ? _a(o) : oe(o), d = await (async () => !r && !s || Ys(c) ? c : ea({
+    address: r,
+    data: s,
+    signature: c
+  }))();
+  try {
+    const h = i ? {
+      to: i,
+      data: W({
+        abi: Bt,
+        functionName: "isValidSig",
+        args: [n, a, d]
+      }),
+      ...u
+    } : {
+      data: Gt({
+        abi: Bt,
+        args: [n, a, d],
+        bytecode: hr
+      }),
+      ...u
+    }, { data: g } = await C(e, Vt, "call")(h);
+    return Hr(g ?? "0x0");
+  } catch (h) {
+    try {
+      if (Xe(sn(n), await mr({ hash: a, signature: o })))
+        return !0;
+    } catch {
+    }
+    if (h instanceof gr)
+      return !1;
+    throw h;
+  }
+}
+async function qa(e, { address: t, message: n, factory: r, factoryData: s, signature: a, ...o }) {
+  const i = En(n);
+  return it(e, {
+    address: t,
+    factory: r,
+    factoryData: s,
+    hash: i,
+    signature: a,
+    ...o
+  });
+}
+async function Oa(e, t) {
+  const { address: n, factory: r, factoryData: s, signature: a, message: o, primaryType: i, types: u, domain: c, ...d } = t, l = Ws({ message: o, primaryType: i, types: u, domain: c });
+  return it(e, {
+    address: n,
+    factory: r,
+    factoryData: s,
+    hash: l,
+    signature: a,
+    ...d
+  });
+}
+function Fn(e, { emitOnBegin: t = !1, emitMissed: n = !1, onBlockNumber: r, onError: s, poll: a, pollingInterval: o = e.pollingInterval }) {
+  const i = typeof a < "u" ? a : !(e.transport.type === "webSocket" || e.transport.type === "ipc" || e.transport.type === "fallback" && (e.transport.transports[0].config.type === "webSocket" || e.transport.transports[0].config.type === "ipc"));
+  let u;
+  return i ? (() => {
+    const l = F([
+      "watchBlockNumber",
+      e.uid,
+      t,
+      n,
+      o
+    ]);
+    return H(l, { onBlockNumber: r, onError: s }, (p) => ie(async () => {
+      var f;
+      try {
+        const h = await C(e, Te, "getBlockNumber")({ cacheTime: 0 });
+        if (u) {
+          if (h === u)
+            return;
+          if (h - u > 1 && n)
+            for (let g = u + 1n; g < h; g++)
+              p.onBlockNumber(g, u), u = g;
+        }
+        (!u || h > u) && (p.onBlockNumber(h, u), u = h);
+      } catch (h) {
+        (f = p.onError) == null || f.call(p, h);
+      }
+    }, {
+      emitOnBegin: t,
+      interval: o
+    }));
+  })() : (() => {
+    const l = F([
+      "watchBlockNumber",
+      e.uid,
+      t,
+      n
+    ]);
+    return H(l, { onBlockNumber: r, onError: s }, (p) => {
+      let f = !0, h = () => f = !1;
+      return (async () => {
+        try {
+          const g = (() => {
+            if (e.transport.type === "fallback") {
+              const m = e.transport.transports.find((b) => b.config.type === "webSocket" || b.config.type === "ipc");
+              return m ? m.value : e.transport;
+            }
+            return e.transport;
+          })(), { unsubscribe: y } = await g.subscribe({
+            params: ["newHeads"],
+            onData(m) {
+              var w;
+              if (!f)
+                return;
+              const b = j((w = m.result) == null ? void 0 : w.number);
+              p.onBlockNumber(b, u), u = b;
+            },
+            onError(m) {
+              var b;
+              (b = p.onError) == null || b.call(p, m);
+            }
+          });
+          h = y, f || h();
+        } catch (g) {
+          s == null || s(g);
+        }
+      })(), () => h();
+    });
+  })();
+}
+async function Ma(e, t) {
+  const {
+    checkReplacement: n = !0,
+    confirmations: r = 1,
+    hash: s,
+    onReplaced: a,
+    retryCount: o = 6,
+    retryDelay: i = ({ count: T }) => ~~(1 << T) * 200,
+    // exponential backoff
+    timeout: u = 18e4
+  } = t, c = F(["waitForTransactionReceipt", e.uid, s]), d = (() => {
+    var T;
+    return t.pollingInterval ? t.pollingInterval : (T = e.chain) != null && T.experimental_preconfirmationTime ? e.chain.experimental_preconfirmationTime : e.pollingInterval;
+  })();
+  let l, p, f, h = !1, g, y;
+  const { promise: m, resolve: b, reject: w } = Mt(), x = u ? setTimeout(() => {
+    y(), g(), w(new Wr({ hash: s }));
+  }, u) : void 0;
+  return g = H(c, { onReplaced: a, resolve: b, reject: w }, async (T) => {
+    if (f = await C(e, ge, "getTransactionReceipt")({ hash: s }).catch(() => {
+    }), f && r <= 1) {
+      clearTimeout(x), T.resolve(f), g();
+      return;
+    }
+    y = C(e, Fn, "watchBlockNumber")({
+      emitMissed: !0,
+      emitOnBegin: !0,
+      poll: !0,
+      pollingInterval: d,
+      async onBlockNumber(k) {
+        const v = (N) => {
+          clearTimeout(x), y(), N(), g();
+        };
+        let I = k;
+        if (!h)
+          try {
+            if (f) {
+              if (r > 1 && (!f.blockNumber || I - f.blockNumber + 1n < r))
+                return;
+              v(() => T.resolve(f));
+              return;
+            }
+            if (n && !l && (h = !0, await qe(async () => {
+              l = await C(e, st, "getTransaction")({ hash: s }), l.blockNumber && (I = l.blockNumber);
+            }, {
+              delay: i,
+              retryCount: o
+            }), h = !1), f = await C(e, ge, "getTransactionReceipt")({ hash: s }), r > 1 && (!f.blockNumber || I - f.blockNumber + 1n < r))
+              return;
+            v(() => T.resolve(f));
+          } catch (N) {
+            if (N instanceof nn || N instanceof rn) {
+              if (!l) {
+                h = !1;
+                return;
+              }
+              try {
+                p = l, h = !0;
+                const B = await qe(() => C(e, Z, "getBlock")({
+                  blockNumber: I,
+                  includeTransactions: !0
+                }), {
+                  delay: i,
+                  retryCount: o,
+                  shouldRetry: ({ error: S }) => S instanceof br
+                });
+                h = !1;
+                const E = B.transactions.find(({ from: S, nonce: V }) => S === p.from && V === p.nonce);
+                if (!E || (f = await C(e, ge, "getTransactionReceipt")({
+                  hash: E.hash
+                }), r > 1 && (!f.blockNumber || I - f.blockNumber + 1n < r)))
+                  return;
+                let P = "replaced";
+                E.to === p.to && E.value === p.value && E.input === p.input ? P = "repriced" : E.from === E.to && E.value === 0n && (P = "cancelled"), v(() => {
+                  var S;
+                  (S = T.onReplaced) == null || S.call(T, {
+                    reason: P,
+                    replacedTransaction: p,
+                    transaction: E,
+                    transactionReceipt: f
+                  }), T.resolve(f);
+                });
+              } catch (B) {
+                v(() => T.reject(B));
+              }
+            } else
+              v(() => T.reject(N));
+          }
+      }
+    });
+  }), m;
+}
+function La(e, { blockTag: t = e.experimental_blockTag ?? "latest", emitMissed: n = !1, emitOnBegin: r = !1, onBlock: s, onError: a, includeTransactions: o, poll: i, pollingInterval: u = e.pollingInterval }) {
+  const c = typeof i < "u" ? i : !(e.transport.type === "webSocket" || e.transport.type === "ipc" || e.transport.type === "fallback" && (e.transport.transports[0].config.type === "webSocket" || e.transport.transports[0].config.type === "ipc")), d = o ?? !1;
+  let l;
+  return c ? (() => {
+    const h = F([
+      "watchBlocks",
+      e.uid,
+      t,
+      n,
+      r,
+      d,
+      u
+    ]);
+    return H(h, { onBlock: s, onError: a }, (g) => ie(async () => {
+      var y;
+      try {
+        const m = await C(e, Z, "getBlock")({
+          blockTag: t,
+          includeTransactions: d
+        });
+        if (m.number !== null && (l == null ? void 0 : l.number) != null) {
+          if (m.number === l.number)
+            return;
+          if (m.number - l.number > 1 && n)
+            for (let b = (l == null ? void 0 : l.number) + 1n; b < m.number; b++) {
+              const w = await C(e, Z, "getBlock")({
+                blockNumber: b,
+                includeTransactions: d
+              });
+              g.onBlock(w, l), l = w;
+            }
+        }
+        // If no previous block exists, emit.
+        ((l == null ? void 0 : l.number) == null || // If the block tag is "pending" with no block number, emit.
+        t === "pending" && (m == null ? void 0 : m.number) == null || // If the next block number is greater than the previous block number, emit.
+        // We don't want to emit blocks in the past.
+        m.number !== null && m.number > l.number) && (g.onBlock(m, l), l = m);
+      } catch (m) {
+        (y = g.onError) == null || y.call(g, m);
+      }
+    }, {
+      emitOnBegin: r,
+      interval: u
+    }));
+  })() : (() => {
+    let h = !0, g = !0, y = () => h = !1;
+    return (async () => {
+      try {
+        r && C(e, Z, "getBlock")({
+          blockTag: t,
+          includeTransactions: d
+        }).then((w) => {
+          h && g && (s(w, void 0), g = !1);
+        }).catch(a);
+        const m = (() => {
+          if (e.transport.type === "fallback") {
+            const w = e.transport.transports.find((x) => x.config.type === "webSocket" || x.config.type === "ipc");
+            return w ? w.value : e.transport;
+          }
+          return e.transport;
+        })(), { unsubscribe: b } = await m.subscribe({
+          params: ["newHeads"],
+          async onData(w) {
+            var T;
+            if (!h)
+              return;
+            const x = await C(e, Z, "getBlock")({
+              blockNumber: (T = w.result) == null ? void 0 : T.number,
+              includeTransactions: d
+            }).catch(() => {
+            });
+            h && (s(x, l), g = !1, l = x);
+          },
+          onError(w) {
+            a == null || a(w);
+          }
+        });
+        y = b, h || y();
+      } catch (m) {
+        a == null || a(m);
+      }
+    })(), () => y();
+  })();
+}
+function Ua(e, { address: t, args: n, batch: r = !0, event: s, events: a, fromBlock: o, onError: i, onLogs: u, poll: c, pollingInterval: d = e.pollingInterval, strict: l }) {
+  const p = typeof c < "u" ? c : typeof o == "bigint" ? !0 : !(e.transport.type === "webSocket" || e.transport.type === "ipc" || e.transport.type === "fallback" && (e.transport.transports[0].config.type === "webSocket" || e.transport.transports[0].config.type === "ipc")), f = l ?? !1;
+  return p ? (() => {
+    const y = F([
+      "watchEvent",
+      t,
+      n,
+      r,
+      e.uid,
+      s,
+      d,
+      o
+    ]);
+    return H(y, { onLogs: u, onError: i }, (m) => {
+      let b;
+      o !== void 0 && (b = o - 1n);
+      let w, x = !1;
+      const T = ie(async () => {
+        var k;
+        if (!x) {
+          try {
+            w = await C(e, bn, "createEventFilter")({
+              address: t,
+              args: n,
+              event: s,
+              events: a,
+              strict: f,
+              fromBlock: o
+            });
+          } catch {
+          }
+          x = !0;
+          return;
+        }
+        try {
+          let v;
+          if (w)
+            v = await C(e, Ye, "getFilterChanges")({ filter: w });
+          else {
+            const I = await C(e, Te, "getBlockNumber")({});
+            b && b !== I ? v = await C(e, Jt, "getLogs")({
+              address: t,
+              args: n,
+              event: s,
+              events: a,
+              fromBlock: b + 1n,
+              toBlock: I
+            }) : v = [], b = I;
+          }
+          if (v.length === 0)
+            return;
+          if (r)
+            m.onLogs(v);
+          else
+            for (const I of v)
+              m.onLogs([I]);
+        } catch (v) {
+          w && v instanceof Se && (x = !1), (k = m.onError) == null || k.call(m, v);
+        }
+      }, {
+        emitOnBegin: !0,
+        interval: d
+      });
+      return async () => {
+        w && await C(e, et, "uninstallFilter")({ filter: w }), T();
+      };
+    });
+  })() : (() => {
+    let y = !0, m = () => y = !1;
+    return (async () => {
+      try {
+        const b = (() => {
+          if (e.transport.type === "fallback") {
+            const k = e.transport.transports.find((v) => v.config.type === "webSocket" || v.config.type === "ipc");
+            return k ? k.value : e.transport;
+          }
+          return e.transport;
+        })(), w = a ?? (s ? [s] : void 0);
+        let x = [];
+        w && (x = [w.flatMap((v) => Ut({
+          abi: [v],
+          eventName: v.name,
+          args: n
+        }))], s && (x = x[0]));
+        const { unsubscribe: T } = await b.subscribe({
+          params: ["logs", { address: t, topics: x }],
+          onData(k) {
+            var I;
+            if (!y)
+              return;
+            const v = k.result;
+            try {
+              const { eventName: N, args: B } = yr({
+                abi: w ?? [],
+                data: v.data,
+                topics: v.topics,
+                strict: f
+              }), E = we(v, { args: B, eventName: N });
+              u([E]);
+            } catch (N) {
+              let B, E;
+              if (N instanceof wr || N instanceof vr) {
+                if (l)
+                  return;
+                B = N.abiItem.name, E = (I = N.abiItem.inputs) == null ? void 0 : I.some((S) => !("name" in S && S.name));
+              }
+              const P = we(v, {
+                args: E ? [] : {},
+                eventName: B
+              });
+              u([P]);
+            }
+          },
+          onError(k) {
+            i == null || i(k);
+          }
+        });
+        m = T, y || m();
+      } catch (b) {
+        i == null || i(b);
+      }
+    })(), () => m();
+  })();
+}
+function ja(e, { batch: t = !0, onError: n, onTransactions: r, poll: s, pollingInterval: a = e.pollingInterval }) {
+  return (typeof s < "u" ? s : e.transport.type !== "webSocket" && e.transport.type !== "ipc") ? (() => {
+    const c = F([
+      "watchPendingTransactions",
+      e.uid,
+      t,
+      a
+    ]);
+    return H(c, { onTransactions: r, onError: n }, (d) => {
+      let l;
+      const p = ie(async () => {
+        var f;
+        try {
+          if (!l)
+            try {
+              l = await C(e, yn, "createPendingTransactionFilter")({});
+              return;
+            } catch (g) {
+              throw p(), g;
+            }
+          const h = await C(e, Ye, "getFilterChanges")({ filter: l });
+          if (h.length === 0)
+            return;
+          if (t)
+            d.onTransactions(h);
+          else
+            for (const g of h)
+              d.onTransactions([g]);
+        } catch (h) {
+          (f = d.onError) == null || f.call(d, h);
+        }
+      }, {
+        emitOnBegin: !0,
+        interval: a
+      });
+      return async () => {
+        l && await C(e, et, "uninstallFilter")({ filter: l }), p();
+      };
+    });
+  })() : (() => {
+    let c = !0, d = () => c = !1;
+    return (async () => {
+      try {
+        const { unsubscribe: l } = await e.transport.subscribe({
+          params: ["newPendingTransactions"],
+          onData(p) {
+            if (!c)
+              return;
+            const f = p.result;
+            r([f]);
+          },
+          onError(p) {
+            n == null || n(p);
+          }
+        });
+        d = l, c || d();
+      } catch (l) {
+        n == null || n(l);
+      }
+    })(), () => d();
+  })();
+}
+function Ha(e) {
+  var l, p, f;
+  const { scheme: t, statement: n, ...r } = ((l = e.match(Wa)) == null ? void 0 : l.groups) ?? {}, { chainId: s, expirationTime: a, issuedAt: o, notBefore: i, requestId: u, ...c } = ((p = e.match(Ga)) == null ? void 0 : p.groups) ?? {}, d = (f = e.split("Resources:")[1]) == null ? void 0 : f.split(`
+- `).slice(1);
+  return {
+    ...r,
+    ...c,
+    ...s ? { chainId: Number(s) } : {},
+    ...a ? { expirationTime: new Date(a) } : {},
+    ...o ? { issuedAt: new Date(o) } : {},
+    ...i ? { notBefore: new Date(i) } : {},
+    ...u ? { requestId: u } : {},
+    ...d ? { resources: d } : {},
+    ...t ? { scheme: t } : {},
+    ...n ? { statement: n } : {}
+  };
+}
+const Wa = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/, Ga = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;
+function Va(e) {
+  const { address: t, domain: n, message: r, nonce: s, scheme: a, time: o = /* @__PURE__ */ new Date() } = e;
+  if (n && r.domain !== n || s && r.nonce !== s || a && r.scheme !== a || r.expirationTime && o >= r.expirationTime || r.notBefore && o < r.notBefore)
+    return !1;
+  try {
+    if (!r.address || !en(r.address, { strict: !1 }) || t && !Xe(r.address, t))
+      return !1;
+  } catch {
+    return !1;
+  }
+  return !0;
+}
+async function Ja(e, t) {
+  const { address: n, domain: r, message: s, nonce: a, scheme: o, signature: i, time: u = /* @__PURE__ */ new Date(), ...c } = t, d = Ha(s);
+  if (!d.address || !Va({
+    address: n,
+    domain: r,
+    message: d,
+    nonce: a,
+    scheme: o,
+    time: u
+  }))
+    return !1;
+  const p = En(s);
+  return it(e, {
+    address: d.address,
+    hash: p,
+    signature: i,
+    ...c
+  });
+}
+function Za(e) {
+  return {
+    call: (t) => Vt(e, t),
+    createAccessList: (t) => gn(e, t),
+    createBlockFilter: () => $s(e),
+    createContractEventFilter: (t) => Pr(e, t),
+    createEventFilter: (t) => bn(e, t),
+    createPendingTransactionFilter: () => yn(e),
+    estimateContractGas: (t) => Rr(e, t),
+    estimateGas: (t) => Nr(e, t),
+    getBalance: (t) => Ir(e, t),
+    getBlobBaseFee: () => zs(e),
+    getBlock: (t) => Z(e, t),
+    getBlockNumber: (t) => Te(e, t),
+    getBlockTransactionCount: (t) => Ds(e, t),
+    getBytecode: (t) => qt(e, t),
+    getChainId: () => Ae(e),
+    getCode: (t) => qt(e, t),
+    getContractEvents: (t) => kr(e, t),
+    getEip712Domain: (t) => _s(e, t),
+    getEnsAddress: (t) => bs(e, t),
+    getEnsAvatar: (t) => Ps(e, t),
+    getEnsName: (t) => Ss(e, t),
+    getEnsResolver: (t) => Bs(e, t),
+    getEnsText: (t) => mn(e, t),
+    getFeeHistory: (t) => Ms(e, t),
+    estimateFeesPerGas: (t) => Er(e, t),
+    getFilterChanges: (t) => Ye(e, t),
+    getFilterLogs: (t) => Ls(e, t),
+    getGasPrice: () => Cr(e),
+    getLogs: (t) => Jt(e, t),
+    getProof: (t) => ra(e, t),
+    estimateMaxPriorityFeePerGas: (t) => xr(e, t),
+    getStorageAt: (t) => sa(e, t),
+    getTransaction: (t) => st(e, t),
+    getTransactionConfirmations: (t) => aa(e, t),
+    getTransactionCount: (t) => Qt(e, t),
+    getTransactionReceipt: (t) => ge(e, t),
+    multicall: (t) => oa(e, t),
+    prepareTransactionRequest: (t) => Kt(e, t),
+    readContract: (t) => U(e, t),
+    sendRawTransaction: (t) => Zt(e, t),
+    simulate: (t) => Oe(e, t),
+    simulateBlocks: (t) => Oe(e, t),
+    simulateCalls: (t) => Fa(e, t),
+    simulateContract: (t) => Ar(e, t),
+    verifyMessage: (t) => qa(e, t),
+    verifySiweMessage: (t) => Ja(e, t),
+    verifyTypedData: (t) => Oa(e, t),
+    uninstallFilter: (t) => et(e, t),
+    waitForTransactionReceipt: (t) => Ma(e, t),
+    watchBlocks: (t) => La(e, t),
+    watchBlockNumber: (t) => Fn(e, t),
+    watchContractEvent: (t) => Tr(e, t),
+    watchEvent: (t) => Ua(e, t),
+    watchPendingTransactions: (t) => ja(e, t)
+  };
+}
+function bo(e) {
+  const { key: t = "public", name: n = "Public Client" } = e;
+  return fn({
+    ...e,
+    key: t,
+    name: n,
+    type: "publicClient"
+  }).extend(Za);
+}
+async function Ka(e, { chain: t }) {
+  const { id: n, name: r, nativeCurrency: s, rpcUrls: a, blockExplorers: o } = t;
+  await e.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: R(n),
+        chainName: r,
+        nativeCurrency: s,
+        rpcUrls: a.default.http,
+        blockExplorerUrls: o ? Object.values(o).map(({ url: i }) => i) : void 0
+      }
+    ]
+  }, { dedupe: !0, retryCount: 0 });
+}
+function Qa(e, t) {
+  const { abi: n, args: r, bytecode: s, ...a } = t, o = Gt({ abi: n, args: r, bytecode: s });
+  return We(e, {
+    ...a,
+    ...a.authorizationList ? { to: null } : {},
+    data: o
+  });
+}
+async function Xa(e) {
+  var n;
+  return ((n = e.account) == null ? void 0 : n.type) === "local" ? [e.account.address] : (await e.request({ method: "eth_accounts" }, { dedupe: !0 })).map((r) => Gr(r));
+}
+async function Ya(e, t = {}) {
+  const { account: n = e.account, chainId: r } = t, s = n ? _(n) : void 0, a = r ? [s == null ? void 0 : s.address, [R(r)]] : [s == null ? void 0 : s.address], o = await e.request({
+    method: "wallet_getCapabilities",
+    params: a
+  }), i = {};
+  for (const [u, c] of Object.entries(o)) {
+    i[Number(u)] = {};
+    for (let [d, l] of Object.entries(c))
+      d === "addSubAccount" && (d = "unstable_addSubAccount"), i[Number(u)][d] = l;
+  }
+  return typeof r == "number" ? i[r] : i;
+}
+async function eo(e) {
+  return await e.request({ method: "wallet_getPermissions" }, { dedupe: !0 });
+}
+async function _n(e, t) {
+  var u;
+  const { account: n = e.account, chainId: r, nonce: s } = t;
+  if (!n)
+    throw new ue({
+      docsPath: "/docs/eip7702/prepareAuthorization"
+    });
+  const a = _(n), o = (() => {
+    if (t.executor)
+      return t.executor === "self" ? t.executor : _(t.executor);
+  })(), i = {
+    address: t.contractAddress ?? t.address,
+    chainId: r,
+    nonce: s
+  };
+  return typeof i.chainId > "u" && (i.chainId = ((u = e.chain) == null ? void 0 : u.id) ?? await C(e, Ae, "getChainId")({})), typeof i.nonce > "u" && (i.nonce = await C(e, Qt, "getTransactionCount")({
+    address: a.address,
+    blockTag: "pending"
+  }), (o === "self" || o != null && o.address && Xe(o.address, a.address)) && (i.nonce += 1)), i;
+}
+async function to(e) {
+  return (await e.request({ method: "eth_requestAccounts" }, { dedupe: !0, retryCount: 0 })).map((n) => sn(n));
+}
+async function no(e, t) {
+  return e.request({
+    method: "wallet_requestPermissions",
+    params: [t]
+  }, { retryCount: 0 });
+}
+async function ro(e, t) {
+  const { id: n } = t;
+  await e.request({
+    method: "wallet_showCallsStatus",
+    params: [n]
+  });
+}
+async function so(e, t) {
+  const { account: n = e.account } = t;
+  if (!n)
+    throw new ue({
+      docsPath: "/docs/eip7702/signAuthorization"
+    });
+  const r = _(n);
+  if (!r.signAuthorization)
+    throw new Sr({
+      docsPath: "/docs/eip7702/signAuthorization",
+      metaMessages: [
+        "The `signAuthorization` Action does not support JSON-RPC Accounts."
+      ],
+      type: r.type
+    });
+  const s = await _n(e, t);
+  return r.signAuthorization(s);
+}
+async function ao(e, { account: t = e.account, message: n }) {
+  if (!t)
+    throw new ue({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const r = _(t);
+  if (r.signMessage)
+    return r.signMessage({ message: n });
+  const s = typeof n == "string" ? ye(n) : n.raw instanceof Uint8Array ? G(n.raw) : n.raw;
+  return e.request({
+    method: "personal_sign",
+    params: [s, r.address]
+  }, { retryCount: 0 });
+}
+async function oo(e, t) {
+  var c, d, l, p;
+  const { account: n = e.account, chain: r = e.chain, ...s } = t;
+  if (!n)
+    throw new ue({
+      docsPath: "/docs/actions/wallet/signTransaction"
+    });
+  const a = _(n);
+  Ge({
+    account: a,
+    ...t
+  });
+  const o = await C(e, Ae, "getChainId")({});
+  r !== null && Br({
+    currentChainId: o,
+    chain: r
+  });
+  const i = (r == null ? void 0 : r.formatters) || ((c = e.chain) == null ? void 0 : c.formatters), u = ((d = i == null ? void 0 : i.transactionRequest) == null ? void 0 : d.format) || Ve;
+  return a.signTransaction ? a.signTransaction({
+    ...s,
+    chainId: o
+  }, { serializer: (p = (l = e.chain) == null ? void 0 : l.serializers) == null ? void 0 : p.transaction }) : await e.request({
+    method: "eth_signTransaction",
+    params: [
+      {
+        ...u(s),
+        chainId: R(o),
+        from: a.address
+      }
+    ]
+  }, { retryCount: 0 });
+}
+async function io(e, t) {
+  const { account: n = e.account, domain: r, message: s, primaryType: a } = t;
+  if (!n)
+    throw new ue({
+      docsPath: "/docs/actions/wallet/signTypedData"
+    });
+  const o = _(n), i = {
+    EIP712Domain: Cn({ domain: r }),
+    ...t.types
+  };
+  if (xn({ domain: r, message: s, primaryType: a, types: i }), o.signTypedData)
+    return o.signTypedData({ domain: r, message: s, primaryType: a, types: i });
+  const u = Zs({ domain: r, message: s, primaryType: a, types: i });
+  return e.request({
+    method: "eth_signTypedData_v4",
+    params: [o.address, u]
+  }, { retryCount: 0 });
+}
+async function co(e, { id: t }) {
+  await e.request({
+    method: "wallet_switchEthereumChain",
+    params: [
+      {
+        chainId: R(t)
+      }
+    ]
+  }, { retryCount: 0 });
+}
+async function uo(e, t) {
+  return await e.request({
+    method: "wallet_watchAsset",
+    params: t
+  }, { retryCount: 0 });
+}
+function fo(e) {
+  return {
+    addChain: (t) => Ka(e, t),
+    deployContract: (t) => Qa(e, t),
+    getAddresses: () => Xa(e),
+    getCallsStatus: (t) => un(e, t),
+    getCapabilities: (t) => Ya(e, t),
+    getChainId: () => Ae(e),
+    getPermissions: () => eo(e),
+    prepareAuthorization: (t) => _n(e, t),
+    prepareTransactionRequest: (t) => Kt(e, t),
+    requestAddresses: () => to(e),
+    requestPermissions: (t) => no(e, t),
+    sendCalls: (t) => ss(e, t),
+    sendRawTransaction: (t) => Zt(e, t),
+    sendTransaction: (t) => We(e, t),
+    showCallsStatus: (t) => ro(e, t),
+    signAuthorization: (t) => so(e, t),
+    signMessage: (t) => ao(e, t),
+    signTransaction: (t) => oo(e, t),
+    signTypedData: (t) => io(e, t),
+    switchChain: (t) => co(e, t),
+    waitForCallsStatus: (t) => as(e, t),
+    watchAsset: (t) => uo(e, t),
+    writeContract: (t) => $r(e, t)
+  };
+}
+function yo(e) {
+  const { key: t = "wallet", name: n = "Wallet Client", transport: r } = e;
+  return fn({
+    ...e,
+    key: t,
+    name: n,
+    transport: r,
+    type: "walletClient"
+  }).extend(fo);
+}
+export {
+  bo as a,
+  ds as b,
+  yo as c,
+  go as h
+};
+//# sourceMappingURL=createWalletClient-CYva1_XM.js.map