@0xmonaco/types 1.1.8 → 1.1.10

package/dist/applications/index.d.ts

@@ -5,8 +5,8 @@
  * endpoints.
  */
 import type { BaseAPI } from "../api";
-import type { GetAppStatsParams, ListAppBalancesParams, ListAppMovementsParams, ListAppOrdersParams, ListAppUsersParams } from "./requests";
-import type { ApplicationConfigResponse, GetAppStatsResponse, ListAppBalancesResponse, ListAppMovementsResponse, ListAppOrdersResponse, ListAppUsersResponse } from "./responses";
+import type { GetAppStatsParams, ListAppBalancesParams, ListAppMarginAccountsParams, ListAppMovementsParams, ListAppOrdersParams, ListAppUsersParams } from "./requests";
+import type { ApplicationConfigResponse, GetAppStatsResponse, ListAppBalancesResponse, ListAppMarginAccountsResponse, ListAppMovementsResponse, ListAppOrdersResponse, ListAppUsersResponse } from "./responses";
 /**
  * Applications API interface.
  *
@@ -46,12 +46,26 @@ export interface ApplicationsAPI extends BaseAPI {
      */
     listApplicationMovements(params: ListAppMovementsParams): Promise<ListAppMovementsResponse>;
     /**
-     * Lists user balances held within the application. Public, selected by `clientId`.
+     * Lists user wallet balances held within the application. Public, selected by `clientId`.
+     *
+     * 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`).
      *
      * @param params - Pagination and filter options
      * @returns Promise resolving to a paginated list of balances
      */
     listApplicationBalances(params: ListAppBalancesParams): Promise<ListAppBalancesResponse>;
+    /**
+     * Lists the application's margin accounts, sub-accounts included. Public,
+     * selected by `clientId`. 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.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of margin accounts
+     */
+    listApplicationMarginAccounts(params: ListAppMarginAccountsParams): Promise<ListAppMarginAccountsResponse>;
     /**
      * Gets aggregate volume and fee stats for the application. Public, selected by `clientId`.
      *
@@ -60,5 +74,5 @@ export interface ApplicationsAPI extends BaseAPI {
      */
     getApplicationStats(params: GetAppStatsParams): Promise<GetAppStatsResponse>;
 }
-export type { GetAppStatsParams, ListAppBalancesParams, ListAppMovementsParams, ListAppOrdersParams, ListAppUsersParams } from "./requests";
-export type { AppBalance, ApplicationConfigResponse, AppMovement, AppOrder, AppUser, GetAppStatsResponse, ListAppBalancesResponse, ListAppMovementsResponse, ListAppOrdersResponse, ListAppUsersResponse, } from "./responses";
+export type { GetAppStatsParams, ListAppBalancesParams, ListAppMarginAccountsParams, ListAppMovementsParams, ListAppOrdersParams, ListAppUsersParams, } from "./requests";
+export type { AppBalance, ApplicationConfigResponse, AppMarginAccount, AppMovement, AppOrder, AppUser, GetAppStatsResponse, ListAppBalancesResponse, ListAppMarginAccountsResponse, ListAppMovementsResponse, ListAppOrdersResponse, ListAppUsersResponse, } from "./responses";

package/dist/applications/requests.d.ts

@@ -95,6 +95,26 @@ export interface ListAppMovementsParams {
     /** Filter by asset UUID */
     assetId?: string;
 }
+/**
+ * Query parameters for listing application margin accounts.
+ */
+export interface ListAppMarginAccountsParams {
+    /** Public client ID of the application to list (required). An unknown, inactive or hidden one is a `404`. */
+    clientId: string;
+    /**
+     * Keep only this wallet's margin accounts in the application. A wallet with
+     * no margin account here returns an empty page.
+     */
+    address?: string;
+    /** Items per page, 1 to 1000 (default 20). Rejected if larger. */
+    pageSize?: number;
+    /**
+     * Pagination cursor: omit or pass `""` to start, otherwise a previous
+     * response's `nextPageToken`. Ordered by margin account id ascending.
+     * Filters must match the request that minted the token.
+     */
+    pageToken?: string;
+}
 /**
  * Query parameters for listing application balances.
  */

package/dist/applications/responses.d.ts

