@openfort/react-native 0.1.20 → 0.1.21

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,7 +16,7 @@ export type InitOAuthReturnType = {
 };
 export type AuthHookOptions = {
     redirectTo?: string;
-} & OpenfortHookOptions<StoreCredentialsResult | InitOAuthReturnType> & CreateWalletPostAuthOptions;
+} & OpenfortHookOptions<StoreCredentialsResult | InitOAuthReturnType>;
 /**
  * Hook for OAuth-based authentication with supported providers.
  *

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,53 @@
+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 Ethereum wallet management including creation, activation,
+ * and recovery. It returns a discriminated union state that enables type-safe wallet interactions.
+ *
+ * @param options - Configuration with default chainId and callback functions
+ * @returns Discriminated union state object. The `status` field determines available properties.
+ * Possible states: 'disconnected', 'connecting', 'reconnecting', 'creating', 'needs-recovery',
+ * 'connected', 'error'. When connected, includes `provider` and `activeWallet`. All states include
+ * `create`, `setActive`, `setRecovery`, `exportPrivateKey`, and `wallets` methods/properties.
+ *
+ * @example
+ * ```tsx
+ * import { useEmbeddedEthereumWallet, isConnected, isLoading } from '@openfort/react-native';
+ *
+ * const ethereum = useEmbeddedEthereumWallet({
+ *   chainId: 1,
+ *   onCreateSuccess: (account, provider) => console.log('Wallet created:', account.address),
+ * });
+ *
+ * if (isLoading(ethereum)) {
+ *   return <ActivityIndicator />;
+ * }
+ *
+ * if (isConnected(ethereum)) {
+ *   // TypeScript knows provider and activeWallet are available
+ *   const tx = await ethereum.provider.request({
+ *     method: 'eth_sendTransaction',
+ *     params: [{ from: ethereum.activeWallet.address, to: '0x...', value: '0x0' }]
+ *   });
+ * }
+ *
+ * // Create wallet if none exist
+ * if (ethereum.status === 'disconnected' && ethereum.wallets.length === 0) {
+ *   await ethereum.create({ chainId: 1 });
+ * }
+ * ```
+ */
+export declare function useEmbeddedEthereumWallet(options?: UseEmbeddedEthereumWalletOptions): EmbeddedEthereumWalletState;
+export {};

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

@@ -0,0 +1,47 @@
+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 Solana wallet management including creation, activation,
+ * and recovery. It returns a discriminated union state that enables type-safe wallet interactions.
+ *
+ * @param options - Configuration with callback functions
+ * @returns Discriminated union state object. The `status` field determines available properties.
+ * Possible states: 'disconnected', 'connecting', 'reconnecting', 'creating', 'needs-recovery',
+ * 'connected', 'error'. When connected, includes `provider` and `activeWallet`. All states include
+ * `create`, `setActive`, and `wallets` methods/properties.
+ *
+ * @example
+ * ```tsx
+ * import { useEmbeddedSolanaWallet, isConnected, isLoading } from '@openfort/react-native';
+ *
+ * const solana = useEmbeddedSolanaWallet({
+ *   onCreateSuccess: (account, provider) => console.log('Wallet created:', account.address),
+ * });
+ *
+ * if (isLoading(solana)) {
+ *   return <ActivityIndicator />;
+ * }
+ *
+ * if (isConnected(solana)) {
+ *   // TypeScript knows provider and activeWallet are available
+ *   const signed = await solana.provider.signTransaction(transaction);
+ *   const publicKey = solana.provider.publicKey;
+ * }
+ *
+ * // Create wallet if none exist
+ * if (solana.status === 'disconnected' && solana.wallets.length === 0) {
+ *   await solana.create({ recoveryMethod: 'automatic' });
+ * }
+ * ```
+ */
+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

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

