@0xmonaco/core 0.8.7 → 0.8.10

package/dist/api/perp/routes.js

@@ -26,15 +26,19 @@ export const perpRoutes = {
         batchCancelAllByPair: (tradingPairId) => `${API_V1}/orders/batch-cancel-all/${encodeSegment(tradingPairId)}`,
         batchCreate: () => `${API_V1}/orders/batch-create`,
         batchReplace: () => `${API_V1}/orders/batch-replace`,
-        createConditional: () => `${API_V1}/orders/conditional`,
         listConditional: (params) => withQuery(`${API_V1}/orders/conditional`, params),
         cancelConditional: (conditionalOrderId) => `${API_V1}/orders/conditional/${encodeSegment(conditionalOrderId)}`,
     },
     delegatedAgents: {
         list: () => `${API_V1}/delegated-agents`,
+        owners: () => `${API_V1}/delegated-agents/owners`,
         byId: (delegatedAgentId) => `${API_V1}/delegated-agents/${encodeSegment(delegatedAgentId)}`,
         sessions: () => `${API_V1}/delegated-agents/sessions`,
     },
+    withdrawals: {
+        initiate: () => `${API_V1}/withdrawals`,
+        byIndex: (withdrawalIndex) => `${API_V1}/withdrawals/${encodeSegment(String(withdrawalIndex))}`,
+    },
     market: {
         listTradingPairs: (params) => withQuery(`${API_V1}/market/pairs`, params),
         getTradingPair: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}`,
@@ -47,14 +51,35 @@ export const perpRoutes = {
         getFundingState: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding`,
         listFundingHistory: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding/history`, params),
         getOpenInterest: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/open-interest`,
+        getScreener: (params) => withQuery(`${API_V1}/market/screener`, params),
     },
     orderbook: {
         get: (tradingPairId, params) => withQuery(`${API_V1}/orderbook/${encodeSegment(tradingPairId)}`, params),
     },
     trades: {
         publicByPair: (tradingPairId, params) => withQuery(`${API_V1}/trades/${encodeSegment(tradingPairId)}`, params),
+        byId: (tradeId) => `${API_V1}/trades/by-id/${encodeSegment(tradeId)}`,
         user: (params) => withQuery(`${API_V1}/accounts/trades`, params),
     },
+    applications: {
+        orders: (params) => withQuery(`${API_V1}/applications/orders`, params),
+        users: (params) => withQuery(`${API_V1}/applications/users`, params),
+        movements: (params) => withQuery(`${API_V1}/applications/movements`, params),
+        balances: (params) => withQuery(`${API_V1}/applications/balances`, params),
+        stats: (params) => withQuery(`${API_V1}/applications/stats`, params),
+    },
+    subAccounts: {
+        list: () => `${API_V1}/accounts/sub-accounts`,
+        createLimit: () => `${API_V1}/accounts/sub-accounts/limits`,
+        getLimits: (subAccountId) => `${API_V1}/accounts/sub-accounts/${encodeSegment(subAccountId)}/limits`,
+        limit: (subAccountId, assetId) => `${API_V1}/accounts/sub-accounts/${encodeSegment(subAccountId)}/limits/${encodeSegment(assetId)}`,
+    },
+    faucet: {
+        mint: () => `${API_V1}/faucet/mint`,
+    },
+    whitelist: {
+        submit: () => `${API_V1}/whitelist`,
+    },
     positions: {
         list: (params) => withQuery(`${API_V1}/positions`, params),
         get: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}`,
@@ -67,8 +92,7 @@ export const perpRoutes = {
     },
     marginAccounts: {
         list: (params) => withQuery(`${API_V1}/margin/accounts`, params),
-        create: () => `${API_V1}/margin/accounts`,
-        summary: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}`,
+        summary: (marginAccountId, params) => withQuery(`${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}`, params),
         availableCollateral: (params) => withQuery(`${API_V1}/margin/collateral/available`, params),
         transferIn: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-in`,
         transferInAuto: () => `${API_V1}/margin/collateral/transfer-in`,
@@ -85,7 +109,6 @@ export const perpRoutes = {
         privateTrades: () => `${API_V1}/streaming/private-trades`,
         orders: () => `${API_V1}/streaming/orders`,
         positions: () => `${API_V1}/streaming/positions`,
-        marginAccount: () => `${API_V1}/streaming/margin-account`,
         funding: () => `${API_V1}/streaming/funding`,
         liquidationAlerts: () => `${API_V1}/streaming/liquidation-alerts`,
     },

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

@@ -17,7 +17,7 @@
  * console.log(`User: ${profile.username} (${profile.address})`);
  * ```
  */
