@openfort/react 0.3.2 → 1.0.1

package/build/openfort/CoreOpenfortProvider.d.ts

@@ -1,28 +1,15 @@
-import { type EmbeddedAccount, EmbeddedState, type Openfort, type User } from '@openfort/openfort-js';
-import { type QueryObserverResult, type RefetchOptions } from '@tanstack/react-query';
+import { type Openfort } from '@openfort/openfort-js';
 import type React from 'react';
 import { type PropsWithChildren } from 'react';
-import type { WalletFlowStatus } from '../hooks/openfort/useWallets';
-import { type useConnectCallbackProps } from '../hooks/useConnectCallback';
-import type { UserAccount } from '../openfortCustomTypes';
-export type ContextValue = {
-    signUpGuest: () => Promise<void>;
-    embeddedState: EmbeddedState;
-    isLoading: boolean;
-    needsRecovery: boolean;
-    user: User | null;
-    updateUser: (user?: User) => Promise<User | null>;
-    linkedAccounts: UserAccount[];
-    embeddedAccounts?: EmbeddedAccount[];
-    isLoadingAccounts: boolean;
-    logout: () => void;
-    updateEmbeddedAccounts: (options?: RefetchOptions) => Promise<QueryObserverResult<EmbeddedAccount[], Error>>;
-    walletStatus: WalletFlowStatus;
-    setWalletStatus: (status: WalletFlowStatus) => void;
-    client: Openfort;
-};
+import type { ConnectCallbackProps } from './connectCallbackTypes';
+import type { OpenfortStore } from './store';
+/**
+ * Public return type for useOpenfortCore(). Matches the store shape.
+ * Kept as a named type for backward compatibility with consumers that import it.
+ */
+export type OpenfortCoreContextValue = OpenfortStore;
 type CoreOpenfortProviderProps = PropsWithChildren<{
     openfortConfig: ConstructorParameters<typeof Openfort>[0];
-} & useConnectCallbackProps>;
+} & ConnectCallbackProps>;
 export declare const CoreOpenfortProvider: React.FC<CoreOpenfortProviderProps>;
 export {};

package/build/openfort/CoreOpenfortProvider.js

