@getpara/react-sdk 1.7.0 → 1.8.0

package/dist/modal/providers/ExternalWalletContext.js

@@ -0,0 +1,394 @@
+"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, useUserInfoStore } from "../stores/index.js";
+import { ModalStep } from "../utils/steps.js";
+import { AuthMethod, WalletType, isIOS, isIOSWebview, isMobile, truncateAddress } from "@getpara/web-sdk";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { getExternalWalletDisplayName } from "@getpara/react-common";
+import { useSetLoginURLs } from "../hooks/useSetLoginURLs.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,
+  balance: void 0,
+  connectExternalWallet: () => {
+  },
+  disconnectExternalWallet: () => Promise.resolve(),
+  switchChain: () => Promise.resolve(),
+  setChainIdSwitchingTo: () => {
+  },
+  verifyWalletSignature: () => Promise.resolve({})
+};
+const ExternalWalletContext = createContext(defaultExternalWallet);
+function ExternalWalletProvider({
+  children,
+  evmContext,
+  solanaContext,
+  cosmosContext,
+  walletSort,
+  externalWalletsWithFullAuth
+}) {
+  const {
+    wallets: evmWallets,
+    disconnect: evmDisconnect,
+    chains: evmChains,
+    chainId: evmChainId,
+    switchChain: evmSwitchChain,
+    username: evmUsername,
+    avatar: evmAvatar,
+    balance: evmBalance,
+    signVerificationMessage: evmSignVerificationMessage
+  } = useContext(evmContext);
+  const {
+    wallets: solanaWallets,
+    disconnect: solanaDisconnect,
+    signVerificationMessage: solanaSignVerificationMessage
+  } = useContext(solanaContext);
+  const {
+    wallets: cosmosWallets,
+    disconnect: cosmosDisconnect,
+    chains: cosmosChains,
+    chainId: cosmosChainId,
+    switchChain: cosmosSwitchChain,
+    signVerificationMessage: cosmosSignVerificationMessage
+  } = useContext(cosmosContext);
+  const setStep = useModalStore((state) => state.setStep);
+  const setFlow = useModalStore((state) => state.setFlow);
+  const setSupportedAuthMethods = useModalStore((state) => state.setSupportedAuthMethods);
+  const setBiometricLocationHints = useModalStore((state) => state.setBiometricLocationHints);
+  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 setAuthInfo = useUserInfoStore((state) => state.setAuthInfo);
+  const setLoginURLs = useSetLoginURLs();
+  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 balance = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case WalletType.EVM: {
+        return evmBalance;
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }, [evmBalance, selectedExternalWalletId]);
+  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 verifyWalletSignature = useCallback(() => __async(this, null, function* () {
+    var _a;
+    setExternalWalletError();
+    const walletType = (_a = Object.values(para.externalWallets)[0]) == null ? void 0 : _a.type;
+    if (walletType) {
+      const resp = {
+        address: "",
+        signature: "",
+        cosmosPublicKeyHex: "",
+        cosmosSigner: ""
+      };
+      switch (walletType) {
+        case WalletType.COSMOS: {
+          const { signature, error, cosmosPublicKeyHex, cosmosSigner, address } = yield cosmosSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature) {
+            resp.address = address;
+            resp.signature = signature;
+            resp.cosmosPublicKeyHex = cosmosPublicKeyHex;
+            resp.cosmosSigner = cosmosSigner;
+          }
+          return resp;
+        }
+        case WalletType.EVM: {
+          const { signature, error, address } = yield evmSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            resp.address = address;
+            resp.signature = signature;
+          }
+          return resp;
+        }
+        case WalletType.SOLANA: {
+          const { signature, error, address } = yield solanaSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            resp.address = address;
+            resp.signature = signature;
+          }
+          return resp;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+  }), [evmSwitchChain, cosmosSwitchChain]);
+  const completeFullAuth = (address, type, userExists, isVerified, bufferAddress) => __async(this, null, function* () {
+    setAuthInfo({
+      displayName: getExternalWalletDisplayName({
+        address,
+        type
+      }),
+      externalWalletAddress: bufferAddress != null ? bufferAddress : address
+    });
+    if (userExists && isVerified) {
+      const supportedAuthMethods = yield para.supportedAuthMethods({
+        externalWalletAddress: bufferAddress != null ? bufferAddress : address
+      });
+      if (!supportedAuthMethods.size) {
+        setFlow("signUp");
+        setStep(ModalStep.EXTERNAL_WALLET_VERIFICATION);
+        return;
+      }
+      yield para.initiateUserLoginV2({
+        externalWalletAddress: bufferAddress != null ? bufferAddress : address
+      });
+      const biometricLocationHints = supportedAuthMethods.has(AuthMethod.PASSKEY) ? yield para.getUserBiometricLocationHints() : [];
+      yield setLoginURLs({ supportedAuthMethods, authType: "externalWallet" });
+      setFlow("login");
+      setStep(ModalStep.BIOMETRIC_LOGIN);
+      setSupportedAuthMethods(supportedAuthMethods);
+      setBiometricLocationHints(biometricLocationHints);
+    } else {
+      setFlow("signUp");
+      setStep(ModalStep.EXTERNAL_WALLET_VERIFICATION);
+    }
+  });
+  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, bufferAddress, error, userExists, isVerified } = 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 (externalWalletsWithFullAuth == null ? void 0 : externalWalletsWithFullAuth.includes(wallet2.id.toUpperCase())) {
+            yield completeFullAuth(address, wallet2.type, userExists, isVerified, bufferAddress);
+          } 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) === 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,
+          balance,
+          connectExternalWallet,
+          disconnectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo,
+          verifyWalletSignature
+        }),
+        [
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          balance,
+          disconnectExternalWallet,
+          connectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo,
+          verifyWalletSignature
+        ]
+      ),
+      children
+    }
+  );
+}
+const useExternalWallets = () => useContext(ExternalWalletContext);
+export {
+  ExternalWalletContext,
+  ExternalWalletProvider,
+  defaultExternalWallet,
+  useExternalWallets
+};

package/dist/modal/providers/SolanaExternalWalletContextStub.js

@@ -0,0 +1,32 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from "react";
+const defaultSolanaExternalWallet = {
+  wallets: [],
+  disconnect: () => Promise.resolve(),
+  signMessage: () => Promise.resolve({}),
+  signVerificationMessage: () => Promise.resolve({})
+};
+const SolanaExternalWalletContext = createContext(defaultSolanaExternalWallet);
+function SolanaExternalWalletProvider({ children }) {
+  const wallets = [];
+  const disconnect = () => Promise.resolve();
+  const signMessage = () => Promise.resolve({});
+  const signVerificationMessage = () => Promise.resolve({});
+  return /* @__PURE__ */ jsx(
+    SolanaExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({ wallets, disconnect, signMessage, signVerificationMessage }),
+        [wallets, disconnect, signMessage, signVerificationMessage]
+      ),
+      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,21 @@
+"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,
+  fullAuthWallets: []
+};
+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
+};