@0xmonaco/core 1.1.9 → 1.1.10

package/README.md

@@ -349,6 +349,41 @@ interface MarketAPI extends BaseAPI {
 }
 ```
 
+### RFQ API
+
+RFQ (block trades): a taker requests quotes for a size, makers quote privately, the taker accepts one side of the aggregated view, and the selected makers get a 250 ms last look (silence executes). Available to accounts RFQ is enabled for; see the [RFQ guide](https://docs.0xmonaco.com/developers/rfq).
+
+```typescript
+interface RfqAPI extends BaseAPI {
+  getCapabilities(): Promise<GetRfqCapabilitiesResponse>;
+  // As taker
+  createRfq(params: CreateRfqParams): Promise<RfqStatus>;
+  getRfq(rfqId: string): Promise<RfqStatus>;
+  listRfqs(params?: ListRfqsParams): Promise<ListRfqsResponse>;
+  acceptRfq(rfqId: string, params: AcceptRfqParams): Promise<RfqStatus>;
+  cancelRfq(rfqId: string, params?: CancelRfqParams): Promise<RfqStatus>;
+  // As maker
+  upsertQuote(rfqId: string, params: UpsertRfqQuoteParams): Promise<RfqQuoteVersion>;
+  withdrawQuote(rfqId: string, params: WithdrawRfqQuoteParams): Promise<WithdrawRfqQuoteResponse>;
+  respondLastLook(rfqId: string, params: RespondRfqLastLookParams): Promise<RespondRfqLastLookResponse>;
+}
+```
+
+Pushes arrive on `sdk.ws.rfq(handler)` (authenticated), and public block prints on `sdk.ws.rfqTrades(tradingPairId, handler)`.
+
+A taker waiting for quotes should follow its view on the `RfqView` pushes rather than poll `getRfq`: the view is pushed on every change, and every `getRfq` rebuilds it on the server. `waitForRfqView` does this, reading `getRfq` only when a push may have been missed (at the start, after a reconnect, while the socket is down, and at the timeout). It rejects with an `InvalidStateError` when no view matched by `timeoutMs` (default 10000) or the RFQ ended first.
+
+```typescript
+import { waitForRfqView } from "@0xmonaco/core";
+
+const rfq = await sdk.rfq.createRfq({ tradingPairId, product: "PERPETUAL", quantity: "25", leverage: "2" });
+const rfqId = rfq.terms!.rfqId;
+const { view } = await waitForRfqView(sdk, rfqId, (view) => view.ask?.availableQuantity === "25", {
+  initialView: rfq.view,
+});
+await sdk.rfq.acceptRfq(rfqId, { side: "BUY", viewVersion: view.viewVersion });
+```
+
 ### WebSocket Authentication
 
 The SDK provides three WebSocket clients with different authentication requirements:

package/dist/api/applications/api.d.ts

@@ -18,7 +18,7 @@
  * const orders = await applicationsAPI.listApplicationOrders({ clientId: config.clientId, status: "FILLED" });
  * ```
  */
