@getpara/react-sdk 1.6.0 → 1.6.1-dev.0

package/dist/modal/providers/CosmosExternalWalletContextStub.js

@@ -0,0 +1,34 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from "react";
+const defaultCosmosExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  disconnect: () => Promise.resolve(),
+  switchChain: () => Promise.resolve({})
+};
+const CosmosExternalWalletContext = createContext(defaultCosmosExternalWallet);
+function CosmosExternalWalletProvider({ children }) {
+  const wallets = [];
+  const chains = [];
+  const chainId = void 0;
+  const disconnect = () => Promise.resolve();
+  const switchChain = () => Promise.resolve({});
+  return /* @__PURE__ */ jsx(
+    CosmosExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({ wallets, chains, chainId, disconnect, switchChain }),
+        [wallets, chains, chainId, disconnect, switchChain]
+      ),
+      children
+    }
+  );
+}
+export {
+  CosmosExternalWalletContext,
+  CosmosExternalWalletProvider,
+  defaultCosmosExternalWallet
+};

package/dist/modal/providers/EvmExternalWalletContextStub.js

@@ -0,0 +1,38 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from "react";
+const defaultEvmExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  username: void 0,
+  avatar: void 0,
+  disconnect: () => Promise.resolve(),
+  switchChain: () => Promise.resolve({})
+};
+const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+function EvmExternalWalletProvider({ children }) {
+  const wallets = [];
+  const chains = [];
+  const chainId = void 0;
+  const username = void 0;
+  const avatar = void 0;
+  const disconnect = () => Promise.resolve();
+  const switchChain = () => Promise.resolve({});
+  return /* @__PURE__ */ jsx(
+    EvmExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({ wallets, chains, chainId, username, avatar, disconnect, switchChain }),
+        [wallets, chains, chainId, username, avatar, disconnect, switchChain]
+      ),
+      children
+    }
+  );
+}
+export {
+  EvmExternalWalletContext,
+  EvmExternalWalletProvider,
+  defaultEvmExternalWallet
+};

package/dist/modal/providers/ExternalWalletContext.js

