@danielgroen/dxtrade-api 1.0.21 → 1.0.22

package/README.md

@@ -21,18 +21,18 @@ npm install dxtrade-api
 
 - [x] Authentication & session management
 - [x] Submit orders (market, limit, stop)
-- [x] Positions (get & close)
-- [x] Account metrics & trade journal
+- [x] Get & cancel orders
+- [x] Positions (get, close, close all)
+- [x] Position metrics (per-position P&L)
+- [x] Account metrics, trade journal & trade history
 - [x] Symbol search & instrument info
 - [x] OHLC / price bar data
 - [x] PnL assessments
 - [x] Multi-broker support (FTMO, Eightcap, Lark Funding)
 - [x] Full TypeScript support
 - [ ] Batch orders
-- [ ] Close whole position helper
 - [ ] Modify existing orders
 - [ ] Real-time price streaming
-- [ ] Order history
 
 ## Quick Start
 
@@ -105,16 +105,22 @@ BROKER.FTMO         // "https://dxtrade.ftmo.com"
 ### Trading
 
 - `client.submitOrder(params)` — Submit an order and wait for WebSocket confirmation
+- `client.getOrders()` — Get all pending/open orders via WebSocket
+- `client.cancelOrder(orderChainId)` — Cancel a single pending order
+- `client.cancelAllOrders()` — Cancel all pending orders
 
 ### Positions
 
 - `client.getPositions()` — Get all open positions via WebSocket
-- `client.closePosition(params)` — Close a position
+- `client.closePosition(params)` — Close a position (supports partial closes via the quantity field)
+- `client.closeAllPositions()` — Close all open positions with market orders
+- `client.getPositionMetrics()` — Get position-level P&L metrics via WebSocket
 
 ### Account
 
 - `client.getAccountMetrics()` — Get account metrics (equity, balance, margin, open P&L, etc.)
 - `client.getTradeJournal({ from, to })` — Fetch trade journal entries for a date range (Unix timestamps)
+- `client.getTradeHistory({ from, to })` — Fetch trade history for a date range (Unix timestamps)
 
 ### Analytics
 
