hedgequantx 2.6.160 → 2.6.162

package/src/pages/algo/copy-engine.js

@@ -0,0 +1,449 @@
+/**
+ * @fileoverview Copy Trading Engine
+ * @module pages/algo/copy-engine
+ * 
+ * Ultra-low latency copy trading with:
+ * - Fast polling (250ms adaptive)
+ * - Multi-follower support
+ * - Parallel order execution
+ * - Position reconciliation
+ */
+
+const { logger } = require('../../utils');
+const { algoLogger } = require('./logger');
+const StrategySupervisor = require('../../services/ai/strategy-supervisor');
+
+const log = logger.scope('CopyEngine');
+
+/**
+ * CopyEngine - Handles all copy trading logic with professional execution
+ */
+class CopyEngine {
+  constructor(config) {
+    this.lead = config.lead;
+    this.followers = config.followers;
+    this.symbol = config.symbol;
+    this.dailyTarget = config.dailyTarget;
+    this.maxRisk = config.maxRisk;
+    this.ui = config.ui;
+    this.stats = config.stats;
+    
+    // Engine state
+    this.running = false;
+    this.stopReason = null;
+    
+    // Position tracking
+    this.leadPositions = new Map();
+    this.followerPositions = new Map();
+    this.pendingOrders = new Map();
+    
+    // Order queue
+    this.orderQueues = new Map();
+    this.processingQueue = new Map();
+    
+    // Timing
+    this.pollInterval = 250;
+    this.lastPollTime = 0;
+    this.pollCount = 0;
+    this.orderCount = 0;
+    this.failedOrders = 0;
+    this.lastLogTime = 0;
+    this.positionEntryTime = null;
+    
+    // Retry configuration
+    this.maxRetries = 3;
+    this.retryDelayBase = 100;
+    this.maxSlippageTicks = 4;
+  }
+
+  getPositionKey(position) {
+    return position.contractId || position.symbol || position.id;
+  }
+
+  resolveSymbol(position, targetAccount) {
+    const targetType = targetAccount.type;
+    
+    if (targetType === 'rithmic') {
+      return {
+        symbol: position.symbol || this.symbol.name,
+        exchange: position.exchange || this.symbol.exchange || 'CME',
+        contractId: null
+      };
+    } else {
+      return {
+        contractId: position.contractId || this.symbol.id || this.symbol.contractId,
+        symbol: null,
+        exchange: null
+      };
+    }
+  }
+
+  buildOrderData(params, platformType) {
+    const { accountId, contractId, symbol, exchange, side, size, type, price } = params;
+    
+    if (platformType === 'rithmic') {
+      return { accountId, symbol, exchange: exchange || 'CME', size, side, type, price: price || 0 };
+    } else {
+      return { accountId, contractId, type, side, size };
+    }
+  }
+
+  async executeOrderWithRetry(follower, orderData, retryCount = 0) {
+    try {
+      const startTime = Date.now();
+      const result = await follower.service.placeOrder(orderData);
+      const latency = Date.now() - startTime;
+      
+      if (result.success) {
+        this.orderCount++;
+        this.stats.latency = Math.round((this.stats.latency + latency) / 2);
+        return { success: true, latency };
+      }
+      
+      if (retryCount < this.maxRetries) {
+        const delay = this.retryDelayBase * Math.pow(2, retryCount);
+        await this.sleep(delay);
+        return this.executeOrderWithRetry(follower, orderData, retryCount + 1);
+      }
+      
+      this.failedOrders++;
+      return { success: false, error: result.error || 'Max retries exceeded' };
+    } catch (err) {
+      if (retryCount < this.maxRetries) {
+        const delay = this.retryDelayBase * Math.pow(2, retryCount);
+        await this.sleep(delay);
+        return this.executeOrderWithRetry(follower, orderData, retryCount + 1);
+      }
+      
+      this.failedOrders++;
+      return { success: false, error: err.message };
+    }
+  }
+
+  async queueOrder(followerIdx, orderFn) {
+    if (!this.orderQueues.has(followerIdx)) {
+      this.orderQueues.set(followerIdx, []);
+    }
+    
+    return new Promise((resolve) => {
+      this.orderQueues.get(followerIdx).push({ fn: orderFn, resolve });
+      this.processQueue(followerIdx);
+    });
+  }
+
+  async processQueue(followerIdx) {
+    if (this.processingQueue.get(followerIdx)) return;
+    
+    const queue = this.orderQueues.get(followerIdx);
+    if (!queue || queue.length === 0) return;
+    
+    this.processingQueue.set(followerIdx, true);
+    
+    while (queue.length > 0 && this.running) {
+      const { fn, resolve } = queue.shift();
+      try {
+        const result = await fn();
+        resolve(result);
+      } catch (err) {
+        resolve({ success: false, error: err.message });
+      }
+    }
+    
+    this.processingQueue.set(followerIdx, false);
+  }
+
+  async copyPositionOpen(position) {
+    const side = position.quantity > 0 ? 'LONG' : 'SHORT';
+    const orderSide = position.quantity > 0 ? 0 : 1;
+    const displaySymbol = position.symbol || this.symbol.name;
+    const size = Math.abs(position.quantity);
+    const entry = position.averagePrice || 0;
+    
+    this.positionEntryTime = Date.now();
+    algoLogger.positionOpened(this.ui, displaySymbol, side, size, entry);
+    
+    if (this.stats.aiSupervision) {
+      StrategySupervisor.feedSignal({
+        direction: side.toLowerCase(),
+        entry,
+        stopLoss: null,
+        takeProfit: null,
+        confidence: 0.5
+      });
+    }
+    
+    const promises = this.followers.map((follower, idx) => {
+      return this.queueOrder(idx, async () => {
+        const resolved = this.resolveSymbol(position, follower);
+        const orderData = this.buildOrderData({
+          accountId: follower.account.accountId,
+          contractId: resolved.contractId,
+          symbol: resolved.symbol,
+          exchange: resolved.exchange,
+          side: orderSide,
+          size: follower.contracts,
+          type: 2
+        }, follower.type);
+        
+        algoLogger.info(this.ui, 'COPY ORDER', `${side} ${follower.contracts}x -> ${follower.propfirm}`);
+        
+        const result = await this.executeOrderWithRetry(follower, orderData);
+        
+        if (result.success) {
+          algoLogger.orderFilled(this.ui, displaySymbol, side, follower.contracts, entry);
+          const posKey = this.getPositionKey(position);
+          this.followerPositions.set(`${idx}:${posKey}`, {
+            ...position,
+            followerIdx: idx,
+            openTime: Date.now()
+          });
+        } else {
+          algoLogger.orderRejected(this.ui, displaySymbol, result.error);
+        }
+        
+        return result;
+      });
+    });
+    
+    const results = await Promise.all(promises);
+    const successCount = results.filter(r => r.success).length;
+    
+    if (successCount === this.followers.length) {
+      algoLogger.info(this.ui, 'ALL COPIED', `${successCount}/${this.followers.length} followers`);
+    } else if (successCount > 0) {
+      algoLogger.info(this.ui, 'PARTIAL COPY', `${successCount}/${this.followers.length} followers`);
+    }
+    
+    return results;
+  }
+
+  async copyPositionClose(position, exitPrice, pnl) {
+    const side = position.quantity > 0 ? 'LONG' : 'SHORT';
+    const closeSide = position.quantity > 0 ? 1 : 0;
+    const displaySymbol = position.symbol || this.symbol.name;
+    const size = Math.abs(position.quantity);
+    
+    this.positionEntryTime = null;
+    algoLogger.positionClosed(this.ui, displaySymbol, side, size, exitPrice, pnl);
+    
+    if (this.stats.aiSupervision) {
+      StrategySupervisor.feedTradeResult({
+        side,
+        qty: size,
+        price: exitPrice,
+        pnl,
+        symbol: displaySymbol,
+        direction: side
+      });
+      
+      const aiStatus = StrategySupervisor.getStatus();
+      if (aiStatus.patternsLearned.winning + aiStatus.patternsLearned.losing > 0) {
+        algoLogger.info(this.ui, 'AI LEARNING', 
+          `${aiStatus.patternsLearned.winning}W/${aiStatus.patternsLearned.losing}L patterns`);
+      }
+    }
+    
+    const posKey = this.getPositionKey(position);
+    
+    const promises = this.followers.map((follower, idx) => {
+      return this.queueOrder(idx, async () => {
+        const resolved = this.resolveSymbol(position, follower);
+        const posIdentifier = follower.type === 'rithmic' 
+          ? (position.symbol || this.symbol.name)
+          : (position.contractId || this.symbol.id);
+        
+        algoLogger.info(this.ui, 'CLOSE ORDER', `${displaySymbol} -> ${follower.propfirm}`);
+        
+        let result = await follower.service.closePosition(follower.account.accountId, posIdentifier);
+        
+        if (!result.success) {
+          const orderData = this.buildOrderData({
+            accountId: follower.account.accountId,
+            contractId: resolved.contractId,
+            symbol: resolved.symbol,
+            exchange: resolved.exchange,
+            side: closeSide,
+            size: follower.contracts,
+            type: 2
+          }, follower.type);
+          
+          result = await this.executeOrderWithRetry(follower, orderData);
+        }
+        
+        if (result.success) {
+          algoLogger.info(this.ui, 'CLOSED', `${displaySymbol} on ${follower.propfirm}`);
+          this.followerPositions.delete(`${idx}:${posKey}`);
+        } else {
+          algoLogger.error(this.ui, 'CLOSE FAILED', `${follower.propfirm}: ${result.error}`);
+        }
+        
+        return result;
+      });
+    });
+    
+    const results = await Promise.all(promises);
+    const successCount = results.filter(r => r.success).length;
+    
+    if (successCount === this.followers.length) {
+      this.stats.trades++;
+      this.stats.sessionPnl += pnl;
+      if (pnl >= 0) this.stats.wins++;
+      else this.stats.losses++;
+    }
+    
+    return results;
+  }
+
+  async pollLeadPositions() {
+    if (!this.running) return;
+    
+    const startTime = Date.now();
+    
+    try {
+      const result = await this.lead.service.getPositions(this.lead.account.accountId);
+      if (!result.success) return;
+      
+      const currentPositions = result.positions || [];
+      const currentMap = new Map();
+      
+      for (const pos of currentPositions) {
+        if (pos.quantity === 0) continue;
+        const key = this.getPositionKey(pos);
+        currentMap.set(key, pos);
+      }
+      
+      // Detect new positions
+      for (const [key, pos] of currentMap) {
+        if (!this.leadPositions.has(key)) {
+          await this.copyPositionOpen(pos);
+          this.leadPositions.set(key, pos);
+        } else {
+          const oldPos = this.leadPositions.get(key);
+          if (Math.abs(pos.quantity) !== Math.abs(oldPos.quantity)) {
+            this.leadPositions.set(key, pos);
+          }
+        }
+      }
+      
+      // Detect closed positions
+      for (const [key, oldPos] of this.leadPositions) {
+        if (!currentMap.has(key)) {
+          const exitPrice = oldPos.averagePrice || 0;
+          const pnl = oldPos.profitAndLoss || 0;
+          await this.copyPositionClose(oldPos, exitPrice, pnl);
+          this.leadPositions.delete(key);
+        }
+      }
+      
+      // Update P&L
+      const totalPnL = currentPositions.reduce((sum, p) => sum + (p.profitAndLoss || 0), 0);
+      this.stats.pnl = totalPnL;
+      
+      // Check limits
+      if (totalPnL >= this.dailyTarget) {
+        this.stop('target');
+        algoLogger.info(this.ui, 'TARGET REACHED', `+$${totalPnL.toFixed(2)}`);
+      } else if (totalPnL <= -this.maxRisk) {
+        this.stop('risk');
+        algoLogger.error(this.ui, 'MAX RISK HIT', `-$${Math.abs(totalPnL).toFixed(2)}`);
+      }
+      
+      // Adaptive polling
+      const pollTime = Date.now() - startTime;
+      this.stats.latency = pollTime;
+      
+      if (this.leadPositions.size > 0) {
+        this.pollInterval = Math.max(100, Math.min(250, pollTime * 2));
+      } else {
+        this.pollInterval = Math.max(250, Math.min(500, pollTime * 3));
+      }
+      
+      this.pollCount++;
+      
+      // Smart logs
+      const now = Date.now();
+      if (now - this.lastLogTime > 1000) {
+        const smartLogs = require('./smart-logs');
+        
+        if (this.leadPositions.size === 0) {
+          const scanLog = smartLogs.getScanningLog(true);
+          this.ui.addLog('info', `${scanLog.message} poll #${this.pollCount} | ${pollTime}ms`);
+        }
+        this.lastLogTime = now;
+      }
+      
+    } catch (err) {
+      log.warn('Poll error', { error: err.message });
+    }
+  }
+
+  async reconcilePositions() {
+    for (let idx = 0; idx < this.followers.length; idx++) {
+      const follower = this.followers[idx];
+      
+      try {
+        const result = await follower.service.getPositions(follower.account.accountId);
+        if (!result.success) continue;
+        
+        const followerPositions = result.positions || [];
+        
+        // Check missing positions
+        for (const [key, leadPos] of this.leadPositions) {
+          const hasFollowerPos = followerPositions.some(fp => {
+            const fpKey = this.getPositionKey(fp);
+            return fpKey === key && fp.quantity !== 0;
+          });
+          
+          if (!hasFollowerPos) {
+            algoLogger.info(this.ui, 'RECONCILE', `Missing ${key} on ${follower.propfirm}`);
+            await this.copyPositionOpen(leadPos);
+          }
+        }
+        
+        // Check orphaned positions
+        for (const fp of followerPositions) {
+          if (fp.quantity === 0) continue;
+          const fpKey = this.getPositionKey(fp);
+          
+          if (!this.leadPositions.has(fpKey)) {
+            algoLogger.info(this.ui, 'RECONCILE', `Orphaned ${fpKey} on ${follower.propfirm}`);
+            const posIdentifier = follower.type === 'rithmic' ? fp.symbol : fp.contractId;
+            await follower.service.closePosition(follower.account.accountId, posIdentifier);
+          }
+        }
+        
+      } catch (err) {
+        log.warn('Reconcile error', { follower: follower.propfirm, error: err.message });
+      }
+    }
+  }
+
+  async start() {
+    this.running = true;
+    this.stats.connected = true;
+    
+    algoLogger.info(this.ui, 'ENGINE STARTED', `Polling every ${this.pollInterval}ms`);
+    algoLogger.info(this.ui, 'FOLLOWERS', `${this.followers.length} account(s)`);
+    
+    await this.reconcilePositions();
+    
+    while (this.running) {
+      await this.pollLeadPositions();
+      await this.sleep(this.pollInterval);
+    }
+    
+    return this.stopReason;
+  }
+
+  stop(reason = 'manual') {
+    this.running = false;
+    this.stopReason = reason;
+    this.stats.connected = false;
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = { CopyEngine };