@0xmonaco/core 1.0.74 → 1.0.76

package/dist/api/trades/api.d.ts

@@ -26,23 +26,54 @@ export declare function parseRawTradeEvent(raw: RawTradeEvent): TradeEvent;
  * Options for fetching trades
  */
 export interface GetTradesOptions {
-    /** Page number (starts from 1, default: 1) */
-    page?: number;
-    /** Maximum number of records to return (default: 25, max: 100) */
+    /** Maximum number of records to return (default: 25, max: 1000) */
     pageSize?: number;
+    /**
+     * Cursor from a previous response's `nextPageToken`. Omit (or pass "") to
+     * start at the most recent trade.
+     */
+    pageToken?: string;
+}
+/**
+ * One page of a pair's trade feed.
+ *
+ * `nextPageToken` is empty exactly when the walk is finished — the server
+ * over-fetches one row to prove it — so a caller can stop on the empty token
+ * without a confirming extra request.
+ */
+export interface GetTradesPage {
+    /** Trades in this page, newest first. */
+    trades: TradeEvent[];
+    /** Cursor to pass as `pageToken` for the next page; "" when exhausted. */
+    nextPageToken: string;
 }
 /**
  * Trades API for fetching historical trade data
  */
 export declare class TradesAPIImpl extends BaseAPI {
     /**
-     * Get historical trades for a trading pair
+     * Get one page of historical trades for a trading pair.
+     *
+     * Cursor paged (0XM-2821): the page number was removed because `trades` is
+     * appended to continuously, so an offset silently repeated the newest trades
+     * as fills landed mid-walk. Start with no `pageToken` and follow
+     * `nextPageToken` until it comes back empty.
      *
      * @param tradingPairId - The trading pair UUID
-     * @param options - Pagination options
-     * @returns Array of TradeEvent records sorted by executedAt descending (newest first)
+     * @param options - Cursor pagination options
+     * @returns One page of TradeEvent records sorted by executedAt descending (newest first), plus the next cursor
+     *
+     * @example
+     * ```typescript
+     * let pageToken: string | undefined;
+     * do {
+     *   const page = await sdk.trades.getTrades(pairId, { pageSize: 100, pageToken });
+     *   handle(page.trades);
+     *   pageToken = page.nextPageToken || undefined;
+     * } while (pageToken);
+     * ```
      */
-    getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<TradeEvent[]>;
+    getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<GetTradesPage>;
     /**
      * Get a single trade by its UUID.
      *

package/dist/api/trades/api.js

@@ -1,3 +1,4 @@
+import { GetTradesSchema, validate } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 /**
@@ -22,23 +23,49 @@ export function parseRawTradeEvent(raw) {
  */
 export class TradesAPIImpl extends BaseAPI {
     /**
-     * Get historical trades for a trading pair
+     * Get one page of historical trades for a trading pair.
+     *
+     * Cursor paged (0XM-2821): the page number was removed because `trades` is
+     * appended to continuously, so an offset silently repeated the newest trades
+     * as fills landed mid-walk. Start with no `pageToken` and follow
+     * `nextPageToken` until it comes back empty.
      *
      * @param tradingPairId - The trading pair UUID
-     * @param options - Pagination options
-     * @returns Array of TradeEvent records sorted by executedAt descending (newest first)
+     * @param options - Cursor pagination options
+     * @returns One page of TradeEvent records sorted by executedAt descending (newest first), plus the next cursor
+     *
+     * @example
+     * ```typescript
+     * let pageToken: string | undefined;
+     * do {
+     *   const page = await sdk.trades.getTrades(pairId, { pageSize: 100, pageToken });
+     *   handle(page.trades);
+     *   pageToken = page.nextPageToken || undefined;
+     * } while (pageToken);
+     * ```
      */
     async getTrades(tradingPairId, options = {}) {
-        const { page = 1 } = options;
-        // Ensure pageSize is a positive number between 1 and 100, defaulting to 25
-        const pageSize = options.pageSize != null && options.pageSize > 0 ? Math.min(options.pageSize, 100) : 25;
+        validate(GetTradesSchema, options);
         const params = new URLSearchParams();
-        if (page > 1) {
-            params.set("page", String(page));
+        // Only send what the caller set: the server owns the 25 default, so
+        // restating it here would pin the SDK to a value the API can move.
+        if (options.pageSize != null) {
+            params.set("pageSize", String(options.pageSize));
+        }
+        if (options.pageToken != null && options.pageToken !== "") {
+            params.set("pageToken", options.pageToken);
         }
-        params.set("pageSize", String(pageSize));
-        const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
-        return response.trades.map(parseRawTradeEvent);
+        const query = params.toString();
+        const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}${query === "" ? "" : `?${query}`}`);
+        return {
+            // `?? []` because an empty page omits `trades` entirely; without it the
+            // last page of a walk would throw instead of ending it.
+            trades: (response.trades ?? []).map(parseRawTradeEvent),
+            // Absent rather than "" on a wire that omits empty strings: either way the
+            // walk is finished, and a caller testing `nextPageToken || undefined`
+            // must not see `undefined` become a truthy string.
+            nextPageToken: response.nextPageToken ?? "",
+        };
     }
     /**
      * Get a single trade by its UUID.

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}).
@@ -360,6 +399,7 @@ function parseMarketStatsData(raw) {
         bestAskPrice: readOptionalString(data, "bestAskPrice"),
         openInterest: readOptionalString(data, "openInterest"),
         openInterestLimit: readOptionalString(data, "openInterestLimit"),
+        openInterestHeadroom: readOptionalString(data, "openInterestHeadroom"),
         lastTradePrice: readOptionalString(data, "lastTradePrice"),
         dailyBaseTokenVolume: readOptionalString(data, "dailyBaseTokenVolume"),
         dailyQuoteTokenVolume: readOptionalString(data, "dailyQuoteTokenVolume"),
@@ -374,6 +414,11 @@ function parseMarketStatsData(raw) {
         baseInterestRate: readOptionalString(data, "baseInterestRate"),
         fundingClampSmall: readOptionalString(data, "fundingClampSmall"),
         fundingClampBig: readOptionalString(data, "fundingClampBig"),
+        // Lenient like the summary's marketStatus: an unrecognized value passes
+        // through rather than dropping the frame.
+        marketStatus: readOptionalString(data, "marketStatus"),
+        fundingIntervalSeconds: readOptionalNumber(data, "fundingIntervalSeconds"),
+        lastFundingTime: readOptionalNumber(data, "lastFundingTime"),
     };
 }
 function parseMarketStatsEvent(rawData) {
@@ -451,6 +496,17 @@ function parseInstrumentEventData(raw) {
         // non-string value still throws.
         baseIconUrl: readOptionalString(data, "baseIconUrl") ?? null,
         quoteIconUrl: readOptionalString(data, "quoteIconUrl") ?? null,
+        // Asset identity and minLeverage: a server that predates them omits the
+        // keys, so absent reads as `undefined` and never as a made-up `0` or `""`.
+        baseAssetId: readOptionalString(data, "baseAssetId"),
+        quoteAssetId: readOptionalString(data, "quoteAssetId"),
+        baseToken: readOptionalString(data, "baseToken"),
+        quoteToken: readOptionalString(data, "quoteToken"),
+        baseAssetName: readOptionalString(data, "baseAssetName"),
+        quoteAssetName: readOptionalString(data, "quoteAssetName"),
+        baseDecimals: readOptionalNumber(data, "baseDecimals"),
+        quoteDecimals: readOptionalNumber(data, "quoteDecimals"),
+        minLeverage: readOptionalString(data, "minLeverage"),
         maxLeverage: readOptionalString(data, "maxLeverage"),
         initialMarginRate: readOptionalString(data, "initialMarginRate"),
         maintenanceMarginRate: readOptionalString(data, "maintenanceMarginRate"),
@@ -772,6 +828,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 +883,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 +895,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 +975,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 +1003,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 +1140,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 +1151,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 +1224,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 +1236,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 +1256,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 +1290,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 +1633,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 +1646,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/api/withdrawals/api.js

@@ -1,3 +1,4 @@
+import { ListPendingWithdrawalsSchema, validate } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 /**
@@ -30,6 +31,7 @@ export class WithdrawalsAPIImpl extends BaseAPI {
     async listPendingWithdrawals(params) {
         // The gateway serves camelCase (the REST wire format), which matches the
         // public surface, so the response is returned directly with no remapping.
-        return this.makeAuthenticatedRequest(perpRoutes.withdrawals.list({ page: params?.page, pageSize: params?.pageSize }));
+        validate(ListPendingWithdrawalsSchema, params ?? {});
+        return this.makeAuthenticatedRequest(perpRoutes.withdrawals.list({ pageSize: params?.pageSize, pageToken: params?.pageToken }));
     }
 }

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.76",
 	"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.76",
+		"@0xmonaco/types": "1.0.76",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"