@0xmonaco/core 0.6.3 → 0.7.1

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;

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);
@@ -179,11 +189,9 @@ export class MonacoSDKImpl {
                 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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "0.6.3",
+	"version": "0.7.1",
 	"type": "module",
 	"repository": {
 		"type": "git",