動平衡交易

// 動平衡交易所套利系統
interface ExchangeConfig {
  name: string;
  apiKey: string;
  apiSecret: string;
  baseUrl: string;
  tradingFee: number;
}

interface ArbitrageOpportunity {
  symbol: string;
  buyExchange: string;
  sellExchange: string;
  buyPrice: number;
  sellPrice: number;
  profitMargin: number;
  volume: number;
}

class ArbitrageEngine {
  private exchanges: Map<string, ExchangeConfig>;
  private minProfitMargin: number = 0.005; // 最小利潤率 0.5%
  private maxPositionSize: number = 10000; // 最大持倉金額
  
  constructor() {
    this.exchanges = new Map([
      ['binance', {
        name: 'Binance',
        apiKey: process.env.BINANCE_API_KEY,
        apiSecret: process.env.BINANCE_SECRET,
        baseUrl: 'https://api.binance.com',
        tradingFee: 0.001
      }],
      ['okx', {
        name: 'OKX',
        apiKey: process.env.OKX_API_KEY,
        apiSecret: process.env.OKX_SECRET,
        baseUrl: 'https://www.okx.com',
        tradingFee: 0.001
      }]
    ]);
  }

  // 監控價差機會
  async monitorArbitrageOpportunities(): Promise<ArbitrageOpportunity[]> {
    const symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT', 'ADA/USDT'];
    const opportunities: ArbitrageOpportunity[] = [];
    
    for (const symbol of symbols) {
      try {
        const prices = await this.fetchPricesFromAllExchanges(symbol);
        const opportunity = this.calculateArbitrage(symbol, prices);
        
        if (opportunity && opportunity.profitMargin > this.minProfitMargin) {
          opportunities.push(opportunity);
        }
      } catch (error) {
        console.error(`監控 ${symbol} 價差失敗:`, error);
      }
    }
    
    return opportunities.sort((a, b) => b.profitMargin - a.profitMargin);
  }

  // 執行套利交易
  async executeArbitrage(opportunity: ArbitrageOpportunity): Promise<boolean> {
    const { symbol, buyExchange, sellExchange, buyPrice, sellPrice, volume } = opportunity;
    
    try {
      // 風險檢查
      if (!await this.riskCheck(opportunity)) {
        console.log('風險檢查未通過,取消交易');
        return false;
      }
      
      // 計算交易數量
      const tradeAmount = Math.min(volume, this.maxPositionSize / buyPrice);
      
      // 同時執行買入和賣出訂單
      const [buyResult, sellResult] = await Promise.all([
        this.placeBuyOrder(buyExchange, symbol, buyPrice, tradeAmount),
        this.placeSellOrder(sellExchange, symbol, sellPrice, tradeAmount)
      ]);
      
      if (buyResult.success && sellResult.success) {
        await this.logArbitrageTransaction({
          symbol,
          buyExchange,
          sellExchange,
          buyPrice,
          sellPrice,
          amount: tradeAmount,
          profit: (sellPrice - buyPrice) * tradeAmount,
          timestamp: new Date()
        });
        
        console.log(`套利交易成功: ${symbol} 利潤 ${((sellPrice - buyPrice) * tradeAmount).toFixed(4)} USDT`);
        return true;
      }
      
      // 如果只有一邊成功,需要平倉處理
      await this.handlePartialFill(buyResult, sellResult, symbol, tradeAmount);
      return false;
      
    } catch (error) {
      console.error('執行套利交易失敗:', error);
      return false;
    }
  }

  // 風險控制檢查
  private async riskCheck(opportunity: ArbitrageOpportunity): Promise<boolean> {
    // 檢查賬戶餘額
    const balanceCheck = await this.checkAccountBalance(opportunity);
    if (!balanceCheck) return false;
    
    // 檢查市場流動性
    const liquidityCheck = await this.checkMarketLiquidity(opportunity);
    if (!liquidityCheck) return false;
    
    // 檢查價格波動
    const volatilityCheck = await this.checkPriceVolatility(opportunity.symbol);
    if (!volatilityCheck) return false;
    
    // 檢查交易所狀態
    const exchangeStatusCheck = await this.checkExchangeStatus([
      opportunity.buyExchange, 
      opportunity.sellExchange
    ]);
    
    return exchangeStatusCheck;
  }

  // 從所有交易所獲取價格
  private async fetchPricesFromAllExchanges(symbol: string): Promise<Map<string, number>> {
    const prices = new Map<string, number>();
    const promises = Array.from(this.exchanges.keys()).map(async (exchangeName) => {
      try {
        const price = await this.fetchPrice(exchangeName, symbol);
        prices.set(exchangeName, price);
      } catch (error) {
        console.error(`獲取 ${exchangeName} ${symbol} 價格失敗:`, error);
      }
    });
    
    await Promise.all(promises);
    return prices;
  }

