@openfort/react-native 0.1.11 → 0.1.13

package/dist/constants/config.js

@@ -3,7 +3,7 @@
  */
 export const SDK_INFO = {
     name: '@openfort/react-native',
-    version: '0.1.9',
+    version: '0.1.13',
     description: 'React Native client for Openfort',
     homepage: 'https://openfort.io/docs',
 };

package/dist/core/client.js

@@ -39,7 +39,10 @@ export function createOpenfortClient({ baseConfiguration, overrides, shieldConfi
     // baseUrl,
     // logLevel,
     return new OpenfortClient({
-        baseConfiguration,
+        baseConfiguration: {
+            nativeAppIdentifier: nativeAppId,
+            ...baseConfiguration
+        },
         overrides: {
             ...overrides,
             crypto: {

package/dist/core/provider.js

@@ -4,6 +4,7 @@ import { OpenfortContext } from './context';
 import { createOpenfortClient, setDefaultClient } from './client';
 import { EmbeddedWalletWebView, WebViewUtils } from '../native';
 import { logger, getEmbeddedStateName } from '../lib/logger';
+import { validateEnvironment } from '../lib/environmentValidation';
 /**
  * Starts polling the embedded wallet state and invokes the callback when transitions occur.
  *
@@ -69,6 +70,11 @@ function startEmbeddedStatePolling(client, onChange, intervalMs = 1000) {
  * ```
  */
 export const OpenfortProvider = ({ children, publishableKey, customAuth, supportedChains, walletConfig, overrides, thirdPartyAuth, verbose = false, }) => {
+    // Validate environment variables before anything else
+    validateEnvironment({
+        publishableKey,
+        shieldPublishableKey: walletConfig?.shieldPublishableKey,
+    });
     // Prevent multiple OpenfortProvider instances
     const existingContext = React.useContext(OpenfortContext);
     if (existingContext) {

package/dist/hooks/wallet/index.js

@@ -5,4 +5,3 @@
  */
 // Embedded wallet hooks
 export { useWallets } from './useWallets';
-export { useWallet } from './useWallet';

package/dist/hooks/wallet/useWallets.js

@@ -73,6 +73,39 @@ export function useWallets(hookOptions = {}) {
             },
         };
     }, [activeWalletId, embeddedAccounts, client.embeddedWallet]);
+    const resolveEncryptionSession = useCallback(async () => {
+        if (!walletConfig) {
+            throw new OpenfortError('Encryption session configuration is required', OpenfortErrorType.WALLET_ERROR);
+        }
+        if (walletConfig.getEncryptionSession) {
+            return await walletConfig.getEncryptionSession();
+        }
+        if (walletConfig.createEncryptedSessionEndpoint) {
+            try {
+                const response = await fetch(walletConfig.createEncryptedSessionEndpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+                if (!response.ok) {
+                    throw new OpenfortError('Failed to create encryption session', OpenfortErrorType.WALLET_ERROR, { status: response.status });
+                }
+                const body = await response.json();
+                if (!body?.session || typeof body.session !== 'string') {
+                    throw new OpenfortError('Encryption session response is missing the `session` property', OpenfortErrorType.WALLET_ERROR);
+                }
+                return body.session;
+            }
+            catch (error) {
+                if (error instanceof OpenfortError) {
+                    throw error;
+                }
+                throw new OpenfortError('Failed to create encryption session', OpenfortErrorType.WALLET_ERROR, { error });
+            }
+        }
+        throw new OpenfortError('Encryption session configuration is required', OpenfortErrorType.WALLET_ERROR);
+    }, [walletConfig]);
     const setActiveWallet = useCallback(async (options) => {
         // If there's already a recovery in progress, return the existing promise
         if (recoverPromiseRef.current) {
@@ -105,22 +138,22 @@ export function useWallets(hookOptions = {}) {
                     chainId = supportedChains[0].id;
                 }
                 const address = options?.address || wallets[0]?.address;
-                const embeddedAccountToRecover = embeddedAccounts.find(account => account.chainId === chainId && account.address === address);
+                // Find account to recover based on whether we're using EOA or Smart Account
+                let embeddedAccountToRecover;
+                if (walletConfig?.accountType === AccountTypeEnum.EOA) {
+                    // For EOAs, match only by address (EOAs work across all chains)
+                    embeddedAccountToRecover = embeddedAccounts.find(account => account.address.toLowerCase() === address?.toLowerCase());
+                }
+                else {
+                    // For Smart Accounts, match by both address and chainId (Smart Accounts are chain-specific)
+                    embeddedAccountToRecover = embeddedAccounts.find(account => account.chainId === chainId && account.address.toLowerCase() === address?.toLowerCase());
+                }
                 let embeddedAccount;
                 if (!embeddedAccountToRecover) {
-                    // Different chain maybe?
-                    // if (embeddedAccounts.some(account => account.address === address)) {
-                    // create wallet with new chain
-                    // embeddedAccount = await client.embeddedWallet.create({
-                    //   chainId: chainId!,
-                    //   accountType: AccountTypeEnum.SMART_ACCOUNT,
-                    //   chainType: ChainTypeEnum.EVM,
-                    //   shieldAuthentication: shieldAuthentication ?? undefined,
-                    //   recoveryParams: options?.recoveryPassword ? { password: options.recoveryPassword, recoveryMethod: RecoveryMethod.PASSWORD } : undefined
-                    // });
-                    // } else {
-                    throw new OpenfortError(`No embedded account found for address ${address} on chain ID ${chainId}`, OpenfortErrorType.WALLET_ERROR);
-                    // }
+                    const errorMsg = walletConfig?.accountType === AccountTypeEnum.EOA
+                        ? `No embedded EOA account found for address ${address}`
+                        : `No embedded account found for address ${address} on chain ID ${chainId}`;
+                    throw new OpenfortError(errorMsg, OpenfortErrorType.WALLET_ERROR);
                 }
                 else {
                     let recoveryParams;
@@ -132,12 +165,9 @@ export function useWallets(hookOptions = {}) {
                         };
                     }
                     else {
-                        if (!walletConfig?.getEncryptionSession) {
-                            throw new OpenfortError('Encryption session (walletConfig.getEncryptionSession) is required for automatic recovery', OpenfortErrorType.WALLET_ERROR);
-                        }
                         recoveryParams = {
                             recoveryMethod: RecoveryMethod.AUTOMATIC,
-                            encryptionSession: await walletConfig.getEncryptionSession()
+                            encryptionSession: await resolveEncryptionSession()
                         };
                     }
                     // Recover the embedded wallet with shield authentication
@@ -185,7 +215,7 @@ export function useWallets(hookOptions = {}) {
             }
         })();
         return recoverPromiseRef.current;
-    }, [client, supportedChains, walletConfig, _internal, embeddedAccounts, hookOptions]);
+    }, [client, supportedChains, resolveEncryptionSession, _internal, embeddedAccounts, hookOptions]);
     // Fetch embedded wallets using embeddedWallet.list()
     const fetchEmbeddedWallets = useCallback(async () => {
         if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
@@ -193,13 +223,18 @@ export function useWallets(hookOptions = {}) {
             return;
         }
         try {
-            const accounts = await client.embeddedWallet.list();
+            const accounts = await client.embeddedWallet.list({
+                limit: 100,
+                // If its EOA we want all accounts, otherwise we want only smart accounts
+                accountType: walletConfig?.accountType === AccountTypeEnum.EOA ?
+                    undefined : AccountTypeEnum.SMART_ACCOUNT
+            });
             setEmbeddedAccounts(accounts);
         }
         catch {
             setEmbeddedAccounts([]);
         }
-    }, [client, embeddedState, user]);
+    }, [client, embeddedState, user, walletConfig]);
     useEffect(() => {
         fetchEmbeddedWallets();
     }, [fetchEmbeddedWallets]);
@@ -233,24 +268,36 @@ export function useWallets(hookOptions = {}) {
         })();
     }, [setActiveWalletId, client]);
     // Extract Ethereum wallets from embedded accounts
