@openfort/react-native 0.0.3 → 0.1.1

package/dist/hooks/auth/useWalletAuth.js

@@ -0,0 +1,133 @@
+import { useCallback } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+const mapStatus = (status) => {
+    return {
+        isLoading: status.status === 'generating-message' || status.status === 'awaiting-signature' || status.status === 'submitting-signature',
+        isError: status.status === 'error',
+        isSuccess: status.status === 'done',
+        error: "error" in status ? status.error : null,
+        isAwaitingSignature: status.status === 'awaiting-signature',
+        isGeneratingMessage: status.status === 'generating-message',
+        isSubmittingSignature: status.status === 'submitting-signature',
+    };
+};
+export function useWalletAuth(hookOptions) {
+    const { client, siweState, setSiweState, _internal } = useOpenfortContext();
+    const generateSiweMessage = useCallback(async (args) => {
+        try {
+            setSiweState({ status: 'generating-message' });
+            // Get wallet address from the external wallet
+            const walletAddress = typeof args.wallet === 'string' ? args.wallet : args.wallet.address;
+            const result = await client.auth.initSIWE({
+                address: walletAddress,
+            });
+            // Build the SIWE message
+            const siweMessage = `${args.from.domain} wants you to sign in with your Ethereum account:\n${walletAddress}\n\nSign in to ${args.from.domain}\n\nURI: ${args.from.uri}\nVersion: 1\nChain ID: 1\nNonce: ${result.nonce}\nIssued At: ${new Date().toISOString()}`;
+            setSiweState({
+                status: 'awaiting-signature',
+            });
+            return onSuccess({
+                hookOptions,
+                options: args,
+                data: { message: siweMessage },
+            });
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error('Failed to generate SIWE message');
+            setSiweState({
+                status: 'error',
+                error: errorObj
+            });
+            return onError({
+                hookOptions,
+                options: args,
+                error: new OpenfortError('Failed to generate SIWE message', OpenfortErrorType.AUTHENTICATION_ERROR, { error: errorObj }),
+            });
+        }
+    }, [client, setSiweState]);
+    const linkSiwe = useCallback(async (opts) => {
+        try {
+            setSiweState({ status: 'submitting-signature' });
+            const message = opts.messageOverride || '';
+            if (!message) {
+                throw new Error('SIWE message is required. Call generateSiweMessage first.');
+            }
+            // Get current user access token for linking
+            const accessToken = await client.getAccessToken();
+            if (!accessToken) {
+                throw new Error('User must be authenticated to link wallet');
+            }
+            const result = await client.auth.authenticateWithSIWE({
+                signature: opts.signature,
+                message: message,
+                walletClientType: 'unknown',
+                connectorType: 'unknown',
+            });
+            setSiweState({ status: 'done' });
+            const user = result.player;
+            // Refresh user state to reflect SIWE linking
+            await _internal.refreshUserState();
+            return onSuccess({
+                hookOptions,
+                options: opts,
+                data: { user },
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to link in with Ethereum', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setSiweState({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options: opts,
+                error
+            });
+        }
+    }, [client, siweState, setSiweState, _internal]);
+    const signInWithSiwe = useCallback(async (opts) => {
+        try {
+            setSiweState({ status: 'submitting-signature' });
+            const message = opts.messageOverride || '';
+            if (!message) {
+                throw new Error('SIWE message is required. Call generateSiweMessage first.');
+            }
+            const result = await client.auth.authenticateWithSIWE({
+                signature: opts.signature,
+                message: message,
+                walletClientType: 'unknown',
+                connectorType: 'unknown'
+            });
+            setSiweState({ status: 'done' });
+            const user = result.player;
+            // Refresh user state in provider
+            await _internal.refreshUserState(user);
+            return onSuccess({
+                hookOptions,
+                options: opts,
+                data: { user },
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to sign in with Ethereum', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setSiweState({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options: opts,
+                error
+            });
+        }
+    }, [client, siweState, setSiweState, _internal]);
+    return {
+        generateSiweMessage,
+        signInWithSiwe,
+        linkSiwe,
+        ...mapStatus(siweState),
+    };
+}

package/dist/hooks/core/index.js

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

package/dist/hooks/core/useOpenfort.js