@@ -132,13 +132,13 @@ export interface AppBalance {
     decimals: number;
     /** Balance UUID */
     id: string;
-    /** Last sync timestamp (ISO 8601) */
+    /** @deprecated This timestamp is not kept up to date and must not be used. It is not a sync or health signal. */
     lastSyncAt: string | null;
-    /** Last sync block number */
+    /** @deprecated This block number is not kept up to date and must not be used. It is not a sync or health signal. */
     lastSyncBlock: number | null;
     /** Locked balance */
     lockedBalance: string;
-    /** On-chain balance */
+    /** @deprecated This value is not kept up to date and must not be used. It is not a sync or health signal. */
     onChainBalance: string;
     /** Token symbol */
     symbol: string | null;
@@ -225,6 +225,50 @@ export interface ListAppBalancesResponse {
      */
     totalCapped: boolean;
 }
+/**
+ * One margin account of an application.
+ *
+ * Every figure is a persisted baseline repriced at the latest risk marks, so it
+ * can briefly lag the matching engine.
+ */
+export interface AppMarginAccount {
+    /** Margin account UUID */
+    marginAccountId: string;
+    /** UUID of the user who owns this margin account */
+    userId: string;
+    /** Wallet address of the owning user */
+    address: string;
+    /** Sub-account key; `default` is the parent margin account */
+    subaccountKey: string;
+    /** `ACTIVE`, or `CLOSED` for a closed sub-account */
+    marginAccountState: string;
+    /** Deposited collateral in USD, before any PnL */
+    collateral: string;
+    /** Settled collateral, unrealized PnL at the latest risk marks, and realized PnL held by open risk buckets */
+    equity: string;
+    /** Collateral available for new margin. Not the withdrawal bound. */
+    freeCollateral: string;
+    /** Collateral a transfer out can take. The matching engine enforces the transfer and can accept less. */
+    withdrawableCollateral: string;
+    /** When this margin account was last persisted. Repricing at newer marks does not move it. */
+    updatedAt: string;
+}
+/**
+ * Paginated list of application margin accounts.
+ */
+export interface ListAppMarginAccountsResponse {
+    marginAccounts: AppMarginAccount[];
+    /** Margin accounts matching the filter, bounded by the server count ceiling. */
+    total: number;
+    /** Items per page */
+    pageSize: number;
+    /** Pages at this `pageSize`, bounded by the same ceiling as `total`. */
+    totalPages: number;
+    /** Cursor for the next page; `""` proves the walk is exhausted. */
+    nextPageToken: string;
+    /** `true` when more than the server ceiling matched, so `total` / `totalPages` are a lower bound. */
+    totalCapped: boolean;
+}
 /**
  * Aggregate volume and fee stats for an application.
  *

package/dist/margin-accounts/index.d.ts

@@ -593,7 +593,7 @@ export interface CloseMarginSubAccountResponse {
     /** Collateral moved to the default margin account. */
     amount: string;
 }
