@openfort/react 1.0.1 → 1.0.3

package/build/components/Openfort/OpenfortProvider.js

@@ -9,12 +9,14 @@ import { CoreOpenfortProvider } from '../../openfort/CoreOpenfortProvider.js';
 import { logger } from '../../utils/logger.js';
 import { buildChainFromConfig } from '../../utils/rpc.js';
 import { isFamily } from '../../utils/wallets.js';
-import { EmbeddedWalletWagmiSync } from '../../wagmi/useEmbeddedWalletWagmiSync.js';
 import { OpenfortContext, UIContext } from './context.js';
 import { UIAuthProvider, routes, defaultSendFormState, defaultBuyFormState, notStoredInHistoryRoutes } from './types.js';
 
-const SolanaContextProvider = lazy(() => import('../../solana/SolanaContext.js').then((m) => ({ default: m.SolanaContextProvider })));
-const LazyConnectKitModal = lazy(() => import('../ConnectModal/index.js'));
+const SolanaContextProvider = lazy(() => import(/* @vite-ignore */ '../../solana/SolanaContext.js').then((m) => ({ default: m.SolanaContextProvider })));
+const LazyEmbeddedWalletWagmiSync = lazy(() => import(/* @vite-ignore */ '../../wagmi/useEmbeddedWalletWagmiSync.js').then((m) => ({
+    default: m.EmbeddedWalletWagmiSync,
+})));
+const LazyConnectKitModal = lazy(() => import(/* @vite-ignore */ '../ConnectModal/index.js'));
 let openfortProviderWarnedNoWagmi = false;
 /**
  * Root provider for Openfort. Wrap your app with this to enable connect modal, auth, and wallet features.
@@ -92,8 +94,8 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
             defaultMethod: allowAutomaticRecovery ? RecoveryMethod.AUTOMATIC : RecoveryMethod.PASSWORD,
         },
         authProviders: hasWagmi
-            ? [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.WALLET]
-            : [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP],
+            ? [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.WALLET, UIAuthProvider.GOOGLE]
+            : [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.GOOGLE],
     }), [allowAutomaticRecovery, hasWagmi]);
     const safeUiConfig = useMemo(() => {
         var _a, _b, _c, _d, _e;
@@ -318,7 +320,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
         setBuyForm,
         triggerResize,
     ]);
-    const innerChildren = (jsxs(Fragment, { children: [hasWagmi && jsx(EmbeddedWalletWagmiSync, {}), debugModeOptions.debugRoutes && (jsx("pre", { style: {
+    const innerChildren = (jsxs(Fragment, { children: [hasWagmi && (jsx(Suspense, { fallback: null, children: jsx(LazyEmbeddedWalletWagmiSync, {}) })), debugModeOptions.debugRoutes && (jsx("pre", { style: {
                     position: 'absolute',
                     top: 0,
                     left: 0,

package/build/components/Openfort/OpenfortProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"OpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"OpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/CreateWallet/SolanaCreateWallet.js

@@ -1,10 +1,9 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
+import { RecoveryMethod } from '@openfort/openfort-js';
 import { motion } from 'framer-motion';
 import { useState, useEffect, useCallback, useMemo } from 'react';
 import { PhoneIcon, EmailIcon, FingerPrintIcon, KeyIcon, LockIcon } from '../../../assets/icons.js';
 import { OpenfortError } from '../../../types.js';
-import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { useRecoveryOTP } from '../../../shared/hooks/useRecoveryOTP.js';
 import { handleOtpRecoveryError } from '../../../shared/utils/otpError.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
@@ -55,7 +54,6 @@ const OtherMethod = ({ currentMethod, onChangeMethod, }) => {
 };
 const SolanaCreateAutomatic = ({ onBack, logoutOnBack }) => {
     var _a;
-    const { embeddedState } = useOpenfortCore();
     const { setRoute, triggerResize } = useOpenfort();
     const embeddedWallet = useSolanaEmbeddedWallet();
     const { isEnabled: isWalletRecoveryOTPEnabled, requestOTP } = useRecoveryOTP();
@@ -115,11 +113,12 @@ const SolanaCreateAutomatic = ({ onBack, logoutOnBack }) => {
         })();
     }, [shouldCreate]);
     const [canSendOtp, setCanSendOtp] = useState(true);
+    // Trigger creation on mount. We only land here when no Solana wallet exists.
+    // Don't gate on embeddedState — the user may have an EVM wallet (embeddedState=READY)
+    // but still need a Solana wallet.
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreate(true);
-        }
-    }, [embeddedState]);
+        setShouldCreate(true);
+    }, []);
     const handleResendClick = useCallback(() => {
         setOtpStatus('send-otp');
         setCanSendOtp(false);
@@ -145,7 +144,6 @@ const SolanaCreateAutomatic = ({ onBack, logoutOnBack }) => {
 const SolanaCreatePasskey = ({ onChangeMethod, onBack, logoutOnBack, }) => {
     const { triggerResize, setRoute } = useOpenfort();
     const embeddedWallet = useSolanaEmbeddedWallet();
-    const { embeddedState } = useOpenfortCore();
     const [shouldCreate, setShouldCreate] = useState(false);
     const [recoveryError, setRecoveryError] = useState(null);
     useEffect(() => {
@@ -164,11 +162,12 @@ const SolanaCreatePasskey = ({ onChangeMethod, onBack, logoutOnBack, }) => {
             }
         })();
     }, [shouldCreate]);
+    // Trigger creation on mount. We only land here when no Solana wallet exists.
+    // Don't gate on embeddedState — the user may have an EVM wallet (embeddedState=READY)
+    // but still need a Solana wallet.
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreate(true);
-        }
-    }, [embeddedState]);
+        setShouldCreate(true);
+    }, []);
     useEffect(() => {
         if (recoveryError)
             triggerResize();

package/build/components/Pages/CreateWallet/SolanaCreateWallet.js.map

@@ -1 +1 @@
-{"version":3,"file":"SolanaCreateWallet.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"SolanaCreateWallet.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/CreateWallet/index.js

@@ -1,7 +1,7 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
 import { motion } from 'framer-motion';
-import { useEffect, useState, useCallback, useMemo } from 'react';
+import { useEffect, useState, useRef, useCallback, useMemo } from 'react';
 import { PlusIcon, PhoneIcon, EmailIcon, FingerPrintIcon, KeyIcon, ShieldIcon, LockIcon } from '../../../assets/icons.js';
 import Logos from '../../../assets/logos.js';
 import { OpenfortError } from '../../../types.js';
@@ -64,15 +64,17 @@ const OtherMethod = ({ currentMethod, onChangeMethod, }) => {
 const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
     var _a;
     const { embeddedState } = useOpenfortCore();
-    const { setRoute, triggerResize } = useOpenfort();
+    const { setRoute, triggerResize, walletConfig } = useOpenfort();
     const [recoveryError, setRecoveryError] = useState(null);
     const { create } = useEthereumEmbeddedWallet();
     const { isEnabled: isWalletRecoveryOTPEnabled, requestOTP } = useRecoveryOTP();
     const [shouldCreateWallet, setShouldCreateWallet] = useState(false);
+    const isCreatingRef = useRef(false);
     const [needsOTP, setNeedsOTP] = useState(false);
     const [otpResponse, setOtpResponse] = useState(null);
     const [otpStatus, setOtpStatus] = useState('idle');
     const [error, setError] = useState(false);
+    const [canSendOtp, setCanSendOtp] = useState(true);
     const handleCompleteOtp = async (otp) => {
         setOtpStatus('loading');
         try {
@@ -96,13 +98,18 @@ const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
     useEffect(() => {
         if (!shouldCreateWallet)
             return;
+        if (isCreatingRef.current)
+            return;
+        isCreatingRef.current = true;
         (async () => {
             logger.log('Creating wallet Automatic recover');
             try {
                 await create({ recoveryMethod: RecoveryMethod.AUTOMATIC });
+                setShouldCreateWallet(false);
                 setRoute(routes.CONNECTED_SUCCESS);
             }
             catch (err) {
+                setShouldCreateWallet(false);
                 const { error, isOTPRequired } = handleOtpRecoveryError(err, isWalletRecoveryOTPEnabled);
                 if (isOTPRequired && isWalletRecoveryOTPEnabled) {
                     try {
@@ -120,15 +127,19 @@ const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
                     setRecoveryError(error);
                 }
             }
+            finally {
+                isCreatingRef.current = false;
+            }
             triggerResize();
         })();
     }, [shouldCreateWallet, create, isWalletRecoveryOTPEnabled, requestOTP, triggerResize]);
-    const [canSendOtp, setCanSendOtp] = useState(true);
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreateWallet(true);
-        }
-    }, [embeddedState]);
+        if (embeddedState !== EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED)
+            return;
+        if ((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) === false)
+            return;
+        setShouldCreateWallet(true);
+    }, [embeddedState, walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin]);
     const handleResendClick = useCallback(() => {
         setOtpStatus('send-otp');
         setCanSendOtp(false);
@@ -152,18 +163,23 @@ const CreateWalletAutomaticRecovery = ({ onBack, logoutOnBack, }) => {
     return (jsx(PageContent, { onBack: onBack, logoutOnBack: logoutOnBack, children: jsx(Loader, { isError: !!recoveryError, header: recoveryError ? 'Error creating wallet.' : `Creating wallet...`, description: recoveryError ? recoveryError.message : undefined }) }));
 };
 const CreateWalletPasskeyRecovery = ({ onChangeMethod, onBack, logoutOnBack, }) => {
-    const { triggerResize, setRoute } = useOpenfort();
+    const { triggerResize, setRoute, walletConfig } = useOpenfort();
     const { create } = useEthereumEmbeddedWallet();
     const [shouldCreateWallet, setShouldCreateWallet] = useState(false);
+    const isCreatingRef = useRef(false);
     const [recoveryError, setRecoveryError] = useState(null);
     const { embeddedState } = useOpenfortCore();
     useEffect(() => {
         if (!shouldCreateWallet)
             return;
+        if (isCreatingRef.current)
+            return;
+        isCreatingRef.current = true;
         (async () => {
             logger.log('Creating wallet passkey recovery');
             try {
                 await create({ recoveryMethod: RecoveryMethod.PASSKEY });
+                setShouldCreateWallet(false);
                 setRoute(routes.CONNECTED_SUCCESS);
             }
             catch (err) {
@@ -171,13 +187,18 @@ const CreateWalletPasskeyRecovery = ({ onChangeMethod, onBack, logoutOnBack, })
                 setRecoveryError(new Error('Failed to create wallet'));
                 setShouldCreateWallet(false);
             }
+            finally {
+                isCreatingRef.current = false;
+            }
         })();
     }, [shouldCreateWallet, create]);
     useEffect(() => {
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            setShouldCreateWallet(true);
-        }
-    }, [embeddedState]);
+        if (embeddedState !== EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED)
+            return;
+        if ((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) === false)
+            return;
+        setShouldCreateWallet(true);
+    }, [embeddedState, walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin]);
     useEffect(() => {
         if (recoveryError)
             triggerResize();
@@ -269,8 +290,7 @@ const CreateOrConnectWallet = () => {
 };
 const EthereumCreateWallet = () => {
     const { uiConfig, walletConfig, setRoute } = useOpenfort();
-    const { user } = useOpenfortCore();
-    const { chainType } = useOpenfortCore();
+    const { user, chainType } = useOpenfortCore();
     // Use chain-specific hooks
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();

package/build/components/Pages/CreateWallet/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/LoadWallets/index.js

@@ -29,9 +29,8 @@ const errorForChainRegistry = {
     }),
 };
 const LoadWallets = () => {
-    const { chainType } = useOpenfortCore();
-    const { user } = useOpenfortCore();
-    const { triggerResize, setRoute, setConnector } = useOpenfort();
+    const { chainType, user, isLoadingAccounts } = useOpenfortCore();
+    const { triggerResize, setRoute, setConnector, walletConfig } = useOpenfort();
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
     const embeddedWallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
@@ -39,7 +38,10 @@ const LoadWallets = () => {
     const wallets = embeddedWallet.wallets;
     const isLoadingWallets = embeddedWallet.status === 'fetching-wallets' ||
         embeddedWallet.status === 'connecting' ||
-        embeddedWallet.status === 'creating';
+        embeddedWallet.status === 'creating' ||
+        // For Solana, the hook never enters 'fetching-wallets' — accounts are derived from the
+        // core embeddedAccounts store. Wait for the core fetch to complete before routing.
+        isLoadingAccounts;
     const errorWallets = embeddedWallet.status === 'error' ? new Error(embeddedWallet.error) : undefined;
     useEffect(() => {
         let timeout;
@@ -62,6 +64,10 @@ const LoadWallets = () => {
         }
         logger.log('User wallets loaded:', wallets.length);
         if (wallets.length === 0) {
+            if ((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) === false) {
+                setRoute(routes.CONNECTED);
+                return;
+            }
             setRoute(createRoute(chainType));
             return;
         }
@@ -80,7 +86,7 @@ const LoadWallets = () => {
             return;
         }
         setRoute(routes.SELECT_WALLET_TO_RECOVER);
-    }, [loadingUX, isLoadingWallets, wallets, user, chainType, setRoute, setConnector]);
+    }, [loadingUX, isLoadingWallets, wallets, user, chainType, setRoute, setConnector, walletConfig]);
     const { isError: isErrorFromChain, message: errorMessageFromChain } = errorForChainRegistry[chainType](errorWallets);
     const isError = !user || isErrorFromChain;
     const errorMessage = !user ? undefined : errorMessageFromChain;

package/build/components/Pages/LoadWallets/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/constants/openfort.d.ts

@@ -1,5 +1,8 @@
+import { AccountTypeEnum } from '@openfort/openfort-js';
 /**
  * Identifier for the Openfort embedded wallet connector.
  * Used when identifying the embedded wallet in connector lists.
  */
 export declare const embeddedWalletId = "xyz.openfort";
