@openfort/react 0.3.1 → 1.0.0

package/build/ethereum/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ethereum-specific exports for @openfort/react/ethereum
+ *
+ * Import from '@openfort/react/ethereum' for Ethereum-only features.
+ *
+ * @packageDocumentation
+ */
+export type { CreateEmbeddedWalletOptions, CreateEmbeddedWalletResult, } from '../shared/types';
+export { useEthereumEmbeddedWallet } from './hooks/useEthereumEmbeddedWallet';
+export { useEthereumWalletAssets } from './hooks/useEthereumWalletAssets';
+export type { ConnectedEmbeddedEthereumWallet, EthereumConfig, EthereumWalletActions, EthereumWalletState, FeeSponsorshipConfig, OpenfortEmbeddedEthereumWalletProvider, SetActiveEthereumWalletOptions, UseEmbeddedEthereumWalletOptions, } from './types';

package/build/ethereum/index.js

@@ -0,0 +1,3 @@
+export { useEthereumEmbeddedWallet } from './hooks/useEthereumEmbeddedWallet.js';
+export { useEthereumWalletAssets } from './hooks/useEthereumWalletAssets.js';
+//# sourceMappingURL=index.js.map

package/build/ethereum/index.js.map

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

package/build/ethereum/types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Ethereum-specific types for @openfort/react/ethereum
+ *
+ * These types define the Ethereum wallet state machine and related interfaces.
+ */
+import type { AccountTypeEnum, ChainTypeEnum, EmbeddedAccount, RecoveryMethod, RecoveryParams } from '@openfort/openfort-js';
+import type { Hex } from 'viem';
+import type { ConnectedWalletState, CreateEmbeddedWalletOptions, SetActiveEmbeddedWalletOptionsBase, SetRecoveryOptions as SharedSetRecoveryOptions, WalletDerived } from '../shared/types';
+export type FeeSponsorshipConfig = string | Record<number, string>;
+export type EthereumConfig = {
+    /** Initial chain ID for the embedded wallet provider.
+     * Optional when using OpenfortWagmiBridge — chain is managed by wagmi.
+     * Required for SDK-only (no wagmi) mode; defaults to Sepolia if omitted. */
+    chainId?: number;
+    rpcUrls?: Record<number, string>;
+    /** Fee sponsorship ID for gas sponsorship / embedded signer */
+    ethereumFeeSponsorshipId?: FeeSponsorshipConfig;
+    accountType?: AccountTypeEnum;
+    /** Token addresses for asset inventory (chainId -> Hex[]) */
+    assets?: Record<number, Hex[]>;
+};
+/**
+ * EIP-1193 Provider interface for Ethereum wallets
+ */
+export interface OpenfortEmbeddedEthereumWalletProvider {
+    request(args: EIP1193RequestArguments): Promise<unknown>;
+    on(event: EIP1193EventName | string, handler: EIP1193EventHandler): void;
+    removeListener(event: EIP1193EventName | string, handler: EIP1193EventHandler): void;
+}
+export type EIP1193RequestArguments = {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+};
+export type EIP1193EventName = 'accountsChanged' | 'chainChanged' | 'connect' | 'disconnect' | 'message';
+export type EIP1193EventHandler = (...args: unknown[]) => void;
+type SimpleAccount = {
+    id: string;
+    chainId?: number;
+};
+export type ConnectedEmbeddedEthereumWallet = {
+    id: string;
+    address: `0x${string}`;
+    ownerAddress?: string;
+    implementationType?: string;
+    chainType: typeof ChainTypeEnum.EVM;
+    walletIndex: number;
+    recoveryMethod?: RecoveryMethod;
+    getProvider(): Promise<OpenfortEmbeddedEthereumWalletProvider>;
+    isAvailable: boolean;
+    isActive: boolean;
+    isConnecting: boolean;
+    accounts: SimpleAccount[];
+    connectorType?: string;
+    walletClientType?: string;
+    accountId?: string;
+    accountType?: AccountTypeEnum;
+    createdAt?: number;
+    salt?: string;
+};
+/** Options for setting active Ethereum wallet (chain-specific address + shared recovery). */
+export type SetActiveEthereumWalletOptions = SetActiveEmbeddedWalletOptionsBase & {
+    /** Wallet address to set as active */
+    address: `0x${string}`;
+    /** Chain ID (required for Smart Accounts) */
+    chainId?: number;
+};
+/**
+ * Actions available on Ethereum embedded wallets
+ */
+export interface EthereumWalletActions {
+    /** Create a new Ethereum embedded wallet */
+    create(options?: CreateEmbeddedWalletOptions): Promise<EmbeddedAccount>;
+    /** List of available Ethereum wallets */
+    wallets: ConnectedEmbeddedEthereumWallet[];
+    /** Set the active wallet */
+    setActive(options: SetActiveEthereumWalletOptions): Promise<void>;
+    /** Update recovery method */
+    setRecovery(options: SharedSetRecoveryOptions): Promise<void>;
+    /** Export the private key (requires user confirmation) */
+    exportPrivateKey(): Promise<string>;
+}
+export type EthereumWalletStateBase = (EthereumWalletActions & {
+    status: 'disconnected';
+    activeWallet: null;
+    address?: never;
+    chainId?: never;
+    displayAddress?: never;
+}) | (EthereumWalletActions & {
+    status: 'fetching-wallets';
+    activeWallet: null;
+    address?: never;
+    chainId?: never;
+    displayAddress?: never;
+}) | (EthereumWalletActions & {
+    status: 'connecting';
+    activeWallet: ConnectedEmbeddedEthereumWallet;
+    address: `0x${string}`;
+    chainId?: number;
+    displayAddress: string;
+}) | (EthereumWalletActions & {
+    status: 'reconnecting';
+    activeWallet: ConnectedEmbeddedEthereumWallet;
+    address: `0x${string}`;
+    chainId?: number;
+    displayAddress: string;
+}) | (EthereumWalletActions & {
+    status: 'creating';
+    activeWallet: null;
+    address?: never;
+    chainId?: never;
+    displayAddress?: never;
+}) | (EthereumWalletActions & {
+    status: 'needs-recovery';
+    activeWallet: ConnectedEmbeddedEthereumWallet;
+    address?: `0x${string}`;
+    chainId?: number;
+    displayAddress?: string;
+}) | (EthereumWalletActions & {
+    status: 'connected';
+    activeWallet: ConnectedEmbeddedEthereumWallet;
+    provider: OpenfortEmbeddedEthereumWalletProvider;
+    address: `0x${string}`;
+    chainId: number;
+    displayAddress: string;
+}) | (EthereumWalletActions & {
+    status: 'error';
+    activeWallet: ConnectedEmbeddedEthereumWallet | null;
+    error: string;
+    address?: `0x${string}`;
+    chainId?: number;
+    displayAddress?: string;
+});
+export type EthereumWalletState = EthereumWalletStateBase & WalletDerived & ConnectedWalletState;
+export type UseEmbeddedEthereumWalletOptions = {
+    /** Chain ID for smart account operations */
+    chainId?: number;
+    /** Recovery params for wallet access */
+    recoveryParams?: RecoveryParams;
+};
+export {};

