@pufferfinance/puffer-sdk 1.28.0 → 1.28.2

package/dist/http-CajzXkt4.js

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