@danielgroen/dxtrade-api 1.0.20 → 1.0.22

package/dist/index.js

@@ -34,6 +34,7 @@ __export(index_exports, {
   BROKER: () => BROKER,
   DxtradeClient: () => DxtradeClient,
   DxtradeError: () => DxtradeError,
+  ERROR: () => ERROR,
   ORDER_TYPE: () => ORDER_TYPE,
   SIDE: () => SIDE,
   TIF: () => TIF,
@@ -50,7 +51,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}`,
@@ -58,9 +62,13 @@ var endpoints = {
   instrumentInfo: (base, symbol, tzOffset) => `${base}/api/instruments/info?symbol=${symbol}&timezoneOffset=${tzOffset}&withExDividends=true`,
   submitOrder: (base) => `${base}/api/orders/single`,
   closePosition: (base) => `${base}/api/positions/close`,
+  cancelOrder: (base, accountId, orderChainId) => `${base}/api/orders/cancel?accountId=${accountId}&orderChainId=${orderChainId}`,
   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}`,
+  tradeHistory: (base, params) => `${base}/api/history?from=${params.from}&to=${params.to}&orderId=`,
+  subscribeInstruments: (base) => `${base}/api/instruments/subscribeInstrumentSymbols`,
+  charts: (base) => `${base}/api/charts`
 };
 
 // src/constants/enums.ts
@@ -86,21 +94,63 @@ 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["ORDERS_TIMEOUT"] = "ORDERS_TIMEOUT";
+  ERROR2["ORDERS_ERROR"] = "ORDERS_ERROR";
+  ERROR2["CANCEL_ORDER_ERROR"] = "CANCEL_ORDER_ERROR";
+  ERROR2["POSITION_CLOSE_ERROR"] = "POSITION_CLOSE_ERROR";
+  ERROR2["POSITION_METRICS_TIMEOUT"] = "POSITION_METRICS_TIMEOUT";
+  ERROR2["POSITION_METRICS_ERROR"] = "POSITION_METRICS_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["TRADE_HISTORY_ERROR"] = "TRADE_HISTORY_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["LIMITS"] = "LIMITS";
   WS_MESSAGE2["MESSAGE"] = "MESSAGE";
   WS_MESSAGE2["ORDERS"] = "ORDERS";
   WS_MESSAGE2["POSITIONS"] = "POSITIONS";
+  WS_MESSAGE2["POSITION_METRICS"] = "POSITION_METRICS";
   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 {
@@ -189,6 +239,14 @@ function debugLog(msg) {
 function clearDebugLog() {
   (0, import_fs.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("|");
@@ -203,13 +261,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 import_ws.default(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);
@@ -225,10 +283,36 @@ 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}`));
     });
   });
 }
+async function getTradeHistory(ctx, params) {
+  ctx.ensureSession();
+  try {
+    const cookieStr = Cookies.serialize(ctx.cookies);
+    const response = await retryRequest(
+      {
+        method: "GET",
+        url: endpoints.tradeHistory(ctx.broker, params),
+        headers: { ...baseHeaders(), Cookie: cookieStr }
+      },
+      ctx.retries
+    );
+    if (response.status === 200) {
+      const setCookies = response.headers["set-cookie"] ?? [];
+      const incoming = Cookies.parse(setCookies);
+      ctx.cookies = Cookies.merge(ctx.cookies, incoming);
+      return response.data;
+    } else {
+      ctx.throwError("TRADE_HISTORY_ERROR" /* TRADE_HISTORY_ERROR */, `Trade history failed: ${response.status}`);
+    }
+  } catch (error) {
+    if (error instanceof DxtradeError) throw error;
+    const message = error instanceof Error ? error.message : "Unknown error";
+    ctx.throwError("TRADE_HISTORY_ERROR" /* TRADE_HISTORY_ERROR */, `Trade history error: ${message}`);
+  }
+}
 async function getTradeJournal(ctx, params) {
   ctx.ensureSession();
   try {
@@ -247,12 +331,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}`);
   }
 }
 
