@openfort/react 0.3.2 → 1.0.1

package/build/components/Openfort/OpenfortProvider.d.ts

@@ -1,8 +1,8 @@
 import { type SDKOverrides, type ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
-import React from 'react';
-import type { useConnectCallbackProps } from '../../hooks/useConnectCallback';
-import { type ContextValue } from './context';
+import type React from 'react';
+import type { useConnectCallbackProps } from '../../openfort/connectCallbackTypes';
 import { type ConnectUIOptions, type DebugModeOptions, type OpenfortWalletConfig } from './types';
+/** {@link OpenfortProvider} props. */
 type OpenfortProviderProps = {
     children?: React.ReactNode;
     debugMode?: boolean | DebugModeOptions;
@@ -13,32 +13,17 @@ type OpenfortProviderProps = {
     thirdPartyAuth?: ThirdPartyAuthConfiguration;
 } & useConnectCallbackProps;
 /**
- * Provides Openfort configuration and context to descendant components.
+ * Root provider for Openfort. Wrap your app with this to enable connect modal, auth, and wallet features.
+ * Requires publishableKey. Use with wagmi's OpenfortProvider for EVM + wagmi.
  *
- * The provider must be rendered within a {@link WagmiContext} and should only be mounted once
- * to avoid conflicting global state. See {@link OpenfortProviderProps} for the supported options.
- *
- * @param props - Provider configuration including callbacks, UI options and the wrapped children.
- * @returns A React element that sets up the Openfort context.
- * @throws If the component is rendered outside of a Wagmi provider or mounted multiple times.
+ * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
  *
  * @example
  * ```tsx
- * import { WagmiConfig, createConfig } from 'wagmi';
- * import { OpenfortProvider } from '@openfort/openfort-react';
- *
- * const config = createConfig({ YOU_WAGMI_CONFIG_HERE });
- *
- * export function App() {
- *   return (
- *     <WagmiConfig config={config}>
- *       <OpenfortProvider publishableKey={process.env.NEXT_PUBLIC_PUBLISHABLE_KEY!}>
- *         <YourApp />
- *       </OpenfortProvider>
- *     </WagmiConfig>
- *   );
- * }
+ * <OpenfortProvider publishableKey="pk_test_...">
+ *   <App />
+ * </OpenfortProvider>
  * ```
  */
-export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
+export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }: OpenfortProviderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/build/components/Openfort/OpenfortProvider.js

@@ -0,0 +1,351 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { RecoveryMethod, ChainTypeEnum } from '@openfort/openfort-js';
+import { Buffer } from 'buffer';
+import { lazy, useContext, useMemo, useEffect, useState, useCallback, useLayoutEffect, Suspense } from 'react';
+import { DEFAULT_DEV_CHAIN_ID } from '../../core/ConnectionStrategy.js';
+import { OpenfortEthereumBridgeContext } from '../../ethereum/OpenfortEthereumBridgeContext.js';
+import { useThemeFont } from '../../hooks/useGoogleFont.js';
+import { CoreOpenfortProvider } from '../../openfort/CoreOpenfortProvider.js';
+import { logger } from '../../utils/logger.js';
+import { buildChainFromConfig } from '../../utils/rpc.js';
+import { isFamily } from '../../utils/wallets.js';
+import { EmbeddedWalletWagmiSync } from '../../wagmi/useEmbeddedWalletWagmiSync.js';
+import { OpenfortContext, UIContext } from './context.js';
+import { UIAuthProvider, routes, defaultSendFormState, defaultBuyFormState, notStoredInHistoryRoutes } from './types.js';
+
+const SolanaContextProvider = lazy(() => import('../../solana/SolanaContext.js').then((m) => ({ default: m.SolanaContextProvider })));
+const LazyConnectKitModal = lazy(() => import('../ConnectModal/index.js'));
+let openfortProviderWarnedNoWagmi = false;
+/**
+ * Root provider for Openfort. Wrap your app with this to enable connect modal, auth, and wallet features.
+ * Requires publishableKey. Use with wagmi's OpenfortProvider for EVM + wagmi.
+ *
+ * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
+ *
+ * @example
+ * ```tsx
+ * <OpenfortProvider publishableKey="pk_test_...">
+ *   <App />
+ * </OpenfortProvider>
+ * ```
+ */
+const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const bridge = useContext(OpenfortEthereumBridgeContext);
+    const hasWagmi = !!bridge;
+    const hasSolana = !!(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana);
+    // Only allow for mounting OpenfortProvider once, so we avoid weird global
+    // state collisions.
+    if (useContext(OpenfortContext)) {
+        throw new Error('Multiple, nested usages of OpenfortProvider detected. Please use only one.');
+    }
+    const debugModeOptions = useMemo(() => {
+        var _a, _b, _c, _d;
+        const result = typeof debugMode === 'undefined'
+            ? { shieldDebugMode: false, openfortCoreDebugMode: false, openfortReactDebugMode: false, debugRoutes: false }
+            : typeof debugMode === 'boolean'
+                ? {
+                    shieldDebugMode: debugMode,
+                    openfortCoreDebugMode: debugMode,
+                    openfortReactDebugMode: debugMode,
+                    debugRoutes: false,
+                }
+                : {
+                    shieldDebugMode: (_a = debugMode.shieldDebugMode) !== null && _a !== void 0 ? _a : false,
+                    openfortCoreDebugMode: (_b = debugMode.openfortCoreDebugMode) !== null && _b !== void 0 ? _b : false,
+                    openfortReactDebugMode: (_c = debugMode.openfortReactDebugMode) !== null && _c !== void 0 ? _c : false,
+                    debugRoutes: (_d = debugMode.debugRoutes) !== null && _d !== void 0 ? _d : false,
+                };
+        logger.enabled = result.openfortReactDebugMode;
+        return result;
+    }, [debugMode]);
+    const injectedConnector = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) === null || _a === void 0 ? void 0 : _a.find((c) => c.id === 'injected');
+    const allowAutomaticRecovery = !!((walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.createEncryptedSessionEndpoint) || (walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.getEncryptionSession));
+    const defaultUIOptions = useMemo(() => ({
+        appName: 'Openfort',
+        theme: 'auto',
+        mode: 'auto',
+        language: 'en-US',
+        hideBalance: false,
+        hideTooltips: false,
+        hideQuestionMarkCTA: false,
+        hideNoWalletCTA: false,
+        walletConnectCTA: 'link',
+        hideRecentBadge: false,
+        avoidLayoutShift: true,
+        embedGoogleFonts: false,
+        truncateLongENSAddress: true,
+        walletConnectName: undefined,
+        reducedMotion: false,
+        disclaimer: null,
+        bufferPolyfill: true,
+        customAvatar: undefined,
+        enforceSupportedChains: false,
+        ethereumOnboardingUrl: undefined,
+        walletOnboardingUrl: undefined,
+        buyWithCardUrl: undefined,
+        buyFromExchangeUrl: undefined,
+        buyTroubleshootingUrl: undefined,
+        disableSiweRedirect: false,
+        walletRecovery: {
+            allowedMethods: [RecoveryMethod.PASSWORD, ...(allowAutomaticRecovery ? [RecoveryMethod.AUTOMATIC] : [])],
+            defaultMethod: allowAutomaticRecovery ? RecoveryMethod.AUTOMATIC : RecoveryMethod.PASSWORD,
+        },
+        authProviders: hasWagmi
+            ? [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP, UIAuthProvider.WALLET]
+            : [UIAuthProvider.GUEST, UIAuthProvider.EMAIL_OTP],
+    }), [allowAutomaticRecovery, hasWagmi]);
+    const safeUiConfig = useMemo(() => {
+        var _a, _b, _c, _d, _e;
+        const merged = { ...defaultUIOptions, ...uiConfig };
+        let authProviders = (_a = merged.authProviders) !== null && _a !== void 0 ? _a : defaultUIOptions.authProviders;
+        if (!hasWagmi && authProviders.includes(UIAuthProvider.WALLET)) {
+            authProviders = authProviders.filter((p) => p !== UIAuthProvider.WALLET);
+            if (process.env.NODE_ENV === 'development' && !openfortProviderWarnedNoWagmi) {
+                openfortProviderWarnedNoWagmi = true;
+                logger.warn('[@openfort/react] UIAuthProvider.WALLET was removed from authProviders because no Wagmi bridge is present. Add OpenfortWagmiBridge to enable external wallet sign-in.');
+            }
+        }
+        const walletRecovery = {
+            allowedMethods: (_c = (_b = merged.walletRecovery) === null || _b === void 0 ? void 0 : _b.allowedMethods) !== null && _c !== void 0 ? _c : defaultUIOptions.walletRecovery.allowedMethods,
+            defaultMethod: (_e = (_d = merged.walletRecovery) === null || _d === void 0 ? void 0 : _d.defaultMethod) !== null && _e !== void 0 ? _e : defaultUIOptions.walletRecovery.defaultMethod,
+        };
+        if (walletRecovery.allowedMethods.includes(RecoveryMethod.AUTOMATIC) && !allowAutomaticRecovery) {
+            walletRecovery.allowedMethods = walletRecovery.allowedMethods.filter((m) => m !== RecoveryMethod.AUTOMATIC);
+            logger.warn('Automatic recovery method was removed from allowedMethods because no recovery options are configured in the walletConfig. Please provide either createEncryptedSessionEndpoint or getEncryptionSession to enable automatic recovery.');
+        }
+        return { ...merged, authProviders, walletRecovery };
+    }, [defaultUIOptions, uiConfig, hasWagmi, allowAutomaticRecovery]);
+    useEffect(() => {
+        if (typeof window !== 'undefined' && safeUiConfig.bufferPolyfill && !window.Buffer) {
+            window.Buffer = Buffer;
+        }
+    }, [safeUiConfig.bufferPolyfill]);
+    const [ckTheme, setTheme] = useState((_b = safeUiConfig.theme) !== null && _b !== void 0 ? _b : 'auto');
+    const [ckMode, setMode] = useState((_c = safeUiConfig.mode) !== null && _c !== void 0 ? _c : 'auto');
+    const [ckCustomTheme, setCustomTheme] = useState((_d = safeUiConfig.customTheme) !== null && _d !== void 0 ? _d : {});
+    const [ckLang, setLang] = useState('en-US');
+    const [open, setOpenWithoutHistory] = useState(false);
+    const initialConnector = { id: '' };
+    const [connector, setConnector] = useState(initialConnector);
+    const [route, setRoute] = useState({ route: routes.LOADING });
+    const [routeHistory, setRouteHistory] = useState([]);
+    const [resize, onResize] = useState(0);
+    const [emailInput, setEmailInput] = useState('');
+    const [phoneInput, setPhoneInput] = useState('');
+    const [sendForm, setSendForm] = useState(defaultSendFormState);
+    const [buyForm, setBuyForm] = useState(defaultBuyFormState);
+    const [headerLeftSlot, setHeaderLeftSlot] = useState(null);
+    const [chainType, setChainType] = useState((_e = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.chainType) !== null && _e !== void 0 ? _e : ChainTypeEnum.EVM);
+    const setOpen = useCallback((value) => {
+        if (value) {
+            setRouteHistory([]);
+        }
+        setOpenWithoutHistory(value);
+    }, []);
+    // Include Google Font that is needed for a themes
+    useThemeFont(safeUiConfig.embedGoogleFonts ? ckTheme : '');
+    // Sync theme/mode/lang from config before paint to avoid one-render lag
+    useLayoutEffect(() => { var _a; return setTheme((_a = safeUiConfig.theme) !== null && _a !== void 0 ? _a : 'auto'); }, [safeUiConfig.theme]);
+    useLayoutEffect(() => { var _a; return setMode((_a = safeUiConfig.mode) !== null && _a !== void 0 ? _a : 'auto'); }, [safeUiConfig.mode]);
+    useLayoutEffect(() => { var _a; return setCustomTheme((_a = safeUiConfig.customTheme) !== null && _a !== void 0 ? _a : {}); }, [safeUiConfig.customTheme]);
+    useLayoutEffect(() => setLang(safeUiConfig.language || 'en-US'), [safeUiConfig.language]);
+    const chains = useMemo(() => {
+        var _a, _b, _c;
+        if ((_b = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.switchChain) === null || _a === void 0 ? void 0 : _a.chains) === null || _b === void 0 ? void 0 : _b.length) {
+            return bridge.switchChain.chains;
+        }
+        if (walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) {
+            const rpcUrls = walletConfig.ethereum.rpcUrls;
+            const defaultChainId = (_c = walletConfig.ethereum.chainId) !== null && _c !== void 0 ? _c : DEFAULT_DEV_CHAIN_ID;
+            const chainIds = rpcUrls && Object.keys(rpcUrls).length > 0
+                ? [...new Set([...Object.keys(rpcUrls).map(Number), defaultChainId])]
+                : [defaultChainId];
+            return chainIds.map((id) => buildChainFromConfig(id, rpcUrls));
+        }
+        return [];
+    }, [(_f = bridge === null || bridge === void 0 ? void 0 : bridge.switchChain) === null || _f === void 0 ? void 0 : _f.chains, (_g = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _g === void 0 ? void 0 : _g.rpcUrls, (_h = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _h === void 0 ? void 0 : _h.chainId]);
+    const chain = bridge === null || bridge === void 0 ? void 0 : bridge.account.chain;
+    const isConnected = (_j = bridge === null || bridge === void 0 ? void 0 : bridge.account.isConnected) !== null && _j !== void 0 ? _j : false;
+    const isChainSupported = !(chain === null || chain === void 0 ? void 0 : chain.id) || ((_l = (_k = bridge === null || bridge === void 0 ? void 0 : bridge.config.chains) === null || _k === void 0 ? void 0 : _k.some((c) => c.id === chain.id)) !== null && _l !== void 0 ? _l : false);
+    useEffect(() => {
+        if (hasWagmi && isConnected && safeUiConfig.enforceSupportedChains && !isChainSupported) {
+            setOpen(true);
+            setRoute({ route: routes.ETH_SWITCH_NETWORK });
+        }
+    }, [hasWagmi, isConnected, isChainSupported, safeUiConfig.enforceSupportedChains, setOpen, setRoute]);
+    useEffect(() => {
+        if (hasWagmi && isFamily() && injectedConnector && bridge) {
+            bridge.connect({ connector: injectedConnector });
+        }
+    }, [hasWagmi, injectedConnector, bridge]);
+    const typedSetRoute = useCallback((options) => {
+        const routeObj = typeof options === 'string' ? { route: options } : options;
+        const { route } = routeObj;
+        setRoute(routeObj);
+        setRouteHistory((prev) => {
+            const lastRoute = prev.length > 0 ? prev[prev.length - 1] : null;
+            if (lastRoute && lastRoute.route === route)
+                return prev;
+            if (notStoredInHistoryRoutes.includes(route))
+                return prev;
+            return [...prev, routeObj];
+        });
+    }, []);
+    const setPreviousRoute = useCallback(() => {
+        setRouteHistory((prev) => {
+            const newHistory = [...prev];
+            newHistory.pop();
+            if (newHistory.length > 0) {
+                setRoute(newHistory[newHistory.length - 1]);
+            }
+            else {
+                setRoute({ route: routes.CONNECTED });
+            }
+            return newHistory;
+        });
+    }, []);
+    const triggerResize = useCallback(() => {
+        onResize((prev) => prev + 1);
+    }, []);
+    const [onBack, setOnBack] = useState(null);
+    const value = useMemo(() => ({
+        setTheme,
+        chainType,
+        setChainType,
+        mode: ckMode,
+        setMode,
+        setCustomTheme,
+        lang: ckLang,
+        setLang,
+        open,
+        setOpen,
+        route,
+        setRoute: typedSetRoute,
+        onBack,
+        setOnBack,
+        headerLeftSlot,
+        setHeaderLeftSlot,
+        previousRoute: routeHistory.length > 1 ? routeHistory[routeHistory.length - 2] : null,
+        setPreviousRoute,
+        routeHistory,
+        setRouteHistory,
+        connector,
+        setConnector,
+        debugMode: debugModeOptions,
+        resize,
+        triggerResize,
+        publishableKey,
+        uiConfig: safeUiConfig,
+        walletConfig,
+        overrides,
+        thirdPartyAuth,
+        emailInput,
+        setEmailInput,
+        phoneInput,
+        setPhoneInput,
+        sendForm,
+        setSendForm,
+        buyForm,
+        setBuyForm,
+        onConnect,
+        onDisconnect,
+        chains,
+    }), [
+        ckMode,
+        ckLang,
+        chainType,
+        setChainType,
+        open,
+        setOpen,
+        route,
+        typedSetRoute,
+        onBack,
+        setPreviousRoute,
+        routeHistory,
+        connector,
+        debugModeOptions,
+        resize,
+        triggerResize,
+        safeUiConfig,
+        publishableKey,
+        walletConfig,
+        overrides,
+        thirdPartyAuth,
+        emailInput,
+        phoneInput,
+        sendForm,
+        buyForm,
+        headerLeftSlot,
+        onConnect,
+        onDisconnect,
+        chains,
+    ]);
+    const connectUIValue = useMemo(() => {
+        var _a;
+        return ({
+            isOpen: open,
+            openModal: () => setOpen(true),
+            closeModal: () => setOpen(false),
+            currentRoute: route,
+            navigate: typedSetRoute,
+            goBack: setPreviousRoute,
+            routeHistory,
+            theme: ckTheme,
+            mode: (_a = safeUiConfig.mode) !== null && _a !== void 0 ? _a : ckMode,
+            setTheme,
+            setMode,
+            forms: { send: sendForm, buy: buyForm },
+            updateSendForm: (updates) => setSendForm((prev) => ({ ...prev, ...updates })),
+            updateBuyForm: (updates) => setBuyForm((prev) => ({ ...prev, ...updates })),
+            triggerResize,
+        });
+    }, [
+        open,
+        setOpen,
+        route,
+        typedSetRoute,
+        setPreviousRoute,
+        routeHistory,
+        ckTheme,
+        safeUiConfig.mode,
+        ckMode,
+        setTheme,
+        setMode,
+        sendForm,
+        buyForm,
+        setSendForm,
+        setBuyForm,
+        triggerResize,
+    ]);
+    const innerChildren = (jsxs(Fragment, { children: [hasWagmi && jsx(EmbeddedWalletWagmiSync, {}), debugModeOptions.debugRoutes && (jsx("pre", { style: {
+                    position: 'absolute',
+                    top: 0,
+                    left: 0,
+                    fontSize: '14px',
+                    color: 'gray',
+                    background: 'white',
+                    zIndex: 9999,
+                }, children: JSON.stringify(routeHistory.map((item) => Object.fromEntries(Object.entries(item).map(([key, value]) => [
+                    key,
+                    typeof value === 'object' && value !== null ? '[object]' : value,
+                ]))), null, 2) })), children, jsx(Suspense, { fallback: null, children: jsx(LazyConnectKitModal, { lang: ckLang, theme: ckTheme, mode: (_m = safeUiConfig.mode) !== null && _m !== void 0 ? _m : ckMode, customTheme: ckCustomTheme }) })] }));
+    return (jsx(UIContext.Provider, { value: connectUIValue, children: jsx(OpenfortContext.Provider, { value: value, children: jsx(CoreOpenfortProvider, { openfortConfig: {
+                    baseConfiguration: { publishableKey },
+                    shieldConfiguration: walletConfig
+                        ? {
+                            shieldPublishableKey: walletConfig.shieldPublishableKey,
+                            debug: debugModeOptions.shieldDebugMode,
+                            ...(walletConfig.passkeyDisplayName && {
+                                passkeyRpName: walletConfig.passkeyDisplayName,
+                            }),
+                        }
+                        : undefined,
+                    debug: debugModeOptions.openfortCoreDebugMode,
+                    overrides,
+                    thirdPartyAuth,
+                }, onConnect: onConnect, onDisconnect: onDisconnect, children: hasSolana ? (jsx(Suspense, { fallback: null, children: jsx(SolanaContextProvider, { config: walletConfig.solana, children: innerChildren }) })) : (innerChildren) }) }) }));
+};
+
+export { OpenfortProvider };
+//# sourceMappingURL=OpenfortProvider.js.map

