@openfort/react-native 0.1.3 → 0.1.5

package/dist/core/client.js

@@ -2,6 +2,7 @@ import { Openfort as OpenfortClient } from '@openfort/openfort-js';
 import { digest } from 'expo-crypto';
 import { applicationId } from 'expo-application';
 import { SecureStorageAdapter, createNormalizedStorage } from './storage';
+import { logger } from '../lib/logger';
 /**
  * Creates an instance of the Openfort client configured for Expo/React Native
  *
@@ -16,7 +17,7 @@ import { SecureStorageAdapter, createNormalizedStorage } from './storage';
  */
 export function createOpenfortClient({ baseConfiguration, overrides, shieldConfiguration, }) {
     const nativeAppId = getNativeApplicationId();
-    console.log('Creating Openfort client with native app ID:', nativeAppId);
+    logger.info('Creating Openfort client with native app ID', nativeAppId);
     // appId,
     // clientId,
     // supportedChains,

package/dist/core/provider.js

@@ -1,18 +1,54 @@
-import React, { useState, useEffect, useCallback, useMemo, useRef } from 'react';
-import { OpenfortConfiguration, ShieldConfiguration, EmbeddedState } from '@openfort/openfort-js';
+import React, { useState, useEffect, useCallback, useMemo } from 'react';
+import { OpenfortConfiguration, ShieldConfiguration, EmbeddedState, } from '@openfort/openfort-js';
 import { OpenfortContext } from './context';
 import { createOpenfortClient, setDefaultClient } from './client';
 import { EmbeddedWalletWebView, WebViewUtils } from '../native';
+import { logger, getEmbeddedStateName } from '../lib/logger';
+/**
+ * Starts polling the embedded wallet state and calls onChange only when the
+ * state actually changes. Returns a cleanup function to stop polling.
+ */
+function startEmbeddedStatePolling(client, onChange, intervalMs = 1000) {
+    let lastState = null;
+    let stopped = false;
+    const check = async () => {
+        if (stopped)
+            return;
+        try {
+            const state = await client.embeddedWallet.getEmbeddedState();
+            if (state !== lastState) {
+                lastState = state;
+                onChange(state);
+            }
+        }
+        catch (error) {
+            logger.error('Error checking embedded state with Openfort', error);
+        }
+    };
+    const intervalId = setInterval(check, intervalMs);
+    // Run once immediately so we don't wait for the first interval tick
+    void check();
+    return () => {
+        stopped = true;
+        clearInterval(intervalId);
+    };
+}
 /**
  * Main provider component that wraps the entire application and provides
  * Openfort SDK functionality through React context
  */
-export const OpenfortProvider = ({ children, publishableKey, customAuth, supportedChains, walletConfig, overrides, }) => {
+export const OpenfortProvider = ({ children, publishableKey, customAuth, supportedChains, walletConfig, overrides, thirdPartyAuth, verbose = false, }) => {
     // Prevent multiple OpenfortProvider instances
     const existingContext = React.useContext(OpenfortContext);
     if (existingContext) {
         throw new Error('Found multiple instances of OpenfortProvider. Ensure there is only one mounted in your application tree.');
     }
+    // Set logger verbose mode
+    useEffect(() => {
+        if (verbose)
+            logger.printVerboseWarning();
+        logger.setVerbose(verbose);
+    }, [verbose]);
     // Create or use provided client
     const client = useMemo(() => {
         const newClient = createOpenfortClient({
@@ -21,49 +57,25 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
             }),
             shieldConfiguration: walletConfig ? new ShieldConfiguration({
                 shieldPublishableKey: walletConfig.shieldPublishableKey,
-                shieldEncryptionKey: 'shieldEncryptionKey' in walletConfig ? walletConfig.shieldEncryptionKey : undefined,
                 shieldDebug: walletConfig.debug,
             }) : undefined,
-            overrides: {
-                ...overrides,
-            },
+            overrides,
+            thirdPartyAuth,
         });
         setDefaultClient(newClient);
         return newClient;
     }, [publishableKey, walletConfig, overrides]);
     // Embedded state
     const [embeddedState, setEmbeddedState] = useState(EmbeddedState.NONE);
-    const pollingRef = useRef(null);
-    const pollEmbeddedState = useCallback(async () => {
-        if (!client)
-            return;
-        try {
-            const state = await client.embeddedWallet.getEmbeddedState();
-            console.log('Current embedded state:', state);
-            setEmbeddedState(state);
-        }
-        catch (error) {
-            console.error('Error checking embedded state with Openfort:', error);
-            if (pollingRef.current)
-                clearInterval(pollingRef.current);
-        }
-    }, [client]);
-    const startPollingEmbeddedState = useCallback(() => {
-        if (pollingRef.current)
-            return;
-        pollingRef.current = setInterval(pollEmbeddedState, 1000);
-    }, [pollEmbeddedState]);
-    const stopPollingEmbeddedState = useCallback(() => {
-        clearInterval(pollingRef.current || undefined);
-        pollingRef.current = null;
-    }, []);
+    // Start polling embedded state: only update and log when state changes
     useEffect(() => {
         if (!client)
             return;
-        startPollingEmbeddedState();
-        return () => {
-            stopPollingEmbeddedState();
-        };
+        const stop = startEmbeddedStatePolling(client, (state) => {
+            setEmbeddedState(state);
+            logger.info('Current state of the embedded wallet:', getEmbeddedStateName(state));
+        }, 1000);
+        return stop;
     }, [client]);
     // Core state
     const [user, setUser] = useState(null);
@@ -77,7 +89,15 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
     const [recoveryFlowState, setRecoveryFlowState] = useState({ status: 'initial' });
     // User state management
     const handleUserChange = useCallback((newUser) => {
-        console.log('User state changed:', newUser);
+        if (newUser === null) {
+            logger.info('User not authenticated. User state changed to: null');
+        }
+        else if ('id' in newUser) {
+            logger.info('User authenticated. User state changed to user with id:', newUser.id);
+        }
+        else {
+            logger.error('User state changed to user in wrong format:', newUser);
+        }
         setUser(newUser);
         if (newUser) {
             setError(null);
@@ -93,41 +113,22 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
             return await client.getAccessToken();
         }
         catch (err) {
-            console.debug('Failed to get access token:', err);
+            logger.debug('Failed to get access token', err);
             return null;
         }
     }, [client]);
-    // Initialize client and user
-    useEffect(() => {
-        console.log('Initializing Openfort client and user state', isUserInitialized);
-        if (!isUserInitialized) {
-            (async () => {
-                console.log('Initializing Openfort client');
-                try {
-                    // Openfort client doesn't need explicit initialization
-                    setIsClientReady(true);
-                }
-                catch (err) {
-                    setError(err instanceof Error ? err : new Error(String(err)));
-                }
-                try {
-                    console.log('Refreshing user state on initial load');
-                    await refreshUserState();
-                }
-                catch {
-                    // User not logged in, which is fine
-                    handleUserChange(null);
-                }
-                finally {
-                    setIsUserInitialized(true);
-                }
-            })();
-        }
-    }, [client, isUserInitialized, handleUserChange]);
     // Internal refresh function for auth hooks to use
     const refreshUserState = useCallback(async (user) => {
         try {
-            console.log('Refreshing user state', user);
+            if (user === undefined) {
+                logger.info('Refreshing user state, no user provided');
+            }
+            else if ('id' in user) {
+                logger.info('Refreshing user state, user provided with id:', user.id);
+            }
+            else {
+                logger.error('Refreshing user state, user provided is in wrong format:', user);
+            }
             // If user is provided, use it directly instead of fetching from API
             if (user !== undefined) {
                 handleUserChange(user);
@@ -135,16 +136,46 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
             }
             // Otherwise, fetch from API
             const currentUser = await client.user.get();
-            console.log('Refreshed user state:', currentUser);
+            logger.info('Refreshed user state', currentUser);
             handleUserChange(currentUser);
             return currentUser;
         }
         catch (err) {
-            console.log('Failed to refresh user state:', err);
+            logger.warn('Failed to refresh user state', err);
             handleUserChange(null);
             return null;
         }
     }, [client, handleUserChange]);
+    // Initialize client and user
+    useEffect(() => {
+        if (isUserInitialized) {
+            logger.info('Openfort client and user state already initialized. isUserInitialized:', isUserInitialized);
+            return;
+        }
+        let cancelled = false;
+        const initialize = async () => {
+            logger.info('Initializing Openfort client and user state');
+            // No explicit client initialization required
+            setIsClientReady(true);
+            try {
+                logger.info('Refreshing user state on initial load');
+                await refreshUserState();
+            }
+            catch (err) {
+                logger.error('Failed to initialize user state', err);
+                // User not logged in or fetch failed; treat as unauthenticated
+                handleUserChange(null);
+            }
+            finally {
+                if (!cancelled)
+                    setIsUserInitialized(true);
+            }
+        };
+        void initialize();
+        return () => {
+            cancelled = true;
+        };
+    }, [client, isUserInitialized, handleUserChange, refreshUserState]);
     // Custom auth state management
     useEffect(() => {
         if (customAuth?.enabled && isUserInitialized && isClientReady) {
@@ -157,11 +188,11 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
                     if (customToken) {
                         // Custom auth sync implementation would go here
                         // This would typically handle SIWE authentication with the custom token
-                        console.debug('Custom token available for authentication sync');
+                        logger.debug('Custom token available for authentication sync');
                     }
                 }
                 catch (err) {
-                    console.error('Custom auth sync failed:', err);
+                    logger.error('Custom auth sync failed', err);
                 }
             })();
         }
