@0xmonaco/types 1.0.65 → 1.0.66

package/dist/positions/index.d.ts

@@ -249,16 +249,56 @@ export interface TpSlLeg {
     slippageToleranceBps?: number;
     expiresAt?: string;
 }
+/**
+ * A trailing stop attached to an open position (0XM-2827).
+ *
+ * A reduce-only MARKET close whose trigger trails the best mark price reached
+ * since it armed (the watermark) by `trailBps`: for a long, trigger =
+ * watermark × (1 − trailBps/10000) and it fires when the mark falls to or below
+ * it; a short mirrors it. The trigger only ever moves in the position's
+ * favour. One trailing stop per position — a second attach is rejected with
+ * HTTP 409. It coexists with `takeProfit` / `stopLoss` and never joins `oco`.
+ * There is no modify: cancel and recreate. Fires through the standard
+ * conditional market close (1,200 bps protective band, optional slippage cap).
+ */
+export interface TrailingStopLeg {
+    /** Retracement behind the watermark in basis points; integer, 10 to 2000 inclusive */
+    trailBps: number;
+    /**
+     * Mark level at which tracking starts, seeding the watermark there. Omitted,
+     * tracking starts at the current mark. Rejected if the mark has already
+     * reached it. The row stays `ACTIVE` while waiting and `trailArmedAt` is set
+     * once it arms.
+     */
+    activationPrice?: string;
+    /**
+     * Deliberate partial size that never resizes. Mutually exclusive with
+     * `closePosition: true`; required when `closePosition: false`.
+     */
+    quantity?: string;
+    /**
+     * Resolve the full live position size when triggered. Mutually exclusive
+     * with `quantity`. Omitting both also means full-position close.
+     */
+    closePosition?: boolean;
+    /** Slippage cap for the triggered MARKET close, 0 to 10000 basis points */
+    slippageToleranceBps?: number;
+    /** Optional conditional order expiry timestamp (ISO 8601) */
+    expiresAt?: string;
+}
 export interface AttachPositionTpSlRequest {
     takeProfit?: TpSlLeg;
     stopLoss?: TpSlLeg;
-    /** Cancel the sibling after one leg triggers. Requires both legs. */
+    /** Trailing stop; may be the only leg. Never part of `oco`. */
+    trailingStop?: TrailingStopLeg;
+    /** Cancel the sibling after one leg triggers. Requires both fixed legs. */
     oco?: boolean;
 }
 export interface AttachPositionTpSlResponse {
     positionId: string;
     takeProfitOrderId?: string;
     stopLossOrderId?: string;
+    trailingStopOrderId?: string;
     status: "SUCCESS" | "FAILED";
     message: string;
 }

package/dist/trading/index.d.ts

@@ -6,7 +6,7 @@
 import type { BaseAPI } from "../api/index";
 import type { MarginMode } from "../margin-accounts";
 import type { Order, OrderSide, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode } from "./orders";
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, ParentTpSlLegParams, ReplaceOrderResponse, TwapOrder } from "./responses";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, ParentTpSlLegParams, ParentTrailingStopLegParams, ReplaceOrderResponse, TwapOrder } from "./responses";
 /**
  * Trading API interface.
  * Provides methods for placing and managing orders.
@@ -66,6 +66,8 @@ export interface TradingAPI extends BaseAPI {
         idempotencyKey?: string;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
+        /** Trailing stop that arms when this order fully fills; margin entry orders only. */
+        trailingStop?: ParentTrailingStopLegParams;
     }): Promise<CreateOrderResponse>;
     /**
      * Places a market order for immediate execution.
@@ -110,6 +112,8 @@ export interface TradingAPI extends BaseAPI {
         idempotencyKey?: string;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
+        /** Trailing stop that arms when this order fully fills; margin entry orders only. */
+        trailingStop?: ParentTrailingStopLegParams;
     }): Promise<CreateOrderResponse>;
     /**
      * Cancels an existing order.
@@ -263,4 +267,4 @@ export interface TradingAPI extends BaseAPI {
 }
 export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, ListedOrderType, Order, OrderRole, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState, } from "./orders";
 export { ORDER_STATUS_VALUES } from "./orders";
-export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MatchResult, ParentTpSlLegParams, ReplaceOrderResponse, TriggeredOrderSummary, TwapOrder, UpdatedFields, } from "./responses";
+export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MatchResult, ParentTpSlLegParams, ParentTrailingStopLegParams, ReplaceOrderResponse, TriggeredOrderSummary, TwapOrder, UpdatedFields, } from "./responses";

package/dist/trading/orders.d.ts

@@ -265,9 +265,11 @@ export type TimeInForce = "GTC" | "IOC" | "FOK" | "GTD";
  */
 export type SelfTradePreventionMode = "CANCEL_MAKER" | "CANCEL_TAKER" | "CANCEL_BOTH" | "SKIP";
 /**
- * Conditional TP/SL condition type.
+ * Conditional order condition type: a fixed stop-loss or take-profit, or a
+ * trailing stop whose trigger follows the best mark reached since it armed
+ * (0XM-2827).
  */
