@microcosmmoney/portal-react 3.12.8 → 3.13.0

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/dexscreener.d.ts

@@ -0,0 +1,126 @@
+export interface HourlyVolume {
+    hour: string;
+    buyVolume: number;
+    sellVolume: number;
+    totalVolume: number;
+    tradeCount: number;
+}
+export interface HeatmapCell {
+    dow: number;
+    hour: number;
+    volume: number;
+    tradeCount: number;
+}
+export interface MCCMarketData {
+    price: number;
+    priceChange: {
+        h1: number;
+        h24: number;
+    };
+    volume: {
+        h1: number;
+        h24: number;
+    };
+    txns: {
+        h1: {
+            buys: number;
+            sells: number;
+        };
+        h24: {
+            buys: number;
+            sells: number;
+        };
+    };
+    liquidityUsd: number;
+    fdvUsd: number;
+    marketCapUsd: number;
+    dailyStats: {
+        tradeCount: number;
+        miningCount: number;
+        marketMakingCount: number;
+        buyVolume: number;
+        sellVolume: number;
+    };
+    hourlyVolumes: HourlyVolume[];
+    weeklyHeatmap: HeatmapCell[];
+    updatedAt: string;
+}
+export declare function fetchMCCMarketData(): Promise<MCCMarketData | null>;
+export interface CustodyVaultInfo {
+    index: number;
+    vaultPda: string;
+    gasPayer: string;
+    usdcBalance: number;
+    mccBalance: number;
+    gasPayerSol: number;
+    gasConsumed: number;
+    txCount24h: number;
+    status: "active" | "idle";
+}
+export interface CustodyVaultSummary {
+    totalUsdc: number;
+    totalMcc: number;
+    totalGasConsumed: number;
+    totalTx24h: number;
+    totalTrades24h: number;
+    activeVaults: number;
+    avgGasPerTx: number;
+    totalProfit: number;
+}
+export interface CustodyAgentRoles {
+    minerActive: boolean;
+    traderActive: boolean;
+}
+export interface EcosystemMining {
+    total_usd: number;
+    total_mcc: number;
+    total_count: number;
+}
+export interface EcosystemBuyback {
+    total_usd: number;
+    total_mcc: number;
+    total_count: number;
+    pool_usd_balance: number;
+}
+export interface EcosystemLp {
+    mcc_allocated: number;
+    usdc_balance: number;
+}
+export interface EcosystemEpoch {
+    current_epoch: number;
+    epoch_minted: number;
+    epoch_yield: number;
+    mining_vault_mcc: number;
+}
+export interface CustodyVaultData {
+    vaults: CustodyVaultInfo[];
+    summary: CustodyVaultSummary;
+    agentRoles: CustodyAgentRoles;
+    mining: EcosystemMining;
+    buyback: EcosystemBuyback;
+    lp: EcosystemLp;
+    epoch: EcosystemEpoch;
+    updatedAt: string;
+}
+export declare function fetchCustodyVaultData(): Promise<CustodyVaultData | null>;
+export declare const SOLSCAN_LINKS: {
+    mccToken: string;
+    mcdToken: string;
+    miningVault: string;
+    buybackVault: string;
+    teamVault: string;
+    poolPda: string;
+    cpmmPool: string;
+    custodyProgram: string;
+    programId: string;
+    transaction: (sig: string) => string;
+    account: (address: string) => string;
+};
+/** Official Market Making Custody Vault PDAs (#0-#9) */
+export declare const CUSTODY_VAULT_ADDRESSES: readonly ["8GgSjyrnXfxzF9A2ptTVbwr5x7HbApBZAiNfLtasZymG", "GPGfHSzEMQG1w5fCGXoM4Qyq4AJKe2jEoE5Bp7FTEvvv", "Ay6nzAC1iNqNtBDqkWvjfkZRVJaw61v4tkNKs1h5QEsx", "8H4N2rT9JT3xxxVqFRiSECHY9dcbU51KjxsEfsBJSr5N", "8TzH83qkXUn2uifjVSFsfaBzpKvpf2h1FnKkP6gx33xo", "AkCWQ1Cgef3kD33YZN6RcbNdcG2uzGPqTm298DsRpEBh", "2ts8u1L21vZsJRHmB9SvGYw715bRp9wfM9gj9P8VZhah", "FtuVwEijmLiKLFriSQaQ5mQVexHpDEjGYojiCaXzNhrp", "HJiPgHoWrjmV8cguayJu6ggaBa2Kue5cbcdnt3T3eKbe", "2H1uXk3wwrhkxssKj5dKSK8cUVq5BxeLAvgfF2CweVoc"];
+export declare const RAYDIUM_POOL_URL = "https://raydium.io/swap/?inputMint=MCCn6eqiTGzaiPKECg3viPmkdkS9YmkguqKvRcTxCsb&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export declare const JUPITER_TRADE_URL = "https://jup.ag/tokens/MCCn6eqiTGzaiPKECg3viPmkdkS9YmkguqKvRcTxCsb";
+export declare const BIRDEYE_TOKEN_URL = "https://birdeye.so/token/MCCn6eqiTGzaiPKECg3viPmkdkS9YmkguqKvRcTxCsb?chain=solana";
+export declare const GMGN_TOKEN_URL = "https://gmgn.ai/sol/token/MCCn6eqiTGzaiPKECg3viPmkdkS9YmkguqKvRcTxCsb";
+export declare const OKX_DEX_URL = "https://web3.okx.com/zh-hans/token/solana/MCCn6eqiTGzaiPKECg3viPmkdkS9YmkguqKvRcTxCsb";
+export declare const DEXSCREENER_URL = "https://dexscreener.com/solana/4AiaTd9bAWf3u8ScZWhXadJF1roc8bJKEKvaDudKacZd";