-import type { AccountBalance, GetPaginatedUserMovementsResponse, GetUserBalancesParams, GetUserBalancesResponse, GetUserMovementsParams, GetUserTradesParams, GetUserTradesResponse, PortfolioChartResponse, PortfolioMetric, PortfolioPeriod, PortfolioStats, ProfileAPI, UserProfile } from "@0xmonaco/types";
+import type { AccountBalance, GetPaginatedUserMovementsResponse, GetUserBalancesParams, GetUserBalancesResponse, GetUserMovementsParams, GetUserTradesParams, GetUserTradesResponse, ListFundingPaymentsParams, ListFundingPaymentsResponse, PortfolioChartResponse, PortfolioMetric, PortfolioPeriod, PortfolioStats, ProfileAPI, UserProfile } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
     /**
@@ -188,4 +188,21 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * ```
      */
     getUserTrades(params?: GetUserTradesParams): Promise<GetUserTradesResponse>;
+    /**
+     * List the current user's funding payment history with pagination and filters.
+     *
+     * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
+     * Requires a valid access token to be set.
+     *
+     * @param params - Optional query parameters for pagination and filtering
+     * @returns Promise resolving to paginated funding payments response
+     * @throws {APIError} When the request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const funding = await profileAPI.listFundingPayments({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * console.log(`Total funding payments: ${funding.total}`);
+     * ```
+     */
+    listFundingPayments(params?: ListFundingPaymentsParams): Promise<ListFundingPaymentsResponse>;
 }

package/dist/api/profile/api.js

@@ -17,7 +17,7 @@
  * console.log(`User: ${profile.username} (${profile.address})`);
  * ```
  */
-import { GetUserMovementsSchema, GetUserTradesSchema, validate } from "@0xmonaco/types";
+import { GetUserMovementsSchema, GetUserTradesSchema, ListFundingPaymentsSchema, validate } from "@0xmonaco/types";
 import { APIError } from "../../errors";
 import { BaseAPI } from "../base";
 export class ProfileAPIImpl extends BaseAPI {
@@ -256,4 +256,44 @@ export class ProfileAPIImpl extends BaseAPI {
         const url = queryString ? `/api/v1/accounts/trades?${queryString}` : "/api/v1/accounts/trades";
         return await this.makeAuthenticatedRequest(url);
     }
+    /**
+     * List the current user's funding payment history with pagination and filters.
+     *
+     * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
+     * Requires a valid access token to be set.
+     *
+     * @param params - Optional query parameters for pagination and filtering
+     * @returns Promise resolving to paginated funding payments response
+     * @throws {APIError} When the request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const funding = await profileAPI.listFundingPayments({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * console.log(`Total funding payments: ${funding.total}`);
+     * ```
+     */
+    async listFundingPayments(params) {
+        if (params) {
+            validate(ListFundingPaymentsSchema, params);
+        }
+        const searchParams = new URLSearchParams();
+        if (params?.page !== undefined) {
+            searchParams.append("page", params.page.toString());
+        }
+        if (params?.page_size !== undefined) {
+            searchParams.append("page_size", params.page_size.toString());
+        }
+        if (params?.trading_pair_id !== undefined) {
+            searchParams.append("trading_pair_id", params.trading_pair_id);
+        }
+        if (params?.position_id !== undefined) {
+            searchParams.append("position_id", params.position_id);
+        }
+        if (params?.margin_account_id !== undefined) {
+            searchParams.append("margin_account_id", params.margin_account_id);
+        }
+        const queryString = searchParams.toString();
+        const url = queryString ? `/api/v1/accounts/funding-payments?${queryString}` : "/api/v1/accounts/funding-payments";
+        return await this.makeAuthenticatedRequest(url);
+    }
 }

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

