hedgequantx 2.7.15 → 2.7.17

package/src/lib/n/r3.js

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