  // 計算套利機會
  private calculateArbitrage(symbol: string, prices: Map<string, number>): ArbitrageOpportunity | null {
    const priceArray = Array.from(prices.entries());
    if (priceArray.length < 2) return null;
    
    // 找出最低價和最高價
    let minPrice = Infinity;
    let maxPrice = -Infinity;
    let buyExchange = '';
    let sellExchange = '';
    
    for (const [exchange, price] of priceArray) {
      if (price < minPrice) {
        minPrice = price;
        buyExchange = exchange;
      }
      if (price > maxPrice) {
        maxPrice = price;
        sellExchange = exchange;
      }
    }
    
    // 計算利潤率(扣除手續費)
    const buyFee = this.exchanges.get(buyExchange)?.tradingFee || 0;
    const sellFee = this.exchanges.get(sellExchange)?.tradingFee || 0;
    const totalFees = (buyFee + sellFee) * maxPrice;
    const netProfit = maxPrice - minPrice - totalFees;
    const profitMargin = netProfit / minPrice;
    
    if (profitMargin <= 0) return null;
    
    return {
      symbol,
      buyExchange,
      sellExchange,
      buyPrice: minPrice,
      sellPrice: maxPrice,
      profitMargin,
      volume: await this.getAvailableVolume(symbol, buyExchange, sellExchange)
    };
  }

  // 下買單
  private async placeBuyOrder(exchange: string, symbol: string, price: number, amount: number) {
    const config = this.exchanges.get(exchange);
    if (!config) throw new Error(`交易所配置不存在: ${exchange}`);
    
    const orderData = {
      symbol: symbol.replace('/', ''),
      side: 'BUY',
      type: 'LIMIT',
      quantity: amount.toFixed(8),
      price: price.toFixed(8),
      timeInForce: 'IOC' // 立即成交或取消
    };
    
    return await this.sendOrderRequest(config, orderData);
  }

  // 下賣單
  private async placeSellOrder(exchange: string, symbol: string, price: number, amount: number) {
    const config = this.exchanges.get(exchange);
    if (!config) throw new Error(`交易所配置不存在: ${exchange}`);
    
    const orderData = {
      symbol: symbol.replace('/', ''),
      side: 'SELL',
      type: 'LIMIT',
      quantity: amount.toFixed(8),
      price: price.toFixed(8),
      timeInForce: 'IOC'
    };
    
    return await this.sendOrderRequest(config, orderData);
  }

  // 檢查賬戶餘額
  private async checkAccountBalance(opportunity: ArbitrageOpportunity): Promise<boolean> {
    const { buyExchange, sellExchange, symbol, buyPrice, volume } = opportunity;
    
    try {
      // 檢查買入交易所的USDT餘額
      const buyExchangeBalance = await this.getBalance(buyExchange, 'USDT');
      const requiredUSDT = buyPrice * volume * 1.1; // 預留10%緩衝
      
      if (buyExchangeBalance < requiredUSDT) {
        console.log(`${buyExchange} USDT餘額不足: ${buyExchangeBalance} < ${requiredUSDT}`);
        return false;
      }
      
      // 檢查賣出交易所的幣種餘額
      const baseCurrency = symbol.split('/')[0];
      const sellExchangeBalance = await this.getBalance(sellExchange, baseCurrency);
      
      if (sellExchangeBalance < volume) {
        console.log(`${sellExchange} ${baseCurrency}餘額不足: ${sellExchangeBalance} < ${volume}`);
        return false;
      }
      
      return true;
    } catch (error) {
      console.error('檢查賬戶餘額失敗:', error);
      return false;
    }
  }

  // 檢查市場流動性
  private async checkMarketLiquidity(opportunity: ArbitrageOpportunity): Promise<boolean> {
    const { symbol, buyExchange, sellExchange, volume } = opportunity;
    
    try {
      // 獲取訂單簿深度
      const [buyOrderBook, sellOrderBook] = await Promise.all([
        this.getOrderBook(buyExchange, symbol),
        this.getOrderBook(sellExchange, symbol)
      ]);
      
      // 檢查買入深度
      const buyDepth = this.calculateOrderBookDepth(buyOrderBook.asks, volume);
      if (buyDepth < volume * 0.8) {
        console.log(`${buyExchange} 買入流動性不足`);
        return false;
      }
      
      // 檢查賣出深度
      const sellDepth = this.calculateOrderBookDepth(sellOrderBook.bids, volume);
      if (sellDepth < volume * 0.8) {
        console.log(`${sellExchange} 賣出流動性不足`);
        return false;
      }
      
      return true;
    } catch (error) {
      console.error('檢查市場流動性失敗:', error);
      return false;
    }
  }

  // 檢查價格波動率
  private async checkPriceVolatility(symbol: string): Promise<boolean> {
    try {
      const volatility = await this.calculateVolatility(symbol, '1h', 24);
      const maxVolatility = 0.05; // 最大允許波動率 5%
      
      if (volatility > maxVolatility) {
        console.log(`${symbol} 波動率過高: ${(volatility * 100).toFixed(2)}%`);
        return false;
      }
      
      return true;
    } catch (error) {
      console.error('檢查價格波動率失敗:', error);
      return false;
    }
  }

  // 緊急停止機制
  async emergencyStop(): Promise<void> {
    console.log('觸發緊急停止機制');
    
    // 取消所有掛單
    await this.cancelAllOrders();
    
    // 記錄緊急停止事件
    await this.logEmergencyStop({
      timestamp: new Date(),
      reason: '系統檢測到異常,觸發緊急停止',
      activeOrders: await this.getActiveOrders()
    });
    
    // 發送警報通知
    await this.sendAlert('緊急停止', '套利系統已緊急停止,請檢查系統狀態');
  }