@openfort/react-native 0.1.24 → 0.1.26

package/dist/hooks/wallet/useEmbeddedEthereumWallet.js

@@ -96,7 +96,7 @@ import { buildRecoveryParams } from './utils';
  * ```
  */
 export function useEmbeddedEthereumWallet(options = {}) {
-    const { client, supportedChains, walletConfig, embeddedState } = useOpenfortContext();
+    const { client, supportedChains, walletConfig, embeddedState, user } = useOpenfortContext();
     const [embeddedAccounts, setEmbeddedAccounts] = useState([]);
     const [activeWalletId, setActiveWalletId] = useState(null);
     const [activeAccount, setActiveAccount] = useState(null);
@@ -106,12 +106,16 @@ export function useEmbeddedEthereumWallet(options = {}) {
         status: 'idle',
     });
     // Fetch Ethereum embedded accounts
-    const fetchEmbeddedAccounts = useCallback(async () => {
+    const fetchEmbeddedAccounts = useCallback(async (options) => {
         if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
             setEmbeddedAccounts([]);
             return;
         }
         try {
+            // Only set fetching status if not called silently (e.g., during create/setActive)
+            if (!options?.silent) {
+                setStatus({ status: 'fetching-wallets' });
+            }
             const accounts = await client.embeddedWallet.list({
                 limit: 100,
                 chainType: ChainTypeEnum.EVM,
@@ -119,9 +123,15 @@ export function useEmbeddedEthereumWallet(options = {}) {
             });
             // Filter for Ethereum accounts only
             setEmbeddedAccounts(accounts);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
         catch {
             setEmbeddedAccounts([]);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
     }, [client, embeddedState, walletConfig]);
     useEffect(() => {
@@ -250,7 +260,7 @@ export function useEmbeddedEthereumWallet(options = {}) {
                 throw new OpenfortError('No supported chains available for wallet creation', OpenfortErrorType.WALLET_ERROR);
             }
             // Build recovery params
-            const recoveryParams = await buildRecoveryParams(createOptions, walletConfig);
+            const recoveryParams = await buildRecoveryParams({ ...createOptions, userId: user?.id }, walletConfig);
             const accountType = createOptions?.accountType || walletConfig?.accountType || AccountTypeEnum.SMART_ACCOUNT;
             // Create embedded wallet
             const embeddedAccount = await client.embeddedWallet.create({
@@ -263,8 +273,8 @@ export function useEmbeddedEthereumWallet(options = {}) {
             // Get provider
             const ethProvider = await getEthereumProvider();
             setProvider(ethProvider);
-            // Refresh accounts and set as active
-            await fetchEmbeddedAccounts();
+            // Refresh accounts silently (don't override 'creating' status) and set as active
+            await fetchEmbeddedAccounts({ silent: true });
             setActiveWalletId(embeddedAccount.id);
             setActiveAccount(embeddedAccount);
             setStatus({ status: 'success' });
@@ -300,7 +310,7 @@ export function useEmbeddedEthereumWallet(options = {}) {
             }
             throw error;
         }
-    }, [client, supportedChains, walletConfig, options, getEthereumProvider, fetchEmbeddedAccounts]);
+    }, [client, supportedChains, walletConfig, options, getEthereumProvider, fetchEmbeddedAccounts, user]);
     // Set active wallet action
     const setActive = useCallback(async (setActiveOptions) => {
         // Prevent concurrent recoveries
@@ -356,7 +366,7 @@ export function useEmbeddedEthereumWallet(options = {}) {
                     throw new OpenfortError(errorMsg, OpenfortErrorType.WALLET_ERROR);
                 }
                 // Build recovery params
-                const recoveryParams = await buildRecoveryParams(setActiveOptions, walletConfig);
+                const recoveryParams = await buildRecoveryParams({ ...setActiveOptions, userId: user?.id }, walletConfig);
                 // Recover the embedded wallet
                 const embeddedAccount = await client.embeddedWallet.recover({
                     account: embeddedAccountToRecover.id,
@@ -415,7 +425,7 @@ export function useEmbeddedEthereumWallet(options = {}) {
             }
         })();
         await recoverPromiseRef.current;
-    }, [client, supportedChains, walletConfig, embeddedAccounts, options, wallets.length, getEthereumProvider]);
+    }, [client, supportedChains, walletConfig, embeddedAccounts, options, wallets.length, getEthereumProvider, user]);
     // Set recovery method action
     const setRecovery = useCallback(async (params) => {
         try {
@@ -476,6 +486,9 @@ export function useEmbeddedEthereumWallet(options = {}) {
             exportPrivateKey: client.embeddedWallet.exportPrivateKey,
         };
         // Priority 1: Explicit action states (user-initiated operations)
+        if (status.status === 'fetching-wallets') {
+            return { ...baseActions, status: 'fetching-wallets', activeWallet: null };
+        }
         if (status.status === 'creating') {
             return { ...baseActions, status: 'creating', activeWallet: null };
         }

package/dist/hooks/wallet/useEmbeddedSolanaWallet.js

@@ -107,7 +107,7 @@ import { buildRecoveryParams } from './utils';
  * ```
  */
 export function useEmbeddedSolanaWallet(options = {}) {
-    const { client, walletConfig, embeddedState } = useOpenfortContext();
+    const { client, walletConfig, embeddedState, user } = useOpenfortContext();
     const [embeddedAccounts, setEmbeddedAccounts] = useState([]);
     const [activeWalletId, setActiveWalletId] = useState(null);
     const [activeAccount, setActiveAccount] = useState(null);
@@ -117,21 +117,31 @@ export function useEmbeddedSolanaWallet(options = {}) {
         status: 'idle',
     });
     // Fetch Solana embedded accounts
