@danielgroen/dxtrade-api 1.0.19 → 1.0.21

package/dist/index.mjs

@@ -6,7 +6,10 @@ var BROKER = {
 };
 
 // src/constants/endpoints.ts
-var websocketQuery = `?X-Atmosphere-tracking-id=0&X-Atmosphere-Framework=2.3.2-javascript&X-Atmosphere-Transport=websocket&X-Atmosphere-TrackMessageSize=true&Content-Type=text/x-gwt-rpc;%20charset=UTF-8&X-atmo-protocol=true&sessionState=dx-new&guest-mode=false`;
+function websocketQuery(atmosphereId) {
+  const trackingId = atmosphereId ?? "0";
+  return `?X-Atmosphere-tracking-id=${trackingId}&X-Atmosphere-Framework=2.3.2-javascript&X-Atmosphere-Transport=websocket&X-Atmosphere-TrackMessageSize=true&Content-Type=text/x-gwt-rpc;%20charset=UTF-8&X-atmo-protocol=true&sessionState=dx-new&guest-mode=false`;
+}
 var endpoints = {
   login: (base) => `${base}/api/auth/login`,
   switchAccount: (base, id) => `${base}/api/accounts/switch?accountId=${id}`,
@@ -15,8 +18,10 @@ var endpoints = {
   submitOrder: (base) => `${base}/api/orders/single`,
   closePosition: (base) => `${base}/api/positions/close`,
   assessments: (base) => `${base}/api/assessments`,
-  websocket: (base) => `wss://${base.split("//")[1]}/client/connector` + websocketQuery,
-  tradeJournal: (base, params) => `${base}/api/tradejournal?from=${params.from}&to=${params.to}`
+  websocket: (base, atmosphereId) => `wss://${base.split("//")[1]}/client/connector` + websocketQuery(atmosphereId),
+  tradeJournal: (base, params) => `${base}/api/tradejournal?from=${params.from}&to=${params.to}`,
+  subscribeInstruments: (base) => `${base}/api/instruments/subscribeInstrumentSymbols`,
+  charts: (base) => `${base}/api/charts`
 };
 
 // src/constants/enums.ts
@@ -42,11 +47,40 @@ var TIF = /* @__PURE__ */ ((TIF2) => {
   TIF2["GTD"] = "GTD";
   return TIF2;
 })(TIF || {});
+var ERROR = /* @__PURE__ */ ((ERROR2) => {
+  ERROR2["NO_SESSION"] = "NO_SESSION";
+  ERROR2["LOGIN_FAILED"] = "LOGIN_FAILED";
+  ERROR2["LOGIN_ERROR"] = "LOGIN_ERROR";
+  ERROR2["CSRF_NOT_FOUND"] = "CSRF_NOT_FOUND";
+  ERROR2["CSRF_ERROR"] = "CSRF_ERROR";
+  ERROR2["ACCOUNT_SWITCH_ERROR"] = "ACCOUNT_SWITCH_ERROR";
+  ERROR2["NO_SUGGESTIONS"] = "NO_SUGGESTIONS";
+  ERROR2["SUGGEST_ERROR"] = "SUGGEST_ERROR";
+  ERROR2["NO_SYMBOL_INFO"] = "NO_SYMBOL_INFO";
+  ERROR2["SYMBOL_INFO_ERROR"] = "SYMBOL_INFO_ERROR";
+  ERROR2["INSTRUMENTS_TIMEOUT"] = "INSTRUMENTS_TIMEOUT";
+  ERROR2["INSTRUMENTS_ERROR"] = "INSTRUMENTS_ERROR";
+  ERROR2["LIMITS_TIMEOUT"] = "LIMITS_TIMEOUT";
+  ERROR2["LIMITS_ERROR"] = "LIMITS_ERROR";
+  ERROR2["OHLC_TIMEOUT"] = "OHLC_TIMEOUT";
+  ERROR2["OHLC_ERROR"] = "OHLC_ERROR";
+  ERROR2["ORDER_ERROR"] = "ORDER_ERROR";
+  ERROR2["POSITION_CLOSE_ERROR"] = "POSITION_CLOSE_ERROR";
+  ERROR2["ACCOUNT_METRICS_TIMEOUT"] = "ACCOUNT_METRICS_TIMEOUT";
+  ERROR2["ACCOUNT_METRICS_ERROR"] = "ACCOUNT_METRICS_ERROR";
+  ERROR2["ACCOUNT_POSITIONS_TIMEOUT"] = "ACCOUNT_POSITIONS_TIMEOUT";
+  ERROR2["ACCOUNT_POSITIONS_ERROR"] = "ACCOUNT_POSITIONS_ERROR";
+  ERROR2["TRADE_JOURNAL_ERROR"] = "TRADE_JOURNAL_ERROR";
+  ERROR2["ASSESSMENTS_ERROR"] = "ASSESSMENTS_ERROR";
+  return ERROR2;
+})(ERROR || {});
 var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
   WS_MESSAGE2["ACCOUNT_METRICS"] = "ACCOUNT_METRICS";
   WS_MESSAGE2["ACCOUNTS"] = "ACCOUNTS";
   WS_MESSAGE2["AVAILABLE_WATCHLISTS"] = "AVAILABLE_WATCHLISTS";
+  WS_MESSAGE2["CHART_FEED_SUBTOPIC"] = "chartFeedSubtopic";
   WS_MESSAGE2["INSTRUMENTS"] = "INSTRUMENTS";
+  WS_MESSAGE2["INSTRUMENT_METRICS"] = "INSTRUMENT_METRICS";
   WS_MESSAGE2["LIMITS"] = "LIMITS";
   WS_MESSAGE2["MESSAGE"] = "MESSAGE";
   WS_MESSAGE2["ORDERS"] = "ORDERS";
@@ -54,9 +88,16 @@ var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
   WS_MESSAGE2["POSITION_CASH_TRANSFERS"] = "POSITION_CASH_TRANSFERS";
   WS_MESSAGE2["PRIVATE_LAYOUT_NAMES"] = "PRIVATE_LAYOUT_NAMES";
   WS_MESSAGE2["SHARED_PROPERTIES_MESSAGE"] = "SHARED_PROPERTIES_MESSAGE";
+  WS_MESSAGE2["TRADE_STATUSES"] = "TRADE_STATUSES";
   WS_MESSAGE2["USER_LOGIN_INFO"] = "USER_LOGIN_INFO";
   return WS_MESSAGE2;
 })(WS_MESSAGE || {});
