@danielgroen/dxtrade-api 1.0.8 → 1.0.9

package/dist/index.d.mts

@@ -33,8 +33,11 @@ declare enum TIF {
     GTD = "GTD"
 }
 declare enum WS_MESSAGE {
+    ACCOUNT_METRICS = "ACCOUNT_METRICS",
     ACCOUNTS = "ACCOUNTS",
     AVAILABLE_WATCHLISTS = "AVAILABLE_WATCHLISTS",
+    INSTRUMENTS = "INSTRUMENTS",
+    LIMITS = "LIMITS",
     MESSAGE = "MESSAGE",
     ORDERS = "ORDERS",
     POSITIONS = "POSITIONS",
@@ -162,17 +165,18 @@ interface WsPayload {
     type: string;
 }
 
-declare namespace Symbol {
-    interface Suggestion {
-        id: number;
-        name: string;
-        [key: string]: unknown;
-    }
-    interface Info {
-        maxVolume: number;
-        minVolume: number;
-        volumeStep: number;
-        lotSize: number;
+declare namespace Account {
+    interface Metrics {
+        availableFunds: number;
+        marginCallLevel: number | string;
+        riskLevel: number;
+        openPl: number;
+        cashBalance: number;
+        equity: number;
+        conversionRate: number;
+        initialMargin: number;
+        availableBalance: number;
+        reverseRiskLevel: number | string;
         [key: string]: unknown;
     }
 }
@@ -190,6 +194,72 @@ declare namespace Assessments {
     }
 }
 
+declare namespace Instrument {
+    interface Info {
+        id: number;
+        symbol: string;
+        description: string;
+        type: string;
+        subtype: string;
+        currency: string;
+        currencyPrecision: number;
+        precision: number;
+        pipsSize: number;
+        quantityIncrement: number;
+        quantityPrecision: number;
+        priceIncrement: number;
+        version: number;
+        priceIncrementsTO: {
+            priceIncrements: number[];
+            pricePrecisions: number[];
+            bondFraction: boolean;
+        };
+        lotSize: number;
+        baseCurrency: string | null;
+        lotName: string | null;
+        multiplier: number;
+        open: boolean;
+        expiration: string | null;
+        firstNoticeDate: string | null;
+        lastTradeDate: string | null;
+        underlying: string | null;
+        mmy: string | null;
+        optionParametersTO: unknown;
+        unitName: string | null;
+        additionalFields: unknown;
+        additionalObject: unknown;
+        currencyParametersTO: unknown;
+        tradingHours: string;
+    }
+}
+
+declare namespace Symbol {
+    interface Suggestion {
+        id: number;
+        name: string;
+        [key: string]: unknown;
+    }
+    interface Info {
+        maxVolume: number;
+        minVolume: number;
+        volumeStep: number;
+        lotSize: number;
+        [key: string]: unknown;
+    }
+    interface Limits {
+        symbol: string;
+        instrumentId: number;
+        limitStopDistanceType: string;
+        limitStopDistance: number;
+        limitStopDistanceInPercentOfSpread: number;
+        minOrderSize: number;
+        minOrderSizeBypass: boolean;
+        maxOrderSize: number;
+        minOrderIncrement: number;
+        limitType: string;
+    }
+}
+
 declare class DxtradeClient {
     private _ctx;
     constructor(config: DxtradeConfig);
@@ -199,7 +269,10 @@ declare class DxtradeClient {
     connect(): Promise<void>;
     getSymbolSuggestions(text: string): Promise<Symbol.Suggestion[]>;
     getSymbolInfo(symbol: string): Promise<Symbol.Info>;
+    getSymbolLimits(): Promise<Symbol.Limits[]>;
     submitOrder(params: Order.SubmitParams): Promise<Order.Update>;
+    getAccountMetrics(): Promise<Account.Metrics>;
+    getInstruments(params?: Partial<Instrument.Info>): Promise<Instrument.Info[]>;
     getAssessments(params: Assessments.Params): Promise<Assessments.Response>;
 }
 

package/dist/index.d.ts

@@ -33,8 +33,11 @@ declare enum TIF {
     GTD = "GTD"
 }
 declare enum WS_MESSAGE {
+    ACCOUNT_METRICS = "ACCOUNT_METRICS",
     ACCOUNTS = "ACCOUNTS",
     AVAILABLE_WATCHLISTS = "AVAILABLE_WATCHLISTS",
+    INSTRUMENTS = "INSTRUMENTS",
+    LIMITS = "LIMITS",
     MESSAGE = "MESSAGE",
     ORDERS = "ORDERS",
     POSITIONS = "POSITIONS",
@@ -162,17 +165,18 @@ interface WsPayload {
     type: string;
 }
 
-declare namespace Symbol {
-    interface Suggestion {
-        id: number;
-        name: string;
-        [key: string]: unknown;
-    }
-    interface Info {
-        maxVolume: number;
-        minVolume: number;
-        volumeStep: number;
-        lotSize: number;
+declare namespace Account {
+    interface Metrics {
+        availableFunds: number;
+        marginCallLevel: number | string;
+        riskLevel: number;
+        openPl: number;
+        cashBalance: number;
+        equity: number;
+        conversionRate: number;
+        initialMargin: number;
+        availableBalance: number;
+        reverseRiskLevel: number | string;
         [key: string]: unknown;
     }
 }
@@ -190,6 +194,72 @@ declare namespace Assessments {
     }
 }
 
+declare namespace Instrument {
+    interface Info {
+        id: number;
+        symbol: string;
+        description: string;
+        type: string;
+        subtype: string;
+        currency: string;
+        currencyPrecision: number;
+        precision: number;
+        pipsSize: number;
+        quantityIncrement: number;
+        quantityPrecision: number;
+        priceIncrement: number;
+        version: number;
+        priceIncrementsTO: {
+            priceIncrements: number[];
+            pricePrecisions: number[];
+            bondFraction: boolean;
+        };
+        lotSize: number;
+        baseCurrency: string | null;
+        lotName: string | null;
+        multiplier: number;
+        open: boolean;
+        expiration: string | null;
+        firstNoticeDate: string | null;
+        lastTradeDate: string | null;
+        underlying: string | null;
+        mmy: string | null;
+        optionParametersTO: unknown;
+        unitName: string | null;
+        additionalFields: unknown;
+        additionalObject: unknown;
+        currencyParametersTO: unknown;
+        tradingHours: string;
+    }
+}
+
+declare namespace Symbol {
+    interface Suggestion {
+        id: number;
+        name: string;
+        [key: string]: unknown;
+    }
+    interface Info {
+        maxVolume: number;
+        minVolume: number;
+        volumeStep: number;
+        lotSize: number;
+        [key: string]: unknown;
+    }
+    interface Limits {
+        symbol: string;
+        instrumentId: number;
+        limitStopDistanceType: string;
+        limitStopDistance: number;
+        limitStopDistanceInPercentOfSpread: number;
+        minOrderSize: number;
+        minOrderSizeBypass: boolean;
+        maxOrderSize: number;
+        minOrderIncrement: number;
+        limitType: string;
+    }
+}
+
 declare class DxtradeClient {
     private _ctx;
     constructor(config: DxtradeConfig);
@@ -199,7 +269,10 @@ declare class DxtradeClient {
     connect(): Promise<void>;
     getSymbolSuggestions(text: string): Promise<Symbol.Suggestion[]>;
     getSymbolInfo(symbol: string): Promise<Symbol.Info>;
+    getSymbolLimits(): Promise<Symbol.Limits[]>;
     submitOrder(params: Order.SubmitParams): Promise<Order.Update>;
+    getAccountMetrics(): Promise<Account.Metrics>;
+    getInstruments(params?: Partial<Instrument.Info>): Promise<Instrument.Info[]>;
     getAssessments(params: Assessments.Params): Promise<Assessments.Response>;
 }
 

package/dist/index.js

@@ -93,8 +93,11 @@ var TIF = /* @__PURE__ */ ((TIF2) => {
   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";
@@ -115,7 +118,7 @@ var DxtradeError = class extends Error {
   }
 };
 
-// src/domains/session/session.ts
+// src/domains/account/account.ts
 var import_ws = __toESM(require("ws"));
 
 // src/utils/cookies.ts
@@ -203,115 +206,113 @@ function parseWsData(data) {
   }
 }
 
-// src/domains/session/session.ts
-function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
+// 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 import_ws.default(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 msg = parseWsData(data);
-      if (shouldLog(msg, debug)) debugLog(msg);
+      if (shouldLog(msg, ctx.debug)) debugLog(msg);
       if (typeof msg === "string") return;
-      if (msg.type === "POSITIONS" /* POSITIONS */) {
+      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}`));
     });
   });
 }
-async function login(ctx) {
+
+// src/domains/assessments/assessments.ts
+async function getAssessments(ctx, params) {
+  ctx.ensureSession();
   try {
     const response = await retryRequest(
       {
         method: "POST",
-        url: endpoints.login(ctx.baseUrl),
+        url: endpoints.assessments(ctx.baseUrl),
         data: {
-          username: ctx.config.username,
-          password: ctx.config.password,
-          domain: ctx.config.broker
+          from: params.from,
+          instrument: params.instrument,
+          subtype: params.subtype ?? null,
+          to: params.to
         },
-        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);
+    return response.data;
   } 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("ASSESSMENTS_ERROR", `Error fetching assessments: ${message}`);
   }
 }
-async function connect(ctx) {
-  await login(ctx);
-  await fetchCsrf(ctx);
-  if (ctx.debug) clearDebugLog();
+
+// src/domains/instrument/instrument.ts
+var import_ws2 = __toESM(require("ws"));
+async function getInstruments(ctx, params = {}, timeout = 3e4) {
+  ctx.ensureSession();
   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);
-  }
+  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"));
+    }, 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
+var import_crypto = __toESM(require("crypto"));
+var import_ws4 = __toESM(require("ws"));
+
 // src/domains/symbol/symbol.ts
+var import_ws3 = __toESM(require("ws"));
 async function getSymbolSuggestions(ctx, text) {
   ctx.ensureSession();
   try {
@@ -358,12 +359,45 @@ async function getSymbolInfo(ctx, symbol) {
     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 import_ws3.default(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
-var import_crypto = __toESM(require("crypto"));
-var import_ws2 = __toESM(require("ws"));
 function createOrderListener(wsUrl, cookieStr, timeout = 3e4, debug = false) {
-  const ws = new import_ws2.default(wsUrl, { headers: { Cookie: cookieStr } });
+  const ws = new import_ws4.default(wsUrl, { headers: { Cookie: cookieStr } });
   let settled = false;
   const ready = new Promise((resolve) => {
     ws.on("open", resolve);
@@ -521,29 +555,112 @@ async function submitOrder(ctx, params) {
   }
 }
 
-// src/domains/assessments/assessments.ts
-async function getAssessments(ctx, params) {
-  ctx.ensureSession();
+// src/domains/session/session.ts
+var import_ws5 = __toESM(require("ws"));
+function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
+  return new Promise((resolve, reject) => {
+    const ws = new import_ws5.default(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.assessments(ctx.baseUrl),
+        url: endpoints.login(ctx.baseUrl),
         data: {
-          from: params.from,
-          instrument: params.instrument,
-          subtype: params.subtype ?? null,
-          to: params.to
+          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
     );
-    return response.data;
+    ctx.callbacks.onAccountSwitch?.(accountId);
   } 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("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);
   }
 }
 
@@ -590,9 +707,18 @@ var DxtradeClient = class {
   async getSymbolInfo(symbol) {
     return getSymbolInfo(this._ctx, symbol);
   }
+  async getSymbolLimits() {
+    return getSymbolLimits(this._ctx);
+  }
   async submitOrder(params) {
     return submitOrder(this._ctx, params);
   }
+  async getAccountMetrics() {
+    return getAccountMetrics(this._ctx);
+  }
+  async getInstruments(params = {}) {
+    return getInstruments(this._ctx, params);
+  }
   async getAssessments(params) {
     return getAssessments(this._ctx, params);
   }