@microcosmmoney/portal-react 3.12.8 → 3.13.0

package/dist/main-portal/hooks/useAuth.d.ts

@@ -0,0 +1,30 @@
+import { type NativeUser } from '../lib/auth-service';
+export type UserRole = 'admin' | 'agent' | 'user';
+export interface WalletEntry {
+    wallet_address: string;
+    is_primary?: boolean;
+}
+export interface UserInfo {
+    uid: string;
+    email: string | null;
+    role: UserRole;
+    apiKeysConfigured: boolean;
+    display_name?: string | null;
+    avatar_url?: string | null;
+    wallet_address?: string | null;
+    wallets?: WalletEntry[];
+    unit_level?: number | null;
+    source_project_id?: string | null;
+}
+export declare const useAuth: () => {
+    user: NativeUser | null;
+    userInfo: UserInfo | null;
+    loading: boolean;
+    error: string | null;
+    isAuthenticated: () => boolean;
+    isAdmin: () => boolean;
+    isAgent: () => boolean;
+    isTrader: () => boolean;
+    hasPermission: (requiredRole: UserRole) => boolean;
+    refreshUserInfo: () => Promise<void>;
+};

package/dist/main-portal/hooks/useAuth.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = void 0;
+// AI-generated · AI-managed · AI-maintained
+// Native Auth Hook — 同步初始化 + 缓存，刷新无闪烁
+const react_1 = require("react");
+const auth_service_1 = require("../lib/auth-service");
+const api_service_1 = require("../lib/api-service");
+const ROLE_HIERARCHY = {
+    'admin': ['admin', 'agent', 'user'],
+    'agent': ['agent', 'user'],
+    'user': ['user']
+};
+// ── 缓存层：sessionStorage 同步读写 ──
+const USER_INFO_CACHE_KEY = 'mc_user_info';
+function getCachedUserInfo() {
+    try {
+        const raw = sessionStorage.getItem(USER_INFO_CACHE_KEY);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function setCachedUserInfo(info) {
+    try {
+        sessionStorage.setItem(USER_INFO_CACHE_KEY, JSON.stringify(info));
+    }
+    catch { }
+}
+function clearCachedUserInfo() {
+    try {
+        sessionStorage.removeItem(USER_INFO_CACHE_KEY);
+    }
+    catch { }
+}
+// ── 同步初始化：第一帧就确定用户状态 ──
+function getInitialState() {
+    if (typeof window === 'undefined') {
+        return { user: null, userInfo: null, loading: true };
+    }
+    const token = (0, auth_service_1.getSessionToken)();
+    if (!token) {
+        return { user: null, userInfo: null, loading: false };
+    }
+    const user = { uid: (0, auth_service_1.getNativeUid)() || 'native-user' };
+    const cached = getCachedUserInfo();
+    // 有 token + 有缓存 → loading=false（后台静默刷新）
+    // 有 token + 无缓存 → loading=true（首次登录，需等 API）
+    return { user, userInfo: cached, loading: !cached };
+}
+// ── Hook ──
+const useAuth = () => {
+    const [initial] = (0, react_1.useState)(getInitialState);
+    const [user, setUser] = (0, react_1.useState)(initial.user);
+    const [userInfo, setUserInfo] = (0, react_1.useState)(initial.userInfo);
+    const [loading, setLoading] = (0, react_1.useState)(initial.loading);
+    const [error, setError] = (0, react_1.useState)(null);
+    const fetchUserInfo = (0, react_1.useCallback)(async (nativeUser) => {
+        try {
+            const data = await (0, api_service_1.getCurrentUserProfile)();
+            if (data.success && data.user) {
+                const info = {
+                    uid: data.user.uid,
+                    email: data.user.email,
+                    role: data.user.role,
+                    apiKeysConfigured: data.user.api_keys_configured,
+                    display_name: data.user.display_name,
+                    avatar_url: data.user.avatar_url,
+                    wallet_address: data.user.wallet_address || data.wallet_address,
+                    wallets: data.user.wallets || [],
+                    unit_level: data.user.unit_level,
+                    source_project_id: data.user.source_project_id,
+                };
+                setUserInfo(info);
+                setCachedUserInfo(info);
+            }
+            else {
+                throw new Error('用户信息格式错误');
+            }
+        }
+        catch (err) {
+            console.error('获取用户信息失败:', err);
+            setError(err instanceof Error ? err.message : '获取用户信息失败');
+            // 如果没有缓存才设置降级 userInfo
+            if (!getCachedUserInfo()) {
+                setUserInfo({
+                    uid: nativeUser.uid,
+                    email: null,
+                    role: 'user',
+                    apiKeysConfigured: false
+                });
+            }
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!user) {
+            (0, auth_service_1.clearAuthFlag)();
+            clearCachedUserInfo();
+            return;
+        }
+        (0, auth_service_1.setAuthFlag)();
+        // 后台刷新最新数据（即使有缓存也要刷新）
+        fetchUserInfo(user);
+    }, [user, fetchUserInfo]);
+    const refreshUserInfo = async () => {
+        if (user) {
+            await fetchUserInfo(user);
+        }
+    };
+    const hasPermission = (requiredRole) => {
+        if (!userInfo)
+            return false;
+        const allowedRoles = ROLE_HIERARCHY[userInfo.role] || ['user'];
+        return allowedRoles.includes(requiredRole);
+    };
+    return {
+        user,
+        userInfo,
+        loading,
+        error,
+        isAuthenticated: () => user !== null && userInfo !== null,
+        isAdmin: () => hasPermission('admin'),
+        isAgent: () => hasPermission('agent'),
+        isTrader: () => hasPermission('agent'),
+        hasPermission,
+        refreshUserInfo,
+    };
+};
+exports.useAuth = useAuth;

package/dist/main-portal/hooks/useMCC.d.ts

@@ -0,0 +1,26 @@
+import type { MCCBalance, MCCLockPeriod, MCCMinting, MCCMintingStats, PDABalance } from '../lib/types/api';
+interface PDAInfo {
+    pda_address: string;
+    token_account: string;
+    bump: number;
+}
+interface UseMCCReturn {
+    balance: MCCBalance | null;
+    totalBalance: number;
+    availableBalance: number;
+    lockedBalance: number;
+    pdaBalance: PDABalance | null;
+    pdaInfo: PDAInfo | null;
+    onChainBalance: number;
+    lockPeriods: MCCLockPeriod[];
+    mintingHistory: MCCMinting[];
+    mintingStats: MCCMintingStats | null;
+    loading: boolean;
+    isRefreshing: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    refreshMinting: () => Promise<void>;
+    refreshPDABalance: () => Promise<void>;
+}
+export declare function useMCC(userId: string | undefined): UseMCCReturn;
+export {};

package/dist/main-portal/hooks/useMCC.js

@@ -0,0 +1,148 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCC = useMCC;
+const react_1 = require("react");
+const api_service_1 = require("../lib/api-service");
+const api_1 = require("../lib/api");
+function useMCC(userId) {
+    const [balance, setBalance] = (0, react_1.useState)(null);
+    const [lockPeriods, setLockPeriods] = (0, react_1.useState)([]);
+    const [mintingHistory, setMintingHistory] = (0, react_1.useState)([]);
+    const [mintingStats, setMintingStats] = (0, react_1.useState)(null);
+    const [pdaBalance, setPdaBalance] = (0, react_1.useState)(null);
+    const [pdaInfo, setPdaInfo] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [isRefreshing, setIsRefreshing] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [hasInitialized, setHasInitialized] = (0, react_1.useState)(false);
+    const canFetch = !!userId;
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (!canFetch) {
+            setLoading(false);
+            return;
+        }
+        try {
+            if (hasInitialized) {
+                setIsRefreshing(true);
+            }
+            else {
+                setLoading(true);
+            }
+            setError(null);
+            const [balanceRes, lockPeriodsRes] = await Promise.all([
+                (0, api_service_1.getMCCBalance)(userId),
+                (0, api_service_1.getMCCLockPeriods)(userId)
+            ]);
+            if (balanceRes.success && balanceRes.data) {
+                setBalance(balanceRes.data);
+            }
+            else if (balanceRes.error) {
+                console.warn('[useMCC] 获取余额受限:', balanceRes.error);
+            }
+            if (lockPeriodsRes.success && lockPeriodsRes.data && Array.isArray(lockPeriodsRes.data)) {
+                setLockPeriods(lockPeriodsRes.data);
+            }
+            else {
+                setLockPeriods([]);
+            }
+        }
+        catch (err) {
+            console.error('[useMCC] 刷新失败:', err);
+            setError(err instanceof Error ? err.message : '加载MCC数据失败');
+        }
+        finally {
+            setLoading(false);
+            setIsRefreshing(false);
+            setHasInitialized(true);
+        }
+    }, [userId, canFetch, hasInitialized]);
+    const refreshMinting = (0, react_1.useCallback)(async () => {
+        if (!canFetch)
+            return;
+        try {
+            const [historyRes, statsRes] = await Promise.all([
+                (0, api_service_1.getMCCMintingHistory)(userId, 50),
+                (0, api_service_1.getMCCMintingStats)()
+            ]);
+            if (historyRes.success && historyRes.data && Array.isArray(historyRes.data)) {
+                setMintingHistory(historyRes.data);
+            }
+            else {
+                setMintingHistory([]);
+            }
+            if (statsRes.success && statsRes.data) {
+                setMintingStats(statsRes.data);
+            }
+        }
+        catch (err) {
+            console.error('[useMCC] 刷新铸造信息失败:', err);
+            setMintingHistory([]);
+        }
+    }, [userId, canFetch]);
+    const refreshPDABalance = (0, react_1.useCallback)(async () => {
+        if (!canFetch)
+            return;
+        try {
+            const numericUserId = balance?.user_id;
+            if (!numericUserId)
+                return;
+            const [balanceRes, addressRes] = await Promise.all([
+                (0, api_1.getPDABalance)(String(numericUserId)),
+                (0, api_1.getPDAAddress)(String(numericUserId))
+            ]);
+            if (balanceRes.success && balanceRes.data) {
+                setPdaBalance(balanceRes.data);
+            }
+            if (addressRes.success && addressRes.data) {
+                setPdaInfo({
+                    pda_address: addressRes.data.pda_address,
+                    token_account: addressRes.data.token_account,
+                    bump: addressRes.data.bump
+                });
+            }
+        }
+        catch (err) {
+            console.error('[useMCC] 刷新PDA余额失败:', err);
+        }
+    }, [canFetch, balance?.user_id]);
+    (0, react_1.useEffect)(() => {
+        if (canFetch) {
+            // 并行加载所有数据，减少渲染次数
+            Promise.all([refresh(), refreshMinting()]).then(() => {
+                // PDA 余额依赖 balance?.user_id，在 refresh 完成后再加载
+                refreshPDABalance();
+            });
+        }
+        else {
+            setLoading(false);
+        }
+    }, [canFetch]); // eslint-disable-line react-hooks/exhaustive-deps
+    (0, react_1.useEffect)(() => {
+        if (!canFetch)
+            return;
+        const interval = setInterval(() => {
+            refresh();
+        }, 30000);
+        return () => clearInterval(interval);
+    }, [canFetch, refresh]);
+    return {
+        balance,
+        totalBalance: balance?.total_balance || 0,
+        availableBalance: balance?.available_balance || 0,
+        lockedBalance: balance?.locked_balance || 0,
+        pdaBalance,
+        pdaInfo,
+        onChainBalance: pdaBalance?.balance || 0,
+        lockPeriods,
+        mintingHistory,
+        mintingStats,
+        loading,
+        isRefreshing,
+        error,
+        refresh,
+        refreshMinting,
+        refreshPDABalance
+    };
+}

