@openfort/react-native 0.1.20 → 0.1.22

package/dist/hooks/wallet/useEmbeddedSolanaWallet.js

@@ -0,0 +1,455 @@
+import { AccountTypeEnum, ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+import { logger } from '../../lib/logger';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+import { OpenfortSolanaProvider } from './solanaProvider';
+import { buildRecoveryParams } from './utils';
+/**
+ * Hook for managing embedded Solana wallets.
+ *
+ * This hook provides comprehensive management of embedded Solana (SVM) wallets including
+ * creation, recovery, activation, and transaction signing. Returns a discriminated union
+ * state that enables type-safe wallet interactions based on connection status.
+ *
+ * **Note:** Solana wallets are always EOA (Externally Owned Accounts) and work across
+ * all Solana networks (mainnet, devnet, testnet).
+ *
+ * **Recovery Methods:**
+ * - Automatic recovery (via encryption session)
+ * - Password-based recovery
+ *
+ * @param options - Configuration options including:
+ *   - `onCreateSuccess` - Callback when wallet is created
+ *   - `onCreateError` - Callback when wallet creation fails
+ *   - `onSetActiveSuccess` - Callback when wallet is activated/recovered
+ *   - `onSetActiveError` - Callback when wallet activation fails
+ *
+ * @returns Discriminated union state based on `status` field:
+ *   - **'disconnected'**: No active wallet. Properties: `create`, `setActive`, `wallets`
+ *   - **'connecting'**: Activating wallet. Properties: same as disconnected
+ *   - **'reconnecting'**: Reconnecting to wallet. Properties: same as disconnected + `activeWallet`
+ *   - **'creating'**: Creating new wallet. Properties: same as disconnected
+ *   - **'needs-recovery'**: Recovery required. Properties: same as reconnecting
+ *   - **'connected'**: Wallet ready. Properties: all + `provider` (Solana wallet adapter)
+ *   - **'error'**: Operation failed. Properties: all + `error` message + optional `activeWallet`
+ *
+ * @example
+ * ```tsx
+ * import { useEmbeddedSolanaWallet } from '@openfort/react-native';
+ * import { Transaction } from '@solana/web3.js';
+ * import { ActivityIndicator } from 'react-native';
+ *
+ * function SolanaWalletComponent() {
+ *   const solana = useEmbeddedSolanaWallet({
+ *     onCreateSuccess: (account, provider) => {
+ *       console.log('Solana wallet created:', account.address);
+ *       console.log('Public key:', provider.publicKey);
+ *     },
+ *   });
+ *
+ *   // Handle loading states
+ *   if (solana.status === 'creating' || solana.status === 'connecting') {
+ *     return <ActivityIndicator />;
+ *   }
+ *
+ *   // Create first wallet
+ *   if (solana.status === 'disconnected' && solana.wallets.length === 0) {
+ *     return (
+ *       <Button
+ *         onPress={() => solana.create({ recoveryPassword: 'optional' })}
+ *         title="Create Solana Wallet"
+ *       />
+ *     );
+ *   }
+ *
+ *   // Activate existing wallet
+ *   if (solana.status === 'disconnected' && solana.wallets.length > 0) {
+ *     return (
+ *       <Button
+ *         onPress={() => solana.setActive({
+ *           address: solana.wallets[0].address,
+ *           recoveryPassword: 'optional'
+ *         })}
+ *         title="Connect Solana Wallet"
+ *       />
+ *     );
+ *   }
+ *
+ *   // Use connected wallet
+ *   if (solana.status === 'connected') {
+ *     const signTransaction = async () => {
+ *       const transaction = new Transaction();
+ *       // ... add instructions to transaction
+ *
+ *       const signed = await solana.provider.signTransaction(transaction);
+ *       console.log('Signed transaction:', signed);
+ *     };
+ *
+ *     const signMessage = async () => {
+ *       const message = 'Hello Solana!';
+ *       const signature = await solana.provider.signMessage(message);
+ *       console.log('Message signature:', signature);
+ *     };
+ *
+ *     return (
+ *       <View>
+ *         <Text>Connected: {solana.activeWallet.address}</Text>
+ *         <Button onPress={signTransaction} title="Sign Transaction" />
+ *         <Button onPress={signMessage} title="Sign Message" />
+ *       </View>
+ *     );
+ *   }
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export function useEmbeddedSolanaWallet(options = {}) {
+    const { client, walletConfig, embeddedState } = useOpenfortContext();
+    const [embeddedAccounts, setEmbeddedAccounts] = useState([]);
+    const [activeWalletId, setActiveWalletId] = useState(null);
+    const [activeAccount, setActiveAccount] = useState(null);
+    const [provider, setProvider] = useState(null);
+    const recoverPromiseRef = useRef(null);
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    // Fetch Solana embedded accounts
+    const fetchEmbeddedAccounts = useCallback(async () => {
+        if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
+            setEmbeddedAccounts([]);
+            return;
+        }
+        try {
+            const accounts = await client.embeddedWallet.list({
+                chainType: ChainTypeEnum.SVM,
+                accountType: AccountTypeEnum.EOA,
+                limit: 100,
+            });
+            setEmbeddedAccounts(accounts);
+        }
+        catch {
+            setEmbeddedAccounts([]);
+        }
+    }, [client, embeddedState]);
+    useEffect(() => {
+        fetchEmbeddedAccounts();
+    }, [fetchEmbeddedAccounts]);
+    // Sync active wallet ID and account with client
+    useEffect(() => {
+        ;
+        (async () => {
+            try {
+                const embeddedAccount = await client.embeddedWallet.get();
+                // here we check in case the current account is not SVM
+                if (embeddedAccount.chainType === ChainTypeEnum.SVM) {
+                    setActiveWalletId(embeddedAccount.id);
+                    setActiveAccount(embeddedAccount);
+                }
+                else {
+                    setActiveWalletId(null);
+                    setActiveAccount(null);
+                }
+            }
+            catch {
+                setActiveWalletId(null);
+                setActiveAccount(null);
+            }
+        })();
+    }, [client]);
+    // Get Solana provider
+    const getSolanaProvider = useCallback(async (account) => {
+        // Helper function to sign a single transaction
+        const signSingleTransaction = async (transaction) => {
+            // Extract the message bytes from the transaction
+            // For @solana/kit compiledTransaction, the messageBytes property contains what needs to be signed
+            let messageBytes;
+            if (transaction.messageBytes) {
+                // @solana/kit compiled transaction
+                messageBytes = transaction.messageBytes;
+            }
+            else if (transaction.serializeMessage) {
+                // @solana/web3.js Transaction
+                messageBytes = transaction.serializeMessage();
+            }
+            else if (transaction instanceof Uint8Array) {
+                // Raw bytes
+                messageBytes = transaction;
+            }
+            else {
+                throw new OpenfortError('Unsupported transaction format. Expected @solana/kit compiled transaction, @solana/web3.js Transaction, or Uint8Array', OpenfortErrorType.WALLET_ERROR);
+            }
+            // Convert Uint8Array to Buffer JSON format for React Native WebView serialization
+            // This is necessary because React Native's postMessage only accepts strings,
+            // and Uint8Array serializes incorrectly as {0:1, 1:2, ...} instead of {type:"Buffer", data:[...]}
+            const bufferFormatMessage = {
+                type: 'Buffer',
+                data: Array.from(messageBytes),
+            };
+            // Sign the message bytes (hashMessage: false for Solana - Ed25519 signs raw bytes)
+            // Note: We cast to any because the iframe will deserialize the Buffer format correctly,
+            // but TypeScript doesn't know about this serialization detail
+            const signatureBase58 = await client.embeddedWallet.signMessage(bufferFormatMessage, {
+                hashMessage: false,
+            });
+            // Return the signature in the expected format
+            // Different libraries expect different return formats, so we return a flexible object
+            return {
+                signature: signatureBase58,
+                publicKey: account.address,
+            };
+        };
+        const provider = new OpenfortSolanaProvider({
+            account,
+            signTransaction: signSingleTransaction,
+            signAllTransactions: async (transactions) => {
+                // Sign each transaction sequentially
+                const signedTransactions = [];
+                for (const transaction of transactions) {
+                    const signed = await signSingleTransaction(transaction);
+                    signedTransactions.push(signed);
+                }
+                return signedTransactions;
+            },
+            signMessage: async (message) => {
+                // Sign message using openfort-js (with hashMessage: false for Solana)
+                const result = await client.embeddedWallet.signMessage(message, { hashMessage: false });
+                return result;
+            },
+        });
+        return provider;
+    }, [client.embeddedWallet]);
+    // Initialize provider when recovering an active wallet on mount
+    useEffect(() => {
+        // Only initialize if we have an account but no provider
+        if (!activeAccount || provider) {
+            return;
+        }
+        // Don't interfere with user-initiated actions
+        if (['creating', 'connecting', 'reconnecting', 'loading'].includes(status.status)) {
+            return;
+        }
+        // Only initialize if embedded state is ready
+        if (embeddedState !== EmbeddedState.READY) {
+            return;
+        }
+        ;
+        (async () => {
+            try {
+                logger.info('Initializing provider for recovered Solana wallet session');
+                setStatus({ status: 'connecting' });
+                const solProvider = await getSolanaProvider(activeAccount);
+                setProvider(solProvider);
+                setStatus({ status: 'success' });
+            }
+            catch (e) {
+                const error = e instanceof OpenfortError
+                    ? e
+                    : new OpenfortError('Failed to initialize provider for active Solana wallet', OpenfortErrorType.WALLET_ERROR, { error: e });
+                logger.error('Solana provider initialization failed', error);
+                setStatus({ status: 'error', error });
+            }
+        })();
+    }, [activeAccount, provider, embeddedState, status.status, getSolanaProvider]);
+    // Build wallets list (simple deduplication by address)
+    const wallets = useMemo(() => {
+        return embeddedAccounts.map((account, index) => ({
+            address: account.address,
+            chainType: ChainTypeEnum.SVM,
+            walletIndex: index,
+            getProvider: async () => await getSolanaProvider(account),
+        }));
+    }, [embeddedAccounts, getSolanaProvider]);
+    // Create wallet action
+    const create = useCallback(async (createOptions) => {
+        logger.info('Creating Solana wallet with options', createOptions);
+        try {
+            setStatus({ status: 'creating' });
+            // Build recovery params (only use recoveryPassword, ignore createAdditional)
+            const recoveryParams = await buildRecoveryParams(createOptions?.recoveryPassword ? { recoveryPassword: createOptions.recoveryPassword } : undefined, walletConfig);
+            // Create embedded wallet
+            const embeddedAccount = await client.embeddedWallet.create({
+                chainType: ChainTypeEnum.SVM,
+                recoveryParams,
+                accountType: AccountTypeEnum.EOA, // Solana wallets are EOA
+            });
+            logger.info('Embedded Solana wallet created');
+            // Get provider
+            const solProvider = await getSolanaProvider(embeddedAccount);
+            setProvider(solProvider);
+            // Refresh accounts and set as active
+            await fetchEmbeddedAccounts();
+            setActiveWalletId(embeddedAccount.id);
+            setActiveAccount(embeddedAccount);
+            setStatus({ status: 'success' });
+            onSuccess({
+                options: createOptions,
+                data: {
+                    account: embeddedAccount,
+                    provider: solProvider,
+                },
+            });
+            if (createOptions?.onSuccess) {
+                createOptions.onSuccess({ account: embeddedAccount, provider: solProvider });
+            }
+            if (options.onCreateSuccess) {
+                options.onCreateSuccess(embeddedAccount, solProvider);
+            }
+            return embeddedAccount;
+        }
+        catch (e) {
+            const error = e instanceof OpenfortError
+                ? e
+                : new OpenfortError('Failed to create Solana wallet', OpenfortErrorType.WALLET_ERROR, { error: e });
+            setStatus({ status: 'error', error });
+            onError({
+                options: createOptions,
+                error,
+            });
+            if (createOptions?.onError) {
+                createOptions.onError(error);
+            }
+            if (options.onCreateError) {
+                options.onCreateError(error);
+            }
+            throw error;
+        }
+    }, [client, walletConfig, options, getSolanaProvider, fetchEmbeddedAccounts]);
+    // Set active wallet action
+    const setActive = useCallback(async (setActiveOptions) => {
+        // Prevent concurrent recoveries
+        if (recoverPromiseRef.current) {
+            await recoverPromiseRef.current;
+            return;
+        }
+        if (wallets.length === 0) {
+            const error = new OpenfortError('No embedded Solana wallets available to set as active', OpenfortErrorType.WALLET_ERROR);
+            onError({
+                options: setActiveOptions,
+                error,
+            });
+            if (setActiveOptions.onError) {
+                setActiveOptions.onError(error);
+            }
+            if (options.onSetActiveError) {
+                options.onSetActiveError(error);
+            }
+            throw error;
+        }
+        setStatus({ status: 'connecting' });
+        recoverPromiseRef.current = (async () => {
+            try {
+                // Find account to recover by address only
+                const embeddedAccountToRecover = embeddedAccounts.find((account) => account.address.toLowerCase() === setActiveOptions.address.toLowerCase());
+                if (!embeddedAccountToRecover) {
+                    throw new OpenfortError(`No embedded Solana account found for address ${setActiveOptions.address}`, OpenfortErrorType.WALLET_ERROR);
+                }
+                // Build recovery params
+                const recoveryParams = await buildRecoveryParams(setActiveOptions, walletConfig);
+                // Recover the embedded wallet
+                const embeddedAccount = await client.embeddedWallet.recover({
+                    account: embeddedAccountToRecover.id,
+                    recoveryParams,
+                });
+                // Get provider
+                const solProvider = await getSolanaProvider(embeddedAccount);
+                setProvider(solProvider);
+                // Find the wallet index in the accounts list
+                const walletIndex = embeddedAccounts.findIndex((acc) => acc.address.toLowerCase() === embeddedAccount.address.toLowerCase());
+                const wallet = {
+                    address: embeddedAccount.address,
+                    chainType: ChainTypeEnum.SVM,
+                    walletIndex: walletIndex >= 0 ? walletIndex : 0,
+                    getProvider: async () => solProvider,
+                };
+                recoverPromiseRef.current = null;
+                setStatus({ status: 'success' });
+                setActiveWalletId(embeddedAccount.id);
+                setActiveAccount(embeddedAccount);
+                onSuccess({
+                    options: setActiveOptions,
+                    data: {
+                        wallet,
+                        provider: solProvider,
+                    },
+                });
+                if (setActiveOptions.onSuccess) {
+                    setActiveOptions.onSuccess({ wallet, provider: solProvider });
+                }
+                if (options.onSetActiveSuccess) {
+                    options.onSetActiveSuccess(wallet, solProvider);
+                }
+                return { wallet, provider: solProvider };
+            }
+            catch (e) {
+                recoverPromiseRef.current = null;
+                const error = e instanceof OpenfortError
+                    ? e
+                    : new OpenfortError('Failed to set active Solana wallet', OpenfortErrorType.WALLET_ERROR);
+                setStatus({ status: 'error', error });
+                onError({
+                    options: setActiveOptions,
+                    error,
+                });
+                if (setActiveOptions.onError) {
+                    setActiveOptions.onError(error);
+                }
+                if (options.onSetActiveError) {
+                    options.onSetActiveError(error);
+                }
+                throw error;
+            }
+        })();
+        await recoverPromiseRef.current;
+    }, [client, walletConfig, embeddedAccounts, options, wallets.length, getSolanaProvider]);
+    // Build active wallet from embeddedWallet.get()
+    const activeWallet = useMemo(() => {
+        if (!activeWalletId || !activeAccount)
+            return null;
+        // Find the wallet index in the accounts list
+        const accountIndex = embeddedAccounts.findIndex((acc) => acc.id === activeWalletId);
+        return {
+            address: activeAccount.address,
+            chainType: ChainTypeEnum.SVM,
+            walletIndex: accountIndex >= 0 ? accountIndex : 0,
+            getProvider: async () => await getSolanaProvider(activeAccount),
+        };
+    }, [activeWalletId, activeAccount, embeddedAccounts, getSolanaProvider]);
+    // Build discriminated union state
+    const state = useMemo(() => {
+        const baseActions = {
+            create,
+            wallets,
+            setActive,
+        };
+        // Priority 1: Explicit action states (user-initiated operations)
+        if (status.status === 'creating') {
+            return { ...baseActions, status: 'creating', activeWallet: null };
+        }
+        if (status.status === 'connecting' || status.status === 'reconnecting' || status.status === 'loading') {
+            return { ...baseActions, status: 'connecting' };
+        }
+        if (status.status === 'error') {
+            return { ...baseActions, status: 'error', activeWallet, error: status.error?.message || 'Unknown error' };
+        }
+        // Priority 2: Check authentication state from context
+        if (embeddedState !== EmbeddedState.READY && embeddedState !== EmbeddedState.CREATING_ACCOUNT) {
+            // Not authenticated or no embedded wallet capability
+            return { ...baseActions, status: 'disconnected', activeWallet: null };
+        }
+        // Priority 3: Data-driven connection state
+        if (activeWallet && provider) {
+            // Fully connected - have both wallet and provider
+            return { ...baseActions, status: 'connected', activeWallet, provider };
+        }
+        if (activeAccount && !provider) {
+            // Have wallet but provider not initialized yet (mount recovery in progress)
+            return { ...baseActions, status: 'connecting' };
+        }
+        // Default: disconnected (authenticated but no wallet selected)
+        return { ...baseActions, status: 'disconnected', activeWallet: null };
+    }, [status, activeWallet, activeAccount, provider, wallets, embeddedState, create, setActive]);
+    return state;
+}

package/dist/hooks/wallet/utils.js

@@ -0,0 +1,75 @@
+import { RecoveryMethod } from '@openfort/openfort-js';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+/**
+ * Resolves an encryption session from wallet configuration.
+ *
+ * This utility handles encryption session resolution for automatic wallet recovery.
+ * It supports both callback-based session retrieval and endpoint-based session creation.
+ *
+ * @param walletConfig - The embedded wallet configuration from the provider
+ * @returns A promise that resolves to the encryption session string
+ * @throws {OpenfortError} When wallet config is missing or session cannot be retrieved
+ *
+ * @internal
+ */
+async function resolveEncryptionSession(walletConfig) {
+    if (!walletConfig) {
+        throw new OpenfortError('Encryption session configuration is required', OpenfortErrorType.WALLET_ERROR);
+    }
+    // Try callback-based session retrieval first
+    if (walletConfig.getEncryptionSession) {
+        return await walletConfig.getEncryptionSession();
+    }
+    // Try endpoint-based session creation
+    if (walletConfig.createEncryptedSessionEndpoint) {
+        try {
+            const response = await fetch(walletConfig.createEncryptedSessionEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new OpenfortError('Failed to create encryption session', OpenfortErrorType.WALLET_ERROR, {
+                    status: response.status,
+                });
+            }
+            const body = (await response.json());
+            if (!body?.session || typeof body.session !== 'string') {
+                throw new OpenfortError('Encryption session response is missing the `session` property', OpenfortErrorType.WALLET_ERROR);
+            }
+            return body.session;
+        }
+        catch (error) {
+            if (error instanceof OpenfortError) {
+                throw error;
+            }
+            throw new OpenfortError('Failed to create encryption session', OpenfortErrorType.WALLET_ERROR, { error });
+        }
+    }
+    throw new OpenfortError('Encryption session configuration is required', OpenfortErrorType.WALLET_ERROR);
+}
+/**
+ * Builds recovery parameters from options and wallet configuration.
+ *
+ * This utility constructs the appropriate RecoveryParams object based on whether
+ * a recovery password is provided or automatic recovery should be used.
+ *
+ * @param options - Options containing optional recovery password
+ * @param walletConfig - The embedded wallet configuration from the provider
+ * @returns A promise that resolves to RecoveryParams for the SDK
+ *
+ * @internal
+ */
+export async function buildRecoveryParams(options, walletConfig) {
+    if (options?.recoveryPassword) {
+        return {
+            recoveryMethod: RecoveryMethod.PASSWORD,
+            password: options.recoveryPassword,
+        };
+    }
+    return {
+        recoveryMethod: RecoveryMethod.AUTOMATIC,
+        encryptionSession: await resolveEncryptionSession(walletConfig),
+    };
+}

package/dist/lib/hookConsistency.js

@@ -5,6 +5,9 @@
  * ensuring consistent callback execution across all hooks in the SDK.
  *
  * @param params - Object containing hook options and success data
+ * @param params.hookOptions - Primary hook options (from the hook itself)
+ * @param params.options - Secondary hook options (from the action call)
+ * @param params.data - The success data to pass to callbacks
  * @returns The success data that was passed in
  *
  * @example
@@ -29,6 +32,9 @@ export const onSuccess = ({ hookOptions, options, data, }) => {
  * and optionally throws the error if throwOnError is configured.
  *
  * @param params - Object containing hook options and error information
+ * @param params.hookOptions - Primary hook options (from the hook itself)
+ * @param params.options - Secondary hook options (from the action call)
+ * @param params.error - The error that occurred during the operation
  * @returns Object containing the error, or throws if throwOnError is enabled
  *
  * @example

package/dist/native/oauth.js

@@ -6,6 +6,11 @@ import { Platform } from 'react-native';
 import { logger } from '../lib/logger';
 /**
  * Opens an OAuth authentication session
+ *
+ * @param config - OAuth session configuration
+ * @param config.url - OAuth provider URL to open
+ * @param config.redirectUri - Redirect URI for OAuth flow callback
+ * @returns Promise resolving to OAuth result indicating success, cancellation, or error
  */
 export async function openOAuthSession(config) {
     try {
@@ -38,6 +43,12 @@ export async function openOAuthSession(config) {
 }
 /**
  * Handles Apple Sign-In authentication for iOS
+ *
+ * @param options - Options for Apple authentication
+ * @param options.state - State parameter for the OAuth flow
+ * @param options.isLogin - Whether this is a login or link operation (affects error codes)
+ * @returns Promise resolving to Apple authentication result with authorization code and user info
+ * @throws {Error} When not running on iOS platform or authentication fails
  */
 export async function authenticateWithApple(options) {
     if (Platform.OS !== 'ios') {
@@ -77,6 +88,8 @@ export async function authenticateWithApple(options) {
 }
 /**
  * Checks if Apple Sign-In is available on the current device
+ *
+ * @returns Promise resolving to true if Apple Sign-In is available, false otherwise
  */
 export async function isAppleSignInAvailable() {
     if (Platform.OS !== 'ios') {

package/dist/native/storage.js

@@ -160,12 +160,16 @@ function normalizeKey(key) {
 export const NativeStorageUtils = {
     /**
      * Checks if secure storage is available on the current platform.
+     *
+     * @returns True if the platform is iOS or Android, false otherwise
      */
     isAvailable() {
         return Platform.OS === 'ios' || Platform.OS === 'android';
     },
     /**
      * Gets the platform-specific storage options.
+     *
+     * @returns Secure store options with keychain accessibility configuration
      */
     getStorageOptions() {
         return {

package/dist/native/webview.js

@@ -9,6 +9,8 @@ import { handleSecureStorageMessage, isSecureStorageMessage } from './storage';
  * WebView component for embedded wallet integration
  * Handles secure communication between React Native and the embedded wallet WebView
  * This component is hidden and only used for wallet communication
+ *
+ * @param props - Component props, see {@link EmbeddedWalletWebViewProps}
  */
 export const EmbeddedWalletWebView = ({ client, isClientReady, onProxyStatusChange, }) => {
     const webViewRef = useRef(null);
@@ -42,7 +44,7 @@ export const EmbeddedWalletWebView = ({ client, isClientReady, onProxyStatusChan
     // Set up WebView reference with client immediately when both are available
     useEffect(() => {
         if (webViewRef.current) {
-            // Simple message poster that uses WebView's postMessage directly
+            // Message poster with Uint8Array preprocessing for React Native
             const messagePoster = {
                 postMessage: (message) => {
                     webViewRef.current?.postMessage(message);
@@ -97,12 +99,16 @@ export const EmbeddedWalletWebView = ({ client, isClientReady, onProxyStatusChan
 export const WebViewUtils = {
     /**
      * Checks if WebView is supported on the current platform
+     *
+     * @returns True if the platform is iOS or Android, false otherwise
      */
     isSupported() {
         return Platform.OS === 'ios' || Platform.OS === 'android';
     },
     /**
      * Gets platform-specific WebView configuration
+     *
+     * @returns Platform-specific WebView configuration object
      */
     getPlatformConfig() {
         if (Platform.OS === 'ios') {
@@ -123,6 +129,9 @@ export const WebViewUtils = {
     },
     /**
      * Creates a secure message for WebView communication
+     *
+     * @param data - Data to include in the message
+     * @returns JSON-stringified message with timestamp and platform information
      */
     createSecureMessage(data) {
         return JSON.stringify({
@@ -133,6 +142,9 @@ export const WebViewUtils = {
     },
     /**
      * Validates a message received from WebView
+     *
+     * @param message - JSON string message to validate
+     * @returns Validation result with parsed data or error information
      */
     validateMessage(message) {
         try {
@@ -152,6 +164,8 @@ export const WebViewUtils = {
     },
     /**
      * Gets WebView user agent for the current platform
+     *
+     * @returns User agent string including platform and version information
      */
     getUserAgent() {
         const baseAgent = 'OpenfortEmbeddedWallet/1.0';

package/dist/types/components/AuthBoundary.d.ts

@@ -31,6 +31,7 @@ export interface AuthBoundaryProps {
  * 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';

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

@@ -1,6 +1,6 @@
 export type { SDKOverrides } from '@openfort/openfort-js';
 export { RecoveryMethod } from '@openfort/openfort-js';
-export { createOpenfortClient, getDefaultClient, setDefaultClient } from './client';
+export { createOpenfortClient } from './client';
 export type { OpenfortContextValue } from './context';
 export { isOpenfortContextValue, OpenfortContext, useOpenfortContext, useOpenfortContextSafe } from './context';
 export type { CommonEmbeddedWalletConfiguration, EmbeddedWalletConfiguration, EncryptionSession, OpenfortProviderProps, } from './provider';