@0xmonaco/types 1.1.2 → 1.1.5-prerelease.de852e2

package/dist/validation/rfq.js

@@ -0,0 +1,120 @@
+/**
+ * RFQ (block trading) validation schemas.
+ *
+ * Client-side checks for the RFQ request params, run before a request is
+ * sent. The server stays the authority on every business rule (market size
+ * rules, deadlines, versions, last-look improvement); these catch malformed
+ * input early and mirror the request shape the REST gateway accepts, which
+ * rejects unknown fields.
+ */
+import { z } from "zod";
+import { MarginModeSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading.js";
+/** The taker's side, or a quote's side as the taker sees it. */
+export const RfqSideSchema = z.enum(["BUY", "SELL"]);
+/** The market product an RFQ trades. */
+export const RfqProductSchema = z.enum(["SPOT", "PERPETUAL"]);
+/**
+ * A client idempotency key: 1-64 letters, digits, or `. _ : -`. A retry with
+ * the same key and body returns the first result. Omitted, the SDK generates
+ * one per call.
+ */
+export const RfqIdempotencyKeySchema = z
+    .string()
+    .regex(/^[A-Za-z0-9._:-]{1,64}$/, "idempotencyKey must be 1-64 letters, digits, or . _ : - without whitespace");
+/** A version a request names (`expectedVersion`, `viewVersion`). */
+const VersionSchema = z.number().int("version must be an integer").min(0, "version cannot be negative");
+/** A quote's price (quote units per base unit) and capacity (base units). */
+export const RfqQuoteTermsSchema = z
+    .object({
+    price: PositiveDecimalStringSchema,
+    capacity: PositiveDecimalStringSchema,
+})
+    .strict();
+/** Params for requesting quotes. */
+export const CreateRfqSchema = z
+    .object({
+    tradingPairId: UUIDSchema,
+    product: RfqProductSchema,
+    /** Maximum base quantity; not a guaranteed fill. */
+    quantity: PositiveDecimalStringSchema,
+    /**
+     * Omit for a two-way RFQ, whose direction stays hidden from makers. Set,
+     * makers see it and may quote only the side that fills it (an ask when
+     * you buy, a bid when you sell).
+     */
+    side: RfqSideSchema.optional(),
+    /**
+     * Perpetuals: the leverage your order takes when you accept, as on an
+     * order (required there, refused on spot). For a two-way RFQ it applies
+     * to whichever side you accept.
+     */
+    leverage: PositiveDecimalStringSchema.optional(),
+    /** Perpetuals: ISOLATED (the default) or CROSS, as on an order. */
+    marginMode: MarginModeSchema.optional(),
+    idempotencyKey: RfqIdempotencyKeySchema.optional(),
+})
+    .strict();
+/** Params for accepting one side of the view the taker last saw. */
+export const AcceptRfqSchema = z
+    .object({
+    side: RfqSideSchema,
+    /** The `view.viewVersion` being accepted; a newer view refuses it. */
+    viewVersion: VersionSchema,
+    idempotencyKey: RfqIdempotencyKeySchema.optional(),
+})
+    .strict();
+/** Params for cancelling an RFQ. */
+export const CancelRfqSchema = z
+    .object({
+    idempotencyKey: RfqIdempotencyKeySchema.optional(),
+})
+    .strict();
+/** Params for placing or replacing a quote: a bid, an ask or both. */
+export const UpsertRfqQuoteSchema = z
+    .object({
+    /** Your current version for this RFQ (`ownLatestVersion`); 0 for your first quote. */
+    expectedVersion: VersionSchema,
+    /** You buying. */
+    bid: RfqQuoteTermsSchema.optional(),
+    /** You selling. */
+    ask: RfqQuoteTermsSchema.optional(),
+    /** 15000-60000 ms; omitted means 60000. Capped at the request deadline. */
+    validityMs: z
+        .number()
+        .int("validityMs must be an integer")
+        .min(15000, "validityMs must be at least 15000")
+        .max(60000, "validityMs cannot exceed 60000")
+        .optional(),
+    /**
+     * Perpetuals: the leverage each side's order reserves with, as on an
+     * order (required there, refused on spot). A quote reserves funds like a
+     * resting limit order; leverage, margin mode and bucket are fixed while a
+     * side rests, so to change them withdraw and quote again.
+     */
+    leverage: PositiveDecimalStringSchema.optional(),
+    /** Perpetuals: ISOLATED (the default) or CROSS, as on an order. */
+    marginMode: MarginModeSchema.optional(),
+    idempotencyKey: RfqIdempotencyKeySchema.optional(),
+})
+    .strict()
+    .refine((params) => params.bid !== undefined || params.ask !== undefined, "a quote needs a bid, an ask or both");
+/** Params for withdrawing your current quote. */
+export const WithdrawRfqQuoteSchema = z
+    .object({
+    /** Your current version for this RFQ. */
+    expectedVersion: VersionSchema,
+    idempotencyKey: RfqIdempotencyKeySchema.optional(),
+})
+    .strict();
+/** Params for answering last look. There is no accept: silence executes. */
+export const RespondRfqLastLookSchema = z
+    .object({
+    /** `ownSelection.acceptanceId` from the RFQ's status. */
+    acceptanceId: UUIDSchema,
+    response: z.enum(["REJECT", "IMPROVE"]),
+    /** IMPROVE only: a strictly better price or a higher capacity than the frozen terms. */
+    improvedTerms: RfqQuoteTermsSchema.optional(),
+    idempotencyKey: RfqIdempotencyKeySchema.optional(),
+})
+    .strict()
+    .refine((params) => (params.response === "IMPROVE") === (params.improvedTerms !== undefined), "improvedTerms is required for IMPROVE and not allowed for REJECT");

package/dist/validation/trading.d.ts

@@ -126,6 +126,21 @@ export declare const ParentTrailingStopLegSchema: z.ZodObject<{
     slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
     expiresAt: z.ZodOptional<z.ZodISODateTime>;
 }, z.core.$strip>;
+/**
+ * An order's `strategyKey` names one of the caller's margin accounts by its
+ * sub-account key (`default` is the default margin account), as
+ * `marginAccountId` names it by id; a copy trading account's `copy:` key names
+ * it too, for the reduce-only close a copy account admits. The server refuses
+ * a key outside the sub-account key alphabet and a key naming none of the
+ * caller's open sub-accounts.
+ */
+export declare const OrderStrategyKeySchema: z.ZodString;
+/**
+ * A risk-bucket transfer's or preview's `strategyKey`: the order rule, and a
+ * reserved `copy:` key is refused (a copy account's risk buckets are funded
+ * by its follow only).
+ */
+export declare const StrategyKeySchema: z.ZodString;
 /**
  * Place Limit Order validation schema
  */
@@ -451,6 +466,15 @@ export declare const CreateTwapOrderSchema: z.ZodObject<{
         conditionalExpiry: z.ZodOptional<z.ZodISODateTime>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/** Bounds of a cancel-all-after timeout; 0 disarms. */
+export declare const CANCEL_ALL_AFTER_MIN_TIMEOUT_MS = 5000;
+export declare const CANCEL_ALL_AFTER_MAX_TIMEOUT_MS = 900000;
+export declare const CancelAllAfterSchema: z.ZodObject<{
+    timeoutMs: z.ZodNumber;
+    options: z.ZodOptional<z.ZodObject<{
+        tradingPairId: z.ZodOptional<z.ZodUUID>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const CancelTwapOrderSchema: z.ZodObject<{
     twapOrderId: z.ZodUUID;
 }, z.core.$strip>;

package/dist/validation/trading.js

@@ -171,6 +171,26 @@ export const TrailingStopLegSchema = z
 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")));
+/**
+ * An order's `strategyKey` names one of the caller's margin accounts by its
+ * sub-account key (`default` is the default margin account), as
+ * `marginAccountId` names it by id; a copy trading account's `copy:` key names
+ * it too, for the reduce-only close a copy account admits. The server refuses
+ * a key outside the sub-account key alphabet and a key naming none of the
+ * caller's open sub-accounts.
+ */
+export const OrderStrategyKeySchema = z
+    .string()
+    .trim()
+    .min(1, "strategyKey cannot be empty")
+    .max(64, "strategyKey must be a sub-account key: letters, digits, _ - . :, up to 64 characters")
+    .regex(/^[A-Za-z0-9_.:-]+$/, "strategyKey must be a sub-account key: letters, digits, _ - . :, up to 64 characters");
+/**
+ * A risk-bucket transfer's or preview's `strategyKey`: the order rule, and a
+ * reserved `copy:` key is refused (a copy account's risk buckets are funded
+ * by its follow only).
+ */
+export const StrategyKeySchema = OrderStrategyKeySchema.refine((key) => !key.toLowerCase().startsWith("copy:"), "strategy keys starting with copy: are reserved");
 /**
  * Place Limit Order validation schema
  */
@@ -196,7 +216,7 @@ export const PlaceLimitOrderSchema = z
         marginMode: MarginModeSchema.optional(),
         riskBucketId: UUIDSchema.optional(),
         riskBucketCollateral: PositiveDecimalStringSchema.optional(),
-        strategyKey: z.string().min(1).max(128).optional(),
+        strategyKey: OrderStrategyKeySchema.optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
         reduceOnly: z.boolean().optional(),
@@ -216,7 +236,7 @@ export const PlaceLimitOrderSchema = z
     message: "leverage is required for normal MARGIN orders",
     path: ["options", "leverage"],
 })
-    .refine((data) => !hasParentTpSl(data.options) || data.options?.tradingMode === "MARGIN", {
+    .refine((data) => !hasParentTpSl(data.options) || data.options?.tradingMode !== "SPOT", {
     message: "takeProfit/stopLoss/trailingStop are only supported for MARGIN orders",
     path: ["options"],
 })
@@ -224,17 +244,13 @@ export const PlaceLimitOrderSchema = z
     message: "takeProfit/stopLoss/trailingStop cannot be attached to reduce-only orders",
     path: ["options"],
 })
-    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode !== "SPOT", {
     message: "riskBucketCollateral is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
 })
-    .refine((data) => data.options?.marginMode === undefined || data.options?.tradingMode === "MARGIN", {
+    .refine((data) => data.options?.marginMode === undefined || data.options?.tradingMode !== "SPOT", {
     message: "marginMode is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
-})
-    .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.marginAccountId !== undefined, {
-    message: "marginAccountId is required for CROSS margin orders",
-    path: ["options", "marginAccountId"],
 })
     .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.riskBucketId === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketId",
@@ -243,10 +259,6 @@ export const PlaceLimitOrderSchema = z
     .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.riskBucketCollateral === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketCollateral",
     path: ["options", "riskBucketCollateral"],
-})
-    .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.strategyKey === undefined, {
-    message: "marginMode CROSS cannot be combined with strategyKey",
-    path: ["options", "strategyKey"],
 })
     .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.riskBucketId === undefined, {
     message: "riskBucketCollateral creates a new risk bucket and cannot be combined with riskBucketId",
@@ -277,7 +289,7 @@ export const PlaceMarketOrderSchema = z
         marginMode: MarginModeSchema.optional(),
         riskBucketId: UUIDSchema.optional(),
         riskBucketCollateral: PositiveDecimalStringSchema.optional(),
-        strategyKey: z.string().min(1).max(128).optional(),
+        strategyKey: OrderStrategyKeySchema.optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
         reduceOnly: z.boolean().optional(),
@@ -296,7 +308,7 @@ export const PlaceMarketOrderSchema = z
     message: "leverage is required for normal MARGIN orders",
     path: ["options", "leverage"],
 })
