@0xmonaco/core 1.0.88 → 1.0.91

package/dist/api/base.d.ts

@@ -82,6 +82,7 @@ export declare abstract class BaseAPI {
      *
      * @param endpoint - The API endpoint to call (should start with /)
      * @param options - Request options (method, body, headers, etc.)
+     * @param resendDeadline - Epoch ms after which a clock-skew 401 is returned instead of re-signed
      * @returns Promise resolving to the response data
      * @throws {APIError} When access token is not set or API request fails
      *
@@ -100,7 +101,25 @@ export declare abstract class BaseAPI {
      * );
      * ```
      */
-    protected makeAuthenticatedRequest<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    protected makeAuthenticatedRequest<T>(endpoint: string, options?: RequestInit, resendDeadline?: number): Promise<T>;
+    /**
+     * Sends a keyed submission, re-sending the identical body while its outcome
+     * is unknown (network failure or a 5xx), for at most `maxRetries` extra
+     * attempts with exponential backoff.
+     *
+     * Only safe for a body that carries an `idempotencyKey`: the server replays
+     * the original result for a repeated key instead of executing again. A
+     * maintenance `OPERATIONS_BLOCKED` refusal and every 4xx are definitive and
+     * returned at once. A `Retry-After` beyond {@link MAX_SUBMISSION_RETRY_DELAY_MS},
+     * a resend later than {@link MAX_SUBMISSION_RETRY_WINDOW_MS} after the first
+     * send, or a session change during backoff also stops the loop: keys are
+     * scoped per account, so a resend signed by another session would be a new order.
+     *
+     * @throws {APIError} The last failure, naming the key to reuse, when every attempt is ambiguous
+     */
+    protected makeKeyedSubmission<T>(endpoint: string, options: RequestInit & {
+        body: string;
+    }): Promise<T>;
     /**
      * Compute the per-request ed25519 signature headers.
      *

package/dist/api/base.js

@@ -37,6 +37,56 @@ import { CLOCK_CORRECTION_THRESHOLD_MS, ServerClock } from "../utils/server-cloc
  * only takes effect in server runtimes (Node/undici, Bun, Deno).
  */
 const SDK_USER_AGENT = "@0xmonaco/core";
+/** Longest server-requested wait a keyed submission retry will honour. */
+const MAX_SUBMISSION_RETRY_DELAY_MS = 5000;
+/**
+ * Keyed submission retries stop this long after the first send, far inside
+ * the server's 15-minute key window even if a suspended tab stretches a wait.
+ */
+const MAX_SUBMISSION_RETRY_WINDOW_MS = 60_000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * True when a submission may or may not have been applied: no response came
+ * back at all, a 2xx body could not be read, or the server answered 5xx.
+ * Maintenance (`OPERATIONS_BLOCKED`) is a deliberate refusal before the book,
+ * not an unknown outcome.
+ */
+function isUnknownSubmissionOutcome(error) {
+    if (!(error instanceof APIError))
+        return false;
+    if (error.statusCode === undefined)
+        return error.cause !== undefined;
+    if (error.statusCode >= StatusCodes.OK && error.statusCode < StatusCodes.MULTIPLE_CHOICES)
+        return error.cause !== undefined;
+    if (error.statusCode < StatusCodes.INTERNAL_SERVER_ERROR)
+        return false;
+    const body = error.responseBody;
+    return !(body && typeof body === "object" && body.error === "OPERATIONS_BLOCKED");
+}
+function hasIdempotencyKey(body) {
+    try {
+        const key = JSON.parse(body)?.idempotencyKey;
+        return typeof key === "string" && key.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function unresolvedSubmissionError(last, attempts, reason, cause = last) {
+    const key = last.requestBody?.idempotencyKey;
+    const stopped = reason ? ` (stopped: ${reason})` : "";
+    return new APIError(`Submission outcome unknown after ${attempts} attempts${stopped}: ${last.message}. Retry with idempotencyKey ${String(key)} and the same payload within 15 minutes of the first attempt, under the same account; a new key can execute again.`, {
+        endpoint: last.endpoint,
+        // A 2xx whose body never arrived is no answer at all: report no status
+        // so callers branching on it treat the outcome as unknown.
+        statusCode: last.statusCode !== undefined && last.statusCode < StatusCodes.MULTIPLE_CHOICES ? undefined : last.statusCode,
+        responseBody: last.responseBody,
+        cause,
+        requestBody: last.requestBody,
+        requestId: last.requestId,
+        retryAfter: last.retryAfter,
+    });
+}
 export class BaseAPI {
     apiUrl;
     /** Active session keypair (raw bytes) used to sign authenticated requests. */
@@ -260,6 +310,7 @@ export class BaseAPI {
      *
      * @param endpoint - The API endpoint to call (should start with /)
      * @param options - Request options (method, body, headers, etc.)
+     * @param resendDeadline - Epoch ms after which a clock-skew 401 is returned instead of re-signed
      * @returns Promise resolving to the response data
      * @throws {APIError} When access token is not set or API request fails
      *
@@ -278,7 +329,7 @@ export class BaseAPI {
      * );
      * ```
      */
-    async makeAuthenticatedRequest(endpoint, options = {}) {
+    async makeAuthenticatedRequest(endpoint, options = {}, resendDeadline) {
         if (!this.sessionKeypair) {
             throw new APIError("Session keypair not set. Authenticate (login) first.", {
                 endpoint: `${this.apiUrl}${endpoint}`,
@@ -305,19 +356,80 @@ export class BaseAPI {
             },
         }, requestBody);
         // A 401 whose response moved the server clock was most likely a
-        // timestamp-skew rejection: re-sign once with the corrected time.
+        // timestamp-skew rejection: re-sign once with the corrected time, but
+        // only under the session that signed the rejected request and before the
+        // caller's resend deadline.
         const offsetBefore = this.serverClock.offsetMs;
+        const signer = this.sessionKeypair;
         try {
             return await send();
         }
         catch (error) {
             const clockMoved = Math.abs(this.serverClock.offsetMs - offsetBefore) >= CLOCK_CORRECTION_THRESHOLD_MS;
-            if (error instanceof APIError && error.statusCode === StatusCodes.UNAUTHORIZED && clockMoved) {
+            if (error instanceof APIError &&
+                error.statusCode === StatusCodes.UNAUTHORIZED &&
+                clockMoved &&
+                this.sessionKeypair === signer &&
+                (resendDeadline === undefined || Date.now() <= resendDeadline)) {
                 return send();
             }
             throw error;
         }
     }
+    /**
+     * Sends a keyed submission, re-sending the identical body while its outcome
+     * is unknown (network failure or a 5xx), for at most `maxRetries` extra
+     * attempts with exponential backoff.
+     *
+     * Only safe for a body that carries an `idempotencyKey`: the server replays
+     * the original result for a repeated key instead of executing again. A
+     * maintenance `OPERATIONS_BLOCKED` refusal and every 4xx are definitive and
+     * returned at once. A `Retry-After` beyond {@link MAX_SUBMISSION_RETRY_DELAY_MS},
+     * a resend later than {@link MAX_SUBMISSION_RETRY_WINDOW_MS} after the first
+     * send, or a session change during backoff also stops the loop: keys are
+     * scoped per account, so a resend signed by another session would be a new order.
+     *
+     * @throws {APIError} The last failure, naming the key to reuse, when every attempt is ambiguous
+     */
+    async makeKeyedSubmission(endpoint, options) {
+        if (!hasIdempotencyKey(options.body))
+            throw new Error("Keyed submission requires a JSON body with an idempotencyKey");
+        const { maxRetries, baseDelayMs } = this.retryOptions;
+        const session = this.sessionKeypair;
+        const startedAt = Date.now();
+        let unknownOutcome;
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await this.makeAuthenticatedRequest(endpoint, options, startedAt + MAX_SUBMISSION_RETRY_WINDOW_MS);
+            }
+            catch (error) {
+                const attempts = attempt + 1;
+                if (!isUnknownSubmissionOutcome(error)) {
+                    // A refusal of a resend says nothing about the earlier attempt,
+                    // which may have executed: report that outcome as still unknown.
+                    if (!unknownOutcome)
+                        throw error;
+                    const refusal = error instanceof Error ? error : new Error(String(error));
+                    throw unresolvedSubmissionError(unknownOutcome, attempts, `retry refused: ${refusal.message}`, refusal);
+                }
+                unknownOutcome = error;
+                const retryAfterMs = (error.retryAfter ?? 0) * 1000;
+                if (attempt >= maxRetries || retryAfterMs > MAX_SUBMISSION_RETRY_DELAY_MS) {
+                    throw unresolvedSubmissionError(error, attempts);
+                }
+                const delayMs = Math.max(baseDelayMs * 2 ** attempt, retryAfterMs);
+                if (Date.now() + delayMs - startedAt > MAX_SUBMISSION_RETRY_WINDOW_MS) {
+                    throw unresolvedSubmissionError(error, attempts, "retry window passed");
+                }
+                await sleep(delayMs);
+                if (Date.now() - startedAt > MAX_SUBMISSION_RETRY_WINDOW_MS) {
+                    throw unresolvedSubmissionError(error, attempts, "retry window passed");
+                }
+                if (this.sessionKeypair !== session)
+                    throw unresolvedSubmissionError(error, attempts, "session changed");
+            }
+        }
+    }
     /**
      * Compute the per-request ed25519 signature headers.
      *

package/dist/api/buildercodes/api.d.ts

@@ -61,7 +61,8 @@ export declare class BuildercodesAPIImpl extends BaseAPI implements Buildercodes
      * Read the authenticated wallet's available BuilderCodes reward balances.
      *
      * Current enrollment is not required: a former payout wallet can still see
-     * and claim the balance it accrued before an address rotation.
+     * and claim whatever remains in its bucket. Shortly after a payout-address
+     * change the old wallet's unclaimed balance moves to the new wallet.
      */
     getRewardsBalance(): Promise<GetBuildercodeRewardsBalanceResponse>;
     /**

package/dist/api/buildercodes/api.js

@@ -173,7 +173,8 @@ export class BuildercodesAPIImpl extends BaseAPI {
      * Read the authenticated wallet's available BuilderCodes reward balances.
      *
      * Current enrollment is not required: a former payout wallet can still see
-     * and claim the balance it accrued before an address rotation.
+     * and claim whatever remains in its bucket. Shortly after a payout-address
+     * change the old wallet's unclaimed balance moves to the new wallet.
      */
     async getRewardsBalance() {
         return this.makeAuthenticatedRequest("/api/v1/buildercodes/rewards/balance", { method: "GET" });

package/dist/api/margin-accounts/api.d.ts

@@ -5,8 +5,12 @@ export declare class MarginAccountsAPIImpl extends BaseAPI implements MarginAcco
     closeMarginSubAccount(marginAccountId: string): Promise<CloseMarginSubAccountResponse>;
     getMarginAccountPnl(marginAccountId: string): Promise<MarginAccountPnl>;
     transferMarginCollateral(request: TransferMarginCollateralRequest): Promise<TransferMarginCollateralResponse>;
-    transferCollateralToSubAccount(marginAccountId: string, amount: string): Promise<TransferMarginCollateralResponse>;
-    transferCollateralFromSubAccount(marginAccountId: string, amount: string): Promise<TransferMarginCollateralResponse>;
+    transferCollateralToSubAccount(marginAccountId: string, amount: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<TransferMarginCollateralResponse>;
+    transferCollateralFromSubAccount(marginAccountId: string, amount: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<TransferMarginCollateralResponse>;
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;
     getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getParentMarginAccountSummary(params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;

package/dist/api/margin-accounts/api.js

@@ -29,21 +29,24 @@ export class MarginAccountsAPIImpl extends BaseAPI {
                 amount: request.amount,
                 from: request.from,
                 to: request.to,
+                idempotencyKey: request.idempotencyKey,
             }),
         });
     }
-    async transferCollateralToSubAccount(marginAccountId, amount) {
-        validate(SubAccountCollateralTransferSchema, { marginAccountId, amount });
+    async transferCollateralToSubAccount(marginAccountId, amount, options) {
+        const idempotencyKey = options?.idempotencyKey;
+        validate(SubAccountCollateralTransferSchema, { marginAccountId, amount, idempotencyKey });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.subAccountTransferIn(marginAccountId), {
             method: "POST",
-            body: JSON.stringify({ amount }),
+            body: JSON.stringify({ amount, idempotencyKey }),
         });
     }
-    async transferCollateralFromSubAccount(marginAccountId, amount) {
-        validate(SubAccountCollateralTransferSchema, { marginAccountId, amount });
+    async transferCollateralFromSubAccount(marginAccountId, amount, options) {
+        const idempotencyKey = options?.idempotencyKey;
+        validate(SubAccountCollateralTransferSchema, { marginAccountId, amount, idempotencyKey });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.subAccountTransferOut(marginAccountId), {
             method: "POST",
-            body: JSON.stringify({ amount }),
+            body: JSON.stringify({ amount, idempotencyKey }),
         });
     }
     async listMarginAccounts(params) {
@@ -90,6 +93,7 @@ export class MarginAccountsAPIImpl extends BaseAPI {
                 amount: request.amount,
                 tradingPairId: request.tradingPairId,
                 strategyKey: request.strategyKey,
+                idempotencyKey: request.idempotencyKey,
             }),
         });
     }
