@microcosmmoney/portal-react 3.12.8 → 3.13.0

package/dist/main-portal/lib/exchanges/hooks/useUserExchanges.js

@@ -0,0 +1,51 @@
+"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.useUserExchanges = useUserExchanges;
+const swr_1 = __importDefault(require("swr"));
+const core_1 = require("../../api/core");
+function transformResponse(response) {
+    if (!response.success || !response.data?.exchanges) {
+        return [];
+    }
+    const boundExchanges = [];
+    for (const [exchangeId, exchangeData] of Object.entries(response.data.exchanges)) {
+        const hasActiveAccount = Object.values(exchangeData.accounts || {}).some(account => account.status === 'active');
+        if (hasActiveAccount) {
+            boundExchanges.push(exchangeId.toLowerCase());
+        }
+    }
+    return boundExchanges;
+}
+function useUserExchanges() {
+    const { data, error, isLoading, mutate } = (0, swr_1.default)('/account/exchanges', async (url) => {
+        const response = await (0, core_1.fetchApi)(url);
+        return transformResponse(response);
+    }, {
+        revalidateOnFocus: false,
+        revalidateOnReconnect: false,
+        dedupingInterval: 60000,
+    });
+    const isExchangeBound = (exchangeId) => {
+        if (!data)
+            return false;
+        return data.includes(exchangeId.toLowerCase());
+    };
+    const isSelectedExchangeAvailable = (selectedExchange) => {
+        if (selectedExchange === 'all')
+            return true;
+        return isExchangeBound(selectedExchange);
+    };
+    return {
+        boundExchanges: data || [],
+        isExchangeBound,
+        isSelectedExchangeAvailable,
+        isLoading,
+        error,
+        refresh: mutate,
+    };
+}

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

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './config';
+export * from './utils';
+export * from './hooks';

