@microcosmmoney/portal-react 3.12.8 → 3.13.1

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

@@ -0,0 +1,82 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSpeechRecognition = useSpeechRecognition;
+const react_1 = require("react");
+function useSpeechRecognition(onTranscript) {
+    const [isRecording, setIsRecording] = (0, react_1.useState)(false);
+    const [recordingTime, setRecordingTime] = (0, react_1.useState)(0);
+    const recognitionRef = (0, react_1.useRef)(null);
+    const timerRef = (0, react_1.useRef)(null);
+    const isRecordingRef = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (typeof window === "undefined")
+            return;
+        const Ctor = window.SpeechRecognition
+            || window.webkitSpeechRecognition;
+        if (!Ctor)
+            return;
+        const instance = new Ctor();
+        instance.continuous = true;
+        instance.interimResults = true;
+        instance.lang = "zh-CN";
+        instance.onresult = (event) => {
+            let finalTranscript = "";
+            for (let i = event.resultIndex; i < event.results.length; i++) {
+                if (event.results[i].isFinal) {
+                    finalTranscript += event.results[i][0].transcript;
+                }
+            }
+            if (finalTranscript)
+                onTranscript(finalTranscript);
+        };
+        instance.onerror = () => { };
+        instance.onend = () => {
+            if (isRecordingRef.current) {
+                try {
+                    instance.start();
+                }
+                catch { }
+            }
+        };
+        recognitionRef.current = instance;
+        return () => {
+            instance.stop();
+            if (timerRef.current)
+                clearInterval(timerRef.current);
+        };
+    }, [onTranscript]);
+    const startRecording = (0, react_1.useCallback)(() => {
+        if (!recognitionRef.current)
+            return;
+        try {
+            recognitionRef.current.start();
+            isRecordingRef.current = true;
+            setIsRecording(true);
+            setRecordingTime(0);
+            timerRef.current = setInterval(() => setRecordingTime((prev) => prev + 1), 1000);
+        }
+        catch { }
+    }, []);
+    const stopRecording = (0, react_1.useCallback)(() => {
+        isRecordingRef.current = false;
+        recognitionRef.current?.stop();
+        setIsRecording(false);
+        if (timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+        }
+    }, []);
+    const toggleRecording = (0, react_1.useCallback)(() => {
+        if (isRecording)
+            stopRecording();
+        else
+            startRecording();
+    }, [isRecording, startRecording, stopRecording]);
+    const formatTime = (seconds) => {
+        const mins = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        return `${mins}:${secs.toString().padStart(2, "0")}`;
+    };
+    return { isRecording, recordingTime, toggleRecording, formatTime };
+}

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