@@ -100,6 +104,7 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
+                idempotencyKey: request.idempotencyKey,
             }),
         });
     }
@@ -121,6 +126,7 @@ export class MarginAccountsAPIImpl extends BaseAPI {
                 // the wire or the server applies its Adjust Margin default and every
                 // funding-loop top-up converts into initial margin requirement.
                 applyToPositionMargin: request.applyToPositionMargin,
+                idempotencyKey: request.idempotencyKey,
             }),
         });
     }
@@ -134,6 +140,7 @@ export class MarginAccountsAPIImpl extends BaseAPI {
                 tradingPairId: request.tradingPairId,
                 strategyKey: request.strategyKey,
                 marginMode: request.marginMode,
+                idempotencyKey: request.idempotencyKey,
             }),
         });
     }
@@ -144,6 +151,7 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
+                idempotencyKey: request.idempotencyKey,
             }),
         });
     }

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

@@ -1,4 +1,4 @@
-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 type { Candlestick, FundingState, GetCandlesticksParams, GetLiquidationMetricsParams, GetScreenerParams, GetScreenerResponse, GetTradeFlowParams, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, LiquidationMetrics, ListAllFundingHistoryParams, ListAllFundingHistoryResponse, ListFundingHistoryParams, ListFundingHistoryResponse, ListLiquidationEventsParams, ListLiquidationEventsResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradeFlow, TraderMetrics, TradingMode, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -19,6 +19,10 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
     listAllFundingHistory(params?: ListAllFundingHistoryParams): Promise<ListAllFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
+    getTraderMetrics(tradingPairId: string): Promise<TraderMetrics>;
+    getTradeFlow(tradingPairId: string, params: GetTradeFlowParams): Promise<TradeFlow>;
+    listLiquidationEvents(tradingPairId: string, params?: ListLiquidationEventsParams): Promise<ListLiquidationEventsResponse>;
+    getLiquidationMetrics(tradingPairId: string, params: GetLiquidationMetricsParams): Promise<LiquidationMetrics>;
     getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
     getMarketStats(): Promise<MarketStats>;
 }

