@danielgroen/dxtrade-api 1.0.7 → 1.0.9

package/dist/index.mjs

@@ -1,12 +1,10 @@
 // src/constants/brokers.ts
 var BROKER = {
-  LARK: "https://trade.gooeytrade.com",
+  LARKFUNDING: "https://trade.gooeytrade.com",
   EIGHTCAP: "https://trader.dx-eightcap.com"
 };
 function resolveBrokerUrl(broker, customUrls) {
-  if (customUrls?.[broker]) {
-    return customUrls[broker];
-  }
+  if (customUrls?.[broker]) return customUrls[broker];
   const key = broker.toUpperCase();
   if (BROKER[key]) {
     return BROKER[key];
@@ -15,6 +13,7 @@ function resolveBrokerUrl(broker, customUrls) {
 }
 
 // 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`;
 var endpoints = {
   login: (base) => `${base}/api/auth/login`,
   switchAccount: (base, id) => `${base}/api/accounts/switch?accountId=${id}`,
@@ -22,7 +21,7 @@ var endpoints = {
   instrumentInfo: (base, symbol, tzOffset) => `${base}/api/instruments/info?symbol=${symbol}&timezoneOffset=${tzOffset}&withExDividends=true`,
   submitOrder: (base) => `${base}/api/orders/single`,
   assessments: (base) => `${base}/api/assessments`,
-  websocket: (base) => `wss://${base.split("//")[1]}/client/connector?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`
+  websocket: (base) => `wss://${base.split("//")[1]}/client/connector` + websocketQuery
 };
 
 // src/constants/enums.ts
@@ -42,6 +41,27 @@ var ACTION = /* @__PURE__ */ ((ACTION2) => {
   ACTION2["CLOSING"] = "CLOSING";
   return ACTION2;
 })(ACTION || {});
+var TIF = /* @__PURE__ */ ((TIF2) => {
+  TIF2["GTC"] = "GTC";
+  TIF2["DAY"] = "DAY";
+  TIF2["GTD"] = "GTD";
+  return TIF2;
+})(TIF || {});
+var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
+  WS_MESSAGE2["ACCOUNT_METRICS"] = "ACCOUNT_METRICS";
+  WS_MESSAGE2["ACCOUNTS"] = "ACCOUNTS";
+  WS_MESSAGE2["AVAILABLE_WATCHLISTS"] = "AVAILABLE_WATCHLISTS";
+  WS_MESSAGE2["INSTRUMENTS"] = "INSTRUMENTS";
+  WS_MESSAGE2["LIMITS"] = "LIMITS";
+  WS_MESSAGE2["MESSAGE"] = "MESSAGE";
+  WS_MESSAGE2["ORDERS"] = "ORDERS";
+  WS_MESSAGE2["POSITIONS"] = "POSITIONS";
+  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["USER_LOGIN_INFO"] = "USER_LOGIN_INFO";
+  return WS_MESSAGE2;
+})(WS_MESSAGE || {});
 
 // src/constants/errors.ts
 var DxtradeError = class extends Error {
@@ -53,28 +73,30 @@ var DxtradeError = class extends Error {
   }
 };
 
-// src/client.ts
-import crypto from "crypto";
+// src/domains/account/account.ts
+import WebSocket from "ws";
 
 // src/utils/cookies.ts
-function parseCookies(setCookieHeaders) {
-  const cookies = {};
-  for (const cookie of setCookieHeaders) {
-    const [nameValue] = cookie.split(";");
-    const eqIndex = nameValue.indexOf("=");
-    if (eqIndex === -1) continue;
-    const name = nameValue.slice(0, eqIndex).trim();
-    const value = nameValue.slice(eqIndex + 1).trim();
-    cookies[name] = value;
+var Cookies = class {
+  static parse(setCookieHeaders) {
+    const cookies = {};
+    for (const cookie of setCookieHeaders) {
+      const [nameValue] = cookie.split(";");
+      const eqIndex = nameValue.indexOf("=");
+      if (eqIndex === -1) continue;
+      const name = nameValue.slice(0, eqIndex).trim();
+      const value = nameValue.slice(eqIndex + 1).trim();
+      cookies[name] = value;
+    }
+    return cookies;
   }
-  return cookies;
-}
-function serializeCookies(cookies) {
-  return Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
-}
-function mergeCookies(existing, incoming) {
-  return { ...existing, ...incoming };
-}
+  static serialize(cookies) {
+    return Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
+  }
+  static merge(existing, incoming) {
+    return { ...existing, ...incoming };
+  }
+};
 
 // src/utils/headers.ts
 function baseHeaders() {
@@ -113,362 +135,547 @@ async function retryRequest(config, retries = 3) {
 }
 
 // src/utils/websocket.ts
-import WebSocket from "ws";
-function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
+import { appendFileSync, writeFileSync } from "fs";
+var DEBUG_LOG = "debug.log";
+function shouldLog(msg, debug) {
+  if (!debug) return false;
+  if (debug === true || debug === "true") return true;
+  if (typeof msg === "string") return false;
+  const filters = debug.split(",").map((s) => s.trim().toUpperCase());
+  return filters.includes(msg.type);
+}
+function debugLog(msg) {
+  appendFileSync(DEBUG_LOG, JSON.stringify(msg) + "\n");
+}
+function clearDebugLog() {
+  writeFileSync(DEBUG_LOG, "");
+}
+function parseWsData(data) {
+  const raw = data.toString();
+  const pipeIndex = raw.indexOf("|");
+  if (pipeIndex === -1) return raw;
+  try {
+    return JSON.parse(raw.slice(pipeIndex + 1));
+  } catch {
+    return raw;
+  }
+}
+
+// src/domains/account/account.ts
+async function getAccountMetrics(ctx, timeout = 3e4) {
+  ctx.ensureSession();
+  const wsUrl = endpoints.websocket(ctx.baseUrl);
+  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 Error("[dxtrade-api] Handshake timed out"));
+      reject(new DxtradeError("ACCOUNT_METRICS_TIMEOUT", "Account metrics timed out"));
     }, timeout);
     ws.on("message", (data) => {
-      const str = data.toString();
-      if (debug) console.log("[dxtrade-api:ws]", str);
-      if (str.includes(`"POSITIONS"`)) {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "ACCOUNT_METRICS" /* ACCOUNT_METRICS */) {
         clearTimeout(timer);
         ws.close();
-        resolve();
+        const body = msg.body;
+        resolve(body.allMetrics);
       }
     });
     ws.on("error", (error) => {
       clearTimeout(timer);
       ws.close();
-      reject(new Error(`[dxtrade-api] WebSocket handshake error: ${error.message}`));
+      reject(new DxtradeError("ACCOUNT_METRICS_ERROR", `Account metrics error: ${error.message}`));
     });
   });
 }