package/dist/main-portal/hooks/useMCD.d.ts

@@ -0,0 +1,17 @@
+import type { MCDBalance, MCDTransaction, MCDUserDailyReward } from '../lib/types/api';
+interface UseMCDReturn {
+    balance: MCDBalance | null;
+    mcdBalance: number;
+    totalReceived: number;
+    totalSpent: number;
+    transactions: MCDTransaction[];
+    dailyRewards: MCDUserDailyReward[];
+    loading: boolean;
+    isRefreshing: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    refreshTransactions: () => Promise<void>;
+    refreshDailyRewards: () => Promise<void>;
+}
+export declare function useMCD(userId: string | undefined): UseMCDReturn;
+export {};

package/dist/main-portal/hooks/useMCD.js

@@ -0,0 +1,114 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCD = useMCD;
+const react_1 = require("react");
+const api_1 = require("../lib/api");
+function useMCD(userId) {
+    const [balance, setBalance] = (0, react_1.useState)(null);
+    const [transactions, setTransactions] = (0, react_1.useState)([]);
+    const [dailyRewards, setDailyRewards] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [isRefreshing, setIsRefreshing] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [hasInitialized, setHasInitialized] = (0, react_1.useState)(false);
+    const canFetch = !!userId;
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (!canFetch) {
+            setLoading(false);
+            return;
+        }
+        try {
+            if (hasInitialized) {
+                setIsRefreshing(true);
+            }
+            else {
+                setLoading(true);
+            }
+            setError(null);
+            const balanceRes = await (0, api_1.getMCDBalance)(userId);
+            if (balanceRes.success && balanceRes.data) {
+                setBalance(balanceRes.data);
+            }
+            else if (balanceRes.error) {
+                console.warn('[useMCD] 获取余额受限:', balanceRes.error);
+            }
+        }
+        catch (err) {
+            console.error('[useMCD] 刷新失败:', err);
+            setError(err instanceof Error ? err.message : '加载MCD数据失败');
+        }
+        finally {
+            setLoading(false);
+            setIsRefreshing(false);
+            setHasInitialized(true);
+        }
+    }, [userId, canFetch, hasInitialized]);
+    const refreshTransactions = (0, react_1.useCallback)(async () => {
+        if (!canFetch)
+            return;
+        try {
+            const res = await (0, api_1.getMCDTransactions)(userId, { limit: 50 });
+            if (res.success && res.data && Array.isArray(res.data)) {
+                setTransactions(res.data);
+            }
+            else {
+                console.warn('[useMCD] 交易历史返回非数组数据:', res);
+                setTransactions([]);
+            }
+        }
+        catch (err) {
+            console.error('[useMCD] 刷新交易历史失败:', err);
+            setTransactions([]);
+        }
+    }, [userId, canFetch]);
+    const refreshDailyRewards = (0, react_1.useCallback)(async () => {
+        if (!canFetch)
+            return;
+        try {
+            const res = await (0, api_1.getMCDDailyRewards)(userId, { limit: 30 });
+            if (res.success && res.data && Array.isArray(res.data)) {
+                setDailyRewards(res.data);
+            }
+            else {
+                console.warn('[useMCD] 每日领取记录返回非数组数据:', res);
+                setDailyRewards([]);
+            }
+        }
+        catch (err) {
+            console.error('[useMCD] 刷新每日领取记录失败:', err);
+            setDailyRewards([]);
+        }
+    }, [userId, canFetch]);
+    (0, react_1.useEffect)(() => {
+        if (canFetch) {
+            Promise.all([refresh(), refreshTransactions(), refreshDailyRewards()]);
+        }
+        else {
+            setLoading(false);
+        }
+    }, [canFetch]); // eslint-disable-line react-hooks/exhaustive-deps
+    (0, react_1.useEffect)(() => {
+        if (!canFetch)
+            return;
+        const interval = setInterval(() => {
+            refresh();
+        }, 60000);
+        return () => clearInterval(interval);
+    }, [canFetch, refresh]);
+    return {
+        balance,
+        mcdBalance: balance?.balance || 0,
+        totalReceived: balance?.total_received || 0,
+        totalSpent: balance?.total_spent || 0,
+        transactions,
+        dailyRewards,
+        loading,
+        isRefreshing,
+        error,
+        refresh,
+        refreshTransactions,
+        refreshDailyRewards
+    };
+}