@@ -278,7 +362,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}`);
   }
 }
 
@@ -286,13 +370,13 @@ async function getAssessments(ctx, params) {
 var import_ws2 = __toESM(require("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 import_ws2.default(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;
@@ -322,17 +406,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
+var import_ws3 = __toESM(require("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 import_ws3.default(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
 var import_crypto = __toESM(require("crypto"));
-var import_ws4 = __toESM(require("ws"));
+var import_ws5 = __toESM(require("ws"));
 
 // src/domains/symbol/symbol.ts
-var import_ws3 = __toESM(require("ws"));
+var import_ws4 = __toESM(require("ws"));
 async function getSymbolSuggestions(ctx, text) {
   ctx.ensureSession();
   try {
@@ -347,13 +529,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) {
@@ -370,24 +552,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 import_ws3.default(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new import_ws4.default(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;
@@ -410,14 +592,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 import_ws4.default(wsUrl, { headers: { Cookie: cookieStr } });
+  const ws = new import_ws5.default(wsUrl, { headers: { Cookie: cookieStr } });
   let settled = false;
   const ready = new Promise((resolve) => {
     ws.on("open", resolve);
@@ -482,6 +664,61 @@ function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
   });
   return { promise, ready };
 }
+async function getOrders(ctx, timeout = 3e4) {
+  ctx.ensureSession();
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  return new Promise((resolve, reject) => {
+    const ws = new import_ws5.default(wsUrl, { headers: { Cookie: cookieStr } });
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new DxtradeError("ORDERS_TIMEOUT" /* ORDERS_TIMEOUT */, "Orders request timed out"));
+    }, timeout);
+    ws.on("message", (data) => {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "ORDERS" /* ORDERS */) {
+        clearTimeout(timer);
+        ws.close();
+        resolve(msg.body);
+      }
+    });
+    ws.on("error", (error) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new DxtradeError("ORDERS_ERROR" /* ORDERS_ERROR */, `Orders error: ${error.message}`));
+    });
+  });
+}
+async function cancelOrder(ctx, orderChainId) {
+  ctx.ensureSession();
+  const accountId = ctx.accountId ?? ctx.config.accountId;
+  if (!accountId) {
+    ctx.throwError("CANCEL_ORDER_ERROR" /* CANCEL_ORDER_ERROR */, "accountId is required to cancel an order");
+  }
+  try {
+    await retryRequest(
+      {
+        method: "DELETE",
+        url: endpoints.cancelOrder(ctx.broker, accountId, orderChainId),
+        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
+      },
+      ctx.retries
+    );
+  } catch (error) {
+    if (error instanceof DxtradeError) throw error;
+    const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
+    ctx.throwError("CANCEL_ORDER_ERROR" /* CANCEL_ORDER_ERROR */, `Cancel order error: ${message}`);
+  }
+}
+async function cancelAllOrders(ctx) {
+  const orders = await getOrders(ctx);
+  const pending = orders.filter((o) => !o.finalStatus);
+  for (const order of pending) {
+    await cancelOrder(ctx, order.orderId);
+  }
+}
 async function submitOrder(ctx, params) {
   ctx.ensureSession();
   const {
@@ -551,7 +788,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;
@@ -571,21 +808,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
-var import_ws5 = __toESM(require("ws"));
+var import_ws6 = __toESM(require("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 import_ws5.default(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new import_ws6.default(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);
@@ -600,10 +837,58 @@ 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}`));
     });
   });
 }
