hedgequantx 2.6.163 → 2.7.1

package/src/lib/n/r3.js

@@ -0,0 +1,631 @@
+/**
+ * Rithmic Trading API
+ * Handles order execution via ORDER_PLANT
+ * Supports: Market, Limit, Stop Market, Stop Limit orders
+ */
+
+const EventEmitter = require('events');
+const { RithmicConnection } = require('./r2');
+const { TEMPLATE_IDS, INFRA_TYPES, ORDER_TYPES, NOTIFY_TYPES, RITHMIC_NOTIFY_TYPES } = require('./r7');
+
+class RithmicTrading extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.connection = null;
+    this.config = null;
+    
+    // Login info from ORDER_PLANT
+    this.fcmId = null;
+    this.ibId = null;
+    
+    // Trade routes cache
+    this.tradeRoutes = new Map(); // exchange -> tradeRoute
+    
+    // Accounts cache
+    this.accounts = new Map(); // accountId -> account info
+    
+    // Orders tracking
+    this.pendingOrders = new Map(); // basketId -> { resolve, reject, order }
+    this.openOrders = new Map(); // basketId -> order info
+    this.orderHistory = [];
+    
+    // Positions tracking
+    this.positions = new Map(); // symbol -> position
+    
+    // Order ID counter
+    this._orderIdCounter = 0;
+    
+    // Options
+    this.debug = options.debug || false;
+  }
+
+  /**
+   * Connect to Rithmic ORDER_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('error', (error) => {
+      this.emit('error', error);
+    });
+    
+    this.connection.on('disconnected', (data) => {
+      this.emit('disconnected', data);
+    });
+    
+    // Handle order notifications
+    // Handle both notification types - RithmicOrderNotification (351) and ExchangeOrderNotification (352)
+    this.connection.on('RithmicOrderNotification', (notif) => this._handleOrderNotification(notif));
+    this.connection.on('ExchangeOrderNotification', (notif) => this._handleOrderNotification(notif));
+    this.connection.on('ResponseNewOrder', (resp) => this._handleOrderResponse(resp));
+    this.connection.on('ResponseTradeRoutes', (resp) => this._handleTradeRoutes(resp));
+    this.connection.on('ResponseAccountList', (resp) => this._handleAccountList(resp));
+    
+    // Connect and login
+    const loginData = await this.connection.connect({
+      userId: credentials.userId,
+      password: credentials.password,
+      systemName: credentials.systemName,
+      gateway: credentials.gateway,
+      infraType: INFRA_TYPES.ORDER_PLANT
+    });
+    
+    this.fcmId = loginData.fcmId;
+    this.ibId = loginData.ibId;
+    
+    // Load trade routes and accounts BEFORE signaling ready
+    await this._loadTradeRoutes();
+    await this._loadAccounts();
+    await this._subscribeOrderUpdates();
+    
+    this.emit('connected', loginData);
+    
+    return true;
+  }
+
+  /**
+   * Load trade routes
+   */
+  async _loadTradeRoutes() {
+    try {
+      this.connection.send('RequestTradeRoutes', {
+        templateId: TEMPLATE_IDS.REQUEST_TRADE_ROUTES,
+        subscribeForUpdates: false
+      });
+      
+      // Wait for response
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    } catch (error) {
+      // Silently fail - trade routes not critical
+    }
+  }
+
+  /**
+   * Load accounts
+   */
+  async _loadAccounts() {
+    try {
+      this.connection.send('RequestAccountList', {
+        templateId: TEMPLATE_IDS.REQUEST_ACCOUNT_LIST,
+        fcmId: this.fcmId,
+        ibId: this.ibId,
+        userType: 3 // USER_TYPE_TRADER
+      });
+      
+      // Wait for response
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    } catch (error) {
+      // Silently fail - accounts loaded via events
+    }
+  }
+
+  /**
+   * Subscribe to order updates
+   */
+  async _subscribeOrderUpdates() {
+    try {
+      // Subscribe for all accounts
+      for (const accountId of this.accounts.keys()) {
+        this.connection.send('RequestSubscribeForOrderUpdates', {
+          templateId: TEMPLATE_IDS.REQUEST_SUBSCRIBE_FOR_ORDER_UPDATES,
+          fcmId: this.fcmId,
+          ibId: this.ibId,
+          accountId: accountId
+        });
+      }
+      
+
+      
+    } catch (error) {
+      console.error('[RITHMIC:Trading] Failed to subscribe to order updates:', error.message);
+    }
+  }
+
+  /**
+   * Handle trade routes response
+   */
+  _handleTradeRoutes(response) {
+    if (response.exchange && response.tradeRoute) {
+      this.tradeRoutes.set(response.exchange, {
+        tradeRoute: response.tradeRoute,
+        status: response.status,
+        isDefault: response.isDefault
+      });
+    }
+  }
+
+  /**
+   * Handle account list response
+   */
+  _handleAccountList(response) {
+    if (response.accountId) {
+      this.accounts.set(response.accountId, {
+        accountId: response.accountId,
+        accountName: response.accountName,
+        currency: response.accountCurrency,
+        fcmId: response.fcmId,
+        ibId: response.ibId
+      });
+    }
+  }
+
+  /**
+   * Handle order response (acknowledgment)
+   */
+  _handleOrderResponse(response) {
+    // Get rpCode from either rpCode or rqHandlerRpCode (Rithmic sends both)
+    const rpCodeArr = response.rpCode || response.rqHandlerRpCode;
+    const rpCode = Array.isArray(rpCodeArr) ? rpCodeArr[0] : rpCodeArr;
+    const userMsgs = response.userMsg || [];
+    
+    // Only process responses with success code or error code
+    // Skip if we don't have any response code yet
+    if (!rpCode && rpCode !== '0') {
+      return;
+    }
+    
+    // Find pending order by userMsg
+    for (const [basketId, pending] of this.pendingOrders) {
+      // Check if any userMsg matches the basketId
+      const matches = userMsgs.some(msg => msg === basketId || msg.includes(basketId) || basketId.includes(msg));
+      
+      if (matches) {
+        if (rpCode === '0') {
+          // Success! Store the Rithmic basket ID for tracking
+          const rithmicBasketId = response.basketId || basketId;
+          pending.resolve({ success: true, basketId: rithmicBasketId, orderId: rithmicBasketId, response });
+        } else {
+          // Error - get error text from rpCode array (second element often contains message)
+          const errorText = Array.isArray(rpCodeArr) && rpCodeArr.length > 1 
+            ? rpCodeArr.slice(1).join(' ') 
+            : (response.textMsg || response.text || `Error code: ${rpCode}`);
+          console.log(`[RITHMIC] ORDER REJECTED: ${errorText}`);
+          pending.reject(new Error(errorText));
+        }
+        
+        this.pendingOrders.delete(basketId);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Handle order notification (fill, cancel, etc.)
+   * Handles both RithmicOrderNotification (351) and ExchangeOrderNotification (352)
+   * Uses deduplication to avoid double-emitting fills
+   */
+  _handleOrderNotification(notif) {
+    const notifyType = notif.notifyType;
+    const status = notif.status || '';
+    const symbol = notif.symbol;
+    const basketId = notif.basketId;
+    
+    // Deduplicate fills - use basketId + totalFillSize as unique key
+    const fillKey = `${basketId}-${notif.totalFillSize || 0}-${notif.fillPrice || notif.avgFillPrice || 0}`;
+    if (!this._processedFills) this._processedFills = new Set();
+    
+    // Skip if already processed (within 2 seconds window)
+    if (this._processedFills.has(fillKey)) {
+      return;
+    }
+    this._processedFills.add(fillKey);
+    
+    // Cleanup old fills after 5 seconds
+    setTimeout(() => this._processedFills.delete(fillKey), 5000);
+    
+    // Determine event type from notify_type and status
+    // RithmicOrderNotification uses: COMPLETE=15, OPEN=13, etc.
+    // ExchangeOrderNotification uses: FILL=5, STATUS=1, etc.
+    let eventType = 'status';
+    
+    // Check by numeric notifyType first (most reliable)
+    if (notifyType === RITHMIC_NOTIFY_TYPES.COMPLETE || notifyType === NOTIFY_TYPES.FILL) {
+      eventType = 'fill';
+    } else if (notifyType === RITHMIC_NOTIFY_TYPES.CANCELLATION_FAILED || notifyType === NOTIFY_TYPES.NOT_CANCELLED) {
+      eventType = 'cancel_failed';
+    } else if (notifyType === RITHMIC_NOTIFY_TYPES.MODIFICATION_FAILED) {
+      eventType = 'modify_failed';
+    } else if (status.includes('cancel') || status === 'cancelled') {
+      eventType = 'cancel';
+    } else if (status.includes('reject') || notifyType === NOTIFY_TYPES.REJECT) {
+      eventType = 'reject';
+    } else if (notifyType === RITHMIC_NOTIFY_TYPES.OPEN) {
+      eventType = 'open';
+    } else if (status === 'complete') {
+      // Fallback for status string
+      eventType = 'fill';
+    }
+    
+    // Debug logging for significant events
+    if (this.debug && (eventType === 'fill' || eventType === 'reject' || eventType === 'cancel' || eventType === 'open')) {
+      console.log(`[RITHMIC] ${eventType.toUpperCase()}: ${symbol} type=${notifyType} status="${status}" fill=${notif.totalFillSize || 0}`);
+    }
+    
+    const orderInfo = {
+      type: eventType,
+      basketId: basketId,
+      symbol: symbol,
+      exchange: notif.exchange,
+      accountId: notif.accountId,
+      side: notif.transactionType === 1 ? 'buy' : 'sell',
+      quantity: notif.quantity,
+      price: notif.price,
+      triggerPrice: notif.triggerPrice,
+      priceType: notif.priceType,
+      status: notif.status,
+      
+      // Fill info
+      fillPrice: notif.fillPrice,
+      fillSize: notif.fillSize,
+      avgFillPrice: notif.avgFillPrice,
+      totalFillSize: notif.totalFillSize,
+      totalUnfilledSize: notif.totalUnfilledSize,
+      
+      // Timestamps
+      confirmedTime: notif.confirmedTime,
+      fillTime: notif.fillTime,
+      
+      // Messages
+      text: notif.text,
+      reportText: notif.reportText
+    };
+    
+    // Log based on event type
+    if (eventType === 'fill') {
+      // Use fillSize/fillPrice if available, otherwise use totalFillSize/avgFillPrice
+      const fillSize = notif.fillSize || notif.totalFillSize || 0;
+      const fillPrice = notif.fillPrice || notif.avgFillPrice || 0;
+      const sideStr = notif.transactionType === 'BUY' || notif.transactionType === 1 ? 'BUY' : 'SELL';
+      
+      // Update orderInfo with resolved values
+      orderInfo.fillSize = fillSize;
+      orderInfo.fillPrice = fillPrice;
+      
+      this.emit('fill', orderInfo);
+      
+      // Update position
+      this._updatePosition(symbol, notif);
+      
+    } else if (eventType === 'reject') {
+      console.log(`[RITHMIC] REJECT: ${symbol} - ${notif.text || 'Unknown reason'}`);
+      this.emit('reject', orderInfo);
+      
+      // Reject pending order
+      const pending = this.pendingOrders.get(basketId);
+      if (pending) {
+        pending.reject(new Error(notif.text || 'Order rejected'));
+        this.pendingOrders.delete(basketId);
+      }
+      
+    } else if (eventType === 'cancel') {
+      this.emit('cancel', orderInfo);
+      this.openOrders.delete(basketId);
+    }
+    
+    // Emit generic order event
+    this.emit('order', orderInfo);
+    
+    // Store order info
+    if (eventType !== 'cancel' && eventType !== 'reject') {
+      this.openOrders.set(basketId, orderInfo);
+    }
+  }
+
+  /**
+   * Update position based on fill
+   */
+  _updatePosition(symbol, notif) {
+    const current = this.positions.get(symbol) || { symbol, netQty: 0, avgPrice: 0 };
+    
+    // Use fillSize/fillPrice if available, otherwise use totalFillSize/avgFillPrice
+    const fillQty = notif.fillSize || notif.totalFillSize || 0;
+    const fillPrice = notif.fillPrice || notif.avgFillPrice || 0;
+    // Handle both numeric and string transactionType
+    const isBuy = notif.transactionType === 1 || notif.transactionType === 'BUY';
+    const side = isBuy ? 1 : -1; // 1 = buy, -1 = sell
+    
+    const newQty = current.netQty + (fillQty * side);
+    
+    if (Math.abs(newQty) > Math.abs(current.netQty)) {
+      // Adding to position
+      const totalCost = (current.netQty * current.avgPrice) + (fillQty * fillPrice * side);
+      current.avgPrice = newQty !== 0 ? totalCost / newQty : 0;
+    }
+    
+    current.netQty = newQty;
+    current.lastFillPrice = fillPrice;
+    current.lastFillTime = Date.now();
+    
+    this.positions.set(symbol, current);
+    this.emit('position', current);
+  }
+
+  /**
+   * Generate unique basket ID
+   */
+  _generateBasketId() {
+    return `X_${Date.now()}_${++this._orderIdCounter}`;
+  }
+
+  /**
+   * Get trade route for exchange
+   */
+  _getTradeRoute(exchange) {
+    const route = this.tradeRoutes.get(exchange);
+    return route ? route.tradeRoute : 'DEFAULT';
+  }
+
+  /**
+   * Place a MARKET order
+   */
+  async placeMarketOrder(accountId, symbol, exchange, side, quantity) {
+    return this._placeOrder({
+      accountId,
+      symbol,
+      exchange,
+      side,
+      quantity,
+      priceType: ORDER_TYPES.PRICE_TYPE.MARKET
+    });
+  }
+
+  /**
+   * Place a LIMIT order
+   */
+  async placeLimitOrder(accountId, symbol, exchange, side, quantity, price) {
+    return this._placeOrder({
+      accountId,
+      symbol,
+      exchange,
+      side,
+      quantity,
+      price,
+      priceType: ORDER_TYPES.PRICE_TYPE.LIMIT
+    });
+  }
+
+  /**
+   * Place a STOP MARKET order
+   */
+  async placeStopMarketOrder(accountId, symbol, exchange, side, quantity, stopPrice) {
+    return this._placeOrder({
+      accountId,
+      symbol,
+      exchange,
+      side,
+      quantity,
+      triggerPrice: stopPrice,
+      priceType: ORDER_TYPES.PRICE_TYPE.STOP_MARKET
+    });
+  }
+
+  /**
+   * Place a STOP LIMIT order
+   */
+  async placeStopLimitOrder(accountId, symbol, exchange, side, quantity, stopPrice, limitPrice) {
+    return this._placeOrder({
+      accountId,
+      symbol,
+      exchange,
+      side,
+      quantity,
+      price: limitPrice,
+      triggerPrice: stopPrice,
+      priceType: ORDER_TYPES.PRICE_TYPE.STOP_LIMIT
+    });
+  }
+
+  /**
+   * Internal order placement
+   */
+  async _placeOrder(params) {
+    if (!this.connection || !this.connection.isReady) {
+      throw new Error('Not connected');
+    }
+    
+    const {
+      accountId,
+      symbol,
+      exchange = 'CME',
+      side,
+      quantity,
+      price,
+      triggerPrice,
+      priceType = ORDER_TYPES.PRICE_TYPE.MARKET,
+      duration = ORDER_TYPES.DURATION.DAY
+    } = params;
+    
+    const basketId = this._generateBasketId();
+    const transactionType = side.toLowerCase() === 'buy' 
+      ? ORDER_TYPES.TRANSACTION_TYPE.BUY 
+      : ORDER_TYPES.TRANSACTION_TYPE.SELL;
+    
+    const tradeRoute = this._getTradeRoute(exchange);
+    
+    const orderRequest = {
+      templateId: TEMPLATE_IDS.REQUEST_NEW_ORDER,
+      userMsg: [basketId],
+      fcmId: this.fcmId,
+      ibId: this.ibId,
+      accountId: accountId.toString(),
+      symbol: symbol,
+      exchange: exchange,
+      quantity: quantity,
+      transactionType: transactionType,
+      duration: duration,
+      priceType: priceType,
+      tradeRoute: tradeRoute,
+      manualOrAuto: ORDER_TYPES.ORDER_PLACEMENT.AUTO
+    };
+    
+    // Add price for limit orders
+    if (price && (priceType === ORDER_TYPES.PRICE_TYPE.LIMIT || priceType === ORDER_TYPES.PRICE_TYPE.STOP_LIMIT)) {
+      orderRequest.price = price;
+    }
+    
+    // Add trigger price for stop orders
+    if (triggerPrice && (priceType === ORDER_TYPES.PRICE_TYPE.STOP_MARKET || priceType === ORDER_TYPES.PRICE_TYPE.STOP_LIMIT)) {
+      orderRequest.triggerPrice = triggerPrice;
+    }
+    
+    return new Promise((resolve, reject) => {
+      this.pendingOrders.set(basketId, { resolve, reject, order: orderRequest });
+      
+      // Timeout
+      setTimeout(() => {
+        if (this.pendingOrders.has(basketId)) {
+          this.pendingOrders.delete(basketId);
+          reject(new Error('Order timeout'));
+        }
+      }, 15000);
+      
+      try {
+        this.connection.send('RequestNewOrder', orderRequest);
+      } catch (error) {
+        this.pendingOrders.delete(basketId);
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(basketId) {
+    if (!this.connection || !this.connection.isReady) {
+      throw new Error('Not connected');
+    }
+    
+    const order = this.openOrders.get(basketId);
+    if (!order) {
+      throw new Error('Order not found');
+    }
+    
+    this.connection.send('RequestCancelOrder', {
+      templateId: TEMPLATE_IDS.REQUEST_CANCEL_ORDER,
+      userMsg: [basketId],
+      fcmId: this.fcmId,
+      ibId: this.ibId,
+      accountId: order.accountId,
+      basketId: basketId
+    });
+    
+    return { success: true, basketId };
+  }
+
+  /**
+   * Cancel all orders for an account
+   */
+  async cancelAllOrders(accountId) {
+    if (!this.connection || !this.connection.isReady) {
+      throw new Error('Not connected');
+    }
+    
+    this.connection.send('RequestCancelAllOrders', {
+      templateId: TEMPLATE_IDS.REQUEST_CANCEL_ALL_ORDERS,
+      fcmId: this.fcmId,
+      ibId: this.ibId,
+      accountId: accountId.toString()
+    });
+    
+    return { success: true };
+  }
+
+  /**
+   * Close a position (flatten)
+   */
+  async closePosition(accountId, symbol, exchange = 'CME') {
+    const position = this.positions.get(symbol);
+    
+    if (!position || position.netQty === 0) {
+      return { success: true, message: 'No position' };
+    }
+    
+    // Place opposite order to flatten
+    const side = position.netQty > 0 ? 'sell' : 'buy';
+    const quantity = Math.abs(position.netQty);
+    
+    return this.placeMarketOrder(accountId, symbol, exchange, side, quantity);
+  }
+
+  /**
+   * Get position for symbol
+   */
+  getPosition(symbol) {
+    return this.positions.get(symbol) || null;
+  }
+
+  /**
+   * Get all positions
+   */
+  getPositions() {
+    return Array.from(this.positions.values());
+  }
+
+  /**
+   * Get open orders
+   */
+  getOpenOrders() {
+    return Array.from(this.openOrders.values());
+  }
+
+  /**
+   * Get accounts
+   */
+  getAccounts() {
+    return Array.from(this.accounts.values());
+  }
+
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.connection && this.connection.isReady;
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.disconnect();
+      this.connection = null;
+    }
+    
+    this.pendingOrders.clear();
+    this.openOrders.clear();
+    this.positions.clear();
+    this.tradeRoutes.clear();
+    this.accounts.clear();
+  }
+}
+
+module.exports = { RithmicTrading };