@openfort/react 1.0.6 → 1.0.8

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

@@ -1,4 +1,5 @@
 import { RecoveryMethod } from '@openfort/openfort-js';
+export declare const RECOVERY_METHOD_LABEL: Record<RecoveryMethod, string>;
 export declare const WalletRecoveryIcon: ({ recovery }: {
     recovery: RecoveryMethod | undefined;
 }) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -2,6 +2,11 @@ import { jsx } from 'react/jsx-runtime';
 import { RecoveryMethod } from '@openfort/openfort-js';
 import { LockIcon, FingerPrintIcon, KeyIcon } from '../../../assets/icons.js';
 
+const RECOVERY_METHOD_LABEL = {
+    [RecoveryMethod.AUTOMATIC]: 'Automatic',
+    [RecoveryMethod.PASSWORD]: 'Password',
+    [RecoveryMethod.PASSKEY]: 'Passkey',
+};
 const WalletRecoveryIcon = ({ recovery }) => {
     switch (recovery) {
         case RecoveryMethod.PASSWORD:
@@ -15,5 +20,5 @@ const WalletRecoveryIcon = ({ recovery }) => {
     }
 };
 
-export { WalletRecoveryIcon };
+export { RECOVERY_METHOD_LABEL, WalletRecoveryIcon };
 //# sourceMappingURL=index.js.map

package/build/components/Common/WalletRecoveryIcon/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/ConnectWithInjector/index.js

@@ -118,7 +118,7 @@ const ConnectWithInjector = ({ forceState }) => {
             connectorType: (_b = walletItem.connector) === null || _b === void 0 ? void 0 : _b.type,
             walletClientType: (_c = walletItem.connector) === null || _c === void 0 ? void 0 : _c.id,
             onError: (error, _errorType) => {
-                logger.error(error);
+                logger.error('[ConnectWithInjector] SIWE failed:', error);
                 disconnect();
                 setStatus(states.FAILED);
             },
@@ -211,14 +211,14 @@ const ConnectWithInjector = ({ forceState }) => {
             }
             if (!wallet) {
                 setStatus(states.FAILED);
-                logger.error('No wallet found');
+                logger.error('[ConnectWithInjector] No wallet found after connect');
                 return;
             }
-            logger.log('Connect type is:', props.connectType);
+            logger.log('[ConnectWithInjector] Connect type is:', props.connectType);
             await handleConnectSettled(wallet, connectResult);
         }
         catch (err) {
-            logger.error(err);
+            logger.error('[ConnectWithInjector] Connection error', err instanceof Error ? err.message : err);
             handleConnectError(err && typeof err === 'object' && 'code' in err
                 ? err
                 : {

package/build/components/ConnectModal/ConnectWithMobile.js

@@ -1,5 +1,6 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { useState, useEffect } from 'react';
+import { embeddedWalletId } from '../../constants/openfort.js';
 import { useEthereumBridge } from '../../ethereum/OpenfortEthereumBridgeContext.js';
 import styled from '../../styles/styled/index.js';
 import { isAndroid } from '../../utils/index.js';
@@ -25,7 +26,7 @@ const DownloadFooter = styled.div `
   color: var(--ck-body-color-muted);
 `;
 const ConnectWithMobile = () => {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { connector, setRoute } = useOpenfort();
     const walletId = Object.keys(walletConfigs).find(
     // where id is comma separated list
@@ -35,8 +36,9 @@ const ConnectWithMobile = () => {
         .indexOf(connector.id) !== -1);
     const wallet = useExternalConnector(connector.id) || (walletId && walletConfigs[walletId]) || {};
     const bridge = useEthereumBridge();
-    const isConnected = (_b = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _a === void 0 ? void 0 : _a.isConnected) !== null && _b !== void 0 ? _b : false;
-    const [status, setStatus] = useState(isConnected ? states.INIT : states.CONNECTING);
+    // Only consider external wallets as "connected" — ignore the embedded wallet connector
+    const isExternalConnected = (_d = (((_a = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _a === void 0 ? void 0 : _a.isConnected) && ((_c = (_b = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _b === void 0 ? void 0 : _b.connector) === null || _c === void 0 ? void 0 : _c.id) !== embeddedWalletId)) !== null && _d !== void 0 ? _d : false;
+    const [status, setStatus] = useState(isExternalConnected ? states.CONNECTING : states.INIT);
     const [description, setDescription] = useState(undefined);
     const [hasReturned, setHasReturned] = useState(false);
     const { connectWithSiwe } = useConnectWithSiwe();
@@ -59,7 +61,7 @@ const ConnectWithMobile = () => {
     useEffect(() => {
         if (hasReturned) {
             setHasReturned(false);
-            if (isConnected) {
+            if (isExternalConnected) {
                 setStatus(states.CONNECTING);
             }
             else {
@@ -67,7 +69,7 @@ const ConnectWithMobile = () => {
                 setDescription('Connection failed or cancelled');
             }
         }
-    }, [hasReturned, isConnected]);
+    }, [hasReturned, isExternalConnected]);
     useEffect(() => {
         switch (status) {
             case states.INIT:
@@ -86,13 +88,13 @@ const ConnectWithMobile = () => {
         }
     }, [status]);
     return (jsxs(PageContent, { children: [jsx(Loader, { header: `Connecting with ${connector.id.split(',')[0]}`, icon: wallet === null || wallet === void 0 ? void 0 : wallet.icon, isError: status === states.ERROR, description: description, onRetry: () => {
-                    setStatus(isConnected ? states.CONNECTING : states.INIT);
+                    setStatus(isExternalConnected ? states.CONNECTING : states.INIT);
                     setDescription('');
-                } }), isConnected ? (jsx(Button, { onClick: () => {
+                } }), isExternalConnected ? (jsx(Button, { onClick: () => {
                     openApp();
                 }, children: "Sign in App" })) : (jsx(Button, { onClick: () => {
                     openApp();
-                }, children: "Sign in App" })), jsx(DownloadFooter, { children: jsxs(FitText, { children: ["Don't have ", (_c = wallet.name) !== null && _c !== void 0 ? _c : connector.id.split(',')[0], " installed?", ' ', jsx("a", { style: { marginLeft: 5 }, href: isAndroid() ? (_d = wallet === null || wallet === void 0 ? void 0 : wallet.downloadUrls) === null || _d === void 0 ? void 0 : _d.android : (_e = wallet === null || wallet === void 0 ? void 0 : wallet.downloadUrls) === null || _e === void 0 ? void 0 : _e.ios, target: "_blank", rel: "noreferrer", children: "GET" })] }) })] }));
+                }, children: "Sign in App" })), jsx(DownloadFooter, { children: jsxs(FitText, { children: ["Don't have ", (_e = wallet.name) !== null && _e !== void 0 ? _e : connector.id.split(',')[0], " installed?", ' ', jsx("a", { style: { marginLeft: 5 }, href: isAndroid() ? (_f = wallet === null || wallet === void 0 ? void 0 : wallet.downloadUrls) === null || _f === void 0 ? void 0 : _f.android : (_g = wallet === null || wallet === void 0 ? void 0 : wallet.downloadUrls) === null || _g === void 0 ? void 0 : _g.ios, target: "_blank", rel: "noreferrer", children: "GET" })] }) })] }));
 };
 
 export { ConnectWithMobile as default };

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

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

package/build/components/ConnectModal/ConnectWithOAuth.js

@@ -3,6 +3,7 @@ import { useState, useEffect } from 'react';
 import { providersLogos } from '../../assets/logos.js';
 import { useOpenfortCore } from '../../openfort/useOpenfort.js';
 import { logger } from '../../utils/logger.js';
+import { parseCallbackUrl, suppressReferrer } from '../../utils/urlSecurity.js';
 import Loader from '../Common/Loading/index.js';
 import { routes } from '../Openfort/types.js';
 import { useOpenfort } from '../Openfort/useOpenfort.js';
@@ -27,7 +28,7 @@ const ConnectWithOAuth = () => {
                 return;
             if (connector.type !== 'oauth')
                 throw new Error('Invalid connector type');
-            const url = new URL(win.location.href.replace('?access_token=', '&access_token=')); // handle both ? and & cases
+            const url = parseCallbackUrl(win.location.href);
             const hasProvider = !!url.searchParams.get('openfortAuthProviderUI');
             const provider = connector.id;
             switch (status) {
@@ -38,6 +39,8 @@ const ConnectWithOAuth = () => {
                         setTimeout(() => setStatus(states.REDIRECT), 150); // UX: wait a bit before redirecting
                     break;
                 case states.CONNECTING: {
+                    // Suppress Referer before any async work to prevent token leakage
+                    const restoreReferrer = suppressReferrer();
                     const userId = url.searchParams.get('user_id');
                     const token = url.searchParams.get('access_token');
                     const error = url.searchParams.get('error');
@@ -45,6 +48,7 @@ const ConnectWithOAuth = () => {
                         url.searchParams.delete(key);
                     });
                     win.history.replaceState({}, doc.title, url.toString());
+                    restoreReferrer();
                     if (!userId || !token || error) {
                         logger.error(`Missing user id or access token: userId=${userId}, accessToken=${token ? `${token.substring(0, 10)}...` : token}`);
                         setStatus(states.ERROR);

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

@@ -1 +1 @@
-{"version":3,"file":"ConnectWithOAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"ConnectWithOAuth.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

@@ -142,6 +142,10 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
     const setOpen = useCallback((value) => {
         if (value) {
             setRouteHistory([]);
+            // Reset route and connector to avoid stale state from a previous modal session
+            // (e.g. a failed SIWE attempt leaving route on CONNECT with a stale connector)
+            setRoute({ route: routes.LOADING });
+            setConnector(initialConnector);
         }
         setOpenWithoutHistory(value);
     }, []);

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/Connectors/index.js

@@ -1,64 +1,10 @@
 import { jsx } from 'react/jsx-runtime';
-import { useState, useEffect } from 'react';
-import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
-import useIsMobile from '../../../hooks/useIsMobile.js';
-import { useWalletConnectModal } from '../../../hooks/useWalletConnectModal.js';
 import { logger } from '../../../utils/logger.js';
 import ConnectorList from '../../Common/ConnectorList/index.js';
-import Loader from '../../Common/Loading/index.js';
-import { routes } from '../../Openfort/types.js';
-import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 
 let hasWarnedConnectors = false;
-const ConnectWithMobile = () => {
-    var _a, _b;
-    const { open: openWalletConnectModal } = useWalletConnectModal();
-    const [error, setError] = useState(undefined);
-    const bridge = useEthereumBridge();
-    const connector = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _a === void 0 ? void 0 : _a.connector;
-    const address = (_b = bridge === null || bridge === void 0 ? void 0 : bridge.account) === null || _b === void 0 ? void 0 : _b.address;
-    const { setRoute, setConnector } = useOpenfort();
-    const openWCModal = async () => {
-        setError(undefined);
-        const { error } = await openWalletConnectModal();
-        if (error) {
-            setError(error);
-        }
-    };
-    useEffect(() => {
-        openWCModal();
-    }, []);
-    useEffect(() => {
-        if (connector && address) {
-            const walletConnectDeeplinkChoice = localStorage.getItem('WALLETCONNECT_DEEPLINK_CHOICE');
-            if (walletConnectDeeplinkChoice) {
-                try {
-                    const parsedChoice = JSON.parse(walletConnectDeeplinkChoice);
-                    if (parsedChoice &&
-                        typeof parsedChoice === 'object' &&
-                        'name' in parsedChoice &&
-                        typeof parsedChoice.name === 'string') {
-                        setConnector({ id: parsedChoice.name });
-                    }
-                    else {
-                        setConnector({ id: connector.id });
-                    }
-                }
-                catch {
-                    setConnector({ id: connector.id });
-                }
-            }
-            else {
-                setConnector({ id: connector.id });
-            }
-            setRoute(routes.CONNECT_WITH_MOBILE);
-        }
-    }, [address, connector]);
-    return (jsx(Loader, { header: error ? 'Error connecting wallet.' : `Connecting...`, isError: !!error, description: error, onRetry: () => openWCModal() }));
-};
 const Connectors = ({ logoutOnBack }) => {
-    const isMobile = useIsMobile();
     // Runtime deprecation warning
     if (process.env.NODE_ENV === 'development' && !hasWarnedConnectors) {
         logger.warn('[@openfort/react] <Connectors /> is deprecated and will be moved to @openfort/react/wagmi in v3.0.\n' +
@@ -66,7 +12,7 @@ const Connectors = ({ logoutOnBack }) => {
             'See: https://openfort.io/docs/migration/external-wallets');
         hasWarnedConnectors = true;
     }
-    return (jsx(PageContent, { logoutOnBack: logoutOnBack, width: 312, children: isMobile ? jsx(ConnectWithMobile, {}) : jsx(ConnectorList, {}) }));
+    return (jsx(PageContent, { logoutOnBack: logoutOnBack, width: 312, children: jsx(ConnectorList, {}) }));
 };
 
 export { Connectors as default };

package/build/components/Pages/Connectors/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/LinkedProvider/index.js

@@ -1,5 +1,5 @@
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { useMemo } from 'react';
+import { useRef, useMemo } from 'react';
 import { useUser } from '../../../hooks/openfort/useUser.js';
 import { useResolvedIdentity } from '../../../hooks/useResolvedIdentity.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
@@ -65,11 +65,14 @@ const OAuthContent = ({ account }) => {
 };
 const LinkedProvider = () => {
     const { route } = useOpenfort();
+    const lastAccountRef = useRef(null);
     const account = useMemo(() => {
         if (route.route === 'linkedProvider') {
+            lastAccountRef.current = route.account;
             return route.account;
         }
-        throw new Error('No account found in route');
+        // During exit animations or route transitions, return the last known account
+        return lastAccountRef.current;
     }, [route]);
     const getProviderDetails = (account) => {
         switch (account.provider) {
@@ -83,6 +86,8 @@ const LinkedProvider = () => {
                 return (jsxs("div", { style: { marginTop: '16px', display: 'flex', alignItems: 'center', gap: '8px', flexDirection: 'column' }, children: [jsxs("div", { children: ["Authentication method: ", jsx("b", { children: getProviderName(account.provider) })] }), jsx(FitText, { children: jsx(ProviderHeader, { account: account }) })] }));
         }
     };
+    if (!account)
+        return null;
     return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: getProviderName(account.provider) }), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ProviderIconContainer, { children: jsx(ProviderIconWrapper, { children: jsx(ProviderIconInner, { children: jsx(ProviderIcon, { account: account }) }) }) }), jsx(ModalBody, { children: getProviderDetails(account) })] })] }));
 };
 

