@openfort/react 0.3.2 → 1.0.1

package/build/hooks/openfort/useUI.d.ts

@@ -4,7 +4,6 @@
  * This hook provides programmatic control over the Openfort UI modal, including opening,
  * closing, and navigating between different screens. It handles route validation and
  * automatically selects appropriate screens based on user connection and authentication state.
- * The hook ensures safe navigation by validating routes against user's current state.
  *
  * @returns UI control functions and modal state
  *
@@ -12,53 +11,13 @@
  * ```tsx
  * const ui = useUI();
  *
- * // Check if modal is open
  * if (ui.isOpen) {
- *   console.log('Openfort modal is currently open');
+ *   console.log('Openfort modal is open');
  * }
  *
- * // Open modal with default route (auto-determined by user state)
- * const handleConnect = () => {
- *   ui.open(); // Opens providers screen if not connected, profile if connected
- * };
- *
- * // Close modal
- * const handleClose = () => {
- *   ui.close();
- * };
- *
- * // Programmatically control modal state
- * const toggleModal = () => {
- *   ui.setIsOpen(!ui.isOpen);
- * };
- *
- * // Open specific screens
- * const handleProfileClick = () => {
- *   ui.openProfile(); // Opens user profile screen (connected users only)
- * };
- *
- * const handleProvidersClick = () => {
- *   ui.openProviders(); // Opens authentication providers screen
- * };
- *
- * const handleWalletsClick = () => {
- *   ui.openWallets(); // Opens wallet connectors screen
- * };
- *
- * const handleNetworkClick = () => {
- *   ui.openSwitchNetworks(); // Opens network switching screen (connected users only)
- * };
- *
- * // Example usage in component
- * return (
- *   <div>
- *     <button onClick={handleConnect}>
- *       {ui.isOpen ? 'Close' : 'Open'} Openfort
- *     </button>
- *     <button onClick={handleProfileClick}>Profile</button>
- *     <button onClick={handleWalletsClick}>Wallets</button>
- *   </div>
- * );
+ * ui.open(); // Opens modal with default route
+ * ui.close(); // Closes modal
+ * ui.openProfile(); // Opens user profile screen
  * ```
  */
 export declare function useUI(): {

package/build/hooks/openfort/useUI.js

@@ -0,0 +1,122 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import React from 'react';
+import { routes } from '../../components/Openfort/types.js';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { useConnectionStrategy } from '../../core/ConnectionStrategyContext.js';
+import { useEthereumEmbeddedWallet } from '../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useEthereumBridge } from '../../ethereum/OpenfortEthereumBridgeContext.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { useSolanaEmbeddedWallet } from '../../solana/hooks/useSolanaEmbeddedWallet.js';
+import { logger } from '../../utils/logger.js';
+
+const safeRoutes = {
+    disconnected: [
+        routes.PROVIDERS,
+        { route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' },
+        routes.MOBILECONNECTORS,
+    ],
+    connected: [
+        routes.CONNECTED,
+        { route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' },
+        routes.ETH_SWITCH_NETWORK,
+        routes.PROVIDERS,
+    ],
+};
+const allRoutes = [...safeRoutes.connected, ...safeRoutes.disconnected];
+/** Connector id must be a connector (e.g. injected, walletConnect), not an Openfort account id. */
+function isAccountId(id) {
+    return id.startsWith('acc_');
+}
+/**
+ * Hook for controlling Openfort UI modal and navigation
+ *
+ * This hook provides programmatic control over the Openfort UI modal, including opening,
+ * closing, and navigating between different screens. It handles route validation and
+ * automatically selects appropriate screens based on user connection and authentication state.
+ *
+ * @returns UI control functions and modal state
+ *
+ * @example
+ * ```tsx
+ * const ui = useUI();
+ *
+ * if (ui.isOpen) {
+ *   console.log('Openfort modal is open');
+ * }
+ *
+ * ui.open(); // Opens modal with default route
+ * ui.close(); // Closes modal
+ * ui.openProfile(); // Opens user profile screen
+ * ```
+ */
+function useUI() {
+    var _a;
+    const { open, setOpen, setRoute, setConnector, connector, chainType } = useOpenfort();
+    const { isLoading, user, needsRecovery, embeddedAccounts, activeEmbeddedAddress, embeddedState } = useOpenfortCore();
+    const bridge = useEthereumBridge();
+    const strategy = useConnectionStrategy();
+    const ethereumWallet = useEthereumEmbeddedWallet();
+    const solanaWallet = useSolanaEmbeddedWallet();
+    const wallet = chainType === ChainTypeEnum.EVM ? ethereumWallet : solanaWallet;
+    const state = React.useMemo(() => ({
+        user,
+        embeddedAccounts,
+        activeEmbeddedAddress,
+        chainType,
+        embeddedState,
+    }), [user, embeddedAccounts, activeEmbeddedAddress, chainType, embeddedState]);
+    // Bridge: strategy owns connection. Embedded: wallet hooks are source of truth.
+    const isConnected = (strategy === null || strategy === void 0 ? void 0 : strategy.kind) === 'bridge' ? ((_a = strategy === null || strategy === void 0 ? void 0 : strategy.isConnected(state)) !== null && _a !== void 0 ? _a : false) : wallet.status === 'connected';
+    function defaultOpen() {
+        setOpen(true);
+        if (isAccountId(connector.id)) {
+            setConnector({ id: '' });
+        }
+        if (isLoading)
+            setRoute(routes.LOADING);
+        else if (!user)
+            setRoute(routes.PROVIDERS);
+        else if (!isConnected)
+            setRoute(routes.LOAD_WALLETS);
+        else if (needsRecovery && !bridge)
+            setRoute(routes.LOAD_WALLETS);
+        else
+            setRoute(routes.CONNECTED);
+    }
+    const gotoAndOpen = (route) => {
+        let validRoute = route;
+        if (!allRoutes.includes(route)) {
+            validRoute = isConnected ? routes.CONNECTED : routes.PROVIDERS;
+            logger.log(`Route ${route} is not a valid route, navigating to ${validRoute} instead.`);
+        }
+        else {
+            if (isConnected) {
+                if (!safeRoutes.connected.includes(route)) {
+                    validRoute = routes.CONNECTED;
+                    logger.log(`Route ${route} is not a valid route when connected, navigating to ${validRoute} instead.`);
+                }
+            }
+            else {
+                if (!safeRoutes.disconnected.includes(route)) {
+                    validRoute = routes.PROVIDERS;
+                    logger.log(`Route ${route} is not a valid route when disconnected, navigating to ${validRoute} instead.`);
+                }
+            }
+        }
+        setRoute(validRoute);
+        setOpen(true);
+    };
+    return {
+        isOpen: open,
+        open: () => defaultOpen(),
+        close: () => setOpen(false),
+        setIsOpen: setOpen,
+        openProfile: () => gotoAndOpen(routes.CONNECTED),
+        openSwitchNetworks: () => gotoAndOpen(routes.ETH_SWITCH_NETWORK),
+        openProviders: () => gotoAndOpen(routes.PROVIDERS),
+        openWallets: () => gotoAndOpen({ route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' }),
+    };
+}
+
+export { useUI };
+//# sourceMappingURL=useUI.js.map

package/build/hooks/openfort/useUI.js.map

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

package/build/hooks/openfort/useUser.d.ts

@@ -1,51 +1,28 @@
 /**
- * Hook for accessing current user information and authentication state
+ * Returns the current user, linked accounts, auth state, and token helpers.
  *
- * This hook provides access to the current authenticated user's information and
- * authentication status. It also offers methods to manage access tokens and validate
- * user sessions. The hook automatically updates when authentication state changes.
+ * Use `isConnected` for the common "am I connected?" check: true when authenticated and
+ * wallet is ready for the current chain.
  *
- * @returns Current user state and authentication utilities
+ * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
+ *
+ * @returns user, linkedAccounts, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
  *
  * @example
  * ```tsx
- * const userHook = useUser();
- *
- * // Check if user is authenticated
- * if (userHook.isAuthenticated && userHook.user) {
- *   console.log('User is authenticated:', userHook.user);
- *   console.log('User ID:', userHook.user.id);
- *   console.log('User email:', userHook.user.email);
- *   console.log('Linked accounts:', userHook.linkedAccounts);
- * } else {
- *   console.log('User is not authenticated');
- * }
+ * const { user, isConnected, getAccessToken } = useUser()
  *
- * // Get fresh access token
- * const getToken = async () => {
- *   try {
- *     const token = await userHook.getAccessToken();
- *     console.log('Access token:', token);
- *   } catch (error) {
- *     console.error('Failed to get access token:', error);
- *   }
- * };
+ * if (!isConnected) return <Spinner />
+ * // User is authenticated and wallet is connected — safe to send/sign
  *
- * // Validate and refresh token if needed
- * const refreshToken = async () => {
- *   try {
- *     await userHook.validateAndRefreshToken();
- *     console.log('Token validated and refreshed');
- *   } catch (error) {
- *     console.error('Token validation failed:', error);
- *   }
- * };
+ * const token = await getAccessToken()
  * ```
  */
 export declare function useUser(): {
     user: import("@openfort/openfort-js").User | null;
-    linkedAccounts: import("../../openfortCustomTypes").UserAccount[];
+    linkedAccounts: import("@openfort/openfort-js").UserAccount[];
     isAuthenticated: boolean;
+    isConnected: boolean;
     getAccessToken: () => Promise<string | null>;
     validateAndRefreshToken: () => Promise<void>;
 };

package/build/hooks/openfort/useUser.js

@@ -0,0 +1,61 @@
+import { EmbeddedState } from '@openfort/openfort-js';
+import { useCallback } from 'react';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { handleOAuthConfigError } from '../../utils/oauthErrorHandler.js';
+
+/**
+ * Returns the current user, linked accounts, auth state, and token helpers.
+ *
+ * Use `isConnected` for the common "am I connected?" check: true when authenticated and
+ * wallet is ready for the current chain.
+ *
+ * @remarks Client-only. Use in a Client Component (e.g. add `"use client"` in Next.js App Router).
+ *
+ * @returns user, linkedAccounts, isAuthenticated, isConnected, getAccessToken, validateAndRefreshToken
+ *
+ * @example
+ * ```tsx
+ * const { user, isConnected, getAccessToken } = useUser()
+ *
+ * if (!isConnected) return <Spinner />
+ * // User is authenticated and wallet is connected — safe to send/sign
+ *
+ * const token = await getAccessToken()
+ * ```
+ */
+function useUser() {
+    const { user, client, embeddedState, linkedAccounts, activeEmbeddedAddress } = useOpenfortCore();
+    const isAuthenticated = embeddedState !== EmbeddedState.NONE && embeddedState !== EmbeddedState.UNAUTHENTICATED;
+    const isConnected = embeddedState === EmbeddedState.READY && !!activeEmbeddedAddress;
+    const getAccessTokenAndUpdate = useCallback(async () => {
+        try {
+            await client.validateAndRefreshToken();
+            const token = await client.getAccessToken();
+            return token;
+        }
+        catch (error) {
+            handleOAuthConfigError(error);
+            throw error;
+        }
+    }, [client]);
+    const validateAndRefresh = useCallback(async () => {
+        try {
+            await client.validateAndRefreshToken();
+        }
+        catch (error) {
+            handleOAuthConfigError(error);
+            throw error;
+        }
+    }, [client]);
+    return {
+        user,
+        linkedAccounts,
+        isAuthenticated,
+        isConnected,
+        getAccessToken: getAccessTokenAndUpdate,
+        validateAndRefreshToken: validateAndRefresh,
+    };
+}
+
+export { useUser };
+//# sourceMappingURL=useUser.js.map

package/build/hooks/openfort/useUser.js.map

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

package/build/hooks/openfort/walletTypes.d.ts

@@ -0,0 +1,32 @@
+import { type AccountTypeEnum, ChainTypeEnum, type EmbeddedAccount, type RecoveryMethod } from '@openfort/openfort-js';
+import type { Hex } from 'viem';
+import type { ConnectedEmbeddedEthereumWallet } from '../../ethereum/types';
+import type { ConnectedEmbeddedSolanaWallet } from '../../solana/types';
+import type { BaseFlowState } from './auth/status';
+export type EthereumUserWallet = ConnectedEmbeddedEthereumWallet;
+/** Solana embedded wallet shape (mirrors UserWallet for SVM). address is Base58. Discriminate with chainType. */
+export type SolanaUserWallet = {
+    address: string;
+    id: string;
+    chainType: typeof ChainTypeEnum.SVM;
+    isAvailable: boolean;
+    isActive?: boolean;
+    isConnecting?: boolean;
+    accounts: {
+        id: string;
+    }[];
+    recoveryMethod?: RecoveryMethod;
+    accountType?: AccountTypeEnum;
+    createdAt?: number;
+};
+export type UserWallet = EthereumUserWallet | SolanaUserWallet;
+export type WalletFlowStatus = BaseFlowState | {
+    status: 'creating' | 'connecting';
+    address?: Hex;
+    error?: never;
+};
+export declare function embeddedAccountToUserWallet(account: EmbeddedAccount): EthereumUserWallet;
+/** Build SolanaUserWallet from a ConnectedEmbeddedSolanaWallet (e.g. for route navigation). */
+export declare function toSolanaUserWallet(w: ConnectedEmbeddedSolanaWallet): SolanaUserWallet;
+/** Build SolanaUserWallet from a single SVM embedded account (e.g. for post-auth return). */
+export declare function embeddedAccountToSolanaUserWallet(account: EmbeddedAccount): SolanaUserWallet;

package/build/hooks/openfort/walletTypes.js

@@ -0,0 +1,53 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+
+function embeddedAccountToUserWallet(account) {
+    return {
+        id: account.id,
+        address: account.address,
+        ownerAddress: account.ownerAddress,
+        implementationType: account.implementationType,
+        chainType: ChainTypeEnum.EVM,
+        walletIndex: 0,
+        recoveryMethod: account.recoveryMethod,
+        getProvider: async () => {
+            throw new Error('Wallet not yet loaded; use useEthereumEmbeddedWallet to access provider');
+        },
+        isAvailable: true,
+        isActive: false,
+        isConnecting: false,
+        accounts: [{ id: account.id, chainId: account.chainId }],
+        connectorType: 'embedded',
+        walletClientType: 'openfort',
+        accountId: account.id,
+        accountType: account.accountType,
+        createdAt: account.createdAt,
+        salt: account.salt,
+    };
+}
+/** Build SolanaUserWallet from a ConnectedEmbeddedSolanaWallet (e.g. for route navigation). */
+function toSolanaUserWallet(w) {
+    return {
+        id: w.id,
+        address: w.address,
+        chainType: ChainTypeEnum.SVM,
+        isAvailable: true,
+        accounts: [{ id: w.id }],
+        recoveryMethod: w.recoveryMethod,
+    };
+}
+/** Build SolanaUserWallet from a single SVM embedded account (e.g. for post-auth return). */
+function embeddedAccountToSolanaUserWallet(account) {
+    return {
+        address: account.address,
+        id: account.id,
+        chainType: ChainTypeEnum.SVM,
+        isAvailable: true,
+        accounts: [{ id: account.id }],
+        recoveryMethod: account.recoveryMethod,
+        accountType: account.accountType,
+        createdAt: account.createdAt,
+    };
+}
+
+export { embeddedAccountToSolanaUserWallet, embeddedAccountToUserWallet, toSolanaUserWallet };
+//# sourceMappingURL=walletTypes.js.map

package/build/hooks/openfort/walletTypes.js.map

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

package/build/hooks/useBalance.d.ts

@@ -0,0 +1,50 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import type { SolanaCluster } from '../solana/types';
+/** Event name for balance invalidation. Call invalidateBalance() after balance-changing txs. */
+export declare const BALANCE_INVALIDATE_EVENT = "openfort:balance-invalidate";
+/** Dispatches balance invalidation so all useBalance instances refetch. Call after mint/send. */
+export declare function invalidateBalance(): void;
+type BalanceState = {
+    status: 'idle';
+    refetch: () => void;
+} | {
+    status: 'loading';
+    refetch: () => void;
+} | {
+    status: 'error';
+    error: Error;
+    refetch: () => void;
+} | {
+    status: 'success';
+    value: bigint;
+    formatted: string;
+    symbol: string;
+    decimals: number;
+    refetch: () => void;
+};
+interface UseBalanceOptions {
+    /** Address to fetch balance for */
+    address: string;
+    /** Chain type */
+    chainType: ChainTypeEnum;
+    /** Ethereum chain ID (default: 84532 Base Sepolia) */
+    chainId?: number;
+    /** Solana cluster (default: devnet) */
+    cluster?: SolanaCluster;
+    /** Solana commitment level (default: confirmed) */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Refetch interval in ms (default: 30000) */
+    refetchInterval?: number;
+}
+type BalanceResult = {
+    value: bigint;
+    formatted: string;
+    symbol: string;
+    decimals: number;
+};
+export declare function fetchSolanaBalance(addressStr: string, rpcUrl: string, commitment: 'processed' | 'confirmed' | 'finalized'): Promise<BalanceResult>;
+/** Hook for fetching native token balance. */
+export declare function useBalance(options: UseBalanceOptions): BalanceState;
+export {};

package/build/hooks/useBalance.js

@@ -0,0 +1,80 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { useEffect } from 'react';
+import { createPublicClient, http, formatEther } from 'viem';
+import { useOpenfort } from '../components/Openfort/useOpenfort.js';
+import { DEFAULT_TESTNET_CHAIN_ID } from '../core/ConnectionStrategy.js';
+import { useAsyncData } from '../shared/hooks/useAsyncData.js';
+import { formatSol } from '../solana/hooks/utils.js';
+import { getDefaultEthereumRpcUrl, getDefaultSolanaRpcUrl, getNativeCurrency } from '../utils/rpc.js';
+
+/** Event name for balance invalidation. Call invalidateBalance() after balance-changing txs. */
+const BALANCE_INVALIDATE_EVENT = 'openfort:balance-invalidate';
+/** Dispatches balance invalidation so all useBalance instances refetch. Call after mint/send. */
+function invalidateBalance() {
+    if (typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent(BALANCE_INVALIDATE_EVENT));
+    }
+}
+async function fetchEvmBalance(address, rpcUrl, chainId) {
+    const client = createPublicClient({ transport: http(rpcUrl) });
+    const balance = await client.getBalance({ address: address });
+    const { symbol, decimals } = getNativeCurrency(chainId);
+    return { value: balance, formatted: formatEther(balance), symbol, decimals };
+}
+async function fetchSolanaBalance(addressStr, rpcUrl, commitment) {
+    const { address, createSolanaRpc } = await import('@solana/kit');
+    const rpc = createSolanaRpc(rpcUrl);
+    const { value: lamports } = await rpc.getBalance(address(addressStr), { commitment }).send();
+    return {
+        value: BigInt(lamports),
+        formatted: formatSol(BigInt(lamports), 9),
+        symbol: 'SOL',
+        decimals: 9,
+    };
+}
+/** Hook for fetching native token balance. */
+function useBalance(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const { address, chainType, chainId = DEFAULT_TESTNET_CHAIN_ID, cluster = 'devnet', commitment = 'confirmed', enabled = true, refetchInterval = 30000, } = options;
+    const { walletConfig } = useOpenfort();
+    const rpcUrl = chainType === ChainTypeEnum.EVM
+        ? ((_c = (_b = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.rpcUrls) === null || _b === void 0 ? void 0 : _b[chainId]) !== null && _c !== void 0 ? _c : getDefaultEthereumRpcUrl(chainId))
+        : ((_f = (_e = (_d = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana) === null || _d === void 0 ? void 0 : _d.rpcUrls) === null || _e === void 0 ? void 0 : _e[cluster]) !== null && _f !== void 0 ? _f : getDefaultSolanaRpcUrl(cluster));
+    const isEnabled = enabled && !!address && address.length > 0;
+    const { data, error, isLoading, refetch } = useAsyncData({
+        queryKey: ['balance', chainType, address, chainId, cluster],
+        queryFn: () => chainType === ChainTypeEnum.EVM
+            ? fetchEvmBalance(address, rpcUrl, chainId)
+            : fetchSolanaBalance(address, rpcUrl, commitment),
+        enabled: isEnabled,
+        refetchInterval,
+        staleTime: 30000,
+    });
+    useEffect(() => {
+        if (!isEnabled)
+            return;
+        const handler = () => refetch().catch(() => { });
+        window.addEventListener(BALANCE_INVALIDATE_EVENT, handler);
+        return () => window.removeEventListener(BALANCE_INVALIDATE_EVENT, handler);
+    }, [isEnabled, refetch]);
+    if (!isEnabled) {
+        return { status: 'idle', refetch };
+    }
+    if (isLoading) {
+        return { status: 'loading', refetch };
+    }
+    if (error) {
+        return { status: 'error', error, refetch };
+    }
+    return {
+        status: 'success',
+        value: (_g = data === null || data === void 0 ? void 0 : data.value) !== null && _g !== void 0 ? _g : BigInt(0),
+        formatted: (_h = data === null || data === void 0 ? void 0 : data.formatted) !== null && _h !== void 0 ? _h : '0',
+        symbol: (_j = data === null || data === void 0 ? void 0 : data.symbol) !== null && _j !== void 0 ? _j : '',
+        decimals: (_k = data === null || data === void 0 ? void 0 : data.decimals) !== null && _k !== void 0 ? _k : 18,
+        refetch,
+    };
+}
+
+export { BALANCE_INVALIDATE_EVENT, fetchSolanaBalance, invalidateBalance, useBalance };
+//# sourceMappingURL=useBalance.js.map

package/build/hooks/useBalance.js.map

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

package/build/hooks/useConnectLifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectionStrategy } from '../core/ConnectionStrategy';
+import type { ConnectCallbackProps } from '../openfort/connectCallbackTypes';
+/**
+ * Standalone hook: subscribes to connection lifecycle and fires onConnect/onDisconnect
+ * when strategy.isConnected(state) changes. Must be used inside CoreOpenfortProvider.
+ */
+export declare function useConnectLifecycle(strategy: ConnectionStrategy | null, onConnect: ConnectCallbackProps['onConnect'], onDisconnect: ConnectCallbackProps['onDisconnect']): void;

package/build/hooks/useConnectLifecycle.js

@@ -0,0 +1,43 @@
+import { useRef, useLayoutEffect, useEffect } from 'react';
+import { useOpenfortStore } from '../openfort/useOpenfortStore.js';
+
+/**
+ * Standalone hook: subscribes to connection lifecycle and fires onConnect/onDisconnect
+ * when strategy.isConnected(state) changes. Must be used inside CoreOpenfortProvider.
+ */
+function useConnectLifecycle(strategy, onConnect, onDisconnect) {
+    const user = useOpenfortStore((s) => s.user);
+    const embeddedAccounts = useOpenfortStore((s) => s.embeddedAccounts);
+    const activeEmbeddedAddress = useOpenfortStore((s) => s.activeEmbeddedAddress);
+    const embeddedState = useOpenfortStore((s) => s.embeddedState);
+    const chainType = useOpenfortStore((s) => s.chainType);
+    const prevConnected = useRef(false);
+    const onConnectRef = useRef(onConnect);
+    const onDisconnectRef = useRef(onDisconnect);
+    useLayoutEffect(() => {
+        onConnectRef.current = onConnect;
+        onDisconnectRef.current = onDisconnect;
+    }, [onConnect, onDisconnect]);
+    useEffect(() => {
+        var _a, _b, _c;
+        if (!strategy)
+            return;
+        const state = { user, embeddedAccounts, chainType, activeEmbeddedAddress, embeddedState };
+        const connected = strategy.isConnected(state);
+        if (connected && !prevConnected.current) {
+            prevConnected.current = true;
+            const address = strategy.getAddress(state);
+            (_a = onConnectRef.current) === null || _a === void 0 ? void 0 : _a.call(onConnectRef, { address: address !== null && address !== void 0 ? address : undefined, connectorId: undefined, user: (_b = state.user) !== null && _b !== void 0 ? _b : undefined });
+        }
+        else if (!connected && prevConnected.current) {
+            prevConnected.current = false;
+            (_c = onDisconnectRef.current) === null || _c === void 0 ? void 0 : _c.call(onDisconnectRef);
+        }
+        else {
+            prevConnected.current = connected;
+        }
+    }, [strategy, user, embeddedAccounts, activeEmbeddedAddress, embeddedState, chainType]);
+}
+
+export { useConnectLifecycle };
+//# sourceMappingURL=useConnectLifecycle.js.map

package/build/hooks/useConnectLifecycle.js.map

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

package/build/hooks/useConnectors.d.ts

@@ -1,5 +1,3 @@
-import { type Connector } from 'wagmi';
-export declare function useConnectors(): readonly Connector<import("wagmi").CreateConnectorFn>[];
-export declare function useConnector(id: string, uuid?: string): Connector<import("wagmi").CreateConnectorFn> | undefined;
-export declare function useFamilyAccountsConnector(): Connector<import("wagmi").CreateConnectorFn> | undefined;
-export declare function useFamilyConnector(): Connector<import("wagmi").CreateConnectorFn> | undefined;
+import type { OpenfortEthereumBridgeConnector } from '../ethereum/OpenfortEthereumBridgeContext';
+export declare function useFamilyAccountsConnector(): OpenfortEthereumBridgeConnector | undefined;
+export declare function useFamilyConnector(): OpenfortEthereumBridgeConnector | undefined;

package/build/hooks/useConnectors.js

@@ -0,0 +1,26 @@
+import { useEthereumBridge } from '../ethereum/OpenfortEthereumBridgeContext.js';
+
+function useConnectors() {
+    var _a;
+    const bridge = useEthereumBridge();
+    return (_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) !== null && _a !== void 0 ? _a : [];
+}
+function useConnector(id, uuid) {
+    const connectors = useConnectors();
+    if (id === 'injected' && uuid) {
+        return connectors.find((c) => c.id === id && c.name === uuid);
+    }
+    if (id === 'injected') {
+        return connectors.find((c) => { var _a; return c.id === id && ((_a = c.name) === null || _a === void 0 ? void 0 : _a.includes('Injected')); });
+    }
+    return connectors.find((c) => c.id === id);
+}
+function useFamilyAccountsConnector() {
+    return useConnector('familyAccountsProvider');
+}
+function useFamilyConnector() {
+    return useConnector('co.family.wallet');
+}
+
+export { useFamilyAccountsConnector, useFamilyConnector };
+//# sourceMappingURL=useConnectors.js.map

package/build/hooks/useConnectors.js.map

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