hedgequantx 2.6.163 → 2.7.0

package/src/services/projectx/market.js

@@ -1,172 +0,0 @@
-/**
- * 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 };
-};
-
-/**
- * Get current trading session based on ET time
- * Sessions (in ET):
- * - ASIA: 6:00 PM - 2:00 AM (18:00-02:00)
- * - LONDON: 2:00 AM - 8:00 AM (02:00-08:00)
- * - AMERICAN: 8:00 AM - 5:00 PM (08:00-17:00)
- * - MAINTENANCE: 5:00 PM - 6:00 PM (17:00-18:00)
- */
-const getTradingSession = () => {
-  const now = new Date();
-  // Convert to ET (UTC-5 or UTC-4 for DST)
-  const etOptions = { timeZone: 'America/New_York', hour: 'numeric', hour12: false };
-  const etHour = parseInt(new Intl.DateTimeFormat('en-US', etOptions).format(now));
-  
-  // Determine session based on ET hour
-  if (etHour >= 18 || etHour < 2) {
-    return 'ASIA';
-  } else if (etHour >= 2 && etHour < 8) {
-    return 'LONDON';
-  } else if (etHour >= 8 && etHour < 17) {
-    return 'AMERICAN';
-  } else {
-    return 'MAINTENANCE';
-  }
-};
-
-/**
- * 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}`, session: null };
-  }
-  if (holidayCheck.holiday && holidayCheck.holiday.earlyClose && utcHour >= 18) {
-    return { isOpen: false, message: `Market closed early - ${holidayCheck.holiday.name}`, session: null };
-  }
-  
-  if (utcDay === 6) {
-    return { isOpen: false, message: 'Market closed - Weekend (Saturday)', session: null };
-  }
-  
-  if (utcDay === 0 && utcHour < 23) {
-    return { isOpen: false, message: 'Market closed - Opens Sunday 6:00 PM ET', session: null };
-  }
-  
-  if (utcDay === 5 && utcHour >= 22) {
-    return { isOpen: false, message: 'Market closed - Weekend', session: null };
-  }
-  
-  if (utcHour === 22 && utcDay !== 5) {
-    return { isOpen: false, message: 'Market closed - Daily maintenance (5:00-6:00 PM ET)', session: 'MAINTENANCE' };
-  }
-  
-  const session = getTradingSession();
-  return { isOpen: true, message: 'Market is open', session };
-};
-
-module.exports = {
-  getMarketHolidays,
-  checkHoliday,
-  checkMarketHours
-};

package/src/services/projectx/stats.js

@@ -1,110 +0,0 @@
-/**
- * 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/projectx/trading.js

@@ -1,180 +0,0 @@
-/**
- * ProjectX Trading Operations
- * @module services/projectx/trading
- * 
- * Order management, position control, and trade history.
- */
-
-const { validateAccountId } = require('../../security');
-const { logger } = require('../../utils/logger');
-
-const log = logger.scope('ProjectX');
-
-/**
- * Get open positions
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {number|string} accountId - Account ID
- */
-async function getPositions(request, gatewayApi, accountId) {
-  try {
-    const id = validateAccountId(accountId);
-    const response = await request(gatewayApi, '/api/Position/searchOpen', 'POST', { accountId: id });
-    
-    if (response.statusCode === 200) {
-      const positions = response.data.positions || response.data || [];
-      return { success: true, positions: Array.isArray(positions) ? positions : [] };
-    }
-    
-    return { success: true, positions: [] };
-  } catch (err) {
-    return { success: true, positions: [], error: err.message };
-  }
-}
-
-/**
- * Get open orders
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {number|string} accountId - Account ID
- */
-async function getOrders(request, gatewayApi, accountId) {
-  try {
-    const id = validateAccountId(accountId);
-    const response = await request(gatewayApi, '/api/Order/searchOpen', 'POST', { accountId: id });
-    
-    if (response.statusCode === 200) {
-      const orders = response.data.orders || response.data || [];
-      return { success: true, orders: Array.isArray(orders) ? orders : [] };
-    }
-    
-    return { success: true, orders: [] };
-  } catch (err) {
-    return { success: true, orders: [], error: err.message };
-  }
-}
-
-/**
- * Get trades for today
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {number|string} accountId - Account ID
- */
-async function getTrades(request, gatewayApi, accountId) {
-  try {
-    const id = validateAccountId(accountId);
-    const now = new Date();
-    const startOfDay = new Date(now);
-    startOfDay.setUTCHours(0, 0, 0, 0);
-    
-    const response = await request(gatewayApi, '/api/Trade/search', 'POST', { 
-      accountId: id,
-      startTimestamp: startOfDay.toISOString(),
-      endTimestamp: now.toISOString()
-    });
-    
-    if (response.statusCode === 200) {
-      const trades = response.data.trades || response.data || [];
-      return { success: true, trades: Array.isArray(trades) ? trades : [] };
-    }
-    
-    return { success: true, trades: [] };
-  } catch (err) {
-    return { success: true, trades: [], error: err.message };
-  }
-}
-
-/**
- * Place an order
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {Object} orderData - Order details
- */
-async function placeOrder(request, gatewayApi, orderData) {
-  try {
-    const response = await request(gatewayApi, '/api/Order/place', 'POST', orderData, 'orders');
-    
-    if (response.statusCode === 200 && response.data.success) {
-      log.info('Order placed', { orderId: response.data.orderId });
-      return { success: true, order: response.data };
-    }
-    
-    return { success: false, error: response.data.errorMessage || 'Order failed' };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-
-/**
- * Cancel an order
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {number|string} orderId - Order ID
- */
-async function cancelOrder(request, gatewayApi, orderId) {
-  try {
-    const response = await request(gatewayApi, '/api/Order/cancel', 'POST', { orderId: parseInt(orderId, 10) }, 'orders');
-    return { success: response.statusCode === 200 && response.data.success };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-
-/**
- * Cancel all open orders for an account
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {number|string} accountId - Account ID
- */
-async function cancelAllOrders(request, gatewayApi, accountId) {
-  try {
-    const id = validateAccountId(accountId);
-    const ordersResult = await getOrders(request, gatewayApi, id);
-    
-    if (!ordersResult.success || !ordersResult.orders?.length) {
-      return { success: true, cancelled: 0 };
-    }
-    
-    const pendingOrders = ordersResult.orders.filter(o =>
-      o.status === 'Working' || o.status === 'Pending' ||
-      o.status === 0 || o.status === 1
-    );
-    
-    let cancelled = 0;
-    for (const order of pendingOrders) {
-      const result = await cancelOrder(request, gatewayApi, order.orderId || order.id);
-      if (result.success) cancelled++;
-    }
-    
-    return { success: true, cancelled };
-  } catch (err) {
-    return { success: false, cancelled: 0, error: err.message };
-  }
-}
-
-/**
- * Close a position
- * @param {Function} request - Request function
- * @param {string} gatewayApi - Gateway API host
- * @param {number|string} accountId - Account ID
- * @param {number|string} contractId - Contract ID
- */
-async function closePosition(request, gatewayApi, accountId, contractId) {
-  try {
-    const id = validateAccountId(accountId);
-    const response = await request(gatewayApi, '/api/Position/closeContract', 'POST', { accountId: id, contractId }, 'orders');
-    return { success: response.statusCode === 200 && response.data.success };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-
-module.exports = {
-  getPositions,
-  getOrders,
-  getTrades,
-  placeOrder,
-  cancelOrder,
-  cancelAllOrders,
-  closePosition,
-};

package/src/services/rithmic/latency-tracker.js

@@ -1,182 +0,0 @@
-/**
- * Rithmic Latency Tracking
- * @module services/rithmic/latency-tracker
- * 
- * High-precision order-to-fill latency tracking.
- * Uses circular buffer and high-resolution timing.
- */
-
-/**
- * Get high-resolution timestamp in nanoseconds
- * @returns {bigint}
- */
-const hrNow = () => process.hrtime.bigint();
-
-/**
- * Convert nanoseconds to milliseconds with precision
- * @param {bigint} ns 
- * @returns {number}
- */
-const nsToMs = (ns) => Number(ns) / 1_000_000;
-
-/**
- * Latency tracker with circular buffer for O(1) operations
- */
-const LatencyTracker = {
-  _pending: new Map(), // orderTag -> entryTime (bigint nanoseconds)
-  _samples: null,      // Pre-allocated Float64Array circular buffer
-  _maxSamples: 100,
-  _head: 0,            // Next write position
-  _count: 0,           // Number of valid samples
-  _initialized: false,
-  
-  /** Initialize circular buffer (lazy init) */
-  _init() {
-    if (this._initialized) return;
-    this._samples = new Float64Array(this._maxSamples);
-    this._initialized = true;
-  },
-  
-  /** Record order sent time with high-resolution timestamp */
-  recordEntry(orderTag, entryTimeMs) {
-    this._pending.set(orderTag, hrNow());
-  },
-  
-  /** Record fill received, calculate latency with sub-ms precision */
-  recordFill(orderTag) {
-    const entryTime = this._pending.get(orderTag);
-    if (!entryTime) return null;
-    
-    this._pending.delete(orderTag);
-    const latencyNs = hrNow() - entryTime;
-    const latencyMs = nsToMs(latencyNs);
-    
-    // Store in circular buffer (no shift, O(1))
-    this._init();
-    this._samples[this._head] = latencyMs;
-    this._head = (this._head + 1) % this._maxSamples;
-    if (this._count < this._maxSamples) this._count++;
-    
-    return latencyMs;
-  },
-  
-  /** Get average latency */
-  getAverage() {
-    if (this._count === 0) return null;
-    let sum = 0;
-    for (let i = 0; i < this._count; i++) {
-      sum += this._samples[i];
-    }
-    return sum / this._count;
-  },
-  
-  /** Get min/max/avg stats with high precision */
-  getStats() {
-    if (this._count === 0) {
-      return { min: null, max: null, avg: null, p50: null, p99: null, samples: 0 };
-    }
-    
-    const valid = [];
-    for (let i = 0; i < this._count; i++) {
-      valid.push(this._samples[i]);
-    }
-    valid.sort((a, b) => a - b);
-    
-    const sum = valid.reduce((a, b) => a + b, 0);
-    
-    return {
-      min: valid[0],
-      max: valid[valid.length - 1],
-      avg: sum / valid.length,
-      p50: valid[Math.floor(valid.length * 0.5)],
-      p99: valid[Math.floor(valid.length * 0.99)] || valid[valid.length - 1],
-      samples: this._count,
-    };
-  },
-  
-  /** Get last N latency samples */
-  getRecent(n = 10) {
-    if (this._count === 0) return [];
-    const result = [];
-    const start = this._count < this._maxSamples ? 0 : this._head;
-    for (let i = 0; i < Math.min(n, this._count); i++) {
-      const idx = (start + this._count - 1 - i + this._maxSamples) % this._maxSamples;
-      result.push(this._samples[idx]);
-    }
-    return result;
-  },
-  
-  /** Clear all tracking data */
-  clear() {
-    this._pending.clear();
-    this._head = 0;
-    this._count = 0;
-    if (this._samples) {
-      this._samples.fill(0);
-    }
-  }
-};
-
-/**
- * Pre-allocated fill info pool for zero-allocation in hot path
- */
-const FillInfoPool = {
-  _template: {
-    orderTag: null,
-    basketId: null,
-    orderId: null,
-    status: null,
-    symbol: null,
-    exchange: null,
-    accountId: null,
-    fillQuantity: 0,
-    totalFillQuantity: 0,
-    remainingQuantity: 0,
-    avgFillPrice: 0,
-    lastFillPrice: 0,
-    transactionType: 0,
-    orderType: 0,
-    quantity: 0,
-    ssboe: 0,
-    usecs: 0,
-    localTimestamp: 0,
-    roundTripLatencyMs: null,
-  },
-  
-  /** Fill template with notification data */
-  fill(notif, receiveTime, latency) {
-    const o = this._template;
-    o.orderTag = notif.userTag || null;
-    o.basketId = notif.basketId;
-    o.orderId = notif.exchangeOrderId || notif.orderId;
-    o.status = notif.status;
-    o.symbol = notif.symbol;
-    o.exchange = notif.exchange;
-    o.accountId = notif.accountId;
-    o.fillQuantity = notif.totalFillSize || notif.fillQuantity || 0;
-    o.totalFillQuantity = notif.totalFillSize || notif.totalFillQuantity || 0;
-    o.remainingQuantity = notif.totalUnfilledSize || notif.remainingQuantity || 0;
-    o.avgFillPrice = parseFloat(notif.avgFillPrice || 0);
-    o.lastFillPrice = parseFloat(notif.price || notif.fillPrice || 0);
-    o.transactionType = notif.transactionType;
-    o.orderType = notif.priceType || notif.orderType;
-    o.quantity = notif.quantity;
-    o.ssboe = notif.ssboe;
-    o.usecs = notif.usecs;
-    o.localTimestamp = receiveTime;
-    o.roundTripLatencyMs = latency;
-    return o;
-  },
-  
-  /** Create a copy for async operations */
-  clone(fillInfo) {
-    return { ...fillInfo };
-  }
-};
-
-module.exports = {
-  hrNow,
-  nsToMs,
-  LatencyTracker,
-  FillInfoPool,
-};