package/build/components/Pages/LinkedProvider/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

@@ -1,5 +1,5 @@
 import { jsx } from 'react/jsx-runtime';
-import { ChainTypeEnum } from '@openfort/openfort-js';
+import { ChainTypeEnum, RecoveryMethod } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
 import { toSolanaUserWallet } from '../../../hooks/openfort/walletTypes.js';
@@ -7,20 +7,24 @@ import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
 import { logger } from '../../../utils/logger.js';
 import Loader from '../../Common/Loading/index.js';
-import { recoverRoute, createRoute } from '../../Openfort/routeHelpers.js';
+import { createRoute, recoverRoute } from '../../Openfort/routeHelpers.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
 
-const handleSingleWalletRegistry = {
-    [ChainTypeEnum.SVM]: (w, chainType, setRoute) => {
-        const walletForRoute = toSolanaUserWallet(w);
-        setRoute(recoverRoute(chainType, walletForRoute));
-    },
-    [ChainTypeEnum.EVM]: (w, chainType, setRoute) => {
-        setRoute(recoverRoute(chainType, w));
-    },
-};
+/** Pick the best wallet to auto-recover: automatic > passkey > first available */
+function pickBestWallet(wallets) {
+    var _a, _b;
+    return ((_b = (_a = wallets.find((w) => w.recoveryMethod === RecoveryMethod.AUTOMATIC)) !== null && _a !== void 0 ? _a : wallets.find((w) => w.recoveryMethod === RecoveryMethod.PASSKEY)) !== null && _b !== void 0 ? _b : wallets[0]);
+}
+function routeToRecover(wallet, chainType, setRoute) {
+    if (chainType === ChainTypeEnum.SVM) {
+        setRoute(recoverRoute(chainType, toSolanaUserWallet(wallet)));
+    }
+    else {
+        setRoute(recoverRoute(chainType, wallet));
+    }
+}
 const errorForChainRegistry = {
     [ChainTypeEnum.SVM]: () => ({ isError: false, message: undefined }),
     [ChainTypeEnum.EVM]: (errorWallets) => ({
@@ -29,11 +33,13 @@ const errorForChainRegistry = {
     }),
 };
 const LoadWallets = () => {
+    var _a;
     const { chainType, user, isLoadingAccounts } = useOpenfortCore();
     const { triggerResize, setRoute, setConnector, walletConfig } = useOpenfort();
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
     const embeddedWallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
+    const connectOnLogin = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) !== null && _a !== void 0 ? _a : true;
     const [loadingUX, setLoadingUX] = useState(true);
     const wallets = embeddedWallet.wallets;
     const isLoadingWallets = embeddedWallet.status === 'fetching-wallets' ||
@@ -63,31 +69,32 @@ const LoadWallets = () => {
             return;
         }
         logger.log('User wallets loaded:', wallets.length);
+        // No wallets → create one
         if (wallets.length === 0) {
-            // Always show the create wallet page when no wallets exist.
-            // connectOnLogin only controls whether creation starts automatically
-            // (handled inside CreateWalletAutomaticRecovery), not whether the
-            // page is shown — routing to CONNECTED with 0 wallets would show a
-            // broken "Connect wallet" button aimed at external wagmi wallets.
             setRoute(createRoute(chainType));
             return;
         }
-        if (wallets.length === 1) {
-            const single = wallets[0];
-            const alreadyActive = embeddedWallet.status === 'connected' &&
-                embeddedWallet.address &&
-                (chainType === ChainTypeEnum.SVM
-                    ? embeddedWallet.address === single.address
-                    : embeddedWallet.address.toLowerCase() === single.address.toLowerCase());
-            if (alreadyActive) {
+        // If a wallet is already active and connected, go to connected (triggers auto-close)
+        if (embeddedWallet.status === 'connected' && embeddedWallet.address) {
+            const activeAddr = embeddedWallet.address;
+            const isActiveInList = wallets.some((w) => chainType === ChainTypeEnum.SVM
+                ? w.address === activeAddr
+                : w.address.toLowerCase() === activeAddr.toLowerCase());
+            if (isActiveInList) {
                 setRoute(chainType === ChainTypeEnum.SVM ? routes.SOL_CONNECTED : routes.ETH_CONNECTED);
                 return;
             }
-            handleSingleWalletRegistry[chainType](single, chainType, setRoute, setConnector);
-            return;
         }
-        setRoute(routes.SELECT_WALLET_TO_RECOVER);
-    }, [loadingUX, isLoadingWallets, wallets, user, chainType, setRoute, setConnector, walletConfig]);
+        if (connectOnLogin) {
+            // Auto-connect: pick the best wallet (automatic > passkey > password) and recover it
+            const best = pickBestWallet(wallets);
+            routeToRecover(best, chainType, setRoute);
+        }
+        else {
+            // Not auto-connecting: close modal (go to connected page which triggers auto-close)
+            setRoute(chainType === ChainTypeEnum.SVM ? routes.SOL_CONNECTED : routes.ETH_CONNECTED);
+        }
+    }, [loadingUX, isLoadingWallets, wallets, user, chainType, setRoute, setConnector, walletConfig, connectOnLogin]);
     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/components/Pages/RemoveLinkedProvider/index.js

