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

package/dist/trading/orders.d.ts

@@ -84,6 +84,51 @@ export interface Order {
     positionId?: string;
     /** Stable cause when status is CANCELLED */
     terminalReason?: OrderTerminalReason;
+    /**
+     * Opaque, compare-only revision counter for this order's state: a strictly
+     * higher value is strictly newer state for that order, and equal values
+     * mean identical state.
+     *
+     * Compare two REST reads of the same order with it — whether a re-poll
+     * advanced, or which of `getOrder` and a list row is fresher.
+     *
+     * The SAME counter is on every WebSocket order event and on the `orders`
+     * snapshot frame, so it is also the snapshot-versus-stream reconciliation
+     * key: after a disconnect, keep applying events as they arrive and merge a
+     * REST read per order — take the REST row when
+     * `snapshot.version >= local.version`, else keep local. No buffering, so no
+     * quote blackout on reconnect. The rule is `>=` rather than `>` because one
+     * sequencer step emits several events for one order (an `OrderPlaced` and
+     * then its fills) and a batch shares one step across every item, so equal
+     * means "same step" on the stream — and a REST row is that step's final
+     * state, so it wins the tie. Between two REST reads, equal does mean
+     * identical state.
+     *
+     * The snapshot frame alone does not close a reconnect gap: an order that
+     * filled or was cancelled while the socket was down is in neither the
+     * resting snapshot nor the stream. Recover those explicitly — `listUserTrades`
+     * for fills, and a targeted `getOrder` for anything local state believes is
+     * resting that the snapshot no longer lists.
+     *
+     * Read nothing else into it. It is not a count of updates; consecutive
+     * values are not expected (it is drawn from a global sequence shared by
+     * every order, so per-order values are sparse and gaps are normal); and it
+     * is not comparable across different orders.
+     *
+     * Absent means unknown — an order last written before this field existed.
+     * Fall back to a full field comparison for those rather than treating
+     * absent as version zero. Note that a comparison against an absent value
+     * cannot be true either way, so an order held locally without a version is
+     * never refreshed by the merge above: take the REST row unconditionally for
+     * those rather than letting them go stale.
+     *
+     * Prefer this over `updatedAt`: `version` is identical on every endpoint
+     * that serves the same order state and never advances without a state
+     * change, whereas `updatedAt` carries a different clock per endpoint (order
+     * detail reports the matching-engine event time, order lists report the
+     * database commit time) and can move without the order changing.
+     */
+    version?: number;
 }
 /** Stable terminal causes for accepted orders that end as CANCELLED. */
 export type OrderTerminalReason = "USER_REQUESTED" | "REPLACED" | "LIQUIDATION" | "INSUFFICIENT_MARGIN" | "REDUCE_ONLY_EXHAUSTED" | "POSITION_CLOSED" | "OCO_SIBLING_TRIGGERED" | "SYSTEM";

package/dist/trading/responses.d.ts