-export type ConditionalOrderConditionType = "STOP_LOSS" | "TAKE_PROFIT";
+export type ConditionalOrderConditionType = "STOP_LOSS" | "TAKE_PROFIT" | "TRAILING_STOP";
 /**
  * Conditional order trigger source. v1 supports mark-price triggers.
  */

package/dist/trading/responses.d.ts

@@ -71,6 +71,42 @@ export interface ParentTpSlLegParams {
      */
     closePosition?: boolean;
 }
+/**
+ * A trailing stop attached to a margin entry order at placement (0XM-2827).
+ *
+ * A reduce-only MARKET close whose trigger trails the best mark price reached
+ * since it armed (the watermark) by `trailBps`: for a long, trigger =
+ * watermark × (1 − trailBps/10000) and it fires when the mark falls to or below
+ * it; a short mirrors it. The trigger only ever moves in the position's
+ * favour. It arms only when the entry order FULLY fills and is cancelled with
+ * the order otherwise. One trailing stop per position — a second is rejected
+ * with HTTP 409. It coexists with `takeProfit` / `stopLoss` and never joins
+ * their OCO link. There is no modify: cancel and recreate.
+ */
+export interface ParentTrailingStopLegParams {
+    /** Retracement behind the watermark in basis points; integer, 10 to 2000 inclusive */
+    trailBps: number;
+    /**
+     * Mark level at which tracking starts, seeding the watermark there. Omitted,
+     * tracking starts at the first mark after the fill. Rejected if the mark has
+     * already reached it.
+     */
+    activationPrice?: string;
+    /**
+     * Deliberate partial size that never resizes. Mutually exclusive with
+     * `closePosition: true`; required when `closePosition: false`.
+     */
+    quantity?: string;
+    /**
+     * Resolve the full live position size when triggered. Mutually exclusive
+     * with `quantity`. Omitting both also means full-position close.
+     */
+    closePosition?: boolean;
+    /** Slippage cap for the triggered MARKET close, 0 to 10000 basis points */
+    slippageToleranceBps?: number;
+    /** Optional conditional order expiry timestamp (ISO 8601) */
+    expiresAt?: string;
+}
 /**
  * Response from creating an order.
  *
@@ -99,6 +135,8 @@ export interface CreateOrderResponse {
     takeProfitOrderId?: string;
     /** Conditional order ID for an attached stop-loss leg */
     stopLossOrderId?: string;
+    /** Conditional order ID for an attached trailing stop */
+    trailingStopOrderId?: string;
 }
 /**
  * Response from cancelling an order.
@@ -518,6 +556,29 @@ export interface ConditionalOrder {
     cancelledAt?: string;
     expiresAt?: string;
     failureReason?: string;
+    /**
+     * `TRAILING_STOP` only: retracement in basis points behind the watermark.
+     * Absent on TP/SL rows. Wire: `trailBps`.
+     */
+    trailBps?: number;
+    /**
+     * `TRAILING_STOP` only: the mark level that starts tracking. Absent when the
+     * stop armed immediately. Wire: `activationPrice`.
+     */
+    activationPrice?: string;
+    /**
+     * `TRAILING_STOP` only: best mark (highest for a long, lowest for a short)
+     * observed since arming. `triggerPrice` is derived from it and only ever
+     * moves in the position's favour. Absent until the first mark is observed
+     * after arming. Wire: `watermarkPrice`.
+     */
+    watermarkPrice?: string;
+    /**
+     * `TRAILING_STOP` only: when tracking began (ISO 8601). Absent while the
+     * stop is still waiting for `activationPrice` — `state` stays `ACTIVE` in
+     * both phases. Wire: `trailArmedAt`.
+     */
+    trailArmedAt?: string;
     createdAt: string;
     updatedAt: string;
     /**

package/dist/validation/positions.d.ts

@@ -72,6 +72,14 @@ export declare const AttachPositionTpSlSchema: z.ZodObject<{
             slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
             expiresAt: z.ZodOptional<z.ZodISODateTime>;
         }, z.core.$strip>>;
+        trailingStop: z.ZodOptional<z.ZodObject<{
+            trailBps: z.ZodNumber;
+            activationPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            closePosition: z.ZodOptional<z.ZodBoolean>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
         oco: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
 }, z.core.$strip>;

package/dist/validation/positions.js

@@ -2,7 +2,7 @@
  * Positions API Validation Schemas
  */
 import { z } from "zod";