-    .refine((data) => !hasParentTpSl(data.options) || data.options?.tradingMode === "MARGIN", {
+    .refine((data) => !hasParentTpSl(data.options) || data.options?.tradingMode !== "SPOT", {
     message: "takeProfit/stopLoss/trailingStop are only supported for MARGIN orders",
     path: ["options"],
 })
@@ -304,17 +316,13 @@ export const PlaceMarketOrderSchema = z
     message: "takeProfit/stopLoss/trailingStop cannot be attached to reduce-only orders",
     path: ["options"],
 })
-    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode !== "SPOT", {
     message: "riskBucketCollateral is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
 })
-    .refine((data) => data.options?.marginMode === undefined || data.options?.tradingMode === "MARGIN", {
+    .refine((data) => data.options?.marginMode === undefined || data.options?.tradingMode !== "SPOT", {
     message: "marginMode is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
-})
-    .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.marginAccountId !== undefined, {
-    message: "marginAccountId is required for CROSS margin orders",
-    path: ["options", "marginAccountId"],
 })
     .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.riskBucketId === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketId",
@@ -323,10 +331,6 @@ export const PlaceMarketOrderSchema = z
     .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.riskBucketCollateral === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketCollateral",
     path: ["options", "riskBucketCollateral"],
-})
-    .refine((data) => data.options?.marginMode !== "CROSS" || data.options?.strategyKey === undefined, {
-    message: "marginMode CROSS cannot be combined with strategyKey",
-    path: ["options", "strategyKey"],
 })
     .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.riskBucketId === undefined, {
     message: "riskBucketCollateral creates a new risk bucket and cannot be combined with riskBucketId",
@@ -466,7 +470,7 @@ export const CreateTwapOrderSchema = z
         riskBucketId: UUIDSchema.optional(),
         marginMode: MarginModeSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
-        strategyKey: z.string().min(1).max(128).optional(),
+        strategyKey: OrderStrategyKeySchema.optional(),
         useMasterBalance: z.boolean().optional(),
         clientTwapId: z.string().min(1).max(36, "clientTwapId cannot exceed 36 characters").optional(),
         triggerPrice: PositiveDecimalStringSchema.optional(),
@@ -482,21 +486,17 @@ export const CreateTwapOrderSchema = z
     message: "startTime is only valid together with endTime",
     path: ["options", "startTime"],
 })