@@ -456,6 +456,28 @@ export interface ConditionalOrder {
     failureReason?: string;
     createdAt: string;
     updatedAt: string;
+    /**
+     * Opaque, compare-only revision counter for this conditional order's state —
+     * the sequencer step that wrote it (0XM-2440). A strictly higher value is
+     * strictly newer state for that conditional order.
+     *
+     * Present on REST reads and on the subscribe-time `conditional_orders`
+     * snapshot frame. **Absent on live conditional events**, by design: those are
+     * emitted from a model captured before the sequencer acted, so the only value
+     * available there is the one the row held *before* the change being
+     * announced — a client merging on `>=` would let a snapshot read at that
+     * version win the tie and undo the transition.
+     *
+     * So seed conditional state from the snapshot and REST, comparing with
+     * `snapshot.version >= local.version`, and apply live events as state without
+     * ranking them. `>=` rather than `>`: one sequencer step can write several
+     * conditional rows (a trigger writes the triggered row and cancels its OCO
+     * sibling), so equal means "same step", not identical state.
+     *
+     * Absent means unknown — a row last written before the field existed — never
+     * zero. Wire: `version`.
+     */
+    version?: number;
 }
 export interface ListConditionalOrdersResponse {
     orders: ConditionalOrder[];

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

@@ -90,6 +90,28 @@ export interface ConditionalOrderEventData {
      */
     reason: string;
     updatedAt: string;
+    /**
+     * Opaque, compare-only revision counter for this conditional order's state —
+     * the sequencer step that wrote it (0XM-2440). A strictly higher value is
+     * strictly newer state for that conditional order.
+     *
+     * Present on REST reads and on the subscribe-time `conditional_orders`
+     * snapshot frame. **Absent on live conditional events**, by design: those are
+     * emitted from a model captured before the sequencer acted, so the only value
+     * available there is the one the row held *before* the change being
+     * announced — a client merging on `>=` would let a snapshot read at that
+     * version win the tie and undo the transition.
+     *
+     * So seed conditional state from the snapshot and REST, comparing with
+     * `snapshot.version >= local.version`, and apply live events as state without
+     * ranking them. `>=` rather than `>`: one sequencer step can write several
+     * conditional rows (a trigger writes the triggered row and cancels its OCO
+     * sibling), so equal means "same step", not identical state.
+     *
+     * Absent means unknown — a row last written before the field existed — never
+     * zero. Wire: `version`.
+     */
+    version?: number;
 }
 export interface ConditionalOrderEvent {
     eventType: "conditional_order_update";

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

@@ -79,6 +79,26 @@ export interface CommonOrderEventData {
      * silence. Omitted when the order carried none. Wire: `client_order_id`.
      */
     clientOrderId?: string;
+    /**
+     * Sequencer step that produced this event (0XM-2440) — the SAME counter
+     * `getOrder` and `getPaginatedOrders` return, so the two are directly
+     * comparable. Higher is strictly newer for that order.
+     *
+     * This is what makes a reconnect reconcilable without buffering: apply
+     * events as they arrive, and when the REST snapshot lands take the snapshot
+     * for an order when `snapshot.version >= local.version`, else keep local.
+     *
+     * **Equal does NOT mean identical state here.** One sequencer step emits
+     * several events for one order (an `OrderPlaced` and then its fills), and a
+     * batch place/replace shares one step across every item — so equal means
+     * "same step". A snapshot row is that step's FINAL state, which is why the
+     * rule is `>=` and not `>`: on a tie the snapshot is the authority.
+     *
+     * Values are sparse per order (it comes from a global sequence) and are not
+     * comparable between different orders. Omitted, never zero, when unknown —
+     * an order last written before the field existed. Wire: `version`.
+     */
+    version?: number;
     /**
      * `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`.

package/dist/wire/schema.d.ts

@@ -3167,6 +3167,12 @@ export interface components {
             parentOrderId?: string | null;
             associationType?: string | null;
             activatedAt?: string | null;
+            /**
+             * Format: int64
+             * @description Opaque, compare-only revision counter for this conditional order's state: the sequencer step that wrote it. A strictly higher value is strictly newer state for that conditional order. The SAME counter is carried on the `conditional_orders` WebSocket SNAPSHOT frame — but deliberately NOT on the live `conditional_orders` events, which build from the row as it stood before the sequencer acted and so could only report the version the row held BEFORE the change they announce. So seed conditional state from the snapshot frame and REST, reconciling on `(conditionalOrderId, version)` — take the REST row when `snapshot.version >= local.version`, else keep local state — and apply the live events as state without ranking them. Note `>=`, not `>`: equal versions mean the SAME STEP rather than identical state, because one step can write several conditional rows (a trigger writes the triggered row and cancels its OCO sibling under one step). A REST row is that step's FINAL state, so it wins a tie. One consequence to plan for: the snapshot is read from the database, which lags the matching engine, so a transition that fires during the read is in neither the snapshot nor the delivered stream and cannot be ranked — re-read the affected rows if a conditional order's state matters at reconnect. Do not read anything else into the number: it is drawn from the same global sequence plain orders use, so values are sparse, gaps are normal, and it is not comparable across different conditional orders — nor against a plain order's version. Absent means unknown: a row last written before this field existed. Fall back to a full field comparison for those rather than treating absent as version zero.
+             * @example 918342
+             */
+            version?: number | null;
         };
         CreateDelegatedSessionRequest: {
             /**
@@ -4527,6 +4533,12 @@ export interface components {
              * @example false
              */
             postOnly?: boolean | null;
+            /**
+             * Format: int64
+             * @description Opaque, compare-only revision counter for this order's state: the sequencer step that wrote it. A strictly higher value is strictly newer state for that order. The SAME counter is carried on every order WebSocket event and on the `orders` snapshot frame, so a reconnecting client reconciles on `(id, version)` — take the REST row when `snapshot.version >= local.version`, else keep local state. Note `>=`, not `>`: on the stream, equal versions mean the SAME STEP rather than identical state, because one step emits several events for one order (an `OrderPlaced` and then its fills) and a batch shares one step across every item. A REST row is that step's FINAL state, so it wins a tie. Between two REST reads the comparison is simpler — equal there does mean identical state. Do not read anything else into the number: it is not a count of updates, consecutive values are not expected (it is drawn from a global sequence shared by every order, so per-order values are sparse and gaps are normal), and it is not comparable across different orders. Absent means unknown: an order last written before this field existed. Fall back to a full field comparison for those rather than treating absent as version zero — and note that a comparison against an absent value is false in both directions, so an order held locally without one is never refreshed by the merge above; take the REST row unconditionally for those. Reconciling on this counter does NOT on its own close a reconnect gap: an order that filled or was cancelled while the socket was down appears in neither the resting snapshot nor the stream, so recover fills from `listUserTrades` (ordered by execution time) and resolve anything your local state believes is resting that the snapshot no longer lists with a targeted `getOrder`. Unlike `updatedAt`, this value is identical on every REST endpoint that serves the same order state, and never advances without a state change.
+             * @example 918342
+             */
+            version?: number | null;
         };
         /** @description Orderbook snapshot with token metadata and sequence number. */
         GetOrderbookResponse: {

package/package.json

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