@openfort/react 1.0.9 → 1.0.11

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

@@ -40,9 +40,16 @@ const EthereumConnected = () => {
     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;
-    const isConnected = wallet.status === 'connected';
-    const address = isConnected ? wallet.address : undefined;
-    const chainId = isConnected ? wallet.chainId : undefined;
+    // Use embedded wallet if available, otherwise fall back to bridge (external wallet)
+    const embeddedConnected = wallet.status === 'connected';
+    const bridgeConnected = !!((bridge === null || bridge === void 0 ? void 0 : bridge.account.isConnected) && (bridge === null || bridge === void 0 ? void 0 : bridge.account.address));
+    const isConnected = embeddedConnected || bridgeConnected;
+    const address = embeddedConnected
+        ? wallet.address
+        : bridgeConnected
+            ? bridge.account.address
+            : undefined;
+    const chainId = embeddedConnected ? wallet.chainId : bridgeConnected ? bridge.chainId : undefined;
     const { chainType } = useOpenfortCore();
     useEffect(() => {
         if (process.env.NODE_ENV === 'development' && chainType !== ChainTypeEnum.EVM) {

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

@@ -2,6 +2,7 @@ import { jsx } from 'react/jsx-runtime';
 import { ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
 import React, { useEffect } from 'react';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
 import Loader from '../../Common/Loading/index.js';
@@ -13,12 +14,15 @@ const Loading = () => {
     const { setRoute, walletConfig } = useOpenfort();
     const { user, isLoadingAccounts, isLoading, needsRecovery, embeddedState } = useOpenfortCore();
     const { chainType } = useOpenfortCore();
+    const bridge = useEthereumBridge();
     // Use chain-specific hooks
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
     const wallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
-    const isConnected = wallet.status === 'connected';
-    const address = isConnected ? wallet.address : undefined;
+    // Check embedded wallet or bridge (external wallet) connection
+    const embeddedConnected = wallet.status === 'connected';
+    const bridgeConnected = chainType === ChainTypeEnum.EVM && !!((bridge === null || bridge === void 0 ? void 0 : bridge.account.isConnected) && (bridge === null || bridge === void 0 ? void 0 : bridge.account.address));
+    const address = embeddedConnected ? wallet.address : bridgeConnected ? bridge === null || bridge === void 0 ? void 0 : bridge.account.address : undefined;
     const [isFirstFrame, setIsFirstFrame] = React.useState(true);
     const [retryCount, setRetryCount] = React.useState(0);
     useEffect(() => {
@@ -27,7 +31,8 @@ const Loading = () => {
         // Wait for the SDK to settle. After storeCredentials the embedded state
         // briefly stays UNAUTHENTICATED/NONE while the SDK processes the token.
         // Routing to PROVIDERS here would abort the auth flow.
-        if (embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED)
+        // However, if bridge (external wallet) is already connected, don't block routing.
+        if ((embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) && !bridgeConnected)
             return;
         // Also wait while accounts or user are still loading.
         if (isLoadingAccounts || isLoading)

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

@@ -3,6 +3,7 @@ import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useEffect } from 'react';
 import Logos from '../../../assets/logos.js';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useEthereumBridge } from '../../../ethereum/OpenfortEthereumBridgeContext.js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
 import { CopyIconButton } from '../../Common/CopyToClipboard/CopyIconButton.js';
@@ -27,10 +28,18 @@ const Receive = () => {
     const { chainType } = useOpenfortCore();
     const ethereumWallet = useEthereumEmbeddedWallet();
     const solanaWallet = useSolanaEmbeddedWallet();
+    const bridge = useEthereumBridge();
     const wallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
-    const isConnected = wallet.status === 'connected';
-    const address = isConnected ? wallet.address : undefined;
-    const chainId = isConnected && chainType === ChainTypeEnum.EVM ? wallet.chainId : undefined;
+    // Use embedded wallet if available, otherwise fall back to bridge (external wallet)
+    const embeddedConnected = wallet.status === 'connected';
+    const bridgeConnected = chainType === ChainTypeEnum.EVM && !!((bridge === null || bridge === void 0 ? void 0 : bridge.account.isConnected) && (bridge === null || bridge === void 0 ? void 0 : bridge.account.address));
+    const isConnected = embeddedConnected || bridgeConnected;
+    const address = embeddedConnected ? wallet.address : bridgeConnected ? bridge === null || bridge === void 0 ? void 0 : bridge.account.address : undefined;
+    const chainId = embeddedConnected && chainType === ChainTypeEnum.EVM
+        ? wallet.chainId
+        : bridgeConnected
+            ? bridge === null || bridge === void 0 ? void 0 : bridge.chainId
+            : undefined;
     const chain = chains.find((c) => c.id === chainId);
     const qrValue = address || '';
     const networkLabel = isConnected && chainType === ChainTypeEnum.SVM && solanaWallet.cluster

package/build/components/Pages/Receive/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/openfort/CoreOpenfortProvider.js

@@ -91,13 +91,14 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
         return newClient;
     }, []);
     const store = useMemo(() => {
+        var _a;
         return createOpenfortStore(chainType, openfort, () => {
             var _a;
             return ({
                 hasBridge: !!bridgeRef.current,
                 address: (_a = bridgeRef.current) === null || _a === void 0 ? void 0 : _a.account.address,
             });
-        });
+        }, (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) !== null && _a !== void 0 ? _a : true);
     }, []);
     // Sync chainType from UI context into the store — useLayoutEffect so the store
     // is updated before the next paint, preventing a one-render-cycle race where

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

@@ -43,4 +43,4 @@ export type OpenfortStore = OpenfortStoreState & OpenfortStoreActions;
 export declare function createOpenfortStore(initialChainType: ChainTypeEnum, client: Openfort, getBridgeInfo?: () => {
     hasBridge: boolean;
     address: string | undefined;
-}): StoreApi<OpenfortStore>;
+}, connectOnLogin?: boolean): StoreApi<OpenfortStore>;

package/build/openfort/store.js

@@ -1,7 +1,7 @@
 import { EmbeddedState } from '@openfort/openfort-js';
 import { createStore } from 'zustand/vanilla';
 
-function computeIsLoading(embeddedState, user, hasBridge, bridgeAddress) {
+function computeIsLoading(embeddedState, user, hasBridge, bridgeAddress, embeddedAccounts, activeEmbeddedAddress, connectOnLogin) {
     switch (embeddedState) {
         case EmbeddedState.NONE:
         case EmbeddedState.CREATING_ACCOUNT:
@@ -15,6 +15,11 @@ function computeIsLoading(embeddedState, user, hasBridge, bridgeAddress) {
                 return true;
             if (hasBridge && !bridgeAddress)
                 return true;
+            // Embedded accounts exist but active address not yet synced.
+            // Only when connectOnLogin is true — when false, address is intentionally
+            // not auto-set and the user must pick a wallet via the UI.
+            if (connectOnLogin && (embeddedAccounts === null || embeddedAccounts === void 0 ? void 0 : embeddedAccounts.length) && !activeEmbeddedAddress)
+                return true;
             return false;
         default:
             return true;
@@ -24,7 +29,7 @@ function computeNeedsRecovery(embeddedState, embeddedAccounts) {
     var _a;
     return embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED && ((_a = embeddedAccounts === null || embeddedAccounts === void 0 ? void 0 : embeddedAccounts.length) !== null && _a !== void 0 ? _a : 0) > 0;
 }
-function createOpenfortStore(initialChainType, client, getBridgeInfo) {
+function createOpenfortStore(initialChainType, client, getBridgeInfo, connectOnLogin = true) {
     const store = createStore((set) => ({
         user: null,
         linkedAccounts: [],
@@ -68,7 +73,7 @@ function createOpenfortStore(initialChainType, client, getBridgeInfo) {
             var _a;
             const state = store.getState();
             const info = (_a = getBridgeInfo === null || getBridgeInfo === void 0 ? void 0 : getBridgeInfo()) !== null && _a !== void 0 ? _a : { hasBridge: false, address: undefined };
-            const loading = computeIsLoading(state.embeddedState, state.user, info.hasBridge, info.address);
+            const loading = computeIsLoading(state.embeddedState, state.user, info.hasBridge, info.address, state.embeddedAccounts, state.activeEmbeddedAddress, connectOnLogin);
             if (loading !== state.isLoading) {
                 set({ isLoading: loading });
             }
@@ -86,9 +91,10 @@ function createOpenfortStore(initialChainType, client, getBridgeInfo) {
         const embeddedStateChanged = state.embeddedState !== prev.embeddedState;
         const userChanged = state.user !== prev.user;
         const embeddedAccountsChanged = state.embeddedAccounts !== prev.embeddedAccounts;
-        if (embeddedStateChanged || userChanged) {
+        const activeAddressChanged = state.activeEmbeddedAddress !== prev.activeEmbeddedAddress;
+        if (embeddedStateChanged || userChanged || embeddedAccountsChanged || activeAddressChanged) {
             const info = (_a = getBridgeInfo === null || getBridgeInfo === void 0 ? void 0 : getBridgeInfo()) !== null && _a !== void 0 ? _a : { hasBridge: false, address: undefined };
-            const isLoading = computeIsLoading(state.embeddedState, state.user, info.hasBridge, info.address);
+            const isLoading = computeIsLoading(state.embeddedState, state.user, info.hasBridge, info.address, state.embeddedAccounts, state.activeEmbeddedAddress, connectOnLogin);
             if (isLoading !== state.isLoading) {
                 store.setState({ isLoading });
             }

package/build/openfort/store.js.map

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

package/build/version.d.ts

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

package/build/version.js

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

package/build/wagmi/useEmbeddedWalletWagmiSync.js

@@ -19,6 +19,7 @@ function useEmbeddedWalletWagmiSync() {
     const provider = status === 'connected' ? wallet.provider : null;
     // Track whether an external wallet was explicitly connected — don't override it
     const externalConnectorActiveRef = useRef(false);
+    const connectFailedRef = useRef(false);
     useEffect(() => {
         if (activeConnector && activeConnector.id !== embeddedWalletId) {
             externalConnectorActiveRef.current = true;
@@ -27,6 +28,10 @@ function useEmbeddedWalletWagmiSync() {
             externalConnectorActiveRef.current = false;
         }
     }, [activeConnector]);
+    // Reset failure flag when provider changes (new session = fresh attempt)
+    useEffect(() => {
+        connectFailedRef.current = false;
+    }, [provider]);
     // Keep the module-level provider slot in sync — clear on disconnect
     useEffect(() => {
         if (status === 'connected' && provider) {
@@ -45,6 +50,9 @@ function useEmbeddedWalletWagmiSync() {
             return;
         if ((activeConnector === null || activeConnector === void 0 ? void 0 : activeConnector.id) === embeddedWalletId)
             return;
+        // Already failed for this provider — don't retry
+        if (connectFailedRef.current)
+            return;
         // An external wallet is actively connected — don't override it
         if (externalConnectorActiveRef.current) {
             logger.log('[EmbeddedWalletWagmiSync] Skipping auto-connect — external wallet is active', {
@@ -56,7 +64,10 @@ function useEmbeddedWalletWagmiSync() {
         if (!embeddedConnector)
             return;
         logger.log('[EmbeddedWalletWagmiSync] Auto-connecting embedded wallet to wagmi');
-        connectAsync({ connector: embeddedConnector }).catch(() => { });
+        connectAsync({ connector: embeddedConnector }).catch((error) => {
+            connectFailedRef.current = true;
+            logger.error('[EmbeddedWalletWagmiSync] Failed to connect embedded wallet to wagmi', error);
+        });
     }, [status, provider, wagmiStatus, activeConnector, connectors, connectAsync]);
     // Disconnect embedded connector from wagmi when the embedded wallet logs out
     useEffect(() => {

package/build/wagmi/useEmbeddedWalletWagmiSync.js.map

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

package/package.json

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