@openfort/react-native 0.0.3 → 0.1.1

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

@@ -0,0 +1,61 @@
+import React from 'react';
+import type { Openfort as OpenfortClient, EmbeddedState } from '@openfort/openfort-js';
+import { OAuthFlowState, PasswordFlowState, RecoveryFlowState, SiweFlowState } from '../types';
+import type { Chain, EmbeddedWalletConfiguration } from './provider';
+/**
+ * Core Openfort context interface containing all SDK state and methods
+ */
+export interface OpenfortContextValue {
+    /** The Openfort client instance */
+    client: OpenfortClient;
+    /** The current authenticated user, or null when unauthenticated */
+    user: import('@openfort/openfort-js').AuthPlayerResponse | null;
+    /** Whether the SDK has initialized and is ready for use */
+    isReady: boolean;
+    /** Any error encountered during SDK initialization */
+    error: Error | null;
+    /** Supported chains configuration */
+    supportedChains?: [Chain, ...Chain[]];
+    /** Embedded wallet configuration for Shield integration */
+    walletConfig?: EmbeddedWalletConfiguration;
+    /** Current embedded wallet state */
+    embeddedState: EmbeddedState;
+    /** Password (email/SMS) authentication flow state */
+    passwordState: PasswordFlowState;
+    /** OAuth authentication flow state */
+    oAuthState: OAuthFlowState;
+    /** Sign-in with Ethereum flow state */
+    siweState: SiweFlowState;
+    /** Recovery flow state */
+    recoveryFlowState: RecoveryFlowState;
+    setPasswordState: React.Dispatch<React.SetStateAction<PasswordFlowState>>;
+    setOAuthState: React.Dispatch<React.SetStateAction<OAuthFlowState>>;
+    setSiweState: React.Dispatch<React.SetStateAction<SiweFlowState>>;
+    setRecoveryFlowState: React.Dispatch<React.SetStateAction<RecoveryFlowState>>;
+    /** Logs the current user out and clears any stored tokens */
+    logout: () => Promise<void>;
+    /** Gets the current authenticated user's access token */
+    getAccessToken: () => Promise<string | null>;
+    /** @internal Refreshes user state after authentication changes */
+    _internal: {
+        refreshUserState: (user?: import('@openfort/openfort-js').AuthPlayerResponse) => Promise<import('@openfort/openfort-js').AuthPlayerResponse | null>;
+    };
+}
+/**
+ * React context for sharing Openfort SDK state throughout the component tree
+ */
+export declare const OpenfortContext: React.Context<OpenfortContextValue | null>;
+/**
+ * Hook to access the Openfort context
+ * Throws an error if used outside of a OpenfortProvider
+ */
+export declare function useOpenfortContext(): OpenfortContextValue;
+/**
+ * Hook to safely access the Openfort context
+ * Returns null if used outside of a OpenfortProvider
+ */
+export declare function useOpenfortContextSafe(): OpenfortContextValue | null;
+/**
+ * Type guard to check if a value is a valid OpenfortContextValue
+ */
+export declare function isOpenfortContextValue(value: unknown): value is OpenfortContextValue;

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

@@ -0,0 +1,8 @@
+export { createOpenfortClient, getDefaultClient, setDefaultClient } from './client';
+export { RecoveryMethod } from '@openfort/openfort-js';
+export type { SDKOverrides } from '@openfort/openfort-js';
+export { OpenfortContext, useOpenfortContext, useOpenfortContextSafe, isOpenfortContextValue } from './context';
+export type { OpenfortContextValue } from './context';
+export { OpenfortProvider } from './provider';
+export type { OpenfortProviderProps, EmbeddedWalletConfiguration, CommonEmbeddedWalletConfiguration, EncryptionSession, AutomaticRecoveryEmbeddedWalletConfiguration, PasswordRecoveryEmbeddedWalletConfiguration } from './provider';
+export { SecureStorageAdapter, createNormalizedStorage } from './storage';

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