+((WS_MESSAGE2) => {
+  let SUBTOPIC;
+  ((SUBTOPIC2) => {
+    SUBTOPIC2["BIG_CHART_COMPONENT"] = "BigChartComponentPresenter-4";
+  })(SUBTOPIC = WS_MESSAGE2.SUBTOPIC || (WS_MESSAGE2.SUBTOPIC = {}));
+})(WS_MESSAGE || (WS_MESSAGE = {}));
 
 // src/constants/errors.ts
 var DxtradeError = class extends Error {
@@ -145,6 +186,14 @@ function debugLog(msg) {
 function clearDebugLog() {
   writeFileSync(DEBUG_LOG, "");
 }
+function parseAtmosphereId(data) {
+  const raw = data.toString();
+  const parts = raw.split("|");
+  if (parts.length >= 2 && /^[0-9a-f-]{36}$/.test(parts[1])) {
+    return parts[1];
+  }
+  return null;
+}
 function parseWsData(data) {
   const raw = data.toString();
   const pipeIndex = raw.indexOf("|");
@@ -159,13 +208,13 @@ function parseWsData(data) {
 // src/domains/account/account.ts
 async function getAccountMetrics(ctx, timeout = 3e4) {
   ctx.ensureSession();
-  const wsUrl = endpoints.websocket(ctx.broker);
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
     const ws = new WebSocket(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
-      reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT", "Account metrics timed out"));
+      reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT" /* ACCOUNT_METRICS_TIMEOUT */, "Account metrics timed out"));
     }, timeout);
     ws.on("message", (data) => {
       const msg = parseWsData(data);
@@ -181,7 +230,7 @@ async function getAccountMetrics(ctx, timeout = 3e4) {
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
-      reject(new DxtradeError("ACCOUNT_METRICS_ERROR", `Account metrics error: ${error.message}`));
+      reject(new DxtradeError("ACCOUNT_METRICS_ERROR" /* ACCOUNT_METRICS_ERROR */, `Account metrics error: ${error.message}`));
     });
   });
 }
@@ -203,12 +252,12 @@ async function getTradeJournal(ctx, params) {
       ctx.cookies = Cookies.merge(ctx.cookies, incoming);
       return response.data;
     } else {
-      ctx.throwError("TRADE_JOURNAL_ERROR", `Login failed: ${response.status}`);
+      ctx.throwError("TRADE_JOURNAL_ERROR" /* TRADE_JOURNAL_ERROR */, `Login failed: ${response.status}`);
     }
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("TRADE_JOURNAL_ERROR", `Trade journal error: ${message}`);
+    ctx.throwError("TRADE_JOURNAL_ERROR" /* TRADE_JOURNAL_ERROR */, `Trade journal error: ${message}`);
   }
 }
 