@@ -29,10 +29,21 @@ export interface OAuthSessionConfig {
 }
 /**
  * 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 declare function openOAuthSession(config: OAuthSessionConfig): Promise<OAuthResult>;
 /**
  * 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 declare function authenticateWithApple(options: {
     state: string;
@@ -40,6 +51,8 @@ export declare function authenticateWithApple(options: {
 }): Promise<AppleAuthResult>;
 /**
  * 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 declare function isAppleSignInAvailable(): Promise<boolean>;
 /**

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

@@ -36,10 +36,14 @@ export declare function handleSecureStorageMessage(message: SecureStorageMessage
 export declare const NativeStorageUtils: {
     /**
      * Checks if secure storage is available on the current platform.
+     *
+     * @returns True if the platform is iOS or Android, false otherwise
      */
     isAvailable(): boolean;
     /**
      * Gets the platform-specific storage options.
+     *
+     * @returns Secure store options with keychain accessibility configuration
      */
     getStorageOptions(): SecureStore.SecureStoreOptions;
     /**

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

@@ -16,6 +16,8 @@ interface EmbeddedWalletWebViewProps {
  * 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 declare const EmbeddedWalletWebView: React.FC<EmbeddedWalletWebViewProps>;
 /**
@@ -24,18 +26,28 @@ export declare const EmbeddedWalletWebView: React.FC<EmbeddedWalletWebViewProps>
 export declare const WebViewUtils: {
     /**
      * Checks if WebView is supported on the current platform
+     *
+     * @returns True if the platform is iOS or Android, false otherwise
      */
     isSupported(): boolean;
     /**
      * Gets platform-specific WebView configuration
+     *
+     * @returns Platform-specific WebView configuration object
      */
     getPlatformConfig(): Partial<React.ComponentProps<typeof WebView>>;
     /**
      * 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: any): string;
     /**
      * Validates a message received from WebView
+     *
+     * @param message - JSON string message to validate
+     * @returns Validation result with parsed data or error information
      */
     validateMessage(message: string): {
         isValid: boolean;
@@ -44,6 +56,8 @@ export declare const WebViewUtils: {
     };
     /**
      * Gets WebView user agent for the current platform
+     *
+     * @returns User agent string including platform and version information
      */
     getUserAgent(): string;
 };

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

@@ -43,10 +43,6 @@ export type RecoveryFlowState = {
  * Authentication success callback
  */
 export type AuthSuccessCallback = (user: OpenfortUser, isNewUser?: boolean) => void;
-/**
- * Authentication link success callback
- */
-export type AuthLinkSuccessCallback = (user: OpenfortUser) => void;
 /**
  * Error callback
  */
@@ -58,13 +54,6 @@ export interface EmailLoginHookOptions {
     onError?: ErrorCallback;
     onSuccess?: AuthSuccessCallback;
 }
-/**
- * Email link hook options
- */
-export interface EmailLinkHookOptions {
-    onError?: ErrorCallback;
-    onSuccess?: AuthLinkSuccessCallback;
-}
 /**
  * Email login hook result
  */
@@ -80,16 +69,6 @@ export interface EmailLoginHookResult {
     }) => Promise<OpenfortUser | undefined>;
     state: PasswordFlowState;
 }
-/**
- * Email link hook result
- */
-export interface EmailLinkHookResult {
-    link: (credentials: {
-        email: string;
-        password: string;
-    }) => Promise<OpenfortUser | undefined>;
-    state: PasswordFlowState;
-}
 /**
  * SIWE message generation response
  */
@@ -118,14 +97,6 @@ export interface SiweLoginHookOptions {
     onSuccess?: AuthSuccessCallback;
     onGenerateMessage?: (message: string) => void;
 }
-/**
- * SIWE link hook options
- */
-export interface SiweLinkHookOptions {
-    onError?: ErrorCallback;
-    onSuccess?: AuthLinkSuccessCallback;
-    onGenerateMessage?: (message: string) => void;
-}
 /**
  * SIWE login hook result
  */
@@ -139,15 +110,3 @@ export interface SiweLoginHookResult {
         disableSignup?: boolean;
     }) => Promise<OpenfortUser>;
 }
-/**
- * SIWE link hook result
- */
-export interface SiweLinkHookResult {
-    generateSiweMessage: GenerateSiweMessage;
-    state: SiweFlowState;
-    linkWithSiwe: (opts: {
-        signature: string;
-        messageOverride?: string;
-        walletAddress: string;
-    }) => Promise<OpenfortUser>;
-}

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

@@ -2,37 +2,10 @@
  * Core Openfort hook interface.
  */
 export interface UseOpenfort {
-    /** The current authenticated user, or null when unauthenticated. */
-    user: import('@openfort/openfort-js').AuthPlayerResponse | null;
-    /** Whether or not the SDK has initialized and is ready for use. */
     isReady: boolean;
     /** Any error encountered during SDK initialization. */
     error: Error | null;
-    /** A function that logs the current user out and clears any stored tokens. */
-    logout: () => Promise<void>;
-    /** A function that gets the current authenticated user's access token. */
-    getAccessToken: () => Promise<string | null>;
 }
