@0xmonaco/core 0.8.14 → 0.8.15

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

@@ -9,8 +9,8 @@
  *
  * @example
  * ```typescript
- * const { sub_accounts } = await sdk.subAccounts.list();
- * await sdk.subAccounts.createLimit({ sub_account_id, asset_id, max_amount: "1000.00" });
+ * const { subAccounts } = await sdk.subAccounts.list();
+ * await sdk.subAccounts.createLimit({ subAccountId, assetId, maxAmount: "1000.00" });
  * ```
  */
 import { BaseAPI } from "../base";

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

@@ -1,25 +1,25 @@
 import type { TradeEvent } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
- * Raw trade event from the API (snake_case) - matches websocket structure
+ * Raw trade event from the API (camelCase wire shape).
  */
 interface RawTradeEvent {
-    event_type: string;
-    trading_pair_id: string;
-    trading_mode: string;
+    eventType: string;
+    tradingPairId: string;
+    tradingMode: string;
     data: {
-        trade_id: string;
+        tradeId: string;
         price: string;
         quantity: string;
         /** Raw (integer) quantity; present on single-trade lookups, ignored when mapping */
-        quantity_raw?: string;
-        maker_side: string;
+        quantityRaw?: string;
+        makerSide: string;
         /** Absent when the trade has no recorded execution time */
-        executed_at?: string;
+        executedAt?: string;
     };
 }
 /**
- * Convert a raw trade event (snake_case) to a TradeEvent (camelCase)
+ * Convert a raw wire trade event to an ergonomic TradeEvent.
  */
 export declare function parseRawTradeEvent(raw: RawTradeEvent): TradeEvent;
 /**
@@ -29,7 +29,7 @@ export interface GetTradesOptions {
     /** Page number (starts from 1, default: 1) */
     page?: number;
     /** Maximum number of records to return (default: 25, max: 100) */
-    page_size?: number;
+    pageSize?: number;
 }
 /**
  * Trades API for fetching historical trade data
@@ -40,7 +40,7 @@ export declare class TradesAPIImpl extends BaseAPI {
      *
      * @param tradingPairId - The trading pair UUID
      * @param options - Pagination options
-     * @returns Array of TradeEvent records sorted by executed_at descending (newest first)
+     * @returns Array of TradeEvent records sorted by executedAt descending (newest first)
      */
     getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<TradeEvent[]>;
     /**

package/dist/api/trades/api.js

@@ -1,19 +1,19 @@
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 /**
- * Convert a raw trade event (snake_case) to a TradeEvent (camelCase)
+ * Convert a raw wire trade event to an ergonomic TradeEvent.
  */
 export function parseRawTradeEvent(raw) {
     return {
         eventType: "trade",
-        tradingPairId: raw.trading_pair_id,
-        tradingMode: raw.trading_mode.toUpperCase(),
+        tradingPairId: raw.tradingPairId,
+        tradingMode: raw.tradingMode.toUpperCase(),
         data: {
-            tradeId: raw.data.trade_id,
+            tradeId: raw.data.tradeId,
             price: raw.data.price,
             quantity: raw.data.quantity,
-            makerSide: raw.data.maker_side.toUpperCase(),
-            executedAt: raw.data.executed_at ?? "",
+            makerSide: raw.data.makerSide.toUpperCase(),
+            executedAt: raw.data.executedAt ?? "",
         },
     };
 }