-/** One side of a collateral transfer: the spot wallet, or a margin account. */
+/** One side of a collateral transfer: the spot wallet, a margin account, or one of its risk buckets. */
 export type CollateralTransferEndpoint = {
     wallet: true;
     marginAccountId?: never;
@@ -604,9 +604,11 @@ export type CollateralTransferEndpoint = {
     riskBucketId?: string;
 };
 /**
- * Move collateral between the spot wallet and the caller's margin accounts.
- * Supported: wallet to the default margin account and back, and margin
- * account to margin account.
+ * Move collateral between any two of the caller's places: the spot wallet, a
+ * margin account, a risk bucket. A route that crosses accounts or the wallet
+ * runs up to three moves in one step, and a refused request moves nothing. The
+ * wallet is reached through the default margin account. A route to or from the
+ * wallet or a risk bucket refuses a copy-trading sub-account.
  */
 export interface TransferMarginCollateralRequest {
     asset: string;
@@ -628,6 +630,9 @@ export interface TransferMarginCollateralResponse {
     fromMarginAccountId?: string;
     toMarginAccountId?: string;
     toRiskBucketId?: string;
+    fromRiskBucketId?: string;
+    /** Whether funding the risk bucket credited its sole open position's margin. Absent when the destination is not a risk bucket. */
+    positionMarginCredited?: boolean;
 }
 export interface MarginAccountsAPI extends BaseAPI {
     /**

package/dist/market/index.d.ts

@@ -239,6 +239,8 @@ export interface ScreenerItem {
     totalQuoteVolumeLtd: string;
     /** Life-to-date cumulative number of trades since inception (0 if no trades yet) */
     totalTradeCountLtd: number;
+    /** The life-to-date totals split into their order-book and RFQ parts */
+    totalVolumeLtdBySource?: LtdVolumeBySource;
     /**
      * Latest settled funding rate as a decimal fraction per funding window (the
      * capped settled value); null for spot pairs and margin pairs with no
@@ -273,11 +275,27 @@ export interface ScreenerItem {
     /**
      * Estimated rate for the in-progress funding window (decimal fraction per
      * window), the same value as `getFundingState().estimatedNextFundingRate`.
-     * A window that ends with too few accepted samples settles at the previous
-     * settled rate (0 if none has settled), so the settled rate can differ.
+     * A window that ends with too few accepted samples settles at zero, so the
+     * settled rate can differ.
      * Null for spot pairs and margin pairs whose current window has no samples yet
      */
     estimatedNextFundingRate: string | null;
+    /**
+     * The 24h quote volume split into its order-book and RFQ parts; absent while
+     * any candle in the window has no recorded split, or when `quoteVolume24h`
+     * is null.
+     */
+    quoteVolume24hBySource?: ScreenerQuoteVolumeBySource | null;
+}
+/**
+ * A screener row's 24h quote volume split by execution source: the order-book
+ * part plus the RFQ part is `quoteVolume24h` (decimal strings).
+ */
+export interface ScreenerQuoteVolumeBySource {
+    /** Quote-token volume filled on the order book in the last 24 hours */
+    orderBookQuoteVolume: string;
+    /** Quote-token volume filled by RFQ block trades in the last 24 hours */
+    rfqQuoteVolume: string;
 }
 /**
  * Paginated screener response, sorted by quoteVolume24h desc (nulls last)
@@ -329,12 +347,33 @@ export interface MarketMetadata {
     totalQuoteVolumeLtd: string;
     /** Life-to-date cumulative number of trades since inception (0 if no trades yet) */
     totalTradeCountLtd: number;
+    /** The life-to-date totals split into their order-book and RFQ parts */
+    totalVolumeLtdBySource?: LtdVolumeBySource;
     /**
      * The rolling 24h volumes split into their order-book and RFQ parts; absent
      * while any candle in the window has no recorded split.
      */
     volume24hBySource?: Volume24hBySource | null;
 }
+/**
+ * Life-to-date totals split by how they executed (RFQ-17): the order-book part
+ * and the RFQ part, which add up exactly to the totals beside them. Base volume
+ * is set only for a single market (null or absent elsewhere).
+ */
+export interface LtdVolumeBySource {
+    /** Life-to-date base-token volume filled on the order book (single market only) */
+    orderBookBaseVolume?: string | null;
+    /** Life-to-date base-token volume filled by RFQ block trades (single market only) */
+    rfqBaseVolume?: string | null;
+    /** Life-to-date quote-token volume filled on the order book */
+    orderBookQuoteVolume: string;
+    /** Life-to-date quote-token volume filled by RFQ block trades */
+    rfqQuoteVolume: string;
+    /** Life-to-date number of order-book trades */
+    orderBookTradeCount: number;
+    /** Life-to-date number of RFQ fills (one per maker child) */
+    rfqTradeCount: number;
+}
 /**
  * A market's rolling 24h volume split by execution source: each total is the
  * order-book part plus the RFQ part (decimal strings).
@@ -357,6 +396,8 @@ export interface MarketStats {
     totalQuoteVolumeLtd: string;
     /** Life-to-date cumulative number of trades summed across all pairs */
     totalTradeCountLtd: number;
+    /** The life-to-date totals split into their order-book and RFQ parts */
+    totalVolumeLtdBySource?: LtdVolumeBySource;
 }
 /**
  * One notional bracket of a market's margin ladder. Brackets are MARGINAL: a
@@ -524,7 +565,11 @@ export interface FundingRecord {
     windowClosedAt: string;
     /** Settlement time (ISO 8601); the sort key for `listAllFundingHistory`. */
     settledAt: string;
