@microcosmmoney/portal-react 3.12.8 → 3.13.1

package/dist/main-portal/lib/ai-chat-config.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiChatContext = getAiChatContext;
+const ROUTE_RULES = [
+    {
+        prefix: '/developers/assistant',
+        ctx: {
+            roleKey: 'apex_advisor',
+            accentColor: '#22c55e',
+            questions: ['APEX 评审如何运作？', '项目评分标准是什么？', 'Forge 工程团如何构建？'],
+            placeholder: '描述你的项目想法，APEX 评审院帮你完善方案...',
+            label: 'APEX 顾问',
+        },
+    },
+    {
+        prefix: '/developers',
+        ctx: {
+            roleKey: 'dev_assistant',
+            accentColor: '#22c55e',
+            questions: ['如何接入 Open API？', 'OAuth 2.0 认证流程？', 'SDK 怎么安装？'],
+            placeholder: '询问开发相关问题...',
+            label: 'APEX 顾问',
+        },
+    },
+    {
+        prefix: '/docs',
+        ctx: {
+            roleKey: 'docs_helper',
+            accentColor: '#e2e8f0',
+            questions: ['技术文档入口？', 'API 参考在哪？', '快速上手指南？'],
+            placeholder: '询问文档相关问题...',
+            label: '文档助手',
+        },
+    },
+    {
+        prefix: '/blockchain',
+        ctx: {
+            roleKey: 'blockchain_expert',
+            accentColor: '#5EEAD4',
+            questions: ['链上数据如何查询？', '合约状态如何查看？', 'MCC 合约地址是什么？'],
+            placeholder: '询问区块链相关问题...',
+            label: '链上专家',
+        },
+    },
+    {
+        prefix: '/data',
+        ctx: {
+            roleKey: 'data_analyst',
+            accentColor: '#5EEAD4',
+            questions: ['持币人分布？', '挖矿趋势如何？', '流动性深度？'],
+            placeholder: '询问数据分析相关问题...',
+            label: '数据分析',
+        },
+    },
+    {
+        prefix: '/resources/mining',
+        ctx: {
+            roleKey: 'mining_advisor',
+            accentColor: '#f59e0b',
+            questions: ['挖矿价格如何计算？', '伴生矿是什么？', '减半机制是什么？'],
+            placeholder: '询问挖矿相关问题...',
+            label: '挖矿顾问',
+        },
+    },
+    {
+        prefix: '/mine',
+        ctx: {
+            roleKey: 'mining_advisor',
+            accentColor: '#f59e0b',
+            questions: ['如何开始挖矿？', '支持哪些钱包？', '挖矿收益如何计算？'],
+            placeholder: '询问挖矿相关问题...',
+            label: '挖矿顾问',
+        },
+    },
+    {
+        prefix: '/resources',
+        ctx: {
+            roleKey: 'resource_guide',
+            accentColor: '#f59e0b',
+            questions: ['MCC 代币总量是多少？', '领地系统怎么运作？', '如何参与拍卖？'],
+            placeholder: '询问资源相关问题...',
+            label: '资源向导',
+        },
+    },
+    {
+        prefix: '/market',
+        ctx: {
+            roleKey: 'market_guide',
+            accentColor: '#FF6B00',
+            questions: ['MCC 当前价格？', '如何购买 MCC？', '流动性池状态？'],
+            placeholder: '询问市场相关问题...',
+            label: '市场向导',
+        },
+    },
+    {
+        prefix: '/community',
+        ctx: {
+            roleKey: 'community_guide',
+            accentColor: '#5EEAD4',
+            questions: ['如何加入社区？', '治理机制是什么？', '如何参与生态？'],
+            placeholder: '询问社区相关问题...',
+            label: '社区向导',
+        },
+    },
+    {
+        prefix: '/mainnet',
+        ctx: {
+            roleKey: 'mainnet_guide',
+            accentColor: '#22D3EE',
+            questions: ['合约部署状态？', '如何验证交易？', '主网地址在哪？'],
+            placeholder: '询问主网相关问题...',
+            label: '主网向导',
+        },
+    },
+    {
+        prefix: '/game',
+        ctx: {
+            roleKey: 'game_guide',
+            accentColor: '#a855f7',
+            questions: ['Crash 玩法规则？', 'HODL 对赌怎么玩？', '退场罚没如何分配？'],
+            placeholder: '询问游戏相关问题...',
+            label: '游戏向导',
+        },
+    },
+];
+const DEFAULT_CONTEXT = {
+    roleKey: 'home_guide',
+    accentColor: '#22c55e',
+    questions: ['Microcosm 是什么？', 'MCC 代币介绍', '如何加入生态？'],
+    placeholder: '有什么想了解的？',
+    label: 'AI 助手',
+};
+function stripLocalePrefix(pathname) {
+    return pathname.replace(/^\/[a-z]{2}(?:\/|$)/, '/') || '/';
+}
+function getAiChatContext(pathname) {
+    const cleanPath = stripLocalePrefix(pathname);
+    for (const rule of ROUTE_RULES) {
+        if (cleanPath.startsWith(rule.prefix)) {
+            return rule.ctx;
+        }
+    }
+    return DEFAULT_CONTEXT;
+}

