@0xmonaco/core 1.0.40 → 1.0.41-develop.ebb62ed

package/dist/api/market/api.js

@@ -54,6 +54,7 @@ export class MarketAPIImpl extends BaseAPI {
             startTime: params?.startTime,
             endTime: params?.endTime,
             limit: params?.limit,
+            priceType: params?.priceType,
         });
         const searchParams = new URLSearchParams();
         if (params?.startTime !== undefined) {
@@ -65,6 +66,9 @@ export class MarketAPIImpl extends BaseAPI {
         if (params?.limit !== undefined) {
             searchParams.append("limit", params.limit.toString());
         }
+        if (params?.priceType !== undefined) {
+            searchParams.append("priceType", params.priceType);
+        }
         const queryString = searchParams.toString();
         const url = queryString
             ? `/api/v1/market/pairs/charts/candlestick/${encodeURIComponent(tradingPairId)}/${interval}?${queryString}`

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

@@ -88,6 +88,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         leverage?: string;
         reduceOnly?: boolean;
         postOnly?: boolean;
+        clientOrderId?: string;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
     }): Promise<CreateOrderResponse>;
@@ -147,6 +148,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         reduceOnly?: boolean;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
+        clientOrderId?: string;
     }): Promise<CreateOrderResponse>;
     /**
      * Cancels an existing order.
@@ -203,6 +205,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         quantity?: string;
         useMasterBalance?: boolean;
         postOnly?: boolean;
+        clientOrderId?: string;
     }): Promise<ReplaceOrderResponse>;
     /**
      * Batch creates multiple orders in a single request.

package/dist/api/trading/api.js

@@ -34,6 +34,11 @@ function parentTpSlLegToRequest(leg) {
         timeInForce: leg.timeInForce,
         slippageToleranceBps: leg.slippageToleranceBps,
         expiresAt: leg.expiresAt,
+        // The leg's sizing contract. Omitting these sends neither field, which the
+        // server reads as the legacy "size from the parent order" shape — so a
+        // caller asking to track the position would silently get a frozen partial.
+        quantity: leg.quantity,
+        closePosition: leg.closePosition,
     };
 }
 export class TradingAPIImpl extends BaseAPI {
@@ -115,6 +120,7 @@ export class TradingAPIImpl extends BaseAPI {
             leverage: options?.leverage,
             reduceOnly: options?.reduceOnly,
             postOnly: options?.postOnly,
+            clientOrderId: options?.clientOrderId,
             takeProfit: parentTpSlLegToRequest(options?.takeProfit),
             stopLoss: parentTpSlLegToRequest(options?.stopLoss),
         };
@@ -192,6 +198,7 @@ export class TradingAPIImpl extends BaseAPI {
             reduceOnly: options?.reduceOnly,
             takeProfit: parentTpSlLegToRequest(options?.takeProfit),
             stopLoss: parentTpSlLegToRequest(options?.stopLoss),
+            clientOrderId: options?.clientOrderId,
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
@@ -308,6 +315,9 @@ export class TradingAPIImpl extends BaseAPI {
         if (newOrder.postOnly !== undefined) {
             requestBody.postOnly = newOrder.postOnly;
         }
+        if (newOrder.clientOrderId !== undefined) {
+            requestBody.clientOrderId = newOrder.clientOrderId;
+        }
         return await this.makeAuthenticatedRequest(perpRoutes.orders.replace(orderId), {
             method: "PUT",
             body: JSON.stringify(requestBody),
@@ -366,6 +376,7 @@ export class TradingAPIImpl extends BaseAPI {
                 leverage: order.leverage,
                 reduceOnly: order.reduceOnly,
                 postOnly: order.postOnly,
+                clientOrderId: order.clientOrderId,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchCreate(), {
@@ -407,6 +418,7 @@ export class TradingAPIImpl extends BaseAPI {
                 quantity: order.quantity,
                 useMasterBalance: order.useMasterBalance,
                 postOnly: order.postOnly,
+                clientOrderId: order.clientOrderId,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchReplace(), {

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

@@ -1,4 +1,4 @@
-import type { ConditionalOrderEvent, Interval, LiquidationEvent, MonacoWebSocketConfig, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, PositionEvent, SessionCredentials, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
+import type { AccountEvent, ConditionalOrderEvent, Interval, LiquidationEvent, MarketStatsAllEvent, MarketStatsEvent, MonacoWebSocketConfig, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, PositionEvent, SessionCredentials, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
 export type { ResyncHandler, StatusHandler, WebSocketResyncInfo } from "@0xmonaco/types";
 export type MessageHandler<T> = (data: T) => void;
 /**
@@ -42,4 +42,10 @@ export interface MonacoWebSocket {
     positions: (handler: MessageHandler<PositionEvent>, tradingPairId?: string) => () => void;
     /** Subscribe to liquidation alerts (requires authentication); omit `tradingPairId` for all pairs */
     liquidations: (handler: MessageHandler<LiquidationEvent>, tradingPairId?: string) => () => void;
