hedgequantx 1.2.35 → 1.2.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "1.2.35",
+  "version": "1.2.37",
   "description": "Prop Futures Algo Trading CLI - Connect to Topstep, Alpha Futures, and other prop firms",
   "main": "src/app.js",
   "bin": {

package/src/app.js

@@ -12,6 +12,7 @@ const path = require('path');
 
 const { ProjectXService, connections } = require('./services');
 const { RithmicService } = require('./services/rithmic');
+const { TradovateService } = require('./services/tradovate');
 const { PROPFIRM_CHOICES, getPropFirmsByPlatform, getPropFirm } = require('./config');
 const { getDevice, getSeparator, printLogo, getLogoWidth, drawBoxHeader, drawBoxFooter, centerText, createBoxMenu } = require('./ui');
 const { validateUsername, validatePassword, maskSensitive } = require('./security');
@@ -372,6 +373,88 @@ const rithmicMenu = async () => {
   }
 };
 
+/**
+ * Tradovate platform connection menu
+ */
+const tradovateMenu = async () => {
+  const propfirms = getPropFirmsByPlatform('Tradovate');
+  const boxWidth = getLogoWidth();
+  const innerWidth = boxWidth - 2;
+  
+  // Build numbered list
+  const numbered = propfirms.map((pf, i) => ({
+    num: i + 1,
+    key: pf.key,
+    name: pf.displayName
+  }));
+  
+  // PropFirm selection box
+  console.log();
+  console.log(chalk.cyan('╔' + '═'.repeat(innerWidth) + '╗'));
+  console.log(chalk.cyan('║') + chalk.white.bold(centerText('SELECT PROPFIRM (TRADOVATE)', innerWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + ' '.repeat(innerWidth) + chalk.cyan('║'));
+  
+  // Display propfirms
+  for (const item of numbered) {
+    const numStr = item.num.toString().padStart(2, ' ');
+    const text = '  ' + chalk.cyan(`[${numStr}]`) + ' ' + chalk.white(item.name);
+    const textLen = 4 + 1 + item.name.length + 2;
+    console.log(chalk.cyan('║') + text + ' '.repeat(innerWidth - textLen) + chalk.cyan('║'));
+  }
+  
+  console.log(chalk.cyan('║') + ' '.repeat(innerWidth) + chalk.cyan('║'));
+  const backText = '  ' + chalk.red('[X] Back');
+  const backLen = '[X] Back'.length + 2;
+  console.log(chalk.cyan('║') + backText + ' '.repeat(innerWidth - backLen) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
+  console.log();
+
+  const validInputs = numbered.map(n => n.num.toString());
+  validInputs.push('x', 'X');
+  
+  const { action } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'action',
+      message: chalk.cyan(`Enter choice (1-${numbered.length}/X):`),
+      validate: (input) => {
+        if (validInputs.includes(input)) return true;
+        return `Please enter 1-${numbered.length} or X`;
+      }
+    }
+  ]);
+
+  if (action.toLowerCase() === 'x') return null;
+  
+  const selectedIdx = parseInt(action) - 1;
+  const selectedPropfirm = numbered[selectedIdx];
+
+  const credentials = await loginPrompt(selectedPropfirm.name);
+  const spinner = ora('Connecting to Tradovate...').start();
+
+  try {
+    const service = new TradovateService(selectedPropfirm.key);
+    const result = await service.login(credentials.username, credentials.password);
+
+    if (result.success) {
+      spinner.text = 'Fetching accounts...';
+      await service.getTradingAccounts();
+      
+      connections.add('tradovate', service, service.propfirm.name);
+      currentService = service;
+      currentPlatform = 'tradovate';
+      spinner.succeed(`Connected to ${service.propfirm.name}`);
+      return service;
+    } else {
+      spinner.fail(result.error || 'Authentication failed');
+      return null;
+    }
+  } catch (error) {
+    spinner.fail(error.message);
+    return null;
+  }
+};
+
 /**
  * Main connection menu
  */
@@ -398,7 +481,7 @@ const mainMenu = async () => {
   };
   
   menuRow(chalk.cyan('[1] ProjectX'), chalk.cyan('[2] Rithmic'));
