@0xmonaco/core 0.6.2 → 0.7.0

package/dist/api/trading/api.d.ts

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, OrderSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateConditionalOrderParams, CreateConditionalOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -79,6 +79,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         useMasterBalance?: boolean;
         expirationDate?: string;
         timeInForce?: TimeInForce;
+        marginAccountId?: string;
+        positionSide?: PositionSide;
+        leverage?: string;
+        reduceOnly?: boolean;
     }): Promise<CreateOrderResponse>;
     /**
      * Places a market order for immediate execution.
@@ -124,6 +128,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     placeMarketOrder(tradingPairId: string, side: OrderSide, quantity: string, options?: {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
+        marginAccountId?: string;
+        positionSide?: PositionSide;
+        leverage?: string;
+        reduceOnly?: boolean;
     }): Promise<CreateOrderResponse>;
     /**
      * Cancels an existing order.
@@ -142,6 +150,9 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     cancelOrder(orderId: string): Promise<CancelOrderResponse>;
+    createConditionalOrder(params: CreateConditionalOrderParams): Promise<CreateConditionalOrderResponse>;
+    cancelConditionalOrder(conditionalOrderId: string): Promise<CancelConditionalOrderResponse>;
+    listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**
      * Batch cancels specific orders by their IDs.
      *
@@ -242,7 +253,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      *
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED") (optional)
-     * @param params.trading_pair - Filter by trading pair (e.g., "USDCo/MTK") (optional)
+     * @param params.trading_pair_id - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
      * @param params.page_size - Number of orders per page (defaults to 10, max 100, must be > 0)
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
@@ -253,7 +264,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * // Get submitted orders for a specific trading pair with custom pagination
      * const orders = await tradingAPI.getPaginatedOrders({
      *   status: "SUBMITTED",
-     *   trading_pair: "USDCo/MTK",
+     *   trading_pair_id: "456e7890-e12b-12d3-a456-426614174000",
      *   page: 1,
      *   page_size: 20
      * });

package/dist/api/trading/api.js

@@ -21,8 +21,9 @@
  * );
  * ```
  */
