@0xmonaco/core 1.0.74 → 1.0.75

package/dist/api/trading/api.d.ts

@@ -315,11 +315,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * Gets orders based on query parameters, cursor-paginated by default.
      *
      * Retrieves orders with optional filtering by status, trading pair, and pagination.
-     * Every kind of order comes back in ONE stream ordered by timestamp: book orders,
-     * TWAP parents (`orderType: "TWAP"`, detail on `twap`) and conditional orders
-     * (`orderType: "CONDITIONAL"`, detail on `conditional`). There is no separate
-     * open-orders call — filter `status` to `["SUBMITTED", "PARTIALLY_FILLED"]` for the
-     * working set.
+     * Every row is a BOOK order (`LIMIT` or `MARKET`); filter `status` to
+     * `["SUBMITTED", "PARTIALLY_FILLED"]` for the resting working set. TWAP parents and
+     * conditional (TP/SL) orders are not rows here — list them with `listTwapOrders`
+     * and `listConditionalOrders`.
      * When neither `page` nor `pageToken` is passed, the SDK drives cursor (pageToken)
      * pagination: it starts a cursor walk from the newest (or oldest, for
      * `orderBy: "ASC"`) row and the response's `nextPageToken` resumes it. Both modes
@@ -342,13 +341,9 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      *
      * @example
      * ```typescript
-     * // Every working order, of every kind, in one page
+     * // The resting working set (book orders only)
      * const open = await tradingAPI.getPaginatedOrders({ status: ["SUBMITTED", "PARTIALLY_FILLED"] });
-     * for (const order of open.orders) {
-     *   if (order.orderType === "TWAP") console.log("TWAP parent", order.twap?.slicesPlaced);
-     *   else if (order.orderType === "CONDITIONAL") console.log("trigger", order.conditional?.triggerPrice);
-     *   else console.log("resting", order.price);
-     * }
+     * for (const order of open.orders) console.log("resting", order.quantity, "@", order.price);
      * ```
      *
      * @example

package/dist/api/trading/api.js

