hedgequantx 1.3.0 → 1.3.1

package/src/services/projectx/market.js

@@ -0,0 +1,145 @@
+/**
+ * ProjectX Market Hours & Holidays
+ * CME Futures trading hours and US market holidays
+ */
+
+/**
+ * Get nth weekday of a month
+ */
+const getNthWeekday = (year, month, weekday, n) => {
+  let count = 0;
+  for (let day = 1; day <= 31; day++) {
+    const d = new Date(year, month, day);
+    if (d.getMonth() !== month) break;
+    if (d.getDay() === weekday) {
+      count++;
+      if (count === n) return d.toISOString().split('T')[0];
+    }
+  }
+  return null;
+};
+
+/**
+ * Get last weekday of a month
+ */
+const getLastWeekday = (year, month, weekday) => {
+  const lastDay = new Date(year, month + 1, 0);
+  for (let day = lastDay.getDate(); day >= 1; day--) {
+    const d = new Date(year, month, day);
+    if (d.getDay() === weekday) return d.toISOString().split('T')[0];
+  }
+  return null;
+};
+
+/**
+ * Get Good Friday (Friday before Easter)
+ */
+const getGoodFriday = (year) => {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * m + 114) / 31) - 1;
+  const day = ((h + l - 7 * m + 114) % 31) + 1;
+  
+  const easter = new Date(year, month, day);
+  const goodFriday = new Date(easter);
+  goodFriday.setDate(easter.getDate() - 2);
+  return goodFriday.toISOString().split('T')[0];
+};
+
+/**
+ * Get day after a date
+ */
+const getDayAfter = (dateStr) => {
+  const d = new Date(dateStr);
+  d.setDate(d.getDate() + 1);
+  return d.toISOString().split('T')[0];
+};
+
+/**
+ * Get US market holidays for the current year
+ */
+const getMarketHolidays = () => {
+  const year = new Date().getFullYear();
+  
+  return [
+    { date: `${year}-01-01`, name: "New Year's Day", earlyClose: false },
+    { date: getNthWeekday(year, 0, 1, 3), name: 'MLK Day', earlyClose: false },
+    { date: getNthWeekday(year, 1, 1, 3), name: "Presidents' Day", earlyClose: false },
+    { date: getGoodFriday(year), name: 'Good Friday', earlyClose: false },
+    { date: getLastWeekday(year, 4, 1), name: 'Memorial Day', earlyClose: false },
+    { date: `${year}-06-19`, name: 'Juneteenth', earlyClose: false },
+    { date: `${year}-07-04`, name: 'Independence Day', earlyClose: false },
+    { date: `${year}-07-03`, name: 'Independence Day Eve', earlyClose: true },
+    { date: getNthWeekday(year, 8, 1, 1), name: 'Labor Day', earlyClose: false },
+    { date: getNthWeekday(year, 10, 4, 4), name: 'Thanksgiving', earlyClose: false },
+    { date: getDayAfter(getNthWeekday(year, 10, 4, 4)), name: 'Black Friday', earlyClose: true },
+    { date: `${year}-12-25`, name: 'Christmas Day', earlyClose: false },
+    { date: `${year}-12-24`, name: 'Christmas Eve', earlyClose: true },
+    { date: `${year}-12-31`, name: "New Year's Eve", earlyClose: true },
+  ];
+};
+
+/**
+ * Check if today is a market holiday
+ */
+const checkHoliday = () => {
+  const today = new Date().toISOString().split('T')[0];
+  const holidays = getMarketHolidays();
+  const holiday = holidays.find(h => h.date === today);
+  
+  if (holiday) {
+    return { isHoliday: !holiday.earlyClose, holiday };
+  }
+  return { isHoliday: false };
+};
+
+/**
+ * Check if futures market is open based on CME hours and holidays
+ */
+const checkMarketHours = () => {
+  const now = new Date();
+  const utcDay = now.getUTCDay();
+  const utcHour = now.getUTCHours();
+  
+  const holidayCheck = checkHoliday();
+  if (holidayCheck.isHoliday) {
+    return { isOpen: false, message: `Market closed - ${holidayCheck.holiday.name}` };
+  }
+  if (holidayCheck.holiday && holidayCheck.holiday.earlyClose && utcHour >= 18) {
+    return { isOpen: false, message: `Market closed early - ${holidayCheck.holiday.name}` };
+  }
+  
+  if (utcDay === 6) {
+    return { isOpen: false, message: 'Market closed - Weekend (Saturday)' };
+  }
+  
+  if (utcDay === 0 && utcHour < 23) {
+    return { isOpen: false, message: 'Market closed - Opens Sunday 6:00 PM ET' };
+  }
+  
+  if (utcDay === 5 && utcHour >= 22) {
+    return { isOpen: false, message: 'Market closed - Weekend' };
+  }
+  
+  if (utcHour === 22 && utcDay !== 5) {
+    return { isOpen: false, message: 'Market closed - Daily maintenance (5:00-6:00 PM ET)' };
+  }
+  
+  return { isOpen: true, message: 'Market is open' };
+};
+
+module.exports = {
+  getMarketHolidays,
+  checkHoliday,
+  checkMarketHours
+};