-export type { AuthLinkSuccessCallback, AuthSuccessCallback, EmailLinkHookOptions, EmailLinkHookResult, EmailLoginHookOptions, EmailLoginHookResult, ErrorCallback, GenerateSiweMessage, GenerateSiweMessageResponse, PasswordFlowState, RecoveryFlowState, SiweFlowState, SiweLinkHookOptions, SiweLinkHookResult, SiweLoginHookOptions, SiweLoginHookResult, } from './auth';
-export type { SetRecoveryParams, UseGuestAuth, UseOnEmbeddedWalletStateChange, UseSetEmbeddedWalletRecovery, UseSetEmbeddedWalletRecoveryResult, } from './config';
-export type { LinkWithOAuthInput, LoginWithOAuthInput, OAuthFlowState, OAuthTokens, UnlinkOAuthOptions, UnlinkOAuthParams, UseLinkWithOAuth, UseLoginWithOAuth, UseOAuthTokensOptions, } from './oauth';
-export { canTransact, getActionText, getStateDescription, hasError, isConnected, isConnecting, isCreating, isDisconnected, isLoading, isNotCreated, isReady, isReconnecting, isStable, needsRecovery, needsUserAction, } from './predicates';
-export type { ConnectedEmbeddedEthereumWallet, ConnectedEmbeddedSolanaWallet, CreateSolanaEmbeddedWalletOpts, EmbeddedEthereumWalletActions, EmbeddedEthereumWalletState, EmbeddedSolanaWalletActions, EmbeddedSolanaWalletConnectedState, EmbeddedSolanaWalletConnectingState, EmbeddedSolanaWalletCreatingState, EmbeddedSolanaWalletDisconnectedState, EmbeddedSolanaWalletErrorState, EmbeddedSolanaWalletNeedsRecoveryState, EmbeddedSolanaWalletReconnectingState, EmbeddedSolanaWalletState, EmbeddedSolanaWalletStatus, EmbeddedWalletStatus, OpenfortEmbeddedWalletAccount, RecoverSolanaEmbeddedWalletOpts, RecoveryMethodOptions, SolanaWalletRecoveryCallbacks, UserWallet, WalletRecoveryCallbacks, } from './wallet';
-/**
- * Embedded wallet hook options with callbacks.
- */
-export type UseEmbeddedEthereumWallet = {
-    onCreateWalletSuccess?: (provider: import('@openfort/openfort-js').Provider) => void;
-    onCreateWalletError?: (error: Error) => void;
-    onSetWalletRecoverySuccess?: (result: {
-        user: import('@openfort/openfort-js').AuthPlayerResponse;
-    }) => void;
-    onSetWalletRecoveryError?: (error: Error) => void;
-};
-/**
- * Embedded Solana wallet hook options with callbacks.
- */
-export type UseEmbeddedSolanaWallet = {
-    onCreateWalletSuccess?: (account: import('@openfort/openfort-js').EmbeddedAccount) => void;
-    onCreateWalletError?: (error: Error) => void;
-};
+export type { AuthSuccessCallback, EmailLoginHookOptions, EmailLoginHookResult, ErrorCallback, GenerateSiweMessage, GenerateSiweMessageResponse, PasswordFlowState, RecoveryFlowState, SiweFlowState, SiweLoginHookOptions, SiweLoginHookResult, } from './auth';
+export type { LinkWithOAuthInput, LoginWithOAuthInput, OAuthFlowState, UseLoginWithOAuth, } from './oauth';
+export type { ConnectedEmbeddedEthereumWallet, ConnectedEmbeddedSolanaWallet, CreateSolanaEmbeddedWalletOpts, EmbeddedEthereumWalletState, EmbeddedSolanaWalletState, OpenfortEmbeddedEthereumWalletProvider, OpenfortEmbeddedSolanaWalletProvider, } from './wallet';

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

@@ -1,5 +1,4 @@
 import type { OAuthProvider } from '@openfort/openfort-js';
-import type { AuthSuccessCallback, ErrorCallback } from './auth';
 /**
  * OAuth authentication flow state
  */
@@ -16,22 +15,6 @@ export declare const mapOAuthStatus: (status: OAuthFlowState) => {
     isSuccess: boolean;
     error: Error | null | undefined;
 };
-/**
- * OAuth tokens interface
- */
-export interface OAuthTokens {
-    [key: string]: any;
-}
-/**
- * OAuth tokens hook options
- */
-export interface UseOAuthTokensOptions {
-    /**
-     * Callback function triggered when OAuth tokens are granted to the user after any OAuth Authorization flow.
-     * @param tokens - The set of OAuth tokens granted to the user.
-     */
-    onOAuthTokenGrant: (tokens: OAuthTokens) => void;
-}
 /**
  * Login with OAuth input parameters
  */
@@ -51,24 +34,3 @@ export interface UseLoginWithOAuth {
     state: OAuthFlowState;
     login: (input: LoginWithOAuthInput) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | undefined>;
 }
-/**
- * Link with OAuth hook interface
- */
-export interface UseLinkWithOAuth {
-    state: OAuthFlowState;
-    link: (input: LinkWithOAuthInput) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | undefined>;
-}
-/**
- * Unlink OAuth hook options
- */
-export interface UnlinkOAuthOptions {
-    onError?: ErrorCallback;
-    onSuccess?: AuthSuccessCallback;
-}
-/**
- * Unlink OAuth parameters
- */
-export interface UnlinkOAuthParams {
-    provider: OAuthProvider;
-    subject: string;
-}