@0xmonaco/core 1.1.2-develop.3a25169 → 1.1.5-develop.129b2c6

package/dist/api/rfq/api.d.ts

@@ -0,0 +1,69 @@
+/**
+ * RFQ (block trading) API Implementation
+ *
+ * A taker requests quotes for a size; makers quote privately; the taker
+ * accepts one side of the best allocation, and each selected maker then has a
+ * short last look (reject or improve; silence executes). Available only to
+ * accounts RFQ is enabled for: other callers get `403` with code
+ * `RFQ_DISABLED`.
+ *
+ * Every call is signed. Every write carries an `idempotencyKey` (generated
+ * when omitted) and is sent as a keyed submission, so a write whose outcome
+ * is unknown is resent with the same key and body and the server replays the
+ * first result. The body is built key by key from validated params, because
+ * the gateway rejects unknown fields and stores a maker's request exactly as
+ * signed.
+ *
+ * @example
+ * ```typescript
+ * // Taker
+ * const rfq = await sdk.rfq.createRfq({ tradingPairId, product: "PERPETUAL", quantity: "25" });
+ * const status = await sdk.rfq.getRfq(rfq.terms!.rfqId);
+ * await sdk.rfq.acceptRfq(rfq.terms!.rfqId, { side: "BUY", viewVersion: status.view!.viewVersion });
+ *
+ * // Maker
+ * const quote = await sdk.rfq.upsertQuote(rfqId, { expectedVersion: 0, ask: { price: "65001", capacity: "10" } });
+ * ```
+ */
+import type { AcceptRfqParams, CancelRfqParams, CreateRfqParams, GetRfqCapabilitiesResponse, RespondRfqLastLookParams, RespondRfqLastLookResponse, RfqAPI, RfqQuoteVersion, RfqStatus, UpsertRfqQuoteParams, WithdrawRfqQuoteParams, WithdrawRfqQuoteResponse } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class RfqAPIImpl extends BaseAPI implements RfqAPI {
+    /** Your RFQ limits and the markets RFQ is offered on. */
+    getCapabilities(): Promise<GetRfqCapabilitiesResponse>;
+    /**
+     * Request quotes for up to `quantity` (not a guaranteed fill). Omit `side`
+     * for a two-way RFQ, whose direction stays hidden from makers; set, makers
+     * see it and may quote only the side that fills it (`terms.quoteSide`). On a perpetual give `leverage`
+     * (and optionally `marginMode`) for the order you accept with, as on an
+     * order. Delegated agents cannot request quotes.
+     */
+    createRfq(params: CreateRfqParams): Promise<RfqStatus>;
+    /**
+     * An RFQ's authoritative status. As taker: the current `view` and, once
+     * executed, the `outcome`. As maker: your latest quote, `ownLatestVersion`
+     * and, once selected, `ownSelection` for last look.
+     */
+    getRfq(rfqId: string): Promise<RfqStatus>;
+    /**
+     * Accept one side of the view you last saw. Binding: the selected makers'
+     * last look follows, and silence executes. A newer view refuses an older
+     * `viewVersion` (409); read the RFQ again and accept the current one.
+     */
+    acceptRfq(rfqId: string, params: AcceptRfqParams): Promise<RfqStatus>;
+    /** Cancel an RFQ you have not accepted, before its deadline. */
+    cancelRfq(rfqId: string, params?: CancelRfqParams): Promise<RfqStatus>;
+    /**
+     * As maker: place or replace your quote, a bid, an ask or both. Name your
+     * current version (`ownLatestVersion`; 0 for your first quote); a stale
+     * version is refused (409).
+     */
+    upsertQuote(rfqId: string, params: UpsertRfqQuoteParams): Promise<RfqQuoteVersion>;
+    /** As maker: withdraw your current quote, naming your current version. */
+    withdrawQuote(rfqId: string, params: WithdrawRfqQuoteParams): Promise<WithdrawRfqQuoteResponse>;
+    /**
+     * As a selected maker: reject, or improve your frozen terms (a strictly
+     * better price or a higher capacity), before the last-look deadline. There
+     * is no accept: silence executes.
+     */
+    respondLastLook(rfqId: string, params: RespondRfqLastLookParams): Promise<RespondRfqLastLookResponse>;
+}

package/dist/api/rfq/api.js

