hedgequantx 1.8.48 → 2.3.0

package/src/services/tradovate/index.js

@@ -1,57 +1,79 @@
 /**
- * Tradovate Service
- * Main service for Tradovate prop firm connections (Apex, TakeProfitTrader)
+ * @fileoverview Tradovate Service - Main service for Tradovate prop firm connections
+ * @module services/tradovate
  * 
  * STRICT RULE: Display ONLY values returned by API. No estimation, no simulation.
  */
 
-const https = require('https');
+const crypto = require('crypto');
+const os = require('os');
 const EventEmitter = require('events');
-const { TRADOVATE_URLS, API_PATHS, WS_EVENTS, getBaseUrl, getTradingWebSocketUrl } = require('./constants');
+const { request } = require('../../utils/http');
+const { TIMEOUTS } = require('../../config/settings');
+const { TRADOVATE_URLS, API_PATHS, getBaseUrl, getTradingWebSocketUrl } = require('./constants');
 const { checkMarketHours, isDST } = require('./market');
 const { connectWebSocket, wsSend, disconnectWebSocket } = require('./websocket');
+const { logger } = require('../../utils/logger');
 
+const log = logger.scope('Tradovate');
+
+/** PropFirm configurations */
+const PROPFIRM_CONFIGS = {
+  apex_tradovate: { name: 'Apex (Tradovate)', isDemo: false },
+  takeprofittrader: { name: 'TakeProfitTrader', isDemo: false },
+  myfundedfutures: { name: 'MyFundedFutures', isDemo: false },
+};
+
+/**
+ * Tradovate Service for prop firm trading
+ */
 class TradovateService extends EventEmitter {
+  /**
+   * @param {string} propfirmKey - PropFirm identifier
+   */
   constructor(propfirmKey) {
     super();
     this.propfirmKey = propfirmKey;
-    this.propfirm = this.getPropFirmConfig(propfirmKey);
+    this.propfirm = PROPFIRM_CONFIGS[propfirmKey] || { name: propfirmKey, isDemo: false };
+    
+    // Auth
     this.accessToken = null;
     this.mdAccessToken = null;
     this.userId = null;
     this.tokenExpiration = null;
+    
+    // State
     this.accounts = [];
     this.user = null;
-    this.isDemo = true; // Default to demo
+    this.isDemo = true;
+    this.credentials = null;
+    
+    // WebSocket
     this.ws = null;
     this.wsRequestId = 1;
     this.renewalTimer = null;
-    this.credentials = null; // Store for session restore
+    
+    // Device ID cache
+    this._deviceId = null;
   }
 
-  /**
-   * Get PropFirm configuration
-   */
-  getPropFirmConfig(key) {
-    const propfirms = {
-      'apex_tradovate': { name: 'Apex (Tradovate)', isDemo: false },
-      'takeprofittrader': { name: 'TakeProfitTrader', isDemo: false },
-      'myfundedfutures': { name: 'MyFundedFutures', isDemo: false },
-    };
-    return propfirms[key] || { name: key, isDemo: false };
-  }
+  // ==================== AUTH ====================
 
   /**
    * Login to Tradovate
+   * @param {string} username - Username
+   * @param {string} password - Password
+   * @param {Object} [options] - Additional options (cid, sec)
+   * @returns {Promise<{success: boolean, error?: string}>}
    */
   async login(username, password, options = {}) {
     try {
       const authData = {
         name: username,
-        password: password,
+        password,
         appId: 'HQX-CLI',
-        appVersion: '1.0.0',
-        deviceId: this.generateDeviceId(),
+        appVersion: '2.0.0',
+        deviceId: this._getDeviceId(),
       };
 
       if (options.cid) authData.cid = options.cid;
@@ -59,81 +81,132 @@ class TradovateService extends EventEmitter {
 
       const result = await this._request(API_PATHS.AUTH_TOKEN_REQUEST, 'POST', authData);
 
-      if (result.errorText) {
-        return { success: false, error: result.errorText };
+      if (result.data.errorText) {
+        log.warn('Login failed', { error: result.data.errorText });
+        return { success: false, error: result.data.errorText };
       }
 
-      if (!result.accessToken) {
+      if (!result.data.accessToken) {
         return { success: false, error: 'No access token received' };
       }
 
-      this.accessToken = result.accessToken;
-      this.mdAccessToken = result.mdAccessToken;
-      this.userId = result.userId;
-      this.tokenExpiration = new Date(result.expirationTime);
-      this.user = { userName: result.name, userId: result.userId };
+      this.accessToken = result.data.accessToken;
+      this.mdAccessToken = result.data.mdAccessToken;
+      this.userId = result.data.userId;
+      this.tokenExpiration = new Date(result.data.expirationTime);
+      this.user = { userName: result.data.name, userId: result.data.userId };
       this.credentials = { username, password };
 
-      this.setupTokenRenewal();
-      await this.fetchAccounts();
+      this._setupTokenRenewal();
+      await this._fetchAccounts();
 
+      log.info('Login successful', { accounts: this.accounts.length });
       return { success: true };
-    } catch (error) {
-      return { success: false, error: error.message };
+    } catch (err) {
+      log.error('Login error', { error: err.message });
+      return { success: false, error: err.message };
     }
   }
 
   /**
-   * Fetch accounts
+   * Generate device ID (cached)
+   * @private
    */
-  async fetchAccounts() {
-    try {
-      const accounts = await this._request(API_PATHS.ACCOUNT_LIST, 'GET');
-      
-      if (Array.isArray(accounts)) {
-        this.accounts = accounts;
-        
-        for (const acc of this.accounts) {
-          try {
-            const cashBalance = await this._request(
-              API_PATHS.CASH_BALANCE_SNAPSHOT,
-              'POST',
-              { accountId: acc.id }
-            );
-            acc.cashBalance = cashBalance;
-          } catch (e) {
-            acc.cashBalance = null;
-          }
-        }
+  _getDeviceId() {
+    if (this._deviceId) return this._deviceId;
+    
+    const data = `${os.hostname()}-${os.platform()}-${os.arch()}-hqx-cli`;
+    this._deviceId = crypto.createHash('md5').update(data).digest('hex');
+    return this._deviceId;
+  }
+
+  /**
+   * Setup automatic token renewal
+   * @private
+   */
+  _setupTokenRenewal() {
+    if (this.renewalTimer) {
+      clearTimeout(this.renewalTimer);
+    }
+
+    // Renew 15 minutes before expiration
+    const renewInMs = (90 - 15) * 60 * 1000;
+
+    this.renewalTimer = setTimeout(async () => {
+      try {
+        await this._renewToken();
+      } catch (err) {
+        log.warn('Token renewal failed', { error: err.message });
       }
+    }, renewInMs);
+  }
+
+  /**
+   * Renew access token
+   * @private
+   */
+  async _renewToken() {
+    if (!this.accessToken) return;
+
+    const result = await this._request(API_PATHS.AUTH_RENEW_TOKEN, 'GET');
+
+    if (result.data.accessToken) {
+      this.accessToken = result.data.accessToken;
+      this.mdAccessToken = result.data.mdAccessToken;
+      this.tokenExpiration = new Date(result.data.expirationTime);
+      this._setupTokenRenewal();
+      log.debug('Token renewed');
+    }
+  }
+
+  // ==================== ACCOUNTS ====================
+
+  /**
+   * Fetch accounts from API
+   * @private
+   */
+  async _fetchAccounts() {
+    const result = await this._request(API_PATHS.ACCOUNT_LIST, 'GET');
+
+    if (!Array.isArray(result.data)) {
+      return;
+    }
+
+    this.accounts = result.data;
 
-      return this.accounts;
-    } catch (error) {
-      throw error;
+    // Fetch cash balance for each account
+    for (const acc of this.accounts) {
+      try {
+        const balanceResult = await this._request(
+          API_PATHS.CASH_BALANCE_SNAPSHOT,
+          'POST',
+          { accountId: acc.id }
+        );
+        acc.cashBalance = balanceResult.data;
+      } catch {
+        acc.cashBalance = null;
+      }
     }
   }
 
   /**
-   * Get trading accounts - ONLY returns values from API
-   * No estimation, no simulation
+   * Get trading accounts with REAL P&L from API
+   * @returns {Promise<{success: boolean, accounts: Array}>}
    */
   async getTradingAccounts() {
-    if (this.accounts.length === 0) {
-      await this.fetchAccounts();
+    if (!this.accounts.length) {
+      await this._fetchAccounts();
     }
 
     const tradingAccounts = this.accounts.map((acc) => {
       const cb = acc.cashBalance || {};
-      
+
       // ONLY use values from API - null if not available
-      const balance = cb.totalCashValue !== undefined ? cb.totalCashValue : 
-                      (cb.netLiquidatingValue !== undefined ? cb.netLiquidatingValue : null);
-      
-      // P&L from API only - null if not available
-      const realizedPnL = cb.realizedPnL !== undefined ? cb.realizedPnL : null;
-      const openPnL = cb.openPnL !== undefined ? cb.openPnL : null;
-      
-      // Total P&L from API
+      const balance = cb.totalCashValue ?? cb.netLiquidatingValue ?? null;
+      const realizedPnL = cb.realizedPnL ?? null;
+      const openPnL = cb.openPnL ?? null;
+
+      // Total P&L
       let profitAndLoss = null;
       if (cb.totalPnL !== undefined) {
         profitAndLoss = cb.totalPnL;
@@ -146,12 +219,11 @@ class TradovateService extends EventEmitter {
         tradovateAccountId: acc.id,
         accountName: acc.name,
         name: acc.name,
-        // From API only - null if not available
-        balance: balance,
+        balance,
         todayPnL: realizedPnL,
-        openPnL: openPnL,
-        profitAndLoss: profitAndLoss,
-        startingBalance: null,  // API doesn't provide this
+        openPnL,
+        profitAndLoss,
+        startingBalance: null,
         status: acc.active ? 0 : 3,
         platform: 'Tradovate',
         propfirm: this.propfirm.name,
@@ -162,31 +234,61 @@ class TradovateService extends EventEmitter {
     return { success: true, accounts: tradingAccounts };
   }
 
+  // ==================== POSITIONS ====================
+
   /**
    * Get positions for an account
+   * @param {number} accountId - Account ID
+   * @returns {Promise<Array>}
    */
   async getPositions(accountId) {
     try {
-      const positions = await this._request(API_PATHS.POSITION_DEPS, 'GET', null, { masterid: accountId });
-      return positions.filter(p => p.netPos !== 0);
-    } catch (error) {
+      const result = await this._request(API_PATHS.POSITION_DEPS, 'GET', null, { masterid: accountId });
+      return result.data.filter(p => p.netPos !== 0);
+    } catch {
       return [];
     }
   }
 
+  // ==================== ORDERS ====================
+
   /**
-   * Get fills/trades
+   * Get orders
+   * @param {number} [accountId] - Optional account filter
+   * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
    */
-  async getFills() {
+  async getOrders(accountId) {
     try {
-      return await this._request(API_PATHS.FILL_LIST, 'GET');
-    } catch (error) {
-      return [];
+      const result = await this._request(API_PATHS.ORDER_LIST, 'GET');
+      const orders = Array.isArray(result.data) ? result.data : [];
+      
+      const filtered = accountId
+        ? orders.filter(o => o.accountId === accountId)
+        : orders;
+
+      return {
+        success: true,
+        orders: filtered.map(o => ({
+          orderId: o.id,
+          accountId: o.accountId,
+          symbol: o.contractId,
+          side: o.action === 'Buy' ? 0 : 1,
+          quantity: o.orderQty,
+          filledQuantity: o.filledQty || 0,
+          price: o.price,
+          status: o.ordStatus === 'Working' ? 1 : (o.ordStatus === 'Filled' ? 2 : 0),
+          orderType: o.orderType,
+        })),
+      };
+    } catch (err) {
+      return { success: false, error: err.message, orders: [] };
     }
   }
 
   /**
    * Place an order
+   * @param {Object} orderData - Order details
+   * @returns {Promise<{success: boolean, orderId?: number, error?: string}>}
    */
   async placeOrder(orderData) {
     try {
@@ -200,159 +302,93 @@ class TradovateService extends EventEmitter {
         isAutomated: true,
       });
 
-      if (result.errorText || result.failureReason) {
-        return { success: false, error: result.errorText || result.failureText };
+      if (result.data.errorText || result.data.failureReason) {
+        return { success: false, error: result.data.errorText || result.data.failureText };
       }
 
-      return { success: true, orderId: result.orderId };
-    } catch (error) {
-      return { success: false, error: error.message };
+      log.info('Order placed', { orderId: result.data.orderId });
+      return { success: true, orderId: result.data.orderId };
+    } catch (err) {
+      return { success: false, error: err.message };
     }
   }
 
   /**
    * Cancel an order
+   * @param {number} orderId - Order ID
+   * @returns {Promise<{success: boolean, error?: string}>}
    */
   async cancelOrder(orderId) {
     try {
       const result = await this._request(API_PATHS.ORDER_CANCEL, 'POST', {
-        orderId: orderId,
+        orderId,
         isAutomated: true,
       });
 
-      if (result.errorText) {
-        return { success: false, error: result.errorText };
+      if (result.data.errorText) {
+        return { success: false, error: result.data.errorText };
       }
 
       return { success: true };
-    } catch (error) {
-      return { success: false, error: error.message };
+    } catch (err) {
+      return { success: false, error: err.message };
     }
   }
 
   /**
    * Close a position
+   * @param {number} accountId - Account ID
+   * @param {number} contractId - Contract ID
+   * @returns {Promise<{success: boolean, error?: string}>}
    */
   async closePosition(accountId, contractId) {
     try {
       const result = await this._request(API_PATHS.ORDER_LIQUIDATE_POSITION, 'POST', {
-        accountId: accountId,
-        contractId: contractId,
+        accountId,
+        contractId,
         isAutomated: true,
       });
 
-      if (result.errorText) {
-        return { success: false, error: result.errorText };
+      if (result.data.errorText) {
+        return { success: false, error: result.data.errorText };
       }
 
       return { success: true };
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Search contracts
-   */
-  async searchContracts(text, limit = 10) {
-    try {
-      return await this._request(API_PATHS.CONTRACT_SUGGEST, 'GET', null, { t: text, l: limit });
-    } catch (error) {
-      return [];
+    } catch (err) {
+      return { success: false, error: err.message };
     }
   }
 
-  /**
-   * Get user info
-   */
-  async getUser() {
-    return this.user;
-  }
-
-  /**
-   * Get market status
-   */
-  async getMarketStatus(accountId) {
-    const marketHours = checkMarketHours();
-    return {
-      success: true,
-      isOpen: marketHours.isOpen,
-      message: marketHours.message,
-    };
-  }
-
-  /**
-   * Get token
-   */
-  getToken() {
-    return this.accessToken;
-  }
+  // ==================== TRADES ====================
 
   /**
-   * Get orders for an account
-   */
-  async getOrders(accountId) {
-    try {
-      const orders = await this._request(API_PATHS.ORDER_LIST, 'GET');
-      const filtered = accountId 
-        ? orders.filter(o => o.accountId === accountId)
-        : orders;
-      return { 
-        success: true, 
-        orders: filtered.map(o => ({
-          orderId: o.id,
-          accountId: o.accountId,
-          symbol: o.contractId,
-          side: o.action === 'Buy' ? 0 : 1,
-          quantity: o.orderQty,
-          filledQuantity: o.filledQty || 0,
-          price: o.price,
-          status: o.ordStatus === 'Working' ? 1 : (o.ordStatus === 'Filled' ? 2 : 0),
-          orderType: o.orderType,
-        }))
-      };
-    } catch (error) {
-      return { success: false, error: error.message, orders: [] };
-    }
-  }
-
-  /**
-   * Get order history
+   * Get fills/trades
+   * @returns {Promise<Array>}
    */
-  async getOrderHistory(days = 30) {
+  async getFills() {
     try {
-      const orders = await this._request(API_PATHS.ORDER_LIST, 'GET');
-      return { success: true, orders };
-    } catch (error) {
-      return { success: false, error: error.message, orders: [] };
+      const result = await this._request(API_PATHS.FILL_LIST, 'GET');
+      return result.data || [];
+    } catch {
+      return [];
     }
   }
 
-  /**
-   * Get lifetime stats (stub - Tradovate doesn't provide this directly)
-   */
-  async getLifetimeStats(accountId) {
-    return { success: true, stats: null };
-  }
-
-  /**
-   * Get daily stats (stub - Tradovate doesn't provide this directly)
-   */
-  async getDailyStats(accountId) {
-    return { success: true, stats: [] };
-  }
-
   /**
    * Get trade history
+   * @param {number} [accountId] - Account filter
+   * @param {number} [days=30] - Days of history
+   * @returns {Promise<{success: boolean, trades: Array, error?: string}>}
    */
   async getTradeHistory(accountId, days = 30) {
     try {
       const fills = await this.getFills();
-      const filtered = accountId 
+      const filtered = accountId
         ? fills.filter(f => f.accountId === accountId)
         : fills;
-      return { 
-        success: true, 
+
+      return {
+        success: true,
         trades: filtered.map(f => ({
           tradeId: f.id,
           accountId: f.accountId,
@@ -361,69 +397,92 @@ class TradovateService extends EventEmitter {
           quantity: f.qty,
           price: f.price,
           timestamp: f.timestamp,
-        }))
+        })),
       };
-    } catch (error) {
-      return { success: false, error: error.message, trades: [] };
+    } catch (err) {
+      return { success: false, error: err.message, trades: [] };
     }
   }
 
   /**
-   * Setup automatic token renewal
+   * Get order history
+   * @param {number} [days=30] - Days of history
+   * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
    */
-  setupTokenRenewal() {
-    if (this.renewalTimer) {
-      clearTimeout(this.renewalTimer);
+  async getOrderHistory(days = 30) {
+    try {
+      const result = await this._request(API_PATHS.ORDER_LIST, 'GET');
+      return { success: true, orders: result.data || [] };
+    } catch (err) {
+      return { success: false, error: err.message, orders: [] };
     }
-
-    // Renew 15 minutes before expiration
-    const renewInMs = (90 - 15) * 60 * 1000;
-
-    this.renewalTimer = setTimeout(async () => {
-      try {
-        await this.renewToken();
-      } catch (error) {
-        // Silent fail
-      }
-    }, renewInMs);
   }
 
+  // ==================== CONTRACTS ====================
+
   /**
-   * Renew access token
+   * Search contracts
+   * @param {string} text - Search text
+   * @param {number} [limit=10] - Result limit
+   * @returns {Promise<Array>}
    */
-  async renewToken() {
-    if (!this.accessToken) return;
-
+  async searchContracts(text, limit = 10) {
     try {
-      const result = await this._request(API_PATHS.AUTH_RENEW_TOKEN, 'GET');
-
-      if (result.accessToken) {
-        this.accessToken = result.accessToken;
-        this.mdAccessToken = result.mdAccessToken;
-        this.tokenExpiration = new Date(result.expirationTime);
-        this.setupTokenRenewal();
-      }
-    } catch (error) {
-      // Silent fail - will need to re-login
+      const result = await this._request(API_PATHS.CONTRACT_SUGGEST, 'GET', null, { t: text, l: limit });
+      return result.data || [];
+    } catch {
+      return [];
     }
   }
 
-  /**
-   * Connect to WebSocket for real-time updates
-   */
-  async connectWebSocket() {
-    return connectWebSocket(this);
+  // ==================== STUBS ====================
+
+  async getUser() { return this.user; }
+  async getLifetimeStats() { return { success: true, stats: null }; }
+  async getDailyStats() { return { success: true, stats: [] }; }
+
+  getToken() { return this.accessToken; }
+
+  async getMarketStatus() {
+    const hours = checkMarketHours();
+    return { success: true, isOpen: hours.isOpen, message: hours.message };
   }
 
-  /**
-   * Send WebSocket message
-   */
+  // ==================== WEBSOCKET ====================
+
+  async connectWebSocket() { return connectWebSocket(this); }
+  
   wsSend(url, query = '', body = null) {
     return wsSend(this, url, query, body);
   }
 
+  // ==================== HTTP ====================
+
+  /**
+   * Make an HTTP request
+   * @private
+   */
+  async _request(path, method = 'GET', body = null, queryParams = null) {
+    const baseUrl = getBaseUrl(this.isDemo);
+    let url = `${baseUrl}${path}`;
+
+    if (queryParams) {
+      const params = new URLSearchParams(queryParams).toString();
+      url += `?${params}`;
+    }
+
+    return request(url, {
+      method,
+      body,
+      token: this.accessToken,
+      timeout: TIMEOUTS.API_REQUEST,
+    });
+  }
+
+  // ==================== CLEANUP ====================
+
   /**
-   * Disconnect
+   * Disconnect and cleanup
    */
   async disconnect() {
     if (this.renewalTimer) {
@@ -438,78 +497,8 @@ class TradovateService extends EventEmitter {
     this.accounts = [];
     this.user = null;
     this.credentials = null;
-  }
-
-  /**
-   * Generate device ID
-   */
-  generateDeviceId() {
-    const crypto = require('crypto');
-    const os = require('os');
-    const data = `${os.hostname()}-${os.platform()}-${os.arch()}-hqx-cli`;
-    return crypto.createHash('md5').update(data).digest('hex');
-  }
-
-  /**
-   * HTTP request helper
-   */
-  _request(path, method = 'GET', body = null, queryParams = null) {
-    return new Promise((resolve, reject) => {
-      const baseUrl = getBaseUrl(this.isDemo);
-      const url = new URL(baseUrl + path);
-
-      if (queryParams) {
-        Object.entries(queryParams).forEach(([key, value]) => {
-          url.searchParams.append(key, value);
-        });
-      }
-
-      const postData = body ? JSON.stringify(body) : null;
-
-      const options = {
-        hostname: url.hostname,
-        port: 443,
-        path: url.pathname + url.search,
-        method: method,
-        headers: {
-          'Content-Type': 'application/json',
-          'Accept': 'application/json',
-        },
-      };
-
-      if (postData) {
-        options.headers['Content-Length'] = Buffer.byteLength(postData);
-      }
-
-      if (this.accessToken) {
-        options.headers['Authorization'] = `Bearer ${this.accessToken}`;
-      }
-
-      const req = https.request(options, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-          try {
-            const json = JSON.parse(data);
-            resolve(json);
-          } catch (e) {
-            resolve(data);
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.setTimeout(30000, () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
 
-      if (postData) {
-        req.write(postData);
-      }
-
-      req.end();
-    });
+    log.info('Disconnected');
   }
 }