@varity-labs/ui-kit 2.0.0-alpha.1

package/dist/hooks/useVarityAPI.js

@@ -0,0 +1,138 @@
+/**
+ * useVarityAPI - Main hook for Varity API integration
+ *
+ * Provides a React hook interface to the Varity API with automatic error handling,
+ * loading states, and caching.
+ */
+import React, { useContext, createContext, useState, useCallback } from 'react';
+import { VarityClient } from '../core/VarityClient';
+const VarityAPIContext = createContext(undefined);
+/**
+ * VarityAPIProvider - Context provider for Varity API
+ *
+ * Wrap your app with this provider to enable useVarityAPI hook.
+ *
+ * @example
+ * ```tsx
+ * <VarityAPIProvider config={{ apiEndpoint: 'https://api.varity.io' }}>
+ *   <App />
+ * </VarityAPIProvider>
+ * ```
+ */
+export const VarityAPIProvider = ({ config, children }) => {
+    const [client] = useState(() => new VarityClient(config));
+    const [isAuthenticated, setAuthenticated] = useState(false);
+    return (React.createElement(VarityAPIContext.Provider, { value: { client, isAuthenticated, setAuthenticated } }, children));
+};
+/**
+ * useVarityAPI Hook
+ *
+ * Access Varity client from any component.
+ *
+ * @example
+ * ```tsx
+ * const { client, isAuthenticated } = useVarityAPI()
+ * const data = await client.analytics.getKPIs({ period: 'current_month' })
+ * ```
+ */
+export const useVarityAPI = () => {
+    const context = useContext(VarityAPIContext);
+    if (!context) {
+        throw new Error('useVarityAPI must be used within a VarityAPIProvider');
+    }
+    return context;
+};
+/**
+ * useVarityQuery Hook
+ *
+ * Execute API queries with automatic loading and error states.
+ *
+ * @example
+ * ```tsx
+ * const { data, loading, error, refetch } = useVarityQuery(
+ *   async (client) => client.analytics.getKPIs({ period: 'current_month' })
+ * )
+ * ```
+ */
+export function useVarityQuery(queryFn, deps = []) {
+    const { client } = useVarityAPI();
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const execute = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await queryFn(client);
+            setData(result);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Unknown error');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, ...deps]);
+    // Auto-execute on mount
+    useState(() => {
+        execute();
+    });
+    return {
+        data,
+        loading,
+        error,
+        refetch: execute
+    };
+}
+/**
+ * useVarityMutation Hook
+ *
+ * Execute API mutations with loading and error states.
+ *
+ * @example
+ * ```tsx
+ * const { mutate, loading, error } = useVarityMutation(
+ *   async (client, file: File) => client.storage.uploadFile(file)
+ * )
+ *
+ * // Later in code
+ * await mutate(file)
+ * ```
+ */
+export function useVarityMutation(mutationFn) {
+    const { client } = useVarityAPI();
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [data, setData] = useState(null);
+    const mutate = useCallback(async (...args) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await mutationFn(client, ...args);
+            setData(result);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Unknown error');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client]);
+    return {
+        mutate,
+        loading,
+        error,
+        data,
+        reset: () => {
+            setData(null);
+            setError(null);
+        }
+    };
+}
+//# sourceMappingURL=useVarityAPI.js.map

package/dist/hooks/useVarityAPI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVarityAPI.js","sourceRoot":"","sources":["../../src/hooks/useVarityAPI.tsx"],"names":[],"mappings":"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"}

package/dist/hooks/useWalletAuth.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Wallet session information
+ */
+export interface WalletSession {
+    sessionToken: string;
+    walletAddress: string;
+    expiresAt: number;
+    expiresIn: number;
+}
+/**
+ * Session information from the backend
+ */
+export interface SessionInfo {
+    wallet_address: string;
+    session_token: string;
+    created_at: number;
+    expires_at: number;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Return type for useWalletAuth hook
+ */
+export interface UseWalletAuthReturn {
+    /** Whether the user is authenticated with a valid session */
+    isAuthenticated: boolean;
+    /** The current session token */
+    sessionToken: string | null;
+    /** The authenticated wallet address */
+    walletAddress: string | null;
+    /** Whether authentication is in progress */
+    isAuthenticating: boolean;
+    /** Authentication error message if any */
+    authError: string | null;
+    /** List of active sessions across devices */
+    sessions: SessionInfo[];
+    /** Initiate login with wallet signature */
+    login: () => Promise<void>;
+    /** Logout and invalidate session */
+    logout: () => Promise<void>;
+    /** Refresh session expiration */
+    refreshSession: () => Promise<void>;
+    /** Get all active sessions */
+    getSessions: () => Promise<void>;
+    /** Logout from a specific session */
+    logoutFromSession: (sessionToken: string) => Promise<void>;
+    /** Logout from all devices */
+    logoutFromAllDevices: () => Promise<void>;
+    /** Add additional wallet to session (multi-wallet support) */
+    addWallet: (newWalletAddress: string) => Promise<void>;
+    /** Get axios-like fetch with auth headers */
+    authFetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Configuration for useWalletAuth hook
+ */
+export interface UseWalletAuthConfig {
+    /** Base URL for the API (default: from env or localhost:8000) */
+    apiBaseUrl?: string;
+    /** Auto-login when Privy authenticates (default: true) */
+    autoLogin?: boolean;
+    /** Auto-refresh session interval in minutes (default: 30) */
+    refreshIntervalMinutes?: number;
+    /** Callback when session changes */
+    onSessionChange?: (session: WalletSession | null) => void;
+    /** Callback when auth error occurs */
+    onAuthError?: (error: string) => void;
+}
+/**
+ * useWalletAuth - Wallet-based authentication with session management
+ *
+ * This hook provides complete wallet authentication functionality:
+ * - Signs in using wallet signature (EIP-191)
+ * - Manages session tokens with auto-refresh
+ * - Handles multi-device sessions
+ * - Integrates with Privy for embedded wallets
+ *
+ * @example
+ * ```tsx
+ * import { useWalletAuth } from '@varity-labs/ui-kit';
+ *
+ * function MyComponent() {
+ *   const {
+ *     isAuthenticated,
+ *     walletAddress,
+ *     login,
+ *     logout,
+ *     authFetch,
+ *   } = useWalletAuth({
+ *     apiBaseUrl: 'https://api.example.com',
+ *   });
+ *
+ *   if (!isAuthenticated) {
+ *     return <button onClick={login}>Sign In</button>;
+ *   }
+ *
+ *   const fetchData = async () => {
+ *     // authFetch automatically includes session token
+ *     const response = await authFetch('/api/v1/data');
+ *     return response.json();
+ *   };
+ *
+ *   return <p>Connected: {walletAddress}</p>;
+ * }
+ * ```
+ */
+export declare function useWalletAuth(config?: UseWalletAuthConfig): UseWalletAuthReturn;
+export default useWalletAuth;
+//# sourceMappingURL=useWalletAuth.d.ts.map

package/dist/hooks/useWalletAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useWalletAuth.ts"],"names":[],"mappings":"AAmBA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAElC,6DAA6D;IAC7D,eAAe,EAAE,OAAO,CAAC;IACzB,gCAAgC;IAChC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,uCAAuC;IACvC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,4CAA4C;IAC5C,gBAAgB,EAAE,OAAO,CAAC;IAC1B,0CAA0C;IAC1C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAGzB,6CAA6C;IAC7C,QAAQ,EAAE,WAAW,EAAE,CAAC;IAGxB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,oCAAoC;IACpC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,iCAAiC;IACjC,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,8BAA8B;IAC9B,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,qCAAqC;IACrC,iBAAiB,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,8BAA8B;IAC9B,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,8DAA8D;IAC9D,SAAS,EAAE,CAAC,gBAAgB,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAGvD,6CAA6C;IAC7C,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChF;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,6DAA6D;IAC7D,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oCAAoC;IACpC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1D,sCAAsC;IACtC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,aAAa,CAAC,MAAM,GAAE,mBAAwB,GAAG,mBAAmB,CA4ZnF;AAED,eAAe,aAAa,CAAC"}

package/dist/hooks/useWalletAuth.js

@@ -0,0 +1,415 @@
+/**
+ * Wallet Authentication Hook
+ *
+ * Provides wallet-based authentication with session management.
+ * Integrates with Privy for seamless Web3 UX and backend session tokens.
+ *
+ * This hook handles:
+ * - Wallet signature authentication
+ * - Session token management
+ * - Auto-login when Privy authenticates
+ * - Session refresh and expiration handling
+ * - Multi-device session management
+ *
+ * @packageDocumentation
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { usePrivy, useWallets } from '@privy-io/react-auth';
+import { useActiveAccount } from 'thirdweb/react';
+/**
+ * useWalletAuth - Wallet-based authentication with session management
+ *
+ * This hook provides complete wallet authentication functionality:
+ * - Signs in using wallet signature (EIP-191)
+ * - Manages session tokens with auto-refresh
+ * - Handles multi-device sessions
+ * - Integrates with Privy for embedded wallets
+ *
+ * @example
+ * ```tsx
+ * import { useWalletAuth } from '@varity-labs/ui-kit';
+ *
+ * function MyComponent() {
+ *   const {
+ *     isAuthenticated,
+ *     walletAddress,
+ *     login,
+ *     logout,
+ *     authFetch,
+ *   } = useWalletAuth({
+ *     apiBaseUrl: 'https://api.example.com',
+ *   });
+ *
+ *   if (!isAuthenticated) {
+ *     return <button onClick={login}>Sign In</button>;
+ *   }
+ *
+ *   const fetchData = async () => {
+ *     // authFetch automatically includes session token
+ *     const response = await authFetch('/api/v1/data');
+ *     return response.json();
+ *   };
+ *
+ *   return <p>Connected: {walletAddress}</p>;
+ * }
+ * ```
+ */
+export function useWalletAuth(config = {}) {
+    const { apiBaseUrl = process.env.NEXT_PUBLIC_API_URL ||
+        process.env.NEXT_PUBLIC_BACKEND_URL ||
+        'http://localhost:8000', autoLogin = true, refreshIntervalMinutes = 30, onSessionChange, onAuthError, } = config;
+    const { authenticated, ready } = usePrivy();
+    const { wallets } = useWallets();
+    const activeAccount = useActiveAccount();
+    const [sessionToken, setSessionToken] = useState(null);
+    const [walletAddress, setWalletAddress] = useState(null);
+    const [isAuthenticating, setIsAuthenticating] = useState(false);
+    const [authError, setAuthError] = useState(null);
+    const [sessions, setSessions] = useState([]);
+    // Get wallet address from Privy or thirdweb
+    const address = wallets?.[0]?.address || activeAccount?.address;
+    /**
+     * Verify session is still valid
+     */
+    const verifySession = useCallback(async (token) => {
+        try {
+            const response = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/session`, {
+                headers: {
+                    'X-Session-Token': token,
+                },
+            });
+            return response.status === 200;
+        }
+        catch {
+            return false;
+        }
+    }, [apiBaseUrl]);
+    // Load session from localStorage on mount
+    useEffect(() => {
+        const storedToken = localStorage.getItem('wallet_session_token');
+        const storedAddress = localStorage.getItem('wallet_address');
+        if (storedToken && storedAddress) {
+            setSessionToken(storedToken);
+            setWalletAddress(storedAddress);
+            // Verify session is still valid
+            verifySession(storedToken).catch(() => {
+                // Session invalid, clear storage
+                localStorage.removeItem('wallet_session_token');
+                localStorage.removeItem('wallet_address');
+                setSessionToken(null);
+                setWalletAddress(null);
+            });
+        }
+    }, [verifySession]);
+    /**
+     * Sign message with wallet
+     */
+    const signMessage = useCallback(async (message) => {
+        // Try Privy wallet first
+        const privyWallet = wallets?.[0];
+        if (privyWallet && 'signMessage' in privyWallet) {
+            try {
+                // Privy wallets support signMessage directly
+                const signature = await privyWallet.signMessage(message);
+                return signature;
+            }
+            catch (error) {
+                console.error('Privy wallet signing failed', error);
+                throw error;
+            }
+        }
+        // Fall back to thirdweb active account
+        if (activeAccount && 'signMessage' in activeAccount) {
+            try {
+                const signature = await activeAccount.signMessage({ message });
+                return signature;
+            }
+            catch (error) {
+                console.error('Thirdweb wallet signing failed', error);
+                throw error;
+            }
+        }
+        throw new Error('No wallet available for signing');
+    }, [wallets, activeAccount]);
+    /**
+     * Login with wallet signature
+     */
+    const login = useCallback(async () => {
+        if (!address) {
+            const error = 'No wallet connected';
+            setAuthError(error);
+            onAuthError?.(error);
+            return;
+        }
+        setIsAuthenticating(true);
+        setAuthError(null);
+        try {
+            // Step 1: Get authentication message
+            const messageResponse = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/message`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ wallet_address: address }),
+            });
+            if (!messageResponse.ok) {
+                throw new Error('Failed to get authentication message');
+            }
+            const { message, nonce } = await messageResponse.json();
+            // Step 2: Sign message with wallet
+            const signature = await signMessage(message);
+            // Step 3: Login with signature
+            const loginResponse = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/login`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    wallet_address: address,
+                    signature,
+                    message,
+                    nonce,
+                    user_agent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
+                }),
+            });
+            if (!loginResponse.ok) {
+                const errorData = await loginResponse.json().catch(() => ({}));
+                throw new Error(errorData.detail?.message || errorData.detail || 'Authentication failed');
+            }
+            const session = await loginResponse.json();
+            // Store session
+            setSessionToken(session.sessionToken);
+            setWalletAddress(session.walletAddress);
+            localStorage.setItem('wallet_session_token', session.sessionToken);
+            localStorage.setItem('wallet_address', session.walletAddress);
+            onSessionChange?.(session);
+            console.log('Wallet authentication successful');
+        }
+        catch (error) {
+            console.error('Wallet authentication failed', error);
+            const errorMessage = error instanceof Error ? error.message : 'Authentication failed';
+            setAuthError(errorMessage);
+            onAuthError?.(errorMessage);
+            // Clear any existing session
+            setSessionToken(null);
+            setWalletAddress(null);
+            localStorage.removeItem('wallet_session_token');
+            localStorage.removeItem('wallet_address');
+        }
+        finally {
+            setIsAuthenticating(false);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [address, apiBaseUrl, onSessionChange, onAuthError, signMessage]);
+    /**
+     * Logout and invalidate session
+     */
+    const logout = useCallback(async () => {
+        if (!sessionToken)
+            return;
+        try {
+            await fetch(`${apiBaseUrl}/api/v1/wallet/auth/logout`, {
+                method: 'POST',
+                headers: {
+                    'X-Session-Token': sessionToken,
+                },
+            });
+            console.log('Logged out successfully');
+        }
+        catch (error) {
+            console.error('Logout failed', error);
+        }
+        finally {
+            // Clear session regardless of API success
+            setSessionToken(null);
+            setWalletAddress(null);
+            localStorage.removeItem('wallet_session_token');
+            localStorage.removeItem('wallet_address');
+            onSessionChange?.(null);
+        }
+    }, [sessionToken, apiBaseUrl, onSessionChange]);
+    /**
+     * Refresh session expiration
+     */
+    const refreshSession = useCallback(async () => {
+        if (!sessionToken)
+            return;
+        try {
+            const response = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/refresh`, {
+                method: 'POST',
+                headers: {
+                    'X-Session-Token': sessionToken,
+                },
+            });
+            if (!response.ok) {
+                throw new Error('Session refresh failed');
+            }
+            const session = await response.json();
+            console.log('Session refreshed', { expiresAt: new Date(session.expiresAt * 1000) });
+        }
+        catch (error) {
+            console.error('Session refresh failed', error);
+            // Session might be expired, logout
+            await logout();
+        }
+    }, [sessionToken, apiBaseUrl, logout]);
+    /**
+     * Get all active sessions
+     */
+    const getSessions = useCallback(async () => {
+        if (!sessionToken)
+            return;
+        try {
+            const response = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/sessions`, {
+                headers: {
+                    'X-Session-Token': sessionToken,
+                },
+            });
+            if (!response.ok) {
+                throw new Error('Failed to get sessions');
+            }
+            const sessionsData = await response.json();
+            setSessions(sessionsData);
+        }
+        catch (error) {
+            console.error('Failed to get sessions', error);
+        }
+    }, [sessionToken, apiBaseUrl]);
+    /**
+     * Logout from specific session
+     */
+    const logoutFromSession = useCallback(async (targetSessionToken) => {
+        if (!sessionToken)
+            return;
+        try {
+            await fetch(`${apiBaseUrl}/api/v1/wallet/auth/sessions/${targetSessionToken}`, {
+                method: 'DELETE',
+                headers: {
+                    'X-Session-Token': sessionToken,
+                },
+            });
+            console.log('Session invalidated');
+            // If we logged out our own session, clear local state
+            if (targetSessionToken === sessionToken) {
+                await logout();
+            }
+            else {
+                // Refresh sessions list
+                await getSessions();
+            }
+        }
+        catch (error) {
+            console.error('Failed to invalidate session', error);
+        }
+    }, [sessionToken, apiBaseUrl, logout, getSessions]);
+    /**
+     * Logout from all devices
+     */
+    const logoutFromAllDevices = useCallback(async () => {
+        if (!sessionToken)
+            return;
+        try {
+            await fetch(`${apiBaseUrl}/api/v1/wallet/auth/sessions`, {
+                method: 'DELETE',
+                headers: {
+                    'X-Session-Token': sessionToken,
+                },
+            });
+            console.log('Logged out from all devices');
+            // Clear local session
+            await logout();
+        }
+        catch (error) {
+            console.error('Failed to logout from all devices', error);
+        }
+    }, [sessionToken, apiBaseUrl, logout]);
+    /**
+     * Add additional wallet to session (multi-wallet support)
+     */
+    const addWallet = useCallback(async (newWalletAddress) => {
+        if (!sessionToken)
+            return;
+        try {
+            // Get authentication message for new wallet
+            const messageResponse = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/message`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ wallet_address: newWalletAddress }),
+            });
+            if (!messageResponse.ok) {
+                throw new Error('Failed to get authentication message');
+            }
+            const { message, nonce } = await messageResponse.json();
+            // Sign message with new wallet
+            const signature = await signMessage(message);
+            // Add wallet to session
+            const response = await fetch(`${apiBaseUrl}/api/v1/wallet/auth/add-wallet`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Session-Token': sessionToken,
+                },
+                body: JSON.stringify({
+                    new_wallet_address: newWalletAddress,
+                    signature,
+                    message,
+                    nonce,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error('Failed to add wallet');
+            }
+            console.log('Wallet added successfully');
+        }
+        catch (error) {
+            console.error('Failed to add wallet', error);
+            throw error;
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sessionToken, apiBaseUrl, signMessage]);
+    /**
+     * Fetch with auth headers
+     */
+    const authFetch = useCallback(async (input, init) => {
+        const headers = new Headers(init?.headers);
+        if (sessionToken) {
+            headers.set('X-Session-Token', sessionToken);
+        }
+        return fetch(input, { ...init, headers });
+    }, [sessionToken]);
+    // Auto-login when Privy authenticates
+    useEffect(() => {
+        if (autoLogin && ready && authenticated && address && !sessionToken && !isAuthenticating) {
+            console.log('Auto-logging in with wallet', { address });
+            login().catch((e) => console.error('Auto-login failed', e));
+        }
+    }, [autoLogin, ready, authenticated, address, sessionToken, isAuthenticating, login]);
+    // Auto-refresh session
+    useEffect(() => {
+        if (!sessionToken)
+            return;
+        const intervalId = setInterval(() => {
+            refreshSession().catch((e) => console.error('Auto-refresh failed', e));
+        }, refreshIntervalMinutes * 60 * 1000);
+        return () => clearInterval(intervalId);
+    }, [sessionToken, refreshSession, refreshIntervalMinutes]);
+    return {
+        // Authentication state
+        isAuthenticated: !!sessionToken && !!walletAddress,
+        sessionToken,
+        walletAddress,
+        isAuthenticating,
+        authError,
+        // Session management
+        sessions,
+        // Actions
+        login,
+        logout,
+        refreshSession,
+        getSessions,
+        logoutFromSession,
+        logoutFromAllDevices,
+        addWallet,
+        // Utility
+        authFetch,
+    };
+}
+export default useWalletAuth;
+//# sourceMappingURL=useWalletAuth.js.map