+    /** Subscribe to account-level margin health updates for the authenticated user (requires authentication) */
+    account: (handler: MessageHandler<AccountEvent>) => () => void;
+    /** Subscribe to per-market statistics for one trading pair (public) */
+    marketStats: (tradingPairId: string, handler: MessageHandler<MarketStatsEvent>) => () => void;
+    /** Subscribe to the all-markets statistics summary (public) */
+    marketStatsAll: (handler: MessageHandler<MarketStatsAllEvent>) => () => void;
 }

package/dist/api/websocket/websocket.js

@@ -170,6 +170,104 @@ function parseLiquidationEvent(rawData) {
         },
     };
 }
+function parseAccountEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid account event: payload must be an object");
+    }
+    if (!isRecord(rawData.data)) {
+        throw new Error("Invalid account event: data must be an object");
+    }
+    const data = keysToCamelCase(rawData.data);
+    return {
+        // event_type is the event-class discriminator, validated strictly so a
+        // mis-routed frame is rejected rather than parsed as an account update.
+        eventType: readEnum(rawData, "event_type", ["account_update"]),
+        userId: readString(rawData, "user_id"),
+        data: {
+            marginAccountId: readString(data, "marginAccountId"),
+            equity: readString(data, "equity"),
+            collateral: readString(data, "collateral"),
+            freeCollateral: readString(data, "freeCollateral"),
+            marginRatio: readString(data, "marginRatio"),
+            maintenanceRequirement: readString(data, "maintenanceRequirement"),
+            updatedAt: readString(data, "updatedAt"),
+        },
+    };
+}
+function parseMarketStatsData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid market stats event: data must be an object");
+    }
+    const data = keysToCamelCase(raw);
+    return {
+        symbol: readString(data, "symbol"),
+        tradingPairId: readString(data, "tradingPairId"),
+        indexPrice: readOptionalString(data, "indexPrice"),
+        markPrice: readOptionalString(data, "markPrice"),
+        midPrice: readOptionalString(data, "midPrice"),
+        bestBidPrice: readOptionalString(data, "bestBidPrice"),
+        bestAskPrice: readOptionalString(data, "bestAskPrice"),
+        openInterest: readOptionalString(data, "openInterest"),
+        openInterestLimit: readOptionalString(data, "openInterestLimit"),
+        lastTradePrice: readOptionalString(data, "lastTradePrice"),
+        dailyBaseTokenVolume: readOptionalString(data, "dailyBaseTokenVolume"),
+        dailyQuoteTokenVolume: readOptionalString(data, "dailyQuoteTokenVolume"),
+        dailyPriceLow: readOptionalString(data, "dailyPriceLow"),
+        dailyPriceHigh: readOptionalString(data, "dailyPriceHigh"),
+        dailyPriceChange: readOptionalString(data, "dailyPriceChange"),
+        dailyPriceChangePercent: readOptionalString(data, "dailyPriceChangePercent"),
+        currentFundingRate: readOptionalString(data, "currentFundingRate"),
+        fundingRate: readOptionalString(data, "fundingRate"),
+        fundingTimestamp: readOptionalNumber(data, "fundingTimestamp"),
+        premium: readOptionalString(data, "premium"),
+        baseInterestRate: readOptionalString(data, "baseInterestRate"),
+        fundingClampSmall: readOptionalString(data, "fundingClampSmall"),
+        fundingClampBig: readOptionalString(data, "fundingClampBig"),
+    };
+}
+function parseMarketStatsEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid market stats event: payload must be an object");
+    }
+    // The per-market frame's top-level `trading_pair_id` is not inside `data`, so
+    // it stays snake_case (only `data` is camelCased by parseMarketStatsData).
+    return {
+        tradingPairId: readString(rawData, "trading_pair_id"),
+        data: parseMarketStatsData(rawData.data),
+    };
+}
+function parseMarketStatsSummary(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid market stats summary: entry must be an object");
+    }
+    const data = keysToCamelCase(raw);
+    return {
+        tradingPairId: readString(data, "tradingPairId"),
+        symbol: readString(data, "symbol"),
+        lastTradePrice: readOptionalString(data, "lastTradePrice"),
+        markPrice: readOptionalString(data, "markPrice"),
+        dailyPriceChange: readOptionalString(data, "dailyPriceChange"),
+        dailyPriceChangePercent: readOptionalString(data, "dailyPriceChangePercent"),
+        dailyBaseTokenVolume: readOptionalString(data, "dailyBaseTokenVolume"),
+        dailyQuoteTokenVolume: readOptionalString(data, "dailyQuoteTokenVolume"),
+        dailyPriceHigh: readOptionalString(data, "dailyPriceHigh"),
+        dailyPriceLow: readOptionalString(data, "dailyPriceLow"),
+        openInterest: readOptionalString(data, "openInterest"),
+        currentFundingRate: readOptionalString(data, "currentFundingRate"),
+        fundingTimestamp: readOptionalNumber(data, "fundingTimestamp"),
+        // marketStatus stays lenient (read as string, not a strict enum) so an
+        // unrecognized status value never drops an otherwise-valid summary row.
+        marketStatus: readString(data, "marketStatus"),
+    };
+}
+function parseMarketStatsAllEvent(rawData) {
+    if (!isRecord(rawData) || !Array.isArray(rawData.markets)) {
+        throw new Error("Invalid market stats all event: markets must be an array");
+    }
+    return {
+        markets: rawData.markets.map(parseMarketStatsSummary),
+    };
+}
 /**
  * Create a Monaco WebSocket client
  */