@@ -234,7 +283,7 @@ async function getAssessments(ctx, params) {
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("ASSESSMENTS_ERROR", `Error fetching assessments: ${message}`);
+    ctx.throwError("ASSESSMENTS_ERROR" /* ASSESSMENTS_ERROR */, `Error fetching assessments: ${message}`);
   }
 }
 
@@ -242,13 +291,13 @@ async function getAssessments(ctx, params) {
 import WebSocket2 from "ws";
 async function getInstruments(ctx, params = {}, timeout = 3e4) {
   ctx.ensureSession();
-  const wsUrl = endpoints.websocket(ctx.broker);
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
     const ws = new WebSocket2(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
-      reject(new DxtradeError("INSTRUMENTS_TIMEOUT", "Instruments request timed out"));
+      reject(new DxtradeError("INSTRUMENTS_TIMEOUT" /* INSTRUMENTS_TIMEOUT */, "Instruments request timed out"));
     }, timeout);
     let instruments = [];
     let settleTimer = null;
@@ -278,17 +327,115 @@ async function getInstruments(ctx, params = {}, timeout = 3e4) {
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
-      reject(new DxtradeError("INSTRUMENTS_ERROR", `Instruments error: ${error.message}`));
+      reject(new DxtradeError("INSTRUMENTS_ERROR" /* INSTRUMENTS_ERROR */, `Instruments error: ${error.message}`));
+    });
+  });
+}
+
+// src/domains/ohlc/ohlc.ts
+import WebSocket3 from "ws";
+async function getOHLC(ctx, params, timeout = 3e4) {
+  ctx.ensureSession();
+  const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  const headers = authHeaders(ctx.csrf, cookieStr);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket3(wsUrl, { headers: { Cookie: cookieStr } });
+    const bars = [];
+    let putsSent = false;
+    let initSettleTimer = null;
+    let barSettleTimer = null;
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new DxtradeError("OHLC_TIMEOUT" /* OHLC_TIMEOUT */, "OHLC data timed out"));
+    }, timeout);
+    function cleanup() {
+      clearTimeout(timer);
+      if (initSettleTimer) clearTimeout(initSettleTimer);
+      if (barSettleTimer) clearTimeout(barSettleTimer);
+      ws.close();
+    }
+    async function sendPuts() {
+      putsSent = true;
+      try {
+        await retryRequest(
+          {
+            method: "PUT",
+            url: endpoints.subscribeInstruments(ctx.broker),
+            data: { instruments: [symbol] },
+            headers
+          },
+          ctx.retries
+        );
+        await retryRequest(
+          {
+            method: "PUT",
+            url: endpoints.charts(ctx.broker),
+            data: {
+              chartIds: [],
+              requests: [
+                {
+                  aggregationPeriodSeconds: resolution,
+                  extendedSession: true,
+                  forexPriceField: priceField,
+                  id: 0,
+                  maxBarsCount: maxBars,
+                  range,
+                  studySubscription: [],
+                  subtopic: WS_MESSAGE.SUBTOPIC.BIG_CHART_COMPONENT,
+                  symbol
+                }
+              ]
+            },
+            headers
+          },
+          ctx.retries
+        );
+      } catch (error) {
+        cleanup();
+        const message = error instanceof Error ? error.message : "Unknown error";
+        reject(new DxtradeError("OHLC_ERROR" /* OHLC_ERROR */, `Error fetching OHLC data: ${message}`));
+      }
+    }
+    ws.on("message", (data) => {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (!putsSent) {
+        if (initSettleTimer) clearTimeout(initSettleTimer);
+        initSettleTimer = setTimeout(() => sendPuts(), 1e3);
+        return;
+      }
+      const body = msg.body;
+      if (body?.subtopic !== WS_MESSAGE.SUBTOPIC.BIG_CHART_COMPONENT) return;
+      if (Array.isArray(body.data)) {
+        bars.push(...body.data);
+      }
+      if (barSettleTimer) clearTimeout(barSettleTimer);
+      if (body.snapshotEnd) {
+        cleanup();
+        resolve(bars);
+      } else {
+        barSettleTimer = setTimeout(() => {
+          cleanup();
+          resolve(bars);
+        }, 2e3);
+      }
+    });
+    ws.on("error", (error) => {
+      cleanup();
+      reject(new DxtradeError("OHLC_ERROR" /* OHLC_ERROR */, `OHLC WebSocket error: ${error.message}`));
     });
   });
 }
 
 // src/domains/order/order.ts
 import crypto from "crypto";
