@0xmonaco/types 1.0.48 → 1.0.50-develop.9c1b239

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

@@ -131,17 +131,43 @@ export interface TransferCollateralToParentMarginAccountRequest {
     asset: string;
     amount: string;
 }
+/**
+ * Fund a pair's isolated risk bucket from the parent margin account's
+ * unallocated collateral (no wallet movement; the bucket is created if
+ * needed). What the money becomes when the bucket holds an open position is
+ * stated by `applyToPositionMargin` — the two intents want opposite fates for
+ * the same dollars. Either way the liquidation cushion improves identically.
+ */
 export interface TransferCollateralToIsolatedRiskBucketRequest extends TransferCollateralToParentMarginAccountRequest {
     marginMode?: "ISOLATED";
     tradingPairId: string;
     strategyKey?: string;
     selectedTradingPairIds?: never;
+    /**
+     * `true` (and OMITTED — the default is the human "Adjust Margin" gesture):
+     * the amount is COMMITTED to the sole open position's stored margin.
+     * Effective leverage drops and stays down, initial margin required rises by
+     * the amount, free collateral is unchanged — new orders cannot spend it.
+     *
+     * `false`: plain allocation. Free collateral rises and the next order can
+     * spend it. Programmatic funding loops that top a bucket up to a free
+     * collateral target MUST pass `false`, or each top-up converts into
+     * requirement and the loop never converges.
+     *
+     * On a flat bucket both values are a plain allocation. The response's
+     * `positionMarginCredited` reports what actually happened — a credit can
+     * degrade to a plain allocation when the persisted position row is stale
+     * (close/reopen race).
+     */
+    applyToPositionMargin?: boolean;
 }
 export interface TransferCollateralToCrossRiskBucketRequest extends TransferCollateralToParentMarginAccountRequest {
     marginMode: "CROSS";
     selectedTradingPairIds: string[];
     tradingPairId?: never;
     strategyKey?: never;
+    /** Cross risk is pooled at bucket equity — there is no per-position margin; an explicit `true` is rejected. */
+    applyToPositionMargin?: never;
 }
 export type TransferCollateralToRiskBucketRequest = TransferCollateralToIsolatedRiskBucketRequest | TransferCollateralToCrossRiskBucketRequest;
 export interface TransferCollateralFromParentMarginAccountRequest {
@@ -161,6 +187,16 @@ export interface TransferCollateralResponse {
     newEquity: string;
     newTotalCollateralValue: string;
     newWithdrawableCollateral: string;
+    /**
+     * Whether the transfer was committed to a position's stored margin. Present
+     * only when a position-margin credit was in play: `true` — the credit
+     * landed; `false` — a credit was requested (or defaulted) but degraded to a
+     * plain allocation because the bucket's persisted position row was stale
+     * (close/reopen race) — re-issue the Adjust Margin once the new position
+     * row lands if the commitment still matters. Absent (never null) on plain
+     * allocations, parent deposits, and releases.
+     */
+    positionMarginCredited?: boolean;
 }
 export interface GetMarginAccountMovementsParams {
     movementType?: string;
@@ -237,8 +273,9 @@ export interface MarginAccountsAPI extends BaseAPI {
     getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     /**
-     * @deprecated Prefer transferCollateralToParentMarginAccount() or
-     * transferCollateralToRiskBucket().
+     * @deprecated Use `transferCollateralToRiskBucket` for bucket funding
+     * (which now credits a sole open position's stored margin the same way) and
+     * `transferCollateralToParentMarginAccount` for wallet-to-margin deposits.
      */
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
     transferCollateralToParentMarginAccount(request: TransferCollateralToParentMarginAccountRequest): Promise<TransferCollateralResponse>;

package/dist/sdk/index.d.ts

@@ -109,7 +109,7 @@ export interface MonacoSDK {
     pitpass: PitpassAPI;
     /** Testnet faucet API */
     faucet: FaucetAPI;
-    /** Public deposit-address registration (sweeper) API */
+    /** Deposit-address registration (sweeper) API; requires a session */
     sweeper: SweeperAPI;
     /** Public whitelist (waitlist) submission API */
     whitelist: WhitelistAPI;

package/dist/sweeper/index.d.ts

@@ -1,43 +1,59 @@
 /**
  * Sweeper Types
  *
- * Types for the public deposit-address registration endpoint. Wire shapes are
+ * Types for the deposit-address registration endpoint. Wire shapes are
  * snake_case; these are the camelCase ergonomic forms.
  *
- * NOTE: This endpoint is **public (unauthenticated)**. The deposit address is
- * derived from the (application, user) pair and its destination is fixed in the
- * contract's own bytecode, so a caller can only ever route funds to the user
- * they already belong to. Abuse is bounded by a per-client rate limit and an
- * active-application check instead of authentication.
+ * NOTE: This endpoint is **authenticated**. The credited address is the calling
+ * session's own rather than a request field, so a caller can only ever register
+ * an address they hold the session key for.
  */
+import type { DepositTarget } from "@0xmonaco/contracts";
 import type { BaseAPI } from "../api";
 /**
  * What happened to the registration.
  *
- * - `registered` — the pair was added; its deposit address is now monitored.
- * - `already_registered` — the pair was known before this call; nothing was
+ * - `registered` — the triple was added; its deposit address is now monitored.
+ * - `already_registered` — the triple was known before this call; nothing was
  *   re-triggered.
  */
 export type RegisterSweeperStatus = "registered" | "already_registered";
-/** Body for a deposit-address registration. */
+/**
+ * Body for a deposit-address registration.
+ *
+ * Deliberately tiny: the application and the credited address both come from
+ * the authenticated session (`login` takes the application's client id), so the
+ * only thing left to say is which ledger to aim at.
+ */
 export interface RegisterSweeperRequest {
     /**
-     * The application's client id — the same identifier rollup deposits carry
-     * and `login` takes. The deposit address is derived from these exact bytes
-     * and the application lookup is an exact string match, so the spelling must
-     * match the registered application precisely.
+     * Which ledger swept deposits ask to be credited to. Defaults to `"spot"`.
+     *
+     * `"margin"` asks for the parent margin account's collateral, skipping the
+     * separate `transferCollateralToParentMarginAccount` step. The target is part
+     * of the address derivation, so the two targets yield two different deposit
+     * addresses for the same pair, each carrying its own request. A `"spot"`
+     * address is never credited to margin.
+     *
+     * `"margin"` is a request rather than a guarantee: a deposit the backend
+     * cannot route to collateral — an unsupported collateral asset, or a margin
+     * account that fails validation — is credited to the spot wallet instead, so
+     * funds are never stranded. Read the balance back rather than treating the
+     * address as proof of where the credit landed.
+     *
+     * An unrecognized value is rejected (400) rather than falling back to spot,
+     * which would return an address pointed at a ledger the caller did not ask
+     * for.
      */
-    clientId: string;
-    /** Address credited on the rollup, and half of the deposit-address derivation */
-    userAddress: string;
+    depositTarget?: DepositTarget;
 }
 /** Result of a deposit-address registration. */
 export interface RegisterSweeperResponse {
-    /** Whether this call added the pair or it was known before */
+    /** Whether this call added the triple or it was known before */
     status: RegisterSweeperStatus;
     /**
-     * The pair's deposit address. Stable, and valid to publish and fund before
-     * any contract exists there.
+     * The deposit address for this (application, user, deposit target) triple.
+     * Stable, and valid to publish and fund before any contract exists there.
      */
     sweeperAddress: string;
     /**
@@ -48,20 +64,26 @@ export interface RegisterSweeperResponse {
     initialSweepCheck: boolean;
 }
 /**
- * Sweeper API interface. The register endpoint is public (no auth required).
+ * Sweeper API interface. The register endpoint requires authentication.
  */
 export interface SweeperAPI extends BaseAPI {
     /**
-     * Registers an (application, user) pair so its deterministic deposit
-     * address is monitored and every ERC20 deposit is swept into the rollup
-     * automatically.
+     * Registers an (application, user, deposit target) triple so its
+     * deterministic deposit address is monitored and every ERC20 deposit is
+     * swept into the rollup automatically.
+     *
+     * The application and the credited address both come from the authenticated
+     * session, so this only ever registers the caller's own address under their
+     * own application. Call it with no arguments for a spot address.
      *
      * Returns immediately with the derived deposit address; the one-time
      * initial balance check runs in the background. Idempotent and safe to
      * retry: re-registering answers `already_registered` with the same address
-     * and never re-triggers the initial check. An unknown client id — any
-     * respelling of a real one included, the lookup is exact — throws (404),
-     * and registrations are lightly rate-limited per client (429).
+     * and never re-triggers the initial check.
+     *
+     * Throws on an unrecognized `depositTarget` (before sending), when the
+     * session's application is no longer active (403), and when the endpoint's
+     * global admission limit is exceeded (429).
      */
-    register(body: RegisterSweeperRequest): Promise<RegisterSweeperResponse>;
+    register(body?: RegisterSweeperRequest): Promise<RegisterSweeperResponse>;
 }

package/dist/sweeper/index.js

@@ -1,12 +1,10 @@
 /**
  * Sweeper Types
  *
- * Types for the public deposit-address registration endpoint. Wire shapes are
+ * Types for the deposit-address registration endpoint. Wire shapes are
  * snake_case; these are the camelCase ergonomic forms.
  *
- * NOTE: This endpoint is **public (unauthenticated)**. The deposit address is
- * derived from the (application, user) pair and its destination is fixed in the
- * contract's own bytecode, so a caller can only ever route funds to the user
- * they already belong to. Abuse is bounded by a per-client rate limit and an
- * active-application check instead of authentication.
+ * NOTE: This endpoint is **authenticated**. The credited address is the calling
+ * session's own rather than a request field, so a caller can only ever register
+ * an address they hold the session key for.
  */

package/dist/trading/orders.d.ts

@@ -168,6 +168,11 @@ export type ConditionalOrderState = "PENDING_PARENT" | "ACTIVE" | "TRIGGERING" |
  * - ACTIVE: inside the execution window; child slices are firing
  * - COMPLETED: window ended (fully filled or hard-stopped with a shortfall)
  * - CANCELLED: cancelled by the user before the window ended
+ *
+ * These are the values the server sends today, not a runtime guarantee:
+ * `@0xmonaco/core` parses the `twap_orders` WebSocket frame leniently, so a
+ * state added server-side after this version ships is delivered as-is rather
+ * than dropping the update (0XM-2628). Match it with a default branch.
  */
 export type TwapOrderState = "PENDING" | "ACTIVE" | "COMPLETED" | "CANCELLED";
 /**

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

@@ -45,6 +45,7 @@ export declare const TransferCollateralToRiskBucketSchema: z.ZodObject<{
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
+        applyToPositionMargin: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
@@ -139,6 +140,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
+        applyToPositionMargin: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>, z.ZodObject<{
         tradingPairId: z.ZodUUID;
         side: z.ZodEnum<{

package/dist/validation/margin-accounts.js

@@ -51,6 +51,10 @@ const SelectedCrossTradingPairIdsSchema = z.array(UUIDSchema).min(1, "selectedTr
 const IsolatedRiskBucketRequestSchema = RiskBucketRequestSchema.extend({
     marginMode: z.literal("ISOLATED").optional(),
     selectedTradingPairIds: z.never().optional(),
+    // Omitted defaults server-side to true (the Adjust Margin gesture); false
+    // is the plain allocation programmatic funding loops need. The CROSS form
+    // stays strict-rejected (no per-position margin to commit to).
+    applyToPositionMargin: z.boolean().optional(),
 });
 const CrossRiskBucketScopeSchema = z.object({
     marginMode: z.literal("CROSS"),

package/dist/vault/index.d.ts

@@ -3,6 +3,7 @@
  *
  * Types for vault operations including deposits, withdrawals, and balance management.
  */
+import type { DepositTarget } from "@0xmonaco/contracts";
 import type { Address } from "viem";
 import type { BaseAPI } from "../api/index";
 import type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult } from "./responses";
@@ -13,8 +14,13 @@ import type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult
  *   collateral (auto-creating the account if it does not exist yet). A deposit
  *   that cannot be routed to margin (unsupported asset, etc.) safely falls back
  *   to spot — funds are never lost.
+ *
+ * Re-exported from `@0xmonaco/contracts` rather than redeclared: the same
+ * value selects the on-chain routing hint for a direct deposit and the
+ * derivation of a sweeper deposit address, so one definition keeps the two
+ * from drifting into separately-maintained unions.
  */
-export type DepositTarget = "spot" | "margin";
+export type { DepositTarget };
 /**
  * Options for a deposit.
  */

package/dist/websocket/base.d.ts

@@ -29,6 +29,55 @@ export interface WebSocketResyncInfo {
 }
 /** Handler invoked after a reconnect resumes the live stream. */
 export type ResyncHandler = (info: WebSocketResyncInfo) => void;
+/**
+ * Machine-readable classification the server puts on every `Error` frame so a
+ * client can branch on the failure without string-matching the human message.
+ * Mirrors `ws-api`'s `WsErrorCode` enum, whose SCREAMING_SNAKE_CASE wire
+ * strings are pinned on the Rust side in `ws-api/src/websocket/protocol.rs`
+ * and cross-checked against this union by `@0xmonaco/core`'s
+ * `websocket-enum-parity` test.
+ */
+export type WebSocketErrorCode = 
+/** A user-specific channel was subscribed before authenticating. */
+"AUTH_REQUIRED"
+/** The `Authenticate` handshake was rejected; the connection is closed after this frame. */
+ | "AUTH_FAILED"
+/** The per-user concurrent-connection cap was reached; this connection is closed after the frame. */
+ | "CONNECTION_LIMIT"
+/** The per-connection subscription-cardinality cap was reached. */
+ | "SUBSCRIPTION_LIMIT"
+/** A subscription request was malformed or failed parameter validation. */
+ | "INVALID_SUBSCRIPTION"
+/** An inbound frame could not be parsed, or an unsupported frame type was sent. */
+ | "INVALID_MESSAGE"
+/**
+ * A previously-authenticated session became invalid after the handshake
+ * (revoked, expired, or the account was banned/deactivated). Re-authenticate
+ * rather than blindly reconnecting into the same rejection.
+ */
+ | "SESSION_INVALID"
+/**
+ * The subscribe-time snapshot could not be read. The subscription is still
+ * active and live diffs flow, but the baseline is missing — refetch it (e.g.
+ * from REST) rather than assuming the stream started from a coherent state.
+ */
+ | "SNAPSHOT_UNAVAILABLE";
+/**
+ * An `Error` frame the server sent on this connection.
+ *
+ * `code` is widened past {@link WebSocketErrorCode} on purpose: a code added
+ * server-side after this SDK version shipped is delivered as-is rather than
+ * dropped, so an older client still sees that something failed and can log it.
+ * Narrow with a `switch` on the known values and treat the default as unknown.
+ */
+export interface WebSocketErrorInfo {
+    /** Stable classification of the failure. */
+    code: WebSocketErrorCode | (string & {});
+    /** Human-readable description; for logging and display, never for branching. */
+    message: string;
+}
+/** Handler invoked for every `Error` frame the server sends. */
+export type ErrorHandler = (info: WebSocketErrorInfo) => void;
 /**
  * Reconnect/resync knobs and callbacks for the Monaco WebSocket client.
  *
@@ -62,6 +111,26 @@ export interface MonacoWebSocketConfig {
      * the snapshot was in flight are newer than the snapshot rows they duplicate.
      */
     onResync?: ResyncHandler;
+    /**
+     * Called for every `Error` frame the server sends on this connection.
+     *
+     * `Error` frames are connection-scoped, not channel-scoped, so they reach no
+     * subscription handler — without this callback a failed subscribe, an
+     * invalidated session, or an unreadable subscribe-time snapshot is invisible
+     * to the app. Branch on `code`:
+     *
+     * - `SNAPSHOT_UNAVAILABLE` — live diffs flow but the baseline is missing;
+     *   refetch it. The subscription itself is fine.
+     * - `SESSION_INVALID` — re-authenticate rather than reconnect into the same
+     *   rejection.
+     * - `AUTH_REQUIRED` — a rejected SUBSCRIBE, not an invalidated session: the
+     *   channel was never registered, and this client still holds your handler,
+     *   so it treats the channel as subscribed and sends no new `Subscribe`.
+     *   Re-authenticating alone leaves it dead. Release the last handler for the
+     *   channel and subscribe again after authenticating (0XM-2644 tracks doing
+     *   this automatically).
+     */
+    onError?: ErrorHandler;
 }
 /**
  * Raw event message interface

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

@@ -42,11 +42,14 @@ export interface AccountEventData {
     freeCollateral: string;
     /**
      * Account distress ratio: maintenance margin required over equity (higher is
-     * closer to liquidation, decimal string). When equity is non-positive the
-     * quotient is undefined, so an account that still owes a maintenance
-     * requirement saturates to the max-decimal sentinel
-     * (`79228162514264337593543950335`, maximal distress) and an empty account
-     * with no requirement is `0`. Clamp the sentinel before display.
+     * closer to liquidation, decimal string). The quotient saturates to the
+     * max-decimal sentinel (`79228162514264337593543950335`, maximal distress)
+     * whenever it cannot be computed or represented: an account still owing a
+     * maintenance requirement at zero or negative equity, and equally at
+     * near-zero POSITIVE equity where the true ratio exceeds the decimal range.
+     * An empty account with no requirement is `0`. Clamp the sentinel before
+     * display; treat any value at or above the liquidation threshold as maximal
+     * distress rather than distinguishing the sentinel's causes.
      */
     marginRatio: string;
     /** Maintenance margin required to keep the account solvent (decimal string) */

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

@@ -45,7 +45,7 @@ export interface UserBalanceEventData {
     /** Total balance in raw format (wei) */
     totalRaw: string;
     /** Reason for the balance update */
-    reason: BalanceUpdateReason;
+    reason: BalanceUpdateReason | (string & {});
     /** Reference ID for related entity (e.g., order ID, deposit ID) */
     referenceId: string | null;
     /** Timestamp when the balance was updated (ISO 8601) */

package/dist/websocket/events/conditional-order-events.d.ts

@@ -13,7 +13,10 @@ export type ConditionalOrderEventReason = "created" | "activated" | "cancelled"
  * A conditional (TP/SL) order's current state.
  *
  * **The value unions below are the values the server can send today, not a
- * runtime guarantee.** `@0xmonaco/core` parses this frame leniently — an
+ * runtime guarantee** — which is why each of those fields is typed
+ * `Union | (string & {})`: autocomplete still offers the known values, but a
+ * `switch` over one needs a `default` branch because an unrecognized value
+ * really can arrive (0XM-2628). `@0xmonaco/core` parses this frame leniently — an
  * unrecognized `orderType`, `state`, `side`, `positionSide`, `conditionType`,
  * `triggerSource`, `associationType` or `timeInForce` is passed through as-is
  * rather than validated, because throwing inside the WebSocket message handler
@@ -36,13 +39,13 @@ export interface ConditionalOrderEventData {
     marginAccountId: string;
     positionId?: string;
     parentOrderId?: string;
-    associationType?: "POSITION" | "PARENT_ORDER";
+    associationType?: "POSITION" | "PARENT_ORDER" | (string & {});
     linkedGroupId?: string;
-    conditionType: ConditionalOrderConditionType;
-    triggerSource: ConditionalOrderTriggerSource;
+    conditionType: ConditionalOrderConditionType | (string & {});
+    triggerSource: ConditionalOrderTriggerSource | (string & {});
     triggerPrice: string;
-    side: OrderSide;
-    positionSide: PositionSide;
+    side: OrderSide | (string & {});
+    positionSide: PositionSide | (string & {});
     /**
      * Order shape the conditional order places when it triggers.
      *
@@ -58,7 +61,7 @@ export interface ConditionalOrderEventData {
      * the value would arrive as e.g. `STOPLOSS` rather than the canonical
      * `STOP_LOSS`. The parser passes such a value through untouched.
      */
-    orderType: OrderType;
+    orderType: OrderType | (string & {});
     limitPrice?: string;
     quantity?: string;
     slippageToleranceBps?: number;
@@ -71,8 +74,8 @@ export interface ConditionalOrderEventData {
      * the server maps exhaustively over every variant, so a value written by any
      * other path reaches the wire as-is. Narrow before relying on the subset.
      */
-    timeInForce?: TimeInForce;
-    state: ConditionalOrderState;
+    timeInForce?: TimeInForce | (string & {});
+    state: ConditionalOrderState | (string & {});
     triggeredOrderId?: string;
     triggeredAt?: string;
     activatedAt?: string;

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

@@ -36,8 +36,18 @@ export type InstrumentChangeKind = "listing" | "delisting" | "halt" | "unhalt" |
  * Full current configuration for a market on the `instrument` channel.
  */
 export interface InstrumentEventData {
-    /** What changed for this market */
-    change: InstrumentChangeKind;
+    /**
+     * What changed for this market.
+     *
+     * Widened past {@link InstrumentChangeKind} on purpose: `@0xmonaco/core`
+     * parses this frame leniently, so a change kind added server-side after this
+     * SDK version ships is delivered as-is rather than dropping the frame — and
+     * with it the full market config the frame carries, which can hide a market
+     * going inactive behind an unfamiliar label (0XM-2628).
+     * `InstrumentChangeKind` names the values the server sends today — narrow
+     * with a `switch` that keeps a `default` branch.
+     */
+    change: InstrumentChangeKind | (string & {});
     /** Trading pair identifier (UUID) */
     tradingPairId: string;
     /** Market symbol, e.g. "BTC/USDC" */

package/dist/websocket/events/market-stats-events.d.ts

@@ -85,6 +85,11 @@ export interface MarketStatsEvent {
 /**
  * A single market's row in the all-markets summary frame. A lighter shape than
  * {@link MarketStatsData}: enough to render a markets table.
+ *
+ * `marketStatus` is typed `MarketStatus | (string & {})`: `@0xmonaco/core`
+ * parses this frame leniently, so an unrecognized status is passed through
+ * rather than throwing and dropping the summary row (0XM-2628). `MarketStatus`
+ * names the values the server sends today — match it with a `default` branch.
  */
 export interface MarketStatsSummary {
     /** Trading pair identifier (UUID) */
@@ -114,7 +119,7 @@ export interface MarketStatsSummary {
     /** Next funding time as a millisecond epoch. Perp-only; omitted for spot. */
     fundingTimestamp?: number;
     /** Tradability label (always present) */
-    marketStatus: MarketStatus;
+    marketStatus: MarketStatus | (string & {});
 }
 /**
  * All-markets summary event on the `market_stats` channel: one

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

@@ -21,15 +21,20 @@ export interface OHLCVEvent {
     /** Trading pair ID (UUID) */
     tradingPairId: string;
     /** Candlestick interval */
-    interval: Interval;
+    interval: Interval | (string & {});
     /** Trading mode */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /**
      * Price series this candle belongs to. Always a concrete series on the wire
      * (`trade` or `mark`, never the `*` selector); lets a wildcard subscriber
      * tell the two streams apart. Absent only on legacy frames that omit it.
+     *
+     * Widened past the two known values on purpose: a wildcard subscription
+     * matches any suffix, so a series added server-side after this version still
+     * arrives here, and telling the streams apart is the entire point of the
+     * field. Match it with a `default` branch.
      */
-    priceType?: "trade" | "mark";
+    priceType?: "trade" | "mark" | (string & {});
     /** OHLCV candlestick data */
     candlestick: Candlestick;
 }

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

@@ -29,7 +29,7 @@ export interface OrderbookLevel {
  */
 export interface PriceChange {
     /** Order side (BUY or SELL) */
-    side: OrderSide;
+    side: OrderSide | (string & {});
     /** Old price before the change */
     oldPrice?: string;
     /** New price after the change */
@@ -46,7 +46,7 @@ export interface OrderbookEvent {
     /** Trading pair ID (UUID) */
     tradingPairId: string;
     /** Trading mode (SPOT, MARGIN) */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /** Bid orders (buy orders) - Full depth */
     bids: OrderbookLevel[];
     /** Ask orders (sell orders) - Full depth */

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

@@ -18,7 +18,7 @@ export interface OrderEvent {
     /** Order ID (UUID) */
     orderId: string;
     /** Event type */
-    eventType: OrderEventType;
+    eventType: OrderEventType | (string & {});
     /** ISO 8601 timestamp */
     timestamp: string;
     /** Event-specific data */
@@ -46,11 +46,11 @@ export interface CommonOrderEventData {
      */
     tradingPair: string;
     /** Trading mode (e.g., "SPOT", "MARGIN") */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /** Order type - present in most events */
-    orderType?: OrderType;
+    orderType?: OrderType | (string & {});
     /** Order side - present in most events */
-    side?: OrderSide;
+    side?: OrderSide | (string & {});
     /** Order price - present in most events */
     price?: string;
     /** Order quantity - present in most events */
@@ -58,7 +58,7 @@ export interface CommonOrderEventData {
     /** Order quantity in RAW (integer, base-unit) precision. Wire: `quantity_raw`. */
     quantityRaw?: string;
     /** Time in force - present in most events */
-    timeInForce?: TimeInForce;
+    timeInForce?: TimeInForce | (string & {});
     /**
      * Client-assigned correlation handle, echoed so an event can be matched to
      * the request that placed the order without a round trip to `getOrder`.
@@ -79,6 +79,45 @@ export interface CommonOrderEventData {
      * silence. Omitted when the order carried none. Wire: `client_order_id`.
      */
     clientOrderId?: string;
+    /**
+     * `true` when the order was admitted post-only (maker-only), so a subscriber
+     * can confirm the flag was honoured without a round trip to `getOrder`.
+     * Carried on the `OrderPlaced` acknowledgement, the taker fill, and the
+     * resting order's lifecycle — `OrderPartiallyCancelled` (an in-place
+     * reduction, which is how an MM's own `remainingQuantityTarget` replace is
+     * announced), `OrderCancelled` and `OrderExpired`.
+     *
+     * Declared on the shared block, but two variants can never carry it, and
+     * this optional field is the only thing that says so: a **maker fill**,
+     * which is out of scope because a maker already learned the flag from its
+     * own acknowledgement; and **`OrderRejected`**, which only ever describes a
+     * MARKET order with no liquidity or an unfilled IOC/FOK — and post-only is
+     * refused on both, so no post-only order can reach it.
+     *
+     * Only ever present as `true`: on a variant that CARRIES the field, an order
+     * that is not post-only omits the key rather than sending `postOnly: false`,
+     * exactly as the REST read model's `postOnly?: boolean` does, so
+     * `event.data.postOnly ?? false` reads the same as REST *for that event*.
+     *
+     * That equivalence is per-event, and it does NOT hold on a maker fill.
+     * A post-only order rests and therefore fills as a maker, and the maker
+     * payload never declares the field — so `?? false` there would return
+     * `false` for an order REST reports as `true`. Absence on a maker fill
+     * carries NO information. Track `postOnly` as order-level state learned from
+     * the `OrderPlaced` acknowledgement (or a REST read) and carry it forward;
+     * never re-derive it from whichever event arrived last.
+     *
+     * On a carrying variant, absent is not evidence the flag was dropped — it is
+     * the ordinary shape of a non-post-only order, and also what an order placed
+     * before the flag was persisted reports.
+     *
+     * A post-only order that WOULD have crossed the book is rejected before
+     * acceptance and emits no event at all (see `clientOrderId`), so in practice
+     * the flag reaches a subscriber on a resting order's lifecycle — never on a
+     * taker fill, which an admitted post-only order cannot produce.
+     * Wire: `post_only`.
+     */
+    postOnly?: boolean;
 }
 /**
  * OrderPlaced event - emitted when a new order is placed
@@ -87,54 +126,94 @@ export interface OrderPlacedEvent extends OrderEvent {
     eventType: "OrderPlaced";
     data: CommonOrderEventData & {
         /** Order status */
-        status: OrderStatus;
+        status: OrderStatus | (string & {});
     };
 }
 /**
  * OrderMatched event - emitted when an order is matched but not necessarily filled
- * This event is only emitted for taker orders
+ * This event is only emitted for taker orders.
+ *
+ * Carries the SAME payload as `OrderFilled`/`OrderPartiallyFilled`: the
+ * matching engine builds one `TakerOrderEventData` and picks the event type
+ * from the resulting status, so every execution field below is on the wire
+ * here too.
+ *
+ * Because this event carries only that one shape, the fields below follow it
+ * exactly rather than being uniformly optional. A match that filled nothing
+ * still SENDS the keys — `tradeId`, `executionPrice` and `executedAt` arrive as
+ * `null`, not absent. Only `lastFillQuantity` and `lastFillQuantityRaw` are
+ * ever omitted, being the pair the server skips when there is no incremental
+ * fill.
  */
 export interface OrderMatchedEvent extends OrderEvent {
     eventType: "OrderMatched";
     data: CommonOrderEventData & {
-        /** Taker order ID */
-        takerOrderId?: string;
-        /** Reference price used for slippage calculation */
-        referencePrice?: string;
-        /** Best price achieved in matching */
-        bestPrice?: string;
-        /** Worst price achieved in matching */
-        worstPrice?: string;
-        /** Actual slippage in basis points */
-        actualSlippageBps?: number;
-        /** Maximum allowed slippage in basis points */
-        maxSlippageBps?: number;
-        /** Number of trades executed (taker only) */
-        tradesCount?: number;
-        /** Total quantity filled (taker only) */
-        totalFilled?: string;
-        /** Remaining quantity to be filled (taker only) */
-        remainingQuantity?: string;
-        /** Average fill price across all trades */
-        averageFillPrice?: string;
-        /** Order status */
-        status?: OrderStatus;
+        /** Fill role of this order (`taker` on this event). */
+        role: OrderRole | (string & {});
+        /** Trade ID of the first trade this event covers. `null` when it covers none. */
+        tradeId: string | null;
+        /** Execution price of the first trade this event covers. `null` when it covers none. */
+        executionPrice: string | null;
+        /** Cumulative quantity filled on the order at this event. Wire: `filled_quantity`. */
+        filledQuantity: string;
+        /** `filledQuantity` in RAW (integer, base-unit) precision. Wire: `filled_quantity_raw`. */
+        filledQuantityRaw: string;
+        /** Incremental quantity filled by THIS event. Omitted when there is no fill. Wire: `last_fill_quantity`. */
+        lastFillQuantity?: string;
+        /** `lastFillQuantity` in RAW (integer, base-unit) precision. Omitted with it. Wire: `last_fill_quantity_raw`. */
+        lastFillQuantityRaw?: string;
+        /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
+        remainingQuantityRaw: string;
+        /**
+         * Monaco fee for the fills this event covers, in normalized decimal QUOTE
+         * units (negative = maker rebate). Excludes the application taker fee, so
+         * it is smaller than the order echo's `totalTakerFees` for an application
+         * that charges one, and equal to it for one that does not. Wire: `fee`.
+         */
+        fee: string;
+        /**
+         * `fee` in RAW quote-unit precision (scaled by 10^quoteDecimals). Always a
+         * whole number -- the engine truncates every fee to an integral raw unit
+         * when it stores it -- so `fee` is exactly this value divided by
+         * 10^quoteDecimals, and `BigInt(feeRaw)` is safe. Wire: `fee_raw`.
+         */
+        feeRaw: string;
+        /** Execution timestamp of the first trade this event covers (ISO 8601). `null` when it covers none. */
+        executedAt: string | null;
+        /** Reference price used for slippage calculation. `null` when unset. */
+        referencePrice: string | null;
+        /** Best price achieved in matching. `null` when unset. */
+        bestPrice: string | null;
+        /** Worst price achieved in matching. `null` when unset. */
+        worstPrice: string | null;
+        /** Actual slippage in basis points. `null` when unset. */
+        actualSlippageBps: number | null;
+        /** Maximum allowed slippage in basis points. `null` when unset. */
+        maxSlippageBps: number | null;
+        /** Number of trades executed. */
+        tradesCount: number;
+        /** Remaining quantity to be filled. */
+        remainingQuantity: string;
+        /** Average fill price across all trades. `null` when there is none. */
+        averageFillPrice: string | null;
+        /** Order status. */
+        status: OrderStatus | (string & {});
     };
 }
 /**
  * OrderPartiallyFilled event - emitted when an order is partially filled
- * Can be emitted for both taker and maker orders with different field sets
+ * Can be emitted for both taker and maker orders with different field sets.
  *
- * Taker events include: trades_count, total_filled, slippage data
- * Maker events include: trade_id, execution_price, execution_quantity, maker_fee
+ * Taker events add `trades_count` and the slippage fields; maker events add
+ * `trade_id` and `execution_price`. Both roles report the cumulative fill as
+ * `filled_quantity` and this event's increment as `last_fill_quantity`, and
+ * both carry the fill charge as `fee` (0XM-2389). `total_filled`,
+ * `execution_quantity` and `maker_fee` were never emitted on a fill payload
+ * and are not declared here.
  */
 export interface OrderPartiallyFilledEvent extends OrderEvent {
     eventType: "OrderPartiallyFilled";
     data: CommonOrderEventData & {
-        /** Taker order ID (taker orders only) */
-        takerOrderId?: string;
-        /** Maker order ID (maker orders only) */
-        makerOrderId?: string;
         /** Reference price (taker orders only) */
         referencePrice?: string;
         /** Best price (taker orders only) */
@@ -147,14 +226,12 @@ export interface OrderPartiallyFilledEvent extends OrderEvent {
         maxSlippageBps?: number;
         /** Number of trades (taker orders only - not present for maker) */
         tradesCount?: number;
-        /** Total filled quantity (taker orders only - not present for maker) */
-        totalFilled?: string;
         /** Remaining quantity (present for both taker and maker) */
         remainingQuantity?: string;
         /** Average fill price (taker orders only) */
         averageFillPrice?: string;
         /** Order status (taker orders only) */
-        status?: OrderStatus;
+        status?: OrderStatus | (string & {});
         /** Trade ID (maker orders only) */
         tradeId?: string;
         /** Execution price (maker orders only) */
@@ -180,30 +257,43 @@ export interface OrderPartiallyFilledEvent extends OrderEvent {
         /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
         remainingQuantityRaw?: string;
         /**
-         * Fee charged for this fill (maker orders only). The wire field is `fee`
-         * (→ `fee`), not `makerFee`; taker fills carry the same `fee` field.
+         * Monaco fee for the fills this event covers, in normalized decimal QUOTE
+         * units (negative = maker rebate). The wire field is `fee`, not `makerFee`;
+         * taker and maker carry the same field. A taker event aggregates every
+         * trade it covers; a maker event is one trade.
+         *
+         * Excludes the application taker fee, so it is NOT the order echo's
+         * `totalTakerFees` (which is `fee + applicationTakerFee`). It previously
+         * held the raw integer value now exposed as `feeRaw`.
          */
         fee?: string;
+        /**
+         * `fee` in RAW quote-unit precision (scaled by 10^quoteDecimals). Always a
+         * whole number -- the engine truncates every fee to an integral raw unit
+         * when it stores it -- so `fee` is exactly this value divided by
+         * 10^quoteDecimals, and `BigInt(feeRaw)` is safe. Wire: `fee_raw`.
+         */
+        feeRaw?: string;
         /** Trade execution timestamp (maker orders only) */
         executedAt?: string;
         /** Role of the order in the trade (taker or maker) */
-        role?: OrderRole;
+        role?: OrderRole | (string & {});
     };
 }
 /**
  * OrderFilled event - emitted when an order is completely filled
- * Can be emitted for both taker and maker orders with different field sets
+ * Can be emitted for both taker and maker orders with different field sets.
  *
- * Taker events include: trades_count, total_filled, slippage data
- * Maker events include: trade_id, execution_price, execution_quantity, maker_fee
+ * Taker events add `trades_count` and the slippage fields; maker events add
+ * `trade_id` and `execution_price`. Both roles report the cumulative fill as
+ * `filled_quantity` and this event's increment as `last_fill_quantity`, and
+ * both carry the fill charge as `fee` (0XM-2389). `total_filled`,
+ * `execution_quantity` and `maker_fee` were never emitted on a fill payload
+ * and are not declared here.
  */
 export interface OrderFilledEvent extends OrderEvent {
     eventType: "OrderFilled";
     data: CommonOrderEventData & {
-        /** Taker order ID (taker orders only) */
-        takerOrderId?: string;
-        /** Maker order ID (maker orders only) */
-        makerOrderId?: string;
         /** Reference price (taker orders only) */
         referencePrice?: string;
         /** Best price (taker orders only) */
@@ -216,14 +306,12 @@ export interface OrderFilledEvent extends OrderEvent {
         maxSlippageBps?: number;
         /** Number of trades (taker orders only - not present for maker) */
         tradesCount?: number;
-        /** Total filled quantity (taker orders only - not present for maker) */
-        totalFilled?: string;
         /** Remaining quantity (present for both, should be 0 for filled orders) */
         remainingQuantity?: string;
         /** Average fill price (taker orders only) */
         averageFillPrice?: string;
         /** Order status (taker orders only) */
-        status?: OrderStatus;
+        status?: OrderStatus | (string & {});
         /** Trade ID (maker orders only) */
         tradeId?: string;
         /** Execution price (maker orders only) */
@@ -249,14 +337,27 @@ export interface OrderFilledEvent extends OrderEvent {
         /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
         remainingQuantityRaw?: string;
         /**
-         * Fee charged for this fill (maker orders only). The wire field is `fee`
-         * (→ `fee`), not `makerFee`; taker fills carry the same `fee` field.
+         * Monaco fee for the fills this event covers, in normalized decimal QUOTE
+         * units (negative = maker rebate). The wire field is `fee`, not `makerFee`;
+         * taker and maker carry the same field. A taker event aggregates every
+         * trade it covers; a maker event is one trade.
+         *
+         * Excludes the application taker fee, so it is NOT the order echo's
+         * `totalTakerFees` (which is `fee + applicationTakerFee`). It previously
+         * held the raw integer value now exposed as `feeRaw`.
          */
         fee?: string;
+        /**
+         * `fee` in RAW quote-unit precision (scaled by 10^quoteDecimals). Always a
+         * whole number -- the engine truncates every fee to an integral raw unit
+         * when it stores it -- so `fee` is exactly this value divided by
+         * 10^quoteDecimals, and `BigInt(feeRaw)` is safe. Wire: `fee_raw`.
+         */
+        feeRaw?: string;
         /** Trade execution timestamp (maker orders only) */
         executedAt?: string;
         /** Role of the order in the trade (taker or maker) */
-        role?: OrderRole;
+        role?: OrderRole | (string & {});
     };
 }
 /**
@@ -268,7 +369,7 @@ export interface OrderCancelledEvent extends OrderEvent {
         /** Reason for cancellation */
         reason?: string;
         /** Stable machine-readable cancellation cause */
-        terminalReason?: OrderTerminalReason;
+        terminalReason?: OrderTerminalReason | (string & {});
         /**
          * Cumulative order fill at cancellation, mirroring `filledQuantity` on the
          * taker/maker fill events so consumers read one field across every order
@@ -308,11 +409,15 @@ export interface OrderRejectedEvent extends OrderEvent {
         /** Reason for rejection */
         reason: string;
         /** Order status */
-        status: OrderStatus;
+        status: OrderStatus | (string & {});
         /** Total filled quantity (may-be partially filled) */
         totalFilled: string;
+        /** `totalFilled` in RAW (integer, base-unit) precision. Wire: `total_filled_raw`. */
+        totalFilledRaw: string;
         /** Remaining quantity that couldn't be filled */
         remainingQuantity: string;
+        /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
+        remainingQuantityRaw: string;
     };
 }
 /**
@@ -321,12 +426,16 @@ export interface OrderRejectedEvent extends OrderEvent {
 export interface OrderExpiredEvent extends OrderEvent {
     eventType: "OrderExpired";
     data: CommonOrderEventData & {
-        /** Filled quantity before expiration */
-        filledQuantity?: string;
-        /** Remaining quantity at expiration */
-        remainingQuantity?: string;
-        /** Average fill price (if any fills occurred) */
-        averageFillPrice?: string;
+        /** Filled quantity before expiration. `null` when the order never filled. */
+        filledQuantity: string | null;
+        /** `filledQuantity` in RAW (integer, base-unit) precision. Wire: `filled_quantity_raw`. */
+        filledQuantityRaw: string | null;
+        /** Remaining quantity at expiration. `null` when unset. */
+        remainingQuantity: string | null;
+        /** `remainingQuantity` in RAW (integer, base-unit) precision. Wire: `remaining_quantity_raw`. */
+        remainingQuantityRaw: string | null;
+        /** Average fill price. `null` when no fills occurred. */
+        averageFillPrice: string | null;
         /** Reason for expiration */
         reason: string;
     };
@@ -342,7 +451,7 @@ export interface OrderPartiallyCancelledEvent extends OrderEvent {
     eventType: "OrderPartiallyCancelled";
     data: CommonOrderEventData & {
         /** Order status — non-terminal (the order still rests) */
-        status: OrderStatus;
+        status: OrderStatus | (string & {});
         /** Cumulative filled quantity, unchanged by the reduction */
         filledQuantity: string;
         /** Cumulative filled quantity in RAW precision. Wire: `filled_quantity_raw`. */

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

@@ -23,6 +23,12 @@ export type PositionEventSide = "LONG" | "SHORT";
 export type PositionEventStatus = "OPEN" | "LIQUIDATING" | "CLOSED" | "LIQUIDATED" | "EXPIRED";
 /**
  * Position event data containing the current state of a single position.
+ *
+ * `side` and `status` are typed `Union | (string & {})`: `@0xmonaco/core`
+ * parses this frame leniently, so an unrecognized value is passed through
+ * rather than throwing inside the WebSocket message handler and dropping a
+ * risk-critical update entirely (0XM-2627/0XM-2628). The unions name the values
+ * the server sends today — `switch` over them with a `default` branch.
  */
 export interface PositionEventData {
     /** Position identifier (UUID) */
@@ -32,9 +38,9 @@ export interface PositionEventData {
     /** Trading pair identifier (UUID) */
     tradingPairId: string;
     /** Position side */
-    side: PositionEventSide;
+    side: PositionEventSide | (string & {});
     /** Position lifecycle status (SCREAMING_SNAKE_CASE on the wire, e.g. "OPEN") */
-    status: PositionEventStatus;
+    status: PositionEventStatus | (string & {});
     /** Absolute position size (decimal string) */
     size: string;
     /** Average entry price (decimal string) */

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

@@ -15,7 +15,7 @@ export interface TradeEventData {
     /** Executed quantity */
     quantity: string;
     /** Side of the maker order (BUY or SELL) */
-    makerSide: OrderSide;
+    makerSide: OrderSide | (string & {});
     /** Timestamp when the trade was executed (ISO 8601) */
     executedAt: string;
 }
@@ -28,7 +28,7 @@ export interface TradeEvent {
     /** Trading pair ID (UUID) */
     tradingPairId: string;
     /** Trading mode (SPOT or MARGIN) */
-    tradingMode: TradingMode;
+    tradingMode: TradingMode | (string & {});
     /** Trade execution data */
     data: TradeEventData;
 }

package/dist/websocket/events/twap-order-events.d.ts

@@ -18,12 +18,20 @@ export type TwapOrderEventReason = "created" | "slice_placed" | "slice_skipped"
  * Field names mirror the backend `TwapOrderEventData` payload (snake_case on
  * the wire, camelCased by the client); the SDK parser normalizes explicit
  * `null` values to absent, so nullable wire fields are optional here.
+ *
+ * **The value unions below are the values the server sends today, not a
+ * runtime guarantee**, which is why each is typed `Union | (string & {})`:
+ * `@0xmonaco/core` hands this whole payload through with a single cast and
+ * validates no value field, so an unrecognized `side`, `tradingMode`,
+ * `executionStyle`, `state`, `triggerDirection` or `reason` arrives as-is
+ * rather than dropping the update (0XM-2628). Autocomplete still offers the
+ * known values; `switch` over one with a `default` branch.
  */
 export interface TwapOrderEventData {
     twapOrderId: string;
     tradingPairId: string;
-    side: OrderSide;
-    tradingMode: TradingMode;
+    side: OrderSide | (string & {});
+    tradingMode: TradingMode | (string & {});
     totalQuantity: string;
     executedQuantity: string;
     executedNotional: string;
@@ -41,7 +49,7 @@ export interface TwapOrderEventData {
     clientTwapId?: string;
     randomize: boolean;
     /** Child execution style: "TAKER" (banded MARKET slices) or "PASSIVE" (post-only children at the touch, taker sweep at each slice deadline) */
-    executionStyle: TwapExecutionStyle;
+    executionStyle: TwapExecutionStyle | (string & {});
     /** Window start (ISO 8601) */
     startAt: string;
     /** Window end (ISO 8601). Execution stops hard at this time. */
@@ -55,13 +63,23 @@ export interface TwapOrderEventData {
     nextSliceAt?: string;
     slicesPlaced: number;
     slicesSkipped: number;
-    state: TwapOrderState;
+    /**
+     * Lifecycle state of the parent order.
+     *
+     * Widened past {@link TwapOrderState} on purpose: `@0xmonaco/core` parses
+     * this frame leniently, so a state added server-side after this SDK version
+     * ships is delivered as-is rather than dropping the whole update (0XM-2628).
+     * `TwapOrderState` names the values the server sends today — narrow with a
+     * `switch` that keeps a `default` branch rather than relying on
+     * exhaustiveness.
+     */
+    state: TwapOrderState | (string & {});
     /** Terminal annotation, e.g. "ended with shortfall 1.5"; absent for non-terminal parents */
     terminalReason?: string;
     /** Conditional configuration + activation stamp (parity with the REST read
      * model). All absent on unconditional parents. */
     triggerPrice?: string;
-    triggerDirection?: "ABOVE" | "BELOW";
+    triggerDirection?: "ABOVE" | "BELOW" | (string & {});
     conditionalExpiry?: string;
     triggeredAt?: string;
     createdAt: string;
@@ -69,7 +87,7 @@ export interface TwapOrderEventData {
     cancelledAt?: string;
     completedAt?: string;
     /** Mutation that produced this snapshot */
-    reason: TwapOrderEventReason;
+    reason: TwapOrderEventReason | (string & {});
 }
 export interface TwapOrderEvent {
     eventType: "twap_order_update";

package/dist/wire/schema.d.ts

@@ -869,6 +869,17 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        /**
+         * @deprecated
+         * @description DEPRECATED (0XM-2632): this endpoint overloads two unrelated operations —
+         *      with `trading_pair_id` it allocates into that pair's isolated risk bucket
+         *      (crediting the sole open position's stored margin), without it it performs
+         *      a wallet-debiting deposit to the parent margin account. Use
+         *      `TransferCollateralToRiskBucket` for bucket funding (which now applies the
+         *      same position-margin credit) and `TransferCollateralToParentMarginAccount`
+         *      for wallet-to-margin deposits. Kept for backward compatibility; no removal
+         *      date scheduled.
+         */
         post: operations["transfer_collateral_to_margin_account"];
         delete?: never;
         options?: never;
@@ -1029,6 +1040,15 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        /**
+         * @description Fund a risk bucket from the parent margin account's unallocated
+         *      collateral (no wallet movement; the bucket is created if needed). Since
+         *      0XM-2632, funding an ISOLATED bucket that holds an open position also
+         *      credits that position's stored margin — the same behavior as the
+         *      deprecated `TransferCollateralToMarginAccount` Adjust Margin rail — so
+         *      adding collateral to support a position has one behavior on every route.
+         *      A flat isolated bucket and the cross bucket stay plain allocations.
+         */
         post: operations["transfer_collateral_to_risk_bucket"];
         delete?: never;
         options?: never;
@@ -2072,23 +2092,29 @@ export interface paths {
          * Register a deposit address for monitoring
          * @description Register a deposit address for monitoring.
          *
-         *      Every (application, user) pair has a deterministic deposit address. This
-         *      registers the pair so the sweeper service watches that address and
-         *      automatically forwards every ERC20 deposit into the rollup, crediting the
-         *      user under the application.
+         *      Every (application, user, deposit target) triple has a deterministic
+         *      deposit address. This registers the caller's own address so the sweeper
+         *      service watches it and automatically forwards every ERC20 deposit into the
+         *      rollup, crediting the caller under the application.
+         *
+         *      Authenticated, and the whole identity comes from the session: the
+         *      application is the one `login` established the session under, and the
+         *      credited address is the session's own. Neither is a request parameter, so a
+         *      caller can only ever register their own address under their own
+         *      application. The only thing the body carries is which ledger to aim at.
          *
          *      Registration also runs a one-time initial check in the background: any
          *      balance already sitting on the address is swept without waiting for a new
          *      transfer. The response returns immediately with the derived address; it
          *      does not wait for that check.
          *
-         *      Idempotent and safe to retry: re-registering an existing pair returns
+         *      Idempotent and safe to retry: re-registering an existing triple returns
          *      `already_registered` with the same address and never re-triggers the
          *      initial check.
          *
-         *      Lightly rate-limited per client, and the client id must name an existing
-         *      application — the lookup is an exact string match, which is what pins the
-         *      one spelling the deposit address is derived from.
+         *      Globally rate-limited: registration creates durable state, so the endpoint
+         *      admits a bounded number per minute across all callers and answers `429`
+         *      beyond it.
          */
         post: operations["register_deposit_address"];
         delete?: never;
@@ -6512,25 +6538,21 @@ export interface components {
         };
         RegisterRequest: {
             /**
-             * @description The application's client id — the same identifier rollup deposits carry and `login` takes. The deposit address is derived from these exact bytes and the application lookup is an exact string match, so the spelling must match the registered application precisely.
-             * @example 60eb377aab9f4ea18dcdf4747204c792
-             */
-            clientId: string;
-            /**
-             * @description Address credited on the rollup, and half of the deposit address derivation
-             * @example 0x742d35Cc6634C0532925a3b8D4060f31E2C3d8B5
+             * @description Which ledger swept deposits are requested to be credited to. `SPOT` (the default when omitted) credits the spot wallet; `MARGIN` asks for the parent margin account's collateral, skipping the separate collateral transfer. The target is part of the address derivation, so `SPOT` and `MARGIN` yield two different deposit addresses for the same pair, and each address carries its own request. `MARGIN` is a routing request rather than a guarantee: a deposit the matching engine cannot route to collateral — an unsupported collateral asset, or a margin account that fails validation — is credited to the spot wallet instead, so funds are never stranded. A `SPOT` address is never credited to margin.
+             * @example MARGIN
+             * @enum {string|null}
              */
-            userAddress: string;
+            depositTarget?: "SPOT" | "MARGIN" | null;
         };
         RegisterResponse: {
             /**
-             * @description `registered` when the pair was added, `already_registered` when it was known before this call
+             * @description `registered` when the triple was added, `already_registered` when it was known before this call
              * @example registered
              * @enum {string|null}
              */
             status?: "registered" | "already_registered" | null;
             /**
-             * @description The pair's deposit address. Stable, and valid to publish and fund before any contract exists there.
+             * @description The deposit address for this (application, user, deposit target) triple. Stable, and valid to publish and fund before any contract exists there.
              * @example 0xcf1eF339798914EF7Ee4984Ed45BD141D63a65C9
              */
             sweeperAddress?: string | null;
@@ -7355,6 +7377,16 @@ export interface components {
             marginMode?: string | null;
             /** @description Present for cross risk-bucket transfers. */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * @description Whether the transfer was committed to a position's stored margin.
+             *      Present only when a position-margin credit was in play: true — the credit
+             *      landed; false — a credit was requested (or defaulted) but degraded to a
+             *      plain allocation because the bucket's persisted position row was stale
+             *      (close/reopen race) — re-issue the Adjust Margin once the new position
+             *      row lands if the commitment still matters. Absent on plain allocations,
+             *      parent deposits, and releases.
+             */
+            positionMarginCredited?: boolean | null;
         };
         TransferCollateralToParentMarginAccountRequest: {
             asset?: string | null;
@@ -7374,6 +7406,31 @@ export interface components {
             marginMode?: string | null;
             /** @description Trading pair UUIDs selected into the cross risk bucket. Required when marginMode is CROSS. */
             selectedTradingPairIds?: string[] | null;
+            /**
+             * @description What the transferred collateral becomes when the ISOLATED bucket holds an
+             *      open position. The two intents want opposite fates for the same dollars,
+             *      so the caller states theirs:
+             *
+             *      - true (and UNSET — the default is the human "Adjust Margin" gesture):
+             *       the amount is COMMITTED to the position's stored margin. Effective
+             *       leverage drops and stays down, initial margin required rises by the
+             *       amount, free collateral is unchanged — new orders cannot spend it.
+             *      - false: plain allocation. Free collateral rises and the next order can
+             *       spend it. Programmatic funding loops that top a bucket up to a free
+             *       collateral target MUST pass false, or each top-up converts into
+             *       requirement and the loop never converges.
+             *
+             *      Either way the liquidation cushion improves identically (the breach
+             *      check is bucket-equity based). On a FLAT isolated bucket there is no
+             *      position to commit to and both values are a plain allocation. Explicit
+             *      true is rejected for CROSS buckets (cross has no per-position margin);
+             *      unset/false is a plain allocation there.
+             *
+             *      The response reports what actually happened in `position_margin_credited`
+             *      — a credit can degrade to a plain allocation when the persisted position
+             *      row is stale (close/reopen race).
+             */
+            applyToPositionMargin?: boolean | null;
         };
         TransferRewardsRequest: {
             /**
@@ -12008,14 +12065,21 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Application not found */
-            404: {
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description The application for this session is not active */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Registration rate-limit exceeded */
+            /** @description Registration admission limit exceeded; retry shortly */
             429: {
                 headers: {
                     [name: string]: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.0.48",
+	"version": "1.0.50-develop.9c1b239",
 	"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.48",
+		"@0xmonaco/contracts": "1.0.50-develop.9c1b239",
 		"zod": "^4.1.12"
 	},
 	"peerDependencies": {