@pufferfinance/puffer-sdk 1.8.1 → 1.9.1

package/dist/createWalletClient-DNcW-ENe.js

@@ -0,0 +1,2028 @@
+import { g as R, r as q, p as V, l as Et, f as B, H as L, m as It, U as ee, S as Ce, C as Ee, P as Ie, n as Ne, o as ke, J as xe, L as te, M as Ae, T as Pe, R as Be, q as De, I as re, t as ne, u as qe, v as Fe, x as Se, y as _e, z as Me, A as Nt, B as kt, D as $e, E as xt, F as j, G as Q, K as ze, N as Ge, O as de, Q as Le, V as At, W as fe, X as Ze, Y as Pt, k as le, Z as Bt, _ as Dt, $ as qt, a0 as K, a1 as Ue, a2 as Ft, a3 as St, a4 as _t, a5 as He, a6 as Je, a7 as Mt, j as Ve, i as Qe, a8 as $t, a9 as zt, aa as M, ab as X, ac as Lt, ad as _, ae as Ut, af as Ht, ag as jt, ah as Ot, ai as pe, aj as he, ak as Ke, c as Wt, e as Gt, al as Zt, am as Jt, an as me, a as Vt, ao as Qt, ap as Kt, aq as Xt, ar as Yt, as as Xe, at as Ye, s as er, w as tr, au as et, av as ge, aw as rr, ax as nr, ay as ar, b as sr } from "./writeContract-ChuHpJLC.js";
+import { B as D, n as k, L as or, k as P, s as J, i as tt, b as H, t as ir, a as U, c as ye, d as S, e as cr, h as rt, f as ae, g as ur, I as dr, j as se, l as fr, m as lr, o as nt, T as at, q as pr, r as st, u as hr, v as oe, w as mr, x as ot, W as gr, y as yr } from "./constants-BjRNQpT2.js";
+import { secp256k1 as wr } from "./secp256k1-3OC5y4qp.js";
+class br extends D {
+  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 vr(e, t) {
+  const { address: r, factory: n, factoryData: a } = t;
+  try {
+    const [s, o, u, d, f, i, c] = await R(e, q, "readContract")({
+      abi: Tr,
+      address: r,
+      functionName: "eip712Domain",
+      factory: n,
+      factoryData: a
+    });
+    return {
+      domain: {
+        name: o,
+        version: u,
+        chainId: Number(d),
+        verifyingContract: f,
+        salt: i
+      },
+      extensions: c,
+      fields: s
+    };
+  } catch (s) {
+    const o = s;
+    throw o.name === "ContractFunctionExecutionError" && o.cause.name === "ContractFunctionZeroDataError" ? new br({ address: r }) : o;
+  }
+}
+const Tr = [
+  {
+    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 Rr(e, { chain: t }) {
+  const { id: r, name: n, nativeCurrency: a, rpcUrls: s, blockExplorers: o } = t;
+  await e.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: k(r),
+        chainName: n,
+        nativeCurrency: a,
+        rpcUrls: s.default.http,
+        blockExplorerUrls: o ? Object.values(o).map(({ url: u }) => u) : void 0
+      }
+    ]
+  }, { dedupe: !0, retryCount: 0 });
+}
+const ie = 256;
+let O = ie, W;
+function it(e = 11) {
+  if (!W || O + e > ie * 2) {
+    W = "", O = 0;
+    for (let t = 0; t < ie; t++)
+      W += (256 + Math.random() * 256 | 0).toString(16).substring(1);
+  }
+  return W.substring(O, O++ + e);
+}
+function ct(e) {
+  const { batch: t, cacheTime: r = e.pollingInterval ?? 4e3, ccipRead: n, key: a = "base", name: s = "Base Client", pollingInterval: o = 4e3, type: u = "base" } = e, d = e.chain, f = e.account ? V(e.account) : void 0, { config: i, request: c, value: l } = e.transport({
+    chain: d,
+    pollingInterval: o
+  }), h = { ...i, ...l }, m = {
+    account: f,
+    batch: t,
+    cacheTime: r,
+    ccipRead: n,
+    chain: d,
+    key: a,
+    name: s,
+    pollingInterval: o,
+    request: c,
+    transport: h,
+    type: u,
+    uid: it()
+  };
+  function g(b) {
+    return (p) => {
+      const y = p(b);
+      for (const T in m)
+        delete y[T];
+      const w = { ...b, ...y };
+      return Object.assign(w, { extend: g(w) });
+    };
+  }
+  return Object.assign(m, { extend: g(m) });
+}
+const G = /* @__PURE__ */ new or(8192);
+function Cr(e, { enabled: t = !0, id: r }) {
+  if (!t || !r)
+    return e();
+  if (G.get(r))
+    return G.get(r);
+  const n = e().finally(() => G.delete(r));
+  return G.set(r, n), n;
+}
+function ce(e, { delay: t = 100, retryCount: r = 2, shouldRetry: n = () => !0 } = {}) {
+  return new Promise((a, s) => {
+    const o = async ({ count: u = 0 } = {}) => {
+      const d = async ({ error: f }) => {
+        const i = typeof t == "function" ? t({ count: u, error: f }) : t;
+        i && await Et(i), o({ count: u + 1 });
+      };
+      try {
+        const f = await e();
+        a(f);
+      } catch (f) {
+        if (u < r && await n({ count: u, error: f }))
+          return d({ error: f });
+        s(f);
+      }
+    };
+    o();
+  });
+}
+function Er(e, t = {}) {
+  return async (r, n = {}) => {
+    const { dedupe: a = !1, retryDelay: s = 150, retryCount: o = 3, uid: u } = {
+      ...t,
+      ...n
+    }, d = a ? P(J(`${u}.${B(r)}`)) : void 0;
+    return Cr(() => ce(async () => {
+      try {
+        return await e(r);
+      } catch (f) {
+        const i = f;
+        switch (i.code) {
+          // -32700
+          case _e.code:
+            throw new _e(i);
+          // -32600
+          case Se.code:
+            throw new Se(i);
+          // -32601
+          case Fe.code:
+            throw new Fe(i, { method: r.method });
+          // -32602
+          case qe.code:
+            throw new qe(i);
+          // -32603
+          case ne.code:
+            throw new ne(i);
+          // -32000
+          case re.code:
+            throw new re(i);
+          // -32001
+          case De.code:
+            throw new De(i);
+          // -32002
+          case Be.code:
+            throw new Be(i);
+          // -32003
+          case Pe.code:
+            throw new Pe(i);
+          // -32004
+          case Ae.code:
+            throw new Ae(i, {
+              method: r.method
+            });
+          // -32005
+          case te.code:
+            throw new te(i);
+          // -32006
+          case xe.code:
+            throw new xe(i);
+          // 4001
+          case ee.code:
+            throw new ee(i);
+          // 4100
+          case ke.code:
+            throw new ke(i);
+          // 4200
+          case Ne.code:
+            throw new Ne(i);
+          // 4900
+          case Ie.code:
+            throw new Ie(i);
+          // 4901
+          case Ee.code:
+            throw new Ee(i);
+          // 4902
+          case Ce.code:
+            throw new Ce(i);
+          // CAIP-25: User Rejected Error
+          // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
+          case 5e3:
+            throw new ee(i);
+          default:
+            throw f instanceof D ? f : new It(i);
+        }
+      }
+    }, {
+      delay: ({ count: f, error: i }) => {
+        var c;
+        if (i && i instanceof L) {
+          const l = (c = i == null ? void 0 : i.headers) == null ? void 0 : c.get("Retry-After");
+          if (l != null && l.match(/\d/))
+            return Number.parseInt(l) * 1e3;
+        }
+        return ~~(1 << f) * s;
+      },
+      retryCount: o,
+      shouldRetry: ({ error: f }) => Ir(f)
+    }), { enabled: a, id: d });
+  };
+}
+function Ir(e) {
+  return "code" in e && typeof e.code == "number" ? e.code === -1 || e.code === te.code || e.code === ne.code : e instanceof L && 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 Nr({ key: e, name: t, request: r, retryCount: n = 3, retryDelay: a = 150, timeout: s, type: o }, u) {
+  const d = it();
+  return {
+    config: {
+      key: e,
+      name: t,
+      request: r,
+      retryCount: n,
+      retryDelay: a,
+      timeout: s,
+      type: o
+    },
+    request: Er(r, { retryCount: n, retryDelay: a, uid: d }),
+    value: u
+  };
+}
+class kr extends D {
+  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 xr(e, { errorInstance: t = new Error("timed out"), timeout: r, signal: n }) {
+  return new Promise((a, s) => {
+    (async () => {
+      let o;
+      try {
+        const u = new AbortController();
+        r > 0 && (o = setTimeout(() => {
+          n ? u.abort() : s(t);
+        }, r)), a(await e({ signal: (u == null ? void 0 : u.signal) || null }));
+      } catch (u) {
+        (u == null ? void 0 : u.name) === "AbortError" && s(t), s(u);
+      } finally {
+        clearTimeout(o);
+      }
+    })();
+  });
+}
+function Ar() {
+  return {
+    current: 0,
+    take() {
+      return this.current++;
+    },
+    reset() {
+      this.current = 0;
+    }
+  };
+}
+const je = /* @__PURE__ */ Ar();
+function Pr(e, t = {}) {
+  return {
+    async request(r) {
+      var c;
+      const { body: n, onRequest: a = t.onRequest, onResponse: s = t.onResponse, timeout: o = t.timeout ?? 1e4 } = r, u = {
+        ...t.fetchOptions ?? {},
+        ...r.fetchOptions ?? {}
+      }, { headers: d, method: f, signal: i } = u;
+      try {
+        const l = await xr(async ({ signal: m }) => {
+          const g = {
+            ...u,
+            body: Array.isArray(n) ? B(n.map((w) => ({
+              jsonrpc: "2.0",
+              id: w.id ?? je.take(),
+              ...w
+            }))) : B({
+              jsonrpc: "2.0",
+              id: n.id ?? je.take(),
+              ...n
+            }),
+            headers: {
+              "Content-Type": "application/json",
+              ...d
+            },
+            method: f || "POST",
+            signal: i || (o > 0 ? m : null)
+          }, b = new Request(e, g), p = await (a == null ? void 0 : a(b, g)) ?? { ...g, url: e };
+          return await fetch(p.url ?? e, p);
+        }, {
+          errorInstance: new Me({ body: n, url: e }),
+          timeout: o,
+          signal: !0
+        });
+        s && await s(l);
+        let h;
+        if ((c = l.headers.get("Content-Type")) != null && c.startsWith("application/json"))
+          h = await l.json();
+        else {
+          h = await l.text();
+          try {
+            h = JSON.parse(h || "{}");
+          } catch (m) {
+            if (l.ok)
+              throw m;
+            h = { error: h };
+          }
+        }
+        if (!l.ok)
+          throw new L({
+            body: n,
+            details: B(h.error) || l.statusText,
+            headers: l.headers,
+            status: l.status,
+            url: e
+          });
+        return h;
+      } catch (l) {
+        throw l instanceof L || l instanceof Me ? l : new L({
+          body: n,
+          cause: l,
+          url: e
+        });
+      }
+    }
+  };
+}
+function Jn(e, t = {}) {
+  const { batch: r, fetchOptions: n, key: a = "http", name: s = "HTTP JSON-RPC", onFetchRequest: o, onFetchResponse: u, retryDelay: d } = t;
+  return ({ chain: f, retryCount: i, timeout: c }) => {
+    const { batchSize: l = 1e3, wait: h = 0 } = typeof r == "object" ? r : {}, m = t.retryCount ?? i, g = c ?? t.timeout ?? 1e4, b = e || (f == null ? void 0 : f.rpcUrls.default.http[0]);
+    if (!b)
+      throw new kr();
+    const p = Pr(b, {
+      fetchOptions: n,
+      onRequest: o,
+      onResponse: u,
+      timeout: g
+    });
+    return Nr({
+      key: a,
+      name: s,
+      async request({ method: y, params: w }) {
+        const T = { method: y, params: w }, { schedule: I } = kt({
+          id: b,
+          wait: h,
+          shouldSplitBatch(E) {
+            return E.length > l;
+          },
+          fn: (E) => p.request({
+            body: E
+          }),
+          sort: (E, A) => E.id - A.id
+        }), C = async (E) => r ? I(E) : [
+          await p.request({
+            body: E
+          })
+        ], [{ error: v, result: N }] = await C(T);
+        if (v)
+          throw new Nt({
+            body: T,
+            error: v,
+            url: b
+          });
+        return N;
+      },
+      retryCount: m,
+      retryDelay: d,
+      timeout: g,
+      type: "http"
+    }, {
+      fetchOptions: n,
+      url: b
+    });
+  };
+}
+function we(e, t) {
+  var n, a, s, o, u, d;
+  if (!(e instanceof D))
+    return !1;
+  const r = e.walk((f) => f instanceof $e);
+  return r instanceof $e ? !!(((n = r.data) == null ? void 0 : n.errorName) === "ResolverNotFound" || ((a = r.data) == null ? void 0 : a.errorName) === "ResolverWildcardNotSupported" || ((s = r.data) == null ? void 0 : s.errorName) === "ResolverNotContract" || ((o = r.data) == null ? void 0 : o.errorName) === "ResolverError" || ((u = r.data) == null ? void 0 : u.errorName) === "HttpError" || (d = r.reason) != null && d.includes("Wildcard on non-extended resolvers is not supported") || t === "reverse" && r.reason === xt[50]) : !1;
+}
+function ut(e) {
+  if (e.length !== 66 || e.indexOf("[") !== 0 || e.indexOf("]") !== 65)
+    return null;
+  const t = `0x${e.slice(1, 65)}`;
+  return tt(t) ? t : null;
+}
+function Z(e) {
+  let t = new Uint8Array(32).fill(0);
+  if (!e)
+    return H(t);
+  const r = e.split(".");
+  for (let n = r.length - 1; n >= 0; n -= 1) {
+    const a = ut(r[n]), s = a ? ir(a) : P(U(r[n]), "bytes");
+    t = P(ye([t, s]), "bytes");
+  }
+  return H(t);
+}
+function Br(e) {
+  return `[${e.slice(2)}]`;
+}
+function Dr(e) {
+  const t = new Uint8Array(32).fill(0);
+  return e ? ut(e) || P(U(e)) : H(t);
+}
+function Y(e) {
+  const t = e.replace(/^\.|\.$/gm, "");
+  if (t.length === 0)
+    return new Uint8Array(1);
+  const r = new Uint8Array(U(t).byteLength + 2);
+  let n = 0;
+  const a = t.split(".");
+  for (let s = 0; s < a.length; s++) {
+    let o = U(a[s]);
+    o.byteLength > 255 && (o = U(Br(Dr(a[s])))), 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 qr(e, { blockNumber: t, blockTag: r, coinType: n, name: a, gatewayUrls: s, strict: o, universalResolverAddress: u }) {
+  let d = u;
+  if (!d) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    d = j({
+      blockNumber: t,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  try {
+    const f = Q({
+      abi: ze,
+      functionName: "addr",
+      ...n != null ? { args: [Z(a), BigInt(n)] } : { args: [Z(a)] }
+    }), i = {
+      address: d,
+      abi: Ge,
+      functionName: "resolve",
+      args: [S(Y(a)), f],
+      blockNumber: t,
+      blockTag: r
+    }, c = R(e, q, "readContract"), l = s ? await c({
+      ...i,
+      args: [...i.args, s]
+    }) : await c(i);
+    if (l[0] === "0x")
+      return null;
+    const h = de({
+      abi: ze,
+      args: n != null ? [Z(a), BigInt(n)] : void 0,
+      functionName: "addr",
+      data: l[0]
+    });
+    return h === "0x" || cr(h) === "0x00" ? null : h;
+  } catch (f) {
+    if (o)
+      throw f;
+    if (we(f, "resolve"))
+      return null;
+    throw f;
+  }
+}
+class Fr extends D {
+  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 z extends D {
+  constructor({ reason: t }) {
+    super(`ENS NFT avatar URI is invalid. ${t}`, {
+      name: "EnsAvatarInvalidNftUriError"
+    });
+  }
+}
+class be extends D {
+  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 Sr extends D {
+  constructor({ namespace: t }) {
+    super(`ENS NFT avatar namespace "${t}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
+  }
+}
+const _r = /(?<protocol>https?:\/\/[^\/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/, Mr = /^(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>\/.*)?$/, $r = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/, zr = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
+async function Lr(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 Oe(e, t) {
+  return e ? e.endsWith("/") ? e.slice(0, -1) : e : t;
+}
+function dt({ uri: e, gatewayUrls: t }) {
+  const r = $r.test(e);
+  if (r)
+    return { uri: e, isOnChain: !0, isEncoded: r };
+  const n = Oe(t == null ? void 0 : t.ipfs, "https://ipfs.io"), a = Oe(t == null ? void 0 : t.arweave, "https://arweave.net"), s = e.match(_r), { protocol: o, subpath: u, target: d, subtarget: f = "" } = (s == null ? void 0 : s.groups) || {}, i = o === "ipns:/" || u === "ipns/", c = o === "ipfs:/" || u === "ipfs/" || Mr.test(e);
+  if (e.startsWith("http") && !i && !c) {
+    let h = e;
+    return t != null && t.arweave && (h = e.replace(/https:\/\/arweave.net/g, t == null ? void 0 : t.arweave)), { uri: h, isOnChain: !1, isEncoded: !1 };
+  }
+  if ((i || c) && d)
+    return {
+      uri: `${n}/${i ? "ipns" : "ipfs"}/${d}${f}`,
+      isOnChain: !1,
+      isEncoded: !1
+    };
+  if (o === "ar:/" && d)
+    return {
+      uri: `${a}/${d}${f || ""}`,
+      isOnChain: !1,
+      isEncoded: !1
+    };
+  let l = e.replace(zr, "");
+  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 be({ uri: e });
+}
+function ft(e) {
+  if (typeof e != "object" || !("image" in e) && !("image_url" in e) && !("image_data" in e))
+    throw new Fr({ data: e });
+  return e.image || e.image_url || e.image_data;
+}
+async function Ur({ gatewayUrls: e, uri: t }) {
+  try {
+    const r = await fetch(t).then((a) => a.json());
+    return await ve({
+      gatewayUrls: e,
+      uri: ft(r)
+    });
+  } catch {
+    throw new be({ uri: t });
+  }
+}
+async function ve({ gatewayUrls: e, uri: t }) {
+  const { uri: r, isOnChain: n } = dt({ uri: t, gatewayUrls: e });
+  if (n || await Lr(r))
+    return r;
+  throw new be({ uri: t });
+}
+function Hr(e) {
+  let t = e;
+  t.startsWith("did:nft:") && (t = t.replace("did:nft:", "").replace(/_/g, "/"));
+  const [r, n, a] = t.split("/"), [s, o] = r.split(":"), [u, d] = n.split(":");
+  if (!s || s.toLowerCase() !== "eip155")
+    throw new z({ reason: "Only EIP-155 supported" });
+  if (!o)
+    throw new z({ reason: "Chain ID not found" });
+  if (!d)
+    throw new z({
+      reason: "Contract address not found"
+    });
+  if (!a)
+    throw new z({ reason: "Token ID not found" });
+  if (!u)
+    throw new z({ reason: "ERC namespace not found" });
+  return {
+    chainID: Number.parseInt(o),
+    namespace: u.toLowerCase(),
+    contractAddress: d,
+    tokenID: a
+  };
+}
+async function jr(e, { nft: t }) {
+  if (t.namespace === "erc721")
+    return q(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 q(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 Sr({ namespace: t.namespace });
+}
+async function Or(e, { gatewayUrls: t, record: r }) {
+  return /eip155:/i.test(r) ? Wr(e, { gatewayUrls: t, record: r }) : ve({ uri: r, gatewayUrls: t });
+}
+async function Wr(e, { gatewayUrls: t, record: r }) {
+  const n = Hr(r), a = await jr(e, { nft: n }), { uri: s, isOnChain: o, isEncoded: u } = dt({ uri: a, gatewayUrls: t });
+  if (o && (s.includes("data:application/json;base64,") || s.startsWith("{"))) {
+    const f = u ? (
+      // if it is encoded, decode it
+      atob(s.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)
+      s
+    ), i = JSON.parse(f);
+    return ve({ uri: ft(i), gatewayUrls: t });
+  }
+  let d = n.tokenID;
+  return n.namespace === "erc1155" && (d = d.replace("0x", "").padStart(64, "0")), Ur({
+    gatewayUrls: t,
+    uri: s.replace(/(?:0x)?{id}/, d)
+  });
+}
+async function lt(e, { blockNumber: t, blockTag: r, name: n, key: a, gatewayUrls: s, strict: o, universalResolverAddress: u }) {
+  let d = u;
+  if (!d) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    d = j({
+      blockNumber: t,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  try {
+    const f = {
+      address: d,
+      abi: Ge,
+      functionName: "resolve",
+      args: [
+        S(Y(n)),
+        Q({
+          abi: Le,
+          functionName: "text",
+          args: [Z(n), a]
+        })
+      ],
+      blockNumber: t,
+      blockTag: r
+    }, i = R(e, q, "readContract"), c = s ? await i({
+      ...f,
+      args: [...f.args, s]
+    }) : await i(f);
+    if (c[0] === "0x")
+      return null;
+    const l = de({
+      abi: Le,
+      functionName: "text",
+      data: c[0]
+    });
+    return l === "" ? null : l;
+  } catch (f) {
+    if (o)
+      throw f;
+    if (we(f, "resolve"))
+      return null;
+    throw f;
+  }
+}
+async function Gr(e, { blockNumber: t, blockTag: r, assetGatewayUrls: n, name: a, gatewayUrls: s, strict: o, universalResolverAddress: u }) {
+  const d = await R(e, lt, "getEnsText")({
+    blockNumber: t,
+    blockTag: r,
+    key: "avatar",
+    name: a,
+    universalResolverAddress: u,
+    gatewayUrls: s,
+    strict: o
+  });
+  if (!d)
+    return null;
+  try {
+    return await Or(e, {
+      record: d,
+      gatewayUrls: n
+    });
+  } catch {
+    return null;
+  }
+}
+async function Zr(e, { address: t, blockNumber: r, blockTag: n, gatewayUrls: a, strict: s, universalResolverAddress: o }) {
+  let u = o;
+  if (!u) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    u = j({
+      blockNumber: r,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  const d = `${t.toLowerCase().substring(2)}.addr.reverse`;
+  try {
+    const f = {
+      address: u,
+      abi: At,
+      functionName: "reverse",
+      args: [S(Y(d))],
+      blockNumber: r,
+      blockTag: n
+    }, i = R(e, q, "readContract"), [c, l] = a ? await i({
+      ...f,
+      args: [...f.args, a]
+    }) : await i(f);
+    return t.toLowerCase() !== l.toLowerCase() ? null : c;
+  } catch (f) {
+    if (s)
+      throw f;
+    if (we(f, "reverse"))
+      return null;
+    throw f;
+  }
+}
+async function Jr(e, { blockNumber: t, blockTag: r, name: n, universalResolverAddress: a }) {
+  let s = a;
+  if (!s) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    s = j({
+      blockNumber: t,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  const [o] = await R(e, q, "readContract")({
+    address: s,
+    abi: [
+      {
+        inputs: [{ type: "bytes" }],
+        name: "findResolver",
+        outputs: [{ type: "address" }, { type: "bytes32" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ],
+    functionName: "findResolver",
+    args: [S(Y(n))],
+    blockNumber: t,
+    blockTag: r
+  });
+  return o;
+}
+async function Vr(e) {
+  const t = fe(e, {
+    method: "eth_newBlockFilter"
+  }), r = await e.request({
+    method: "eth_newBlockFilter"
+  });
+  return { id: r, request: t(r), type: "block" };
+}
+async function pt(e, { address: t, args: r, event: n, events: a, fromBlock: s, strict: o, toBlock: u } = {}) {
+  const d = a ?? (n ? [n] : void 0), f = fe(e, {
+    method: "eth_newFilter"
+  });
+  let i = [];
+  d && (i = [d.flatMap((h) => Ze({
+    abi: [h],
+    eventName: h.name,
+    args: r
+  }))], n && (i = i[0]));
+  const c = await e.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address: t,
+        fromBlock: typeof s == "bigint" ? k(s) : s,
+        toBlock: typeof u == "bigint" ? k(u) : u,
+        ...i.length ? { topics: i } : {}
+      }
+    ]
+  });
+  return {
+    abi: d,
+    args: r,
+    eventName: n ? n.name : void 0,
+    fromBlock: s,
+    id: c,
+    request: f(c),
+    strict: !!o,
+    toBlock: u,
+    type: "event"
+  };
+}
+async function ht(e) {
+  const t = fe(e, {
+    method: "eth_newPendingTransactionFilter"
+  }), r = await e.request({
+    method: "eth_newPendingTransactionFilter"
+  });
+  return { id: r, request: t(r), type: "transaction" };
+}
+async function Qr(e) {
+  const t = await e.request({
+    method: "eth_blobBaseFee"
+  });
+  return BigInt(t);
+}
+async function Kr(e, { blockHash: t, blockNumber: r, blockTag: n = "latest" } = {}) {
+  const a = r !== void 0 ? k(r) : void 0;
+  let s;
+  return t ? s = await e.request({
+    method: "eth_getBlockTransactionCountByHash",
+    params: [t]
+  }, { dedupe: !0 }) : s = await e.request({
+    method: "eth_getBlockTransactionCountByNumber",
+    params: [a || n]
+  }, { dedupe: !!a }), rt(s);
+}
+async function We(e, { address: t, blockNumber: r, blockTag: n = "latest" }) {
+  const a = r !== void 0 ? k(r) : void 0, s = await e.request({
+    method: "eth_getCode",
+    params: [t, a || n]
+  }, { dedupe: !!a });
+  if (s !== "0x")
+    return s;
+}
+function Xr(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 Yr(e, { blockCount: t, blockNumber: r, blockTag: n = "latest", rewardPercentiles: a }) {
+  const s = r ? k(r) : void 0, o = await e.request({
+    method: "eth_feeHistory",
+    params: [
+      k(t),
+      s || n,
+      a
+    ]
+  }, { dedupe: !!s });
+  return Xr(o);
+}
+async function en(e, { filter: t }) {
+  const r = t.strict ?? !1, a = (await t.request({
+    method: "eth_getFilterLogs",
+    params: [t.id]
+  })).map((s) => ae(s));
+  return t.abi ? Pt({
+    abi: t.abi,
+    logs: a,
+    strict: r
+  }) : a;
+}
+class tn extends D {
+  constructor({ domain: t }) {
+    super(`Invalid domain "${B(t)}".`, {
+      metaMessages: ["Must be a valid EIP-712 domain."]
+    });
+  }
+}
+class rn extends D {
+  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 nn extends D {
+  constructor({ type: t }) {
+    super(`Struct type "${t}" is invalid.`, {
+      metaMessages: ["Struct type must not be a Solidity type."],
+      name: "InvalidStructTypeError"
+    });
+  }
+}
+function an(e) {
+  const { domain: t = {}, message: r, primaryType: n } = e, a = {
+    EIP712Domain: vt({ domain: t }),
+    ...e.types
+  };
+  bt({
+    domain: t,
+    message: r,
+    primaryType: n,
+    types: a
+  });
+  const s = ["0x1901"];
+  return t && s.push(sn({
+    domain: t,
+    types: a
+  })), n !== "EIP712Domain" && s.push(mt({
+    data: r,
+    primaryType: n,
+    types: a
+  })), P(ye(s));
+}
+function sn({ domain: e, types: t }) {
+  return mt({
+    data: e,
+    primaryType: "EIP712Domain",
+    types: t
+  });
+}
+function mt({ data: e, primaryType: t, types: r }) {
+  const n = gt({
+    data: e,
+    primaryType: t,
+    types: r
+  });
+  return P(n);
+}
+function gt({ data: e, primaryType: t, types: r }) {
+  const n = [{ type: "bytes32" }], a = [on({ primaryType: t, types: r })];
+  for (const s of r[t]) {
+    const [o, u] = wt({
+      types: r,
+      name: s.name,
+      type: s.type,
+      value: e[s.name]
+    });
+    n.push(o), a.push(u);
+  }
+  return le(n, a);
+}
+function on({ primaryType: e, types: t }) {
+  const r = S(cn({ primaryType: e, types: t }));
+  return P(r);
+}
+function cn({ primaryType: e, types: t }) {
+  let r = "";
+  const n = yt({ primaryType: e, types: t });
+  n.delete(e);
+  const a = [e, ...Array.from(n).sort()];
+  for (const s of a)
+    r += `${s}(${t[s].map(({ name: o, type: u }) => `${u} ${o}`).join(",")})`;
+  return r;
+}
+function yt({ primaryType: e, types: t }, r = /* @__PURE__ */ new Set()) {
+  const n = e.match(/^\w*/u), a = n == null ? void 0 : n[0];
+  if (r.has(a) || t[a] === void 0)
+    return r;
+  r.add(a);
+  for (const s of t[a])
+    yt({ primaryType: s.type, types: t }, r);
+  return r;
+}
+function wt({ types: e, name: t, type: r, value: n }) {
+  if (e[r] !== void 0)
+    return [
+      { type: "bytes32" },
+      P(gt({ data: n, primaryType: r, types: e }))
+    ];
+  if (r === "bytes")
+    return n = `0x${(n.length % 2 ? "0" : "") + n.slice(2)}`, [{ type: "bytes32" }, P(n)];
+  if (r === "string")
+    return [{ type: "bytes32" }, P(S(n))];
+  if (r.lastIndexOf("]") === r.length - 1) {
+    const a = r.slice(0, r.lastIndexOf("[")), s = n.map((o) => wt({
+      name: t,
+      type: a,
+      types: e,
+      value: o
+    }));
+    return [
+      { type: "bytes32" },
+      P(le(s.map(([o]) => o), s.map(([, o]) => o)))
+    ];
+  }
+  return [{ type: r }, n];
+}
+function un(e) {
+  const { domain: t, message: r, primaryType: n, types: a } = e, s = (d, f) => {
+    const i = { ...f };
+    for (const c of d) {
+      const { name: l, type: h } = c;
+      h === "address" && (i[l] = i[l].toLowerCase());
+    }
+    return i;
+  }, o = a.EIP712Domain ? t ? s(a.EIP712Domain, t) : {} : {}, u = (() => {
+    if (n !== "EIP712Domain")
+      return s(a[n], r);
+  })();
+  return B({ domain: o, message: u, primaryType: n, types: a });
+}
+function bt(e) {
+  const { domain: t, message: r, primaryType: n, types: a } = e, s = (o, u) => {
+    for (const d of o) {
+      const { name: f, type: i } = d, c = u[f], l = i.match(Bt);
+      if (l && (typeof c == "number" || typeof c == "bigint")) {
+        const [g, b, p] = l;
+        k(c, {
+          signed: b === "int",
+          size: Number.parseInt(p) / 8
+        });
+      }
+      if (i === "address" && typeof c == "string" && !ur(c))
+        throw new dr({ address: c });
+      const h = i.match(Dt);
+      if (h) {
+        const [g, b] = h;
+        if (b && se(c) !== Number.parseInt(b))
+          throw new qt({
+            expectedSize: Number.parseInt(b),
+            givenSize: se(c)
+          });
+      }
+      const m = a[i];
+      m && (dn(i), s(m, c));
+    }
+  };
+  if (a.EIP712Domain && t) {
+    if (typeof t != "object")
+      throw new tn({ domain: t });
+    s(a.EIP712Domain, t);
+  }
+  if (n !== "EIP712Domain")
+    if (a[n])
+      s(a[n], r);
+    else
+      throw new rn({ primaryType: n, types: a });
+}
+function vt({ 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" && {
+      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 dn(e) {
+  if (e === "address" || e === "bool" || e === "string" || e.startsWith("bytes") || e.startsWith("uint") || e.startsWith("int"))
+    throw new nn({ type: e });
+}
+const fn = `Ethereum Signed Message:
+`;
+function ln(e) {
+  const t = typeof e == "string" ? J(e) : typeof e.raw == "string" ? e.raw : H(e.raw), r = J(`${fn}${se(t)}`);
+  return ye([r, t]);
+}
+function Tt(e, t) {
+  return P(ln(e), t);
+}
+const Rt = "0x6492649264926492649264926492649264926492649264926492649264926492";
+function pn(e) {
+  return fr(e, -32) === Rt;
+}
+function hn(e) {
+  const { address: t, data: r, signature: n, to: a = "hex" } = e, s = lr([
+    le([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [t, r, n]),
+    Rt
+  ]);
+  return a === "hex" ? s : nt(s);
+}
+function mn(e) {
+  return e.map((t) => ({
+    ...t,
+    value: BigInt(t.value)
+  }));
+}
+function gn(e) {
+  return {
+    ...e,
+    balance: e.balance ? BigInt(e.balance) : void 0,
+    nonce: e.nonce ? rt(e.nonce) : void 0,
+    storageProof: e.storageProof ? mn(e.storageProof) : void 0
+  };
+}
+async function yn(e, { address: t, blockNumber: r, blockTag: n, storageKeys: a }) {
+  const s = n ?? "latest", o = r !== void 0 ? k(r) : void 0, u = await e.request({
+    method: "eth_getProof",
+    params: [t, a, o || s]
+  });
+  return gn(u);
+}
+async function wn(e, { address: t, blockNumber: r, blockTag: n = "latest", slot: a }) {
+  const s = r !== void 0 ? k(r) : void 0;
+  return await e.request({
+    method: "eth_getStorageAt",
+    params: [t, a, s || n]
+  });
+}
+async function Te(e, { blockHash: t, blockNumber: r, blockTag: n, hash: a, index: s }) {
+  var i, c, l;
+  const o = n || "latest", u = r !== void 0 ? k(r) : void 0;
+  let d = null;
+  if (a ? d = await e.request({
+    method: "eth_getTransactionByHash",
+    params: [a]
+  }, { dedupe: !0 }) : t ? d = await e.request({
+    method: "eth_getTransactionByBlockHashAndIndex",
+    params: [t, k(s)]
+  }, { dedupe: !0 }) : (u || o) && (d = await e.request({
+    method: "eth_getTransactionByBlockNumberAndIndex",
+    params: [u || o, k(s)]
+  }, { dedupe: !!u })), !d)
+    throw new at({
+      blockHash: t,
+      blockNumber: r,
+      blockTag: o,
+      hash: a,
+      index: s
+    });
+  return (((l = (c = (i = e.chain) == null ? void 0 : i.formatters) == null ? void 0 : c.transaction) == null ? void 0 : l.format) || pr)(d);
+}
+async function bn(e, { hash: t, transactionReceipt: r }) {
+  const [n, a] = await Promise.all([
+    R(e, K, "getBlockNumber")({}),
+    t ? R(e, Te, "getTransaction")({ hash: t }) : void 0
+  ]), s = (r == null ? void 0 : r.blockNumber) || (a == null ? void 0 : a.blockNumber);
+  return s ? n - s + 1n : 0n;
+}
+async function ue(e, { hash: t }) {
+  var a, s, o;
+  const r = await e.request({
+    method: "eth_getTransactionReceipt",
+    params: [t]
+  }, { dedupe: !0 });
+  if (!r)
+    throw new st({ hash: t });
+  return (((o = (s = (a = e.chain) == null ? void 0 : a.formatters) == null ? void 0 : s.transactionReceipt) == null ? void 0 : o.format) || hr)(r);
+}
+async function vn(e, t) {
+  var b;
+  const { allowFailure: r = !0, batchSize: n, blockNumber: a, blockTag: s, multicallAddress: o, stateOverride: u } = t, d = t.contracts, f = n ?? (typeof ((b = e.batch) == null ? void 0 : b.multicall) == "object" && e.batch.multicall.batchSize || 1024);
+  let i = o;
+  if (!i) {
+    if (!e.chain)
+      throw new Error("client chain not configured. multicallAddress is required.");
+    i = j({
+      blockNumber: a,
+      chain: e.chain,
+      contract: "multicall3"
+    });
+  }
+  const c = [[]];
+  let l = 0, h = 0;
+  for (let p = 0; p < d.length; p++) {
+    const { abi: y, address: w, args: T, functionName: I } = d[p];
+    try {
+      const C = Q({ abi: y, args: T, functionName: I });
+      h += (C.length - 2) / 2, // Check if batching is enabled.
+      f > 0 && // Check if the current size of the batch exceeds the size limit.
+      h > f && // Check if the current chunk is not already empty.
+      c[l].length > 0 && (l++, h = (C.length - 2) / 2, c[l] = []), c[l] = [
+        ...c[l],
+        {
+          allowFailure: !0,
+          callData: C,
+          target: w
+        }
+      ];
+    } catch (C) {
+      const v = Ue(C, {
+        abi: y,
+        address: w,
+        args: T,
+        docsPath: "/docs/contract/multicall",
+        functionName: I
+      });
+      if (!r)
+        throw v;
+      c[l] = [
+        ...c[l],
+        {
+          allowFailure: !0,
+          callData: "0x",
+          target: w
+        }
+      ];
+    }
+  }
+  const m = await Promise.allSettled(c.map((p) => R(e, q, "readContract")({
+    abi: Ft,
+    address: i,
+    args: [p],
+    blockNumber: a,
+    blockTag: s,
+    functionName: "aggregate3",
+    stateOverride: u
+  }))), g = [];
+  for (let p = 0; p < m.length; p++) {
+    const y = m[p];
+    if (y.status === "rejected") {
+      if (!r)
+        throw y.reason;
+      for (let T = 0; T < c[p].length; T++)
+        g.push({
+          status: "failure",
+          error: y.reason,
+          result: void 0
+        });
+      continue;
+    }
+    const w = y.value;
+    for (let T = 0; T < w.length; T++) {
+      const { returnData: I, success: C } = w[T], { callData: v } = c[p][T], { abi: N, address: E, functionName: A, args: x } = d[g.length];
+      try {
+        if (v === "0x")
+          throw new St();
+        if (!C)
+          throw new _t({ data: I });
+        const F = de({
+          abi: N,
+          args: x,
+          data: I,
+          functionName: A
+        });
+        g.push(r ? { result: F, status: "success" } : F);
+      } catch (F) {
+        const $ = Ue(F, {
+          abi: N,
+          address: E,
+          args: x,
+          docsPath: "/docs/contract/multicall",
+          functionName: A
+        });
+        if (!r)
+          throw $;
+        g.push({ error: $, result: void 0, status: "failure" });
+      }
+    }
+  }
+  if (g.length !== d.length)
+    throw new D("multicall results mismatch");
+  return g;
+}
+function Tn({ r: e, s: t, to: r = "hex", v: n, yParity: a }) {
+  const s = (() => {
+    if (a === 0 || a === 1)
+      return a;
+    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 wr.Signature(oe(e), oe(t)).toCompactHex()}${s === 0 ? "1b" : "1c"}`;
+  return r === "hex" ? o : nt(o);
+}
+async function Re(e, t) {
+  var c, l, h;
+  const { address: r, factory: n, factoryData: a, hash: s, signature: o, universalSignatureVerifierAddress: u = (h = (l = (c = e.chain) == null ? void 0 : c.contracts) == null ? void 0 : l.universalSignatureVerifier) == null ? void 0 : h.address, ...d } = t, f = tt(o) ? o : typeof o == "object" && "r" in o && "s" in o ? Tn(o) : H(o), i = await (async () => !n && !a || pn(f) ? f : hn({
+    address: n,
+    data: a,
+    signature: f
+  }))();
+  try {
+    const m = u ? {
+      to: u,
+      data: Q({
+        abi: He,
+        functionName: "isValidSig",
+        args: [r, s, i]
+      }),
+      ...d
+    } : {
+      data: Je({
+        abi: He,
+        args: [r, s, i],
+        bytecode: Mt
+      }),
+      ...d
+    }, { data: g } = await R(e, Ve, "call")(m);
+    return mr(g ?? "0x0");
+  } catch (m) {
+    try {
+      if (Qe(ot(r), await $t({ hash: s, signature: o })))
+        return !0;
+    } catch {
+    }
+    if (m instanceof zt)
+      return !1;
+    throw m;
+  }
+}
+async function Rn(e, { address: t, message: r, factory: n, factoryData: a, signature: s, ...o }) {
+  const u = Tt(r);
+  return Re(e, {
+    address: t,
+    factory: n,
+    factoryData: a,
+    hash: u,
+    signature: s,
+    ...o
+  });
+}
+async function Cn(e, t) {
+  const { address: r, factory: n, factoryData: a, signature: s, message: o, primaryType: u, types: d, domain: f, ...i } = t, c = an({ message: o, primaryType: u, types: d, domain: f });
+  return Re(e, {
+    address: r,
+    factory: n,
+    factoryData: a,
+    hash: c,
+    signature: s,
+    ...i
+  });
+}
+function Ct(e, { emitOnBegin: t = !1, emitMissed: r = !1, onBlockNumber: n, onError: a, poll: s, pollingInterval: o = e.pollingInterval }) {
+  const u = typeof s < "u" ? s : !(e.transport.type === "webSocket" || e.transport.type === "fallback" && e.transport.transports[0].config.type === "webSocket");
+  let d;
+  return u ? (() => {
+    const c = B([
+      "watchBlockNumber",
+      e.uid,
+      t,
+      r,
+      o
+    ]);
+    return M(c, { onBlockNumber: n, onError: a }, (l) => X(async () => {
+      var h;
+      try {
+        const m = await R(e, K, "getBlockNumber")({ cacheTime: 0 });
+        if (d) {
+          if (m === d)
+            return;
+          if (m - d > 1 && r)
+            for (let g = d + 1n; g < m; g++)
+              l.onBlockNumber(g, d), d = g;
+        }
+        (!d || m > d) && (l.onBlockNumber(m, d), d = m);
+      } catch (m) {
+        (h = l.onError) == null || h.call(l, m);
+      }
+    }, {
+      emitOnBegin: t,
+      interval: o
+    }));
+  })() : (() => {
+    const c = B([
+      "watchBlockNumber",
+      e.uid,
+      t,
+      r
+    ]);
+    return M(c, { onBlockNumber: n, onError: a }, (l) => {
+      let h = !0, m = () => h = !1;
+      return (async () => {
+        try {
+          const g = (() => {
+            if (e.transport.type === "fallback") {
+              const p = e.transport.transports.find((y) => y.config.type === "webSocket");
+              return p ? p.value : e.transport;
+            }
+            return e.transport;
+          })(), { unsubscribe: b } = await g.subscribe({
+            params: ["newHeads"],
+            onData(p) {
+              var w;
+              if (!h)
+                return;
+              const y = oe((w = p.result) == null ? void 0 : w.number);
+              l.onBlockNumber(y, d), d = y;
+            },
+            onError(p) {
+              var y;
+              (y = l.onError) == null || y.call(l, p);
+            }
+          });
+          m = b, h || m();
+        } catch (g) {
+          a == null || a(g);
+        }
+      })(), () => m();
+    });
+  })();
+}
+async function En(e, {
+  confirmations: t = 1,
+  hash: r,
+  onReplaced: n,
+  pollingInterval: a = e.pollingInterval,
+  retryCount: s = 6,
+  retryDelay: o = ({ count: d }) => ~~(1 << d) * 200,
+  // exponential backoff
+  timeout: u = 18e4
+}) {
+  const d = B(["waitForTransactionReceipt", e.uid, r]);
+  let f, i, c, l = !1;
+  const { promise: h, resolve: m, reject: g } = Lt(), b = u ? setTimeout(() => g(new gr({ hash: r })), u) : void 0, p = M(d, { onReplaced: n, resolve: m, reject: g }, (y) => {
+    const w = R(e, Ct, "watchBlockNumber")({
+      emitMissed: !0,
+      emitOnBegin: !0,
+      poll: !0,
+      pollingInterval: a,
+      async onBlockNumber(T) {
+        const I = (v) => {
+          clearTimeout(b), w(), v(), p();
+        };
+        let C = T;
+        if (!l)
+          try {
+            if (c) {
+              if (t > 1 && (!c.blockNumber || C - c.blockNumber + 1n < t))
+                return;
+              I(() => y.resolve(c));
+              return;
+            }
+            if (f || (l = !0, await ce(async () => {
+              f = await R(e, Te, "getTransaction")({ hash: r }), f.blockNumber && (C = f.blockNumber);
+            }, {
+              delay: o,
+              retryCount: s
+            }), l = !1), c = await R(e, ue, "getTransactionReceipt")({ hash: r }), t > 1 && (!c.blockNumber || C - c.blockNumber + 1n < t))
+              return;
+            I(() => y.resolve(c));
+          } catch (v) {
+            if (v instanceof at || v instanceof st) {
+              if (!f) {
+                l = !1;
+                return;
+              }
+              try {
+                i = f, l = !0;
+                const N = await ce(() => R(e, _, "getBlock")({
+                  blockNumber: C,
+                  includeTransactions: !0
+                }), {
+                  delay: o,
+                  retryCount: s,
+                  shouldRetry: ({ error: x }) => x instanceof Ut
+                });
+                l = !1;
+                const E = N.transactions.find(({ from: x, nonce: F }) => x === i.from && F === i.nonce);
+                if (!E || (c = await R(e, ue, "getTransactionReceipt")({
+                  hash: E.hash
+                }), t > 1 && (!c.blockNumber || C - c.blockNumber + 1n < t)))
+                  return;
+                let A = "replaced";
+                E.to === i.to && E.value === i.value ? A = "repriced" : E.from === E.to && E.value === 0n && (A = "cancelled"), I(() => {
+                  var x;
+                  (x = y.onReplaced) == null || x.call(y, {
+                    reason: A,
+                    replacedTransaction: i,
+                    transaction: E,
+                    transactionReceipt: c
+                  }), y.resolve(c);
+                });
+              } catch (N) {
+                I(() => y.reject(N));
+              }
+            } else
+              I(() => y.reject(v));
+          }
+      }
+    });
+  });
+  return h;
+}
+function In(e, { blockTag: t = "latest", emitMissed: r = !1, emitOnBegin: n = !1, onBlock: a, onError: s, includeTransactions: o, poll: u, pollingInterval: d = e.pollingInterval }) {
+  const f = typeof u < "u" ? u : !(e.transport.type === "webSocket" || e.transport.type === "fallback" && e.transport.transports[0].config.type === "webSocket"), i = o ?? !1;
+  let c;
+  return f ? (() => {
+    const m = B([
+      "watchBlocks",
+      e.uid,
+      t,
+      r,
+      n,
+      i,
+      d
+    ]);
+    return M(m, { onBlock: a, onError: s }, (g) => X(async () => {
+      var b;
+      try {
+        const p = await R(e, _, "getBlock")({
+          blockTag: t,
+          includeTransactions: i
+        });
+        if (p.number && (c != null && c.number)) {
+          if (p.number === c.number)
+            return;
+          if (p.number - c.number > 1 && r)
+            for (let y = (c == null ? void 0 : c.number) + 1n; y < p.number; y++) {
+              const w = await R(e, _, "getBlock")({
+                blockNumber: y,
+                includeTransactions: i
+              });
+              g.onBlock(w, c), c = w;
+            }
+        }
+        // If no previous block exists, emit.
+        (!(c != null && c.number) || // If the block tag is "pending" with no block number, emit.
+        t === "pending" && !(p != null && p.number) || // If the next block number is greater than the previous block number, emit.
+        // We don't want to emit blocks in the past.
+        p.number && p.number > c.number) && (g.onBlock(p, c), c = p);
+      } catch (p) {
+        (b = g.onError) == null || b.call(g, p);
+      }
+    }, {
+      emitOnBegin: n,
+      interval: d
+    }));
+  })() : (() => {
+    let m = !0, g = !0, b = () => m = !1;
+    return (async () => {
+      try {
+        n && R(e, _, "getBlock")({
+          blockTag: t,
+          includeTransactions: i
+        }).then((w) => {
+          m && g && (a(w, void 0), g = !1);
+        });
+        const p = (() => {
+          if (e.transport.type === "fallback") {
+            const w = e.transport.transports.find((T) => T.config.type === "webSocket");
+            return w ? w.value : e.transport;
+          }
+          return e.transport;
+        })(), { unsubscribe: y } = await p.subscribe({
+          params: ["newHeads"],
+          async onData(w) {
+            if (!m)
+              return;
+            const T = await R(e, _, "getBlock")({
+              blockNumber: w.blockNumber,
+              includeTransactions: i
+            }).catch(() => {
+            });
+            m && (a(T, c), g = !1, c = T);
+          },
+          onError(w) {
+            s == null || s(w);
+          }
+        });
+        b = y, m || b();
+      } catch (p) {
+        s == null || s(p);
+      }
+    })(), () => b();
+  })();
+}
+function Nn(e, { address: t, args: r, batch: n = !0, event: a, events: s, fromBlock: o, onError: u, onLogs: d, poll: f, pollingInterval: i = e.pollingInterval, strict: c }) {
+  const l = typeof f < "u" ? f : typeof o == "bigint" ? !0 : !(e.transport.type === "webSocket" || e.transport.type === "fallback" && e.transport.transports[0].config.type === "webSocket"), h = c ?? !1;
+  return l ? (() => {
+    const b = B([
+      "watchEvent",
+      t,
+      r,
+      n,
+      e.uid,
+      a,
+      i,
+      o
+    ]);
+    return M(b, { onLogs: d, onError: u }, (p) => {
+      let y;
+      o !== void 0 && (y = o - 1n);
+      let w, T = !1;
+      const I = X(async () => {
+        var C;
+        if (!T) {
+          try {
+            w = await R(e, pt, "createEventFilter")({
+              address: t,
+              args: r,
+              event: a,
+              events: s,
+              strict: h,
+              fromBlock: o
+            });
+          } catch {
+          }
+          T = !0;
+          return;
+        }
+        try {
+          let v;
+          if (w)
+            v = await R(e, he, "getFilterChanges")({ filter: w });
+          else {
+            const N = await R(e, K, "getBlockNumber")({});
+            y && y !== N ? v = await R(e, Ke, "getLogs")({
+              address: t,
+              args: r,
+              event: a,
+              events: s,
+              fromBlock: y + 1n,
+              toBlock: N
+            }) : v = [], y = N;
+          }
+          if (v.length === 0)
+            return;
+          if (n)
+            p.onLogs(v);
+          else
+            for (const N of v)
+              p.onLogs([N]);
+        } catch (v) {
+          w && v instanceof re && (T = !1), (C = p.onError) == null || C.call(p, v);
+        }
+      }, {
+        emitOnBegin: !0,
+        interval: i
+      });
+      return async () => {
+        w && await R(e, pe, "uninstallFilter")({ filter: w }), I();
+      };
+    });
+  })() : (() => {
+    let b = !0, p = () => b = !1;
+    return (async () => {
+      try {
+        const y = (() => {
+          if (e.transport.type === "fallback") {
+            const C = e.transport.transports.find((v) => v.config.type === "webSocket");
+            return C ? C.value : e.transport;
+          }
+          return e.transport;
+        })(), w = s ?? (a ? [a] : void 0);
+        let T = [];
+        w && (T = [w.flatMap((v) => Ze({
+          abi: [v],
+          eventName: v.name,
+          args: r
+        }))], a && (T = T[0]));
+        const { unsubscribe: I } = await y.subscribe({
+          params: ["logs", { address: t, topics: T }],
+          onData(C) {
+            var N;
+            if (!b)
+              return;
+            const v = C.result;
+            try {
+              const { eventName: E, args: A } = Ht({
+                abi: w ?? [],
+                data: v.data,
+                topics: v.topics,
+                strict: h
+              }), x = ae(v, { args: A, eventName: E });
+              d([x]);
+            } catch (E) {
+              let A, x;
+              if (E instanceof jt || E instanceof Ot) {
+                if (c)
+                  return;
+                A = E.abiItem.name, x = (N = E.abiItem.inputs) == null ? void 0 : N.some(($) => !("name" in $ && $.name));
+              }
+              const F = ae(v, {
+                args: x ? [] : {},
+                eventName: A
+              });
+              d([F]);
+            }
+          },
+          onError(C) {
+            u == null || u(C);
+          }
+        });
+        p = I, b || p();
+      } catch (y) {
+        u == null || u(y);
+      }
+    })(), () => p();
+  })();
+}
+function kn(e, { batch: t = !0, onError: r, onTransactions: n, poll: a, pollingInterval: s = e.pollingInterval }) {
+  return (typeof a < "u" ? a : e.transport.type !== "webSocket") ? (() => {
+    const f = B([
+      "watchPendingTransactions",
+      e.uid,
+      t,
+      s
+    ]);
+    return M(f, { onTransactions: n, onError: r }, (i) => {
+      let c;
+      const l = X(async () => {
+        var h;
+        try {
+          if (!c)
+            try {
+              c = await R(e, ht, "createPendingTransactionFilter")({});
+              return;
+            } catch (g) {
+              throw l(), g;
+            }
+          const m = await R(e, he, "getFilterChanges")({ filter: c });
+          if (m.length === 0)
+            return;
+          if (t)
+            i.onTransactions(m);
+          else
+            for (const g of m)
+              i.onTransactions([g]);
+        } catch (m) {
+          (h = i.onError) == null || h.call(i, m);
+        }
+      }, {
+        emitOnBegin: !0,
+        interval: s
+      });
+      return async () => {
+        c && await R(e, pe, "uninstallFilter")({ filter: c }), l();
+      };
+    });
+  })() : (() => {
+    let f = !0, i = () => f = !1;
+    return (async () => {
+      try {
+        const { unsubscribe: c } = await e.transport.subscribe({
+          params: ["newPendingTransactions"],
+          onData(l) {
+            if (!f)
+              return;
+            const h = l.result;
+            n([h]);
+          },
+          onError(l) {
+            r == null || r(l);
+          }
+        });
+        i = c, f || i();
+      } catch (c) {
+        r == null || r(c);
+      }
+    })(), () => i();
+  })();
+}
+function xn(e) {
+  var c, l, h;
+  const { scheme: t, statement: r, ...n } = ((c = e.match(An)) == null ? void 0 : c.groups) ?? {}, { chainId: a, expirationTime: s, issuedAt: o, notBefore: u, requestId: d, ...f } = ((l = e.match(Pn)) == null ? void 0 : l.groups) ?? {}, i = (h = e.split("Resources:")[1]) == null ? void 0 : h.split(`
+- `).slice(1);
+  return {
+    ...n,
+    ...f,
+    ...a ? { chainId: Number(a) } : {},
+    ...s ? { expirationTime: new Date(s) } : {},
+    ...o ? { issuedAt: new Date(o) } : {},
+    ...u ? { notBefore: new Date(u) } : {},
+    ...d ? { requestId: d } : {},
+    ...i ? { resources: i } : {},
+    ...t ? { scheme: t } : {},
+    ...r ? { statement: r } : {}
+  };
+}
+const An = /^(?:(?<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)?/, Pn = /(?: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 Bn(e) {
+  const { address: t, domain: r, message: n, nonce: a, scheme: s, time: o = /* @__PURE__ */ new Date() } = e;
+  if (r && n.domain !== r || a && n.nonce !== a || s && n.scheme !== s || n.expirationTime && o >= n.expirationTime || n.notBefore && o < n.notBefore)
+    return !1;
+  try {
+    if (!n.address || t && !Qe(n.address, t))
+      return !1;
+  } catch {
+    return !1;
+  }
+  return !0;
+}
+async function Dn(e, t) {
+  const { address: r, domain: n, message: a, nonce: s, scheme: o, signature: u, time: d = /* @__PURE__ */ new Date(), ...f } = t, i = xn(a);
+  if (!i.address || !Bn({
+    address: r,
+    domain: n,
+    message: i,
+    nonce: s,
+    scheme: o,
+    time: d
+  }))
+    return !1;
+  const l = Tt(a);
+  return Re(e, {
+    address: i.address,
+    hash: l,
+    signature: u,
+    ...f
+  });
+}
+function qn(e) {
+  return {
+    call: (t) => Ve(e, t),
+    createBlockFilter: () => Vr(e),
+    createContractEventFilter: (t) => Wt(e, t),
+    createEventFilter: (t) => pt(e, t),
+    createPendingTransactionFilter: () => ht(e),
+    estimateContractGas: (t) => Gt(e, t),
+    estimateGas: (t) => Zt(e, t),
+    getBalance: (t) => Jt(e, t),
+    getBlobBaseFee: () => Qr(e),
+    getBlock: (t) => _(e, t),
+    getBlockNumber: (t) => K(e, t),
+    getBlockTransactionCount: (t) => Kr(e, t),
+    getBytecode: (t) => We(e, t),
+    getChainId: () => me(e),
+    getCode: (t) => We(e, t),
+    getContractEvents: (t) => Vt(e, t),
+    getEip712Domain: (t) => vr(e, t),
+    getEnsAddress: (t) => qr(e, t),
+    getEnsAvatar: (t) => Gr(e, t),
+    getEnsName: (t) => Zr(e, t),
+    getEnsResolver: (t) => Jr(e, t),
+    getEnsText: (t) => lt(e, t),
+    getFeeHistory: (t) => Yr(e, t),
+    estimateFeesPerGas: (t) => Qt(e, t),
+    getFilterChanges: (t) => he(e, t),
+    getFilterLogs: (t) => en(e, t),
+    getGasPrice: () => Kt(e),
+    getLogs: (t) => Ke(e, t),
+    getProof: (t) => yn(e, t),
+    estimateMaxPriorityFeePerGas: (t) => Xt(e, t),
+    getStorageAt: (t) => wn(e, t),
+    getTransaction: (t) => Te(e, t),
+    getTransactionConfirmations: (t) => bn(e, t),
+    getTransactionCount: (t) => Yt(e, t),
+    getTransactionReceipt: (t) => ue(e, t),
+    multicall: (t) => vn(e, t),
+    prepareTransactionRequest: (t) => Xe(e, t),
+    readContract: (t) => q(e, t),
+    sendRawTransaction: (t) => Ye(e, t),
+    simulateContract: (t) => er(e, t),
+    verifyMessage: (t) => Rn(e, t),
+    verifySiweMessage: (t) => Dn(e, t),
+    verifyTypedData: (t) => Cn(e, t),
+    uninstallFilter: (t) => pe(e, t),
+    waitForTransactionReceipt: (t) => En(e, t),
+    watchBlocks: (t) => In(e, t),
+    watchBlockNumber: (t) => Ct(e, t),
+    watchContractEvent: (t) => tr(e, t),
+    watchEvent: (t) => Nn(e, t),
+    watchPendingTransactions: (t) => kn(e, t)
+  };
+}
+function Vn(e) {
+  const { key: t = "public", name: r = "Public Client" } = e;
+  return ct({
+    ...e,
+    key: t,
+    name: r,
+    type: "publicClient"
+  }).extend(qn);
+}
+function Fn(e, t) {
+  const { abi: r, args: n, bytecode: a, ...s } = t, o = Je({ abi: r, args: n, bytecode: a });
+  return et(e, {
+    ...s,
+    data: o
+  });
+}
+async function Sn(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) => yr(n));
+}
+async function _n(e) {
+  return await e.request({ method: "wallet_getPermissions" }, { dedupe: !0 });
+}
+async function Mn(e) {
+  return (await e.request({ method: "eth_requestAccounts" }, { dedupe: !0, retryCount: 0 })).map((r) => ot(r));
+}
+async function $n(e, t) {
+  return e.request({
+    method: "wallet_requestPermissions",
+    params: [t]
+  }, { retryCount: 0 });
+}
+async function zn(e, { account: t = e.account, message: r }) {
+  if (!t)
+    throw new ge({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const n = V(t);
+  if (n.signMessage)
+    return n.signMessage({ message: r });
+  const a = typeof r == "string" ? J(r) : r.raw instanceof Uint8Array ? S(r.raw) : r.raw;
+  return e.request({
+    method: "personal_sign",
+    params: [a, n.address]
+  }, { retryCount: 0 });
+}
+async function Ln(e, t) {
+  var f, i, c, l;
+  const { account: r = e.account, chain: n = e.chain, ...a } = t;
+  if (!r)
+    throw new ge({
+      docsPath: "/docs/actions/wallet/signTransaction"
+    });
+  const s = V(r);
+  rr({
+    account: s,
+    ...t
+  });
+  const o = await R(e, me, "getChainId")({});
+  n !== null && nr({
+    currentChainId: o,
+    chain: n
+  });
+  const u = (n == null ? void 0 : n.formatters) || ((f = e.chain) == null ? void 0 : f.formatters), d = ((i = u == null ? void 0 : u.transactionRequest) == null ? void 0 : i.format) || ar;
+  return s.signTransaction ? s.signTransaction({
+    ...a,
+    chainId: o
+  }, { serializer: (l = (c = e.chain) == null ? void 0 : c.serializers) == null ? void 0 : l.transaction }) : await e.request({
+    method: "eth_signTransaction",
+    params: [
+      {
+        ...d(a),
+        chainId: k(o),
+        from: s.address
+      }
+    ]
+  }, { retryCount: 0 });
+}
+async function Un(e, t) {
+  const { account: r = e.account, domain: n, message: a, primaryType: s } = t;
+  if (!r)
+    throw new ge({
+      docsPath: "/docs/actions/wallet/signTypedData"
+    });
+  const o = V(r), u = {
+    EIP712Domain: vt({ domain: n }),
+    ...t.types
+  };
+  if (bt({ domain: n, message: a, primaryType: s, types: u }), o.signTypedData)
+    return o.signTypedData({ domain: n, message: a, primaryType: s, types: u });
+  const d = un({ domain: n, message: a, primaryType: s, types: u });
+  return e.request({
+    method: "eth_signTypedData_v4",
+    params: [o.address, d]
+  }, { retryCount: 0 });
+}
+async function Hn(e, { id: t }) {
+  await e.request({
+    method: "wallet_switchEthereumChain",
+    params: [
+      {
+        chainId: k(t)
+      }
+    ]
+  }, { retryCount: 0 });
+}
+async function jn(e, t) {
+  return await e.request({
+    method: "wallet_watchAsset",
+    params: t
+  }, { retryCount: 0 });
+}
+function On(e) {
+  return {
+    addChain: (t) => Rr(e, t),
+    deployContract: (t) => Fn(e, t),
+    getAddresses: () => Sn(e),
+    getChainId: () => me(e),
+    getPermissions: () => _n(e),
+    prepareTransactionRequest: (t) => Xe(e, t),
+    requestAddresses: () => Mn(e),
+    requestPermissions: (t) => $n(e, t),
+    sendRawTransaction: (t) => Ye(e, t),
+    sendTransaction: (t) => et(e, t),
+    signMessage: (t) => zn(e, t),
+    signTransaction: (t) => Ln(e, t),
+    signTypedData: (t) => Un(e, t),
+    switchChain: (t) => Hn(e, t),
+    watchAsset: (t) => jn(e, t),
+    writeContract: (t) => sr(e, t)
+  };
+}
+function Qn(e) {
+  const { key: t = "wallet", name: r = "Wallet Client", transport: n } = e;
+  return ct({
+    ...e,
+    key: t,
+    name: r,
+    transport: n,
+    type: "walletClient"
+  }).extend(On);
+}
+export {
+  Vn as a,
+  Nr as b,
+  Qn as c,
+  Jn as h
+};
+//# sourceMappingURL=createWalletClient-DNcW-ENe.js.map