hedgequantx 2.7.14 → 2.7.16

package/src/lib/core.js

@@ -1,539 +0,0 @@
-/**
- * Core Module
- */
-
-const { M1 } = require('./m/s1');
-const { L2 } = require('./o/l2');
-const L1 = require('./o/l1');
-const { getB, closeB } = require('./python-bridge');
-const {
-  RithmicAdapter: N1,
-  getCurrentFrontMonth: getFM
-} = require('./n/r1');
-
-class C1 {
-  constructor(sessionId, config, callbacks) {
-    this.sessionId = sessionId;
-    this.config = config;
-    this.callbacks = callbacks;
-    this.running = false;
-    this.rithmicAdapter = null;
-    this.strategy = null;
-    this.pythonBridge = null;  // For Python/Cython strategy mode
-    this.usePythonStrategy = config.usePythonStrategy || false;
-    this.symbol = null;
-    this.exchange = 'CME';
-    
-    // Account info
-    this.rithmicAccountId = null;
-    this.accountDisplayName = null;
-    
-    // Position & P&L from Rithmic
-    this.rithmicData = {
-      pnl: { open: 0, closed: 0, total: 0, dayPnl: 0 },
-      position: null,
-      lastPrice: 0,
-      lastBid: 0,
-      lastAsk: 0
-    };
-    
-    // Stats
-    this.stats = {
-      trades: 0,
-      wins: 0,
-      losses: 0,
-      startTime: null,
-      lastClosedPnl: 0  // Track P&L at last position close
-    };
-    
-    // Order management - CRITICAL
-    this.lastOrderTime = 0;
-    this.orderCooldownMs = 30000;  // 30 seconds minimum between entries
-    this.pendingOrder = false;
-    this.hasOpenPosition = false;
-    this.lastEntryPrice = 0;
-    this.lastEntrySide = null;
-    this.entryTime = 0;
-    this.minHoldTimeMs = 10000;  // MINIMUM 10 seconds hold time per trade
-    
-    // Smart logs state tracking
-    this.lastMarketCondition = null;
-    this.lastLoggedPrice = 0;
-    this.lastDelta = 0;
-    this.logThrottleMs = 5000;  // Min 5s between market flow logs
-    this.lastFlowLogTime = 0;
-  }
-
-  async start() {
-    this.running = true;
-    this.stats.startTime = Date.now();
-    
-    const propfirm = this.config.propfirm || 'apex';
-    const rithmicCredentials = this.config.rithmicCredentials || {};
-    
-    if (!rithmicCredentials.userId || !rithmicCredentials.password) {
-      this._log('error', 'Rithmic credentials required');
-      throw new Error('Rithmic credentials required');
-    }
-    
-    // Initialize smart logger
-    L2.reset();
-    L2.algoStarting('Rithmic', this.config.symbol || 'MNQ');
-    
-    this._log('info', 'Connecting to Rithmic...');
-    
-    try {
-      // Connect to Rithmic
-      this.rithmicAdapter = new N1({ debug: false, usePool: false });
-      
-      await this.rithmicAdapter.connect({
-        userId: rithmicCredentials.userId,
-        password: rithmicCredentials.password,
-        propfirm: propfirm
-      }, {
-        marketData: true,
-        trading: true,
-        pnl: true
-      });
-      
-      // Get account
-      const accounts = this.rithmicAdapter.getAccounts();
-      if (accounts.length === 0) throw new Error('No Rithmic accounts found');
-      
-      this.rithmicAccountId = accounts[0].accountId;
-      this.accountDisplayName = this.rithmicAccountId; // Real Rithmic ID like APEX-130042-62
-      this._log('info', `Account: ${this.accountDisplayName}`);
-      
-      // Resolve symbol
-      this.symbol = this._getSymbol(this.config.symbol);
-      this.exchange = this._getExchange(this.symbol);
-      
-      // Subscribe market data
-      await this.rithmicAdapter.subscribe(this.symbol, this.exchange);
-      this._log('info', `Symbol: ${this.symbol}`);
-      
-      // Subscribe P&L
-      await this.rithmicAdapter.subscribePnL(this.rithmicAccountId);
-      
-      // Event handlers
-      this.rithmicAdapter.on('quote', (q) => this._onQuote(q));
-      this.rithmicAdapter.on('trade', (t) => this._onTrade(t));
-      this.rithmicAdapter.on('fill', (f) => this._onFill(f));
-      this.rithmicAdapter.on('reject', (r) => this._onReject(r));
-      this.rithmicAdapter.on('accountPnL', (p) => this._onAccountPnL(p));
-      this.rithmicAdapter.on('instrumentPnL', (p) => this._onPositionPnL(p));
-      
-      // Initialize strategy
-      // Contract specs MUST come from API via config - NO defaults
-      // P&L comes from PNL_PLANT API - never calculated locally
-      if (!this.config.tickSize) {
-        this._log('warn', 'tickSize not provided - using API data only for P&L');
-      }
-      const tickSize = this.config.tickSize || 0.25; // Only for stop/target calculations in ticks
-      const tickValue = 0; // NOT USED - P&L comes from API
-      
-      if (this.usePythonStrategy) {
-        // Use Python/Cython compiled strategy
-        this._log('info', 'Initializing Python strategy bridge...');
-        try {
-          this.pythonBridge = await getB();
-          await this.pythonBridge.initialize(this.symbol, tickSize);
-          
-          // Listen for signals from Python bridge
-          this.pythonBridge.on('signal', (signal) => {
-            if (signal && signal.confidence >= 0.5) {
-              this._executeSignal(signal);
-            }
-          });
-          
-          // Listen for smart logs from Python
-          this.pythonBridge.on('log', (logData) => {
-            if (logData && logData.message) {
-              this._log('info', `[PY] ${logData.message}${logData.details ? ` | ${logData.details}` : ''}`);
-            }
-          });
-          
-          this._log('success', 'Python strategy bridge connected');
-        } catch (error) {
-          this._log('error', `Python bridge failed: ${error.message}, falling back to JS strategy`);
-          this.usePythonStrategy = false;
-        }
-      }
-      
-      if (!this.usePythonStrategy) {
-        // Use JavaScript strategy - P&L from API, not calculated
-        this.strategy = new M1({
-          tickSize: tickSize
-        });
-        this.strategy.initialize(this.symbol, tickSize);
-        
-        // Forward strategy signals to smart logger
-        this.strategy.on('signal', (signal) => {
-          L2.strategySignal(
-            signal.direction,
-            signal.zScore || 0,
-            signal.confidence,
-            signal.stopTicks,
-            signal.targetTicks
-          );
-        });
-      }
-      
-      L2.algoRunning();
-      const strategyMode = this.usePythonStrategy ? 'Python/Cython' : 'JavaScript';
-      this._log('success', `Engine started [${strategyMode}]`);
-      
-      // Stats interval
-      this.statsInterval = setInterval(() => this._sendStats(), 2000);
-      
-    } catch (error) {
-      this._log('error', `Connection failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async stop() {
-    L2.algoStopping();
-    this._log('info', 'Stopping algo...');
-    this.running = false;
-    
-    if (this.statsInterval) {
-      clearInterval(this.statsInterval);
-      this.statsInterval = null;
-    }
-    
-    // CRITICAL: Cancel all orders and flatten positions
-    if (this.rithmicAdapter && this.rithmicAccountId) {
-      try {
-        // 1. Cancel all open orders
-        this._log('info', 'Cancelling orders...');
-        await this.rithmicAdapter.cancelAllOrders(this.rithmicAccountId);
-        await new Promise(r => setTimeout(r, 500));
-        
-        // 2. Flatten position if any
-        if (this.hasOpenPosition && this.rithmicData.position) {
-          const pos = this.rithmicData.position;
-          const qty = Math.abs(pos.qty || 0);
-          if (qty > 0) {
-            const side = pos.qty > 0 ? 'sell' : 'buy';
-            this._log('info', `Flatten: ${side.toUpperCase()} ${qty}x @MKT`);
-            await this.rithmicAdapter.placeMarketOrder(
-              this.rithmicAccountId,
-              this.symbol,
-              side,
-              qty,
-              this.exchange
-            );
-            await new Promise(r => setTimeout(r, 2000));
-          }
-        }
-        
-        this._log('success', 'Positions closed');
-      } catch (error) {
-        this._log('error', `Cleanup error: ${error.message}`);
-      }
-    }
-    
-    if (this.rithmicAdapter) {
-      this.rithmicAdapter.disconnect();
-      this.rithmicAdapter = null;
-    }
-    
-    // Close Python bridge if using it
-    if (this.pythonBridge) {
-      closeB();
-      this.pythonBridge = null;
-    }
-    
-    this._log('info', 'ALGO STOPPED');
-  }
-
-  // Quote handler - ONLY process valid signals
-  async _onQuote(quote) {
-    if (!this.running) return;
-    
-    if (quote.bid > 0) this.rithmicData.lastBid = quote.bid;
-    if (quote.ask > 0) this.rithmicData.lastAsk = quote.ask;
-    if (quote.price > 0) this.rithmicData.lastPrice = quote.price;
-    
-    const tick = {
-      contract_id: this.symbol,
-      price: this.rithmicData.lastPrice,
-      bid: this.rithmicData.lastBid,
-      ask: this.rithmicData.lastAsk,
-      volume: 1,
-      timestamp: Date.now()
-    };
-    
-    // Process tick with appropriate strategy
-    if (this.usePythonStrategy && this.pythonBridge && this.rithmicData.lastPrice > 0) {
-      // Python/Cython strategy path
-      try {
-        const result = await this.pythonBridge.processTick(tick);
-        if (result && result.signal) {
-          // ONLY execute if: no position, no pending order, cooldown passed
-          if (!this.hasOpenPosition && !this.pendingOrder && this._canOrder()) {
-            if (result.signal.confidence >= 0.5) {
-              this._executeSignal(result.signal);
-            }
-          }
-        }
-      } catch (error) {
-        // Silent fail - don't spam logs
-      }
-    } else if (this.strategy && this.rithmicData.lastPrice > 0) {
-      // JavaScript strategy path
-      this.strategy.processTick(tick);
-      
-      // ONLY generate signal if:
-      // 1. No open position
-      // 2. No pending order
-      // 3. Cooldown passed
-      if (!this.hasOpenPosition && !this.pendingOrder && this._canOrder()) {
-        const signal = this.strategy.generateSignal(this.rithmicData.lastPrice);
-        if (signal && signal.confidence >= 0.5) {
-          this._executeSignal(signal);
-        }
-      }
-    }
-    
-    // Check risk limits
-    this._checkRiskLimits();
-  }
-
-  // Trade handler - pass to strategy for order flow
-  async _onTrade(trade) {
-    if (!this.running) return;
-    
-    this.rithmicData.lastPrice = trade.price;
-    
-    const tradeData = {
-      contract_id: this.symbol,
-      price: trade.price,
-      size: trade.size || trade.volume || 1,
-      volume: trade.size || trade.volume || 1,
-      side: trade.side,
-      timestamp: trade.timestamp || Date.now()
-    };
-    
-    if (this.usePythonStrategy && this.pythonBridge) {
-      // Python strategy processes trades as bars
-      try {
-        await this.pythonBridge.processTick(tradeData);
-      } catch (error) {
-        // Silent fail
-      }
-    } else if (this.strategy) {
-      this.strategy.onTrade(tradeData);
-    }
-  }
-
-  // Fill handler
-  async _onFill(fill) {
-    if (!this.running) return;
-    
-    const side = fill.side === 'buy' ? 'BUY' : 'SELL';
-    const price = fill.fillPrice || fill.avgFillPrice || fill.price;
-    const qty = fill.fillSize || fill.totalFillSize || 1;
-    
-    // Determine if this is entry or exit
-    const wasFlat = !this.hasOpenPosition;
-    
-    if (wasFlat) {
-      // Entry fill
-      this.hasOpenPosition = true;
-      this.lastEntryPrice = price;
-      this.lastEntrySide = side.toLowerCase();
-      this.entryTime = Date.now();  // Track entry time for minimum hold
-      this.pendingOrder = false;
-      this._log('trade', `ENTRY ${side} ${qty}x @${price}`);
-    } else {
-      // Exit fill - P&L comes from API (PNL_PLANT), not calculated locally
-      // Use closedPnL delta from rithmicData which is updated by _onAccountPnL
-      const currentClosedPnl = this.rithmicData.pnl.closed || 0;
-      const tradePnl = currentClosedPnl - this.stats.lastClosedPnl;
-      this.stats.lastClosedPnl = currentClosedPnl;
-      
-      // Calculate hold time
-      const holdTimeMs = Date.now() - this.entryTime;
-      const holdTimeSec = Math.round(holdTimeMs / 1000);
-      
-      if (tradePnl > 0) {
-        this.stats.wins++;
-        this._log('fill_win', `EXIT ${side} ${qty}x @${price} | +$${tradePnl.toFixed(2)} | ${holdTimeSec}s`);
-      } else {
-        this.stats.losses++;
-        this._log('fill_loss', `EXIT ${side} ${qty}x @${price} | -$${Math.abs(tradePnl).toFixed(2)} | ${holdTimeSec}s`);
-      }
-      
-      // Record trade result in strategy for performance tracking
-      if (this.usePythonStrategy && this.pythonBridge) {
-        try {
-          await this.pythonBridge.recordTradeResult(tradePnl);
-        } catch (error) {
-          // Silent fail
-        }
-      } else if (this.strategy && this.strategy.recordTradeResult) {
-        this.strategy.recordTradeResult(tradePnl);
-      }
-      
-      this.hasOpenPosition = false;
-      this.pendingOrder = false;
-      this.lastEntryPrice = 0;
-      this.lastEntrySide = null;
-      this.entryTime = 0;
-    }
-    
-    this.stats.trades++;
-    this._sendStats();
-  }
-
-  // Reject handler
-  _onReject(reject) {
-    this.pendingOrder = false;
-    this._log('error', `REJECTED: ${reject.reason || reject.text || 'Unknown'}`);
-  }
-
-  // Account P&L from Rithmic
-  _onAccountPnL(pnl) {
-    if (!this.running) return;
-    
-    this.rithmicData.pnl.open = parseFloat(pnl.openPositionPnl || pnl.openPositionPnL || 0);
-    this.rithmicData.pnl.closed = parseFloat(pnl.closedPositionPnl || pnl.closedPositionPnL || 0);
-    this.rithmicData.pnl.dayPnl = parseFloat(pnl.dayPnl || 0);
-    this.rithmicData.pnl.total = this.rithmicData.pnl.open + this.rithmicData.pnl.closed;
-  }
-
-  // Position P&L from Rithmic
-  _onPositionPnL(pnl) {
-    if (!this.running) return;
-    
-    const netQty = pnl.netQuantity || 0;
-    
-    if (netQty !== 0) {
-      this.rithmicData.position = {
-        symbol: pnl.symbol,
-        qty: netQty,
-        side: netQty > 0 ? 'long' : 'short',
-        avgPrice: pnl.avgOpenFillPrice || 0,
-        pnl: parseFloat(pnl.openPositionPnl || pnl.openPositionPnL || 0)
-      };
-      this.hasOpenPosition = true;
-    } else {
-      // Position closed
-      if (this.hasOpenPosition && this.rithmicData.position) {
-        const closedPnl = this.rithmicData.pnl.closed - this.stats.lastClosedPnl;
-        this.stats.lastClosedPnl = this.rithmicData.pnl.closed;
-      }
-      this.rithmicData.position = null;
-      this.hasOpenPosition = false;
-    }
-  }
-
-  // Execute signal
-  async _executeSignal(signal) {
-    if (!this.rithmicAdapter || !this.running) return;
-    if (this.hasOpenPosition || this.pendingOrder) return;
-    
-    const side = signal.direction === 'long' ? 'buy' : 'sell';
-    const qty = this.config.contracts || 1;
-    
-    this.pendingOrder = true;
-    this.lastOrderTime = Date.now();
-    
-    const confidence = (signal.confidence * 100).toFixed(0);
-    this._log('info', `SIGNAL: ${side.toUpperCase()} (${confidence}% conf)`);
-    
-    try {
-      await this.rithmicAdapter.placeMarketOrder(
-        this.rithmicAccountId,
-        this.symbol,
-        side,
-        qty,
-        this.exchange
-      );
-    } catch (error) {
-      this.pendingOrder = false;
-      this._log('error', `ORDER FAILED: ${error.message}`);
-    }
-  }
-
-  // Check daily risk limits
-  _checkRiskLimits() {
-    const target = this.config.dailyTarget || 200;
-    const maxRisk = this.config.maxRisk || 100;
-    const totalPnl = this.rithmicData.pnl.total;
-    
-    if (totalPnl >= target) {
-      this._log('success', `TARGET REACHED: +$${totalPnl.toFixed(2)}`);
-      this.stop();
-    }
-    
-    if (totalPnl <= -maxRisk) {
-      this._log('error', `MAX LOSS: -$${Math.abs(totalPnl).toFixed(2)}`);
-      this.stop();
-    }
-  }
-
-  _canOrder() {
-    return Date.now() - this.lastOrderTime >= this.orderCooldownMs;
-  }
-
-  _canExit() {
-    // Minimum 10 seconds hold time before allowing exit
-    if (!this.hasOpenPosition || this.entryTime === 0) return true;
-    const holdTimeMs = Date.now() - this.entryTime;
-    return holdTimeMs >= this.minHoldTimeMs;
-  }
-
-  _getHoldTime() {
-    if (!this.entryTime) return 0;
-    return Math.round((Date.now() - this.entryTime) / 1000);
-  }
-
-  _sendStats() {
-    const totalTrades = this.stats.wins + this.stats.losses;
-    const winRate = totalTrades > 0 ? (this.stats.wins / totalTrades * 100) : 0;
-    
-    this.callbacks.onStats({
-      accountName: this.accountDisplayName,
-      realTimePnL: {
-        openPnL: this.rithmicData.pnl.open,
-        closedPnL: this.rithmicData.pnl.closed,
-        totalPnL: this.rithmicData.pnl.total,
-        dayPnL: this.rithmicData.pnl.dayPnl
-      },
-      position: this.rithmicData.position,
-      hasPosition: this.hasOpenPosition,
-      holdTime: this._getHoldTime(),
-      canExit: this._canExit(),
-      trades: this.stats.trades,
-      wins: this.stats.wins,
-      losses: this.stats.losses,
-      winRate: winRate.toFixed(1),
-      lastPrice: this.rithmicData.lastPrice
-    });
-  }
-
-  _log(type, message) {
-    this.callbacks.onLog({ type, message, timestamp: Date.now() });
-  }
-
-  _getSymbol(symbol) {
-    if (/^[A-Z]{2,4}[FGHJKMNQUVXZ]\d{1,2}$/.test(symbol?.toUpperCase())) {
-      return symbol.toUpperCase();
-    }
-    const base = symbol?.replace(/[^A-Z]/gi, '').toUpperCase() || 'MNQ';
-    return getFM(base);
-  }
-
-  _getExchange(symbol) {
-    const base = symbol?.replace(/[FGHJKMNQUVXZ]\d{1,2}$/, '').toUpperCase();
-    if (['ZB', 'ZN', 'ZF', 'ZT', 'ZC', 'ZS', 'ZW', 'ZL', 'ZM', 'ZO', 'YM', 'MYM', 'TN', 'ZQ'].includes(base)) return 'CBOT';
-    if (['CL', 'MCL', 'NG', 'HO', 'RB', 'PA', 'PL', 'BZ'].includes(base)) return 'NYMEX';
-    if (['GC', 'MGC', 'SI', 'SIL', 'HG', 'MHG', '1OZ'].includes(base)) return 'COMEX';
-    return 'CME';
-  }
-}
-
-module.exports = { C1 };