hedgequantx 2.6.161 → 2.6.162

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

@@ -0,0 +1,182 @@
+/**
+ * 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,
+};

package/src/services/rithmic/specs.js

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview Rithmic Specifications and Configurations
+ * CME Contract Specifications and PropFirm configurations
+ * 
+ * NO FAKE DATA - These are official exchange constants
+ */
+
+const { RITHMIC_ENDPOINTS, RITHMIC_SYSTEMS } = require('./constants');
+
+/**
+ * CME Contract Specifications - Official exchange tick sizes, values, and names
+ * These are technical constants defined by the exchange, not market data.
+ * Source: CME Group contract specifications
+ */
+const CME_CONTRACT_SPECS = {
+  // E-mini Index Futures (CME)
+  ES: { tickSize: 0.25, tickValue: 12.50, name: 'E-mini S&P 500' },
+  NQ: { tickSize: 0.25, tickValue: 5.00, name: 'E-mini NASDAQ-100' },
+  RTY: { tickSize: 0.10, tickValue: 5.00, name: 'E-mini Russell 2000' },
+  YM: { tickSize: 1.00, tickValue: 5.00, name: 'E-mini Dow' },
+  
+  // Micro Index Futures (CME)
+  MES: { tickSize: 0.25, tickValue: 1.25, name: 'Micro E-mini S&P 500' },
+  MNQ: { tickSize: 0.25, tickValue: 0.50, name: 'Micro E-mini NASDAQ-100' },
+  M2K: { tickSize: 0.10, tickValue: 0.50, name: 'Micro E-mini Russell 2000' },
+  MYM: { tickSize: 1.00, tickValue: 0.50, name: 'Micro E-mini Dow' },
+  
+  // Energy Futures (NYMEX)
+  CL: { tickSize: 0.01, tickValue: 10.00, name: 'Crude Oil' },
+  QM: { tickSize: 0.025, tickValue: 12.50, name: 'E-mini Crude Oil' },
+  MCL: { tickSize: 0.01, tickValue: 1.00, name: 'Micro Crude Oil' },
+  NG: { tickSize: 0.001, tickValue: 10.00, name: 'Natural Gas' },
+  QG: { tickSize: 0.005, tickValue: 12.50, name: 'E-mini Natural Gas' },
+  
+  // Metal Futures (COMEX)
+  GC: { tickSize: 0.10, tickValue: 10.00, name: 'Gold' },
+  MGC: { tickSize: 0.10, tickValue: 1.00, name: 'Micro Gold' },
+  SI: { tickSize: 0.005, tickValue: 25.00, name: 'Silver' },
+  SIL: { tickSize: 0.005, tickValue: 2.50, name: '1000oz Silver' },
+  HG: { tickSize: 0.0005, tickValue: 12.50, name: 'Copper' },
+  MHG: { tickSize: 0.0005, tickValue: 1.25, name: 'Micro Copper' },
+  
+  // Treasury Futures (CBOT)
+  ZB: { tickSize: 0.03125, tickValue: 31.25, name: '30-Year T-Bond' },
+  ZN: { tickSize: 0.015625, tickValue: 15.625, name: '10-Year T-Note' },
+  ZF: { tickSize: 0.0078125, tickValue: 7.8125, name: '5-Year T-Note' },
+  ZT: { tickSize: 0.0078125, tickValue: 15.625, name: '2-Year T-Note' },
+  
+  // Agricultural Futures (CBOT)
+  ZC: { tickSize: 0.25, tickValue: 12.50, name: 'Corn' },
+  ZS: { tickSize: 0.25, tickValue: 12.50, name: 'Soybeans' },
+  ZW: { tickSize: 0.25, tickValue: 12.50, name: 'Wheat' },
+  ZL: { tickSize: 0.01, tickValue: 6.00, name: 'Soybean Oil' },
+  ZM: { tickSize: 0.10, tickValue: 10.00, name: 'Soybean Meal' },
+  
+  // Currency Futures (CME)
+  '6E': { tickSize: 0.00005, tickValue: 6.25, name: 'Euro FX' },
+  '6J': { tickSize: 0.0000005, tickValue: 6.25, name: 'Japanese Yen' },
+  '6B': { tickSize: 0.0001, tickValue: 6.25, name: 'British Pound' },
+  '6A': { tickSize: 0.0001, tickValue: 10.00, name: 'Australian Dollar' },
+  '6C': { tickSize: 0.00005, tickValue: 5.00, name: 'Canadian Dollar' },
+  '6M': { tickSize: 0.0001, tickValue: 5.00, name: 'Mexican Peso' },
+  
+  // Nikkei (CME)
+  NKD: { tickSize: 5.0, tickValue: 25.00, name: 'Nikkei 225' },
+  
+  // VIX Futures (CFE)
+  VX: { tickSize: 0.05, tickValue: 50.00, name: 'VIX Futures' },
+};
+
+/**
+ * PropFirm configurations
+ */
+const PROPFIRM_CONFIGS = {
+  apex: { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  apex_rithmic: { name: 'Apex Trader Funding', systemName: 'Apex', gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  topstep_r: { name: 'Topstep (Rithmic)', systemName: RITHMIC_SYSTEMS.TOPSTEP, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  bulenox_r: { name: 'Bulenox (Rithmic)', systemName: RITHMIC_SYSTEMS.BULENOX, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  earn2trade: { name: 'Earn2Trade', systemName: RITHMIC_SYSTEMS.EARN_2_TRADE, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  mescapital: { name: 'MES Capital', systemName: RITHMIC_SYSTEMS.MES_CAPITAL, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  tradefundrr: { name: 'TradeFundrr', systemName: RITHMIC_SYSTEMS.TRADEFUNDRR, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  thetradingpit: { name: 'The Trading Pit', systemName: RITHMIC_SYSTEMS.THE_TRADING_PIT, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  fundedfutures: { name: 'Funded Futures Network', systemName: RITHMIC_SYSTEMS.FUNDED_FUTURES_NETWORK, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  propshop: { name: 'PropShop Trader', systemName: RITHMIC_SYSTEMS.PROPSHOP_TRADER, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  '4proptrader': { name: '4PropTrader', systemName: RITHMIC_SYSTEMS.FOUR_PROP_TRADER, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  daytraders: { name: 'DayTraders.com', systemName: RITHMIC_SYSTEMS.DAY_TRADERS, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  '10xfutures': { name: '10X Futures', systemName: RITHMIC_SYSTEMS.TEN_X_FUTURES, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  lucidtrading: { name: 'Lucid Trading', systemName: RITHMIC_SYSTEMS.LUCID_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  thrivetrading: { name: 'Thrive Trading', systemName: RITHMIC_SYSTEMS.THRIVE_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+  legendstrading: { name: 'Legends Trading', systemName: RITHMIC_SYSTEMS.LEGENDS_TRADING, gateway: RITHMIC_ENDPOINTS.CHICAGO },
+};
+
+/**
+ * Get tick multiplier for P&L calculation
+ * @param {string} symbol - Trading symbol
+ * @returns {number} Multiplier for P&L calculation
+ */
+const getTickMultiplier = (symbol) => {
+  const sym = (symbol || '').toUpperCase();
+  if (sym.startsWith('ES')) return 50;      // E-mini S&P 500: $50 per point
+  if (sym.startsWith('NQ')) return 20;      // E-mini Nasdaq: $20 per point
+  if (sym.startsWith('YM')) return 5;       // E-mini Dow: $5 per point
+  if (sym.startsWith('RTY')) return 50;     // E-mini Russell: $50 per point
+  if (sym.startsWith('MES')) return 5;      // Micro E-mini S&P: $5 per point
+  if (sym.startsWith('MNQ')) return 2;      // Micro E-mini Nasdaq: $2 per point
+  if (sym.startsWith('GC')) return 100;     // Gold: $100 per point
+  if (sym.startsWith('SI')) return 5000;    // Silver: $5000 per point
+  if (sym.startsWith('CL')) return 1000;    // Crude Oil: $1000 per point
+  if (sym.startsWith('NG')) return 10000;   // Natural Gas: $10000 per point
+  if (sym.startsWith('ZB') || sym.startsWith('ZN')) return 1000; // Bonds
+  if (sym.startsWith('6E')) return 125000;  // Euro FX
+  if (sym.startsWith('6J')) return 12500000; // Japanese Yen
+  return 1; // Default
+};
+
+/**
+ * Check market hours
+ * @returns {{isOpen: boolean, message: string}}
+ */
+const checkMarketHours = () => {
+  const now = new Date();
+  const utcDay = now.getUTCDay();
+  const utcHour = now.getUTCHours();
+
+  const isDST = now.getTimezoneOffset() < Math.max(
+    new Date(now.getFullYear(), 0, 1).getTimezoneOffset(),
+    new Date(now.getFullYear(), 6, 1).getTimezoneOffset()
+  );
+  const ctOffset = isDST ? 5 : 6;
+  const ctHour = (utcHour - ctOffset + 24) % 24;
+  const ctDay = utcHour < ctOffset ? (utcDay + 6) % 7 : utcDay;
+
+  if (ctDay === 6) return { isOpen: false, message: 'Market closed (Saturday)' };
+  if (ctDay === 0 && ctHour < 17) return { isOpen: false, message: 'Market opens Sunday 5:00 PM CT' };
+  if (ctDay === 5 && ctHour >= 16) return { isOpen: false, message: 'Market closed (Friday after 4PM CT)' };
+  if (ctHour === 16 && ctDay >= 1 && ctDay <= 4) return { isOpen: false, message: 'Daily maintenance (4:00-5:00 PM CT)' };
+  
+  return { isOpen: true, message: 'Market is open' };
+};
+
+module.exports = {
+  CME_CONTRACT_SPECS,
+  PROPFIRM_CONFIGS,
+  getTickMultiplier,
+  checkMarketHours,
+};

package/src/services/rithmic/trade-history.js

@@ -0,0 +1,254 @@
+/**
+ * @fileoverview Rithmic Trade History
+ * Handles trade history fetching and P&L calculation
+ * 
+ * NO FAKE DATA - Only real values from Rithmic API
+ */
+
+const { logger } = require('../../utils/logger');
+const { getTickMultiplier } = require('./specs');
+
+const log = logger.scope('RithmicTradeHistory');
+
+/**
+ * Get trade history from Rithmic API
+ * Uses RequestShowOrderHistory to fetch historical fills
+ * @param {Object} service - RithmicService instance
+ * @param {string} accountId - Optional account filter
+ * @param {number} days - Number of days to fetch (default: 30)
+ * @returns {Promise<{success: boolean, trades: Array}>}
+ */
+const getTradeHistory = async (service, accountId, days = 30) => {
+  if (!service.orderConn || !service.loginInfo) {
+    return { success: true, trades: service.completedTrades || [] };
+  }
+
+  return new Promise((resolve) => {
+    const historyOrders = [];
+    let resolved = false;
+    
+    // Timeout after 5 seconds
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        // Combine API history with session trades
+        const allTrades = [...processHistoryToTrades(historyOrders, service), ...service.completedTrades];
+        resolve({ success: true, trades: allTrades });
+      }
+    }, 5000);
+    
+    // Listen for order history snapshots
+    const onOrderNotification = (data) => {
+      try {
+        if (data.isSnapshot || data.status === 'complete' || data.status === 'Complete') {
+          const order = {
+            orderId: data.orderId || data.orderTag,
+            accountId: data.accountId,
+            symbol: data.symbol,
+            exchange: data.exchange,
+            side: data.transactionType === 1 ? 0 : 1,
+            quantity: data.quantity || data.totalFillQuantity || 0,
+            fillPrice: data.avgFillPrice || data.lastFillPrice || 0,
+            timestamp: data.ssboe ? data.ssboe * 1000 : Date.now(),
+            status: data.status,
+          };
+          
+          if (order.quantity > 0 && order.fillPrice > 0) {
+            historyOrders.push(order);
+          }
+        }
+      } catch (e) {
+        // Ignore parse errors
+      }
+    };
+    
+    const onHistoryComplete = () => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        const allTrades = [...processHistoryToTrades(historyOrders, service), ...service.completedTrades];
+        resolve({ success: true, trades: allTrades });
+      }
+    };
+    
+    const cleanup = () => {
+      clearTimeout(timeout);
+      service.removeListener('orderNotification', onOrderNotification);
+      service.removeListener('orderHistoryComplete', onHistoryComplete);
+    };
+    
+    service.on('orderNotification', onOrderNotification);
+    service.on('orderHistoryComplete', onHistoryComplete);
+    
+    // Request order history for each account
+    try {
+      const accounts = accountId 
+        ? service.accounts.filter(a => a.accountId === accountId)
+        : service.accounts;
+      
+      for (const acc of accounts) {
+        service.orderConn.send('RequestShowOrderHistory', {
+          templateId: 324,
+          userMsg: ['HQX-HISTORY'],
+          fcmId: acc.fcmId || service.loginInfo.fcmId,
+          ibId: acc.ibId || service.loginInfo.ibId,
+          accountId: acc.accountId,
+        });
+      }
+    } catch (e) {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        resolve({ success: false, error: e.message, trades: service.completedTrades || [] });
+      }
+    }
+  });
+};
+
+/**
+ * Process historical orders into trades with P&L
+ * Matches entries and exits to calculate P&L
+ * @param {Array} orders - Historical orders
+ * @param {Object} service - RithmicService instance (for _getTickMultiplier)
+ * @returns {Array} Processed trades
+ */
+const processHistoryToTrades = (orders, service) => {
+  const trades = [];
+  const openPositions = new Map();
+  
+  // Sort by timestamp (oldest first)
+  const sorted = [...orders].sort((a, b) => a.timestamp - b.timestamp);
+  
+  for (const order of sorted) {
+    const key = `${order.accountId}:${order.symbol}`;
+    const open = openPositions.get(key);
+    
+    if (open && open.side !== order.side) {
+      // Closing trade - calculate P&L
+      const closeQty = Math.min(order.quantity, open.quantity);
+      let pnl;
+      
+      if (open.side === 0) {
+        pnl = (order.fillPrice - open.price) * closeQty;
+      } else {
+        pnl = (open.price - order.fillPrice) * closeQty;
+      }
+      
+      const tickMultiplier = getTickMultiplier(order.symbol);
+      pnl = pnl * tickMultiplier;
+      
+      trades.push({
+        id: order.orderId,
+        accountId: order.accountId,
+        symbol: order.symbol,
+        exchange: order.exchange,
+        side: open.side,
+        size: closeQty,
+        entryPrice: open.price,
+        exitPrice: order.fillPrice,
+        price: order.fillPrice,
+        timestamp: order.timestamp,
+        creationTimestamp: new Date(order.timestamp).toISOString(),
+        status: 'CLOSED',
+        profitAndLoss: pnl,
+        pnl: pnl,
+        fees: 0,
+      });
+      
+      const remaining = open.quantity - closeQty;
+      if (remaining <= 0) {
+        openPositions.delete(key);
+      } else {
+        open.quantity = remaining;
+      }
+    } else if (open && open.side === order.side) {
+      // Adding to position
+      const totalQty = open.quantity + order.quantity;
+      open.price = ((open.price * open.quantity) + (order.fillPrice * order.quantity)) / totalQty;
+      open.quantity = totalQty;
+    } else {
+      // Opening new position
+      openPositions.set(key, {
+        side: order.side,
+        quantity: order.quantity,
+        price: order.fillPrice,
+        timestamp: order.timestamp,
+      });
+    }
+  }
+  
+  return trades;
+};
+
+/**
+ * Setup order fill listener for real-time P&L tracking
+ * @param {Object} service - RithmicService instance
+ */
+const setupOrderFillListener = (service) => {
+  service._openEntries = new Map();
+  
+  service.on('orderFilled', (fillInfo) => {
+    const key = `${fillInfo.accountId}:${fillInfo.symbol}`;
+    const side = fillInfo.transactionType === 1 ? 0 : 1;
+    const qty = fillInfo.fillQuantity || fillInfo.totalFillQuantity || 0;
+    const price = fillInfo.avgFillPrice || fillInfo.lastFillPrice || 0;
+    
+    const openEntry = service._openEntries.get(key);
+    let pnl = null;
+    
+    if (openEntry && openEntry.side !== side) {
+      // Closing trade
+      const closeQty = Math.min(qty, openEntry.qty);
+      
+      if (openEntry.side === 0) {
+        pnl = (price - openEntry.price) * closeQty;
+      } else {
+        pnl = (openEntry.price - price) * closeQty;
+      }
+      
+      const remainingQty = openEntry.qty - closeQty;
+      if (remainingQty <= 0) {
+        service._openEntries.delete(key);
+      } else {
+        openEntry.qty = remainingQty;
+      }
+      
+      service.completedTrades.push({
+        id: fillInfo.orderId || fillInfo.orderTag,
+        orderTag: fillInfo.orderTag,
+        accountId: fillInfo.accountId,
+        symbol: fillInfo.symbol,
+        exchange: fillInfo.exchange,
+        side: openEntry.side,
+        size: closeQty,
+        entryPrice: openEntry.price,
+        exitPrice: price,
+        price: price,
+        timestamp: fillInfo.localTimestamp || Date.now(),
+        creationTimestamp: new Date().toISOString(),
+        status: 'CLOSED',
+        profitAndLoss: pnl,
+        pnl: pnl,
+        fees: 0,
+      });
+      log.debug('Trade closed', { symbol: fillInfo.symbol, pnl, trades: service.completedTrades.length });
+    } else {
+      // Opening or adding to position
+      if (openEntry && openEntry.side === side) {
+        const totalQty = openEntry.qty + qty;
+        openEntry.price = ((openEntry.price * openEntry.qty) + (price * qty)) / totalQty;
+        openEntry.qty = totalQty;
+      } else {
+        service._openEntries.set(key, { side, qty, price, timestamp: Date.now() });
+      }
+      log.debug('Position opened/added', { symbol: fillInfo.symbol, side, qty, price });
+    }
+  });
+};
+
+module.exports = {
+  getTradeHistory,
+  processHistoryToTrades,
+  setupOrderFillListener,
+};