@0xmonaco/core 1.0.25 → 1.0.26-develop.aeb6d5b

package/dist/api/faucet/api.d.ts

@@ -12,7 +12,7 @@
  * const { minted, failed, remainingRequests24h } = await sdk.faucet.mint({ turnstileToken });
  * ```
  */
-import type { FaucetAPI, MintTokensParams, MintTokensResponse } from "@0xmonaco/types";
+import type { FaucetAPI, GetFaucetInfoResponse, MintTokensParams, MintTokensResponse } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class FaucetAPIImpl extends BaseAPI implements FaucetAPI {
     /**
@@ -30,4 +30,15 @@ export declare class FaucetAPIImpl extends BaseAPI implements FaucetAPI {
      * @returns Promise resolving to the minted tokens and remaining quota
      */
     mint(params: MintTokensParams): Promise<MintTokensResponse>;
+    /**
+     * Fetches the authenticated wallet's faucet quota and recent requests.
+     *
+     * Read-only: remaining requests in the rolling 24h window, when the next
+     * request becomes available (`nextAvailableAt`, absent when nothing is in
+     * the window), and the 5 most recent requests. Wallet-scoped across apps,
+     * matching mint enforcement.
+     *
+     * @returns Promise resolving to the quota and recent-request history
+     */
+    getInfo(): Promise<GetFaucetInfoResponse>;
 }

package/dist/api/faucet/api.js

@@ -35,4 +35,19 @@ export class FaucetAPIImpl extends BaseAPI {
             body: JSON.stringify({ turnstileToken: params.turnstileToken }),
         });
     }
+    /**
+     * Fetches the authenticated wallet's faucet quota and recent requests.
+     *
+     * Read-only: remaining requests in the rolling 24h window, when the next
+     * request becomes available (`nextAvailableAt`, absent when nothing is in
+     * the window), and the 5 most recent requests. Wallet-scoped across apps,
+     * matching mint enforcement.
+     *
+     * @returns Promise resolving to the quota and recent-request history
+     */
+    async getInfo() {
+        return await this.makeAuthenticatedRequest(perpRoutes.faucet.info(), {
+            method: "GET",
+        });
+    }
 }

package/dist/api/fees/api.d.ts

@@ -36,7 +36,7 @@ export declare class FeesAPIImpl extends BaseAPI implements FeesAPI {
      * @param params.price - The price per unit as string
      * @param params.quantity - The quantity to trade as string
      * @param params.orderType - Order type: "LIMIT" (default) or "MARKET"
-     * @param params.slippageToleranceBps - Slippage tolerance in bps (0–1000, MARKET only, default 500)
+     * @param params.slippageToleranceBps - Slippage tolerance in bps (0–1000, MARKET only, default 1000)
      * @returns Promise resolving to SimulateFeeResponse with fee breakdown
      *
      * @example

package/dist/api/fees/api.js

@@ -36,7 +36,7 @@ export class FeesAPIImpl extends BaseAPI {
      * @param params.price - The price per unit as string
      * @param params.quantity - The quantity to trade as string
      * @param params.orderType - Order type: "LIMIT" (default) or "MARKET"
-     * @param params.slippageToleranceBps - Slippage tolerance in bps (0–1000, MARKET only, default 500)
+     * @param params.slippageToleranceBps - Slippage tolerance in bps (0–1000, MARKET only, default 1000)
      * @returns Promise resolving to SimulateFeeResponse with fee breakdown
      *
      * @example

package/dist/api/index.d.ts

@@ -16,6 +16,7 @@ export * from "./pitpass";
 export * from "./portfolio";
 export * from "./positions";
 export * from "./profile";
+export * from "./pulse";
 export * from "./sub-accounts";
 export * from "./trades";
 export * from "./trading";

package/dist/api/index.js

@@ -16,6 +16,7 @@ export * from "./pitpass";
 export * from "./portfolio";
 export * from "./positions";
 export * from "./profile";
+export * from "./pulse";
 export * from "./sub-accounts";
 export * from "./trades";
 export * from "./trading";

package/dist/api/market/api.d.ts

@@ -1,4 +1,4 @@
-import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingMode, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListAllFundingHistoryParams, ListAllFundingHistoryResponse, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingMode, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -17,6 +17,7 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getIndexPrice(tradingPairId: string): Promise<IndexPrice>;
     getFundingState(tradingPairId: string): Promise<FundingState>;
     listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
+    listAllFundingHistory(params?: ListAllFundingHistoryParams): Promise<ListAllFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
     getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
     getMarketStats(): Promise<MarketStats>;

package/dist/api/market/api.js

@@ -100,6 +100,9 @@ export class MarketAPIImpl extends BaseAPI {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.listFundingHistory(tradingPairId, params));
     }
+    async listAllFundingHistory(params) {
+        return await this.makePublicRequest(perpRoutes.market.listAllFundingHistory(params));
+    }
     async getOpenInterest(tradingPairId) {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.getOpenInterest(tradingPairId));

package/dist/api/perp/routes.d.ts

@@ -67,6 +67,14 @@ export declare const perpRoutes: {
             endTime?: string;
             page?: number;
             pageSize?: number;
+            orderBy?: string;
+        }) => string;
+        readonly listAllFundingHistory: (params?: {
+            startTime?: string;
+            endTime?: string;
+            page?: number;
+            pageSize?: number;
+            orderBy?: string;
         }) => string;
         readonly getOpenInterest: (tradingPairId: string) => string;
         readonly getScreener: (params?: {
@@ -142,6 +150,7 @@ export declare const perpRoutes: {
     };
     readonly faucet: {
         readonly mint: () => string;
+        readonly info: () => string;
     };
     readonly whitelist: {
         readonly submit: () => string;

package/dist/api/perp/routes.js

@@ -52,6 +52,7 @@ export const perpRoutes = {
         getIndexPrice: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/index-price`,
         getFundingState: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding`,
         listFundingHistory: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding/history`, params),