@@ -26,17 +26,17 @@ export class TradesAPIImpl extends BaseAPI {
      *
      * @param tradingPairId - The trading pair UUID
      * @param options - Pagination options
-     * @returns Array of TradeEvent records sorted by executed_at descending (newest first)
+     * @returns Array of TradeEvent records sorted by executedAt descending (newest first)
      */
     async getTrades(tradingPairId, options = {}) {
         const { page = 1 } = options;
-        // Ensure page_size is a positive number between 1 and 100, defaulting to 25
-        const page_size = options.page_size != null && options.page_size > 0 ? Math.min(options.page_size, 100) : 25;
+        // Ensure pageSize is a positive number between 1 and 100, defaulting to 25
+        const pageSize = options.pageSize != null && options.pageSize > 0 ? Math.min(options.pageSize, 100) : 25;
         const params = new URLSearchParams();
         if (page > 1) {
             params.set("page", String(page));
         }
-        params.set("page_size", String(page_size));
+        params.set("pageSize", String(pageSize));
         const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return response.trades.map(parseRawTradeEvent);
     }

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

@@ -262,9 +262,9 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      *
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED") (optional)
-     * @param params.trading_pair_id - Filter by trading pair UUID (optional)
+     * @param params.tradingPairId - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
-     * @param params.page_size - Number of orders per page (defaults to 10, max 100, must be > 0)
+     * @param params.pageSize - Number of orders per page (defaults to 10, max 100, must be > 0)
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -273,13 +273,13 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * // Get submitted orders for a specific trading pair with custom pagination
      * const orders = await tradingAPI.getPaginatedOrders({
      *   status: "SUBMITTED",
-     *   trading_pair_id: "456e7890-e12b-12d3-a456-426614174000",
+     *   tradingPairId: "456e7890-e12b-12d3-a456-426614174000",
      *   page: 1,
-     *   page_size: 20
+     *   pageSize: 20
      * });
      * console.log(`Found ${orders.total} orders, showing page ${orders.page}`);
      *
-     * // Get all orders with default pagination (page=1, page_size=10)
+     * // Get all orders with default pagination (page=1, pageSize=10)
      * const allOrders = await tradingAPI.getPaginatedOrders();
      * ```
      */
@@ -299,7 +299,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * // Get order details by ID
      * const orderDetails = await tradingAPI.getOrder("order_123");
      * console.log(`Order status: ${orderDetails.order.status}`);
-     * console.log(`Remaining quantity: ${orderDetails.order.remaining_quantity}`);
+     * console.log(`Remaining quantity: ${orderDetails.order.remainingQuantity}`);
      * ```
      */
     getOrder(orderId: string): Promise<GetOrderResponse>;

package/dist/api/trading/api.js

@@ -28,12 +28,12 @@ function parentTpSlLegToRequest(leg) {
     if (!leg)
         return undefined;
     return {
-        trigger_price: leg.triggerPrice,
-        order_type: leg.orderType,
-        limit_price: leg.limitPrice,
-        time_in_force: leg.timeInForce,
-        slippage_tolerance_bps: leg.slippageToleranceBps,
-        expires_at: leg.expiresAt,
+        triggerPrice: leg.triggerPrice,
+        orderType: leg.orderType,
+        limitPrice: leg.limitPrice,
+        timeInForce: leg.timeInForce,
+        slippageToleranceBps: leg.slippageToleranceBps,
+        expiresAt: leg.expiresAt,
     };
 }
 export class TradingAPIImpl extends BaseAPI {
@@ -97,24 +97,24 @@ export class TradingAPIImpl extends BaseAPI {
             options,
         });
         const requestBody = {
-            trading_pair_id: tradingPairId,
-            order_type: "LIMIT",
+            tradingPairId: tradingPairId,
+            orderType: "LIMIT",
             side,
             price,
             quantity,
-            trading_mode: options?.tradingMode || "SPOT",
-            use_master_balance: options?.useMasterBalance,
-            expiration_date: options?.expirationDate,
-            time_in_force: options?.timeInForce,
-            margin_account_id: options?.marginAccountId,
-            risk_bucket_id: options?.riskBucketId,
-            risk_bucket_collateral: options?.riskBucketCollateral,
-            strategy_key: options?.strategyKey,
-            position_side: options?.positionSide,
+            tradingMode: options?.tradingMode || "SPOT",
+            useMasterBalance: options?.useMasterBalance,
+            expirationDate: options?.expirationDate,
+            timeInForce: options?.timeInForce,
+            marginAccountId: options?.marginAccountId,
+            riskBucketId: options?.riskBucketId,
+            riskBucketCollateral: options?.riskBucketCollateral,
+            strategyKey: options?.strategyKey,
+            positionSide: options?.positionSide,
             leverage: options?.leverage,
-            reduce_only: options?.reduceOnly,
-            take_profit: parentTpSlLegToRequest(options?.takeProfit),
-            stop_loss: parentTpSlLegToRequest(options?.stopLoss),
+            reduceOnly: options?.reduceOnly,
+            takeProfit: parentTpSlLegToRequest(options?.takeProfit),
+            stopLoss: parentTpSlLegToRequest(options?.stopLoss),
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
@@ -171,22 +171,22 @@ export class TradingAPIImpl extends BaseAPI {
             options,
         });
         const requestBody = {
-            trading_pair_id: tradingPairId,
-            order_type: "MARKET",
+            tradingPairId: tradingPairId,
+            orderType: "MARKET",
             side,
-            slippage_tolerance_bps: options?.slippageTolerance !== undefined ? Math.round(options.slippageTolerance * 10000) : undefined,
+            slippageToleranceBps: options?.slippageTolerance !== undefined ? Math.round(options.slippageTolerance * 10000) : undefined,
             price: null, // Market orders don't need price
             quantity,
-            trading_mode: options?.tradingMode || "SPOT",
-            margin_account_id: options?.marginAccountId,
-            risk_bucket_id: options?.riskBucketId,
-            risk_bucket_collateral: options?.riskBucketCollateral,
-            strategy_key: options?.strategyKey,
-            position_side: options?.positionSide,
+            tradingMode: options?.tradingMode || "SPOT",
+            marginAccountId: options?.marginAccountId,
+            riskBucketId: options?.riskBucketId,
+            riskBucketCollateral: options?.riskBucketCollateral,
+            strategyKey: options?.strategyKey,
+            positionSide: options?.positionSide,
             leverage: options?.leverage,
-            reduce_only: options?.reduceOnly,
-            take_profit: parentTpSlLegToRequest(options?.takeProfit),
-            stop_loss: parentTpSlLegToRequest(options?.stopLoss),
+            reduceOnly: options?.reduceOnly,
+            takeProfit: parentTpSlLegToRequest(options?.takeProfit),
+            stopLoss: parentTpSlLegToRequest(options?.stopLoss),
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
@@ -213,7 +213,7 @@ export class TradingAPIImpl extends BaseAPI {
         // Validate inputs before making API call
         validate(CancelOrderSchema, { orderId });
         const requestBody = {
-            order_id: orderId,
+            orderId: orderId,
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.cancel(), {
             method: "POST",
@@ -230,12 +230,12 @@ export class TradingAPIImpl extends BaseAPI {
         if (params) {
             validate(ListConditionalOrdersSchema, params);
         }
-        const { page = 1, page_size = 20, margin_account_id, trading_pair_id, state } = params || {};
+        const { page = 1, pageSize = 20, marginAccountId, tradingPairId, state } = params || {};
         return await this.makeAuthenticatedRequest(perpRoutes.orders.listConditional({
             page,
-            page_size: Math.min(Math.max(page_size, 1), 100),
-            margin_account_id,
-            trading_pair_id,
+            pageSize: Math.min(Math.max(pageSize, 1), 100),
+            marginAccountId,
+            tradingPairId,
             state,
         }), { method: "GET" });
     }
@@ -257,7 +257,7 @@ export class TradingAPIImpl extends BaseAPI {
         }
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchCancel(), {
             method: "POST",
-            body: JSON.stringify({ order_ids: orderIds }),
+            body: JSON.stringify({ orderIds: orderIds }),
         });
     }
     /**
@@ -286,7 +286,7 @@ export class TradingAPIImpl extends BaseAPI {
         // Validate inputs before making API call
         validate(ReplaceOrderSchema, { orderId, newOrder });
         const requestBody = {
-            use_master_balance: newOrder.useMasterBalance ?? false,
+            useMasterBalance: newOrder.useMasterBalance ?? false,
         };
         if (newOrder.price !== undefined) {
             requestBody.price = newOrder.price;
@@ -333,23 +333,23 @@ export class TradingAPIImpl extends BaseAPI {
         validate(BatchCreateOrdersSchema, { orders });
         const requestBody = {
             orders: orders.map((order) => ({
-                trading_pair_id: order.tradingPairId,
-                order_type: order.orderType,
+                tradingPairId: order.tradingPairId,
+                orderType: order.orderType,
                 side: order.side,
                 price: order.price,
                 quantity: order.quantity,
-                trading_mode: order.tradingMode || "SPOT",
-                slippage_tolerance_bps: order.slippageTolerance !== undefined ? Math.round(order.slippageTolerance * 10000) : undefined,
-                use_master_balance: order.useMasterBalance,
-                expiration_date: order.expirationDate,
-                time_in_force: order.timeInForce,
-                margin_account_id: order.marginAccountId,
-                risk_bucket_id: order.riskBucketId,
-                risk_bucket_collateral: order.riskBucketCollateral,
-                strategy_key: order.strategyKey,
-                position_side: order.positionSide,
+                tradingMode: order.tradingMode || "SPOT",
+                slippageToleranceBps: order.slippageTolerance !== undefined ? Math.round(order.slippageTolerance * 10000) : undefined,
+                useMasterBalance: order.useMasterBalance,
+                expirationDate: order.expirationDate,
+                timeInForce: order.timeInForce,
+                marginAccountId: order.marginAccountId,
+                riskBucketId: order.riskBucketId,
+                riskBucketCollateral: order.riskBucketCollateral,
+                strategyKey: order.strategyKey,
+                positionSide: order.positionSide,
                 leverage: order.leverage,
-                reduce_only: order.reduceOnly,
+                reduceOnly: order.reduceOnly,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchCreate(), {
@@ -386,10 +386,10 @@ export class TradingAPIImpl extends BaseAPI {
         validate(BatchReplaceOrdersSchema, { orders });
         const requestBody = {
             orders: orders.map((order) => ({
-                order_id: order.orderId,
+                orderId: order.orderId,
                 price: order.price,
                 quantity: order.quantity,
-                use_master_balance: order.useMasterBalance,
+                useMasterBalance: order.useMasterBalance,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchReplace(), {
@@ -405,9 +405,9 @@ export class TradingAPIImpl extends BaseAPI {
      *
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED") (optional)
-     * @param params.trading_pair_id - Filter by trading pair UUID (optional)
+     * @param params.tradingPairId - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
-     * @param params.page_size - Number of orders per page (defaults to 10, max 100, must be > 0)
+     * @param params.pageSize - Number of orders per page (defaults to 10, max 100, must be > 0)
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -416,13 +416,13 @@ export class TradingAPIImpl extends BaseAPI {
      * // Get submitted orders for a specific trading pair with custom pagination
      * const orders = await tradingAPI.getPaginatedOrders({
      *   status: "SUBMITTED",
-     *   trading_pair_id: "456e7890-e12b-12d3-a456-426614174000",
+     *   tradingPairId: "456e7890-e12b-12d3-a456-426614174000",
      *   page: 1,
-     *   page_size: 20
+     *   pageSize: 20
      * });
      * console.log(`Found ${orders.total} orders, showing page ${orders.page}`);
      *
-     * // Get all orders with default pagination (page=1, page_size=10)
+     * // Get all orders with default pagination (page=1, pageSize=10)
      * const allOrders = await tradingAPI.getPaginatedOrders();
      * ```
      */
@@ -432,25 +432,25 @@ export class TradingAPIImpl extends BaseAPI {
             validate(GetPaginatedOrdersSchema, params);
         }
         // Set pagination defaults with destructuring and validation
-        const { page = 1, page_size = 10, status, trading_pair_id, trading_mode, margin_account_id } = params || {};
+        const { page = 1, pageSize: requestedPageSize = 10, status, tradingPairId, tradingMode, marginAccountId } = params || {};
         const validPage = page > 0 ? page : 1;
-        const validPageSize = page_size > 0 ? page_size : 10;
+        const validPageSize = requestedPageSize > 0 ? requestedPageSize : 10;
         const pageSize = Math.min(validPageSize, 100);
         const searchParams = new URLSearchParams();
         // Always include pagination parameters for consistent API behavior
         searchParams.append("page", validPage.toString());
-        searchParams.append("page_size", pageSize.toString());
+        searchParams.append("pageSize", pageSize.toString());
         if (status) {
             searchParams.append("status", status);
         }
-        if (trading_pair_id) {
-            searchParams.append("trading_pair_id", trading_pair_id);
+        if (tradingPairId) {
+            searchParams.append("tradingPairId", tradingPairId);
         }
-        if (trading_mode) {
-            searchParams.append("trading_mode", trading_mode);
+        if (tradingMode) {
+            searchParams.append("tradingMode", tradingMode);
         }
-        if (margin_account_id) {
-            searchParams.append("margin_account_id", margin_account_id);
+        if (marginAccountId) {
+            searchParams.append("marginAccountId", marginAccountId);
         }
         const endpoint = `/api/v1/orders?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {
@@ -472,7 +472,7 @@ export class TradingAPIImpl extends BaseAPI {
      * // Get order details by ID
      * const orderDetails = await tradingAPI.getOrder("order_123");
      * console.log(`Order status: ${orderDetails.order.status}`);
-     * console.log(`Remaining quantity: ${orderDetails.order.remaining_quantity}`);
+     * console.log(`Remaining quantity: ${orderDetails.order.remainingQuantity}`);
      * ```
      */
     async getOrder(orderId) {

package/dist/api/vault/api.js

@@ -338,7 +338,7 @@ export class VaultAPIImpl extends BaseAPI {
         const deadline = Date.now() + timeoutMs;
         for (;;) {
             try {
-                const { vault_address: vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+                const { vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
                 // Ready: non-empty calldata. (Defensively treat an empty/`0x` body as
                 // not-ready too, though the gateway returns an error in that case.)
                 if (calldata && calldata !== "0x") {
@@ -428,13 +428,13 @@ export class VaultAPIImpl extends BaseAPI {
         const source = typeof sourceOrRetry === "string" ? sourceOrRetry : "spot";
         const retryOptions = typeof sourceOrRetry === "string" ? retry : sourceOrRetry;
         validate(WithdrawSchema, { assetId, amount, destination, autoWait, source });
-        // 1. Gateway allocates the withdrawal_index and debits the balance. No
+        // 1. Gateway allocates the withdrawalIndex and debits the balance. No
         // executable calldata yet — it needs the merkle proof, available only once
         // the withdrawal root is confirmed on-chain.
-        const { withdrawal_index: withdrawalIndex } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
+        const { withdrawalIndex } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
             method: "POST",
             body: JSON.stringify({
-                asset_id: assetId,
+                assetId: assetId,
                 amount: amount.toString(),
                 destination,
                 source,

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

@@ -8,8 +8,8 @@
  *
  * @example
  * ```typescript
- * const { message, user_id } = await sdk.whitelist.submit({
- *   wallet_address: "0x...",
+ * const { message, userId } = await sdk.whitelist.submit({
+ *   walletAddress: "0x...",
  *   email: "user@example.com",
  * });
  * ```

package/dist/api/whitelist/api.js

@@ -8,8 +8,8 @@
  *
  * @example
  * ```typescript
- * const { message, user_id } = await sdk.whitelist.submit({
- *   wallet_address: "0x...",
+ * const { message, userId } = await sdk.whitelist.submit({
+ *   walletAddress: "0x...",
  *   email: "user@example.com",
  * });
  * ```

package/dist/api/withdrawals/api.d.ts

@@ -1,10 +1,10 @@
-import type { InitiateWithdrawalRequest, WithdrawalResponse, WithdrawalsAPI } from "@0xmonaco/types";
+import type { InitiateWithdrawalRequest, ListPendingWithdrawalsParams, ListPendingWithdrawalsResponse, WithdrawalResponse, WithdrawalsAPI } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Low-level withdrawals client.
  *
  * `initiateWithdrawal` debits the caller's balance via the matching engine and
- * allocates a `withdrawal_index` (its `calldata` is empty — the proof is not
+ * allocates a `withdrawalIndex` (its `calldata` is empty — the proof is not
  * available until the withdrawal root is confirmed on-chain). `getWithdrawal`
  * returns the `executeWithdrawal` calldata once that proof is ready, and throws
  * an `APIError` (404 not-persisted-yet / 409 not-confirmed-yet) while it is not.
@@ -14,4 +14,5 @@ import { BaseAPI } from "../base";
 export declare class WithdrawalsAPIImpl extends BaseAPI implements WithdrawalsAPI {
     initiateWithdrawal(request: InitiateWithdrawalRequest): Promise<WithdrawalResponse>;
     getWithdrawal(withdrawalIndex: number): Promise<WithdrawalResponse>;
+    listPendingWithdrawals(params?: ListPendingWithdrawalsParams): Promise<ListPendingWithdrawalsResponse>;
 }

package/dist/api/withdrawals/api.js

@@ -4,7 +4,7 @@ import { perpRoutes } from "../perp";
  * Low-level withdrawals client.
  *
  * `initiateWithdrawal` debits the caller's balance via the matching engine and
- * allocates a `withdrawal_index` (its `calldata` is empty — the proof is not
+ * allocates a `withdrawalIndex` (its `calldata` is empty — the proof is not
  * available until the withdrawal root is confirmed on-chain). `getWithdrawal`
  * returns the `executeWithdrawal` calldata once that proof is ready, and throws
  * an `APIError` (404 not-persisted-yet / 409 not-confirmed-yet) while it is not.
@@ -16,7 +16,7 @@ export class WithdrawalsAPIImpl extends BaseAPI {
         return this.makeAuthenticatedRequest(perpRoutes.withdrawals.initiate(), {
             method: "POST",
             body: JSON.stringify({
-                asset_id: request.assetId,
+                assetId: request.assetId,
                 amount: request.amount,
                 destination: request.destination,
                 source: request.source ?? "spot",
@@ -27,4 +27,9 @@ export class WithdrawalsAPIImpl extends BaseAPI {
         // Public lookup — no auth required.
         return this.makePublicRequest(perpRoutes.withdrawals.byIndex(withdrawalIndex));
     }
+    async listPendingWithdrawals(params) {
+        // The gateway serves camelCase (the REST wire format), which matches the
+        // public surface, so the response is returned directly with no remapping.
+        return this.makeAuthenticatedRequest(perpRoutes.withdrawals.list({ page: params?.page, pageSize: params?.pageSize }));
+    }
 }

package/dist/coverage.d.ts

@@ -51,6 +51,7 @@ export declare const COVERED: {
     get_user_trades: string;
     get_withdrawal: string;
     initiate_withdrawal: string;
+    list_pending_withdrawals: string;
     list_application_balances: string;
     list_application_movements: string;
     list_application_orders: string;

package/dist/coverage.js

@@ -51,6 +51,7 @@ export const COVERED = {
     get_user_trades: "getUserTrades",
     get_withdrawal: "getWithdrawal",
     initiate_withdrawal: "initiateWithdrawal",
+    list_pending_withdrawals: "listPendingWithdrawals",
     list_application_balances: "listApplicationBalances",
     list_application_movements: "listApplicationMovements",
     list_application_orders: "listApplicationOrders",

package/dist/sdk.js

@@ -242,10 +242,10 @@ export class MonacoSDKImpl {
         this.authState = {
             sessionPublicKey: session.publicKey,
             sessionPrivateKey: session.privateKey,
-            expiresAt: delegatedSession.expires_at,
+            expiresAt: delegatedSession.expiresAt,
             user: {
-                id: delegatedSession.owner_user_id,
-                address: delegatedSession.agent_address,
+                id: delegatedSession.ownerUserId,
+                address: delegatedSession.agentAddress,
             },
         };
         this.propagateSession(this.sessionFromAuthState(this.authState));

package/package.json

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