-    const wallets = useMemo(() => (embeddedAccounts
-        .reduce((acc, account) => {
-        if (!acc.some(a => a.address === account.address)) {
-            acc.push(account);
-        }
-        return acc;
-    }, [])
-        .map((account) => ({
-        address: account.address,
-        implementationType: account.implementationType,
-        ownerAddress: account.ownerAddress,
-        chainType: account.chainType,
-        isActive: activeWalletId === account.id,
-        isConnecting: status.status === "connecting" && status.address === account.address,
-        getProvider: async () => {
-            return await getEthereumProvider();
-        },
-    }))), [embeddedAccounts, activeWalletId, status.status === "connecting", client.embeddedWallet]);
+    const wallets = useMemo(() => {
+        // Deduplicate accounts based on account type
+        const deduplicatedAccounts = embeddedAccounts.reduce((acc, account) => {
+            if (walletConfig?.accountType === AccountTypeEnum.EOA) {
+                // For EOAs, deduplicate by address only (EOAs work across all chains)
+                if (!acc.some(a => a.address.toLowerCase() === account.address.toLowerCase())) {
+                    acc.push(account);
+                }
+            }
+            else {
+                // For Smart Accounts, keep separate entries per chain (they're chain-specific)
+                // Only deduplicate exact matches (same address AND same chainId)
+                if (!acc.some(a => a.address.toLowerCase() === account.address.toLowerCase() && a.chainId === account.chainId)) {
+                    acc.push(account);
+                }
+            }
+            return acc;
+        }, []);
+        return deduplicatedAccounts.map((account) => ({
+            address: account.address,
+            implementationType: account.implementationType,
+            ownerAddress: account.ownerAddress,
+            chainType: account.chainType,
+            isActive: activeWalletId === account.id,
+            isConnecting: status.status === "connecting" && status.address === account.address,
+            getProvider: async () => {
+                return await getEthereumProvider();
+            },
+        }));
+    }, [embeddedAccounts, activeWalletId, status.status, walletConfig?.accountType, client.embeddedWallet]);
     const create = useCallback(async (options) => {
         logger.info('Creating Ethereum wallet with options', options);
         try {
@@ -282,12 +329,9 @@ export function useWallets(hookOptions = {}) {
                 };
             }
             else {
-                if (!walletConfig?.getEncryptionSession) {
-                    throw new OpenfortError('Encryption session (walletConfig.getEncryptionSession) is required for automatic recovery', OpenfortErrorType.WALLET_ERROR);
-                }
                 recoveryParams = {
                     recoveryMethod: RecoveryMethod.AUTOMATIC,
-                    encryptionSession: await walletConfig.getEncryptionSession()
+                    encryptionSession: await resolveEncryptionSession()
                 };
             }
             // Configure embedded wallet with shield authentication
@@ -337,7 +381,7 @@ export function useWallets(hookOptions = {}) {
                 error
             });
         }