+async function getPositionMetrics(ctx, timeout = 3e4) {
+  ctx.ensureSession();
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  return new Promise((resolve, reject) => {
+    const ws = new import_ws6.default(wsUrl, { headers: { Cookie: cookieStr } });
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new DxtradeError("POSITION_METRICS_TIMEOUT" /* POSITION_METRICS_TIMEOUT */, "Position metrics timed out"));
+    }, timeout);
+    ws.on("message", (data) => {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "POSITION_METRICS" /* POSITION_METRICS */) {
+        clearTimeout(timer);
+        ws.close();
+        resolve(msg.body);
+      }
+    });
+    ws.on("error", (error) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new DxtradeError("POSITION_METRICS_ERROR" /* POSITION_METRICS_ERROR */, `Position metrics error: ${error.message}`));
+    });
+  });
+}
+async function closeAllPositions(ctx) {
+  const positions = await getPositions(ctx);
+  for (const pos of positions) {
+    const closeData = {
+      legs: [
+        {
+          instrumentId: pos.positionKey.instrumentId,
+          positionCode: pos.positionKey.positionCode,
+          positionEffect: "CLOSING",
+          ratioQuantity: 1,
+          symbol: pos.positionKey.positionCode
+        }
+      ],
+      limitPrice: 0,
+      orderType: "MARKET",
+      quantity: -pos.quantity,
+      timeInForce: "GTC"
+    };
+    await closePosition(ctx, closeData);
+  }
+}
 async function closePosition(ctx, data) {
   try {
     await retryRequest(
@@ -618,27 +903,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
-var import_ws6 = __toESM(require("ws"));
+var import_ws7 = __toESM(require("ws"));
 function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
   return new Promise((resolve, reject) => {
-    const ws = new import_ws6.default(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new import_ws7.default(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, accountId: msg.accountId });
       }
     });
     ws.on("error", (error) => {
@@ -669,12 +958,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) {
@@ -692,12 +981,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) {
@@ -715,19 +1004,27 @@ 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);
+  const handshake = await waitForHandshake(endpoints.websocket(ctx.broker), cookieStr, 3e4, ctx.debug);
+  ctx.atmosphereId = handshake.atmosphereId;
+  ctx.accountId = handshake.accountId;
   if (ctx.config.accountId) {
     await switchAccount(ctx, ctx.config.accountId);
-    await waitForHandshake(endpoints.websocket(ctx.broker), Cookies.serialize(ctx.cookies), 3e4, ctx.debug);
+    const reconnect = await waitForHandshake(
+      endpoints.websocket(ctx.broker, ctx.atmosphereId),
+      Cookies.serialize(ctx.cookies),
+      3e4,
+      ctx.debug
+    );
+    ctx.atmosphereId = reconnect.atmosphereId;
+    ctx.accountId = reconnect.accountId;
   }
 }
 
@@ -741,12 +1038,17 @@ var DxtradeClient = class {
       callbacks,
       cookies: {},
       csrf: null,
+      accountId: config.accountId ?? 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) {
@@ -791,6 +1093,18 @@ var DxtradeClient = class {
   async submitOrder(params) {
     return submitOrder(this._ctx, params);
   }
+  /** Get all pending/open orders via WebSocket. */
+  async getOrders() {
+    return getOrders(this._ctx);
+  }
+  /** Cancel a single pending order by its order chain ID. */
+  async cancelOrder(orderChainId) {
+    return cancelOrder(this._ctx, orderChainId);
+  }
+  /** Cancel all pending orders. */
+  async cancelAllOrders() {
+    return cancelAllOrders(this._ctx);
+  }
   /** Get account metrics including equity, balance, margin, and open P&L. */
   async getAccountMetrics() {
     return getAccountMetrics(this._ctx);
@@ -799,10 +1113,20 @@ var DxtradeClient = class {
   async getPositions() {
     return getPositions(this._ctx);
   }
-  /** Close a position. */
+  /**
+   * Close a position. Supports partial closes by specifying a quantity smaller than the full position size.
+   */
   async closePosition(position) {
     return closePosition(this._ctx, position);
   }
+  /** Close all open positions with market orders. */
+  async closeAllPositions() {
+    return closeAllPositions(this._ctx);
+  }
+  /** Get position-level P&L metrics via WebSocket. */
+  async getPositionMetrics() {
+    return getPositionMetrics(this._ctx);
+  }
   /**
    * Fetch trade journal entries for a date range.
    * @param params.from - Start timestamp (Unix ms)
@@ -811,6 +1135,14 @@ var DxtradeClient = class {
   async getTradeJournal(params) {
     return getTradeJournal(this._ctx, params);
   }
+  /**
+   * Fetch trade history for a date range.
+   * @param params.from - Start timestamp (Unix ms)
+   * @param params.to - End timestamp (Unix ms)
+   */
+  async getTradeHistory(params) {
+    return getTradeHistory(this._ctx, params);
+  }
   /** Get all available instruments, optionally filtered by partial match (e.g. `{ type: "FOREX" }`). */
   async getInstruments(params = {}) {
     return getInstruments(this._ctx, params);
@@ -819,6 +1151,17 @@ 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);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -826,6 +1169,7 @@ var DxtradeClient = class {
   BROKER,
   DxtradeClient,
   DxtradeError,
+  ERROR,
   ORDER_TYPE,
   SIDE,
   TIF,