package/src/services/projectx/stats.js

@@ -0,0 +1,110 @@
+/**
+ * ProjectX Statistics Module
+ * Trade statistics calculations
+ */
+
+/**
+ * Calculate lifetime statistics from trades
+ * @param {Array} trades - Array of trade objects
+ * @returns {Object} Calculated statistics
+ */
+const calculateLifetimeStats = (trades) => {
+  if (!trades || trades.length === 0) {
+    return null;
+  }
+
+  const stats = {
+    totalTrades: trades.length,
+    winningTrades: 0,
+    losingTrades: 0,
+    totalWinAmount: 0,
+    totalLossAmount: 0,
+    bestTrade: 0,
+    worstTrade: 0,
+    totalVolume: 0,
+    maxConsecutiveWins: 0,
+    maxConsecutiveLosses: 0,
+    longTrades: 0,
+    shortTrades: 0
+  };
+
+  let consecutiveWins = 0;
+  let consecutiveLosses = 0;
+
+  trades.forEach(t => {
+    const pnl = t.profitAndLoss || t.pnl || 0;
+    const size = t.size || t.quantity || 1;
+
+    stats.totalVolume += Math.abs(size);
+    
+    if (t.side === 0) stats.longTrades++;
+    else if (t.side === 1) stats.shortTrades++;
+
+    if (pnl > 0) {
+      stats.winningTrades++;
+      stats.totalWinAmount += pnl;
+      if (pnl > stats.bestTrade) stats.bestTrade = pnl;
+      consecutiveWins++;
+      consecutiveLosses = 0;
+      if (consecutiveWins > stats.maxConsecutiveWins) stats.maxConsecutiveWins = consecutiveWins;
+    } else if (pnl < 0) {
+      stats.losingTrades++;
+      stats.totalLossAmount += Math.abs(pnl);
+      if (pnl < stats.worstTrade) stats.worstTrade = pnl;
+      consecutiveLosses++;
+      consecutiveWins = 0;
+      if (consecutiveLosses > stats.maxConsecutiveLosses) stats.maxConsecutiveLosses = consecutiveLosses;
+    }
+  });
+
+  stats.profitFactor = stats.totalLossAmount > 0 ? stats.totalWinAmount / stats.totalLossAmount : 0;
+  stats.avgWin = stats.winningTrades > 0 ? stats.totalWinAmount / stats.winningTrades : 0;
+  stats.avgLoss = stats.losingTrades > 0 ? stats.totalLossAmount / stats.losingTrades : 0;
+
+  return stats;
+};
+
+/**
+ * Calculate daily P&L from trades
+ * @param {Array} trades - Array of trade objects
+ * @returns {Array} Daily P&L array
+ */
+const calculateDailyPnL = (trades) => {
+  if (!trades || trades.length === 0) {
+    return [];
+  }
+
+  const dailyPnL = {};
+  
+  trades.forEach(t => {
+    const ts = t.creationTimestamp || t.timestamp;
+    if (ts) {
+      const d = new Date(ts);
+      const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+      dailyPnL[key] = (dailyPnL[key] || 0) + (t.profitAndLoss || t.pnl || 0);
+    }
+  });
+
+  return Object.entries(dailyPnL).map(([date, pnl]) => ({ date, profitAndLoss: pnl }));
+};
+
+/**
+ * Format trades for consistent output
+ * @param {Array} trades - Raw trades from API
+ * @returns {Array} Formatted trades
+ */
+const formatTrades = (trades) => {
+  if (!Array.isArray(trades)) return [];
+  
+  return trades.map(t => ({
+    ...t,
+    timestamp: t.creationTimestamp || t.timestamp,
+    pnl: t.profitAndLoss || t.pnl || 0
+  }));
+};
+
+module.exports = {
+  calculateLifetimeStats,
+  calculateDailyPnL,
+  formatTrades
+};

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
+};