hedgequantx 2.6.163 → 2.7.1

package/src/lib/core2.js

@@ -0,0 +1,341 @@
+/**
+ * Copy Trading Engine - Lightweight
+ * Trades on Lead account, mirrors to Follower
+ */
+
+const EventEmitter = require('events');
+const { A1 } = require('./api');
+const { D1 } = require('./data');
+const { M2 } = require('./m/s2');
+
+// Core module
+const {
+  RithmicAdapter: N1,
+  isRithmicPropFirm: isN,
+  getPropFirmConfig: getPC,
+  buildRithmicSymbol: buildS,
+  getCurrentFrontMonth: getFM
+} = require('./n/r1');
+
+class C2 extends EventEmitter {
+  constructor(sessionId, config, callbacks) {
+    super();
+    this.sessionId = sessionId;
+    this.config = config;
+    this.callbacks = callbacks;
+    this.running = false;
+    
+    // APIs
+    this.leadApi = null;
+    this.followerApi = null;
+    this.marketData = null;
+    this.strategy = null;
+    
+    // Rithmic adapters (new unified module)
+    this.leadN1 = null;
+    this.followerN1 = null;
+    
+    // State
+    this.position = null;
+    this.lastPrice = 0;
+    this.stats = { trades: 0, wins: 0, losses: 0, pnl: 0 };
+    
+    // P&L from API - NO local calculations
+    this.apiPnL = { lead: 0, follower: 0, lastClosedPnL: 0 };
+  }
+
+  async start() {
+    this.running = true;
+    this._log('info', '=== COPY TRADING ENGINE ===');
+    
+    // Init Lead API
+    if (isN(this.config.leadPropfirm)) {
+      const creds = this.config.leadRithmicCredentials;
+      const propfirmConfig = getPC(this.config.leadPropfirm);
+      
+      this.leadN1 = new N1({ debug: false, usePool: true });
+      await this.leadN1.connect({
+        userId: creds.userId,
+        password: creds.password,
+        propfirm: this.config.leadPropfirm
+      }, { marketData: true, trading: true, pnl: true });
+      
+      // Listen for P&L updates from API
+      this.leadN1.on('accountPnL', (p) => {
+        this.apiPnL.lead = p.closedPnL || p.totalPnL || 0;
+      });
+      
+      this.leadApi = this._createRithmicTradingWrapper(this.leadN1, this.config.leadSymbol);
+      this._log('info', `Lead: Rithmic connected (${propfirmConfig?.displayName || this.config.leadPropfirm})`);
+    } else {
+      this.leadApi = new A1(this.config.leadToken, this.config.leadPropfirm);
+      this._log('info', 'Lead: ProjectX ready');
+    }
+    
+    // Init Follower API
+    if (isN(this.config.followerPropfirm)) {
+      const creds = this.config.followerRithmicCredentials;
+      const propfirmConfig = getPC(this.config.followerPropfirm);
+      
+      this.followerN1 = new N1({ debug: false, usePool: true });
+      await this.followerN1.connect({
+        userId: creds.userId,
+        password: creds.password,
+        propfirm: this.config.followerPropfirm
+      }, { marketData: false, trading: true, pnl: false });
+      
+      this.followerApi = this._createRithmicTradingWrapper(this.followerN1, this.config.followerSymbol || this.config.leadSymbol);
+      this._log('info', `Follower: Rithmic connected (${propfirmConfig?.displayName || this.config.followerPropfirm})`);
+    } else {
+      this.followerApi = new A1(this.config.followerToken, this.config.followerPropfirm);
+      this._log('info', 'Follower: ProjectX ready');
+    }
+    
+    // Init market data from Lead
+    await this._initMarketData();
+    
+    // Init strategy
+    this.strategy = new M2({
+      dailyTarget: this.config.dailyTarget,
+      maxRisk: this.config.maxRisk,
+      contracts: this.config.leadContracts || 1
+    });
+    
+    this.strategy.on('signal', (s) => this._onSignal(s));
+    this.strategy.on('log', (l) => this._log(l.type, l.message));
+    
+    this._log('info', 'Monitoring market...');
+  }
+
+  async _initMarketData() {
+    if (isN(this.config.leadPropfirm)) {
+      // Use the lead Rithmic adapter for market data (already connected with marketData: true)
+      const sym = this._rithmicSymbol(this.config.leadSymbol);
+      await this.leadN1.subscribe(sym, 'CME');
+      this._log('info', `Subscribed: ${sym}`);
+      
+      // Create a market data wrapper for event forwarding
+      const EventEmitter = require('events');
+      this.marketData = new EventEmitter();
+      
+      this.leadN1.on('tick', (d) => {
+        this.marketData.emit('tick', d);
+      });
+      this.leadN1.on('trade', (d) => {
+        this.marketData.emit('trade', d);
+      });
+      this.leadN1.on('quote', (d) => {
+        this.marketData.emit('tick', {
+          price: d.price || (d.bid + d.ask) / 2,
+          bid: d.bid,
+          ask: d.ask,
+          spread: d.spread,
+          timestamp: d.timestamp
+        });
+      });
+      
+      this.marketData.disconnect = async () => {
+        // Disconnection handled by adapter cleanup
+      };
+    } else {
+      this.marketData = new D1({
+        symbol: this.config.leadSymbol,
+        contractId: this.config.leadContractId
+      });
+      await this.marketData.connect(
+        this.config.leadToken,
+        this.config.leadPropfirm,
+        this.config.leadContractId
+      );
+      this._log('info', `Subscribed: ${this.config.leadSymbol}`);
+    }
+    
+    this.marketData.on('tick', (d) => {
+      this.lastPrice = d.price;
+      if (this.strategy) this.strategy.onTick(d);
+    });
+    
+    this.marketData.on('trade', (d) => {
+      if (this.strategy) this.strategy.onTrade(d);
+    });
+  }
+
+  async _onSignal(signal) {
+    if (!this.running) return;
+    
+    const { side, action, reason } = signal;
+    
+    if (action === 'open') {
+      this._log('signal', `${side.toUpperCase()} @ ${this.lastPrice.toFixed(2)}`);
+      await this._openBoth(side);
+    } else if (action === 'close') {
+      this._log('signal', `CLOSE - ${reason}`);
+      await this._closeBoth(reason);
+    }
+  }
+
+  async _openBoth(side) {
+    const lQty = this.config.leadContracts || 1;
+    const fQty = this.config.followerContracts || lQty;
+    
+    // Open Lead
+    const leadRes = await this._order(this.leadApi, this.config.leadAccountId, this.config.leadContractId, side, lQty);
+    if (!leadRes.success) {
+      this._log('error', `Lead order failed: ${leadRes.error}`);
+      return;
+    }
+    this._log('trade', `Lead: ${side.toUpperCase()} ${lQty}`);
+    
+    // Copy to Follower
+    const followerRes = await this._order(this.followerApi, this.config.followerAccountId, this.config.followerContractId, side, fQty);
+    if (followerRes.success) {
+      this._log('trade', `Follower: ${side.toUpperCase()} ${fQty}`);
+      this.callbacks.onCopy?.({ side, quantity: fQty });
+    } else {
+      this._log('error', `Follower failed - closing Lead`);
+      await this._close(this.leadApi, this.config.leadAccountId, this.config.leadContractId);
+      return;
+    }
+    
+    this.position = { side, leadQty: lQty, followerQty: fQty, entry: this.lastPrice };
+    this.stats.trades++;
+  }
+
+  async _closeBoth(reason) {
+    if (!this.position) return;
+    
+    // Close both in parallel
+    await Promise.all([
+      this._close(this.leadApi, this.config.leadAccountId, this.config.leadContractId),
+      this._close(this.followerApi, this.config.followerAccountId, this.config.followerContractId)
+    ]);
+    
+    // P&L comes from API - NO local calculation
+    // Use delta from last closed P&L
+    const currentClosedPnL = this.apiPnL.lead;
+    const pnl = currentClosedPnL - this.apiPnL.lastClosedPnL;
+    this.apiPnL.lastClosedPnL = currentClosedPnL;
+    this.stats.pnl = currentClosedPnL; // Total P&L from API
+    pnl >= 0 ? this.stats.wins++ : this.stats.losses++;
+    
+    this._log(pnl >= 0 ? 'trade' : 'loss', `Closed: ${pnl >= 0 ? '+' : ''}$${pnl.toFixed(2)}`);
+    
+    this.callbacks.onTrade?.({ pnl, reason });
+    this.position = null;
+    
+    // Check targets
+    if (this.stats.pnl >= this.config.dailyTarget) {
+      this._log('success', `TARGET! +$${this.stats.pnl.toFixed(2)}`);
+      await this.stop('target');
+    } else if (this.stats.pnl <= -this.config.maxRisk) {
+      this._log('error', `MAX RISK! -$${Math.abs(this.stats.pnl).toFixed(2)}`);
+      await this.stop('risk');
+    }
+  }
+
+  async _order(api, accountId, contractId, side, qty) {
+    try {
+      return await api.placeMarketOrder(accountId, contractId, side, qty, this.lastPrice);
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  async _close(api, accountId, contractId) {
+    try {
+      if (api.closePosition) {
+        return await api.closePosition(accountId, contractId);
+      }
+      // Rithmic: place opposite order
+      const closeSide = this.position.side === 'long' ? 'sell' : 'buy';
+      const qty = api === this.leadApi ? this.position.leadQty : this.position.followerQty;
+      return await api.placeMarketOrder(accountId, contractId, closeSide, qty);
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  // NO LOCAL P&L CALCULATION
+  // P&L comes from API: PNL_PLANT (Rithmic) or /api/Position (ProjectX)
+
+  _rithmicSymbol(sym) {
+    if (/^[A-Z]{2,4}[FGHJKMNQUVXZ]\d{1,2}$/.test(sym)) return sym;
+    const bases = ['MNQ', 'NQ', 'MES', 'ES', 'MYM', 'YM'];
+    let base = 'MNQ';
+    for (const b of bases) {
+      if (sym.toUpperCase().includes(b)) { base = b; break; }
+    }
+    // Use new module to get front month - returns full symbol directly
+    return getFM(base);
+  }
+  
+  /**
+   * Create a trading API wrapper for Rithmic adapter
+   */
+  _createRithmicTradingWrapper(adapter, symbolInput) {
+    const symbol = this._rithmicSymbol(symbolInput);
+    
+    return {
+      async placeMarketOrder(accountId, contractId, side, quantity) {
+        try {
+          const result = await adapter.placeMarketOrder(accountId, symbol, side, quantity, 'CME');
+          return { success: true, orderId: result.orderId };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+      
+      async closePosition(accountId, contractId) {
+        try {
+          await adapter.closePosition(accountId, symbol, 'CME');
+          return { success: true };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+      
+      disconnect() {
+        // Handled by adapter cleanup in stop()
+      }
+    };
+  }
+
+  async stop(reason = 'manual') {
+    if (!this.running) return;
+    this.running = false;
+    
+    this._log('info', `Stopping: ${reason}`);
+    
+    // Close positions
+    if (this.position) {
+      await this._closeBoth(reason);
+    }
+    
+    // Cleanup market data
+    if (this.marketData?.disconnect) await this.marketData.disconnect();
+    
+    // Cleanup Rithmic adapters
+    if (this.leadN1) {
+      await this.leadN1.disconnect();
+      this.leadN1 = null;
+    }
+    if (this.followerN1) {
+      await this.followerN1.disconnect();
+      this.followerN1 = null;
+    }
+    
+    // Cleanup ProjectX APIs
+    if (this.leadApi?.disconnect && !this.leadN1) this.leadApi.disconnect();
+    if (this.followerApi?.disconnect && !this.followerN1) this.followerApi.disconnect();
+    
+    this._log('info', `Final P&L: $${this.stats.pnl.toFixed(2)}`);
+    this.emit('stopped', { reason, stats: this.stats });
+  }
+
+  _log(type, message) {
+    console.log(`[COPY] [${type.toUpperCase()}] ${message}`);
+    this.callbacks.onLog?.({ type, message });
+  }
+}
+
+module.exports = { C2 };