@@ -217,8 +248,8 @@ export const OpenfortProvider = ({ children, publishableKey, customAuth, support
         children,
         client && isReady && WebViewUtils.isSupported() && (React.createElement(EmbeddedWalletWebView, { client: client, isClientReady: isReady, onProxyStatusChange: (status) => {
                 // Handle WebView status changes for debugging
-                if (process.env.NODE_ENV === 'development') {
-                    console.debug('WebView status changed:', status);
+                if (verbose) {
+                    logger.debug('WebView status changed', status);
                 }
             } }))));
 };

package/dist/core/storage.js

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as SecureStore from 'expo-secure-store';
 import { NativeStorageUtils } from '../native';
+import { logger } from '../lib/logger';
 // Define the StorageKeys enum values that match the Openfort SDK
 var StorageKeys;
 (function (StorageKeys) {
@@ -29,16 +30,16 @@ export const SecureStorageAdapter = {
             }
             // Handle unexpected Promise-like objects (shouldn't happen according to docs)
             if (result && typeof result === 'object' && '_j' in result) {
-                console.warn('WARNING: SecureStore returned a Promise-like object instead of a string');
+                logger.warn('WARNING: SecureStore returned a Promise-like object instead of a string');
                 const actualValue = result._j;
                 return typeof actualValue === 'string' ? actualValue : null;
             }
             // If we get here, something is wrong
-            console.error('Unexpected result type from SecureStore:', result);
+            logger.error('Unexpected result type from SecureStore', result);
             return null;
         }
         catch (error) {
-            console.warn('Failed to get item from secure store:', error);
+            logger.warn('Failed to get item from secure store', error);
             return null;
         }
     },
