hedgequantx 2.7.14 → 2.7.16

package/src/lib/n/r2.js

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