@@ -0,0 +1,62 @@
+/**
+ * Sub-Accounts API Implementation
+ *
+ * Manage a master account's sub-accounts and their per-asset spending limits.
+ * All methods are session-authenticated. The limit mutations (`createLimit`,
+ * `updateLimit`, `deleteLimit`) additionally require the master account to hold
+ * the `ManageSubAccounts` permission — enforced server-side, so a non-master or
+ * unpermissioned caller receives a 403.
+ *
+ * @example
+ * ```typescript
+ * const { sub_accounts } = await sdk.subAccounts.list();
+ * await sdk.subAccounts.createLimit({ sub_account_id, asset_id, max_amount: "1000.00" });
+ * ```
+ */
+import type { CreateSubAccountLimitRequest, CreateSubAccountLimitResponse, GetSubAccountLimitsResponse, ListSubAccountsResponse, SubAccountsAPI, UpdateSubAccountLimitBody, UpdateSubAccountLimitResponse } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class SubAccountsAPIImpl extends BaseAPI implements SubAccountsAPI {
+    /**
+     * Lists the authenticated master account's sub-accounts with balances.
+     *
+     * @returns Promise resolving to the sub-accounts and total count
+     */
+    list(): Promise<ListSubAccountsResponse>;
+    /**
+     * Creates a per-asset spending limit on a sub-account.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param body - Sub-account, asset, max amount, and optional daily limit
+     * @returns Promise resolving to the created limit
+     */
+    createLimit(body: CreateSubAccountLimitRequest): Promise<CreateSubAccountLimitResponse>;
+    /**
+     * Gets the limits configured for a sub-account.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @returns Promise resolving to the sub-account's limits
+     */
+    getLimits(subAccountId: string): Promise<GetSubAccountLimitsResponse>;
+    /**
+     * Updates a sub-account's per-asset limit (partial update).
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @param body - Fields to update
+     * @returns Promise resolving to the updated limit
+     */
+    updateLimit(subAccountId: string, assetId: string, body: UpdateSubAccountLimitBody): Promise<UpdateSubAccountLimitResponse>;
+    /**
+     * Deletes a sub-account's per-asset limit.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @returns Promise resolving when the limit is deleted
+     */
+    deleteLimit(subAccountId: string, assetId: string): Promise<void>;
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Sub-Accounts API Implementation
+ *
+ * Manage a master account's sub-accounts and their per-asset spending limits.
+ * All methods are session-authenticated. The limit mutations (`createLimit`,
+ * `updateLimit`, `deleteLimit`) additionally require the master account to hold
+ * the `ManageSubAccounts` permission — enforced server-side, so a non-master or
+ * unpermissioned caller receives a 403.
+ *
+ * @example
+ * ```typescript
+ * const { sub_accounts } = await sdk.subAccounts.list();
+ * await sdk.subAccounts.createLimit({ sub_account_id, asset_id, max_amount: "1000.00" });
+ * ```
+ */
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
+export class SubAccountsAPIImpl extends BaseAPI {
+    /**
+     * Lists the authenticated master account's sub-accounts with balances.
+     *
+     * @returns Promise resolving to the sub-accounts and total count
+     */
+    async list() {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.list());
+    }
+    /**
+     * Creates a per-asset spending limit on a sub-account.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param body - Sub-account, asset, max amount, and optional daily limit
+     * @returns Promise resolving to the created limit
+     */
+    async createLimit(body) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.createLimit(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Gets the limits configured for a sub-account.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @returns Promise resolving to the sub-account's limits
+     */
+    async getLimits(subAccountId) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.getLimits(subAccountId));
+    }
+    /**
+     * Updates a sub-account's per-asset limit (partial update).
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @param body - Fields to update
+     * @returns Promise resolving to the updated limit
+     */
+    async updateLimit(subAccountId, assetId, body) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.limit(subAccountId, assetId), {
+            method: "PUT",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Deletes a sub-account's per-asset limit.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @returns Promise resolving when the limit is deleted
+     */
+    async deleteLimit(subAccountId, assetId) {
+        await this.makeAuthenticatedRequest(perpRoutes.subAccounts.limit(subAccountId, assetId), {
+            method: "DELETE",
+        });
+    }
+}