-import WebSocket4 from "ws";
+import WebSocket5 from "ws";
 
 // src/domains/symbol/symbol.ts
-import WebSocket3 from "ws";
+import WebSocket4 from "ws";
 async function getSymbolSuggestions(ctx, text) {
   ctx.ensureSession();
   try {
@@ -303,13 +450,13 @@ async function getSymbolSuggestions(ctx, text) {
     );
     const suggests = response.data?.suggests;
     if (!suggests?.length) {
-      ctx.throwError("NO_SUGGESTIONS", "No symbol suggestions found");
+      ctx.throwError("NO_SUGGESTIONS" /* NO_SUGGESTIONS */, "No symbol suggestions found");
     }
     return suggests;
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("SUGGEST_ERROR", `Error getting symbol suggestions: ${message}`);
+    ctx.throwError("SUGGEST_ERROR" /* SUGGEST_ERROR */, `Error getting symbol suggestions: ${message}`);
   }
 }
 async function getSymbolInfo(ctx, symbol) {
@@ -326,24 +473,24 @@ async function getSymbolInfo(ctx, symbol) {
       ctx.retries
     );
     if (!response.data) {
-      ctx.throwError("NO_SYMBOL_INFO", "No symbol info returned");
+      ctx.throwError("NO_SYMBOL_INFO" /* NO_SYMBOL_INFO */, "No symbol info returned");
     }
     return response.data;
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("SYMBOL_INFO_ERROR", `Error getting symbol info: ${message}`);
+    ctx.throwError("SYMBOL_INFO_ERROR" /* SYMBOL_INFO_ERROR */, `Error getting symbol info: ${message}`);
   }
 }
 async function getSymbolLimits(ctx, timeout = 3e4) {
   ctx.ensureSession();
-  const wsUrl = endpoints.websocket(ctx.broker);
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket3(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket4(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
-      reject(new DxtradeError("LIMITS_TIMEOUT", "Symbol limits request timed out"));
+      reject(new DxtradeError("LIMITS_TIMEOUT" /* LIMITS_TIMEOUT */, "Symbol limits request timed out"));
     }, timeout);
     let limits = [];
     let settleTimer = null;
@@ -366,14 +513,14 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
-      reject(new DxtradeError("LIMITS_ERROR", `Symbol limits error: ${error.message}`));
+      reject(new DxtradeError("LIMITS_ERROR" /* LIMITS_ERROR */, `Symbol limits error: ${error.message}`));
     });
   });
 }
 
 // src/domains/order/order.ts
 function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
