@0xmonaco/types 1.0.74 → 1.0.76

package/dist/validation/margin-accounts.js

@@ -3,11 +3,18 @@
  */
 import { z } from "zod";
 import { MarketSlippageToleranceBpsSchema, OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
-const PaginationSchema = z.object({
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
-    pageSize: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+const CursorPaginationSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would then come back as the first
+     * cursor page every time — the same silent duplicate-page failure the REST
+     * 400 guard exists to prevent (0XM-2788).
+     */
+    page: z.never().optional(),
+    pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
 });
-export const ListMarginAccountsSchema = PaginationSchema.extend({
+export const ListMarginAccountsSchema = CursorPaginationSchema.extend({
     state: z.string().trim().min(1, "State cannot be empty").optional(),
     tradingPairId: UUIDSchema.optional(),
 });
@@ -121,11 +128,11 @@ export const TransferCollateralToRiskBucketSchema = z.object({
 export const TransferCollateralFromParentMarginAccountSchema = z.object({
     request: ParentMarginAccountCollateralRequestSchema,
 });
-export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
+export const GetMarginAccountMovementsSchema = CursorPaginationSchema.extend({
     marginAccountId: UUIDSchema,
     movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 });
-export const GetParentMarginAccountMovementsSchema = PaginationSchema.extend({
+export const GetParentMarginAccountMovementsSchema = CursorPaginationSchema.extend({
     movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 }).optional();
 const BaseSimulateOrderRiskRequestSchema = z.object({
@@ -246,6 +253,10 @@ export const CreateMarginSubAccountSchema = z.object({
 export const CloseMarginSubAccountSchema = z.object({
     marginAccountId: UUIDSchema,
 });
+export const SubAccountCollateralTransferSchema = z.object({
+    marginAccountId: UUIDSchema,
+    amount: PositiveDecimalStringSchema,
+});
 export const GetMarginAccountPnlSchema = z.object({
     marginAccountId: UUIDSchema,
 });

package/dist/validation/market.d.ts

@@ -220,3 +220,48 @@ export declare const SearchTradingPairsSchema: z.ZodObject<{
 export declare const GetMarketMetadataSchema: z.ZodObject<{
     tradingPairId: z.ZodUUID;
 }, z.core.$strip>;
+/** Per-pair funding history; the pair id is path-bound and validated separately. */
+export declare const ListFundingHistorySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    startTime: z.ZodOptional<z.ZodString>;
+    endTime: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+}, z.core.$strip>;
+/** All-markets funding history. */
+export declare const ListAllFundingHistorySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    startTime: z.ZodOptional<z.ZodString>;
+    endTime: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Public trades-feed listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted, but NOT for
+ * the same reason as {@link ListFundingHistorySchema}. That one is built on a
+ * query builder that serializes whatever keys the params object carries, so a
+ * leftover `page` reaches the wire and comes back as the server's `400`.
+ * `getTrades` instead sets `pageSize` and `pageToken` explicitly, so a stray
+ * `page` never leaves the client at all — which makes rejecting it more
+ * important here, not less. Stripped silently, it would leave the caller
+ * requesting page 2, 3, 4 and receiving the FIRST cursor page every time, with
+ * no error from either side to reveal the loop. `z.never()` turns that silent
+ * non-advancing walk into an immediate `ValidationError`.
+ *
+ * The ceiling is the cursor-mode 1000; the historical default of 25 stays.
+ */
+export declare const GetTradesSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/validation/market.js

@@ -224,3 +224,46 @@ export const SearchTradingPairsSchema = z.object({
 export const GetMarketMetadataSchema = z.object({
     tradingPairId: UUIDSchema,
 });
+/**
+ * Funding-history listing validation schemas.
+ *
+ * Cursor paged (0XM-2818). `page` is REJECTED rather than omitted: `withQuery`
+ * builds the query string from `Object.entries(params)`, so an untyped caller's
+ * leftover `page` would otherwise reach the wire and come back as a server
+ * `400` — a round trip to learn what the SDK already knows. Rejecting here
+ * fails the call immediately with a `ValidationError`, and the `deny_unknown_fields`
+ * 400 stays as the server-side backstop.
+ */
+const FundingHistoryCursorSchema = z.object({
+    page: z.never().optional(),
+    startTime: z.string().optional(),
+    endTime: z.string().optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
+    orderBy: z.enum(["ASC", "DESC"], { message: 'orderBy must be "ASC" or "DESC"' }).optional(),
+});
+/** Per-pair funding history; the pair id is path-bound and validated separately. */
+export const ListFundingHistorySchema = FundingHistoryCursorSchema;
+/** All-markets funding history. */
+export const ListAllFundingHistorySchema = FundingHistoryCursorSchema;
+/**
+ * Public trades-feed listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted, but NOT for
+ * the same reason as {@link ListFundingHistorySchema}. That one is built on a
+ * query builder that serializes whatever keys the params object carries, so a
+ * leftover `page` reaches the wire and comes back as the server's `400`.
+ * `getTrades` instead sets `pageSize` and `pageToken` explicitly, so a stray
+ * `page` never leaves the client at all — which makes rejecting it more
+ * important here, not less. Stripped silently, it would leave the caller
+ * requesting page 2, 3, 4 and receiving the FIRST cursor page every time, with
+ * no error from either side to reveal the loop. `z.never()` turns that silent
+ * non-advancing walk into an immediate `ValidationError`.
+ *
+ * The ceiling is the cursor-mode 1000; the historical default of 25 stays.
+ */
+export const GetTradesSchema = z.object({
+    page: z.never().optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
+});

package/dist/validation/positions.d.ts

@@ -3,8 +3,9 @@
  */
 import { z } from "zod";
 export declare const ListPositionsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     status: z.ZodOptional<z.ZodEnum<{
@@ -21,9 +22,9 @@ export declare const ClosePositionSchema: z.ZodObject<{
     positionId: z.ZodUUID;
     request: z.ZodObject<{
         closeType: z.ZodEnum<{
-            IOC: "IOC";
             LIMIT: "LIMIT";
             MARKET: "MARKET";
+            IOC: "IOC";
         }>;
         limitPrice: z.ZodOptional<z.ZodString>;
         slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
@@ -84,8 +85,9 @@ export declare const AttachPositionTpSlSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const ListPositionHistorySchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     positionId: z.ZodOptional<z.ZodUUID>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;

package/dist/validation/positions.js

@@ -3,9 +3,16 @@
  */
 import { z } from "zod";
 import { ConditionalTimeInForceSchema, ISO8601DateSchema, OrderTypeSchema, PositiveDecimalStringSchema, SlippageToleranceBpsSchema, TrailingStopLegSchema, UUIDSchema, } from "./trading";
-const PaginationSchema = z.object({
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
-    pageSize: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+const CursorPaginationSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would then come back as the first
+     * cursor page every time — the same silent duplicate-page failure the REST
+     * 400 guard exists to prevent (0XM-2788).
+     */
+    page: z.never().optional(),
+    pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
 });
 // Filter values accepted by the list-positions endpoint. Narrower than the
 // returned PositionStatus: the backend folds EXPIRED positions under CLOSED, so
@@ -19,7 +26,7 @@ const ClosePositionTypeSchema = z.enum(["MARKET", "LIMIT", "IOC"], {
 const PositionIdSchema = z.object({
     positionId: UUIDSchema,
 });
-export const ListPositionsSchema = PaginationSchema.extend({
+export const ListPositionsSchema = CursorPaginationSchema.extend({
     marginAccountId: UUIDSchema.optional(),
     tradingPairId: UUIDSchema.optional(),
     status: PositionStatusSchema.optional(),
@@ -100,7 +107,7 @@ export const AttachPositionTpSlSchema = PositionIdSchema.extend({
         path: ["oco"],
     }),
 });
-export const ListPositionHistorySchema = PaginationSchema.extend({
+export const ListPositionHistorySchema = CursorPaginationSchema.extend({
     positionId: UUIDSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
     tradingPairId: UUIDSchema.optional(),

package/dist/validation/profile.d.ts

@@ -48,8 +48,13 @@ export declare const SetSelfTradePreventionDefaultSchema: z.ZodObject<{
  * All fields are optional — an empty object or undefined is valid.
  */
 export declare const GetUserMovementsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
     entryType: z.ZodOptional<z.ZodEnum<{
         CREDIT: "CREDIT";
         DEBIT: "DEBIT";
@@ -81,9 +86,21 @@ export declare const GetUserTradesSchema: z.ZodObject<{
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Get User Balances validation schema
+ *
+ * Validates parameters for the cursor-paged balances listing. All fields are
+ * optional — an empty object or undefined is valid.
+ */
+export declare const GetUserBalancesSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const ListFundingPaymentsSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     positionId: z.ZodOptional<z.ZodUUID>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;

package/dist/validation/profile.js

@@ -33,8 +33,16 @@ export const SetSelfTradePreventionDefaultSchema = z.object({
  * All fields are optional — an empty object or undefined is valid.
  */
 export const GetUserMovementsSchema = z.object({
-    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would come back as the first cursor
+     * page every time — the same silent duplicate-page failure the REST 400
+     * guard exists to prevent (0XM-2788).
+     */
+    page: z.never().optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
+    orderBy: z.enum(["ASC", "DESC"]).optional(),
     entryType: LedgerEntryTypeSchema.optional(),
     transactionType: TransactionTypeSchema.optional(),
     assetId: UUIDSchema.optional(),
@@ -57,9 +65,33 @@ export const GetUserTradesSchema = z.object({
     tradingPairId: UUIDSchema.optional(),
     pageToken: z.string().optional(),
 });
+/**
+ * Get User Balances validation schema
+ *
+ * Validates parameters for the cursor-paged balances listing. All fields are
+ * optional — an empty object or undefined is valid.
+ */
+export const GetUserBalancesSchema = z.object({
+    /**
+     * Rejected, not ignored. Without a schema at all a JS or `any` caller's
+     * `page` was silently dropped while building the query string, so the call
+     * resolved with the FIRST cursor page on every request — the quiet
+     * duplicate-page failure the REST 400 guard exists to prevent (0XM-2821).
+     */
+    page: z.never().optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
+});
 export const ListFundingPaymentsSchema = z.object({
-    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any` caller
+     * keep passing `page`, and the request would come back as the first cursor
+     * page every time — the same silent duplicate-page failure the REST 400
+     * guard exists to prevent (0XM-2788).
+     */
+    page: z.never().optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
     tradingPairId: UUIDSchema.optional(),
     positionId: UUIDSchema.optional(),
     marginAccountId: UUIDSchema.optional(),

package/dist/validation/trading.d.ts

@@ -375,11 +375,11 @@ export declare const ConditionalOrderTriggerSourceSchema: z.ZodEnum<{
 export declare const ConditionalOrderStateSchema: z.ZodEnum<{
     CANCELLED: "CANCELLED";
     EXPIRED: "EXPIRED";
-    FAILED: "FAILED";
     PENDING_PARENT: "PENDING_PARENT";
     ACTIVE: "ACTIVE";
     TRIGGERING: "TRIGGERING";
     TRIGGERED: "TRIGGERED";
+    FAILED: "FAILED";
 }>;
 export declare const ClosePositionSideSchema: z.ZodEnum<{
     LONG: "LONG";
@@ -395,11 +395,11 @@ export declare const ListConditionalOrdersSchema: z.ZodObject<{
     state: z.ZodOptional<z.ZodEnum<{
         CANCELLED: "CANCELLED";
         EXPIRED: "EXPIRED";
-        FAILED: "FAILED";
         PENDING_PARENT: "PENDING_PARENT";
         ACTIVE: "ACTIVE";
         TRIGGERING: "TRIGGERING";
         TRIGGERED: "TRIGGERED";
+        FAILED: "FAILED";
     }>>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;

package/dist/validation/vault.d.ts

@@ -75,3 +75,17 @@ export declare const WithdrawSchema: z.ZodObject<{
 export declare const GetBalanceSchema: z.ZodObject<{
     assetId: z.ZodUUID;
 }, z.core.$strip>;
+/**
+ * Pending-withdrawals listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted: the client
+ * forwards the params field by field, which would drop a stray `page` before it
+ * reached the wire, so a JavaScript or `any` caller looping on `{ page: n }`
+ * would be handed the FIRST cursor page on every call and would never advance —
+ * the exact failure the REST 400 exists to surface.
+ */
+export declare const ListPendingWithdrawalsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/validation/vault.js

@@ -86,3 +86,17 @@ export const WithdrawSchema = z.object({
 export const GetBalanceSchema = z.object({
     assetId: UUIDSchema,
 });
+/**
+ * Pending-withdrawals listing validation schema.
+ *
+ * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted: the client
+ * forwards the params field by field, which would drop a stray `page` before it
+ * reached the wire, so a JavaScript or `any` caller looping on `{ page: n }`
+ * would be handed the FIRST cursor page on every call and would never advance —
+ * the exact failure the REST 400 exists to surface.
+ */
+export const ListPendingWithdrawalsSchema = z.object({
+    page: z.never().optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
+    pageToken: z.string().optional(),
+});

package/dist/websocket/base.d.ts

@@ -7,8 +7,40 @@
  * WebSocket connection status
  */
 export type WebSocketStatus = "connected" | "connecting" | "disconnected" | "reconnecting";
-/** Handler invoked whenever the WebSocket connection status changes. */
-export type StatusHandler = (status: WebSocketStatus) => void;
+/**
+ * Connection-attempt context delivered with every status change.
+ *
+ * `"reconnecting"` with `hasConnected: false` means the client has never
+ * reached the server and is still trying (the first connect failed);
+ * `hasConnected: true` means a working connection was lost.
+ */
+export interface WebSocketStatusInfo {
+    /**
+     * The retry this status refers to. `0` for `"connecting"` and
+     * `"connected"`; `1`, `2`, … for `"reconnecting"` (the retry just
+     * scheduled); for `"disconnected"`, the number of retries scheduled in the
+     * outage before it, counting one still in backoff when `disconnect()` is
+     * called (`0` after a clean close of a working connection).
+     */
+    attempt: number;
+    /**
+     * Whether this client has reached the server at least once since it was
+     * created or since the last `disconnect()`.
+     */
+    hasConnected: boolean;
+    /**
+     * Set only on `"reconnecting"`: the delay, in milliseconds, before the
+     * scheduled retry opens its connection.
+     */
+    nextRetryDelayMs?: number;
+}
+/**
+ * Handler invoked whenever the WebSocket connection status changes.
+ *
+ * Inside the handler, `getStatus()` returns the status being reported. A
+ * handler that takes only `status` remains valid.
+ */
+export type StatusHandler = (status: WebSocketStatus, info: WebSocketStatusInfo) => void;
 /**
  * Why the connection was re-established. Delivered by
  * {@link MonacoWebSocketConfig.onResync} after the socket reopens and sends its
@@ -129,9 +161,11 @@ export interface MonacoWebSocketConfig {
     /** Enable auto-reconnect on disconnect (default: true) */
     autoReconnect?: boolean;
     /**
-     * Maximum reconnection attempts (default: unlimited). Retry delay is
-     * full-jitter exponential backoff capped at 30s, so unlimited retries are
-     * capped-rate, not a tight loop.
+     * Maximum reconnection attempts per outage (default: unlimited). Retry
+     * delay is full-jitter exponential backoff capped at 30s, so unlimited
+     * retries are capped-rate, not a tight loop. Once the attempts run out the
+     * client reports `"disconnected"`; a later `connect()` starts a fresh
+     * budget.
      */
     maxReconnectAttempts?: number;
     /** Base delay for the exponential backoff in milliseconds (default: 1000) */
@@ -141,7 +175,23 @@ export interface MonacoWebSocketConfig {
      * retried, in milliseconds (default: 10000)
      */
     connectionTimeoutMs?: number;
-    /** Callback for connection status changes */
+    /**
+     * Called on every connection status change, with the attempt context in
+     * {@link WebSocketStatusInfo}:
+     *
+     * - `"connecting"` — a connection is opening outside a retry cycle: the
+     *   first connect, a `connect()` after a terminal `"disconnected"`, or a
+     *   fresh session's reconnect after terminal authentication loss.
+     * - `"connected"` — the connection opened.
+     * - `"reconnecting"` — a retry is scheduled, once per retry. It holds until
+     *   a retry connects or the retries run out; retries do not report
+     *   `"connecting"`.
+     * - `"disconnected"` — terminal: a clean close, retries exhausted, terminal
+     *   authentication loss, or `disconnect()`.
+     *
+     * An error thrown by this callback, or a rejection of the promise an async
+     * callback returns, is logged and does not affect the connection.
+     */
     onStatusChange?: StatusHandler;
     /**
      * Called after every automatic reconnect sends authentication/subscription

package/dist/websocket/client.d.ts

@@ -52,7 +52,7 @@ import type { Interval } from "../market";
 import type { TradingMode } from "../trading";
 import type { WebSocketStatus } from "./base";
 import type { OrderbookQuotationMode } from "./clients/orderbook-client";
-import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, CopyEvent, CopyRelationshipEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, TradeEvent, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
+import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, CopyEvent, CopyRelationshipEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, PositionValuationEvent, TradeEvent, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
 import type { OrderSnapshotItem, SnapshotHandler } from "./snapshots";
 export type MessageHandler<T> = (data: T) => void;
 export interface MonacoWebSocket {
@@ -84,8 +84,13 @@ export interface MonacoWebSocket {
     conditionalOrders: (handler: MessageHandler<ConditionalOrderEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<ConditionalOrderEventData>) => () => void;
     /** Subscribe to TWAP parent-order lifecycle events (requires authentication) */
     twapOrders: (handler: MessageHandler<TwapOrderEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<TwapOrderEventData>) => () => void;
-    /** Subscribe to position state updates (requires authentication); omit `tradingPairId` for all pairs. `onSnapshot` receives every open position */
-    positions: (handler: MessageHandler<PositionEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<PositionEventData>) => () => void;
+    /**
+     * Subscribe to position state updates (requires authentication); omit `tradingPairId` for all pairs. `onSnapshot` receives every open position.
+     *
+     * `handler` receives lifecycle `position_update` frames only. `onValuation`, when given, receives the periodic `position_valuation`
+     * frames carried on the same channel; without it they are ignored. Apply a valuation only to a position already held as `OPEN`.
+     */
+    positions: (handler: MessageHandler<PositionEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<PositionEventData>, onValuation?: MessageHandler<PositionValuationEvent>) => () => void;
     /** Subscribe to liquidation alerts (requires authentication); omit `tradingPairId` for all pairs */
     liquidations: (handler: MessageHandler<LiquidationEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<LiquidationEventData>) => () => void;
     /** Subscribe to account-level margin health updates for the authenticated user (requires authentication) */

package/dist/websocket/events/index.d.ts

@@ -10,5 +10,6 @@ export * from "./ohlcv-events";
 export * from "./orderbook-events";
 export * from "./orders-events";
 export * from "./position-events";
+export * from "./position-valuation-events";
 export * from "./trade-events";
 export * from "./twap-order-events";

package/dist/websocket/events/index.js

@@ -10,5 +10,6 @@ export * from "./ohlcv-events";
 export * from "./orderbook-events";
 export * from "./orders-events";
 export * from "./position-events";
+export * from "./position-valuation-events";
 export * from "./trade-events";
 export * from "./twap-order-events";

package/dist/websocket/events/instrument-events.d.ts

@@ -15,13 +15,18 @@
  * A subscriber receives a subscribe-time snapshot of the current active-pair
  * configuration list (each frame a `Listing` baseline) before the live diffs.
  *
- * Perp-only fields (`maxLeverage`, `initialMarginRate`, `maintenanceMarginRate`)
+ * Perp-only fields (`minLeverage`, `maxLeverage`, `initialMarginRate`, `maintenanceMarginRate`)
  * are optional and omitted on the wire for spot markets, which have no leverage
  * or margin parameters. All numeric quantities are decimal strings.
  *
  * Every frame (snapshot and live) carries `baseIconUrl` and `quoteIconUrl` for
  * the market's two assets, each `null` when that asset has no icon configured,
  * so a client can render a position's asset icons from the instrument row alone.
+ *
+ * Every frame also carries the market's asset identity: `baseAssetId`,
+ * `quoteAssetId`, `baseToken`, `quoteToken`, `baseAssetName`, `quoteAssetName`,
+ * `baseDecimals` and `quoteDecimals`. Perp frames add `minLeverage`. These are
+ * declared optional because a server that predates them omits them.
  */
 /**
  * The kind of instrument change a frame reports.
@@ -69,6 +74,25 @@ export interface InstrumentEventData {
     marketType: string;
     /** Asset-class category, e.g. "crypto", "equities", "commodities" */
     category: string;
+    /**
+     * Base asset identifier (UUID). The server sends this on every market (spot
+     * and perp); declared optional because an older server omits it.
+     */
+    baseAssetId?: string;
+    /** Quote asset identifier (UUID). See {@link InstrumentEventData.baseAssetId}. */
+    quoteAssetId?: string;
+    /** Base asset ticker symbol, e.g. "BTC". Sent on every market. */
+    baseToken?: string;
+    /** Quote asset ticker symbol, e.g. "USDC". Sent on every market. */
+    quoteToken?: string;
+    /** Base asset display name, e.g. "Bitcoin". Sent on every market. */
+    baseAssetName?: string;
+    /** Quote asset display name, e.g. "USD Coin". Sent on every market. */
+    quoteAssetName?: string;
+    /** Base asset decimals (integer). Sent on every market. */
+    baseDecimals?: number;
+    /** Quote asset decimals (integer). Sent on every market. */
+    quoteDecimals?: number;
     /**
      * Base asset icon URL, or `null` when the asset has no icon configured.
      * The server sends this on every market (spot and perp) as an explicit `null`
@@ -83,6 +107,8 @@ export interface InstrumentEventData {
      * {@link InstrumentEventData.baseIconUrl}.
      */
     quoteIconUrl?: string | null;
+    /** Minimum leverage (decimal string). Perp-only; omitted for spot. */
+    minLeverage?: string;
     /** Maximum leverage (decimal string). Perp-only; omitted for spot. */
     maxLeverage?: string;
     /** Initial margin rate (decimal string). Perp-only; omitted for spot. */

package/dist/websocket/events/instrument-events.js

@@ -15,11 +15,16 @@
  * A subscriber receives a subscribe-time snapshot of the current active-pair
  * configuration list (each frame a `Listing` baseline) before the live diffs.
  *
- * Perp-only fields (`maxLeverage`, `initialMarginRate`, `maintenanceMarginRate`)
+ * Perp-only fields (`minLeverage`, `maxLeverage`, `initialMarginRate`, `maintenanceMarginRate`)
  * are optional and omitted on the wire for spot markets, which have no leverage
  * or margin parameters. All numeric quantities are decimal strings.
  *
  * Every frame (snapshot and live) carries `baseIconUrl` and `quoteIconUrl` for
  * the market's two assets, each `null` when that asset has no icon configured,
  * so a client can render a position's asset icons from the instrument row alone.
+ *
+ * Every frame also carries the market's asset identity: `baseAssetId`,
+ * `quoteAssetId`, `baseToken`, `quoteToken`, `baseAssetName`, `quoteAssetName`,
+ * `baseDecimals` and `quoteDecimals`. Perp frames add `minLeverage`. These are
+ * declared optional because a server that predates them omits them.
  */