@getpara/react-sdk 2.0.0-alpha.3 → 2.0.0-alpha.6

package/dist/provider/providers/ExternalWalletProvider.js

@@ -0,0 +1,428 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { isIOS, isIOSWebview, isMobile, truncateAddress } from "@getpara/web-sdk";
+import { useInternalClient } from "../hooks/utils/useInternalClient.js";
+import { useStore } from "../stores/useStore.js";
+import { ModalStep } from "../../modal/index.js";
+import { useModalStore } from "../../modal/stores/index.js";
+import { useVerifyExternalWallet, useWalletState } from "../hooks/index.js";
+import { useAuthActions } from "./AuthProvider.js";
+const defaultExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  wallet: void 0,
+  qrUri: void 0,
+  chainIdSwitchingTo: void 0,
+  walletDisplayHelpers: { showExtension: false, showMobile: false, isSolanaMobileIOS: false, isCosmosMobileWallet: false },
+  username: void 0,
+  avatar: void 0,
+  connectExternalWallet: () => Promise.resolve(),
+  disconnectExternalWallet: () => Promise.resolve(),
+  switchChain: () => Promise.resolve(),
+  setChainIdSwitchingTo: () => {
+  },
+  connectEmbeddedToExternalConnectors: () => Promise.resolve(),
+  verifyWalletSignature: () => Promise.resolve({}),
+  getWalletBalance: () => Promise.resolve(void 0),
+  isExternalWalletVerifying: false
+};
+const ExternalWalletContext = createContext(defaultExternalWallet);
+function ExternalWalletProvider({ children }) {
+  const evmContext = useStore((state) => state.evmContext);
+  const cosmosContext = useStore((state) => state.cosmosContext);
+  const solanaContext = useStore((state) => state.solanaContext);
+  const externalWallets = useStore((state) => state.externalWallets);
+  const externalWalletsWithFullAuth = useStore((state) => state.externalWalletsWithFullAuth);
+  const {
+    wallets: evmWallets,
+    disconnect: evmDisconnect,
+    chains: evmChains,
+    chainId: evmChainId,
+    switchChain: evmSwitchChain,
+    username: evmUsername,
+    avatar: evmAvatar,
+    connectParaEmbedded: evmConnectParaEmbedded,
+    signVerificationMessage: evmSignVerificationMessage,
+    getWalletBalance: evmGetWalletBalance
+  } = useContext(evmContext);
+  const {
+    wallets: solanaWallets,
+    disconnect: solanaDisconnect,
+    signVerificationMessage: solanaSignVerificationMessage
+  } = useContext(solanaContext);
+  const {
+    wallets: cosmosWallets,
+    disconnect: cosmosDisconnect,
+    chains: cosmosChains,
+    chainId: cosmosChainId,
+    switchChain: cosmosSwitchChain,
+    connectParaEmbedded: cosmosConnectParaEmbedded,
+    signVerificationMessage: cosmosSignVerificationMessage
+  } = useContext(cosmosContext);
+  const onLoginRef = useStore((state) => state.onLoginRef);
+  const setStep = useModalStore((state) => state.setStep);
+  const setStepDirection = useModalStore((state) => state.setStepDirection);
+  const setIsExternalWalletConnecting = useModalStore((state) => state.setIsExternalWalletConnecting);
+  const isExternalWalletConnecting = useModalStore((state) => state.isExternalWalletConnecting);
+  const setSelectedExternalWalletId = useModalStore((state) => state.setSelectedExternalWalletId);
+  const selectedExternalWalletId = useModalStore((state) => state.selectedExternalWalletId);
+  const setExternalWalletError = useModalStore((state) => state.setExternalWalletError);
+  const setIsUsingMobileConnector = useModalStore((state) => state.setIsUsingMobileConnector);
+  const isUsingMobileConnector = useModalStore((state) => state.isUsingMobileConnector);
+  const para = useInternalClient();
+  const { setSelectedWallet } = useWalletState();
+  const { onNewAuthState } = useAuthActions();
+  const { mutate: verifyExternalWallet } = useVerifyExternalWallet();
+  const [qrUri, setQrUri] = useState();
+  const [chainIdSwitchingTo, setChainIdSwitchingTo] = useState();
+  const [isExternalWalletVerifying, setIsExternalWalletVerifying] = useState(false);
+  const wallets = [...evmWallets, ...solanaWallets, ...cosmosWallets].filter((w) => externalWallets.includes(w.id.toUpperCase())).sort(
+    (a, b) => externalWallets.indexOf(a.id.toUpperCase()) - externalWallets.indexOf(b.id.toUpperCase())
+  ).sort((a, b) => a.installed === b.installed ? 0 : a.installed ? -1 : 1);
+  const wallet = useMemo(() => wallets.find((w) => w.id === selectedExternalWalletId), [wallets, selectedExternalWalletId]);
+  const updateQrUri = () => __async(this, null, function* () {
+    var _a;
+    const uri = yield (_a = wallet == null ? void 0 : wallet.getQrUri) == null ? void 0 : _a.call(wallet);
+    setQrUri(uri);
+  });
+  useEffect(() => {
+    if (wallet) {
+      if (!qrUri) {
+        updateQrUri();
+      }
+    } else if (qrUri) {
+      setQrUri(void 0);
+    }
+  }, [wallet]);
+  const getWalletBalance = useCallback(() => __async(this, null, function* () {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case "EVM": {
+        return yield evmGetWalletBalance();
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }), [evmGetWalletBalance, selectedExternalWalletId]);
+  const chains = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case "COSMOS": {
+        return cosmosChains;
+      }
+      case "EVM": {
+        return evmChains;
+      }
+      default: {
+        return [];
+      }
+    }
+  }, [cosmosChains, evmChains, selectedExternalWalletId]);
+  const chainId = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case "COSMOS": {
+        return cosmosChainId;
+      }
+      case "EVM": {
+        return evmChainId == null ? void 0 : evmChainId.toString();
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }, [cosmosChains, evmChains, selectedExternalWalletId]);
+  const switchChain = useCallback(
+    (chainId2) => __async(this, null, function* () {
+      var _a;
+      const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+      if (walletType) {
+        let resp;
+        setExternalWalletError();
+        setChainIdSwitchingTo(chainId2);
+        switch (walletType) {
+          case "COSMOS": {
+            setStep(ModalStep.CHAIN_SWITCH);
+            resp = yield cosmosSwitchChain(chainId2);
+            break;
+          }
+          case "EVM": {
+            setStep(ModalStep.CHAIN_SWITCH);
+            resp = yield evmSwitchChain(parseInt(chainId2));
+            break;
+          }
+          default: {
+            resp = {};
+            break;
+          }
+        }
+        if (resp.error) {
+          setExternalWalletError(resp.error);
+        } else {
+          setChainIdSwitchingTo(void 0);
+          setStepDirection(-1);
+          setStep(ModalStep.ACCOUNT_MAIN);
+        }
+      }
+    }),
+    [evmSwitchChain, cosmosSwitchChain]
+  );
+  const verifyWalletSignature = useCallback(() => __async(this, null, function* () {
+    var _a;
+    setExternalWalletError();
+    setIsExternalWalletVerifying(true);
+    const walletType = (_a = Object.values(para.externalWallets)[0]) == null ? void 0 : _a.type;
+    let verifyExternalWalletParams;
+    switch (walletType) {
+      case "COSMOS":
+        {
+          const { address, signature, error, cosmosPublicKeyHex, cosmosSigner } = yield cosmosSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            verifyExternalWalletParams = {
+              externalWallet: {
+                type: "COSMOS",
+                address
+              },
+              signedMessage: signature,
+              cosmosPublicKeyHex,
+              cosmosSigner
+            };
+          }
+        }
+        break;
+      case "EVM":
+        {
+          const { signature, error, address } = yield evmSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            verifyExternalWalletParams = {
+              externalWallet: {
+                type: "EVM",
+                address
+              },
+              signedMessage: signature
+            };
+          }
+        }
+        break;
+      case "SOLANA":
+        {
+          const { signature, error, address } = yield solanaSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            verifyExternalWalletParams = {
+              externalWallet: {
+                type: "SOLANA",
+                address
+              },
+              signedMessage: signature
+            };
+          }
+        }
+        break;
+      default:
+        break;
+    }
+    if (verifyExternalWalletParams) {
+      if (!(verifyExternalWalletParams == null ? void 0 : verifyExternalWalletParams.externalWallet) || !(verifyExternalWalletParams == null ? void 0 : verifyExternalWalletParams.signedMessage)) {
+        console.error("No signature or address found on the verifyWalletSignature response.");
+        return;
+      }
+      verifyExternalWallet(verifyExternalWalletParams, {
+        onSuccess: onNewAuthState,
+        onError: (e) => {
+          console.error("Error verifying signature:", e);
+          setExternalWalletError(["Signature verification failed."]);
+        },
+        onSettled: () => {
+          setIsExternalWalletVerifying(false);
+        }
+      });
+      return verifyExternalWalletParams;
+    }
+    setIsExternalWalletVerifying(false);
+    return void 0;
+  }), [cosmosSignVerificationMessage, evmSignVerificationMessage, solanaSignVerificationMessage]);
+  const connectExternalWallet = useCallback(
+    (wallet2, isMobileConnect, isManualWalletConnect, isResetAfterManualWalletConnect) => __async(this, null, function* () {
+      if (isExternalWalletConnecting && isManualWalletConnect) {
+        yield evmDisconnect();
+        yield solanaDisconnect();
+        yield cosmosDisconnect();
+        setQrUri(void 0);
+        setIsExternalWalletConnecting(false);
+      }
+      if (isResetAfterManualWalletConnect || isManualWalletConnect || !isExternalWalletConnecting) {
+        setExternalWalletError();
+        setIsExternalWalletConnecting(true);
+        setIsUsingMobileConnector(isMobileConnect);
+        const { address, error, authState } = yield isMobileConnect ? wallet2.connectMobile(isManualWalletConnect) : wallet2.connect();
+        if (error) {
+          setExternalWalletError([error]);
+          setIsUsingMobileConnector();
+          if (isManualWalletConnect && error === "Connection request rejected") {
+            setExternalWalletError();
+            yield connectExternalWallet(wallet2, false, false, true);
+            yield updateQrUri();
+            return;
+          }
+        } else if (address) {
+          if (!!authState && (externalWalletsWithFullAuth == null ? void 0 : externalWalletsWithFullAuth.includes(wallet2.id.toUpperCase()))) {
+            onNewAuthState(authState);
+          } else {
+            setStep(ModalStep.LOGIN_DONE);
+          }
+        }
+        setIsExternalWalletConnecting(false);
+      }
+    }),
+    [isExternalWalletConnecting, externalWalletsWithFullAuth]
+  );
+  const disconnectExternalWallet = () => __async(this, null, function* () {
+    yield para.logout();
+    yield evmDisconnect();
+    yield cosmosDisconnect();
+    setSelectedExternalWalletId();
+    yield solanaDisconnect();
+  });
+  const walletDisplayHelpers = {
+    // Show the extension screen if on web and the wallet is an extension and installed or the wallet isn't a mobile wallet
+    // Also show the extension connection if on desktop for a solana wallet (no walletConnect)
+    showExtension: !isMobile() && ((wallet == null ? void 0 : wallet.isExtension) && (wallet == null ? void 0 : wallet.installed) || !(wallet == null ? void 0 : wallet.isMobile) || (wallet == null ? void 0 : wallet.type) === "SOLANA"),
+    // Show the mobile screen if on mobile and the wallet is a mobile wallet or if on desktop and the wallet isn't installed
+    showMobile: isMobile() && (wallet == null ? void 0 : wallet.isMobile) || !isMobile() && !(wallet == null ? void 0 : wallet.installed),
+    isSolanaMobileIOS: isIOS() && isMobile() && !isIOSWebview() && (wallet == null ? void 0 : wallet.type) === "SOLANA",
+    isCosmosMobileWallet: (wallet == null ? void 0 : wallet.type) === "COSMOS" && !!isUsingMobileConnector
+  };
+  const username = useMemo(() => {
+    let username2;
+    const storedExternalWallet = Object.values(para.externalWallets || {})[0];
+    if (storedExternalWallet) {
+      const walletType = storedExternalWallet == null ? void 0 : storedExternalWallet.type;
+      switch (walletType) {
+        case "EVM": {
+          username2 = evmUsername ? evmUsername.startsWith("0x") ? truncateAddress(evmUsername, "EVM") : evmUsername : void 0;
+          break;
+        }
+        default: {
+          username2 = storedExternalWallet.address && storedExternalWallet.type ? truncateAddress(storedExternalWallet.address, storedExternalWallet.type) : void 0;
+          break;
+        }
+      }
+    }
+    return username2;
+  }, [evmUsername, wallet]);
+  const avatar = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    if (walletType) {
+      switch (walletType) {
+        case "EVM": {
+          return evmAvatar;
+        }
+        default: {
+          return void 0;
+        }
+      }
+    }
+  }, [evmAvatar, wallet]);
+  const connectEmbeddedToExternalConnectors = useCallback(() => __async(this, null, function* () {
+    try {
+      const { error } = yield evmConnectParaEmbedded();
+      if (error) {
+        console.warn("Failed to connect Para EVM wallet to Wagmi:", error);
+      } else {
+        const wallet2 = para.findWallet(void 0, void 0, { type: ["EVM"] });
+        if (wallet2) {
+          setSelectedWallet({ id: wallet2.id, type: "EVM" });
+        }
+      }
+    } catch (err) {
+      console.warn("Error calling connectParaEvmWallet:", err);
+    }
+    try {
+      const { error } = yield cosmosConnectParaEmbedded();
+      if (error) {
+        console.warn("Failed to connect Para Cosmos wallet to Graz:", error);
+      } else {
+        const wallet2 = para.findWallet(void 0, void 0, { type: ["COSMOS"] });
+        if (wallet2) {
+          setSelectedWallet({ id: wallet2.id, type: "COSMOS" });
+        }
+      }
+    } catch (err) {
+      console.warn("Error calling connectParaCosmosWallet:", err);
+    }
+  }), [evmConnectParaEmbedded, cosmosConnectParaEmbedded]);
+  useEffect(() => {
+    onLoginRef.current = () => __async(this, null, function* () {
+      yield connectEmbeddedToExternalConnectors();
+    });
+  }, [connectEmbeddedToExternalConnectors]);
+  return /* @__PURE__ */ jsx(
+    ExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          connectExternalWallet,
+          disconnectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo,
+          connectEmbeddedToExternalConnectors,
+          verifyWalletSignature,
+          isExternalWalletVerifying,
+          getWalletBalance
+        }),
+        [
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          disconnectExternalWallet,
+          connectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo,
+          connectEmbeddedToExternalConnectors,
+          verifyWalletSignature,
+          isExternalWalletVerifying,
+          getWalletBalance
+        ]
+      ),
+      children
+    }
+  );
+}
+const useExternalWallets = () => useContext(ExternalWalletContext);
+export {
+  ExternalWalletContext,
+  ExternalWalletProvider,
+  defaultExternalWallet,
+  useExternalWallets
+};

