@0xmonaco/core 0.7.7 → 0.7.8

package/dist/api/websocket/websocket.js

@@ -0,0 +1,556 @@
+import { ALL_MAGNITUDES } from "../../utils";
+import { keysToCamelCase } from "./utils";
+// Connection constants
+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
+ */
+export function createMonacoWebSocket(baseUrl, options = {}) {
+    let ws = null;
+    let token = options.token;
+    let reconnectAttempts = 0;
+    let reconnectTimer = null;
+    let heartbeatTimer = null;
+    let autoReconnect = options.autoReconnect ?? true;
+    const maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    // Handler storage: channel -> set of handlers (supports multiple subscribers per channel)
+    const handlers = new Map();
+    const getStatus = () => {
+        if (!ws)
+            return "disconnected";
+        switch (ws.readyState) {
+            case WebSocket.CONNECTING:
+                return "connecting";
+            case WebSocket.OPEN:
+                return "connected";
+            default:
+                return "disconnected";
+        }
+    };
+    const getUrl = () => {
+        const url = new URL(baseUrl);
+        if (token)
+            url.searchParams.set("token", token);
+        return url.toString();
+    };
+    const stopHeartbeat = () => {
+        if (heartbeatTimer) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = null;
+        }
+    };
+    const startHeartbeat = () => {
+        stopHeartbeat();
+        heartbeatTimer = setInterval(() => {
+            if (ws?.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "Ping" }));
+            }
+        }, HEARTBEAT_INTERVAL);
+    };
+    const stopReconnect = () => {
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+    };
+    const scheduleReconnect = () => {
+        if (!autoReconnect || reconnectAttempts >= maxReconnectAttempts) {
+            console.error("WebSocket: Max reconnect attempts reached");
+            return;
+        }
+        reconnectAttempts++;
+        const delay = Math.min(1000 * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY);
+        reconnectTimer = setTimeout(() => {
+            connect().catch((err) => {
+                console.warn("WebSocket: Failed to reconnect:", err);
+            });
+        }, delay);
+    };
+    const send = (data) => {
+        if (ws?.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(data));
+        }
+    };
+    const resubscribeAll = () => {
+        const channels = Array.from(handlers.keys());
+        if (channels.length > 0) {
+            send({ type: "Subscribe", channels });
+        }
+    };
+    const routeMessage = (msg) => {
+        if (msg.type !== "Event" || !msg.channel)
+            return;
+        // Find matching handlers and call all of them
+        for (const [subscriptionChannel, channelHandlers] of handlers) {
+            if (msg.channel === subscriptionChannel || msg.channel.startsWith(`${subscriptionChannel}:`)) {
+                for (const handler of channelHandlers) {
+                    handler(msg.data);
+                }
+            }
+        }
+    };
+    const connect = () => {
+        return new Promise((resolve, reject) => {
+            // Use WebSocket's built-in readyState instead of manual tracking
+            if (ws?.readyState === WebSocket.CONNECTING || ws?.readyState === WebSocket.OPEN) {
+                resolve();
+                return;
+            }
+            try {
+                const socket = new WebSocket(getUrl());
+                ws = socket;
+                const timeout = setTimeout(() => {
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    if (socket.readyState === WebSocket.CONNECTING) {
+                        socket.close(1000, "Connection timeout");
+                        reject(new Error("WebSocket connection timeout"));
+                    }
+                }, CONNECTION_TIMEOUT);
+                socket.onopen = () => {
+                    clearTimeout(timeout);
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    reconnectAttempts = 0;
+                    startHeartbeat();
+                    resubscribeAll();
+                    options.onStatusChange?.("connected");
+                    resolve();
+                };
+                socket.onmessage = (event) => {
+                    if (ws !== socket)
+                        return;
+                    try {
+                        const msg = JSON.parse(event.data);
+                        // Handle pong silently
+                        if (msg.type === "Pong")
+                            return;
+                        routeMessage(msg);
+                    }
+                    catch (err) {
+                        console.warn("WebSocket: Failed to parse message", err);
+                    }
+                };
+                socket.onclose = (event) => {
+                    clearTimeout(timeout);
+                    if (ws !== socket) {
+                        resolve();
+                        return;
+                    }
+                    ws = null;
+                    stopHeartbeat();
+                    options.onStatusChange?.("disconnected");
+                    // Reconnect on abnormal close
+                    if (autoReconnect && event.code !== 1000) {
+                        scheduleReconnect();
+                    }
+                };
+                socket.onerror = () => clearTimeout(timeout);
+            }
+            catch (err) {
+                options.onStatusChange?.("disconnected");
+                reject(err);
+            }
+        });
+    };
+    const disconnect = () => {
+        autoReconnect = false;
+        stopReconnect();
+        stopHeartbeat();
+        handlers.clear();
+        ws?.close(1000, "Client disconnect");
+        ws = null;
+        options.onStatusChange?.("disconnected");
+    };
+    const subscribe = (channel, handler) => {
+        const isFirstSubscriber = !handlers.has(channel);
+        // Add handler to the set for this channel
+        if (!handlers.has(channel)) {
+            handlers.set(channel, new Set());
+        }
+        handlers.get(channel)?.add(handler);
+        // Only send Subscribe message on first subscriber for this channel
+        if (isFirstSubscriber && ws?.readyState === WebSocket.OPEN) {
+            send({ type: "Subscribe", channels: [channel] });
+        }
+        // Return unsubscribe function
+        return () => {
+            const channelHandlers = handlers.get(channel);
+            if (channelHandlers) {
+                channelHandlers.delete(handler);
+                // Only send Unsubscribe on last subscriber for this channel
+                if (channelHandlers.size === 0) {
+                    handlers.delete(channel);
+                    if (ws?.readyState === WebSocket.OPEN) {
+                        send({ type: "Unsubscribe", channels: [channel] });
+                    }
+                }
+            }
+        };
+    };
+    // --- Channel-specific subscription methods ---
+    const subscribeOrders = (tradingPairId, tradingMode, handler) => {
+        const channel = `orders:${tradingPairId}:${tradingMode}`;
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const event = {
+                    orderId: data.order_id,
+                    eventType: data.event_type,
+                    timestamp: data.timestamp,
+                    data: keysToCamelCase(data.data),
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing order event", err);
+            }
+        });
+    };
+    const subscribeOrderbook = (tradingPairId, tradingMode, magnitude, quotationMode, handler) => {
+        if (!tradingPairId || !tradingMode || magnitude === undefined || !quotationMode) {
+            throw new Error(`orderbook subscription requires all params: tradingPairId="${tradingPairId}", tradingMode="${tradingMode}", magnitude=${magnitude} (valid: ${ALL_MAGNITUDES.join(", ")}), quotationMode="${quotationMode}" (valid: "BASE", "QUOTE")`);
+        }
+        if (!ALL_MAGNITUDES.includes(magnitude)) {
+            throw new Error(`Invalid magnitude: ${magnitude}. Must be one of: ${ALL_MAGNITUDES.join(", ")}`);
+        }
+        const channel = `orderbook:${tradingPairId}:${tradingMode}:${magnitude}:${quotationMode.toLowerCase()}`;
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const orderbookData = data.data;
+                const event = {
+                    tradingPairId: data.symbol,
+                    tradingMode: data.trading_mode,
+                    bids: (orderbookData?.bids || []).map((level) => ({
+                        price: level.price,
+                        quantity: level.quantity,
+                        orderCount: level.order_count || 0,
+                    })),
+                    asks: (orderbookData?.asks || []).map((level) => ({
+                        price: level.price,
+                        quantity: level.quantity,
+                        orderCount: level.order_count || 0,
+                    })),
+                    bestBid: orderbookData?.best_bid,
+                    bestAsk: orderbookData?.best_ask,
+                    bidVolume: orderbookData?.bid_volume || undefined,
+                    askVolume: orderbookData?.ask_volume || undefined,
+                    priceChange: orderbookData?.price_change
+                        ? {
+                            side: orderbookData.price_change.side,
+                            oldPrice: orderbookData.price_change.old_price,
+                            newPrice: orderbookData.price_change.new_price,
+                            levelRemoved: orderbookData.price_change.level_removed || false,
+                            levelAdded: orderbookData.price_change.level_added || false,
+                        }
+                        : undefined,
+                    baseDecimals: data.base_decimals || 0,
+                    quoteDecimals: data.quote_decimals || 0,
+                    timestamp: data.timestamp || new Date().toISOString(),
+                    sequence: data.sequence_number || 0,
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing orderbook event", err);
+            }
+        });
+    };
+    const subscribeOHLCV = (tradingPairId, tradingMode, interval, handler) => {
+        const channel = `ohlcv:${tradingPairId}:${tradingMode}:${interval}`;
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const ohlcvData = data.data;
+                const event = {
+                    tradingPairId: data.symbol,
+                    tradingMode: data.trading_mode,
+                    interval: data.interval,
+                    candlestick: {
+                        T: ohlcvData.period_start || 0,
+                        t: ohlcvData.period_end || 0,
+                        o: ohlcvData.open || "0",
+                        h: ohlcvData.high || "0",
+                        l: ohlcvData.low || "0",
+                        c: ohlcvData.close || "0",
+                        v: ohlcvData.volume || "0",
+                        s: data.symbol,
+                        i: data.interval,
+                        n: ohlcvData.trades_count || 0,
+                    },
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing OHLCV event", err);
+            }
+        });
+    };
+    const subscribeTrades = (tradingPairId, handler) => {
+        const channel = `trades:${tradingPairId}`;
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const tradeData = data.data;
+                const event = {
+                    eventType: "trade",
+                    tradingPairId: data.trading_pair_id,
+                    tradingMode: data.trading_mode.toUpperCase(),
+                    data: {
+                        tradeId: tradeData.trade_id,
+                        price: tradeData.price,
+                        quantity: tradeData.quantity,
+                        makerSide: tradeData.maker_side.toUpperCase(),
+                        executedAt: tradeData.executed_at,
+                    },
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing trade event", err);
+            }
+        });
+    };
+    const subscribeMovements = (handler) => {
+        // User is identified from the JWT token, so channel is just "movements"
+        const channel = "movements";
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const movementData = data.data;
+                const event = {
+                    eventType: "movement",
+                    userId: data.user_id,
+                    data: {
+                        id: movementData.id,
+                        entryType: movementData.entry_type,
+                        transactionType: movementData.transaction_type,
+                        tokenAddress: movementData.token_address,
+                        amount: String(movementData.amount),
+                        amountRaw: movementData.amount_raw,
+                        balanceBefore: movementData.balance_before != null ? String(movementData.balance_before) : undefined,
+                        balanceAfter: movementData.balance_after != null ? String(movementData.balance_after) : undefined,
+                        lockedBefore: movementData.locked_before != null ? String(movementData.locked_before) : undefined,
+                        lockedAfter: movementData.locked_after != null ? String(movementData.locked_after) : undefined,
+                        referenceId: movementData.reference_id,
+                        referenceType: movementData.reference_type,
+                        description: movementData.description,
+                        txHash: movementData.tx_hash,
+                        createdAt: movementData.created_at,
+                        decimals: movementData.decimals,
+                    },
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing movement event", err);
+            }
+        });
+    };
+    /**
+     * Subscribe to authenticated user's order events (all trading pairs)
+     * Requires authentication - user is identified from the JWT token
+     */
+    const subscribeUserOrders = (handler) => {
+        // User is identified from the JWT token, so channel is just "orders"
+        const channel = "orders";
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const event = {
+                    orderId: data.order_id,
+                    eventType: data.event_type,
+                    timestamp: data.timestamp,
+                    data: keysToCamelCase(data.data),
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing user order event", err);
+            }
+        });
+    };
+    /**
+     * Subscribe to authenticated user's balance events
+     * Requires authentication - user is identified from the JWT token
+     */
+    const subscribeBalances = (handler) => {
+        // User is identified from the JWT token, so channel is just "balances"
+        const channel = "balances";
+        return subscribe(channel, (rawData) => {
+            try {
+                const data = rawData;
+                const balanceData = data.data;
+                const event = {
+                    eventType: "balance_update",
+                    userId: data.user_id,
+                    data: {
+                        tokenAddress: balanceData.token_address,
+                        tokenSymbol: balanceData.token_symbol,
+                        available: balanceData.available,
+                        availableRaw: balanceData.available_raw,
+                        locked: balanceData.locked,
+                        lockedRaw: balanceData.locked_raw,
+                        total: balanceData.total,
+                        totalRaw: balanceData.total_raw,
+                        reason: balanceData.reason,
+                        referenceId: balanceData.reference_id,
+                        updatedAt: balanceData.updated_at,
+                    },
+                };
+                handler(event);
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing balance event", err);
+            }
+        });
+    };
+    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 || 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);
+            });
+        },
+        orders: subscribeOrders,
+        orderbook: subscribeOrderbook,
+        ohlcv: subscribeOHLCV,
+        trades: subscribeTrades,
+        movements: subscribeMovements,
+        userOrders: subscribeUserOrders,
+        balances: subscribeBalances,
+        conditionalOrders: subscribeConditionalOrders,
+    };
+}