astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es319.js

@@ -0,0 +1,277 @@
+import { subscribeWithSelector as O, persist as W } from "./astra-sdk.es417.js";
+import { createStore as j } from "./astra-sdk.es418.js";
+import { injected as A } from "./astra-sdk.es322.js";
+import { createEmitter as B } from "./astra-sdk.es419.js";
+import { createStorage as F, noopStorage as R } from "./astra-sdk.es420.js";
+import { ChainNotConfiguredError as _ } from "./astra-sdk.es383.js";
+import { uid as T } from "./astra-sdk.es421.js";
+import { version as M } from "./astra-sdk.es422.js";
+import { createStore as $ } from "./astra-sdk.es423.js";
+import { createClient as q } from "./astra-sdk.es394.js";
+function nt(z) {
+  const { multiInjectedProviderDiscovery: D = !0, storage: m = F({
+    storage: typeof window < "u" && window.localStorage ? window.localStorage : R
+  }), syncConnectedChain: V = !0, ssr: g = !1, ...f } = z, h = typeof window < "u" && D ? $() : void 0, s = j(() => f.chains), d = j(() => {
+    const t = [], e = /* @__PURE__ */ new Set();
+    for (const n of f.connectors ?? []) {
+      const c = S(n);
+      if (t.push(c), !g && c.rdns) {
+        const o = typeof c.rdns == "string" ? [c.rdns] : c.rdns;
+        for (const a of o)
+          e.add(a);
+      }
+    }
+    if (!g && h) {
+      const n = h.getProviders();
+      for (const c of n)
+        e.has(c.info.rdns) || t.push(S(C(c)));
+    }
+    return t;
+  });
+  function S(t) {
+    var c;
+    const e = B(T()), n = {
+      ...t({
+        emitter: e,
+        chains: s.getState(),
+        storage: m,
+        transports: f.transports
+      }),
+      emitter: e,
+      uid: e.uid
+    };
+    return e.on("connect", w), (c = n.setup) == null || c.call(n), n;
+  }
+  function C(t) {
+    const { info: e } = t, n = t.provider;
+    return A({ target: { ...e, id: e.rdns, provider: n } });
+  }
+  const y = /* @__PURE__ */ new Map();
+  function E(t = {}) {
+    const e = t.chainId ?? r.getState().chainId, n = s.getState().find((o) => o.id === e);
+    if (t.chainId && !n)
+      throw new _();
+    {
+      const o = y.get(r.getState().chainId);
+      if (o && !n)
+        return o;
+      if (!n)
+        throw new _();
+    }
+    {
+      const o = y.get(e);
+      if (o)
+        return o;
+    }
+    let c;
+    if (f.client)
+      c = f.client({ chain: n });
+    else {
+      const o = n.id, a = s.getState().map((i) => i.id), u = {}, P = Object.entries(f);
+      for (const [i, l] of P)
+        if (!(i === "chains" || i === "client" || i === "connectors" || i === "transports"))
+          if (typeof l == "object")
+            if (o in l)
+              u[i] = l[o];
+            else {
+              if (a.some((H) => H in l))
+                continue;
+              u[i] = l;
+            }
+          else
+            u[i] = l;
+      c = q({
+        ...u,
+        chain: n,
+        batch: u.batch ?? { multicall: !0 },
+        transport: (i) => f.transports[o]({ ...i, connectors: d })
+      });
+    }
+    return y.set(e, c), c;
+  }
+  function p() {
+    return {
+      chainId: s.getState()[0].id,
+      connections: /* @__PURE__ */ new Map(),
+      current: null,
+      status: "disconnected"
+    };
+  }
+  let I;
+  const k = "0.0.0-canary-";
+  M.startsWith(k) ? I = Number.parseInt(M.replace(k, "")) : I = Number.parseInt(M.split(".")[0] ?? "0");
+  const r = j(O(
+    // only use persist middleware if storage exists
+    m ? W(p, {
+      migrate(t, e) {
+        if (e === I)
+          return t;
+        const n = p(), c = N(t, n.chainId);
+        return { ...n, chainId: c };
+      },
+      name: "store",
+      partialize(t) {
+        return {
+          connections: {
+            __type: "Map",
+            value: Array.from(t.connections.entries()).map(([e, n]) => {
+              const { id: c, name: o, type: a, uid: u } = n.connector;
+              return [e, { ...n, connector: { id: c, name: o, type: a, uid: u } }];
+            })
+          },
+          chainId: t.chainId,
+          current: t.current
+        };
+      },
+      merge(t, e) {
+        typeof t == "object" && t && "status" in t && delete t.status;
+        const n = N(t, e.chainId);
+        return {
+          ...e,
+          ...t,
+          chainId: n
+        };
+      },
+      skipHydration: g,
+      storage: m,
+      version: I
+    }) : p
+  ));
+  r.setState(p());
+  function N(t, e) {
+    return t && typeof t == "object" && "chainId" in t && typeof t.chainId == "number" && s.getState().some((n) => n.id === t.chainId) ? t.chainId : e;
+  }
+  V && r.subscribe(({ connections: t, current: e }) => {
+    var n;
+    return e ? (n = t.get(e)) == null ? void 0 : n.chainId : void 0;
+  }, (t) => {
+    if (s.getState().some((n) => n.id === t))
+      return r.setState((n) => ({
+        ...n,
+        chainId: t ?? n.chainId
+      }));
+  }), h == null || h.subscribe((t) => {
+    const e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+    for (const o of d.getState())
+      if (e.add(o.id), o.rdns) {
+        const a = typeof o.rdns == "string" ? [o.rdns] : o.rdns;
+        for (const u of a)
+          n.add(u);
+      }
+    const c = [];
+    for (const o of t) {
+      if (n.has(o.info.rdns))
+        continue;
+      const a = S(C(o));
+      e.has(a.id) || c.push(a);
+    }
+    m && !r.persist.hasHydrated() || d.setState((o) => [...o, ...c], !0);
+  });
+  function b(t) {
+    r.setState((e) => {
+      const n = e.connections.get(t.uid);
+      return n ? {
+        ...e,
+        connections: new Map(e.connections).set(t.uid, {
+          accounts: t.accounts ?? n.accounts,
+          chainId: t.chainId ?? n.chainId,
+          connector: n.connector
+        })
+      } : e;
+    });
+  }
+  function w(t) {
+    r.getState().status === "connecting" || r.getState().status === "reconnecting" || r.setState((e) => {
+      const n = d.getState().find((c) => c.uid === t.uid);
+      return n ? (n.emitter.listenerCount("connect") && n.emitter.off("connect", b), n.emitter.listenerCount("change") || n.emitter.on("change", b), n.emitter.listenerCount("disconnect") || n.emitter.on("disconnect", v), {
+        ...e,
+        connections: new Map(e.connections).set(t.uid, {
+          accounts: t.accounts,
+          chainId: t.chainId,
+          connector: n
+        }),
+        current: t.uid,
+        status: "connected"
+      }) : e;
+    });
+  }
+  function v(t) {
+    r.setState((e) => {
+      const n = e.connections.get(t.uid);
+      if (n) {
+        const o = n.connector;
+        o.emitter.listenerCount("change") && n.connector.emitter.off("change", b), o.emitter.listenerCount("disconnect") && n.connector.emitter.off("disconnect", v), o.emitter.listenerCount("connect") || n.connector.emitter.on("connect", w);
+      }
+      if (e.connections.delete(t.uid), e.connections.size === 0)
+        return {
+          ...e,
+          connections: /* @__PURE__ */ new Map(),
+          current: null,
+          status: "disconnected"
+        };
+      const c = e.connections.values().next().value;
+      return {
+        ...e,
+        connections: new Map(e.connections),
+        current: c.connector.uid
+      };
+    });
+  }
+  return {
+    get chains() {
+      return s.getState();
+    },
+    get connectors() {
+      return d.getState();
+    },
+    storage: m,
+    getClient: E,
+    get state() {
+      return r.getState();
+    },
+    setState(t) {
+      let e;
+      typeof t == "function" ? e = t(r.getState()) : e = t;
+      const n = p();
+      typeof e != "object" && (e = n), Object.keys(n).some((o) => !(o in e)) && (e = n), r.setState(e, !0);
+    },
+    subscribe(t, e, n) {
+      return r.subscribe(t, e, n ? {
+        ...n,
+        fireImmediately: n.emitImmediately
+        // Workaround cast since Zustand does not support `'exactOptionalPropertyTypes'`
+      } : void 0);
+    },
+    _internal: {
+      mipd: h,
+      store: r,
+      ssr: !!g,
+      syncConnectedChain: V,
+      transports: f.transports,
+      chains: {
+        setState(t) {
+          const e = typeof t == "function" ? t(s.getState()) : t;
+          if (e.length !== 0)
+            return s.setState(e, !0);
+        },
+        subscribe(t) {
+          return s.subscribe(t);
+        }
+      },
+      connectors: {
+        providerDetailToConnector: C,
+        setup: S,
+        setState(t) {
+          return d.setState(typeof t == "function" ? t(d.getState()) : t, !0);
+        },
+        subscribe(t) {
+          return d.subscribe(t);
+        }
+      },
+      events: { change: b, connect: w, disconnect: v }
+    }
+  };
+}
+export {
+  nt as createConfig
+};

