hedgequantx 2.6.162 → 2.7.0

package/src/lib/core.js

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