-    .refine((data) => data.options.marginMode === undefined || data.options.tradingMode === "MARGIN", {
+    .refine((data) => data.options.marginMode === undefined || data.options.tradingMode !== "SPOT", {
     message: "marginMode is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
 })
-    .refine((data) => data.options.riskBucketId === undefined || data.options.tradingMode === "MARGIN", {
+    .refine((data) => data.options.riskBucketId === undefined || data.options.tradingMode !== "SPOT", {
     message: "riskBucketId is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
 })
     .refine((data) => data.options.marginMode !== "CROSS" || data.options.riskBucketId === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketId",
     path: ["options", "riskBucketId"],
-})
-    .refine((data) => data.options.marginMode !== "CROSS" || data.options.strategyKey === undefined, {
-    message: "marginMode CROSS cannot be combined with strategyKey",
-    path: ["options", "strategyKey"],
 })
     .refine((data) => data.options.tradingMode !== "MARGIN" || data.options.reduceOnly === true || data.options.leverage !== undefined, {
     message: "leverage is required for normal MARGIN TWAP orders",
@@ -544,6 +544,27 @@ export const CreateTwapOrderSchema = z
     message: "conditionalExpiry cannot be more than 30 days after creation (the maximum window)",
     path: ["options", "conditionalExpiry"],
 });
+/** Bounds of a cancel-all-after timeout; 0 disarms. */
+export const CANCEL_ALL_AFTER_MIN_TIMEOUT_MS = 5_000;
+export const CANCEL_ALL_AFTER_MAX_TIMEOUT_MS = 900_000;
+export const CancelAllAfterSchema = z
+    .object({
+    timeoutMs: z
+        .number()
+        .int()
+        .refine((ms) => ms === 0 || (ms >= CANCEL_ALL_AFTER_MIN_TIMEOUT_MS && ms <= CANCEL_ALL_AFTER_MAX_TIMEOUT_MS), {
+        message: `timeoutMs must be 0 or between ${CANCEL_ALL_AFTER_MIN_TIMEOUT_MS} and ${CANCEL_ALL_AFTER_MAX_TIMEOUT_MS}`,
+    }),
+    // Strict: a misspelled scope key must fail rather than be dropped, or the
+    // call would quietly arm the account-wide timer.
+    options: z
+        .object({
+        tradingPairId: UUIDSchema.optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
 export const CancelTwapOrderSchema = z.object({
     twapOrderId: UUIDSchema,
 });
@@ -593,7 +614,7 @@ export const BatchCreateOrderItemSchema = z
     marginMode: MarginModeSchema.optional(),
     riskBucketId: UUIDSchema.optional(),
     riskBucketCollateral: PositiveDecimalStringSchema.optional(),
-    strategyKey: z.string().min(1).max(128).optional(),
+    strategyKey: OrderStrategyKeySchema.optional(),
     positionSide: PositionSideSchema.optional(),
     leverage: PositiveDecimalStringSchema.optional(),
     reduceOnly: z.boolean().optional(),
@@ -620,17 +641,13 @@ export const BatchCreateOrderItemSchema = z
     message: "postOnly cannot be combined with IOC/FOK time in force",
     path: ["postOnly"],
 })
-    .refine((data) => data.riskBucketCollateral === undefined || data.tradingMode === "MARGIN", {
+    .refine((data) => data.riskBucketCollateral === undefined || data.tradingMode !== "SPOT", {
     message: "riskBucketCollateral is only supported for MARGIN orders",
     path: ["tradingMode"],
 })
-    .refine((data) => data.marginMode === undefined || data.tradingMode === "MARGIN", {
+    .refine((data) => data.marginMode === undefined || data.tradingMode !== "SPOT", {
     message: "marginMode is only supported for MARGIN orders",
     path: ["tradingMode"],
-})
-    .refine((data) => data.marginMode !== "CROSS" || data.marginAccountId !== undefined, {
-    message: "marginAccountId is required for CROSS margin orders",
-    path: ["marginAccountId"],
 })
     .refine((data) => data.marginMode !== "CROSS" || data.riskBucketId === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketId",
@@ -639,10 +656,6 @@ export const BatchCreateOrderItemSchema = z
     .refine((data) => data.marginMode !== "CROSS" || data.riskBucketCollateral === undefined, {
     message: "marginMode CROSS cannot be combined with riskBucketCollateral",
     path: ["riskBucketCollateral"],
-})
-    .refine((data) => data.marginMode !== "CROSS" || data.strategyKey === undefined, {
-    message: "marginMode CROSS cannot be combined with strategyKey",
-    path: ["strategyKey"],
 })
     .refine((data) => data.riskBucketCollateral === undefined || data.riskBucketId === undefined, {
     message: "riskBucketCollateral creates a new risk bucket and cannot be combined with riskBucketId",

package/dist/websocket/base.d.ts

@@ -71,23 +71,43 @@ export interface WebSocketStatusInfo {
  */
 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
- * authentication/subscription requests. It does not wait for server acks or
- * snapshots. The application owns channel-specific recovery; the SDK does not
- * automatically refetch REST state.
+ * Why the application should refetch REST state, delivered by
+ * {@link MonacoWebSocketConfig.onResync}. Two cases:
+ *
+ * - A reconnect (`reason` absent): sent after the socket reopens and sends its
+ *   authentication/subscription requests, without waiting for server acks or
+ *   snapshots. Refetch every channel.
+ * - A scoped resync (`reason: "resynced"`, 0XM-3553): the connection stayed
+ *   open, but the server reported that an upstream loss may have cost the
+ *   listed `channels` frames, or re-sent a snapshot for a channel that has no
+ *   snapshot handler. Delivered once per burst, no earlier than the server's
+ *   requested delay, with `code: 1013` and `slowClient: true` so a handler
+ *   written for reconnects still refetches (everything). Refetch only
+ *   `channels` to recover precisely. The subscriptions stay active.
+ *
+ * The application owns channel-specific recovery; the SDK does not refetch
+ * REST state itself.
  */
 export interface WebSocketResyncInfo {
     /** WebSocket close code of the connection that was lost. */
     code: number;
     /**
-     * True when the server closed with 1013 (try again later): the client fell
-     * behind a sequential stream (orders, conditional orders, liquidations,
-     * trades, movements) and the stream has a gap. There is no wire sequence
-     * number — the 1013 close is the gap signal, and a snapshot refetch is the
-     * only safe repair.
+     * True when the server closed with 1013 (try again later): the connection
+     * fell behind, or the server lost events upstream, and any of its streams
+     * may have a gap. Order, account and engine-sourced public streams carry no
+     * wire sequence number, so the 1013 close is their gap signal and a snapshot
+     * refetch is the only safe repair. `depth`, `bbo` and a single market's
+     * market-data-sourced `trades` rebuild from the snapshot the reconnect
+     * brings; `trades:*` has no snapshot, so backfill its history over REST.
      */
     slowClient: boolean;
+    /** `"resynced"` for a scoped resync; absent on a reconnect. */
+    reason?: "resynced";
+    /**
+     * The channels to refetch, exactly as subscribed, on a scoped resync;
+     * absent on a reconnect, which covers every channel.
+     */
+    channels?: string[];
 }
 /** Handler invoked after a reconnect resumes the live stream. */
 export type ResyncHandler = (info: WebSocketResyncInfo) => void;
@@ -135,7 +155,13 @@ export type WebSocketErrorCode =
  * and back off before reconnecting — a hot re-subscribe loop trips the cap
  * again.
  */
- | "MESSAGE_RATE_LIMIT";
+ | "MESSAGE_RATE_LIMIT"
+/**
+ * The `rfq` subscription was refused: RFQ is switched off, or this account
+ * is not on its access list. The same `RFQ_DISABLED` the REST and gRPC RFQ
+ * calls return. The connection stays open.
+ */
+ | "RFQ_DISABLED";
 /**
  * An `Error` frame the server sent on this connection.
  *
@@ -194,6 +220,16 @@ export type ReauthenticationRequiredHandler = (info: WebSocketReauthenticationIn
 export interface MonacoWebSocketConfig {
     /** Enable auto-reconnect on disconnect (default: true) */
     autoReconnect?: boolean;
+    /**
+     * Offer the server the `resync` capability (default: true when
+     * {@link onResync} is set, 0XM-3553; never without it, since the channels
+     * would have nowhere to go): on an
+     * upstream loss it can attribute, the server keeps the connection open and
+     * names the channels to refetch (delivered through {@link onResync} with
+     * `reason: "resynced"`), or re-sends their snapshots, instead of closing it
+     * with 1013. `false` keeps the close-and-reconnect behaviour.
+     */
+    scopedResync?: boolean;
     /**
      * Maximum reconnection attempts per outage (default: unlimited). Retry
      * delay is full-jitter exponential backoff capped at 30s, so unlimited

package/dist/websocket/client.d.ts

@@ -59,8 +59,14 @@ import type { Interval } from "../market";
 import type { TradingMode } from "../trading";
 import type { SubscriptionChangeHandler, WebSocketStatus, WebSocketSubscriptionState } from "./base";
 import type { OrderbookQuotationMode } from "./clients/orderbook-client";
-import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, CopyEvent, CopyRelationshipEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketLiquidationEvent, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, PositionValuationEvent, TradeEvent, TradeEventData, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
+import type { Bbo, DepthBook, LocalBookOptions } from "./depth";
+import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, CopyEvent, CopyRelationshipEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketLiquidationEvent, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, PositionValuationEvent, RfqEvent, RfqTradeEvent, TradeEvent, TradeEventData, TradeGap, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
 import type { OHLCVSnapshotCandle, OrderSnapshotItem, SnapshotHandler } from "./snapshots";
+/** Options for `ws.trades`. */
+export interface TradesOptions {
+    /** Called when a sequenced trade does not link to the last trade delivered (it is still delivered). */
+    onGap?: (gap: TradeGap) => void;
+}
 export type MessageHandler<T> = (data: T) => void;
 export interface MonacoWebSocket {
     /** Connect to the WebSocket server */
@@ -92,10 +98,26 @@ export interface MonacoWebSocket {
     /** Subscribe to order events (requires authentication); `onSnapshot` receives every resting order on the pair */
     orders: (tradingPairId: string, tradingMode: TradingMode, handler: MessageHandler<OrderEvent>, onSnapshot?: SnapshotHandler<OrderSnapshotItem>) => () => void;
     /**
-     * Subscribe to orderbook events (public); `onSnapshot` receives one event, the current book read from the matching
-     * engine, in the same shape as a live event. Its `sequence` is 0. A pair or mode with no book gets `[]`.
+     * Subscribe to orderbook events (public); `onSnapshot` receives one event, the current book, in the same shape as a
+     * live event. From the matching engine it is the top 20 levels with `sequence` 0; from the market-data service it is
+     * grouped over the whole book (at most 20 levels or buckets per side), carries `bookSeq`, and its `sequence` equals
+     * `bookSeq`. From the engine, a pair or mode with no book gets `[]`; from the market-data service, an unknown pair
+     * gets a `SNAPSHOT_UNAVAILABLE` error (through `onError`) instead, and no snapshot until the pair is listed.
      */
     orderbook: (tradingPairId: string, tradingMode: TradingMode, magnitude: number, quotationMode: OrderbookQuotationMode, handler: MessageHandler<OrderbookEvent>, onSnapshot?: SnapshotHandler<OrderbookEvent>) => () => void;
+    /**
+     * Keep a local depth book from the market-data `depth:<tradingPairId>:<SPOT|MARGIN>` channel (public): up to 1000
+     * levels per side. The subscribe-time snapshot is the base; live frames that do not link to it are dropped or
+     * trigger a rebuild from a fresh snapshot. `onBook` receives the whole book after the snapshot and after every
+     * applied frame. Subscribers on the same channel share one book. Returns a function that stops listening.
+     */
+    depth: (tradingPairId: string, tradingMode: TradingMode, onBook: MessageHandler<DepthBook>, options?: LocalBookOptions) => () => void;
+    /**
+     * Keep the top of book from the market-data `bbo:<tradingPairId>:<SPOT|MARGIN>` channel (public), with the same
+     * snapshot handoff and link checks as `depth`. `onBbo` receives the current best bid and ask (an empty side is
+     * `null`) after the snapshot and after every applied frame.
+     */
+    bbo: (tradingPairId: string, tradingMode: TradingMode, onBbo: MessageHandler<Bbo>, options?: LocalBookOptions) => () => void;
     /**
      * Subscribe to OHLCV candlestick events (public); `onSnapshot` receives the series' newest 350 candles, oldest first.
      * The newest snapshot candle can be partial or missing, so upsert live candles by `T`. A `*` price type gets no snapshot.
@@ -104,8 +126,14 @@ export interface MonacoWebSocket {
     /**
      * Subscribe to trade events (public); `onSnapshot` receives the pair's newest 50 trades, newest first.
      * The snapshot can overlap the first live trades or miss one executed just before subscribing, so dedupe on `tradeId`.
+     *
+     * When the server sources trades from market-data, each trade carries `seq` / `matchIndex` / `prevSeq` /
+     * `prevMatchIndex`, and the snapshot's `meta.cursor` names the trade it is current as of. The helper then drops
+     * trades at or below the cursor or the last delivered trade, and reports one that does not link to the last
+     * delivered trade to `options.onGap` (still delivering it: the server forwards only linking trades, so a mismatch
+     * means a frame was lost on this client). Without those fields every trade is delivered as before.
      */
-    trades: (tradingPairId: string, handler: MessageHandler<TradeEvent>, onSnapshot?: SnapshotHandler<TradeEventData>) => () => void;
+    trades: (tradingPairId: string, handler: MessageHandler<TradeEvent>, onSnapshot?: SnapshotHandler<TradeEventData>, options?: TradesOptions) => () => void;
     /** Subscribe to user movement events (requires authentication) */
     movements: (handler: MessageHandler<UserMovementEvent>) => () => void;
     /** Subscribe to user order events for all trading pairs (requires authentication); `onSnapshot` receives every resting order */
@@ -158,4 +186,23 @@ export interface MonacoWebSocket {
     marketStats: (tradingPairId: string, handler: MessageHandler<MarketStatsEvent>, onSnapshot?: SnapshotHandler<MarketStatsData>) => () => void;
     /** Subscribe to the all-markets statistics summary (public) */
     marketStatsAll: (handler: MessageHandler<MarketStatsAllEvent>, onSnapshot?: SnapshotHandler<MarketStatsSummary>) => () => void;
+    /**
+     * Subscribe to RFQ pushes for the authenticated account (requires
+     * authentication): `RfqRequested` for every new RFQ you can quote as a maker
+     * (never your own wallet family's), and for the RFQs you are party to the
+     * taker's `RfqView`, a selected maker's `RfqSelected` (its last-look prompt)
+     * and `RfqOutcome`. Narrow on `eventType` (the wire's `type` tag). There is
+     * no per-pair variant and no
+     * snapshot: a push is a notification, so read a missed RFQ with `getRfq`.
+     * While RFQ is not enabled for the account the subscribe is refused with an
+     * `RFQ_DISABLED` error to `onError`.
+     */
+    rfq: (handler: MessageHandler<RfqEvent>) => () => void;
+    /**
+     * Subscribe to the public, anonymised RFQ block prints for one pair. RFQ
+     * fills never print on `trades`. There is no snapshot: deduplicate on
+     * `data.executionId`, and backfill from the REST trade reads, which include
+     * RFQ fills with `executionSource: "RFQ"`.
+     */
+    rfqTrades: (tradingPairId: string, handler: MessageHandler<RfqTradeEvent>) => () => void;
 }