package/dist/api/sub-accounts/index.d.ts

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

package/dist/api/sub-accounts/index.js

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

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

@@ -11,8 +11,11 @@ interface RawTradeEvent {
         trade_id: string;
         price: string;
         quantity: string;
+        /** Raw (integer) quantity; present on single-trade lookups, ignored when mapping */
+        quantity_raw?: string;
         maker_side: string;
-        executed_at: string;
+        /** Absent when the trade has no recorded execution time */
+        executed_at?: string;
     };
 }
 /**
@@ -40,5 +43,13 @@ export declare class TradesAPIImpl extends BaseAPI {
      * @returns Array of TradeEvent records sorted by executed_at descending (newest first)
      */
     getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<TradeEvent[]>;
+    /**
+     * Get a single trade by its UUID.
+     *
+     * @param tradeId - The trade UUID
+     * @returns The matching TradeEvent
+     * @throws {APIError} If the trade is not found
+     */
+    getTradeById(tradeId: string): Promise<TradeEvent>;
 }
 export {};

package/dist/api/trades/api.js

@@ -1,4 +1,5 @@
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
 /**
  * Convert a raw trade event (snake_case) to a TradeEvent (camelCase)
  */
@@ -12,7 +13,7 @@ export function parseRawTradeEvent(raw) {
             price: raw.data.price,
             quantity: raw.data.quantity,
             makerSide: raw.data.maker_side.toUpperCase(),
-            executedAt: raw.data.executed_at,
+            executedAt: raw.data.executed_at ?? "",
         },
     };
 }
@@ -39,4 +40,15 @@ export class TradesAPIImpl extends BaseAPI {
         const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return response.trades.map(parseRawTradeEvent);
     }
+    /**
+     * Get a single trade by its UUID.
+     *
+     * @param tradeId - The trade UUID
+     * @returns The matching TradeEvent
+     * @throws {APIError} If the trade is not found
+     */
+    async getTradeById(tradeId) {
+        const response = await this.makePublicRequest(perpRoutes.trades.byId(tradeId));
+        return parseRawTradeEvent(response);
+    }
 }

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

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateConditionalOrderParams, CreateConditionalOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -80,6 +80,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
+        marginBucketId?: string;
+        marginBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -132,6 +134,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
+        marginBucketId?: string;
+        marginBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -156,7 +160,6 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     cancelOrder(orderId: string): Promise<CancelOrderResponse>;
-    createConditionalOrder(params: CreateConditionalOrderParams): Promise<CreateConditionalOrderResponse>;
     cancelConditionalOrder(conditionalOrderId: string): Promise<CancelConditionalOrderResponse>;
     listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**