package/build/components/Openfort/OpenfortProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenfortProvider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Openfort/context.d.ts

@@ -1,6 +1,7 @@
-import type { OAuthProvider, SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
+import type { ChainTypeEnum, OAuthProvider, SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 import type React from 'react';
-import type { useConnectCallbackProps } from '../../hooks/useConnectCallback';
+import type { Chain } from 'viem';
+import type { useConnectCallbackProps } from '../../openfort/connectCallbackTypes';
 import type { CustomTheme, Languages, Mode, Theme } from '../../types';
 import type { BuyFormState, DebugModeOptions, OpenfortUIOptionsExtended, OpenfortWalletConfig, RouteOptions, SendFormState, SetRouteOptions } from './types';
 type Connector = {
@@ -10,8 +11,9 @@ type Connector = {
     id: OAuthProvider;
     type: 'oauth';
 };
-type ErrorMessage = string | React.ReactNode | null;
 export type ContextValue = {
+    chainType: ChainTypeEnum;
+    setChainType: (chainType: ChainTypeEnum) => void;
     setTheme: React.Dispatch<React.SetStateAction<Theme>>;
     mode: Mode;
     setMode: React.Dispatch<React.SetStateAction<Mode>>;
@@ -32,7 +34,6 @@ export type ContextValue = {
     setRouteHistory: React.Dispatch<React.SetStateAction<RouteOptions[]>>;
     connector: Connector;
     setConnector: React.Dispatch<React.SetStateAction<Connector>>;
-    errorMessage: ErrorMessage;
     debugMode: Required<DebugModeOptions>;
     resize: number;
     triggerResize: () => void;
@@ -49,6 +50,48 @@ export type ContextValue = {
     setSendForm: React.Dispatch<React.SetStateAction<SendFormState>>;
     buyForm: BuyFormState;
     setBuyForm: React.Dispatch<React.SetStateAction<BuyFormState>>;
+    /** Configured EVM chains (from wagmi bridge or walletConfig.ethereum). Empty when not EVM. */
+    chains: Chain[];
 } & useConnectCallbackProps;
-export declare const Openfortcontext: React.Context<ContextValue | null>;
+export declare const OpenfortContext: React.Context<ContextValue | null>;
+/**
+ * UI context value for modal control, navigation, and theme management.
+ * This is an internal context used by OpenfortProvider.
+ */
+export interface UIContextValue {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Open the modal */
+    openModal: () => void;
+    /** Close the modal */
+    closeModal: () => void;
+    /** Current route in the modal */
+    currentRoute: RouteOptions;
+    /** Navigate to a new route */
+    navigate: (route: SetRouteOptions) => void;
+    /** Go back to the previous route */
+    goBack: () => void;
+    /** Route history stack */
+    routeHistory: RouteOptions[];
+    /** Current theme */
+    theme: Theme;
+    /** Current color mode */
+    mode: Mode;
+    /** Update theme */
+    setTheme: (theme: Theme) => void;
+    /** Update color mode */
+    setMode: (mode: Mode) => void;
+    /** Form states */
+    forms: {
+        send: SendFormState;
+        buy: BuyFormState;
+    };
+    /** Update send form state */
+    updateSendForm: (updates: Partial<SendFormState>) => void;
+    /** Update buy form state */
+    updateBuyForm: (updates: Partial<BuyFormState>) => void;
+    /** Trigger a resize calculation */
+    triggerResize: () => void;
+}
+export declare const UIContext: React.Context<UIContextValue | null>;
 export {};

package/build/components/Openfort/context.js

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+
+const OpenfortContext = createContext(null);
+const UIContext = createContext(null);
+
+export { OpenfortContext, UIContext };
+//# sourceMappingURL=context.js.map

package/build/components/Openfort/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/build/components/Openfort/routeHelpers.d.ts

@@ -0,0 +1,5 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import type { EthereumUserWallet, SolanaUserWallet } from '../../hooks/openfort/walletTypes';
+import { type SetRouteOptions } from './types';
+export declare function recoverRoute(chainType: ChainTypeEnum, wallet: EthereumUserWallet | SolanaUserWallet): SetRouteOptions;
+export declare function createRoute(chainType: ChainTypeEnum): SetRouteOptions;

package/build/components/Openfort/routeHelpers.js

@@ -0,0 +1,20 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { routes } from './types.js';
+
+const recoverRouteRegistry = {
+    [ChainTypeEnum.EVM]: (wallet) => ({ route: routes.RECOVER_WALLET, wallet: wallet }),
+    [ChainTypeEnum.SVM]: (wallet) => ({ route: routes.SOL_RECOVER_WALLET, wallet: wallet }),
+};
+function recoverRoute(chainType, wallet) {
+    return recoverRouteRegistry[chainType](wallet);
+}
+const createRouteRegistry = {
+    [ChainTypeEnum.EVM]: () => routes.CREATE_WALLET,
+    [ChainTypeEnum.SVM]: () => routes.SOL_CREATE_WALLET,
+};
+function createRoute(chainType) {
+    return createRouteRegistry[chainType]();
+}
+
+export { createRoute, recoverRoute };
+//# sourceMappingURL=routeHelpers.js.map

package/build/components/Openfort/routeHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}