@openfort/react 1.0.10 → 1.0.12

package/build/openfort/CoreOpenfortProvider.js

@@ -5,6 +5,7 @@ import { routes } from '../components/Openfort/types.js';
 import { useOpenfort } from '../components/Openfort/useOpenfort.js';
 import { embeddedWalletId } from '../constants/openfort.js';
 import { ConnectionStrategyProvider, useConnectionStrategy } from '../core/ConnectionStrategyContext.js';
+import { resolveEthereumFeeSponsorship } from '../core/strategyUtils.js';
 import { OpenfortEthereumBridgeContext } from '../ethereum/OpenfortEthereumBridgeContext.js';
 import { useConnectLifecycle } from '../hooks/useConnectLifecycle.js';
 import { showInitBanner } from '../utils/banner.js';
@@ -91,13 +92,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
@@ -229,6 +231,7 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
     const initInProgressRef = useRef(false);
     // Init provider; only fetch accounts when READY (prevents list() before auth is stored)
     useEffect(() => {
+        var _a;
         if (!openfort || !walletConfig || !strategy)
             return;
         // EVM: only run at READY — auto-recover handles EMBEDDED_SIGNER_NOT_CONFIGURED → READY.
@@ -241,12 +244,14 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
             }
         }
         // Skip if we already initialized with the same parameters
-        const initKey = { kind: strategy.kind, chainType: strategy.chainType, evmChainId };
+        const feeSponsorshipPolicy = evmChainId != null ? (_a = resolveEthereumFeeSponsorship(walletConfig, evmChainId)) === null || _a === void 0 ? void 0 : _a.policy : undefined;
+        const initKey = { kind: strategy.kind, chainType: strategy.chainType, evmChainId, feeSponsorshipPolicy };
         const prev = lastInitRef.current;
         if (prev &&
             prev.kind === initKey.kind &&
             prev.chainType === initKey.chainType &&
-            prev.evmChainId === initKey.evmChainId) {
+            prev.evmChainId === initKey.evmChainId &&
+            prev.feeSponsorshipPolicy === initKey.feeSponsorshipPolicy) {
             return;
         }
         // Prevent concurrent initProvider calls

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.10";
+export declare const OPENFORT_VERSION = "1.0.12";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.0.10';
+const OPENFORT_VERSION = '1.0.12';
 
 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.10",
+  "version": "1.0.12",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",