-    }, [client, supportedChains, walletConfig, _internal, user]);
+    }, [client, supportedChains, walletConfig, resolveEncryptionSession, _internal, user]);
     const setRecovery = useCallback(async (params) => {
         try {
             setStatus({

package/dist/index.js

@@ -10,7 +10,9 @@
 // Re-export commonly used types from @openfort/openfort-js
 export { OpenfortError, RecoveryMethod, Openfort as OpenfortClient, OpenfortConfiguration, ShieldConfiguration, EmbeddedState, } from '@openfort/openfort-js';
 // Re-export enums and values from @openfort/openfort-js
-export { OAuthProvider, } from '@openfort/openfort-js';
+export { OAuthProvider, AccountTypeEnum, } from '@openfort/openfort-js';
+// Re-export event listener functionality from @openfort/openfort-js
+export { openfortEvents, OpenfortEvents, } from '@openfort/openfort-js';
 // Re-export all types from the main types module
 export * from './types';
 // Re-export all hooks

package/dist/lib/environmentValidation.js

@@ -0,0 +1,25 @@
+/**
+ * Maps config keys to their corresponding .env variable names
+ */
+const KEY_TO_ENV_VAR = {
+    publishableKey: 'OPENFORT_PUBLISHABLE_KEY',
+    shieldPublishableKey: 'OPENFORT_SHIELD_PUBLISHABLE_KEY',
+};
+/**
+ * Validates that required environment variables are present.
+ *
+ * @param config - Dictionary of configuration keys and their values
+ * @throws Error if required environment variables are missing
+ */
+export function validateEnvironment(config) {
+    const missing = [];
+    Object.entries(config).forEach(([key, value]) => {
+        if (!value) {
+            const envVarName = KEY_TO_ENV_VAR[key] || key;
+            missing.push(envVarName);
+        }
+    });
+    if (missing.length > 0) {
+        throw new Error(`[Openfort SDK] Missing required .env variables: ${missing.join(', ')}`);
+    }
+}

package/dist/types/constants/config.d.ts

@@ -3,7 +3,7 @@
  */
 export declare const SDK_INFO: {
     readonly name: "@openfort/react-native";
-    readonly version: "0.1.9";
+    readonly version: "0.1.13";
     readonly description: "React Native client for Openfort";
     readonly homepage: "https://openfort.io/docs";
 };

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import { SDKOverrides, AccountTypeEnum, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 /**
- * Shape for configuring custom authentication synchronisation behaviour.
+ * Shape for configuring custom authentication synchronization behavior.
  */
 interface CustomAuthConfig {
     enabled: boolean;
@@ -16,6 +16,8 @@ export type CommonEmbeddedWalletConfiguration = {
     ethereumProviderPolicyId?: PolicyConfig;
     accountType?: AccountTypeEnum;
     debug?: boolean;
+    /** Recovery method for the embedded wallet: 'automatic' or 'password' */
+    recoveryMethod?: 'automatic' | 'password';
 };
 export type EncryptionSession = {
     /** Function to retrieve an encryption session using a session ID */

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

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

package/dist/types/index.d.ts

@@ -7,8 +7,9 @@
  * 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';
+export { AuthPlayerResponse, OpenfortError, RecoveryMethod, RecoveryParams, Openfort as OpenfortClient, Provider, OpenfortConfiguration, ShieldConfiguration, EmbeddedState, AuthResponse, EmbeddedAccount, SignedMessagePayload, AuthInitPayload, } from '@openfort/openfort-js';
+export { OAuthProvider, AccountTypeEnum, } from '@openfort/openfort-js';
+export { openfortEvents, OpenfortEventMap, OpenfortEvents, } from '@openfort/openfort-js';
 export * from './types';
 export * from './hooks';
 export * from './components';

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

@@ -0,0 +1,7 @@
+/**
+ * Validates that required environment variables are present.
+ *
+ * @param config - Dictionary of configuration keys and their values
+ * @throws Error if required environment variables are missing
+ */
+export declare function validateEnvironment(config: Record<string, string | undefined>): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "license": "MIT",
   "description": "React Native SDK for Openfort platform integration",
   "scripts": {
@@ -23,7 +23,7 @@
     }
   },
   "dependencies": {
-    "@openfort/openfort-js": "^0.10.24"
+    "@openfort/openfort-js": "^0.10.28"
   },
   "peerDependencies": {
     "expo-apple-authentication": "*",

package/dist/hooks/wallet/useWallet.js

@@ -1,32 +0,0 @@
-import { useWallets } from "./useWallets";
-/**
- * Hook for accessing the currently active embedded wallet
- *
- * This hook provides access to the currently active embedded wallet from the wallet collection.
- * It automatically updates when the active wallet changes through other wallet operations.
- *
- * @returns The active embedded wallet when available, otherwise `null`
- *
- * @example
- * ```tsx
- * const activeWallet = useWallet();
- *
- * // Check if wallet is available
- * if (activeWallet) {
- *   console.log('Active wallet address:', activeWallet.address);
- *
- *   // Get provider for transactions
- *   const provider = await activeWallet.getProvider();
- *
- *   // Use wallet for operations
- *   console.log('Wallet chain type:', activeWallet.chainType);
- *   console.log('Is connecting:', activeWallet.isConnecting);
- * } else {
- *   console.log('No active wallet available');
- * }
- * ```
- */
-export function useWallet() {
-    const { activeWallet } = useWallets();
-    return activeWallet;
-}

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

@@ -1,28 +0,0 @@
-/**
- * Hook for accessing the currently active embedded wallet
- *
- * This hook provides access to the currently active embedded wallet from the wallet collection.
- * It automatically updates when the active wallet changes through other wallet operations.
- *
- * @returns The active embedded wallet when available, otherwise `null`
- *
- * @example
- * ```tsx
- * const activeWallet = useWallet();
- *
- * // Check if wallet is available
- * if (activeWallet) {
- *   console.log('Active wallet address:', activeWallet.address);
- *
- *   // Get provider for transactions
- *   const provider = await activeWallet.getProvider();
- *
- *   // Use wallet for operations
- *   console.log('Wallet chain type:', activeWallet.chainType);
- *   console.log('Is connecting:', activeWallet.isConnecting);
- * } else {
- *   console.log('No active wallet available');
- * }
- * ```
- */
-export declare function useWallet(): import("../..").UserWallet | null;