@openfort/react-native 0.1.19 → 0.1.21

package/dist/components/AuthBoundary.js

@@ -1,3 +1,4 @@
+import { useUser } from '../hooks';
 import { useOpenfort } from '../hooks/core/useOpenfort';
 /**
  * Authentication boundary component that renders content based on authentication state.
@@ -9,6 +10,7 @@ import { useOpenfort } from '../hooks/core/useOpenfort';
  * 3. **Unauthenticated** – the user is not logged in.
  * 4. **Authenticated** – the user is logged in and the SDK is ready.
  *
+ * @param props - Component props, see {@link AuthBoundaryProps}
  * @example
  * ```tsx
  * import { AuthBoundary } from '@openfort/react-native';
@@ -59,7 +61,8 @@ import { useOpenfort } from '../hooks/core/useOpenfort';
  * ```
  */
 export const AuthBoundary = ({ loading, unauthenticated, error: errorComponent, children, }) => {
-    const { user, isReady, error } = useOpenfort();
+    const { isReady, error } = useOpenfort();
+    const { user } = useUser();
     // SDK encountered an error during initialization
     if (error && errorComponent) {
         if (typeof errorComponent === 'function') {

package/dist/core/index.js

@@ -1,7 +1,7 @@
 // Client creation and configuration
 // Re-export important types and enums from openfort-js
 export { RecoveryMethod } from '@openfort/openfort-js';
-export { createOpenfortClient, getDefaultClient, setDefaultClient } from './client';
+export { createOpenfortClient } from './client';
 // React context and hooks
 export { isOpenfortContextValue, OpenfortContext, useOpenfortContext, useOpenfortContextSafe } from './context';
 // Main provider component

package/dist/core/provider.js

@@ -69,7 +69,7 @@ function startEmbeddedStatePolling(client, onChange, intervalMs = 1000) {
  * }
  * ```
  */
-export const OpenfortProvider = ({ children, publishableKey, customAuth, supportedChains, walletConfig, overrides, thirdPartyAuth, verbose = false, }) => {
+export const OpenfortProvider = ({ children, publishableKey, supportedChains, walletConfig, overrides, thirdPartyAuth, verbose = false, }) => {
     // Validate environment variables before anything else
     validateEnvironment({
         publishableKey,
@@ -215,33 +215,10 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
             cancelled = true;
         };
     }, [client, isUserInitialized, handleUserChange, refreshUserState]);
-    // Custom auth state management
-    useEffect(() => {
-        if (customAuth?.enabled && isUserInitialized && isClientReady) {
-            ;
-            (async () => {
-                try {
-                    const { getCustomAccessToken, isLoading } = customAuth;
-                    if (isLoading)
-                        return;
-                    const customToken = await getCustomAccessToken();
-                    if (customToken) {
-                        // Custom auth sync implementation would go here
-                        // This would typically handle SIWE authentication with the custom token
-                        logger.debug('Custom token available for authentication sync');
-                    }
-                }
-                catch (err) {
-                    logger.error('Custom auth sync failed', err);
-                }
-            })();
-        }
-    }, [client, customAuth, isUserInitialized, isClientReady]);
     // Determine if SDK is ready
     const isReady = useMemo(() => {
-        const customAuthReady = !customAuth?.enabled || !customAuth.isLoading;
-        return isUserInitialized && isClientReady && customAuthReady;
-    }, [isUserInitialized, isClientReady, customAuth?.enabled, customAuth?.isLoading]);
+        return isUserInitialized && isClientReady;
+    }, [isUserInitialized, isClientReady]);
     // Context value
     const contextValue = useMemo(() => ({
         client,
@@ -250,7 +227,6 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
         error,
         supportedChains,
         walletConfig,
-        embeddedWallet: walletConfig,
         embeddedState,
         // Flow states
         passwordState,

package/dist/hooks/auth/useEmailAuth.js

@@ -1,6 +1,7 @@
 import { useCallback } from 'react';
 import { useOpenfortContext } from '../../core/context';
 import { onError, onSuccess } from '../../lib/hookConsistency';
+import { createOAuthRedirectUri } from '../../native/oauth';
 import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
 const mapStatus = (status) => {
     return {
@@ -185,9 +186,95 @@ export const useEmailAuth = (hookOptions = {}) => {
             });
         }
     }, [client, setPasswordState, _internal, hookOptions]);
-    const verifyEmail = () => { }; // TODO
-    const resetPassword = () => { }; // TODO
-    const requestResetPassword = () => { }; // TODO
+    const requestResetPassword = useCallback(async (options) => {
+        try {
+            setPasswordState({ status: 'sending-verification-code' });
+            // Request password reset email
+            await client.auth.requestResetPassword({
+                email: options.email,
+                redirectUrl: options.emailVerificationRedirectTo || createOAuthRedirectUri('/password/reset'),
+            });
+            setPasswordState({ status: 'awaiting-code-input' });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: { requiresEmailVerification: true },
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to request password reset', OpenfortErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setPasswordState({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setPasswordState, hookOptions]);
+    const resetPassword = useCallback(async (options) => {
+        try {
+            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,
+            });
+            setPasswordState({ status: 'done' });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: {},
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to reset password', OpenfortErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setPasswordState({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setPasswordState, hookOptions]);
+    const verifyEmail = useCallback(async (options) => {
+        try {
+            setPasswordState({ status: 'submitting-code' });
+            // Verify email with state token
+            await client.auth.verifyEmail({
+                email: options.email,
+                state: options.state,
+            });
+            setPasswordState({ status: 'done' });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: { email: options.email },
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to verify email', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setPasswordState({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setPasswordState, hookOptions]);
     const reset = () => {
         setPasswordState({ status: 'initial' });
     };

package/dist/hooks/core/useOpenfort.js

@@ -2,7 +2,7 @@ import { useOpenfortContext } from '../../core/context';
 /**
  * Hook that exposes the core state of the Openfort SDK.
  *
- * This hook provides access to the current authenticated user object, SDK initialization status, and core authentication methods.
+ * This hook provides access to the current SDK initialization status.
  *
  * @returns The Openfort SDK's core state and methods.
  *
@@ -12,7 +12,7 @@ import { useOpenfortContext } from '../../core/context';
  * import { useOpenfort } from '@openfort/react-native/hooks';
  *
  * export function HomeScreen() {
- *   const { user, isReady, error, logout } = useOpenfort();
+ *   const { isReady, error } = useOpenfort();
  *
  *   if (!isReady) {
  *     return <ActivityIndicator size="large" />;
@@ -22,26 +22,12 @@ import { useOpenfortContext } from '../../core/context';
  *     return <Text>{`Failed to initialise: ${error.message}`}</Text>;
  *   }
  *
- *   if (!user) {
- *     return <Text>Please sign in</Text>;
- *   }
- *
- *   return (
- *     <View>
- *       <Text>{`Welcome, ${user.id}`}</Text>
- *       <Button title="Log out" onPress={() => void logout()} />
- *     </View>
- *   );
- * }
  * ```
  */
 export function useOpenfort() {
-    const { user, isReady, error, logout, getAccessToken } = useOpenfortContext();
+    const { isReady, error } = useOpenfortContext();
     return {
-        user,
         isReady,
         error,
-        logout,
-        getAccessToken,
     };
 }

package/dist/hooks/wallet/index.js

@@ -3,5 +3,7 @@
  *
  * This module re-exports all wallet-related hooks for convenient importing.
  */
-// Embedded wallet hooks
-export { useWallets } from './useWallets';
+// Embedded Ethereum wallet hook
+export { useEmbeddedEthereumWallet } from './useEmbeddedEthereumWallet';
+// Embedded Solana wallet hook
+export { useEmbeddedSolanaWallet } from './useEmbeddedSolanaWallet';

package/dist/hooks/wallet/solanaProvider.js

@@ -0,0 +1,77 @@
+/**
+ * Embedded Solana wallet provider implementation for Openfort.
+ *
+ * This provider implements the request-based API pattern similar to EIP-1193
+ * but adapted for Solana operations.
+ */
+export class OpenfortSolanaProvider {
+    _account;
+    _signTransaction;
+    _signAllTransactions;
+    _signMessage;
+    /**
+     * Legacy API for reading the public key for this provider.
+     * @deprecated Use publicKey getter instead
+     */
+    _publicKey;
+    /**
+     * Creates a new OpenfortSolanaProvider instance
+     * @param params - Provider configuration
+     * @param params.account - The embedded account to use for this provider
+     * @param params.signTransaction - Function to sign a single transaction
+     * @param params.signAllTransactions - Function to sign multiple transactions
+     * @param params.signMessage - Function to sign a message
+     */
+    constructor(params) {
+        this._account = params.account;
+        this._publicKey = params.account.address;
+        this._signTransaction = params.signTransaction;
+        this._signAllTransactions = params.signAllTransactions;
+        this._signMessage = params.signMessage;
+    }
+    /**
+     * The public key of the wallet (Solana address)
+     */
+    get publicKey() {
+        return this._account.address;
+    }
+    async request(args) {
+        switch (args.method) {
+            case 'signMessage': {
+                // Convert message string to Uint8Array
+                const signature = await this._signMessage(args.params.message);
+                return { signature: signature };
+            }
+            case 'signTransaction': {
+                const signedTransaction = await this._signTransaction(args.params.transaction);
+                return { signedTransaction };
+            }
+            default:
+                throw new Error(`Unsupported method: ${args.method}`);
+        }
+    }
+    /**
+     * Sign a single transaction (direct method)
+     */
+    async signTransaction(transaction) {
+        return await this._signTransaction(transaction);
+    }
+    /**
+     * Sign multiple transactions (direct method)
+     */
+    async signAllTransactions(transactions) {
+        return await this._signAllTransactions(transactions);
+    }
+    /**
+     * Sign a message (direct method)
+     */
+    async signMessage(message) {
+        return await this._signMessage(message);
+    }
+    /**
+     * Pretty log output for when an instance of this class is `console.log`'d
+     */
+    toJSON() {
+        return `OpenfortSolanaProvider(${this.publicKey})`;
+    }
+}