@openfort/react 0.3.2 → 1.0.0

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

@@ -0,0 +1,496 @@
+import { useState, useCallback } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { logger } from '../../../utils/logger.js';
+import { isValidEmail } from '../../../utils/validation.js';
+import { onError, onSuccess } from '../hookConsistency.js';
+import { useUI } from '../useUI.js';
+import { buildCallbackUrl } from './requestEmailVerification.js';
+import { mapStatus } from './status.js';
+import { useConnectToWalletPostAuth } from './useConnectToWalletPostAuth.js';
+
+/**
+ * Hook for email-based authentication operations
+ *
+ * This hook manages email authentication flows including sign-in, sign-up, password reset,
+ * email verification, and email linking. It handles both password and passwordless authentication
+ * and automatically manages wallet connection after successful authentication.
+ *
+ * @param hookOptions - Optional configuration with callback functions and authentication options
+ * @returns Current authentication state with email auth actions
+ *
+ * @example
+ * ```tsx
+ * const emailAuth = useEmailAuth({
+ *   onSignInEmailSuccess: (result) => console.log('Signed in:', result.user),
+ *   onSignInEmailError: (error) => console.error('Sign-in failed:', error),
+ *   emailVerificationRedirectTo: 'https://yourapp.com/verify',
+ *   recoverWalletAutomatically: true,
+ * });
+ *
+ * // Sign up with email and password
+ * await emailAuth.signUpEmail({
+ *   email: 'user@example.com',
+ *   password: 'securePassword123',
+ *   name: 'John Doe',
+ * });
+ *
+ * // Sign in with email and password
+ * await emailAuth.signInEmail({
+ *   email: 'user@example.com',
+ *   password: 'securePassword123',
+ * });
+ *
+ * // Request password reset
+ * await emailAuth.requestResetPassword({
+ *   email: 'user@example.com',
+ * });
+ *
+ * // Reset password with state token
+ * await emailAuth.resetPassword({
+ *   email: 'user@example.com',
+ *   password: 'newPassword123',
+ *   state: 'reset-token-from-email',
+ * });
+ *
+ * // Verify email with state token
+ * await emailAuth.verifyEmail({
+ *   email: 'user@example.com',
+ *   state: 'verification-token-from-email',
+ * });
+ *
+ * // Link email to existing authenticated account
+ * await emailAuth.linkEmail({
+ *   email: 'secondary@example.com',
+ *   password: 'password123',
+ * });
+ *
+ * // Check authentication state
+ * if (emailAuth.isLoading) {
+ *   console.log('Processing authentication...');
+ * } else if (emailAuth.isError) {
+ *   console.error('Authentication error:', emailAuth.error);
+ * } else if (emailAuth.isSuccess) {
+ *   console.log('Authentication successful');
+ * }
+ *
+ * // Handle email verification requirement
+ * if (emailAuth.requiresEmailVerification) {
+ *   console.log('Please check your email to verify your account');
+ * }
+ * ```
+ */
+const useEmailAuth = (hookOptions = {}) => {
+    const { client, updateUser } = useOpenfortCore();
+    const { isOpen } = useUI();
+    const [requiresEmailVerification, setRequiresEmailVerification] = useState(false);
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const reset = useCallback(() => {
+        setStatus({
+            status: 'idle',
+        });
+        setRequiresEmailVerification(false);
+    }, []);
+    const { tryUseWallet } = useConnectToWalletPostAuth();
+    const signInEmail = useCallback(async (options) => {
+        var _a, _b, _c;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            setRequiresEmailVerification(false);
+            if (!options.email || !options.password) {
+                const error = new OpenfortError('Email and password are required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            const result = await client.auth.logInWithEmailPassword({
+                email: options.email,
+                password: options.password,
+            });
+            if ('action' in result) {
+                setStatus({
+                    status: 'awaiting-input',
+                });
+                client.auth.requestEmailVerification({
+                    email: options.email,
+                    redirectUrl: buildCallbackUrl({
+                        email: options.email,
+                        callbackUrl: (_a = options.emailVerificationRedirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.emailVerificationRedirectTo,
+                        provider: 'email',
+                        isOpen,
+                    }),
+                });
+                setRequiresEmailVerification(true);
+                return onSuccess({
+                    data: { requiresEmailVerification: true },
+                    hookOptions,
+                    options,
+                });
+            }
+            else {
+                const { wallet } = await tryUseWallet({
+                    logoutOnError: (_b = options.logoutOnError) !== null && _b !== void 0 ? _b : hookOptions.logoutOnError,
+                    recoverWalletAutomatically: (_c = options.recoverWalletAutomatically) !== null && _c !== void 0 ? _c : hookOptions.recoverWalletAutomatically,
+                });
+                setStatus({
+                    status: 'success',
+                });
+                const user = result.user;
+                await updateUser();
+                return onSuccess({
+                    data: { user, wallet },
+                    hookOptions,
+                    options,
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with email and password', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const requestResetPassword = useCallback(async (options) => {
+        var _a;
+        try {
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            setStatus({
+                status: 'loading',
+            });
+            setRequiresEmailVerification(false);
+            await client.auth.requestResetPassword({
+                email: options.email,
+                redirectUrl: buildCallbackUrl({
+                    email: options.email,
+                    callbackUrl: (_a = options.emailVerificationRedirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.emailVerificationRedirectTo,
+                    provider: 'password',
+                    isOpen,
+                }),
+            });
+            setStatus({
+                status: 'success',
+            });
+            setRequiresEmailVerification(true);
+            return onSuccess({
+                data: { requiresEmailVerification: true },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to reset password', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const resetPassword = useCallback(async (options) => {
+        try {
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            setStatus({
+                status: 'loading',
+            });
+            setRequiresEmailVerification(false);
+            await client.auth.resetPassword({
+                password: options.password,
+                token: options.state,
+            });
+            setStatus({
+                status: 'success',
+            });
+            setRequiresEmailVerification(true);
+            return onSuccess({
+                data: { requiresEmailVerification: true },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to reset password', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const signUpEmail = useCallback(async (options) => {
+        var _a, _b, _c;
+        try {
+            if (!options.email || !options.password) {
+                const error = new OpenfortError('Email and password are required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            setStatus({
+                status: 'loading',
+            });
+            setRequiresEmailVerification(false);
+            const result = await client.auth.signUpWithEmailPassword({
+                email: options.email,
+                password: options.password,
+                callbackURL: buildCallbackUrl({
+                    email: options.email,
+                    callbackUrl: (_a = options.emailVerificationRedirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.emailVerificationRedirectTo,
+                    provider: 'email',
+                    isOpen,
+                }),
+                ...(options.name && { name: options.name }),
+            });
+            // API returns token when auth succeeds immediately; otherwise requires email verification
+            if ('token' in result && result.token != null) {
+                const { wallet } = await tryUseWallet({
+                    logoutOnError: (_b = options.logoutOnError) !== null && _b !== void 0 ? _b : hookOptions.logoutOnError,
+                    recoverWalletAutomatically: (_c = options.recoverWalletAutomatically) !== null && _c !== void 0 ? _c : hookOptions.recoverWalletAutomatically,
+                });
+                setStatus({
+                    status: 'success',
+                });
+                const user = result.user;
+                await updateUser(user);
+                return onSuccess({
+                    data: { user, wallet },
+                    hookOptions,
+                    options,
+                });
+            }
+            else {
+                setStatus({
+                    status: 'awaiting-input',
+                });
+                setRequiresEmailVerification(true);
+                return onSuccess({
+                    data: { requiresEmailVerification: true },
+                    hookOptions,
+                    options,
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with email and password', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions, isOpen]);
+    const linkEmail = useCallback(async (options) => {
+        var _a;
+        try {
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            await client.validateAndRefreshToken();
+            const authToken = await client.getAccessToken();
+            if (!authToken) {
+                logger.log('No token found');
+                const error = new OpenfortError('No token found', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            await client.auth.addEmail({
+                // name: options.name || '',
+                email: options.email,
+                // password: options.password,
+                // method: 'password',
+                callbackURL: buildCallbackUrl({
+                    callbackUrl: (_a = options.emailVerificationRedirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.emailVerificationRedirectTo,
+                    email: options.email,
+                    provider: 'email',
+                    isOpen,
+                }),
+            });
+            logger.log('Email linked successfully');
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to link email', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions, isOpen]);
+    const verifyEmail = useCallback(async (options) => {
+        setStatus({
+            status: 'loading',
+        });
+        try {
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            await client.auth.verifyEmail({
+                token: options.state,
+            });
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: {
+                    email: options.email,
+                },
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to verify email', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            logger.error('Error verifying email', e);
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, hookOptions]);
+    return {
+        signInEmail,
+        signUpEmail,
+        verifyEmail,
+        linkEmail,
+        requestResetPassword,
+        resetPassword,
+        reset,
+        ...mapStatus(status),
+        requiresEmailVerification,
+        isAwaitingInput: status.status === 'awaiting-input',
+    };
+};
+
+export { useEmailAuth };
+//# sourceMappingURL=useEmailAuth.js.map

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

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

package/build/hooks/openfort/auth/useEmailOtpAuth.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 EmailOtpAuthResult = {
     error?: OpenfortError;
     user?: User;
-    wallet?: UserWallet;
+    wallet?: EthereumUserWallet | SolanaUserWallet;
 };
 type LoginWithEmailOtpOptions = {
     email: string;

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

@@ -0,0 +1,151 @@
+import { useState, useCallback } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { isValidEmail } from '../../../utils/validation.js';
+import { onError, onSuccess } from '../hookConsistency.js';
+import { mapStatus } from './status.js';
+import { useConnectToWalletPostAuth } from './useConnectToWalletPostAuth.js';
+
+const useEmailOtpAuth = (hookOptions = {}) => {
+    const { client, updateUser } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const reset = useCallback(() => {
+        setStatus({
+            status: 'idle',
+        });
+    }, []);
+    const { tryUseWallet } = useConnectToWalletPostAuth();
+    const signInEmailOtp = useCallback(async (options) => {
+        var _a, _b;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.email || !options.otp) {
+                const error = new OpenfortError('Email and OTP are required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            const result = await client.auth.logInWithEmailOtp({
+                email: options.email,
+                otp: options.otp,
+            });
+            const { wallet } = await tryUseWallet({
+                logoutOnError: (_a = options.logoutOnError) !== null && _a !== void 0 ? _a : hookOptions.logoutOnError,
+                recoverWalletAutomatically: (_b = options.recoverWalletAutomatically) !== null && _b !== void 0 ? _b : hookOptions.recoverWalletAutomatically,
+            });
+            setStatus({
+                status: 'success',
+            });
+            const user = result.user;
+            await updateUser();
+            return onSuccess({
+                data: { user, wallet },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with email OTP', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const requestEmailOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'requesting',
+            });
+            if (!options.email) {
+                const error = new OpenfortError('Email is required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            if (!isValidEmail(options.email)) {
+                const error = new OpenfortError('Invalid email', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            await client.auth.requestEmailOtp({
+                email: options.email,
+            });
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to request email OTP', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    return {
+        signInEmailOtp,
+        requestEmailOtp,
+        reset,
+        isRequesting: status.status === 'requesting',
+        ...mapStatus(status),
+        isAwaitingInput: status.status === 'awaiting-input',
+    };
+};
+
+export { useEmailOtpAuth };
+//# sourceMappingURL=useEmailOtpAuth.js.map

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

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

package/build/hooks/openfort/auth/useGuestAuth.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 GuestHookResult = {
     error?: OpenfortError;
     user?: User;
-    wallet?: UserWallet;
+    wallet?: EthereumUserWallet | SolanaUserWallet;
 };
 type GuestHookOptions = OpenfortHookOptions<GuestHookResult> & CreateWalletPostAuthOptions;
 /**