@@ -0,0 +1,126 @@
+import React from 'react';
+import { RecoveryMethod, SDKOverrides } from '@openfort/openfort-js';
+/**
+ * Custom auth configuration
+ */
+interface CustomAuthConfig {
+    enabled: boolean;
+    isLoading: boolean;
+    getCustomAccessToken: () => Promise<string | null>;
+}
+export type CommonEmbeddedWalletConfiguration = {
+    /** Publishable key for the Shield API */
+    shieldPublishableKey: string;
+    /** Policy ID (pol_...) for the embedded signer */
+    ethereumProviderPolicyId?: string;
+    debug?: boolean;
+};
+export type EncryptionSession = {
+    /** Function to retrieve an encryption session using a session ID */
+    getEncryptionSession: () => Promise<string>;
+    createEncryptedSessionEndpoint?: never;
+} | {
+    /** API endpoint for creating an encrypted session */
+    createEncryptedSessionEndpoint: string;
+    getEncryptionSession?: never;
+};
+/**
+ * Configuration for automatic recovery, which requires an encryption session.
+ */
+export type AutomaticRecoveryEmbeddedWalletConfiguration = {
+    /** Specifies that the recovery method is automatic */
+    recoveryMethod: RecoveryMethod.AUTOMATIC;
+} & EncryptionSession;
+export type PasswordRecoveryEmbeddedWalletConfiguration = {
+    /** Specifies that the recovery method is password-based */
+    recoveryMethod: RecoveryMethod.PASSWORD;
+} & ((EncryptionSession & {
+    shieldEncryptionKey?: never;
+}) | {
+    /** Required shield encryption key when no encryption session is used */
+    shieldEncryptionKey: string;
+    createEncryptedSessionEndpoint?: never;
+    getEncryptionSession?: never;
+});
+/**
+ * Configuration for automatic recovery.
+ * - An encryption session is required.
+ *
+ * Configuration for password-based recovery.
+ * - An encryption session, OR
+ * - A `shieldEncryptionKey` without an encryption session.
+ *
+ * Encryption session can be created using either:
+ * - `createEncryptedSessionEndpoint` as a string, OR
+ * - `getEncryptionSession.` as a function that returns a promise.
+ */
+export type EmbeddedWalletConfiguration = CommonEmbeddedWalletConfiguration & (AutomaticRecoveryEmbeddedWalletConfiguration | PasswordRecoveryEmbeddedWalletConfiguration);
+/**
+ * These types are fully compatible with WAGMI chain types, in case
+ * we need interop in the future.
+ */
+type RpcUrls = {
+    http: readonly string[];
+    webSocket?: readonly string[];
+};
+type NativeCurrency = {
+    name: string;
+    /** 2-6 characters long */
+    symbol: string;
+    decimals: number;
+};
+type BlockExplorer = {
+    name: string;
+    url: string;
+};
+/** A subset of WAGMI's chain type
+ * https://github.com/wagmi-dev/references/blob/6aea7ee9c65cfac24f33173ab3c98176b8366f05/packages/chains/src/types.ts#L8
+ */
+export type Chain = {
+    /** Id in number form */
+    id: number;
+    /** Human readable name */
+    name: string;
+    /** Internal network name */
+    network?: string;
+    /** Currency used by chain */
+    nativeCurrency: NativeCurrency;
+    /** Collection of block explorers */
+    blockExplorers?: {
+        [key: string]: BlockExplorer;
+        default: BlockExplorer;
+    };
+    /** Collection of RPC endpoints */
+    rpcUrls: {
+        [key: string]: RpcUrls;
+        default: RpcUrls;
+    };
+    /** Flag for test networks */
+    testnet?: boolean;
+};
+/**
+ * Props for the OpenfortProvider component
+ */
+export interface OpenfortProviderProps {
+    children: React.ReactNode;
+    customAuth?: CustomAuthConfig;
+    /**
+     * Openfort application ID (can be found in openfort developer dashboard)
+     */
+    publishableKey: string;
+    supportedChains?: [Chain, ...Chain[]];
+    /**
+     * Embedded signer configuration for Shield integration
+     */
+    walletConfig?: EmbeddedWalletConfiguration;
+    /**
+     * SDK overrides configuration for advanced customization
+     */
+    overrides?: SDKOverrides;
+}
+/**
+ * Main provider component that wraps the entire application and provides
+ * Openfort SDK functionality through React context
+ */
+export declare const OpenfortProvider: ({ children, publishableKey, customAuth, supportedChains, walletConfig, overrides, }: OpenfortProviderProps) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,34 @@
+declare enum StorageKeys {
+    AUTHENTICATION = "openfort.authentication",
+    SIGNER = "openfort.signer",
+    CONFIGURATION = "openfort.configuration",
+    ACCOUNT = "openfort.account",
+    TEST = "openfort.test",
+    RECOVERY = "openfort.recovery",
+    SESSION = "openfort.session",
+    PKCE_STATE = "openfort.pkce_state",
+    PKCE_VERIFIER = "openfort.pkce_verifier"
+}
+interface OpenfortStorage {
+    get(key: StorageKeys): Promise<string | null>;
+    save(key: StorageKeys, value: string): Promise<void>;
+    remove(key: StorageKeys): Promise<void>;
+    flush(): void;
+    keyExists(key: StorageKeys): Promise<boolean>;
+    getStorageInfo(): Promise<{
+        isAvailable: boolean;
+        platform: string;
+        keychainAccessible: number;
+    }>;
+}
+/**
+ * Storage adapter using `expo-secure-store` intended for
+ * use with `Openfort` class from `@openfort/openfort-js`.
+ */
+export declare const SecureStorageAdapter: OpenfortStorage;
+/**
+ * Creates a type-safe storage adapter that bridges between the Openfort SDK's
+ * expected Storage interface and our React Native implementation
+ */
+export declare function createNormalizedStorage(customStorage?: OpenfortStorage): import('@openfort/openfort-js').Storage;
+export {};

