@0xmonaco/core 1.0.73 → 1.0.74-develop.367860f

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"),
@@ -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) {
@@ -772,6 +817,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 +872,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 +884,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 +964,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 +992,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 +1129,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 +1140,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 +1213,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 +1225,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 +1245,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 +1279,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 +1622,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 +1635,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

@@ -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);

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.73",
+	"version": "1.0.74-develop.367860f",
 	"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.73",
-		"@0xmonaco/types": "1.0.73",
+		"@0xmonaco/contracts": "1.0.74-develop.367860f",
+		"@0xmonaco/types": "1.0.74-develop.367860f",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"