package/build/hooks/openfort/auth/requestEmailVerification.js

@@ -0,0 +1,21 @@
+const buildCallbackUrl = ({ email, callbackUrl, provider, isOpen, }) => {
+    if (callbackUrl && !callbackUrl.startsWith('http')) {
+        callbackUrl = `${window.location.origin}${callbackUrl.startsWith('/') ? '' : '/'}${callbackUrl}`;
+    }
+    const redirectUrl = new URL(callbackUrl || window.location.origin);
+    // Validate that the redirect URL stays on the same origin to prevent open redirect attacks
+    if (redirectUrl.origin !== window.location.origin) {
+        throw new Error(`Invalid callbackUrl: origin "${redirectUrl.origin}" does not match current origin "${window.location.origin}"`);
+    }
+    redirectUrl.searchParams.append('openfortAuthProvider', provider);
+    if (email) {
+        redirectUrl.searchParams.append('email', email);
+    }
+    if (isOpen) {
+        redirectUrl.searchParams.append('openfortEmailVerificationUI', 'true');
+    }
+    return redirectUrl.toString();
+};
+
+export { buildCallbackUrl };
+//# sourceMappingURL=requestEmailVerification.js.map

package/build/hooks/openfort/auth/requestEmailVerification.js.map

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

package/build/hooks/openfort/auth/status.js

@@ -0,0 +1,11 @@
+const mapStatus = (status) => {
+    return {
+        isLoading: status.status === 'loading',
+        isError: status.status === 'error',
+        isSuccess: status.status === 'success',
+        error: 'error' in status ? status.error : undefined,
+    };
+};
+
+export { mapStatus };
+//# sourceMappingURL=status.js.map