@@ -0,0 +1,129 @@
+/**
+ * RFQ (block trading) API Implementation
+ *
+ * A taker requests quotes for a size; makers quote privately; the taker
+ * accepts one side of the best allocation, and each selected maker then has a
+ * short last look (reject or improve; silence executes). Available only to
+ * accounts RFQ is enabled for: other callers get `403` with code
+ * `RFQ_DISABLED`.
+ *
+ * Every call is signed. Every write carries an `idempotencyKey` (generated
+ * when omitted) and is sent as a keyed submission, so a write whose outcome
+ * is unknown is resent with the same key and body and the server replays the
+ * first result. The body is built key by key from validated params, because
+ * the gateway rejects unknown fields and stores a maker's request exactly as
+ * signed.
+ *
+ * @example
+ * ```typescript
+ * // Taker
+ * const rfq = await sdk.rfq.createRfq({ tradingPairId, product: "PERPETUAL", quantity: "25" });
+ * const status = await sdk.rfq.getRfq(rfq.terms!.rfqId);
+ * await sdk.rfq.acceptRfq(rfq.terms!.rfqId, { side: "BUY", viewVersion: status.view!.viewVersion });
+ *
+ * // Maker
+ * const quote = await sdk.rfq.upsertQuote(rfqId, { expectedVersion: 0, ask: { price: "65001", capacity: "10" } });
+ * ```
+ */
+import { AcceptRfqSchema, CancelRfqSchema, CreateRfqSchema, RespondRfqLastLookSchema, UpsertRfqQuoteSchema, UUIDSchema, validate, WithdrawRfqQuoteSchema, } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+const BASE = "/api/v1/rfqs";
+/** The RFQ path for a validated RFQ id. */
+function rfqPath(rfqId) {
+    return `${BASE}/${validate(UUIDSchema, rfqId)}`;
+}
+/** The caller's key, or a fresh one. */
+function keyOf(idempotencyKey) {
+    return idempotencyKey ?? crypto.randomUUID();
+}
+export class RfqAPIImpl extends BaseAPI {
+    /** Your RFQ limits and the markets RFQ is offered on. */
+    async getCapabilities() {
+        return await this.makeAuthenticatedRequest("/api/v1/rfq/capabilities", { method: "GET" });
+    }
+    /**
+     * Request quotes for up to `quantity` (not a guaranteed fill). Omit `side`
+     * for a two-way RFQ, whose direction stays hidden from makers; set, makers
+     * see it and may quote only the side that fills it (`terms.quoteSide`). On a perpetual give `leverage`
+     * (and optionally `marginMode`) for the order you accept with, as on an
+     * order. Delegated agents cannot request quotes.
+     */
+    async createRfq(params) {
+        const { tradingPairId, product, quantity, side, leverage, marginMode, idempotencyKey } = validate(CreateRfqSchema, params);
+        const body = { idempotencyKey: keyOf(idempotencyKey), tradingPairId, product, quantity };
+        if (side !== undefined)
+            body.side = side;
+        if (leverage !== undefined)
+            body.leverage = leverage;
+        if (marginMode !== undefined)
+            body.marginMode = marginMode;
+        return await this.makeKeyedSubmission(BASE, { method: "POST", body: JSON.stringify(body) });
+    }
+    /**
+     * An RFQ's authoritative status. As taker: the current `view` and, once
+     * executed, the `outcome`. As maker: your latest quote, `ownLatestVersion`
+     * and, once selected, `ownSelection` for last look.
+     */
+    async getRfq(rfqId) {
+        return await this.makeAuthenticatedRequest(rfqPath(rfqId), { method: "GET" });
+    }
+    /**
+     * Accept one side of the view you last saw. Binding: the selected makers'
+     * last look follows, and silence executes. A newer view refuses an older
+     * `viewVersion` (409); read the RFQ again and accept the current one.
+     */
+    async acceptRfq(rfqId, params) {
+        const path = rfqPath(rfqId);
+        const { side, viewVersion, idempotencyKey } = validate(AcceptRfqSchema, params);
+        const body = { idempotencyKey: keyOf(idempotencyKey), side, viewVersion };
+        return await this.makeKeyedSubmission(`${path}/accept`, { method: "POST", body: JSON.stringify(body) });
+    }
+    /** Cancel an RFQ you have not accepted, before its deadline. */
+    async cancelRfq(rfqId, params = {}) {
+        const path = rfqPath(rfqId);
+        const { idempotencyKey } = validate(CancelRfqSchema, params);
+        const body = { idempotencyKey: keyOf(idempotencyKey) };
+        return await this.makeKeyedSubmission(`${path}/cancel`, { method: "POST", body: JSON.stringify(body) });
+    }
+    /**
+     * As maker: place or replace your quote, a bid, an ask or both. Name your
+     * current version (`ownLatestVersion`; 0 for your first quote); a stale
+     * version is refused (409).
+     */
+    async upsertQuote(rfqId, params) {
+        const path = rfqPath(rfqId);
+        const { expectedVersion, bid, ask, validityMs, leverage, marginMode, idempotencyKey } = validate(UpsertRfqQuoteSchema, params);
+        const body = { idempotencyKey: keyOf(idempotencyKey), expectedVersion };
+        if (bid !== undefined)
+            body.bid = { price: bid.price, capacity: bid.capacity };
+        if (ask !== undefined)
+            body.ask = { price: ask.price, capacity: ask.capacity };
+        if (validityMs !== undefined)
+            body.validityMs = validityMs;
+        if (leverage !== undefined)
+            body.leverage = leverage;
+        if (marginMode !== undefined)
+            body.marginMode = marginMode;
+        return await this.makeKeyedSubmission(`${path}/quote`, { method: "PUT", body: JSON.stringify(body) });
+    }
+    /** As maker: withdraw your current quote, naming your current version. */
+    async withdrawQuote(rfqId, params) {
+        const path = rfqPath(rfqId);
+        const { expectedVersion, idempotencyKey } = validate(WithdrawRfqQuoteSchema, params);
+        const body = { idempotencyKey: keyOf(idempotencyKey), expectedVersion };
+        return await this.makeKeyedSubmission(`${path}/quote`, { method: "DELETE", body: JSON.stringify(body) });
+    }
+    /**
+     * As a selected maker: reject, or improve your frozen terms (a strictly
+     * better price or a higher capacity), before the last-look deadline. There
+     * is no accept: silence executes.
+     */
+    async respondLastLook(rfqId, params) {
+        const path = rfqPath(rfqId);
+        const { acceptanceId, response, improvedTerms, idempotencyKey } = validate(RespondRfqLastLookSchema, params);
+        const body = { idempotencyKey: keyOf(idempotencyKey), acceptanceId, response };
+        if (improvedTerms !== undefined)
+            body.improvedTerms = { price: improvedTerms.price, capacity: improvedTerms.capacity };
+        return await this.makeKeyedSubmission(`${path}/last-look`, { method: "POST", body: JSON.stringify(body) });
+    }
+}

