@openfort/react-native 0.1.9 → 0.1.10

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

@@ -1,6 +1,3 @@
-/**
- * Hook for embedded Ethereum wallet functionality
- */
 import { AccountTypeEnum, ChainTypeEnum, Provider, RecoveryParams } from '@openfort/openfort-js';
 import { Hex } from '../../types/hex';
 import { OpenfortHookOptions } from '../../types/hookOption';
@@ -32,31 +29,36 @@ type WalletOptions = {
     chainId?: number;
 } & OpenfortHookOptions<SetActiveWalletResult | CreateWalletResult>;
 /**
- * Hook for interacting with embedded Ethereum wallets
+ * Hook for interacting with embedded wallets
  *
- * This hook manages embedded Ethereum wallets based on the user's state from the provider.
- * Wallet state is determined by polling in the provider, not by local state management.
+ * This hook manages embedded wallets based on the user's state from the provider. Wallet state is determined by
+ * polling in the provider, not by local state management. It provides wallet creation, recovery, and management capabilities.
  *
- * @param props - Optional configuration with callback functions
- * @returns Current embedded Ethereum wallet state with actions
+ * @param hookOptions - Optional configuration with callback functions and chain ID settings
+ * @returns Current embedded wallet state with actions and wallet collection
  *
  * @example
  * ```tsx
- * const ethereumWallet = useEmbeddedEthereumWallet({
- *   onCreateWalletSuccess: (provider) => console.log('Ethereum wallet created:', provider),
- *   onCreateWalletError: (error) => console.error('Ethereum wallet creation failed:', error),
+ * const { wallets, activeWallet, createWallet, setActiveWallet, isCreating } = useWallets({
+ *   onSuccess: ({ wallet }) => console.log('Wallet operation successful:', wallet?.address),
+ *   onError: ({ error }) => console.error('Wallet operation failed:', error?.message),
+ *   chainId: 1, // Ethereum mainnet
  * });
  *
- * // Check wallet status and create if needed
- * if (ethereumWallet.status === 'disconnected') {
- *   await ethereumWallet.create(); // Uses default chain
- *   // Or with specific chain: await ethereumWallet.create({ chainId: 1 });
+ * // Create a new wallet if none exist
+ * if (wallets.length === 0 && !isCreating) {
+ *   await createWallet({ chainId: 1 });
+ * }
+ *
+ * // Use existing wallets
+ * if (wallets.length > 0 && !activeWallet) {
+ *   await setActiveWallet({ address: wallets[0].address });
  * }
  *
- * // Use connected wallets
- * if (ethereumWallet.status === 'connected' && ethereumWallet.wallets.length > 0) {
- *   const provider = await ethereumWallet.wallets[0].getProvider();
- *   // Use provider for Ethereum transactions
+ * // Access active wallet
+ * if (activeWallet) {
+ *   const provider = await activeWallet.getProvider();
+ *   // Use provider for transactions
  * }
  * ```
  */

package/dist/types/index.d.ts

@@ -1,12 +1,11 @@
 /**
- * Openfort React Native SDK
+ * @packageDocumentation
  *
- * A comprehensive React Native SDK for integrating with the Openfort platform.
- * This SDK provides authentication, embedded wallets, session management, and UI components
- * for building decentralized applications on React Native.
+ * Entry point for the Openfort React Native SDK.
  *
- * @author Openfort
- * @version 0.1.8
+ * This package re-exports the core SDK functionality, hooks, components and native helpers
+ * required to integrate Openfort authentication and embedded wallets into React Native and
+ * Expo applications.
  */
 export { AuthPlayerResponse, OpenfortError, RecoveryMethod, Openfort as OpenfortClient, Provider, OpenfortConfiguration, ShieldConfiguration, EmbeddedState, } from '@openfort/openfort-js';
 export { OAuthProvider, } from '@openfort/openfort-js';

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

@@ -1,10 +1,52 @@
 import { OpenfortHookOptions } from "../types/hookOption";
 import { OpenfortError } from "../types/openfortError";