@@ -48,7 +49,7 @@ export const SecureStorageAdapter = {
             await SecureStore.setItemAsync(normalizedKey, value, NativeStorageUtils.getStorageOptions());
         }
         catch (error) {
-            console.warn('Failed to set item in secure store:', error);
+            logger.warn('Failed to set item in secure store', error);
             throw error;
         }
     },
@@ -58,7 +59,7 @@ export const SecureStorageAdapter = {
             await SecureStore.deleteItemAsync(normalizedKey, NativeStorageUtils.getStorageOptions());
         }
         catch (error) {
-            console.warn('Failed to delete item from secure store:', error);
+            logger.warn('Failed to delete item from secure store', error);
             throw error;
         }
     },
@@ -96,23 +97,23 @@ export function createNormalizedStorage(customStorage) {
             return result;
         },
         save(key, value) {
-            console.log('storage save:', key, value);
+            logger.info(`Saving to storage key: ${key}, value: ${value}`);
             const storageKey = keyToStorageKeys(key);
             // Fire and forget - don't await as the SDK expects synchronous behavior
             baseStorage.save(storageKey, value).catch(error => {
-                console.error('Failed to save to storage:', error);
+                logger.error('Failed to save to storage', error);
             });
         },
         remove(key) {
-            console.log('storage remove:', key);
+            logger.info(`Removing from storage key: ${key}`);
             const storageKey = keyToStorageKeys(key);
             // Fire and forget - don't await as the SDK expects synchronous behavior
             baseStorage.remove(storageKey).catch(error => {
-                console.error('Failed to remove from storage:', error);
+                logger.error('Failed to remove from storage', error);
             });
         },
         flush() {
-            console.log('storage flush');
+            logger.info('Flushing storage');
             baseStorage.flush();
         },
     };

