@0xmonaco/types 1.1.2 → 1.1.5

package/dist/fees/responses.js

@@ -107,7 +107,7 @@ export const GetMyFeeTierParamsSchema = z.object({
 export const FeeTierScheduleRowSchema = z.object({
     /** Tier level, 1 (lowest volume) through 6 (highest) */
     tierLevel: z.number().int(),
-    /** Weighted 14-day volume floor for this tier, in quote/USD units */
+    /** Minimum weighted 14-day volume for this tier, in quote/USD units */
     minVolumeThreshold: z.string(),
     /** Maker fee in human basis points; negative is a rebate */
     makerFeeBps: z.string(),
@@ -118,7 +118,7 @@ export const FeeTierScheduleRowSchema = z.object({
  * Zod schema for the "my fee tier" response
  */
 export const GetMyFeeTierResponseSchema = z.object({
-    /** Caller's resolved tier (1–6) from the higher of their wallet's weighted 14-day volume and any volume floor set on the wallet. A floor that is set or changed counts once it applies to the wallet's fills, usually within a minute, and likewise for an account the wallet opens in a new application; a removed or expired floor stops counting at once */
+    /** Caller's resolved tier (1–6) from their wallet's recorded weighted 14-day volume */
     currentTierLevel: z.number().int(),
     /** Caller's weighted 14-day volume (perp + 2.5× spot), summed across every application the wallet trades through */
     weightedVolume14d: z.string(),

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/market/index.d.ts

@@ -54,9 +54,25 @@ export interface TradingPair {
      * `CROSS_MARGIN_NOT_ALLOWED`; open the position with `marginMode: "ISOLATED"`.
      */
     isolatedOnly: boolean;
-    /** Maker fee in basis points */
+    /**
+     * Flat pair-level maker fee in basis points (negative = rebate).
+     *
+     * @deprecated Not the rate an order is charged: fees are tiered per account.
+     * Use `fees.getFeeSchedule(tradingPairId)` for the pair's tier schedule,
+     * `fees.getMyFeeTier({ tradingPairId })` for your own rate, and
+     * `placementMakerFeeBps` on an order for the rate it was placed at. This
+     * field will be removed in a later release.
+     */
     makerFeeBps: number;
-    /** Taker fee in basis points */
+    /**
+     * Flat pair-level taker fee in basis points.
+     *
+     * @deprecated Not the rate an order is charged: fees are tiered per account.
+     * Use `fees.getFeeSchedule(tradingPairId)` for the pair's tier schedule,
+     * `fees.getMyFeeTier({ tradingPairId })` for your own rate, and
+     * `placementTakerFeeBps` on an order for the rate it was placed at. This
+     * field will be removed in a later release.
+     */
     takerFeeBps: number;
     /** Minimum order size */
     minOrderSize: string;
@@ -693,6 +709,10 @@ export interface LiquidationHistoryEvent {
     /** Position size × event-time mark price, in quote-asset units. */
     markNotional: string;
     quoteAssetSymbol: string;
+    /** The position's liquidation (trigger) price captured with the event, in quote units per base unit. */
+    liquidationPrice: string;
+    /** Liquidation penalty charged on the event, in quote-asset units; null when none was charged. */
+    liquidationFee?: string | null;
 }
 export interface ListLiquidationEventsResponse {
     tradingPairId: string;
@@ -701,6 +721,27 @@ export interface ListLiquidationEventsResponse {
     pageSize: number;
     nextPageToken: string;
 }
+/** Query for {@link MarketAPI.listAllLiquidationEvents}: the per-pair listing's window and cursor. */
+export type ListAllLiquidationEventsParams = ListLiquidationEventsParams;
+export interface ListAllLiquidationEventsResponse {
+    /** Events across every market, newest first; each carries its tradingPairId. */
+    events: LiquidationHistoryEvent[];
+    pageSize: number;
+    /** Cursor for the next page; empty when the walk is finished. */
+    nextPageToken: string;
+}
+/** One asset's insurance fund. Scale the balance with the asset's decimals from the trading pairs listing. */
+export interface InsuranceFund {
+    assetId: string;
+    /** Balance available to cover bad debt, in raw asset units (the asset's smallest unit). */
+    availableBalanceRaw: string;
+    /** When the balance last changed (ISO 8601). */
+    updatedAt: string;
+}
+export interface ListInsuranceFundsResponse {
+    /** Every insurance fund, one per asset. */
+    funds: InsuranceFund[];
+}
 export type LiquidationMetricsInterval = "1m" | "5m" | "1h";
 export interface GetLiquidationMetricsParams {
     interval: LiquidationMetricsInterval;
@@ -817,4 +858,12 @@ export interface MarketAPI extends BaseAPI {
     listLiquidationEvents(tradingPairId: string, params?: ListLiquidationEventsParams): Promise<ListLiquidationEventsResponse>;
     /** Fetch bounded UTC-aligned long/short liquidation totals by side. */
     getLiquidationMetrics(tradingPairId: string, params: GetLiquidationMetricsParams): Promise<LiquidationMetrics>;
+    /**
+     * Fetch liquidation events across every market, newest first, with the same
+     * window and keyset cursor as listLiquidationEvents. Public; each client IP
+     * has a read budget.
+     */
+    listAllLiquidationEvents(params?: ListAllLiquidationEventsParams): Promise<ListAllLiquidationEventsResponse>;
+    /** Fetch every insurance fund's current balance, one per asset. Public; each client IP has a read budget. */
+    listInsuranceFunds(): Promise<ListInsuranceFundsResponse>;
 }

package/dist/profile/index.d.ts

@@ -602,9 +602,22 @@ export interface UserProfile {
     accountType: string;
     /** Whether the user can withdraw funds */
     canWithdraw: boolean;
-    /** Taker fee rate in basis points */
+    /**
+     * Flat taker fee in basis points, echoed from a trading pair.
+     *
+     * @deprecated Not the rate you are charged: fees are tiered per account. Use
+     * `fees.getMyFeeTier({ tradingPairId })` for your own rate. This field will
+     * be removed in a later release.
+     */
     takerFeeBps: number;
-    /** Maker fee rate in basis points */
+    /**
+     * Flat maker fee in basis points (negative = rebate), echoed from a trading
+     * pair.
+     *
+     * @deprecated Not the rate you are charged: fees are tiered per account. Use
+     * `fees.getMyFeeTier({ tradingPairId })` for your own rate. This field will
+     * be removed in a later release.
+     */
     makerFeeBps: number;
     /** Account creation timestamp (ISO string) */
     createdAt: string;

package/dist/rfq/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * RFQ (block trading) Types
+ *
+ * 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`.
+ */
+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";
+/**
+ * RFQ API.
+ *
+ * Every call is signed and acts for the session's account. Every write takes
+ * an `idempotencyKey` (generated when omitted): a retry with the same key and
+ * body returns the first result, and the SDK resends a write whose outcome is
+ * unknown with the same key. Maker writes (quote, withdraw, last look) are
+ * stored with the request exactly as signed.
+ */
+export interface RfqAPI extends BaseAPI {
+    /** Your RFQ limits and the markets RFQ is offered on. */
+    getCapabilities(): Promise<GetRfqCapabilitiesResponse>;
+    /** Request quotes for up to `quantity`. Omit `side` for a two-way RFQ. Delegated agents cannot. */
+    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 (`view.viewVersion`). Binding. */
+    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), naming your current version. */
+    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, before the last-look deadline. */
+    respondLastLook(rfqId: string, params: RespondRfqLastLookParams): Promise<RespondRfqLastLookResponse>;
+}
+export * from "./responses";

package/dist/rfq/index.js

@@ -0,0 +1,10 @@
+/**
+ * RFQ (block trading) Types
+ *
+ * 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`.
+ */
+export * from "./responses";

package/dist/rfq/responses.d.ts

@@ -0,0 +1,246 @@
+/**
+ * RFQ (block trading) response types.
+ *
+ * Zod schemas for every RFQ REST/gRPC response, with the inferred TypeScript
+ * types. The REST API returns camelCase JSON; an optional field the server has
+ * no value for may arrive as `null` or be absent, so optional fields are typed
+ * `T | null | undefined` (`.nullish()`). Prices, quantities and fees are exact
+ * decimal strings; versions and `*Ms` times are JSON numbers (times are Unix
+ * milliseconds).
+ *
+ * Label fields (states, sides, products) are typed `Union | (string & {})`:
+ * the unions name the values the server sends today, and the schemas accept
+ * any string so a value added server-side later does not fail parsing.
+ */
+import { z } from "zod";
+/** An RFQ's lifecycle state. */
+export type RfqState = "COLLECTING" | "LAST_LOOK" | "RISK_CLEARING" | "CONFIRMED" | "SETTLED" | "CANCELLED" | "EXPIRED" | "REJECTED";
+/** A quote's price (quote units per base unit) and capacity (base units). */
+export declare const RfqQuoteTermsResponseSchema: z.ZodObject<{
+    price: z.ZodString;
+    capacity: z.ZodString;
+}, z.core.$strip>;
+/** The request as created. */
+export declare const RfqRequestTermsSchema: 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>;
+/** One side of the taker's view: the allocation that would fill the quantity. */
+export declare const RfqSideViewSchema: z.ZodObject<{
+    vwap: z.ZodString;
+    availableQuantity: z.ZodString;
+}, z.core.$strip>;
+/** The taker's current view of the quotes. */
+export declare const RfqViewSchema: z.ZodObject<{
+    viewVersion: z.ZodNumber;
+    bid: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        vwap: z.ZodString;
+        availableQuantity: z.ZodString;
+    }, z.core.$strip>>>;
+    ask: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        vwap: z.ZodString;
+        availableQuantity: z.ZodString;
+    }, z.core.$strip>>>;
+    asOfMs: z.ZodNumber;
+}, z.core.$strip>;
+/** One fill of an executed RFQ. */
+export declare const RfqFillSchema: z.ZodObject<{
+    executionId: z.ZodString;
+    price: z.ZodString;
+    quantity: z.ZodString;
+    fee: z.ZodString;
+}, z.core.$strip>;
+/** What an accepted RFQ executed. */
+export declare const RfqOutcomeSchema: 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;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** A quoted side the venue refused; nothing is reserved for it. */
+export declare const RfqRefusedSideSchema: 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>;
+/** A quote version as its maker sees it. */
+export declare const RfqQuoteVersionSchema: 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>;
+/** A selected maker's own part of an acceptance, for answering last look. */
+export declare const RfqMakerSelectionSchema: 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;
+}, z.core.$strip>;
+/**
+ * Authoritative RFQ status. A taker sees `view` and `outcome`; a maker sees
+ * its own latest quote and, once selected, its own selection.
+ */
+export declare const RfqStatusSchema: 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;
+        }, z.core.$strip>>>;
+        ask: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            vwap: z.ZodString;
+            availableQuantity: z.ZodString;
+        }, z.core.$strip>>>;
+        asOfMs: 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;
+    }, 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;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    durableSequence: z.ZodNumber;
+}, z.core.$strip>;
+/** A market RFQ is offered on. */
+export declare const RfqMarketCapabilitySchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+    product: z.ZodOptional<z.ZodNullable<z.ZodType<"PERPETUAL" | "SPOT" | (string & {}), unknown, z.core.$ZodTypeInternals<"PERPETUAL" | "SPOT" | (string & {}), unknown>>>>;
+    minQuantity: z.ZodString;
+    maxQuantity: z.ZodString;
+}, z.core.$strip>;
+/** Your RFQ limits and the markets RFQ is offered on. */
+export declare const GetRfqCapabilitiesResponseSchema: z.ZodObject<{
+    protocolVersion: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    markets: z.ZodArray<z.ZodObject<{
+        tradingPairId: z.ZodString;
+        product: z.ZodOptional<z.ZodNullable<z.ZodType<"PERPETUAL" | "SPOT" | (string & {}), unknown, z.core.$ZodTypeInternals<"PERPETUAL" | "SPOT" | (string & {}), unknown>>>>;
+        minQuantity: z.ZodString;
+        maxQuantity: z.ZodString;
+    }, z.core.$strip>>;
+    requestWindowMs: z.ZodNumber;
+    minQuoteValidityMs: z.ZodNumber;
+    maxQuoteValidityMs: z.ZodNumber;
+    lastLookMs: z.ZodNumber;
+    maxNewRfqs: z.ZodNumber;
+    quotaWindowMs: z.ZodNumber;
+    quotaRemaining: z.ZodNumber;
+    quotaRetryAfterMs: z.ZodNumber;
+}, z.core.$strip>;
+/** A withdrawn quote: the withdrawal's version. */
+export declare const WithdrawRfqQuoteResponseSchema: z.ZodObject<{
+    rfqId: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+/** A recorded last-look answer. */
+export declare const RespondRfqLastLookResponseSchema: z.ZodObject<{
+    acceptanceId: z.ZodString;
+    response: z.ZodOptional<z.ZodNullable<z.ZodType<"IMPROVE" | "REJECT" | (string & {}), unknown, z.core.$ZodTypeInternals<"IMPROVE" | "REJECT" | (string & {}), unknown>>>>;
+    recordedAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type RfqRequestTerms = z.infer<typeof RfqRequestTermsSchema>;
+export type RfqSideView = z.infer<typeof RfqSideViewSchema>;
+export type RfqView = z.infer<typeof RfqViewSchema>;
+export type RfqFill = z.infer<typeof RfqFillSchema>;
+export type RfqOutcome = z.infer<typeof RfqOutcomeSchema>;
+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 RfqMarketCapability = z.infer<typeof RfqMarketCapabilitySchema>;
+export type GetRfqCapabilitiesResponse = z.infer<typeof GetRfqCapabilitiesResponseSchema>;
+export type WithdrawRfqQuoteResponse = z.infer<typeof WithdrawRfqQuoteResponseSchema>;
+export type RespondRfqLastLookResponse = z.infer<typeof RespondRfqLastLookResponseSchema>;

package/dist/rfq/responses.js

@@ -0,0 +1,167 @@
+/**
+ * RFQ (block trading) response types.
+ *
+ * Zod schemas for every RFQ REST/gRPC response, with the inferred TypeScript
+ * types. The REST API returns camelCase JSON; an optional field the server has
+ * no value for may arrive as `null` or be absent, so optional fields are typed
+ * `T | null | undefined` (`.nullish()`). Prices, quantities and fees are exact
+ * decimal strings; versions and `*Ms` times are JSON numbers (times are Unix
+ * milliseconds).
+ *
+ * Label fields (states, sides, products) are typed `Union | (string & {})`:
+ * the unions name the values the server sends today, and the schemas accept
+ * any string so a value added server-side later does not fail parsing.
+ */
+import { z } from "zod";
+/** A string schema typed as a known-value union that still admits unknown values. */
+function openUnion() {
+    return z.string();
+}
+/** A quote's price (quote units per base unit) and capacity (base units). */
+export const RfqQuoteTermsResponseSchema = z.object({
+    price: z.string(),
+    capacity: z.string(),
+});
+/** The request as created. */
+export const RfqRequestTermsSchema = z.object({
+    rfqId: z.string(),
+    tradingPairId: z.string(),
+    /** `SPOT` or `PERPETUAL`. */
+    product: openUnion().nullish(),
+    /** Maximum base quantity; not a guaranteed fill. */
+    quantity: z.string(),
+    createdAtMs: z.number(),
+    /** No new quotes after it. */
+    deadlineAtMs: z.number(),
+    /** The taker's side, `BUY` or `SELL`, for a one-way RFQ (makers see it too); absent for a two-way RFQ. */
+    side: openUnion().nullish(),
+    /**
+     * The side makers quote on a one-way RFQ, the one that fills the taker:
+     * `ASK` (an offer) when it buys, `BID` when it sells; a quote on the other
+     * side is refused. Absent for a two-way RFQ.
+     */
+    quoteSide: openUnion().nullish(),
+    /** Taker only: the leverage given on create (perpetuals). */
+    leverage: z.string().nullish(),
+    /** Taker only: the margin mode given on create (perpetuals). */
+    marginMode: z.string().nullish(),
+});
+/** One side of the taker's view: the allocation that would fill the quantity. */
+export const RfqSideViewSchema = z.object({
+    /** All-in volume-weighted price, fees included. */
+    vwap: z.string(),
+    availableQuantity: z.string(),
+});
+/** The taker's current view of the quotes. */
+export const RfqViewSchema = z.object({
+    /** The version to accept; a newer view refuses an older one. */
+    viewVersion: z.number(),
+    bid: RfqSideViewSchema.nullish(),
+    ask: RfqSideViewSchema.nullish(),
+    asOfMs: z.number(),
+});
+/** One fill of an executed RFQ. */
+export const RfqFillSchema = z.object({
+    executionId: z.string(),
+    price: z.string(),
+    quantity: z.string(),
+    fee: z.string(),
+});
+/** What an accepted RFQ executed. */
+export const RfqOutcomeSchema = z.object({
+    executedQuantity: z.string(),
+    unfilledQuantity: z.string(),
+    vwap: z.string(),
+    fills: z.array(RfqFillSchema),
+});
+/** A quoted side the venue refused; nothing is reserved for it. */
+export const RfqRefusedSideSchema = z.object({
+    side: openUnion(),
+    /** INSUFFICIENT_BALANCE or QUOTE_REJECTED. */
+    code: z.string(),
+    reason: z.string(),
+});
+/** A quote version as its maker sees it. */
+export const RfqQuoteVersionSchema = z.object({
+    rfqId: z.string(),
+    quoteId: z.string(),
+    /** This version; name it to replace or withdraw. */
+    version: z.number(),
+    bid: RfqQuoteTermsResponseSchema.nullish(),
+    ask: RfqQuoteTermsResponseSchema.nullish(),
+    issuedAtMs: z.number(),
+    validUntilMs: z.number(),
+    /** Perpetuals: the leverage the quote's orders reserve with. */
+    leverage: z.string().nullish(),
+    /** Perpetuals: ISOLATED or CROSS. */
+    marginMode: z.string().nullish(),
+    /**
+     * Quoted sides the venue refused. The version holds only the funded sides;
+     * when none is funded the quote is refused instead.
+     */
+    refusedSides: z.array(RfqRefusedSideSchema).nullish(),
+});
+/** A selected maker's own part of an acceptance, for answering last look. */
+export const RfqMakerSelectionSchema = z.object({
+    acceptanceId: z.string(),
+    /** The taker's side. */
+    takerSide: openUnion().nullish(),
+    quoteId: z.string(),
+    quoteVersion: z.number(),
+    quantity: z.string(),
+    frozenTerms: RfqQuoteTermsResponseSchema.nullish(),
+    lastLookDeadlineAtMs: z.number(),
+});
+/**
+ * Authoritative RFQ status. A taker sees `view` and `outcome`; a maker sees
+ * its own latest quote and, once selected, its own selection.
+ */
+export const RfqStatusSchema = z.object({
+    terms: RfqRequestTermsSchema.nullish(),
+    state: openUnion(),
+    stateVersion: z.number(),
+    acceptedSide: openUnion().nullish(),
+    lastLookDeadlineAtMs: z.number().nullish(),
+    view: RfqViewSchema.nullish(),
+    ownQuote: RfqQuoteVersionSchema.nullish(),
+    ownSelection: RfqMakerSelectionSchema.nullish(),
+    /** The `expectedVersion` for your next quote or withdrawal. */
+    ownLatestVersion: z.number(),
+    ownQuoteWithdrawn: z.boolean(),
+    outcome: RfqOutcomeSchema.nullish(),
+    durableSequence: z.number(),
+});
+/** A market RFQ is offered on. */
+export const RfqMarketCapabilitySchema = z.object({
+    tradingPairId: z.string(),
+    product: openUnion().nullish(),
+    minQuantity: z.string(),
+    maxQuantity: z.string(),
+});
+/** Your RFQ limits and the markets RFQ is offered on. */
+export const GetRfqCapabilitiesResponseSchema = z.object({
+    protocolVersion: z.number(),
+    /** Whether RFQ is enabled for you. */
+    enabled: z.boolean(),
+    markets: z.array(RfqMarketCapabilitySchema),
+    requestWindowMs: z.number(),
+    minQuoteValidityMs: z.number(),
+    maxQuoteValidityMs: z.number(),
+    lastLookMs: z.number(),
+    /** RFQs you may create per quota window. */
+    maxNewRfqs: z.number(),
+    quotaWindowMs: z.number(),
+    quotaRemaining: z.number(),
+    quotaRetryAfterMs: z.number(),
+});
+/** A withdrawn quote: the withdrawal's version. */
+export const WithdrawRfqQuoteResponseSchema = z.object({
+    rfqId: z.string(),
+    version: z.number(),
+});
+/** A recorded last-look answer. */
+export const RespondRfqLastLookResponseSchema = z.object({
+    acceptanceId: z.string(),
+    response: openUnion().nullish(),
+    recordedAtMs: z.number(),
+});

package/dist/sdk/index.d.ts

@@ -14,6 +14,7 @@ import type { PortfolioAPI } from "../portfolio";
 import type { PositionsAPI } from "../positions";
 import type { ProfileAPI } from "../profile";
 import type { PulseAPI } from "../pulse";
+import type { RfqAPI } from "../rfq";
 import type { SubAccountsAPI } from "../sub-accounts";
 import type { SweeperAPI } from "../sweeper";
 import type { TraderCodesAPI } from "../tradercodes";
@@ -120,6 +121,8 @@ export interface MonacoSDK {
     buildercodes: BuildercodesAPI;
     /** Copy trading API: lead trader profiles and the leaderboard, and your follows */
     copyTrading: CopyTradingAPI;
+    /** RFQ (block trading) API: request and accept quotes as taker, quote and answer last look as maker */
+    rfq: RfqAPI;
     /** Testnet faucet API */
     faucet: FaucetAPI;
     /** Deposit-address registration (sweeper) API; requires a session */
@@ -138,7 +141,7 @@ export interface MonacoSDK {
             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' type, quantities are multiplied by the quote price. */
             denomination?: OrderbookQuotationMode;
@@ -160,6 +163,23 @@ export interface MonacoSDK {
             /** Empty exactly when the walk is finished. */
             nextPageToken: string;
         }>;
+        /**
+         * One page of the trade feed: every market, newest first, or only the
+         * trades one application took (`takerApplicationId`). Public and rate
+         * limited per client IP; follow `nextPageToken` until it is empty.
+         */
+        listTrades: (options?: {
+            /** Only the trades this application (frontend) took, as the taker's application. */
+            takerApplicationId?: string;
+            /** Maximum number of records to return (default: 25, max: 1000) */
+            pageSize?: number;
+            /** Cursor from a previous response's `nextPageToken`; omit to start */
+            pageToken?: string;
+        }) => Promise<{
+            trades: TradeEvent[];
+            /** Empty exactly when the walk is finished. */
+            nextPageToken: string;
+        }>;
     };
     /** WebSocket client for real-time data — the full typed channel surface of {@link MonacoWebSocket} */
     ws: MonacoWebSocket;