+/** Default account type when none is specified in walletConfig or create options. */
+export declare const DEFAULT_ACCOUNT_TYPE = AccountTypeEnum.EOA;

package/build/constants/openfort.js

@@ -1,8 +1,12 @@
+import { AccountTypeEnum } from '@openfort/openfort-js';
+
 /**
  * Identifier for the Openfort embedded wallet connector.
  * Used when identifying the embedded wallet in connector lists.
  */
 const embeddedWalletId = 'xyz.openfort';
+/** Default account type when none is specified in walletConfig or create options. */
+const DEFAULT_ACCOUNT_TYPE = AccountTypeEnum.EOA;
 
-export { embeddedWalletId };
+export { DEFAULT_ACCOUNT_TYPE, embeddedWalletId };
 //# sourceMappingURL=openfort.js.map

package/build/constants/openfort.js.map

@@ -1 +1 @@
-{"version":3,"file":"openfort.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}
+{"version":3,"file":"openfort.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/build/ethereum/hooks/useEthereumEmbeddedWallet.js

@@ -1,7 +1,8 @@
-import { ChainTypeEnum, AccountTypeEnum, EmbeddedState, RecoveryMethod } from '@openfort/openfort-js';
+import { ChainTypeEnum, EmbeddedState, RecoveryMethod } from '@openfort/openfort-js';
 import { useRef, useState, useMemo, useCallback, useEffect } from 'react';
 import { baseSepolia } from 'viem/chains';
 import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { DEFAULT_ACCOUNT_TYPE } from '../../constants/openfort.js';
 import { useConnectionStrategy } from '../../core/ConnectionStrategyContext.js';
 import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
 import { useOpenfortCore } from '../../openfort/useOpenfort.js';
@@ -131,11 +132,11 @@ function useEthereumEmbeddedWallet(options) {
                 },
             });
             // Determine account type (use createOptions, then walletConfig, else default to Smart Account)
