hedgequantx 1.2.147 → 1.3.1

package/src/services/rithmic/accounts.js

@@ -0,0 +1,183 @@
+/**
+ * Rithmic Accounts Module
+ * Account fetching, PnL, and positions
+ */
+
+const { REQ } = require('./constants');
+
+/**
+ * Hash account ID to numeric (for compatibility)
+ */
+const hashAccountId = (str) => {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+};
+
+/**
+ * Fetch accounts from ORDER_PLANT
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const fetchAccounts = async (service) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return [];
+  }
+
+  return new Promise((resolve) => {
+    const accounts = [];
+    
+    const timeout = setTimeout(() => {
+      service.accounts = accounts;
+      resolve(accounts);
+    }, 2000);
+
+    service.once('accountReceived', (account) => {
+      accounts.push(account);
+    });
+
+    service.once('accountListComplete', () => {
+      clearTimeout(timeout);
+      service.accounts = accounts;
+      resolve(accounts);
+    });
+
+    try {
+      service.orderConn.send('RequestAccountList', {
+        templateId: REQ.ACCOUNT_LIST,
+        userMsg: ['HQX'],
+        fcmId: service.loginInfo.fcmId,
+        ibId: service.loginInfo.ibId,
+      });
+    } catch (e) {
+      clearTimeout(timeout);
+      resolve([]);
+    }
+  });
+};
+
+/**
+ * Get trading accounts formatted like ProjectX
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const getTradingAccounts = async (service) => {
+  if (service.accounts.length === 0 && service.orderConn && service.loginInfo) {
+    try {
+      await fetchAccounts(service);
+    } catch (e) {
+      // Ignore fetch errors
+    }
+  }
+
+  let tradingAccounts = service.accounts.map((acc) => {
+    const pnl = service.accountPnL.get(acc.accountId) || {};
+    const balance = parseFloat(pnl.accountBalance || pnl.marginBalance || pnl.cashOnHand || 0) || service.propfirm.defaultBalance;
+    const startingBalance = service.propfirm.defaultBalance;
+    const profitAndLoss = balance - startingBalance;
+
+    return {
+      accountId: hashAccountId(acc.accountId),
+      rithmicAccountId: acc.accountId,
+      accountName: acc.accountName || acc.accountId,
+      name: acc.accountName || acc.accountId,
+      balance: balance,
+      startingBalance: startingBalance,
+      profitAndLoss: profitAndLoss,
+      status: 0,
+      platform: 'Rithmic',
+      propfirm: service.propfirm.name,
+    };
+  });
+
+  if (tradingAccounts.length === 0 && service.user) {
+    const userName = service.user.userName || 'Unknown';
+    tradingAccounts = [{
+      accountId: hashAccountId(userName),
+      rithmicAccountId: userName,
+      accountName: userName,
+      name: userName,
+      balance: service.propfirm.defaultBalance,
+      startingBalance: service.propfirm.defaultBalance,
+      profitAndLoss: 0,
+      status: 0,
+      platform: 'Rithmic',
+      propfirm: service.propfirm.name,
+    }];
+  }
+
+  return { success: true, accounts: tradingAccounts };
+};
+
+/**
+ * Request PnL snapshot for accounts
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const requestPnLSnapshot = async (service) => {
+  if (!service.pnlConn || !service.loginInfo) return;
+
+  for (const acc of service.accounts) {
+    service.pnlConn.send('RequestPnLPositionSnapshot', {
+      templateId: REQ.PNL_POSITION_SNAPSHOT,
+      userMsg: ['HQX'],
+      fcmId: acc.fcmId || service.loginInfo.fcmId,
+      ibId: acc.ibId || service.loginInfo.ibId,
+      accountId: acc.accountId,
+    });
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 2000));
+};
+
+/**
+ * Subscribe to PnL updates
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const subscribePnLUpdates = (service) => {
+  if (!service.pnlConn || !service.loginInfo) return;
+
+  for (const acc of service.accounts) {
+    service.pnlConn.send('RequestPnLPositionUpdates', {
+      templateId: REQ.PNL_POSITION_UPDATES,
+      userMsg: ['HQX'],
+      request: 1,
+      fcmId: acc.fcmId || service.loginInfo.fcmId,
+      ibId: acc.ibId || service.loginInfo.ibId,
+      accountId: acc.accountId,
+    });
+  }
+};
+
+/**
+ * Get positions
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const getPositions = async (service) => {
+  if (!service.pnlConn && service.credentials) {
+    await service.connectPnL(service.credentials.username, service.credentials.password);
+    await requestPnLSnapshot(service);
+  }
+  
+  const positions = Array.from(service.positions.values()).map(pos => ({
+    symbol: pos.symbol,
+    exchange: pos.exchange,
+    quantity: pos.quantity,
+    averagePrice: pos.averagePrice,
+    unrealizedPnl: pos.openPnl,
+    realizedPnl: pos.closedPnl,
+    side: pos.quantity > 0 ? 'LONG' : 'SHORT',
+  }));
+  
+  return { success: true, positions };
+};
+
+module.exports = {
+  hashAccountId,
+  fetchAccounts,
+  getTradingAccounts,
+  requestPnLSnapshot,
+  subscribePnLUpdates,
+  getPositions
+};

package/src/services/rithmic/handlers.js

@@ -0,0 +1,191 @@
+/**
+ * Rithmic Message Handlers
+ * Handles ORDER_PLANT and PNL_PLANT messages
+ */
+
+const { proto, decodeAccountPnL, decodeInstrumentPnL } = require('./protobuf');
+const { RES, STREAM } = require('./constants');
+
+/**
+ * Create ORDER_PLANT message handler
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const createOrderHandler = (service) => {
+  return (msg) => {
+    const { templateId, data } = msg;
+
+    switch (templateId) {
+      case RES.LOGIN_INFO:
+        handleLoginInfo(service, data);
+        break;
+      case RES.ACCOUNT_LIST:
+        handleAccountList(service, data);
+        break;
+      case RES.TRADE_ROUTES:
+        handleTradeRoutes(service, data);
+        break;
+      case RES.SHOW_ORDERS:
+        handleShowOrdersResponse(service, data);
+        break;
+      case STREAM.EXCHANGE_NOTIFICATION:
+        service.emit('exchangeNotification', data);
+        break;
+      case STREAM.ORDER_NOTIFICATION:
+        service.emit('orderNotification', data);
+        break;
+    }
+  };
+};
+
+/**
+ * Create PNL_PLANT message handler
+ * @param {RithmicService} service - The Rithmic service instance
+ */
+const createPnLHandler = (service) => {
+  return (msg) => {
+    const { templateId, data } = msg;
+
+    switch (templateId) {
+      case RES.PNL_POSITION_SNAPSHOT:
+      case RES.PNL_POSITION_UPDATES:
+        // OK response, nothing to do
+        break;
+      case STREAM.ACCOUNT_PNL_UPDATE:
+        handleAccountPnLUpdate(service, data);
+        break;
+      case STREAM.INSTRUMENT_PNL_UPDATE:
+        handleInstrumentPnLUpdate(service, data);
+        break;
+    }
+  };
+};
+
+/**
+ * Handle login info response
+ */
+const handleLoginInfo = (service, data) => {
+  try {
+    const res = proto.decode('ResponseLoginInfo', data);
+    service.emit('loginInfoReceived', {
+      fcmId: res.fcmId,
+      ibId: res.ibId,
+      firstName: res.firstName,
+      lastName: res.lastName,
+      userType: res.userType,
+    });
+  } catch (e) {
+    // Ignore decode errors
+  }
+};
+
+/**
+ * Handle account list response
+ */
+const handleAccountList = (service, data) => {
+  try {
+    const res = proto.decode('ResponseAccountList', data);
+    
+    if (res.rpCode?.[0] === '0') {
+      // End of list
+      service.emit('accountListComplete');
+    } else if (res.accountId) {
+      const account = {
+        fcmId: res.fcmId,
+        ibId: res.ibId,
+        accountId: res.accountId,
+        accountName: res.accountName,
+        accountCurrency: res.accountCurrency,
+      };
+      service.accounts.push(account);
+      service.emit('accountReceived', account);
+    }
+  } catch (e) {
+    // Ignore decode errors
+  }
+};
+
+/**
+ * Handle trade routes response
+ */
+const handleTradeRoutes = (service, data) => {
+  try {
+    const res = proto.decode('ResponseTradeRoutes', data);
+    service.emit('tradeRoutes', res);
+  } catch (e) {
+    // Ignore decode errors
+  }
+};
+
+/**
+ * Handle show orders response
+ */
+const handleShowOrdersResponse = (service, data) => {
+  try {
+    const res = proto.decode('ResponseShowOrders', data);
+    if (res.rpCode?.[0] === '0') {
+      service.emit('ordersReceived');
+    }
+  } catch (e) {
+    // Ignore decode errors
+  }
+};
+
+/**
+ * Handle account PnL update
+ */
+const handleAccountPnLUpdate = (service, data) => {
+  try {
+    const pnl = decodeAccountPnL(data);
+    if (pnl.accountId) {
+      service.accountPnL.set(pnl.accountId, {
+        accountBalance: parseFloat(pnl.accountBalance || 0),
+        cashOnHand: parseFloat(pnl.cashOnHand || 0),
+        marginBalance: parseFloat(pnl.marginBalance || 0),
+        openPositionPnl: parseFloat(pnl.openPositionPnl || 0),
+        closedPositionPnl: parseFloat(pnl.closedPositionPnl || 0),
+        dayPnl: parseFloat(pnl.dayPnl || 0),
+      });
+      service.emit('pnlUpdate', pnl);
+    }
+  } catch (e) {
+    // Ignore decode errors
+  }
+};
+
+/**
+ * Handle instrument PnL update (positions)
+ */
+const handleInstrumentPnLUpdate = (service, data) => {
+  try {
+    const pos = decodeInstrumentPnL(data);
+    if (pos.symbol && pos.accountId) {
+      const key = `${pos.accountId}:${pos.symbol}:${pos.exchange}`;
+      const netQty = pos.netQuantity || pos.openPositionQuantity || ((pos.buyQty || 0) - (pos.sellQty || 0));
+      
+      if (netQty !== 0) {
+        service.positions.set(key, {
+          accountId: pos.accountId,
+          symbol: pos.symbol,
+          exchange: pos.exchange || 'CME',
+          quantity: netQty,
+          averagePrice: pos.avgOpenFillPrice || 0,
+          openPnl: parseFloat(pos.openPositionPnl || pos.dayOpenPnl || 0),
+          closedPnl: parseFloat(pos.closedPositionPnl || pos.dayClosedPnl || 0),
+          dayPnl: parseFloat(pos.dayPnl || 0),
+          isSnapshot: pos.isSnapshot || false,
+        });
+      } else {
+        service.positions.delete(key);
+      }
+      
+      service.emit('positionUpdate', service.positions.get(key));
+    }
+  } catch (e) {
+    // Ignore decode errors
+  }
+};
+
+module.exports = {
+  createOrderHandler,
+  createPnLHandler
+};