hedgequantx 2.6.163 → 2.7.0

package/src/pages/algo/algo-utils.js

@@ -1,58 +0,0 @@
-/**
- * Algo Trading Utilities
- * Shared functions and constants for algo trading
- */
-
-'use strict';
-
-/**
- * Format price to avoid floating point errors
- * @param {number} price - Raw price
- * @param {number} tickSize - Tick size (default 0.25)
- * @returns {string} - Formatted price string
- */
-const formatPrice = (price, tickSize = 0.25) => {
-  if (price === null || price === undefined || isNaN(price)) return '--';
-  const rounded = Math.round(price / tickSize) * tickSize;
-  const decimals = tickSize < 1 ? Math.max(0, -Math.floor(Math.log10(tickSize))) : 0;
-  return rounded.toFixed(decimals);
-};
-
-/**
- * Check if service supports fast path (Rithmic direct)
- * @param {Object} service - Trading service
- * @returns {boolean}
- */
-const isRithmicFastPath = (service) => {
-  return typeof service.fastEntry === 'function' && 
-         typeof service.fastExit === 'function' &&
-         service.orderConn?.isConnected;
-};
-
-// Maximum symbols for multi-symbol trading
-const MAX_MULTI_SYMBOLS = 5;
-
-// Use HFT tick-based strategy for Rithmic
-const USE_HFT_STRATEGY = true;
-
-// Timeout for async operations
-const TIMEOUT_MS = 5000;
-
-/**
- * Wrap promise with timeout
- */
-const withTimeout = (promise, ms) => {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), ms))
-  ]);
-};
-
-module.exports = {
-  formatPrice,
-  isRithmicFastPath,
-  MAX_MULTI_SYMBOLS,
-  USE_HFT_STRATEGY,
-  TIMEOUT_MS,
-  withTimeout
-};

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

@@ -1,449 +0,0 @@
-/**
- * @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 };