package/dist/provider/providers/SolanaExternalWalletProvider.js

@@ -0,0 +1,66 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { memo, useEffect, useMemo } from "react";
+import { useStore } from "../stores/useStore.js";
+import { getParaSolanaConnector } from "../external/getParaSolanaConnector.js";
+function SolanaExternalWalletProvider(_a) {
+  var _b = _a, {
+    children,
+    isUsing,
+    wallets: walletsFromProps
+  } = _b, rest = __objRest(_b, [
+    "children",
+    "isUsing",
+    "wallets"
+  ]);
+  const setSolanaContext = useStore((state) => state.setSolanaContext);
+  const setSolanaProvider = useStore((state) => state.setSolanaProvider);
+  const SolanaProvider = useStore((state) => state.SolanaProvider);
+  const setSolanaWallets = useStore((state) => state.setSolanaWallets);
+  const solanaWallets = useStore((state) => state.solanaWallets);
+  const isLoadingLib = useStore((state) => state.isLoadingSolanaLib);
+  const setIsLoadingLib = useStore((state) => state.setIsLoadingSolanaLib);
+  const filteredWallets = useMemo(
+    () => solanaWallets.filter((w) => walletsFromProps.includes(w().id.toUpperCase())),
+    [solanaWallets, walletsFromProps]
+  );
+  useEffect(() => {
+    const loadLib = () => __async(this, null, function* () {
+      if (SolanaProvider) {
+        return;
+      }
+      const { Provider, context, wallets } = yield getParaSolanaConnector();
+      if (Provider) {
+        setSolanaProvider(Provider);
+      }
+      if (wallets) {
+        setSolanaWallets(wallets);
+      }
+      if (context) {
+        setSolanaContext(context);
+      }
+      setIsLoadingLib(false);
+    });
+    loadLib();
+  }, []);
+  if (isLoadingLib) {
+    return null;
+  }
+  if (SolanaProvider) {
+    return /* @__PURE__ */ jsx(SolanaProvider, __spreadProps(__spreadValues({}, rest), { config: __spreadProps(__spreadValues({}, rest == null ? void 0 : rest.config), { wallets: filteredWallets }), children }));
+  } else if (isUsing) {
+    console.warn("@getpara/solana-wallet-connectors is required to use an external Solana wallet.");
+  }
+  return children;
+}
+const MemoizedSolanaExternalWalletProvider = memo(SolanaExternalWalletProvider);
+export {
+  MemoizedSolanaExternalWalletProvider,
+  SolanaExternalWalletProvider
+};