@@ -0,0 +1,131 @@
+export interface OverviewStats {
+    total_users: number;
+    active_users_24h: number;
+    new_users_today: number;
+    total_territories: number;
+    mcc_circulating: number;
+    mcd_locked: number;
+    updated_at: string;
+}
+export interface MCCStats {
+    total_supply: number;
+    circulating_supply: number;
+    genesis_pool_balance: number;
+    current_phase: number;
+    current_mining_rate: number;
+    next_halving_at: number;
+    remaining_to_halving: number;
+    total_mining_count: number;
+    total_mining_usdc: number;
+    holders_count: number;
+}
+export interface MCDStats {
+    total_supply: number;
+    circulating_supply: number;
+    genesis_pool_balance: number;
+    total_vault_balance: number;
+    total_spent: number;
+    user_balance: number;
+    daily_distribution: number;
+    active_vaults: number;
+    holders_count: number;
+    daily_distribution_rate: number;
+}
+export interface TerritoryItem {
+    type: string;
+    name: string;
+    total: number;
+    active: number;
+    capacity: number;
+    population: number;
+}
+export interface TerritoryStats {
+    territories: TerritoryItem[];
+    total_capacity: number;
+    total_users_in_territories: number;
+}
+export interface UserLevelItem {
+    level: number;
+    name: string;
+    chinese: string;
+    count: number;
+    percentage: number;
+}
+export interface UserLevelStats {
+    levels: UserLevelItem[];
+    total_users: number;
+    miners_and_above: number;
+    new_users_today: number;
+    monthly_active_rate: number;
+}
+export interface TeamWalletItem {
+    key: string;
+    label: string;
+    address: string;
+    ata: string;
+    mcc_balance: number;
+    percentage: number;
+}
+export interface TeamWalletStats {
+    wallets: TeamWalletItem[];
+    total_mcc: number;
+    updated_at: string;
+}
+export interface MiningHistoryItem {
+    date: string;
+    usdc_amount: number;
+    usdt_amount: number;
+    total_mcc: number;
+    total_mcd: number;
+    tx_count: number;
+}
+export interface MiningHistoryStats {
+    history: MiningHistoryItem[];
+    days: number;
+    summary: {
+        total_usdc: number;
+        total_usdt: number;
+        total_stablecoin: number;
+        total_mcc: number;
+        total_mcd: number;
+        total_tx: number;
+        avg_daily: number;
+    };
+}
+interface UseStatsReturn<T> {
+    data: T | null;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare const useOverviewStats: () => UseStatsReturn<OverviewStats>;
+export declare const useMCCStats: () => UseStatsReturn<MCCStats>;
+export declare const useMCDStats: () => UseStatsReturn<MCDStats>;
+export declare const useTerritoryStats: () => UseStatsReturn<TerritoryStats>;
+export declare const useUserLevelStats: () => UseStatsReturn<UserLevelStats>;
+export declare const useTeamWalletStats: () => UseStatsReturn<TeamWalletStats>;
+export interface UserGrowthPoint {
+    date: string;
+    new_users: number;
+    total_users: number;
+}
+export interface UserGrowthStats {
+    history: UserGrowthPoint[];
+    days: number;
+    total_users: number;
+}
+export declare function useUserGrowth(days?: number): UseStatsReturn<UserGrowthStats>;
+export declare function useMiningHistory(days?: number): UseStatsReturn<MiningHistoryStats>;
+export declare function useAllStats(): {
+    overview: OverviewStats | null;
+    mcc: MCCStats | null;
+    mcd: MCDStats | null;
+    territories: TerritoryStats | null;
+    userLevels: UserLevelStats | null;
+    teamWallets: TeamWalletStats | null;
+    miningHistory: MiningHistoryStats | null;
+    loading: boolean;
+    error: string | null;
+    refreshAll: () => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,161 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTeamWalletStats = exports.useUserLevelStats = exports.useTerritoryStats = exports.useMCDStats = exports.useMCCStats = exports.useOverviewStats = void 0;
+exports.useUserGrowth = useUserGrowth;
+exports.useMiningHistory = useMiningHistory;
+exports.useAllStats = useAllStats;
+const react_1 = require("react");
+async function fetchStats(endpoint) {
+    try {
+        const response = await fetch(`/api/stats/${endpoint}`);
+        const data = await response.json();
+        return data;
+    }
+    catch (error) {
+        console.error(`[useStats] fetch ${endpoint} error:`, error);
+        return { success: false, error: String(error) };
+    }
+}
+function createStatsHook(endpoint, refreshInterval) {
+    return function useStatsData() {
+        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 result = await fetchStats(endpoint);
+                if (result.success && result.data) {
+                    setData(result.data);
+                }
+                else if (result.error) {
+                    setError(result.error);
+                }
+            }
+            catch (err) {
+                setError(String(err));
+            }
+            finally {
+                setLoading(false);
+            }
+        }, []);
+        (0, react_1.useEffect)(() => {
+            refresh();
+            if (refreshInterval) {
+                const interval = setInterval(refresh, refreshInterval);
+                return () => clearInterval(interval);
+            }
+        }, [refresh]);
+        return { data, loading, error, refresh };
+    };
+}
+// 非即时数据: 不轮询, 页面加载读一次缓存 (后端 scheduler 每4h刷新)
+exports.useOverviewStats = createStatsHook('overview');
+exports.useMCCStats = createStatsHook('mcc');
+exports.useMCDStats = createStatsHook('mcd');
+exports.useTerritoryStats = createStatsHook('territories');
+exports.useUserLevelStats = createStatsHook('users');
+exports.useTeamWalletStats = createStatsHook('team-wallets');
+function useUserGrowth(days = 30) {
+    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/user-growth?days=${days}`);
+            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);
+        }
+    }, [days]);
+    (0, react_1.useEffect)(() => { refresh(); }, [refresh]);
+    return { data, loading, error, refresh };
+}
+function useMiningHistory(days = 7) {
+    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/mining-history?days=${days}`);
+            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);
+        }
+    }, [days]);
+    (0, react_1.useEffect)(() => {
+        // 非即时数据: 页面加载读一次缓存, 不轮询
+        refresh();
+    }, [refresh]);
+    return { data, loading, error, refresh };
+}
+function useAllStats() {
+    const overview = (0, exports.useOverviewStats)();
+    const mcc = (0, exports.useMCCStats)();
+    const mcd = (0, exports.useMCDStats)();
+    const territories = (0, exports.useTerritoryStats)();
+    const userLevels = (0, exports.useUserLevelStats)();
+    const teamWallets = (0, exports.useTeamWalletStats)();
+    const miningHistory = useMiningHistory(7);
+    const loading = overview.loading ||
+        mcc.loading ||
+        mcd.loading ||
+        territories.loading ||
+        userLevels.loading ||
+        teamWallets.loading ||
+        miningHistory.loading;
+    const error = overview.error ||
+        mcc.error ||
+        mcd.error ||
+        territories.error ||
+        userLevels.error ||
+        teamWallets.error ||
+        miningHistory.error;
+    const refreshAll = (0, react_1.useCallback)(async () => {
+        await Promise.all([
+            overview.refresh(),
+            mcc.refresh(),
+            mcd.refresh(),
+            territories.refresh(),
+            userLevels.refresh(),
+            teamWallets.refresh(),
+            miningHistory.refresh()
+        ]);
+    }, [overview, mcc, mcd, territories, userLevels, teamWallets, miningHistory]);
+    return {
+        overview: overview.data,
+        mcc: mcc.data,
+        mcd: mcd.data,
+        territories: territories.data,
+        userLevels: userLevels.data,
+        teamWallets: teamWallets.data,
+        miningHistory: miningHistory.data,
+        loading,
+        error,
+        refreshAll
+    };
+}

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