@@ -0,0 +1,275 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { useModalStore } from "../stores/index.js";
+import { ModalStep } from "../utils/steps.js";
+import { WalletType, isIOS, isIOSWebview, isMobile, truncateAddress } from "@getpara/web-sdk";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.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: () => {
+  },
+  disconnectExternalWallet: () => Promise.resolve(),
+  switchChain: () => Promise.resolve(),
+  setChainIdSwitchingTo: () => {
+  }
+};
+const ExternalWalletContext = createContext(defaultExternalWallet);
+function ExternalWalletProvider({
+  children,
+  evmContext,
+  solanaContext,
+  cosmosContext,
+  walletSort
+}) {
+  const {
+    wallets: evmWallets,
+    disconnect: evmDisconnect,
+    chains: evmChains,
+    chainId: evmChainId,
+    switchChain: evmSwitchChain,
+    username: evmUsername,
+    avatar: evmAvatar
+  } = useContext(evmContext);
+  const { wallets: solanaWallets, disconnect: solanaDisconnect } = useContext(solanaContext);
+  const {
+    wallets: cosmosWallets,
+    disconnect: cosmosDisconnect,
+    chains: cosmosChains,
+    chainId: cosmosChainId,
+    switchChain: cosmosSwitchChain
+  } = useContext(cosmosContext);
+  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 [qrUri, setQrUri] = useState();
+  const [chainIdSwitchingTo, setChainIdSwitchingTo] = useState();
+  const wallets = [...evmWallets, ...solanaWallets, ...cosmosWallets].filter((w) => walletSort.includes(w.id.toUpperCase())).sort(
+    (a, b) => walletSort.indexOf(a.id.toUpperCase()) - walletSort.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 chains = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case WalletType.COSMOS: {
+        return cosmosChains;
+      }
+      case WalletType.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 WalletType.COSMOS: {
+        return cosmosChainId;
+      }
+      case WalletType.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 WalletType.COSMOS: {
+            setStep(ModalStep.CHAIN_SWITCH);
+            resp = yield cosmosSwitchChain(chainId2);
+            break;
+          }
+          case WalletType.EVM: {
+            setStep(ModalStep.CHAIN_SWITCH);
+            resp = yield evmSwitchChain(parseInt(chainId2));
+            break;
+          }
+          default: {
+            break;
+          }
+        }
+        if (resp.error) {
+          setExternalWalletError(resp.error);
+        } else {
+          setChainIdSwitchingTo(void 0);
+          setStepDirection(-1);
+          setStep(ModalStep.ACCOUNT_MAIN);
+        }
+      }
+    }),
+    [evmSwitchChain, cosmosSwitchChain]
+  );
+  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 } = 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) {
+          setStep(ModalStep.LOGIN_DONE);
+        }
+        setIsExternalWalletConnecting(false);
+      }
+    }),
+    [isExternalWalletConnecting]
+  );
+  const disconnectExternalWallet = () => __async(this, null, function* () {
+    yield evmDisconnect();
+    yield solanaDisconnect();
+    yield cosmosDisconnect();
+    setSelectedExternalWalletId();
+  });
+  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) === WalletType.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) === WalletType.SOLANA,
+    isCosmosMobileWallet: (wallet == null ? void 0 : wallet.type) === WalletType.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 WalletType.EVM: {
+          username2 = evmUsername ? evmUsername.startsWith("0x") ? truncateAddress(evmUsername, "EVM") : evmUsername : void 0;
+          break;
+        }
+        default: {
+          username2 = storedExternalWallet.address ? 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 WalletType.EVM: {
+          return evmAvatar;
+        }
+        default: {
+          return void 0;
+        }
+      }
+    }
+  }, [evmAvatar, wallet]);
+  return /* @__PURE__ */ jsx(
+    ExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          connectExternalWallet,
+          disconnectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo
+        }),
+        [
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          disconnectExternalWallet,
+          connectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo
+        ]
+      ),
+      children
+    }
+  );
+}
+const useExternalWallets = () => useContext(ExternalWalletContext);
+export {
+  ExternalWalletContext,
+  ExternalWalletProvider,
+  defaultExternalWallet,
+  useExternalWallets
+};

package/dist/modal/providers/SolanaExternalWalletContextStub.js

@@ -0,0 +1,19 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from "react";
+const defaultSolanaExternalWallet = {
+  wallets: [],
+  disconnect: () => Promise.resolve()
+};
+const SolanaExternalWalletContext = createContext(defaultSolanaExternalWallet);
+function SolanaExternalWalletProvider({ children }) {
+  const wallets = [];
+  const disconnect = () => Promise.resolve();
+  return /* @__PURE__ */ jsx(SolanaExternalWalletContext.Provider, { value: useMemo(() => ({ wallets, disconnect }), [wallets, disconnect]), children });
+}
+export {
+  SolanaExternalWalletContext,
+  SolanaExternalWalletProvider,
+  defaultSolanaExternalWallet
+};

package/dist/modal/stores/externalWalletProvider/actions.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const getActions = (set) => ({
+  updateState: (state) => {
+    set(state);
+  }
+});
+export {
+  getActions
+};

package/dist/modal/stores/externalWalletProvider/useExternalWalletProviderStore.js