package/dist/api/rfq/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RFQ API Module
+ *
+ * Exports the RFQ (block trading) API implementation.
+ */
+export { RfqAPIImpl } from "./api";

package/dist/api/rfq/index.js

@@ -0,0 +1,6 @@
+/**
+ * RFQ API Module
+ *
+ * Exports the RFQ (block trading) API implementation.
+ */
+export { RfqAPIImpl } from "./api";

package/dist/api/trades/api.d.ts

@@ -16,6 +16,13 @@ interface RawTradeEvent {
         makerSide: string;
         /** Absent when the trade has no recorded execution time */
         executedAt?: string;
+        /** CLOB or RFQ */
+        executionSource?: string;
+        makerAddress?: string;
+        takerAddress?: string;
+        takerFeeRaw?: string;
+        quoteVolumeRaw?: string;
+        takerApplicationId?: string;
     };
 }
 /**
@@ -34,6 +41,13 @@ export interface GetTradesOptions {
      */
     pageToken?: string;
 }
+/**
+ * Options for the every-market trade feed.
+ */
+export interface ListTradesOptions extends GetTradesOptions {
+    /** Only the trades this application (frontend) took, as the taker's application. */
+    takerApplicationId?: string;
+}
 /**
  * One page of a pair's trade feed.
  *
@@ -74,6 +88,16 @@ export declare class TradesAPIImpl extends BaseAPI {
      * ```
      */
     getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<GetTradesPage>;
