@openfort/react 1.0.7 → 1.0.9

package/build/assets/icons.js

@@ -1,4 +1,4 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
+import { jsx, jsxs } from 'react/jsx-runtime';
 
 const SendIcon = ({ ...props }) => (jsxs("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props, children: [jsx("path", { d: "M5 19L19 5", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M9 5H19V15", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));
 const ReceiveIcon = ({ ...props }) => (jsxs("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props, children: [jsx("path", { d: "M19 5L5 19", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M15 19H5V9", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));

package/build/components/Common/ConnectorList/index.js

@@ -14,7 +14,6 @@ import { ConnectorsContainer, ConnectorButton, ConnectorIcon, ConnectorLabel, Re
 
 const ConnectorList = () => {
     const context = useOpenfort();
-    const isMobile = useIsMobile();
     const wallets = useExternalConnectors();
     const { lastConnectorId } = useLastConnector();
     const familyConnector = useFamilyConnector();
@@ -31,7 +30,7 @@ const ConnectorList = () => {
             ...wallets.filter((wallet) => lastConnectorId === wallet.connector.id && wallet.id !== embeddedWalletId),
             ...wallets.filter((wallet) => lastConnectorId !== wallet.connector.id && wallet.id !== embeddedWalletId),
         ];
-    return (jsxs(ScrollArea, { mobileDirection: 'horizontal', children: [filteredWallets.length === 0 && jsx(Alert, { error: true, children: "No connectors found in Openfort config." }), filteredWallets.length > 0 && (jsx(ConnectorsContainer, { "$mobile": isMobile, "$totalResults": walletsToDisplay.length, children: filteredWallets.map((wallet) => (jsx(ConnectorItem, { wallet: wallet, isRecent: wallet.id === lastConnectorId }, wallet.id))) }))] }));
+    return (jsxs(ScrollArea, { mobileDirection: 'horizontal', children: [filteredWallets.length === 0 && jsx(Alert, { error: true, children: "No connectors found in Openfort config." }), filteredWallets.length > 0 && (jsx(ConnectorsContainer, { "$mobile": false, "$totalResults": walletsToDisplay.length, children: filteredWallets.map((wallet) => (jsx(ConnectorItem, { wallet: wallet, isRecent: wallet.id === lastConnectorId }, wallet.id))) }))] }));
 };
 const ConnectorItem = ({ wallet, isRecent }) => {
     var _a;
@@ -44,9 +43,9 @@ const ConnectorItem = ({ wallet, isRecent }) => {
         return (jsxs(Fragment, { children: [jsx(ConnectorIcon, { "data-small": wallet.iconShouldShrink, "data-shape": wallet.iconShape, children: (_a = wallet.iconConnector) !== null && _a !== void 0 ? _a : wallet.icon }), jsxs(ConnectorLabel, { children: [isMobile ? ((_b = wallet.shortName) !== null && _b !== void 0 ? _b : wallet.name) : wallet.name, !context.uiConfig.hideRecentBadge && isRecent && (jsx(RecentlyUsedTag, { children: jsx("span", { children: "Recent" }) }))] })] }));
     };
     return (jsx(ConnectorButton, { type: "button", onClick: async () => {
-            // Disconnect if the same connector is selected, otherwise wagmi won't trigger the connection flow
-            // Disconnect for wallet connect to work
-            if (bridge && (wallet.id === 'walletConnect' || wallet.id === (connector === null || connector === void 0 ? void 0 : connector.id))) {
+            var _a;
+            // Only disconnect if actually connected and switching connectors or reconnecting WC
+            if (((_a = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _a === void 0 ? void 0 : _a.isConnected) && (wallet.id === 'walletConnect' || wallet.id === (connector === null || connector === void 0 ? void 0 : connector.id))) {
                 await bridge.disconnect();
             }
             context.setRoute({ route: routes.CONNECT, connectType: 'linkIfUserConnectIfNoUser' });

package/build/components/Common/ConnectorList/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/ConnectModal/ConnectWithQRCode.js

@@ -1,5 +1,5 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { useEffect, useState, useCallback } from 'react';
+import { useEffect, useState, useCallback, useRef } from 'react';
 import { useEthereumBridge } from '../../ethereum/OpenfortEthereumBridgeContext.js';
 import { useWalletConnectModal } from '../../hooks/useWalletConnectModal.js';
 import 'detect-browser';
@@ -46,6 +46,7 @@ const ConnectWithWalletConnect = () => {
     const wallet = useExternalConnector(connector.id);
     const { open: openWalletConnectModal } = useWalletConnectModal();
     const [error, setError] = useState(undefined);
+    const hasOpenedRef = useRef(false);
     const openModal = useCallback(async () => {
         setError(undefined);
         const { error } = await openWalletConnectModal();
@@ -53,6 +54,9 @@ const ConnectWithWalletConnect = () => {
             setError(error);
     }, [openWalletConnectModal]);
     useEffect(() => {
+        if (hasOpenedRef.current)
+            return;
+        hasOpenedRef.current = true;
         openModal();
     }, [openModal]);
     return (jsx(PageContent, { children: jsx(Loader, { header: error ? 'Error connecting wallet.' : `Connecting...`, icon: wallet === null || wallet === void 0 ? void 0 : wallet.icon, isError: !!error, description: error, onRetry: openModal }) }));

package/build/components/ConnectModal/ConnectWithQRCode.js.map

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

package/build/components/ConnectModal/index.js

@@ -1,10 +1,9 @@
 import { jsx } from 'react/jsx-runtime';
 import { ChainTypeEnum, OAuthProvider } from '@openfort/openfort-js';
-import { useMemo, useRef, useEffect } from 'react';
+import { lazy, Suspense, useMemo, useRef, useEffect } from 'react';
 import { useConnectionStrategy } from '../../core/ConnectionStrategyContext.js';
 import { useOpenfortCore } from '../../openfort/useOpenfort.js';
 import { logger } from '../../utils/logger.js';
-import SwitchNetworks from '../../wagmi/components/SwitchNetworks/index.js';
 import Modal from '../Common/Modal/index.js';
 import { ConnectKitThemeProvider } from '../ConnectKitThemeProvider/ConnectKitThemeProvider.js';
 import { routes } from '../Openfort/types.js';
@@ -49,6 +48,7 @@ import SocialProviders from '../Pages/SocialProviders/index.js';
 import ConnectUsing from './ConnectUsing.js';
 import ConnectWithMobile from './ConnectWithMobile.js';
 
+const LazySwitchNetworks = lazy(() => import('../../wagmi/components/SwitchNetworks/index.js'));
 function buildSharedPages() {
     return {
         onboarding: jsx(Introduction, {}),
@@ -99,7 +99,7 @@ const CHAIN_PREFIXED_PAGES = {
         'eth:connected': jsx(Connected, {}),
         'eth:createWallet': jsx(CreateWallet, {}),
         'eth:recoverWallet': jsx(RecoverPage, {}),
-        'eth:switchNetworks': jsx(SwitchNetworks, {}),
+        'eth:switchNetworks': (jsx(Suspense, { fallback: null, children: jsx(LazySwitchNetworks, {}) })),
         'eth:send': jsx(Send, {}),
         'eth:receive': jsx(Receive, {}),
         'eth:buy': jsx(Buy, {}),

package/build/components/Openfort/OpenfortProvider.js

@@ -32,9 +32,10 @@ let openfortProviderWarnedNoWagmi = false;
  * ```
  */
 const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const bridge = useContext(OpenfortEthereumBridgeContext);
     const hasWagmi = !!bridge;
+    const hasExternalWallets = (_b = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) === null || _a === void 0 ? void 0 : _a.some((c) => c.id === 'walletConnect')) !== null && _b !== void 0 ? _b : false;
     const hasSolana = !!(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana);
     // Only allow for mounting OpenfortProvider once, so we avoid weird global
     // state collisions.
@@ -61,7 +62,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
         logger.enabled = result.openfortReactDebugMode;
         return result;
     }, [debugMode]);
-    const injectedConnector = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) === null || _a === void 0 ? void 0 : _a.find((c) => c.id === 'injected');
+    const injectedConnector = (_c = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) === null || _c === void 0 ? void 0 : _c.find((c) => c.id === 'injected');
     const allowAutomaticRecovery = !!((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.createEncryptedSessionEndpoint) || (walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.getEncryptionSession));
     const defaultUIOptions = useMemo(() => ({
         appName: 'Openfort',
@@ -93,19 +94,19 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
             allowedMethods: [RecoveryMethod.PASSWORD, ...(allowAutomaticRecovery ? [RecoveryMethod.AUTOMATIC] : [])],
             defaultMethod: allowAutomaticRecovery ? RecoveryMethod.AUTOMATIC : RecoveryMethod.PASSWORD,
         },
-        authProviders: hasWagmi
+        authProviders: hasExternalWallets
             ? [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.WALLET, UIAuthProvider.GOOGLE]
             : [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.GOOGLE],
-    }), [allowAutomaticRecovery, hasWagmi]);
+    }), [allowAutomaticRecovery, hasExternalWallets]);
     const safeUiConfig = useMemo(() => {
         var _a, _b, _c, _d, _e;
         const merged = { ...defaultUIOptions, ...uiConfig };
         let authProviders = (_a = merged.authProviders) !== null && _a !== void 0 ? _a : defaultUIOptions.authProviders;
-        if (!hasWagmi && authProviders.includes(UIAuthProvider.WALLET)) {
+        if (!hasExternalWallets && authProviders.includes(UIAuthProvider.WALLET)) {
             authProviders = authProviders.filter((p) => p !== UIAuthProvider.WALLET);
             if (process.env.NODE_ENV === 'development' && !openfortProviderWarnedNoWagmi) {
                 openfortProviderWarnedNoWagmi = true;
-                logger.warn('[@openfort/react] UIAuthProvider.WALLET was removed from authProviders because no Wagmi bridge is present. Add OpenfortWagmiBridge to enable external wallet sign-in.');
+                logger.warn('[@openfort/react] UIAuthProvider.WALLET was removed from authProviders because no WalletConnect connector is present. Pass walletConnectProjectId to getDefaultConfig/getDefaultConnectors to enable external wallet sign-in.');
             }
         }
         const walletRecovery = {
@@ -117,15 +118,15 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
             logger.warn('Automatic recovery method was removed from allowedMethods because no recovery options are configured in the walletConfig. Please provide either createEncryptedSessionEndpoint or getEncryptionSession to enable automatic recovery.');
         }
         return { ...merged, authProviders, walletRecovery };
-    }, [defaultUIOptions, uiConfig, hasWagmi, allowAutomaticRecovery]);
+    }, [defaultUIOptions, uiConfig, hasExternalWallets, allowAutomaticRecovery]);
     useEffect(() => {
         if (typeof window !== 'undefined' && safeUiConfig.bufferPolyfill && !window.Buffer) {
             window.Buffer = Buffer;
         }
     }, [safeUiConfig.bufferPolyfill]);
-    const [ckTheme, setTheme] = useState((_b = safeUiConfig.theme) !== null && _b !== void 0 ? _b : 'auto');
-    const [ckMode, setMode] = useState((_c = safeUiConfig.mode) !== null && _c !== void 0 ? _c : 'auto');
-    const [ckCustomTheme, setCustomTheme] = useState((_d = safeUiConfig.customTheme) !== null && _d !== void 0 ? _d : {});
+    const [ckTheme, setTheme] = useState((_d = safeUiConfig.theme) !== null && _d !== void 0 ? _d : 'auto');
+    const [ckMode, setMode] = useState((_e = safeUiConfig.mode) !== null && _e !== void 0 ? _e : 'auto');
+    const [ckCustomTheme, setCustomTheme] = useState((_f = safeUiConfig.customTheme) !== null && _f !== void 0 ? _f : {});
     const [ckLang, setLang] = useState('en-US');
     const [open, setOpenWithoutHistory] = useState(false);
     const initialConnector = { id: '' };
@@ -138,7 +139,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
     const [sendForm, setSendForm] = useState(defaultSendFormState);
     const [buyForm, setBuyForm] = useState(defaultBuyFormState);
     const [headerLeftSlot, setHeaderLeftSlot] = useState(null);
-    const [chainType, setChainType] = useState((_e = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.chainType) !== null && _e !== void 0 ? _e : ChainTypeEnum.EVM);
+    const [chainType, setChainType] = useState((_g = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.chainType) !== null && _g !== void 0 ? _g : ChainTypeEnum.EVM);
     const setOpen = useCallback((value) => {
         if (value) {
             setRouteHistory([]);
@@ -170,10 +171,10 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
             return chainIds.map((id) => buildChainFromConfig(id, rpcUrls));
         }
         return [];
-    }, [(_f = bridge === null || bridge === void 0 ? void 0 : bridge.switchChain) === null || _f === void 0 ? void 0 : _f.chains, (_g = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _g === void 0 ? void 0 : _g.rpcUrls, (_h = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _h === void 0 ? void 0 : _h.chainId]);
+    }, [(_h = bridge === null || bridge === void 0 ? void 0 : bridge.switchChain) === null || _h === void 0 ? void 0 : _h.chains, (_j = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _j === void 0 ? void 0 : _j.rpcUrls, (_k = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _k === void 0 ? void 0 : _k.chainId]);
     const chain = bridge === null || bridge === void 0 ? void 0 : bridge.account.chain;
-    const isConnected = (_j = bridge === null || bridge === void 0 ? void 0 : bridge.account.isConnected) !== null && _j !== void 0 ? _j : false;
-    const isChainSupported = !(chain === null || chain === void 0 ? void 0 : chain.id) || ((_l = (_k = bridge === null || bridge === void 0 ? void 0 : bridge.config.chains) === null || _k === void 0 ? void 0 : _k.some((c) => c.id === chain.id)) !== null && _l !== void 0 ? _l : false);
+    const isConnected = (_l = bridge === null || bridge === void 0 ? void 0 : bridge.account.isConnected) !== null && _l !== void 0 ? _l : false;
+    const isChainSupported = !(chain === null || chain === void 0 ? void 0 : chain.id) || ((_o = (_m = bridge === null || bridge === void 0 ? void 0 : bridge.config.chains) === null || _m === void 0 ? void 0 : _m.some((c) => c.id === chain.id)) !== null && _o !== void 0 ? _o : false);
     useEffect(() => {
         if (hasWagmi && isConnected && safeUiConfig.enforceSupportedChains && !isChainSupported) {
             setOpen(true);
@@ -335,7 +336,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
                 }, children: JSON.stringify(routeHistory.map((item) => Object.fromEntries(Object.entries(item).map(([key, value]) => [
                     key,
                     typeof value === 'object' && value !== null ? '[object]' : value,
-                ]))), null, 2) })), children, jsx(Suspense, { fallback: null, children: jsx(LazyConnectKitModal, { lang: ckLang, theme: ckTheme, mode: (_m = safeUiConfig.mode) !== null && _m !== void 0 ? _m : ckMode, customTheme: ckCustomTheme }) })] }));
+                ]))), null, 2) })), children, jsx(Suspense, { fallback: null, children: jsx(LazyConnectKitModal, { lang: ckLang, theme: ckTheme, mode: (_p = safeUiConfig.mode) !== null && _p !== void 0 ? _p : ckMode, customTheme: ckCustomTheme }) })] }));
     return (jsx(UIContext.Provider, { value: connectUIValue, children: jsx(OpenfortContext.Provider, { value: value, children: jsx(CoreOpenfortProvider, { openfortConfig: {
                     baseConfiguration: { publishableKey },
                     shieldConfiguration: walletConfig

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/Connected/EthereumConnected.js

@@ -1,20 +1,21 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { ChainTypeEnum } from '@openfort/openfort-js';
 import { AnimatePresence, motion } from 'framer-motion';
-import { useEffect, useMemo, useState } from 'react';
+import { lazy, useEffect, useMemo, useState, Suspense } from 'react';
 import { formatUnits } from 'viem';
 import { UserRoundIcon, SendIcon, ReceiveIcon, BuyIcon } from '../../../assets/icons.js';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
 import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
+import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
 import useLocales from '../../../hooks/useLocales.js';
 import { useResolvedIdentity } from '../../../hooks/useResolvedIdentity.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { nFormatter } from '../../../utils/index.js';
 import { logger } from '../../../utils/logger.js';
-import ChainSelector from '../../../wagmi/components/ChainSelect/index.js';
 import Avatar from '../../Common/Avatar/index.js';
 import Button from '../../Common/Button/index.js';
 import { TextLinkButton } from '../../Common/Button/styles.js';
+import Chain from '../../Common/Chain/index.js';
 import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
 import { ModalBody } from '../../Common/Modal/styles.js';
 import { useThemeContext } from '../../ConnectKitThemeProvider/ConnectKitThemeProvider.js';
@@ -26,6 +27,7 @@ import { ConnectedPageLayout } from './ConnectedPageLayout.js';
 import { LinkedProvidersToggle, Balance, Unsupported, ChainSelectorContainer, ActionButton } from './styles.js';
 import { truncateEthAddress } from '../../../utils/format.js';
 
+const LazyChainSelector = lazy(() => import('../../../wagmi/components/ChainSelect/index.js'));
 function getFirstBalanceAsset(assets) {
     return assets === null || assets === void 0 ? void 0 : assets.find((a) => a.balance && a.balance > BigInt(0));
 }
@@ -34,6 +36,7 @@ const EthereumConnected = () => {
     const context = useOpenfort();
     const { setHeaderLeftSlot, setRoute, chains } = context;
     const themeContext = useThemeContext();
+    const bridge = useEthereumBridge();
     const wallet = useEthereumEmbeddedWallet();
     const { embeddedAccounts } = useOpenfortCore();
     const hasEthereumWallets = ((_a = embeddedAccounts === null || embeddedAccounts === void 0 ? void 0 : embeddedAccounts.filter((a) => a.chainType === ChainTypeEnum.EVM)) !== null && _a !== void 0 ? _a : []).length > 0;
@@ -117,8 +120,8 @@ const EthereumConnected = () => {
             }
             setRoute(routes.ASSET_INVENTORY);
         }, children: jsxs(Balance, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, transition: { duration: 0.2 }, children: ["$", nFormatter(totalBalanceUsd)] }, `chain-${chain === null || chain === void 0 ? void 0 : chain.id}`) })) : null;
-    const noWalletFallback = hasEthereumWallets ? (jsx(Button, { onClick: () => context.setRoute(routes.LOAD_WALLETS), children: "Manage wallets" })) : (jsx(Button, { onClick: () => context.setRoute({ route: routes.CONNECTORS, connectType: 'link' }), icon: jsx(Unsupported, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, children: jsxs("svg", { width: "130", height: "120", viewBox: "0 0 13 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("title", { children: "Unsupported wallet icon" }), jsx("path", { d: "M2.61317 11.2501H9.46246C10.6009 11.2501 11.3256 10.3506 11.3256 9.3549C11.3256 9.05145 11.255 8.73244 11.0881 8.43303L7.65903 2.14708C7.659 2.14702 7.65897 2.14696 7.65893 2.1469C7.65889 2.14682 7.65884 2.14673 7.65879 2.14664C7.31045 1.50746 6.6741 1.17871 6.04 1.17871C5.41478 1.17871 4.763 1.50043 4.41518 2.14968L0.993416 8.43476C0.828865 8.72426 0.75 9.04297 0.75 9.3549C0.75 10.3506 1.47471 11.2501 2.61317 11.2501Z", fill: "currentColor", stroke: "var(--ck-body-background, #fff)", strokeWidth: "1.5" }), jsx("path", { d: "M6.03258 7.43916C5.77502 7.43916 5.63096 7.29153 5.62223 7.02311L5.55675 4.96973C5.54802 4.69684 5.74446 4.5 6.02821 4.5C6.3076 4.5 6.51277 4.70131 6.50404 4.9742L6.43856 7.01864C6.42546 7.29153 6.2814 7.43916 6.03258 7.43916ZM6.03258 9.11676C5.7401 9.11676 5.5 8.9065 5.5 8.60677C5.5 8.30704 5.7401 8.09678 6.03258 8.09678C6.32506 8.09678 6.56515 8.30256 6.56515 8.60677C6.56515 8.91097 6.32069 9.11676 6.03258 9.11676Z", fill: "white" })] }) }), children: "Connect wallet" }));
-    return (jsx(PageContent, { onBack: null, header: locales.profileScreen_heading, children: jsx(ConnectedPageLayout, { address: address !== null && address !== void 0 ? address : '', displayName: jsx(CopyText, { value: address !== null && address !== void 0 ? address : '', children: ensName !== null && ensName !== void 0 ? ensName : truncateEthAddress(address !== null && address !== void 0 ? address : '', separator) }), avatar: address ? jsx(Avatar, { address: address }) : jsx("span", {}), beforeAvatar: jsx(ChainSelectorContainer, { initial: { opacity: 0 }, animate: { opacity: 1 }, transition: { duration: 0.2 }, children: jsx(ChainSelector, {}) }, chainId !== null && chainId !== void 0 ? chainId : 'loading'), balance: balanceNode, actions: jsxs(Fragment, { children: [jsx(ActionButton, { icon: jsx(SendIcon, {}), onClick: () => {
+    const noWalletFallback = hasEthereumWallets ? (jsx(Button, { onClick: () => context.setRoute(routes.SELECT_WALLET_TO_RECOVER), children: "Manage wallets" })) : (jsx(Button, { onClick: () => context.setRoute({ route: routes.CONNECTORS, connectType: 'link' }), icon: jsx(Unsupported, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, children: jsxs("svg", { width: "130", height: "120", viewBox: "0 0 13 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [jsx("title", { children: "Unsupported wallet icon" }), jsx("path", { d: "M2.61317 11.2501H9.46246C10.6009 11.2501 11.3256 10.3506 11.3256 9.3549C11.3256 9.05145 11.255 8.73244 11.0881 8.43303L7.65903 2.14708C7.659 2.14702 7.65897 2.14696 7.65893 2.1469C7.65889 2.14682 7.65884 2.14673 7.65879 2.14664C7.31045 1.50746 6.6741 1.17871 6.04 1.17871C5.41478 1.17871 4.763 1.50043 4.41518 2.14968L0.993416 8.43476C0.828865 8.72426 0.75 9.04297 0.75 9.3549C0.75 10.3506 1.47471 11.2501 2.61317 11.2501Z", fill: "currentColor", stroke: "var(--ck-body-background, #fff)", strokeWidth: "1.5" }), jsx("path", { d: "M6.03258 7.43916C5.77502 7.43916 5.63096 7.29153 5.62223 7.02311L5.55675 4.96973C5.54802 4.69684 5.74446 4.5 6.02821 4.5C6.3076 4.5 6.51277 4.70131 6.50404 4.9742L6.43856 7.01864C6.42546 7.29153 6.2814 7.43916 6.03258 7.43916ZM6.03258 9.11676C5.7401 9.11676 5.5 8.9065 5.5 8.60677C5.5 8.30704 5.7401 8.09678 6.03258 8.09678C6.32506 8.09678 6.56515 8.30256 6.56515 8.60677C6.56515 8.91097 6.32069 9.11676 6.03258 9.11676Z", fill: "white" })] }) }), children: "Connect wallet" }));
+    return (jsx(PageContent, { onBack: null, header: locales.profileScreen_heading, children: jsx(ConnectedPageLayout, { address: address !== null && address !== void 0 ? address : '', displayName: jsx(CopyText, { value: address !== null && address !== void 0 ? address : '', children: ensName !== null && ensName !== void 0 ? ensName : truncateEthAddress(address !== null && address !== void 0 ? address : '', separator) }), avatar: address ? jsx(Avatar, { address: address }) : jsx("span", {}), beforeAvatar: jsx(ChainSelectorContainer, { initial: { opacity: 0 }, animate: { opacity: 1 }, transition: { duration: 0.2 }, children: bridge ? (jsx(Suspense, { fallback: jsx(Chain, { id: chainId }), children: jsx(LazyChainSelector, {}) })) : (jsx(Chain, { id: chainId })) }, chainId !== null && chainId !== void 0 ? chainId : 'loading'), balance: balanceNode, actions: jsxs(Fragment, { children: [jsx(ActionButton, { icon: jsx(SendIcon, {}), onClick: () => {
                             const firstBalanceAsset = getFirstBalanceAsset(assets);
                             if (!firstBalanceAsset) {
                                 setRoute(routes.NO_ASSETS_AVAILABLE);

package/build/components/Pages/Connected/EthereumConnected.js.map

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

package/build/components/Pages/Connected/SolanaConnected.js

@@ -89,7 +89,7 @@ const SolanaConnected = () => {
         : undefined;
     const avatar = address ? CustomAvatar ? jsx(CustomAvatar, { address: address }) : jsx(Avatar, { address: address }) : jsx("span", {});
     const balanceNode = balanceSol != null && !isBalanceLoading ? (jsxs(Balance, { initial: { opacity: 0 }, animate: { opacity: 1 }, exit: { opacity: 0 }, transition: { duration: 0.2 }, children: [nFormatter(Number(balanceSol)), " SOL"] }, "solana-balance")) : null;
-    return (jsx(PageContent, { onBack: null, header: locales.profileScreen_heading, children: jsx(ConnectedPageLayout, { address: address !== null && address !== void 0 ? address : '', displayName: jsx(CopyText, { value: address !== null && address !== void 0 ? address : '', children: truncateSolanaAddress(address !== null && address !== void 0 ? address : '', separator) }), avatar: avatar, balance: balanceNode, actions: jsx(ActionButton, { icon: jsx(ReceiveIcon, {}), onClick: () => context.setRoute(routes.SOL_RECEIVE), children: "Get" }), hideBalance: context === null || context === void 0 ? void 0 : context.uiConfig.hideBalance, isBalanceLoading: isBalanceLoading, isAddressLoading: isAddressLoading, noWalletFallback: hasSolanaWallets ? (jsx(Button, { onClick: () => setRoute(routes.SOL_WALLETS), children: "Manage wallets" })) : (jsx(Button, { onClick: () => setRoute(routes.SOL_CREATE_WALLET), children: "Create Solana Wallet" })) }) }));
+    return (jsx(PageContent, { onBack: null, header: locales.profileScreen_heading, children: jsx(ConnectedPageLayout, { address: address !== null && address !== void 0 ? address : '', displayName: jsx(CopyText, { value: address !== null && address !== void 0 ? address : '', children: truncateSolanaAddress(address !== null && address !== void 0 ? address : '', separator) }), avatar: avatar, balance: balanceNode, actions: jsx(ActionButton, { icon: jsx(ReceiveIcon, {}), onClick: () => context.setRoute(routes.SOL_RECEIVE), children: "Get" }), hideBalance: context === null || context === void 0 ? void 0 : context.uiConfig.hideBalance, isBalanceLoading: isBalanceLoading, isAddressLoading: isAddressLoading, noWalletFallback: hasSolanaWallets ? (jsx(Button, { onClick: () => setRoute(routes.SELECT_WALLET_TO_RECOVER), children: "Manage wallets" })) : (jsx(Button, { onClick: () => setRoute(routes.SOL_CREATE_WALLET), children: "Create Solana Wallet" })) }) }));
 };
 
 export { SolanaConnected as default };

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

@@ -88,14 +88,20 @@ function WalletRow({ chainType, wallet, }) {
     const tag = wallet.recoveryMethod != null ? RECOVERY_METHOD_LABEL[wallet.recoveryMethod] : undefined;
     return (jsx(ProvidersButton, { children: jsxs(Button, { onClick: handleClick, children: [jsxs(ProviderLabel, { children: [display, tag && jsx(RecoveryTag, { children: tag })] }), jsx(ProviderIcon, { children: walletIcon() })] }) }));
 }
+/** Connected-page routes that indicate the user navigated here from "Manage wallets" */
+const CONNECTED_ROUTES = new Set([routes.CONNECTED, routes.ETH_CONNECTED, routes.SOL_CONNECTED]);
 function SelectWalletToRecover() {
     const { chainType } = useOpenfortCore();
+    const { previousRoute } = useOpenfort();
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
     const embeddedWallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
     const wallets = embeddedWallet.wallets;
     const list = wallets.map((wallet) => jsx(WalletRow, { chainType: chainType, wallet: wallet }, wallet.id));
-    return (jsxs(PageContent, { onBack: routes.PROVIDERS, logoutOnBack: true, children: [jsx(ModalHeading, { children: "Select a wallet to recover" }), jsx(WalletListScroll, { children: list })] }));
+    // When arriving from a connected page (Manage wallets), go back there without logging out.
+    // When arriving from the login flow, go back to providers and log out.
+    const fromConnected = previousRoute != null && CONNECTED_ROUTES.has(previousRoute.route);
+    return (jsxs(PageContent, { onBack: fromConnected ? 'back' : routes.PROVIDERS, logoutOnBack: !fromConnected, children: [jsx(ModalHeading, { children: "Select a wallet" }), jsx(WalletListScroll, { children: list })] }));
 }
 
 export { SelectWalletToRecover as default };

package/build/components/Pages/SelectWalletToRecover/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/ethereum/hooks/useEthereumEmbeddedWallet.js

@@ -139,6 +139,11 @@ function useEthereumEmbeddedWallet(options) {
                 ...(accountType !== DEFAULT_ACCOUNT_TYPE && { chainId: (_d = createOptions === null || createOptions === void 0 ? void 0 : createOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
                 recoveryParams,
             });
+            // Set the address before fetching accounts or setting connected state.
+            // This prevents a race where the sync effect sees status='connected' but
+            // no activeEmbeddedAddress and disconnects (especially for the first wallet
+            // when embeddedAccounts is still empty).
+            setActiveEmbeddedAddress(account.address);
             await updateEmbeddedAccounts({ silent: true });
             const provider = await getEmbeddedEthereumProvider();
             const connectedWallet = buildConnectedWallet(account, 0, async () => provider, {
@@ -151,7 +156,6 @@ function useEthereumEmbeddedWallet(options) {
                 provider,
                 error: null,
             });
-            setActiveEmbeddedAddress(account.address);
             (_e = createOptions === null || createOptions === void 0 ? void 0 : createOptions.onSuccess) === null || _e === void 0 ? void 0 : _e.call(createOptions, { account });
             return account;
         }

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/useWalletConnectModal.d.ts

@@ -1,8 +1,8 @@
 export declare function useWalletConnectModal(): {
     isOpen: boolean;
     open: () => Promise<{
-        error: string;
-    } | {
         error?: undefined;
+    } | {
+        error: string;
     }>;
 };

package/build/hooks/useWalletConnectModal.js

@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useState, useRef, useCallback } from 'react';
 import { useEthereumBridge } from '../ethereum/OpenfortEthereumBridgeContext.js';
 import { isWalletConnectConnector } from '../utils/index.js';
 import { logger } from '../utils/logger.js';
@@ -6,53 +6,58 @@ import { logger } from '../utils/logger.js';
 function useWalletConnectModal() {
     const bridge = useEthereumBridge();
     const [isOpen, setIsOpen] = useState(false);
-    return {
-        isOpen,
-        open: async () => {
-            var _a;
-            const w3mcss = document.createElement('style');
-            w3mcss.textContent = `w3m-modal, wcm-modal{ --wcm-z-index: 2147483647; --w3m-z-index:2147483647; }`;
-            document.head.appendChild(w3mcss);
-            const removeChild = () => {
-                if (document.head.contains(w3mcss)) {
-                    document.head.removeChild(w3mcss);
-                }
-            };
-            const connectors = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) !== null && _a !== void 0 ? _a : [];
-            const clientConnector = connectors.find((c) => isWalletConnectConnector(c.id));
-            if (clientConnector && (bridge === null || bridge === void 0 ? void 0 : bridge.connectAsync)) {
-                try {
-                    setIsOpen(true);
-                    try {
-                        await bridge.connectAsync({ connector: clientConnector });
-                    }
-                    catch (err) {
-                        logger.log('WalletConnect', err);
-                        return {
-                            error: 'Connection failed',
-                        };
-                    }
-                    setIsOpen(false);
-                    removeChild();
-                    return {};
-                }
-                catch (err) {
-                    logger.log('Could not get WalletConnect provider', err);
-                    removeChild();
-                    return {
-                        error: 'Could not get WalletConnect provider',
-                    };
-                }
+    const bridgeRef = useRef(bridge);
+    bridgeRef.current = bridge;
+    const connectingRef = useRef(false);
+    const open = useCallback(async () => {
+        var _a;
+        if (connectingRef.current)
+            return {};
+        connectingRef.current = true;
+        const currentBridge = bridgeRef.current;
+        const w3mcss = document.createElement('style');
+        w3mcss.textContent = `w3m-modal, wcm-modal{ --wcm-z-index: 2147483647; --w3m-z-index:2147483647; }`;
+        document.head.appendChild(w3mcss);
+        const removeChild = () => {
+            if (document.head.contains(w3mcss)) {
+                document.head.removeChild(w3mcss);
             }
-            else {
+        };
+        const connectors = (_a = currentBridge === null || currentBridge === void 0 ? void 0 : currentBridge.connectors) !== null && _a !== void 0 ? _a : [];
+        const clientConnector = connectors.find((c) => isWalletConnectConnector(c.id));
+        if (clientConnector && (currentBridge === null || currentBridge === void 0 ? void 0 : currentBridge.connectAsync)) {
+            try {
+                currentBridge.reset();
+                setIsOpen(true);
+                await currentBridge.connectAsync({ connector: clientConnector });
+                setIsOpen(false);
                 removeChild();
-                logger.log('Configuration error: Please provide a WalletConnect Project ID in your wagmi config.');
-                return {
-                    error: 'Configuration error: Please provide a WalletConnect Project ID in your wagmi config.',
-                };
+                connectingRef.current = false;
+                return {};
             }
-        },
-    };
+            catch (err) {
+                setIsOpen(false);
+                removeChild();
+                connectingRef.current = false;
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('Connection request reset')) {
+                    currentBridge.reset();
+                    return { error: 'Connection cancelled' };
+                }
+                logger.log('WalletConnect', err);
+                return { error: 'Connection failed' };
+            }
+        }
+        else {
+            removeChild();
+            connectingRef.current = false;
+            logger.log('Configuration error: Please provide a WalletConnect Project ID in your wagmi config.');
+            return {
+                error: 'Configuration error: Please provide a WalletConnect Project ID in your wagmi config.',
+            };
+        }
+    }, []);
+    return { isOpen, open };
 }
 
 export { useWalletConnectModal };

package/build/hooks/useWalletConnectModal.js.map

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

package/build/openfort/CoreOpenfortProvider.js

@@ -219,6 +219,7 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
         storeActiveEmbeddedAddress,
         chainType,
         store,
+        walletConfig,
     });
     // Current chain for EVM provider reconfiguration
     const evmChainId = (strategy === null || strategy === void 0 ? void 0 : strategy.chainType) === ChainTypeEnum.EVM ? (bridge ? bridge.chainId : strategy === null || strategy === void 0 ? void 0 : strategy.getChainId()) : undefined;

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/openfort/hooks/useActiveAddressSync.d.ts

@@ -1,5 +1,6 @@
 import { type ChainTypeEnum, type Openfort } from '@openfort/openfort-js';
 import type { StoreApi } from 'zustand/vanilla';
+import type { OpenfortWalletConfig } from '../../components/Openfort/types';
 import type { OpenfortStore } from '../store';
 type Params = {
     openfort: Openfort;
@@ -8,13 +9,16 @@ type Params = {
     storeActiveEmbeddedAddress: OpenfortStore['activeEmbeddedAddress'];
     chainType: ChainTypeEnum;
     store: StoreApi<OpenfortStore>;
+    walletConfig: OpenfortWalletConfig | undefined;
 };
 /**
  * Syncs the active embedded address into the store.
  *
  * - Clears address when there are no accounts or user is logged out.
- * - When READY: asks the SDK for its active wallet, falls back to the first
- *   account for the current chain.
+ * - When connectOnLogin is false and the session went through
+ *   EMBEDDED_SIGNER_NOT_CONFIGURED (login flow), skips auto-seeding at READY
+ *   so the user must pick a wallet explicitly.
+ * - Returning sessions (SDK starts directly at READY) always auto-seed.
  */
-export declare function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store, }: Params): void;
+export declare function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store, walletConfig, }: Params): void;
 export {};

package/build/openfort/hooks/useActiveAddressSync.js

@@ -1,18 +1,30 @@
 import { EmbeddedState } from '@openfort/openfort-js';
-import { useEffect } from 'react';
+import { useRef, useEffect } from 'react';
 import { firstEmbeddedAddress } from '../../core/strategyUtils.js';
 
 /**
  * Syncs the active embedded address into the store.
  *
  * - Clears address when there are no accounts or user is logged out.
- * - When READY: asks the SDK for its active wallet, falls back to the first
- *   account for the current chain.
+ * - When connectOnLogin is false and the session went through
+ *   EMBEDDED_SIGNER_NOT_CONFIGURED (login flow), skips auto-seeding at READY
+ *   so the user must pick a wallet explicitly.
+ * - Returning sessions (SDK starts directly at READY) always auto-seed.
  */
-function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store, }) {
+function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store, walletConfig, }) {
+    var _a;
+    const connectOnLogin = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) !== null && _a !== void 0 ? _a : true;
+    // Track whether the current session went through EMBEDDED_SIGNER_NOT_CONFIGURED
+    // (i.e. a login flow, not a returning session). When connectOnLogin is false, we
+    // skip auto-seeding at READY only for login flows — returning sessions (where the
+    // SDK starts directly at READY with a configured signer) should always auto-seed.
+    const sawSignerNotConfiguredRef = useRef(false);
     useEffect(() => {
         if (!openfort || !(storeEmbeddedAccounts === null || storeEmbeddedAccounts === void 0 ? void 0 : storeEmbeddedAccounts.length)) {
-            if (!(storeEmbeddedAccounts === null || storeEmbeddedAccounts === void 0 ? void 0 : storeEmbeddedAccounts.length)) {
+            // Only clear the address on genuine logout (no user). During wallet creation
+            // the accounts list is briefly empty while updateEmbeddedAccounts refetches —
+            // clearing here would undo the address that create() just set.
+            if (!(storeEmbeddedAccounts === null || storeEmbeddedAccounts === void 0 ? void 0 : storeEmbeddedAccounts.length) && !store.getState().user) {
                 store.getState().setActiveEmbeddedAddress(undefined);
             }
             return;
@@ -23,13 +35,16 @@ function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedSt
         if (storeEmbeddedState === EmbeddedState.UNAUTHENTICATED || storeEmbeddedState === EmbeddedState.NONE) {
             if (!store.getState().user) {
                 store.getState().setActiveEmbeddedAddress(undefined);
+                sawSignerNotConfiguredRef.current = false;
             }
             return;
         }
         // Bootstrap recovery: when signer is not yet configured and no address is set,
         // seed the active address so useAutoRecovery can trigger and drive state → READY.
+        // Skip when connectOnLogin is false — the user should explicitly choose a wallet.
         if (storeEmbeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            if (storeActiveEmbeddedAddress === undefined) {
+            sawSignerNotConfiguredRef.current = true;
+            if (connectOnLogin && storeActiveEmbeddedAddress === undefined) {
                 const first = firstEmbeddedAddress(storeEmbeddedAccounts, chainType);
                 if (first)
                     store.getState().setActiveEmbeddedAddress(first);
@@ -42,6 +57,13 @@ function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedSt
         // Already have an address — nothing to resolve
         if (storeActiveEmbeddedAddress !== undefined)
             return;
+        // Login flow with connectOnLogin=false: the session went through
+        // EMBEDDED_SIGNER_NOT_CONFIGURED, so don't auto-seed. The user must pick
+        // a wallet via the UI. create() and setActive() set the address directly,
+        // so they bypass this check.
+        if (!connectOnLogin && sawSignerNotConfiguredRef.current) {
+            return;
+        }
         // Priority 1: ask the SDK for its active wallet
         let cancelled = false;
         openfort.embeddedWallet
@@ -69,7 +91,15 @@ function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedSt
         return () => {
             cancelled = true;
         };
-    }, [openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store]);
+    }, [
+        openfort,
+        storeEmbeddedAccounts,
+        storeEmbeddedState,
+        storeActiveEmbeddedAddress,
+        chainType,
+        store,
+        connectOnLogin,
+    ]);
 }
 
 export { useActiveAddressSync };

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

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

package/build/solana/hooks/useSolanaEmbeddedWallet.js

@@ -123,6 +123,7 @@ function useSolanaEmbeddedWallet(options) {
                 accountType: AccountTypeEnum.EOA,
                 recoveryParams,
             });
+            setActiveEmbeddedAddress(account.address);
             await updateEmbeddedAccounts({ silent: true });
             const provider = createProviderForAccount(account);
             const connectedWallet = {
@@ -139,7 +140,6 @@ function useSolanaEmbeddedWallet(options) {
                 provider,
                 error: null,
             });
-            setActiveEmbeddedAddress(account.address);
             (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(createOptions, { account });
             return account;
         }

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.0.7";
+export declare const OPENFORT_VERSION = "1.0.9";

package/build/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",
@@ -94,11 +94,10 @@
     "@types/styled-components": "^5.1.25",
     "@wagmi/connectors": "^6.2.0",
     "@wagmi/core": "^2.22.1",
-    "happy-dom": "^20.8.3",
+    "happy-dom": "^20.8.9",
     "jsdom": "^28.1.0",
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-plugin-typescript2": "^0.36.0",
-    "styled-components": "^5.3.5",
     "typescript": "^5.0.4",
     "typescript-plugin-styled-components": "^2.0.0",
     "vitest": "^2.0.0",