-import { ConditionalTimeInForceSchema, ISO8601DateSchema, OrderTypeSchema, PositiveDecimalStringSchema, SlippageToleranceBpsSchema, UUIDSchema, } from "./trading";
+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(),
@@ -88,11 +88,13 @@ export const AttachPositionTpSlSchema = PositionIdSchema.extend({
         .object({
         takeProfit: TpSlLegSchema.optional(),
         stopLoss: TpSlLegSchema.optional(),
+        trailingStop: TrailingStopLegSchema.optional(),
         oco: z.boolean().optional(),
     })
-        .refine((data) => data.takeProfit !== undefined || data.stopLoss !== undefined, {
-        message: "At least one of takeProfit or stopLoss is required",
+        .refine((data) => data.takeProfit !== undefined || data.stopLoss !== undefined || data.trailingStop !== undefined, {
+        message: "At least one of takeProfit, stopLoss, or trailingStop is required",
     })
+        // A trailing stop never takes part in OCO: the pair is the two fixed legs.
         .refine((data) => data.oco !== true || (data.takeProfit !== undefined && data.stopLoss !== undefined), {
         message: "oco=true requires both takeProfit and stopLoss",
         path: ["oco"],

package/dist/validation/trading.d.ts

@@ -101,6 +101,31 @@ export declare const ParentTpSlLegSchema: z.ZodObject<{
     slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
     expiresAt: z.ZodOptional<z.ZodISODateTime>;
 }, z.core.$strip>;
+/** Trailing-stop retracement: an integer from 10 to 2000 basis points (0XM-2827). */
+export declare const TrailBpsSchema: z.ZodNumber;
+/**
+ * The trailing-stop leg, shared by the position-attached rail and the
+ * entry-order rail: the shape is identical on both. The close is always a
+ * reduce-only MARKET order, so there is no order type, limit price or time in
+ * force to check — only the ratchet distance, the optional activation level,
+ * the same sizing contract a TP/SL leg carries, and the slippage cap.
+ */
+export declare const TrailingStopLegSchema: z.ZodObject<{
+    trailBps: z.ZodNumber;
+    activationPrice: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodOptional<z.ZodString>;
+    closePosition: z.ZodOptional<z.ZodBoolean>;
+    slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export declare const ParentTrailingStopLegSchema: z.ZodObject<{
+    trailBps: z.ZodNumber;
+    activationPrice: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodOptional<z.ZodString>;
+    closePosition: z.ZodOptional<z.ZodBoolean>;
+    slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
 /**
  * Place Limit Order validation schema
  */
@@ -180,6 +205,14 @@ export declare const PlaceLimitOrderSchema: z.ZodObject<{
             slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
             expiresAt: z.ZodOptional<z.ZodISODateTime>;
         }, z.core.$strip>>;
+        trailingStop: z.ZodOptional<z.ZodObject<{
+            trailBps: z.ZodNumber;
+            activationPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            closePosition: z.ZodOptional<z.ZodBoolean>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
@@ -252,6 +285,14 @@ export declare const PlaceMarketOrderSchema: z.ZodObject<{
             slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
             expiresAt: z.ZodOptional<z.ZodISODateTime>;
         }, z.core.$strip>>;
+        trailingStop: z.ZodOptional<z.ZodObject<{
+            trailBps: z.ZodNumber;
+            activationPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            closePosition: z.ZodOptional<z.ZodBoolean>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
@@ -327,6 +368,7 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
 export declare const ConditionalOrderConditionTypeSchema: z.ZodEnum<{
     STOP_LOSS: "STOP_LOSS";
     TAKE_PROFIT: "TAKE_PROFIT";
+    TRAILING_STOP: "TRAILING_STOP";
 }>;
 export declare const ConditionalOrderTriggerSourceSchema: z.ZodEnum<{
     MARK_PRICE: "MARK_PRICE";

package/dist/validation/trading.js

@@ -138,7 +138,38 @@ export const ParentTpSlLegSchema = z
     message: "quantity is required when closePosition is false",
     path: ["closePosition"],
 });
-const hasParentTpSl = (options) => options?.takeProfit !== undefined || options?.stopLoss !== undefined;
+/** Trailing-stop retracement: an integer from 10 to 2000 basis points (0XM-2827). */
+export const TrailBpsSchema = z
+    .number()
+    .int("trailBps must be an integer number of basis points")
+    .min(10, "trailBps must be at least 10 bps")
+    .max(2000, "trailBps cannot exceed 2000 bps");
+/**
+ * The trailing-stop leg, shared by the position-attached rail and the
+ * entry-order rail: the shape is identical on both. The close is always a
+ * reduce-only MARKET order, so there is no order type, limit price or time in
+ * force to check — only the ratchet distance, the optional activation level,
+ * the same sizing contract a TP/SL leg carries, and the slippage cap.
+ */
+export const TrailingStopLegSchema = z
+    .object({
+    trailBps: TrailBpsSchema,
+    activationPrice: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema.optional(),
+    closePosition: z.boolean().optional(),
+    slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+    expiresAt: ISO8601DateSchema.optional(),
+})
+    .refine((data) => data.closePosition !== true || data.quantity === undefined, {
+    message: "quantity must be omitted when closePosition is true",
+    path: ["quantity"],
+})
+    .refine((data) => data.quantity !== undefined || data.closePosition !== false, {
+    message: "quantity is required when closePosition is false",
+    path: ["closePosition"],
+});
+export const ParentTrailingStopLegSchema = TrailingStopLegSchema;
+const hasParentTpSl = (options) => options?.takeProfit !== undefined || options?.stopLoss !== undefined || options?.trailingStop !== undefined;
 const legacyPositionSideMatchesOrderSide = (side, positionSide) => positionSide === undefined || (positionSide !== "NONE" && ((side === "BUY" && positionSide === "LONG") || (side === "SELL" && positionSide === "SHORT")));
 /**
  * Place Limit Order validation schema
@@ -173,6 +204,7 @@ export const PlaceLimitOrderSchema = z
         selfTradePreventionMode: SelfTradePreventionModeSchema.optional(),
         takeProfit: ParentTpSlLegSchema.optional(),
         stopLoss: ParentTpSlLegSchema.optional(),
+        trailingStop: ParentTrailingStopLegSchema.optional(),
     })
         .optional(),
 })
@@ -185,11 +217,11 @@ export const PlaceLimitOrderSchema = z
     path: ["options", "leverage"],
 })
     .refine((data) => !hasParentTpSl(data.options) || data.options?.tradingMode === "MARGIN", {
-    message: "takeProfit/stopLoss are only supported for MARGIN orders",
+    message: "takeProfit/stopLoss/trailingStop are only supported for MARGIN orders",
     path: ["options"],
 })
     .refine((data) => !hasParentTpSl(data.options) || data.options?.reduceOnly !== true, {
-    message: "takeProfit/stopLoss cannot be attached to reduce-only orders",
+    message: "takeProfit/stopLoss/trailingStop cannot be attached to reduce-only orders",
     path: ["options"],
 })
     .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
@@ -252,6 +284,7 @@ export const PlaceMarketOrderSchema = z
         selfTradePreventionMode: SelfTradePreventionModeSchema.optional(),
         takeProfit: ParentTpSlLegSchema.optional(),
         stopLoss: ParentTpSlLegSchema.optional(),
+        trailingStop: ParentTrailingStopLegSchema.optional(),
     })
         .optional(),
 })
@@ -264,11 +297,11 @@ export const PlaceMarketOrderSchema = z
     path: ["options", "leverage"],
 })
     .refine((data) => !hasParentTpSl(data.options) || data.options?.tradingMode === "MARGIN", {
-    message: "takeProfit/stopLoss are only supported for MARGIN orders",
+    message: "takeProfit/stopLoss/trailingStop are only supported for MARGIN orders",
     path: ["options"],
 })
     .refine((data) => !hasParentTpSl(data.options) || data.options?.reduceOnly !== true, {
-    message: "takeProfit/stopLoss cannot be attached to reduce-only orders",
+    message: "takeProfit/stopLoss/trailingStop cannot be attached to reduce-only orders",
     path: ["options"],
 })
     .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
@@ -372,8 +405,8 @@ export const GetPaginatedOrdersSchema = z
         });
     }
 });
-export const ConditionalOrderConditionTypeSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT"], {
-    message: 'conditionType must be "STOP_LOSS" or "TAKE_PROFIT"',
+export const ConditionalOrderConditionTypeSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT", "TRAILING_STOP"], {
+    message: 'conditionType must be "STOP_LOSS", "TAKE_PROFIT", or "TRAILING_STOP"',
 });
 export const ConditionalOrderTriggerSourceSchema = z.enum(["MARK_PRICE"], {
     message: 'triggerSource must be "MARK_PRICE"',

package/dist/websocket/base.d.ts

@@ -82,9 +82,39 @@ export interface WebSocketErrorInfo {
     code: WebSocketErrorCode | (string & {});
     /** Human-readable description; for logging and display, never for branching. */
     message: string;
+    /**
+     * The channel a per-channel failure concerns, echoed exactly as this client
+     * sent it (an unparseable string included). Present on
+     * `INVALID_SUBSCRIPTION`, `AUTH_REQUIRED`, `SUBSCRIPTION_LIMIT` and
+     * `SNAPSHOT_UNAVAILABLE`; absent on connection-wide failures.
+     *
+     * `Subscribed` / `Unsubscribed` acks list only the channels a request
+     * changed, so a rejected channel is missing from the ack and reported by
+     * its own `Error` frame instead — this is how to pair the two, e.g. to
+     * resync only the channel whose snapshot was unavailable.
+     */
+    channel?: string;
 }
 /** Handler invoked for every `Error` frame the server sends. */
 export type ErrorHandler = (info: WebSocketErrorInfo) => void;
+/**
+ * Why the connection stopped reconnecting and needs fresh credentials.
+ * Delivered by {@link MonacoWebSocketConfig.onReauthenticationRequired}.
+ */
+export interface WebSocketReauthenticationInfo {
+    /**
+     * The `Error` frame code that ended the connection: `SESSION_INVALID` (the
+     * session was revoked or expired after the handshake) or `AUTH_FAILED` (the
+     * `Authenticate` handshake itself was rejected).
+     */
+    code: "SESSION_INVALID" | "AUTH_FAILED";
+    /** Human-readable description from the `Error` frame; for logging and display, never for branching. */
+    message: string;
+    /** WebSocket close code of the connection that was lost (1008 for `SESSION_INVALID`). */
+    closeCode: number;
+}
+/** Handler invoked when the connection lost its authentication terminally. */
+export type ReauthenticationRequiredHandler = (info: WebSocketReauthenticationInfo) => void;
 /**
  * Reconnect/resync knobs and callbacks for the Monaco WebSocket client.
  *
@@ -121,23 +151,47 @@ export interface MonacoWebSocketConfig {
     /**
      * Called for every `Error` frame the server sends on this connection.
      *
-     * `Error` frames are connection-scoped, not channel-scoped, so they reach no
-     * subscription handler — without this callback a failed subscribe, an
-     * invalidated session, or an unreadable subscribe-time snapshot is invisible
-     * to the app. Branch on `code`:
+     * `Error` frames match no subscription, so they reach no channel handler —
+     * without this callback a failed subscribe, an invalidated session, or an
+     * unreadable subscribe-time snapshot is invisible to the app. A failure
+     * caused by one requested channel additionally carries
+     * {@link WebSocketErrorInfo.channel}, the channel string this client sent;
+     * a connection-wide failure carries none. Branch on `code`:
      *
-     * - `SNAPSHOT_UNAVAILABLE` — live diffs flow but the baseline is missing;
-     *   refetch it. The subscription itself is fine.
-     * - `SESSION_INVALID` — re-authenticate rather than reconnect into the same
-     *   rejection.
-     * - `AUTH_REQUIRED` — a rejected SUBSCRIBE, not an invalidated session: the
-     *   channel was never registered, and this client still holds your handler,
-     *   so it treats the channel as subscribed and sends no new `Subscribe`.
-     *   Re-authenticating alone leaves it dead. Release the last handler for the
-     *   channel and subscribe again after authenticating (0XM-2644 tracks doing
-     *   this automatically).
+     * - `SNAPSHOT_UNAVAILABLE` — live diffs flow but that channel's baseline is
+     *   missing; refetch it for `channel` alone. The subscription itself is fine.
+     * - `SESSION_INVALID` — the session was revoked or expired; the connection
+     *   closes and {@link onReauthenticationRequired} follows. No `channel`.
+     * - `AUTH_REQUIRED` — a rejected SUBSCRIBE of `channel`, not an invalidated
+     *   session: it was never registered, and this client still holds your
+     *   handler, so it treats the channel as subscribed and sends no new
+     *   `Subscribe`. Re-authenticating alone leaves it dead. Release the last
+     *   handler for that channel and subscribe again after authenticating
+     *   (0XM-2644 tracks doing this automatically).
      */
     onError?: ErrorHandler;
+    /**
+     * Called once when the connection lost its authentication terminally: the
+     * server invalidated the session (`SESSION_INVALID`, then a 1008 close) or
+     * rejected this connection's `Authenticate` handshake (`AUTH_FAILED`).
+     *
+     * Reconnecting with the same credentials would only be rejected again, so
+     * the client does not reconnect automatically after either. It forgets the
+     * rejected session keypair, keeps your subscription handlers, and reports
+     * `"disconnected"`. Obtain a fresh session and pass it to
+     * `setSessionKeypair` (the SDK's `login` does this): the client reconnects,
+     * authenticates with it, resubscribes every held channel, and fires
+     * {@link onResync} so you can reconcile what was missed — also when
+     * {@link autoReconnect} is off. A session you already replaced before the
+     * close (e.g. from {@link onError}) is kept, and the client reconnects with
+     * it instead of calling this. Supply the fresh session rather than calling
+     * `connect()` first: a session-less socket re-sends user-specific channels
+     * unauthenticated, and the server rejects them with `AUTH_REQUIRED`.
+     *
+     * Every other abnormal close — including a 1008 for exceeding the message
+     * rate cap and a 1013 slow-client shed — keeps the backoff reconnect.
+     */
+    onReauthenticationRequired?: ReauthenticationRequiredHandler;
 }
 /**
  * Raw event message interface

package/dist/websocket/events/conditional-order-events.d.ts

@@ -7,8 +7,13 @@ import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalO
  * wire field is a free-form server string rather than a closed enum, so this
  * alias is documentation and a narrowing aid only. Match on it with a default
  * branch; see `ConditionalOrderEventData.reason`.
+ *
+ * A `TRAILING_STOP` row adds two: `armed` when tracking begins (its
+ * `activationPrice` was reached, or immediately when none was set) and
+ * `ratcheted` on every move of its trigger, carrying the new `triggerPrice`
+ * and the `watermarkPrice` it was derived from (0XM-2827).
  */
-export type ConditionalOrderEventReason = "created" | "activated" | "cancelled" | "parent_cancelled" | "triggered" | "failed" | "oco_cancelled";
+export type ConditionalOrderEventReason = "created" | "activated" | "cancelled" | "parent_cancelled" | "triggered" | "failed" | "oco_cancelled" | "armed" | "ratcheted";
 /**
  * A conditional (TP/SL) order's current state.
  *
@@ -82,6 +87,29 @@ export interface ConditionalOrderEventData {
     cancelledAt?: string;
     expiresAt?: string;
     failureReason?: string;
+    /**
+     * `TRAILING_STOP` only: retracement in basis points behind the watermark.
+     * Absent (`null` on the wire) on TP/SL rows. Wire: `trail_bps`.
+     */
+    trailBps?: number;
+    /**
+     * `TRAILING_STOP` only: the mark level that starts tracking. Absent when the
+     * stop armed immediately. Wire: `activation_price`.
+     */
+    activationPrice?: string;
+    /**
+     * `TRAILING_STOP` only: best mark (highest for a long, lowest for a short)
+     * observed since arming — `triggerPrice` is derived from it and only ever
+     * moves in the position's favour. A `ratcheted` frame carries both. Absent
+     * until the first mark is observed after arming. Wire: `watermark_price`.
+     */
+    watermarkPrice?: string;
+    /**
+     * `TRAILING_STOP` only: when tracking began (ISO 8601). Absent while the
+     * stop is still waiting for `activationPrice` — `state` stays `ACTIVE` in
+     * both phases. Wire: `trail_armed_at`.
+     */
+    trailArmedAt?: string;
     /**
      * What produced this update. Free-form on the wire — the server field is a
      * plain string, not an enum — but a live update's canonical values are the

package/dist/wire/schema.d.ts

@@ -2972,13 +2972,18 @@ export interface components {
             updatedAt?: string | null;
         };
         AttachPositionTpSlRequest: {
+            /**
+             * @description Trailing stop (0XM-2827). May be attached alone or alongside take_profit /
+             *      stop_loss; it never takes part in oco and coexists with fixed legs.
+             */
+            trailingStop?: components["schemas"]["TrailingStopLeg"] | null;
+            takeProfit?: components["schemas"]["TpSlLeg"];
+            stopLoss?: components["schemas"]["TpSlLeg"];
             /**
              * @description One-cancels-the-other. Defaults to false. When true, both take_profit and
              *      stop_loss are required and the sibling is cancelled after either triggers.
              */
             oco?: boolean | null;
-            takeProfit?: components["schemas"]["TpSlLeg"];
-            stopLoss?: components["schemas"]["TpSlLeg"];
         };
         AttachPositionTpSlResponse: {
             positionId?: string | null;
@@ -2986,6 +2991,7 @@ export interface components {
             stopLossOrderId?: string | null;
             status?: string | null;
             message?: string | null;
+            trailingStopOrderId?: string | null;
         };
         BatchCancelAllResponse: {
             /**
@@ -3691,6 +3697,17 @@ export interface components {
             version?: number | null;
             /** @description Present only when state is TRIGGERED: the execution outcome of the order this conditional fired into (triggeredOrderId) — status, filled quantity, volume-weighted average fill price, taker fees and fill time — read from that order at request time. Trigger price and fill price are different numbers: the trigger fires on the mark price and the leg then trades against the book, so a MARKET leg fills at least the half-spread plus its own impact away from triggerPrice, and a LIMIT leg may still be resting (SUBMITTED / PARTIALLY_FILLED) or have been cut by the protective band (CANCELLED with a terminalReason). Absent while waiting on the trigger, on the conditional_orders WebSocket frames, and in the rare case the triggered order cannot be read. */
             triggeredOrder?: components["schemas"]["TriggeredOrderSummary"] | null;
+            /**
+             * Format: int32
+             * @description TRAILING_STOP only: retracement in basis points behind the watermark.
+             */
+            trailBps?: number | null;
+            /** @description TRAILING_STOP only: mark level that starts tracking. Absent when the stop armed immediately. */
+            activationPrice?: string | null;
+            /** @description TRAILING_STOP only: best mark (highest for a long, lowest for a short) observed since arming. triggerPrice is derived from it and only ever moves in the position's favour. Absent until the first mark is observed after arming. */
+            watermarkPrice?: string | null;
+            /** @description TRAILING_STOP only: when tracking began. Absent while the stop is still waiting for activationPrice (state stays ACTIVE in both phases). */
+            trailArmedAt?: string | null;
         };
         CreateDelegatedSessionRequest: {
             /**
@@ -3866,6 +3883,8 @@ export interface components {
              * @enum {string|null}
              */
             selfTradePreventionMode?: "CANCEL_MAKER" | "CANCEL_TAKER" | "CANCEL_BOTH" | "SKIP" | null;
+            /** @description Trailing stop attached to this entry order (margin only). Arms only when the order fully fills; cancelled with the order otherwise. One per position. */
+            trailingStop?: components["schemas"]["ParentTrailingStopLeg"] | null;
         };
         CreateOrderResponse: {
             /**
@@ -3912,6 +3931,11 @@ export interface components {
              * @description Delegated agent UUID when submitted through a delegated session
              */
             delegationId?: string | null;
+            /**
+             * Format: uuid
+             * @description Conditional order id of the trailing stop attached to this entry order, when one was requested
+             */
+            trailingStopOrderId?: string | null;
         };
         CreateTwapOrderRequest: {
             /**
@@ -5570,7 +5594,7 @@ export interface components {
             cumFees?: string | null;
             /**
              * Format: int64
-             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, does restamp the account's open positions), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
              * @example 918342
              */
             version?: number | null;
@@ -6723,6 +6747,46 @@ export interface components {
              */
             closePosition?: boolean | null;
         };
+        /**
+         * @description Trailing stop leg on an entry order (0XM-2827). Same ratchet semantics as
+         *      TrailingStopLeg on the position-attached rail: reduce-only MARKET close,
+         *      trigger trails the watermark by trail_bps in the position's favour, fires
+         *      through the standard conditional market close path.
+         */
+        ParentTrailingStopLeg: {
+            /**
+             * Format: int32
+             * @description Retracement in basis points behind the best mark reached since arming; integer, 10 to 2000 inclusive.
+             * @example 150
+             */
+            trailBps?: number | null;
+            /**
+             * @description Optional mark level that starts tracking once the entry has fully filled. Omit to start tracking at the first mark after the fill. Rejected at attach time if already met by the current mark.
+             * @example 66000
+             */
+            activationPrice?: string | null;
+            /**
+             * @description Deliberate partial size that never resizes. Mutually exclusive with closePosition; omit both to close the full live position at trigger time.
+             * @example 0.5
+             */
+            quantity?: string | null;
+            /**
+             * @description Resolve the full live position size when triggered. Mutually exclusive with quantity.
+             * @example true
+             */
+            closePosition?: boolean | null;
+            /**
+             * Format: int32
+             * @description Slippage cap in basis points for the triggered MARKET close (TP/SL parity).
+             * @example 1000
+             */
+            slippageToleranceBps?: number | null;
+            /**
+             * @description Optional expiry timestamp (ISO 8601)
+             * @example 2026-06-01T00:00:00Z
+             */
+            expiresAt?: string | null;
+        };
         /**
          * @description A single pending withdrawal in a list response. A lightweight summary — the
          *      executable calldata is not included (it does not exist until the withdrawal
@@ -7187,7 +7251,7 @@ export interface components {
             cumFees?: string | null;
             /**
              * Format: int64
-             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, does restamp the account's open positions), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, persists the account's snapshot and restamps the positions it changed), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. The version advances exactly when the row's versioned content changed at that sequence, a change undone within one persistence batch included; a position a command left unchanged keeps its version, so a RANKED live frame for an untouched sibling of a filled position can carry a higher version than the persisted row while describing identical content — rank it as newer, and nothing changes. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
              * @example 918342
              */
             version?: number | null;
@@ -8524,6 +8588,41 @@ export interface components {
              */
             quoteAssetName?: string | null;
         };
+        /**
+         * @description Trailing stop leg (0XM-2827). Reduce-only MARKET close whose trigger trails
+         *      the best mark price reached since it armed (the "watermark") by `trail_bps`:
+         *      for a long, trigger = watermark x (1 - trail_bps/10000) and fires when mark
+         *      falls to or below it; for a short, trigger = watermark x (1 + trail_bps/10000)
+         *      and fires when mark rises to or above it. The trigger only ever moves in the
+         *      position's favour. One trailing stop per position; a second attach is
+         *      rejected with a conflict, never a replace. Fires through the same market
+         *      close path as a TP/SL (1,200 bps protective band, optional slippage cap).
+         */
+        TrailingStopLeg: {
+            /**
+             * Format: int32
+             * @description Retracement in basis points, integer, 10 to 2000 inclusive.
+             */
+            trailBps?: number | null;
+            /**
+             * @description Optional mark level that starts tracking. Omitted: tracking starts
+             *      immediately at the current mark. Present: rejected if the mark has
+             *      already reached it; once reached, the watermark seeds at this level.
+             */
+            activationPrice?: string | null;
+            /**
+             * @description Deliberate partial size; mutually exclusive with close_position. Omit both
+             *      to close the full live position at trigger time. Same contract as TpSlLeg.
+             */
+            quantity?: string | null;
+            closePosition?: boolean | null;
+            /**
+             * Format: int32
+             * @description Slippage cap for the triggered MARKET close, 0 to 10000 bps (TP/SL parity).
+             */
+            slippageToleranceBps?: number | null;
+            expiresAt?: string | null;
+        };
         TransferCollateralFromMarginAccountRequest: {
             /** @description Parent margin account UUID that releases collateral. */
             marginAccountId?: string | null;
@@ -14294,6 +14393,13 @@ export interface operations {
                     "application/json": components["schemas"]["AttachPositionTpSlResponse"];
                 };
             };
+            /** @description Order rate limit exceeded — each attach draws one item from the per-account order-creation budget it shares with order creates (and the budget the account family shares); retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     get_pulse: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.0.65",
+	"version": "1.0.66",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -16,7 +16,7 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.65",
+		"@0xmonaco/contracts": "1.0.66",
 		"zod": "^4.1.12"
 	},
 	"peerDependencies": {