-    /** True when the window settled at the carried last rate (sparse-sample rule). */
+    /**
+     * True when the window held too few accepted samples and settled at zero
+     * (sparse-sample rule). Windows settled before 0XM-3728 carried the last
+     * settled rate instead.
+     */
     carried?: boolean;
 }
 export interface ListFundingHistoryParams {

package/dist/portfolio/index.d.ts

@@ -73,6 +73,8 @@ export interface PortfolioPerformance {
     netExternalFlows: string;
     pnl?: string;
     returnPct?: string;
+    /** Modified Dietz return: pnl over starting equity plus deposits minus withdrawals, each weighted by time in the account. Never below -100%. Defined after equity touches zero; omitted when the window has no positive-equity sample or withdrawals leave the time-weighted capital below 5% of what it would have been without them. Not bounded above: a capital just over that limit can still give a gain of up to about 20 times the return on the full base. */
+    modifiedDietzReturnPct?: string;
     maxDrawdown?: PortfolioPerformanceDrawdown;
     points: PortfolioPerformancePoint[];
 }
@@ -116,6 +118,7 @@ export interface PortfolioRealizedPnl {
 export interface PortfolioAssetsPerformance {
     pnl?: string;
     returnPct?: string;
+    modifiedDietzReturnPct?: string;
     calculationMethod: "sampled_twr";
 }
 export interface PortfolioAssetRow {

package/dist/rfq/index.d.ts

@@ -9,7 +9,30 @@
  */
 import type { BaseAPI } from "../api";
 import type { AcceptRfqParams, CancelRfqParams, CreateRfqParams, RespondRfqLastLookParams, UpsertRfqQuoteParams, WithdrawRfqQuoteParams } from "../validation/rfq";
-import type { GetRfqCapabilitiesResponse, RespondRfqLastLookResponse, RfqQuoteVersion, RfqStatus, WithdrawRfqQuoteResponse } from "./responses";
+import type { GetRfqCapabilitiesResponse, ListRfqsResponse, RespondRfqLastLookResponse, RfqQuoteVersion, RfqStatus, RfqView, WithdrawRfqQuoteResponse } from "./responses";
+/** `listRfqs` paging: up to 100 per page (default 50), and the previous page's token. */
+export interface ListRfqsParams {
+    pageSize?: number;
+    pageToken?: string;
+}
+/** Options for `waitForRfqView`. */
+export interface WaitForRfqViewOptions {
+    /**
+     * How long to wait for a matching view, in milliseconds (default 10000).
+     * When it passes, the RFQ is read once; no match then rejects.
+     */
+    timeoutMs?: number;
+    /** A view you already hold (e.g. `createRfq`'s `view`), checked first. */
+    initialView?: RfqView | null;
+    /** Aborts the wait; it rejects with the signal's reason. */
+    signal?: AbortSignal;
+}
+/** The taker's view `waitForRfqView` found, and where it came from. */
+export interface RfqViewMatch {
+    view: RfqView;
+    /** `push` from the `rfq` channel; `read` from a `getRfq` fallback; `initial` from `initialView`. */
+    source: "initial" | "push" | "read";
+}
 /**
  * RFQ API.
  *
@@ -27,9 +50,17 @@ export interface RfqAPI 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 `rfq` channel's `RfqView` pushes (`waitForRfqView` in
+     * `@0xmonaco/core`) instead of polling this: each read rebuilds the view.
      */
     getRfq(rfqId: string): Promise<RfqStatus>;
+    /**
+     * Your RFQs as the taker, newest first, in every state (those that filled
+     * nothing included). Each is as `getRfq` gives it, without the live `view`.
+     * Follow `nextPageToken` until it is empty.
+     */
+    listRfqs(params?: ListRfqsParams): Promise<ListRfqsResponse>;
     /** Accept one side of the view you last saw (`view.viewVersion`). Binding. */
     acceptRfq(rfqId: string, params: AcceptRfqParams): Promise<RfqStatus>;
     /** Cancel an RFQ you have not accepted, before its deadline. */

package/dist/rfq/responses.d.ts

@@ -336,6 +336,147 @@ export declare const RfqStatusSchema: z.ZodObject<{
         bookFullSize: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+/** A page of your RFQs as the taker, newest first. */
+export declare const ListRfqsResponseSchema: z.ZodObject<{
+    rfqs: z.ZodArray<z.ZodObject<{
+        terms: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            rfqId: z.ZodString;
+            tradingPairId: z.ZodString;
+            product: z.ZodOptional<z.ZodNullable<z.ZodType<"PERPETUAL" | "SPOT" | (string & {}), unknown, z.core.$ZodTypeInternals<"PERPETUAL" | "SPOT" | (string & {}), unknown>>>>;
+            quantity: z.ZodString;
+            createdAtMs: z.ZodNumber;
+            deadlineAtMs: z.ZodNumber;
+            side: z.ZodOptional<z.ZodNullable<z.ZodType<"BUY" | "SELL" | (string & {}), unknown, z.core.$ZodTypeInternals<"BUY" | "SELL" | (string & {}), unknown>>>>;
+            quoteSide: z.ZodOptional<z.ZodNullable<z.ZodType<"ASK" | "BID" | (string & {}), unknown, z.core.$ZodTypeInternals<"ASK" | "BID" | (string & {}), unknown>>>>;
+            leverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marginMode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        state: z.ZodType<RfqState | (string & {}), unknown, z.core.$ZodTypeInternals<RfqState | (string & {}), unknown>>;
+        stateVersion: z.ZodNumber;
+        acceptedSide: z.ZodOptional<z.ZodNullable<z.ZodType<"BUY" | "SELL" | (string & {}), unknown, z.core.$ZodTypeInternals<"BUY" | "SELL" | (string & {}), unknown>>>>;
+        lastLookDeadlineAtMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        view: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            viewVersion: z.ZodNumber;
+            bid: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                vwap: z.ZodString;
+                availableQuantity: z.ZodString;
+                grossVwap: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                estimatedMonacoFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                estimatedBuilderFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                estimatedTotalFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                book: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    vwap: z.ZodString;
+                    grossVwap: z.ZodString;
+                    asOfMs: z.ZodNumber;
+                    levels: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            ask: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                vwap: z.ZodString;
+                availableQuantity: z.ZodString;
+                grossVwap: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                estimatedMonacoFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                estimatedBuilderFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                estimatedTotalFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                book: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    vwap: z.ZodString;
+                    grossVwap: z.ZodString;
+                    asOfMs: z.ZodNumber;
+                    levels: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            asOfMs: z.ZodNumber;
+            monacoFeeCbps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            builderFeeCbps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+        ownQuote: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            rfqId: z.ZodString;
+            quoteId: z.ZodString;
+            version: z.ZodNumber;
+            bid: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                price: z.ZodString;
+                capacity: z.ZodString;
+            }, z.core.$strip>>>;
+            ask: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                price: z.ZodString;
+                capacity: z.ZodString;
+            }, z.core.$strip>>>;
+            issuedAtMs: z.ZodNumber;
+            validUntilMs: z.ZodNumber;
+            leverage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marginMode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            refusedSides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                side: z.ZodType<"ASK" | "BID" | (string & {}), unknown, z.core.$ZodTypeInternals<"ASK" | "BID" | (string & {}), unknown>>;
+                code: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>>;
+        ownSelection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            acceptanceId: z.ZodString;
+            takerSide: z.ZodOptional<z.ZodNullable<z.ZodType<"BUY" | "SELL" | (string & {}), unknown, z.core.$ZodTypeInternals<"BUY" | "SELL" | (string & {}), unknown>>>>;
+            quoteId: z.ZodString;
+            quoteVersion: z.ZodNumber;
+            quantity: z.ZodString;
+            frozenTerms: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                price: z.ZodString;
+                capacity: z.ZodString;
+            }, z.core.$strip>>>;
+            lastLookDeadlineAtMs: z.ZodNumber;
+            monacoFeeCbps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxBuilderFeeCbps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            estimatedNet: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        ownLatestVersion: z.ZodNumber;
+        ownQuoteWithdrawn: z.ZodBoolean;
+        outcome: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            executedQuantity: z.ZodString;
+            unfilledQuantity: z.ZodString;
+            vwap: z.ZodString;
+            fills: z.ZodArray<z.ZodObject<{
+                executionId: z.ZodString;
+                price: z.ZodString;
+                quantity: z.ZodString;
+                fee: z.ZodString;
+                monacoFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                builderFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            allInVwap: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            bookAtFill: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                vwap: z.ZodString;
+                grossVwap: z.ZodString;
+                asOfMs: z.ZodNumber;
+                levels: z.ZodNumber;
+            }, z.core.$strip>>>;
+            bookAtFillFullSize: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        durableSequence: z.ZodNumber;
+        ownFills: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            executionId: z.ZodString;
+            price: z.ZodString;
+            quantity: z.ZodString;
+            fee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            monacoFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            builderFee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>>;
+        acceptance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            viewVersion: z.ZodNumber;
+            acceptedAtMs: z.ZodNumber;
+            vwap: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            grossVwap: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            availableQuantity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            monacoFeeCbps: z.ZodNumber;
+            builderFeeCbps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            book: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                vwap: z.ZodString;
+                grossVwap: z.ZodString;
+                asOfMs: z.ZodNumber;
+                levels: z.ZodNumber;
+            }, z.core.$strip>>>;
+            bookFullSize: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodString;
+}, z.core.$strip>;
 /** A market RFQ is offered on. */
 export declare const RfqMarketCapabilitySchema: z.ZodObject<{
     tradingPairId: z.ZodString;
@@ -385,6 +526,7 @@ export type RfqQuoteVersion = z.infer<typeof RfqQuoteVersionSchema>;
 export type RfqRefusedSide = z.infer<typeof RfqRefusedSideSchema>;
 export type RfqMakerSelection = z.infer<typeof RfqMakerSelectionSchema>;
 export type RfqStatus = z.infer<typeof RfqStatusSchema>;
+export type ListRfqsResponse = z.infer<typeof ListRfqsResponseSchema>;
 export type RfqMarketCapability = z.infer<typeof RfqMarketCapabilitySchema>;
 export type GetRfqCapabilitiesResponse = z.infer<typeof GetRfqCapabilitiesResponseSchema>;
 export type WithdrawRfqQuoteResponse = z.infer<typeof WithdrawRfqQuoteResponseSchema>;

package/dist/rfq/responses.js

@@ -233,6 +233,13 @@ export const RfqStatusSchema = z.object({
     /** Taker only: what your view showed when you accepted. */
     acceptance: RfqAcceptanceRecordSchema.nullish(),
 });
+/** A page of your RFQs as the taker, newest first. */
+export const ListRfqsResponseSchema = z.object({
+    /** Each as `getRfq` gives it to the taker, without the live `view`. */
+    rfqs: z.array(RfqStatusSchema),
+    /** Pass as `pageToken` for the next page; empty once there are no more. */
+    nextPageToken: z.string(),
+});
 /** A market RFQ is offered on. */
 export const RfqMarketCapabilitySchema = z.object({
     tradingPairId: z.string(),

package/dist/sdk/index.d.ts

@@ -161,11 +161,29 @@ export interface MonacoSDK {
             pageSize?: number;
             /** Cursor from a previous response's `nextPageToken`; omit to start */
             pageToken?: string;
+            /** The execution source to keep: RFQ block fills or order-book fills (each trade's `data.executionSource`); omit for every fill. */
+            executionSource?: "RFQ" | "CLOB";
         }) => Promise<{
             trades: TradeEvent[];
             /** Empty exactly when the walk is finished. */
             nextPageToken: string;
         }>;
+        /**
+         * The RFQ block prints a `rfqTrades` subscriber missed, oldest first: pages
+         * the pair's RFQ history newest first until `sinceExecutionId`.
+         * `complete` is `false` when `maxPages` ran out first.
+         */
+        recoverRfqTrades: (tradingPairId: string, options?: {
+            /** The newest `executionId` already seen; omit to read only the newest page. */
+            sinceExecutionId?: string;
+            /** Rows per page (default: 100, max: 1000) */
+            pageSize?: number;
+            /** Most pages to read (default: 10) */
+            maxPages?: number;
+        }) => Promise<{
+            trades: TradeEvent[];
+            complete: boolean;
+        }>;
         /**
          * One page of the trade feed: every market, newest first, or only the
          * trades one application took (`takerApplicationId`). Public and rate

package/dist/validation/applications.d.ts

@@ -1,7 +1,7 @@
 /**
  * Public application listing validation schemas
  *
- * The four reporting listings are cursor paged (0XM-2822). Each schema
+ * The five reporting listings are cursor paged (0XM-2822). Each schema
  * REJECTS `page` rather than omitting it: forwarding the params field by
  * field drops a stray `page` before it reaches the wire, which means a
  * JavaScript or `any` caller looping on `{ page: n }` would be handed the
@@ -49,3 +49,10 @@ export declare const ListAppBalancesSchema: z.ZodObject<{
     userId: z.ZodOptional<z.ZodUUID>;
     assetId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
+export declare const ListAppMarginAccountsSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    page: z.ZodOptional<z.ZodNever>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/validation/applications.js

@@ -1,7 +1,7 @@
 /**
  * Public application listing validation schemas
  *
- * The four reporting listings are cursor paged (0XM-2822). Each schema
+ * The five reporting listings are cursor paged (0XM-2822). Each schema
  * REJECTS `page` rather than omitting it: forwarding the params field by
  * field drops a stray `page` before it reaches the wire, which means a
  * JavaScript or `any` caller looping on `{ page: n }` would be handed the
@@ -12,6 +12,7 @@
  */
 import { z } from "zod";
 import { UUIDSchema } from "./trading";
+import { AddressSchema } from "./vault";
 /** A client ID is required; `page` is gone; a page size is bounded; a cursor may be `""` to start. */
 const AppCursorPaginationSchema = z.object({
     /** The application's public client ID; the listings are selected by it. */
@@ -43,3 +44,6 @@ export const ListAppBalancesSchema = AppCursorPaginationSchema.extend({
     userId: UUIDSchema.optional(),
     assetId: UUIDSchema.optional(),
 });
+export const ListAppMarginAccountsSchema = AppCursorPaginationSchema.extend({
+    address: AddressSchema.optional(),
+});

package/dist/validation/market.d.ts

@@ -246,26 +246,14 @@ export declare const ListAllFundingHistorySchema: z.ZodObject<{
         DESC: "DESC";
     }>>;
 }, z.core.$strip>;
-/**
- * Public trades-feed listing validation schema.
- *
- * Cursor paged (0XM-2821). `page` is REJECTED rather than omitted, but NOT for
- * the same reason as {@link ListFundingHistorySchema}. That one is built on a
- * query builder that serializes whatever keys the params object carries, so a
- * leftover `page` reaches the wire and comes back as the server's `400`.
- * `getTrades` instead sets `pageSize` and `pageToken` explicitly, so a stray
- * `page` never leaves the client at all — which makes rejecting it more
- * important here, not less. Stripped silently, it would leave the caller
- * requesting page 2, 3, 4 and receiving the FIRST cursor page every time, with
- * no error from either side to reveal the loop. `z.never()` turns that silent
- * non-advancing walk into an immediate `ValidationError`.
- *
- * The ceiling is the cursor-mode 1000; the historical default of 25 stays.
- */
 export declare const GetTradesSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
+    executionSource: z.ZodOptional<z.ZodEnum<{
+        CLOB: "CLOB";
+        RFQ: "RFQ";
+    }>>;
 }, z.core.$strip>;
 /** Options for the every-market trade feed (`listTrades`). */
 export declare const ListTradesSchema: z.ZodObject<{

package/dist/validation/market.js

@@ -262,12 +262,16 @@ export const ListAllFundingHistorySchema = FundingHistoryCursorSchema;
  *
  * The ceiling is the cursor-mode 1000; the historical default of 25 stays.
  */
-export const GetTradesSchema = z.object({
+const TradesPageSchema = z.object({
     page: z.never().optional(),
     pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
 });
+export const GetTradesSchema = TradesPageSchema.extend({
+    /** The execution source to keep (RFQ-15). */
+    executionSource: z.enum(["RFQ", "CLOB"]).optional(),
+});
 /** Options for the every-market trade feed (`listTrades`). */
-export const ListTradesSchema = GetTradesSchema.extend({
+export const ListTradesSchema = TradesPageSchema.extend({
     takerApplicationId: UUIDSchema.optional(),
 });

package/dist/validation/rfq.d.ts

@@ -62,6 +62,11 @@ export declare const CancelRfqSchema: z.ZodObject<{
     idempotencyKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /** Params for placing or replacing a quote: a bid, an ask or both. */
+/** `listRfqs` paging: 1 to 100 per page, and the previous page's token. */
+export declare const ListRfqsSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const UpsertRfqQuoteSchema: z.ZodObject<{
     expectedVersion: z.ZodNumber;
     bid: z.ZodOptional<z.ZodObject<{