hedgequantx 2.6.162 → 2.7.0

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