-import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelOrderSchema, GetPaginatedOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
+import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, CreateConditionalOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
 export class TradingAPIImpl extends BaseAPI {
     /**
      * Places a limit order on the order book.
@@ -93,8 +94,12 @@ export class TradingAPIImpl extends BaseAPI {
             use_master_balance: options?.useMasterBalance,
             expiration_date: options?.expirationDate,
             time_in_force: options?.timeInForce,
+            margin_account_id: options?.marginAccountId,
+            position_side: options?.positionSide,
+            leverage: options?.leverage,
+            reduce_only: options?.reduceOnly,
         };
-        return await this.makeAuthenticatedRequest("/api/v1/orders", {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -156,8 +161,12 @@ export class TradingAPIImpl extends BaseAPI {
             price: null, // Market orders don't need price
             quantity,
             trading_mode: options?.tradingMode || "SPOT",
+            margin_account_id: options?.marginAccountId,
+            position_side: options?.positionSide,
+            leverage: options?.leverage,
+            reduce_only: options?.reduceOnly,
         };
-        return await this.makeAuthenticatedRequest("/api/v1/orders", {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -184,11 +193,53 @@ export class TradingAPIImpl extends BaseAPI {
         const requestBody = {
             order_id: orderId,
         };
-        return await this.makeAuthenticatedRequest("/api/v1/orders/cancel", {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.cancel(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
     }
+    async createConditionalOrder(params) {
+        validate(CreateConditionalOrderSchema, params);
+        const requestBody = {
+            trading_pair_id: params.tradingPairId,
+            margin_account_id: params.marginAccountId,
+            condition_type: params.conditionType,
+            trigger_price: params.triggerPrice,
+            trigger_source: params.triggerSource ?? "MARK_PRICE",
+            side: params.side,
+            position_side: params.positionSide,
+            order_type: params.orderType,
+            limit_price: params.limitPrice,
+            quantity: params.quantity,
+            reduce_only: params.reduceOnly ?? true,
+            time_in_force: params.timeInForce,
+            slippage_tolerance_bps: params.slippageToleranceBps,
+            expires_at: params.expiresAt,
+        };
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.createConditional(), {
+            method: "POST",
+            body: JSON.stringify(requestBody),
+        });
+    }
+    async cancelConditionalOrder(conditionalOrderId) {
+        validate(CancelConditionalOrderSchema, { conditionalOrderId });
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.cancelConditional(conditionalOrderId), {
+            method: "DELETE",
+        });
+    }
+    async listConditionalOrders(params) {
+        if (params) {
+            validate(ListConditionalOrdersSchema, params);
+        }
+        const { page = 1, page_size = 20, margin_account_id, trading_pair_id, state } = params || {};
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.listConditional({
+            page,
+            page_size: Math.min(Math.max(page_size, 1), 100),
+            margin_account_id,
+            trading_pair_id,
+            state,
+        }), { method: "GET" });
+    }
     /**
      * Batch cancels specific orders by their IDs.
      *
@@ -205,7 +256,7 @@ export class TradingAPIImpl extends BaseAPI {
         if (!orderIds || orderIds.length === 0) {
             throw new Error("orderIds is required and must not be empty");
         }
-        return this.makeAuthenticatedRequest("/api/v1/orders/batch-cancel", {
+        return this.makeAuthenticatedRequest(perpRoutes.orders.batchCancel(), {
             method: "POST",
             body: JSON.stringify({ order_ids: orderIds }),
         });
@@ -227,7 +278,7 @@ export class TradingAPIImpl extends BaseAPI {
      * ```
      */
     async batchCancelAll(tradingPairId) {
-        const endpoint = tradingPairId ? `/api/v1/orders/batch-cancel-all/${tradingPairId}` : "/api/v1/orders/batch-cancel-all";
+        const endpoint = tradingPairId ? perpRoutes.orders.batchCancelAllByPair(tradingPairId) : perpRoutes.orders.batchCancelAll();
         return this.makeAuthenticatedRequest(endpoint, {
             method: "POST",
         });
@@ -244,7 +295,7 @@ export class TradingAPIImpl extends BaseAPI {
         if (newOrder.quantity !== undefined) {
             requestBody.quantity = newOrder.quantity;
         }
-        return await this.makeAuthenticatedRequest(`/api/v1/orders/${orderId}`, {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.replace(orderId), {
             method: "PUT",
             body: JSON.stringify(requestBody),
         });
@@ -293,9 +344,13 @@ export class TradingAPIImpl extends BaseAPI {
                 use_master_balance: order.useMasterBalance,
                 expiration_date: order.expirationDate,
                 time_in_force: order.timeInForce,
+                margin_account_id: order.marginAccountId,
+                position_side: order.positionSide,
+                leverage: order.leverage,
+                reduce_only: order.reduceOnly,
             })),
         };
-        return this.makeAuthenticatedRequest("/api/v1/orders/batch-create", {
+        return this.makeAuthenticatedRequest(perpRoutes.orders.batchCreate(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -335,7 +390,7 @@ export class TradingAPIImpl extends BaseAPI {
                 use_master_balance: order.useMasterBalance,
             })),
         };
-        return this.makeAuthenticatedRequest("/api/v1/orders/batch-replace", {
+        return this.makeAuthenticatedRequest(perpRoutes.orders.batchReplace(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
@@ -348,7 +403,7 @@ export class TradingAPIImpl extends BaseAPI {
      *
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED") (optional)
-     * @param params.trading_pair - Filter by trading pair (e.g., "USDCo/MTK") (optional)
+     * @param params.trading_pair_id - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
      * @param params.page_size - Number of orders per page (defaults to 10, max 100, must be > 0)
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
@@ -359,7 +414,7 @@ export class TradingAPIImpl extends BaseAPI {
      * // Get submitted orders for a specific trading pair with custom pagination
      * const orders = await tradingAPI.getPaginatedOrders({
      *   status: "SUBMITTED",
-     *   trading_pair: "USDCo/MTK",
+     *   trading_pair_id: "456e7890-e12b-12d3-a456-426614174000",
      *   page: 1,
      *   page_size: 20
      * });
@@ -375,7 +430,7 @@ export class TradingAPIImpl extends BaseAPI {
             validate(GetPaginatedOrdersSchema, params);
         }
         // Set pagination defaults with destructuring and validation
-        const { page = 1, page_size = 10, status, trading_pair } = params || {};
+        const { page = 1, page_size = 10, status, trading_pair_id, trading_mode, margin_account_id } = params || {};
         const validPage = page > 0 ? page : 1;
         const validPageSize = page_size > 0 ? page_size : 10;
         const pageSize = Math.min(validPageSize, 100);
@@ -386,8 +441,14 @@ export class TradingAPIImpl extends BaseAPI {
         if (status) {
             searchParams.append("status", status);
         }
-        if (trading_pair) {
-            searchParams.append("trading_pair", trading_pair);
+        if (trading_pair_id) {
+            searchParams.append("trading_pair_id", trading_pair_id);
+        }
+        if (trading_mode) {
+            searchParams.append("trading_mode", trading_mode);
+        }
+        if (margin_account_id) {
+            searchParams.append("margin_account_id", margin_account_id);
         }
         const endpoint = `/api/v1/orders?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {
@@ -413,7 +474,7 @@ export class TradingAPIImpl extends BaseAPI {
      * ```
      */
     async getOrder(orderId) {
-        return await this.makeAuthenticatedRequest(`/api/v1/orders/${orderId}`, {
+        return await this.makeAuthenticatedRequest(perpRoutes.orders.get(orderId), {
             method: "GET",
         });
     }

package/dist/api/websocket/types.d.ts

@@ -1,4 +1,4 @@
-import type { Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
+import type { ConditionalOrderEvent, Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
 export type StatusHandler = (status: WebSocketStatus) => void;
 export type MessageHandler<T> = (data: T) => void;
 export interface MonacoWebSocketOptions {
@@ -36,4 +36,6 @@ export interface MonacoWebSocket {
     userOrders: (handler: MessageHandler<OrderEvent>) => () => void;
     /** Subscribe to user balance events (requires authentication) */
     balances: (handler: MessageHandler<UserBalanceEvent>) => () => void;
+    /** Subscribe to conditional TP/SL lifecycle events (requires authentication) */
+    conditionalOrders: (handler: MessageHandler<ConditionalOrderEvent>, tradingPairId?: string) => () => void;
 }

package/dist/api/websocket/websocket.js

@@ -4,6 +4,100 @@ import { keysToCamelCase } from "./utils";
 const CONNECTION_TIMEOUT = 10000;
 const HEARTBEAT_INTERVAL = 15000;
 const MAX_RECONNECT_DELAY = 30000;
+const CONDITIONAL_ORDER_REASONS = ["created", "cancelled", "triggered", "failed", "oco_cancelled"];
+const CONDITIONAL_ORDER_CONDITION_TYPES = ["STOP_LOSS", "TAKE_PROFIT"];
+const CONDITIONAL_ORDER_TRIGGER_SOURCES = ["MARK_PRICE"];
+const CONDITIONAL_ORDER_STATES = ["ACTIVE", "TRIGGERING", "TRIGGERED", "CANCELLED", "EXPIRED", "FAILED"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(source, field) {
+    const value = source[field];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Invalid conditional order event: ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function readOptionalString(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new Error(`Invalid conditional order event: ${field} must be a string`);
+    }
+    return value;
+}
+function readBoolean(source, field) {
+    const value = source[field];
+    if (typeof value !== "boolean") {
+        throw new Error(`Invalid conditional order event: ${field} must be a boolean`);
+    }
+    return value;
+}
+function readOptionalNumber(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`Invalid conditional order event: ${field} must be a finite number`);
+    }
+    return value;
+}
+function readEnum(source, field, allowed) {
+    const value = readString(source, field);
+    if (!allowed.includes(value)) {
+        throw new Error(`Invalid conditional order event: ${field} must be one of ${allowed.join(", ")}`);
+    }
+    return value;
+}
+function readOptionalEnum(source, field, allowed) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        throw new Error(`Invalid conditional order event: ${field} must be one of ${allowed.join(", ")}`);
+    }
+    return value;
+}
+function parseConditionalOrderEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid conditional order event: payload must be an object");
+    }
+    if (!isRecord(rawData.data)) {
+        throw new Error("Invalid conditional order event: data must be an object");
+    }
+    const data = keysToCamelCase(rawData.data);
+    return {
+        eventType: readEnum(rawData, "event_type", ["conditional_order_update"]),
+        userId: readString(rawData, "user_id"),
+        data: {
+            conditionalOrderId: readString(data, "conditionalOrderId"),
+            tradingPairId: readString(data, "tradingPairId"),
+            marginAccountId: readString(data, "marginAccountId"),
+            positionId: readOptionalString(data, "positionId"),
+            linkedGroupId: readOptionalString(data, "linkedGroupId"),
+            conditionType: readEnum(data, "conditionType", CONDITIONAL_ORDER_CONDITION_TYPES),
+            triggerSource: readEnum(data, "triggerSource", CONDITIONAL_ORDER_TRIGGER_SOURCES),
+            triggerPrice: readString(data, "triggerPrice"),
+            side: readEnum(data, "side", ["BUY", "SELL"]),
+            positionSide: readEnum(data, "positionSide", ["LONG", "SHORT", "NONE"]),
+            orderType: readEnum(data, "orderType", ["LIMIT", "MARKET"]),
+            limitPrice: readOptionalString(data, "limitPrice"),
+            quantity: readOptionalString(data, "quantity"),
+            slippageToleranceBps: readOptionalNumber(data, "slippageToleranceBps"),
+            reduceOnly: readBoolean(data, "reduceOnly"),
+            timeInForce: readOptionalEnum(data, "timeInForce", ["GTC", "IOC"]),
+            state: readEnum(data, "state", CONDITIONAL_ORDER_STATES),
+            triggeredOrderId: readOptionalString(data, "triggeredOrderId"),
+            triggeredAt: readOptionalString(data, "triggeredAt"),
+            cancelledAt: readOptionalString(data, "cancelledAt"),
+            expiresAt: readOptionalString(data, "expiresAt"),
+            failureReason: readOptionalString(data, "failureReason"),
+            reason: readEnum(data, "reason", CONDITIONAL_ORDER_REASONS),
+            updatedAt: readString(data, "updatedAt"),
+        },
+    };
+}
 /**
  * Create a Monaco WebSocket client
  */
@@ -62,7 +156,11 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         }
         reconnectAttempts++;
         const delay = Math.min(1000 * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY);
-        reconnectTimer = setTimeout(() => connect(), delay);
+        reconnectTimer = setTimeout(() => {
+            connect().catch((err) => {
+                console.warn("WebSocket: Failed to reconnect:", err);
+            });
+        }, delay);
     };
     const send = (data) => {
         if (ws?.readyState === WebSocket.OPEN) {
@@ -84,7 +182,6 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 for (const handler of channelHandlers) {
                     handler(msg.data);
                 }
-                return;
             }
         }
     };
@@ -96,22 +193,33 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 return;
             }
             try {
-                ws = new WebSocket(getUrl());
+                const socket = new WebSocket(getUrl());
+                ws = socket;
                 const timeout = setTimeout(() => {
-                    if (ws?.readyState === WebSocket.CONNECTING) {
-                        ws.close();
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    if (socket.readyState === WebSocket.CONNECTING) {
+                        socket.close(1000, "Connection timeout");
                         reject(new Error("WebSocket connection timeout"));
                     }
                 }, CONNECTION_TIMEOUT);
-                ws.onopen = () => {
+                socket.onopen = () => {
                     clearTimeout(timeout);
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
                     reconnectAttempts = 0;
                     startHeartbeat();
                     resubscribeAll();
                     options.onStatusChange?.("connected");
                     resolve();
                 };
-                ws.onmessage = (event) => {
+                socket.onmessage = (event) => {
+                    if (ws !== socket)
+                        return;
                     try {
                         const msg = JSON.parse(event.data);
                         // Handle pong silently
@@ -123,8 +231,13 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         console.warn("WebSocket: Failed to parse message", err);
                     }
                 };
-                ws.onclose = (event) => {
+                socket.onclose = (event) => {
                     clearTimeout(timeout);
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    ws = null;
                     stopHeartbeat();
                     options.onStatusChange?.("disconnected");
                     // Reconnect on abnormal close
@@ -132,7 +245,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         scheduleReconnect();
                     }
                 };
-                ws.onerror = () => clearTimeout(timeout);
+                socket.onerror = () => clearTimeout(timeout);
             }
             catch (err) {
                 options.onStatusChange?.("disconnected");
@@ -207,7 +320,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 const data = rawData;
                 const orderbookData = data.data;
                 const event = {
-                    tradingPairId: data.pair,
+                    tradingPairId: data.symbol,
                     tradingMode: data.trading_mode,
                     bids: (orderbookData?.bids || []).map((level) => ({
                         price: level.price,
@@ -251,7 +364,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 const data = rawData;
                 const ohlcvData = data.data;
                 const event = {
-                    tradingPairId: data.pair,
+                    tradingPairId: data.symbol,
                     tradingMode: data.trading_mode,
                     interval: data.interval,
                     candlestick: {
@@ -262,7 +375,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         l: ohlcvData.low || "0",
                         c: ohlcvData.close || "0",
                         v: ohlcvData.volume || "0",
-                        s: data.pair,
+                        s: data.symbol,
                         i: data.interval,
                         n: ohlcvData.trades_count || 0,
                     },
@@ -282,7 +395,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 const tradeData = data.data;
                 const event = {
                     eventType: "trade",
-                    tradingPairId: data.pair_id,
+                    tradingPairId: data.trading_pair_id,
                     tradingMode: data.trading_mode.toUpperCase(),
                     data: {
                         tradeId: tradeData.trade_id,
@@ -393,18 +506,40 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
             }
         });
     };
+    const subscribeConditionalOrders = (handler, tradingPairId) => {
+        if (!handler) {
+            throw new Error("conditionalOrders subscription requires a handler");
+        }
+        if (tradingPairId !== undefined && tradingPairId.length === 0) {
+            throw new Error("conditionalOrders tradingPairId cannot be empty");
+        }
+        const channel = tradingPairId ? `conditional_orders:${tradingPairId}` : "conditional_orders";
+        return subscribe(channel, (rawData) => {
+            try {
+                handler(parseConditionalOrderEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing conditional order event", err);
+            }
+        });
+    };
     return {
         connect,
         disconnect,
         isConnected: () => ws?.readyState === WebSocket.OPEN,
         getStatus,
         setToken: (newToken) => {
-            token = newToken;
-            // Reconnect to include token in ws URL
-            if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) {
-                ws.close(1000, "Token updated, reconnecting.");
+            token = newToken || undefined;
+            stopReconnect();
+            const currentSocket = ws;
+            if (currentSocket?.readyState === WebSocket.OPEN ||
+                currentSocket?.readyState === WebSocket.CONNECTING ||
+                currentSocket?.readyState === WebSocket.CLOSING) {
+                currentSocket.close(1000, newToken ? "Token updated, reconnecting." : "Token cleared.");
                 ws = null;
             }
+            if (!newToken)
+                return;
             connect().catch((err) => {
                 console.warn("WebSocket: Failed to reconnect after token update:", err);
             });
@@ -416,5 +551,6 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         movements: subscribeMovements,
         userOrders: subscribeUserOrders,
         balances: subscribeBalances,
+        conditionalOrders: subscribeConditionalOrders,
     };
 }

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationsAPI, AuthAPI, AuthState, FeesAPI, MarketAPI, MonacoSDK, Network, ProfileAPI, SDKConfig, TradingAPI, VaultAPI } from "@0xmonaco/types";
+import type { ApplicationsAPI, AuthAPI, AuthState, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PositionsAPI, ProfileAPI, SDKConfig, TradingAPI, VaultAPI } from "@0xmonaco/types";
 import { type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
@@ -8,6 +8,8 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     vault: VaultAPI;
     trading: TradingAPI;
     market: MarketAPI;
+    marginAccounts: MarginAccountsAPI;
+    positions: PositionsAPI;
     profile: ProfileAPI;
     orderbook: OrderbookAPIImpl;
     trades: TradesAPIImpl;
@@ -31,8 +33,8 @@ export declare class MonacoSDKImpl implements MonacoSDK {
      * - `expiresAt`: When the access token expires
      * - `user`: User information
      *
-     * Note: There is NO separate `revokeToken` property. Use `authState.refreshToken`
-     * when calling `auth.revokeToken()` or just call `sdk.logout()`.
+     * Note: Use `sdk.logout()` to revoke the token and clean up, or call
+     * `sdk.auth.revokeToken()` directly to just revoke.
      *
      * @param clientId - The client ID for authentication
      * @param options - Optional configuration
@@ -50,7 +52,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
      * await sdk.ws.connect();
      *
      * // Later, to revoke:
-     * await sdk.auth.revokeToken(authState.refreshToken); // ✅
+     * await sdk.auth.revokeToken(); // ✅
      * // Or revoke and disconnect WebSocket:
      * await sdk.logout(); // ✅ Calls revokeToken internally and disconnects WebSocket
      * ```
@@ -76,7 +78,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
      *
      * This method revokes the refresh token (if available), disconnects all authenticated
      * WebSocket channels, and clears the local auth state.
-     * It internally calls `auth.revokeToken(refreshToken)` to invalidate the token on the server.
+     * It internally calls `auth.revokeToken()` to invalidate the token on the server.
      *
      * @example
      * ```typescript

package/dist/sdk.js

@@ -4,7 +4,9 @@ import { sei, seiTestnet } from "viem/chains";
 import { ApplicationsAPIImpl, createMonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 import { AuthAPIImpl } from "./api/auth";
 import { FeesAPIImpl } from "./api/fees";
+import { MarginAccountsAPIImpl } from "./api/margin-accounts";
 import { MarketAPIImpl } from "./api/market";
+import { PositionsAPIImpl } from "./api/positions";
 import { ProfileAPIImpl } from "./api/profile";
 import { TradingAPIImpl } from "./api/trading";
 import { VaultAPIImpl } from "./api/vault";
@@ -17,6 +19,8 @@ export class MonacoSDKImpl {
     vault;
     trading;
     market;
+    marginAccounts;
+    positions;
     profile;
     orderbook;
     trades;
@@ -36,7 +40,11 @@ export class MonacoSDKImpl {
         this.vault.setAccessToken(accessToken);
         this.trading.setAccessToken(accessToken);
         this.market.setAccessToken(accessToken);
+        this.marginAccounts.setAccessToken(accessToken);
+        this.positions.setAccessToken(accessToken);
         this.profile.setAccessToken(accessToken);
+        this.orderbook.setAccessToken(accessToken);
+        this.trades.setAccessToken(accessToken);
         this.ws.setToken(accessToken);
     }
     constructor(cfg) {
@@ -79,6 +87,8 @@ export class MonacoSDKImpl {
         // Instantiate APIs (wallet-dependent APIs will be initialized lazily or error if wallet not set)
         this.applications = new ApplicationsAPIImpl(apiUrl);
         this.market = new MarketAPIImpl(apiUrl);
+        this.marginAccounts = new MarginAccountsAPIImpl(apiUrl);
+        this.positions = new PositionsAPIImpl(apiUrl);
         this.auth = new AuthAPIImpl(this.walletClient, this.chain, apiUrl);
         this.fees = new FeesAPIImpl(apiUrl);
         this.profile = new ProfileAPIImpl(apiUrl);
@@ -99,8 +109,8 @@ export class MonacoSDKImpl {
      * - `expiresAt`: When the access token expires
      * - `user`: User information
      *
-     * Note: There is NO separate `revokeToken` property. Use `authState.refreshToken`
-     * when calling `auth.revokeToken()` or just call `sdk.logout()`.
+     * Note: Use `sdk.logout()` to revoke the token and clean up, or call
+     * `sdk.auth.revokeToken()` directly to just revoke.
      *
      * @param clientId - The client ID for authentication
      * @param options - Optional configuration
@@ -118,7 +128,7 @@ export class MonacoSDKImpl {
      * await sdk.ws.connect();
      *
      * // Later, to revoke:
-     * await sdk.auth.revokeToken(authState.refreshToken); // ✅
+     * await sdk.auth.revokeToken(); // ✅
      * // Or revoke and disconnect WebSocket:
      * await sdk.logout(); // ✅ Calls revokeToken internally and disconnects WebSocket
      * ```
@@ -161,7 +171,7 @@ export class MonacoSDKImpl {
      *
      * This method revokes the refresh token (if available), disconnects all authenticated
      * WebSocket channels, and clears the local auth state.
-     * It internally calls `auth.revokeToken(refreshToken)` to invalidate the token on the server.
+     * It internally calls `auth.revokeToken()` to invalidate the token on the server.
      *
      * @example
      * ```typescript
@@ -172,18 +182,16 @@ export class MonacoSDKImpl {
     async logout() {
         if (this.authState?.refreshToken) {
             try {
-                await this.auth.revokeToken(this.authState.refreshToken);
+                await this.auth.revokeToken();
             }
             catch (error) {
                 // Log but don't throw - we want to clear the local state regardless
                 console.warn("Failed to revoke token on logout:", error);
             }
         }
-        // Disconnect WebSocket if connected
-        if (this.ws.isConnected()) {
-            this.ws.disconnect();
-        }
         this.authState = undefined;
+        this.propagateAccessToken("");
+        this.ws.disconnect();
     }
     /**
      * Refresh the access token