hedgequantx 2.6.162 → 2.7.0

package/src/lib/m/s2.js

@@ -0,0 +1,34 @@
+/**
+ * M2 Module
+ */
+const EventEmitter = require('events');
+const DP = { et: 0.6, vrng: [0.8, 2.5], cth: 0.45, mxl: 3, stk: 6, tgt: 8, ctr: 1, roc: true, mht: 10000, cd: 30000 };
+
+class S2 extends EventEmitter {
+  constructor(cfg = {}) { super(); this.p = { ...DP, ...cfg }; this.ts = cfg.tickSize || 0.25; this.cid = null; this.bh = []; this.cd = { v: 0, cv: 0, tpv: 0, sd: 0 }; this.of = { bd: 0, ad: 0, lt: null }; this.st = { s: 0, t: 0, w: 0, l: 0, pnl: 0 }; this.lst = 0; this.lss = 0; }
+  // tickSize for tick calculations, P&L comes from API
+  initialize(c, ts = 0.25) { this.cid = c; this.ts = ts; this.bh = []; this.cd = { v: 0, cv: 0, tpv: 0, sd: 0 }; this.of = { bd: 0, ad: 0, lt: null }; }
+  processTick(t) { const { price, volume, side, timestamp } = t; this.bh.push({ p: price, v: volume || 1, s: side, t: timestamp || Date.now() }); if (this.bh.length > 500) this.bh.shift(); const tp = price; this.cd.cv += volume || 1; this.cd.tpv += tp * (volume || 1); if (this.cd.cv > 0) this.cd.v = this.cd.tpv / this.cd.cv; if (side === 'buy') this.of.bd += volume || 1; else if (side === 'sell') this.of.ad += volume || 1; this.of.lt = side; }
+  onTick(t) { return this.processTick(t); }
+  onTrade(t) { this.processTick({ price: t.price, volume: t.size || t.volume || 1, side: t.side, timestamp: t.timestamp }); }
+  generateSignal(cp) { if (this.bh.length < 50) return null; if (Date.now() - this.lst < this.p.cd) return null; if (this.lss >= this.p.mxl) return null; const v = this.cd.v; if (v <= 0) return null; const sd = this.csd(); if (sd <= 0) return null; const dv = (cp - v) / sd; const ad = Math.abs(dv); if (ad < this.p.vrng[0] || ad > this.p.vrng[1]) return null; let dir = null; if (dv < -this.p.et) dir = 'long'; else if (dv > this.p.et) dir = 'short'; if (!dir) return null; if (this.p.roc) { const ofc = this.cof(dir); if (!ofc) return null; } const cf = Math.min(1.0, 0.5 + ad * 0.15); if (cf < this.p.cth) return null; this.lst = Date.now(); this.st.s++; return { direction: dir, confidence: cf, zScore: dv, stopTicks: this.p.stk, targetTicks: this.p.tgt }; }
+  csd() { if (this.bh.length < 20) return 0; const ps = this.bh.slice(-100).map(b => b.p); const m = ps.reduce((a, b) => a + b, 0) / ps.length; const va = ps.reduce((s, p) => s + Math.pow(p - m, 2), 0) / ps.length; return Math.sqrt(va); }
+  cof(dir) { const tb = this.of.bd + this.of.ad; if (tb < 10) return true; const br = this.of.bd / tb; if (dir === 'long' && br > 0.45) return true; if (dir === 'short' && br < 0.55) return true; if (this.of.lt === 'buy' && dir === 'long') return true; if (this.of.lt === 'sell' && dir === 'short') return true; return false; }
+  recordTradeResult(pnl) { this.st.t++; this.st.pnl += pnl; if (pnl > 0) { this.st.w++; this.lss = 0; } else { this.st.l++; this.lss++; } }
+  getStats() { return this.st; }
+  reset() { this.bh = []; this.cd = { v: 0, cv: 0, tpv: 0, sd: 0 }; this.of = { bd: 0, ad: 0, lt: null }; this.lss = 0; }
+}
+
+class M2 extends EventEmitter {
+  constructor(cfg = {}) { super(); this.s = new S2(cfg); }
+  initialize(c, ts, tv) { this.s.initialize(c, ts, tv); }
+  processTick(t) { this.s.processTick(t); }
+  onTick(t) { this.s.onTick(t); const sig = this.s.generateSignal(t.price); if (sig) this.emit('signal', { side: sig.direction === 'long' ? 'buy' : 'sell', action: 'open', ...sig }); }
+  onTrade(t) { this.s.onTrade(t); }
+  generateSignal(p) { return this.s.generateSignal(p); }
+  recordTradeResult(p) { this.s.recordTradeResult(p); }
+  getStats() { return this.s.getStats(); }
+  reset() { this.s.reset(); this.emit('log', { type: 'info', message: 'Reset' }); }
+}
+
+module.exports = { S2, M2, DP };