@@ -32,7 +32,7 @@ const RemoveLinkedProvider = () => {
         if (route.route === 'removeLinkedProvider') {
             return route.account;
         }
-        throw new Error('No provider found in route');
+        return null;
     }, [route]);
     useEffect(() => {
         if (error)
@@ -60,6 +60,8 @@ const RemoveLinkedProvider = () => {
     }, [isSuccess]);
     const handleRemove = async () => {
         var _a;
+        if (!provider)
+            return;
         const errorMsg = 'Failed to remove linked provider. Please try again.';
         if (provider.provider === 'siwe' || provider.provider === 'wallet') {
             try {
@@ -97,6 +99,8 @@ const RemoveLinkedProvider = () => {
             }
         }
     };
+    if (!provider)
+        return null;
     return (jsxs(PageContent, { children: [jsxs(ModalHeading, { children: ["Remove ", getProviderName(provider.provider)] }), jsxs(ModalContent, { style: { paddingBottom: 0 }, children: [jsx(ProviderIconContainer, { style: { marginBottom: '16px' }, children: jsx(ProviderIconWrapper, { children: jsx(ProviderIconInner, { children: jsx(ProviderIcon, { account: provider }) }) }) }), isSuccess ? (jsxs(Fragment, { children: [jsx(ModalH1, { "$valid": true, children: "Success" }), jsxs(ModalBody, { children: ["Successfully removed", ' ', provider.provider === 'siwe' ? (jsxs("span", { children: [jsx("b", { children: jsx(WalletDisplay, { walletAddress: provider.accountId }) }), "."] })) : (jsxs(Fragment, { children: [jsx("b", { children: getProviderName(provider.provider) }), " as an authentication method."] }))] }), jsx(ButtonWrapper, { style: { marginTop: 0 }, children: jsx(Button, { onClick: () => onBack === null || onBack === void 0 ? void 0 : onBack(), children: "Back" }) })] })) : (jsxs(Fragment, { children: [jsxs("p", { children: ["Are you sure you want to remove", ' ', provider.provider === 'siwe' ? (jsxs(CopyText, { value: provider.accountId, children: [jsx("b", { children: jsx(WalletDisplay, { walletAddress: provider.accountId }) }), "?"] })) : (jsxs(Fragment, { children: [jsx("b", { children: getProviderName(provider.provider) }), "as an authentication method?"] }))] }), error && jsx(ErrorMessage, { children: error }), jsxs(ButtonWrapper, { style: { marginTop: 0 }, children: [jsx(Button, { onClick: () => onBack === null || onBack === void 0 ? void 0 : onBack(), children: "Cancel" }), jsx(Button, { onClick: handleRemove, children: "Remove" })] })] }))] })] }));
 };
 

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

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