@pufferfinance/puffer-sdk 1.4.1 → 1.5.0

package/dist/createWalletClient-DKcpswHR.js

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