+    /**
+     * Get one page of the trade feed: every market, newest first, recent and
+     * archived trades alike, or only the trades one application took when
+     * `takerApplicationId` is set. Each trade carries both wallets, the raw taker
+     * fee and quote volume, and the taker's application.
+     *
+     * Public; each client IP has a read budget (HTTP 429 over it). Start with no
+     * `pageToken` and follow `nextPageToken` until it comes back empty.
+     */
+    listTrades(options?: ListTradesOptions): Promise<GetTradesPage>;
     /**
      * Get a single trade by its UUID.
      *

package/dist/api/trades/api.js

@@ -1,4 +1,4 @@
-import { GetTradesSchema, validate } from "@0xmonaco/types";
+import { GetTradesSchema, ListTradesSchema, validate } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 /**
@@ -15,6 +15,12 @@ export function parseRawTradeEvent(raw) {
             quantity: raw.data.quantity,
             makerSide: raw.data.makerSide.toUpperCase(),
             executedAt: raw.data.executedAt ?? "",
+            ...(raw.data.executionSource ? { executionSource: raw.data.executionSource } : {}),
+            ...(raw.data.makerAddress ? { makerAddress: raw.data.makerAddress } : {}),
+            ...(raw.data.takerAddress ? { takerAddress: raw.data.takerAddress } : {}),
+            ...(raw.data.takerFeeRaw ? { takerFeeRaw: raw.data.takerFeeRaw } : {}),
+            ...(raw.data.quoteVolumeRaw ? { quoteVolumeRaw: raw.data.quoteVolumeRaw } : {}),
+            ...(raw.data.takerApplicationId ? { takerApplicationId: raw.data.takerApplicationId } : {}),
         },
     };
 }
@@ -67,6 +73,27 @@ export class TradesAPIImpl extends BaseAPI {
             nextPageToken: response.nextPageToken ?? "",
         };
     }
+    /**
+     * Get one page of the trade feed: every market, newest first, recent and
+     * archived trades alike, or only the trades one application took when
+     * `takerApplicationId` is set. Each trade carries both wallets, the raw taker
+     * fee and quote volume, and the taker's application.
+     *
+     * Public; each client IP has a read budget (HTTP 429 over it). Start with no
+     * `pageToken` and follow `nextPageToken` until it comes back empty.
+     */
+    async listTrades(options = {}) {
+        validate(ListTradesSchema, options);
+        const response = await this.makePublicRequest(perpRoutes.trades.feed({
+            ...(options.takerApplicationId ? { takerApplicationId: options.takerApplicationId } : {}),
+            ...(options.pageSize != null ? { pageSize: options.pageSize } : {}),
+            ...(options.pageToken ? { pageToken: options.pageToken } : {}),
+        }));
+        return {
+            trades: (response.trades ?? []).map(parseRawTradeEvent),
+            nextPageToken: response.nextPageToken ?? "",
+        };
+    }
     /**
      * Get a single trade by its UUID.
      *

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

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrderSlicesParams, ListTwapOrderSlicesResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MarginMode, OrderSide, ParentTpSlLegParams, ParentTrailingStopLegParams, PositionSide, ReplaceOrderResponse, SelfTradePreventionMode, TimeInForce, TradingAPI, TradingMode, TwapOrder } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelAllAfterOptions, CancelAllAfterResponse, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrderSlicesParams, ListTwapOrderSlicesResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MarginMode, OrderSide, ParentTpSlLegParams, ParentTrailingStopLegParams, PositionSide, ReplaceOrderResponse, SelfTradePreventionMode, TimeInForce, TradingAPI, TradingMode, TwapOrder } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -41,7 +41,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * @param quantity - The order quantity as string
      * @param price - The limit price as string
      * @param options - Optional parameters for the limit order
-     * @param options.tradingMode - Trading mode (e.g., "SPOT")
+     * @param options.tradingMode - Trading mode ("SPOT" or "MARGIN"). Omit it to use the trading pair market type.
      * @param options.useMasterBalance - Whether to use master balance for sub-accounts
      * @param options.expirationDate - Optional expiration date for GTC orders (ISO 8601 format)
      * @param options.timeInForce - Time in force ("GTC", "IOC", or "FOK")
@@ -115,7 +115,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * @param side - The order side ("BUY" or "SELL")
      * @param quantity - The order quantity as string
      * @param options - Optional parameters for the market order
-     * @param options.tradingMode - Trading mode (e.g., "SPOT")
+     * @param options.tradingMode - Trading mode ("SPOT" or "MARGIN"). Omit it to use the trading pair market type.
      * @param options.slippageTolerance - Tightens the mandatory 1,000 bps price band, as a decimal (e.g., 0.01 for 1%; 0 for best price only). It can only tighten the band, never widen it; omitting it applies the full 1,000 bps band.
      * @returns Promise resolving to CreateOrderResponse with order details
      *
@@ -241,6 +241,38 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     batchCancelAll(tradingPairId?: string): Promise<BatchCancelOrdersResponse>;
+    /**
+     * Arms, refreshes or disarms a dead man's switch.
+     *
+     * Unless you call again before `timeoutMs` runs out, the exchange cancels
+     * your resting orders with terminalReason `CANCEL_ALL_AFTER`. Call it on an
+     * interval shorter than the timeout to keep pushing the deadline out; send
+     * 0 to disarm. A timer that fires is spent, so arm it again afterwards.
+     *
+     * @param timeoutMs - 0 disarms; otherwise 5000 to 900000 (5 s to 15 min)
+     * @param options - Optional `tradingPairId` to scope the timer to one market
+     * @returns Promise resolving to the deadline that was set
+     * @throws {ValidationError} When the timeout or trading pair id is invalid
+     * @throws {APIError} When API communication fails
+     *
+     * @example
+     * ```typescript
+     * // Cancel everything if this process stops refreshing for 30 seconds.
+     * const { cancelAt } = await tradingAPI.cancelAllAfter(30_000);
+     * // One refresh at a time, each after the previous call settles.
+     * let pending: Promise<unknown> = Promise.resolve();
+     * const refresh = setInterval(() => {
+     *   pending = pending.then(() => tradingAPI.cancelAllAfter(30_000)).catch(() => undefined);
+     * }, 10_000);
+     *
+     * // Clean shutdown: let the last refresh settle before disarming, or it
+     * // could land after the disarm and re-arm the timer.
+     * clearInterval(refresh);
+     * await pending;
+     * await tradingAPI.cancelAllAfter(0);
+     * ```
+     */
+    cancelAllAfter(timeoutMs: number, options?: CancelAllAfterOptions): Promise<CancelAllAfterResponse>;
     replaceOrder(orderId: string, newOrder: {
         price?: string;
         quantity?: string;

package/dist/api/trading/api.js

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, CancelTwapOrderSchema, CreateTwapOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, ListTwapOrderSlicesSchema, ListTwapOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
+import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelAllAfterSchema, CancelConditionalOrderSchema, CancelOrderSchema, CancelTwapOrderSchema, CreateTwapOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, ListTwapOrderSlicesSchema, ListTwapOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 function parentTpSlLegToRequest(leg) {
@@ -77,7 +77,7 @@ export class TradingAPIImpl extends BaseAPI {
      * @param quantity - The order quantity as string
      * @param price - The limit price as string
      * @param options - Optional parameters for the limit order
-     * @param options.tradingMode - Trading mode (e.g., "SPOT")
+     * @param options.tradingMode - Trading mode ("SPOT" or "MARGIN"). Omit it to use the trading pair market type.
      * @param options.useMasterBalance - Whether to use master balance for sub-accounts
      * @param options.expirationDate - Optional expiration date for GTC orders (ISO 8601 format)
      * @param options.timeInForce - Time in force ("GTC", "IOC", or "FOK")
@@ -131,7 +131,7 @@ export class TradingAPIImpl extends BaseAPI {
             side,
             price,
             quantity,
-            tradingMode: options?.tradingMode || "SPOT",
+            tradingMode: options?.tradingMode,
             useMasterBalance: options?.useMasterBalance,
             expirationDate: options?.expirationDate,
             timeInForce: options?.timeInForce,
@@ -165,7 +165,7 @@ export class TradingAPIImpl extends BaseAPI {
      * @param side - The order side ("BUY" or "SELL")
      * @param quantity - The order quantity as string
      * @param options - Optional parameters for the market order
-     * @param options.tradingMode - Trading mode (e.g., "SPOT")
+     * @param options.tradingMode - Trading mode ("SPOT" or "MARGIN"). Omit it to use the trading pair market type.
      * @param options.slippageTolerance - Tightens the mandatory 1,000 bps price band, as a decimal (e.g., 0.01 for 1%; 0 for best price only). It can only tighten the band, never widen it; omitting it applies the full 1,000 bps band.
      * @returns Promise resolving to CreateOrderResponse with order details
      *
@@ -211,7 +211,7 @@ export class TradingAPIImpl extends BaseAPI {
             slippageToleranceBps: options?.slippageTolerance !== undefined ? Math.round(options.slippageTolerance * 10000) : undefined,
             price: null, // Market orders don't need price
             quantity,
-            tradingMode: options?.tradingMode || "SPOT",
+            tradingMode: options?.tradingMode,
             marginAccountId: options?.marginAccountId,
             marginMode: options?.marginMode,
             riskBucketId: options?.riskBucketId,
@@ -353,6 +353,48 @@ export class TradingAPIImpl extends BaseAPI {
             method: "POST",
         });
     }
+    /**
+     * Arms, refreshes or disarms a dead man's switch.
+     *
+     * Unless you call again before `timeoutMs` runs out, the exchange cancels
+     * your resting orders with terminalReason `CANCEL_ALL_AFTER`. Call it on an
+     * interval shorter than the timeout to keep pushing the deadline out; send
+     * 0 to disarm. A timer that fires is spent, so arm it again afterwards.
+     *
+     * @param timeoutMs - 0 disarms; otherwise 5000 to 900000 (5 s to 15 min)
+     * @param options - Optional `tradingPairId` to scope the timer to one market
+     * @returns Promise resolving to the deadline that was set
+     * @throws {ValidationError} When the timeout or trading pair id is invalid
+     * @throws {APIError} When API communication fails
+     *
+     * @example
+     * ```typescript
+     * // Cancel everything if this process stops refreshing for 30 seconds.
+     * const { cancelAt } = await tradingAPI.cancelAllAfter(30_000);
+     * // One refresh at a time, each after the previous call settles.
+     * let pending: Promise<unknown> = Promise.resolve();
+     * const refresh = setInterval(() => {
+     *   pending = pending.then(() => tradingAPI.cancelAllAfter(30_000)).catch(() => undefined);
+     * }, 10_000);
+     *
+     * // Clean shutdown: let the last refresh settle before disarming, or it
+     * // could land after the disarm and re-arm the timer.
+     * clearInterval(refresh);
+     * await pending;
+     * await tradingAPI.cancelAllAfter(0);
+     * ```
+     */
+    async cancelAllAfter(timeoutMs, options) {
+        validate(CancelAllAfterSchema, { timeoutMs, options });
+        const body = { timeoutMs };
+        if (options?.tradingPairId !== undefined) {
+            body.tradingPairId = options.tradingPairId;
+        }
+        return this.makeAuthenticatedRequest(perpRoutes.orders.cancelAllAfter(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
     async replaceOrder(orderId, newOrder) {
         // Validate inputs before making API call
         validate(ReplaceOrderSchema, { orderId, newOrder });
@@ -418,7 +460,7 @@ export class TradingAPIImpl extends BaseAPI {
                 side: order.side,
                 price: order.price,
                 quantity: order.quantity,
-                tradingMode: order.tradingMode || "SPOT",
+                tradingMode: order.tradingMode,
                 slippageToleranceBps: order.slippageTolerance !== undefined ? Math.round(order.slippageTolerance * 10000) : undefined,
                 useMasterBalance: order.useMasterBalance,
                 expirationDate: order.expirationDate,
@@ -719,7 +761,7 @@ export class TradingAPIImpl extends BaseAPI {
             slippageToleranceBps: options.slippageToleranceBps,
             randomize: options.randomize,
             reduceOnly: options.reduceOnly,
-            tradingMode: options.tradingMode || "SPOT",
+            tradingMode: options.tradingMode,
             marginAccountId: options.marginAccountId,
             riskBucketId: options.riskBucketId,
             marginMode: options.marginMode,

package/dist/api/websocket/local-book.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Local depth book and BBO state for the market-data `depth` / `bbo`
+ * WebSocket channels (0XM-3551).
+ *
+ * Handoff rules (the server enforces them; the client checks defensively):
+ * - A Snapshot replaces the local state, including mid-stream.
+ * - A frame with `book_seq <=` the current sequence is stale or a duplicate
+ *   and is dropped.
+ * - Every kept frame must have `prev_book_seq <=` the current sequence (the
+ *   snapshot's for the first frame, else the last applied frame's): a delta
+ *   restates every level changed since its link, so it may link below the
+ *   previous frame. A frame that links above it means a lost frame: rebuild
+ *   from a new snapshot.
+ * - A BBO frame carries the whole top of book, so any frame newer than the
+ *   state applies without a link check.
+ * - Frames that arrive before the snapshot are buffered and replayed through
+ *   the same rules once it lands.
+ * - On a side whose snapshot was not complete, levels beyond its deepest
+ *   returned level are unknown, so the book keeps only levels at or better
+ *   than that boundary.
+ *
+ * Sequences are u64 durable-log positions, held as decimal strings and
+ * compared as `BigInt`.
+ */
+import type { Bbo, BboEvent, BboSnapshot, DepthBook, DepthDelta, DepthSnapshot } from "@0xmonaco/types";
+/**
+ * Quote the market-data sequence numbers in a raw frame before `JSON.parse`,
+ * so a u64 above `Number.MAX_SAFE_INTEGER` survives exactly. Only the
+ * unescaped `"book_seq":` / `"prev_book_seq":` keys followed by an integer are
+ * touched; inside a JSON string those quotes would be escaped.
+ */
+export declare function quoteSequenceNumbers(raw: string): string;
+/**
+ * {@link readSequence} that leaves an absent or malformed value `undefined`
+ * instead of throwing. A JSON number counts only while it is still exact (a
+ * quoted integer always does), so a rounded u64 never passes for a precise one.
+ */
+export declare function tryReadSequence(data: Record<string, unknown>, key: string): string | undefined;
+export declare function parseDepthSnapshot(raw: unknown): DepthSnapshot;
+export declare function parseDepthDelta(raw: unknown): DepthDelta;
+export declare function parseBboSnapshot(raw: unknown): BboSnapshot;
+export declare function parseBboEvent(raw: unknown): BboEvent;
+/** Compare two non-negative decimal strings numerically. */
+export declare function compareDecimal(a: string, b: string): number;
+/** The result of offering a frame to the local state. */
+export type FrameOutcome = 
+/** Applied; the state moved forward. */
+"applied"
+/** Held until the snapshot arrives. */
+ | "buffered"
+/** Stale or a duplicate. */
+ | "dropped"
+/** Did not link: a frame was lost. */
+ | "gap"
+/** Applied, but a side whose snapshot was incomplete is now empty: its remainder is unknown. */
+ | "truncated";
+/** The result of applying a snapshot (with any buffered frames replayed). */
+export type SnapshotOutcome = "applied" | "gap" | "truncated";
+/**
+ * The sequence guard shared by `depth` and `bbo`: snapshot replaces, stale
+ * frames drop, a frame linking above the current sequence is a gap, frames
+ * before the snapshot buffer.
+ */
+declare abstract class SequencedState<Snapshot extends {
+    bookSeq: string;
+}, Frame extends {
+    bookSeq: string;
+    prevBookSeq: string;
+}> {
+    private current;
+    private buffered;
+    /**
+     * Whether a frame must link to the current state. Depth deltas carry only
+     * changed levels, so a frame past a lost one is a gap; a BBO frame carries
+     * the whole top of book, so any newer one is complete on its own.
+     */
+    protected readonly checksLinks: boolean;
+    /** Whether a snapshot has been applied since the last reset. */
+    get ready(): boolean;
+    protected abstract resetFrom(snapshot: Snapshot): void;
+    protected abstract applyFrame(frame: Frame): void;
+    /** Whether the state can no longer be trusted past its known levels (see `"truncated"`). */
+    protected truncated(): boolean;
+    /** Replace the state with `snapshot`, then replay buffered frames. Returns `"gap"` if a buffered frame does not link. */
+    applySnapshot(snapshot: Snapshot): SnapshotOutcome;
+    /** Offer a live frame. */
+    offer(frame: Frame): FrameOutcome;
+    /** Discard everything; the next snapshot starts over. */
+    reset(): void;
+}
+/** The local depth book for one `depth` channel. */
+export declare class LocalDepthBook extends SequencedState<DepthSnapshot, DepthDelta> {
+    private readonly bids;
+    private readonly asks;
+    private header;
+    protected resetFrom(snapshot: DepthSnapshot): void;
+    protected applyFrame(frame: DepthDelta): void;
+    protected truncated(): boolean;
+    reset(): void;
+    /** The current book, or `null` before a snapshot. */
+    view(): DepthBook | null;
+}
+/** The local top of book for one `bbo` channel. */
+export declare class LocalBbo extends SequencedState<BboSnapshot, BboEvent> {
+    protected readonly checksLinks = false;
+    private state;
+    protected resetFrom(snapshot: BboSnapshot): void;
+    protected applyFrame(frame: BboEvent): void;
+    reset(): void;
+    view(): Bbo | null;
+}
+export {};