hedgequantx 2.6.162 → 2.7.0

package/src/lib/n/r2.js

@@ -0,0 +1,514 @@
+/**
+ * Rithmic Connection Manager
+ * Handles WebSocket connection, protobuf encoding/decoding, and heartbeat
+ */
+
+const EventEmitter = require('events');
+const WebSocket = require('ws');
+const protobuf = require('protobufjs');
+const path = require('path');
+const fs = require('fs');
+
+const { TEMPLATE_IDS, INFRA_TYPES, RITHMIC_GATEWAYS } = require('./r7');
+
+// Proto path
+const PROTO_PATH = path.join(__dirname, '../../../protos/rithmic');
+
+class RithmicConnection extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.ws = null;
+    this.isConnected = false;
+    this.isLoggedIn = false;
+    this.infraType = null;
+    this.config = null;
+    
+    // Login info from server
+    this.fcmId = null;
+    this.ibId = null;
+    this.uniqueUserId = null;
+    this.heartbeatInterval = 30; // seconds
+    
+    // Protobuf message types (loaded dynamically)
+    this.protoRoot = null;
+    this.messageTypes = {};
+    
+    // Heartbeat
+    this._heartbeatTimer = null;
+    this._lastHeartbeat = 0;
+    
+    // Reconnection
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
+    this.reconnectDelay = options.reconnectDelay || 2000;
+    this._intentionalDisconnect = false;
+    
+    // Message handling
+    this._messageHandlers = new Map();
+    this._pendingRequests = new Map();
+    this._requestId = 0;
+    
+    // Debug
+    this.debug = options.debug || false;
+  }
+
+  /**
+   * Load all protobuf definitions
+   */
+  async _loadProtos() {
+    if (this.protoRoot) return;
+    
+    try {
+      // Get all proto files
+      const protoFiles = fs.readdirSync(PROTO_PATH)
+        .filter(f => f.endsWith('.proto'))
+        .map(f => path.join(PROTO_PATH, f));
+      
+      if (protoFiles.length === 0) {
+        throw new Error('No proto files found in ' + PROTO_PATH);
+      }
+      
+      this.protoRoot = await protobuf.load(protoFiles);
+      
+      // Load all message types
+      const messageNames = [
+        'RequestLogin', 'ResponseLogin',
+        'RequestLogout', 'ResponseLogout',
+        'RequestHeartbeat', 'ResponseHeartbeat',
+        'RequestMarketDataUpdate', 'ResponseMarketDataUpdate',
+        'LastTrade', 'BestBidOffer',
+        'RequestNewOrder', 'ResponseNewOrder',
+        'RequestCancelAllOrders',
+        'RequestSubscribeForOrderUpdates', 'ResponseSubscribeForOrderUpdates',
+        'ExchangeOrderNotification', 'RithmicOrderNotification',
+        'RequestTradeRoutes', 'ResponseTradeRoutes',
+        'RequestAccountList', 'ResponseAccountList',
+        'RequestPnLPositionSnapshot', 'ResponsePnLPositionSnapshot',
+        'RequestPnLPositionUpdates', 'ResponsePnLPositionUpdates',
+        'AccountPnLPositionUpdate', 'InstrumentPnLPositionUpdate',
+        'RequestShowOrders', 'ResponseShowOrders',
+        'RequestLoginInfo', 'ResponseLoginInfo'
+      ];
+      
+      for (const name of messageNames) {
+        try {
+          this.messageTypes[name] = this.protoRoot.lookupType(`rti.${name}`);
+        } catch (e) {
+          // Some message types may not exist
+          if (this.debug) {
+            // Proto type not found - skip silently
+          }
+        }
+      }
+      
+
+      
+    } catch (error) {
+      console.error('[RITHMIC] Failed to load protos:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Connect to Rithmic gateway
+   * @param {Object} config - Connection config
+   * @param {string} config.userId - Rithmic username
+   * @param {string} config.password - Rithmic password
+   * @param {string} config.systemName - PropFirm system name
+   * @param {string} config.gateway - Gateway URL
+   * @param {number} config.infraType - Plant type (TICKER_PLANT, ORDER_PLANT, etc.)
+   */
+  async connect(config) {
+    await this._loadProtos();
+    
+    this.config = config;
+    this.infraType = config.infraType || INFRA_TYPES.TICKER_PLANT;
+    
+    const gatewayUrl = config.gateway || RITHMIC_GATEWAYS.CHICAGO;
+    const infraName = this._getInfraName(this.infraType);
+    
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(gatewayUrl, {
+        rejectUnauthorized: false,
+        handshakeTimeout: 15000
+      });
+      
+      const timeout = setTimeout(() => {
+        this.ws.close();
+        reject(new Error('Connection timeout'));
+      }, 20000);
+      
+      this.ws.on('open', () => {
+        this.isConnected = true;
+        this._sendLogin();
+      });
+      
+      this.ws.on('message', (data) => {
+        this._handleMessage(data, (success, error, loginData) => {
+          if (success !== undefined) {
+            clearTimeout(timeout);
+            if (success) {
+              this.isLoggedIn = true;
+              this.reconnectAttempts = 0;
+              this._startHeartbeat();
+              this.emit('loggedIn', loginData);
+              resolve(loginData);
+            } else {
+              this.emit('loginFailed', error);
+              reject(new Error(error || 'Login failed'));
+            }
+          }
+        });
+      });
+      
+      this.ws.on('error', (error) => {
+        console.error(`[RITHMIC:${infraName}] WebSocket error:`, error.message);
+        this.emit('error', error);
+        clearTimeout(timeout);
+        if (!this.isLoggedIn) {
+          reject(error);
+        }
+      });
+      
+      this.ws.on('close', (code, reason) => {
+        const reasonStr = reason ? reason.toString() : 'unknown';
+        this.isConnected = false;
+        this.isLoggedIn = false;
+        this._stopHeartbeat();
+        this.emit('disconnected', { code, reason: reasonStr });
+        
+        // Auto-reconnect if not intentional
+        if (!this._intentionalDisconnect) {
+          this._attemptReconnect();
+        }
+      });
+    });
+  }
+
+  /**
+   * Send login request
+   */
+  _sendLogin() {
+    const RequestLogin = this.messageTypes.RequestLogin;
+    if (!RequestLogin) {
+      throw new Error('RequestLogin proto not loaded');
+    }
+    
+    const loginRequest = RequestLogin.create({
+      templateId: TEMPLATE_IDS.REQUEST_LOGIN,
+      templateVersion: '3.9',
+      user: this.config.userId,
+      password: this.config.password,
+      appName: 'App',
+      appVersion: '1.0.0',
+      systemName: this.config.systemName,
+      infraType: this.infraType
+    });
+    
+    const buffer = RequestLogin.encode(loginRequest).finish();
+    this.ws.send(buffer);
+    
+    if (this.debug) {
+      console.log(`[RITHMIC] Login sent for ${this.config.userId} on ${this.config.systemName}`);
+    }
+  }
+
+  /**
+   * Handle incoming message
+   */
+  _handleMessage(data, loginCallback) {
+    try {
+      const buffer = new Uint8Array(data);
+      
+      // Try to decode as ResponseLogin first
+      if (loginCallback && !this.isLoggedIn) {
+        try {
+          const ResponseLogin = this.messageTypes.ResponseLogin;
+          if (ResponseLogin) {
+            const response = ResponseLogin.decode(buffer);
+            
+            if (response.templateId === TEMPLATE_IDS.RESPONSE_LOGIN) {
+              const rpCode = Array.isArray(response.rpCode) ? response.rpCode[0] : response.rpCode;
+              
+              if (rpCode === '0') {
+                this.fcmId = response.fcmId;
+                this.ibId = response.ibId;
+                this.uniqueUserId = response.uniqueUserId;
+                if (response.heartbeatInterval) {
+                  this.heartbeatInterval = response.heartbeatInterval;
+                }
+                
+                loginCallback(true, null, { fcmId: this.fcmId, ibId: this.ibId });
+                return;
+              } else {
+                const errorMsg = response.textMsg || `Error code: ${rpCode}`;
+                loginCallback(false, errorMsg);
+                return;
+              }
+            }
+          }
+        } catch (e) {
+          // Not a login response
+        }
+      }
+      
+      // Decode based on template ID (first few bytes contain it)
+      const decoded = this._decodeMessage(buffer);
+      if (decoded) {
+        this._dispatchMessage(decoded);
+      }
+      
+    } catch (error) {
+      if (this.debug) {
+        console.error('[RITHMIC] Message decode error:', error.message);
+      }
+    }
+  }
+
+/**
+    * Decode a protobuf message
+    */
+  _decodeMessage(buffer) {
+    // First check template ID for messages that need manual decoding (large field IDs)
+    const { getTemplateId, decodeAccountPnL, decodeInstrumentPnL } = require('../decoder');
+    const templateId = getTemplateId(Buffer.from(buffer));
+    
+    // Use manual decoder for P&L messages (protobufjs can't handle field IDs > 100000)
+    if (templateId === 450) {
+      const decoded = decodeAccountPnL(Buffer.from(buffer));
+      return { type: 'AccountPnLPositionUpdate', data: decoded };
+    }
+    if (templateId === 451) {
+      const decoded = decodeInstrumentPnL(Buffer.from(buffer));
+      return { type: 'InstrumentPnLPositionUpdate', data: decoded };
+    }
+    
+    // Try different message types based on context
+    const decoders = [
+      { type: 'ResponseHeartbeat', id: TEMPLATE_IDS.RESPONSE_HEARTBEAT },
+      { type: 'LastTrade', id: TEMPLATE_IDS.LAST_TRADE },
+      { type: 'BestBidOffer', id: TEMPLATE_IDS.BEST_BID_OFFER },
+      { type: 'ResponseNewOrder', id: TEMPLATE_IDS.RESPONSE_NEW_ORDER },
+      // RithmicOrderNotification (351) - internal order status updates
+      { type: 'RithmicOrderNotification', id: TEMPLATE_IDS.RITHMIC_ORDER_NOTIFICATION },
+      // ExchangeOrderNotification (352) - exchange order fills/updates  
+      { type: 'ExchangeOrderNotification', id: TEMPLATE_IDS.EXCHANGE_ORDER_NOTIFICATION },
+      { type: 'ResponseTradeRoutes', id: TEMPLATE_IDS.RESPONSE_TRADE_ROUTES },
+      { type: 'ResponseAccountList', id: TEMPLATE_IDS.RESPONSE_ACCOUNT_LIST },
+      { type: 'ResponsePnLPositionUpdates', id: TEMPLATE_IDS.RESPONSE_PNL_POSITION_UPDATES },
+      { type: 'ResponseSubscribeForOrderUpdates', id: TEMPLATE_IDS.RESPONSE_SUBSCRIBE_FOR_ORDER_UPDATES },
+      { type: 'ResponseLoginInfo', id: TEMPLATE_IDS.RESPONSE_LOGIN_INFO },
+      { type: 'ResponseShowOrders', id: TEMPLATE_IDS.RESPONSE_SHOW_ORDERS }
+    ];
+    
+    for (const decoder of decoders) {
+      try {
+        const MessageType = this.messageTypes[decoder.type];
+        if (MessageType) {
+          const decoded = MessageType.decode(buffer);
+          if (decoded.templateId === decoder.id) {
+            return { type: decoder.type, data: decoded };
+          }
+        }
+      } catch (e) {
+        // Not this message type
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Dispatch decoded message to handlers
+   */
+  _dispatchMessage(decoded) {
+    const { type, data } = decoded;
+    
+    // Handle heartbeat silently
+    if (type === 'ResponseHeartbeat') {
+      this._lastHeartbeat = Date.now();
+      return;
+    }
+    
+    // Emit specific event
+    this.emit(type, data);
+    
+    // Also emit generic message event
+    this.emit('message', decoded);
+    
+    // Handle pending requests
+    if (data.userMsg && Array.isArray(data.userMsg)) {
+      for (const msg of data.userMsg) {
+        if (this._pendingRequests.has(msg)) {
+          const { resolve } = this._pendingRequests.get(msg);
+          this._pendingRequests.delete(msg);
+          resolve(data);
+        }
+      }
+    }
+  }
+
+  /**
+   * Send a protobuf message
+   */
+  send(messageType, messageData) {
+    if (!this.isConnected || !this.ws) {
+      throw new Error('Not connected');
+    }
+    
+    const MessageType = this.messageTypes[messageType];
+    if (!MessageType) {
+      throw new Error(`Unknown message type: ${messageType}`);
+    }
+    
+    const message = MessageType.create(messageData);
+    const buffer = MessageType.encode(message).finish();
+    this.ws.send(buffer);
+    
+    return true;
+  }
+
+  /**
+   * Send a request and wait for response
+   */
+  async sendRequest(messageType, messageData, timeoutMs = 10000) {
+    const requestId = `req_${++this._requestId}_${Date.now()}`;
+    
+    // Add request ID to user_msg for tracking
+    messageData.userMsg = [requestId];
+    
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this._pendingRequests.delete(requestId);
+        reject(new Error('Request timeout'));
+      }, timeoutMs);
+      
+      this._pendingRequests.set(requestId, {
+        resolve: (data) => {
+          clearTimeout(timeout);
+          resolve(data);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+      
+      try {
+        this.send(messageType, messageData);
+      } catch (error) {
+        this._pendingRequests.delete(requestId);
+        clearTimeout(timeout);
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Start heartbeat
+   */
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    
+    const intervalMs = (this.heartbeatInterval || 30) * 1000;
+    
+    this._heartbeatTimer = setInterval(() => {
+      if (this.isConnected && this.ws) {
+        try {
+          this.send('RequestHeartbeat', {
+            templateId: TEMPLATE_IDS.REQUEST_HEARTBEAT
+          });
+        } catch (e) {
+          console.error('[RITHMIC] Heartbeat failed:', e.message);
+        }
+      }
+    }, intervalMs);
+  }
+
+  /**
+   * Stop heartbeat
+   */
+  _stopHeartbeat() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+
+  /**
+   * Attempt reconnection
+   */
+  _attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error('[RITHMIC] Max reconnect attempts reached');
+      this.emit('maxReconnectAttempts');
+      return;
+    }
+    
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    const maxDelay = 30000;
+    const actualDelay = Math.min(delay, maxDelay);
+    
+    setTimeout(() => {
+      if (!this._intentionalDisconnect) {
+        this.connect(this.config).catch(err => {
+          console.error('[RITHMIC] Reconnect failed:', err.message);
+        });
+      }
+    }, actualDelay);
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    this._intentionalDisconnect = true;
+    this._stopHeartbeat();
+    
+    if (this.ws) {
+      // Send logout first
+      if (this.isLoggedIn) {
+        try {
+          this.send('RequestLogout', {
+            templateId: TEMPLATE_IDS.REQUEST_LOGOUT
+          });
+          // Give it a moment
+          await new Promise(resolve => setTimeout(resolve, 200));
+        } catch (e) {
+          // Ignore logout errors
+        }
+      }
+      
+      this.ws.close();
+      this.ws = null;
+    }
+    
+    this.isConnected = false;
+    this.isLoggedIn = false;
+  }
+
+  /**
+   * Get infra type name for logging
+   */
+  _getInfraName(infraType) {
+    const names = {
+      [INFRA_TYPES.TICKER_PLANT]: 'TICKER',
+      [INFRA_TYPES.ORDER_PLANT]: 'ORDER',
+      [INFRA_TYPES.HISTORY_PLANT]: 'HISTORY',
+      [INFRA_TYPES.PNL_PLANT]: 'PNL',
+      [INFRA_TYPES.REPOSITORY_PLANT]: 'REPO'
+    };
+    return names[infraType] || 'UNKNOWN';
+  }
+
+  /**
+   * Check if connected and logged in
+   */
+  get isReady() {
+    return this.isConnected && this.isLoggedIn;
+  }
+}
+
+module.exports = { RithmicConnection };