+        listAllFundingHistory: (params) => withQuery(`${API_V1}/market/funding/history`, params),
         getOpenInterest: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/open-interest`,
         getScreener: (params) => withQuery(`${API_V1}/market/screener`, params),
         getMarketStats: () => `${API_V1}/market/stats`,
@@ -79,6 +80,7 @@ export const perpRoutes = {
     },
     faucet: {
         mint: () => `${API_V1}/faucet/mint`,
+        info: () => `${API_V1}/faucet/info`,
     },
     whitelist: {
         submit: () => `${API_V1}/whitelist`,

package/dist/api/positions/api.js

@@ -70,6 +70,7 @@ export class PositionsAPIImpl extends BaseAPI {
                         orderType: request.takeProfit.orderType,
                         limitPrice: request.takeProfit.limitPrice,
                         quantity: request.takeProfit.quantity,
+                        closePosition: request.takeProfit.closePosition,
                         timeInForce: request.takeProfit.timeInForce,
                         slippageToleranceBps: request.takeProfit.slippageToleranceBps,
                         expiresAt: request.takeProfit.expiresAt,
@@ -81,11 +82,13 @@ export class PositionsAPIImpl extends BaseAPI {
                         orderType: request.stopLoss.orderType,
                         limitPrice: request.stopLoss.limitPrice,
                         quantity: request.stopLoss.quantity,
+                        closePosition: request.stopLoss.closePosition,
                         timeInForce: request.stopLoss.timeInForce,
                         slippageToleranceBps: request.stopLoss.slippageToleranceBps,
                         expiresAt: request.stopLoss.expiresAt,
                     }
                     : undefined,
+                oco: request.oco,
             }),
         });
     }

package/dist/api/profile/api.d.ts

@@ -173,6 +173,11 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * @param params.page - Page number (starts from 1, default: 1)
      * @param params.pageSize - Number of items per page (default: 20, max: 100)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
+     * @param params.pageToken - Pagination cursor (optional): omit for legacy page-number
+     * pagination; pass `""` to start a cursor walk from the newest row; pass a previous
+     * response's `nextPageToken` to resume. Any cursor-walk value (`""` or non-empty)
+     * ignores `page` and covers full trade history (hot and archived rows merged), unlike
+     * page-number mode.
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
      * @throws {APIError} When the request fails or user is not authenticated

package/dist/api/profile/api.js

@@ -224,6 +224,11 @@ export class ProfileAPIImpl extends BaseAPI {
      * @param params.page - Page number (starts from 1, default: 1)
      * @param params.pageSize - Number of items per page (default: 20, max: 100)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
+     * @param params.pageToken - Pagination cursor (optional): omit for legacy page-number
+     * pagination; pass `""` to start a cursor walk from the newest row; pass a previous
+     * response's `nextPageToken` to resume. Any cursor-walk value (`""` or non-empty)
+     * ignores `page` and covers full trade history (hot and archived rows merged), unlike
+     * page-number mode.
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
      * @throws {APIError} When the request fails or user is not authenticated
@@ -252,6 +257,9 @@ export class ProfileAPIImpl extends BaseAPI {
         if (params?.tradingPairId !== undefined) {
             searchParams.append("tradingPairId", params.tradingPairId);
         }
+        if (params?.pageToken !== undefined) {
+            searchParams.append("pageToken", params.pageToken);
+        }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/trades?${queryString}` : "/api/v1/accounts/trades";
         return await this.makeAuthenticatedRequest(url);