@@ -0,0 +1,389 @@
+import { ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
+import { useContext, useMemo, useState, useEffect, useRef, useCallback, useLayoutEffect, createElement, Fragment } from 'react';
+import { useStore } from 'zustand';
+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 { OpenfortEthereumBridgeContext } from '../ethereum/OpenfortEthereumBridgeContext.js';
+import { useConnectLifecycle } from '../hooks/useConnectLifecycle.js';
+import { showInitBanner } from '../utils/banner.js';
+import { logger } from '../utils/logger.js';
+import { handleOAuthConfigError } from '../utils/oauthErrorHandler.js';
+import { mapBridgeConnectorsToWalletProps } from '../wallets/useExternalConnectors.js';
+import { StoreContext } from './context.js';
+import { createOpenfortClient } from './core/client.js';
+import { useActiveAddressSync } from './hooks/useActiveAddressSync.js';
+import { useAutoRecovery } from './hooks/useAutoRecovery.js';
+import { useEmbeddedStateMachine } from './hooks/useEmbeddedStateMachine.js';
+import { createOpenfortStore } from './store.js';
+
+function ConnectLifecycleEffect({ onConnect, onDisconnect }) {
+    const strategy = useConnectionStrategy();
+    useConnectLifecycle(strategy, onConnect, onDisconnect);
+    return null;
+}
+const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfig, }) => {
+    const bridge = useContext(OpenfortEthereumBridgeContext);
+    const { walletConfig, chainType, setChainType, uiConfig, open, route, connector } = useOpenfort();
+    const bridgeConnectors = useMemo(() => {
+        if (!bridge)
+            return [];
+        return mapBridgeConnectorsToWalletProps(bridge, {
+            walletConnectName: uiConfig.walletConnectName,
+        });
+    }, [bridge, uiConfig.walletConnectName]);
+    const [solanaStrategy, setSolanaStrategy] = useState(null);
+    useEffect(() => {
+        if (!(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana)) {
+            setSolanaStrategy(null);
+            return;
+        }
+        let cancelled = false;
+        import('../core/strategies/SolanaEmbeddedStrategy.js').then((m) => {
+            if (!cancelled)
+                setSolanaStrategy(m.createSolanaEmbeddedStrategy(walletConfig));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [walletConfig]);
+    const [evmStrategy, setEvmStrategy] = useState(null);
+    useEffect(() => {
+        if (!(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) && !bridge) {
+            setEvmStrategy(null);
+            return;
+        }
+        let cancelled = false;
+        if (bridge) {
+            import('../core/strategies/EthereumBridgeStrategy.js').then((m) => {
+                if (!cancelled)
+                    setEvmStrategy(m.createEthereumBridgeStrategy(bridge, bridgeConnectors));
+            });
+        }
+        else {
+            import('../core/strategies/EthereumEmbeddedStrategy.js').then((m) => {
+                if (!cancelled)
+                    setEvmStrategy(m.createEthereumEmbeddedStrategy(walletConfig));
+            });
+        }
+        return () => {
+            cancelled = true;
+        };
+    }, [bridge, bridgeConnectors, walletConfig]);
+    // ---- Zustand store + Openfort client ----
+    const bridgeRef = useRef(bridge);
+    bridgeRef.current = bridge;
+    // ---- Openfort instance ----
+    const openfort = useMemo(() => {
+        logger.log('Creating Openfort instance.', openfortConfig);
+        if (!openfortConfig.baseConfiguration.publishableKey)
+            throw Error('CoreOpenfortProvider requires a publishableKey to be set in the baseConfiguration.');
+        let resolvedShieldConfig = openfortConfig.shieldConfiguration;
+        if (resolvedShieldConfig && !resolvedShieldConfig.passkeyRpId && typeof window !== 'undefined') {
+            resolvedShieldConfig = {
+                passkeyRpId: window.location.hostname,
+                passkeyRpName: document.title || 'Openfort app',
+                ...resolvedShieldConfig,
+            };
+        }
+        const newClient = createOpenfortClient({ ...openfortConfig, shieldConfiguration: resolvedShieldConfig });
+        return newClient;
+    }, []);
+    const store = useMemo(() => {
+        return createOpenfortStore(chainType, openfort, () => {
+            var _a;
+            return ({
+                hasBridge: !!bridgeRef.current,
+                address: (_a = bridgeRef.current) === null || _a === void 0 ? void 0 : _a.account.address,
+            });
+        });
+    }, []);
+    // Sync chainType from UI context into the store
+    useEffect(() => {
+        store.getState().setChainType(chainType);
+    }, [store, chainType]);
+    // Recompute isLoading when bridge address changes (bridge connects/disconnects)
+    const address = bridge === null || bridge === void 0 ? void 0 : bridge.account.address;
+    useEffect(() => {
+        store.getState().recomputeIsLoading();
+    }, [store, address]);
+    const strategy = useMemo(() => {
+        var _a;
+        const strategyByChain = {
+            [ChainTypeEnum.SVM]: solanaStrategy,
+            [ChainTypeEnum.EVM]: evmStrategy,
+        };
+        return (_a = strategyByChain[chainType]) !== null && _a !== void 0 ? _a : null;
+    }, [chainType, solanaStrategy, evmStrategy]);
+    // ---- Embedded state ----
+    useEffect(() => {
+        showInitBanner();
+        if (!openfort)
+            return;
+        const unwatch = openfort.embeddedWallet.watchEmbeddedState({
+            onChange: (state, prevState) => {
+                logger.log('Embedded state changed:', EmbeddedState[state], '(prev:', prevState !== undefined ? EmbeddedState[prevState] : 'none', ')');
+                store.getState().setEmbeddedState(state);
+            },
+            onError: (error) => {
+                logger.error('Error watching embedded state:', error);
+            },
+        });
+        return unwatch;
+    }, [openfort, store]);
+    const updateUser = useCallback(async (user, logoutOnError = false) => {
+        var _a;
+        if (!openfort)
+            return null;
+        logger.log('Updating user', { user, logoutOnError });
+        if (user) {
+            store.getState().setUser(user);
+            return user;
+        }
+        try {
+            const user = await openfort.user.get();
+            logger.log('Getting user');
+            store.getState().setLinkedAccounts(user.linkedAccounts);
+            store.getState().setUser(user);
+            return user;
+        }
+        catch (err) {
+            logger.log('Error getting user', err);
+            if (!logoutOnError)
+                return null;
+            const status = err && typeof err === 'object' && 'response' in err
+                ? (_a = err.response) === null || _a === void 0 ? void 0 : _a.status
+                : undefined;
+            if (status === 404) {
+                logger.log('User not found, logging out');
+                logout();
+            }
+            else if (status === 401) {
+                logger.log('User not authenticated, logging out');
+                logout();
+            }
+            return null;
+        }
+    }, [openfort, store]);
+    const [silentRefetchInProgress, setSilentRefetchInProgress] = useState(false);
+    const [isAccountsPending, setAccountsPending] = useState(false);
+    const fetchSeqRef = useRef(0);
+    const fetchEmbeddedAccounts = useCallback(async (options) => {
+        const seq = ++fetchSeqRef.current;
+        if (options === null || options === void 0 ? void 0 : options.silent)
+            setSilentRefetchInProgress(true);
+        setAccountsPending(true);
+        try {
+            const accounts = await openfort.embeddedWallet.list({
+                limit: 100,
+            });
+            if (seq === fetchSeqRef.current) {
+                store.getState().setEmbeddedAccounts(accounts);
+            }
+            return accounts;
+        }
+        catch (error) {
+            handleOAuthConfigError(error);
+            throw error;
+        }
+        finally {
+            if (seq === fetchSeqRef.current) {
+                setAccountsPending(false);
+                if (options === null || options === void 0 ? void 0 : options.silent)
+                    setSilentRefetchInProgress(false);
+            }
+        }
+    }, [openfort, store]);
+    const isLoadingAccounts = isAccountsPending && !silentRefetchInProgress;
+    useEffect(() => {
+        store.getState().setIsLoadingAccounts(isLoadingAccounts);
+    }, [store, isLoadingAccounts]);
+    const updateUserRef = useRef(updateUser);
+    const fetchEmbeddedAccountsRef = useRef(fetchEmbeddedAccounts);
+    useLayoutEffect(() => {
+        updateUserRef.current = updateUser;
+        fetchEmbeddedAccountsRef.current = fetchEmbeddedAccounts;
+    }, [updateUser, fetchEmbeddedAccounts]);
+    // Subscribe to store state for effects
+    const storeEmbeddedState = useStore(store, (s) => s.embeddedState);
+    const storeEmbeddedAccounts = useStore(store, (s) => s.embeddedAccounts);
+    const storeActiveEmbeddedAddress = useStore(store, (s) => s.activeEmbeddedAddress);
+    const storeUser = useStore(store, (s) => s.user);
+    useActiveAddressSync({
+        openfort,
+        storeEmbeddedAccounts,
+        storeEmbeddedState,
+        storeActiveEmbeddedAddress,
+        chainType,
+        store,
+    });
+    // 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;
+    // Track what we last initialized to avoid redundant initProvider calls when
+    // the strategy object is recreated but nothing meaningful changed.
+    const lastInitRef = useRef(null);
+    const initInProgressRef = useRef(false);
+    // Init provider; only fetch accounts when READY (prevents list() before auth is stored)
+    useEffect(() => {
+        if (!openfort || !walletConfig || !strategy)
+            return;
+        // EVM: only run at READY — auto-recover handles EMBEDDED_SIGNER_NOT_CONFIGURED → READY.
+        // Running getEthereumProvider() concurrently with recover() causes a race condition.
+        // SVM: initProvider is a no-op, safe to run anytime.
+        if (storeEmbeddedState !== EmbeddedState.READY) {
+            if (strategy.chainType === ChainTypeEnum.EVM ||
+                storeEmbeddedState !== EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
+                return;
+            }
+        }
+        // Skip if we already initialized with the same parameters
+        const initKey = { kind: strategy.kind, chainType: strategy.chainType, evmChainId };
+        const prev = lastInitRef.current;
+        if (prev &&
+            prev.kind === initKey.kind &&
+            prev.chainType === initKey.chainType &&
+            prev.evmChainId === initKey.evmChainId) {
+            return;
+        }
+        // Prevent concurrent initProvider calls
+        if (initInProgressRef.current) {
+            return;
+        }
+        initInProgressRef.current = true;
+        let cancelled = false;
+        strategy
+            .initProvider(openfort, walletConfig, evmChainId)
+            .then(() => {
+            if (cancelled)
+                return;
+            lastInitRef.current = initKey;
+            // Only fetch accounts when authenticated — avoids SessionError on callback pages
+            if (store.getState().embeddedState === EmbeddedState.READY) {
+                return fetchEmbeddedAccounts({ silent: true });
+            }
+            logger.log('[CoreProvider] initProvider: not fetching accounts, state is', EmbeddedState[store.getState().embeddedState]);
+        })
+            .catch((_err) => { })
+            .finally(() => {
+            initInProgressRef.current = false;
+        });
+        return () => {
+            cancelled = true;
+            lastInitRef.current = null;
+            initInProgressRef.current = false;
+        };
+    }, [openfort, walletConfig, strategy, evmChainId, storeEmbeddedState]);
+    // On refresh, embeddedState reaches READY before the user is loaded, so
+    // fetchEmbeddedAccounts (called inside initProvider) returns empty. Re-fetch
+    // once the user becomes available while still in READY state.
+    // returns empty. Re-fetch once user becomes available while already READY.
+    useEffect(() => {
+        var _a;
+        if (!storeUser || storeEmbeddedState !== EmbeddedState.READY)
+            return;
+        if ((_a = store.getState().embeddedAccounts) === null || _a === void 0 ? void 0 : _a.length)
+            return;
+        fetchEmbeddedAccounts({ silent: true }).catch(() => { });
+    }, [storeUser, storeEmbeddedState, store, fetchEmbeddedAccounts]);
+    const { isConnectedWithEmbeddedSigner, setIsConnectedWithEmbeddedSigner, connectingRef } = useEmbeddedStateMachine({
+        openfort,
+        storeEmbeddedState,
+        storeUser,
+        store,
+        updateUserRef,
+        fetchEmbeddedAccountsRef,
+    });
+    useAutoRecovery({
+        storeEmbeddedState,
+        storeActiveEmbeddedAddress,
+        openfort,
+        walletConfig,
+        store,
+    });
+    // Refs for UI state that the bridge-connect guard reads but should NOT trigger re-runs.
+    const openRef = useRef(open);
+    const routeRef = useRef(route);
+    const connectorRef = useRef(connector);
+    useLayoutEffect(() => {
+        openRef.current = open;
+    }, [open]);
+    useLayoutEffect(() => {
+        routeRef.current = route;
+    }, [route]);
+    useLayoutEffect(() => {
+        connectorRef.current = connector;
+    }, [connector]);
+    useEffect(() => {
+        var _a;
+        if (!bridge || address || !storeUser)
+            return;
+        if (chainType !== ChainTypeEnum.EVM)
+            return;
+        if (isConnectedWithEmbeddedSigner)
+            return;
+        if (connectingRef.current)
+            return;
+        if (storeEmbeddedState !== EmbeddedState.READY)
+            return;
+        if (bridge.account.connector && bridge.account.connector.id !== embeddedWalletId)
+            return;
+        const currentRoute = routeRef.current;
+        const routeRoute = typeof currentRoute === 'object' && currentRoute && 'route' in currentRoute ? currentRoute.route : currentRoute;
+        if (openRef.current &&
+            routeRoute === routes.CONNECT &&
+            ((_a = connectorRef.current) === null || _a === void 0 ? void 0 : _a.id) &&
+            connectorRef.current.id !== embeddedWalletId)
+            return;
+        const openfortConnector = bridge.connectors.find((c) => c.name === 'Openfort');
+        if (!openfortConnector)
+            return;
+        connectingRef.current = true;
+        setIsConnectedWithEmbeddedSigner(true);
+        bridge.connect({ connector: openfortConnector });
+    }, [bridge, address, storeUser, chainType, storeEmbeddedState, isConnectedWithEmbeddedSigner]);
+    // ---- Auth functions ----
+    const logout = useCallback(async () => {
+        if (!openfort)
+            return;
+        store.getState().setUser(null);
+        store.getState().setActiveEmbeddedAddress(undefined);
+        store.getState().setEmbeddedAccounts(undefined);
+        store.getState().setWalletStatus({ status: 'idle' });
+        connectingRef.current = false;
+        setIsConnectedWithEmbeddedSigner(false);
+        lastInitRef.current = null;
+        logger.log('Logging out...');
+        await openfort.auth.logout();
+        if (bridge) {
+            await bridge.disconnect();
+            bridge.reset();
+        }
+    }, [openfort, bridge, store]);
+    const signUpGuest = useCallback(async () => {
+        if (!openfort)
+            return;
+        try {
+            logger.log('Signing up as guest...');
+            const res = await openfort.auth.signUpGuest();
+            logger.log('Signed up as guest:', res);
+        }
+        catch (error) {
+            logger.error('Error logging in as guest:', error);
+        }
+    }, [openfort]);
+    // ---- Inject actions into store ----
+    useLayoutEffect(() => {
+        store.setState({
+            logout,
+            signUpGuest,
+            updateUser,
+            updateEmbeddedAccounts: fetchEmbeddedAccounts,
+            setChainType,
+        });
+    }, [store, logout, signUpGuest, updateUser, fetchEmbeddedAccounts, setChainType]);
+    return createElement(StoreContext.Provider, { value: store }, createElement(ConnectionStrategyProvider, { strategy }, createElement(Fragment, null, createElement(ConnectLifecycleEffect, { onConnect, onDisconnect }), children)));
+};
+
+export { CoreOpenfortProvider };
+//# sourceMappingURL=CoreOpenfortProvider.js.map

package/build/openfort/CoreOpenfortProvider.js.map

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

package/build/{hooks/useConnectCallback.d.ts → openfort/connectCallbackTypes.d.ts}

@@ -1,5 +1,5 @@
 import type { User } from '@openfort/openfort-js';
-export type useConnectCallbackProps = {
+export type ConnectCallbackProps = {
     onConnect?: ({ address, connectorId, user }: {
         address?: string;
         connectorId?: string;
@@ -7,4 +7,4 @@ export type useConnectCallbackProps = {
     }) => void;
     onDisconnect?: () => void;
 };
-export declare const useConnectCallback: ({ onConnect, onDisconnect }: useConnectCallbackProps) => void;
+export type useConnectCallbackProps = ConnectCallbackProps;

package/build/openfort/context.d.ts

@@ -1,2 +1,3 @@
-import type { ContextValue } from './CoreOpenfortProvider';
-export declare const Context: import("react").Context<ContextValue | null>;
+import type { StoreApi } from 'zustand';
+import type { OpenfortStore } from './store';
+export declare const StoreContext: import("react").Context<StoreApi<OpenfortStore> | null>;

package/build/openfort/context.js

@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+
+const StoreContext = createContext(null);
+
+export { StoreContext };
+//# sourceMappingURL=context.js.map

package/build/openfort/context.js.map

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

package/build/openfort/core/client.d.ts

@@ -17,6 +17,7 @@ import { Openfort as OpenfortClient, type OpenfortSDKConfiguration } from '@open
 export declare function createOpenfortClient(config: OpenfortSDKConfiguration): OpenfortClient;
 /**
  * Sets the shared {@link OpenfortClient} instance.
+ * Kept for backwards compatibility; the client is provided via React context.
  *
  * @param client - Pre-configured Openfort client to store as the default.
  *
@@ -26,4 +27,4 @@ export declare function createOpenfortClient(config: OpenfortSDKConfiguration):
  * setDefaultClient(client);
  * ```
  */
-export declare function setDefaultClient(client: OpenfortClient): void;
+export declare function setDefaultClient(_client: OpenfortClient): void;

package/build/openfort/core/client.js

@@ -0,0 +1,23 @@
+import { Openfort } from '@openfort/openfort-js';
+
+/**
+ * Creates a new {@link OpenfortClient} instance.
+ *
+ * @param config - Configuration options passed directly to the Openfort SDK constructor.
+ * @returns A configured Openfort client instance.
+ *
+ * @example
+ * ```ts
+ * const client = createOpenfortClient({
+ *   baseConfiguration: { publishableKey: 'pk_test_123' },
+ * });
+ *
+ * const token = await client.getAccessToken();
+ * ```
+ */
+function createOpenfortClient(config) {
+    return new Openfort(config);
+}
+
+export { createOpenfortClient };
+//# sourceMappingURL=client.js.map

package/build/openfort/core/client.js.map

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

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

@@ -0,0 +1,20 @@
+import { type ChainTypeEnum, type Openfort } from '@openfort/openfort-js';
+import type { StoreApi } from 'zustand/vanilla';
+import type { OpenfortStore } from '../store';
+type Params = {
+    openfort: Openfort;
+    storeEmbeddedAccounts: OpenfortStore['embeddedAccounts'];
+    storeEmbeddedState: OpenfortStore['embeddedState'];
+    storeActiveEmbeddedAddress: OpenfortStore['activeEmbeddedAddress'];
+    chainType: ChainTypeEnum;
+    store: StoreApi<OpenfortStore>;
+};
+/**
+ * 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.
+ */
+export declare function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store, }: Params): void;
+export {};

package/build/openfort/hooks/useActiveAddressSync.js

@@ -0,0 +1,76 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+import { 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.
+ */
+function useActiveAddressSync({ openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store, }) {
+    useEffect(() => {
+        if (!openfort || !(storeEmbeddedAccounts === null || storeEmbeddedAccounts === void 0 ? void 0 : storeEmbeddedAccounts.length)) {
+            if (!(storeEmbeddedAccounts === null || storeEmbeddedAccounts === void 0 ? void 0 : storeEmbeddedAccounts.length)) {
+                store.getState().setActiveEmbeddedAddress(undefined);
+            }
+            return;
+        }
+        // Terminal non-READY states: clear only on genuine logout (no user).
+        // During OAuth the state passes through UNAUTHENTICATED → EMBEDDED_SIGNER_NOT_CONFIGURED → READY
+        // while accounts and address are already set. Clearing here would undo that.
+        if (storeEmbeddedState === EmbeddedState.UNAUTHENTICATED || storeEmbeddedState === EmbeddedState.NONE) {
+            if (!store.getState().user) {
+                store.getState().setActiveEmbeddedAddress(undefined);
+            }
+            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.
+        if (storeEmbeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
+            if (storeActiveEmbeddedAddress === undefined) {
+                const first = firstEmbeddedAddress(storeEmbeddedAccounts, chainType);
+                if (first)
+                    store.getState().setActiveEmbeddedAddress(first);
+            }
+            return;
+        }
+        if (storeEmbeddedState !== EmbeddedState.READY) {
+            return;
+        }
+        // Already have an address — nothing to resolve
+        if (storeActiveEmbeddedAddress !== undefined)
+            return;
+        // Priority 1: ask the SDK for its active wallet
+        let cancelled = false;
+        openfort.embeddedWallet
+            .get()
+            .then((active) => {
+            if (cancelled)
+                return;
+            const addr = active === null || active === void 0 ? void 0 : active.address;
+            if (addr) {
+                store.getState().setActiveEmbeddedAddress(addr);
+                return;
+            }
+            // Priority 2: fallback to first account for current chain
+            const first = firstEmbeddedAddress(storeEmbeddedAccounts, chainType);
+            if (first)
+                store.getState().setActiveEmbeddedAddress(first);
+        })
+            .catch((_err) => {
+            if (cancelled)
+                return;
+            const first = firstEmbeddedAddress(storeEmbeddedAccounts, chainType);
+            if (first)
+                store.getState().setActiveEmbeddedAddress(first);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [openfort, storeEmbeddedAccounts, storeEmbeddedState, storeActiveEmbeddedAddress, chainType, store]);
+}
+
+export { useActiveAddressSync };
+//# sourceMappingURL=useActiveAddressSync.js.map

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

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

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

@@ -0,0 +1,26 @@
+import { 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 = {
+    storeEmbeddedState: OpenfortStore['embeddedState'];
+    storeActiveEmbeddedAddress: OpenfortStore['activeEmbeddedAddress'];
+    openfort: Openfort | null;
+    walletConfig: OpenfortWalletConfig | undefined;
+    store: StoreApi<OpenfortStore>;
+};
+/**
+ * Auto-recover: when the SDK reaches EMBEDDED_SIGNER_NOT_CONFIGURED with a known
+ * active address, attempts to configure the signer via recover() → READY.
+ *
+ * Reads embeddedAccounts imperatively from the store (not as a dep) so that
+ * fetchEmbeddedAccounts updating the store mid-recovery does not re-trigger the
+ * effect and cancel the closure before recover() runs.
+ *
+ * PASSWORD recovery is skipped — it requires explicit user input.
+ *
+ * On failure: surfaces recoveryError in the store. Does NOT auto-create a new wallet
+ * because silently replacing a wallet can strand the user's funds.
+ */
+export declare function useAutoRecovery({ storeEmbeddedState, storeActiveEmbeddedAddress, openfort, walletConfig, store, }: Params): void;
+export {};