package/dist/provider/stores/getters.d.ts

@@ -1,4 +1,4 @@
 export declare const getClient: () => import("@getpara/web-sdk").ParaWeb | undefined;
 export declare const getIsOpen: () => boolean;
 export declare const getSelectedWalletId: () => string | undefined;
-export declare const getSelectedWalletType: () => import("@getpara/user-management-client").WalletType | undefined;
+export declare const getSelectedWalletType: () => "EVM" | "SOLANA" | "COSMOS" | undefined;

package/dist/provider/stores/getters.js

@@ -0,0 +1,13 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { vanillaStore } from "./useStore.js";
+const getClient = () => vanillaStore.getState().client;
+const getIsOpen = () => vanillaStore.getState().isOpen;
+const getSelectedWalletId = () => vanillaStore.getState().selectedWalletId;
+const getSelectedWalletType = () => vanillaStore.getState().selectedWalletType;
+export {
+  getClient,
+  getIsOpen,
+  getSelectedWalletId,
+  getSelectedWalletType
+};

package/dist/provider/stores/setters.js

@@ -0,0 +1,7 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { vanillaStore } from "./useStore.js";
+const setIsOpen = (isOpen) => vanillaStore.setState({ isOpen });
+export {
+  setIsOpen
+};

package/dist/provider/stores/slices/client.js

