hedgequantx 2.6.162 → 2.7.0

package/src/lib/n/r4.js

@@ -0,0 +1,401 @@
+/**
+ * Rithmic Market Data Feed
+ * Handles real-time quotes and trades from TICKER_PLANT
+ */
+
+const EventEmitter = require('events');
+const { RithmicConnection } = require('./r2');
+const { TEMPLATE_IDS, INFRA_TYPES, getCurrentFrontMonth } = require('./r7');
+
+class RithmicMarketData extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.connection = null;
+    this.config = null;
+    this.subscriptions = new Map(); // symbol -> { exchange, active }
+    
+    // Current market data
+    this.quotes = new Map(); // symbol -> { bid, ask, bidSize, askSize, timestamp }
+    this.trades = new Map(); // symbol -> last trade
+    this.lastPrices = new Map(); // symbol -> last price
+    
+    // Stats
+    this.quoteCount = 0;
+    this.tradeCount = 0;
+    
+    // Options
+    this.debug = options.debug || false;
+  }
+
+  /**
+   * Connect to Rithmic TICKER_PLANT
+   * @param {Object} credentials - { userId, password, systemName, gateway }
+   */
+  async connect(credentials) {
+    this.config = credentials;
+    
+    this.connection = new RithmicConnection({
+      debug: this.debug,
+      maxReconnectAttempts: 5
+    });
+    
+    // Forward connection events
+    this.connection.on('loggedIn', (data) => {
+      this.emit('connected', data);
+      
+      // Resubscribe to all symbols after reconnect
+      for (const [symbol, sub] of this.subscriptions) {
+        if (sub.active) {
+          this._sendSubscribe(symbol, sub.exchange);
+        }
+      }
+    });
+    
+    this.connection.on('error', (error) => {
+      this.emit('error', error);
+    });
+    
+    this.connection.on('disconnected', (data) => {
+      this.emit('disconnected', data);
+    });
+    
+    // Handle market data messages
+    this.connection.on('LastTrade', (trade) => this._handleTrade(trade));
+    this.connection.on('BestBidOffer', (quote) => this._handleQuote(quote));
+    
+    // Connect
+    await this.connection.connect({
+      userId: credentials.userId,
+      password: credentials.password,
+      systemName: credentials.systemName,
+      gateway: credentials.gateway,
+      infraType: INFRA_TYPES.TICKER_PLANT
+    });
+    
+    return true;
+  }
+
+  /**
+   * Subscribe to market data for a symbol
+   * @param {string} symbol - Rithmic symbol (e.g., 'MNQH5')
+   * @param {string} exchange - Exchange (e.g., 'CME')
+   */
+  async subscribe(symbol, exchange = 'CME') {
+    if (!this.connection || !this.connection.isReady) {
+      throw new Error('Not connected');
+    }
+    
+    // Store subscription
+    this.subscriptions.set(symbol, { exchange, active: true });
+    
+    // Send subscribe request
+    return this._sendSubscribe(symbol, exchange);
+  }
+
+  /**
+   * Internal subscribe
+   */
+  _sendSubscribe(symbol, exchange) {
+    try {
+      this.connection.send('RequestMarketDataUpdate', {
+        templateId: TEMPLATE_IDS.REQUEST_MARKET_DATA_UPDATE,
+        symbol: symbol,
+        exchange: exchange,
+        request: 1, // Subscribe
+        updateBits: 3 // LAST_TRADE (1) + BBO (2)
+      });
+      this.emit('subscribed', { symbol, exchange });
+      return true;
+      
+    } catch (error) {
+      console.error(`[RITHMIC:MarketData] Subscribe error:`, error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Unsubscribe from market data
+   */
+  async unsubscribe(symbol, exchange = 'CME') {
+    if (!this.connection || !this.connection.isReady) {
+      return false;
+    }
+    
+    const sub = this.subscriptions.get(symbol);
+    if (sub) {
+      sub.active = false;
+    }
+    
+    try {
+      this.connection.send('RequestMarketDataUpdate', {
+        templateId: TEMPLATE_IDS.REQUEST_MARKET_DATA_UPDATE,
+        symbol: symbol,
+        exchange: exchange,
+        request: 2 // Unsubscribe
+      });
+      
+      this.subscriptions.delete(symbol);
+      this.emit('unsubscribed', { symbol, exchange });
+      return true;
+      
+    } catch (error) {
+      console.error(`[RITHMIC:MarketData] Unsubscribe error:`, error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Unsubscribe from all symbols
+   */
+  async unsubscribeAll() {
+    for (const [symbol, sub] of this.subscriptions) {
+      await this.unsubscribe(symbol, sub.exchange);
+    }
+  }
+
+  /**
+   * Handle trade data
+   */
+  _handleTrade(trade) {
+    this.tradeCount++;
+    
+    const symbol = trade.symbol;
+    const price = trade.tradePrice || 0;
+    const size = trade.tradeSize || 1;
+    
+    // Determine side from aggressor field
+    // aggressor: 1 = BUY (buyer aggressor), 2 = SELL (seller aggressor)
+    let side = 'unknown';
+    if (trade.aggressor === 1) side = 'buy';
+    else if (trade.aggressor === 2) side = 'sell';
+    
+    if (price <= 0) return;
+    
+    // Update last price
+    this.lastPrices.set(symbol, price);
+    
+    // Store trade
+    const tradeData = {
+      type: 'trade',
+      symbol: symbol,
+      exchange: trade.exchange || 'CME',
+      price: price,
+      size: size,
+      side: side,
+      volume: size,
+      timestamp: Date.now(),
+      ssboe: trade.ssboe,
+      usecs: trade.usecs
+    };
+    
+    this.trades.set(symbol, tradeData);
+    
+
+    
+    // Emit events
+    this.emit('trade', tradeData);
+    
+    // Also emit tick for compatibility
+    const quote = this.quotes.get(symbol) || {};
+    this.emit('tick', {
+      symbol: symbol,
+      price: price,
+      bid: quote.bid || 0,
+      ask: quote.ask || 0,
+      spread: (quote.ask || 0) - (quote.bid || 0),
+      volume: size,
+      side: side,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * Handle quote data (BBO)
+   */
+  _handleQuote(quote) {
+    this.quoteCount++;
+    
+    const symbol = quote.symbol;
+    const bid = quote.bidPrice || 0;
+    const ask = quote.askPrice || 0;
+    const bidSize = quote.bidSize || 0;
+    const askSize = quote.askSize || 0;
+    
+    // Store quote
+    const quoteData = {
+      type: 'quote',
+      symbol: symbol,
+      exchange: quote.exchange || 'CME',
+      bid: bid,
+      ask: ask,
+      bidSize: bidSize,
+      askSize: askSize,
+      spread: ask > 0 && bid > 0 ? ask - bid : 0,
+      mid: bid > 0 && ask > 0 ? (bid + ask) / 2 : 0,
+      timestamp: Date.now(),
+      ssboe: quote.ssboe,
+      usecs: quote.usecs
+    };
+    
+    // Update stored quote
+    this.quotes.set(symbol, quoteData);
+    
+    // Update last price if we don't have one
+    if (!this.lastPrices.has(symbol) && quoteData.mid > 0) {
+      this.lastPrices.set(symbol, quoteData.mid);
+    }
+    
+
+    
+    // Emit events
+    this.emit('quote', quoteData);
+    
+    // Also emit tick for compatibility
+    const lastPrice = this.lastPrices.get(symbol) || quoteData.mid;
+    this.emit('tick', {
+      symbol: symbol,
+      price: lastPrice,
+      bid: bid,
+      ask: ask,
+      spread: quoteData.spread,
+      bidSize: bidSize,
+      askSize: askSize,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * Get last price for symbol
+   */
+  getLastPrice(symbol) {
+    return this.lastPrices.get(symbol) || 0;
+  }
+
+  /**
+   * Get current quote for symbol
+   */
+  getQuote(symbol) {
+    return this.quotes.get(symbol) || null;
+  }
+
+  /**
+   * Get last trade for symbol
+   */
+  getLastTrade(symbol) {
+    return this.trades.get(symbol) || null;
+  }
+
+  /**
+   * Get all subscribed symbols
+   */
+  getSubscriptions() {
+    return Array.from(this.subscriptions.entries()).map(([symbol, sub]) => ({
+      symbol,
+      exchange: sub.exchange,
+      active: sub.active
+    }));
+  }
+
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.connection && this.connection.isReady;
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    await this.unsubscribeAll();
+    
+    if (this.connection) {
+      await this.connection.disconnect();
+      this.connection = null;
+    }
+    
+    this.subscriptions.clear();
+    this.quotes.clear();
+    this.trades.clear();
+    this.lastPrices.clear();
+  }
+
+  /**
+   * Get stats
+   */
+  getStats() {
+    return {
+      quoteCount: this.quoteCount,
+      tradeCount: this.tradeCount,
+      subscriptions: this.subscriptions.size,
+      connected: this.isConnected
+    };
+  }
+
+  /**
+   * Get front month contract for a base symbol
+   * @param {string} baseSymbol - Base symbol (e.g., 'MNQ', 'ES')
+   * @param {string} exchange - Exchange (e.g., 'CME')
+   * @returns {Promise<string>} Full contract symbol (e.g., 'MNQH6')
+   */
+  async getFrontMonthContract(baseSymbol, exchange = 'CME') {
+    if (!this.connection || !this.connection.isReady) {
+      throw new Error('Not connected');
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Front month request timeout'));
+      }, 10000);
+
+      // Listen for response
+      const handler = (msg) => {
+        if (msg.templateId === 114) { // ResponseFrontMonthContract
+          clearTimeout(timeout);
+          this.connection.removeListener('message', handler);
+          
+          if (msg.rpCode && msg.rpCode[0] === '0') {
+            resolve(msg.symbol || msg.tradingSymbol);
+          } else {
+            reject(new Error(`Front month failed: ${msg.rpCode?.join(', ')}`));
+          }
+        }
+      };
+
+      this.connection.on('message', handler);
+
+      // Send request (Template ID 113)
+      try {
+        this.connection.send('RequestFrontMonthContract', {
+          templateId: 113,
+          symbol: baseSymbol,
+          exchange: exchange
+        });
+      } catch (error) {
+        clearTimeout(timeout);
+        this.connection.removeListener('message', handler);
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Subscribe to a base symbol by auto-detecting front month
+   * @param {string} baseSymbol - Base symbol (e.g., 'MNQ', 'ES')
+   * @param {string} exchange - Exchange (e.g., 'CME')
+   */
+  async subscribeByBaseSymbol(baseSymbol, exchange = 'CME') {
+    try {
+      // Try to get front month from Rithmic
+      const fullSymbol = await this.getFrontMonthContract(baseSymbol, exchange);
+      return this.subscribe(fullSymbol, exchange);
+    } catch (error) {
+      // Fallback to calculated front month
+      const calculated = getCurrentFrontMonth(baseSymbol);
+      return this.subscribe(calculated, exchange);
+    }
+  }
+}
+
+module.exports = { RithmicMarketData };