package/build/hooks/openfort/auth/status.js.map

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

package/build/hooks/openfort/auth/useAuthCallback.d.ts

@@ -1,5 +1,6 @@
 import type { UIAuthProvider } from '../../../components/Openfort/types';
-import { OpenfortError, type OpenfortHookOptions } from '../../../types';
+import { OpenfortError } from '../../../core/errors';
+import type { OpenfortHookOptions } from '../../../types';
 import type { CreateWalletPostAuthOptions } from './useConnectToWalletPostAuth';
 import { type EmailVerificationResult } from './useEmailAuth';
 import { type StoreCredentialsResult } from './useOAuth';

package/build/hooks/openfort/auth/useAuthCallback.js

@@ -0,0 +1,197 @@
+import { useState, useRef, useEffect } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { logger } from '../../../utils/logger.js';
+import { useEmailAuth } from './useEmailAuth.js';
+import { useOAuth } from './useOAuth.js';
+
+/**
+ * Hook for handling authentication callbacks from OAuth providers and email verification
+ *
+ * This hook automatically processes authentication callbacks when the page loads with
+ * authentication parameters in the URL. It handles both OAuth provider callbacks
+ * (with access tokens) and email verification callbacks (with state tokens).
+ * The hook extracts parameters from the URL and automatically calls the appropriate
+ * authentication methods, then cleans up the URL parameters.
+ *
+ * @param options - Optional configuration with callback functions and authentication options
+ * @returns Current callback processing state and extracted information
+ *
+ * @example
+ * ```tsx
+ * const authCallback = useAuthCallback({
+ *   enabled: true,
+ *   onSuccess: (result) => {
+ *     if (result.type === 'storeCredentials') {
+ *       console.log('OAuth callback processed:', result.user);
+ *     } else if (result.type === 'verifyEmail') {
+ *       console.log('Email verified:', result.email);
+ *     }
+ *   },
+ *   onError: (error) => console.error('Callback processing failed:', error),
+ *   recoverWalletAutomatically: true,
+ * });
+ *
+ * // Check callback processing state
+ * if (authCallback.isLoading) {
+ *   console.log('Processing authentication callback...');
+ * } else if (authCallback.isError) {
+ *   console.error('Callback error:', authCallback.error);
+ * } else if (authCallback.isSuccess) {
+ *   console.log('Callback processed successfully');
+ * }
+ *
+ * // Access extracted information
+ * if (authCallback.provider) {
+ *   console.log('Authentication provider:', authCallback.provider);
+ * }
+ *
+ * if (authCallback.email) {
+ *   console.log('Email from callback:', authCallback.email);
+ * }
+ *
+ * // Manually trigger verification (if needed)
+ * const handleManualVerification = async () => {
+ *   await authCallback.verifyEmail({
+ *     email: 'user@example.com',
+ *     state: 'verification-token',
+ *   });
+ * };
+ * // Manually trigger storing credentials (if needed)
+ * const handleManualStoreCredentials = async () => {
+ *   await authCallback.storeCredentials({
+ *     userId: 'player-id',
+ *     token: 'access-token',
+ *   });
+ * };
+ * ```
+ */
+const useAuthCallback = ({ enabled = true, // Automatically handle OAuth and email callback
+...hookOptions } = {}) => {
+    const [provider, setProvider] = useState(null);
+    const [email, setEmail] = useState(null);
+    const [alreadyVerified, setAlreadyVerified] = useState(false);
+    const { verifyEmail, isSuccess: isEmailSuccess, isLoading: isEmailLoading, isError: isEmailError, error: emailError, } = useEmailAuth();
+    const { storeCredentials, isSuccess: isOAuthSuccess, isLoading: isOAuthLoading, isError: isOAuthError, error: oAuthError, } = useOAuth();
+    const callbackProcessedRef = useRef(false);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (callbackProcessedRef.current)
+            return;
+        callbackProcessedRef.current = true;
+        (async () => {
+            var _a, _b, _c;
+            // redirectUrl is not working with query params OF-1013
+            const fixedUrl = window.location.href.replace('?state=', '&state=');
+            const url = new URL(fixedUrl);
+            const openfortAuthProvider = url.searchParams.get('openfortAuthProvider');
+            if (!openfortAuthProvider) {
+                return;
+            }
+            setProvider(openfortAuthProvider);
+            if (openfortAuthProvider === 'email') {
+                // Email verification flow
+                // The backend verifies the email server-side via /auth/verify-email?token=...
+                // and then redirects here. If a `state` token is present we verify client-side
+                // as well; otherwise the email is already verified and we just signal success.
+                const state = url.searchParams.get('state');
+                const email = url.searchParams.get('email');
+                const removeParams = () => {
+                    ['state', 'openfortAuthProvider', 'email'].forEach((key) => {
+                        url.searchParams.delete(key);
+                    });
+                    window.history.replaceState({}, document.title, url.toString());
+                };
+                if (state && email) {
+                    // State present — verify client-side as well
+                    const options = {
+                        onSuccess: (data) => {
+                            var _a;
+                            (_a = hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                                ...data,
+                                type: 'verifyEmail',
+                            });
+                        },
+                        onError: hookOptions.onError,
+                        throwOnError: hookOptions.throwOnError,
+                    };
+                    await verifyEmail({ email, state, ...options });
+                    setEmail(email);
+                    removeParams();
+                }
+                else if (email) {
+                    // No state — backend already verified the email, just signal success
+                    setEmail(email);
+                    setAlreadyVerified(true);
+                    (_a = hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                        email,
+                        type: 'verifyEmail',
+                    });
+                    removeParams();
+                }
+                else {
+                    const err = new OpenfortError('No email found in URL', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+                    logger.error('No email found in URL');
+                    (_b = hookOptions.onError) === null || _b === void 0 ? void 0 : _b.call(hookOptions, err);
+                    if (hookOptions.throwOnError)
+                        throw err;
+                    return;
+                }
+            }
+            else {
+                const userId = url.searchParams.get('user_id');
+                const token = url.searchParams.get('access_token');
+                if (!userId || !token) {
+                    logger.error(`Missing user id or access token`, {
+                        hasUserId: !!userId,
+                        hasToken: !!token,
+                    });
+                    const err = new OpenfortError('Missing player id or access token or refresh token', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+                    (_c = hookOptions.onError) === null || _c === void 0 ? void 0 : _c.call(hookOptions, err);
+                    if (hookOptions.throwOnError)
+                        throw err;
+                    return;
+                }
+                const removeParams = () => {
+                    ['openfortAuthProvider', 'access_token', 'user_id'].forEach((key) => {
+                        url.searchParams.delete(key);
+                    });
+                    window.history.replaceState({}, document.title, url.toString());
+                };
+                logger.log('callback', { userId });
+                const options = {
+                    onSuccess: (data) => {
+                        var _a;
+                        (_a = hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                            ...data,
+                            type: 'storeCredentials',
+                        });
+                    },
+                    onError: hookOptions.onError,
+                    throwOnError: hookOptions.throwOnError,
+                };
+                await storeCredentials({
+                    userId,
+                    token,
+                    logoutOnError: hookOptions.logoutOnError,
+                    recoverWalletAutomatically: hookOptions.recoverWalletAutomatically,
+                    ...options,
+                });
+                removeParams();
+            }
+        })();
+    }, []); // intentionally empty — runs once on mount to process the URL callback
+    return {
+        email,
+        provider,
+        verifyEmail,
+        storeCredentials,
+        isLoading: isEmailLoading || isOAuthLoading,
+        isError: isEmailError || isOAuthError,
+        isSuccess: isEmailSuccess || isOAuthSuccess || alreadyVerified,
+        error: emailError || oAuthError,
+    };
+};
+
+export { useAuthCallback };
+//# sourceMappingURL=useAuthCallback.js.map