@@ -0,0 +1,9 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createClientSlice = (set) => ({
+  client: void 0,
+  setClient: (client) => set({ client })
+});
+export {
+  createClientSlice
+};

package/dist/provider/stores/slices/config.js

@@ -0,0 +1,9 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createConfigSlice = (set) => ({
+  appName: "",
+  setAppName: (appName) => set({ appName })
+});
+export {
+  createConfigSlice
+};

package/dist/provider/stores/slices/externalWallets.js

@@ -0,0 +1,40 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { EvmExternalWalletContext } from "../../external/stubs/EvmExternalWalletContextStub.js";
+import { CosmosExternalWalletContext } from "../../external/stubs/CosmosExternalWalletContextStub.js";
+import { SolanaExternalWalletContext } from "../../external/stubs/SolanaExternalWalletContextStub.js";
+import { createRef } from "react";
+const createExternalWalletsSlice = (set) => ({
+  externalWallets: [],
+  setExternalWallets: (externalWallets) => set({ externalWallets }),
+  externalWalletsWithFullAuth: [],
+  setExternalWalletsWithFullAuth: (externalWalletsWithFullAuth) => set({ externalWalletsWithFullAuth }),
+  evmContext: EvmExternalWalletContext,
+  setEvmContext: (evmContext) => set({ evmContext }),
+  EvmProvider: void 0,
+  setEvmProvider: (EvmProvider) => set({ EvmProvider }),
+  evmWallets: [],
+  setEvmWallets: (evmWallets) => set({ evmWallets }),
+  isLoadingEvmLib: true,
+  setIsLoadingEvmLib: (isLoadingEvmLib) => set({ isLoadingEvmLib }),
+  cosmosContext: CosmosExternalWalletContext,
+  setCosmosContext: (cosmosContext) => set({ cosmosContext }),
+  CosmosProvider: void 0,
+  setCosmosProvider: (CosmosProvider) => set({ CosmosProvider }),
+  cosmosWallets: [],
+  setCosmosWallets: (cosmosWallets) => set({ cosmosWallets }),
+  isLoadingCosmosLib: true,
+  setIsLoadingCosmosLib: (isLoadingCosmosLib) => set({ isLoadingCosmosLib }),
+  solanaContext: SolanaExternalWalletContext,
+  setSolanaContext: (solanaContext) => set({ solanaContext }),
+  SolanaProvider: void 0,
+  setSolanaProvider: (SolanaProvider) => set({ SolanaProvider }),
+  solanaWallets: [],
+  setSolanaWallets: (solanaWallets) => set({ solanaWallets }),
+  isLoadingSolanaLib: true,
+  setIsLoadingSolanaLib: (isLoadingSolanaLib) => set({ isLoadingSolanaLib }),
+  onLoginRef: createRef()
+});
+export {
+  createExternalWalletsSlice
+};

