@openfort/react-native 0.1.25 → 1.0.0

package/README.md

@@ -0,0 +1,20 @@
+<div align="center">
+  <h4>
+    <a href="https://www.openfort.io/">
+      Website
+    </a>
+    <span> | </span>
+    <a href="https://www.openfort.io/docs/products/embedded-wallet/react-native/">
+      Documentation
+    </a>
+    <span> | </span>
+    <a href="https://x.com/openfort_hq">
+      X
+    </a>
+  </h4>
+</div>
+
+# Openfort React Native SDK
+
+Quickstart sample:
+https://github.com/openfort-xyz/react-native-auth-sample

package/dist/hooks/auth/index.js

@@ -5,10 +5,12 @@
  */
 // Email authentication
 export { useEmailAuth } from './useEmailAuth';
+export { useEmailAuthOtp } from './useEmailAuthOtp';
 // Guest accounts
 export { useGuestAuth } from './useGuestAuth';
 // OAuth authentication
 export { useOAuth } from './useOAuth';
+export { usePhoneAuthOtp } from './usePhoneAuthOtp';
 export { useSignOut } from './useSignOut';
 // Wallet-based authentication (SIWE)
 export { useWalletAuth } from './useWalletAuth';

package/dist/hooks/auth/useEmailAuth.js