package/dist/hooks/wallet/useWallets.js

@@ -6,6 +6,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useOpenfortContext } from '../../core/context';
 import { onError, onSuccess } from '../../lib/hookConsistency';
 import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+import { logger } from '../../lib/logger';
 const mapWalletStatus = (status) => {
     return {
         error: status.error,
@@ -130,7 +131,7 @@ export function useWallets(hookOptions = {}) {
                     }
                     else {
                         if (!walletConfig?.getEncryptionSession) {
-                            throw new OpenfortError('Encryption session is required for automatic recovery', OpenfortErrorType.WALLET_ERROR);
+                            throw new OpenfortError('Encryption session (walletConfig.getEncryptionSession) is required for automatic recovery', OpenfortErrorType.WALLET_ERROR);
                         }
                         recoveryParams = {
                             recoveryMethod: RecoveryMethod.AUTOMATIC,
@@ -231,7 +232,7 @@ export function useWallets(hookOptions = {}) {
         },
     }))), [embeddedAccounts, activeWalletId, status.status === "connecting", client.embeddedWallet]);
     const create = useCallback(async (options) => {
-        console.log('Creating Ethereum wallet with options:', options);
+        logger.info('Creating Ethereum wallet with options', options);
         try {
             setStatus({
                 status: 'creating',
@@ -251,7 +252,7 @@ export function useWallets(hookOptions = {}) {
             else {
                 throw new OpenfortError('No supported chains available for wallet creation', OpenfortErrorType.WALLET_ERROR);
             }
-            console.log('Using chain ID for wallet creation:', chainId);
+            logger.info('Using chain ID for wallet creation', chainId);
             let recoveryParams;
             ;
             if (options?.recoveryPassword) {
@@ -262,7 +263,7 @@ export function useWallets(hookOptions = {}) {
             }
             else {
                 if (!walletConfig?.getEncryptionSession) {
-                    throw new OpenfortError('Encryption session is required for automatic recovery', OpenfortErrorType.WALLET_ERROR);
+                    throw new OpenfortError('Encryption session (walletConfig.getEncryptionSession) is required for automatic recovery', OpenfortErrorType.WALLET_ERROR);
                 }
                 recoveryParams = {
                     recoveryMethod: RecoveryMethod.AUTOMATIC,
@@ -276,7 +277,7 @@ export function useWallets(hookOptions = {}) {
                 chainType: options?.chainType || ChainTypeEnum.EVM,
                 recoveryParams,
             });
-            console.log('Embedded wallet configured with shield authentication');
+            logger.info('Embedded wallet configured with shield authentication');
             // Get the Ethereum provider
             const provider = await client.embeddedWallet.getEthereumProvider({
                 announceProvider: false,

package/dist/index.js

@@ -8,6 +8,8 @@
  * @author Openfort
  * @version 0.1.0
  */
+// 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';
 // Re-export all types from the main types module

package/dist/lib/logger.js

@@ -0,0 +1,62 @@
+// Lightweight logger with standardized prefix
+// Usage: logger.info('message', optionalData)
+import { EmbeddedState } from '@openfort/openfort-js';
+const PREFIX = '[OPENFORT_PROVIDER]';
+let verboseMode = false;
+function formatMessage(level, message) {
+    const text = typeof message === 'string' ? message : JSON.stringify(message);
+    return `${PREFIX} ${text}`;
+}
+function log(level, message, ...optionalParams) {
+    // Only log debug and info messages in verbose mode
+    if ((level === 'debug' || level === 'info') && !verboseMode) {
+        return;
+    }
+    const formatted = formatMessage(level, message);
+    switch (level) {
+        case 'debug':
+            // eslint-disable-next-line no-console
+            console.debug(formatted, ...optionalParams);
+            break;
+        case 'info':
+            // eslint-disable-next-line no-console
+            console.log(formatted, ...optionalParams);
+            break;
+        case 'warn':
+            // eslint-disable-next-line no-console
+            console.warn(formatted, ...optionalParams);
+            break;
+        case 'error':
+            // eslint-disable-next-line no-console
+            console.error(formatted, ...optionalParams);
+            break;
+    }
+}
+export const logger = {
+    debug: (message, ...optionalParams) => log('debug', message, ...optionalParams),
+    info: (message, ...optionalParams) => log('info', message, ...optionalParams),
+    warn: (message, ...optionalParams) => log('warn', message, ...optionalParams),
+    error: (message, ...optionalParams) => log('error', message, ...optionalParams),
+    setVerbose: (verbose) => {
+        verboseMode = verbose;
+    },
+    printVerboseWarning: () => {
+        log('warn', 'Verbose mode is enabled. Debug and info logs will be printed. To disable, set the "verbose" prop on OpenfortProvider to false.');
+    },
+};
+export const getEmbeddedStateName = (state) => {
+    switch (state) {
+        case EmbeddedState.NONE:
+            return 'NONE';
+        case EmbeddedState.UNAUTHENTICATED:
+            return 'UNAUTHENTICATED';
+        case EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED:
+            return 'EMBEDDED_SIGNER_NOT_CONFIGURED';
+        case EmbeddedState.CREATING_ACCOUNT:
+            return 'CREATING_ACCOUNT';
+        case EmbeddedState.READY:
+            return 'READY';
+        default:
+            return `STATE: ${String(state)}`;
+    }
+};

package/dist/native/oauth.js

@@ -1,6 +1,7 @@
 import { Platform } from 'react-native';
 import * as WebBrowser from 'expo-web-browser';
 import * as Linking from 'expo-linking';
+import { logger } from '../lib/logger';
 import * as AppleAuthentication from 'expo-apple-authentication';
 import { OAuthProvider as OAuthProviderType } from '@openfort/openfort-js';
 /**
@@ -94,7 +95,7 @@ export async function isAppleSignInAvailable() {
 export function parseOAuthUrl(url) {
     try {
         const { queryParams } = Linking.parse(url);
-        console.log('Parsed OAuth URL:', queryParams);
+        logger.info('Parsed OAuth URL', queryParams);
         return {
             access_token: queryParams?.access_token,
             refresh_token: queryParams?.refresh_token,
@@ -104,7 +105,7 @@ export function parseOAuthUrl(url) {
         };
     }
     catch (error) {
-        console.warn('Failed to parse OAuth URL:', error);
+        logger.warn('Failed to parse OAuth URL', error);
         return {};
     }
 }

package/dist/native/storage.js

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as SecureStore from 'expo-secure-store';
 import { Platform } from 'react-native';
+import { logger } from '../lib/logger';
 /**
  * Checks if a message is a secure storage related message
  */
@@ -22,7 +23,7 @@ export function isSecureStorageMessage(message) {
  * Handles secure storage operations from WebView messages
  */
 export async function handleSecureStorageMessage(message) {
-    console.log('Handling secure storage message:', message);
+    logger.info('Handling secure storage message', message);
     switch (message.event) {
         case 'app:secure-storage:get': {
             const { key } = message.data;
@@ -37,7 +38,7 @@ export async function handleSecureStorageMessage(message) {
                 };
             }
             catch (error) {
-                console.warn('Failed to get the value from secure store', error);
+                logger.warn('Failed to get the value from secure store', error);
                 return {
                     event: message.event,
                     id: message.id,
@@ -58,7 +59,7 @@ export async function handleSecureStorageMessage(message) {
                 };
             }
             catch (error) {
-                console.warn('Failed to write the value to secure store', error);
+                logger.warn('Failed to write the value to secure store', error);
                 return {
                     event: message.event,
                     id: message.id,
@@ -79,7 +80,7 @@ export async function handleSecureStorageMessage(message) {
                 };
             }
             catch (error) {
-                console.warn('Failed to remove the value from secure store', error);
+                logger.warn('Failed to remove the value from secure store', error);
                 return {
                     event: message.event,
                     id: message.id,
@@ -105,11 +106,11 @@ export async function handleSecureStorageMessage(message) {
                     }
                     catch (error) {
                         // Ignore errors for keys that don't exist
-                        console.debug(`Key ${fullKey} not found during flush:`, error);
+                        logger.debug(`Key ${fullKey} not found during flush`, error);
                     }
                 });
                 await Promise.all(deletePromises);
-                console.log('Flushed secure storage for origin:', origin);
+                logger.info('Flushed secure storage for origin', origin);
                 return {
                     event: message.event,
                     id: message.id,
@@ -117,7 +118,7 @@ export async function handleSecureStorageMessage(message) {
                 };
             }
             catch (error) {
-                console.warn('Failed to flush secure store', error);
+                logger.warn('Failed to flush secure store', error);
                 return {
                     event: message.event,
                     id: message.id,

package/dist/native/webview.js

@@ -3,6 +3,7 @@ import React, { useRef, useCallback, useEffect } from 'react';
 import { AppState, Platform, View } from 'react-native';
 import WebView from 'react-native-webview';
 import { isSecureStorageMessage, handleSecureStorageMessage } from './storage';
+import { logger } from '../lib/logger';
 /**
  * WebView component for embedded wallet integration
  * Handles secure communication between React Native and the embedded wallet WebView
@@ -23,7 +24,7 @@ export const EmbeddedWalletWebView = ({ client, isClientReady, onProxyStatusChan
                     // }
                 }
                 catch (error) {
-                    console.warn('Failed to ping embedded wallet:', error);
+                    logger.warn('Failed to ping embedded wallet', error);
                 }
             }
         };
@@ -35,7 +36,7 @@ export const EmbeddedWalletWebView = ({ client, isClientReady, onProxyStatusChan
         onProxyStatusChange?.('loaded');
     }, [onProxyStatusChange]);
     const handleError = useCallback((error) => {
-        console.error('WebView error:', error);
+        logger.error('WebView error', error);
     }, []);
     // Set up WebView reference with client immediately when both are available
     useEffect(() => {
@@ -65,7 +66,7 @@ export const EmbeddedWalletWebView = ({ client, isClientReady, onProxyStatusChan
             client.embeddedWallet.onMessage(messageData);
         }
         catch (error) {
-            console.error('Failed to handle WebView message:', error);
+            logger.error('Failed to handle WebView message', error);
             // Don't crash the app on message handling errors
         }
     }, [client]);

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

@@ -4,5 +4,5 @@ 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 type { OpenfortProviderProps, EmbeddedWalletConfiguration, CommonEmbeddedWalletConfiguration, EncryptionSession, } from './provider';
 export { SecureStorageAdapter, createNormalizedStorage } from './storage';

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { RecoveryMethod, SDKOverrides, AccountTypeEnum } from '@openfort/openfort-js';
+import { SDKOverrides, AccountTypeEnum, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 /**
  * Custom auth configuration
  */
@@ -13,36 +13,18 @@ export type CommonEmbeddedWalletConfiguration = {
     shieldPublishableKey: string;
     /** Policy ID (pol_...) for the embedded signer */
     ethereumProviderPolicyId?: string;
-    debug?: boolean;
     accountType?: AccountTypeEnum;
+    debug?: boolean;
 };
 export type EncryptionSession = {
     /** Function to retrieve an encryption session using a session ID */
-    getEncryptionSession: () => Promise<string>;
+    getEncryptionSession?: () => Promise<string>;
     createEncryptedSessionEndpoint?: never;
 } | {
     /** API endpoint for creating an encrypted session */
-    createEncryptedSessionEndpoint: string;
+    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.
@@ -55,7 +37,7 @@ export type PasswordRecoveryEmbeddedWalletConfiguration = {
  * - `createEncryptedSessionEndpoint` as a string, OR
  * - `getEncryptionSession.` as a function that returns a promise.
  */
-export type EmbeddedWalletConfiguration = CommonEmbeddedWalletConfiguration & (AutomaticRecoveryEmbeddedWalletConfiguration | PasswordRecoveryEmbeddedWalletConfiguration);
+export type EmbeddedWalletConfiguration = CommonEmbeddedWalletConfiguration & EncryptionSession;
 /**
  * These types are fully compatible with WAGMI chain types, in case
  * we need interop in the future.
@@ -118,10 +100,18 @@ export interface OpenfortProviderProps {
      * SDK overrides configuration for advanced customization
      */
     overrides?: SDKOverrides;
+    /**
+     * Third party auth configuration for integrating with external auth providers
+     */
+    thirdPartyAuth?: ThirdPartyAuthConfiguration;
+    /**
+     * Enable verbose logging for debugging purposes
+     */
+    verbose?: boolean;
 }
 /**
  * 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 declare const OpenfortProvider: ({ children, publishableKey, customAuth, supportedChains, walletConfig, overrides, thirdPartyAuth, verbose, }: OpenfortProviderProps) => React.JSX.Element;
 export {};

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

@@ -1,3 +1,4 @@
+import { Storage } from '@openfort/openfort-js';
 declare enum StorageKeys {
     AUTHENTICATION = "openfort.authentication",
     SIGNER = "openfort.signer",
@@ -30,5 +31,5 @@ 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 declare function createNormalizedStorage(customStorage?: OpenfortStorage): Storage;
 export {};

package/dist/types/index.d.ts

@@ -8,7 +8,7 @@
  * @author Openfort
  * @version 0.1.0
  */
-export type { AuthPlayerResponse, OpenfortError, RecoveryMethod, Openfort as OpenfortClient, Provider, OpenfortConfiguration, ShieldConfiguration, EmbeddedState, } from '@openfort/openfort-js';
+export { AuthPlayerResponse, OpenfortError, RecoveryMethod, Openfort as OpenfortClient, Provider, OpenfortConfiguration, ShieldConfiguration, EmbeddedState, } from '@openfort/openfort-js';
 export { OAuthProvider, } from '@openfort/openfort-js';
 export * from './types';
 export * from './hooks';

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

@@ -0,0 +1,12 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare const logger: {
+    debug: (message: unknown, ...optionalParams: unknown[]) => void;
+    info: (message: unknown, ...optionalParams: unknown[]) => void;
+    warn: (message: unknown, ...optionalParams: unknown[]) => void;
+    error: (message: unknown, ...optionalParams: unknown[]) => void;
+    setVerbose: (verbose: boolean) => void;
+    printVerboseWarning: () => void;
+};
+export declare const getEmbeddedStateName: (state: EmbeddedState) => string;
+export type { LogLevel };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openfort/react-native",
   "main": "dist/index.js",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "license": "MIT",
   "description": "React Native SDK for Openfort platform integration",
   "scripts": {
@@ -21,8 +21,10 @@
       "types": "./dist/types/index.d.ts"
     }
   },
+  "dependencies": {
+    "@openfort/openfort-js": "^0.10.9"
+  },
   "peerDependencies": {
-    "@openfort/openfort-js": "^0.10.1",
     "expo-apple-authentication": "*",
     "expo-crypto": "*",
     "expo-linking": "*",
@@ -35,7 +37,6 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
-    "@openfort/openfort-js": "^0.10.1",
     "@types/react": "~18.3.12",
     "@types/react-test-renderer": "^18.3.0",
     "buffer": "^5.4.3",