hedgequantx 1.2.147 → 1.3.1

package/src/services/projectx/index.js

@@ -0,0 +1,345 @@
+/**
+ * ProjectX API Service
+ * Main service for ProjectX prop firm connections
+ */
+
+const https = require('https');
+const { PROPFIRMS } = require('../../config');
+const { 
+  validateUsername, 
+  validatePassword, 
+  validateApiKey,
+  validateAccountId,
+  sanitizeString,
+  maskSensitive 
+} = require('../../security');
+const { getLimiter } = require('../../security/rateLimit');
+const { getMarketHolidays, checkHoliday, checkMarketHours } = require('./market');
+const { calculateLifetimeStats, calculateDailyPnL, formatTrades } = require('./stats');
+
+class ProjectXService {
+  constructor(propfirmKey = 'topstep') {
+    this.propfirm = PROPFIRMS[propfirmKey] || PROPFIRMS.topstep;
+    this.propfirmKey = propfirmKey;
+    this.token = null;
+    this.user = null;
+    this.rateLimiter = getLimiter('api');
+    this.loginLimiter = getLimiter('login');
+    this.orderLimiter = getLimiter('orders');
+  }
+
+  getToken() { return this.token; }
+  getPropfirm() { return this.propfirmKey; }
+
+  // ==================== HTTP ====================
+
+  async _request(host, path, method = 'GET', data = null, limiterType = 'api') {
+    const limiter = limiterType === 'login' ? this.loginLimiter : 
+                    limiterType === 'orders' ? this.orderLimiter : this.rateLimiter;
+    return limiter.execute(() => this._doRequest(host, path, method, data));
+  }
+
+  async _doRequest(host, path, method, data) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: host,
+        port: 443,
+        path: path,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'User-Agent': 'HedgeQuantX-CLI/1.3.0'
+        },
+        timeout: 15000
+      };
+
+      if (this.token) {
+        options.headers['Authorization'] = `Bearer ${this.token}`;
+      }
+
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            resolve({ statusCode: res.statusCode, data: JSON.parse(body) });
+          } catch (e) {
+            resolve({ statusCode: res.statusCode, data: body });
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+      if (data) req.write(JSON.stringify(data));
+      req.end();
+    });
+  }
+
+  // ==================== AUTH ====================
+
+  async login(userName, password) {
+    try {
+      validateUsername(userName);
+      validatePassword(password);
+      
+      const response = await this._request(
+        this.propfirm.userApi, '/Login', 'POST',
+        { userName: sanitizeString(userName), password },
+        'login'
+      );
+      
+      if (response.statusCode === 200 && response.data.token) {
+        this.token = response.data.token;
+        return { success: true, token: maskSensitive(this.token) };
+      }
+      
+      return { success: false, error: response.data.errorMessage || 'Invalid credentials' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async loginWithApiKey(userName, apiKey) {
+    try {
+      validateUsername(userName);
+      validateApiKey(apiKey);
+      
+      const response = await this._request(
+        this.propfirm.userApi, '/Login/key', 'POST',
+        { userName: sanitizeString(userName), apiKey },
+        'login'
+      );
+      
+      if (response.statusCode === 200 && response.data.token) {
+        this.token = response.data.token;
+        return { success: true, token: maskSensitive(this.token) };
+      }
+      
+      return { success: false, error: response.data.errorMessage || 'Invalid API key' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  logout() {
+    this.token = null;
+    this.user = null;
+  }
+
+  // ==================== USER ====================
+
+  async getUser() {
+    try {
+      const response = await this._request(this.propfirm.userApi, '/User', 'GET');
+      if (response.statusCode === 200) {
+        this.user = response.data;
+        return { success: true, user: response.data };
+      }
+      return { success: false, error: 'Failed to get user info' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  // ==================== ACCOUNTS ====================
+
+  async getTradingAccounts() {
+    try {
+      const response = await this._request(this.propfirm.userApi, '/TradingAccount', 'GET');
+      if (response.statusCode === 200) {
+        return { success: true, accounts: Array.isArray(response.data) ? response.data : [] };
+      }
+      return { success: false, accounts: [], error: 'Failed to get accounts' };
+    } catch (error) {
+      return { success: false, accounts: [], error: error.message };
+    }
+  }
+
+  // ==================== TRADING ====================
+
+  async getPositions(accountId) {
+    try {
+      const id = validateAccountId(accountId);
+      const response = await this._request(
+        this.propfirm.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 (error) {
+      return { success: true, positions: [], error: error.message };
+    }
+  }
+
+  async getOrders(accountId) {
+    try {
+      const id = validateAccountId(accountId);
+      const response = await this._request(
+        this.propfirm.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 (error) {
+      return { success: true, orders: [], error: error.message };
+    }
+  }
+
+  async placeOrder(orderData) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Order/place', 'POST', orderData, 'orders'
+      );
+      if (response.statusCode === 200 && response.data.success) {
+        return { success: true, order: response.data };
+      }
+      return { success: false, error: response.data.errorMessage || 'Order failed' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async cancelOrder(orderId) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Order/cancel', 'POST',
+        { orderId: parseInt(orderId, 10) }, 'orders'
+      );
+      return { success: response.statusCode === 200 && response.data.success };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async cancelAllOrders(accountId) {
+    try {
+      const id = validateAccountId(accountId);
+      const ordersResult = await this.getOrders(id);
+      if (!ordersResult.success || !ordersResult.orders) {
+        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 this.cancelOrder(order.orderId || order.id);
+        if (result.success) cancelled++;
+      }
+      
+      return { success: true, cancelled };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async closePosition(accountId, contractId) {
+    try {
+      const id = validateAccountId(accountId);
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Position/closeContract', 'POST',
+        { accountId: id, contractId }, 'orders'
+      );
+      return { success: response.statusCode === 200 && response.data.success };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  // ==================== TRADES & STATS ====================
+
+  async getTradeHistory(accountId, days = 30) {
+    try {
+      const id = validateAccountId(accountId);
+      const endDate = new Date();
+      const startDate = new Date();
+      startDate.setDate(startDate.getDate() - days);
+
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Trade/search', 'POST',
+        { accountId: id, startTimestamp: startDate.toISOString(), endTimestamp: endDate.toISOString() }
+      );
+
+      if (response.statusCode === 200 && response.data) {
+        let trades = Array.isArray(response.data) ? response.data : (response.data.trades || []);
+        return { success: true, trades: formatTrades(trades) };
+      }
+
+      return { success: true, trades: [] };
+    } catch (error) {
+      return { success: true, trades: [], error: error.message };
+    }
+  }
+
+  async getDailyStats(accountId) {
+    try {
+      const id = validateAccountId(accountId);
+      const now = new Date();
+      const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Trade/search', 'POST',
+        { accountId: id, startTimestamp: startOfMonth.toISOString(), endTimestamp: now.toISOString() }
+      );
+
+      if (response.statusCode === 200 && response.data) {
+        let trades = Array.isArray(response.data) ? response.data : (response.data.trades || []);
+        return { success: true, stats: calculateDailyPnL(trades) };
+      }
+
+      return { success: false, stats: [] };
+    } catch (error) {
+      return { success: false, stats: [], error: error.message };
+    }
+  }
+
+  async getLifetimeStats(accountId) {
+    try {
+      const tradesResult = await this.getTradeHistory(accountId, 90);
+      if (!tradesResult.success || tradesResult.trades.length === 0) {
+        return { success: true, stats: null };
+      }
+      return { success: true, stats: calculateLifetimeStats(tradesResult.trades) };
+    } catch (error) {
+      return { success: false, stats: null, error: error.message };
+    }
+  }
+
+  // ==================== CONTRACTS ====================
+
+  async searchContracts(searchText) {
+    try {
+      const response = await this._request(
+        this.propfirm.gatewayApi, '/api/Contract/search', 'POST',
+        { searchText: sanitizeString(searchText), live: false }
+      );
+      if (response.statusCode === 200) {
+        return { success: true, contracts: response.data.contracts || response.data || [] };
+      }
+      return { success: false, contracts: [] };
+    } catch (error) {
+      return { success: false, contracts: [], error: error.message };
+    }
+  }
+
+  // ==================== MARKET STATUS ====================
+
+  getMarketHolidays() { return getMarketHolidays(); }
+  checkHoliday() { return checkHoliday(); }
+  checkMarketHours() { return checkMarketHours(); }
+
+  async getMarketStatus(accountId) {
+    const hours = checkMarketHours();
+    return { success: true, isOpen: hours.isOpen, message: hours.message };
+  }
+}
+
+module.exports = { ProjectXService };

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