-function waitForOrderUpdate(wsUrl, cookieStr, timeout = 3e4, debug = false) {
+
+// src/domains/assessments/assessments.ts
+async function getAssessments(ctx, params) {
+  ctx.ensureSession();
+  try {
+    const response = await retryRequest(
+      {
+        method: "POST",
+        url: endpoints.assessments(ctx.baseUrl),
+        data: {
+          from: params.from,
+          instrument: params.instrument,
+          subtype: params.subtype ?? null,
+          to: params.to
+        },
+        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
+      },
+      ctx.retries
+    );
+    return response.data;
+  } 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}`);
+  }
+}
+
+// src/domains/instrument/instrument.ts
+import WebSocket2 from "ws";
+async function getInstruments(ctx, params = {}, timeout = 3e4) {
+  ctx.ensureSession();
+  const wsUrl = endpoints.websocket(ctx.baseUrl);
+  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("INSTRUMENTS_TIMEOUT", "Instruments request timed out"));
+    }, timeout);
+    let instruments = [];
+    let settleTimer = null;
+    ws.on("message", (data) => {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "INSTRUMENTS" /* INSTRUMENTS */) {
+        instruments.push(...msg.body);
+        if (settleTimer) clearTimeout(settleTimer);
+        settleTimer = setTimeout(() => {
+          clearTimeout(timer);
+          ws.close();
+          resolve(
+            instruments.filter((instrument) => {
+              for (const key in params) {
+                if (params[key] !== instrument[key]) {
+                  return false;
+                }
+              }
+              return true;
+            })
+          );
+        }, 0);
+      }
+    });
+    ws.on("error", (error) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new DxtradeError("INSTRUMENTS_ERROR", `Instruments error: ${error.message}`));
+    });
+  });
+}
+
+// src/domains/order/order.ts
+import crypto from "crypto";
+import WebSocket4 from "ws";
+
+// src/domains/symbol/symbol.ts
+import WebSocket3 from "ws";
+async function getSymbolSuggestions(ctx, text) {
+  ctx.ensureSession();
+  try {
+    const cookieStr = Cookies.serialize(ctx.cookies);
+    const response = await retryRequest(
+      {
+        method: "GET",
+        url: endpoints.suggest(ctx.baseUrl, text),
+        headers: { ...baseHeaders(), Cookie: cookieStr }
+      },
+      ctx.retries
+    );
+    const suggests = response.data?.suggests;
+    if (!suggests?.length) {
+      ctx.throwError("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}`);
+  }
+}
+async function getSymbolInfo(ctx, symbol) {
+  ctx.ensureSession();
+  try {
+    const offsetMinutes = Math.abs((/* @__PURE__ */ new Date()).getTimezoneOffset());
+    const cookieStr = Cookies.serialize(ctx.cookies);
+    const response = await retryRequest(
+      {
+        method: "GET",
+        url: endpoints.instrumentInfo(ctx.baseUrl, symbol, offsetMinutes),
+        headers: { ...baseHeaders(), Cookie: cookieStr }
+      },
+      ctx.retries
+    );
+    if (!response.data) {
+      ctx.throwError("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}`);
+  }
+}
+async function getSymbolLimits(ctx, timeout = 3e4) {
+  ctx.ensureSession();
+  const wsUrl = endpoints.websocket(ctx.baseUrl);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket3(wsUrl, { headers: { Cookie: cookieStr } });
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new DxtradeError("LIMITS_TIMEOUT", "Symbol limits request timed out"));
+    }, timeout);
+    let limits = [];
+    let settleTimer = null;
+    ws.on("message", (data) => {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "LIMITS" /* LIMITS */) {
+        const batch = msg.body;
+        if (batch.length === 0) return;
+        limits.push(...batch);
+        if (settleTimer) clearTimeout(settleTimer);
+        settleTimer = setTimeout(() => {
+          clearTimeout(timer);
+          ws.close();
+          resolve(limits);
+        }, 0);
+      }
+    });
+    ws.on("error", (error) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new DxtradeError("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 } });
+  let settled = false;
+  const ready = new Promise((resolve) => {
+    ws.on("open", resolve);
+  });
+  const promise = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
       ws.close();
       reject(new Error("[dxtrade-api] Order update timed out"));
     }, timeout);