-    const fetchEmbeddedAccounts = useCallback(async () => {
+    const fetchEmbeddedAccounts = useCallback(async (options) => {
         if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
             setEmbeddedAccounts([]);
             return;
         }
         try {
+            // Only set fetching status if not called silently (e.g., during create/setActive)
+            if (!options?.silent) {
+                setStatus({ status: 'fetching-wallets' });
+            }
             const accounts = await client.embeddedWallet.list({
                 chainType: ChainTypeEnum.SVM,
                 accountType: AccountTypeEnum.EOA,
                 limit: 100,
             });
             setEmbeddedAccounts(accounts);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
         catch {
             setEmbeddedAccounts([]);
+            if (!options?.silent) {
+                setStatus({ status: 'idle' });
+            }
         }
     }, [client, embeddedState]);
     useEffect(() => {
@@ -266,8 +276,10 @@ export function useEmbeddedSolanaWallet(options = {}) {
         logger.info('Creating Solana wallet with options', createOptions);
         try {
             setStatus({ status: 'creating' });
-            // Build recovery params (only use recoveryPassword, ignore createAdditional)
-            const recoveryParams = await buildRecoveryParams(createOptions?.recoveryPassword ? { recoveryPassword: createOptions.recoveryPassword } : undefined, walletConfig);
+            // Build recovery params (only use recoveryPassword, otpCode, and userId, ignore createAdditional)
+            const recoveryParams = await buildRecoveryParams(createOptions?.recoveryPassword || createOptions?.otpCode || user?.id
+                ? { recoveryPassword: createOptions?.recoveryPassword, otpCode: createOptions?.otpCode, userId: user?.id }
+                : undefined, walletConfig);
             // Create embedded wallet
             const embeddedAccount = await client.embeddedWallet.create({
                 chainType: ChainTypeEnum.SVM,
@@ -278,8 +290,8 @@ export function useEmbeddedSolanaWallet(options = {}) {
             // Get provider
             const solProvider = await getSolanaProvider(embeddedAccount);
             setProvider(solProvider);
-            // Refresh accounts and set as active
-            await fetchEmbeddedAccounts();
+            // Refresh accounts silently (don't override 'creating' status) and set as active
+            await fetchEmbeddedAccounts({ silent: true });
             setActiveWalletId(embeddedAccount.id);
             setActiveAccount(embeddedAccount);
             setStatus({ status: 'success' });
@@ -315,7 +327,7 @@ export function useEmbeddedSolanaWallet(options = {}) {
             }
             throw error;
         }
-    }, [client, walletConfig, options, getSolanaProvider, fetchEmbeddedAccounts]);
+    }, [client, walletConfig, options, getSolanaProvider, fetchEmbeddedAccounts, user]);
     // Set active wallet action
     const setActive = useCallback(async (setActiveOptions) => {
         // Prevent concurrent recoveries
@@ -346,7 +358,7 @@ export function useEmbeddedSolanaWallet(options = {}) {
                     throw new OpenfortError(`No embedded Solana account found for address ${setActiveOptions.address}`, OpenfortErrorType.WALLET_ERROR);
                 }
                 // Build recovery params
-                const recoveryParams = await buildRecoveryParams(setActiveOptions, walletConfig);
+                const recoveryParams = await buildRecoveryParams({ ...setActiveOptions, userId: user?.id }, walletConfig);
                 // Recover the embedded wallet
                 const embeddedAccount = await client.embeddedWallet.recover({
                     account: embeddedAccountToRecover.id,
@@ -402,7 +414,7 @@ export function useEmbeddedSolanaWallet(options = {}) {
             }
         })();
         await recoverPromiseRef.current;
-    }, [client, walletConfig, embeddedAccounts, options, wallets.length, getSolanaProvider]);
+    }, [client, walletConfig, embeddedAccounts, options, wallets.length, getSolanaProvider, user]);
     // Build active wallet from embeddedWallet.get()
     const activeWallet = useMemo(() => {
         if (!activeWalletId || !activeAccount)
@@ -424,6 +436,9 @@ export function useEmbeddedSolanaWallet(options = {}) {
             setActive,
         };
         // Priority 1: Explicit action states (user-initiated operations)
+        if (status.status === 'fetching-wallets') {
+            return { ...baseActions, status: 'fetching-wallets', activeWallet: null };
+        }
         if (status.status === 'creating') {
             return { ...baseActions, status: 'creating', activeWallet: null };
         }

package/dist/hooks/wallet/utils.js

@@ -7,18 +7,20 @@ import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
  * It supports both callback-based session retrieval and endpoint-based session creation.
  *
  * @param walletConfig - The embedded wallet configuration from the provider
+ * @param otpCode - Optional OTP code for Shield verification
+ * @param userId - Optional user ID for the encryption session
  * @returns A promise that resolves to the encryption session string
  * @throws {OpenfortError} When wallet config is missing or session cannot be retrieved
  *
  * @internal
  */
-async function resolveEncryptionSession(walletConfig) {
+async function resolveEncryptionSession(walletConfig, otpCode, userId) {
     if (!walletConfig) {
         throw new OpenfortError('Encryption session configuration is required', OpenfortErrorType.WALLET_ERROR);
     }
     // Try callback-based session retrieval first
     if (walletConfig.getEncryptionSession) {
-        return await walletConfig.getEncryptionSession();
+        return await walletConfig.getEncryptionSession({ otpCode, userId });
     }
     // Try endpoint-based session creation
     if (walletConfig.createEncryptedSessionEndpoint) {
@@ -28,6 +30,7 @@ async function resolveEncryptionSession(walletConfig) {
                 headers: {
                     'Content-Type': 'application/json',
                 },
+                body: JSON.stringify({ otp_code: otpCode, user_id: userId }),
             });
             if (!response.ok) {
                 throw new OpenfortError('Failed to create encryption session', OpenfortErrorType.WALLET_ERROR, {
@@ -55,7 +58,7 @@ async function resolveEncryptionSession(walletConfig) {
  * 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 options - Options containing optional recovery password, OTP code, and/or user ID
  * @param walletConfig - The embedded wallet configuration from the provider
  * @returns A promise that resolves to RecoveryParams for the SDK
  *
@@ -70,6 +73,6 @@ export async function buildRecoveryParams(options, walletConfig) {
     }
     return {
         recoveryMethod: RecoveryMethod.AUTOMATIC,
-        encryptionSession: await resolveEncryptionSession(walletConfig),
+        encryptionSession: await resolveEncryptionSession(walletConfig, options?.otpCode, options?.userId),
     };
 }

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

@@ -3,6 +3,6 @@ export { RecoveryMethod } from '@openfort/openfort-js';
 export { createOpenfortClient } from './client';
 export type { OpenfortContextValue } from './context';
 export { isOpenfortContextValue, OpenfortContext, useOpenfortContext, useOpenfortContextSafe } from './context';
-export type { CommonEmbeddedWalletConfiguration, EmbeddedWalletConfiguration, EncryptionSession, OpenfortProviderProps, } from './provider';
+export type { CommonEmbeddedWalletConfiguration, EmbeddedWalletConfiguration, EncryptionSession, EncryptionSessionParams, OpenfortProviderProps, } from './provider';
 export { OpenfortProvider } from './provider';
 export { createNormalizedStorage, SecureStorageAdapter } from './storage';

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

@@ -11,9 +11,18 @@ export type CommonEmbeddedWalletConfiguration = {
     /** Recovery method for the embedded wallet: 'automatic' or 'password' */
     recoveryMethod?: 'automatic' | 'password';
 };
+/**
+ * Parameters passed to the encryption session callback
+ */
+export type EncryptionSessionParams = {
+    /** OTP code for Shield verification (if required) */
+    otpCode?: string;
+    /** User ID for the encryption session */
+    userId?: string;
+};
 export type EncryptionSession = {
-    /** Function to retrieve an encryption session using a session ID */
-    getEncryptionSession?: () => Promise<string>;
+    /** Function to retrieve an encryption session, optionally with OTP verification */
+    getEncryptionSession?: (params?: EncryptionSessionParams) => Promise<string>;
     createEncryptedSessionEndpoint?: never;
 } | {
     /** API endpoint for creating an encrypted session */

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

@@ -6,7 +6,7 @@ import type { EmbeddedWalletConfiguration } from '../../core/provider';
  * 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 options - Options containing optional recovery password, OTP code, and/or user ID
  * @param walletConfig - The embedded wallet configuration from the provider
  * @returns A promise that resolves to RecoveryParams for the SDK
  *
@@ -14,4 +14,6 @@ import type { EmbeddedWalletConfiguration } from '../../core/provider';
  */
 export declare function buildRecoveryParams(options: {
     recoveryPassword?: string;
+    otpCode?: string;
+    userId?: string;
 } | undefined, walletConfig?: EmbeddedWalletConfiguration): Promise<RecoveryParams>;

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

@@ -135,6 +135,8 @@ export type CreateEthereumWalletResult = {
 export type CreateEthereumWalletOptions = {
     chainId?: number;
     recoveryPassword?: string;
+    /** OTP code for Shield verification when using automatic recovery */
+    otpCode?: string;
     accountType?: AccountTypeEnum;
     policyId?: string;
 } & OpenfortHookOptions<CreateEthereumWalletResult>;
@@ -153,6 +155,8 @@ export type SetActiveEthereumWalletOptions = {
     address: Hex;
     chainId?: number;
     recoveryPassword?: string;
+    /** OTP code for Shield verification when using automatic recovery */
+    otpCode?: string;
 } & OpenfortHookOptions<SetActiveEthereumWalletResult>;
 /**
  * Result of setting recovery method
@@ -176,6 +180,10 @@ export type CreateSolanaEmbeddedWalletOpts = {
      * If omitted, automatic recovery will be used.
      */
     recoveryPassword?: string;
+    /**
+     * OTP code for Shield verification when using automatic recovery
+     */
+    otpCode?: string;
     /**
      * Create additional wallet if one already exists
      */
@@ -207,6 +215,8 @@ export type SetActiveSolanaWalletResult = {
 export type SetActiveSolanaWalletOptions = {
     address: string;
     recoveryPassword?: string;
+    /** OTP code for Shield verification when using automatic recovery */
+    otpCode?: string;
 } & OpenfortHookOptions<SetActiveSolanaWalletResult>;
 /**
  * Common actions available on all Ethereum wallet states
@@ -256,6 +266,9 @@ export interface SolanaWalletActions {
 export type EmbeddedEthereumWalletState = (EthereumWalletActions & {
     status: 'disconnected';
     activeWallet: null;
+}) | (EthereumWalletActions & {
+    status: 'fetching-wallets';
+    activeWallet: null;
 }) | (EthereumWalletActions & {
     status: 'connecting';
     activeWallet: ConnectedEmbeddedEthereumWallet;
@@ -283,6 +296,9 @@ export type EmbeddedEthereumWalletState = (EthereumWalletActions & {
 export type EmbeddedSolanaWalletState = (SolanaWalletActions & {
     status: 'disconnected';
     activeWallet: null;
+}) | (SolanaWalletActions & {
+    status: 'fetching-wallets';
+    activeWallet: null;
 }) | (SolanaWalletActions & {
     status: 'connecting';
 }) | (SolanaWalletActions & {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "license": "MIT",
   "description": "React Native SDK for Openfort platform integration",
   "types": "dist/types/index.d.ts",