@0xmonaco/types 1.1.5-prerelease.de852e2 → 1.1.6

package/README.md

@@ -237,8 +237,6 @@ interface TradingPair {
   marketType: TradingMode;
   category: string;
   isActive: boolean;
-  makerFeeBps: number;
-  takerFeeBps: number;
   minOrderSize: string;
   maxOrderSize: string;
   quantityStepSize: string;

package/dist/analytics/builders.d.ts

@@ -34,6 +34,8 @@ export interface BuilderApplication {
     additionalTakerFeeBps: number;
     /** Maker add-on the application charges, in basis points. */
     additionalMakerFeeBps: number;
+    /** Whether this is the exchange's default application: the one a sign-in that names no client id is placed under. */
+    isDefault: boolean;
 }
 /** A builder's identity. */
 export interface Builder {
@@ -70,6 +72,12 @@ export interface BuilderFigures {
     takerFeesUsd: string;
     /** Maker add-ons on the trades it made, whoever took them. */
     makerFeesUsd: string;
+    /** USDC deposited through the builder's applications, in USD (1:1); other tokens are unvalued. */
+    depositsUsd: string;
+    /** USDC withdrawals the builder's applications initiated, in USD (1:1); attributed by the initiating application. */
+    withdrawalsUsd: string;
+    /** `depositsUsd` less `withdrawalsUsd`; negative when more left than arrived. */
+    netFlowUsd: string;
 }
 /** Every displayed builder, by name. */
 export interface ListBuildersResponse {
@@ -107,10 +115,17 @@ export interface ListBuilderLeaderboardParams extends AnalyticsWindowParams {
     /** Builders to return, largest volume first (1-100, default 25). */
     limit?: number;
 }
-/** One builder's row on the leaderboard; a display group ranks as one. */
+/** One builder's row on the leaderboard; a display group ranks as one. A builder that only took deposits ranks with zero volume. */
 export interface BuilderLeaderboardRow extends BuilderFigures {
     builder: Builder;
     newTraders: number;
+    /**
+     * Distinct taker wallets that traded through the builder, each once. With
+     * `window: "all"`, every wallet that ever traded through it. `null` for a
+     * window counted in hours that starts before the 90 days its hourly sets
+     * are kept.
+     */
+    activeTakers?: number | null;
 }
 /** Displayed builders ranked by volume over a window. */
 export interface ListBuilderLeaderboardResponse {

package/dist/analytics/index.d.ts

@@ -15,6 +15,11 @@
  * explorer displays only. Fees, active takers, new traders and per-market
  * volume count every trade. USD amounts are decimal strings (USDC 1:1).
  *
+ * Custody: deposits, withdrawals, net flow and total value locked count USDC
+ * only (1:1); other tokens are unvalued. A withdrawal counts when initiated.
+ * TVL is the USDC custody (deposits less initiated withdrawals, never below
+ * zero) at a point, `null` before any custody was folded.
+ *
  * NOTE: These endpoints are **public (unauthenticated)** and rate limited per
  * client IP.
  */
@@ -62,14 +67,31 @@ export interface ProtocolFigures {
     /** Wallets whose first trade through a builder fell inside, once per (builder, wallet), all builders included. */
     newTraders: number;
 }
+/** USDC custody flow over a window or one bucket, in USD (1:1). */
+export interface CustodyFlows {
+    /** USDC deposited. */
+    depositsUsd: string;
+    /** USDC withdrawals initiated. */
+    withdrawalsUsd: string;
+    /** `depositsUsd` less `withdrawalsUsd`; negative when more left than arrived. */
+    netFlowUsd: string;
+}
 /** Protocol totals over a window. */
-export interface GetProtocolTotalsResponse extends ProtocolFigures {
+export interface GetProtocolTotalsResponse extends ProtocolFigures, CustodyFlows {
     window: AnalyticsWindow;
+    /** Total value locked in USD at the end of the window (the end of the bucket holding `endTime`); `null` before any custody was folded. */
+    tvlUsd?: string | null;
+    /** Total value locked in USD at the start of the window; `tvlUsd` less this is the window's change. `null` before any custody was folded. */
+    openingTvlUsd?: string | null;
+    /** Distinct wallets that took a trade, received a deposit or were paid out a withdrawal initiated in the window (by payout address), each once. */
+    activeAccounts: number;
 }
 /** Protocol figures for one bucket. */
-export interface ProtocolSeriesPoint extends ProtocolFigures {
+export interface ProtocolSeriesPoint extends ProtocolFigures, CustodyFlows {
     /** Bucket start as Unix milliseconds (UTC; weeks start Monday). */
     bucketStart: number;
+    /** Total value locked in USD at the end of the bucket, carried across buckets without movement; `null` before any custody was folded. */
+    tvlUsd?: string | null;
 }
 /** Protocol figures per bucket over a window. */
 export interface GetProtocolSeriesResponse {
@@ -100,7 +122,7 @@ export interface ListMarketVolumesResponse {
 }
 /** The treasury's all-time net fees (not windowed). */
 export interface GetTreasuryNetFeesResponse {
-    /** Net protocol fees in USD: the treasury's net fee less BuilderCodes payouts and TraderCodes rewards; negative when payouts exceed fees. */
+    /** Net protocol fees in USD: the treasury's net protocol fee (taker fees less maker rebates) plus the insurance fund's liquidation fees, less BuilderCodes payouts and TraderCodes rewards; negative when payouts exceed fees. */
     netFeesUsd: string;
     /** When the first counted fee landed, as Unix milliseconds; null before any. */
     countingSince?: number | null;

package/dist/analytics/index.js

@@ -15,6 +15,11 @@
  * explorer displays only. Fees, active takers, new traders and per-market
  * volume count every trade. USD amounts are decimal strings (USDC 1:1).
  *
+ * Custody: deposits, withdrawals, net flow and total value locked count USDC
+ * only (1:1); other tokens are unvalued. A withdrawal counts when initiated.
+ * TVL is the USDC custody (deposits less initiated withdrawals, never below
+ * zero) at a point, `null` before any custody was folded.
+ *
  * NOTE: These endpoints are **public (unauthenticated)** and rate limited per
  * client IP.
  */

package/dist/analytics/wallets.d.ts

@@ -125,8 +125,12 @@ export interface GetTokenCustodyResponse {
 export interface VaultFeedParams {
     /** Rows per page (1-1000, default 50). */
     pageSize?: number;
-    /** Cursor from the previous page. */
+    /** Cursor from the previous page; bound to `token` and `wallet`. */
     pageToken?: string;
+    /** Only this token's rows: an asset symbol (any case), asset UUID or contract address. A token nothing answers to lists nothing. */
+    token?: string;
+    /** Only rows whose destination (the credited account, or a withdrawal's payout address) is this wallet. */
+    wallet?: string;
 }
 /** One deposit into the vault. */
 export interface VaultDeposit {

package/dist/market/index.d.ts

@@ -54,26 +54,6 @@ export interface TradingPair {
      * `CROSS_MARGIN_NOT_ALLOWED`; open the position with `marginMode: "ISOLATED"`.
      */
     isolatedOnly: boolean;
-    /**
-     * 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;
-    /**
-     * 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;
     /** Maximum order size */

package/dist/profile/index.d.ts

@@ -612,23 +612,6 @@ export interface UserProfile {
     accountType: string;
     /** Whether the user can withdraw funds */
     canWithdraw: boolean;
-    /**
-     * 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;
-    /**
-     * 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;
     /** Additional taker fee in basis points contributed by the application (if any) */

package/dist/rfq/responses.d.ts

@@ -129,6 +129,9 @@ export declare const RfqMakerSelectionSchema: z.ZodObject<{
         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>;
 /**
  * Authoritative RFQ status. A taker sees `view` and `outcome`; a maker sees
@@ -206,6 +209,9 @@ export declare const RfqStatusSchema: z.ZodObject<{
             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;

package/dist/rfq/responses.js

@@ -126,6 +126,20 @@ export const RfqMakerSelectionSchema = z.object({
     quantity: z.string(),
     frozenTerms: RfqQuoteTermsResponseSchema.nullish(),
     lastLookDeadlineAtMs: z.number(),
+    /** Your Monaco maker fee rate in centi-bps, frozen at acceptance; negative for a rebate. */
+    monacoFeeCbps: z.number().nullish(),
+    /**
+     * The MOST your frontend's builder add-on charges on this fill, in centi-bps:
+     * the rate stored on your quote order. A fill charges it or nothing, never
+     * more; an IMPROVE re-places the quote at the rate configured then.
+     */
+    maxBuilderFeeCbps: z.number().nullish(),
+    /**
+     * Estimated net at the selected quantity and frozen price, in the quote
+     * asset, at monacoFeeCbps plus the maximum add-on: the least you receive
+     * when selling, the most you pay when buying.
+     */
+    estimatedNet: z.string().nullish(),
 });
 /**
  * Authoritative RFQ status. A taker sees `view` and `outcome`; a maker sees

package/dist/trading/index.d.ts

@@ -156,7 +156,9 @@ export interface TradingAPI extends BaseAPI {
      */
     listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**
-     * Batch cancels specific orders by their IDs.
+     * Batch cancels specific orders by their IDs. Every ID gets one result, in
+     * request order; an ID that is not one of your live orders fails with
+     * `ORDER_NOT_FOUND`.
      * @param orderIds - Array of order IDs to cancel
      * @returns Promise resolving to the batch cancellation result
      */

package/dist/trading/responses.d.ts

@@ -284,7 +284,13 @@ export interface BatchCancelResult {
     error?: BatchCancelError;
 }
 /**
- * Response from batch cancelling orders
+ * Response from batch cancelling orders.
+ *
+ * For `batchCancel`, `results` holds one entry per requested ID, in request
+ * order (a repeated ID is answered at each occurrence), and
+ * `totalRequested === totalCancelled + totalFailed === results.length`. An ID
+ * that is not one of your live orders (unknown, another user's, or already
+ * terminal) is a failed entry with code `ORDER_NOT_FOUND`.
  */
 export interface BatchCancelOrdersResponse {
     /** Total number of orders requested to cancel */

package/dist/websocket/events/rfq-events.d.ts

@@ -42,9 +42,17 @@ export interface RfqRequestedEvent {
 }
 /** One side of the taker's view: the allocation that would fill the quantity. */
 export interface RfqSideViewEventData {
-    /** All-in volume-weighted price, the taker's fee included. */
+    /** All-in volume-weighted price, the taker's Monaco and builder fees included. */
     vwap: string;
     availableQuantity: string;
+    /** The volume-weighted price before fees. */
+    grossVwap?: string;
+    /** Estimated Monaco taker fee on `availableQuantity`, in the quote asset. */
+    estimatedMonacoFee?: string;
+    /** Estimated builder fee on `availableQuantity`, in the quote asset. */
+    estimatedBuilderFee?: string;
+    /** Estimated total taker fee on `availableQuantity`, in the quote asset. */
+    estimatedTotalFee?: string;
 }
 /** The taker's view of the quotes. No maker identity or individual quote. */
 export interface RfqViewEventData {
@@ -57,6 +65,10 @@ export interface RfqViewEventData {
     asOfMs: number;
     /** Pushes can arrive out of order: keep the view with the highest `sequence`. */
     sequence: number;
+    /** Your Monaco taker fee rate in this view, in centi-bps. */
+    monacoFeeCbps?: number;
+    /** Your frontend's builder fee rate in this view, in centi-bps; frozen when you accept. */
+    builderFeeCbps?: number;
 }
 /** To the taker: its view moved. */
 export interface RfqViewEvent {
@@ -82,6 +94,18 @@ export interface RfqSelectionEventData {
     makerFeeCbps: number;
     /** Reject or improve before this time; silence executes. */
     lastLookDeadlineAtMs: number;
+    /**
+     * The MOST your frontend's builder add-on charges on this fill, in centi-bps:
+     * the rate stored on your quote order. A fill charges it or nothing, never
+     * more; the receipt shows what was charged. Absent when it could not be read.
+     */
+    maxBuilderFeeCbps?: number;
+    /**
+     * Estimated net at `quantity` and `price`, in the quote asset, at
+     * `makerFeeCbps` plus `maxBuilderFeeCbps`: the least you receive when
+     * selling, the most you pay when buying. Absent with `maxBuilderFeeCbps`.
+     */
+    estimatedNet?: string;
 }
 /** To one selected maker: its last-look prompt. */
 export interface RfqSelectedEvent {
@@ -94,7 +118,12 @@ export interface RfqFillEventData {
     executionId: string;
     price: string;
     quantity: string;
+    /** Your whole taker fee on this fill: `monacoFee` plus `builderFee`. */
     fee: string;
+    /** The Monaco part of `fee`. */
+    monacoFee?: string;
+    /** The builder part of `fee`. */
+    builderFee?: string;
 }
 /** How an RFQ ended, for its taker. */
 export interface RfqOutcomeEventData {

package/dist/websocket/events/trade-events.d.ts

@@ -40,6 +40,12 @@ export interface TradeEventData {
     quoteVolumeRaw?: string;
     /** Application (frontend) that placed the taker order; trade volume and fees are attributed to it. REST trade reads only. */
     takerApplicationId?: string;
+    /**
+     * The taker's builder fee: the add-on the taker's application charged, in
+     * raw quote-asset units, on top of `takerFeeRaw`; `"0"` when it charged
+     * none. REST trade reads only.
+     */
+    builderFeeRaw?: string;
 }
 /**
  * Trade event emitted when a trade is executed

package/dist/wire/schema.d.ts

@@ -2938,8 +2938,17 @@ export interface paths {
          * Batch cancel specific orders
          * @description Batch cancel specific orders.
          *
-         *      Cancel multiple specific orders by their IDs. For canceling all orders,
-         *      use /batch-cancel-all or /batch-cancel-all/{tradingPairId}.
+         *      Cancel multiple specific orders by their IDs. Every requested ID gets one
+         *      entry in `results`, in request order (a repeated ID is answered at each
+         *      occurrence), and the totals count every requested ID, so
+         *      `totalRequested == totalCancelled + totalFailed`. An ID that is not one of
+         *      your live orders (unknown, another user's, or already filled or
+         *      cancelled) is a failed entry with code `ORDER_NOT_FOUND`. An order the
+         *      matching engine accepted is cancellable as soon as it is acknowledged.
+         *      A delegated session's cancel policy is checked against each order's
+         *      persisted fields: an ID with no persisted order yet is a failed entry
+         *      (`BAD_REQUEST`) and is not cancelled. For canceling all orders, use
+         *      /batch-cancel-all or /batch-cancel-all/{tradingPairId}.
          */
         post: operations["batch_cancel_orders"];
         delete?: never;
@@ -4680,22 +4689,23 @@ export interface components {
         BatchCancelOrdersResponse: {
             /**
              * Format: int32
-             * @description Number of orders requested to cancel
+             * @description Number of order IDs in the request, repeats included. Always equals totalCancelled + totalFailed and the length of results.
              * @example 5
              */
             totalRequested?: number | null;
             /**
              * Format: int32
-             * @description Number of orders successfully cancelled
+             * @description Number of results with cancelledAt and no error
              * @example 4
              */
             totalCancelled?: number | null;
             /**
              * Format: int32
-             * @description Number of cancellations that failed
+             * @description Number of results with an error, including IDs that are unknown or not yours (ORDER_NOT_FOUND)
              * @example 1
              */
             totalFailed?: number | null;
+            /** @description One result per requested order ID, in request order */
             results?: components["schemas"]["BatchCancelResult"][] | null;
         };
         BatchCancelResult: {
@@ -4899,7 +4909,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key: resubmitting after a lost response can execute a second time. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. Rejections split in two: an item rejected before acceptance (malformed, post-only would cross, handle conflict, a plain MARKET submit with no liquidity, rejected during pricing) fails only that item — a per-item error in an otherwise-successful response — emits no event and is never written to order history (an item rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent); an accepted LIMIT with IOC or FOK that cannot fill, or an accepted MARKET order whose apparent liquidity is invalidated by maker-risk revalidation, reports matchResult.status REJECTED in its result slot and emits OrderPlaced then OrderRejected, both carrying this value. Neither the batch's 2xx nor a populated result slot therefore means the order executed. Where no surface is conclusive, do not resubmit.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key: resubmitting after a lost response can execute a second time. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and events are not persisted for redelivery, so one can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. Rejections split in two: an item rejected before acceptance (malformed, post-only would cross, handle conflict, a plain MARKET submit with no liquidity, rejected during pricing) fails only that item — a per-item error in an otherwise-successful response — emits no event and is never written to order history (an item rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent); an accepted LIMIT with IOC or FOK that cannot fill, or an accepted MARKET order whose apparent liquidity is invalidated by maker-risk revalidation, reports matchResult.status REJECTED in its result slot and emits OrderPlaced then OrderRejected, both carrying this value. Neither the batch's 2xx nor a populated result slot therefore means the order executed. Where no surface is conclusive, do not resubmit.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -4986,7 +4996,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replace item carries no order type or time-in-force and its original must still be RESTING, so the IOC/FOK and MARKET post-acceptance rejection shapes are unreachable here. Failures split by WHEN they occur, and the difference decides whether your original survives. Before sequencing: every validation failure — a malformed value included — fails ITS ITEM alone with a structured error.code (INVALID_CLIENT_ORDER_ID for a malformed handle, the same code batch-create uses) and no mutation and no event, batch-create parity; the whole request 400s only for an empty or oversize batch. (Earlier releases rejected the whole batch for a malformed value here.) A pre-cancel gate then drops two more classes before anything is cancelled — a handle conflict, and a post-only replacement that would cross the book as it will stand once this batch's originals are cancelled — so in the ordinary POST_ONLY_WOULD_CROSS case the item fails with its original still RESTING and untouched. After that the endpoint is CANCEL-FIRST: the original is cancelled in pass 1, so a residual placement failure then — a self-trade rejection, or a crossing that only became apparent in pass 2 — leaves the original CANCELLED and emits its cancellation events (terminal reason 'replaced') while the item reports the placement error and no replacement is placed. Never assume a failed item left your original resting; read results[] and the stream. Single ReplaceOrder differs: it is atomic, and a rejected replacement leaves the original untouched. Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and events are not persisted for redelivery, so one can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replace item carries no order type or time-in-force and its original must still be RESTING, so the IOC/FOK and MARKET post-acceptance rejection shapes are unreachable here. Failures split by WHEN they occur, and the difference decides whether your original survives. Before sequencing: every validation failure — a malformed value included — fails ITS ITEM alone with a structured error.code (INVALID_CLIENT_ORDER_ID for a malformed handle, the same code batch-create uses) and no mutation and no event, batch-create parity; the whole request 400s only for an empty or oversize batch. (Earlier releases rejected the whole batch for a malformed value here.) A pre-cancel gate then drops two more classes before anything is cancelled — a handle conflict, and a post-only replacement that would cross the book as it will stand once this batch's originals are cancelled — so in the ordinary POST_ONLY_WOULD_CROSS case the item fails with its original still RESTING and untouched. After that the endpoint is CANCEL-FIRST: the original is cancelled in pass 1, so a residual placement failure then — a self-trade rejection, or a crossing that only became apparent in pass 2 — leaves the original CANCELLED and emits its cancellation events (terminal reason 'replaced') while the item reports the placement error and no replacement is placed. Never assume a failed item left your original resting; read results[] and the stream. Single ReplaceOrder differs: it is atomic, and a rejected replacement leaves the original untouched. Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -5101,7 +5111,7 @@ export interface components {
             name?: string | null;
             /**
              * @description On-chain client id the application's deposits carry
-             * @example 688a21440e304c06b935f743dae88278
+             * @example 6fe0da813f1a4adcbe675d52ca530a43
              */
             clientId?: string | null;
             /**
@@ -5126,6 +5136,11 @@ export interface components {
              * @example 0
              */
             additionalMakerFeeBps?: number | null;
+            /**
+             * @description Whether this is the exchange's default application: the one a sign-in that names no client id is placed under
+             * @example false
+             */
+            isDefault?: boolean | null;
         };
         BuilderFeeChange: {
             /**
@@ -5232,6 +5247,27 @@ export interface components {
              * @example 4
              */
             newTraders?: number | null;
+            /**
+             * Format: int64
+             * @description Distinct taker wallets that traded through the builder in the window, each once however many buckets or applications it traded in. With window=all, every wallet that ever traded through it. Null for a window counted in hours that starts before the 90 days its hourly sets are kept.
+             * @example 18
+             */
+            activeTakers?: number | null;
+            /**
+             * @description USDC deposited through the builder's applications in the window, in USD (1:1). Other tokens are unvalued and not counted.
+             * @example 15000
+             */
+            depositsUsd?: string | null;
+            /**
+             * @description USDC withdrawals initiated through the builder's applications in the window, in USD (1:1). Attributed by the application that initiated the withdrawal; other tokens are unvalued and not counted.
+             * @example 4000
+             */
+            withdrawalsUsd?: string | null;
+            /**
+             * @description depositsUsd less withdrawalsUsd; negative when more left than arrived
+             * @example 11000
+             */
+            netFlowUsd?: string | null;
         };
         BuilderSeriesPoint: {
             /**
@@ -5288,6 +5324,21 @@ export interface components {
              * @example 1
              */
             newTraders?: number | null;
+            /**
+             * @description USDC deposited through the builder's applications in the bucket, in USD (1:1)
+             * @example 500
+             */
+            depositsUsd?: string | null;
+            /**
+             * @description USDC withdrawals initiated through the builder's applications in the bucket, in USD (1:1). Attributed by the application that initiated the withdrawal; other tokens are unvalued and not counted.
+             * @example 4000
+             */
+            withdrawalsUsd?: string | null;
+            /**
+             * @description depositsUsd less withdrawalsUsd; negative when more left than arrived
+             * @example 11000
+             */
+            netFlowUsd?: string | null;
         };
         BuildercodePayout: {
             /**
@@ -5972,7 +6023,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: a create or replace reusing a value another of your resting orders still holds is rejected with HTTP 409 / gRPC ALREADY_EXISTS and the code CLIENT_ORDER_ID_CONFLICT. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key: resubmitting after a lost response can execute a second time. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. Rejections split in two: one rejected before acceptance (malformed, post-only would cross, handle conflict, a plain MARKET submit with no liquidity, rejected during pricing) fails the request, emits no event and is never written to order history (an order rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent); an accepted LIMIT with IOC or FOK that cannot fill, or an accepted MARKET order whose apparent liquidity is invalidated by maker-risk revalidation, returns 2xx with matchResult.status REJECTED and emits OrderPlaced then OrderRejected, both carrying this value. A 2xx therefore does not mean the order executed. Where no surface is conclusive, do not resubmit.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: a create or replace reusing a value another of your resting orders still holds is rejected with HTTP 409 / gRPC ALREADY_EXISTS and the code CLIENT_ORDER_ID_CONFLICT. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key: resubmitting after a lost response can execute a second time. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and events are not persisted for redelivery, so one can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. Rejections split in two: one rejected before acceptance (malformed, post-only would cross, handle conflict, a plain MARKET submit with no liquidity, rejected during pricing) fails the request, emits no event and is never written to order history (an order rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent); an accepted LIMIT with IOC or FOK that cannot fill, or an accepted MARKET order whose apparent liquidity is invalidated by maker-risk revalidation, returns 2xx with matchResult.status REJECTED and emits OrderPlaced then OrderRejected, both carrying this value. A 2xx therefore does not mean the order executed. Where no surface is conclusive, do not resubmit.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -6811,6 +6862,21 @@ export interface components {
              * @example 4
              */
             newTraders?: number | null;
+            /**
+             * @description USDC deposited through the builder's applications in the window, in USD (1:1). Other tokens are unvalued and not counted.
+             * @example 15000
+             */
+            depositsUsd?: string | null;
+            /**
+             * @description USDC withdrawals initiated through the builder's applications in the window, in USD (1:1). Attributed by the application that initiated the withdrawal; other tokens are unvalued and not counted.
+             * @example 4000
+             */
+            withdrawalsUsd?: string | null;
+            /**
+             * @description depositsUsd less withdrawalsUsd; negative when more left than arrived
+             * @example 11000
+             */
+            netFlowUsd?: string | null;
         };
         GetBuildercodePayoutSummaryResponse: {
             /**
@@ -8236,20 +8302,6 @@ export interface components {
              * @example 2023-11-13T10:30:00Z
              */
             createdAt?: string | null;
-            /**
-             * Format: int32
-             * @deprecated
-             * @description DEPRECATED: legacy flat maker fee in bps echoed from the trading pair. Does NOT reflect the tiered fee actually charged, which is per-user and fractional. Call GET /api/v1/fees/tier for the caller's real rate. Will be removed in a later release.
-             * @example -1
-             */
-            makerFeeBps?: number | null;
-            /**
-             * Format: int32
-             * @deprecated
-             * @description DEPRECATED: legacy flat taker fee in bps echoed from the trading pair. Does NOT reflect the tiered fee actually charged, which is per-user and fractional. Call GET /api/v1/fees/tier for the caller's real rate. Will be removed in a later release.
-             * @example 5
-             */
-            takerFeeBps?: number | null;
             /**
              * Format: int32
              * @description Additional taker fee in basis points from application
@@ -8313,6 +8365,37 @@ export interface components {
              * @example 27
              */
             newTraders?: number | null;
+            /**
+             * @description Total value locked in USD at the end of the window (the end of the bucket holding endTime): USDC custody, deposits less initiated withdrawals, valued 1:1. Null when no custody had been folded by then.
+             * @example 536172600
+             */
+            tvlUsd?: string | null;
+            /**
+             * @description Total value locked in USD at the start of the window (the start of its first bucket). tvlUsd less openingTvlUsd is the window's change. Null when no custody had been folded by then.
+             * @example 535000000
+             */
+            openingTvlUsd?: string | null;
+            /**
+             * @description USDC deposited in the window, in USD (1:1). Other tokens are unvalued and not counted.
+             * @example 1250000
+             */
+            depositsUsd?: string | null;
+            /**
+             * @description USDC withdrawals initiated in the window, in USD (1:1). Other tokens are unvalued and not counted.
+             * @example 78000
+             */
+            withdrawalsUsd?: string | null;
+            /**
+             * @description depositsUsd less withdrawalsUsd; negative when more left than arrived
+             * @example 1172000
+             */
+            netFlowUsd?: string | null;
+            /**
+             * Format: int64
+             * @description Distinct wallets active in the window, each once: wallets that took a trade, received a deposit, or were paid out a withdrawal initiated in it (by payout address), all builders included
+             * @example 418
+             */
+            activeAccounts?: number | null;
         };
         GetPulseResponse: {
             /**
@@ -8532,7 +8615,7 @@ export interface components {
         /** @description The treasury's all-time net fees. Not windowed: the treasury keeps only running totals. */
         GetTreasuryNetFeesResponse: {
             /**
-             * @description All-time net protocol fees in USD (USDC 1:1): the treasury's net fee less BuilderCodes payouts and TraderCodes rewards. Negative when payouts exceed fees; "0" before any fee. The definition may widen to more fee sources without a contract change.
+             * @description All-time net protocol fees in USD (USDC 1:1): the treasury's net protocol fee (taker fees less maker rebates) plus the insurance fund's liquidation fees, less BuilderCodes payouts and TraderCodes rewards. Negative when payouts exceed fees; "0" before any fee. The definition may widen to more fee sources without a contract change.
              * @example 260.37
              */
             netFeesUsd?: string | null;
@@ -9263,7 +9346,7 @@ export interface components {
             /**
              * @description Displayed builders with figures in the window, largest volume first
              *      (ties by builder id), up to limit. A builder that only earned maker
-             *      add-ons ranks with zero volume.
+             *      add-ons, or only took deposits, ranks with zero volume.
              */
             rows?: components["schemas"]["BuilderLeaderboardRow"][] | null;
         };
@@ -10940,6 +11023,26 @@ export interface components {
              * @example 3
              */
             newTraders?: number | null;
+            /**
+             * @description Total value locked in USD at the end of the bucket: USDC custody, deposits less initiated withdrawals, valued 1:1. Carried across buckets without custody movement; null before the first folded custody hour.
+             * @example 536172600
+             */
+            tvlUsd?: string | null;
+            /**
+             * @description USDC deposited in the bucket, in USD (1:1)
+             * @example 52000
+             */
+            depositsUsd?: string | null;
+            /**
+             * @description USDC withdrawals initiated in the bucket, in USD (1:1)
+             * @example 3000
+             */
+            withdrawalsUsd?: string | null;
+            /**
+             * @description depositsUsd less withdrawalsUsd; negative when more left than arrived
+             * @example 49000
+             */
+            netFlowUsd?: string | null;
         };
         PublicHealthCheckResponse: {
             /**
@@ -11288,7 +11391,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: a create or replace reusing a value another of your resting orders still holds is rejected with HTTP 409 / gRPC ALREADY_EXISTS and the code CLIENT_ORDER_ID_CONFLICT. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and its fan-out is non-persistent Core NATS: the service can re-establish an ended upstream subscription without closing your socket, so events can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replacement carries no order type or time-in-force and its original must still be RESTING, so the post-acceptance rejection shapes are unreachable here: the reachable failures are all pre-acceptance — malformed, post-only would cross, handle conflict, or the original no longer resting (ORDER_NOT_FOUND) — and each fails the request, emits no event and is never written to order history (an order rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent). Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: a create or replace reusing a value another of your resting orders still holds is rejected with HTTP 409 / gRPC ALREADY_EXISTS and the code CLIENT_ORDER_ID_CONFLICT. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and events are not persisted for redelivery, so one can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replacement carries no order type or time-in-force and its original must still be RESTING, so the post-acceptance rejection shapes are unreachable here: the reachable failures are all pre-acceptance — malformed, post-only would cross, handle conflict, or the original no longer resting (ORDER_NOT_FOUND) — and each fails the request, emits no event and is never written to order history (an order rejected AFTER acceptance is persisted with status REJECTED, so only the pre-acceptance class is absent). Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -11447,6 +11550,18 @@ export interface components {
             frozenTerms?: components["schemas"]["RfqQuoteTerms"];
             /** Format: int64 */
             lastLookDeadlineAtMs?: number | null;
+            /**
+             * Format: int32
+             * @description Your Monaco maker fee rate in centi-bps, frozen at acceptance; negative for a rebate
+             */
+            monacoFeeCbps?: number | null;
+            /**
+             * Format: int32
+             * @description The MOST your frontend's builder add-on charges on this fill, in centi-bps: the rate stored on your quote order. A fill charges this rate or nothing, never more; the receipt shows what was charged. An IMPROVE re-places the quote at the rate configured then. Absent when it could not be read
+             */
+            maxBuilderFeeCbps?: number | null;
+            /** @description Estimated net at the selected quantity and frozen price, in the quote asset, at monacoFeeCbps plus the maximum builder add-on: the least you receive when selling, the most you pay when buying. Absent with maxBuilderFeeCbps */
+            estimatedNet?: string | null;
         };
         /** @description A market RFQ is offered on. */
         RfqMarketCapability: {
@@ -12566,6 +12681,11 @@ export interface components {
              * @example 789e0123-e45b-12d3-a456-426614174000
              */
             takerApplicationId?: string | null;
+            /**
+             * @description The taker's builder fee: the add-on the taker's application (frontend) charged on the trade, in raw quote-asset units (the asset's smallest unit), on top of takerFeeRaw. "0" when it charged none.
+             * @example 4375
+             */
+            builderFeeRaw?: string | null;
         };
         TradeFlowBucket: {
             /**
@@ -12656,13 +12776,6 @@ export interface components {
              * @example true
              */
             isActive?: boolean | null;
-            /**
-             * Format: int32
-             * @deprecated
-             * @description DEPRECATED: legacy flat maker fee in bps (negative = rebate). This is the pre-tiered pair-level rate and does NOT reflect the tiered fee actually charged, which is per-user and fractional. Do not display this as the user's fee — call GET /api/v1/fees/tier for the caller's real rate. Will be removed in a later release.
-             * @example -2
-             */
-            makerFeeBps?: number | null;
             /**
              * @description Market type: SPOT or MARGIN
              * @example SPOT
@@ -12710,13 +12823,6 @@ export interface components {
              * @example BTC/USDC
              */
             symbol?: string | null;
-            /**
-             * Format: int32
-             * @deprecated
-             * @description DEPRECATED: legacy flat taker fee in bps. This is the pre-tiered pair-level rate and does NOT reflect the tiered fee actually charged, which is per-user and fractional. Do not display this as the user's fee — call GET /api/v1/fees/tier for the caller's real rate. Will be removed in a later release.
-             * @example 10
-             */
-            takerFeeBps?: number | null;
             /**
              * @description Minimum price increment
              * @example 0.01
@@ -15373,8 +15479,10 @@ export interface operations {
             query?: {
                 /** @description Deposits per page (max 1000) */
                 pageSize?: number;
-                /** @description Opaque keyset cursor from the previous response. */
+                /** @description Opaque keyset cursor from the previous response, bound to the filters. */
                 pageToken?: string;
+                token?: string;
+                wallet?: string;
             };
             header?: never;
             path?: never;
@@ -15811,8 +15919,10 @@ export interface operations {
             query?: {
                 /** @description Withdrawals per page (max 1000) */
                 pageSize?: number;
-                /** @description Opaque keyset cursor from the previous response. */
+                /** @description Opaque keyset cursor from the previous response, bound to the filters. */
                 pageToken?: string;
+                token?: string;
+                wallet?: string;
             };
             header?: never;
             path?: never;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.1.5-prerelease.de852e2",
+	"version": "1.1.6",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -16,7 +16,7 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.1.5-prerelease.de852e2",
+		"@0xmonaco/contracts": "1.1.6",
 		"zod": "^4.6.7"
 	},
 	"peerDependencies": {