+    function done(err, result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      ws.close();
+      if (err) reject(err);
+      else resolve(result);
+    }
     ws.on("message", (data) => {
-      const str = data.toString();
-      if (debug) console.log("[dxtrade-api:ws]", str);
-      if (!str.includes(`"ORDERS"`)) return;
-      if (!str.includes(`orderId`)) return;
-      const json = str.replace(/^.*?\{/, "{");
-      if (!json.includes("{")) return;
-      try {
-        const response = JSON.parse(json);
-        const body = response.body?.[0];
-        if (!body) return;
-        clearTimeout(timer);
-        ws.close();
+      const msg = parseWsData(data);
+      if (shouldLog(msg, debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "MESSAGE" /* MESSAGE */) {
+        const messages = msg.body;
+        const orderMsg = messages?.findLast?.(
+          (m) => m.messageCategory === "TRADE_LOG" && m.messageType === "ORDER" && !m.historyMessage
+        );
+        if (!orderMsg) return;
+        const params = orderMsg.parametersTO;
+        if (params.orderStatus === "REJECTED") {
+          const reason = params.rejectReason?.key ?? "Unknown reason";
+          done(new Error(`[dxtrade-api] Order rejected: ${reason}`));
+        } else if (params.orderStatus === "FILLED") {
+          done(null, {
+            orderId: params.orderKey,
+            status: params.orderStatus,
+            symbol: params.symbol,
+            filledQuantity: params.filledQuantity,
+            filledPrice: params.filledPrice
+          });
+        }
+        return;
+      }
+      if (msg.type === "ORDERS" /* ORDERS */) {
+        const body = msg.body?.[0];
+        if (!body?.orderId) return;
         if (body.status === "REJECTED") {
-          reject(new Error(`[dxtrade-api] Order rejected: ${body.statusDescription ?? "Unknown reason"}`));
-        } else {
-          resolve(body);
+          done(new Error(`[dxtrade-api] Order rejected: ${body.statusDescription ?? "Unknown reason"}`));
+        } else if (body.status === "FILLED") {
+          done(null, body);
         }
-      } catch {
       }
     });
     ws.on("error", (error) => {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
       ws.close();
       reject(new Error(`[dxtrade-api] WebSocket order listener error: ${error.message}`));
     });
   });
+  return { promise, ready };
+}
+async function submitOrder(ctx, params) {
+  ctx.ensureSession();
+  const {
+    symbol,
+    side,
+    quantity,
+    orderType,
+    orderCode,
+    price,
+    instrumentId,
+    stopLoss,
+    takeProfit,
+    positionEffect = "OPENING" /* OPENING */,
+    positionCode,
+    tif = "GTC",
+    expireDate,
+    metadata
+  } = params;
+  const info = await getSymbolInfo(ctx, symbol);
+  const units = Math.round(quantity * info.lotSize);
+  const qty = side === "BUY" /* BUY */ ? units : -units;
+  const priceParam = orderType === "STOP" /* STOP */ ? "stopPrice" : "limitPrice";
+  const orderData = {
+    directExchange: false,
+    legs: [
+      {
+        ...instrumentId != null && { instrumentId },
+        ...positionCode != null && { positionCode },
+        positionEffect,
+        ratioQuantity: 1,
+        symbol
+      }
+    ],
+    orderSide: side,
+    orderType,
+    quantity: qty,
+    requestId: orderCode ?? `gwt-uid-931-${crypto.randomUUID()}`,
+    timeInForce: tif,
+    ...expireDate != null && { expireDate },
+    ...metadata != null && { metadata }
+  };
+  if (price != null && orderType !== "MARKET" /* MARKET */) {
+    orderData[priceParam] = price;
+  }
+  if (stopLoss) {
+    orderData.stopLoss = {
+      ...stopLoss.offset != null && { fixedOffset: stopLoss.offset },
+      ...stopLoss.price != null && { fixedPrice: stopLoss.price },
+      priceFixed: stopLoss.price != null,
+      orderChainId: 0,
+      orderId: 0,
+      orderType: "STOP" /* STOP */,
+      quantityForProtection: qty,
+      removed: false
+    };
+  }
+  if (takeProfit) {
+    orderData.takeProfit = {
+      ...takeProfit.offset != null && { fixedOffset: takeProfit.offset },
+      ...takeProfit.price != null && { fixedPrice: takeProfit.price },
+      priceFixed: takeProfit.price != null,
+      orderChainId: 0,
+      orderId: 0,
+      orderType: "LIMIT" /* LIMIT */,
+      quantityForProtection: qty,
+      removed: false
+    };
+  }
+  try {
+    const wsUrl = endpoints.websocket(ctx.baseUrl);
+    const cookieStr = Cookies.serialize(ctx.cookies);
+    const listener = createOrderListener(wsUrl, cookieStr, 3e4, ctx.debug);
+    await listener.ready;
+    const response = await retryRequest(
+      {
+        method: "POST",
+        url: endpoints.submitOrder(ctx.baseUrl),
+        data: orderData,
+        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
+      },
+      ctx.retries
+    );
+    ctx.callbacks.onOrderPlaced?.(response.data);
+    const orderUpdate = await listener.promise;
+    ctx.callbacks.onOrderUpdate?.(orderUpdate);
+    return orderUpdate;
+  } 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}`);
+  }
+}
+
+// src/domains/session/session.ts
+import WebSocket5 from "ws";
+function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket5(wsUrl, { headers: { Cookie: cookieStr } });
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error("[dxtrade-api] Handshake timed out"));
+    }, timeout);
+    ws.on("message", (data) => {
+      const msg = parseWsData(data);
+      if (shouldLog(msg, debug)) debugLog(msg);
+      if (typeof msg === "string") return;
+      if (msg.type === "POSITIONS" /* POSITIONS */) {
+        clearTimeout(timer);
+        ws.close();
+        resolve();
+      }
+    });
+    ws.on("error", (error) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new Error(`[dxtrade-api] WebSocket handshake error: ${error.message}`));
+    });
+  });
+}
+async function login(ctx) {
+  try {
+    const response = await retryRequest(
+      {
+        method: "POST",
+        url: endpoints.login(ctx.baseUrl),
+        data: {
+          username: ctx.config.username,
+          password: ctx.config.password,
+          domain: ctx.config.broker
+        },
+        headers: { "Content-Type": "application/json" }
+      },
+      ctx.retries
+    );
+    if (response.status === 200) {
+      const setCookies = response.headers["set-cookie"] ?? [];
+      const incoming = Cookies.parse(setCookies);
+      ctx.cookies = Cookies.merge(ctx.cookies, incoming);
+      ctx.callbacks.onLogin?.();
+    } else {
+      ctx.throwError("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}`);
+  }
+}
+async function fetchCsrf(ctx) {
+  try {
+    const cookieStr = Cookies.serialize(ctx.cookies);
+    const response = await retryRequest(
+      {
+        method: "GET",
+        url: ctx.baseUrl,
+        headers: { ...cookieOnlyHeaders(cookieStr), Referer: ctx.baseUrl }
+      },
+      ctx.retries
+    );
+    const csrfMatch = response.data?.match(/name="csrf" content="([^"]+)"/);
+    if (csrfMatch) {
+      ctx.csrf = csrfMatch[1];
+    } else {
+      ctx.throwError("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}`);
+  }
+}
+async function switchAccount(ctx, accountId) {
+  ctx.ensureSession();
+  try {
+    await retryRequest(
+      {
+        method: "POST",
+        url: endpoints.switchAccount(ctx.baseUrl, accountId),
+        headers: authHeaders(ctx.csrf, Cookies.serialize(ctx.cookies))
+      },
+      ctx.retries
+    );
+    ctx.callbacks.onAccountSwitch?.(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}`);
+  }
+}
+async function connect(ctx) {
+  await login(ctx);
+  await fetchCsrf(ctx);
+  if (ctx.debug) clearDebugLog();
+  const wsUrl = endpoints.websocket(ctx.baseUrl);
+  const cookieStr = Cookies.serialize(ctx.cookies);
+  await waitForHandshake(wsUrl, cookieStr, 3e4, ctx.debug);
+  if (ctx.config.accountId) {
+    await switchAccount(ctx, ctx.config.accountId);
+    await waitForHandshake(endpoints.websocket(ctx.baseUrl), Cookies.serialize(ctx.cookies), 3e4, ctx.debug);
+  }
 }
 
 // src/client.ts
 var DxtradeClient = class {
-  config;
-  callbacks;
-  cookies = {};
-  csrf = null;
-  baseUrl;
-  retries;
-  debug;
+  _ctx;
   constructor(config) {
-    this.config = config;
-    this.callbacks = config.callbacks ?? {};
-    this.baseUrl = resolveBrokerUrl(config.broker, config.brokerUrls);
-    this.retries = config.retries ?? 3;
-    this.debug = config.debug ?? false;
+    const callbacks = config.callbacks ?? {};
+    this._ctx = {
+      config,
+      callbacks,
+      cookies: {},
+      csrf: null,
+      baseUrl: resolveBrokerUrl(config.broker, config.brokerUrls),
+      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.");
+        }
+      },
+      throwError(code, message) {
+        const error = new DxtradeError(code, message);
+        callbacks.onError?.(error);
+        throw error;
+      }
+    };
   }
-  // ── Session ─────────────────────────────────────────────────────────────────────────────────────────────────────────
   async login() {
-    try {
-      const response = await retryRequest(
-        {
-          method: "POST",
-          url: endpoints.login(this.baseUrl),
-          data: {
-            username: this.config.username,
-            password: this.config.password,
-            domain: this.config.broker
-          },
-          headers: { "Content-Type": "application/json" }
-        },
-        this.retries
-      );
-      if (response.status === 200) {
-        const setCookies = response.headers["set-cookie"] ?? [];
-        const incoming = parseCookies(setCookies);
-        this.cookies = mergeCookies(this.cookies, incoming);
-        this.callbacks.onLogin?.();
-      } else {
-        this.throwError("LOGIN_FAILED", `Login failed: ${response.status}`);
-      }
-    } catch (error) {
-      if (error instanceof DxtradeError) throw error;
-      const message = error instanceof Error ? error.message : "Unknown error";
-      this.throwError("LOGIN_ERROR", `Login error: ${message}`);
-    }
+    return login(this._ctx);
   }
   async fetchCsrf() {
-    try {
-      const cookieStr = serializeCookies(this.cookies);
-      const response = await retryRequest(
-        {
-          method: "GET",
-          url: this.baseUrl,
-          headers: { ...cookieOnlyHeaders(cookieStr), Referer: this.baseUrl }
-        },
-        this.retries
-      );
-      const csrfMatch = response.data?.match(/name="csrf" content="([^"]+)"/);
-      if (csrfMatch) {
-        this.csrf = csrfMatch[1];
-      } else {
-        this.throwError("CSRF_NOT_FOUND", "CSRF token not found");
-      }
-    } catch (error) {
-      if (error instanceof DxtradeError) throw error;
-      const message = error instanceof Error ? error.message : "Unknown error";
-      this.throwError("CSRF_ERROR", `CSRF fetch error: ${message}`);
-    }
+    return fetchCsrf(this._ctx);
   }
   async switchAccount(accountId) {
-    this.ensureSession();
-    try {
-      await retryRequest(
-        {
-          method: "POST",
-          url: endpoints.switchAccount(this.baseUrl, accountId),
-          headers: authHeaders(this.csrf, serializeCookies(this.cookies))
-        },
-        this.retries
-      );
-      this.callbacks.onAccountSwitch?.(accountId);
-    } catch (error) {
-      if (error instanceof DxtradeError) throw error;
-      const message = error instanceof Error ? error.message : "Unknown error";
-      this.throwError(
-        "ACCOUNT_SWITCH_ERROR",
-        `Error switching account: ${message}`
-      );
-    }
+    return switchAccount(this._ctx, accountId);
+  }
+  async connect() {
+    return connect(this._ctx);
   }
-  // ── Market Data ─────────────────────────────────────────────────────────────────────────────────────────────────────
   async getSymbolSuggestions(text) {
-    this.ensureSession();
-    try {
-      const cookieStr = serializeCookies(this.cookies);
-      const response = await retryRequest(
-        {
-          method: "GET",
-          url: endpoints.suggest(this.baseUrl, text),
-          headers: { ...baseHeaders(), Cookie: cookieStr }
-        },
-        this.retries
-      );
-      const suggests = response.data?.suggests;
-      if (!suggests?.length) {
-        this.throwError("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";
-      this.throwError(
-        "SUGGEST_ERROR",
-        `Error getting symbol suggestions: ${message}`
-      );
-    }
+    return getSymbolSuggestions(this._ctx, text);
   }
   async getSymbolInfo(symbol) {
-    this.ensureSession();
-    try {
-      const offsetMinutes = Math.abs((/* @__PURE__ */ new Date()).getTimezoneOffset());
-      const cookieStr = serializeCookies(this.cookies);
-      const response = await retryRequest(
-        {
-          method: "GET",
-          url: endpoints.instrumentInfo(this.baseUrl, symbol, offsetMinutes),
-          headers: { ...baseHeaders(), Cookie: cookieStr }
-        },
-        this.retries
-      );
-      if (!response.data) {
-        this.throwError("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";
-      this.throwError(
-        "SYMBOL_INFO_ERROR",
-        `Error getting symbol info: ${message}`
-      );
-    }
+    return getSymbolInfo(this._ctx, symbol);
   }
-  // ── Trading ─────────────────────────────────────────────────────────────────────────────────────────────────────────
-  async submitOrder(params) {
-    this.ensureSession();
-    const {
-      symbol,
-      side,
-      quantity,
-      orderType,
-      price,
-      instrumentId,
-      stopLoss,
-      takeProfit,
-      positionEffect = "OPENING" /* OPENING */
-    } = params;
-    const qty = side === "BUY" /* BUY */ ? Math.abs(quantity) : -Math.abs(quantity);
-    const priceParam = orderType === "STOP" /* STOP */ ? "stopPrice" : "limitPrice";
-    const orderData = {
-      directExchange: false,
-      legs: [
-        {
-          ...instrumentId != null && { instrumentId },
-          positionEffect,
-          ratioQuantity: 1,
-          symbol
-        }
-      ],
-      orderSide: side,
-      orderType,
-      quantity: qty,
-      requestId: `gwt-uid-931-${crypto.randomUUID()}`,
-      timeInForce: "GTC"
-    };
-    if (price != null && orderType !== "MARKET" /* MARKET */) {
-      orderData[priceParam] = price;
-    }
-    if (stopLoss) {
-      orderData.stopLoss = {
-        ...stopLoss.offset != null && { fixedOffset: stopLoss.offset },
-        ...stopLoss.price != null && { fixedPrice: stopLoss.price },
-        priceFixed: stopLoss.price != null,
-        orderChainId: 0,
-        orderId: 0,
-        orderType: "STOP" /* STOP */,
-        quantityForProtection: qty,
-        removed: false
-      };
-    }
-    if (takeProfit) {
-      orderData.takeProfit = {
-        ...takeProfit.offset != null && { fixedOffset: takeProfit.offset },
-        ...takeProfit.price != null && { fixedPrice: takeProfit.price },
-        priceFixed: takeProfit.price != null,
-        orderChainId: 0,
-        orderId: 0,
-        orderType: "LIMIT" /* LIMIT */,
-        quantityForProtection: qty,
-        removed: false
-      };
-    }
-    try {
-      const response = await retryRequest(
-        {
-          method: "POST",
-          url: endpoints.submitOrder(this.baseUrl),
-          data: orderData,
-          headers: authHeaders(this.csrf, serializeCookies(this.cookies))
-        },
-        this.retries
-      );
-      if (response.status !== 200) {
-        this.throwError(
-          "ORDER_SUBMIT_FAILED",
-          `Order submission failed with status: ${response.status}`
-        );
-      }
-      this.callbacks.onOrderPlaced?.({
-        status: response.status,
-        data: response.data
-      });
-      const wsUrl = endpoints.websocket(this.baseUrl);
-      const cookieStr = serializeCookies(this.cookies);
-      const orderUpdate = await waitForOrderUpdate(
-        wsUrl,
-        cookieStr,
-        3e4,
-        this.debug
-      );
-      this.callbacks.onOrderUpdate?.(orderUpdate);
-      return orderUpdate;
-    } catch (error) {
-      if (error instanceof DxtradeError) throw error;
-      const message = error instanceof Error ? error.response?.data?.message ?? error.message : "Unknown error";
-      this.throwError("ORDER_ERROR", `Error submitting order: ${message}`);
-    }
+  async getSymbolLimits() {
+    return getSymbolLimits(this._ctx);
   }
-  // ── Analytics ───────────────────────────────────────────────────────────────────────────────────────────────────────
-  async getAssessments(params) {
-    this.ensureSession();
-    try {
-      const response = await retryRequest(
-        {
-          method: "POST",
-          url: endpoints.assessments(this.baseUrl),
-          data: {
-            from: params.from,
-            instrument: params.instrument,
-            subtype: params.subtype ?? null,
-            to: params.to
-          },
-          headers: authHeaders(this.csrf, serializeCookies(this.cookies))
-        },
-        this.retries
-      );
-      return response.data;
-    } catch (error) {
-      if (error instanceof DxtradeError) throw error;
-      const message = error instanceof Error ? error.message : "Unknown error";
-      this.throwError(
-        "ASSESSMENTS_ERROR",
-        `Error fetching assessments: ${message}`
-      );
-    }
+  async submitOrder(params) {
+    return submitOrder(this._ctx, params);
   }
-  // ── Convenience ─────────────────────────────────────────────────────────────────────────────────────────────────────
-  async connect() {
-    await this.login();
-    await this.fetchCsrf();
-    const wsUrl = endpoints.websocket(this.baseUrl);
-    const cookieStr = serializeCookies(this.cookies);
-    await waitForHandshake(wsUrl, cookieStr, 3e4, this.debug);
-    if (this.config.accountId) {
-      await this.switchAccount(this.config.accountId);
-      await waitForHandshake(
-        endpoints.websocket(this.baseUrl),
-        serializeCookies(this.cookies),
-        3e4,
-        this.debug
-      );
-    }
+  async getAccountMetrics() {
+    return getAccountMetrics(this._ctx);
   }
-  // ── Internals ───────────────────────────────────────────────────────────────────────────────────────────────────────
-  ensureSession() {
-    if (!this.csrf) {
-      throw new DxtradeError(
-        "NO_SESSION",
-        "No active session. Call login() and fetchCsrf() or connect() first."
-      );
-    }
+  async getInstruments(params = {}) {
+    return getInstruments(this._ctx, params);
   }
-  throwError(code, message) {
-    const error = new DxtradeError(code, message);
-    this.callbacks.onError?.(error);
-    throw error;
+  async getAssessments(params) {
+    return getAssessments(this._ctx, params);
   }
 };
 export {
@@ -478,6 +685,8 @@ export {
   DxtradeError,
   ORDER_TYPE,
   SIDE,
+  TIF,
+  WS_MESSAGE,
   endpoints,
   resolveBrokerUrl
 };