package/dist/api/market/api.js

@@ -113,6 +113,22 @@ export class MarketAPIImpl extends BaseAPI {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.getOpenInterest(tradingPairId));
     }
+    async getTraderMetrics(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getTraderMetrics(tradingPairId));
+    }
+    async getTradeFlow(tradingPairId, params) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getTradeFlow(tradingPairId, params));
+    }
+    async listLiquidationEvents(tradingPairId, params) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.listLiquidationEvents(tradingPairId, params));
+    }
+    async getLiquidationMetrics(tradingPairId, params) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getLiquidationMetrics(tradingPairId, params));
+    }
     async getScreener(params) {
         return await this.makePublicRequest(perpRoutes.market.getScreener(params));
     }

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

@@ -92,6 +92,23 @@ export declare const perpRoutes: {
             orderBy?: string;
         }) => string;
         readonly getOpenInterest: (tradingPairId: string) => string;
+        readonly getTraderMetrics: (tradingPairId: string) => string;
+        readonly getTradeFlow: (tradingPairId: string, params: {
+            interval: string;
+            startTime: number;
+            endTime: number;
+        }) => string;
+        readonly listLiquidationEvents: (tradingPairId: string, params?: {
+            startTime?: number;
+            endTime?: number;
+            pageSize?: number;
+            pageToken?: string;
+        }) => string;
+        readonly getLiquidationMetrics: (tradingPairId: string, params: {
+            interval: string;
+            startTime: number;
+            endTime: number;
+        }) => string;
         readonly getScreener: (params?: {
             page?: number;
             pageSize?: number;
@@ -175,6 +192,11 @@ export declare const perpRoutes: {
     readonly sweeper: {
         readonly register: () => string;
         readonly chains: () => string;
+        readonly deposits: (txHash: string) => string;
+        readonly listDeposits: (params?: {
+            pageSize?: number;
+            pageToken?: string;
+        }) => string;
     };
     readonly whitelist: {
         readonly submit: () => string;

package/dist/api/perp/routes.js

@@ -60,6 +60,10 @@ export const perpRoutes = {
         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`,
+        getTraderMetrics: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/trader-metrics`,
+        getTradeFlow: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/trade-flow`, params),
+        listLiquidationEvents: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/liquidation-events`, params),
+        getLiquidationMetrics: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/liquidation-metrics`, params),
         getScreener: (params) => withQuery(`${API_V1}/market/screener`, params),
         getMarketStats: () => `${API_V1}/market/stats`,
     },
@@ -91,6 +95,8 @@ export const perpRoutes = {
     sweeper: {
         register: () => `${API_V1}/sweeper/register`,
         chains: () => `${API_V1}/sweeper/chains`,
+        deposits: (txHash) => `${API_V1}/sweeper/deposits/${encodeSegment(txHash)}`,
+        listDeposits: (params) => withQuery(`${API_V1}/sweeper/deposits`, params),
     },
     whitelist: {
         submit: () => `${API_V1}/whitelist`,

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

@@ -200,14 +200,16 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *
      * An unfiltered response carries `total` and `totalPages`, bounded by the
      * server count ceiling; `totalCapped` is `true` when more than that matched,
-     * so `total` is a lower bound. A response filtered by `tradingPairId` carries
-     * neither (counting one pair would read the user's whole trade history), nor
+     * so `total` is a lower bound. A filtered response carries neither (counting
+     * one pair, account or order would read the user's whole trade history), nor
      * does one whose count ran out of its server time budget: treat absent as
      * unknown. Do not drive a paging loop off `total`; follow `nextPageToken`.
      *
      * @param params - Optional query parameters for pagination and filtering
      * @param params.pageSize - Number of items per page (default: 20; up to 1000)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
+     * @param params.marginAccountId - Filter by the margin account this user's side was placed from (UUID)
+     * @param params.orderId - Filter by the order that placed this user's side (UUID)
      * @param params.pageToken - Pagination cursor: pass `""` to start a cursor walk from
      * the newest row; pass a previous response's `nextPageToken` to resume. Omitting it
      * starts the same walk. Every walk covers full trade history, hot and archived rows

package/dist/api/profile/api.js

@@ -261,14 +261,16 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * An unfiltered response carries `total` and `totalPages`, bounded by the
      * server count ceiling; `totalCapped` is `true` when more than that matched,
-     * so `total` is a lower bound. A response filtered by `tradingPairId` carries
-     * neither (counting one pair would read the user's whole trade history), nor
+     * so `total` is a lower bound. A filtered response carries neither (counting
+     * one pair, account or order would read the user's whole trade history), nor
      * does one whose count ran out of its server time budget: treat absent as
      * unknown. Do not drive a paging loop off `total`; follow `nextPageToken`.
      *
      * @param params - Optional query parameters for pagination and filtering
      * @param params.pageSize - Number of items per page (default: 20; up to 1000)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
+     * @param params.marginAccountId - Filter by the margin account this user's side was placed from (UUID)
+     * @param params.orderId - Filter by the order that placed this user's side (UUID)
      * @param params.pageToken - Pagination cursor: pass `""` to start a cursor walk from
      * the newest row; pass a previous response's `nextPageToken` to resume. Omitting it
      * starts the same walk. Every walk covers full trade history, hot and archived rows
@@ -302,6 +304,12 @@ export class ProfileAPIImpl extends BaseAPI {
         if (params?.tradingPairId !== undefined) {
             searchParams.append("tradingPairId", params.tradingPairId);
         }
+        if (params?.marginAccountId !== undefined) {
+            searchParams.append("marginAccountId", params.marginAccountId);
+        }
+        if (params?.orderId !== undefined) {
+            searchParams.append("orderId", params.orderId);
+        }
         // One pagination mode. `pageToken` is sent even as the empty string — the
         // server selects the walk by the token's PRESENCE, not its value — so it
         // must not be dropped the way a falsy value usually would be.

package/dist/api/sweeper/api.d.ts

@@ -22,7 +22,7 @@
  * const margin = await sdk.sweeper.register({ depositTarget: "margin" });
  * ```
  */
-import type { GetSweeperChainsResponse, RegisterSweeperRequest, RegisterSweeperResponse, SweeperAPI } from "@0xmonaco/types";
+import type { GetSweeperChainsResponse, GetSweeperDepositStatusResponse, ListSweeperDepositsParams, ListSweeperDepositsResponse, RegisterSweeperRequest, RegisterSweeperResponse, SweeperAPI } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class SweeperAPIImpl extends BaseAPI implements SweeperAPI {
     /**
@@ -63,4 +63,31 @@ export declare class SweeperAPIImpl extends BaseAPI implements SweeperAPI {
      * @returns Promise resolving to the supported chain/asset listing
      */
     getChains(): Promise<GetSweeperChainsResponse>;
+    /**
+     * Where the caller's deposits made by one transaction are, by the hash of
+     * the transaction that sent funds to the caller's deposit address (any
+     * supported chain). Requires authentication; only the session's own
+     * deposits are returned.
+     *
+     * Empty until the sweeper has indexed the transaction — poll until each
+     * deposit reads `DEPOSITED` (or `FAILED`).
+     *
+     * @param txHash - The deposit transaction's hash, 0x-prefixed 32-byte hex
+     * @returns Promise resolving to the transaction's deposits, in chain then
+     *   log order
+     */
+    getDepositStatus(txHash: string): Promise<GetSweeperDepositStatusResponse>;
+    /**
+     * The caller's sweeper deposits, newest recorded first, by cursor. Each
+     * entry is the same {@link SweeperDeposit} `getDepositStatus` returns; a
+     * swept CCTP deposit is listed once, by its source-chain transfer, and a
+     * burn made straight to the hub deposit address by its hub mint. Requires
+     * authentication; only the session's own deposits are returned.
+     *
+     * @param params - `pageSize` (1-100, default 20) and the previous page's
+     *   `nextPageToken`
+     * @returns Promise resolving to one page and the cursor for the next (empty
+     *   on the last page)
+     */
+    listDeposits(params?: ListSweeperDepositsParams): Promise<ListSweeperDepositsResponse>;
 }

package/dist/api/sweeper/api.js

@@ -101,4 +101,50 @@ export class SweeperAPIImpl extends BaseAPI {
             method: "GET",
         });
     }
+    /**
+     * Where the caller's deposits made by one transaction are, by the hash of
+     * the transaction that sent funds to the caller's deposit address (any
+     * supported chain). Requires authentication; only the session's own
+     * deposits are returned.
+     *
+     * Empty until the sweeper has indexed the transaction — poll until each
+     * deposit reads `DEPOSITED` (or `FAILED`).
+     *
+     * @param txHash - The deposit transaction's hash, 0x-prefixed 32-byte hex
+     * @returns Promise resolving to the transaction's deposits, in chain then
+     *   log order
+     */
+    async getDepositStatus(txHash) {
+        if (!TX_HASH_PATTERN.test(txHash)) {
+            throw new InvalidConfigError(`Invalid transaction hash: ${JSON.stringify(txHash)}. Expected a 0x-prefixed 32-byte hex hash.`);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.sweeper.deposits(txHash), {
+            method: "GET",
+        });
+    }
+    /**
+     * The caller's sweeper deposits, newest recorded first, by cursor. Each
+     * entry is the same {@link SweeperDeposit} `getDepositStatus` returns; a
+     * swept CCTP deposit is listed once, by its source-chain transfer, and a
+     * burn made straight to the hub deposit address by its hub mint. Requires
+     * authentication; only the session's own deposits are returned.
+     *
+     * @param params - `pageSize` (1-100, default 20) and the previous page's
+     *   `nextPageToken`
+     * @returns Promise resolving to one page and the cursor for the next (empty
+     *   on the last page)
+     */
+    async listDeposits(params = {}) {
+        const { pageSize, pageToken } = params;
+        if (pageSize !== undefined && !(Number.isInteger(pageSize) && pageSize >= 1 && pageSize <= MAX_DEPOSIT_PAGE_SIZE)) {
+            throw new InvalidConfigError(`Invalid pageSize: ${pageSize}. Expected an integer between 1 and ${MAX_DEPOSIT_PAGE_SIZE}.`);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.sweeper.listDeposits({ pageSize, pageToken }), {
+            method: "GET",
+        });
+    }
 }
+/** The deposit listing's page size bounds, matching the endpoint's schema. */
+const MAX_DEPOSIT_PAGE_SIZE = 100;
+/** A 0x-prefixed 32-byte hex transaction hash, matching the endpoint's schema. */
+const TX_HASH_PATTERN = /^0x[0-9a-fA-F]{64}$/;

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

@@ -24,6 +24,12 @@
 import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrderSlicesParams, ListTwapOrderSlicesResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MarginMode, OrderSide, ParentTpSlLegParams, ParentTrailingStopLegParams, PositionSide, ReplaceOrderResponse, SelfTradePreventionMode, TimeInForce, TradingAPI, TradingMode, TwapOrder } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
