@0xmonaco/core 1.1.2 → 1.1.5

package/README.md

@@ -118,7 +118,13 @@ async function marketExample() {
   
   // Get specific trading pair
   const btcPair = await monaco.market.getTradingPairBySymbol("BTC/USDC");
-  console.log("BTC pair:", btcPair?.symbol, btcPair?.maker_fee_bps);
+  console.log("BTC pair:", btcPair?.symbol, btcPair?.tickSize);
+
+  // Fee rates are tiered: read the pair's schedule (public) or your own tier
+  if (btcPair) {
+    const { feeSchedule } = await monaco.fees.getFeeSchedule(btcPair.id);
+    console.log("Tier 1 taker fee (bps):", feeSchedule[0]?.takerFeeBps);
+  }
 }
 
 // Vault Operations

package/dist/api/index.d.ts

@@ -20,6 +20,7 @@ export * from "./portfolio";
 export * from "./positions";
 export * from "./profile";
 export * from "./pulse";
+export * from "./rfq";
 export * from "./sub-accounts";
 export * from "./sweeper";
 export * from "./tradercodes";

package/dist/api/index.js

@@ -20,6 +20,7 @@ export * from "./portfolio";
 export * from "./positions";
 export * from "./profile";
 export * from "./pulse";
+export * from "./rfq";
 export * from "./sub-accounts";
 export * from "./sweeper";
 export * from "./tradercodes";

package/dist/api/market/api.d.ts

@@ -1,4 +1,4 @@
-import type { Candlestick, FundingState, GetCandlesticksParams, GetLiquidationMetricsParams, GetScreenerParams, GetScreenerResponse, GetTradeFlowParams, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, LiquidationMetrics, ListAllFundingHistoryParams, ListAllFundingHistoryResponse, ListFundingHistoryParams, ListFundingHistoryResponse, ListLiquidationEventsParams, ListLiquidationEventsResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradeFlow, TraderMetrics, TradingMode, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetLiquidationMetricsParams, GetScreenerParams, GetScreenerResponse, GetTradeFlowParams, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, LiquidationMetrics, ListAllFundingHistoryParams, ListAllFundingHistoryResponse, ListAllLiquidationEventsParams, ListAllLiquidationEventsResponse, ListFundingHistoryParams, ListFundingHistoryResponse, ListInsuranceFundsResponse, ListLiquidationEventsParams, ListLiquidationEventsResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradeFlow, TraderMetrics, TradingMode, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -22,6 +22,8 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getTraderMetrics(tradingPairId: string): Promise<TraderMetrics>;
     getTradeFlow(tradingPairId: string, params: GetTradeFlowParams): Promise<TradeFlow>;
     listLiquidationEvents(tradingPairId: string, params?: ListLiquidationEventsParams): Promise<ListLiquidationEventsResponse>;
+    listAllLiquidationEvents(params?: ListAllLiquidationEventsParams): Promise<ListAllLiquidationEventsResponse>;
+    listInsuranceFunds(): Promise<ListInsuranceFundsResponse>;
     getLiquidationMetrics(tradingPairId: string, params: GetLiquidationMetricsParams): Promise<LiquidationMetrics>;
     getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
     getMarketStats(): Promise<MarketStats>;

package/dist/api/market/api.js

@@ -125,6 +125,15 @@ export class MarketAPIImpl extends BaseAPI {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.listLiquidationEvents(tradingPairId, params));
     }
+    async listAllLiquidationEvents(params) {
+        const response = await this.makePublicRequest(perpRoutes.market.listAllLiquidationEvents(params));
+        // An empty page omits the repeated field and the finished cursor.
+        return { ...response, events: response.events ?? [], nextPageToken: response.nextPageToken ?? "" };
+    }
+    async listInsuranceFunds() {
+        const response = await this.makePublicRequest(perpRoutes.market.listInsuranceFunds());
+        return { funds: response.funds ?? [] };
+    }
     async getLiquidationMetrics(tradingPairId, params) {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.getLiquidationMetrics(tradingPairId, params));

package/dist/api/orderbook/api.d.ts