-            const accountType = (_c = (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.accountType) !== null && _a !== void 0 ? _a : (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : AccountTypeEnum.SMART_ACCOUNT;
+            const accountType = (_c = (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.accountType) !== null && _a !== void 0 ? _a : (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : DEFAULT_ACCOUNT_TYPE;
             const account = await client.embeddedWallet.create({
                 chainType: ChainTypeEnum.EVM,
                 accountType,
-                ...(accountType !== AccountTypeEnum.EOA && { chainId: (_d = createOptions === null || createOptions === void 0 ? void 0 : createOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
+                ...(accountType !== DEFAULT_ACCOUNT_TYPE && { chainId: (_d = createOptions === null || createOptions === void 0 ? void 0 : createOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
                 recoveryParams,
             });
             await updateEmbeddedAccounts({ silent: true });

package/build/ethereum/hooks/useEthereumEmbeddedWallet.js.map

@@ -1 +1 @@
-{"version":3,"file":"useEthereumEmbeddedWallet.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useEthereumEmbeddedWallet.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.js

@@ -1,6 +1,7 @@
-import { AccountTypeEnum, ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
+import { ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
 import { useCallback } from 'react';
 import { useOpenfort } from '../../../components/Openfort/useOpenfort.js';
+import { DEFAULT_ACCOUNT_TYPE } from '../../../constants/openfort.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { buildRecoveryParams } from '../../../shared/utils/recovery.js';
 import { logger } from '../../../utils/logger.js';
@@ -54,11 +55,11 @@ const useConnectToWalletPostAuth = () => {
                     getAccessToken: () => client.getAccessToken(),
                     getUserId: async () => { var _a; return (_a = (await client.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
                 });
-                const accountType = (_c = (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : AccountTypeEnum.SMART_ACCOUNT;
+                const accountType = (_c = (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : DEFAULT_ACCOUNT_TYPE;
                 const account = await client.embeddedWallet.create({
                     chainType,
-                    accountType: chainType === ChainTypeEnum.EVM ? accountType : AccountTypeEnum.EOA,
-                    ...(chainType === ChainTypeEnum.EVM && accountType !== AccountTypeEnum.EOA && { chainId }),
+                    accountType: chainType === ChainTypeEnum.EVM ? accountType : DEFAULT_ACCOUNT_TYPE,
+                    ...(chainType === ChainTypeEnum.EVM && accountType !== DEFAULT_ACCOUNT_TYPE && { chainId }),
                     recoveryParams,
                 });
                 await updateEmbeddedAccounts({ silent: true });

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.js.map

@@ -1 +1 @@
-{"version":3,"file":"useConnectToWalletPostAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useConnectToWalletPostAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useUser.d.ts

@@ -6,7 +6,7 @@
  *
  * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
  *
- * @returns user, linkedAccounts, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
+ * @returns user, linkedAccounts, isLoading, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
  *
  * @example
  * ```tsx
@@ -21,6 +21,7 @@
 export declare function useUser(): {
     user: import("@openfort/openfort-js").User | null;
     linkedAccounts: import("@openfort/openfort-js").UserAccount[];
+    isLoading: boolean;
     isAuthenticated: boolean;
     isConnected: boolean;
     getAccessToken: () => Promise<string | null>;

package/build/hooks/openfort/useUser.js

@@ -11,7 +11,7 @@ import { handleOAuthConfigError } from '../../utils/oauthErrorHandler.js';
  *
  * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
  *
- * @returns user, linkedAccounts, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
+ * @returns user, linkedAccounts, isLoading, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
  *
  * @example
  * ```tsx
@@ -24,7 +24,7 @@ import { handleOAuthConfigError } from '../../utils/oauthErrorHandler.js';
  * ```
  */
 function useUser() {
-    const { user, client, embeddedState, linkedAccounts, activeEmbeddedAddress } = useOpenfortCore();
+    const { user, client, embeddedState, linkedAccounts, activeEmbeddedAddress, isLoading } = useOpenfortCore();
     const isAuthenticated = embeddedState !== EmbeddedState.NONE && embeddedState !== EmbeddedState.UNAUTHENTICATED;
     const isConnected = embeddedState === EmbeddedState.READY && !!activeEmbeddedAddress;
     const getAccessTokenAndUpdate = useCallback(async () => {
@@ -50,6 +50,7 @@ function useUser() {
     return {
         user,
         linkedAccounts,
+        isLoading,
         isAuthenticated,
         isConnected,
         getAccessToken: getAccessTokenAndUpdate,

package/build/hooks/openfort/useUser.js.map

@@ -1 +1 @@
-{"version":3,"file":"useUser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useUser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/openfort/CoreOpenfortProvider.js

@@ -1,5 +1,5 @@
 import { ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
-import { useContext, useMemo, useState, useEffect, useRef, useCallback, useLayoutEffect, createElement, Fragment } from 'react';
+import { useContext, useMemo, useState, useEffect, useRef, useLayoutEffect, useCallback, createElement, Fragment } from 'react';
 import { useStore } from 'zustand';
 import { routes } from '../components/Openfort/types.js';
 import { useOpenfort } from '../components/Openfort/useOpenfort.js';
@@ -99,8 +99,10 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
             });
         });
     }, []);
-    // Sync chainType from UI context into the store
-    useEffect(() => {
+    // Sync chainType from UI context into the store — useLayoutEffect so the store
+    // is updated before the next paint, preventing a one-render-cycle race where
+    // the strategy context (synchronous) sees SVM but the store still shows EVM.
+    useLayoutEffect(() => {
         store.getState().setChainType(chainType);
     }, [store, chainType]);
     // Recompute isLoading when bridge address changes (bridge connects/disconnects)

package/build/openfort/CoreOpenfortProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"CoreOpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"CoreOpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.0.1";
+export declare const OPENFORT_VERSION = "1.0.3";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.0.1';
+const OPENFORT_VERSION = '1.0.3';
 
 export { OPENFORT_VERSION };
 //# sourceMappingURL=version.js.map

package/build/wagmi/embeddedConnector.js

@@ -9,7 +9,12 @@ function setEmbeddedWalletProvider(p) {
 function embeddedWalletConnector() {
     return createConnector((config) => {
         const accountsChangedHandler = (accs) => {
-            config.emitter.emit('change', { accounts: accs });
+            // Filter out non-EVM addresses (e.g. Solana base58) that the SDK may emit
+            // when recover() is called for a Solana wallet — sdk bug, defensive guard.
+            const valid = accs.filter((a) => /^0x[0-9a-fA-F]{40}$/i.test(a));
+            if (valid.length === 0)
+                return;
+            config.emitter.emit('change', { accounts: valid });
         };
         const chainChangedHandler = (chain) => {
             config.emitter.emit('change', { chainId: Number(chain) });

package/build/wagmi/embeddedConnector.js.map

@@ -1 +1 @@
-{"version":3,"file":"embeddedConnector.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"embeddedConnector.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",