@@ -741,6 +839,72 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
             }
         });
     };
+    /**
+     * Subscribe to the authenticated user's account-level margin health updates
+     * (equity, collateral, free collateral, margin ratio, maintenance
+     * requirement). Requires authentication - the user is identified from the
+     * signed session-key handshake. Lag policy is Conflate: a lagging subscriber
+     * is fast-forwarded, no gap signal. Each frame is a terminal-state snapshot
+     * per margin account, not an additive delta.
+     */
+    const subscribeAccount = (handler) => {
+        if (!handler) {
+            throw new Error("account subscription requires a handler");
+        }
+        return subscribe("account", (rawData) => {
+            try {
+                handler(parseAccountEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing account event", err);
+            }
+        });
+    };
+    /**
+     * Subscribe to per-market statistics for a single trading pair (public). Each
+     * frame carries the market's full current stats as a terminal-state snapshot.
+     * Use {@link subscribeMarketStatsAll} for the all-markets summary instead.
+     */
+    const subscribeMarketStats = (tradingPairId, handler) => {
+        if (!tradingPairId) {
+            throw new Error("marketStats subscription requires a tradingPairId");
+        }
+        if (!handler) {
+            throw new Error("marketStats subscription requires a handler");
+        }
+        return subscribe(`market_stats:${tradingPairId}`, (rawData) => {
+            try {
+                handler(parseMarketStatsEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing market stats event", err);
+            }
+        });
+    };
+    /**
+     * Subscribe to the all-markets statistics summary (public): one summary row
+     * per market in a single frame per push.
+     */
+    const subscribeMarketStatsAll = (handler) => {
+        if (!handler) {
+            throw new Error("marketStatsAll subscription requires a handler");
+        }
+        return subscribe("market_stats", (rawData) => {
+            // routeMessage prefix-matches the bare `market_stats` subscription against
+            // per-market `market_stats:<pair>` frames too; those carry
+            // `{ trading_pair_id, data }`, not `{ markets }`. Drop them here so the
+            // all-markets handler only ever sees all-markets frames.
+            if (!isRecord(rawData) || !Array.isArray(rawData.markets)) {
+                return;
+            }
+            try {
+                handler(parseMarketStatsAllEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing market stats all event", err);
+            }
+        });
+    };
     return {
         connect,
         disconnect,
@@ -771,5 +935,8 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         conditionalOrders: subscribeConditionalOrders,
         positions: subscribePositions,
         liquidations: subscribeLiquidations,
+        account: subscribeAccount,
+        marketStats: subscribeMarketStats,
+        marketStatsAll: subscribeMarketStatsAll,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.40",
+	"version": "1.0.41-develop.ebb62ed",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -23,8 +23,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.40",
-		"@0xmonaco/types": "1.0.40",
+		"@0xmonaco/contracts": "1.0.41-develop.ebb62ed",
+		"@0xmonaco/types": "1.0.41-develop.ebb62ed",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^1.8.0",
 		"http-status-codes": "^2.3.0"