@danielgroen/dxtrade-api 1.0.23 → 1.0.25

package/dist/index.mjs

@@ -21,7 +21,7 @@ var endpoints = {
   assessments: (base) => `${base}/api/assessments`,
   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=`,
+  tradeHistory: (base, params) => `${base}/api/history?from=${params.from}&to=${params.to}`,
   subscribeInstruments: (base) => `${base}/api/instruments/subscribeInstrumentSymbols`,
   charts: (base) => `${base}/api/charts`
 };
@@ -80,6 +80,9 @@ var ERROR = /* @__PURE__ */ ((ERROR2) => {
   ERROR2["TRADE_JOURNAL_ERROR"] = "TRADE_JOURNAL_ERROR";
   ERROR2["TRADE_HISTORY_ERROR"] = "TRADE_HISTORY_ERROR";
   ERROR2["ASSESSMENTS_ERROR"] = "ASSESSMENTS_ERROR";
+  ERROR2["RATE_LIMITED"] = "RATE_LIMITED";
+  ERROR2["WS_MANAGER_ERROR"] = "WS_MANAGER_ERROR";
+  ERROR2["STREAM_REQUIRES_CONNECT"] = "STREAM_REQUIRES_CONNECT";
   return ERROR2;
 })(ERROR || {});
 var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
@@ -104,6 +107,7 @@ var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
   let SUBTOPIC;
   ((SUBTOPIC2) => {
     SUBTOPIC2["BIG_CHART_COMPONENT"] = "BigChartComponentPresenter-4";
+    SUBTOPIC2["OHLC_STREAM"] = "OHLCStreamPresenter-0";
   })(SUBTOPIC = WS_MESSAGE2.SUBTOPIC || (WS_MESSAGE2.SUBTOPIC = {}));
 })(WS_MESSAGE || (WS_MESSAGE = {}));
 
@@ -118,7 +122,7 @@ var DxtradeError = class extends Error {
 };
 
 // src/domains/account/account.ts
-import WebSocket from "ws";
+import WebSocket2 from "ws";
 
 // src/utils/cookies.ts
 var Cookies = class {
@@ -171,7 +175,9 @@ async function retryRequest(config, retries = 3) {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       console.warn(`[dxtrade-api] Attempt ${attempt} failed: ${message}`, config.url);
-      if (isAxiosError(error) && error.response?.status === 429) throw error;
+      if (isAxiosError(error) && error.response?.status === 429) {
+        throw new DxtradeError("RATE_LIMITED" /* RATE_LIMITED */, "Rate limited (429). Too many requests \u2014 try again later.");
+      }
       if (attempt === retries) throw error;
       await new Promise((res) => setTimeout(res, 1e3 * attempt));
     }
@@ -214,13 +220,83 @@ function parseWsData(data) {
   }
 }
 
+// src/utils/ws-manager.ts
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+var WsManager = class extends EventEmitter {
+  _ws = null;
+  _cache = /* @__PURE__ */ new Map();
+  connect(wsUrl, cookieStr, debug = false) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl, { headers: { Cookie: cookieStr } });
+      ws.on("open", () => {
+        this._ws = ws;
+        resolve();
+      });
+      ws.on("message", (data) => {
+        const msg = parseWsData(data);
+        if (shouldLog(msg, debug)) debugLog(msg);
+        if (typeof msg === "string") return;
+        const payload = msg;
+        this._cache.set(payload.type, payload.body);
+        this.emit(payload.type, payload.body);
+      });
+      ws.on("error", (error) => {
+        if (!this._ws) {
+          return reject(error);
+        }
+        this.emit("error", error);
+      });
+      ws.on("close", () => {
+        this._ws = null;
+        this.emit("close");
+      });
+    });
+  }
+  waitFor(type, timeout = 3e4) {
+    const cached = this._cache.get(type);
+    if (cached !== void 0) {
+      return Promise.resolve(cached);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.removeListener(type, onMessage);
+        reject(new Error(`WsManager: timed out waiting for ${type}`));
+      }, timeout);
+      const onMessage = (body) => {
+        clearTimeout(timer);
+        resolve(body);
+      };
+      this.once(type, onMessage);
+    });
+  }
+  getCached(type) {
+    return this._cache.get(type);
+  }
+  close() {
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    this._cache.clear();
+    this.removeAllListeners();
+  }
+  get isConnected() {
+    return this._ws !== null && this._ws.readyState === WebSocket.OPEN;
+  }
+};
+
 // src/domains/account/account.ts
 async function getAccountMetrics(ctx, timeout = 3e4) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    const body = await ctx.wsManager.waitFor("ACCOUNT_METRICS" /* ACCOUNT_METRICS */, timeout);
+    return body.allMetrics;
+  }
   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 ws = new WebSocket2(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT" /* ACCOUNT_METRICS_TIMEOUT */, "Account metrics timed out"));
@@ -246,12 +322,11 @@ async function getAccountMetrics(ctx, timeout = 3e4) {
 async function getTradeHistory(ctx, params) {
   ctx.ensureSession();
   try {
-    const cookieStr = Cookies.serialize(ctx.cookies);
     const response = await retryRequest(
       {
-        method: "GET",
+        method: "POST",
         url: endpoints.tradeHistory(ctx.broker, params),
-        headers: { ...baseHeaders(), Cookie: cookieStr }
+        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
       },
       ctx.retries
     );
@@ -323,13 +398,13 @@ async function getAssessments(ctx, params) {
 }
 
 // src/domains/instrument/instrument.ts
-import WebSocket2 from "ws";
+import WebSocket3 from "ws";
 async function getInstruments(ctx, params = {}, 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 WebSocket2(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket3(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("INSTRUMENTS_TIMEOUT" /* INSTRUMENTS_TIMEOUT */, "Instruments request timed out"));
@@ -356,7 +431,7 @@ async function getInstruments(ctx, params = {}, timeout = 3e4) {
               return true;
             })
           );
-        }, 0);
+        }, 200);
       }
     });
     ws.on("error", (error) => {
@@ -368,7 +443,96 @@ async function getInstruments(ctx, params = {}, timeout = 3e4) {
 }
 
 // src/domains/ohlc/ohlc.ts
-import WebSocket3 from "ws";
+import WebSocket4 from "ws";
+async function streamOHLC(ctx, params, callback) {
+  if (!ctx.wsManager) {
+    ctx.throwError(
+      "STREAM_REQUIRES_CONNECT" /* STREAM_REQUIRES_CONNECT */,
+      "Streaming requires a persistent WebSocket. Use connect() instead of auth()."
+    );
+  }
+  const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
+  const subtopic = WS_MESSAGE.SUBTOPIC.OHLC_STREAM;
+  const headers = authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies));
+  const snapshotBars = [];
+  let snapshotDone = false;
+  let resolveSnapshot = null;
+  const onChartFeed = (body) => {
+    if (body?.subtopic !== subtopic) return;
+    const data = body.data;
+    if (!Array.isArray(data)) return;
+    if (!snapshotDone) {
+      snapshotBars.push(...data);
+      if (body.snapshotEnd) {
+        snapshotDone = true;
+        callback([...snapshotBars]);
+        resolveSnapshot?.();
+      }
+    } else {
+      callback(data);
+    }
+  };
+  ctx.wsManager.on("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+  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,
+              symbol
+            }
+          ]
+        },
+        headers
+      },
+      ctx.retries
+    );
+  } catch (error) {
+    ctx.wsManager.removeListener("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    ctx.throwError("OHLC_ERROR" /* OHLC_ERROR */, `OHLC stream subscription error: ${message}`);
+  }
+  await new Promise((resolve, reject) => {
+    if (snapshotDone) return resolve();
+    const timer = setTimeout(() => {
+      if (snapshotBars.length > 0) {
+        snapshotDone = true;
+        callback([...snapshotBars]);
+        resolve();
+      } else {
+        ctx.wsManager?.removeListener("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+        reject(new DxtradeError("OHLC_TIMEOUT" /* OHLC_TIMEOUT */, "OHLC stream snapshot timed out"));
+      }
+    }, 3e4);
+    resolveSnapshot = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+  });
+  return () => {
+    ctx.wsManager?.removeListener("chartFeedSubtopic" /* CHART_FEED_SUBTOPIC */, onChartFeed);
+  };
+}
 async function getOHLC(ctx, params, timeout = 3e4) {
   ctx.ensureSession();
   const { symbol, resolution = 60, range = 432e3, maxBars = 3500, priceField = "bid" } = params;
@@ -376,7 +540,7 @@ async function getOHLC(ctx, params, timeout = 3e4) {
   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 ws = new WebSocket4(wsUrl, { headers: { Cookie: cookieStr } });
     const bars = [];
     let putsSent = false;
     let initSettleTimer = null;
@@ -467,10 +631,10 @@ async function getOHLC(ctx, params, timeout = 3e4) {
 
 // src/domains/order/order.ts
 import crypto from "crypto";
-import WebSocket5 from "ws";
+import WebSocket6 from "ws";
 
 // src/domains/symbol/symbol.ts
-import WebSocket4 from "ws";
+import WebSocket5 from "ws";
 async function getSymbolSuggestions(ctx, text) {
   ctx.ensureSession();
   try {
@@ -522,7 +686,7 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket4(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("LIMITS_TIMEOUT" /* LIMITS_TIMEOUT */, "Symbol limits request timed out"));
@@ -542,7 +706,7 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
           clearTimeout(timer);
           ws.close();
           resolve(limits);
-        }, 0);
+        }, 200);
       }
     });
     ws.on("error", (error) => {
@@ -555,7 +719,7 @@ async function getSymbolLimits(ctx, timeout = 3e4) {
 
 // src/domains/order/order.ts
 function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
-  const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
+  const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
   let settled = false;
   const ready = new Promise((resolve) => {
     ws.on("open", resolve);
@@ -622,10 +786,13 @@ function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
 }
 async function getOrders(ctx, timeout = 3e4) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    return ctx.wsManager.waitFor("ORDERS" /* ORDERS */, timeout);
+  }
   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("ORDERS_TIMEOUT" /* ORDERS_TIMEOUT */, "Orders request timed out"));
@@ -769,13 +936,63 @@ async function submitOrder(ctx, params) {
 }
 
 // src/domains/position/position.ts
-import WebSocket6 from "ws";
+import WebSocket7 from "ws";
+function mergePositionsWithMetrics(positions, metrics) {
+  const metricsMap = new Map(metrics.map((m) => [m.uid, m]));
+  return positions.map((pos) => {
+    const m = metricsMap.get(pos.uid);
+    return {
+      ...pos,
+      margin: m?.margin ?? 0,
+      plOpen: m?.plOpen ?? 0,
+      plClosed: m?.plClosed ?? 0,
+      totalCommissions: m?.totalCommissions ?? 0,
+      totalFinancing: m?.totalFinancing ?? 0,
+      plRate: m?.plRate ?? 0,
+      averagePrice: m?.averagePrice ?? 0,
+      marketValue: m?.marketValue ?? 0
+    };
+  });
+}
+function streamPositions(ctx, callback) {
+  if (!ctx.wsManager) {
+    ctx.throwError(
+      "STREAM_REQUIRES_CONNECT" /* STREAM_REQUIRES_CONNECT */,
+      "Streaming requires a persistent WebSocket. Use connect() instead of auth()."
+    );
+  }
+  const emit = () => {
+    const positions = ctx.wsManager.getCached("POSITIONS" /* POSITIONS */);
+    const metrics = ctx.wsManager.getCached("POSITION_METRICS" /* POSITION_METRICS */);
+    if (positions && metrics) {
+      callback(mergePositionsWithMetrics(positions, metrics));
+    }
+  };
+  const onPositions = () => emit();
+  const onMetrics = () => emit();
+  ctx.wsManager.on("POSITIONS" /* POSITIONS */, onPositions);
+  ctx.wsManager.on("POSITION_METRICS" /* POSITION_METRICS */, onMetrics);
+  emit();
+  return () => {
+    ctx.wsManager?.removeListener("POSITIONS" /* POSITIONS */, onPositions);
+    ctx.wsManager?.removeListener("POSITION_METRICS" /* POSITION_METRICS */, onMetrics);
+  };
+}
 async function getPositions(ctx) {
   ctx.ensureSession();
+  if (ctx.wsManager) {
+    const [positions, metrics] = await Promise.all([
+      ctx.wsManager.waitFor("POSITIONS" /* POSITIONS */),
+      ctx.wsManager.waitFor("POSITION_METRICS" /* POSITION_METRICS */)
+    ]);
+    return mergePositionsWithMetrics(positions, metrics);
+  }
   const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
   const cookieStr = Cookies.serialize(ctx.cookies);
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket6(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket7(wsUrl, { headers: { Cookie: cookieStr } });
+    let positions = null;
+    let metrics = null;
     const timer = setTimeout(() => {
       ws.close();
       reject(new DxtradeError("ACCOUNT_POSITIONS_TIMEOUT" /* ACCOUNT_POSITIONS_TIMEOUT */, "Account positions timed out"));
@@ -785,42 +1002,21 @@ async function getPositions(ctx) {
       if (shouldLog(msg, ctx.debug)) debugLog(msg);
       if (typeof msg === "string") return;
       if (msg.type === "POSITIONS" /* POSITIONS */) {
-        clearTimeout(timer);
-        ws.close();
-        resolve(msg.body);
+        positions = msg.body;
       }
-    });
-    ws.on("error", (error) => {
-      clearTimeout(timer);
-      ws.close();
-      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 WebSocket6(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 */) {
+        metrics = msg.body;
+      }
+      if (positions && metrics) {
         clearTimeout(timer);
         ws.close();
-        resolve(msg.body);
+        resolve(mergePositionsWithMetrics(positions, metrics));
       }
     });
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
-      reject(new DxtradeError("POSITION_METRICS_ERROR" /* POSITION_METRICS_ERROR */, `Position metrics error: ${error.message}`));
+      reject(new DxtradeError("ACCOUNT_POSITIONS_ERROR" /* ACCOUNT_POSITIONS_ERROR */, `Account positions error: ${error.message}`));
     });
   });
 }
@@ -864,10 +1060,10 @@ async function closePosition(ctx, data) {
 }
 
 // src/domains/session/session.ts
-import WebSocket7 from "ws";
+import WebSocket8 from "ws";
 function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket7(wsUrl, { headers: { Cookie: cookieStr } });
+    const ws = new WebSocket8(wsUrl, { headers: { Cookie: cookieStr } });
     let atmosphereId = null;
     const timer = setTimeout(() => {
       ws.close();
@@ -967,7 +1163,7 @@ async function switchAccount(ctx, accountId) {
     ctx.throwError("ACCOUNT_SWITCH_ERROR" /* ACCOUNT_SWITCH_ERROR */, `Error switching account: ${message}`);
   }
 }
-async function connect(ctx) {
+async function auth(ctx) {
   await login(ctx);
   await fetchCsrf(ctx);
   if (ctx.debug) clearDebugLog();
@@ -987,112 +1183,81 @@ async function connect(ctx) {
     ctx.accountId = reconnect.accountId;
   }
 }
+async function connect(ctx) {
+  await auth(ctx);
+  const wsManager = new WsManager();
+  const wsUrl = endpoints.websocket(ctx.broker, ctx.atmosphereId);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  await wsManager.connect(wsUrl, cookieStr, ctx.debug);
+  ctx.wsManager = wsManager;
+}
+function disconnect(ctx) {
+  if (ctx.wsManager) {
+    ctx.wsManager.close();
+    ctx.wsManager = null;
+  }
+}
 
 // src/client.ts
-var DxtradeClient = class {
-  _ctx;
-  constructor(config) {
-    const callbacks = config.callbacks ?? {};
-    this._ctx = {
-      config,
-      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_SESSION */,
-            "No active session. Call login() and fetchCsrf() or connect() first."
-          );
-        }
-      },
-      throwError(code, message) {
-        const error = new DxtradeError(code, message);
-        callbacks.onError?.(error);
-        throw error;
-      }
-    };
+var PositionsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-  /** Authenticate with the broker using username and password. */
-  async login() {
-    return login(this._ctx);
+  /** Get all open positions with P&L metrics merged. */
+  get() {
+    return getPositions(this._ctx);
   }
-  /** Fetch the CSRF token required for authenticated requests. */
-  async fetchCsrf() {
-    return fetchCsrf(this._ctx);
+  /** Close a position. Supports partial closes by specifying a quantity smaller than the full position size. */
+  close(params) {
+    return closePosition(this._ctx, params);
   }
-  /** Switch to a specific trading account by ID. */
-  async switchAccount(accountId) {
-    return switchAccount(this._ctx, accountId);
-  }
-  /** Connect to the broker: login, fetch CSRF, WebSocket handshake, and optional account switch. */
-  async connect() {
-    return connect(this._ctx);
+  /** Close all open positions with market orders. */
+  closeAll() {
+    return closeAllPositions(this._ctx);
   }
-  /** Search for symbols matching the given text (e.g. "EURUSD", "BTC"). */
-  async getSymbolSuggestions(text) {
-    return getSymbolSuggestions(this._ctx, text);
+  /** Stream real-time position updates with P&L metrics. Requires connect(). Returns unsubscribe function. */
+  stream(callback) {
+    return streamPositions(this._ctx, callback);
   }
-  /** Get detailed instrument info for a symbol, including volume limits and lot size. */
-  async getSymbolInfo(symbol) {
-    return getSymbolInfo(this._ctx, symbol);
+};
+var OrdersDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
-  /** Get order size limits and stop/limit distances for all symbols. */
-  async getSymbolLimits() {
-    return getSymbolLimits(this._ctx);
+  /** Get all pending/open orders via WebSocket. */
+  get() {
+    return getOrders(this._ctx);
   }
   /**
    * Submit a trading order and wait for WebSocket confirmation.
    * Supports market, limit, and stop orders with optional stop loss and take profit.
    */
-  async submitOrder(params) {
+  submit(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) {
+  cancel(orderChainId) {
     return cancelOrder(this._ctx, orderChainId);
   }
   /** Cancel all pending orders. */
-  async cancelAllOrders() {
+  cancelAll() {
     return cancelAllOrders(this._ctx);
   }
+};
+var AccountDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
   /** Get account metrics including equity, balance, margin, and open P&L. */
-  async getAccountMetrics() {
+  metrics() {
     return getAccountMetrics(this._ctx);
   }
-  /** Get all open positions via WebSocket. */
-  async getPositions() {
-    return getPositions(this._ctx);
-  }
-  /**
-   * 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)
    * @param params.to - End timestamp (Unix ms)
    */
-  async getTradeJournal(params) {
+  tradeJournal(params) {
     return getTradeJournal(this._ctx, params);
   }
   /**
@@ -1100,16 +1265,39 @@ var DxtradeClient = class {
    * @param params.from - Start timestamp (Unix ms)
    * @param params.to - End timestamp (Unix ms)
    */
-  async getTradeHistory(params) {
+  tradeHistory(params) {
     return getTradeHistory(this._ctx, params);
   }
+};
+var SymbolsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Search for symbols matching the given text (e.g. "EURUSD", "BTC"). */
+  search(text) {
+    return getSymbolSuggestions(this._ctx, text);
+  }
+  /** Get detailed instrument info for a symbol, including volume limits and lot size. */
+  info(symbol) {
+    return getSymbolInfo(this._ctx, symbol);
+  }
+  /** Get order size limits and stop/limit distances for all symbols. */
+  limits() {
+    return getSymbolLimits(this._ctx);
+  }
+};
+var InstrumentsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
   /** Get all available instruments, optionally filtered by partial match (e.g. `{ type: "FOREX" }`). */
-  async getInstruments(params = {}) {
+  get(params = {}) {
     return getInstruments(this._ctx, params);
   }
-  /** Fetch PnL assessments for an instrument within a date range. */
-  async getAssessments(params) {
-    return getAssessments(this._ctx, params);
+};
+var OhlcDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
   }
   /**
    * Fetch OHLC price bars for a symbol.
@@ -1119,9 +1307,95 @@ var DxtradeClient = class {
    * @param params.maxBars - Maximum bars to return (default: 3500)
    * @param params.priceField - "bid" or "ask" (default: "bid")
    */
-  async getOHLC(params) {
+  get(params) {
     return getOHLC(this._ctx, params);
   }
+  /** Stream real-time OHLC bar updates. Requires connect(). Returns unsubscribe function. */
+  stream(params, callback) {
+    return streamOHLC(this._ctx, params, callback);
+  }
+};
+var AssessmentsDomain = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  /** Fetch PnL assessments for an instrument within a date range. */
+  get(params) {
+    return getAssessments(this._ctx, params);
+  }
+};
+var DxtradeClient = class {
+  _ctx;
+  /** Position operations: get, close, metrics, streaming. */
+  positions;
+  /** Order operations: get, submit, cancel. */
+  orders;
+  /** Account operations: metrics, trade journal, trade history. */
+  account;
+  /** Symbol operations: search, info, limits. */
+  symbols;
+  /** Instrument operations: get (with optional filtering). */
+  instruments;
+  /** OHLC price bar operations: get, stream. */
+  ohlc;
+  /** PnL assessment operations: get. */
+  assessments;
+  constructor(config) {
+    const callbacks = config.callbacks ?? {};
+    this._ctx = {
+      config,
+      callbacks,
+      cookies: {},
+      csrf: null,
+      accountId: config.accountId ?? null,
+      atmosphereId: null,
+      wsManager: null,
+      broker: config.broker,
+      retries: config.retries ?? 3,
+      debug: config.debug ?? false,
+      ensureSession() {
+        if (!this.csrf) {
+          throw new DxtradeError("NO_SESSION" /* NO_SESSION */, "No active session. Call auth() or connect() first.");
+        }
+      },
+      throwError(code, message) {
+        const error = new DxtradeError(code, message);
+        callbacks.onError?.(error);
+        throw error;
+      }
+    };
+    this.positions = new PositionsDomain(this._ctx);
+    this.orders = new OrdersDomain(this._ctx);
+    this.account = new AccountDomain(this._ctx);
+    this.symbols = new SymbolsDomain(this._ctx);
+    this.instruments = new InstrumentsDomain(this._ctx);
+    this.ohlc = new OhlcDomain(this._ctx);
+    this.assessments = new AssessmentsDomain(this._ctx);
+  }
+  /** Authenticate with the broker using username and password. */
+  async login() {
+    return login(this._ctx);
+  }
+  /** Fetch the CSRF token required for authenticated requests. */
+  async fetchCsrf() {
+    return fetchCsrf(this._ctx);
+  }
+  /** Switch to a specific trading account by ID. */
+  async switchAccount(accountId) {
+    return switchAccount(this._ctx, accountId);
+  }
+  /** Authenticate and establish a session: login, fetch CSRF, WebSocket handshake, and optional account switch. */
+  async auth() {
+    return auth(this._ctx);
+  }
+  /** Connect to the broker with a persistent WebSocket: auth + persistent WS for data reuse and streaming. */
+  async connect() {
+    return connect(this._ctx);
+  }
+  /** Close the persistent WebSocket connection. */
+  disconnect() {
+    return disconnect(this._ctx);
+  }
 };
 export {
   ACTION,