-  const ws = new WebSocket4(wsUrl, { headers: { Cookie: cookieStr } });
+  const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
   let settled = false;
   const ready = new Promise((resolve) => {
     ws.on("open", resolve);
@@ -507,7 +654,7 @@ async function submitOrder(ctx, params) {
     };
   }
   try {
-    const wsUrl = endpoints.websocket(ctx.broker);
+    const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
     const cookieStr = Cookies.serialize(ctx.cookies);
     const listener = createOrderListener(wsUrl, cookieStr, 3e4, ctx.debug);
     await listener.ready;
@@ -527,21 +674,21 @@ async function submitOrder(ctx, params) {
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
-    ctx.throwError("ORDER_ERROR", `Error submitting order: ${message}`);
+    ctx.throwError("ORDER_ERROR" /* ORDER_ERROR */, `Error submitting order: ${message}`);
   }
 }
 
 // src/domains/position/position.ts
-import WebSocket5 from "ws";
+import WebSocket6 from "ws";
 async function getPositions(ctx) {
   ctx.ensureSession();
-  const wsUrl = endpoints.websocket(ctx.broker);
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
-      reject(new DxtradeError("ACCOUNT_POSITIONS_TIMEOUT", "Account positions timed out"));
+      reject(new DxtradeError("ACCOUNT_POSITIONS_TIMEOUT" /* ACCOUNT_POSITIONS_TIMEOUT */, "Account positions timed out"));
     }, 3e4);
     ws.on("message", (data) => {
       const msg = parseWsData(data);
@@ -556,7 +703,7 @@ async function getPositions(ctx) {
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
-      reject(new DxtradeError("ACCOUNT_POSITIONS_ERROR", `Account positions error: ${error.message}`));
+      reject(new DxtradeError("ACCOUNT_POSITIONS_ERROR" /* ACCOUNT_POSITIONS_ERROR */, `Account positions error: ${error.message}`));
     });
   });
 }
@@ -574,27 +721,31 @@ async function closePosition(ctx, data) {
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
-    ctx.throwError("POSITION_CLOSE_ERROR", `Position close error: ${message}`);
+    ctx.throwError("POSITION_CLOSE_ERROR" /* POSITION_CLOSE_ERROR */, `Position close error: ${message}`);
   }
 }
 
 // src/domains/session/session.ts
-import WebSocket6 from "ws";
+import WebSocket7 from "ws";
 function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket7(wsUrl, { headers: { Cookie: cookieStr } });
