@openfort/react-native 0.1.20 → 0.1.22

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

@@ -103,13 +103,22 @@ export interface OpenfortProviderProps {
     verbose?: boolean;
 }
 /**
- * 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
@@ -123,7 +132,12 @@ export interface OpenfortProviderProps {
  *       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}
  *     >

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

@@ -1,7 +1,6 @@
 import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
-import type { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
 export type EmailAuthResult = {
     error?: OpenfortError;
     user?: OpenfortUser;
@@ -11,13 +10,13 @@ export type SignInEmailOptions = {
     email: string;
     password: string;
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
+} & OpenfortHookOptions<EmailAuthResult>;
 export type SignUpEmailOptions = {
     email: string;
     password: string;
     name?: string;
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
+} & OpenfortHookOptions<EmailAuthResult>;
 export type RequestResetPasswordOptions = {
     email: string;
     emailVerificationRedirectTo?: string;
@@ -42,16 +41,27 @@ export type EmailVerificationResult = {
 };
 export type UseEmailHookOptions = {
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult | EmailVerificationResult> & CreateWalletPostAuthOptions;
+} & OpenfortHookOptions<EmailAuthResult | EmailVerificationResult>;
 /**
  * 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
@@ -60,12 +70,14 @@ export type UseEmailHookOptions = {
  *   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' });
  * ```
  */
@@ -77,9 +89,9 @@ export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
     error: Error | null;
     signInEmail: (options: SignInEmailOptions) => Promise<EmailAuthResult>;
     signUpEmail: (options: SignUpEmailOptions) => Promise<EmailAuthResult>;
-    verifyEmail: () => void;
+    verifyEmail: (options: VerifyEmailOptions) => Promise<EmailVerificationResult>;
     linkEmail: (options: LinkEmailOptions) => Promise<EmailAuthResult>;
-    requestResetPassword: () => void;
-    resetPassword: () => void;
+    requestResetPassword: (options: RequestResetPasswordOptions) => Promise<EmailAuthResult>;
+    resetPassword: (options: ResetPasswordOptions) => Promise<EmailAuthResult>;
     reset: () => void;
 };

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

@@ -1,31 +1,40 @@
 import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
-import type { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
 export type GuestHookResult = {
     error?: OpenfortError;
     user?: OpenfortUser;
 };
-export type GuestHookOptions = OpenfortHookOptions<GuestHookResult> & CreateWalletPostAuthOptions;
+export type GuestHookOptions = OpenfortHookOptions<GuestHookResult>;
 /**
- * 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 declare const useGuestAuth: (hookOptions?: GuestHookOptions) => {

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

@@ -1,7 +1,6 @@
 import { OAuthProvider, type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import type { OpenfortHookOptions } from '../../types/hookOption';
 import { OpenfortError } from '../../types/openfortError';
-import type { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
 export type InitializeOAuthOptions = {
     provider: OAuthProvider;
     redirectTo?: string;
@@ -17,19 +16,28 @@ export type InitOAuthReturnType = {
 };
 export type AuthHookOptions = {
     redirectTo?: string;
-} & OpenfortHookOptions<StoreCredentialsResult | InitOAuthReturnType> & CreateWalletPostAuthOptions;
+} & OpenfortHookOptions<StoreCredentialsResult | InitOAuthReturnType>;
 /**
  * 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/types/hooks/auth/useWalletAuth.d.ts

@@ -31,28 +31,47 @@ type GenerateSiweMessageResult = {
     message?: string;
 };
 /**
- * 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 declare function useWalletAuth(hookOptions?: WalletHookOptions): {

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

@@ -2,7 +2,7 @@ import type { UseOpenfort } from '../../types';
 /**
  * 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 type { UseOpenfort } from '../../types';
  * 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,17 +22,6 @@ import type { UseOpenfort } from '../../types';
  *     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 declare function useOpenfort(): UseOpenfort;

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

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

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

@@ -0,0 +1,75 @@
+import type { EmbeddedAccount } from '@openfort/openfort-js';
+import type { OpenfortEmbeddedSolanaWalletProvider } from '../../types/wallet';
+type SignMessageRequestArguments = {
+    method: 'signMessage';
+    params: {
+        message: string;
+    };
+};
+type SignTransactionRequestArguments<T = any> = {
+    method: 'signTransaction';
+    params: {
+        transaction: T;
+    };
+};
+/**
+ * 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 declare class OpenfortSolanaProvider implements OpenfortEmbeddedSolanaWalletProvider {
+    private _account;
+    private _signTransaction;
+    private _signAllTransactions;
+    private _signMessage;
+    /**
+     * Legacy API for reading the public key for this provider.
+     * @deprecated Use publicKey getter instead
+     */
+    readonly _publicKey: string;
+    /**
+     * 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: {
+        account: EmbeddedAccount;
+        signTransaction: (transaction: any) => Promise<any>;
+        signAllTransactions: (transactions: any[]) => Promise<any[]>;
+        signMessage: (message: string) => Promise<string>;
+    });
+    /**
+     * The public key of the wallet (Solana address)
+     */
+    get publicKey(): string;
+    /**
+     * Request-based API for wallet operations
+     */
+    request(args: SignMessageRequestArguments): Promise<{
+        signature: string;
+    }>;
+    request(args: SignTransactionRequestArguments): Promise<{
+        signedTransaction: any;
+    }>;
+    /**
+     * Sign a single transaction (direct method)
+     */
+    signTransaction(transaction: any): Promise<any>;
+    /**
+     * Sign multiple transactions (direct method)
+     */
+    signAllTransactions(transactions: any[]): Promise<any[]>;
+    /**
+     * Sign a message (direct method)
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Pretty log output for when an instance of this class is `console.log`'d
+     */
+    toJSON(): string;
+}
+export {};

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