@@ -152,8 +158,11 @@ const client = new DxtradeClient({
 cp .env.example .env  # fill in credentials
 npm run example:connect
 npm run example:order
+npm run example:orders
 npm run example:positions
 npm run example:close-position
+npm run example:close-all-positions
+npm run example:position-metrics
 npm run example:assessments
 npm run example:assessments:btc
 npm run example:account
@@ -163,6 +172,7 @@ npm run example:instruments:forex
 npm run example:symbol
 npm run example:symbol:btc
 npm run example:trade-journal
+npm run example:trade-history
 npm run example:debug
 ```
 

package/dist/index.d.mts

@@ -11,12 +11,17 @@ declare const endpoints: {
     instrumentInfo: (base: string, symbol: string, tzOffset: number) => string;
     submitOrder: (base: string) => string;
     closePosition: (base: string) => string;
+    cancelOrder: (base: string, accountId: string, orderChainId: number) => string;
     assessments: (base: string) => string;
     websocket: (base: string, atmosphereId?: string | null) => string;
     tradeJournal: (base: string, params: {
         from: number;
         to: number;
     }) => string;
+    tradeHistory: (base: string, params: {
+        from: number;
+        to: number;
+    }) => string;
     subscribeInstruments: (base: string) => string;
     charts: (base: string) => string;
 };
@@ -57,12 +62,18 @@ declare enum ERROR {
     OHLC_TIMEOUT = "OHLC_TIMEOUT",
     OHLC_ERROR = "OHLC_ERROR",
     ORDER_ERROR = "ORDER_ERROR",
+    ORDERS_TIMEOUT = "ORDERS_TIMEOUT",
+    ORDERS_ERROR = "ORDERS_ERROR",
+    CANCEL_ORDER_ERROR = "CANCEL_ORDER_ERROR",
     POSITION_CLOSE_ERROR = "POSITION_CLOSE_ERROR",
+    POSITION_METRICS_TIMEOUT = "POSITION_METRICS_TIMEOUT",
+    POSITION_METRICS_ERROR = "POSITION_METRICS_ERROR",
     ACCOUNT_METRICS_TIMEOUT = "ACCOUNT_METRICS_TIMEOUT",
     ACCOUNT_METRICS_ERROR = "ACCOUNT_METRICS_ERROR",
     ACCOUNT_POSITIONS_TIMEOUT = "ACCOUNT_POSITIONS_TIMEOUT",
     ACCOUNT_POSITIONS_ERROR = "ACCOUNT_POSITIONS_ERROR",
     TRADE_JOURNAL_ERROR = "TRADE_JOURNAL_ERROR",
+    TRADE_HISTORY_ERROR = "TRADE_HISTORY_ERROR",
     ASSESSMENTS_ERROR = "ASSESSMENTS_ERROR"
 }
 declare enum WS_MESSAGE {
@@ -71,11 +82,11 @@ declare enum WS_MESSAGE {
     AVAILABLE_WATCHLISTS = "AVAILABLE_WATCHLISTS",
     CHART_FEED_SUBTOPIC = "chartFeedSubtopic",
     INSTRUMENTS = "INSTRUMENTS",
-    INSTRUMENT_METRICS = "INSTRUMENT_METRICS",
     LIMITS = "LIMITS",
     MESSAGE = "MESSAGE",
     ORDERS = "ORDERS",
     POSITIONS = "POSITIONS",
+    POSITION_METRICS = "POSITION_METRICS",
     POSITION_CASH_TRANSFERS = "POSITION_CASH_TRANSFERS",
     PRIVATE_LAYOUT_NAMES = "PRIVATE_LAYOUT_NAMES",
     SHARED_PROPERTIES_MESSAGE = "SHARED_PROPERTIES_MESSAGE",
@@ -94,6 +105,22 @@ declare class DxtradeError extends Error {
 }
 
 declare namespace Order {
+    interface Get {
+        account: string;
+        orderId: number;
+        orderCode: string;
+        version: number;
+        type: ORDER_TYPE;
+        instrument: string;
+        status: string;
+        finalStatus: boolean;
+        side: SIDE;
+        tif: TIF;
+        legs: Leg[];
+        issueTime: string;
+        transactionTime: string;
+        [key: string]: unknown;
+    }
     interface SubmitParams {
         symbol: string;
         side: SIDE;
@@ -207,6 +234,20 @@ interface WsPayload {
 }
 
 declare namespace Account {
+    interface TradeHistory {
+        orderId: number;
+        orderCode: string;
+        instrument: string;
+        side: string;
+        type: string;
+        status: string;
+        quantity: number;
+        filledQuantity: number;
+        price: number;
+        averagePrice: number;
+        time: string;
+        [key: string]: unknown;
+    }
     interface Metrics {
         availableFunds: number;
         marginCallLevel: number | string;
@@ -318,6 +359,14 @@ declare namespace Position {
         takeProfit: number | null;
         stopLoss: number | null;
     }
+    interface Metrics {
+        positionCode: string;
+        openPl: number;
+        openPlPerLot: number;
+        currentPrice: number;
+        convertedOpenPl: number;
+        [key: string]: unknown;
+    }
     interface Close {
         legs: {
             instrumentId: number;
@@ -398,12 +447,24 @@ declare class DxtradeClient {
      * Supports market, limit, and stop orders with optional stop loss and take profit.
      */
     submitOrder(params: Order.SubmitParams): Promise<Order.Update>;
+    /** Get all pending/open orders via WebSocket. */
+    getOrders(): Promise<Order.Get[]>;
+    /** Cancel a single pending order by its order chain ID. */
+    cancelOrder(orderChainId: number): Promise<void>;
+    /** Cancel all pending orders. */
+    cancelAllOrders(): Promise<void>;
     /** Get account metrics including equity, balance, margin, and open P&L. */
     getAccountMetrics(): Promise<Account.Metrics>;
     /** Get all open positions via WebSocket. */
     getPositions(): Promise<Position.Get[]>;
-    /** Close a position. */
+    /**
+     * Close a position. Supports partial closes by specifying a quantity smaller than the full position size.
+     */
     closePosition(position: Position.Close): Promise<void>;
+    /** Close all open positions with market orders. */
+    closeAllPositions(): Promise<void>;
+    /** Get position-level P&L metrics via WebSocket. */
+    getPositionMetrics(): Promise<Position.Metrics[]>;
     /**
      * Fetch trade journal entries for a date range.
      * @param params.from - Start timestamp (Unix ms)
@@ -413,6 +474,15 @@ declare class DxtradeClient {
         from: number;
         to: number;
     }): Promise<any>;
+    /**
+     * Fetch trade history for a date range.
+     * @param params.from - Start timestamp (Unix ms)
+     * @param params.to - End timestamp (Unix ms)
+     */
+    getTradeHistory(params: {
+        from: number;
+        to: number;
+    }): Promise<Account.TradeHistory[]>;
     /** Get all available instruments, optionally filtered by partial match (e.g. `{ type: "FOREX" }`). */
     getInstruments(params?: Partial<Instrument.Info>): Promise<Instrument.Info[]>;
     /** Fetch PnL assessments for an instrument within a date range. */

package/dist/index.d.ts

@@ -11,12 +11,17 @@ declare const endpoints: {
     instrumentInfo: (base: string, symbol: string, tzOffset: number) => string;
     submitOrder: (base: string) => string;
     closePosition: (base: string) => string;
+    cancelOrder: (base: string, accountId: string, orderChainId: number) => string;
     assessments: (base: string) => string;
     websocket: (base: string, atmosphereId?: string | null) => string;
     tradeJournal: (base: string, params: {
         from: number;
         to: number;
     }) => string;
+    tradeHistory: (base: string, params: {
+        from: number;
+        to: number;
+    }) => string;
     subscribeInstruments: (base: string) => string;
     charts: (base: string) => string;
 };
@@ -57,12 +62,18 @@ declare enum ERROR {
     OHLC_TIMEOUT = "OHLC_TIMEOUT",
     OHLC_ERROR = "OHLC_ERROR",
     ORDER_ERROR = "ORDER_ERROR",
+    ORDERS_TIMEOUT = "ORDERS_TIMEOUT",
+    ORDERS_ERROR = "ORDERS_ERROR",
+    CANCEL_ORDER_ERROR = "CANCEL_ORDER_ERROR",
     POSITION_CLOSE_ERROR = "POSITION_CLOSE_ERROR",
+    POSITION_METRICS_TIMEOUT = "POSITION_METRICS_TIMEOUT",
+    POSITION_METRICS_ERROR = "POSITION_METRICS_ERROR",
     ACCOUNT_METRICS_TIMEOUT = "ACCOUNT_METRICS_TIMEOUT",
     ACCOUNT_METRICS_ERROR = "ACCOUNT_METRICS_ERROR",
     ACCOUNT_POSITIONS_TIMEOUT = "ACCOUNT_POSITIONS_TIMEOUT",
     ACCOUNT_POSITIONS_ERROR = "ACCOUNT_POSITIONS_ERROR",
     TRADE_JOURNAL_ERROR = "TRADE_JOURNAL_ERROR",
+    TRADE_HISTORY_ERROR = "TRADE_HISTORY_ERROR",
     ASSESSMENTS_ERROR = "ASSESSMENTS_ERROR"
 }
 declare enum WS_MESSAGE {
@@ -71,11 +82,11 @@ declare enum WS_MESSAGE {
     AVAILABLE_WATCHLISTS = "AVAILABLE_WATCHLISTS",
     CHART_FEED_SUBTOPIC = "chartFeedSubtopic",
     INSTRUMENTS = "INSTRUMENTS",
-    INSTRUMENT_METRICS = "INSTRUMENT_METRICS",
     LIMITS = "LIMITS",
     MESSAGE = "MESSAGE",
     ORDERS = "ORDERS",
     POSITIONS = "POSITIONS",
+    POSITION_METRICS = "POSITION_METRICS",
     POSITION_CASH_TRANSFERS = "POSITION_CASH_TRANSFERS",
     PRIVATE_LAYOUT_NAMES = "PRIVATE_LAYOUT_NAMES",
     SHARED_PROPERTIES_MESSAGE = "SHARED_PROPERTIES_MESSAGE",
@@ -94,6 +105,22 @@ declare class DxtradeError extends Error {
 }
 
 declare namespace Order {
+    interface Get {
+        account: string;
+        orderId: number;
+        orderCode: string;
+        version: number;
+        type: ORDER_TYPE;
+        instrument: string;
+        status: string;
+        finalStatus: boolean;
+        side: SIDE;
+        tif: TIF;
+        legs: Leg[];
+        issueTime: string;
+        transactionTime: string;
+        [key: string]: unknown;
+    }
     interface SubmitParams {
         symbol: string;
         side: SIDE;
@@ -207,6 +234,20 @@ interface WsPayload {
 }
 
 declare namespace Account {
+    interface TradeHistory {
+        orderId: number;
+        orderCode: string;
+        instrument: string;
+        side: string;
+        type: string;
+        status: string;
+        quantity: number;
+        filledQuantity: number;
+        price: number;
+        averagePrice: number;
+        time: string;
+        [key: string]: unknown;
+    }
     interface Metrics {
         availableFunds: number;
         marginCallLevel: number | string;
@@ -318,6 +359,14 @@ declare namespace Position {
         takeProfit: number | null;
         stopLoss: number | null;
     }
+    interface Metrics {
+        positionCode: string;
+        openPl: number;
+        openPlPerLot: number;
+        currentPrice: number;
+        convertedOpenPl: number;
+        [key: string]: unknown;
+    }
     interface Close {
         legs: {
             instrumentId: number;
@@ -398,12 +447,24 @@ declare class DxtradeClient {
      * Supports market, limit, and stop orders with optional stop loss and take profit.
      */
     submitOrder(params: Order.SubmitParams): Promise<Order.Update>;
+    /** Get all pending/open orders via WebSocket. */
+    getOrders(): Promise<Order.Get[]>;
+    /** Cancel a single pending order by its order chain ID. */
+    cancelOrder(orderChainId: number): Promise<void>;
+    /** Cancel all pending orders. */
+    cancelAllOrders(): Promise<void>;
     /** Get account metrics including equity, balance, margin, and open P&L. */
     getAccountMetrics(): Promise<Account.Metrics>;
     /** Get all open positions via WebSocket. */
     getPositions(): Promise<Position.Get[]>;
-    /** Close a position. */
+    /**
+     * Close a position. Supports partial closes by specifying a quantity smaller than the full position size.
+     */
     closePosition(position: Position.Close): Promise<void>;
+    /** Close all open positions with market orders. */
+    closeAllPositions(): Promise<void>;
+    /** Get position-level P&L metrics via WebSocket. */
+    getPositionMetrics(): Promise<Position.Metrics[]>;
     /**
      * Fetch trade journal entries for a date range.
      * @param params.from - Start timestamp (Unix ms)
@@ -413,6 +474,15 @@ declare class DxtradeClient {
         from: number;
         to: number;
     }): Promise<any>;
+    /**
+     * Fetch trade history for a date range.
+     * @param params.from - Start timestamp (Unix ms)
+     * @param params.to - End timestamp (Unix ms)
+     */
+    getTradeHistory(params: {
+        from: number;
+        to: number;
+    }): Promise<Account.TradeHistory[]>;
     /** Get all available instruments, optionally filtered by partial match (e.g. `{ type: "FOREX" }`). */
     getInstruments(params?: Partial<Instrument.Info>): Promise<Instrument.Info[]>;
     /** Fetch PnL assessments for an instrument within a date range. */

package/dist/index.js

@@ -62,9 +62,11 @@ 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, 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`
 };
@@ -110,12 +112,18 @@ var ERROR = /* @__PURE__ */ ((ERROR2) => {
   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 || {});
@@ -125,11 +133,11 @@ var WS_MESSAGE = /* @__PURE__ */ ((WS_MESSAGE2) => {
   WS_MESSAGE2["AVAILABLE_WATCHLISTS"] = "AVAILABLE_WATCHLISTS";
   WS_MESSAGE2["CHART_FEED_SUBTOPIC"] = "chartFeedSubtopic";
   WS_MESSAGE2["INSTRUMENTS"] = "INSTRUMENTS";
-  WS_MESSAGE2["INSTRUMENT_METRICS"] = "INSTRUMENT_METRICS";
   WS_MESSAGE2["LIMITS"] = "LIMITS";
   WS_MESSAGE2["MESSAGE"] = "MESSAGE";
   WS_MESSAGE2["ORDERS"] = "ORDERS";
   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";
@@ -279,6 +287,32 @@ 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",
+        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 {
@@ -630,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 {
@@ -752,6 +841,54 @@ async function getPositions(ctx) {
     });
   });
 }
+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(
@@ -790,7 +927,7 @@ function waitForHandshake(wsUrl, cookieStr, timeout = 3e4, debug = false) {
       if (msg.accountId) {
         clearTimeout(timer);
         ws.close();
-        resolve(atmosphereId);
+        resolve({ atmosphereId, accountId: msg.accountId });
       }
     });
     ws.on("error", (error) => {
@@ -875,15 +1012,19 @@ async function connect(ctx) {
   await fetchCsrf(ctx);
   if (ctx.debug) clearDebugLog();
   const cookieStr = Cookies.serialize(ctx.cookies);
-  ctx.atmosphereId = await waitForHandshake(endpoints.websocket(ctx.broker), 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);
-    ctx.atmosphereId = await waitForHandshake(
+    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;
   }
 }
 
@@ -897,6 +1038,7 @@ var DxtradeClient = class {
       callbacks,
       cookies: {},
       csrf: null,
+      accountId: config.accountId ?? null,
       atmosphereId: null,
       broker: config.broker,
       retries: config.retries ?? 3,
@@ -951,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);
@@ -959,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)
@@ -971,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);