package/dist/main-portal/hooks/useMarketData.d.ts

@@ -0,0 +1,9 @@
+import { type MCCMarketData } from '../lib/api/dexscreener';
+interface UseMarketDataReturn {
+    data: MCCMarketData | null;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function useMarketData(): UseMarketDataReturn;
+export {};

package/dist/main-portal/hooks/useMarketData.js

@@ -0,0 +1,32 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarketData = useMarketData;
+const react_1 = require("react");
+const dexscreener_1 = require("../lib/api/dexscreener");
+function useMarketData() {
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const refresh = (0, react_1.useCallback)(async () => {
+        try {
+            setError(null);
+            const marketData = await (0, dexscreener_1.fetchMCCMarketData)();
+            if (marketData) {
+                setData(marketData);
+            }
+        }
+        catch (err) {
+            setError(String(err));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    (0, react_1.useEffect)(() => {
+        // 非即时数据: 页面加载读一次缓存, 不轮询 (后端 scheduler 每4h刷新)
+        refresh();
+    }, [refresh]);
+    return { data, loading, error, refresh };
+}

package/dist/main-portal/hooks/useMultiWalletBalance.d.ts

@@ -0,0 +1,31 @@
+export interface TokenBalance {
+    symbol: string;
+    name: string;
+    balance: number;
+    usdValue: number;
+    price: number | null;
+}
+export interface WalletInfo {
+    wallet_address: string;
+    wallet_type?: string;
+    is_primary?: boolean;
+}
+export interface WalletBalanceDetail {
+    wallet_address: string;
+    is_primary: boolean;
+    sol: number;
+    mcc: number;
+    usdc: number;
+}
+export interface MultiWalletBalanceData {
+    totalSolBalance: number;
+    totalUsdcBalance: number;
+    totalMccBalance: number;
+    totalUsdValue: number;
+    tokens: TokenBalance[];
+    walletDetails: WalletBalanceDetail[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function useMultiWalletBalance(wallets: WalletInfo[]): MultiWalletBalanceData;

package/dist/main-portal/hooks/useMultiWalletBalance.js

@@ -0,0 +1,65 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiWalletBalance = useMultiWalletBalance;
+const react_1 = require("react");
+const blockchain_1 = require("../lib/api/blockchain");
+function useMultiWalletBalance(wallets) {
+    const [walletDetails, setWalletDetails] = (0, react_1.useState)([]);
+    const [mccPrice, setMccPrice] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const fetchAllBalances = (0, react_1.useCallback)(async () => {
+        if (!wallets || wallets.length === 0) {
+            setLoading(false);
+            setWalletDetails([]);
+            return;
+        }
+        try {
+            setLoading(true);
+            setError(null);
+            const [details, price] = await Promise.all([
+                Promise.all(wallets.map(async (wallet) => {
+                    try {
+                        const balance = await (0, blockchain_1.getWalletBalance)(wallet.wallet_address);
+                        let sol = 0, mcc = 0, usdc = 0;
+                        if (balance) {
+                            sol = balance.sol?.balance || 0;
+                            mcc = balance.tokens?.find(t => t.symbol === 'MCC')?.balance || 0;
+                            usdc = balance.tokens?.find(t => t.symbol === 'USDC')?.balance || 0;
+                        }
+                        return { wallet_address: wallet.wallet_address, is_primary: wallet.is_primary || false, sol, mcc, usdc };
+                    }
+                    catch {
+                        return { wallet_address: wallet.wallet_address, is_primary: wallet.is_primary || false, sol: 0, mcc: 0, usdc: 0 };
+                    }
+                })),
+                (0, blockchain_1.getMccPrice)()
+            ]);
+            setWalletDetails(details);
+            setMccPrice(price);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to fetch balances');
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [wallets]);
+    (0, react_1.useEffect)(() => {
+        fetchAllBalances();
+    }, [fetchAllBalances]);
+    const totalSolBalance = walletDetails.reduce((sum, w) => sum + w.sol, 0);
+    const totalUsdcBalance = walletDetails.reduce((sum, w) => sum + w.usdc, 0);
+    const totalMccBalance = walletDetails.reduce((sum, w) => sum + w.mcc, 0);
+    const tokens = [
+        { symbol: 'MCC', name: 'Microcosm Coin', balance: totalMccBalance, price: mccPrice, usdValue: mccPrice ? totalMccBalance * mccPrice : 0 },
+        { symbol: 'MCD', name: 'Microcosm Dollar', balance: 0, price: null, usdValue: 0 },
+        { symbol: 'SOL', name: 'Solana', balance: totalSolBalance, price: null, usdValue: 0 },
+        { symbol: 'USDC', name: 'USD Coin', balance: totalUsdcBalance, price: null, usdValue: 0 },
+    ];
+    tokens.sort((a, b) => b.usdValue - a.usdValue);
+    const totalUsdValue = tokens.reduce((sum, t) => sum + t.usdValue, 0);
+    return { totalSolBalance, totalUsdcBalance, totalMccBalance, totalUsdValue, tokens, walletDetails, loading, error, refresh: fetchAllBalances };
+}

package/dist/main-portal/hooks/usePriceHistory.d.ts

@@ -0,0 +1,9 @@
+import type { OHLCVData, PriceTimeRange } from '../lib/api/geckoterminal';
+interface UsePriceHistoryReturn {
+    data: OHLCVData[] | null;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function usePriceHistory(range?: PriceTimeRange): UsePriceHistoryReturn;
+export {};

package/dist/main-portal/hooks/usePriceHistory.js

@@ -0,0 +1,36 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePriceHistory = usePriceHistory;
+const react_1 = require("react");
+function usePriceHistory(range = '7D') {
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const refresh = (0, react_1.useCallback)(async () => {
+        try {
+            setError(null);
+            const response = await fetch(`/api/stats/price-history?range=${range}`);
+            const result = await response.json();
+            if (result.success && result.data) {
+                setData(result.data);
+            }
+            else if (result.error) {
+                setError(result.error);
+            }
+        }
+        catch (err) {
+            setError(String(err));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [range]);
+    (0, react_1.useEffect)(() => {
+        setLoading(true);
+        // 非即时数据: 页面加载读一次缓存, 不轮询 (后端 scheduler 每4h刷新)
+        refresh();
+    }, [refresh]);
+    return { data, loading, error, refresh };
+}

package/dist/main-portal/hooks/useSolanaBalance.d.ts

@@ -0,0 +1,21 @@
+export interface TokenBalance {
+    symbol: string;
+    name: string;
+    balance: number;
+    usdValue: number;
+    price: number | null;
+    change24h?: number;
+    icon?: string;
+}
+export interface SolanaBalanceData {
+    walletAddress: string | null;
+    solBalance: number;
+    usdcBalance: number;
+    mccBalance: number;
+    totalUsdValue: number;
+    tokens: TokenBalance[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function useSolanaBalance(walletAddress: string | null): SolanaBalanceData;