@@ -5,7 +5,7 @@ export interface GetOrderbookOptions {
     depth?: number;
     /** Trading mode: 'Spot' or 'Margin'. Defaults to 'Spot'. */
     tradingMode?: TradingMode;
-    /** Price grouping magnitude. Valid values: 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000. */
+    /** Price grouping magnitude. Valid values: 0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000. */
     magnitude?: number;
     /** Quantity denomination: 'BASE' or 'QUOTE'. When 'QUOTE', quantities are multiplied by price. */
     denomination?: OrderbookQuotationMode;

package/dist/api/perp/routes.d.ts

@@ -15,6 +15,7 @@ export declare const perpRoutes: {
         readonly batchCancel: () => string;
         readonly batchCancelAll: () => string;
         readonly batchCancelAllByPair: (tradingPairId: string) => string;
+        readonly cancelAllAfter: () => string;
         readonly batchCreate: () => string;
         readonly batchReplace: () => string;
         readonly listConditional: (params?: {
@@ -109,6 +110,13 @@ export declare const perpRoutes: {
             startTime: number;
             endTime: number;
         }) => string;
+        readonly listAllLiquidationEvents: (params?: {
+            startTime?: number;
+            endTime?: number;
+            pageSize?: number;
+            pageToken?: string;
+        }) => string;
+        readonly listInsuranceFunds: () => string;
         readonly getScreener: (params?: {
             page?: number;
             pageSize?: number;
@@ -132,6 +140,11 @@ export declare const perpRoutes: {
             limit?: number;
         }) => string;
         readonly byId: (tradeId: string) => string;
+        readonly feed: (params?: {
+            takerApplicationId?: string;
+            pageSize?: number;
+            pageToken?: string;
+        }) => string;
         readonly user: (params?: {
             marginAccountId?: string;
             tradingPairId?: string;

package/dist/api/perp/routes.js

@@ -24,6 +24,7 @@ export const perpRoutes = {
         batchCancel: () => `${API_V1}/orders/batch-cancel`,
         batchCancelAll: () => `${API_V1}/orders/batch-cancel-all`,
         batchCancelAllByPair: (tradingPairId) => `${API_V1}/orders/batch-cancel-all/${encodeSegment(tradingPairId)}`,
+        cancelAllAfter: () => `${API_V1}/orders/cancel-all-after`,
         batchCreate: () => `${API_V1}/orders/batch-create`,
         batchReplace: () => `${API_V1}/orders/batch-replace`,
         listConditional: (params) => withQuery(`${API_V1}/orders/conditional`, params),
@@ -64,6 +65,8 @@ export const perpRoutes = {
         getTradeFlow: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/trade-flow`, params),
         listLiquidationEvents: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/liquidation-events`, params),
         getLiquidationMetrics: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/liquidation-metrics`, params),
+        listAllLiquidationEvents: (params) => withQuery(`${API_V1}/market/liquidation-events`, params),
+        listInsuranceFunds: () => `${API_V1}/market/insurance-funds`,
         getScreener: (params) => withQuery(`${API_V1}/market/screener`, params),
         getMarketStats: () => `${API_V1}/market/stats`,
     },
@@ -73,6 +76,7 @@ export const perpRoutes = {
     trades: {
         publicByPair: (tradingPairId, params) => withQuery(`${API_V1}/trades/${encodeSegment(tradingPairId)}`, params),
         byId: (tradeId) => `${API_V1}/trades/by-id/${encodeSegment(tradeId)}`,
+        feed: (params) => withQuery(`${API_V1}/trades`, params),
         user: (params) => withQuery(`${API_V1}/accounts/trades`, params),
     },
     applications: {

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 {
     /**
@@ -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) {
@@ -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 });

package/dist/api/websocket/websocket.js

@@ -116,6 +116,17 @@ function readOptionalNumber(source, field) {
     }
     return value;
 }
+/**
+ * Read a wire integer that can be negative (a maker's fee rate is negative for
+ * a rebate): any safe integer, unlike {@link readSequence}.
+ */
+function readInteger(source, field) {
+    const value = source[field];
+    if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw new Error(`Invalid WebSocket event: ${field} must be a safe integer`);
+    }
+    return value;
+}
 function readOptionalSequence(source, field) {
     const value = source[field];
     if (value === undefined || value === null)
@@ -395,6 +406,150 @@ function parseMarketLiquidationEvent(rawData) {
         data: parseMarketLiquidationEventData(rawData.data),
     };
 }
+/**
+ * Parse a new RFQ to quote. The `rfq` channel's wire keys are camelCase
+ * already (serde `rename_all = "camelCase"`), so they are read as sent, bar
+ * the `type` tag, surfaced as `eventType` (see {@link parseRfqEvent}). A
+ * two-way request carries neither side.
+ */
+function parseRfqRequestedEvent(raw) {
+    const oneWaySide = readOptionalEnumValue(raw, "oneWaySide");
+    const quoteSide = readOptionalEnumValue(raw, "quoteSide");
+    return {
+        eventType: "RfqRequested",
+        rfqId: readString(raw, "rfqId"),
+        tradingPairId: readString(raw, "tradingPairId"),
+        // Value fields: a product or side this SDK predates is passed through.
+        product: readString(raw, "product"),
+        quantity: readString(raw, "quantity"),
+        ...(oneWaySide !== undefined && { oneWaySide }),
+        ...(quoteSide !== undefined && { quoteSide }),
+        newQuoteCutoffAtMs: readSequence(raw, "newQuoteCutoffAtMs"),
+    };
+}
+function parseRfqSideViewEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ view: a side must be an object");
+    }
+    return {
+        vwap: readString(raw, "vwap"),
+        availableQuantity: readString(raw, "availableQuantity"),
+    };
+}
+/** Parse the taker's view. A side no maker quotes is absent. */
+function parseRfqViewEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ view: view must be an object");
+    }
+    return {
+        viewVersion: readSequence(raw, "viewVersion"),
+        ...(raw.bid != null && { bid: parseRfqSideViewEventData(raw.bid) }),
+        ...(raw.ask != null && { ask: parseRfqSideViewEventData(raw.ask) }),
+        asOfMs: readSequence(raw, "asOfMs"),
+        sequence: readSequence(raw, "sequence"),
+    };
+}
+/** Parse a selected maker's own part of an acceptance. */
+function parseRfqSelectionEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ selection: selection must be an object");
+    }
+    return {
+        acceptanceId: readString(raw, "acceptanceId"),
+        takerSide: readString(raw, "takerSide"),
+        makerAccountId: readString(raw, "makerAccountId"),
+        quoteId: readString(raw, "quoteId"),
+        quoteVersion: readSequence(raw, "quoteVersion"),
+        quantity: readString(raw, "quantity"),
+        price: readString(raw, "price"),
+        capacity: readString(raw, "capacity"),
+        makerFeeCbps: readInteger(raw, "makerFeeCbps"),
+        lastLookDeadlineAtMs: readSequence(raw, "lastLookDeadlineAtMs"),
+    };
+}
+function parseRfqFillEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ outcome: a fill must be an object");
+    }
+    return {
+        executionId: readString(raw, "executionId"),
+        price: readString(raw, "price"),
+        quantity: readString(raw, "quantity"),
+        fee: readString(raw, "fee"),
+    };
+}
+/** Parse the taker's outcome. Nothing filled leaves `vwap` absent and `fills` empty. */
+function parseRfqOutcomeEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ outcome: outcome must be an object");
+    }
+    if (!Array.isArray(raw.fills)) {
+        throw new Error("Invalid RFQ outcome: fills must be an array");
+    }
+    const vwap = readOptionalDecimalString(raw, "vwap");
+    return {
+        executedQuantity: readString(raw, "executedQuantity"),
+        unfilledQuantity: readString(raw, "unfilledQuantity"),
+        ...(vwap !== undefined && { vwap }),
+        fills: raw.fills.map(parseRfqFillEventData),
+    };
+}
+/** Parse an RFQ's end. Only the taker's push carries `outcome`. */
+function parseRfqOutcomeEvent(raw) {
+    return {
+        eventType: "RfqOutcome",
+        rfqId: readString(raw, "rfqId"),
+        // A terminal state this SDK predates is passed through.
+        state: readString(raw, "state"),
+        ...(raw.outcome != null && { outcome: parseRfqOutcomeEventData(raw.outcome) }),
+    };
+}
+/**
+ * Parse an `rfq` channel push. The wire's `type` is the channel-class
+ * discriminator that picks the payload shape, so it is matched strictly: a push
+ * of a type this SDK predates is rejected rather than parsed as the wrong
+ * shape. It is surfaced as `eventType`, the discriminator every other channel's
+ * events carry; no `type` key is kept.
+ */
+function parseRfqEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid RFQ event: payload must be an object");
+    }
+    const eventType = readEnum(rawData, "type", ["RfqRequested", "RfqView", "RfqSelected", "RfqOutcome"]);
+    switch (eventType) {
+        case "RfqRequested":
+            return parseRfqRequestedEvent(rawData);
+        case "RfqView":
+            return { eventType, rfqId: readString(rawData, "rfqId"), view: parseRfqViewEventData(rawData.view) };
+        case "RfqSelected":
+            return { eventType, rfqId: readString(rawData, "rfqId"), selection: parseRfqSelectionEventData(rawData.selection) };
+        case "RfqOutcome":
+            return parseRfqOutcomeEvent(rawData);
+    }
+}
+function parseRfqTradeEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid RFQ trade event: data must be an object");
+    }
+    return {
+        executionId: readString(raw, "execution_id"),
+        price: readString(raw, "price"),
+        quantity: readString(raw, "quantity"),
+        executedAt: readString(raw, "executed_at"),
+        publishedAt: readString(raw, "published_at"),
+    };
+}
+/** Parse a public RFQ block print from `rfq_trades:<pair>`. */
+function parseRfqTradeEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid RFQ trade event: payload must be an object");
+    }
+    return {
+        tradingPairId: readString(rawData, "trading_pair_id"),
+        tradingMode: readString(rawData, "trading_mode"),
+        data: parseRfqTradeEventData(rawData.data),
+    };
+}
 /**
  * Parse an account's margin-health payload. Shared by the live event and the
  * subscribe-time snapshot (see {@link parseConditionalOrderEventData}).
@@ -2310,6 +2465,38 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             }
         });
     };
+    /**
+     * Subscribe to the authenticated account's RFQ pushes. The account comes from
+     * the signed session, so the channel is just `rfq`; a subscribe the server
+     * refuses for want of authentication is retried once the connection
+     * authenticates, as on every private channel.
+     */
+    const subscribeRfq = (handler) => {
+        if (!handler) {
+            throw new Error("rfq subscription requires a handler");
+        }
+        return subscribe("rfq", (rawData) => {
+            try {
+                handler(parseRfqEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing RFQ event", err);
+            }
+        });
+    };
+    const subscribeRfqTrades = (tradingPairId, handler) => {
+        if (!handler) {
+            throw new Error("rfqTrades subscription requires a handler");
+        }
+        return subscribe(`rfq_trades:${tradingPairId}`, (rawData) => {
+            try {
+                handler(parseRfqTradeEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing RFQ trade event", err);
+            }
+        });
+    };
     return {
         connect,
         disconnect,
@@ -2350,5 +2537,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         marketStats: subscribeMarketStats,
         marketStatsAll: subscribeMarketStatsAll,
         marketLiquidations: subscribeMarketLiquidations,
+        rfq: subscribeRfq,
+        rfqTrades: subscribeRfqTrades,
     };
 }

package/dist/coverage.d.ts

@@ -3,6 +3,7 @@ export declare const COVERED: {
     attach_position_tp_sl: string;
     batch_cancel_all: string;
     batch_cancel_all_by_pair: string;
+    cancel_all_after: string;
     batch_cancel_orders: string;
     batch_close_all_positions: string;
     batch_create_orders: string;
@@ -26,6 +27,14 @@ export declare const COVERED: {
     get_follow: string;
     list_follow_leader_positions: string;
     preview_follow: string;
+    get_rfq_capabilities: string;
+    create_rfq: string;
+    get_rfq: string;
+    accept_rfq: string;
+    cancel_rfq: string;
+    upsert_rfq_quote: string;
+    withdraw_rfq_quote: string;
+    respond_rfq_last_look: string;
     cancel_twap_order: string;
     create_twap_order: string;
     get_twap_order: string;
@@ -98,6 +107,7 @@ export declare const COVERED: {
     get_sub_account_limits: string;
     get_trade_by_id: string;
     get_trades: string;
+    list_trades: string;
     get_trade_flow: string;
     get_trader_metrics: string;
     get_liquidation_metrics: string;
@@ -122,6 +132,8 @@ export declare const COVERED: {
     list_delegated_agents: string;
     list_funding_history: string;
     list_liquidation_events: string;
+    list_all_liquidation_events: string;
+    list_insurance_funds: string;
     list_funding_payments: string;
     list_margin_accounts: string;
     list_position_history: string;

package/dist/coverage.js

@@ -3,6 +3,7 @@ export const COVERED = {
     attach_position_tp_sl: "attachPositionTpSl",
     batch_cancel_all: "batchCancelAll",
     batch_cancel_all_by_pair: "batchCancelAll (with tradingPairId)",
+    cancel_all_after: "cancelAllAfter",
     batch_cancel_orders: "batchCancel",
     batch_close_all_positions: "batchCloseAllPositions",
     batch_create_orders: "batchCreate",
@@ -26,6 +27,14 @@ export const COVERED = {
     get_follow: "copyTrading.getFollow",
     list_follow_leader_positions: "copyTrading.listFollowLeaderPositions",
     preview_follow: "copyTrading.previewFollow",
+    get_rfq_capabilities: "rfq.getCapabilities",
+    create_rfq: "rfq.createRfq",
+    get_rfq: "rfq.getRfq",
+    accept_rfq: "rfq.acceptRfq",
+    cancel_rfq: "rfq.cancelRfq",
+    upsert_rfq_quote: "rfq.upsertQuote",
+    withdraw_rfq_quote: "rfq.withdrawQuote",
+    respond_rfq_last_look: "rfq.respondLastLook",
     cancel_twap_order: "cancelTwapOrder",
     create_twap_order: "createTwapOrder",
     get_twap_order: "getTwapOrder",
@@ -98,6 +107,7 @@ export const COVERED = {
     get_sub_account_limits: "subAccounts.getLimits",
     get_trade_by_id: "getTradeById",
     get_trades: "getTrades",
+    list_trades: "listTrades",
     get_trade_flow: "getTradeFlow",
     get_trader_metrics: "getTraderMetrics",
     get_liquidation_metrics: "getLiquidationMetrics",
@@ -122,6 +132,8 @@ export const COVERED = {
     list_delegated_agents: "listDelegatedAgents",
     list_funding_history: "listFundingHistory",
     list_liquidation_events: "listLiquidationEvents",
+    list_all_liquidation_events: "listAllLiquidationEvents",
+    list_insurance_funds: "listInsuranceFunds",
     list_funding_payments: "listFundingPayments",
     list_margin_accounts: "listMarginAccounts",
     list_position_history: "listPositionHistory",

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationsAPI, AuthAPI, AuthState, BuildercodesAPI, ComplianceAPI, CopyTradingAPI, DelegatedAgentsAPI, FaucetAPI, FeesAPI, ManagedMarketsAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PortfolioAPI, PositionsAPI, ProfileAPI, PulseAPI, SDKConfig, SubAccountsAPI, SweeperAPI, TraderCodesAPI, TradingAPI, VaultAPI, WithdrawalsAPI } from "@0xmonaco/types";
+import type { ApplicationsAPI, AuthAPI, AuthState, BuildercodesAPI, ComplianceAPI, CopyTradingAPI, DelegatedAgentsAPI, FaucetAPI, FeesAPI, ManagedMarketsAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PortfolioAPI, PositionsAPI, ProfileAPI, PulseAPI, RfqAPI, SDKConfig, SubAccountsAPI, SweeperAPI, TraderCodesAPI, TradingAPI, VaultAPI, WithdrawalsAPI } from "@0xmonaco/types";
 import { type Address, type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
@@ -8,6 +8,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     fees: FeesAPI;
     buildercodes: BuildercodesAPI;
     copyTrading: CopyTradingAPI;
+    rfq: RfqAPI;
     tradercodes: TraderCodesAPI;
     vault: VaultAPI;
     withdrawals: WithdrawalsAPI;

package/dist/sdk.js

@@ -16,6 +16,7 @@ import { PortfolioAPIImpl } from "./api/portfolio";
 import { PositionsAPIImpl } from "./api/positions";
 import { ProfileAPIImpl } from "./api/profile";
 import { PulseAPIImpl } from "./api/pulse";
+import { RfqAPIImpl } from "./api/rfq";
 import { SubAccountsAPIImpl } from "./api/sub-accounts";
 import { SweeperAPIImpl } from "./api/sweeper";
 import { TraderCodesAPIImpl } from "./api/tradercodes";
@@ -49,6 +50,7 @@ export class MonacoSDKImpl {
     fees;
     buildercodes;
     copyTrading;
+    rfq;
     tradercodes;
     vault;
     withdrawals;
@@ -83,6 +85,7 @@ export class MonacoSDKImpl {
         this.fees.setSessionKeypair(credentials);
         this.buildercodes.setSessionKeypair(credentials);
         this.copyTrading.setSessionKeypair(credentials);
+        this.rfq.setSessionKeypair(credentials);
         this.tradercodes.setSessionKeypair(credentials);
         this.vault.setSessionKeypair(credentials);
         this.withdrawals.setSessionKeypair(credentials);
@@ -173,6 +176,7 @@ export class MonacoSDKImpl {
         this.fees = configureSigning(new FeesAPIImpl(apiUrl));
         this.buildercodes = configureSigning(new BuildercodesAPIImpl(apiUrl));
         this.copyTrading = configureSigning(new CopyTradingAPIImpl(apiUrl));
+        this.rfq = configureSigning(new RfqAPIImpl(apiUrl));
         this.tradercodes = configureSigning(new TraderCodesAPIImpl(apiUrl));
         this.profile = configureSigning(new ProfileAPIImpl(apiUrl));
         this.vault = configureSigning(new VaultAPIImpl(this.publicClient, this.walletClient, this.chain, this.applications, this.profile, apiUrl));

package/dist/utils/magnitude.d.ts

@@ -7,7 +7,10 @@ export declare const MIN_BUCKETS_ALLOWED = 10;
  */
 export declare const MAX_BUCKETS_ALLOWED = 10000000;
 /**
- * All possible magnitude values we support (from 0.0001 to 10000)
+ * All possible magnitude values we support (from 0.000001 to 10000).
+ *
+ * The finest grouping is the 6-decimal USDC unit, so every pair's tick has a
+ * grouping at its own precision (the SEI and FARTCOIN perps trade on 0.00001).
  */
 export declare const ALL_MAGNITUDES: number[];
 /**
@@ -21,6 +24,6 @@ export declare const ALL_MAGNITUDES: number[];
  * @example
  * calculateValidMagnitudes(112000);  // [0.1, 1, 10, 100, 1000, 10000]
  * calculateValidMagnitudes(4200);    // [0.001, 0.01, 0.1, 1, 10, 100]
- * calculateValidMagnitudes(0.5);     // [0.0001, 0.001, 0.01]
+ * calculateValidMagnitudes(0.5);     // [0.000001, 0.00001, 0.0001, 0.001, 0.01]
  */
 export declare const calculateValidMagnitudes: (currentPrice: number) => number[];

package/dist/utils/magnitude.js

@@ -7,9 +7,12 @@ export const MIN_BUCKETS_ALLOWED = 10;
  */
 export const MAX_BUCKETS_ALLOWED = 10_000_000;
 /**
- * All possible magnitude values we support (from 0.0001 to 10000)
+ * All possible magnitude values we support (from 0.000001 to 10000).
+ *
+ * The finest grouping is the 6-decimal USDC unit, so every pair's tick has a
+ * grouping at its own precision (the SEI and FARTCOIN perps trade on 0.00001).
  */
-export const ALL_MAGNITUDES = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000];
+export const ALL_MAGNITUDES = [0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000];
 /**
  * Calculate which magnitude levels are valid for a given price.
  *
@@ -21,7 +24,7 @@ export const ALL_MAGNITUDES = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000
  * @example
  * calculateValidMagnitudes(112000);  // [0.1, 1, 10, 100, 1000, 10000]
  * calculateValidMagnitudes(4200);    // [0.001, 0.01, 0.1, 1, 10, 100]
- * calculateValidMagnitudes(0.5);     // [0.0001, 0.001, 0.01]
+ * calculateValidMagnitudes(0.5);     // [0.000001, 0.00001, 0.0001, 0.001, 0.01]
  */
 export const calculateValidMagnitudes = (currentPrice) => {
     return ALL_MAGNITUDES.filter((magnitude) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.1.2",
+	"version": "1.1.5",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -19,8 +19,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.1.2",
-		"@0xmonaco/types": "1.1.2",
+		"@0xmonaco/contracts": "1.1.5",
+		"@0xmonaco/types": "1.1.5",
 		"@noble/curves": "^2.4.0",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"