package/src/lib/n/r1.js

@@ -0,0 +1,454 @@
+/**
+ * Rithmic Adapter - Main Entry Point
+ * Complete Rithmic integration for CLI
+ * 
+ * Features:
+ * - Market Data (TICKER_PLANT): Real-time quotes and trades
+ * - Trading (ORDER_PLANT): Full order management
+ * - P&L (PNL_PLANT): Real-time account and position P&L
+ * - Connection Pool: Optimized connection reuse
+ * 
+ * Supported PropFirms:
+ * - Apex Trader Funding
+ * - TopstepTrader (Rithmic)
+ * - Bulenox (Rithmic)
+ * - MES Capital
+ * - Earn2Trade
+ * - TradeFundrr
+ * - The Trading Pit
+ * - Funded Futures Network
+ * - PropShop Trader
+ * - 4PropTrader
+ * - DayTraders.com
+ * - 10X Futures
+ * - Lucid Trading
+ * - Thrive Trading
+ * - Legends Trading
+ * - TradeSea
+ * - UProfit
+ * - FastTrack Trading
+ * - My Funded Futures
+ */
+
+const EventEmitter = require('events');
+
+// Core modules
+const { RithmicConnection } = require('./r2');
+const { RithmicMarketData } = require('./r4');
+const { RithmicTrading } = require('./r3');
+const { RithmicPnL } = require('./r5');
+const { RithmicConnectionPool, rithmicPool } = require('./r6');
+
+// Constants
+const constants = require('./r7');
+const {
+  RITHMIC_GATEWAYS,
+  RITHMIC_PROPFIRMS,
+  TEMPLATE_IDS,
+  INFRA_TYPES,
+  ORDER_TYPES,
+  NOTIFY_TYPES,
+  EXCHANGES,
+  getPropFirmConfig,
+  isRithmicPropFirm,
+  getSupportedPropFirms,
+  buildRithmicSymbol,
+  getCurrentFrontMonth
+} = constants;
+
+/**
+ * RithmicAdapter - High-level adapter that manages all connections
+ */
+class RithmicAdapter extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.marketData = null;
+    this.trading = null;
+    this.pnl = null;
+    
+    this.credentials = null;
+    this.propfirmConfig = null;
+    
+    this.debug = options.debug || false;
+    this.usePool = options.usePool !== false; // Default true
+  }
+
+  /**
+   * Connect to all Rithmic plants
+   * @param {Object} credentials
+   * @param {string} credentials.userId - Rithmic username
+   * @param {string} credentials.password - Rithmic password
+   * @param {string} credentials.propfirm - PropFirm name (e.g., 'apex', 'topsteptrader')
+   * @param {Object} options
+   * @param {boolean} options.marketData - Connect to market data (default: true)
+   * @param {boolean} options.trading - Connect to trading (default: true)
+   * @param {boolean} options.pnl - Connect to P&L (default: true)
+   */
+  async connect(credentials, options = {}) {
+    const {
+      marketData = true,
+      trading = true,
+      pnl = true
+    } = options;
+    
+    this.credentials = credentials;
+    this.propfirmConfig = getPropFirmConfig(credentials.propfirm);
+    
+    if (!this.propfirmConfig) {
+      throw new Error(`Unknown PropFirm: ${credentials.propfirm}. Use getSupportedPropFirms() to see available options.`);
+    }
+    
+    const fullCredentials = {
+      userId: credentials.userId,
+      password: credentials.password,
+      propfirm: credentials.propfirm,
+      systemName: this.propfirmConfig.systemName,
+      gateway: this.propfirmConfig.gateway
+    };
+    
+    const connectPromises = [];
+    
+    // Connect to market data
+    if (marketData) {
+      if (this.usePool) {
+        connectPromises.push(
+          rithmicPool.getMarketData(fullCredentials).then(client => {
+            this.marketData = client;
+            this._forwardEvents(client, 'marketData');
+          })
+        );
+      } else {
+        this.marketData = new RithmicMarketData({ debug: this.debug });
+        connectPromises.push(
+          this.marketData.connect(fullCredentials).then(() => {
+            this._forwardEvents(this.marketData, 'marketData');
+          })
+        );
+      }
+    }
+    
+    // Connect to trading
+    if (trading) {
+      if (this.usePool) {
+        connectPromises.push(
+          rithmicPool.getTrading(fullCredentials).then(client => {
+            this.trading = client;
+            this._forwardEvents(client, 'trading');
+          })
+        );
+      } else {
+        this.trading = new RithmicTrading({ debug: this.debug });
+        connectPromises.push(
+          this.trading.connect(fullCredentials).then(() => {
+            this._forwardEvents(this.trading, 'trading');
+          })
+        );
+      }
+    }
+    
+    // Connect to P&L
+    if (pnl) {
+      if (this.usePool) {
+        connectPromises.push(
+          rithmicPool.getPnL(fullCredentials).then(client => {
+            this.pnl = client;
+            this._forwardEvents(client, 'pnl');
+          })
+        );
+      } else {
+        this.pnl = new RithmicPnL({ debug: this.debug });
+        connectPromises.push(
+          this.pnl.connect(fullCredentials).then(() => {
+            this._forwardEvents(this.pnl, 'pnl');
+          })
+        );
+      }
+    }
+    
+    // Wait for all connections
+    await Promise.all(connectPromises);
+    
+    this.emit('connected', {
+      propfirm: this.propfirmConfig.displayName,
+      marketData: !!this.marketData,
+      trading: !!this.trading,
+      pnl: !!this.pnl
+    });
+    
+    return true;
+  }
+
+  /**
+   * Forward events from sub-modules
+   */
+  _forwardEvents(module, prefix) {
+    const events = ['tick', 'quote', 'trade', 'order', 'fill', 'reject', 'cancel', 'position', 'accountPnL', 'instrumentPnL', 'error'];
+    
+    for (const event of events) {
+      module.on(event, (data) => {
+        this.emit(`${prefix}:${event}`, data);
+        this.emit(event, data); // Also emit without prefix
+      });
+    }
+  }
+
+  // ===========================================================================
+  // MARKET DATA
+  // ===========================================================================
+
+  /**
+   * Subscribe to market data
+   * @param {string} symbol - Rithmic symbol (e.g., 'MNQH5')
+   * @param {string} exchange - Exchange (default: 'CME')
+   */
+  async subscribe(symbol, exchange = 'CME') {
+    if (!this.marketData) {
+      throw new Error('Market data not connected');
+    }
+    return this.marketData.subscribe(symbol, exchange);
+  }
+
+  /**
+   * Unsubscribe from market data
+   */
+  async unsubscribe(symbol, exchange = 'CME') {
+    if (!this.marketData) return false;
+    return this.marketData.unsubscribe(symbol, exchange);
+  }
+
+  /**
+   * Get last price
+   */
+  getLastPrice(symbol) {
+    if (!this.marketData) return 0;
+    return this.marketData.getLastPrice(symbol);
+  }
+
+  /**
+   * Get current quote
+   */
+  getQuote(symbol) {
+    if (!this.marketData) return null;
+    return this.marketData.getQuote(symbol);
+  }
+
+  // ===========================================================================
+  // TRADING
+  // ===========================================================================
+
+  /**
+   * Place a market order
+   * @param {string} accountId - Account ID
+   * @param {string} symbol - Symbol (e.g., 'MNQH6')
+   * @param {string} side - 'buy' or 'sell'
+   * @param {number} quantity - Number of contracts
+   * @param {string} exchange - Exchange (default: 'CME')
+   */
+  async placeMarketOrder(accountId, symbol, side, quantity, exchange = 'CME') {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    // trading.placeMarketOrder expects: (accountId, symbol, exchange, side, quantity)
+    return this.trading.placeMarketOrder(accountId, symbol, exchange, side, quantity);
+  }
+
+  /**
+   * Place a limit order
+   */
+  async placeLimitOrder(accountId, symbol, side, quantity, price, exchange = 'CME') {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    // trading.placeLimitOrder expects: (accountId, symbol, exchange, side, quantity, price)
+    return this.trading.placeLimitOrder(accountId, symbol, exchange, side, quantity, price);
+  }
+
+  /**
+   * Place a stop market order
+   */
+  async placeStopMarketOrder(accountId, symbol, side, quantity, stopPrice, exchange = 'CME') {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    return this.trading.placeStopMarketOrder(accountId, symbol, exchange, side, quantity, stopPrice);
+  }
+
+  /**
+   * Place a stop limit order
+   */
+  async placeStopLimitOrder(accountId, symbol, side, quantity, stopPrice, limitPrice, exchange = 'CME') {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    return this.trading.placeStopLimitOrder(accountId, symbol, exchange, side, quantity, stopPrice, limitPrice);
+  }
+
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(basketId) {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    return this.trading.cancelOrder(basketId);
+  }
+
+  /**
+   * Cancel all orders
+   */
+  async cancelAllOrders(accountId) {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    return this.trading.cancelAllOrders(accountId);
+  }
+
+  /**
+   * Close a position
+   */
+  async closePosition(accountId, symbol, exchange = 'CME') {
+    if (!this.trading) {
+      throw new Error('Trading not connected');
+    }
+    return this.trading.closePosition(accountId, symbol, exchange);
+  }
+
+  /**
+   * Get open orders
+   */
+  getOpenOrders() {
+    if (!this.trading) return [];
+    return this.trading.getOpenOrders();
+  }
+
+  /**
+   * Get accounts
+   */
+  getAccounts() {
+    if (!this.trading) return [];
+    return this.trading.getAccounts();
+  }
+
+  // ===========================================================================
+  // P&L
+  // ===========================================================================
+
+  /**
+   * Subscribe to P&L updates
+   */
+  async subscribePnL(accountId) {
+    if (!this.pnl) {
+      throw new Error('P&L not connected');
+    }
+    return this.pnl.subscribe(accountId);
+  }
+
+  /**
+   * Get account P&L
+   */
+  getAccountPnL(accountId) {
+    if (!this.pnl) return null;
+    return this.pnl.getAccountPnL(accountId);
+  }
+
+  /**
+   * Get instrument P&L
+   */
+  getInstrumentPnL(accountId, symbol) {
+    if (!this.pnl) return null;
+    return this.pnl.getInstrumentPnL(accountId, symbol);
+  }
+
+  /**
+   * Get all positions
+   */
+  getPositions(accountId) {
+    if (!this.pnl) return [];
+    return this.pnl.getPositions(accountId);
+  }
+
+  // ===========================================================================
+  // STATUS
+  // ===========================================================================
+
+  /**
+   * Check if fully connected
+   */
+  get isConnected() {
+    return (
+      (!this.marketData || this.marketData.isConnected) &&
+      (!this.trading || this.trading.isConnected) &&
+      (!this.pnl || this.pnl.isConnected)
+    );
+  }
+
+  /**
+   * Get connection status
+   */
+  getStatus() {
+    return {
+      propfirm: this.propfirmConfig?.displayName || 'Not connected',
+      marketData: this.marketData?.isConnected || false,
+      trading: this.trading?.isConnected || false,
+      pnl: this.pnl?.isConnected || false,
+      pool: this.usePool ? rithmicPool.getStats() : null
+    };
+  }
+
+  /**
+   * Disconnect all
+   */
+  async disconnect() {
+    if (this.usePool && this.credentials) {
+      // Release to pool
+      rithmicPool.release(
+        this.credentials.userId,
+        this.propfirmConfig?.systemName || 'unknown'
+      );
+    } else {
+      // Disconnect directly
+      if (this.marketData) await this.marketData.disconnect();
+      if (this.trading) await this.trading.disconnect();
+      if (this.pnl) await this.pnl.disconnect();
+    }
+    
+    this.marketData = null;
+    this.trading = null;
+    this.pnl = null;
+    
+    this.emit('disconnected');
+  }
+}
+
+// Export everything
+module.exports = {
+  // Main adapter
+  RithmicAdapter,
+  
+  // Individual modules
+  RithmicConnection,
+  RithmicMarketData,
+  RithmicTrading,
+  RithmicPnL,
+  RithmicConnectionPool,
+  
+  // Singleton pool
+  rithmicPool,
+  
+  // Constants
+  RITHMIC_GATEWAYS,
+  RITHMIC_PROPFIRMS,
+  TEMPLATE_IDS,
+  INFRA_TYPES,
+  ORDER_TYPES,
+  NOTIFY_TYPES,
+  EXCHANGES,
+  
+  // Helpers
+  getPropFirmConfig,
+  isRithmicPropFirm,
+  getSupportedPropFirms,
+  buildRithmicSymbol,
+  getCurrentFrontMonth
+};