@openfort/react-native 0.1.20 → 0.1.22

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

@@ -39,13 +39,22 @@ function startEmbeddedStatePolling(client, onChange, intervalMs = 1000) {
     };
 }
 /**
- * Provider component that initialises the Openfort SDK and exposes its state via {@link OpenfortContext}
+ * Root provider component that initializes the Openfort SDK and makes it available throughout your app.
  *
- * This component must wrap your React Native app to provide Openfort functionality to all child components.
- * It initializes the SDK with the provided configuration and manages authentication state.
+ * This component must wrap your React Native application to enable Openfort functionality.
+ * It initializes the SDK, manages authentication state, handles embedded wallet connections,
+ * and provides context to all child components through {@link OpenfortContext}.
  *
- * @param props - Provider configuration including the publishable key and optional overrides
- * @returns A React element that provides the Openfort context to its children
+ * **Key Features:**
+ * - Initializes Openfort client with platform-specific configuration
+ * - Manages user authentication state and session persistence
+ * - Polls embedded wallet state for real-time status updates
+ * - Provides hidden WebView for embedded wallet communication
+ * - Supports multiple blockchain networks via supportedChains
+ * - Integrates Shield for secure embedded wallet management
+ *
+ * @param props - Provider configuration, see {@link OpenfortProviderProps}
+ * @returns React element that provides Openfort context to all children
  *
  * @example
  * ```tsx
@@ -59,7 +68,12 @@ function startEmbeddedStatePolling(client, onChange, intervalMs = 1000) {
  *       supportedChains={[polygon, polygonMumbai]}
  *       walletConfig={{
  *         shieldPublishableKey: "shield_pk_...",
- *         getEncryptionSession: () => fetchEncryptionSession(),
+ *         getEncryptionSession: async () => {
+ *           // Fetch session from your backend
+ *           const response = await fetch('/api/encryption-session');
+ *           return response.text();
+ *         },
+ *         recoveryMethod: 'automatic',
  *       }}
  *       verbose={true}
  *     >
@@ -227,7 +241,6 @@ export const OpenfortProvider = ({ children, publishableKey, supportedChains, wa
         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 {
@@ -14,12 +15,23 @@ const mapStatus = (status) => {
 /**
  * Hook for email and password authentication.
  *
- * This hook provides email/password authentication flows including sign-in, sign-up, and
- * account linking. Password reset and verification helpers are exposed but currently stubbed
- * (TODOs) until the SDK wiring is complete.
+ * This hook provides comprehensive email/password authentication flows including sign-in,
+ * sign-up, account linking, password reset, and email verification functionality.
  *
- * @param hookOptions - Optional configuration with callback functions and email verification settings.
- * @returns Email authentication state and methods with flow status indicators.
+ * @param hookOptions - Optional configuration with callback functions and email verification settings
+ * @returns Email authentication state and methods with flow status indicators including:
+ *   - `signInEmail` - Sign in with email and password
+ *   - `signUpEmail` - Create new account with email and password
+ *   - `linkEmail` - Link email/password to existing authenticated account
+ *   - `requestResetPassword` - Request password reset email
+ *   - `resetPassword` - Complete password reset with token from email
+ *   - `verifyEmail` - Verify email address with verification code
+ *   - `reset` - Reset flow state to initial
+ *   - `isLoading` - Whether an operation is in progress
+ *   - `isError` - Whether the last operation failed
+ *   - `isSuccess` - Whether the last operation succeeded
+ *   - `requiresEmailVerification` - Whether email verification is pending
+ *   - `error` - Error from the last failed operation
  *
  * @example
  * ```tsx
@@ -28,12 +40,14 @@ const mapStatus = (status) => {
  *   onError: ({ error }) => console.error('Email auth failed:', error?.message),
  * });
  *
+ * // Sign up a new user
  * await signUpEmail({ email: 'user@example.com', password: 'securePassword123' });
  *
  * if (requiresEmailVerification) {
  *   console.log('Check email for verification code');
  * }
  *
+ * // Sign in existing user
  * await signInEmail({ email: 'user@example.com', password: 'securePassword123' });
  * ```
  */
@@ -185,9 +199,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/auth/useGuestAuth.js