package/dist/provider/stores/slices/index.js

@@ -0,0 +1,5 @@
+"use client";
+export * from "./client.js";
+export * from "./modal.js";
+export * from "./wallet.js";
+export * from "./externalWallets.js";

package/dist/provider/stores/slices/modal.js

@@ -0,0 +1,16 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createModalSlice = (set, get) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  return {
+    modalConfig: void 0,
+    setModalConfig: (modalConfig) => set({ modalConfig }),
+    isDarkTheme: ((_c = (_b = (_a = get()) == null ? void 0 : _a.modalConfig) == null ? void 0 : _b.theme) == null ? void 0 : _c.mode) === "dark",
+    oAuthLogoVariant: (_g = (_f = (_e = (_d = get()) == null ? void 0 : _d.modalConfig) == null ? void 0 : _e.theme) == null ? void 0 : _f.oAuthLogoVariant) != null ? _g : "default",
+    isOpen: false,
+    setIsOpen: (isOpen) => set({ isOpen })
+  };
+};
+export {
+  createModalSlice
+};

package/dist/provider/stores/slices/wallet.js

@@ -0,0 +1,13 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const createWalletSlice = (set) => ({
+  rpcUrl: void 0,
+  setRpcUrl: (rpcUrl) => set({ rpcUrl }),
+  selectedWalletId: void 0,
+  selectedWalletType: void 0,
+  setSelectedWallet: (selectedWalletId, selectedWalletType) => set({ selectedWalletId, selectedWalletType }),
+  clearSelectedWallet: () => set({ selectedWalletId: void 0, selectedWalletType: void 0 })
+});
+export {
+  createWalletSlice
+};