@@ -0,0 +1,20 @@
+"use client";
+import {
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { create } from "zustand";
+import { getActions } from "./actions.js";
+const DEFAULT_EX_WALLET_PROVIDER_STATE = {
+  EvmProvider: void 0,
+  evmContext: void 0,
+  SolanaProvider: void 0,
+  solanaContext: void 0,
+  CosmosProvider: void 0,
+  cosmosContext: void 0,
+  connectParaEvmWallet: void 0,
+  connectParaCosmosWallet: void 0
+};
+const useExternalWalletProviderStore = create((set) => __spreadValues(__spreadValues({}, DEFAULT_EX_WALLET_PROVIDER_STATE), getActions(set)));
+export {
+  useExternalWalletProviderStore
+};

package/dist/modal/stores/index.js

@@ -0,0 +1,4 @@
+"use client";
+export * from "./modal/useModalStore.js";
+export * from "./userInfo/useUserInfoStore.js";
+export * from "./theme/useThemeStore.js";

package/dist/modal/stores/modal/actions.js

@@ -0,0 +1,70 @@
+"use client";
+import {
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { DEFAULT_MODAL_STATE } from "./useModalStore.js";
+import { AccountPreviousStep, LoginPreviousStep, ModalStep, SignUpPreviousStep } from "../../utils/steps.js";
+const getActions = (set, get) => ({
+  resetState: () => set(DEFAULT_MODAL_STATE),
+  setOnModalStepChange: (onModalStepChange) => set({ onModalStepChange }),
+  setStep: (step) => {
+    const onModalStepChange = get().onModalStepChange;
+    const previousStep = get().step;
+    set({ step });
+    onModalStepChange == null ? void 0 : onModalStepChange({ previousStep, currentStep: step, canGoBack: get().hasPreviousStep() });
+  },
+  decrementStep: () => {
+    var _a;
+    const onModalStepChange = get().onModalStepChange;
+    const isLogin = get().flow === "login";
+    const isAccount = get().flow === "account";
+    const currentStep = get().step;
+    const webAuthURLForCreate = get().webAuthURLForCreate;
+    const iFrameUrl = get().iFrameUrl;
+    const refs = get().refs;
+    let prevStep = (isAccount ? AccountPreviousStep : isLogin ? LoginPreviousStep : SignUpPreviousStep)[currentStep];
+    if (currentStep === ModalStep.PASSWORD_CREATION && iFrameUrl && !webAuthURLForCreate) {
+      prevStep = ModalStep.AUTH_MAIN;
+    }
+    if (currentStep === ModalStep.EX_WALLET_SELECTED) {
+      set({ selectedExternalWalletId: void 0, isExternalWalletConnecting: false, externalWalletError: void 0 });
+    }
+    if (prevStep) {
+      set({ step: prevStep, stepDirection: -1 });
+      onModalStepChange == null ? void 0 : onModalStepChange({ previousStep: currentStep, currentStep: prevStep, canGoBack: get().hasPreviousStep() });
+    }
+    (_a = refs.popupWindow.current) == null ? void 0 : _a.close();
+    refs.popupWindow.current = void 0;
+  },
+  hasPreviousStep: () => {
+    const isLogin = get().flow === "login";
+    const isAccount = get().flow === "account";
+    const currentStep = get().step;
+    return !!(isAccount ? AccountPreviousStep[currentStep] : isLogin ? LoginPreviousStep[currentStep] : SignUpPreviousStep[currentStep]);
+  },
+  setFlow: (flow) => set({ flow }),
+  isLogin: () => get().flow === "login",
+  isAccount: () => get().flow === "account",
+  setWebAuthURLForLogin: (url) => set({ webAuthURLForLogin: url }),
+  setWebAuthURLForCreate: (url) => set({ webAuthURLForCreate: url }),
+  setPasswordUrlForLogin: (url) => set({ passwordUrlForLogin: url }),
+  setSupportedAuthMethods: (supportedAuthMethods) => set({ supportedAuthMethods }),
+  setOnRampPurchase: (onRampPurchase) => set((state) => ({ onRampPurchase: __spreadValues(__spreadValues({}, state.onRampPurchase || {}), onRampPurchase) })),
+  setOnRampConfig: (onRampConfig) => set({ onRampConfig }),
+  setIsFullyLoggedIn: (isFullyLoggedIn) => set({ isFullyLoggedIn }),
+  setAccountAddFundTab: (accountAddFundTab) => set({ accountAddFundTab }),
+  setSelectedExternalWalletId: (selectedExternalWalletId) => set({ selectedExternalWalletId }),
+  setIsExternalWalletConnecting: (isExternalWalletConnecting) => set({ isExternalWalletConnecting }),
+  setExternalWalletError: (externalWalletError) => set({ externalWalletError }),
+  setIsUsingMobileConnector: (isUsingMobileConnector) => set({ isUsingMobileConnector }),
+  setStepDirection: (stepDirection) => set({ stepDirection }),
+  setFarcasterConnectUri: (farcasterConnectUri) => set({ farcasterConnectUri }),
+  setBiometricLocationHints: (biometricLocationHints) => set({ biometricLocationHints }),
+  setIFrameUrl: (iFrameUrl) => set({ iFrameUrl }),
+  setIsIFrameReady: (isIFrameReady) => set({ isIFrameReady }),
+  setAuthStepRoute: (authStepRoute) => set({ authStepRoute }),
+  setIsPasskeySupported: (isPasskeySupported) => set({ isPasskeySupported })
+});
+export {
+  getActions
+};

package/dist/modal/stores/modal/useModalStore.js

@@ -0,0 +1,65 @@
+"use client";
+import {
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { create } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+import { ModalStep } from "../../utils/steps.js";
+import { getActions } from "./actions.js";
+import { createRef } from "react";
+const DEFAULT_MODAL_STATE = {
+  flow: void 0,
+  stepDirection: 1,
+  webAuthURLForLogin: void 0,
+  webAuthURLForCreate: void 0,
+  passwordUrlForLogin: void 0,
+  supportedAuthMethods: /* @__PURE__ */ new Set(),
+  onModalStepChange: void 0,
+  onRampPurchase: void 0,
+  isFullyLoggedIn: false,
+  accountAddFundTab: void 0,
+  isExternalWalletConnecting: false,
+  externalWalletError: void 0,
+  activeWallet: [void 0, void 0],
+  farcasterConnectUri: void 0,
+  biometricLocationHints: void 0,
+  iFrameUrl: void 0,
+  isIFrameReady: void 0,
+  refs: {
+    popupWindow: createRef(),
+    poll: createRef(),
+    currentStep: createRef()
+  },
+  authStepRoute: void 0,
+  isPasskeySupported: true
+};
+const useModalStore = create()(
+  persist(
+    (set, get) => __spreadValues(__spreadValues({
+      step: ModalStep.AUTH_MAIN,
+      onRampConfig: void 0,
+      activeWallet: void 0
+    }, DEFAULT_MODAL_STATE), getActions(set, get)),
+    {
+      version: 1,
+      name: "@PARA/modalState",
+      storage: createJSONStorage(() => localStorage),
+      partialize: (state) => ({
+        step: state.step,
+        webAuthURLForLogin: state.webAuthURLForLogin,
+        webAuthURLForCreate: state.webAuthURLForCreate,
+        passwordUrlForLogin: state.passwordUrlForLogin,
+        biometricLocationHints: state.biometricLocationHints,
+        onRampPurchase: state.onRampPurchase,
+        selectedExternalWalletId: state.selectedExternalWalletId,
+        isUsingMobileConnector: state.isUsingMobileConnector,
+        supportedAuthMethods: state.supportedAuthMethods,
+        isPasskeySupported: state.isPasskeySupported
+      })
+    }
+  )
+);
+export {
+  DEFAULT_MODAL_STATE,
+  useModalStore
+};

package/dist/modal/stores/theme/actions.js

@@ -0,0 +1,28 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+const getActions = (set, get) => ({
+  updateState: (state) => {
+    set(state);
+  },
+  getLogo: () => {
+    var _a;
+    return (_a = get().logo) != null ? _a : void 0;
+  },
+  setAuthLayout: (authLayout) => {
+    const types = [];
+    const uniqueLayouts = [];
+    authLayout.map((layout) => {
+      const type = layout.split(":")[0];
+      if (!types.includes(type)) {
+        uniqueLayouts.push(layout);
+        types.push(type);
+      } else {
+        console.warn(`${layout} is a duplicate ${type} layout type. Please remove the duplicate type from your config.`);
+      }
+    });
+    set({ authLayout: uniqueLayouts });
+  }
+});
+export {
+  getActions
+};

package/dist/modal/stores/theme/useThemeStore.js

@@ -0,0 +1,21 @@
+"use client";
+import {
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { create } from "zustand";
+import { getActions } from "./actions.js";
+import { AuthLayout } from "../../types/modalProps.js";
+const DEFAULT_THEME = {
+  isDark: false,
+  logo: void 0,
+  appName: void 0,
+  bareModal: false,
+  embeddedModal: false,
+  oAuthLogoVariant: void 0,
+  authLayout: [AuthLayout.AUTH_FULL, AuthLayout.EXTERNAL_FULL],
+  hideWallets: false
+};
+const useThemeStore = create((set, get) => __spreadValues(__spreadValues({}, DEFAULT_THEME), getActions(set, get)));
+export {
+  useThemeStore
+};

package/dist/modal/stores/userInfo/actions.js

@@ -0,0 +1,30 @@
+"use client";
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { DEFAULT_USER_INFO_STATE } from "./useUserInfoStore.js";
+import { extractAuthInfo } from "@getpara/user-management-client";
+const getActions = (set, get) => ({
+  resetState: () => {
+    set(DEFAULT_USER_INFO_STATE);
+  },
+  setAuthInfo: (_a) => {
+    var _b = _a, { pfpUrl, displayName } = _b, auth = __objRest(_b, ["pfpUrl", "displayName"]);
+    set({ auth, pfpUrl: pfpUrl || null, displayName: displayName || null });
+  },
+  getAuthInfo: () => {
+    try {
+      return get().auth ? __spreadProps(__spreadValues({}, extractAuthInfo(get().auth, { isRequired: true })), { pfpUrl: get().pfpUrl, displayName: get().displayName }) : null;
+    } catch (e) {
+      return null;
+    }
+  },
+  setRecoveryShare: (recoveryShare) => {
+    set({ recoveryShare });
+  }
+});
+export {
+  getActions
+};

package/dist/modal/stores/userInfo/useUserInfoStore.js

@@ -0,0 +1,17 @@
+"use client";
+import {
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { create } from "zustand";
+import { getActions } from "./actions.js";
+const DEFAULT_USER_INFO_STATE = {
+  auth: null,
+  recoveryShare: null,
+  pfpUrl: null,
+  displayName: null
+};
+const useUserInfoStore = create((set, get) => __spreadValues(__spreadValues({}, DEFAULT_USER_INFO_STATE), getActions(set, get)));
+export {
+  DEFAULT_USER_INFO_STATE,
+  useUserInfoStore
+};

package/dist/modal/types/commonTypes.js

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

package/dist/modal/types/externalWallets.js

@@ -0,0 +1,31 @@
+"use client";
+import {
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+var EvmWallet = /* @__PURE__ */ ((EvmWallet2) => {
+  EvmWallet2["METAMASK"] = "METAMASK";
+  EvmWallet2["RAINBOW"] = "RAINBOW";
+  EvmWallet2["COINBASE"] = "COINBASE";
+  EvmWallet2["WALLETCONNECT"] = "WALLETCONNECT";
+  EvmWallet2["ZERION"] = "ZERION";
+  EvmWallet2["RABBY"] = "RABBY";
+  return EvmWallet2;
+})(EvmWallet || {});
+var SolanaWallet = /* @__PURE__ */ ((SolanaWallet2) => {
+  SolanaWallet2["PHANTOM"] = "PHANTOM";
+  SolanaWallet2["GLOW"] = "GLOW";
+  SolanaWallet2["BACKPACK"] = "BACKPACK";
+  return SolanaWallet2;
+})(SolanaWallet || {});
+var CosmosWallet = /* @__PURE__ */ ((CosmosWallet2) => {
+  CosmosWallet2["KEPLR"] = "KEPLR";
+  CosmosWallet2["LEAP"] = "LEAP";
+  return CosmosWallet2;
+})(CosmosWallet || {});
+const ExternalWallet = __spreadValues(__spreadValues(__spreadValues({}, EvmWallet), SolanaWallet), CosmosWallet);
+export {
+  CosmosWallet,
+  EvmWallet,
+  ExternalWallet,
+  SolanaWallet
+};