package/dist/api/pulse/api.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pulse API Implementation
+ *
+ * Read-only access to the market-pulse news feed: AI-synthesized, per-asset
+ * headlines with sentiment tags, served from the backend's hourly-refreshed
+ * cache. Public — no authentication required.
+ *
+ * @example
+ * ```typescript
+ * const pulse = await sdk.pulse.getPulse();
+ * for (const item of pulse.items) {
+ *   console.log(`[${item.sentiment}] ${item.asset}: ${item.summary}`);
+ * }
+ * ```
+ */
+import type { GetPulseResponse, PulseAPI } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class PulseAPIImpl extends BaseAPI implements PulseAPI {
+    /**
+     * Get the latest market pulse snapshot (public, no auth headers).
+     * Returns 503 while the backend cache is cold.
+     */
+    getPulse(): Promise<GetPulseResponse>;
+}

package/dist/api/pulse/api.js

@@ -0,0 +1,27 @@
+/**
+ * Pulse API Implementation
+ *
+ * Read-only access to the market-pulse news feed: AI-synthesized, per-asset
+ * headlines with sentiment tags, served from the backend's hourly-refreshed
+ * cache. Public — no authentication required.
+ *
+ * @example
+ * ```typescript
+ * const pulse = await sdk.pulse.getPulse();
+ * for (const item of pulse.items) {
+ *   console.log(`[${item.sentiment}] ${item.asset}: ${item.summary}`);
+ * }
+ * ```
+ */
+import { BaseAPI } from "../base";
+export class PulseAPIImpl extends BaseAPI {
+    /**
+     * Get the latest market pulse snapshot (public, no auth headers).
+     * Returns 503 while the backend cache is cold.
+     */
+    async getPulse() {
+        return await this.makePublicRequest("/api/v1/pulse", {
+            method: "GET",
+        });
+    }
+}

package/dist/api/pulse/index.d.ts

@@ -0,0 +1 @@
+export { PulseAPIImpl } from "./api";

package/dist/api/pulse/index.js

@@ -0,0 +1 @@
+export { PulseAPIImpl } from "./api";

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

@@ -93,15 +93,17 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
      * Places a market order for immediate execution.
      *
-     * Market orders execute immediately at the current market price. They provide
-     * immediate execution but may experience slippage.
+     * Market orders execute immediately against available liquidity, inside a
+     * mandatory 1,000 bps server-side protective price band. Fills beyond the band
+     * are cut off, so an order may partially fill and cancel the remainder, or be
+     * rejected when no liquidity sits inside the band.
      *
      * @param tradingPairId - The trading pair UUID
      * @param side - The order side ("BUY" or "SELL")
      * @param quantity - The order quantity as string
      * @param options - Optional parameters for the market order
      * @param options.tradingMode - Trading mode (e.g., "SPOT")
-     * @param options.slippageTolerance - Slippage tolerance as decimal (e.g., 0.01 for 1%, 0 for best price only, undefined for unlimited slippage)
+     * @param options.slippageTolerance - Tightens the mandatory 1,000 bps price band, as a decimal (e.g., 0.01 for 1%; 0 for best price only). It can only tighten the band, never widen it; omitting it applies the full 1,000 bps band.
      * @returns Promise resolving to CreateOrderResponse with order details
      *
      * @example
@@ -122,12 +124,12 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      *   { slippageTolerance: 0 } // Only execute at best ask price
      * );
      *