+    /**
+     * Sends a single create. A key the SDK generated for this call is resent
+     * after a lost response; a caller-supplied key is sent once, because it may
+     * be a recovery of an earlier submission whose 15-minute window is nearly over.
+     */
+    private submitCreate;
     /**
      * Places a limit order on the order book.
      *
@@ -90,7 +96,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         postOnly?: boolean;
         selfTradePreventionMode?: SelfTradePreventionMode;
         clientOrderId?: string;
-        /** Generated once per call when omitted. Supply the same key to retry a logical order within 15 minutes. */
+        /** Generated once per call when omitted, and then re-sent inside the call after a lost response. A supplied key is sent once: reuse it with the same order to recover across calls within 15 minutes. */
         idempotencyKey?: string;
         takeProfit?: ParentTpSlLegParams;
         stopLoss?: ParentTpSlLegParams;
@@ -157,7 +163,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         /** Trailing stop that arms when this order fully fills; margin entry orders only. */
         trailingStop?: ParentTrailingStopLegParams;
         clientOrderId?: string;
-        /** Generated once per call when omitted. Supply the same key to retry a logical order within 15 minutes. */
+        /** Generated once per call when omitted, and then re-sent inside the call after a lost response. A supplied key is sent once: reuse it with the same order to recover across calls within 15 minutes. */
         idempotencyKey?: string;
     }): Promise<CreateOrderResponse>;
     /**
@@ -426,7 +432,9 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * @param options.slippageToleranceBps - Per-slice protective price band in
      *   basis points (default 100 = 1%)
      * @param options.clientTwapId - Idempotency key (max 36 chars), unique per
-     *   user and application; a duplicate is rejected with 409
+     *   user and application while the parent is live and for a reservation
+     *   lifetime after it ends (30 days by default); a duplicate inside that
+     *   window is rejected with 409
      * @returns Promise resolving to CreateTwapOrderResponse with the parent id,
      *   initial state, and the planned schedule summary
      * @throws {APIError} When API communication fails

package/dist/api/trading/api.js

@@ -55,6 +55,17 @@ function parentTrailingStopLegToRequest(leg) {
     };
 }
 export class TradingAPIImpl extends BaseAPI {
+    /**
+     * Sends a single create. A key the SDK generated for this call is resent
+     * after a lost response; a caller-supplied key is sent once, because it may
+     * be a recovery of an earlier submission whose 15-minute window is nearly over.
+     */
+    submitCreate(requestBody, keyGenerated) {
+        const request = { method: "POST", body: JSON.stringify(requestBody) };
+        return keyGenerated
+            ? this.makeKeyedSubmission(perpRoutes.orders.create(), request)
+            : this.makeAuthenticatedRequest(perpRoutes.orders.create(), request);
+    }
     /**
      * Places a limit order on the order book.
      *
@@ -140,10 +151,7 @@ export class TradingAPIImpl extends BaseAPI {
             stopLoss: parentTpSlLegToRequest(options?.stopLoss),
             trailingStop: parentTrailingStopLegToRequest(options?.trailingStop),
         };
-        return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
-            method: "POST",
-            body: JSON.stringify(requestBody),
-        });
+        return await this.submitCreate(requestBody, options?.idempotencyKey === undefined);
     }
     /**
      * Places a market order for immediate execution.
@@ -219,10 +227,7 @@ export class TradingAPIImpl extends BaseAPI {
             clientOrderId: options?.clientOrderId,
             idempotencyKey: options?.idempotencyKey === undefined ? crypto.randomUUID() : options.idempotencyKey,
         };
-        return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
-            method: "POST",
-            body: JSON.stringify(requestBody),
-        });
+        return await this.submitCreate(requestBody, options?.idempotencyKey === undefined);
     }
     /**
      * Cancels an existing order.
@@ -660,7 +665,9 @@ export class TradingAPIImpl extends BaseAPI {
      * @param options.slippageToleranceBps - Per-slice protective price band in
      *   basis points (default 100 = 1%)
      * @param options.clientTwapId - Idempotency key (max 36 chars), unique per
-     *   user and application; a duplicate is rejected with 409
+     *   user and application while the parent is live and for a reservation
+     *   lifetime after it ends (30 days by default); a duplicate inside that
+     *   window is rejected with 409
      * @returns Promise resolving to CreateTwapOrderResponse with the parent id,
      *   initial state, and the planned schedule summary
      * @throws {APIError} When API communication fails

package/dist/api/websocket/websocket.js

@@ -366,6 +366,34 @@ function parseLiquidationEvent(rawData) {
         data: parseLiquidationEventData(rawData.data),
     };
 }
+function parseMarketLiquidationEventData(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("Invalid market liquidation event: data must be an object");
+    }
+    const data = keysToCamelCase(raw);
+    return {
+        eventId: readString(data, "eventId"),
+        timestamp: readSequence(data, "timestamp"),
+        wallet: readString(data, "wallet"),
+        // Side is a value field: preserve a future server label so an SDK version
+        // skew cannot drop the entire persisted liquidation event.
+        side: readString(data, "side"),
+        positionSize: readString(data, "positionSize"),
+        markPrice: readString(data, "markPrice"),
+        markNotional: readString(data, "markNotional"),
+        quoteAssetSymbol: readString(data, "quoteAssetSymbol"),
+    };
+}
+function parseMarketLiquidationEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid market liquidation event: payload must be an object");
+    }
+    return {
+        eventType: readEnum(rawData, "event_type", ["liquidation_event"]),
+        tradingPairId: readString(rawData, "trading_pair_id"),
+        data: parseMarketLiquidationEventData(rawData.data),
+    };
+}
 /**
  * Parse an account's margin-health payload. Shared by the live event and the
  * subscribe-time snapshot (see {@link parseConditionalOrderEventData}).
@@ -2155,6 +2183,19 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         // reach the event handler.
         onSnapshot && snapshotFrameHandler("all-markets stats", parseMarketStatsSummary, onSnapshot));
     };
+    const subscribeMarketLiquidations = (tradingPairId, handler) => {
+        if (!handler) {
+            throw new Error("marketLiquidations subscription requires a handler");
+        }
+        return subscribe(`market_liquidations:${tradingPairId}`, (rawData) => {
+            try {
+                handler(parseMarketLiquidationEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing market liquidation event", err);
+            }
+        });
+    };
     return {
         connect,
         disconnect,
@@ -2194,5 +2235,6 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         instruments: subscribeInstruments,
         marketStats: subscribeMarketStats,
         marketStatsAll: subscribeMarketStatsAll,
+        marketLiquidations: subscribeMarketLiquidations,
     };
 }

package/dist/coverage.d.ts

@@ -61,6 +61,8 @@ export declare const COVERED: {
     claim_managed_market_lease: string;
     refresh_managed_market_quotes: string;
     get_sweeper_chains: string;
+    get_sweeper_deposit_status: string;
+    list_sweeper_deposits: string;
     get_my_trader_code: string;
     get_rewards_balance: string;
     get_my_referral_position: string;
@@ -94,6 +96,9 @@ export declare const COVERED: {
     get_sub_account_limits: string;
     get_trade_by_id: string;
     get_trades: string;
+    get_trade_flow: string;
+    get_trader_metrics: string;
+    get_liquidation_metrics: string;
     get_trading_pair_by_id: string;
     get_user_balance_by_asset: string;
     get_user_balances: string;
@@ -114,6 +119,7 @@ export declare const COVERED: {
     list_delegated_agent_owners: string;
     list_delegated_agents: string;
     list_funding_history: string;
+    list_liquidation_events: string;
     list_funding_payments: string;
     list_margin_accounts: string;
     list_position_history: string;

package/dist/coverage.js

@@ -61,6 +61,8 @@ export const COVERED = {
     claim_managed_market_lease: "managedMarkets.claimLease",
     refresh_managed_market_quotes: "managedMarkets.refreshQuotes",
     get_sweeper_chains: "sweeper.getChains",
+    get_sweeper_deposit_status: "sweeper.getDepositStatus",
+    list_sweeper_deposits: "sweeper.listDeposits",
     get_my_trader_code: "tradercodes.getMyTraderCode",
     get_rewards_balance: "tradercodes.getRewardsBalance",
     get_my_referral_position: "tradercodes.getMyReferralPosition",
@@ -94,6 +96,9 @@ export const COVERED = {
     get_sub_account_limits: "subAccounts.getLimits",
     get_trade_by_id: "getTradeById",
     get_trades: "getTrades",
+    get_trade_flow: "getTradeFlow",
+    get_trader_metrics: "getTraderMetrics",
+    get_liquidation_metrics: "getLiquidationMetrics",
     get_trading_pair_by_id: "getTradingPair",
     get_user_balance_by_asset: "getUserBalanceByAssetId",
     get_user_balances: "getUserBalances",
@@ -114,6 +119,7 @@ export const COVERED = {
     list_delegated_agent_owners: "listDelegatedOwners",
     list_delegated_agents: "listDelegatedAgents",
     list_funding_history: "listFundingHistory",
+    list_liquidation_events: "listLiquidationEvents",
     list_funding_payments: "listFundingPayments",
     list_margin_accounts: "listMarginAccounts",
     list_position_history: "listPositionHistory",

package/dist/sdk.js

@@ -27,12 +27,11 @@ import { APIError, InvalidConfigError, InvalidStateError } from "./errors";
 import { resolveApiUrl, resolveWsUrl } from "./networks";
 import { ServerClock } from "./utils/server-clock";
 /**
- * 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.
+ * Default receipt-polling frequency for the SDK's internal viem public client:
+ * about half a Sei block (~400ms). viem's 4000ms default adds seconds of slack
+ * to every `waitForTransactionReceipt`.
  */
-const DEFAULT_POLLING_INTERVAL_MS = 750;
+const DEFAULT_POLLING_INTERVAL_MS = 200;
 /** Validate a user-supplied URL override, returning it unchanged when valid. */
 function validateUrl(value, field) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.88",
+	"version": "1.0.91",
 	"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.88",
-		"@0xmonaco/types": "1.0.88",
+		"@0xmonaco/contracts": "1.0.91",
+		"@0xmonaco/types": "1.0.91",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"