package/dist/main-portal/lib/api/blockchain.d.ts

@@ -0,0 +1,178 @@
+export interface TokenBalance {
+    symbol: string;
+    mint: string;
+    balance: number;
+    raw_balance: number;
+    decimals: number;
+    usd_value: number;
+}
+export interface WalletBalance {
+    wallet: string;
+    sol: TokenBalance;
+    tokens: TokenBalance[];
+    total_usd_value: number;
+    cached_at: string;
+    from_cache: boolean;
+}
+export interface PoolStatus {
+    pool_address: string;
+    usdc_vault: string;
+    usdc_balance: number;
+    usdt_vault: string;
+    usdt_balance: number;
+    total_mcc_bought: number;
+    total_market_made: number;
+    status: 'active' | 'empty' | 'paused';
+    updated_at: string;
+}
+export declare function getMccPrice(): Promise<number | null>;
+export declare function getWalletBalance(walletAddress: string, forceRefresh?: boolean): Promise<WalletBalance | null>;
+export declare function getMCCBalance(walletAddress: string, forceRefresh?: boolean): Promise<TokenBalance | null>;
+export declare function refreshWalletBalance(walletAddress: string): Promise<WalletBalance | null>;
+export declare function invalidateWalletCache(walletAddress: string, txType?: string): Promise<boolean>;
+export declare function getPoolStatus(forceRefresh?: boolean): Promise<PoolStatus | null>;
+export declare function getTokenFromBalance(balance: WalletBalance | null, symbol: string): TokenBalance | null;
+export declare function formatTokenBalance(balance: number, decimals?: number): string;
+export interface McdAccountStatus {
+    uid: string;
+    has_account: boolean;
+    is_miner: boolean;
+    territory_id: string | null;
+    can_receive_mcd: boolean;
+}
+export interface McdAccountResult {
+    uid: string;
+    territory_id: string;
+    status: 'created' | 'exists';
+    tx_signature?: string;
+}
+export declare function getMcdAccountStatus(uid: string): Promise<McdAccountStatus | null>;
+export declare function ensureUserMcdAccount(uid: string): Promise<McdAccountResult>;
+export declare function batchGetMcdAccountStatus(uids: string[]): Promise<Record<string, McdAccountStatus>>;
+export interface ZombieAccount {
+    uid: string;
+    email: string;
+    display_name: string | null;
+    wallet_address: string | null;
+    mcd_balance: number;
+    inactive_days: number;
+    last_login_at: string | null;
+    account_created_at: string | null;
+}
+export interface ZombieAccountsResult {
+    accounts: ZombieAccount[];
+    total: number;
+    summary: {
+        total_zombie_accounts: number;
+        estimated_rent_recovery: number;
+        min_inactive_days: number;
+    };
+}
+export interface ClosureResult {
+    uid: string;
+    rent_recovered: number;
+    tx_signature: string | null;
+    closure_id: number;
+}
+export interface BatchClosureResult {
+    closed_count: number;
+    failed_count: number;
+    total_rent_recovered: number;
+    results: Array<{
+        uid: string;
+        success: boolean;
+        error?: string;
+        rent_recovered: number;
+    }>;
+}
+export interface RentStatistics {
+    summary: {
+        total_accounts: number;
+        zombie_accounts: number;
+        cumulative_closures: number;
+        cumulative_rent_recovered: number;
+    };
+    daily_stats: Array<{
+        date: string;
+        closed_count: number;
+        rent_recovered: number;
+    }>;
+}
+export interface ClosureHistory {
+    closures: Array<{
+        id: number;
+        uid: string;
+        user_mcd_pda: string;
+        rent_recovered: number;
+        tx_signature: string | null;
+        closed_by: string;
+        reason: string;
+        user_email: string | null;
+        last_active_at: string | null;
+        closed_at: string;
+    }>;
+    total: number;
+}
+export declare function getZombieAccounts(options?: {
+    limit?: number;
+    offset?: number;
+    min_inactive_days?: number;
+}): Promise<ZombieAccountsResult>;
+export declare function closeMcdAccount(uid: string, reason?: 'zombie' | 'user_request' | 'admin'): Promise<ClosureResult>;
+export declare function batchCloseMcdAccounts(uids: string[], reason?: 'zombie' | 'admin'): Promise<BatchClosureResult>;
+export declare function getRentStatistics(startDate?: string, endDate?: string): Promise<RentStatistics>;
+export declare function getClosureHistory(options?: {
+    limit?: number;
+    offset?: number;
+    reason?: string;
+}): Promise<ClosureHistory>;
+export interface SystemAddress {
+    id: number;
+    category: string;
+    subcategory?: string;
+    name: string;
+    address: string;
+    description?: string;
+    status: string;
+    address_type?: string;
+    parent_address?: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    archived_at?: string;
+    archived_reason?: string;
+}
+export interface SystemAddressStats {
+    total: number;
+    categories: number;
+    by_category: Record<string, number>;
+    by_status: Record<string, number>;
+}
+export declare function getSystemAddresses(options?: {
+    category?: string;
+    status?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    addresses: SystemAddress[];
+    total: number;
+}>;
+export declare function getSystemAddressStats(): Promise<SystemAddressStats>;
+export declare function updateSystemAddress(id: number, data: {
+    description?: string;
+    status?: string;
+    archived_reason?: string;
+}): Promise<{
+    success: boolean;
+    id?: number;
+    name?: string;
+    status?: string;
+    error?: string;
+}>;
+export declare function seedSystemAddresses(): Promise<{
+    success: boolean;
+    inserted: number;
+    updated: number;
+    total: number;
+}>;

package/dist/main-portal/lib/api/blockchain.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMccPrice = getMccPrice;
+exports.getWalletBalance = getWalletBalance;
+exports.getMCCBalance = getMCCBalance;
+exports.refreshWalletBalance = refreshWalletBalance;
+exports.invalidateWalletCache = invalidateWalletCache;
+exports.getPoolStatus = getPoolStatus;
+exports.getTokenFromBalance = getTokenFromBalance;
+exports.formatTokenBalance = formatTokenBalance;
+exports.getMcdAccountStatus = getMcdAccountStatus;
+exports.ensureUserMcdAccount = ensureUserMcdAccount;
+exports.batchGetMcdAccountStatus = batchGetMcdAccountStatus;
+exports.getZombieAccounts = getZombieAccounts;
+exports.closeMcdAccount = closeMcdAccount;
+exports.batchCloseMcdAccounts = batchCloseMcdAccounts;
+exports.getRentStatistics = getRentStatistics;
+exports.getClosureHistory = getClosureHistory;
+exports.getSystemAddresses = getSystemAddresses;
+exports.getSystemAddressStats = getSystemAddressStats;
+exports.updateSystemAddress = updateSystemAddress;
+exports.seedSystemAddresses = seedSystemAddresses;
+// AI-generated · AI-managed · AI-maintained
+const core_1 = require("./core");
+async function getMccPrice() {
+    try {
+        const response = await fetch('/api/blockchain-service/mining/ratio');
+        const data = await response.json();
+        if (data.success && data.data?.usdc_per_mcc) {
+            return data.data.usdc_per_mcc;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getWalletBalance(walletAddress, forceRefresh = false) {
+    try {
+        const queryParams = forceRefresh ? '?force=true' : '';
+        const response = await (0, core_1.fetchApi)(`/blockchain/balance/wallet/${walletAddress}${queryParams}`, { method: 'GET' }, true);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取钱包余额失败:', error);
+        return null;
+    }
+}
+async function getMCCBalance(walletAddress, forceRefresh = false) {
+    try {
+        const queryParams = forceRefresh ? '?force=true' : '';
+        const response = await (0, core_1.fetchApi)(`/blockchain/balance/wallet/${walletAddress}/mcc${queryParams}`, { method: 'GET' }, true);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取 MCC 余额失败:', error);
+        return null;
+    }
+}
+async function refreshWalletBalance(walletAddress) {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/balance/wallet/${walletAddress}/refresh`, { method: 'POST' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('[Blockchain API] 刷新钱包余额失败:', error);
+        return null;
+    }
+}
+async function invalidateWalletCache(walletAddress, txType) {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/balance/invalidate/${walletAddress}`, {
+            method: 'POST',
+            body: JSON.stringify({ tx_type: txType })
+        });
+        return response.success === true;
+    }
+    catch (error) {
+        console.error('[Blockchain API] 失效缓存失败:', error);
+        return false;
+    }
+}
+async function getPoolStatus(forceRefresh = false) {
+    try {
+        const queryParams = forceRefresh ? '?force=true' : '';
+        const response = await (0, core_1.fetchApi)(`/blockchain/balance/pool/reincarnation${queryParams}`, { method: 'GET' }, true);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取轮回池状态失败:', error);
+        return null;
+    }
+}
+function getTokenFromBalance(balance, symbol) {
+    if (!balance)
+        return null;
+    if (symbol.toUpperCase() === 'SOL') {
+        return balance.sol;
+    }
+    return balance.tokens.find(t => t.symbol.toUpperCase() === symbol.toUpperCase()) || null;
+}
+function formatTokenBalance(balance, decimals = 2) {
+    return balance.toLocaleString('en-US', {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+    });
+}
+async function getMcdAccountStatus(uid) {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/mcd/admin/account-status/${uid}`, { method: 'GET' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取 MCD 账户状态失败:', error);
+        throw error;
+    }
+}
+async function ensureUserMcdAccount(uid) {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/mcd/admin/account/ensure/${uid}`, { method: 'POST' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || '创建 MCD 账户失败');
+    }
+    catch (error) {
+        console.error('[Blockchain API] 创建 MCD 账户失败:', error);
+        throw error;
+    }
+}
+async function batchGetMcdAccountStatus(uids) {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/mcd/admin/batch-status`, {
+            method: 'POST',
+            body: JSON.stringify({ uids })
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {};
+    }
+    catch (error) {
+        console.error('[Blockchain API] 批量获取 MCD 账户状态失败:', error);
+        return {};
+    }
+}
+async function getZombieAccounts(options = {}) {
+    const { limit = 50, offset = 0, min_inactive_days = 180 } = options;
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/mcd/admin/zombie-accounts?limit=${limit}&offset=${offset}&inactive_days=${min_inactive_days}`, { method: 'GET' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || '获取僵尸账户失败');
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取僵尸账户失败:', error);
+        throw error;
+    }
+}
+async function closeMcdAccount(uid, reason = 'zombie') {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/mcd/admin/close-account/${uid}`, {
+            method: 'POST',
+            body: JSON.stringify({ reason })
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || '关闭账户失败');
+    }
+    catch (error) {
+        console.error('[Blockchain API] 关闭 MCD 账户失败:', error);
+        throw error;
+    }
+}
+async function batchCloseMcdAccounts(uids, reason = 'zombie') {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/mcd/admin/batch-close-accounts`, {
+            method: 'POST',
+            body: JSON.stringify({ uids, reason })
+        });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || '批量关闭账户失败');
+    }
+    catch (error) {
+        console.error('[Blockchain API] 批量关闭 MCD 账户失败:', error);
+        throw error;
+    }
+}
+async function getRentStatistics(startDate, endDate) {
+    try {
+        const params = new URLSearchParams();
+        if (startDate)
+            params.append('start_date', startDate);
+        if (endDate)
+            params.append('end_date', endDate);
+        const url = `/blockchain/mcd/admin/rent-statistics${params.toString() ? `?${params.toString()}` : ''}`;
+        const response = await (0, core_1.fetchApi)(url, { method: 'GET' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || '获取租金统计失败');
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取租金统计失败:', error);
+        throw error;
+    }
+}
+async function getClosureHistory(options = {}) {
+    const { limit = 50, offset = 0, reason } = options;
+    try {
+        let url = `/blockchain/mcd/admin/closure-history?limit=${limit}&offset=${offset}`;
+        if (reason)
+            url += `&reason=${reason}`;
+        const response = await (0, core_1.fetchApi)(url, { method: 'GET' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || '获取关闭历史失败');
+    }
+    catch (error) {
+        console.error('[Blockchain API] 获取关闭历史失败:', error);
+        throw error;
+    }
+}
+async function getSystemAddresses(options = {}) {
+    const { category, status, search, limit = 200, offset = 0 } = options;
+    try {
+        const params = new URLSearchParams();
+        params.set('limit', String(limit));
+        params.set('offset', String(offset));
+        if (category)
+            params.set('category', category);
+        if (status)
+            params.set('status', status);
+        if (search)
+            params.set('search', search);
+        const response = await (0, core_1.fetchApi)(`/blockchain/system-addresses/admin/list?${params.toString()}`, { method: 'GET' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || 'Failed to load system addresses');
+    }
+    catch (error) {
+        console.error('[Blockchain API] getSystemAddresses failed:', error);
+        throw error;
+    }
+}
+async function getSystemAddressStats() {
+    try {
+        const response = await (0, core_1.fetchApi)('/blockchain/system-addresses/admin/stats', { method: 'GET' });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        throw new Error(response.error || 'Failed to load stats');
+    }
+    catch (error) {
+        console.error('[Blockchain API] getSystemAddressStats failed:', error);
+        throw error;
+    }
+}
+async function updateSystemAddress(id, data) {
+    try {
+        const response = await (0, core_1.fetchApi)(`/blockchain/system-addresses/admin/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(data)
+        });
+        return response;
+    }
+    catch (error) {
+        console.error('[Blockchain API] updateSystemAddress failed:', error);
+        throw error;
+    }
+}
+async function seedSystemAddresses() {
+    try {
+        const response = await (0, core_1.fetchApi)('/blockchain/system-addresses/admin/seed', { method: 'POST' });
+        return response;
+    }
+    catch (error) {
+        console.error('[Blockchain API] seedSystemAddresses failed:', error);
+        throw error;
+    }
+}

package/dist/main-portal/lib/api/core.d.ts

@@ -0,0 +1,3 @@
+import { getCurrentUserToken } from '../auth-service';
+export declare const fetchApi: (endpoint: string, options?: RequestInit, isPublic?: boolean) => Promise<any>;
+export { getCurrentUserToken };

package/dist/main-portal/lib/api/core.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentUserToken = exports.fetchApi = void 0;
+// AI-generated · AI-managed · AI-maintained
+const auth_service_1 = require("../auth-service");
+Object.defineProperty(exports, "getCurrentUserToken", { enumerable: true, get: function () { return auth_service_1.getCurrentUserToken; } });
+const BASE_URL = '/api';
+const fetchApi = async (endpoint, options = {}, isPublic = false) => {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (options.headers) {
+        const originalHeaders = options.headers;
+        Object.assign(headers, originalHeaders);
+    }
+    if (!isPublic) {
+        const authToken = await (0, auth_service_1.getCurrentUserToken)();
+        if (!authToken) {
+            throw new Error('用户未登录，无法发起请求。');
+        }
+        headers['Authorization'] = `Bearer ${authToken}`;
+    }
+    const config = {
+        ...options,
+        headers
+    };
+    const response = await fetch(`${BASE_URL}${endpoint}`, config);
+    const safeJson = async (res) => {
+        const contentType = res.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            return res.json();
+        }
+        const text = await res.text();
+        return { error: text || `服务器返回了非 JSON 错误 (状态: ${res.status})` };
+    };
+    if (!response.ok) {
+        // 401/403: 认证失效，强制登出（不再继续处理业务错误）
+        if (response.status === 401 || response.status === 403) {
+            (0, auth_service_1.handleAuthFailure)(response.status);
+            throw new Error('认证已失效，正在跳转登录页...');
+        }
+        const errorData = await safeJson(response);
+        throw new Error(errorData.error || `服务器返回了一个错误 (状态: ${response.status})`);
+    }
+    return safeJson(response);
+};
+exports.fetchApi = fetchApi;

package/dist/main-portal/lib/api/index.d.ts

@@ -0,0 +1,9 @@
+export { fetchApi, getCurrentUserToken } from './core';
+export declare const apiService: {
+    get: (endpoint: string) => Promise<any>;
+    post: (endpoint: string, data?: unknown) => Promise<any>;
+    put: (endpoint: string, data?: unknown) => Promise<any>;
+    delete: (endpoint: string) => Promise<any>;
+};
+export * from './services';
+export { getMCCBalance as getOnchainMCCBalance, getPoolStatus, type PoolStatus, } from './blockchain';