@@ -0,0 +1,104 @@
+import { type EmbeddedAccount } from '@openfort/openfort-js';
+import { OpenfortError } from '../../types/openfortError';
+import type { ConnectedEmbeddedEthereumWallet, EmbeddedEthereumWalletState, OpenfortEmbeddedEthereumWalletProvider } from '../../types/wallet';
+type UseEmbeddedEthereumWalletOptions = {
+    chainId?: number;
+    onCreateSuccess?: (account: EmbeddedAccount, provider: OpenfortEmbeddedEthereumWalletProvider) => void;
+    onCreateError?: (error: OpenfortError) => void;
+    onSetActiveSuccess?: (wallet: ConnectedEmbeddedEthereumWallet, provider: OpenfortEmbeddedEthereumWalletProvider) => void;
+    onSetActiveError?: (error: OpenfortError) => void;
+    onSetRecoverySuccess?: () => void;
+    onSetRecoveryError?: (error: OpenfortError) => void;
+};
+/**
+ * Hook for managing embedded Ethereum wallets.
+ *
+ * This hook provides comprehensive management of embedded Ethereum wallets including creation,
+ * recovery, activation, and EIP-1193 provider access. Returns a discriminated union state that
+ * enables type-safe wallet interactions based on connection status.
+ *
+ * **Wallet Types Supported:**
+ * - Smart Contract Accounts (Account Abstraction)
+ * - EOA (Externally Owned Accounts)
+ *
+ * **Recovery Methods:**
+ * - Automatic recovery (via encryption session)
+ * - Password-based recovery
+ *
+ * @param options - Configuration options including:
+ *   - `chainId` - Default chain ID for wallet operations
+ *   - `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
+ *   - `onSetRecoverySuccess` - Callback when recovery method is updated
+ *   - `onSetRecoveryError` - Callback when recovery update fails
+ *
+ * @returns Discriminated union state based on `status` field:
+ *   - **'disconnected'**: No active wallet. Properties: `create`, `setActive`, `wallets`, `setRecovery`, `exportPrivateKey`
+ *   - **'connecting'**: Activating wallet. Properties: same as disconnected + `activeWallet`
+ *   - **'reconnecting'**: Reconnecting to wallet. Properties: same as connecting
+ *   - **'creating'**: Creating new wallet. Properties: same as disconnected
+ *   - **'needs-recovery'**: Recovery required. Properties: same as connecting
+ *   - **'connected'**: Wallet ready. Properties: all + `provider` (EIP-1193 provider)
+ *   - **'error'**: Operation failed. Properties: all + `error` message
+ *
+ * @example
+ * ```tsx
+ * import { useEmbeddedEthereumWallet } from '@openfort/react-native';
+ * import { ActivityIndicator } from 'react-native';
+ *
+ * function WalletComponent() {
+ *   const ethereum = useEmbeddedEthereumWallet({
+ *     chainId: 137, // Polygon
+ *     onCreateSuccess: (account, provider) => {
+ *       console.log('Wallet created:', account.address);
+ *     },
+ *   });
+ *
+ *   // Handle loading states
+ *   if (ethereum.status === 'creating' || ethereum.status === 'connecting') {
+ *     return <ActivityIndicator />;
+ *   }
+ *
+ *   // Create first wallet
+ *   if (ethereum.status === 'disconnected' && ethereum.wallets.length === 0) {
+ *     return <Button onPress={() => ethereum.create()} title="Create Wallet" />;
+ *   }
+ *
+ *   // Activate existing wallet
+ *   if (ethereum.status === 'disconnected' && ethereum.wallets.length > 0) {
+ *     return (
+ *       <Button
+ *         onPress={() => ethereum.setActive({
+ *           address: ethereum.wallets[0].address,
+ *           recoveryPassword: 'optional-password'
+ *         })}
+ *         title="Connect Wallet"
+ *       />
+ *     );
+ *   }
+ *
+ *   // Use connected wallet
+ *   if (ethereum.status === 'connected') {
+ *     const sendTransaction = async () => {
+ *       const tx = await ethereum.provider.request({
+ *         method: 'eth_sendTransaction',
+ *         params: [{
+ *           from: ethereum.activeWallet.address,
+ *           to: '0x...',
+ *           value: '0x0'
+ *         }]
+ *       });
+ *       console.log('Transaction hash:', tx);
+ *     };
+ *
+ *     return <Button onPress={sendTransaction} title="Send Transaction" />;
+ *   }
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export declare function useEmbeddedEthereumWallet(options?: UseEmbeddedEthereumWalletOptions): EmbeddedEthereumWalletState;
+export {};

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

@@ -0,0 +1,111 @@
+import { type EmbeddedAccount } from '@openfort/openfort-js';
+import { OpenfortError } from '../../types/openfortError';
+import type { ConnectedEmbeddedSolanaWallet, EmbeddedSolanaWalletState, OpenfortEmbeddedSolanaWalletProvider } from '../../types/wallet';
+type UseEmbeddedSolanaWalletOptions = {
+    onCreateSuccess?: (account: EmbeddedAccount, provider: OpenfortEmbeddedSolanaWalletProvider) => void;
+    onCreateError?: (error: OpenfortError) => void;
+    onSetActiveSuccess?: (wallet: ConnectedEmbeddedSolanaWallet, provider: OpenfortEmbeddedSolanaWalletProvider) => void;
+    onSetActiveError?: (error: OpenfortError) => void;
+};
+/**
+ * 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 declare function useEmbeddedSolanaWallet(options?: UseEmbeddedSolanaWalletOptions): EmbeddedSolanaWalletState;
+export {};

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

@@ -0,0 +1,17 @@
+import type { RecoveryParams } from '@openfort/openfort-js';
+import type { EmbeddedWalletConfiguration } from '../../core/provider';
+/**
+ * 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 declare function buildRecoveryParams(options: {
+    recoveryPassword?: string;
+} | undefined, walletConfig?: EmbeddedWalletConfiguration): Promise<RecoveryParams>;

package/dist/types/index.js

@@ -1,2 +1 @@
-// Predicate functions (exported directly, not as types)
-export { canTransact, getActionText, getStateDescription, hasError, isConnected, isConnecting, isCreating, isDisconnected, isLoading, isNotCreated, isReady, isReconnecting, isStable, needsRecovery, needsUserAction, } from './predicates';
+export {};

package/dist/types/lib/hookConsistency.d.ts

@@ -7,6 +7,9 @@ import type { OpenfortError } from '../types/openfortError';
  * 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
@@ -31,6 +34,9 @@ export declare const onSuccess: <T>({ 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