-  menuRow(chalk.gray('[3] Tradovate (Coming Soon)'), chalk.red('[X] Exit'));
+  menuRow(chalk.cyan('[3] Tradovate'), chalk.red('[X] Exit'));
   
   console.log(chalk.cyan('╚' + '═'.repeat(innerWidth) + '╝'));
   console.log();
@@ -407,11 +490,11 @@ const mainMenu = async () => {
     {
       type: 'input',
       name: 'action',
-      message: chalk.cyan('Enter choice (1/2/X):'),
+      message: chalk.cyan('Enter choice (1/2/3/X):'),
       validate: (input) => {
-        const valid = ['1', '2', 'x', 'X'];
+        const valid = ['1', '2', '3', 'x', 'X'];
         if (valid.includes(input)) return true;
-        return 'Please enter 1, 2 or X';
+        return 'Please enter 1, 2, 3 or X';
       }
     }
   ]);
@@ -420,6 +503,7 @@ const mainMenu = async () => {
   const actionMap = {
     '1': 'projectx',
     '2': 'rithmic',
+    '3': 'tradovate',
     'x': 'exit',
     'X': 'exit'
   };
@@ -621,6 +705,11 @@ const run = async () => {
         const service = await rithmicMenu();
         if (service) currentService = service;
       }
+      
+      if (choice === 'tradovate') {
+        const service = await tradovateMenu();
+        if (service) currentService = service;
+      }
     } else {
       const action = await dashboardMenu(currentService);
       

package/src/config/propfirms.js

@@ -179,6 +179,14 @@ const PROPFIRMS = {
     userApi: 'userapi.takeprofittrader.tradovate.com',
     gatewayApi: 'api.takeprofittrader.tradovate.com'
   },
+  myfundedfutures: {
+    id: 'myfundedfutures',
+    name: 'MyFundedFutures',
+    displayName: 'MyFundedFutures',
+    platform: 'Tradovate',
+    userApi: 'live.tradovateapi.com',
+    gatewayApi: 'live.tradovateapi.com'
+  },
 
   // ==================== Rithmic Platform ====================
   apex_rithmic: {

package/src/services/rithmic/index.js

@@ -70,21 +70,22 @@ class RithmicService extends EventEmitter {
       // Login
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
-          reject(new Error('Login timeout'));
-        }, 15000);
+          resolve({ success: false, error: 'Login timeout - server did not respond' });
+        }, 30000);
 
         this.orderConn.once('loggedIn', async (data) => {
           clearTimeout(timeout);
           this.loginInfo = data;
-          this.user = { userName: username };
+          this.user = { userName: username, fcmId: data.fcmId, ibId: data.ibId };
           
+          // Try to get accounts but don't fail if it doesn't work
           try {
-            // Get accounts
             await this.fetchAccounts();
-            resolve({ success: true });
           } catch (e) {
-            resolve({ success: false, error: e.message });
+            // Accounts fetch failed, but login succeeded
+            console.log('Note: Could not fetch accounts');
           }
+          resolve({ success: true });
         });
 
         this.orderConn.once('loginFailed', (data) => {

package/src/services/tradovate/constants.js

@@ -0,0 +1,109 @@
+/**
+ * Tradovate Constants
+ */
+
+// Base URLs
+const TRADOVATE_URLS = {
+  // Live Trading
+  LIVE_API: 'https://live.tradovateapi.com/v1',
+  LIVE_MD_WS: 'wss://md.tradovateapi.com/v1/websocket',
+  LIVE_TRADING_WS: 'wss://live.tradovateapi.com/v1/websocket',
+
+  // Demo/Simulation Trading
+  DEMO_API: 'https://demo.tradovateapi.com/v1',
+  DEMO_MD_WS: 'wss://md-demo.tradovateapi.com/v1/websocket',
+  DEMO_TRADING_WS: 'wss://demo.tradovateapi.com/v1/websocket',
+};
+
+// API Paths
+const API_PATHS = {
+  // Authentication
+  AUTH_TOKEN_REQUEST: '/auth/accesstokenrequest',
+  AUTH_RENEW_TOKEN: '/auth/renewaccesstoken',
+  AUTH_ME: '/auth/me',
+
+  // Account
+  ACCOUNT_LIST: '/account/list',
+  ACCOUNT_FIND: '/account/find',
+  ACCOUNT_ITEM: '/account/item',
+
+  // Cash Balance
+  CASH_BALANCE_LIST: '/cashBalance/list',
+  CASH_BALANCE_SNAPSHOT: '/cashBalance/getcashbalancesnapshot',
+
+  // Contract
+  CONTRACT_FIND: '/contract/find',
+  CONTRACT_ITEM: '/contract/item',
+  CONTRACT_SUGGEST: '/contract/suggest',
+
+  // Product
+  PRODUCT_LIST: '/product/list',
+  PRODUCT_FIND: '/product/find',
+
+  // Order
+  ORDER_LIST: '/order/list',
+  ORDER_PLACE: '/order/placeorder',
+  ORDER_MODIFY: '/order/modifyorder',
+  ORDER_CANCEL: '/order/cancelorder',
+  ORDER_LIQUIDATE_POSITION: '/order/liquidateposition',
+
+  // Position
+  POSITION_LIST: '/position/list',
+  POSITION_DEPS: '/position/deps',
+
+  // Fill
+  FILL_LIST: '/fill/list',
+  FILL_DEPS: '/fill/deps',
+};
+
+// WebSocket Events
+const WS_EVENTS = {
+  CONNECTED: 'connected',
+  DISCONNECTED: 'disconnected',
+  ERROR: 'error',
+  QUOTE: 'md/quote',
+  DOM: 'md/dom',
+  ORDER: 'order',
+  FILL: 'fill',
+  POSITION: 'position',
+  ACCOUNT: 'account',
+  CASH_BALANCE: 'cashBalance',
+  HEARTBEAT: 'heartbeat',
+};
+
+// Token config
+const TOKEN_CONFIG = {
+  EXPIRATION_MINUTES: 90,
+  RENEW_BEFORE_MINUTES: 15,
+};
+
+/**
+ * Get base URL for Tradovate API
+ */
+function getBaseUrl(isDemo = true) {
+  return isDemo ? TRADOVATE_URLS.DEMO_API : TRADOVATE_URLS.LIVE_API;
+}
+
+/**
+ * Get WebSocket URL for trading
+ */
+function getTradingWebSocketUrl(isDemo = true) {
+  return isDemo ? TRADOVATE_URLS.DEMO_TRADING_WS : TRADOVATE_URLS.LIVE_TRADING_WS;
+}
+
+/**
+ * Get WebSocket URL for market data
+ */
+function getMdWebSocketUrl(isDemo = true) {
+  return isDemo ? TRADOVATE_URLS.DEMO_MD_WS : TRADOVATE_URLS.LIVE_MD_WS;
+}
+
+module.exports = {
+  TRADOVATE_URLS,
+  API_PATHS,
+  WS_EVENTS,
+  TOKEN_CONFIG,
+  getBaseUrl,
+  getTradingWebSocketUrl,
+  getMdWebSocketUrl,
+};

package/src/services/tradovate/index.js

@@ -0,0 +1,508 @@
+/**
+ * Tradovate Service
+ * Main service for Tradovate prop firm connections (Apex, TakeProfitTrader)
+ */
+
+const https = require('https');
+const WebSocket = require('ws');
+const EventEmitter = require('events');
+const { TRADOVATE_URLS, API_PATHS, WS_EVENTS, getBaseUrl, getTradingWebSocketUrl } = require('./constants');
+
+class TradovateService extends EventEmitter {
+  constructor(propfirmKey) {
+    super();
+    this.propfirmKey = propfirmKey;
+    this.propfirm = this.getPropFirmConfig(propfirmKey);
+    this.accessToken = null;
+    this.mdAccessToken = null;
+    this.userId = null;
+    this.tokenExpiration = null;
+    this.accounts = [];
+    this.user = null;
+    this.isDemo = true; // Default to demo
+    this.ws = null;
+    this.renewalTimer = null;
+  }
+
+  /**
+   * Get PropFirm configuration
+   */
+  getPropFirmConfig(key) {
+    const propfirms = {
+      'apex_tradovate': { name: 'Apex (Tradovate)', isDemo: false, defaultBalance: 300000 },
+      'takeprofittrader': { name: 'TakeProfitTrader', isDemo: false, defaultBalance: 150000 },
+      'myfundedfutures': { name: 'MyFundedFutures', isDemo: false, defaultBalance: 150000 },
+    };
+    return propfirms[key] || { name: key, isDemo: false, defaultBalance: 150000 };
+  }
+
+  /**
+   * Login to Tradovate
+   * @param {string} username - Tradovate username
+   * @param {string} password - Tradovate password
+   * @param {object} options - Optional { cid, sec } for API key auth
+   */
+  async login(username, password, options = {}) {
+    try {
+      const authData = {
+        name: username,
+        password: password,
+        appId: 'HQX-CLI',
+        appVersion: '1.0.0',
+        deviceId: this.generateDeviceId(),
+      };
+
+      // Add API key if provided
+      if (options.cid) authData.cid = options.cid;
+      if (options.sec) authData.sec = options.sec;
+
+      const result = await this._request(API_PATHS.AUTH_TOKEN_REQUEST, 'POST', authData);
+
+      if (result.errorText) {
+        return { success: false, error: result.errorText };
+      }
+
+      if (!result.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 };
+
+      // Setup token renewal
+      this.setupTokenRenewal();
+
+      // Fetch accounts
+      await this.fetchAccounts();
+
+      return { success: true };
+
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Fetch accounts
+   */
+  async fetchAccounts() {
+    try {
+      const accounts = await this._request(API_PATHS.ACCOUNT_LIST, 'GET');
+      
+      if (Array.isArray(accounts)) {
+        this.accounts = accounts;
+        
+        // Fetch cash balance for each account
+        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;
+          }
+        }
+      }
+
+      return this.accounts;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get trading accounts (formatted for HQX)
+   */
+  async getTradingAccounts() {
+    if (this.accounts.length === 0) {
+      await this.fetchAccounts();
+    }
+
+    const tradingAccounts = this.accounts.map((acc) => {
+      const cb = acc.cashBalance || {};
+      const balance = cb.totalCashValue || cb.netLiquidatingValue || this.propfirm.defaultBalance;
+      const startingBalance = this.propfirm.defaultBalance;
+      const profitAndLoss = cb.totalPnL || (balance - startingBalance);
+      const openPnL = cb.openPnL || 0;
+
+      return {
+        accountId: acc.id,
+        tradovateAccountId: acc.id,
+        accountName: acc.name,
+        name: acc.name,
+        balance: balance,
+        startingBalance: startingBalance,
+        profitAndLoss: profitAndLoss,
+        openPnL: openPnL,
+        status: acc.active ? 0 : 3, // 0=Active, 3=Inactive
+        platform: 'Tradovate',
+        propfirm: this.propfirm.name,
+        accountType: acc.accountType, // 'Customer' or 'Demo'
+      };
+    });
+
+    return { success: true, accounts: tradingAccounts };
+  }
+
+  /**
+   * Get positions for an account
+   */
+  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) {
+      return [];
+    }
+  }
+
+  /**
+   * Get fills/trades
+   */
+  async getFills() {
+    try {
+      return await this._request(API_PATHS.FILL_LIST, 'GET');
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Place an order
+   */
+  async placeOrder(orderData) {
+    try {
+      const result = await this._request(API_PATHS.ORDER_PLACE, 'POST', {
+        accountId: orderData.accountId,
+        action: orderData.side === 0 ? 'Buy' : 'Sell',
+        symbol: orderData.symbol,
+        orderQty: orderData.size,
+        orderType: orderData.type === 2 ? 'Market' : 'Limit',
+        price: orderData.price,
+        isAutomated: true,
+      });
+
+      if (result.errorText || result.failureReason) {
+        return { success: false, error: result.errorText || result.failureText };
+      }
+
+      return { success: true, orderId: result.orderId };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(orderId) {
+    try {
+      const result = await this._request(API_PATHS.ORDER_CANCEL, 'POST', {
+        orderId: orderId,
+        isAutomated: true,
+      });
+
+      if (result.errorText) {
+        return { success: false, error: result.errorText };
+      }
+
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Close a position
+   */
+  async closePosition(accountId, contractId) {
+    try {
+      const result = await this._request(API_PATHS.ORDER_LIQUIDATE_POSITION, 'POST', {
+        accountId: accountId,
+        contractId: contractId,
+        isAutomated: true,
+      });
+
+      if (result.errorText) {
+        return { success: false, error: result.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 [];
+    }
+  }
+
+  /**
+   * Get user info
+   */
+  async getUser() {
+    return this.user;
+  }
+
+  /**
+   * Check market hours (same logic as ProjectX)
+   */
+  checkMarketHours() {
+    const now = new Date();
+    const utcDay = now.getUTCDay();
+    const utcHour = now.getUTCHours();
+
+    const ctOffset = this.isDST(now) ? 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' };
+  }
+
+  isDST(date) {
+    const jan = new Date(date.getFullYear(), 0, 1);
+    const jul = new Date(date.getFullYear(), 6, 1);
+    const stdOffset = Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
+    return date.getTimezoneOffset() < stdOffset;
+  }
+
+  /**
+   * Setup automatic token renewal
+   */
+  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 (error) {
+        // Silent fail
+      }
+    }, renewInMs);
+  }
+
+  /**
+   * Renew access token
+   */
+  async renewToken() {
+    if (!this.accessToken) return;
+
+    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
+    }
+  }
+
+  /**
+   * Connect to WebSocket for real-time updates
+   */
+  async connectWebSocket() {
+    return new Promise((resolve, reject) => {
+      const wsUrl = getTradingWebSocketUrl(this.isDemo);
+      this.ws = new WebSocket(wsUrl);
+
+      this.ws.on('open', () => {
+        // Authorize
+        this.wsSend('authorize', '', { token: this.accessToken });
+        resolve(true);
+      });
+
+      this.ws.on('message', (data) => {
+        this.handleWsMessage(data);
+      });
+
+      this.ws.on('error', (err) => {
+        this.emit('error', err);
+        reject(err);
+      });
+
+      this.ws.on('close', () => {
+        this.emit('disconnected');
+      });
+
+      setTimeout(() => reject(new Error('WebSocket timeout')), 10000);
+    });
+  }
+
+  /**
+   * Send WebSocket message
+   */
+  wsSend(url, query = '', body = null) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+
+    const msg = body
+      ? `${url}\n${this.wsRequestId++}\n${query}\n${JSON.stringify(body)}`
+      : `${url}\n${this.wsRequestId++}\n${query}\n`;
+
+    this.ws.send(msg);
+  }
+
+  wsRequestId = 1;
+
+  /**
+   * Handle WebSocket message
+   */
+  handleWsMessage(data) {
+    try {
+      const str = data.toString();
+      
+      // Tradovate WS format: frame\nid\ndata
+      if (str.startsWith('a')) {
+        const json = JSON.parse(str.slice(1));
+        if (Array.isArray(json)) {
+          json.forEach(msg => this.processWsEvent(msg));
+        }
+      }
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  /**
+   * Process WebSocket event
+   */
+  processWsEvent(msg) {
+    if (msg.e === 'props') {
+      // User data sync
+      if (msg.d?.orders) this.emit(WS_EVENTS.ORDER, msg.d.orders);
+      if (msg.d?.positions) this.emit(WS_EVENTS.POSITION, msg.d.positions);
+      if (msg.d?.cashBalances) this.emit(WS_EVENTS.CASH_BALANCE, msg.d.cashBalances);
+    }
+  }
+
+  /**
+   * Disconnect
+   */
+  async disconnect() {
+    if (this.renewalTimer) {
+      clearTimeout(this.renewalTimer);
+      this.renewalTimer = null;
+    }
+
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+
+    this.accessToken = null;
+    this.mdAccessToken = null;
+    this.accounts = [];
+    this.user = 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();
+    });
+  }
+}
+
+module.exports = { TradovateService };