@@ -0,0 +1,134 @@
+interface PositionData {
+    amount?: number;
+    entryPrice?: number;
+}
+interface PowerStartCheck {
+    profit_check?: {
+        passed: boolean;
+        current: number;
+        threshold: number;
+    };
+    gap_check?: {
+        passed: boolean;
+        current: number;
+        threshold: number;
+    };
+    thickness_check?: {
+        passed: boolean;
+        thickness_pct: number;
+    };
+    orders_check?: {
+        passed: boolean;
+        long_count: number;
+        short_count: number;
+        max_orders: number;
+    };
+}
+export interface LiveState {
+    total_unrealized_pnl?: number;
+    energy_unrealized_pnl?: number;
+    price_gap_pct?: number;
+    price_gap_abs?: number;
+    current_drawdown_pct?: number;
+    current_price?: number;
+    wallet_balance?: number;
+    total_long_pos_amount?: number;
+    total_short_pos_amount?: number;
+    power_open_orders_long?: number;
+    power_open_orders_short?: number;
+    power_tp_orders_long?: number;
+    power_tp_orders_short?: number;
+    power_total_realized_pnl?: number;
+    power_closed_trades_long?: number;
+    power_closed_trades_short?: number;
+    energy_realized_pnl?: number;
+    user_manual_long_position?: number;
+    user_manual_short_position?: number;
+    user_manual_realized_pnl?: number;
+    power_start_mode?: string;
+    power_start_check?: PowerStartCheck;
+    positions?: {
+        energy?: {
+            LONG?: PositionData;
+            SHORT?: PositionData;
+        };
+        power?: {
+            LONG?: {
+                amount?: number;
+                open_orders?: number;
+                tp_orders?: number;
+            };
+            SHORT?: {
+                amount?: number;
+                open_orders?: number;
+                tp_orders?: number;
+            };
+        };
+        total_long?: PositionData;
+        total_short?: PositionData;
+    };
+    raw_snapshot?: {
+        positions?: Array<{
+            positionSide: 'LONG' | 'SHORT';
+            unRealizedProfit: string;
+            positionAmt: string;
+            entryPrice: string;
+            markPrice: string;
+        }>;
+    };
+    start_time?: string;
+    duration?: string;
+    power_today_realized_pnl?: number;
+    energy_today_realized_pnl?: number;
+    power_win_rate?: number;
+    power_profit_factor?: number;
+    energy_win_rate?: number;
+    energy_profit_factor?: number;
+    energy_hedge_count?: number;
+    energy_sync_hedge_count?: number;
+    energy_tp_form_a_count?: number;
+    energy_tp_form_b_count?: number;
+    power_stale_converted_count?: number;
+    power_avg_holding_duration?: number;
+    power_longest_stale_duration?: number;
+    power_avg_stale_duration?: number;
+    power_stale_cleanup_count?: number;
+    power_protection_trigger_count?: number;
+    power_total_fees?: number;
+    energy_total_fees?: number;
+    power_today_fees?: number;
+    energy_today_fees?: number;
+    power_month_fees?: number;
+    energy_month_fees?: number;
+    manual_open_count?: number;
+    manual_close_count?: number;
+    manual_chase_count?: number;
+    manual_cancel_count?: number;
+}
+export interface PowerParams {
+    start_price_gap_pct?: number;
+    open_pos_quantity?: number;
+    start_pos_thickness_pct?: number;
+    max_open_orders?: number;
+    start_energy_profit_pct?: number;
+}
+export interface Strategy {
+    id: string;
+    name?: string;
+    strategy_name?: string;
+    symbol?: string;
+    is_active: boolean;
+    base?: {
+        symbol?: string;
+    };
+    power?: PowerParams;
+    params?: {
+        power?: PowerParams;
+    };
+    live_state?: LiveState;
+    created_at?: string;
+    updated_at?: string;
+}
+export declare function useStrategies(refreshInterval?: number): import("swr").SWRResponse<Strategy[], any, import("swr").SWRConfiguration<Strategy[], any, import("swr").BareFetcher<Strategy[]>> | undefined>;
+export declare function useStrategyDetails(strategyId: string | null, refreshInterval?: number): import("swr").SWRResponse<Strategy, any, import("swr").SWRConfiguration<Strategy, any, import("swr").BareFetcher<Strategy>> | undefined>;
+export {};

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