-     * // Market order with unlimited slippage
+     * // Market order with the default protective band (no client tightening)
      * const order3 = await tradingAPI.placeMarketOrder(
      *   "123e4567-e89b-12d3-a456-426614174000",
      *   "BUY",
      *   "1.0"
-     *   // No slippageTolerance specified = unlimited slippage
+     *   // No slippageTolerance specified = full 1,000 bps band applies
      * );
      * ```
      */
@@ -268,6 +270,11 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * @param params.tradingPairId - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
      * @param params.pageSize - Number of orders per page (defaults to 10, max 100, must be > 0)
+     * @param params.pageToken - Pagination cursor (optional): omit for legacy page-number
+     * pagination; pass `""` to start a cursor walk from the newest (or oldest, for
+     * `orderBy: "ASC"`) row; pass a previous response's `nextPageToken` to resume. Any
+     * cursor-walk value (`""` or non-empty) ignores `page` and covers full order history
+     * (hot and archived rows merged), unlike page-number mode.
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *

package/dist/api/trading/api.js

@@ -125,15 +125,17 @@ export class TradingAPIImpl extends BaseAPI {
     /**
      * Places a market order for immediate execution.
      *
-     * Market orders execute immediately at the current market price. They provide
-     * immediate execution but may experience slippage.
+     * Market orders execute immediately against available liquidity, inside a
+     * mandatory 1,000 bps server-side protective price band. Fills beyond the band
+     * are cut off, so an order may partially fill and cancel the remainder, or be
+     * rejected when no liquidity sits inside the band.
      *
      * @param tradingPairId - The trading pair UUID
      * @param side - The order side ("BUY" or "SELL")
      * @param quantity - The order quantity as string
      * @param options - Optional parameters for the market order
      * @param options.tradingMode - Trading mode (e.g., "SPOT")
-     * @param options.slippageTolerance - Slippage tolerance as decimal (e.g., 0.01 for 1%, 0 for best price only, undefined for unlimited slippage)
+     * @param options.slippageTolerance - Tightens the mandatory 1,000 bps price band, as a decimal (e.g., 0.01 for 1%; 0 for best price only). It can only tighten the band, never widen it; omitting it applies the full 1,000 bps band.
      * @returns Promise resolving to CreateOrderResponse with order details
      *
      * @example
@@ -154,12 +156,12 @@ export class TradingAPIImpl extends BaseAPI {
      *   { slippageTolerance: 0 } // Only execute at best ask price
      * );
      *
-     * // Market order with unlimited slippage
+     * // Market order with the default protective band (no client tightening)
      * const order3 = await tradingAPI.placeMarketOrder(
      *   "123e4567-e89b-12d3-a456-426614174000",
      *   "BUY",
      *   "1.0"
-     *   // No slippageTolerance specified = unlimited slippage
+     *   // No slippageTolerance specified = full 1,000 bps band applies
      * );
      * ```
      */