@@ -0,0 +1,50 @@
+/**
+ * Core Openfort hook for accessing SDK state and methods
+ */
+import { useOpenfortContext } from '../../core/context';
+/**
+ * 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 function useOpenfort() {
+    const { user, isReady, error, logout, getAccessToken } = useOpenfortContext();
+    return {
+        user,
+        isReady,
+        error,
+        logout,
+        getAccessToken,
+    };
+}

package/dist/hooks/core/useOpenfortClient.js

@@ -0,0 +1,29 @@
+import { useOpenfortContext } from '../../core/context';
+/**
+ * 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 function useOpenfortClient() {
+    const { client } = useOpenfortContext();
+    return client;
+}

package/dist/hooks/core/useUser.js

@@ -0,0 +1,10 @@
+import { EmbeddedState } from "@openfort/openfort-js";
+import { useOpenfortContext } from "../../core";
+export function useUser() {
+    const { user, embeddedState, getAccessToken } = useOpenfortContext();
+    return {
+        user,
+        isAuthenticated: embeddedState !== EmbeddedState.NONE && embeddedState !== EmbeddedState.UNAUTHENTICATED,
+        getAccessToken,
+    };
+}

package/dist/hooks/index.js

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+// Re-export all core hooks
+export * from './core';
+// Re-export all authentication hooks
+export * from './auth';
+// Re-export all wallet hooks
+export * from './wallet';

package/dist/hooks/wallet/index.js

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

package/dist/hooks/wallet/useWallets.js

@@ -0,0 +1,389 @@
+/**
+ * Hook for embedded Ethereum wallet functionality
+ */
+import { AccountTypeEnum, ChainTypeEnum, EmbeddedState, RecoveryMethod, ShieldAuthType } from '@openfort/openfort-js';
+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';
+const mapWalletStatus = (status) => {
+    return {
+        error: status.error,
+        isError: status.status === 'error',
+        isSuccess: status.status === 'success',
+        isCreating: status.status === 'creating',
+        isConnecting: status.status === 'connecting',
+    };
+};
+/**
+ * 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 function useWallets(hookOptions = {}) {
+    const { client, user, supportedChains, walletConfig, embeddedState, _internal } = useOpenfortContext();
+    const [embeddedAccounts, setEmbeddedAccounts] = useState([]);
+    const recoverPromiseRef = useRef(null);
+    const [activeWalletId, setActiveWalletId] = useState(null); // OPENFORT-JS Should provide this
+    const [status, setStatus] = useState({
+        status: "idle",
+    });
+    const activeWallet = useMemo(() => {
+        if (!activeWalletId || !embeddedAccounts)
+            return null;
+        const account = embeddedAccounts.find(acc => acc.id === activeWalletId);
+        if (!account)
+            return null;
+        return {
+            address: account.address,
+            implementationType: account.implementationType,
+            ownerAddress: account.ownerAddress,
+            chainType: account.chainType,
+            isActive: true,
+            isConnecting: false,
+            getProvider: async () => {
+                return await client.embeddedWallet.getEthereumProvider({ announceProvider: false });
+            },
+        };
+    }, [activeWalletId, embeddedAccounts, client.embeddedWallet]);
+    const setActiveWallet = useCallback(async (options) => {
+        // If there's already a recovery in progress, return the existing promise
+        if (recoverPromiseRef.current) {
+            return recoverPromiseRef.current;
+        }
+        if (wallets.length === 0) {
+            return onError({
+                hookOptions,
+                options,
+                error: new OpenfortError('No embedded wallets available to set as active', OpenfortErrorType.WALLET_ERROR),
+            });
+        }
+        setStatus({
+            status: 'connecting',
+            address: options?.address,
+        });
+        // Create and store the recovery promise
+        recoverPromiseRef.current = (async () => {
+            try {
+                // Validate chainId if provided
+                let chainId;
+                if (options?.chainId) {
+                    if (!supportedChains || !supportedChains.some(chain => chain.id === options.chainId)) {
+                        throw new OpenfortError(`Chain ID ${options.chainId} is not supported. Supported chains: ${supportedChains?.map(c => c.id).join(', ') || 'none'}`, OpenfortErrorType.WALLET_ERROR);
+                    }
+                    chainId = options.chainId;
+                }
+                else if (supportedChains && supportedChains.length > 0) {
+                    // Use the first supported chain as default
+                    chainId = supportedChains[0].id;
+                }
+                // Create shield authentication object
+                let shieldAuthentication = null;
+                console.log('Using walletConfig:', walletConfig);
+                if (walletConfig) {
+                    const accessToken = await client.getAccessToken();
+                    if (!accessToken) {
+                        throw new OpenfortError('Access token is required for shield authentication', OpenfortErrorType.WALLET_ERROR);
+                    }
+                    // Get encryption session from embedded wallet configuration
+                    let encryptionSession;
+                    if ('getEncryptionSession' in walletConfig && walletConfig.getEncryptionSession) {
+                        encryptionSession = await walletConfig.getEncryptionSession();
+                    }
+                    shieldAuthentication = {
+                        auth: ShieldAuthType.OPENFORT,
+                        token: accessToken,
+                        ...(encryptionSession && { encryptionSession }),
+                    };
+                }
+                const address = options?.address || wallets[0]?.address;
+                const embeddedAccountToRecover = embeddedAccounts.find(account => account.chainId === chainId && account.address === address);
+                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);
+                    // }
+                }
+                else {
+                    // Recover the embedded wallet with shield authentication
+                    embeddedAccount = await client.embeddedWallet.recover({
+                        account: embeddedAccountToRecover.id,
+                        shieldAuthentication: shieldAuthentication ?? undefined,
+                        recoveryParams: options?.recoveryPassword ? { password: options.recoveryPassword, recoveryMethod: RecoveryMethod.PASSWORD } : undefined
+                    });
+                }
+                const wallet = {
+                    address: embeddedAccount.address,
+                    implementationType: embeddedAccount.implementationType,
+                    ownerAddress: embeddedAccount.ownerAddress,
+                    chainType: embeddedAccount.chainType,
+                    isActive: true,
+                    isConnecting: false,
+                    getProvider: async () => {
+                        return await client.embeddedWallet.getEthereumProvider({ announceProvider: false });
+                    },
+                };
+                recoverPromiseRef.current = null;
+                setStatus({
+                    status: 'success',
+                });
+                setActiveWalletId(embeddedAccount.id);
+                return onSuccess({
+                    options,
+                    hookOptions,
+                    data: {
+                        wallet,
+                    }
+                });
+            }
+            catch (e) {
+                recoverPromiseRef.current = null;
+                const error = e instanceof OpenfortError ? e : new OpenfortError('Failed to recover embedded wallet', OpenfortErrorType.WALLET_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    options,
+                    hookOptions,
+                    error,
+                });
+            }
+        })();
+        return recoverPromiseRef.current;
+    }, [client, supportedChains, walletConfig, _internal, embeddedAccounts, hookOptions]);
+    // Fetch embedded wallets using embeddedWallet.list()
+    const fetchEmbeddedWallets = useCallback(async () => {
+        if (!client || embeddedState === EmbeddedState.NONE || embeddedState === EmbeddedState.UNAUTHENTICATED) {
+            setEmbeddedAccounts([]);
+            return;
+        }
+        try {
+            const accounts = await client.embeddedWallet.list();
+            setEmbeddedAccounts(accounts);
+        }
+        catch {
+            setEmbeddedAccounts([]);
+        }
+    }, [client, embeddedState, user]);
+    useEffect(() => {
+        fetchEmbeddedWallets();
+    }, [fetchEmbeddedWallets]);
+    useEffect(() => {
+        (async () => {
+            try {
+                const embeddedAccount = await client.embeddedWallet.get();
+                setActiveWalletId(embeddedAccount.id);
+            }
+            catch {
+                setActiveWalletId(null);
+            }
+        })();
+    }, [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 client.embeddedWallet.getEthereumProvider({ announceProvider: false });
+        },
+    }))), [embeddedAccounts, activeWalletId, status.status === "connecting", client.embeddedWallet]);
+    const create = useCallback(async (options) => {
+        console.log('Creating Ethereum wallet with options:', options);
+        try {
+            setStatus({
+                status: 'creating',
+            });
+            // Validate chainId if provided
+            let chainId;
+            if (options?.chainId) {
+                if (!supportedChains || !supportedChains.some(chain => chain.id === options.chainId)) {
+                    throw new OpenfortError(`Chain ID ${options.chainId} is not supported. Supported chains: ${supportedChains?.map(c => c.id).join(', ') || 'none'}`, OpenfortErrorType.WALLET_ERROR);
+                }
+                chainId = options.chainId;
+            }
+            else if (supportedChains && supportedChains.length > 0) {
+                // Use the first supported chain as default
+                chainId = supportedChains[0].id;
+            }
+            else {
+                throw new OpenfortError('No supported chains available for wallet creation', OpenfortErrorType.WALLET_ERROR);
+            }
+            console.log('Using chain ID for wallet creation:', chainId);
+            // Create shield authentication object
+            let shieldAuthentication = null;
+            if (walletConfig) {
+                const accessToken = await client.getAccessToken();
+                if (!accessToken) {
+                    throw new Error('Access token is required for shield authentication');
+                }
+                console.log('Access token for shield authentication:', accessToken);
+                // Get encryption session from embedded wallet configuration
+                let encryptionSession;
+                if ('getEncryptionSession' in walletConfig && walletConfig.getEncryptionSession) {
+                    encryptionSession = await walletConfig.getEncryptionSession();
+                    console.log('Encryption session for shield authentication:', encryptionSession);
+                }
+                shieldAuthentication = {
+                    auth: ShieldAuthType.OPENFORT,
+                    token: accessToken,
+                    ...(encryptionSession && { encryptionSession }),
+                };
+            }
+            console.log('Shield authentication object:', shieldAuthentication);
+            // Configure embedded wallet with shield authentication
+            const embeddedAccount = await client.embeddedWallet.create({
+                chainId,
+                accountType: AccountTypeEnum.SMART_ACCOUNT,
+                chainType: options?.chainType || ChainTypeEnum.EVM,
+                shieldAuthentication: shieldAuthentication ?? undefined,
+                recoveryParams: options?.recoveryPassword ? { password: options.recoveryPassword, recoveryMethod: RecoveryMethod.PASSWORD } : undefined
+            });
+            console.log('Embedded wallet configured with shield authentication');
+            // Get the Ethereum provider
+            const provider = await client.embeddedWallet.getEthereumProvider({
+                announceProvider: false,
+                ...(options?.policyId && { policy: options.policyId }),
+            });
+            // Refetch the list of wallets to ensure the state is up to date
+            await fetchEmbeddedWallets();
+            setActiveWalletId(embeddedAccount.id);
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: {
+                    provider,
+                    wallet: {
+                        address: embeddedAccount.address,
+                        implementationType: embeddedAccount.implementationType,
+                        ownerAddress: embeddedAccount.ownerAddress,
+                        chainType: embeddedAccount.chainType,
+                        isActive: true,
+                        isConnecting: false,
+                        getProvider: async () => {
+                            return await client.embeddedWallet.getEthereumProvider();
+                        },
+                    }
+                }
+            });
+        }
+        catch (e) {
+            const error = e instanceof OpenfortError ? e : new OpenfortError('Failed to create Ethereum wallet', OpenfortErrorType.WALLET_ERROR, { error: e });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error
+            });
+        }
+    }, [client, supportedChains, walletConfig, _internal, user]);
+    const setRecovery = useCallback(async (params) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            // Set embedded wallet recovery method
+            if (params.recoveryMethod === 'password') {
+                await client.embeddedWallet.setEmbeddedRecovery({
+                    recoveryMethod: RecoveryMethod.PASSWORD,
+                    recoveryPassword: params.recoveryPassword
+                });
+            }
+            else {
+                await client.embeddedWallet.setEmbeddedRecovery({
+                    recoveryMethod: RecoveryMethod.AUTOMATIC
+                });
+            }
+            // Get the updated embedded account
+            const embeddedAccount = await client.embeddedWallet.get();
+            // Refresh user state to reflect recovery changes
+            await _internal.refreshUserState();
+            setStatus({ status: 'success' });
+            return onSuccess({
+                hookOptions,
+                options: params,
+                data: {
+                    wallet: {
+                        address: embeddedAccount.address,
+                        implementationType: embeddedAccount.implementationType,
+                        ownerAddress: embeddedAccount.ownerAddress,
+                        chainType: embeddedAccount.chainType,
+                        isActive: true,
+                        isConnecting: false,
+                        getProvider: async () => {
+                            return await client.embeddedWallet.getEthereumProvider({ announceProvider: false });
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error('Failed to set wallet recovery');
+            return onError({
+                hookOptions,
+                options: params,
+                error: new OpenfortError('Failed to set wallet recovery', OpenfortErrorType.WALLET_ERROR, { error: errorObj }),
+            });
+        }
+    }, [client, _internal]);
+    return {
+        wallets,
+        activeWallet,
+        setRecovery,
+        setActiveWallet,
+        createWallet: create,
+        ...mapWalletStatus(status),
+        exportPrivateKey: client.embeddedWallet.exportPrivateKey,
+    };
+}

package/dist/index.js

@@ -1 +1,24 @@
-export { default as Iframe } from './Iframe';
+/**
+ * Openfort React Native SDK
+ *
+ * A comprehensive React Native SDK for integrating with the Openfort platform.
+ * This SDK provides authentication, embedded wallets, session management, and UI components
+ * for building decentralized applications on React Native.
+ *
+ * @author Openfort
+ * @version 0.1.0
+ */
+// Re-export enums and values from @openfort/openfort-js
+export { OAuthProvider, } from '@openfort/openfort-js';
+// Re-export all types from the main types module
+export * from './types';
+// Re-export all hooks
+export * from './hooks';
+// Re-export all components and UI elements
+export * from './components';
+// Re-export core functionality
+export * from './core';
+// Re-export native functionality
+export * from './native';
+// Re-export constants
+export * from './constants';