package/dist/astra-sdk.es32.js

@@ -0,0 +1,49 @@
+import { proxy as a, subscribe as d } from "./astra-sdk.es441.js";
+import { CoreHelperUtil as r } from "./astra-sdk.es58.js";
+import { FetchUtil as c } from "./astra-sdk.es445.js";
+import { OptionsController as s } from "./astra-sdk.es29.js";
+const p = r.getAnalyticsUrl(), l = new c({ baseUrl: p, clientId: null }), m = ["MODAL_CREATED"], e = a({
+  timestamp: Date.now(),
+  data: {
+    type: "track",
+    event: "MODAL_CREATED"
+  }
+}), o = {
+  state: e,
+  subscribe(t) {
+    return d(e, () => t(e));
+  },
+  _getApiHeaders() {
+    const { projectId: t, sdkType: n, sdkVersion: i } = s.state;
+    return {
+      "x-project-id": t,
+      "x-sdk-type": n,
+      "x-sdk-version": i || "html-wagmi-4.2.2"
+    };
+  },
+  async _sendAnalyticsEvent(t) {
+    try {
+      if (m.includes(t.data.event) || typeof window > "u")
+        return;
+      await l.post({
+        path: "/e",
+        headers: o._getApiHeaders(),
+        body: {
+          eventId: r.getUUID(),
+          url: window.location.href,
+          domain: window.location.hostname,
+          timestamp: t.timestamp,
+          props: t.data
+        }
+      });
+    } catch {
+    }
+  },
+  sendEvent(t) {
+    var n;
+    e.timestamp = Date.now(), e.data = t, (n = s.state.features) != null && n.analytics && o._sendAnalyticsEvent(e);
+  }
+};
+export {
+  o as EventsController
+};