@@ -417,6 +419,11 @@ export class TradingAPIImpl extends BaseAPI {
      * @param params.tradingPairId - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
      * @param params.pageSize - Number of orders per page (defaults to 10, max 100, must be > 0)
+     * @param params.pageToken - Pagination cursor (optional): omit for legacy page-number
+     * pagination; pass `""` to start a cursor walk from the newest (or oldest, for
+     * `orderBy: "ASC"`) row; pass a previous response's `nextPageToken` to resume. Any
+     * cursor-walk value (`""` or non-empty) ignores `page` and covers full order history
+     * (hot and archived rows merged), unlike page-number mode.
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -441,7 +448,7 @@ export class TradingAPIImpl extends BaseAPI {
             validate(GetPaginatedOrdersSchema, params);
         }
         // Set pagination defaults with destructuring and validation
-        const { page = 1, pageSize: requestedPageSize = 10, status, tradingPairId, tradingMode, marginAccountId } = params || {};
+        const { page = 1, pageSize: requestedPageSize = 10, status, tradingPairId, tradingMode, marginAccountId, pageToken } = params || {};
         const validPage = page > 0 ? page : 1;
         const validPageSize = requestedPageSize > 0 ? requestedPageSize : 10;
         const pageSize = Math.min(validPageSize, 100);
@@ -461,6 +468,13 @@ export class TradingAPIImpl extends BaseAPI {
         if (marginAccountId) {
             searchParams.append("marginAccountId", marginAccountId);
         }
+        // `!== undefined` (not a truthy check): an explicitly-provided empty
+        // string is the documented way to start a cursor walk (distinct from
+        // omitting `pageToken` entirely), so it must still be sent rather than
+        // silently dropped like a falsy value would be.
+        if (pageToken !== undefined) {
+            searchParams.append("pageToken", pageToken);
+        }
         const endpoint = `/api/v1/orders?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {
             method: "GET",

package/dist/api/websocket/types.d.ts

@@ -1,15 +1,51 @@
 import type { ConditionalOrderEvent, Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, SessionCredentials, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
 export type StatusHandler = (status: WebSocketStatus) => void;
 export type MessageHandler<T> = (data: T) => void;
+/**
+ * Why the connection was re-established. Delivered by
+ * {@link MonacoWebSocketOptions.onResync} after the client has reconnected,
+ * re-authenticated, and re-subscribed — the point where the app should
+ * refetch REST snapshots and reconcile by `(id, updatedAt)`.
+ */
+export interface WebSocketResyncInfo {
+    /** WebSocket close code of the connection that was lost. */
+    code: number;
+    /**
+     * True when the server closed with 1013 (try again later): the client fell
+     * behind a sequential stream (orders, conditional orders, liquidations,
+     * trades, movements) and the stream has a gap. There is no wire sequence
+     * number — the 1013 close is the gap signal, and a snapshot refetch is the
+     * only safe repair.
+     */
+    slowClient: boolean;
+}
+export type ResyncHandler = (info: WebSocketResyncInfo) => void;
 export interface MonacoWebSocketOptions {
     /** Session keypair for authenticated channels (orders, balances, etc.) */
     session?: SessionCredentials;
     /** Enable auto-reconnect on disconnect (default: true) */
     autoReconnect?: boolean;
-    /** Maximum reconnection attempts (default: 5) */
+    /**
+     * Maximum reconnection attempts (default: unlimited). Retry delay is
+     * full-jitter exponential backoff capped at 30s, so unlimited retries are
+     * capped-rate, not a tight loop.
+     */
     maxReconnectAttempts?: number;
+    /** Base delay for the exponential backoff in milliseconds (default: 1000) */
+    reconnectBaseDelayMs?: number;
+    /** How long a connection attempt may stay CONNECTING before it is failed
+     * and retried, in milliseconds (default: 10000) */
+    connectionTimeoutMs?: number;
     /** Callback for connection status changes */
     onStatusChange?: StatusHandler;
+    /**
+     * Called after every automatic reconnect once the live stream is resumed
+     * (re-authenticated and re-subscribed). Refetch REST snapshots here and
+     * reconcile by `(id, updatedAt)`, last-writer-wins; events that arrived
+     * while the snapshot was in flight are newer than the snapshot rows they
+     * duplicate.
+     */
+    onResync?: ResyncHandler;
 }
 export interface MonacoWebSocket {
     /** Connect to the WebSocket server */

package/dist/api/websocket/websocket.js

@@ -6,6 +6,7 @@ import { keysToCamelCase } from "./utils";
 const CONNECTION_TIMEOUT = 10000;
 const HEARTBEAT_INTERVAL = 15000;
 const MAX_RECONNECT_DELAY = 30000;
+const RECONNECT_BASE_DELAY = 1000;
 const CONDITIONAL_ORDER_REASONS = ["created", "activated", "cancelled", "parent_cancelled", "triggered", "failed", "oco_cancelled"];
 const CONDITIONAL_ORDER_CONDITION_TYPES = ["STOP_LOSS", "TAKE_PROFIT"];
 const CONDITIONAL_ORDER_TRIGGER_SOURCES = ["MARK_PRICE"];
@@ -114,19 +115,33 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
     let reconnectTimer = null;
     let heartbeatTimer = null;
     let autoReconnect = options.autoReconnect ?? true;
-    const maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    // Capped-infinite by default: unlimited attempts, delay capped at 30s. A
+    // client that gives up permanently (the old 5-attempt default) turns any
+    // blip longer than ~1 minute into a dead app.
+    const maxReconnectAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+    // Normalize to a positive finite base: a negative/NaN/Infinity override
+    // would degenerate into a tight reconnect loop or no reconnect at all.
+    const reconnectBaseDelay = Number.isFinite(options.reconnectBaseDelayMs) && options.reconnectBaseDelayMs > 0
+        ? options.reconnectBaseDelayMs
+        : RECONNECT_BASE_DELAY;
+    const connectionTimeout = Number.isFinite(options.connectionTimeoutMs) && options.connectionTimeoutMs > 0 ? options.connectionTimeoutMs : CONNECTION_TIMEOUT;
+    // Close code of the connection loss the next successful reopen recovers
+    // from; null when no resync is owed (first connect, clean disconnect).
+    let pendingResyncCode = null;
     // Handler storage: channel -> set of handlers (supports multiple subscribers per channel)
     const handlers = new Map();
     const getStatus = () => {
         if (!ws)
-            return "disconnected";
+            return reconnectTimer ? "reconnecting" : "disconnected";
         switch (ws.readyState) {
             case WebSocket.CONNECTING:
                 return "connecting";
             case WebSocket.OPEN:
                 return "connected";
             default:
-                return "disconnected";
+                // CLOSING/CLOSED with a retry armed is mid-outage, not terminal:
+                // the timeout path arms the retry before the close event lands.
+                return reconnectTimer ? "reconnecting" : "disconnected";
         }
     };
     const getUrl = () => baseUrl;
@@ -169,17 +184,35 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         }
     };
     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) {
             console.error("WebSocket: Max reconnect attempts reached");
             return;
         }
+        // Full-jitter exponential backoff: uniform in [0, min(base * 2^n, cap)],
+        // n starting at 0 so the first retry's ceiling is the base itself.
+        // Jitter desynchronizes the reconnect storm after a server deploy or a
+        // mass 1013 shed — synchronized clients would otherwise reconnect in
+        // lockstep waves.
+        const ceiling = Math.min(reconnectBaseDelay * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY);
         reconnectAttempts++;
-        const delay = Math.min(1000 * 2 ** reconnectAttempts, MAX_RECONNECT_DELAY);
+        const delay = Math.random() * ceiling;
         reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            // Re-check: a callback already dequeued when disconnect() ran is not
+            // stopped by clearTimeout and must not reopen a socket.
+            if (!autoReconnect)
+                return;
             connect().catch((err) => {
                 console.warn("WebSocket: Failed to reconnect:", err);
+                scheduleReconnect();
             });
         }, delay);
+        options.onStatusChange?.("reconnecting");
     };
     const send = (data) => {
         if (ws?.readyState === WebSocket.OPEN) {
@@ -223,7 +256,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         socket.close(1000, "Connection timeout");
                         reject(new Error("WebSocket connection timeout"));
                     }
-                }, CONNECTION_TIMEOUT);
+                }, connectionTimeout);
                 socket.onopen = () => {
                     clearTimeout(timeout);
                     if (ws !== socket) {
@@ -231,12 +264,26 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         return;
                     }
                     reconnectAttempts = 0;
+                    // 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
+                    // close.
+                    stopReconnect();
                     startHeartbeat();
                     // Authenticate before resubscribing so user-specific channels
                     // (orders, balances, …) are authorized when the Subscribe arrives.
                     sendAuthenticate();
                     resubscribeAll();
                     options.onStatusChange?.("connected");
+                    // Resync-join order: resume the live stream first (auth +
+                    // subscribe above), then tell the app to refetch snapshots and
+                    // reconcile by (id, updatedAt) — events racing the snapshot are
+                    // newer than the rows they duplicate.
+                    if (pendingResyncCode !== null) {
+                        const code = pendingResyncCode;
+                        pendingResyncCode = null;
+                        options.onResync?.({ code, slowClient: code === 1013 });
+                    }
                     resolve();
                 };
                 socket.onmessage = (event) => {
@@ -247,6 +294,12 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                         // Handle pong silently
                         if (msg.type === "Pong")
                             return;
+                        // Answer a server-initiated application ping: the server owns
+                        // liveness through proxy idle timeouts, the client just echoes.
+                        if (msg.type === "Ping") {
+                            send({ type: "Pong" });
+                            return;
+                        }
                         routeMessage(msg);
                     }
                     catch (err) {
@@ -261,11 +314,22 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                     }
                     ws = null;
                     stopHeartbeat();
-                    options.onStatusChange?.("disconnected");
-                    // Reconnect on abnormal close
+                    // Reconnect on abnormal close. 1013 is the server's slow-client
+                    // shed: the stream has a gap, so the reopen owes the app a resync.
+                    // Keep the first owed code (upgrading to 1013 if it arrives later):
+                    // failures of the reconnect attempts themselves must not launder
+                    // the slow-client signal into a generic 1006.
                     if (autoReconnect && event.code !== 1000) {
+                        if (pendingResyncCode === null || event.code === 1013) {
+                            pendingResyncCode = event.code;
+                        }
                         scheduleReconnect();
                     }
+                    // "disconnected" is terminal: suppressed while a retry is armed
+                    // (scheduleReconnect emitted "reconnecting" instead).
+                    if (!reconnectTimer) {
+                        options.onStatusChange?.("disconnected");
+                    }
                 };
                 socket.onerror = () => clearTimeout(timeout);
             }
@@ -279,6 +343,7 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         autoReconnect = false;
         stopReconnect();
         stopHeartbeat();
+        pendingResyncCode = null;
         handlers.clear();
         ws?.close(1000, "Client disconnect");
         ws = null;

package/dist/coverage.d.ts

@@ -21,6 +21,7 @@ export declare const COVERED: {
     get_application_stats: string;
     get_available_collateral: string;
     get_candles: string;
+    get_faucet_info: string;
     get_funding_state: string;
     get_index_price: string;
     get_margin_account_movements: string;
@@ -29,6 +30,7 @@ export declare const COVERED: {
     get_market_metadata: string;
     get_market_stats: string;
     get_my_fee_tier: string;
+    get_pulse: string;
     get_my_trader_code: string;
     get_rewards_balance: string;
     get_trader_code_info: string;
@@ -63,6 +65,7 @@ export declare const COVERED: {
     get_withdrawal: string;
     initiate_withdrawal: string;
     list_pending_withdrawals: string;
+    list_all_funding_history: string;
     list_application_balances: string;
     list_application_movements: string;
     list_application_orders: string;

package/dist/coverage.js

@@ -21,6 +21,7 @@ export const COVERED = {
     get_application_stats: "getApplicationStats",
     get_available_collateral: "getAvailableCollateral",
     get_candles: "getCandlesticks",
+    get_faucet_info: "faucet.getInfo",
     get_funding_state: "getFundingState",
     get_index_price: "getIndexPrice",
     get_margin_account_movements: "getMarginAccountMovements",
@@ -29,6 +30,7 @@ export const COVERED = {
     get_market_metadata: "getMarketMetadata",
     get_market_stats: "getMarketStats",
     get_my_fee_tier: "getMyFeeTier",
+    get_pulse: "pulse.getPulse",
     get_my_trader_code: "pitpass.getMyTraderCode",
     get_rewards_balance: "pitpass.getRewardsBalance",
     get_trader_code_info: "pitpass.getTraderCodeInfo",
@@ -63,6 +65,7 @@ export const COVERED = {
     get_withdrawal: "getWithdrawal",
     initiate_withdrawal: "initiateWithdrawal",
     list_pending_withdrawals: "listPendingWithdrawals",
+    list_all_funding_history: "listAllFundingHistory",
     list_application_balances: "listApplicationBalances",
     list_application_movements: "listApplicationMovements",
     list_application_orders: "listApplicationOrders",

package/dist/networks/networks.js

@@ -22,7 +22,10 @@ const DEFAULT_API_URLS = {
  */
 const DEFAULT_WS_URLS = {
     local: "ws://localhost:8085/ws",
-    development: "wss://develop.apimonaco.xyz/ws",
+    // Dedicated WebSocket ingress (NLB behind Cloudflare). The previous
+    // ALB path (wss://develop.apimonaco.xyz/ws) keeps working during the
+    // migration window.
+    development: "wss://ws-develop.apimonaco.xyz/ws",
     staging: "wss://staging.apimonaco.xyz/ws",
     mainnet: "wss://api.monaco.xyz/ws",
 };

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationsAPI, AuthAPI, AuthState, DelegatedAgentsAPI, FaucetAPI, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PitpassAPI, PortfolioAPI, PositionsAPI, ProfileAPI, SDKConfig, SubAccountsAPI, TradingAPI, VaultAPI, WhitelistAPI, WithdrawalsAPI } from "@0xmonaco/types";
+import type { ApplicationsAPI, AuthAPI, AuthState, DelegatedAgentsAPI, FaucetAPI, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PitpassAPI, PortfolioAPI, PositionsAPI, ProfileAPI, PulseAPI, SDKConfig, SubAccountsAPI, TradingAPI, VaultAPI, WhitelistAPI, WithdrawalsAPI } from "@0xmonaco/types";
 import { type Address, type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
@@ -18,6 +18,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     faucet: FaucetAPI;
     whitelist: WhitelistAPI;
     profile: ProfileAPI;
+    pulse: PulseAPI;
     orderbook: OrderbookAPIImpl;
     trades: TradesAPIImpl;
     ws: MonacoWebSocket;

package/dist/sdk.js

@@ -12,6 +12,7 @@ import { PitpassAPIImpl } from "./api/pitpass";
 import { PortfolioAPIImpl } from "./api/portfolio";
 import { PositionsAPIImpl } from "./api/positions";
 import { ProfileAPIImpl } from "./api/profile";
+import { PulseAPIImpl } from "./api/pulse";
 import { SubAccountsAPIImpl } from "./api/sub-accounts";
 import { TradingAPIImpl } from "./api/trading";
 import { VaultAPIImpl } from "./api/vault";
@@ -20,6 +21,13 @@ import { WithdrawalsAPIImpl } from "./api/withdrawals";
 import { generateSessionKeypair, privateKeyHex, publicKeyHex } from "./crypto/session";
 import { APIError, InvalidConfigError, InvalidStateError } from "./errors";
 import { resolveApiUrl, resolveWsUrl } from "./networks";
+/**
+ * Default receipt-polling frequency for the SDK's internal viem public client.
+ * Sei produces sub-second blocks, so viem's 4000ms default adds seconds of
+ * slack to every `waitForTransactionReceipt`; 750ms keeps waits near one to
+ * two blocks while staying gentle on public RPC endpoints.
+ */
+const DEFAULT_POLLING_INTERVAL_MS = 750;
 /** Validate a user-supplied URL override, returning it unchanged when valid. */
 function validateUrl(value, field) {
     try {
@@ -47,6 +55,7 @@ export class MonacoSDKImpl {
     faucet;
     whitelist;
     profile;
+    pulse;
     orderbook;
     trades;
     ws;
@@ -75,6 +84,7 @@ export class MonacoSDKImpl {
         this.subAccounts.setSessionKeypair(credentials);
         this.faucet.setSessionKeypair(credentials);
         this.whitelist.setSessionKeypair(credentials);
+        this.pulse.setSessionKeypair(credentials);
         this.profile.setSessionKeypair(credentials);
         this.orderbook.setSessionKeypair(credentials);
         this.trades.setSessionKeypair(credentials);
@@ -113,6 +123,7 @@ export class MonacoSDKImpl {
         this.subAccounts.setServerKey(serverKey);
         this.faucet.setServerKey(serverKey);
         this.whitelist.setServerKey(serverKey);
+        this.pulse.setServerKey(serverKey);
         this.profile.setServerKey(serverKey);
         this.orderbook.setServerKey(serverKey);
         this.trades.setServerKey(serverKey);
@@ -146,11 +157,15 @@ export class MonacoSDKImpl {
         // Use Sei mainnet chain only for "mainnet" network, testnet for everything else
         const chain = this.network === "mainnet" ? sei : seiTestnet;
         this.chain = chain;
+        if (cfg.pollingInterval !== undefined && (!Number.isFinite(cfg.pollingInterval) || cfg.pollingInterval <= 0)) {
+            throw new InvalidConfigError(`pollingInterval must be a positive number of milliseconds, got: ${cfg.pollingInterval}`, "pollingInterval");
+        }
         // Create public client with provided RPC URL
         const transport = http(cfg.seiRpcUrl);
         this.publicClient = createPublicClient({
             chain,
             transport,
+            pollingInterval: cfg.pollingInterval ?? DEFAULT_POLLING_INTERVAL_MS,
         });
         // Resolve the API URL: explicit override (validated) or network preset.
         const apiUrl = cfg.apiUrl ? validateUrl(cfg.apiUrl, "apiUrl") : resolveApiUrl(this.network);
@@ -170,6 +185,7 @@ export class MonacoSDKImpl {
         this.subAccounts = new SubAccountsAPIImpl(apiUrl);
         this.faucet = new FaucetAPIImpl(apiUrl);
         this.whitelist = new WhitelistAPIImpl(apiUrl);
+        this.pulse = new PulseAPIImpl(apiUrl);
         this.auth = new AuthAPIImpl(this.walletClient, this.chain, apiUrl);
         this.delegatedAgents = new DelegatedAgentsAPIImpl(apiUrl);
         this.fees = new FeesAPIImpl(apiUrl);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.25",
+	"version": "1.0.26-develop.aeb6d5b",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -23,8 +23,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.25",
-		"@0xmonaco/types": "1.0.25",
+		"@0xmonaco/contracts": "1.0.26-develop.aeb6d5b",
+		"@0xmonaco/types": "1.0.26-develop.aeb6d5b",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^1.8.0",
 		"http-status-codes": "^2.3.0"