@@ -76,7 +76,7 @@ export const useEmailAuth = (hookOptions = {}) => {
             else {
                 // Login successful
                 setPasswordState({ status: 'done' });
-                const user = result.player;
+                const user = result.user;
                 // Refresh user state in provider
                 await _internal.refreshUserState(user);
                 return onSuccess({
@@ -106,6 +106,7 @@ export const useEmailAuth = (hookOptions = {}) => {
             const result = await client.auth.signUpWithEmailPassword({
                 email: options.email,
                 password: options.password,
+                callbackURL: options.emailVerificationRedirectTo || createOAuthRedirectUri(),
                 ...(options.name && { name: options.name }),
             });
             // Check if action is required (email verification)
@@ -123,7 +124,7 @@ export const useEmailAuth = (hookOptions = {}) => {
             else {
                 // Signup successful
                 setPasswordState({ status: 'done' });
-                const user = result.player;
+                const user = result.user;
                 // Refresh user state in provider
                 await _internal.refreshUserState(user);
                 return onSuccess({
@@ -146,59 +147,61 @@ export const useEmailAuth = (hookOptions = {}) => {
             });
         }
     }, [client, setPasswordState, _internal, hookOptions]);
-    const linkEmail = useCallback(async (options) => {
-        try {
-            setPasswordState({ status: 'sending-verification-code' });
-            // Get current user access token
-            const accessToken = await client.getAccessToken();
-            if (!accessToken) {
-                throw new Error('User must be authenticated to link email');
-            }
-            // Link email account
-            const result = await client.auth.linkEmailPassword({
-                email: options.email,
-                password: options.password,
-                authToken: accessToken,
-            });
-            // Check if action is required (email verification)
-            if ('action' in result) {
-                setPasswordState({
-                    status: 'awaiting-code-input',
-                });
-                // Return undefined as email verification is required
-                return onSuccess({
-                    hookOptions,
-                    options,
-                    data: { requiresEmailVerification: true },
-                });
-            }
-            else {
-                // Link successful
-                setPasswordState({ status: 'done' });
-                // Refresh user state to reflect email linking
-                await _internal.refreshUserState();
-                return onSuccess({
-                    hookOptions,
-                    options,
-                    data: { user: result },
-                });
-            }
-        }
-        catch (e) {
-            const error = new OpenfortError('Failed to link email and password', OpenfortErrorType.AUTHENTICATION_ERROR, {
-                error: e,
-            });
-            setPasswordState({
-                status: 'error',
-                error,
-            });
-            return onError({
-                hookOptions,
-                options,
-                error,
-            });
-        }
-    }, [client, setPasswordState, _internal, hookOptions]);
+    // TODO: Auth V2
+    // const linkEmail = useCallback(
+    //   async (options: LinkEmailOptions): Promise<EmailAuthResult> => {
+    //     try {
+    //       setPasswordState({ status: 'sending-verification-code' })
+    //       // Get current user access token
+    //       const accessToken = await client.getAccessToken()
+    //       if (!accessToken) {
+    //         throw new Error('User must be authenticated to link email')
+    //       }
+    //       // Link email account
+    //       const result = await client.auth.linkEmailPassword({
+    //         email: options.email,
+    //         password: options.password,
+    //         authToken: accessToken,
+    //       })
+    //       // Check if action is required (email verification)
+    //       if ('action' in result) {
+    //         setPasswordState({
+    //           status: 'awaiting-code-input',
+    //         })
+    //         // Return undefined as email verification is required
+    //         return onSuccess({
+    //           hookOptions,
+    //           options,
+    //           data: { requiresEmailVerification: true },
+    //         })
+    //       } else {
+    //         // Link successful
+    //         setPasswordState({ status: 'done' })
+    //         // Refresh user state to reflect email linking
+    //         await _internal.refreshUserState()
+    //         return onSuccess({
+    //           hookOptions,
+    //           options,
+    //           data: { user: result },
+    //         })
+    //       }
+    //     } catch (e) {
+    //       const error = new OpenfortError('Failed to link email and password', OpenfortErrorType.AUTHENTICATION_ERROR, {
+    //         error: e,
+    //       })
+    //       setPasswordState({
+    //         status: 'error',
+    //         error,
+    //       })
+    //       return onError({
+    //         hookOptions,
+    //         options,
+    //         error,
+    //       })
+    //     }
+    //   },
+    //   [client, setPasswordState, _internal, hookOptions]
+    // )
     const requestResetPassword = useCallback(async (options) => {
         try {
             setPasswordState({ status: 'sending-verification-code' });
@@ -234,9 +237,8 @@ export const useEmailAuth = (hookOptions = {}) => {
             setPasswordState({ status: 'submitting-code' });
             // Reset password with new password and state token
             await client.auth.resetPassword({
-                email: options.email,
                 password: options.password,
-                state: options.state,
+                token: options.token,
             });
             setPasswordState({ status: 'done' });
             return onSuccess({
@@ -265,14 +267,13 @@ export const useEmailAuth = (hookOptions = {}) => {
             setPasswordState({ status: 'submitting-code' });
             // Verify email with state token
             await client.auth.verifyEmail({
-                email: options.email,
-                state: options.state,
+                token: options.token,
             });
             setPasswordState({ status: 'done' });
             return onSuccess({
                 hookOptions,
                 options,
-                data: { email: options.email },
+                data: {},
             });
         }
         catch (e) {
@@ -295,7 +296,7 @@ export const useEmailAuth = (hookOptions = {}) => {
         signInEmail,
         signUpEmail,
         verifyEmail,
-        linkEmail,
+        linkEmail: () => { },
         requestResetPassword,
         resetPassword,
         reset,

package/dist/hooks/auth/useEmailAuthOtp.js

@@ -0,0 +1,111 @@
+import { useCallback, useState } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+import { mapStatus } from '../../types/baseFlowState';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+export const useEmailAuthOtp = (hookOptions = {}) => {
+    const { client, _internal } = useOpenfortContext();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const signInEmailOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.email || !options.otp) {
+                const error = new OpenfortError('Email and OTP are required', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            const result = await client.auth.logInWithEmailOtp({
+                email: options.email,
+                otp: options.otp,
+            });
+            setStatus({
+                status: 'success',
+            });
+            const user = result.user;
+            await _internal.refreshUserState(user);
+            return onSuccess({
+                data: { user },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with email OTP', OpenfortErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error: error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: error,
+            });
+        }
+    }, [client, setStatus, _internal, hookOptions]);
+    const requestEmailOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.email) {
+                const error = new OpenfortError('Email is required', OpenfortErrorType.AUTHENTICATION_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', OpenfortErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error: error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: error,
+            });
+        }
+    }, [client, setStatus, hookOptions]);
+    const reset = () => {
+        setStatus({ status: 'idle' });
+    };
+    return {
+        requestEmailOtp,
+        signInEmailOtp,
+        reset,
+        ...mapStatus(status),
+    };
+};

package/dist/hooks/auth/useGuestAuth.js

@@ -47,7 +47,7 @@ export const useGuestAuth = (hookOptions = {}) => {
                 status: 'loading',
             });
             const result = await client.auth.signUpGuest();
-            const user = result.player;
+            const user = result.user;
             await updateUser(user);
             // const { wallet } = await tryUseWallet({
             //   logoutOnError: options.logoutOnError || hookOptions.logoutOnError,

package/dist/hooks/auth/useOAuth.js

@@ -50,29 +50,29 @@ export const useOAuth = (hookOptions = {}) => {
             const redirectUri = options.redirectTo || createOAuthRedirectUri('/oauth/callback');
             const result = await client.auth.initOAuth({
                 provider: options.provider,
+                redirectTo: redirectUri,
                 options: {
                     skipBrowserRedirect: true,
-                    redirectTo: redirectUri,
                 },
             });
             // Handle OAuth flow using native utilities
             setOAuthState({ status: 'awaiting-redirect' });
             // Check if we should use native Apple authentication
-            if (options.provider === 'apple' && !options.isLegacyAppleIosBehaviorEnabled) {
+            if (options.provider === 'apple') {
                 const isAppleAvailable = await isAppleSignInAvailable();
                 if (isAppleAvailable) {
                     try {
                         const appleResult = await authenticateWithApple({
-                            state: result.key || '',
+                            state: result || '',
                             isLogin: true,
                         });
                         // Complete OAuth flow with Apple credentials
-                        const authResult = await client.auth.loginWithIdToken({
+                        const authResult = await client.auth.logInWithIdToken({
                             provider: OAuthProvider.APPLE,
                             token: appleResult.identityToken,
                         });
                         setOAuthState({ status: 'done' });
-                        const user = authResult.player;
+                        const user = authResult.user;
                         // Refresh user state in provider
                         await _internal.refreshUserState(user);
                         return onSuccess({
@@ -98,7 +98,7 @@ export const useOAuth = (hookOptions = {}) => {
                 }
             }
             // For other providers, use web-based OAuth
-            const providerUrl = OAuthUtils.getProviderUrl(options.provider, result.url);
+            const providerUrl = OAuthUtils.getProviderUrl(options.provider, result);
             const oauthResult = await OAuthUtils.withTimeout(openOAuthSession({
                 url: providerUrl,
                 redirectUri,
@@ -106,14 +106,13 @@ export const useOAuth = (hookOptions = {}) => {
             );
             if (oauthResult.type === 'success' && oauthResult.url) {
                 // Parse OAuth response from redirect URL
-                const { access_token, refresh_token, player_id, error, errorDescription } = parseOAuthUrl(oauthResult.url);
-                if (error) {
+                const { access_token, user_id, error, errorDescription } = parseOAuthUrl(oauthResult.url);
+                if (error || !user_id) {
                     throw new Error(errorDescription || error);
                 }
                 await client.auth.storeCredentials({
-                    player: player_id,
-                    accessToken: access_token,
-                    refreshToken: refresh_token,
+                    userId: user_id,
+                    token: access_token,
                 });
                 setOAuthState({ status: 'done' });
                 const user = await client.user.get();
@@ -177,30 +176,30 @@ export const useOAuth = (hookOptions = {}) => {
             const redirectUri = options.redirectTo || createOAuthRedirectUri('/oauth/callback');
             const result = await client.auth.initLinkOAuth({
                 provider: options.provider,
-                authToken: accessToken,
+                // authToken: accessToken,
+                redirectTo: redirectUri,
                 options: {
                     skipBrowserRedirect: true,
-                    redirectTo: redirectUri,
                 },
             });
             // Handle OAuth linking flow using native utilities
             setOAuthState({ status: 'awaiting-redirect' });
             // Check if we should use native Apple authentication for linking
-            if (options.provider === 'apple' && !options.isLegacyAppleIosBehaviorEnabled) {
+            if (options.provider === 'apple') {
                 const isAppleAvailable = await isAppleSignInAvailable();
                 if (isAppleAvailable) {
                     try {
                         const appleResult = await authenticateWithApple({
-                            state: result.key || '',
+                            state: result || '',
                             isLogin: false, // This is a linking operation
                         });
                         // Complete OAuth linking flow with Apple credentials
-                        const linkResult = await client.auth.loginWithIdToken({
+                        const linkResult = await client.auth.logInWithIdToken({
                             provider: OAuthProvider.APPLE,
                             token: appleResult.identityToken,
                         });
                         setOAuthState({ status: 'done' });
-                        const user = linkResult.player;
+                        const user = linkResult.user;
                         // Refresh user state to reflect OAuth linking
                         await _internal.refreshUserState();
                         return onSuccess({
@@ -226,7 +225,7 @@ export const useOAuth = (hookOptions = {}) => {
                 }
             }
             // For other providers, use web-based OAuth
-            const providerUrl = OAuthUtils.getProviderUrl(options.provider, result.url);
+            const providerUrl = OAuthUtils.getProviderUrl(options.provider, result);
             const oauthResult = await OAuthUtils.withTimeout(openOAuthSession({
                 url: providerUrl,
                 redirectUri,
@@ -234,14 +233,13 @@ export const useOAuth = (hookOptions = {}) => {
             );
             if (oauthResult.type === 'success' && oauthResult.url) {
                 // Parse OAuth response from redirect URL
-                const { access_token, refresh_token, player_id, error, errorDescription } = parseOAuthUrl(oauthResult.url);
-                if (error) {
+                const { access_token, user_id, error, errorDescription } = parseOAuthUrl(oauthResult.url);
+                if (error || !user_id) {
                     throw new Error(errorDescription || error);
                 }
                 await client.auth.storeCredentials({
-                    player: player_id,
-                    accessToken: access_token,
-                    refreshToken: refresh_token,
+                    userId: user_id,
+                    token: access_token,
                 });
                 setOAuthState({ status: 'done' });
                 const user = await client.user.get();
@@ -291,11 +289,9 @@ export const useOAuth = (hookOptions = {}) => {
             });
         }
     }, [client, setOAuthState, _internal]);
-    const storeCredentials = () => { }; // TODO
     return {
         initOAuth,
         linkOauth,
-        storeCredentials,
         ...mapOAuthStatus(oAuthState),
     };
 };

package/dist/hooks/auth/usePhoneAuthOtp.js

@@ -0,0 +1,111 @@
+import { useCallback, useState } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+import { mapStatus } from '../../types/baseFlowState';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+export const usePhoneAuthOtp = (hookOptions = {}) => {
+    const { client, _internal } = useOpenfortContext();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const signInPhoneOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.phone || !options.otp) {
+                const error = new OpenfortError('Phone and OTP are required', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            const result = await client.auth.logInWithPhoneOtp({
+                phoneNumber: options.phone,
+                otp: options.otp,
+            });
+            setStatus({
+                status: 'success',
+            });
+            const user = result.user;
+            await _internal.refreshUserState(user);
+            return onSuccess({
+                data: { user },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with phone OTP', OpenfortErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error: error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: error,
+            });
+        }
+    }, [client, setStatus, _internal, hookOptions]);
+    const requestPhoneOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.phone) {
+                const error = new OpenfortError('Phone is required', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            await client.auth.requestPhoneOtp({
+                phoneNumber: options.phone,
+            });
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to request phone OTP', OpenfortErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error: error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: error,
+            });
+        }
+    }, [client, setStatus, hookOptions]);
+    const reset = () => {
+        setStatus({ status: 'idle' });
+    };
+    return {
+        requestPhoneOtp,
+        signInPhoneOtp,
+        reset,
+        ...mapStatus(status),
+    };
+};

package/dist/hooks/auth/useSignOut.js

@@ -55,7 +55,7 @@ export function useSignOut(hookOptions = {}) {
         setStatus({ status: 'loading' });
         try {
             await client.auth.logout();
-            await internalRef.current.refreshUserState(null);
+            await internalRef.current.refreshUserState(undefined);
             setStatus({ status: 'success' });
             return onSuccess({
                 hookOptions: hookOptionsRef.current,

package/dist/hooks/auth/useWalletAuth.js

@@ -112,9 +112,10 @@ export function useWalletAuth(hookOptions) {
                 message: message,
                 walletClientType: 'unknown',
                 connectorType: 'unknown',
+                address: opts.walletAddress,
             });
             setSiweState({ status: 'done' });
-            const user = result.player;
+            const user = result.user;
             // Refresh user state to reflect SIWE linking
             await _internal.refreshUserState();
             return onSuccess({
@@ -150,9 +151,10 @@ export function useWalletAuth(hookOptions) {
                 message: message,
                 walletClientType: 'unknown',
                 connectorType: 'unknown',
+                address: opts.walletAddress,
             });
             setSiweState({ status: 'done' });
-            const user = result.player;
+            const user = result.user;
             // Refresh user state in provider
             await _internal.refreshUserState(user);
             return onSuccess({

package/dist/hooks/wallet/useEmbeddedEthereumWallet.js

@@ -106,12 +106,16 @@ export function useEmbeddedEthereumWallet(options = {}) {
         status: 'idle',
     });
     // Fetch Ethereum embedded accounts
-    const fetchEmbeddedAccounts = useCallback(async () => {
+    const fetchEmbeddedAccounts = useCallback(async (options) => {
         if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
             setEmbeddedAccounts([]);
             return;
         }
         try {
+            // Only set fetching status if not called silently (e.g., during create/setActive)
+            if (!options?.silent) {
+                setStatus({ status: 'fetching-wallets' });
+            }
             const accounts = await client.embeddedWallet.list({
                 limit: 100,
                 chainType: ChainTypeEnum.EVM,
@@ -119,9 +123,15 @@ export function useEmbeddedEthereumWallet(options = {}) {
             });
             // Filter for Ethereum accounts only
             setEmbeddedAccounts(accounts);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
         catch {
             setEmbeddedAccounts([]);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
     }, [client, embeddedState, walletConfig]);
     useEffect(() => {
@@ -263,8 +273,8 @@ export function useEmbeddedEthereumWallet(options = {}) {
             // Get provider
             const ethProvider = await getEthereumProvider();
             setProvider(ethProvider);
-            // Refresh accounts and set as active
-            await fetchEmbeddedAccounts();
+            // Refresh accounts silently (don't override 'creating' status) and set as active
+            await fetchEmbeddedAccounts({ silent: true });
             setActiveWalletId(embeddedAccount.id);
             setActiveAccount(embeddedAccount);
             setStatus({ status: 'success' });
@@ -476,6 +486,9 @@ export function useEmbeddedEthereumWallet(options = {}) {
             exportPrivateKey: client.embeddedWallet.exportPrivateKey,
         };
         // Priority 1: Explicit action states (user-initiated operations)
+        if (status.status === 'fetching-wallets') {
+            return { ...baseActions, status: 'fetching-wallets', activeWallet: null };
+        }
         if (status.status === 'creating') {
             return { ...baseActions, status: 'creating', activeWallet: null };
         }

package/dist/hooks/wallet/useEmbeddedSolanaWallet.js

@@ -117,21 +117,31 @@ export function useEmbeddedSolanaWallet(options = {}) {
         status: 'idle',
     });
     // Fetch Solana embedded accounts
-    const fetchEmbeddedAccounts = useCallback(async () => {
+    const fetchEmbeddedAccounts = useCallback(async (options) => {
         if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
             setEmbeddedAccounts([]);
             return;
         }
         try {
+            // Only set fetching status if not called silently (e.g., during create/setActive)
+            if (!options?.silent) {
+                setStatus({ status: 'fetching-wallets' });
+            }
             const accounts = await client.embeddedWallet.list({
                 chainType: ChainTypeEnum.SVM,
                 accountType: AccountTypeEnum.EOA,
                 limit: 100,
             });
             setEmbeddedAccounts(accounts);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
         catch {
             setEmbeddedAccounts([]);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
     }, [client, embeddedState]);
     useEffect(() => {
@@ -280,8 +290,8 @@ export function useEmbeddedSolanaWallet(options = {}) {
             // Get provider
             const solProvider = await getSolanaProvider(embeddedAccount);
             setProvider(solProvider);
-            // Refresh accounts and set as active
-            await fetchEmbeddedAccounts();
+            // Refresh accounts silently (don't override 'creating' status) and set as active
+            await fetchEmbeddedAccounts({ silent: true });
             setActiveWalletId(embeddedAccount.id);
             setActiveAccount(embeddedAccount);
             setStatus({ status: 'success' });
@@ -426,6 +436,9 @@ export function useEmbeddedSolanaWallet(options = {}) {
             setActive,
         };
         // Priority 1: Explicit action states (user-initiated operations)
+        if (status.status === 'fetching-wallets') {
+            return { ...baseActions, status: 'fetching-wallets', activeWallet: null };
+        }
         if (status.status === 'creating') {
             return { ...baseActions, status: 'creating', activeWallet: null };
         }

package/dist/native/oauth.js

@@ -129,8 +129,7 @@ export function parseOAuthUrl(url) {
         logger.info('Parsed OAuth URL', queryParams);
         return {
             access_token: queryParams?.access_token,
-            refresh_token: queryParams?.refresh_token,
-            player_id: queryParams?.player_id,
+            user_id: queryParams?.user_id,
             error: queryParams?.error,
             errorDescription: queryParams?.error_description,
         };

package/dist/types/core/context.d.ts

@@ -9,7 +9,7 @@ export interface OpenfortContextValue {
     /** The Openfort client instance. */
     client: OpenfortClient;
     /** The current authenticated user, or null when unauthenticated. */
-    user: import('@openfort/openfort-js').AuthPlayerResponse | null;
+    user: import('@openfort/openfort-js').User | null;
     /** Whether the SDK has initialized and is ready for use. */
     isReady: boolean;
     /** Any error encountered during SDK initialization. */
@@ -38,7 +38,7 @@ export interface OpenfortContextValue {
     getAccessToken: () => Promise<string | null>;
     /** @internal Refreshes user state after authentication changes. */
     _internal: {
-        refreshUserState: (user?: import('@openfort/openfort-js').AuthPlayerResponse | null) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | null>;
+        refreshUserState: (user?: import('@openfort/openfort-js').User) => Promise<import('@openfort/openfort-js').AuthResponse | null>;
     };
 }
 /**

package/dist/types/hooks/auth/index.d.ts

@@ -5,10 +5,14 @@
  */
 export type { EmailAuthResult, EmailVerificationResult, LinkEmailOptions, RequestResetPasswordOptions, ResetPasswordOptions, SignInEmailOptions, SignUpEmailOptions, UseEmailHookOptions, VerifyEmailOptions, } from './useEmailAuth';
 export { useEmailAuth } from './useEmailAuth';
+export type { EmailOtpAuthResult, LoginWithEmailOtpOptions, RequestEmailOtpOptions, UseEmailOtpHookOptions, } from './useEmailAuthOtp';
+export { useEmailAuthOtp } from './useEmailAuthOtp';
 export type { GuestHookOptions, GuestHookResult } from './useGuestAuth';
 export { useGuestAuth } from './useGuestAuth';
 export type { AuthHookOptions, InitializeOAuthOptions, InitOAuthReturnType, StoreCredentialsResult, } from './useOAuth';
 export { useOAuth } from './useOAuth';
+export type { LoginWithPhoneOtpOptions, PhoneOtpAuthResult, RequestPhoneOtpOptions, UsePhoneOtpHookOptions, } from './usePhoneAuthOtp';
+export { usePhoneAuthOtp } from './usePhoneAuthOtp';
 export { useSignOut } from './useSignOut';
 export type { WalletHookOptions, WalletHookResult } from './useWalletAuth';
 export { useWalletAuth } from './useWalletAuth';

package/dist/types/hooks/auth/useEmailAuth.d.ts

@@ -1,4 +1,4 @@
-import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import type { User as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
 export type EmailAuthResult = {
@@ -22,9 +22,8 @@ export type RequestResetPasswordOptions = {
     emailVerificationRedirectTo?: string;
 } & OpenfortHookOptions<EmailAuthResult>;
 export type ResetPasswordOptions = {
-    email: string;
     password: string;
-    state: string;
+    token: string;
 } & OpenfortHookOptions<EmailAuthResult>;
 export type LinkEmailOptions = {
     email: string;
@@ -32,8 +31,7 @@ export type LinkEmailOptions = {
     emailVerificationRedirectTo?: string;
 } & OpenfortHookOptions<EmailAuthResult>;
 export type VerifyEmailOptions = {
-    email: string;
-    state: string;
+    token: string;
 } & OpenfortHookOptions<EmailVerificationResult>;
 export type EmailVerificationResult = {
     email?: string;
@@ -90,7 +88,7 @@ export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
     signInEmail: (options: SignInEmailOptions) => Promise<EmailAuthResult>;
     signUpEmail: (options: SignUpEmailOptions) => Promise<EmailAuthResult>;
     verifyEmail: (options: VerifyEmailOptions) => Promise<EmailVerificationResult>;
-    linkEmail: (options: LinkEmailOptions) => Promise<EmailAuthResult>;
+    linkEmail: () => void;
     requestResetPassword: (options: RequestResetPasswordOptions) => Promise<EmailAuthResult>;
     resetPassword: (options: ResetPasswordOptions) => Promise<EmailAuthResult>;
     reset: () => void;

package/dist/types/hooks/auth/useEmailAuthOtp.d.ts

@@ -0,0 +1,24 @@
+import type { User } from '@openfort/openfort-js';
+import type { OpenfortHookOptions } from '../../types/hookOption';
+import { OpenfortError } from '../../types/openfortError';
+export type EmailOtpAuthResult = {
+    error?: OpenfortError;
+    user?: User;
+};
+export type LoginWithEmailOtpOptions = {
+    email: string;
+    otp: string;
+} & OpenfortHookOptions<EmailOtpAuthResult>;
+export type RequestEmailOtpOptions = {
+    email: string;
+} & OpenfortHookOptions<EmailOtpAuthResult>;
+export type UseEmailOtpHookOptions = OpenfortHookOptions<EmailOtpAuthResult>;
+export declare const useEmailAuthOtp: (hookOptions?: UseEmailOtpHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+    requestEmailOtp: (options: RequestEmailOtpOptions) => Promise<EmailOtpAuthResult>;
+    signInEmailOtp: (options: LoginWithEmailOtpOptions) => Promise<EmailOtpAuthResult>;
+    reset: () => void;
+};

package/dist/types/hooks/auth/useGuestAuth.d.ts

@@ -1,4 +1,4 @@
-import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import type { User as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
 export type GuestHookResult = {

package/dist/types/hooks/auth/useOAuth.d.ts

@@ -1,10 +1,9 @@
-import { OAuthProvider, type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OAuthProvider, type User as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
 export type InitializeOAuthOptions = {
     provider: OAuthProvider;
     redirectTo?: string;
-    isLegacyAppleIosBehaviorEnabled?: boolean;
 } & OpenfortHookOptions<InitOAuthReturnType>;
 export type StoreCredentialsResult = {
     user?: OpenfortUser;
@@ -60,5 +59,4 @@ export declare const useOAuth: (hookOptions?: AuthHookOptions) => {
     error: Error | null | undefined;
     initOAuth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
     linkOauth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
-    storeCredentials: () => void;
 };

package/dist/types/hooks/auth/usePhoneAuthOtp.d.ts

@@ -0,0 +1,24 @@
+import type { User } from '@openfort/openfort-js';
+import type { OpenfortHookOptions } from '../../types/hookOption';
+import { OpenfortError } from '../../types/openfortError';
+export type PhoneOtpAuthResult = {
+    error?: OpenfortError;
+    user?: User;
+};
+export type LoginWithPhoneOtpOptions = {
+    phone: string;
+    otp: string;
+} & OpenfortHookOptions<PhoneOtpAuthResult>;
+export type RequestPhoneOtpOptions = {
+    phone: string;
+} & OpenfortHookOptions<PhoneOtpAuthResult>;
+export type UsePhoneOtpHookOptions = OpenfortHookOptions<PhoneOtpAuthResult>;
+export declare const usePhoneAuthOtp: (hookOptions?: UsePhoneOtpHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+    requestPhoneOtp: (options: RequestPhoneOtpOptions) => Promise<PhoneOtpAuthResult>;
+    signInPhoneOtp: (options: LoginWithPhoneOtpOptions) => Promise<PhoneOtpAuthResult>;
+    reset: () => void;
+};

package/dist/types/hooks/auth/useWalletAuth.d.ts

@@ -1,4 +1,4 @@
-import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import type { User as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
 export type WalletHookResult = {

package/dist/types/hooks/core/useUser.d.ts

@@ -27,7 +27,7 @@
  * ```
  */
 export declare function useUser(): {
-    user: import("@openfort/openfort-js").AuthPlayerResponse | null;
+    user: import("@openfort/openfort-js").User | null;
     isAuthenticated: boolean;
     getAccessToken: () => Promise<string | null>;
 };

package/dist/types/index.d.ts

@@ -7,7 +7,7 @@
  * required to integrate Openfort authentication and embedded wallets into React Native and
  * Expo applications.
  */
-export { AccountTypeEnum, AuthInitPayload, AuthPlayerResponse, AuthResponse, ChainTypeEnum, EmbeddedAccount, EmbeddedState, OAuthProvider, Openfort as OpenfortClient, OpenfortConfiguration, OpenfortError, OpenfortEventMap, OpenfortEvents, openfortEvents, Provider, RecoveryMethod, RecoveryParams, ShieldConfiguration, SignedMessagePayload, } from '@openfort/openfort-js';
+export { AccountTypeEnum, AuthInitPayload, AuthResponse, ChainTypeEnum, EmbeddedAccount, EmbeddedState, OAuthProvider, Openfort as OpenfortClient, OpenfortConfiguration, OpenfortError, OpenfortEventMap, OpenfortEvents, openfortEvents, Provider, RecoveryMethod, RecoveryParams, ShieldConfiguration, SignedMessagePayload, } from '@openfort/openfort-js';
 export * from './components';
 export * from './constants';
 export * from './core';

package/dist/types/native/oauth.d.ts

@@ -79,7 +79,7 @@ export declare function isAppleSignInAvailable(): Promise<boolean>;
 export declare function parseOAuthUrl(url: string): {
     access_token?: string;
     refresh_token?: string;
-    player_id?: string;
+    user_id?: string;
     error?: string;
     errorDescription?: string;
 };

package/dist/types/types/auth.d.ts

@@ -1,4 +1,4 @@
-import type { OpenfortError, AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import type { OpenfortError, AuthResponse as OpenfortUser } from '@openfort/openfort-js';
 /**
  * Password authentication flow state
  */

package/dist/types/types/oauth.d.ts

@@ -32,5 +32,5 @@ export type LinkWithOAuthInput = {
  */
 export interface UseLoginWithOAuth {
     state: OAuthFlowState;
-    login: (input: LoginWithOAuthInput) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | undefined>;
+    login: (input: LoginWithOAuthInput) => Promise<import('@openfort/openfort-js').AuthResponse | undefined>;
 }

package/dist/types/types/wallet.d.ts

@@ -266,6 +266,9 @@ export interface SolanaWalletActions {
 export type EmbeddedEthereumWalletState = (EthereumWalletActions & {
     status: 'disconnected';
     activeWallet: null;
+}) | (EthereumWalletActions & {
+    status: 'fetching-wallets';
+    activeWallet: null;
 }) | (EthereumWalletActions & {
     status: 'connecting';
     activeWallet: ConnectedEmbeddedEthereumWallet;
@@ -293,6 +296,9 @@ export type EmbeddedEthereumWalletState = (EthereumWalletActions & {
 export type EmbeddedSolanaWalletState = (SolanaWalletActions & {
     status: 'disconnected';
     activeWallet: null;
+}) | (SolanaWalletActions & {
+    status: 'fetching-wallets';
+    activeWallet: null;
 }) | (SolanaWalletActions & {
     status: 'connecting';
 }) | (SolanaWalletActions & {

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.1.25",
+  "version": "1.0.0",
   "license": "MIT",
   "description": "React Native SDK for Openfort platform integration",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openfort-xyz/react-native.git"
+  },
+  "homepage": "https://github.com/openfort-xyz/react-native#readme",
+  "bugs": {
+    "url": "https://github.com/openfort-xyz/react-native/issues"
+  },
   "types": "dist/types/index.d.ts",
   "files": [
     "dist"
@@ -16,7 +24,7 @@
     }
   },
   "dependencies": {
-    "@openfort/openfort-js": "^0.10.39"
+    "@openfort/openfort-js": "^1.0.0"
   },
   "peerDependencies": {
     "expo-apple-authentication": "*",
@@ -33,6 +41,7 @@
     "@biomejs/biome": "^2.2.4",
     "@changesets/changelog-github": "^0.5.1",
     "@changesets/cli": "^2.29.7",
+    "@size-limit/preset-small-lib": "^11.2.0",
     "@types/react": "~18.3.12",
     "buffer": "^5.4.3",
     "expo-apple-authentication": "^7.2.4",
@@ -45,60 +54,32 @@
     "react": "^18.3.1",
     "react-native": "0.77.1",
     "react-native-webview": "^13.15.0",
+    "size-limit": "^11.2.0",
     "typedoc": "^0.28.14",
     "typescript": "^5.9.3"
   },
   "knip": {
+    "entry": [
+      "src/index.ts!"
+    ],
     "ignore": [
       ".github/**",
       ".husky/**",
-      ".parcel-cache/**",
-      "**/.next/**",
       "**/dist/**",
-      "**/stats.html",
-      "sdk/copyVersion.cjs",
-      "sdk/scripts/**",
-      "test/**",
-      "**/next-env.d.ts",
-      "**/vite-env.d.ts"
+      "test/**"
     ],
     "ignoreDependencies": [
       "buffer"
     ],
-    "jest": {
-      "entry": [
-        "**/*.{test,spec}.{js,ts,tsx}"
-      ]
-    },
-    "workspaces": {
-      ".": {
-        "entry": [
-          "typedoc.json!"
-        ]
-      },
-      "sdk": {
-        "entry": [
-          "src/index.ts!"
-        ],
-        "ignore": [
-          "version.ts"
-        ],
-        "ignoreDependencies": [
-          "axios-retry"
-        ]
-      },
-      "packages/internal/openapi-clients": {
-        "entry": [
-          "src/backend-api-clients.ts!",
-          "src/backend/index.ts!"
-        ],
-        "ignore": [
-          "src/backend-openapi.json"
-        ]
-      }
-    }
+    "ignoreExportsUsedInFile": true
   },
   "private": false,
+  "size-limit": [
+    {
+      "path": "dist/index.js",
+      "limit": "250 KB"
+    }
+  ],
   "scripts": {
     "build": "tsc",
     "check": "biome check",
@@ -111,6 +92,8 @@
     "lint": "tsc -b && biome lint .",
     "link": "pnpm link",
     "unlink": "pnpm unlink",
-    "docs:build": "typedoc"
+    "docs:build": "typedoc",
+    "size": "size-limit",
+    "size:check": "size-limit --ci"
   }
 }