@pufferfinance/puffer-sdk 1.13.0 → 1.13.2

package/dist/createWalletClient-DNLhBkOd.js

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