+/**
+ * Handles successful hook operation callbacks
+ *
+ * This utility function invokes success and settled callbacks from hook options,
+ * ensuring consistent callback execution across all hooks in the SDK.
+ *
+ * @param params - Object containing hook options and success data
+ * @returns The success data that was passed in
+ *
+ * @example
+ * ```tsx
+ * const result = await someAsyncOperation();
+ * return onSuccess({
+ *   hookOptions,
+ *   options,
+ *   data: { user: result.user },
+ * });
+ * ```
+ */
 export declare const onSuccess: <T>({ hookOptions, options, data, }: {
     hookOptions?: OpenfortHookOptions<T>;
     options?: OpenfortHookOptions<T>;
     data: T;
 }) => T;
+/**
+ * Handles failed hook operation callbacks
+ *
+ * This utility function invokes error and settled callbacks from hook options,
+ * and optionally throws the error if throwOnError is configured.
+ *
+ * @param params - Object containing hook options and error information
+ * @returns Object containing the error, or throws if throwOnError is enabled
+ *
+ * @example
+ * ```tsx
+ * try {
+ *   await someAsyncOperation();
+ * } catch (e) {
+ *   const error = new OpenfortError('Operation failed', OpenfortErrorType.GENERIC);
+ *   return onError({
+ *     hookOptions,
+ *     options,
+ *     error,
+ *   });
+ * }
+ * ```
+ */
 export declare const onError: <T>({ hookOptions, options, error, }: {
     hookOptions?: OpenfortHookOptions<T>;
     options?: OpenfortHookOptions<T>;

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

@@ -43,7 +43,25 @@ export declare function authenticateWithApple(options: {
  */
 export declare function isAppleSignInAvailable(): Promise<boolean>;
 /**
- * Parses OAuth parameters from a URL
+ * Parses OAuth parameters from a redirect URL
+ *
+ * This function extracts OAuth authentication parameters from a callback URL after
+ * a successful or failed OAuth flow. It safely handles URL parsing errors.
+ *
+ * @param url - The OAuth redirect URL containing query parameters
+ * @returns Object containing parsed OAuth parameters including tokens and error information
+ *
+ * @example
+ * ```tsx
+ * const redirectUrl = 'myapp://oauth/callback?access_token=abc123&player_id=player_123';
+ * const result = parseOAuthUrl(redirectUrl);
+ *
+ * if (result.access_token && result.player_id) {
+ *   console.log('OAuth successful:', result.player_id);
+ * } else if (result.error) {
+ *   console.error('OAuth failed:', result.errorDescription);
+ * }
+ * ```
  */
 export declare function parseOAuthUrl(url: string): {
     access_token?: string;
@@ -54,6 +72,25 @@ export declare function parseOAuthUrl(url: string): {
 };
 /**
  * Creates a redirect URI for OAuth flows
+ *
+ * This function generates a deep link URL that OAuth providers can redirect back to
+ * after authentication. The URL follows the app's custom URL scheme.
+ *
+ * @param path - The path component for the redirect URI, defaults to '/'
+ * @returns A complete redirect URI that can be used in OAuth flows
+ *
+ * @example
+ * ```tsx
+ * // Create default OAuth callback URI
+ * const callbackUri = createOAuthRedirectUri('/oauth/callback');
+ * console.log(callbackUri); // 'myapp://oauth/callback'
+ *
+ * // Use in OAuth configuration
+ * const oauthConfig = {
+ *   redirectUri: createOAuthRedirectUri('/auth/success'),
+ *   provider: 'google',
+ * };
+ * ```
  */
 export declare function createOAuthRedirectUri(path?: string): string;
 /**

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

@@ -1,6 +1,6 @@
 import * as SecureStore from 'expo-secure-store';
 /**
- * Interface for secure storage message handling in WebView
+ * Shape of messages sent from the embedded WebView when interacting with secure storage.
  */
 export interface SecureStorageMessage {
     event: string;
@@ -8,7 +8,7 @@ export interface SecureStorageMessage {
     data: Record<string, any>;
 }
 /**
- * Interface for secure storage response
+ * Shape of responses returned to the WebView after processing a storage message.
  */
 export interface SecureStorageResponse {
     event: string;
@@ -16,31 +16,43 @@ export interface SecureStorageResponse {
     data: Record<string, any>;
 }
 /**
- * Checks if a message is a secure storage related message
+ * Checks if the provided value is a secure storage related message.
+ *
+ * @param message - Incoming message payload.
+ * @returns `true` when the payload matches the {@link SecureStorageMessage} structure.
  */
 export declare function isSecureStorageMessage(message: unknown): message is SecureStorageMessage;
 /**
- * Handles secure storage operations from WebView messages
+ * Handles secure storage operations initiated from WebView messages.
+ *
+ * @param message - Parsed WebView message describing the desired storage action.
+ * @returns The response payload that should be sent back to the WebView.
+ * @throws {Error} When the message event is unknown.
  */
 export declare function handleSecureStorageMessage(message: SecureStorageMessage): Promise<SecureStorageResponse>;
 /**
- * Native storage utilities for platform-specific operations
+ * Native storage utilities for platform-specific operations.
  */
 export declare const NativeStorageUtils: {
     /**
-     * Checks if secure storage is available on the current platform
+     * Checks if secure storage is available on the current platform.
      */
     isAvailable(): boolean;
     /**
-     * Gets the platform-specific storage options
+     * Gets the platform-specific storage options.
      */
     getStorageOptions(): SecureStore.SecureStoreOptions;
     /**
-     * Safely checks if a key exists in secure storage
+     * Safely checks if a key exists in secure storage.
+     *
+     * @param key - Storage key to look up.
+     * @returns `true` if the key is present, otherwise `false`.
      */
     keyExists(key: string): Promise<boolean>;
     /**
-     * Gets all available storage information
+     * Gets diagnostic information about the native storage capabilities.
+     *
+     * @returns Platform availability information and keychain accessibility value.
      */
     getStorageInfo(): Promise<{
         isAvailable: boolean;

package/dist/types/predicates.js

@@ -26,7 +26,26 @@ export function needsRecovery(s) {
  * Additional utility predicates
  */
 /**
- * Type guard to check if wallet is in a loading state (connecting, creating, reconnecting)
+ * Type guard to check if wallet is in a loading state
+ *
+ * This function determines whether a wallet is currently in a transitional state
+ * (connecting, creating, or reconnecting) and should show loading indicators.
+ *
+ * @param s - The embedded wallet state to check
+ * @returns True if the wallet is in any loading state, false otherwise
+ *
+ * @example
+ * ```tsx
+ * const { wallets } = useWallets();
+ * const wallet = wallets[0];
+ *
+ * if (isLoading(wallet)) {
+ *   return <ActivityIndicator />; // Show spinner
+ * }
+ *
+ * // Safe to show wallet interface
+ * return <WalletInterface wallet={wallet} />;
+ * ```
  */
 export function isLoading(s) {
     return s.status === 'connecting' || s.status === 'creating' || s.status === 'reconnecting';

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

@@ -1,16 +1,16 @@
 /**
- * Core Openfort hook interface
+ * Core Openfort hook interface.
  */
 export interface UseOpenfort {
-    /** The current authenticated user, or null when unauthenticated */
+    /** 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 */
+    /** Whether or not the SDK has initialized and is ready for use. */
     isReady: boolean;
-    /** Any error encountered during SDK initialization */
+    /** Any error encountered during SDK initialization. */
     error: Error | null;
-    /** A function that logs the current user out and clears any stored tokens */
+    /** 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 */
+    /** A function that gets the current authenticated user's access token. */
     getAccessToken: () => Promise<string | null>;
 }
 export type { PasswordFlowState, SiweFlowState, RecoveryFlowState, CustomAuthFlowState, AuthSuccessCallback, AuthLinkSuccessCallback, ErrorCallback, EmailLoginHookOptions, EmailLinkHookOptions, EmailLoginHookResult, EmailLinkHookResult, SiweLoginHookOptions, SiweLinkHookOptions, SiweLoginHookResult, SiweLinkHookResult, GenerateSiweMessageResponse, GenerateSiweMessage, } from './auth';
@@ -19,7 +19,7 @@ export type { OpenfortEmbeddedWalletAccount, WalletRecoveryCallbacks, SolanaWall
 export type { CustomAuthProviderConfig, UseGuestAuth, UseOnEmbeddedWalletStateChange, SetRecoveryParams, UseSetEmbeddedWalletRecoveryResult, UseSetEmbeddedWalletRecovery, } from './config';
 export { isConnected, isReconnecting, isConnecting, isDisconnected, isNotCreated, isCreating, hasError, needsRecovery, isLoading, isReady, needsUserAction, isStable, canTransact, getStateDescription, getActionText, } from './predicates';
 /**
- * Embedded wallet hook options with callbacks
+ * Embedded wallet hook options with callbacks.
  */
 export type UseEmbeddedEthereumWallet = {
     onCreateWalletSuccess?: (provider: import('@openfort/openfort-js').Provider) => void;
@@ -30,7 +30,7 @@ export type UseEmbeddedEthereumWallet = {
     onSetWalletRecoveryError?: (error: Error) => void;
 };
 /**
- * Embedded Solana wallet hook options with callbacks
+ * Embedded Solana wallet hook options with callbacks.
  */
 export type UseEmbeddedSolanaWallet = {
     onCreateWalletSuccess?: (account: import('@openfort/openfort-js').EmbeddedAccount) => void;

package/dist/types/types/predicates.d.ts

@@ -1,6 +1,24 @@
 import type { EmbeddedEthereumWalletState, EmbeddedSolanaWalletState, EmbeddedSolanaWalletConnectedState, EmbeddedSolanaWalletConnectingState, EmbeddedSolanaWalletReconnectingState, EmbeddedSolanaWalletDisconnectedState, EmbeddedSolanaWalletNeedsRecoveryState, EmbeddedSolanaWalletCreatingState, EmbeddedSolanaWalletErrorState } from './wallet';
 /**
  * Type guard to check if embedded wallet is connected
+ *
+ * This function determines whether an embedded wallet is in a connected state and ready for use.
+ * It provides TypeScript type narrowing for wallet state management.
+ *
+ * @param s - The embedded wallet state to check
+ * @returns True if the wallet is connected, false otherwise
+ *
+ * @example
+ * ```tsx
+ * const { wallets } = useWallets();
+ * const wallet = wallets[0];
+ *
+ * if (isConnected(wallet)) {
+ *   // TypeScript knows wallet is connected, safe to use
+ *   const provider = await wallet.getProvider();
+ *   console.log('Wallet is connected:', wallet.address);
+ * }
+ * ```
  */
 export declare function isConnected(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletConnectedState;
 /**
@@ -13,6 +31,23 @@ export declare function isReconnecting(s: EmbeddedSolanaWalletState): s is Embed
 export declare function isConnecting(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletConnectingState;
 /**
  * Type guard to check if embedded wallet is disconnected
+ *
+ * This function determines whether an embedded wallet is in a disconnected state.
+ * Disconnected wallets need to be connected before they can be used for transactions.
+ *
+ * @param s - The embedded wallet state to check
+ * @returns True if the wallet is disconnected, false otherwise
+ *
+ * @example
+ * ```tsx
+ * const { wallets, setActiveWallet } = useWallets();
+ * const wallet = wallets[0];
+ *
+ * if (isDisconnected(wallet)) {
+ *   console.log('Wallet needs connection');
+ *   await setActiveWallet({ address: wallet.address });
+ * }
+ * ```
  */
 export declare function isDisconnected(s: EmbeddedSolanaWalletState): s is EmbeddedSolanaWalletDisconnectedState;
 /**
@@ -35,7 +70,26 @@ export declare function needsRecovery(s: EmbeddedSolanaWalletState): s is Embedd
  * Additional utility predicates
  */
 /**
- * Type guard to check if wallet is in a loading state (connecting, creating, reconnecting)
+ * Type guard to check if wallet is in a loading state
+ *
+ * This function determines whether a wallet is currently in a transitional state
+ * (connecting, creating, or reconnecting) and should show loading indicators.
+ *
+ * @param s - The embedded wallet state to check
+ * @returns True if the wallet is in any loading state, false otherwise
+ *
+ * @example
+ * ```tsx
+ * const { wallets } = useWallets();
+ * const wallet = wallets[0];
+ *
+ * if (isLoading(wallet)) {
+ *   return <ActivityIndicator />; // Show spinner
+ * }
+ *
+ * // Safe to show wallet interface
+ * return <WalletInterface wallet={wallet} />;
+ * ```
  */
 export declare function isLoading(s: EmbeddedEthereumWalletState | EmbeddedSolanaWalletState): boolean;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "license": "MIT",
   "description": "React Native SDK for Openfort platform integration",
   "scripts": {