package/build/hooks/openfort/auth/useAuthCallback.js.map

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

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.d.ts

@@ -1,4 +1,4 @@
-import { type UserWallet } from '../useWallets';
+import { type EthereumUserWallet, type SolanaUserWallet } from '../walletTypes';
 /**
  * Options that control the behaviour of {@link useConnectToWalletPostAuth} when attempting to
  * recover or create an embedded wallet after authentication.
@@ -35,6 +35,7 @@ export type CreateWalletPostAuthOptions = {
  */
 export declare const useConnectToWalletPostAuth: () => {
     tryUseWallet: ({ logoutOnError: signOutOnError, recoverWalletAutomatically, }: CreateWalletPostAuthOptions) => Promise<{
-        wallet?: UserWallet;
+        wallet?: EthereumUserWallet | SolanaUserWallet;
+        passwordRequired?: boolean;
     }>;
 };

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.js

@@ -0,0 +1,161 @@
+import { AccountTypeEnum, ChainTypeEnum, RecoveryMethod, EmbeddedState } from '@openfort/openfort-js';
+import { useCallback } from 'react';
+import { useOpenfort } from '../../../components/Openfort/useOpenfort.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { buildRecoveryParams } from '../../../shared/utils/recovery.js';
+import { logger } from '../../../utils/logger.js';
+import { embeddedAccountToSolanaUserWallet, embeddedAccountToUserWallet } from '../walletTypes.js';
+import { useSignOut } from './useSignOut.js';
+
+/**
+ * React hook that attempts to recover or create an embedded wallet once a user has authenticated.
+ *
+ * @returns Helpers that execute the post-authentication wallet connection flow.
+ *
+ * @example
+ * ```ts
+ * const { tryUseWallet } = useConnectToWalletPostAuth();
+ *
+ * const result = await tryUseWallet({ recoverWalletAutomatically: false });
+ * if (!result.wallet) {
+ *   console.warn('No embedded wallet available after authentication');
+ * }
+ * ```
+ */
+const useConnectToWalletPostAuth = () => {
+    var _a, _b;
+    const { chainType, setActiveEmbeddedAddress, embeddedState, client, activeEmbeddedAddress, updateEmbeddedAccounts } = useOpenfortCore();
+    const { walletConfig } = useOpenfort();
+    const chainId = (_b = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.chainId) !== null && _b !== void 0 ? _b : 84532;
+    const { signOut } = useSignOut();
+    const tryUseWallet = useCallback(async ({ logoutOnError: signOutOnError = true, recoverWalletAutomatically, }) => {
+        var _a, _b, _c, _d, _e;
+        const connectOnLogin = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.connectOnLogin) !== null && _a !== void 0 ? _a : true;
+        const shouldRecover = recoverWalletAutomatically !== null && recoverWalletAutomatically !== void 0 ? recoverWalletAutomatically : connectOnLogin;
+        const shouldCreate = connectOnLogin;
+        if (!shouldRecover)
+            return {};
+        if (!(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.createEncryptedSessionEndpoint) && !(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.getEncryptionSession)) {
+            return {};
+        }
+        // Fetch + sync accounts directly via the store — no TanStack Query peer dep needed
+        const wallets = await updateEmbeddedAccounts();
+        if (!wallets)
+            return {};
+        const chainWallets = wallets.filter((w) => w.chainType === chainType);
+        if (chainWallets.length === 0) {
+            if (!shouldCreate) {
+                logger.log('tryUseWallet: no wallet for chain, connectOnLogin=false, skipping creation');
+                return {};
+            }
+            try {
+                const recoveryParams = await buildRecoveryParams({ recoveryMethod: undefined }, {
+                    walletConfig,
+                    getAccessToken: () => client.getAccessToken(),
+                    getUserId: async () => { var _a; return (_a = (await client.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
+                });
+                const accountType = (_c = (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : AccountTypeEnum.SMART_ACCOUNT;
+                const account = await client.embeddedWallet.create({
+                    chainType,
+                    accountType: chainType === ChainTypeEnum.EVM ? accountType : AccountTypeEnum.EOA,
+                    ...(chainType === ChainTypeEnum.EVM && accountType !== AccountTypeEnum.EOA && { chainId }),
+                    recoveryParams,
+                });
+                await updateEmbeddedAccounts({ silent: true });
+                setActiveEmbeddedAddress(account.address);
+                return {
+                    wallet: chainType === ChainTypeEnum.SVM
+                        ? embeddedAccountToSolanaUserWallet(account)
+                        : embeddedAccountToUserWallet(account),
+                };
+            }
+            catch (err) {
+                logger.error('Error creating wallet:', err);
+                if (signOutOnError)
+                    await signOut();
+                return {};
+            }
+        }
+        // Prefer automatic recovery, then passkey — these can be recovered without user input.
+        const autoRecoverableWallet = (_d = chainWallets.find((w) => w.recoveryMethod === RecoveryMethod.AUTOMATIC)) !== null && _d !== void 0 ? _d : chainWallets.find((w) => w.recoveryMethod === RecoveryMethod.PASSKEY);
+        if (autoRecoverableWallet) {
+            // If the embedded signer isn't READY yet, skip recover() — the state machine in
+            // CoreOpenfortProvider will handle wallet connection once READY is reached.
+            // Calling recover() before READY races against the state machine's own recovery.
+            if (embeddedState !== EmbeddedState.READY) {
+                // Store the intended address so the state machine activates it when READY
+                setActiveEmbeddedAddress(autoRecoverableWallet.address);
+                return {
+                    wallet: chainType === ChainTypeEnum.SVM
+                        ? embeddedAccountToSolanaUserWallet(autoRecoverableWallet)
+                        : embeddedAccountToUserWallet(autoRecoverableWallet),
+                };
+            }
+            // Check already-active using store state — no chain-specific wallet hook needed
+            const alreadyActive = activeEmbeddedAddress != null &&
+                (chainType === ChainTypeEnum.SVM
+                    ? activeEmbeddedAddress === autoRecoverableWallet.address
+                    : activeEmbeddedAddress.toLowerCase() === autoRecoverableWallet.address.toLowerCase());
+            if (alreadyActive) {
+                return {
+                    wallet: chainType === ChainTypeEnum.SVM
+                        ? embeddedAccountToSolanaUserWallet(autoRecoverableWallet)
+                        : embeddedAccountToUserWallet(autoRecoverableWallet),
+                };
+            }
+            try {
+                // Configure signer directly — no chain-specific wallet hook import needed
+                const recoveryParams = await buildRecoveryParams({
+                    recoveryMethod: autoRecoverableWallet.recoveryMethod === RecoveryMethod.PASSKEY ? RecoveryMethod.PASSKEY : undefined,
+                    passkeyId: autoRecoverableWallet.recoveryMethod === RecoveryMethod.PASSKEY
+                        ? (_e = autoRecoverableWallet.recoveryMethodDetails) === null || _e === void 0 ? void 0 : _e.passkeyId
+                        : undefined,
+                }, {
+                    walletConfig,
+                    getAccessToken: () => client.getAccessToken(),
+                    getUserId: async () => { var _a; return (_a = (await client.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
+                });
+                await client.embeddedWallet.recover({ account: autoRecoverableWallet.id, recoveryParams });
+                setActiveEmbeddedAddress(autoRecoverableWallet.address);
+                return {
+                    wallet: chainType === ChainTypeEnum.SVM
+                        ? embeddedAccountToSolanaUserWallet(autoRecoverableWallet)
+                        : embeddedAccountToUserWallet(autoRecoverableWallet),
+                };
+            }
+            catch (_err) {
+                if (signOutOnError)
+                    await signOut();
+                return {};
+            }
+        }
+        // Password recovery requires user input — signal the caller
+        if (chainWallets.some((w) => w.recoveryMethod === RecoveryMethod.PASSWORD)) {
+            return { wallet: undefined, passwordRequired: true };
+        }
+        const first = chainWallets[0];
+        return {
+            wallet: first
+                ? chainType === ChainTypeEnum.SVM
+                    ? embeddedAccountToSolanaUserWallet(first)
+                    : embeddedAccountToUserWallet(first)
+                : undefined,
+        };
+    }, [
+        chainType,
+        client,
+        walletConfig,
+        chainId,
+        signOut,
+        embeddedState,
+        setActiveEmbeddedAddress,
+        updateEmbeddedAccounts,
+        activeEmbeddedAddress,
+    ]);
+    return {
+        tryUseWallet,
+    };
+};
+
+export { useConnectToWalletPostAuth };
+//# sourceMappingURL=useConnectToWalletPostAuth.js.map

package/build/hooks/openfort/auth/useConnectToWalletPostAuth.js.map

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

package/build/hooks/openfort/auth/useEmailAuth.d.ts

@@ -1,11 +1,12 @@
 import type { User } from '@openfort/openfort-js';
-import { OpenfortError, type OpenfortHookOptions } from '../../../types';
-import type { UserWallet } from '../useWallets';
+import { OpenfortError } from '../../../core/errors';
+import type { OpenfortHookOptions } from '../../../types';
+import type { EthereumUserWallet, SolanaUserWallet } from '../walletTypes';
 import { type CreateWalletPostAuthOptions } from './useConnectToWalletPostAuth';
 type EmailAuthResult = {
     error?: OpenfortError;
     user?: User;
-    wallet?: UserWallet;
+    wallet?: EthereumUserWallet | SolanaUserWallet;
     requiresEmailVerification?: boolean;
 };
 type SignInEmailOptions = {