@0xmonaco/core 0.8.14 → 0.8.16

package/dist/api/profile/api.js

@@ -40,8 +40,8 @@ export class ProfileAPIImpl extends BaseAPI {
      * console.log(`User ID: ${profile.id}`);
      * console.log(`Address: ${profile.address}`);
      * console.log(`Username: ${profile.username}`);
-     * console.log(`Account type: ${profile.account_type}`);
-     * console.log(`Can withdraw: ${profile.can_withdraw}`);
+     * console.log(`Account type: ${profile.accountType}`);
+     * console.log(`Can withdraw: ${profile.canWithdraw}`);
      * ```
      */
     async getProfile() {
@@ -56,27 +56,27 @@ export class ProfileAPIImpl extends BaseAPI {
      * @param params - Optional query parameters for pagination and filtering
      * @param params.page - Page number (starts from 1, default: 1)
      * @param params.limit - Number of items per page (default: 20, max: 100)
-     * @param params.entry_type - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
-     * @param params.transaction_type - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
-     * @param params.asset_id - Filter by asset ID (UUID)
+     * @param params.entryType - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
+     * @param params.transactionType - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
+     * @param params.assetId - Filter by asset ID (UUID)
      * @returns Promise resolving to paginated movements response
      * @throws {APIError} When the request fails or user is not authenticated
      *
      * @example
      * ```typescript
-     * // Get first page with default page_size (20)
+     * // Get first page with default pageSize (20)
      * const movements = await profileAPI.getPaginatedUserMovements();
      * console.log(`Total movements: ${movements.total}`);
      *
-     * // Get second page with custom page_size
-     * const page2 = await profileAPI.getPaginatedUserMovements({ page: 2, page_size: 50 });
-     * console.log(`Page ${page2.page} of ${page2.total_pages}`);
+     * // Get second page with custom pageSize
+     * const page2 = await profileAPI.getPaginatedUserMovements({ page: 2, pageSize: 50 });
+     * console.log(`Page ${page2.page} of ${page2.totalPages}`);
      *
      * // Filter by entry type and transaction type
-     * const deposits = await profileAPI.getPaginatedUserMovements({ entry_type: "CREDIT", transaction_type: "DEPOSIT" });
+     * const deposits = await profileAPI.getPaginatedUserMovements({ entryType: "CREDIT", transactionType: "DEPOSIT" });
      *
      * // Filter by asset
-     * const usdcMovements = await profileAPI.getPaginatedUserMovements({ asset_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * const usdcMovements = await profileAPI.getPaginatedUserMovements({ assetId: "550e8400-e29b-41d4-a716-446655440000" });
      * ```
      */
     async getPaginatedUserMovements(params) {
@@ -87,17 +87,17 @@ export class ProfileAPIImpl extends BaseAPI {
         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?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
-        if (params?.entry_type !== undefined) {
-            searchParams.append("entry_type", params.entry_type);
+        if (params?.entryType !== undefined) {
+            searchParams.append("entryType", params.entryType);
         }
-        if (params?.transaction_type !== undefined) {
-            searchParams.append("transaction_type", params.transaction_type);
+        if (params?.transactionType !== undefined) {
+            searchParams.append("transactionType", params.transactionType);
         }
-        if (params?.asset_id !== undefined) {
-            searchParams.append("asset_id", params.asset_id);
+        if (params?.assetId !== undefined) {
+            searchParams.append("assetId", params.assetId);
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/movements?${queryString}` : "/api/v1/accounts/movements";
@@ -111,7 +111,7 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * @param params - Optional query parameters for pagination
      * @param params.page - Page number (starts from 1, default: 1)
-     * @param params.page_size - Number of items per page (default: 20, max: 100)
+     * @param params.pageSize - Number of items per page (default: 20, max: 100)
      * @returns Promise resolving to paginated balances response
      * @throws {APIError} When the request fails or user is not authenticated
      *
@@ -121,11 +121,11 @@ export class ProfileAPIImpl extends BaseAPI {
      * const balances = await profileAPI.getUserBalances();
      * console.log(`Total balances: ${balances.total}`);
      * balances.balances.forEach(balance => {
-     *   console.log(`${balance.symbol}: ${balance.available_balance}`);
+     *   console.log(`${balance.symbol}: ${balance.availableBalance}`);
      * });
      *
      * // Get page 2 with 50 items per page
-     * const nextBalances = await profileAPI.getUserBalances({ page: 2, page_size: 50 });
+     * const nextBalances = await profileAPI.getUserBalances({ page: 2, pageSize: 50 });
      * console.log(`Returned ${nextBalances.balances.length} balances`);
      * ```
      */
@@ -134,8 +134,8 @@ export class ProfileAPIImpl extends BaseAPI {
         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?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/balances?${queryString}` : "/api/v1/accounts/balances";
@@ -144,7 +144,7 @@ export class ProfileAPIImpl extends BaseAPI {
     /**
      * Get the current user's balance for a specific asset.
      *
-     * Fetches the user's balance for a specific asset from the /api/v1/accounts/balances/{asset_id} endpoint.
+     * Fetches the user's balance for a specific asset from the /api/v1/accounts/balances/{assetId} endpoint.
      * Requires a valid access token to be set. If no balance exists for a valid asset, returns zero balances.
      *
      * @param assetId - The asset identifier (UUID)
@@ -155,15 +155,15 @@ export class ProfileAPIImpl extends BaseAPI {
      * ```typescript
      * // Get balance for a specific asset
      * const balance = await profileAPI.getUserBalanceByAssetId('123e4567-e89b-12d3-a456-426614174000');
-     * console.log(`${balance.symbol}: ${balance.available_balance}`);
-     * console.log(`Locked: ${balance.locked_balance}`);
-     * console.log(`Total: ${balance.total_balance}`);
+     * console.log(`${balance.symbol}: ${balance.availableBalance}`);
+     * console.log(`Locked: ${balance.lockedBalance}`);
+     * console.log(`Total: ${balance.totalBalance}`);
      * ```
      */
     async getUserBalanceByAssetId(assetId) {
         if (!assetId || assetId.trim() === "") {
             throw new APIError("assetId is required and cannot be empty", {
-                endpoint: "/api/v1/accounts/balances/{asset_id}",
+                endpoint: "/api/v1/accounts/balances/{assetId}",
             });
         }
         const url = `/api/v1/accounts/balances/${assetId}`;
@@ -184,7 +184,7 @@ export class ProfileAPIImpl extends BaseAPI {
      * const stats = await profileAPI.getPortfolioStats("30d");
      * console.log(`PnL: ${stats.pnl}`);
      * console.log(`Volume: ${stats.volume}`);
-     * console.log(`Total equity: ${stats.total_equity}`);
+     * console.log(`Total equity: ${stats.totalEquity}`);
      * ```
      */
     async getPortfolioStats(period) {
@@ -222,8 +222,8 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * @param params - Optional query parameters for pagination and filtering
      * @param params.page - Page number (starts from 1, default: 1)
-     * @param params.page_size - Number of items per page (default: 20, max: 100)
-     * @param params.trading_pair_id - Filter by trading pair ID (UUID)
+     * @param params.pageSize - Number of items per page (default: 20, max: 100)
+     * @param params.tradingPairId - Filter by trading pair ID (UUID)
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
      * @throws {APIError} When the request fails or user is not authenticated
@@ -235,7 +235,7 @@ export class ProfileAPIImpl extends BaseAPI {
      * console.log(`Total trades: ${trades.total}`);
      *
      * // Filter by trading pair
-     * const pairTrades = await profileAPI.getUserTrades({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * const pairTrades = await profileAPI.getUserTrades({ tradingPairId: "550e8400-e29b-41d4-a716-446655440000" });
      * ```
      */
     async getUserTrades(params) {
@@ -246,11 +246,11 @@ export class ProfileAPIImpl extends BaseAPI {
         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?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
-        if (params?.trading_pair_id !== undefined) {
-            searchParams.append("trading_pair_id", params.trading_pair_id);
+        if (params?.tradingPairId !== undefined) {
+            searchParams.append("tradingPairId", params.tradingPairId);
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/trades?${queryString}` : "/api/v1/accounts/trades";
@@ -268,7 +268,7 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * @example
      * ```typescript
-     * const funding = await profileAPI.listFundingPayments({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * const funding = await profileAPI.listFundingPayments({ tradingPairId: "550e8400-e29b-41d4-a716-446655440000" });
      * console.log(`Total funding payments: ${funding.total}`);
      * ```
      */
@@ -280,17 +280,17 @@ export class ProfileAPIImpl extends BaseAPI {
         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?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
-        if (params?.trading_pair_id !== undefined) {
-            searchParams.append("trading_pair_id", params.trading_pair_id);
+        if (params?.tradingPairId !== undefined) {
+            searchParams.append("tradingPairId", params.tradingPairId);
         }
-        if (params?.position_id !== undefined) {
-            searchParams.append("position_id", params.position_id);
+        if (params?.positionId !== undefined) {
+            searchParams.append("positionId", params.positionId);
         }
-        if (params?.margin_account_id !== undefined) {
-            searchParams.append("margin_account_id", params.margin_account_id);
+        if (params?.marginAccountId !== undefined) {
+            searchParams.append("marginAccountId", params.marginAccountId);
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/funding-payments?${queryString}` : "/api/v1/accounts/funding-payments";

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

@@ -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 type { CreateSubAccountLimitRequest, CreateSubAccountLimitResponse, GetSubAccountLimitsResponse, ListSubAccountsResponse, SubAccountsAPI, UpdateSubAccountLimitBody, UpdateSubAccountLimitResponse } from "@0xmonaco/types";

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) {