@@ -495,11 +495,10 @@ export class TradingAPIImpl extends BaseAPI {
      * Gets orders based on query parameters, cursor-paginated by default.
      *
      * Retrieves orders with optional filtering by status, trading pair, and pagination.
-     * Every kind of order comes back in ONE stream ordered by timestamp: book orders,
-     * TWAP parents (`orderType: "TWAP"`, detail on `twap`) and conditional orders
-     * (`orderType: "CONDITIONAL"`, detail on `conditional`). There is no separate
-     * open-orders call — filter `status` to `["SUBMITTED", "PARTIALLY_FILLED"]` for the
-     * working set.
+     * Every row is a BOOK order (`LIMIT` or `MARKET`); filter `status` to
+     * `["SUBMITTED", "PARTIALLY_FILLED"]` for the resting working set. TWAP parents and
+     * conditional (TP/SL) orders are not rows here — list them with `listTwapOrders`
+     * and `listConditionalOrders`.
      * When neither `page` nor `pageToken` is passed, the SDK drives cursor (pageToken)
      * pagination: it starts a cursor walk from the newest (or oldest, for
      * `orderBy: "ASC"`) row and the response's `nextPageToken` resumes it. Both modes
@@ -522,13 +521,9 @@ export class TradingAPIImpl extends BaseAPI {
      *
      * @example
      * ```typescript
-     * // Every working order, of every kind, in one page
+     * // The resting working set (book orders only)
      * const open = await tradingAPI.getPaginatedOrders({ status: ["SUBMITTED", "PARTIALLY_FILLED"] });
-     * for (const order of open.orders) {
-     *   if (order.orderType === "TWAP") console.log("TWAP parent", order.twap?.slicesPlaced);
-     *   else if (order.orderType === "CONDITIONAL") console.log("trigger", order.conditional?.triggerPrice);
-     *   else console.log("resting", order.price);
-     * }
+     * for (const order of open.orders) console.log("resting", order.quantity, "@", order.price);
      * ```
      *
      * @example

package/dist/api/websocket/websocket.js

@@ -245,6 +245,9 @@ function parsePositionEventData(raw) {
         orderId: readOptionalString(data, "orderId"),
         reason: readString(data, "reason"),
         updatedAt: readString(data, "updatedAt"),
+        // Optional: an older deployment does not send it, and the server omits it
+        // when it does not know when the position opened.
+        openedAt: readOptionalString(data, "openedAt"),
         // Opaque durable row version (0XM-2673). `readOptionalSequence`, not
         // `readOptionalNumber`: this is an ordering counter, so a fractional,
         // negative, or unsafe-integer value would silently corrupt every
@@ -269,6 +272,42 @@ function parsePositionEvent(rawData) {
         data: parsePositionEventData(rawData.data),
     };
 }
+/** The `positions` channel's valuation frame discriminator. */
+const POSITION_VALUATION_EVENT_TYPE = "position_valuation";
+/**
+ * Whether a `positions` channel frame is a periodic valuation rather than a
+ * lifecycle update. Checked on the raw discriminator BEFORE any lifecycle
+ * field is read, so a valuation never reaches the lifecycle parser.
+ */
+function isPositionValuationFrame(rawData) {
+    return isRecord(rawData) && rawData.event_type === POSITION_VALUATION_EVENT_TYPE;
+}
+function parsePositionValuationEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid position valuation event: payload must be an object");
+    }
+    if (!isRecord(rawData.data)) {
+        throw new Error("Invalid position valuation event: data must be an object");
+    }
+    const data = keysToCamelCase(rawData.data);
+    // Always present on the wire; `null` when the server cannot derive one.
+    const liquidationPrice = data.liquidationPrice === null ? null : readString(data, "liquidationPrice");
+    return {
+        eventType: readEnum(rawData, "event_type", [POSITION_VALUATION_EVENT_TYPE]),
+        userId: readString(rawData, "user_id"),
+        data: {
+            positionId: readString(data, "positionId"),
+            marginAccountId: readString(data, "marginAccountId"),
+            tradingPairId: readString(data, "tradingPairId"),
+            markPrice: readString(data, "markPrice"),
+            unrealizedPnl: readString(data, "unrealizedPnl"),
+            liquidationPrice,
+            initialMarginRequired: readString(data, "initialMarginRequired"),
+            maintenanceMarginRequired: readString(data, "maintenanceMarginRequired"),
+            valuedAt: readString(data, "valuedAt"),
+        },
+    };
+}
 /**
  * Parse a liquidation alert's payload. Shared by the live event and the
  * subscribe-time snapshot (see {@link parseConditionalOrderEventData}).
@@ -772,6 +811,10 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
     let ws = null;
     let session = options.session;
     let reconnectAttempts = 0;
+    // Whether a socket has opened since the client was created or last
+    // disconnect()ed, so a status consumer can tell a first connect that keeps
+    // failing from a lost working connection.
+    let hasConnected = false;
     let reconnectTimer = null;
     let heartbeatTimer = null;
     let autoReconnect = options.autoReconnect ?? true;
@@ -823,7 +866,9 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             return reconnectTimer ? "reconnecting" : "disconnected";
         switch (ws.readyState) {
             case WebSocket.CONNECTING:
-                return "connecting";
+                // A retry's socket is still inside the outage the last status
+                // reported, so it reads as reconnecting, not connecting.
+                return reconnectAttempts > 0 ? "reconnecting" : "connecting";
             case WebSocket.OPEN:
                 return "connected";
             default:
@@ -833,6 +878,43 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         }
     };
     const getUrl = () => baseUrl;
+    /**
+     * The single place a status change is reported. Recovery must not hinge on
+     * the application's observer, so an error it throws is logged, not
+     * propagated into the connection lifecycle. An async observer is assignable
+     * to the void-returning handler type, so its rejection is logged the same
+     * way rather than left unhandled.
+     */
+    const emitStatus = (status, nextRetryDelayMs, attempt = reconnectAttempts) => {
+        const info = { attempt, hasConnected };
+        if (nextRetryDelayMs !== undefined) {
+            info.nextRetryDelayMs = nextRetryDelayMs;
+        }
+        const logObserverError = (err) => console.error("WebSocket: onStatusChange threw", err);
+        try {
+            const result = options.onStatusChange?.(status, info);
+            // Any thenable, not just this realm's Promise: an async handler from
+            // another realm (an iframe) returns a promise `instanceof` misses.
+            if (typeof result?.then === "function") {
+                Promise.resolve(result).catch(logObserverError);
+            }
+        }
+        catch (err) {
+            logObserverError(err);
+        }
+    };
+    /**
+     * Report a terminal "disconnected", which ends the retry cycle so the next
+     * connect() reports "connecting" with a fresh retry budget. The counter is
+     * reset before the observer runs, so a connect() made from inside the
+     * callback already starts the new cycle; the status still reports the
+     * retries the cycle ran.
+     */
+    const emitTerminalDisconnected = () => {
+        const attempt = reconnectAttempts;
+        reconnectAttempts = 0;
+        emitStatus("disconnected", undefined, attempt);
+    };
     /**
      * Send the signed auth handshake as the first message after the socket
      * opens. The client signs `WS-AUTH\n<pubkey>\n<ts>` with the session private
@@ -876,13 +958,15 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             reconnectTimer = null;
         }
     };
+    // Whether the retry cycle may schedule another attempt.
+    const retryBudgetLeft = () => autoReconnect && reconnectAttempts < maxReconnectAttempts;
     const scheduleReconnect = () => {
         // Single scheduling authority: a failed attempt can report through both
         // the connect() rejection and the socket's own close event — an armed
         // timer means the retry is already owned.
         if (reconnectTimer)
             return;
-        if (!autoReconnect || reconnectAttempts >= maxReconnectAttempts) {
+        if (!retryBudgetLeft()) {
             console.error("WebSocket: Max reconnect attempts reached");
             return;
         }
@@ -902,10 +986,14 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                 return;
             connect().catch((err) => {
                 console.warn("WebSocket: Failed to reconnect:", err);
-                scheduleReconnect();
+                // Not when the failure already ended the retry cycle (the last
+                // retry's socket could not be constructed).
+                if (reconnectAttempts > 0) {
+                    scheduleReconnect();
+                }
             });
         }, delay);
-        options.onStatusChange?.("reconnecting");
+        emitStatus("reconnecting", delay);
     };
     const send = (data) => {
         if (ws?.readyState === WebSocket.OPEN) {
@@ -1035,6 +1123,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                         return;
                     }
                     reconnectAttempts = 0;
+                    hasConnected = true;
                     // A retry armed before this open (e.g. a manual connect() during
                     // backoff) is moot now — left running it would suppress the
                     // terminal disconnected emit and reopen a socket after a clean
@@ -1045,7 +1134,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                     // (orders, balances, …) are authorized when the Subscribe arrives.
                     sendAuthenticate();
                     resubscribeAll();
-                    options.onStatusChange?.("connected");
+                    emitStatus("connected");
                     // Resync-join order: the live stream resumes first (auth +
                     // subscribe above), then the application is asked to refetch
                     // snapshots and reconcile against each channel's authoritative
@@ -1118,13 +1207,8 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                         if (pendingResyncCode === null) {
                             pendingResyncCode = event.code;
                         }
-                        try {
-                            options.onStatusChange?.("disconnected");
-                        }
-                        finally {
-                            // Recovery must not hinge on the status observer not throwing.
-                            options.onReauthenticationRequired?.({ code: authError.code, message: authError.message, closeCode: event.code });
-                        }
+                        emitStatus("disconnected");
+                        options.onReauthenticationRequired?.({ code: authError.code, message: authError.message, closeCode: event.code });
                         return;
                     }
                     // The app already handed over a replacement session on this socket.
@@ -1135,14 +1219,10 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                         if (pendingResyncCode === null) {
                             pendingResyncCode = event.code;
                         }
-                        try {
-                            options.onStatusChange?.("disconnected");
-                        }
-                        finally {
-                            connect().catch((err) => {
-                                console.warn("WebSocket: Failed to connect with the replacement session:", err);
-                            });
-                        }
+                        emitStatus("disconnected");
+                        connect().catch((err) => {
+                            console.warn("WebSocket: Failed to connect with the replacement session:", err);
+                        });
                         return;
                     }
                     // Reconnect on abnormal close. 1013 is the server's slow-client
@@ -1159,13 +1239,26 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                     // "disconnected" is terminal: suppressed while a retry is armed
                     // (scheduleReconnect emitted "reconnecting" instead).
                     if (!reconnectTimer) {
-                        options.onStatusChange?.("disconnected");
+                        emitTerminalDisconnected();
                     }
                 };
                 socket.onerror = () => clearTimeout(timeout);
+                // A retry's socket stays inside the outage "reconnecting" already
+                // reported; only a connection opened outside a retry cycle is new.
+                if (reconnectAttempts === 0) {
+                    emitStatus("connecting");
+                }
             }
             catch (err) {
-                options.onStatusChange?.("disconnected");
+                // The socket could not be constructed. Inside a retry cycle the retry
+                // timer schedules the next attempt while the budget lasts; otherwise
+                // nothing follows, so this ends the cycle.
+                if (reconnectTimer || (reconnectAttempts > 0 && retryBudgetLeft())) {
+                    emitStatus("disconnected");
+                }
+                else {
+                    emitTerminalDisconnected();
+                }
                 reject(err);
             }
         });
@@ -1180,7 +1273,8 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         instrumentBaseline.clear();
         ws?.close(1000, "Client disconnect");
         ws = null;
-        options.onStatusChange?.("disconnected");
+        hasConnected = false;
+        emitTerminalDisconnected();
     };
     const subscribe = (channel, handler, snapshotHandler) => {
         const isFirstSubscriber = !handlers.has(channel);
@@ -1522,8 +1616,11 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
      * handshake. Omit `tradingPairId` for all pairs, or pass one to filter.
      * Detected broadcast lag closes the connection with 1013; reconcile
      * missed keys and terminal updates on reconnect.
+     *
+     * The channel also carries periodic `position_valuation` frames. Those go to
+     * `onValuation` only, never to `handler`, and are ignored without one.
      */