package/dist/main-portal/lib/exchanges/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// AI-generated · AI-managed · AI-maintained
+__exportStar(require("./types"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./hooks"), exports);

package/dist/main-portal/lib/exchanges/types.d.ts

@@ -0,0 +1,102 @@
+export interface AccountBalance {
+    asset: string;
+    balance: number;
+    availableBalance: number;
+    unrealizedProfit: number;
+}
+export interface Position {
+    symbol: string;
+    side: "LONG" | "SHORT";
+    amount: number;
+    entryPrice: number;
+    markPrice: number;
+    liquidationPrice: number;
+    unrealizedProfit: number;
+    leverage: number;
+}
+export interface OpenOrder {
+    orderId: string;
+    symbol: string;
+    side: string;
+    type: string;
+    price: number;
+    quantity: number;
+    filled: number;
+    status: string;
+    time: string;
+    clientOrderId?: string;
+}
+export interface Trade {
+    id: string;
+    orderId: string;
+    symbol: string;
+    side: string;
+    price: number;
+    quantity: number;
+    realizedPnl: number;
+    commission: number;
+    time: number;
+    isMaker: boolean;
+}
+export interface GroupedPosition {
+    symbol: string;
+    longPosition?: Position;
+    shortPosition?: Position;
+    totalUnrealizedProfit: number;
+    orders: OpenOrder[];
+}
+export interface GroupedOrders {
+    symbol: string;
+    orders: OpenOrder[];
+    totalQuantity: number;
+}
+export interface GroupedTrades {
+    symbol: string;
+    trades: Trade[];
+    totalRealizedPnl: number;
+    totalVolume: number;
+}
+export interface CleanupProgress {
+    status: string;
+    phase: string;
+    total_operations: number;
+    completed_operations: number;
+    current_operation: string;
+    result?: {
+        LONG?: {
+            tp_merged: number;
+            open_deleted: number;
+        };
+        SHORT?: {
+            tp_merged: number;
+            open_deleted: number;
+        };
+    };
+    error?: string;
+}
+export interface CleanupPreview {
+    LONG?: {
+        tp_orders?: {
+            before: number;
+            after: number;
+            merge_count: number;
+        };
+        open_orders?: {
+            before: number;
+            after: number;
+            delete_count: number;
+        };
+    };
+    SHORT?: {
+        tp_orders?: {
+            before: number;
+            after: number;
+            merge_count: number;
+        };
+        open_orders?: {
+            before: number;
+            after: number;
+            delete_count: number;
+        };
+    };
+}

package/dist/main-portal/lib/exchanges/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/main-portal/lib/exchanges/utils.d.ts

@@ -0,0 +1 @@
+export declare function formatNumber(value: number, decimals?: number): string;

package/dist/main-portal/lib/exchanges/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNumber = formatNumber;
+// AI-generated · AI-managed · AI-maintained
+function formatNumber(value, decimals = 2) {
+    return value.toLocaleString('en-US', {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+    });
+}

package/dist/main-portal/lib/gcp-secrets.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read secrets from GCP Secret Manager via REST API (Workload Identity).
+ * Zero external dependencies — uses native fetch + GKE metadata API.
+ * Falls back to process.env for local development.
+ */
+export declare function getSecret(secretId: string, envFallback?: string): Promise<string>;
+export declare function getGeminiApiKey(): Promise<string>;

package/dist/main-portal/lib/gcp-secrets.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Read secrets from GCP Secret Manager via REST API (Workload Identity).
+ * Zero external dependencies — uses native fetch + GKE metadata API.
+ * Falls back to process.env for local development.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSecret = getSecret;
+exports.getGeminiApiKey = getGeminiApiKey;
+const GCP_PROJECT = process.env.GCP_PROJECT_ID || 'double-helix-9f030';
+const cache = {};
+async function getSecret(secretId, envFallback) {
+    if (cache[secretId])
+        return cache[secretId];
+    try {
+        // Get access token from GKE metadata server (Workload Identity)
+        const tokenRes = await fetch('http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token', { headers: { 'Metadata-Flavor': 'Google' } });
+        if (!tokenRes.ok)
+            throw new Error(`Metadata token: ${tokenRes.status}`);
+        const { access_token } = await tokenRes.json();
+        // Fetch secret from Secret Manager REST API
+        const secretRes = await fetch(`https://secretmanager.googleapis.com/v1/projects/${GCP_PROJECT}/secrets/${secretId}/versions/latest:access`, { headers: { Authorization: `Bearer ${access_token}` } });
+        if (!secretRes.ok)
+            throw new Error(`Secret Manager: ${secretRes.status}`);
+        const data = await secretRes.json();
+        const value = Buffer.from(data.payload.data, 'base64').toString('utf-8').trim();
+        cache[secretId] = value;
+        console.log(`[gcp-secrets] Loaded '${secretId}' from Secret Manager`);
+        return value;
+    }
+    catch (e) {
+        console.warn(`[gcp-secrets] Fallback to env for '${secretId}':`, e instanceof Error ? e.message : e);
+    }
+    const value = envFallback ?? '';
+    cache[secretId] = value;
+    return value;
+}
+/** Pre-cached Gemini API key. Call initSecrets() at startup or use getGeminiApiKey(). */
+let _geminiKey = null;
+async function getGeminiApiKey() {
+    if (_geminiKey !== null)
+        return _geminiKey;
+    _geminiKey = await getSecret('gemini-api-key', process.env.GEMINI_API_KEY || '');
+    return _geminiKey;
+}

package/dist/main-portal/lib/mockWallet.d.ts

@@ -0,0 +1,130 @@
+interface Transaction {
+    type: string;
+    amount: number;
+    txHash: string;
+    timestamp: string;
+    balanceBefore?: number;
+    balanceAfter?: number;
+    to?: string;
+    from?: string;
+}
+interface TransferResult {
+    success: boolean;
+    txHash: string;
+    amount: number;
+    to?: string;
+    from?: string;
+    balanceBefore: number;
+    balanceAfter: number;
+    transaction: Transaction;
+}
+interface DepositResult {
+    success: boolean;
+    txHash: string;
+    amount: number;
+    balanceBefore: number;
+    balanceAfter: number;
+    transaction: Transaction;
+}
+interface WalletInfo {
+    userId: string;
+    balance: number;
+    transactionCount: number;
+    lastTransaction: Transaction | null;
+    isMock: boolean;
+}
+interface WalletExport {
+    userId: string;
+    balance: number;
+    transactions: Transaction[];
+    exportTime: string;
+}
+export declare function generateMockTxHash(): string;
+export declare class PersistentMockWallet {
+    private userId;
+    private defaultBalance;
+    private storageKey;
+    private transactionsKey;
+    private balance;
+    private transactions;
+    constructor(userId: string, defaultBalance?: number);
+    private loadBalance;
+    private saveBalance;
+    private loadTransactions;
+    private saveTransactions;
+    private addTransaction;
+    getBalance(): number;
+    deposit(amount: number): DepositResult;
+    transfer(amount: number, to?: string): TransferResult;
+    refund(amount: number, from?: string): TransferResult;
+    reset(amount?: number): {
+        success: boolean;
+        newBalance: number;
+    };
+    clear(): void;
+    getTransactions(limit?: number): Transaction[];
+    getInfo(): WalletInfo;
+    hasEnough(amount: number): boolean;
+    export(): WalletExport;
+    import(data: WalletExport): void;
+}
+export declare class MemoryMockWallet {
+    private balance;
+    private transactions;
+    constructor(initialBalance?: number);
+    getBalance(): number;
+    deposit(amount: number): {
+        newBalance: number;
+        type: string;
+        amount: number;
+        txHash: string;
+        timestamp: string;
+        balanceBefore?: number;
+        balanceAfter?: number;
+        to?: string;
+        from?: string;
+        success: boolean;
+    };
+    transfer(amount: number, to?: string): {
+        newBalance: number;
+        type: string;
+        amount: number;
+        txHash: string;
+        timestamp: string;
+        balanceBefore?: number;
+        balanceAfter?: number;
+        to?: string;
+        from?: string;
+        success: boolean;
+    };
+    refund(amount: number, from?: string): {
+        newBalance: number;
+        type: string;
+        amount: number;
+        txHash: string;
+        timestamp: string;
+        balanceBefore?: number;
+        balanceAfter?: number;
+        to?: string;
+        from?: string;
+        success: boolean;
+    };
+    getTransactions(limit?: number): Transaction[];
+    hasEnough(amount: number): boolean;
+}
+export declare function createTestAccounts(): {
+    admin: PersistentMockWallet;
+    rich: PersistentMockWallet;
+    normal1: PersistentMockWallet;
+    normal2: PersistentMockWallet;
+    poor: PersistentMockWallet;
+};
+export declare function formatMCC(amount: number): string;
+declare const _default: {
+    PersistentMockWallet: typeof PersistentMockWallet;
+    MemoryMockWallet: typeof MemoryMockWallet;
+    generateMockTxHash: typeof generateMockTxHash;
+    createTestAccounts: typeof createTestAccounts;
+    formatMCC: typeof formatMCC;
+};
+export default _default;

package/dist/main-portal/lib/mockWallet.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMockWallet = exports.PersistentMockWallet = void 0;
+exports.generateMockTxHash = generateMockTxHash;
+exports.createTestAccounts = createTestAccounts;
+exports.formatMCC = formatMCC;
+function generateMockTxHash() {
+    const chars = '0123456789abcdef';
+    let hash = '0x';
+    for (let i = 0; i < 64; i++) {
+        hash += chars[Math.floor(Math.random() * 16)];
+    }
+    return hash;
+}
+class PersistentMockWallet {
+    constructor(userId, defaultBalance = 100000) {
+        this.balance = 0;
+        this.transactions = [];
+        if (!userId) {
+            throw new Error('userId is required');
+        }
+        this.userId = userId;
+        this.defaultBalance = defaultBalance;
+        this.storageKey = `mock_wallet_${userId}`;
+        this.transactionsKey = `mock_wallet_tx_${userId}`;
+        this.loadBalance();
+        this.loadTransactions();
+    }
+    loadBalance() {
+        if (typeof window === 'undefined') {
+            this.balance = this.defaultBalance;
+            return;
+        }
+        const saved = localStorage.getItem(this.storageKey);
+        this.balance = saved ? parseFloat(saved) : this.defaultBalance;
+    }
+    saveBalance() {
+        if (typeof window === 'undefined')
+            return;
+        localStorage.setItem(this.storageKey, this.balance.toString());
+    }
+    loadTransactions() {
+        if (typeof window === 'undefined') {
+            this.transactions = [];
+            return;
+        }
+        const saved = localStorage.getItem(this.transactionsKey);
+        this.transactions = saved ? JSON.parse(saved) : [];
+    }
+    saveTransactions() {
+        if (typeof window === 'undefined')
+            return;
+        localStorage.setItem(this.transactionsKey, JSON.stringify(this.transactions));
+    }
+    addTransaction(type, amount, txHash, details = {}) {
+        const transaction = {
+            type,
+            amount,
+            txHash,
+            timestamp: new Date().toISOString(),
+            balanceBefore: this.balance,
+            balanceAfter: this.balance,
+            ...details
+        };
+        this.transactions.unshift(transaction);
+        if (this.transactions.length > 100) {
+            this.transactions = this.transactions.slice(0, 100);
+        }
+        this.saveTransactions();
+        return transaction;
+    }
+    getBalance() {
+        return this.balance;
+    }
+    deposit(amount) {
+        if (amount <= 0) {
+            throw new Error('充值金额必须大于0');
+        }
+        const txHash = generateMockTxHash();
+        const balanceBefore = this.balance;
+        this.balance += amount;
+        this.saveBalance();
+        const transaction = this.addTransaction('deposit', amount, txHash, {
+            balanceBefore,
+            balanceAfter: this.balance
+        });
+        console.log(`✅ 模拟充值成功: ${amount} MCC`);
+        console.log(`Transaction Hash: ${txHash}`);
+        console.log(`新余额: ${this.balance} MCC`);
+        return {
+            success: true,
+            txHash,
+            amount,
+            balanceBefore,
+            balanceAfter: this.balance,
+            transaction
+        };
+    }
+    transfer(amount, to = 'contract') {
+        if (amount <= 0) {
+            throw new Error('转账金额必须大于0');
+        }
+        if (this.balance < amount) {
+            throw new Error(`余额不足! 当前余额: ${this.balance} MCC, 需要: ${amount} MCC`);
+        }
+        const txHash = generateMockTxHash();
+        const balanceBefore = this.balance;
+        this.balance -= amount;
+        this.saveBalance();
+        const transaction = this.addTransaction('transfer', amount, txHash, {
+            balanceBefore,
+            balanceAfter: this.balance,
+            to
+        });
+        console.log(`✅ 模拟转账成功: ${amount} MCC → ${to}`);
+        console.log(`Transaction Hash: ${txHash}`);
+        console.log(`剩余余额: ${this.balance} MCC`);
+        return {
+            success: true,
+            txHash,
+            amount,
+            to,
+            balanceBefore,
+            balanceAfter: this.balance,
+            transaction
+        };
+    }
+    refund(amount, from = 'contract') {
+        if (amount <= 0) {
+            throw new Error('退款金额必须大于0');
+        }
+        const txHash = generateMockTxHash();
+        const balanceBefore = this.balance;
+        this.balance += amount;
+        this.saveBalance();
+        const transaction = this.addTransaction('refund', amount, txHash, {
+            balanceBefore,
+            balanceAfter: this.balance,
+            from
+        });
+        console.log(`✅ 模拟退款成功: ${amount} MCC ← ${from}`);
+        console.log(`Transaction Hash: ${txHash}`);
+        console.log(`新余额: ${this.balance} MCC`);
+        return {
+            success: true,
+            txHash,
+            amount,
+            from,
+            balanceBefore,
+            balanceAfter: this.balance,
+            transaction
+        };
+    }
+    reset(amount = 100000) {
+        this.balance = amount;
+        this.saveBalance();
+        console.log(`🔄 余额已重置为: ${amount} MCC`);
+        return {
+            success: true,
+            newBalance: this.balance
+        };
+    }
+    clear() {
+        if (typeof window === 'undefined')
+            return;
+        localStorage.removeItem(this.storageKey);
+        localStorage.removeItem(this.transactionsKey);
+        this.balance = this.defaultBalance;
+        this.transactions = [];
+        console.log('🗑️  钱包数据已清除');
+    }
+    getTransactions(limit = 10) {
+        return this.transactions.slice(0, limit);
+    }
+    getInfo() {
+        return {
+            userId: this.userId,
+            balance: this.balance,
+            transactionCount: this.transactions.length,
+            lastTransaction: this.transactions[0] || null,
+            isMock: true
+        };
+    }
+    hasEnough(amount) {
+        return this.balance >= amount;
+    }
+    export() {
+        return {
+            userId: this.userId,
+            balance: this.balance,
+            transactions: this.transactions,
+            exportTime: new Date().toISOString()
+        };
+    }
+    import(data) {
+        if (data.userId !== this.userId) {
+            throw new Error('用户ID不匹配');
+        }
+        this.balance = data.balance;
+        this.transactions = data.transactions || [];
+        this.saveBalance();
+        this.saveTransactions();
+        console.log('✅ 钱包数据导入成功');
+    }
+}
+exports.PersistentMockWallet = PersistentMockWallet;
+class MemoryMockWallet {
+    constructor(initialBalance = 100000) {
+        this.balance = initialBalance;
+        this.transactions = [];
+    }
+    getBalance() {
+        return this.balance;
+    }
+    deposit(amount) {
+        if (amount <= 0)
+            throw new Error('充值金额必须大于0');
+        this.balance += amount;
+        const tx = {
+            type: 'deposit',
+            amount,
+            txHash: generateMockTxHash(),
+            timestamp: new Date().toISOString()
+        };
+        this.transactions.push(tx);
+        return { success: true, ...tx, newBalance: this.balance };
+    }
+    transfer(amount, to = 'contract') {
+        if (amount <= 0)
+            throw new Error('转账金额必须大于0');
+        if (this.balance < amount)
+            throw new Error('余额不足');
+        this.balance -= amount;
+        const tx = {
+            type: 'transfer',
+            amount,
+            to,
+            txHash: generateMockTxHash(),
+            timestamp: new Date().toISOString()
+        };
+        this.transactions.push(tx);
+        return { success: true, ...tx, newBalance: this.balance };
+    }
+    refund(amount, from = 'contract') {
+        if (amount <= 0)
+            throw new Error('退款金额必须大于0');
+        this.balance += amount;
+        const tx = {
+            type: 'refund',
+            amount,
+            from,
+            txHash: generateMockTxHash(),
+            timestamp: new Date().toISOString()
+        };
+        this.transactions.push(tx);
+        return { success: true, ...tx, newBalance: this.balance };
+    }
+    getTransactions(limit = 10) {
+        return this.transactions.slice(-limit).reverse();
+    }
+    hasEnough(amount) {
+        return this.balance >= amount;
+    }
+}
+exports.MemoryMockWallet = MemoryMockWallet;
+function createTestAccounts() {
+    return {
+        admin: new PersistentMockWallet('admin_test_001', Infinity),
+        rich: new PersistentMockWallet('user_rich_001', 500000),
+        normal1: new PersistentMockWallet('user_normal_001', 50000),
+        normal2: new PersistentMockWallet('user_normal_002', 50000),
+        poor: new PersistentMockWallet('user_poor_001', 5000)
+    };
+}
+function formatMCC(amount) {
+    return `${amount.toLocaleString()} MCC`;
+}
+exports.default = {
+    PersistentMockWallet,
+    MemoryMockWallet,
+    generateMockTxHash,
+    createTestAccounts,
+    formatMCC
+};

package/dist/main-portal/lib/oauth-config.d.ts

@@ -0,0 +1,12 @@
+export declare const OAUTH_CONFIG: {
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    firebaseTokenEndpoint: string;
+    clientId: string;
+    redirectUri: string;
+    scopes: string[];
+};
+export declare function generateState(): string;
+export declare function saveState(state: string): void;
+export declare function verifyState(state: string): boolean;
+export declare function buildAuthorizationUrl(): string;