package/dist/types/hex.js

@@ -0,0 +1 @@
+export {};

package/dist/types/hookOption.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+/**
+ * Authentication hooks index
+ *
+ * This module re-exports all authentication-related hooks for convenient importing.
+ */
+export { useEmailAuth } from './useEmailAuth';
+export { useOAuth } from './useOAuth';
+export { useWalletAuth } from './useWalletAuth';
+export { useGuestAuth } from './useGuestAuth';
+export { useSignOut } from './useSignOut';

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

@@ -0,0 +1,6 @@
+export type CreateWalletPostAuthOptions = {};
+export declare const useCreateWalletPostAuth: () => {
+    tryUseWallet: ({}: CreateWalletPostAuthOptions) => Promise<{
+        wallet: undefined;
+    }>;
+};

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

@@ -0,0 +1,59 @@
+import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OpenfortHookOptions } from '../../types/hookOption';
+import { OpenfortError } from '../../types/openfortError';
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+export type EmailAuthResult = {
+    error?: OpenfortError;
+    user?: OpenfortUser;
+    requiresEmailVerification?: boolean;
+};
+export type SignInEmailOptions = {
+    email: string;
+    password: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
+export type SignUpEmailOptions = {
+    email: string;
+    password: string;
+    name?: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
+export type RequestResetPasswordOptions = {
+    email: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type ResetPasswordOptions = {
+    email: string;
+    password: string;
+    state: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type LinkEmailOptions = {
+    email: string;
+    password: string;
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult>;
+export type VerifyEmailOptions = {
+    email: string;
+    state: string;
+} & OpenfortHookOptions<EmailVerificationResult>;
+export type EmailVerificationResult = {
+    email?: string;
+    error?: OpenfortError;
+};
+export type UseEmailHookOptions = {
+    emailVerificationRedirectTo?: string;
+} & OpenfortHookOptions<EmailAuthResult | EmailVerificationResult> & CreateWalletPostAuthOptions;
+export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    requiresEmailVerification: boolean;
+    error: Error | null;
+    signInEmail: (options: SignInEmailOptions) => Promise<EmailAuthResult>;
+    signUpEmail: (options: SignUpEmailOptions) => Promise<EmailAuthResult>;
+    verifyEmail: () => void;
+    linkEmail: (options: LinkEmailOptions) => Promise<EmailAuthResult>;
+    requestResetPassword: () => void;
+    resetPassword: () => void;
+    reset: () => void;
+};

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

@@ -0,0 +1,39 @@
+/**
+ * Hook for creating guest accounts
+ */
+import type { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OpenfortHookOptions } from '../../types/hookOption';
+import { OpenfortError } from '../../types/openfortError';
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+/**
+ * Hook for creating guest accounts
+ *
+ * Guest accounts allow users to access certain features without full authentication.
+ * These accounts can later be upgraded to full accounts by linking authentication methods.
+ *
+ * @param opts - Configuration options including success/error callbacks
+ * @returns Object with create function
+ *
+ * @example
+ * ```tsx
+ * const { create } = useGuestAuth({
+ *   onSuccess: (user) => console.log('Guest account created:', user),
+ *   onError: (error) => console.error('Failed to create guest account:', error),
+ * });
+ *
+ * // Create a guest account
+ * const guestUser = await create();
+ * ```
+ */
+export type GuestHookResult = {
+    error?: OpenfortError;
+    user?: OpenfortUser;
+};
+export type GuestHookOptions = OpenfortHookOptions<GuestHookResult> & CreateWalletPostAuthOptions;
+export declare const useGuestAuth: (hookOptions?: GuestHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+    signUpGuest: (options?: GuestHookOptions) => Promise<GuestHookResult>;
+};

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

@@ -0,0 +1,62 @@
+/**
+ * Hook for OAuth-based login functionality
+ */
+import { OAuthProvider, type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OpenfortHookOptions } from '../../types/hookOption';
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+import { OpenfortError } from '../../types/openfortError';
+export type InitializeOAuthOptions = {
+    provider: OAuthProvider;
+    redirectTo?: string;
+    isLegacyAppleIosBehaviorEnabled?: boolean;
+} & OpenfortHookOptions<InitOAuthReturnType>;
+export type StoreCredentialsResult = {
+    user?: OpenfortUser;
+    error?: OpenfortError;
+};
+export type InitOAuthReturnType = {
+    error?: OpenfortError;
+    user?: OpenfortUser;
+};
+export type AuthHookOptions = {
+    redirectTo?: string;
+} & OpenfortHookOptions<StoreCredentialsResult | InitOAuthReturnType> & CreateWalletPostAuthOptions;
+/**
+ * Hook for OAuth-based authentication with supported providers
+ *
+ * This hook provides OAuth authentication flow for various providers (Google, Apple, Discord, etc.).
+ * It opens the provider's web authentication page and handles the OAuth flow automatically.
+ *
+ * @param opts - Configuration options including success/error callbacks
+ * @returns Object with login function and current OAuth flow state
+ *
+ * @example
+ * ```tsx
+ * const { login, state } = useLoginWithOAuth({
+ *   onSuccess: (user) => console.log('OAuth login successful:', user),
+ *   onError: (error) => console.error('OAuth login failed:', error),
+ * });
+ *
+ * // Login with Google
+ * const user = await login({ provider: 'google' });
+ *
+ * // Login with Apple (using legacy web flow on iOS if needed)
+ * const user = await login({
+ *   provider: 'apple',
+ *   isLegacyAppleIosBehaviorEnabled: true
+ * });
+ *
+ * // Other supported providers
+ * await login({ provider: 'discord' });
+ * await login({ provider: 'twitter' });
+ * ```
+ */
+export declare const useOAuth: (hookOptions?: AuthHookOptions) => {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null | undefined;
+    initOAuth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
+    linkOauth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
+    storeCredentials: () => void;
+};

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

@@ -0,0 +1,9 @@
+import { OpenfortHookOptions } from "../../types/hookOption";
+import { OpenfortError } from "../../types/openfortError";
+export declare function useSignOut(hookOptions?: OpenfortHookOptions): {
+    signOut: (options?: OpenfortHookOptions) => Promise<{} | undefined>;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortError | null | undefined;
+};

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

@@ -0,0 +1,48 @@
+/**
+ * Hook for linking Ethereum accounts using SIWE to existing users
+ */
+import { AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
+import { OpenfortHookOptions } from '../../types/hookOption';
+import { OpenfortError } from '../../types/openfortError';
+export type WalletHookResult = {
+    error?: OpenfortError;
+    user?: OpenfortUser;
+};
+export type WalletHookOptions = OpenfortHookOptions<WalletHookResult | GenerateSiweMessageResult>;
+type SiweOptions = {
+    signature: string;
+    walletAddress: string;
+    messageOverride?: string;
+    disableSignup?: boolean;
+} & OpenfortHookOptions<WalletHookResult>;
+type LinkSiweOptions = {
+    signature: string;
+    walletAddress: string;
+    messageOverride?: string;
+} & OpenfortHookOptions<WalletHookResult>;
+type GenerateSiweMessageOptions = {
+    wallet: string | {
+        address: string;
+    };
+    from: {
+        domain: string;
+        uri: string;
+    };
+} & OpenfortHookOptions<GenerateSiweMessageResult>;
+type GenerateSiweMessageResult = {
+    error?: OpenfortError;
+    message?: string;
+};
+export declare function useWalletAuth(hookOptions?: WalletHookOptions): {
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    isAwaitingSignature: boolean;
+    isGeneratingMessage: boolean;
+    isSubmittingSignature: boolean;
+    generateSiweMessage: (args: GenerateSiweMessageOptions) => Promise<GenerateSiweMessageResult>;
+    signInWithSiwe: (opts: SiweOptions) => Promise<WalletHookResult>;
+    linkSiwe: (opts: LinkSiweOptions) => Promise<WalletHookResult>;
+};
+export {};

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

@@ -0,0 +1,8 @@
+/**
+ * Core hooks index
+ *
+ * This module re-exports all core SDK hooks for convenient importing.
+ */
+export { useOpenfort } from './useOpenfort';
+export { useOpenfortClient } from './useOpenfortClient';
+export { useUser } from './useUser';

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

@@ -0,0 +1,38 @@
+import { 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.
+ *
+ * @returns The Openfort SDK's core state and methods
+ *
+ * @example
+ * ```tsx
+ * const { user, isReady, error, logout, getAccessToken } = useOpenfort();
+ *
+ * // Check if SDK is ready
+ * if (!isReady) {
+ *   return <LoadingSpinner />;
+ * }
+ *
+ * // Handle initialization errors
+ * if (error) {
+ *   return <ErrorDisplay error={error} />;
+ * }
+ *
+ * // Check authentication status
+ * if (!user) {
+ *   return <LoginScreen />;
+ * }
+ *
+ * // User is authenticated
+ * return (
+ *   <div>
+ *     <h1>Welcome, {user.id}!</h1>
+ *     <button onClick={logout}>Logout</button>
+ *   </div>
+ * );
+ * ```
+ */
+export declare function useOpenfort(): UseOpenfort;

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

@@ -0,0 +1,29 @@
+/**
+ * Hook for accessing the Openfort client instance
+ */
+import type { Openfort as OpenfortClient } from '@openfort/openfort-js';
+/**
+ * Hook for accessing the Openfort client instance directly
+ *
+ * This hook provides access to the underlying Openfort client for advanced use cases
+ * where you need direct access to the client methods.
+ *
+ * @returns The Openfort client instance
+ *
+ * @example
+ * ```tsx
+ * const client = useOpenfortClient();
+ *
+ * // Use client methods directly
+ * const customResult = await client.auth.customMethod();
+ *
+ * // Access client configuration
+ * console.log('App ID:', client.config.appId);
+ *
+ * // Check client status
+ * if (client.isInitialized) {
+ *   // Perform operations that require initialization
+ * }
+ * ```
+ */
+export declare function useOpenfortClient(): OpenfortClient;

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

@@ -0,0 +1,5 @@
+export declare function useUser(): {
+    user: import("@openfort/openfort-js").AuthPlayerResponse | null;
+    isAuthenticated: boolean;
+    getAccessToken: () => Promise<string | null>;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Openfort React Native SDK Hooks
+ *
+ * This module provides a comprehensive set of React hooks for integrating
+ * with the Openfort platform in React Native applications.
+ *
+ * The hooks are organized into the following categories:
+ * - Core: Core SDK functionality hooks
+ */
+export * from './core';
+export * from './auth';
+export * from './wallet';

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

@@ -0,0 +1,6 @@
+/**
+ * Wallet hooks index
+ *
+ * This module re-exports all wallet-related hooks for convenient importing.
+ */
+export { useWallets } from './useWallets';

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

@@ -0,0 +1,74 @@
+/**
+ * Hook for embedded Ethereum wallet functionality
+ */
+import { ChainTypeEnum, Provider, RecoveryMethod } from '@openfort/openfort-js';
+import { Hex } from '../../types/hex';
+import { OpenfortHookOptions } from '../../types/hookOption';
+import { OpenfortError } from '../../types/openfortError';
+import { UserWallet } from '../../types/wallet';
+type SetActiveWalletResult = {
+    error?: OpenfortError;
+    wallet?: UserWallet;
+    provider?: Provider;
+};
+type SetActiveWalletOptions = {
+    address?: Hex | undefined;
+    chainId?: number;
+    recoveryPassword?: string;
+} & OpenfortHookOptions<SetActiveWalletResult>;
+type CreateWalletResult = SetActiveWalletResult;
+type CreateWalletOptions = {
+    chainType?: ChainTypeEnum;
+    chainId?: number;
+    policyId?: string;
+    recoveryPassword?: string;
+} & OpenfortHookOptions<CreateWalletResult>;
+type RecoverEmbeddedWalletResult = SetActiveWalletResult;
+type SetRecoveryOptions = {
+    recoveryMethod: RecoveryMethod;
+    recoveryPassword?: string;
+} & OpenfortHookOptions<CreateWalletResult>;
+type WalletOptions = OpenfortHookOptions<SetActiveWalletResult | CreateWalletResult>;
+/**
+ * Hook for interacting with embedded Ethereum 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.
+ *
+ * @param props - Optional configuration with callback functions
+ * @returns Current embedded Ethereum wallet state with actions
+ *
+ * @example
+ * ```tsx
+ * const ethereumWallet = useEmbeddedEthereumWallet({
+ *   onCreateWalletSuccess: (provider) => console.log('Ethereum wallet created:', provider),
+ *   onCreateWalletError: (error) => console.error('Ethereum wallet creation failed:', error),
+ * });
+ *
+ * // 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 });
+ * }
+ *
+ * // Use connected wallets
+ * if (ethereumWallet.status === 'connected' && ethereumWallet.wallets.length > 0) {
+ *   const provider = await ethereumWallet.wallets[0].getProvider();
+ *   // Use provider for Ethereum transactions
+ * }
+ * ```
+ */
+export declare function useWallets(hookOptions?: WalletOptions): {
+    exportPrivateKey: () => Promise<string>;
+    error: OpenfortError | null | undefined;
+    isError: boolean;
+    isSuccess: boolean;
+    isCreating: boolean;
+    isConnecting: boolean;
+    wallets: UserWallet[];
+    activeWallet: UserWallet | null;
+    setRecovery: (params: SetRecoveryOptions) => Promise<RecoverEmbeddedWalletResult>;
+    setActiveWallet: (options?: SetActiveWalletOptions) => Promise<SetActiveWalletResult>;
+    createWallet: (options?: CreateWalletOptions) => Promise<CreateWalletResult>;
+};
+export {};