-import type { ApplicationConfigResponse, ApplicationsAPI, GetAppStatsParams, GetAppStatsResponse, ListAppBalancesParams, ListAppBalancesResponse, ListAppMovementsParams, ListAppMovementsResponse, ListAppOrdersParams, ListAppOrdersResponse, ListAppUsersParams, ListAppUsersResponse } from "@0xmonaco/types";
+import type { ApplicationConfigResponse, ApplicationsAPI, GetAppStatsParams, GetAppStatsResponse, ListAppBalancesParams, ListAppBalancesResponse, ListAppMarginAccountsParams, ListAppMarginAccountsResponse, ListAppMovementsParams, ListAppMovementsResponse, ListAppOrdersParams, ListAppOrdersResponse, ListAppUsersParams, ListAppUsersResponse } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class ApplicationsAPIImpl extends BaseAPI implements ApplicationsAPI {
     /**
@@ -96,7 +96,11 @@ export declare class ApplicationsAPIImpl extends BaseAPI implements Applications
      */
     listApplicationMovements(params: ListAppMovementsParams): Promise<ListAppMovementsResponse>;
     /**
-     * Lists user balances held within the application.
+     * Lists user wallet balances held within the application.
+     *
+     * Funds held in a margin account are not included, so a user funded through
+     * margin can show zero here. Read those users from
+     * `GET /api/v1/applications/margin-accounts` (`listApplicationMarginAccounts`).
      *
      * Public — the application is selected by `params.clientId`.
      *
@@ -113,6 +117,23 @@ export declare class ApplicationsAPIImpl extends BaseAPI implements Applications
      * @throws {APIError} When the request fails (404 for an unknown, inactive or hidden client ID, 429 when rate limited)
      */
     listApplicationBalances(params: ListAppBalancesParams): Promise<ListAppBalancesResponse>;
+    /**
+     * Lists the application's margin accounts, sub-accounts included.
+     *
+     * Margin collateral is not a wallet balance, so an application that funds its
+     * users through margin reads it here, not from `listApplicationBalances`.
+     * Figures are a persisted baseline repriced at the latest risk marks, so they
+     * can briefly lag the matching engine. Copy-trading accounts are not listed.
+     * Public — the application is selected by `params.clientId`.
+     *
+     * Cursor paged: omit `pageToken` or pass `""` to start, then follow
+     * `nextPageToken` until it comes back empty.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of margin accounts
+     * @throws {APIError} When the request fails (404 for an unknown, inactive or hidden client ID, 429 when rate limited)
+     */
+    listApplicationMarginAccounts(params: ListAppMarginAccountsParams): Promise<ListAppMarginAccountsResponse>;
     /**
      * Gets aggregate volume and fee stats for the application.
      *

package/dist/api/applications/api.js

@@ -18,7 +18,7 @@
  * const orders = await applicationsAPI.listApplicationOrders({ clientId: config.clientId, status: "FILLED" });
  * ```
  */
-import { ListAppBalancesSchema, ListAppMovementsSchema, ListAppOrdersSchema, ListAppUsersSchema, validate } from "@0xmonaco/types";
+import { ListAppBalancesSchema, ListAppMarginAccountsSchema, ListAppMovementsSchema, ListAppOrdersSchema, ListAppUsersSchema, validate } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp/routes";
 export class ApplicationsAPIImpl extends BaseAPI {
@@ -142,7 +142,11 @@ export class ApplicationsAPIImpl extends BaseAPI {
         }));
     }
     /**
-     * Lists user balances held within the application.
+     * Lists user wallet balances held within the application.
+     *
+     * Funds held in a margin account are not included, so a user funded through
+     * margin can show zero here. Read those users from
+     * `GET /api/v1/applications/margin-accounts` (`listApplicationMarginAccounts`).
      *
      * Public — the application is selected by `params.clientId`.
      *
@@ -168,6 +172,31 @@ export class ApplicationsAPIImpl extends BaseAPI {
             assetId: params.assetId,
         }));
     }
+    /**
+     * Lists the application's margin accounts, sub-accounts included.
+     *
+     * Margin collateral is not a wallet balance, so an application that funds its
+     * users through margin reads it here, not from `listApplicationBalances`.
+     * Figures are a persisted baseline repriced at the latest risk marks, so they
+     * can briefly lag the matching engine. Copy-trading accounts are not listed.
+     * Public — the application is selected by `params.clientId`.
+     *
+     * Cursor paged: omit `pageToken` or pass `""` to start, then follow
+     * `nextPageToken` until it comes back empty.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of margin accounts
+     * @throws {APIError} When the request fails (404 for an unknown, inactive or hidden client ID, 429 when rate limited)
+     */
+    async listApplicationMarginAccounts(params) {
+        validate(ListAppMarginAccountsSchema, params);
+        return await this.makePublicRequest(perpRoutes.applications.marginAccounts({
+            clientId: params.clientId,
+            address: params.address,
+            pageSize: params.pageSize,
+            pageToken: params.pageToken,
+        }));
+    }
     /**
      * Gets aggregate volume and fee stats for the application.
      *

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

@@ -246,6 +246,12 @@ export declare const perpRoutes: {
             userId?: string;
             assetId?: string;
         }) => string;
+        readonly marginAccounts: (params?: {
+            clientId?: string;
+            address?: string;
+            pageSize?: number;
+            pageToken?: string;
+        }) => string;
         readonly stats: (params?: {
             clientId?: string;
             since?: string;

package/dist/api/perp/routes.js

@@ -102,6 +102,7 @@ export const perpRoutes = {
         users: (params) => withQuery(`${API_V1}/applications/users`, params),
         movements: (params) => withQuery(`${API_V1}/applications/movements`, params),
         balances: (params) => withQuery(`${API_V1}/applications/balances`, params),
+        marginAccounts: (params) => withQuery(`${API_V1}/applications/margin-accounts`, params),
         stats: (params) => withQuery(`${API_V1}/applications/stats`, params),
     },
     subAccounts: {

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

@@ -14,12 +14,17 @@
  * the gateway rejects unknown fields and stores a maker's request exactly as
  * signed.
  *
+ * A taker waiting for quotes follows its view on the `rfq` WebSocket
+ * channel (`waitForRfqView`) rather than polling `getRfq`: the view is
+ * pushed on every change, and every `getRfq` rebuilds it on the server.
+ *
  * @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 });
+ * const rfqId = rfq.terms!.rfqId;
+ * const { view } = await waitForRfqView(sdk, rfqId, (view) => view.ask?.availableQuantity === "25", { initialView: rfq.view });
+ * await sdk.rfq.acceptRfq(rfqId, { side: "BUY", viewVersion: view.viewVersion });
  *
  * // Maker
  * const quote = await sdk.rfq.upsertQuote(rfqId, { expectedVersion: 0, ask: { price: "65001", capacity: "10" } });
@@ -41,7 +46,8 @@ export declare class RfqAPIImpl extends BaseAPI implements RfqAPI {
     /**
      * 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.
+     * and, once selected, `ownSelection` for last look. To wait for quotes,
+     * follow the `RfqView` pushes (`waitForRfqView`) instead of polling.
      */
     getRfq(rfqId: string): Promise<RfqStatus>;
     /**

package/dist/api/rfq/api.js

@@ -14,12 +14,17 @@
  * the gateway rejects unknown fields and stores a maker's request exactly as
  * signed.
  *
+ * A taker waiting for quotes follows its view on the `rfq` WebSocket
+ * channel (`waitForRfqView`) rather than polling `getRfq`: the view is
+ * pushed on every change, and every `getRfq` rebuilds it on the server.
+ *
  * @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 });
+ * const rfqId = rfq.terms!.rfqId;
+ * const { view } = await waitForRfqView(sdk, rfqId, (view) => view.ask?.availableQuantity === "25", { initialView: rfq.view });
+ * await sdk.rfq.acceptRfq(rfqId, { side: "BUY", viewVersion: view.viewVersion });
  *
  * // Maker
  * const quote = await sdk.rfq.upsertQuote(rfqId, { expectedVersion: 0, ask: { price: "65001", capacity: "10" } });
@@ -62,7 +67,8 @@ export class RfqAPIImpl extends BaseAPI {
     /**
      * 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.
+     * and, once selected, `ownSelection` for last look. To wait for quotes,
+     * follow the `RfqView` pushes (`waitForRfqView`) instead of polling.
      */
     async getRfq(rfqId) {
         return await this.makeAuthenticatedRequest(rfqPath(rfqId), { method: "GET" });

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

@@ -4,3 +4,4 @@
  * Exports the RFQ (block trading) API implementation.
  */
 export { RfqAPIImpl } from "./api";
+export { type RfqViewSource, waitForRfqView } from "./view";

package/dist/api/rfq/index.js

@@ -4,3 +4,4 @@
  * Exports the RFQ (block trading) API implementation.
  */
 export { RfqAPIImpl } from "./api";
+export { waitForRfqView } from "./view";

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

@@ -0,0 +1,45 @@
+/**
+ * The taker's RFQ view from the `rfq` WebSocket channel.
+ *
+ * The RFQ service pushes the taker its view (`RfqView`) every time the quotes
+ * change, so a taker waiting for the quotes it wants should follow those
+ * pushes instead of polling `getRfq`: every `getRfq` builds the whole view on
+ * the RFQ service. {@link waitForRfqView} does that, and reads the RFQ only
+ * when a push may have been missed.
+ */
+import type { MonacoWebSocket, RfqAPI, RfqView, RfqViewMatch, WaitForRfqViewOptions } from "@0xmonaco/types";
+/** What {@link waitForRfqView} reads from: the SDK itself (`sdk`) has both. */
+export interface RfqViewSource {
+    rfq: Pick<RfqAPI, "getRfq">;
+    ws: Pick<MonacoWebSocket, "rfq" | "isConnected" | "getSubscriptionState" | "onSubscriptionChange">;
+}
+/**
+ * Wait for the taker's view of `rfqId` to satisfy `predicate`, from the
+ * `RfqView` pushes on the `rfq` channel (the one with the highest `sequence`
+ * wins; pushes can arrive out of order).
+ *
+ * `getRfq` is read only where a push may have been missed:
+ * - once at the start, or, while the `rfq` subscribe is unanswered, once
+ *   when it is confirmed: pushes sent before the wait began (makers can
+ *   quote before `createRfq` returns) are not replayed to it;
+ * - once more on every confirmed resubscribe (after a reconnect);
+ * - repeatedly (250 ms, doubling to 2 s) while the socket is not connected or
+ *   the subscription is not confirmed, including when it drops mid-wait;
+ * - once when `timeoutMs` passes without a match.
+ * A read that a newer push overlapped is dropped (the pushes decide); the
+ * final read is retried, up to 3 times, until one is not overlapped.
+ *
+ * Resolves with the first view that matches. Rejects with an
+ * `InvalidStateError` when no view matched by the timeout, or when an
+ * `RfqOutcome` push says the RFQ ended; with the signal's reason when aborted;
+ * and with the error of the final read if that read fails.
+ *
+ * @example
+ * ```typescript
+ * const rfq = await sdk.rfq.createRfq({ tradingPairId, product: "PERPETUAL", quantity: "25" });
+ * const rfqId = rfq.terms!.rfqId;
+ * const { view } = await waitForRfqView(sdk, rfqId, (view) => view.ask?.availableQuantity === "25", { initialView: rfq.view });
+ * await sdk.rfq.acceptRfq(rfqId, { side: "BUY", viewVersion: view.viewVersion });
+ * ```
+ */
+export declare function waitForRfqView(source: RfqViewSource, rfqId: string, predicate: (view: RfqView) => boolean, options?: WaitForRfqViewOptions): Promise<RfqViewMatch>;

package/dist/api/rfq/view.js

@@ -0,0 +1,242 @@
+/**
+ * The taker's RFQ view from the `rfq` WebSocket channel.
+ *
+ * The RFQ service pushes the taker its view (`RfqView`) every time the quotes
+ * change, so a taker waiting for the quotes it wants should follow those
+ * pushes instead of polling `getRfq`: every `getRfq` builds the whole view on
+ * the RFQ service. {@link waitForRfqView} does that, and reads the RFQ only
+ * when a push may have been missed.
+ */
+import { UUIDSchema, validate } from "@0xmonaco/types";
+import { InvalidStateError } from "../../errors";
+const RFQ_CHANNEL = "rfq";
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Reads while no push can arrive start at this pause and double up to the cap. */
+const FIRST_POLL_PAUSE_MS = 250;
+const MAX_POLL_PAUSE_MS = 2_000;
+/** Final reads tried when a newer push keeps overlapping them. */
+const FINAL_READ_ATTEMPTS = 3;
+/**
+ * Wait for the taker's view of `rfqId` to satisfy `predicate`, from the
+ * `RfqView` pushes on the `rfq` channel (the one with the highest `sequence`
+ * wins; pushes can arrive out of order).
+ *
+ * `getRfq` is read only where a push may have been missed:
+ * - once at the start, or, while the `rfq` subscribe is unanswered, once
+ *   when it is confirmed: pushes sent before the wait began (makers can
+ *   quote before `createRfq` returns) are not replayed to it;
+ * - once more on every confirmed resubscribe (after a reconnect);
+ * - repeatedly (250 ms, doubling to 2 s) while the socket is not connected or
+ *   the subscription is not confirmed, including when it drops mid-wait;
+ * - once when `timeoutMs` passes without a match.
+ * A read that a newer push overlapped is dropped (the pushes decide); the
+ * final read is retried, up to 3 times, until one is not overlapped.
+ *
+ * Resolves with the first view that matches. Rejects with an
+ * `InvalidStateError` when no view matched by the timeout, or when an
+ * `RfqOutcome` push says the RFQ ended; with the signal's reason when aborted;
+ * and with the error of the final read if that read fails.
+ *
+ * @example
+ * ```typescript
+ * const rfq = await sdk.rfq.createRfq({ tradingPairId, product: "PERPETUAL", quantity: "25" });
+ * const rfqId = rfq.terms!.rfqId;
+ * const { view } = await waitForRfqView(sdk, rfqId, (view) => view.ask?.availableQuantity === "25", { initialView: rfq.view });
+ * await sdk.rfq.acceptRfq(rfqId, { side: "BUY", viewVersion: view.viewVersion });
+ * ```
+ */
+export function waitForRfqView(source, rfqId, predicate, options = {}) {
+    const id = validate(UUIDSchema, rfqId);
+    const { timeoutMs = DEFAULT_TIMEOUT_MS, initialView, signal } = options;
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        let settled = false;
+        let latestSequence = -1;
+        /** `RfqView` pushes of this RFQ newer than every earlier one, so far. */
+        let pushesSeen = 0;
+        let pollTimer;
+        let pollPause = FIRST_POLL_PAUSE_MS;
+        let polling = false;
+        let reading = false;
+        let readAgain = false;
+        const cleanups = [];
+        const stop = () => {
+            settled = true;
+            polling = false;
+            clearTimeout(pollTimer);
+            for (const cleanup of cleanups.splice(0))
+                cleanup();
+        };
+        const finish = (match) => {
+            if (settled)
+                return;
+            stop();
+            resolve(match);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            stop();
+            reject(error);
+        };
+        /** True when `view` matched (and the wait is over). */
+        const consider = (view, from) => {
+            try {
+                if (predicate(view)) {
+                    finish({ view, source: from });
+                    return true;
+                }
+            }
+            catch (error) {
+                fail(error);
+                return true;
+            }
+            return false;
+        };
+        if (initialView && consider(initialView, "initial"))
+            return;
+        /**
+         * One `getRfq`; errors only matter to the final read. `overlapped` when a
+         * newer push arrived while it was in flight: a read has no `sequence`, so
+         * it may be older than that push. Anything newer than the latest push is
+         * pushed too (the service always pushes the last change), so while the
+         * wait goes on the pushes decide.
+         */
+        const read = async () => {
+            const before = pushesSeen;
+            const status = await source.rfq.getRfq(id);
+            return { view: status.view ?? undefined, overlapped: pushesSeen !== before };
+        };
+        const catchUp = async () => {
+            if (settled)
+                return;
+            if (reading) {
+                // The read in flight may predate what asked for this one.
+                readAgain = true;
+                return;
+            }
+            reading = true;
+            try {
+                const { view, overlapped } = await read();
+                if (!settled && view && !overlapped)
+                    consider(view, "read");
+            }
+            catch {
+                // A push or the final read decides.
+            }
+            finally {
+                reading = false;
+            }
+            if (readAgain) {
+                readAgain = false;
+                await catchUp();
+            }
+        };
+        const stopPolling = () => {
+            polling = false;
+            clearTimeout(pollTimer);
+            pollTimer = undefined;
+            pollPause = FIRST_POLL_PAUSE_MS;
+        };
+        const poll = async () => {
+            pollTimer = undefined;
+            if (!polling || settled)
+                return;
+            await catchUp();
+            if (!polling || settled)
+                return;
+            if (pushesFlow()) {
+                stopPolling();
+                return;
+            }
+            pollTimer = setTimeout(poll, pollPause);
+            pollPause = Math.min(pollPause * 2, MAX_POLL_PAUSE_MS);
+        };
+        const startPolling = () => {
+            if (polling || settled)
+                return;
+            polling = true;
+            void poll();
+        };
+        const pushesFlow = () => source.ws.isConnected() && source.ws.getSubscriptionState(RFQ_CHANNEL) === "subscribed";
+        /** No push can arrive: the socket is down, or the subscribe was not taken. */
+        const pushesCannotArrive = () => {
+            const state = source.ws.getSubscriptionState(RFQ_CHANNEL);
+            return !source.ws.isConnected() || (state !== "subscribed" && state !== "pending");
+        };
+        // Subscribed first, so nothing pushed from here on is missed.
+        cleanups.push(source.ws.rfq((event) => {
+            if (settled || event.rfqId !== id)
+                return;
+            if (event.eventType === "RfqOutcome") {
+                fail(new InvalidStateError(`RFQ ${id} ended ${event.state} before a view matched`, event.state, "COLLECTING"));
+                return;
+            }
+            if (event.eventType !== "RfqView" || event.view.sequence <= latestSequence)
+                return;
+            latestSequence = event.view.sequence;
+            pushesSeen += 1;
+            consider(event.view, "push");
+        }));
+        // A confirmed (re)subscribe: what changed before it was never pushed to
+        // this handler, so read once and stop any polling.
+        cleanups.push(source.ws.onSubscriptionChange((change) => {
+            if (settled || change.channel !== RFQ_CHANNEL)
+                return;
+            if (change.state === "subscribed") {
+                stopPolling();
+                void catchUp();
+            }
+            else {
+                startPolling();
+            }
+        }));
+        // The last word: a read no newer push overlapped, tried a few times.
+        const timer = setTimeout(async () => {
+            if (settled)
+                return;
+            stopPolling();
+            try {
+                for (let attempt = 0; attempt < FINAL_READ_ATTEMPTS && !settled; attempt++) {
+                    const { view, overlapped } = await read();
+                    if (settled)
+                        return;
+                    if (overlapped)
+                        continue;
+                    if (view && consider(view, "read"))
+                        return;
+                    break;
+                }
+                fail(new InvalidStateError(`No view of RFQ ${id} matched within ${timeoutMs} ms`));
+            }
+            catch (error) {
+                fail(error);
+            }
+        }, timeoutMs);
+        cleanups.push(() => clearTimeout(timer));
+        if (signal) {
+            const onAbort = () => fail(signal.reason);
+            signal.addEventListener("abort", onAbort, { once: true });
+            cleanups.push(() => signal.removeEventListener("abort", onAbort));
+        }
+        // A dropped socket fires no subscription change: check it locally, and
+        // read until pushes can arrive again.
+        const liveness = setInterval(() => {
+            if (!settled && pushesCannotArrive())
+                startPolling();
+        }, FIRST_POLL_PAUSE_MS);
+        cleanups.push(() => clearInterval(liveness));
+        // What was pushed before this wait subscribed is gone: read it once now,
+        // or, while the subscribe is unanswered, when it is confirmed. With no
+        // push able to arrive yet, read until one can.
+        if (pushesCannotArrive()) {
+            startPolling();
+        }
+        else if (source.ws.getSubscriptionState(RFQ_CHANNEL) === "subscribed") {
+            void catchUp();
+        }
+    });
+}

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

