hedgequantx 2.6.162 → 2.7.0

package/src/lib/n/r5.js

@@ -0,0 +1,335 @@
+/**
+ * Rithmic P&L and Positions
+ * Handles real-time P&L updates from PNL_PLANT
+ */
+
+const EventEmitter = require('events');
+const { RithmicConnection } = require('./r2');
+const { TEMPLATE_IDS, INFRA_TYPES } = require('./r7');
+
+class RithmicPnL extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.connection = null;
+    this.config = null;
+    
+    // Login info
+    this.fcmId = null;
+    this.ibId = null;
+    
+    // Account P&L cache
+    this.accountPnL = new Map(); // accountId -> P&L data
+    
+    // Instrument P&L cache
+    this.instrumentPnL = new Map(); // `${accountId}:${symbol}` -> P&L data
+    
+    // Subscriptions
+    this.subscriptions = new Set(); // accountIds subscribed
+    
+    // Options
+    this.debug = options.debug || false;
+  }
+
+  /**
+   * Connect to Rithmic PNL_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.fcmId = data.fcmId;
+      this.ibId = data.ibId;
+      this.emit('connected', data);
+      
+      // Resubscribe after reconnect
+      for (const accountId of this.subscriptions) {
+        this._sendSubscribe(accountId);
+      }
+    });
+    
+    this.connection.on('error', (error) => {
+      this.emit('error', error);
+    });
+    
+    this.connection.on('disconnected', (data) => {
+      this.emit('disconnected', data);
+    });
+    
+    // Handle P&L updates
+    this.connection.on('AccountPnLPositionUpdate', (update) => this._handleAccountPnL(update));
+    this.connection.on('InstrumentPnLPositionUpdate', (update) => this._handleInstrumentPnL(update));
+    
+    // Connect
+    await this.connection.connect({
+      userId: credentials.userId,
+      password: credentials.password,
+      systemName: credentials.systemName,
+      gateway: credentials.gateway,
+      infraType: INFRA_TYPES.PNL_PLANT
+    });
+    
+    return true;
+  }
+
+  /**
+   * Subscribe to P&L updates for an account
+   */
+  async subscribe(accountId) {
+    if (!this.connection || !this.connection.isReady) {
+      throw new Error('Not connected');
+    }
+    
+    this.subscriptions.add(accountId);
+    return this._sendSubscribe(accountId);
+  }
+
+  /**
+   * Internal subscribe
+   */
+  _sendSubscribe(accountId) {
+    try {
+      this.connection.send('RequestPnLPositionUpdates', {
+        templateId: TEMPLATE_IDS.REQUEST_PNL_POSITION_UPDATES,
+        request: 1, // Subscribe
+        fcmId: this.fcmId,
+        ibId: this.ibId,
+        accountId: accountId.toString()
+      });
+      
+      return true;
+      
+    } catch (error) {
+      console.error('[RITHMIC:PnL] Subscribe error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Unsubscribe from P&L updates
+   */
+  async unsubscribe(accountId) {
+    if (!this.connection || !this.connection.isReady) {
+      return false;
+    }
+    
+    this.subscriptions.delete(accountId);
+    
+    try {
+      this.connection.send('RequestPnLPositionUpdates', {
+        templateId: TEMPLATE_IDS.REQUEST_PNL_POSITION_UPDATES,
+        request: 2, // Unsubscribe
+        fcmId: this.fcmId,
+        ibId: this.ibId,
+        accountId: accountId.toString()
+      });
+      
+      return true;
+      
+    } catch (error) {
+      console.error('[RITHMIC:PnL] Unsubscribe error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Handle account-level P&L update
+   */
+  _handleAccountPnL(update) {
+    const accountId = update.accountId;
+    
+    const pnlData = {
+      accountId: accountId,
+      
+      // P&L
+      openPositionPnL: this._parseNumber(update.openPositionPnl),
+      closedPositionPnL: this._parseNumber(update.closedPositionPnl),
+      dayOpenPnL: this._parseNumber(update.dayOpenPnl),
+      dayClosedPnL: this._parseNumber(update.dayClosedPnl),
+      dayPnL: this._parseNumber(update.dayPnl),
+      
+      // Positions
+      openPositionQuantity: update.openPositionQuantity || 0,
+      closedPositionQuantity: update.closedPositionQuantity || 0,
+      netQuantity: update.netQuantity || 0,
+      
+      // Volume
+      fillBuyQty: update.fillBuyQty || 0,
+      fillSellQty: update.fillSellQty || 0,
+      buyQty: update.buyQty || 0,
+      sellQty: update.sellQty || 0,
+      
+      // Balances
+      accountBalance: this._parseNumber(update.accountBalance),
+      cashOnHand: this._parseNumber(update.cashOnHand),
+      marginBalance: this._parseNumber(update.marginBalance),
+      minMarginBalance: this._parseNumber(update.minMarginBalance),
+      availableBuyingPower: this._parseNumber(update.availableBuyingPower),
+      usedBuyingPower: this._parseNumber(update.usedBuyingPower),
+      
+      // Risk
+      percentMaximumAllowableLoss: this._parseNumber(update.percentMaximumAllowableLoss),
+      
+      // Timestamps
+      isSnapshot: update.isSnapshot || false,
+      timestamp: Date.now()
+    };
+    
+    // Calculate total P&L
+    pnlData.totalPnL = pnlData.openPositionPnL + pnlData.closedPositionPnL;
+    
+    // Store
+    this.accountPnL.set(accountId, pnlData);
+    
+    // Debug
+    if (this.debug) {
+      console.log(`[RITHMIC:PnL] Account ${accountId}: Open=$${pnlData.openPositionPnL.toFixed(2)}, Closed=$${pnlData.closedPositionPnL.toFixed(2)}, Net=${pnlData.netQuantity}`);
+    }
+    
+    // Emit
+    this.emit('accountPnL', pnlData);
+    this.emit('pnl', pnlData);
+  }
+
+  /**
+   * Handle instrument-level P&L update
+   */
+  _handleInstrumentPnL(update) {
+    const accountId = update.accountId;
+    const symbol = update.symbol;
+    const key = `${accountId}:${symbol}`;
+    
+    const pnlData = {
+      accountId: accountId,
+      symbol: symbol,
+      exchange: update.exchange,
+      productCode: update.productCode,
+      instrumentType: update.instrumentType,
+      
+      // P&L
+      openPositionPnL: this._parseNumber(update.openPositionPnl),
+      closedPositionPnL: this._parseNumber(update.closedPositionPnl),
+      dayOpenPnL: update.dayOpenPnl || 0,
+      dayClosedPnL: update.dayClosedPnl || 0,
+      dayPnL: update.dayPnl || 0,
+      
+      // Position
+      openPositionQuantity: update.openPositionQuantity || 0,
+      closedPositionQuantity: update.closedPositionQuantity || 0,
+      netQuantity: update.netQuantity || 0,
+      avgOpenFillPrice: update.avgOpenFillPrice || 0,
+      
+      // Volume
+      fillBuyQty: update.fillBuyQty || 0,
+      fillSellQty: update.fillSellQty || 0,
+      buyQty: update.buyQty || 0,
+      sellQty: update.sellQty || 0,
+      
+      // Timestamps
+      isSnapshot: update.isSnapshot || false,
+      timestamp: Date.now()
+    };
+    
+    // Calculate total P&L
+    pnlData.totalPnL = pnlData.openPositionPnL + pnlData.closedPositionPnL;
+    
+    // Store
+    this.instrumentPnL.set(key, pnlData);
+    
+    // Emit
+    this.emit('instrumentPnL', pnlData);
+    this.emit('position', pnlData);
+  }
+
+  /**
+   * Parse number from string or return 0
+   */
+  _parseNumber(value) {
+    if (typeof value === 'number') return value;
+    if (typeof value === 'string') {
+      const parsed = parseFloat(value);
+      return isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+  }
+
+  /**
+   * Get account P&L
+   */
+  getAccountPnL(accountId) {
+    return this.accountPnL.get(accountId) || null;
+  }
+
+  /**
+   * Get instrument P&L
+   */
+  getInstrumentPnL(accountId, symbol) {
+    return this.instrumentPnL.get(`${accountId}:${symbol}`) || null;
+  }
+
+  /**
+   * Get all positions for an account
+   */
+  getPositions(accountId) {
+    const positions = [];
+    for (const [key, pnl] of this.instrumentPnL) {
+      if (key.startsWith(`${accountId}:`) && pnl.netQuantity !== 0) {
+        positions.push(pnl);
+      }
+    }
+    return positions;
+  }
+
+  /**
+   * Get all account P&L data
+   */
+  getAllAccountPnL() {
+    return Array.from(this.accountPnL.values());
+  }
+
+  /**
+   * Get summary for an account
+   */
+  getSummary(accountId) {
+    const account = this.accountPnL.get(accountId);
+    const positions = this.getPositions(accountId);
+    
+    return {
+      accountId,
+      pnl: account,
+      positions,
+      openPositionCount: positions.length,
+      totalNetQuantity: positions.reduce((sum, p) => sum + p.netQuantity, 0)
+    };
+  }
+
+  /**
+   * 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.subscriptions.clear();
+    this.accountPnL.clear();
+    this.instrumentPnL.clear();
+  }
+}
+
+module.exports = { RithmicPnL };