package/dist/astra-sdk.es320.js

@@ -0,0 +1,18 @@
+import { getAction as d } from "./astra-sdk.es384.js";
+import { watchPendingTransactions as l } from "./astra-sdk.es409.js";
+function P(i, a) {
+  const { syncConnectedChain: s = i._internal.syncConnectedChain, ...r } = a;
+  let t;
+  const e = (n) => {
+    t && t();
+    const h = i.getClient({ chainId: n });
+    return t = d(h, l, "watchPendingTransactions")(r), t;
+  }, o = e(a.chainId);
+  let c;
+  return s && !a.chainId && (c = i.subscribe(({ chainId: n }) => n, async (n) => e(n))), () => {
+    o == null || o(), c == null || c();
+  };
+}
+export {
+  P as watchPendingTransactions
+};

package/dist/astra-sdk.es321.js

@@ -0,0 +1,244 @@
+import { createConnector as x } from "./astra-sdk.es342.js";
+import { getAddress as y } from "./astra-sdk.es344.js";
+import { UserRejectedRequestError as a, SwitchChainError as U } from "./astra-sdk.es343.js";
+import { ChainNotConfiguredError as A } from "./astra-sdk.es383.js";
+import { numberToHex as I } from "./astra-sdk.es416.js";
+q.type = "coinbaseWallet";
+function q(r = {}) {
+  return r.version === "3" || r.headlessMode ? _(r) : L(r);
+}
+function L(r) {
+  let b, f, u, s;
+  return x((l) => ({
+    id: "coinbaseWalletSDK",
+    name: "Coinbase Wallet",
+    rdns: "com.coinbase.wallet",
+    type: q.type,
+    async connect({ chainId: t } = {}) {
+      try {
+        const e = await this.getProvider(), n = (await e.request({
+          method: "eth_requestAccounts"
+        })).map((o) => y(o));
+        f || (f = this.onAccountsChanged.bind(this), e.on("accountsChanged", f)), u || (u = this.onChainChanged.bind(this), e.on("chainChanged", u)), s || (s = this.onDisconnect.bind(this), e.on("disconnect", s));
+        let c = await this.getChainId();
+        if (t && c !== t) {
+          const o = await this.switchChain({ chainId: t }).catch((i) => {
+            if (i.code === a.code)
+              throw i;
+            return { id: c };
+          });
+          c = (o == null ? void 0 : o.id) ?? c;
+        }
+        return { accounts: n, chainId: c };
+      } catch (e) {
+        throw /(user closed modal|accounts received is empty|user denied account|request rejected)/i.test(e.message) ? new a(e) : e;
+      }
+    },
+    async disconnect() {
+      var e;
+      const t = await this.getProvider();
+      f && (t.removeListener("accountsChanged", f), f = void 0), u && (t.removeListener("chainChanged", u), u = void 0), s && (t.removeListener("disconnect", s), s = void 0), t.disconnect(), (e = t.close) == null || e.call(t);
+    },
+    async getAccounts() {
+      return (await (await this.getProvider()).request({
+        method: "eth_accounts"
+      })).map((e) => y(e));
+    },
+    async getChainId() {
+      const e = await (await this.getProvider()).request({
+        method: "eth_chainId"
+      });
+      return Number(e);
+    },
+    async getProvider() {
+      if (!b) {
+        const t = (() => {
+          var c;
+          return typeof r.preference == "string" ? { options: r.preference } : {
+            ...r.preference,
+            options: ((c = r.preference) == null ? void 0 : c.options) ?? "all"
+          };
+        })(), { createCoinbaseWalletSDK: e } = await import("./astra-sdk.es737.js");
+        b = e({
+          ...r,
+          appChainIds: l.chains.map((c) => c.id),
+          preference: t
+        }).getProvider();
+      }
+      return b;
+    },
+    async isAuthorized() {
+      try {
+        return !!(await this.getAccounts()).length;
+      } catch {
+        return !1;
+      }
+    },
+    async switchChain({ addEthereumChainParameter: t, chainId: e }) {
+      var o, i, w, h;
+      const n = l.chains.find((d) => d.id === e);
+      if (!n)
+        throw new U(new A());
+      const c = await this.getProvider();
+      try {
+        return await c.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: I(n.id) }]
+        }), n;
+      } catch (d) {
+        if (d.code === 4902)
+          try {
+            let p;
+            t != null && t.blockExplorerUrls ? p = t.blockExplorerUrls : p = (o = n.blockExplorers) != null && o.default.url ? [(i = n.blockExplorers) == null ? void 0 : i.default.url] : [];
+            let v;
+            (w = t == null ? void 0 : t.rpcUrls) != null && w.length ? v = t.rpcUrls : v = [((h = n.rpcUrls.default) == null ? void 0 : h.http[0]) ?? ""];
+            const g = {
+              blockExplorerUrls: p,
+              chainId: I(e),
+              chainName: (t == null ? void 0 : t.chainName) ?? n.name,
+              iconUrls: t == null ? void 0 : t.iconUrls,
+              nativeCurrency: (t == null ? void 0 : t.nativeCurrency) ?? n.nativeCurrency,
+              rpcUrls: v
+            };
+            return await c.request({
+              method: "wallet_addEthereumChain",
+              params: [g]
+            }), n;
+          } catch (p) {
+            throw new a(p);
+          }
+        throw new U(d);
+      }
+    },
+    onAccountsChanged(t) {
+      t.length === 0 ? this.onDisconnect() : l.emitter.emit("change", {
+        accounts: t.map((e) => y(e))
+      });
+    },
+    onChainChanged(t) {
+      const e = Number(t);
+      l.emitter.emit("change", { chainId: e });
+    },
+    async onDisconnect(t) {
+      l.emitter.emit("disconnect");
+      const e = await this.getProvider();
+      f && (e.removeListener("accountsChanged", f), f = void 0), u && (e.removeListener("chainChanged", u), u = void 0), s && (e.removeListener("disconnect", s), s = void 0);
+    }
+  }));
+}
+function _(r) {
+  let f, u, s, l, t;
+  return x((e) => ({
+    id: "coinbaseWalletSDK",
+    name: "Coinbase Wallet",
+    type: q.type,
+    async connect({ chainId: n } = {}) {
+      try {
+        const c = await this.getProvider(), o = (await c.request({
+          method: "eth_requestAccounts"
+        })).map((w) => y(w));
+        s || (s = this.onAccountsChanged.bind(this), c.on("accountsChanged", s)), l || (l = this.onChainChanged.bind(this), c.on("chainChanged", l)), t || (t = this.onDisconnect.bind(this), c.on("disconnect", t));
+        let i = await this.getChainId();
+        if (n && i !== n) {
+          const w = await this.switchChain({ chainId: n }).catch((h) => {
+            if (h.code === a.code)
+              throw h;
+            return { id: i };
+          });
+          i = (w == null ? void 0 : w.id) ?? i;
+        }
+        return { accounts: o, chainId: i };
+      } catch (c) {
+        throw /(user closed modal|accounts received is empty|user denied account)/i.test(c.message) ? new a(c) : c;
+      }
+    },
+    async disconnect() {
+      const n = await this.getProvider();
+      s && (n.removeListener("accountsChanged", s), s = void 0), l && (n.removeListener("chainChanged", l), l = void 0), t && (n.removeListener("disconnect", t), t = void 0), n.disconnect(), n.close();
+    },
+    async getAccounts() {
+      return (await (await this.getProvider()).request({
+        method: "eth_accounts"
+      })).map((c) => y(c));
+    },
+    async getChainId() {
+      const c = await (await this.getProvider()).request({
+        method: "eth_chainId"
+      });
+      return Number(c);
+    },
+    async getProvider() {
+      var n;
+      if (!u) {
+        const c = await (async () => {
+          const { default: d } = await import("./astra-sdk.es738.js").then((p) => p.i);
+          return typeof d != "function" && typeof d.default == "function" ? d.default : d;
+        })();
+        f = new c({ ...r, reloadOnDisconnect: !1 });
+        const o = (n = f.walletExtension) == null ? void 0 : n.getChainId(), i = e.chains.find((d) => r.chainId ? d.id === r.chainId : d.id === o) || e.chains[0], w = r.chainId || (i == null ? void 0 : i.id), h = r.jsonRpcUrl || (i == null ? void 0 : i.rpcUrls.default.http[0]);
+        u = f.makeWeb3Provider(h, w);
+      }
+      return u;
+    },
+    async isAuthorized() {
+      try {
+        return !!(await this.getAccounts()).length;
+      } catch {
+        return !1;
+      }
+    },
+    async switchChain({ addEthereumChainParameter: n, chainId: c }) {
+      var w, h, d, p;
+      const o = e.chains.find((v) => v.id === c);
+      if (!o)
+        throw new U(new A());
+      const i = await this.getProvider();
+      try {
+        return await i.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: I(o.id) }]
+        }), o;
+      } catch (v) {
+        if (v.code === 4902)
+          try {
+            let g;
+            n != null && n.blockExplorerUrls ? g = n.blockExplorerUrls : g = (w = o.blockExplorers) != null && w.default.url ? [(h = o.blockExplorers) == null ? void 0 : h.default.url] : [];
+            let k;
+            (d = n == null ? void 0 : n.rpcUrls) != null && d.length ? k = n.rpcUrls : k = [((p = o.rpcUrls.default) == null ? void 0 : p.http[0]) ?? ""];
+            const D = {
+              blockExplorerUrls: g,
+              chainId: I(c),
+              chainName: (n == null ? void 0 : n.chainName) ?? o.name,
+              iconUrls: n == null ? void 0 : n.iconUrls,
+              nativeCurrency: (n == null ? void 0 : n.nativeCurrency) ?? o.nativeCurrency,
+              rpcUrls: k
+            };
+            return await i.request({
+              method: "wallet_addEthereumChain",
+              params: [D]
+            }), o;
+          } catch (g) {
+            throw new a(g);
+          }
+        throw new U(v);
+      }
+    },
+    onAccountsChanged(n) {
+      n.length === 0 ? this.onDisconnect() : e.emitter.emit("change", {
+        accounts: n.map((c) => y(c))
+      });
+    },
+    onChainChanged(n) {
+      const c = Number(n);
+      e.emitter.emit("change", { chainId: c });
+    },
+    async onDisconnect(n) {
+      e.emitter.emit("disconnect");
+      const c = await this.getProvider();
+      s && (c.removeListener("accountsChanged", s), s = void 0), l && (c.removeListener("chainChanged", l), l = void 0), t && (c.removeListener("disconnect", t), t = void 0);
+    }
+  }));
+}
+export {
+  q as coinbaseWallet
+};