package/dist/provider/stores/types.d.ts

@@ -1,10 +1,11 @@
 import { Context, MutableRefObject } from 'react';
-import ParaWeb, { WalletType } from '@getpara/web-sdk';
+import ParaWeb, { TWalletType } from '@getpara/web-sdk';
 import { EvmExternalWalletContextType, ParaEvmProvider, WalletList as EvmWalletList } from '@getpara/evm-wallet-connectors';
 import { CosmosExternalWalletContextType, ParaCosmosProvider, WalletList as CosmosWalletList } from '@getpara/cosmos-wallet-connectors';
 import { ParaSolanaProvider, SolanaExternalWalletContextType, WalletList as SolanaWalletList } from '@getpara/solana-wallet-connectors';
-import { ParaModalProps, TExternalWallet } from '../../modal/index.js';
+import { ParaModalProps } from '../../modal/index.js';
 import { OAuthLogoVariantType } from '../../modal/types/modalProps.js';
+import { type TExternalWallet } from '@getpara/react-common';
 export interface ClientSlice {
     client?: ParaWeb;
     setClient: (_: ParaWeb) => void;
@@ -22,9 +23,11 @@ export interface ModalSlice {
     setIsOpen: (_: boolean) => void;
 }
 export interface WalletSlice {
+    rpcUrl?: string;
+    setRpcUrl: (_?: string) => void;
     selectedWalletId?: string;
-    selectedWalletType?: WalletType;
-    setSelectedWallet: (_?: string, __?: WalletType) => void;
+    selectedWalletType?: TWalletType;
+    setSelectedWallet: (_?: string, __?: TWalletType) => void;
     clearSelectedWallet: () => void;
 }
 export interface ExternalWalletsSlice {

package/dist/provider/stores/types.js

@@ -0,0 +1 @@
+"use client";

package/dist/provider/stores/useStore.js

@@ -0,0 +1,28 @@
+"use client";
+import {
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { createStore, useStore as useZustandStore } from "zustand";
+import { createClientSlice, createExternalWalletsSlice, createModalSlice, createWalletSlice } from "./slices/index.js";
+import { createJSONStorage, persist } from "zustand/middleware";
+import { createConfigSlice } from "./slices/config.js";
+const vanillaStore = createStore()(
+  persist(
+    (...a) => __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, createClientSlice(...a)), createModalSlice(...a)), createWalletSlice(...a)), createExternalWalletsSlice(...a)), createConfigSlice(...a)),
+    {
+      version: 1,
+      name: "@PARA/provider-state",
+      storage: createJSONStorage(() => localStorage),
+      partialize: (state) => ({
+        selectedWalletId: state.selectedWalletId,
+        selectedWalletType: state.selectedWalletType
+      })
+    }
+  )
+);
+const createBoundedUseStore = (store) => (selector) => useZustandStore(store, selector);
+const useStore = createBoundedUseStore(vanillaStore);
+export {
+  useStore,
+  vanillaStore
+};