@@ -34,7 +34,7 @@ export declare function parseRawTradeEvent(raw: RawTradeEvent): TradeEvent;
 /**
  * Options for fetching trades
  */
-export interface GetTradesOptions {
+interface TradesPageOptions {
     /** Maximum number of records to return (default: 25, max: 1000) */
     pageSize?: number;
     /**
@@ -43,10 +43,55 @@ export interface GetTradesOptions {
      */
     pageToken?: string;
 }
+/**
+ * Options for fetching a pair's trades
+ */
+export interface GetTradesOptions extends TradesPageOptions {
+    /**
+     * The execution source to keep: `"RFQ"` (RFQ block fills, the history
+     * behind `rfqTrades`) or `"CLOB"` (order-book fills), the values of each
+     * trade's `data.executionSource`. Omit for every fill. A page token is tied
+     * to the filter it was minted under.
+     */
+    executionSource?: "RFQ" | "CLOB";
+}
+/**
+ * Options for recovering missed RFQ prints.
+ */
+export interface RecoverRfqTradesOptions {
+    /**
+     * The newest `executionId` the caller already has. Recovery stops at it;
+     * omit to read only the newest page.
+     */
+    sinceExecutionId?: string;
+    /** Rows per page (default: 100, max: 1000). */
+    pageSize?: number;
+    /**
+     * Most pages to read before giving up (default: 10). A `sinceExecutionId`
+     * not found within this many pages is reported as `complete: false`.
+     */
+    maxPages?: number;
+}
+/**
+ * The RFQ prints a caller missed, oldest first.
+ */
+export interface RecoveredRfqTrades {
+    /**
+     * RFQ fills newer than `sinceExecutionId`, plus the other fills sharing its
+     * execution time, oldest first. Deduplicate by `executionId` on replay.
+     */
+    trades: TradeEvent[];
+    /**
+     * `true` when the walk reached `sinceExecutionId` or the start of the
+     * pair's history; `false` when it stopped at `maxPages`, so older prints may
+     * still be missing.
+     */
+    complete: boolean;
+}
 /**
  * Options for the every-market trade feed.
  */
-export interface ListTradesOptions extends GetTradesOptions {
+export interface ListTradesOptions extends TradesPageOptions {
     /** Only the trades this application (frontend) took, as the taker's application. */
     takerApplicationId?: string;
 }
@@ -90,6 +135,25 @@ export declare class TradesAPIImpl extends BaseAPI {
      * ```
      */
     getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<GetTradesPage>;
+    /**
+     * Recover the RFQ block prints a `rfqTrades` subscriber missed (RFQ-15).
+     *
+     * `rfq_trades` prints are best-effort, so a gap is possible. This pages the
+     * pair's public RFQ history (`getTrades` with `executionSource: "RFQ"`),
+     * newest first, until it reaches `sinceExecutionId`, and returns what is
+     * newer than it, oldest first, ready to replay. Each trade's `tradeId` is
+     * the print's `executionId`.
+     *
+     * It also returns every other fill with the same execution time as
+     * `sinceExecutionId`: an RFQ's fills share one execution time and need not
+     * arrive in id order, so a missed one can sort after the last print seen.
+     * Some of those may already have been received, so deduplicate replayed
+     * fills by `executionId`.
+     *
+     * @param tradingPairId - The trading pair UUID
+     * @param options - Where to stop, and how far to look
+     */
+    recoverRfqTrades(tradingPairId: string, options?: RecoverRfqTradesOptions): Promise<RecoveredRfqTrades>;
     /**
      * Get one page of the trade feed: every market, newest first, recent and
      * archived trades alike, or only the trades one application took when

package/dist/api/trades/api.js

@@ -63,6 +63,9 @@ export class TradesAPIImpl extends BaseAPI {
         if (options.pageToken != null && options.pageToken !== "") {
             params.set("pageToken", options.pageToken);
         }
+        if (options.executionSource != null) {
+            params.set("executionSource", options.executionSource);
+        }
         const query = params.toString();
         const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}${query === "" ? "" : `?${query}`}`);
         return {
@@ -75,6 +78,61 @@ export class TradesAPIImpl extends BaseAPI {
             nextPageToken: response.nextPageToken ?? "",
         };
     }
+    /**
+     * Recover the RFQ block prints a `rfqTrades` subscriber missed (RFQ-15).
+     *
+     * `rfq_trades` prints are best-effort, so a gap is possible. This pages the
+     * pair's public RFQ history (`getTrades` with `executionSource: "RFQ"`),
+     * newest first, until it reaches `sinceExecutionId`, and returns what is
+     * newer than it, oldest first, ready to replay. Each trade's `tradeId` is
+     * the print's `executionId`.
+     *
+     * It also returns every other fill with the same execution time as
+     * `sinceExecutionId`: an RFQ's fills share one execution time and need not
+     * arrive in id order, so a missed one can sort after the last print seen.
+     * Some of those may already have been received, so deduplicate replayed
+     * fills by `executionId`.
+     *
+     * @param tradingPairId - The trading pair UUID
+     * @param options - Where to stop, and how far to look
+     */
+    async recoverRfqTrades(tradingPairId, options = {}) {
+        const pageSize = options.pageSize ?? 100;
+        const maxPages = options.maxPages ?? 10;
+        if (!Number.isInteger(maxPages) || maxPages < 1) {
+            throw new Error("maxPages must be a positive integer");
+        }
+        const newestFirst = [];
+        // Set once the walk reaches `sinceExecutionId`: that print's execution
+        // time. RFQ children share one execution time and their ids need not
+        // follow receipt order, so a missed child can sort after the last seen
+        // one; the walk reads on through the whole group before it stops.
+        let anchorExecutedAt;
+        let pageToken;
+        for (let pages = 0; pages < maxPages; pages++) {
+            const page = await this.getTrades(tradingPairId, { pageSize, executionSource: "RFQ", ...(pageToken ? { pageToken } : {}) });
+            for (const trade of page.trades) {
+                if (anchorExecutedAt !== undefined) {
+                    if (trade.data.executedAt !== anchorExecutedAt) {
+                        return { trades: newestFirst.reverse(), complete: true };
+                    }
+                    newestFirst.push(trade);
+                    continue;
+                }
+                if (options.sinceExecutionId != null && trade.data.tradeId === options.sinceExecutionId) {
+                    anchorExecutedAt = trade.data.executedAt;
+                    continue;
+                }
+                newestFirst.push(trade);
+            }
+            // Without a known last print, only the newest page is wanted.
+            if (options.sinceExecutionId == null || page.nextPageToken === "") {
+                return { trades: newestFirst.reverse(), complete: true };
+            }
+            pageToken = page.nextPageToken;
+        }
+        return { trades: newestFirst.reverse(), complete: false };
+    }
     /**
      * Get one page of the trade feed: every market, newest first, recent and
      * archived trades alike, or only the trades one application took when

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

@@ -323,11 +323,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * Failed replacements do not prevent other orders from being replaced.
      *
      * Pre-sequencing validation is scoped per item too, matching `batchCreate`:
-     * a malformed `orderId`, `price`, `quantity` or `clientOrderId`, or a
-     * `postOnly` violation, fails only that item — its result slot carries a
-     * structured `error.code` (`INVALID_ORDER_ID`, `INVALID_PRICE`,
-     * `INVALID_QUANTITY`, `INVALID_CLIENT_ORDER_ID`, `INVALID_POST_ONLY`) and its
-     * original is left untouched — while the valid items proceed. A `2xx`
+     * a malformed `orderId`, `price`, `quantity` or `clientOrderId` fails only
+     * that item — its result slot carries a structured `error.code`
+     * (`INVALID_ORDER_ID`, `INVALID_PRICE`, `INVALID_QUANTITY`,
+     * `INVALID_CLIENT_ORDER_ID`) and its original is left untouched — while the valid items proceed. A `2xx`
      * response can therefore mix executed replacements and failed items: read
      * `results[]` per item rather than treating the status code as the verdict.
      * Only an empty or oversize (>100) batch rejects the whole request.

package/dist/api/trading/api.js

@@ -495,11 +495,10 @@ export class TradingAPIImpl extends BaseAPI {
      * Failed replacements do not prevent other orders from being replaced.
      *
      * Pre-sequencing validation is scoped per item too, matching `batchCreate`:
-     * a malformed `orderId`, `price`, `quantity` or `clientOrderId`, or a
-     * `postOnly` violation, fails only that item — its result slot carries a
-     * structured `error.code` (`INVALID_ORDER_ID`, `INVALID_PRICE`,
-     * `INVALID_QUANTITY`, `INVALID_CLIENT_ORDER_ID`, `INVALID_POST_ONLY`) and its
-     * original is left untouched — while the valid items proceed. A `2xx`
+     * a malformed `orderId`, `price`, `quantity` or `clientOrderId` fails only
+     * that item — its result slot carries a structured `error.code`
+     * (`INVALID_ORDER_ID`, `INVALID_PRICE`, `INVALID_QUANTITY`,
+     * `INVALID_CLIENT_ORDER_ID`) and its original is left untouched — while the valid items proceed. A `2xx`
      * response can therefore mix executed replacements and failed items: read
      * `results[]` per item rather than treating the status code as the verdict.
      * Only an empty or oversize (>100) batch rejects the whole request.

package/dist/api/websocket/websocket.js

@@ -728,6 +728,7 @@ function parseMarketStatsSummary(raw) {
         fundingRate: readOptionalString(data, "fundingRate"),
         premium: readOptionalString(data, "premium"),
         openInterestNotional: readOptionalString(data, "openInterestNotional"),
+        dailyVolumeBySource: parseDailyVolumeBySource(data.dailyVolumeBySource),
     };
 }
 function parseMarketStatsAllEvent(rawData) {
@@ -3075,7 +3076,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             }
         });
     };
-    const subscribeRfqTrades = (tradingPairId, handler) => {
+    const subscribeRfqTrades = (tradingPairId, handler, onSnapshot) => {
         if (!handler) {
             throw new Error("rfqTrades subscription requires a handler");
         }
@@ -3086,7 +3087,9 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             catch (err) {
                 console.error("WebSocket: Error processing RFQ trade event", err);
             }
-        });
+        }, 
+        // The pair's newest RFQ prints from the public RFQ history (RFQ-15).
+        onSnapshot && snapshotFrameHandler("rfq_trades", parseRfqTradeEventData, onSnapshot));
     };
     return {
         connect,

package/dist/coverage.d.ts

@@ -139,6 +139,7 @@ export declare const COVERED: {
     list_pending_withdrawals: string;
     list_all_funding_history: string;
     list_application_balances: string;
+    list_application_margin_accounts: string;
     list_application_movements: string;
     list_application_orders: string;
     list_application_users: string;

package/dist/coverage.js

@@ -139,6 +139,7 @@ export const COVERED = {
     list_pending_withdrawals: "listPendingWithdrawals",
     list_all_funding_history: "listAllFundingHistory",
     list_application_balances: "listApplicationBalances",
+    list_application_margin_accounts: "listApplicationMarginAccounts",
     list_application_movements: "listApplicationMovements",
     list_application_orders: "listApplicationOrders",
     list_application_users: "listApplicationUsers",

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { type RfqViewSource, waitForRfqView } from "./api/rfq";
 export { createMonacoWebSocket, type MonacoWebSocket, type MonacoWebSocketOptions } from "./api/websocket";
 export { APIError, ContractError, InvalidConfigError, InvalidStateError, MonacoCoreError, WithdrawalRateLimitedError } from "./errors";
 export { resolveApiUrl, resolveWsUrl } from "./networks";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { waitForRfqView } from "./api/rfq";
 export { createMonacoWebSocket } from "./api/websocket";
 export { APIError, ContractError, InvalidConfigError, InvalidStateError, MonacoCoreError, WithdrawalRateLimitedError } from "./errors";
 export { resolveApiUrl, resolveWsUrl } from "./networks";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.1.9",
+	"version": "1.1.10",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -19,15 +19,15 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.1.9",
-		"@0xmonaco/types": "1.1.9",
+		"@0xmonaco/contracts": "1.1.10",
+		"@0xmonaco/types": "1.1.10",
 		"@noble/curves": "^2.4.0",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"
 	},
 	"devDependencies": {
 		"dotenv": "^18.0.8",
-		"ws": "^8.22.0"
+		"ws": "^8.22.1"
 	},
 	"exports": {
 		".": {