+    let atmosphereId = null;
     const timer = setTimeout(() => {
       ws.close();
       reject(new Error("[dxtrade-api] Handshake timed out"));
     }, timeout);
     ws.on("message", (data) => {
+      if (!atmosphereId) {
+        atmosphereId = parseAtmosphereId(data);
+      }
       const msg = parseWsData(data);
       if (shouldLog(msg, debug)) debugLog(msg);
       if (typeof msg === "string") return;
       if (msg.accountId) {
         clearTimeout(timer);
         ws.close();
-        resolve();
+        resolve(atmosphereId);
       }
     });
     ws.on("error", (error) => {
@@ -625,12 +776,12 @@ async function login(ctx) {
       ctx.cookies = Cookies.merge(ctx.cookies, incoming);
       ctx.callbacks.onLogin?.();
     } else {
-      ctx.throwError("LOGIN_FAILED", `Login failed: ${response.status}`);
+      ctx.throwError("LOGIN_FAILED" /* LOGIN_FAILED */, `Login failed: ${response.status}`);
     }
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("LOGIN_ERROR", `Login error: ${message}`);
+    ctx.throwError("LOGIN_ERROR" /* LOGIN_ERROR */, `Login error: ${message}`);
   }
 }
 async function fetchCsrf(ctx) {
@@ -648,12 +799,12 @@ async function fetchCsrf(ctx) {
     if (csrfMatch) {
       ctx.csrf = csrfMatch[1];
     } else {
-      ctx.throwError("CSRF_NOT_FOUND", "CSRF token not found");
+      ctx.throwError("CSRF_NOT_FOUND" /* CSRF_NOT_FOUND */, "CSRF token not found");
     }
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("CSRF_ERROR", `CSRF fetch error: ${message}`);
+    ctx.throwError("CSRF_ERROR" /* CSRF_ERROR */, `CSRF fetch error: ${message}`);
   }
 }
 async function switchAccount(ctx, accountId) {
@@ -671,19 +822,23 @@ async function switchAccount(ctx, accountId) {
   } catch (error) {
     if (error instanceof DxtradeError) throw error;
     const message = error instanceof Error ? error.message : "Unknown error";
-    ctx.throwError("ACCOUNT_SWITCH_ERROR", `Error switching account: ${message}`);
+    ctx.throwError("ACCOUNT_SWITCH_ERROR" /* ACCOUNT_SWITCH_ERROR */, `Error switching account: ${message}`);
   }
 }
 async function connect(ctx) {
   await login(ctx);
   await fetchCsrf(ctx);
   if (ctx.debug) clearDebugLog();
-  const wsUrl = endpoints.websocket(ctx.broker);
   const cookieStr = Cookies.serialize(ctx.cookies);
-  await waitForHandshake(wsUrl, cookieStr, 3e4, ctx.debug);
+  ctx.atmosphereId = await waitForHandshake(endpoints.websocket(ctx.broker), cookieStr, 3e4, ctx.debug);
   if (ctx.config.accountId) {
     await switchAccount(ctx, ctx.config.accountId);
-    await waitForHandshake(endpoints.websocket(ctx.broker), Cookies.serialize(ctx.cookies), 3e4, ctx.debug);
+    ctx.atmosphereId = await waitForHandshake(
+      endpoints.websocket(ctx.broker, ctx.atmosphereId),
+      Cookies.serialize(ctx.cookies),
+      3e4,
+      ctx.debug
+    );
   }
 }
 
@@ -697,12 +852,16 @@ var DxtradeClient = class {
       callbacks,
       cookies: {},
       csrf: null,
+      atmosphereId: null,
       broker: config.broker,
       retries: config.retries ?? 3,
       debug: config.debug ?? false,
       ensureSession() {
         if (!this.csrf) {
-          throw new DxtradeError("NO_SESSION", "No active session. Call login() and fetchCsrf() or connect() first.");
+          throw new DxtradeError(
+            "NO_SESSION" /* NO_SESSION */,
+            "No active session. Call login() and fetchCsrf() or connect() first."
+          );
         }
       },
       throwError(code, message) {
@@ -775,12 +934,24 @@ var DxtradeClient = class {
   async getAssessments(params) {
     return getAssessments(this._ctx, params);
   }
+  /**
+   * Fetch OHLC price bars for a symbol.
+   * @param params.symbol - Instrument symbol (e.g. "EURUSD")
+   * @param params.resolution - Bar period in seconds (default: 60 = 1 min)
+   * @param params.range - Lookback window in seconds (default: 432000 = 5 days)
+   * @param params.maxBars - Maximum bars to return (default: 3500)
+   * @param params.priceField - "bid" or "ask" (default: "bid")
+   */
+  async getOHLC(params) {
+    return getOHLC(this._ctx, params);
+  }
 };
 export {
   ACTION,
   BROKER,
   DxtradeClient,
   DxtradeError,
+  ERROR,
   ORDER_TYPE,
   SIDE,
   TIF,