@@ -0,0 +1,28 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStrategies = useStrategies;
+exports.useStrategyDetails = useStrategyDetails;
+const swr_1 = __importDefault(require("swr"));
+const api_service_1 = require("../lib/api-service");
+const fetcher = async (url) => (0, api_service_1.fetchApi)(url);
+function useStrategies(refreshInterval = 15000) {
+    return (0, swr_1.default)('/strategies', fetcher, {
+        refreshInterval,
+        revalidateOnFocus: true,
+        dedupingInterval: 5000,
+        errorRetryCount: 3,
+    });
+}
+function useStrategyDetails(strategyId, refreshInterval = 15000) {
+    return (0, swr_1.default)(strategyId ? `/strategies/${strategyId}` : null, fetcher, {
+        refreshInterval,
+        revalidateOnFocus: true,
+        dedupingInterval: 5000,
+        errorRetryCount: 3,
+    });
+}

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

@@ -0,0 +1,16 @@
+import type { UserRank, NextLevelRequirement, TerritoryHoldings, MiningWeight } from '../lib/types/api';
+interface UseUserRankReturn {
+    rank: UserRank | null;
+    currentLevel: number | null;
+    nextRank: UserRank | null;
+    nextLevel: number | null;
+    progressPercent: number;
+    holdings: TerritoryHoldings;
+    nextLevelRequirement: NextLevelRequirement | null;
+    miningWeight: MiningWeight | null;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function useUserRank(userId: string | undefined): UseUserRankReturn;
+export {};

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

@@ -0,0 +1,61 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserRank = useUserRank;
+const react_1 = require("react");
+const api_service_1 = require("../lib/api-service");
+const EMPTY_HOLDINGS = { station: 0, matrix: 0, sector: 0, system: 0 };
+function useUserRank(userId) {
+    const [rank, setRank] = (0, react_1.useState)(null);
+    const [progress, setProgress] = (0, react_1.useState)(null);
+    const [miningWeight, setMiningWeight] = (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 () => {
+        if (!userId) {
+            setLoading(false);
+            return;
+        }
+        try {
+            setLoading(true);
+            setError(null);
+            const [rankRes, progressRes, weightRes] = await Promise.all([
+                (0, api_service_1.getUserRank)(userId),
+                (0, api_service_1.getUserLevelProgress)(userId),
+                (0, api_service_1.getMiningWeight)(userId),
+            ]);
+            if (rankRes.success && rankRes.data) {
+                setRank(rankRes.data.rank);
+            }
+            if (progressRes.success && progressRes.data) {
+                setProgress(progressRes.data);
+            }
+            if (weightRes.success && weightRes.data) {
+                setMiningWeight(weightRes.data);
+            }
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            setError(message);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [userId]);
+    (0, react_1.useEffect)(() => {
+        refresh();
+    }, [refresh]);
+    return {
+        rank,
+        currentLevel: progress?.current_level ?? null,
+        nextRank: progress?.next_rank ?? null,
+        nextLevel: progress?.next_level ?? null,
+        progressPercent: progress?.progress_percent ?? 0,
+        holdings: progress?.holdings ?? EMPTY_HOLDINGS,
+        nextLevelRequirement: progress?.next_level_requirement ?? null,
+        miningWeight,
+        loading,
+        error,
+        refresh,
+    };
+}

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

@@ -0,0 +1,29 @@
+import { type MainstreamToken } from '../lib/config/mainstream-tokens';
+export interface TokenHolding {
+    token: MainstreamToken;
+    balance: number;
+    price: number;
+    usdValue: number;
+    wallet?: string;
+    walletShort?: string;
+    isPrimary?: boolean;
+}
+export interface WalletTokenData {
+    wallet_address: string;
+    is_primary: boolean;
+    holdings: TokenHolding[];
+    totalUsdValue: number;
+}
+export interface WalletTokenBalancesResult {
+    wallets: WalletTokenData[];
+    aggregated: TokenHolding[];
+    flat: TokenHolding[];
+    totalUsdValue: number;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function useWalletTokenBalances(walletInfos: {
+    wallet_address: string;
+    is_primary?: boolean;
+}[]): WalletTokenBalancesResult;