-    const subscribePositions = (handler, tradingPairId, onSnapshot) => {
+    const subscribePositions = (handler, tradingPairId, onSnapshot, onValuation) => {
         if (!handler) {
             throw new Error("positions subscription requires a handler");
         }
@@ -1532,6 +1629,17 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         }
         const channel = tradingPairId ? `positions:${tradingPairId}` : "positions";
         return subscribe(channel, (rawData) => {
+            if (isPositionValuationFrame(rawData)) {
+                if (!onValuation)
+                    return;
+                try {
+                    onValuation(parsePositionValuationEvent(rawData));
+                }
+                catch (err) {
+                    console.error("WebSocket: Error processing position valuation event", err);
+                }
+                return;
+            }
             try {
                 handler(parsePositionEvent(rawData));
             }

package/dist/coverage.d.ts

@@ -137,6 +137,8 @@ export declare const COVERED: {
     close_sub_account: string;
     get_margin_account_pnl: string;
     transfer_collateral: string;
+    transfer_collateral_to_sub_account: string;
+    transfer_collateral_from_sub_account: string;
     claim_buildercode_rewards: string;
     set_builder_fee: string;
     transfer_rewards: string;

package/dist/coverage.js

@@ -137,6 +137,8 @@ export const COVERED = {
     close_sub_account: "closeMarginSubAccount",
     get_margin_account_pnl: "getMarginAccountPnl",
     transfer_collateral: "transferMarginCollateral",
+    transfer_collateral_to_sub_account: "transferCollateralToSubAccount",
+    transfer_collateral_from_sub_account: "transferCollateralFromSubAccount",
     claim_buildercode_rewards: "buildercodes.claimBuildercodeRewards",
     set_builder_fee: "buildercodes.setBuilderFee",
     transfer_rewards: "pitpass.transferRewards",

package/dist/sdk.d.ts

@@ -36,24 +36,6 @@ export declare class MonacoSDKImpl implements MonacoSDK {
      * the WebSocket client.
      */
     private propagateSession;
-    /**
-     * Set (or clear) the application secret key used for backend-authenticated
-     * requests (those annotated `#[require_backend]` on the gateway, e.g. the
-     * `applications` reporting endpoints).
-     *
-     * The raw `sk_...` key is sent in the `x-server-key` header on each such
-     * request. This is independent of {@link login}/session auth — a client may
-     * hold both a session and a server key at once.
-     *
-     * @param serverKey - The application secret key (`sk_...`), or `undefined` to clear.
-     *
-     * @example
-     * ```typescript
-     * sdk.setServerKey("sk_live_...");
-     * const orders = await sdk.applications.listApplicationOrders({ status: "FILLED" });
-     * ```
-     */
-    setServerKey(serverKey: string | undefined): void;
     /** Extract the session keypair from an auth state. */
     private sessionFromAuthState;
     constructor(cfg: SDKConfig);

package/dist/sdk.js

@@ -103,48 +103,6 @@ export class MonacoSDKImpl {
         this.trades.setSessionKeypair(credentials);
         this.ws.setSessionKeypair(credentials);
     }
-    /**
-     * Set (or clear) the application secret key used for backend-authenticated
-     * requests (those annotated `#[require_backend]` on the gateway, e.g. the
-     * `applications` reporting endpoints).
-     *
-     * The raw `sk_...` key is sent in the `x-server-key` header on each such
-     * request. This is independent of {@link login}/session auth — a client may
-     * hold both a session and a server key at once.
-     *
-     * @param serverKey - The application secret key (`sk_...`), or `undefined` to clear.
-     *
-     * @example
-     * ```typescript
-     * sdk.setServerKey("sk_live_...");
-     * const orders = await sdk.applications.listApplicationOrders({ status: "FILLED" });
-     * ```
-     */
-    setServerKey(serverKey) {
-        this.auth.setServerKey(serverKey);
-        this.delegatedAgents.setServerKey(serverKey);
-        this.applications.setServerKey(serverKey);
-        this.fees.setServerKey(serverKey);
-        this.buildercodes.setServerKey(serverKey);
-        this.copyTrading.setServerKey(serverKey);
-        this.pitpass.setServerKey(serverKey);
-        this.vault.setServerKey(serverKey);
-        this.withdrawals.setServerKey(serverKey);
-        this.trading.setServerKey(serverKey);
-        this.market.setServerKey(serverKey);
-        this.marginAccounts.setServerKey(serverKey);
-        this.positions.setServerKey(serverKey);
-        this.portfolio.setServerKey(serverKey);
-        this.subAccounts.setServerKey(serverKey);
-        this.faucet.setServerKey(serverKey);
-        this.sweeper.setServerKey(serverKey);
-        this.managedMarkets.setServerKey(serverKey);
-        this.whitelist.setServerKey(serverKey);
-        this.pulse.setServerKey(serverKey);
-        this.profile.setServerKey(serverKey);
-        this.orderbook.setServerKey(serverKey);
-        this.trades.setServerKey(serverKey);
-    }
     /** Extract the session keypair from an auth state. */
     sessionFromAuthState(authState) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.74",
+	"version": "1.0.75",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -19,8 +19,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.74",
-		"@0xmonaco/types": "1.0.74",
+		"@0xmonaco/contracts": "1.0.75",
+		"@0xmonaco/types": "1.0.75",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"