@0xmonaco/core 1.0.73 → 1.0.75

package/dist/api/profile/api.js

@@ -17,7 +17,7 @@
  * console.log(`User: ${profile.username} (${profile.address})`);
  * ```
  */
-import { GetUserMovementsSchema, GetUserTradesSchema, ListFundingPaymentsSchema, SetSelfTradePreventionDefaultSchema, validate } from "@0xmonaco/types";
+import { GetUserBalancesSchema, GetUserMovementsSchema, GetUserTradesSchema, ListFundingPaymentsSchema, SetSelfTradePreventionDefaultSchema, validate, } from "@0xmonaco/types";
 import { APIError } from "../../errors";
 import { BaseAPI } from "../base";
 export class ProfileAPIImpl extends BaseAPI {
@@ -53,14 +53,19 @@ export class ProfileAPIImpl extends BaseAPI {
      * Fetches the user's transaction history from the /api/v1/accounts/movements endpoint.
      * Requires a valid access token to be set.
      *
-     * The response `total` and `totalPages` are bounded by the listing's pagination reach:
-     * exact up to `pageSize` x 10,000 rows (10,000 pages) and saturating there, so a user
-     * with more matching movements than the listing can page through reads the cap, not
-     * their lifetime total. A `page` above 10,000 is rejected.
+     * Cursor paged (0XM-2788/0XM-2820): omit `pageToken` or pass `""` to start,
+     * then follow `nextPageToken` from each response until it comes back empty.
+     * There is no `page` — sending one is a `400`.
+     *
+     * The response `total` and `totalPages` are bounded by the server count
+     * ceiling; `totalCapped` is `true` when more than that matched, so `total`
+     * is a lower bound. Do not drive a paging loop off `total`: a user past the
+     * ceiling would stop early. Follow `nextPageToken`.
      *
      * @param params - Optional query parameters for pagination and filtering
-     * @param params.page - Page number (starts from 1, default: 1, at most 10,000)
-     * @param params.limit - Number of items per page (default: 20, max: 100)
+     * @param params.pageToken - Cursor from a previous response's `nextPageToken`
+     * @param params.pageSize - Number of items per page (default: 20, max: 1000)
+     * @param params.orderBy - Sort direction for `createdAt` (default: `"DESC"`)
      * @param params.entryType - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
      * @param params.transactionType - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
      * @param params.assetId - Filter by asset ID (UUID)
@@ -73,9 +78,14 @@ export class ProfileAPIImpl extends BaseAPI {
      * const movements = await profileAPI.getPaginatedUserMovements();
      * console.log(`Total movements: ${movements.total}`);
      *
-     * // Get second page with custom pageSize
-     * const page2 = await profileAPI.getPaginatedUserMovements({ page: 2, pageSize: 50 });
-     * console.log(`Page ${page2.page} of ${page2.totalPages}`);
+     * // Walk every page
+     * let pageToken = "";
+     * for (;;) {
+     *   const page = await profileAPI.getPaginatedUserMovements({ pageToken, pageSize: 50 });
+     *   console.log(page.movements.length);
+     *   if (page.nextPageToken === "") break;
+     *   pageToken = page.nextPageToken;
+     * }
      *
      * // Filter by entry type and transaction type
      * const deposits = await profileAPI.getPaginatedUserMovements({ entryType: "CREDIT", transactionType: "DEPOSIT" });
@@ -89,12 +99,17 @@ export class ProfileAPIImpl extends BaseAPI {
             validate(GetUserMovementsSchema, params);
         }
         const searchParams = new URLSearchParams();
-        if (params?.page !== undefined) {
-            searchParams.append("page", params.page.toString());
-        }
         if (params?.pageSize !== undefined) {
             searchParams.append("pageSize", params.pageSize.toString());
         }
+        // An empty token is a distinct, meaningful value — "start the walk" — so
+        // it must reach the wire rather than be dropped as falsy.
+        if (params?.pageToken !== undefined) {
+            searchParams.append("pageToken", params.pageToken);
+        }
+        if (params?.orderBy !== undefined) {
+            searchParams.append("orderBy", params.orderBy);
+        }
         if (params?.entryType !== undefined) {
             searchParams.append("entryType", params.entryType);
         }
@@ -114,9 +129,13 @@ export class ProfileAPIImpl extends BaseAPI {
      * Fetches the user's token balances from the /api/v1/accounts/balances endpoint.
      * Requires a valid access token to be set.
      *
+     * Cursor paged (0XM-2788/0XM-2821): omit `pageToken` or pass `""` to start,
+     * then follow `nextPageToken` until it comes back empty. There is no `page`
+     * — sending one is a `400`.
+     *
      * @param params - Optional query parameters for pagination
-     * @param params.page - Page number (starts from 1, default: 1)
-     * @param params.pageSize - Number of items per page (default: 20, max: 100)
+     * @param params.pageToken - Cursor from a previous response's `nextPageToken`
+     * @param params.pageSize - Number of items per page (default: 20, max: 1000)
      * @returns Promise resolving to paginated balances response
      * @throws {APIError} When the request fails or user is not authenticated
      *
@@ -129,19 +148,29 @@ export class ProfileAPIImpl extends BaseAPI {
      *   console.log(`${balance.symbol}: ${balance.availableBalance}`);
      * });
      *
-     * // Get page 2 with 50 items per page
-     * const nextBalances = await profileAPI.getUserBalances({ page: 2, pageSize: 50 });
-     * console.log(`Returned ${nextBalances.balances.length} balances`);
+     * // Walk every page
+     * let pageToken = "";
+     * for (;;) {
+     *   const page = await profileAPI.getUserBalances({ pageToken, pageSize: 50 });
+     *   console.log(page.balances.length);
+     *   if (page.nextPageToken === "") break;
+     *   pageToken = page.nextPageToken;
+     * }
      * ```
      */
     async getUserBalances(params) {
-        const searchParams = new URLSearchParams();
-        if (params?.page !== undefined) {
-            searchParams.append("page", params.page.toString());
+        if (params) {
+            validate(GetUserBalancesSchema, params);
         }
+        const searchParams = new URLSearchParams();
         if (params?.pageSize !== undefined) {
             searchParams.append("pageSize", params.pageSize.toString());
         }
+        // An empty token is a distinct, meaningful value — "start the walk" — so
+        // it must reach the wire rather than be dropped as falsy.
+        if (params?.pageToken !== undefined) {
+            searchParams.append("pageToken", params.pageToken);
+        }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/balances?${queryString}` : "/api/v1/accounts/balances";
         return await this.makeAuthenticatedRequest(url);
@@ -315,12 +344,21 @@ export class ProfileAPIImpl extends BaseAPI {
      * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
      * Requires a valid access token to be set.
      *
-     * The response `total` and `totalPages` are bounded by the listing's pagination reach:
-     * exact up to `pageSize` x 10,000 rows (10,000 pages) and saturating there, so a user
-     * with more matching payments than the listing can page through reads the cap, not
-     * their lifetime total. A `page` above 10,000 is rejected.
+     * Cursor paged (0XM-2788/0XM-2818): omit `pageToken` or pass `""` to start,
+     * then follow `nextPageToken` from each response until it comes back empty.
+     * There is no `page` — sending one is a `400`.
+     *
+     * The response `total` and `totalPages` are bounded by the server count
+     * ceiling; `totalCapped` is `true` when more than that matched, so `total`
+     * is a lower bound. Do not drive a paging loop off `total`: a user past the
+     * ceiling would stop early. Follow `nextPageToken`.
      *
      * @param params - Optional query parameters for pagination and filtering
+     * @param params.pageToken - Cursor from a previous response's `nextPageToken`
+     * @param params.pageSize - Number of items per page (default: 20, max: 1000)
+     * @param params.tradingPairId - Filter by trading pair ID (UUID)
+     * @param params.positionId - Filter by margin position ID (UUID)
+     * @param params.marginAccountId - Filter by margin account ID (UUID)
      * @returns Promise resolving to paginated funding payments response
      * @throws {APIError} When the request fails or user is not authenticated
      *
@@ -328,6 +366,15 @@ export class ProfileAPIImpl extends BaseAPI {
      * ```typescript
      * const funding = await profileAPI.listFundingPayments({ tradingPairId: "550e8400-e29b-41d4-a716-446655440000" });
      * console.log(`Total funding payments: ${funding.total}`);
+     *
+     * // Walk every page
+     * let pageToken = "";
+     * for (;;) {
+     *   const page = await profileAPI.listFundingPayments({ pageToken, pageSize: 100 });
+     *   console.log(page.records.length);
+     *   if (page.nextPageToken === "") break;
+     *   pageToken = page.nextPageToken;
+     * }
      * ```
      */
     async listFundingPayments(params) {
@@ -335,12 +382,14 @@ export class ProfileAPIImpl extends BaseAPI {
             validate(ListFundingPaymentsSchema, params);
         }
         const searchParams = new URLSearchParams();
-        if (params?.page !== undefined) {
-            searchParams.append("page", params.page.toString());
-        }
         if (params?.pageSize !== undefined) {
             searchParams.append("pageSize", params.pageSize.toString());
         }
+        // An empty token is a distinct, meaningful value — "start the walk" — so
+        // it must reach the wire rather than be dropped as falsy.
+        if (params?.pageToken !== undefined) {
+            searchParams.append("pageToken", params.pageToken);
+        }
         if (params?.tradingPairId !== undefined) {
             searchParams.append("tradingPairId", params.tradingPairId);
         }

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}).
@@ -284,7 +323,7 @@ function parseLiquidationEventData(raw) {
         positionId: readOptionalString(data, "positionId"),
         tradingPairId: readOptionalString(data, "tradingPairId"),
         status: readString(data, "status"),
-        accountState: readString(data, "accountState"),
+        riskBucketState: readString(data, "riskBucketState"),
         liquidationPrice: readOptionalString(data, "liquidationPrice"),
         markPrice: readOptionalString(data, "markPrice"),
         estimatedShortfall: readString(data, "estimatedShortfall"),
@@ -299,7 +338,7 @@ function parseLiquidationEvent(rawData) {
     return {
         // event_type is the event-class discriminator, validated strictly so a
         // mis-routed frame is rejected rather than parsed as a liquidation. The
-        // free-form value fields in the payload (status/accountState) stay lenient
+        // free-form value fields in the payload (status/riskBucketState) stay lenient
         // so an unexpected *value* never drops a risk-critical alert.
         eventType: readEnum(rawData, "event_type", ["liquidation_alert"]),
         userId: readString(rawData, "user_id"),
@@ -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

@@ -62,6 +62,7 @@ export declare const COVERED: {
     get_rewards_balance: string;
     get_my_referral_position: string;
     get_my_referral_downline: string;
+    get_my_referral_tree: string;
     get_self_trade_prevention_default: string;
     get_trader_code_info: string;
     set_self_trade_prevention_default: string;
@@ -132,6 +133,12 @@ export declare const COVERED: {
     transfer_collateral_to_margin_account: string;
     transfer_collateral_to_parent_margin_account: string;
     transfer_collateral_to_risk_bucket: string;
+    create_sub_account: string;
+    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

@@ -62,6 +62,7 @@ export const COVERED = {
     get_rewards_balance: "pitpass.getRewardsBalance",
     get_my_referral_position: "pitpass.getMyReferralPosition",
     get_my_referral_downline: "pitpass.getMyReferralDownline",
+    get_my_referral_tree: "pitpass.getMyReferralTree",
     get_self_trade_prevention_default: "profile.getSelfTradePreventionDefault",
     get_trader_code_info: "pitpass.getTraderCodeInfo",
     set_self_trade_prevention_default: "profile.setSelfTradePreventionDefault",
@@ -132,6 +133,12 @@ export const COVERED = {
     transfer_collateral_to_margin_account: "transferCollateralToMarginAccount",
     transfer_collateral_to_parent_margin_account: "transferCollateralToParentMarginAccount",
     transfer_collateral_to_risk_bucket: "transferCollateralToRiskBucket",
+    create_sub_account: "createMarginSubAccount",
+    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);