@0xmonaco/types 1.0.60 → 1.0.61

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

@@ -1,5 +1,5 @@
 import type { BaseAPI } from "../api";
-import type { OrderSide, OrderType, PositionSide } from "../trading";
+import type { MatchResult, OrderSide, OrderType, PositionSide } from "../trading";
 export type MarginMode = "ISOLATED" | "CROSS";
 export interface MarginAccountSummary {
     marginAccountId: string;
@@ -245,6 +245,25 @@ export interface SimulateOrderRiskRequest {
     /** Required for normal orders; optional and ignored for reduce-only. */
     leverage?: string;
     reduceOnly?: boolean;
+    /**
+     * MARKET-only slippage tolerance in basis points, 0..1,000 — the rule the
+     * server applies to a placed MARKET order: a LIMIT preview carrying it is
+     * rejected with the message the order itself would get. It TIGHTENS the walk
+     * the preview runs (merged tighter-wins with the engine's 1,000 bps
+     * protective band), so `expectedMatchResult` and `estimatedFee` price under
+     * the band the real placement will run under. Omit for the placement
+     * default; it never widens the band.
+     *
+     * Carrying a previewed value into placement: the SDK's `placeMarketOrder`
+     * and batch helpers take `slippageTolerance` as a RATIO (`0.05` = 500 bps),
+     * so pass `slippageToleranceBps / 10_000`; a `slippageToleranceBps` key on
+     * those calls is not forwarded.
+     *
+     * On a first-use ISOLATED preview the value is also forwarded to the
+     * bucket's auto-funding for parity with placement; that path floors it at
+     * 1,000 bps, so today it does not change the funded figure.
+     */
+    slippageToleranceBps?: number;
 }
 export type SimulateIsolatedRiskBucketOrderRiskRequest = SimulateOrderRiskRequest & {
     marginMode?: "ISOLATED";
@@ -327,6 +346,51 @@ export interface SimulateOrderRiskResponse {
      * as unavailable, never as zero.
      */
     estimatedLiquidationPrice?: string;
+    /**
+     * The simulated match the engine ran to admit this order — the same
+     * `MatchResult` shape a placement's `matchResult` carries, from the same
+     * walk over the live book at the moment of the preview, under
+     * `slippageToleranceBps` merged tighter-wins with the 1,000 bps protective
+     * band and the caller's own self-trade-prevention default (the preview runs
+     * under the caller's wallet, as placement does). Not a client-side re-walk,
+     * so preflight and placement read the same numbers. What a preview cannot
+     * carry: `postOnly`, TP/SL legs and a per-order self-trade-prevention
+     * override — a post-only order that would cross is refused by placement, not
+     * by this preview.
+     *
+     * Read it as: `totalFilled` is what would execute; `remainingQuantity` what
+     * the band or the depth leaves unfilled (the partial-fill indicator — a
+     * MARKET preview with a non-zero remainder comes back partially filled when
+     * placed); `averageFillPrice` and `executionPriceRange.worstPrice` the fill
+     * levels, `null` when nothing crosses; `status` the status placement would
+     * end in — `FILLED` for a full fill, `CANCELLED` for a MARKET order the band
+     * or the depth cuts short (a MARKET remainder cannot rest, so the fills
+     * execute and the rest is cancelled; read `remainingQuantity` for the
+     * partial fill), `SUBMITTED` for a LIMIT that rests, `PARTIALLY_FILLED` for
+     * a LIMIT that crosses partly and rests the remainder; `actualSlippageBps`
+     * the realized slippage against `referencePrice`
+     * — for a LIMIT or IOC preview, against the limit price, and `null` when
+     * every fill improved on it; `maxSlippageBps` echoes your tolerance.
+     *
+     * Priced against the book RIGHT NOW. A take-profit / stop-loss closes later,
+     * on a different book, under the wider 1,200 bps band a triggered market leg
+     * carries — so for a TP/SL estimate apply `actualSlippageBps` to the TRIGGER
+     * price as an impact figure rather than displaying this absolute average.
+     *
+     * Present only when `accepted` is true. Absent (`null` on the wire, like
+     * `estimatedLiquidationPrice`) on every refused preview, including the
+     * post-match maker-risk rejection; treat absence as unknown, not as a zero
+     * fill.
+     */
+    expectedMatchResult?: MatchResult;
+    /**
+     * The touch on the taking side when a MARKET preview ran (best ask for a
+     * BUY, best bid for a SELL) — what `expectedMatchResult` and its
+     * `actualSlippageBps` are measured from. Present only when `accepted` is
+     * true and the preview is a MARKET order; a LIMIT or IOC preview is measured
+     * against its own limit price and publishes nothing here.
+     */
+    referencePrice?: string;
 }
 export interface MarginAccountsAPI extends BaseAPI {
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;

package/dist/market/index.d.ts

@@ -312,23 +312,87 @@ export interface MarketStats {
     /** Life-to-date cumulative number of trades summed across all pairs */
     totalTradeCountLtd: number;
 }
+/**
+ * One notional bracket of a market's margin ladder. Brackets are MARGINAL: a
+ * bracket's rate applies only to the notional inside it, and the deduction
+ * carries the cheaper margin already charged by the brackets below, so margin
+ * is continuous across every bound rather than jumping at it.
+ *
+ * `PerpMarketConfig.riskTiers` lists every bracket ascending by
+ * `lowerBoundNotional`. A position's bracket is the LAST tier whose
+ * `lowerBoundNotional` is at or below its notional, `abs(quantity) x markPrice`.
+ */
 export interface RiskTier {
+    /**
+     * Marginal initial-margin floor rate for notional inside this bracket, as a
+     * decimal fraction. The ladder floor is
+     * `IM_floor(N) = N x initialMarginRatio - initialMarginDeduction`.
+     * A position's requirement is the greater of this floor and its
+     * selected-leverage initial margin scaled to the current mark.
+     */
     initialMarginRatio: string;
+    /**
+     * Marginal maintenance-margin rate for notional inside this bracket, as a
+     * decimal fraction. Maintenance margin for a position of notional N in this
+     * bracket is `MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction`.
+     */
     maintenanceMarginRatio: string;
     /** Maximum authoritative absolute base-asset quantity. */
     maxPositionSize?: string;
     /** @deprecated This legacy alias is base quantity, not notional. */
     maxPositionNotional?: string;
+    /** 1-based bracket index within the market's ladder; 1 is the lowest bracket. */
+    tierLevel: number;
+    /** USD notional at which this bracket starts, inclusive; "0" for tier 1. */
+    lowerBoundNotional: string;
+    /**
+     * Maximum leverage available inside this bracket. Absent only for a
+     * single-tier market configured from explicit margin rates rather than
+     * from a leverage.
+     */
+    maxLeverage?: string;
+    /**
+     * Continuity term of the ladder's initial-margin floor formula
+     * `IM_floor(N) = N x initialMarginRatio - initialMarginDeduction`; "0" for tier 1.
+     */
+    initialMarginDeduction: string;
+    /**
+     * Continuity term of the maintenance-margin formula
+     * `MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction`; "0" for tier 1.
+     */
+    maintenanceMarginDeduction: string;
 }
 export interface PerpMarketConfig {
     tradingPairId: string;
     symbol: string;
     minLeverage: string;
+    /**
+     * Tier 1 (the lowest bracket) of `riskTiers` — its `maxLeverage`, mirrored
+     * here for backward compatibility. Brackets above tier 1 are described
+     * only by `riskTiers`.
+     */
     maxLeverage: string;
+    /**
+     * Tier 1 (the lowest bracket) of `riskTiers` — its `initialMarginRatio`,
+     * mirrored here for backward compatibility. Brackets above tier 1 are
+     * described only by `riskTiers`. This rate contributes to the ladder floor;
+     * selected leverage can produce a higher position initial-margin requirement.
+     */
     initialMarginRatio: string;
+    /**
+     * Tier 1 (the lowest bracket) of `riskTiers` — its `maintenanceMarginRatio`,
+     * mirrored here for backward compatibility. Brackets above tier 1 are
+     * described only by `riskTiers`.
+     */
     maintenanceMarginRatio: string;
     fundingIntervalSeconds: number;
     liquidationFeeBps?: string;
+    /**
+     * The market's full margin ladder, ascending by `lowerBoundNotional` and
+     * always non-empty (a market with no configured brackets reports a single
+     * tier). A position's bracket is the LAST tier whose `lowerBoundNotional`
+     * is at or below its notional, `abs(quantity) x markPrice`.
+     */
     riskTiers: RiskTier[];
     updatedAt: string;
 }

package/dist/trading/index.d.ts

@@ -153,7 +153,10 @@ export interface TradingAPI extends BaseAPI {
      *   partially filled order the replacement rests `total - filled` and locks
      *   collateral for that remainder only (FIX convention: `LeavesQty =
      *   OrderQty - CumQty`); must exceed the filled amount. Omitted, the
-     *   replacement keeps the unfilled remainder.
+     *   replacement keeps the unfilled remainder. Margin reduce-only orders are
+     *   the exception: their quantity is a close size measured against the live
+     *   position, placed as given, so neither the subtraction nor the
+     *   must-exceed-filled rule applies.
      * @param newOrder.useMasterBalance - Whether to use master balance (optional, defaults to false)
      * @param newOrder.postOnly - Re-states post-only intent for the replacement (nothing is inherited from the original order)
      * @returns Promise resolving to a `ReplaceOrderResponse`

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

@@ -99,6 +99,7 @@ export declare const SimulateOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const SimulateParentMarginOrderRiskSchema: z.ZodObject<{
@@ -121,6 +122,7 @@ export declare const SimulateParentMarginOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
@@ -148,6 +150,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
         tradingPairId: z.ZodUUID;
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
@@ -172,6 +175,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
         marginMode: z.ZodLiteral<"CROSS">;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         strategyKey: z.ZodOptional<z.ZodNever>;

package/dist/validation/margin-accounts.js

@@ -2,7 +2,7 @@
  * Margin Account API Validation Schemas
  */
 import { z } from "zod";
-import { OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
+import { MarketSlippageToleranceBpsSchema, OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
 const PaginationSchema = z.object({
     page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
@@ -132,8 +132,23 @@ const BaseSimulateOrderRiskRequestSchema = z.object({
     quantity: PositiveDecimalStringSchema,
     leverage: PositiveDecimalStringSchema.optional(),
     reduceOnly: z.boolean().optional(),
+    // The server caps a preview's tolerance at 1,000 bps (the same cap
+    // placement enforces on a MARKET order), so 1,001..10,000 fail here rather
+    // than round-trip to a 400 — one shared schema, so the cap lives once.
+    slippageToleranceBps: MarketSlippageToleranceBpsSchema.optional(),
 });
 const validateOneWaySimulationFields = (data, ctx) => {
+    // Mirrors the server (`utils::slippage::validate_slippage_tolerance`, the
+    // rule placement applies): a tolerance is MARKET-only, so a LIMIT preview
+    // carrying one fails client-side with the same complaint the server would
+    // raise instead of round-tripping to a 400.
+    if (data.orderType !== "MARKET" && data.slippageToleranceBps !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "slippageToleranceBps is only supported for MARKET orders",
+            path: ["slippageToleranceBps"],
+        });
+    }
     if (data.positionSide !== undefined) {
         const expected = data.side === "BUY" ? "LONG" : "SHORT";
         if (data.positionSide !== expected) {

package/dist/validation/trading.d.ts

@@ -76,6 +76,13 @@ export declare const ISO8601DateSchema: z.ZodISODateTime;
  */
 export declare const SlippageToleranceSchema: z.ZodOptional<z.ZodNumber>;
 export declare const SlippageToleranceBpsSchema: z.ZodNumber;
+/**
+ * A standalone MARKET order's tolerance, and a MARKET risk preview's: the
+ * server caps it at 1,000 bps — the mandatory protective band, which a client
+ * value can only tighten — so anything wider fails here instead of
+ * round-tripping to a 400. The 10,000 bps schema above is for TP/SL legs.
+ */
+export declare const MarketSlippageToleranceBpsSchema: z.ZodNumber;
 /** TWAP slices cap at 500 bps (5%) — tighter than standalone market orders. */
 export declare const TwapSlippageToleranceBpsSchema: z.ZodNumber;
 export declare const ParentTpSlLegSchema: z.ZodObject<{

package/dist/validation/trading.js

@@ -84,6 +84,17 @@ export const SlippageToleranceBpsSchema = z
     .int()
     .min(0, "Slippage tolerance must be at least 0 bps")
     .max(10000, "Slippage tolerance cannot exceed 10000 bps");
+/**
+ * A standalone MARKET order's tolerance, and a MARKET risk preview's: the
+ * server caps it at 1,000 bps — the mandatory protective band, which a client
+ * value can only tighten — so anything wider fails here instead of
+ * round-tripping to a 400. The 10,000 bps schema above is for TP/SL legs.
+ */
+export const MarketSlippageToleranceBpsSchema = z
+    .number()
+    .int()
+    .min(0, "Slippage tolerance must be at least 0 bps")
+    .max(1000, "Slippage tolerance cannot exceed 1000 bps");
 /** TWAP slices cap at 500 bps (5%) — tighter than standalone market orders. */
 export const TwapSlippageToleranceBpsSchema = z
     .number()

package/dist/wire/schema.d.ts

@@ -3246,7 +3246,7 @@ export interface components {
              */
             price?: string | null;
             /**
-             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder.
+             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder. Margin reduce-only orders are the exception: their quantity is a close size measured against the live position, placed as given, with no subtraction and no must-exceed-filled rule.
              * @example 0.7
              */
             quantity?: string | null;
@@ -5141,12 +5141,25 @@ export interface components {
             tradingPairId?: string | null;
             symbol?: string | null;
             minLeverage?: string | null;
+            /**
+             * @description Tier-1 maximum leverage: the cap for a position in the lowest notional bracket. Larger positions are capped by their own bracket in riskTiers.
+             * @example 50
+             */
             maxLeverage?: string | null;
+            /**
+             * @description Tier-1 initial-margin floor rate, as a decimal fraction. Mirrors riskTiers[0].initialMarginRatio; use the active bracket's rate and deduction for the ladder floor. Selected leverage can produce a higher position initial-margin requirement.
+             * @example 0.02
+             */
             initialMarginRatio?: string | null;
+            /**
+             * @description Tier-1 maintenance-margin rate, as a decimal fraction. Mirrors riskTiers[0].maintenanceMarginRatio; use the active bracket's rate and deduction to calculate maintenance margin.
+             * @example 0.01
+             */
             maintenanceMarginRatio?: string | null;
             /** Format: uint32 */
             fundingIntervalSeconds?: number | null;
             liquidationFeeBps?: string | null;
+            /** @description The market's full margin ladder, ascending by lowerBoundNotional and always non-empty (a market with no configured brackets reports a single tier). A position's bracket is the LAST tier whose lowerBoundNotional is at or below its notional, abs(quantity) x markPrice. */
             riskTiers?: components["schemas"]["RiskTier"][] | null;
             updatedAt?: string | null;
         };
@@ -7336,7 +7349,7 @@ export interface components {
              */
             price?: string | null;
             /**
-             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder.
+             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder. Margin reduce-only orders are the exception: their quantity is a close size measured against the live position, placed as given, with no subtraction and no must-exceed-filled rule.
              * @example 0.7
              */
             quantity?: string | null;
@@ -7409,16 +7422,56 @@ export interface components {
              */
             available?: string | null;
         };
+        /**
+         * @description One notional bracket of a market's margin ladder. Brackets are MARGINAL:
+         *      a bracket's rate applies only to the notional inside it, and the deduction
+         *      carries the cheaper margin already charged by the brackets below, so margin
+         *      is continuous across every bound rather than jumping at it.
+         */
         RiskTier: {
+            /**
+             * @description Marginal initial-margin floor rate for notional inside this bracket, as a decimal fraction. The ladder floor is IM_floor(N) = N x initialMarginRatio - initialMarginDeduction. A position's initial-margin requirement is the greater of this floor and its selected-leverage initial margin scaled to the current mark.
+             * @example 0.04
+             */
             initialMarginRatio?: string | null;
+            /**
+             * @description Marginal maintenance-margin rate for notional inside this bracket, as a decimal fraction. Maintenance margin for a position of notional N in this bracket is MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction.
+             * @example 0.02
+             */
             maintenanceMarginRatio?: string | null;
             /**
              * @deprecated
              * @description DEPRECATED compatibility alias. This value is a maximum absolute base-asset quantity, not a notional. Use maxPositionSize.
              */
             maxPositionNotional?: string | null;
-            /** @description Maximum authoritative absolute position size in base-asset quantity. */
+            /** @description Maximum authoritative absolute position size in base-asset quantity. A market-wide cap, repeated on every tier rather than varying per bracket. */
             maxPositionSize?: string | null;
+            /**
+             * Format: uint32
+             * @description 1-based bracket index within the market's ladder; 1 is the lowest bracket.
+             * @example 2
+             */
+            tierLevel?: number | null;
+            /**
+             * @description USD notional at which this bracket starts, inclusive; "0" for tier 1.
+             * @example 100000000
+             */
+            lowerBoundNotional?: string | null;
+            /**
+             * @description Maximum leverage available inside this bracket. Absent only for a single-tier market configured from explicit margin rates rather than from a leverage.
+             * @example 25
+             */
+            maxLeverage?: string | null;
+            /**
+             * @description Continuity term of the ladder's initial-margin floor formula IM_floor(N) = N x initialMarginRatio - initialMarginDeduction; "0" for tier 1.
+             * @example 2000000
+             */
+            initialMarginDeduction?: string | null;
+            /**
+             * @description Continuity term of the maintenance-margin formula MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction; "0" for tier 1.
+             * @example 1000000
+             */
+            maintenanceMarginDeduction?: string | null;
         };
         /** @description Per-pair screener row. Window fields null when insufficient history. */
         ScreenerItem: {
@@ -7676,6 +7729,11 @@ export interface components {
             /** @description Required for normal orders; optional and ignored for reduce-only. */
             leverage?: string | null;
             reduceOnly?: boolean | null;
+            /**
+             * Format: int32
+             * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
+             */
+            slippageToleranceBps?: number | null;
         };
         SimulateOrderRiskResponse: {
             accepted?: boolean | null;
@@ -7739,6 +7797,66 @@ export interface components {
              *      previewed pair.
              */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * @description The simulated match the engine ran to admit this order (0XM-2746): the
+             *      same `MatchResult` shape `CreateOrderResponse.match_result` carries for a
+             *      real placement, produced by the same `simulate_match_with_stp` walk over
+             *      the live book at the moment of the preview — under the caller's
+             *      `slippage_tolerance_bps` merged tighter-wins with the mandatory 1,000 bps
+             *      protective band, the caller's own self-trade-prevention default (the
+             *      preview runs under the caller's wallet, as placement does) and
+             *      reduce-only sizing. Not a handler-side re-walk of an orderbook snapshot,
+             *      so a preflight and the placement it precedes read the same numbers — the
+             *      reason this rides the risk simulation rather than a separate quote
+             *      endpoint. What a preview cannot carry: a post-only flag, TP/SL legs and a
+             *      per-order self-trade-prevention override, so a post-only placement that
+             *      would cross is refused by placement, not by this preview.
+             *
+             *      Fields: `total_filled` is what the walk fills; `remaining_quantity` what
+             *      it could NOT fill inside the merged band — the partial-fill / band-cut
+             *      indicator (0 means the whole size executes; a MARKET preview with a
+             *      non-zero remainder comes back partially filled when placed);
+             *      `average_fill_price` is the quantity-weighted fill price and
+             *      `execution_price_range.worst_price` the worst level reached (highest ask a
+             *      BUY takes, lowest bid a SELL hits), both absent when nothing crosses;
+             *      `status` is the status placement would end in: FILLED for a full fill,
+             *      CANCELLED for a MARKET order the band or the depth cuts short (a MARKET
+             *      remainder cannot rest, so the fills execute and the rest is cancelled —
+             *      read `remaining_quantity` for the partial fill), SUBMITTED for a LIMIT
+             *      that rests, PARTIALLY_FILLED for a LIMIT that crosses partly and rests
+             *      the remainder; `actual_slippage_bps` the realized
+             *      slippage against `reference_price` as the engine computes it for a
+             *      placement, absent when nothing crosses; `max_slippage_bps` echoes the
+             *      caller's tolerance, not the merged band. A LIMIT preview that would rest
+             *      reports 0 filled, the full size remaining and no prices.
+             *
+             *      For a LIMIT or IOC preview the engine measures slippage against the LIMIT
+             *      price and reports none when every fill improved on it, exactly as the
+             *      placement's `match_result` does; `reference_price` below is therefore
+             *      published for MARKET previews only.
+             *
+             *      Priced against the book RIGHT NOW. For a take-profit / stop-loss the close
+             *      runs later, on a different book, under the wider 1,200 bps band the engine
+             *      stamps on a triggered market leg and anchored at trigger time — so for a
+             *      TP/SL estimate apply `actual_slippage_bps` to the TRIGGER price as an
+             *      impact figure rather than displaying this call's absolute average price.
+             *      Fees for this walk are `estimated_fee` above, at the caller's own tier,
+             *      which can lag the engine's copy by one refresh interval.
+             *
+             *      PRESENT ONLY when `accepted` is true. Absent — never zeros — on every
+             *      refused preview (`accepted: false` with a `reject_reason`): validation, an
+             *      unknown market or account, insufficient margin, a maker-risk constraint, a
+             *      MARKET order with nothing fillable inside the band, and the post-match
+             *      maker-risk revalidation, whose match the engine discards. Such previews
+             *      may still carry `estimated_fee`, which is priced independently of risk
+             *      state. Treat absence as unknown, not as "fills at zero".
+             */
+            expectedMatchResult?: components["schemas"]["MatchResult"] | null;
+            /**
+             * @description The touch on the taking side when a MARKET preview ran (best ask for a BUY, best bid for a SELL) — what expectedMatchResult's walk and its actualSlippageBps are measured from. Present only when accepted is true and the preview is a MARKET order; a LIMIT or IOC preview is measured against its own limit price and publishes nothing here.
+             * @example 100.25
+             */
+            referencePrice?: string | null;
         };
         SimulateParentMarginOrderRiskRequest: {
             /** Format: uuid */
@@ -7752,6 +7870,11 @@ export interface components {
             /** @description Required for normal orders; optional and ignored for reduce-only. */
             leverage?: string | null;
             reduceOnly?: boolean | null;
+            /**
+             * Format: int32
+             * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
+             */
+            slippageToleranceBps?: number | null;
         };
         SimulateRiskBucketOrderRiskRequest: {
             /** Format: uuid */
@@ -7773,6 +7896,11 @@ export interface components {
              * @description Deprecated: accepted and ignored. Cross scope is derived from trading (a pair joins the cross bucket when a cross order on it succeeds; after its positions close it stays listed until a later successful cross order on another pair reconciles the bucket), so a cross preview has nothing to declare: it runs against the account's active cross bucket — or the deterministic bucket a first cross order would create — and the previewed pair is in scope by construction. Rejected for ISOLATED, as before. The response's selectedTradingPairIds reports the derived scope (recorded pairs, pairs with open positions in the bucket, and the previewed pair), never this list.
              */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * Format: int32
+             * @description MARKET only: client slippage tolerance in basis points, 0..1000, the same rule placement enforces — a LIMIT or IOC preview carrying it is rejected. Tightens the previewed walk to the band the real order will run under and never widens it; omit for the placement default.
+             */
+            slippageToleranceBps?: number | null;
         };
         SubAccount: {
             /**

package/package.json

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