@@ -4,24 +4,34 @@ import { onError, onSuccess } from '../../lib/hookConsistency';
 import { mapStatus } from '../../types/baseFlowState';
 import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
 /**
- * Hook for creating guest accounts.
+ * Hook for guest account authentication.
  *
- * Guest accounts allow users to access certain features without full authentication and can later be upgraded to full accounts
- * by linking additional authentication methods.
+ * This hook provides functionality for creating anonymous guest accounts that allow
+ * users to access features without full authentication. Guest accounts can later be
+ * upgraded to permanent accounts by linking email, OAuth, or wallet authentication.
  *
- * @param hookOptions - Configuration options including success and error callbacks.
- * @returns Current guest authentication helpers with flow status indicators.
+ * @param hookOptions - Configuration options including success and error callbacks
+ * @returns Guest authentication method and flow state including:
+ *   - `signUpGuest` - Create anonymous guest account
+ *   - `isLoading` - Whether guest account creation is in progress
+ *   - `isError` - Whether guest account creation failed
+ *   - `isSuccess` - Whether guest account was created successfully
+ *   - `error` - Error from the last failed operation
  *
  * @example
  * ```tsx
  * const { signUpGuest, isLoading } = useGuestAuth({
- *   onSuccess: ({ user }) => console.log('Guest account created:', user),
+ *   onSuccess: ({ user }) => console.log('Guest account created:', user?.id),
  *   onError: ({ error }) => console.error('Failed to create guest account:', error),
  * });
  *
+ * // Create guest account for anonymous access
  * if (!isLoading) {
  *   await signUpGuest();
  * }
+ *
+ * // Later, upgrade to permanent account by linking authentication
+ * // Use linkEmail, linkOauth, or linkSiwe from other hooks
  * ```
  */
 export const useGuestAuth = (hookOptions = {}) => {

package/dist/hooks/auth/useOAuth.js

@@ -8,15 +8,24 @@ import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
 /**
  * Hook for OAuth-based authentication with supported providers.
  *
- * This hook provides helpers for starting OAuth login flows (`initOAuth`) and linking
- * additional providers to an authenticated user (`linkOauth`). Some advanced flows may
- * require manual credential storage via `storeCredentials`, which is currently a TODO.
+ * This hook provides OAuth authentication flows including login and account linking
+ * for various OAuth providers (Google, Apple, Discord, Twitter, Facebook, etc.).
+ * Supports both web-based OAuth flows and native Apple Sign-In on iOS.
  *
- * @param hookOptions - Configuration options including success and error callbacks.
- * @returns OAuth helpers and derived flow state flags.
+ * @param hookOptions - Configuration options including success and error callbacks
+ * @returns OAuth authentication methods and flow state including:
+ *   - `initOAuth` - Start OAuth login flow for authentication
+ *   - `linkOauth` - Link additional OAuth provider to authenticated account
+ *   - `storeCredentials` - (Reserved for future use)
+ *   - `isLoading` - Whether OAuth flow is in progress
+ *   - `isError` - Whether the last OAuth flow failed
+ *   - `isSuccess` - Whether the last OAuth flow succeeded
+ *   - `error` - Error from the last failed OAuth operation
  *
  * @example
  * ```tsx
+ * import { OAuthProvider } from '@openfort/openfort-js';
+ *
  * const { initOAuth, linkOauth, isLoading, isError, error } = useOAuth({
  *   onSuccess: ({ user }) => console.log('OAuth completed for', user?.id),
  * });

package/dist/hooks/auth/useWalletAuth.js

@@ -16,28 +16,47 @@ const mapStatus = (status) => {
     };
 };
 /**
- * Hook for handling Sign-In With Ethereum (SIWE) flows.
+ * Hook for Sign-In With Ethereum (SIWE) authentication flows.
  *
- * This hook orchestrates SIWE message generation, signature submission, and state
- * tracking so that external wallets can either authenticate a user (`signInWithSiwe`)
- * or be linked to an existing account (`linkSiwe`).
+ * This hook provides SIWE authentication functionality allowing users to authenticate
+ * or link accounts using their external Ethereum wallets. It handles message generation,
+ * signature verification, and state management throughout the authentication flow.
  *
- * @param hookOptions - Optional callbacks for handling success or error events from the SIWE flows.
- * @returns SIWE helpers for generating messages, signing in, linking wallets, and inspecting flow status.
+ * @param hookOptions - Optional callbacks for handling success or error events from SIWE flows
+ * @returns SIWE authentication methods and flow state including:
+ *   - `generateSiweMessage` - Generate SIWE message for wallet to sign
+ *   - `signInWithSiwe` - Authenticate user with signed SIWE message
+ *   - `linkSiwe` - Link external wallet to existing authenticated account
+ *   - `isLoading` - Whether a SIWE operation is in progress
+ *   - `isError` - Whether the last SIWE operation failed
+ *   - `isSuccess` - Whether the last SIWE operation succeeded
+ *   - `isAwaitingSignature` - Whether waiting for user to sign message
+ *   - `isGeneratingMessage` - Whether generating SIWE message
+ *   - `isSubmittingSignature` - Whether submitting signature to server
+ *   - `error` - Error from the last failed operation
  *
  * @example
  * ```tsx
- * const { generateSiweMessage, signInWithSiwe, linkSiwe, isAwaitingSignature } = useWalletAuth({
- *   onSuccess: ({ user }) => console.log('SIWE flow completed for', user?.id),
+ * // Using with an external wallet like WalletConnect or MetaMask
+ * const { generateSiweMessage, signInWithSiwe, isAwaitingSignature } = useWalletAuth({
+ *   onSuccess: ({ user }) => console.log('SIWE authentication successful:', user?.id),
  * });
  *
+ * // Step 1: Generate SIWE message
  * const { message } = await generateSiweMessage({
  *   wallet: connectedWallet.address,
- *   from: { domain: 'app.openfort.io', uri: 'https://app.openfort.io' },
+ *   from: { domain: 'myapp.com', uri: 'https://myapp.com' },
  * });
  *
+ * // Step 2: Request signature from user's wallet
  * const signature = await connectedWallet.signMessage(message);
- * await signInWithSiwe({ walletAddress: connectedWallet.address, signature, messageOverride: message });
+ *
+ * // Step 3: Authenticate with signed message
+ * await signInWithSiwe({
+ *   walletAddress: connectedWallet.address,
+ *   signature,
+ *   messageOverride: message
+ * });
  * ```
  */
 export function useWalletAuth(hookOptions) {

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})`;
+    }
+}