package/dist/api/trading/api.js

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, CreateConditionalOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
+import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 function parentTpSlLegToRequest(leg) {
@@ -107,6 +107,8 @@ export class TradingAPIImpl extends BaseAPI {
             expiration_date: options?.expirationDate,
             time_in_force: options?.timeInForce,
             margin_account_id: options?.marginAccountId,
+            margin_bucket_id: options?.marginBucketId,
+            margin_bucket_collateral: options?.marginBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -177,6 +179,8 @@ export class TradingAPIImpl extends BaseAPI {
             quantity,
             trading_mode: options?.tradingMode || "SPOT",
             margin_account_id: options?.marginAccountId,
+            margin_bucket_id: options?.marginBucketId,
+            margin_bucket_collateral: options?.marginBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -216,29 +220,6 @@ export class TradingAPIImpl extends BaseAPI {
             body: JSON.stringify(requestBody),
         });
     }
-    async createConditionalOrder(params) {
-        validate(CreateConditionalOrderSchema, params);
-        const requestBody = {
-            trading_pair_id: params.tradingPairId,
-            margin_account_id: params.marginAccountId,
-            condition_type: params.conditionType,
-            trigger_price: params.triggerPrice,
-            trigger_source: params.triggerSource ?? "MARK_PRICE",
-            side: params.side,
-            position_side: params.positionSide,
-            order_type: params.orderType,
-            limit_price: params.limitPrice,
-            quantity: params.quantity,
-            reduce_only: params.reduceOnly ?? true,
-            time_in_force: params.timeInForce,
-            slippage_tolerance_bps: params.slippageToleranceBps,
-            expires_at: params.expiresAt,
-        };
-        return await this.makeAuthenticatedRequest(perpRoutes.orders.createConditional(), {
-            method: "POST",
-            body: JSON.stringify(requestBody),
-        });
-    }
     async cancelConditionalOrder(conditionalOrderId) {
         validate(CancelConditionalOrderSchema, { conditionalOrderId });
         return await this.makeAuthenticatedRequest(perpRoutes.orders.cancelConditional(conditionalOrderId), {
@@ -363,6 +344,8 @@ export class TradingAPIImpl extends BaseAPI {
                 expiration_date: order.expirationDate,
                 time_in_force: order.timeInForce,
                 margin_account_id: order.marginAccountId,
+                margin_bucket_id: order.marginBucketId,
+                margin_bucket_collateral: order.marginBucketCollateral,
                 strategy_key: order.strategyKey,
                 position_side: order.positionSide,
                 leverage: order.leverage,
@@ -493,8 +476,11 @@ export class TradingAPIImpl extends BaseAPI {
      * ```
      */
     async getOrder(orderId) {
-        return await this.makeAuthenticatedRequest(perpRoutes.orders.get(orderId), {
-            method: "GET",
-        });
+        // The REST endpoint returns the order fields at the top level (a flat
+        // `Order`), not wrapped in `{ order, status }`. Wrap it here so the SDK
+        // honors its declared `GetOrderResponse` contract. A non-2xx response
+        // throws in `makeAuthenticatedRequest`, so reaching here means success.
+        const order = await this.makeAuthenticatedRequest(perpRoutes.orders.get(orderId), { method: "GET" });
+        return { order, status: "SUCCESS" };
     }
 }

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

@@ -1,9 +1,9 @@
-import type { ConditionalOrderEvent, Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
+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;
 export interface MonacoWebSocketOptions {
-    /** JWT access token for authenticated channels (orders) */
-    token?: string;
+    /** Session keypair for authenticated channels (orders, balances, etc.) */
+    session?: SessionCredentials;
     /** Enable auto-reconnect on disconnect (default: true) */
     autoReconnect?: boolean;
     /** Maximum reconnection attempts (default: 5) */
@@ -20,8 +20,8 @@ export interface MonacoWebSocket {
     isConnected: () => boolean;
     /** Get current websocket connection status */
     getStatus: () => WebSocketStatus;
-    /** Update the access token (for re-auth) */
-    setToken: (token: string) => void;
+    /** Set (or clear) the session keypair used to authenticate the connection */
+    setSessionKeypair: (credentials: SessionCredentials | undefined) => void;
     /** Subscribe to order events (requires authentication) */
     orders: (tradingPairId: string, tradingMode: TradingMode, handler: MessageHandler<OrderEvent>) => () => void;
     /** Subscribe to orderbook events (public) */

package/dist/api/websocket/websocket.js

@@ -1,3 +1,5 @@
+import { hexToBytes } from "@noble/hashes/utils";
+import { composeWsSigningString, signMessage } from "../../crypto/session";
 import { ALL_MAGNITUDES } from "../../utils";
 import { keysToCamelCase } from "./utils";
 // Connection constants
@@ -107,7 +109,7 @@ function parseConditionalOrderEvent(rawData) {
  */
 export function createMonacoWebSocket(baseUrl, options = {}) {
     let ws = null;
-    let token = options.token;
+    let session = options.session;
     let reconnectAttempts = 0;
     let reconnectTimer = null;
     let heartbeatTimer = null;
@@ -127,11 +129,24 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 return "disconnected";
         }
     };
-    const getUrl = () => {
-        const url = new URL(baseUrl);
-        if (token)
-            url.searchParams.set("token", token);
-        return url.toString();
+    const getUrl = () => baseUrl;
+    /**
+     * 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
+     * key; the server binds the connection to the session. No-op if no session
+     * is set (public channels work unauthenticated).
+     */
+    const sendAuthenticate = () => {
+        if (!session || ws?.readyState !== WebSocket.OPEN)
+            return;
+        const timestamp = Date.now();
+        const signature = signMessage(hexToBytes(session.privateKey), composeWsSigningString(session.publicKey, timestamp));
+        ws.send(JSON.stringify({
+            type: "Authenticate",
+            public_key: session.publicKey,
+            timestamp,
+            signature,
+        }));
     };
     const stopHeartbeat = () => {
         if (heartbeatTimer) {
@@ -217,6 +232,9 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                     }
                     reconnectAttempts = 0;
                     startHeartbeat();
+                    // Authenticate before resubscribing so user-specific channels
+                    // (orders, balances, …) are authorized when the Subscribe arrives.
+                    sendAuthenticate();
                     resubscribeAll();
                     options.onStatusChange?.("connected");
                     resolve();
@@ -324,7 +342,9 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 const data = rawData;
                 const orderbookData = data.data;
                 const event = {
-                    tradingPairId: data.symbol,
+                    // `trading_pair_id` is the pair UUID; `symbol` is the display string
+                    // (e.g. "AMZN/USDC"). `tradingPairId` must carry the UUID.
+                    tradingPairId: data.trading_pair_id,
                     tradingMode: data.trading_mode,
                     bids: (orderbookData?.bids || []).map((level) => ({
                         price: level.price,
@@ -368,7 +388,9 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
                 const data = rawData;
                 const ohlcvData = data.data;
                 const event = {
-                    tradingPairId: data.symbol,
+                    // `trading_pair_id` is the pair UUID; `symbol` is the display string.
+                    // `tradingPairId` must carry the UUID (the symbol lives in `candlestick.s`).
+                    tradingPairId: data.trading_pair_id,
                     tradingMode: data.trading_mode,
                     interval: data.interval,
                     candlestick: {
@@ -532,21 +554,20 @@ export function createMonacoWebSocket(baseUrl, options = {}) {
         disconnect,
         isConnected: () => ws?.readyState === WebSocket.OPEN,
         getStatus,
-        setToken: (newToken) => {
-            token = newToken || undefined;
-            stopReconnect();
-            const currentSocket = ws;
-            if (currentSocket?.readyState === WebSocket.OPEN ||
-                currentSocket?.readyState === WebSocket.CONNECTING ||
-                currentSocket?.readyState === WebSocket.CLOSING) {
-                currentSocket.close(1000, newToken ? "Token updated, reconnecting." : "Token cleared.");
-                ws = null;
+        setSessionKeypair: (credentials) => {
+            session = credentials ?? undefined;
+            // If already connected, (re)send the signed handshake so the connection
+            // picks up the new session without tearing down. If not yet connected,
+            // onopen will send it. Clearing the session leaves the connection up for
+            // public channels; logout calls disconnect() to fully tear down.
+            if (session && ws?.readyState === WebSocket.OPEN) {
+                sendAuthenticate();
+            }
+            else if (session && (!ws || ws.readyState === WebSocket.CLOSED)) {
+                connect().catch((err) => {
+                    console.warn("WebSocket: Failed to connect after session update:", err);
+                });
             }
-            if (!newToken)
-                return;
-            connect().catch((err) => {
-                console.warn("WebSocket: Failed to reconnect after token update:", err);
-            });
         },
         orders: subscribeOrders,
         orderbook: subscribeOrderbook,

package/dist/api/whitelist/api.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Whitelist API Implementation
+ *
+ * Public (unauthenticated) whitelist/waitlist application submission. The
+ * server validates and de-duplicates by wallet address and email, creating an
+ * inactive user pending manual approval. This is an onboarding endpoint, not a
+ * trading operation.
+ *
+ * @example
+ * ```typescript
+ * const { message, user_id } = await sdk.whitelist.submit({
+ *   wallet_address: "0x...",
+ *   email: "user@example.com",
+ * });
+ * ```
+ */
+import type { SubmitWhitelistRequest, SubmitWhitelistResponse, WhitelistAPI } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class WhitelistAPIImpl extends BaseAPI implements WhitelistAPI {
+    /**
+     * Submits a whitelist (waitlist) application. Public — no auth required.
+     *
+     * @param body - Applicant details
+     * @returns Promise resolving to the status message and created user id
+     */
+    submit(body: SubmitWhitelistRequest): Promise<SubmitWhitelistResponse>;
+}