@0xmonaco/core 0.8.11 → 0.8.15

package/dist/api/applications/api.js

@@ -48,10 +48,10 @@ export class ApplicationsAPIImpl extends BaseAPI {
         return {
             id: data.id,
             name: data.name,
-            allowedOrigins: data.allowed_origins,
-            webhookUrl: data.webhook_url,
-            vaultContractAddress: data.vault_contract_address,
-            clientId: data.client_id,
+            allowedOrigins: data.allowedOrigins,
+            webhookUrl: data.webhookUrl,
+            vaultContractAddress: data.vaultContractAddress,
+            clientId: data.clientId,
         };
     }
     /**

package/dist/api/auth/api.d.ts

@@ -142,7 +142,7 @@ export declare class AuthAPIImpl extends BaseAPI implements AuthAPI {
      * Extends the current session's expiry.
      *
      * The request is signed with the active session key (set via
-     * {@link setSessionKeypair}); the server bumps the session's `expires_at`.
+     * {@link setSessionKeypair}); the server bumps the session's `expiresAt`.
      * No new credential is issued — the same keypair keeps working.
      *
      * @returns Promise resolving to the new expiry

package/dist/api/auth/api.js

@@ -157,15 +157,15 @@ export class AuthAPIImpl extends BaseAPI {
             method: "POST",
             body: JSON.stringify({
                 address,
-                client_id: clientId,
-                chain_id: this.chain.id,
-                session_public_key: sessionPublicKey,
+                clientId: clientId,
+                chainId: this.chain.id,
+                sessionPublicKey: sessionPublicKey,
             }),
         });
         return {
             nonce: responseBody.nonce,
             message: responseBody.message,
-            expiresAt: responseBody.expires_at,
+            expiresAt: responseBody.expiresAt,
         };
     }
     /**
@@ -199,15 +199,15 @@ export class AuthAPIImpl extends BaseAPI {
                 address,
                 signature,
                 nonce,
-                client_id: clientId,
-                chain_id: this.chain.id,
-                session_public_key: session.publicKey,
+                clientId: clientId,
+                chainId: this.chain.id,
+                sessionPublicKey: session.publicKey,
             }),
         });
         return {
             sessionPublicKey: session.publicKey,
             sessionPrivateKey: session.privateKey,
-            expiresAt: responseBody.expires_at,
+            expiresAt: responseBody.expiresAt,
             user: {
                 id: responseBody.user.id,
                 address: responseBody.user.address,
@@ -219,7 +219,7 @@ export class AuthAPIImpl extends BaseAPI {
      * Extends the current session's expiry.
      *
      * The request is signed with the active session key (set via
-     * {@link setSessionKeypair}); the server bumps the session's `expires_at`.
+     * {@link setSessionKeypair}); the server bumps the session's `expiresAt`.
      * No new credential is issued — the same keypair keeps working.
      *
      * @returns Promise resolving to the new expiry
@@ -236,7 +236,7 @@ export class AuthAPIImpl extends BaseAPI {
             method: "POST",
         });
         return {
-            expiresAt: responseBody.expires_at,
+            expiresAt: responseBody.expiresAt,
         };
     }
     /**

package/dist/api/base.d.ts

@@ -99,7 +99,7 @@ export declare abstract class BaseAPI {
      *   '/api/v1/orders',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ trading_pair: 'ETH-USD', side: 'BUY' })
+     *     body: JSON.stringify({ tradingPair: 'ETH-USD', side: 'BUY' })
      *   }
      * );
      * ```
@@ -155,7 +155,7 @@ export declare abstract class BaseAPI {
      *   '/api/v1/auth/challenge',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ address, client_id: clientId })
+     *     body: JSON.stringify({ address, clientId: clientId })
      *   }
      * );
      * ```

package/dist/api/base.js

@@ -241,7 +241,7 @@ export class BaseAPI {
      *   '/api/v1/orders',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ trading_pair: 'ETH-USD', side: 'BUY' })
+     *     body: JSON.stringify({ tradingPair: 'ETH-USD', side: 'BUY' })
      *   }
      * );
      * ```
@@ -350,7 +350,7 @@ export class BaseAPI {
      *   '/api/v1/auth/challenge',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ address, client_id: clientId })
+     *     body: JSON.stringify({ address, clientId: clientId })
      *   }
      * );
      * ```

package/dist/api/delegated-agents/api.js

@@ -5,17 +5,17 @@ export class DelegatedAgentsAPIImpl extends BaseAPI {
         return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.list(), {
             method: "POST",
             body: JSON.stringify({
-                agent_address: request.agentAddress,
+                agentAddress: request.agentAddress,
                 name: request.name,
-                expires_at: request.expiresAt,
-                allowed_actions: request.allowedActions,
-                allowed_trading_pair_ids: request.allowedTradingPairIds,
-                allowed_margin_account_ids: request.allowedMarginAccountIds,
-                allowed_order_types: request.allowedOrderTypes,
-                allowed_time_in_force: request.allowedTimeInForce,
-                max_leverage: request.maxLeverage,
-                max_order_notional: request.maxOrderNotional,
-                max_open_orders: request.maxOpenOrders,
+                expiresAt: request.expiresAt,
+                allowedActions: request.allowedActions,
+                allowedTradingPairIds: request.allowedTradingPairIds,
+                allowedMarginAccountIds: request.allowedMarginAccountIds,
+                allowedOrderTypes: request.allowedOrderTypes,
+                allowedTimeInForce: request.allowedTimeInForce,
+                maxLeverage: request.maxLeverage,
+                maxOrderNotional: request.maxOrderNotional,
+                maxOpenOrders: request.maxOpenOrders,
             }),
         });
     }
@@ -34,8 +34,8 @@ export class DelegatedAgentsAPIImpl extends BaseAPI {
         return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.sessions(), {
             method: "POST",
             body: JSON.stringify({
-                owner_user_id: request.ownerUserId,
-                session_public_key: request.sessionPublicKey,
+                ownerUserId: request.ownerUserId,
+                sessionPublicKey: request.sessionPublicKey,
             }),
         });
     }

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

@@ -8,7 +8,7 @@
  *
  * @example
  * ```typescript
- * const { minted, failed, remaining_requests_24h } = await sdk.faucet.mint();
+ * const { minted, failed, remainingRequests24h } = await sdk.faucet.mint();
  * ```
  */
 import type { FaucetAPI, MintTokensResponse } from "@0xmonaco/types";

package/dist/api/faucet/api.js

@@ -8,7 +8,7 @@
  *
  * @example
  * ```typescript
- * const { minted, failed, remaining_requests_24h } = await sdk.faucet.mint();
+ * const { minted, failed, remainingRequests24h } = await sdk.faucet.mint();
  * ```
  */
 import { BaseAPI } from "../base";

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

@@ -14,7 +14,7 @@
  *
  * // Simulate fees for an order
  * const feeDetails = await feesAPI.simulateFees({
- *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
  *   side: "BUY",
  *   price: "40000.00",
  *   quantity: "0.5"
@@ -31,41 +31,41 @@ export declare class FeesAPIImpl extends BaseAPI implements FeesAPI {
      * application fees, and total amounts the taker must pay or maker will receive.
      *
      * @param params - Parameters for fee simulation
-     * @param params.trading_pair_id - The trading pair UUID
+     * @param params.tradingPairId - The trading pair UUID
      * @param params.side - The order side ("BUY" or "SELL")
      * @param params.price - The price per unit as string
      * @param params.quantity - The quantity to trade as string
-     * @param params.order_type - Order type: "LIMIT" (default) or "MARKET"
-     * @param params.slippage_tolerance_bps - Slippage tolerance in bps (0–1000, MARKET only, default 500)
+     * @param params.orderType - Order type: "LIMIT" (default) or "MARKET"
+     * @param params.slippageToleranceBps - Slippage tolerance in bps (0–1000, MARKET only, default 500)
      * @returns Promise resolving to SimulateFeeResponse with fee breakdown
      *
      * @example
      * ```typescript
      * // Simulate fees for a buy order
      * const buyFees = await feesAPI.simulateFees({
-     *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+     *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      *   side: "BUY",
      *   price: "40000.00",
      *   quantity: "0.5"
      * });
      *
      * console.log(`Notional value: ${buyFees.notional}`);
-     * console.log(`Monaco taker fee: ${buyFees.monaco_taker_fee}`);
-     * console.log(`Application taker fee: ${buyFees.application_taker_fee}`);
-     * console.log(`Total taker fees: ${buyFees.total_taker_fees}`);
-     * console.log(`Total payment required: ${buyFees.taker_total_payment}`);
-     * console.log(`Lock amount for BUY: ${buyFees.buy_order_lock_amount}`);
+     * console.log(`Monaco taker fee: ${buyFees.monacoTakerFee}`);
+     * console.log(`Application taker fee: ${buyFees.applicationTakerFee}`);
+     * console.log(`Total taker fees: ${buyFees.totalTakerFees}`);
+     * console.log(`Total payment required: ${buyFees.takerTotalPayment}`);
+     * console.log(`Lock amount for BUY: ${buyFees.buyOrderLockAmount}`);
      *
      * // Simulate fees for a sell order
      * const sellFees = await feesAPI.simulateFees({
-     *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+     *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      *   side: "SELL",
      *   price: "40000.00",
      *   quantity: "0.5"
      * });
      *
-     * console.log(`Maker rebate: ${sellFees.monaco_maker_rebate}`);
-     * console.log(`Maker total receipt: ${sellFees.maker_total_receipt}`);
+     * console.log(`Maker rebate: ${sellFees.monacoMakerRebate}`);
+     * console.log(`Maker total receipt: ${sellFees.makerTotalReceipt}`);
      * ```
      */
     simulateFees(params: SimulateFeeParams): Promise<SimulateFeeResponse>;

package/dist/api/fees/api.js

@@ -14,7 +14,7 @@
  *
  * // Simulate fees for an order
  * const feeDetails = await feesAPI.simulateFees({
- *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
  *   side: "BUY",
  *   price: "40000.00",
  *   quantity: "0.5"
@@ -31,56 +31,56 @@ export class FeesAPIImpl extends BaseAPI {
      * application fees, and total amounts the taker must pay or maker will receive.
      *
      * @param params - Parameters for fee simulation
-     * @param params.trading_pair_id - The trading pair UUID
+     * @param params.tradingPairId - The trading pair UUID
      * @param params.side - The order side ("BUY" or "SELL")
      * @param params.price - The price per unit as string
      * @param params.quantity - The quantity to trade as string
-     * @param params.order_type - Order type: "LIMIT" (default) or "MARKET"
-     * @param params.slippage_tolerance_bps - Slippage tolerance in bps (0–1000, MARKET only, default 500)
+     * @param params.orderType - Order type: "LIMIT" (default) or "MARKET"
+     * @param params.slippageToleranceBps - Slippage tolerance in bps (0–1000, MARKET only, default 500)
      * @returns Promise resolving to SimulateFeeResponse with fee breakdown
      *
      * @example
      * ```typescript
      * // Simulate fees for a buy order
      * const buyFees = await feesAPI.simulateFees({
-     *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+     *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      *   side: "BUY",
      *   price: "40000.00",
      *   quantity: "0.5"
      * });
      *
      * console.log(`Notional value: ${buyFees.notional}`);
-     * console.log(`Monaco taker fee: ${buyFees.monaco_taker_fee}`);
-     * console.log(`Application taker fee: ${buyFees.application_taker_fee}`);
-     * console.log(`Total taker fees: ${buyFees.total_taker_fees}`);
-     * console.log(`Total payment required: ${buyFees.taker_total_payment}`);
-     * console.log(`Lock amount for BUY: ${buyFees.buy_order_lock_amount}`);
+     * console.log(`Monaco taker fee: ${buyFees.monacoTakerFee}`);
+     * console.log(`Application taker fee: ${buyFees.applicationTakerFee}`);
+     * console.log(`Total taker fees: ${buyFees.totalTakerFees}`);
+     * console.log(`Total payment required: ${buyFees.takerTotalPayment}`);
+     * console.log(`Lock amount for BUY: ${buyFees.buyOrderLockAmount}`);
      *
      * // Simulate fees for a sell order
      * const sellFees = await feesAPI.simulateFees({
-     *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+     *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      *   side: "SELL",
      *   price: "40000.00",
      *   quantity: "0.5"
      * });
      *
-     * console.log(`Maker rebate: ${sellFees.monaco_maker_rebate}`);
-     * console.log(`Maker total receipt: ${sellFees.maker_total_receipt}`);
+     * console.log(`Maker rebate: ${sellFees.monacoMakerRebate}`);
+     * console.log(`Maker total receipt: ${sellFees.makerTotalReceipt}`);
      * ```
      */
     async simulateFees(params) {
         // Validate parameters using the validate helper
         const validatedParams = validate(SimulateFeeParamsSchema, params);
         const searchParams = new URLSearchParams();
-        searchParams.append("trading_pair_id", validatedParams.trading_pair_id);
+        searchParams.append("tradingPairId", validatedParams.tradingPairId);
         searchParams.append("side", validatedParams.side);
         searchParams.append("price", validatedParams.price);
         searchParams.append("quantity", validatedParams.quantity);
-        if (validatedParams.order_type !== undefined) {
-            searchParams.append("order_type", validatedParams.order_type);
+        if (validatedParams.orderType !== undefined) {
+            searchParams.append("orderType", validatedParams.orderType);
         }
-        if (validatedParams.slippage_tolerance_bps !== undefined) {
-            searchParams.append("slippage_tolerance_bps", String(validatedParams.slippage_tolerance_bps));
+        if (validatedParams.slippageToleranceBps !== undefined) {
+            searchParams.append("slippageToleranceBps", String(validatedParams.slippageToleranceBps));
         }
         const endpoint = `/api/v1/fees/simulate?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {

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

@@ -1,13 +1,18 @@
-import type { GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, GetMarginAccountSummaryParams, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateAutoMarginOrderRiskRequest, SimulateOrderRiskRequest, SimulateOrderRiskResponse, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToAutoMarginAccountRequest } from "@0xmonaco/types";
+import type { GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, GetMarginAccountSummaryParams, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateOrderRiskRequest, SimulateOrderRiskResponse, SimulateRiskBucketOrderRiskRequest, TransferCollateralFromParentMarginAccountRequest, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToParentMarginAccountRequest, TransferCollateralToRiskBucketRequest } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class MarginAccountsAPIImpl extends BaseAPI implements MarginAccountsAPI {
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;
     getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
+    getParentMarginAccountSummary(params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
-    transferCollateralToAutoMarginAccount(request: TransferCollateralToAutoMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToParentMarginAccount(request: TransferCollateralToParentMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToRiskBucket(request: TransferCollateralToRiskBucketRequest): Promise<TransferCollateralResponse>;
     transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    transferCollateralFromParentMarginAccount(request: TransferCollateralFromParentMarginAccountRequest): Promise<TransferCollateralResponse>;
     getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
+    getParentMarginAccountMovements(params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
     simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
-    simulateAutoMarginOrderRisk(request: SimulateAutoMarginOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateParentMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateRiskBucketOrderRisk(request: SimulateRiskBucketOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }

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

@@ -1,4 +1,4 @@
-import { GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateAutoMarginOrderRiskSchema, SimulateOrderRiskSchema, TransferCollateralSchema, TransferCollateralToAutoMarginAccountSchema, validate, } from "@0xmonaco/types";
+import { GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, GetParentMarginAccountMovementsSchema, GetParentMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateOrderRiskSchema, SimulateParentMarginOrderRiskSchema, SimulateRiskBucketOrderRiskSchema, TransferCollateralFromParentMarginAccountSchema, TransferCollateralSchema, TransferCollateralToParentMarginAccountSchema, TransferCollateralToRiskBucketSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 export class MarginAccountsAPIImpl extends BaseAPI {
@@ -9,15 +9,19 @@ export class MarginAccountsAPIImpl extends BaseAPI {
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.list(params
             ? {
                 page: params.page,
-                page_size: params.page_size,
+                pageSize: params.pageSize,
                 state: params.state,
-                trading_pair_id: params.tradingPairId,
+                tradingPairId: params.tradingPairId,
             }
             : undefined));
     }
     async getMarginAccountSummary(marginAccountId, params) {
         validate(GetMarginAccountSummarySchema, { marginAccountId, ...params });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId, { trading_pair_id: params?.tradingPairId }));
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId, { tradingPairId: params?.tradingPairId }));
+    }
+    async getParentMarginAccountSummary(params) {
+        validate(GetParentMarginAccountSummarySchema, params);
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.parentSummary({ tradingPairId: params?.tradingPairId }));
     }
     async getAvailableCollateral(params) {
         validate(GetAvailableCollateralSchema, params);
@@ -30,20 +34,30 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
-                trading_pair_id: request.tradingPairId,
-                strategy_key: request.strategyKey,
+                tradingPairId: request.tradingPairId,
+                strategyKey: request.strategyKey,
             }),
         });
     }
-    async transferCollateralToAutoMarginAccount(request) {
-        validate(TransferCollateralToAutoMarginAccountSchema, { request });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInAuto(), {
+    async transferCollateralToParentMarginAccount(request) {
+        validate(TransferCollateralToParentMarginAccountSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInParent(), {
             method: "POST",
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
-                trading_pair_id: request.tradingPairId,
-                strategy_key: request.strategyKey,
+            }),
+        });
+    }
+    async transferCollateralToRiskBucket(request) {
+        validate(TransferCollateralToRiskBucketSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInRiskBucket(), {
+            method: "POST",
+            body: JSON.stringify({
+                asset: request.asset,
+                amount: request.amount,
+                tradingPairId: request.tradingPairId,
+                strategyKey: request.strategyKey,
             }),
         });
     }
@@ -54,8 +68,18 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
-                trading_pair_id: request.tradingPairId,
-                strategy_key: request.strategyKey,
+                tradingPairId: request.tradingPairId,
+                strategyKey: request.strategyKey,
+            }),
+        });
+    }
+    async transferCollateralFromParentMarginAccount(request) {
+        validate(TransferCollateralFromParentMarginAccountSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferOutParent(), {
+            method: "POST",
+            body: JSON.stringify({
+                asset: request.asset,
+                amount: request.amount,
             }),
         });
     }
@@ -63,36 +87,56 @@ export class MarginAccountsAPIImpl extends BaseAPI {
         validate(GetMarginAccountMovementsSchema, { marginAccountId, ...params });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.movements(marginAccountId, params));
     }
+    async getParentMarginAccountMovements(params) {
+        validate(GetParentMarginAccountMovementsSchema, params);
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.parentMovements(params));
+    }
     async simulateOrderRisk(marginAccountId, request) {
         validate(SimulateOrderRiskSchema, { marginAccountId, request });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateOrderRisk(marginAccountId), {
             method: "POST",
             body: JSON.stringify({
-                trading_pair_id: request.tradingPairId,
+                tradingPairId: request.tradingPairId,
+                side: request.side,
+                positionSide: request.positionSide,
+                orderType: request.orderType,
+                price: request.price,
+                quantity: request.quantity,
+                leverage: request.leverage,
+                reduceOnly: request.reduceOnly,
+            }),
+        });
+    }
+    async simulateParentMarginOrderRisk(request) {
+        validate(SimulateParentMarginOrderRiskSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateParentMarginOrderRisk(), {
+            method: "POST",
+            body: JSON.stringify({
+                tradingPairId: request.tradingPairId,
                 side: request.side,
-                position_side: request.positionSide,
-                order_type: request.orderType,
+                positionSide: request.positionSide,
+                orderType: request.orderType,
                 price: request.price,
                 quantity: request.quantity,
                 leverage: request.leverage,
-                reduce_only: request.reduceOnly,
+                reduceOnly: request.reduceOnly,
             }),
         });
     }
-    async simulateAutoMarginOrderRisk(request) {
-        validate(SimulateAutoMarginOrderRiskSchema, { request });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateOrderRiskAuto(), {
+    async simulateRiskBucketOrderRisk(request) {
+        validate(SimulateRiskBucketOrderRiskSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateRiskBucketOrderRisk(), {
             method: "POST",
             body: JSON.stringify({
-                trading_pair_id: request.tradingPairId,
-                strategy_key: request.strategyKey,
+                tradingPairId: request.tradingPairId,
+                strategyKey: request.strategyKey,
                 side: request.side,
-                position_side: request.positionSide,
-                order_type: request.orderType,
+                positionSide: request.positionSide,
+                orderType: request.orderType,
                 price: request.price,
                 quantity: request.quantity,
                 leverage: request.leverage,
-                reduce_only: request.reduceOnly,
+                reduceOnly: request.reduceOnly,
             }),
         });
     }

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

@@ -1,4 +1,4 @@
-import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingMode, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -8,7 +8,7 @@ import { BaseAPI } from "../base";
 export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getPaginatedTradingPairs(params?: GetTradingPairsParams): Promise<GetTradingPairsResponse>;
     getTradingPair(tradingPairId: string): Promise<TradingPair>;
-    getTradingPairBySymbol(symbol: string): Promise<TradingPair | undefined>;
+    getTradingPairBySymbol(symbol: string, marketType?: TradingMode): Promise<TradingPair | undefined>;
     getCandlesticks(tradingPairId: string, interval: Interval, params?: GetCandlesticksParams): Promise<Candlestick[]>;
     getMarketMetadata(tradingPairId: string): Promise<MarketMetadata>;
     getPerpMarketConfig(tradingPairId: string): Promise<PerpMarketConfig>;

package/dist/api/market/api.js

@@ -12,20 +12,20 @@ export class MarketAPIImpl 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?.market_type) {
-            searchParams.append("market_type", params.market_type);
+        if (params?.marketType) {
+            searchParams.append("marketType", params.marketType);
         }
-        if (params?.base_token) {
-            searchParams.append("base_token", params.base_token);
+        if (params?.baseToken) {
+            searchParams.append("baseToken", params.baseToken);
         }
-        if (params?.quote_token) {
-            searchParams.append("quote_token", params.quote_token);
+        if (params?.quoteToken) {
+            searchParams.append("quoteToken", params.quoteToken);
         }
-        if (params?.is_active !== undefined) {
-            searchParams.append("is_active", params.is_active.toString());
+        if (params?.isActive !== undefined) {
+            searchParams.append("isActive", params.isActive.toString());
         }
         if (params?.category) {
             searchParams.append("category", params.category);
@@ -37,12 +37,14 @@ export class MarketAPIImpl extends BaseAPI {
     async getTradingPair(tradingPairId) {
         validate(GetMarketMetadataSchema, { tradingPairId });
         const response = await this.makePublicRequest(perpRoutes.market.getTradingPair(tradingPairId));
-        return response.trading_pair;
+        return response.tradingPair;
     }
-    async getTradingPairBySymbol(symbol) {
-        // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter
-        const response = await this.getPaginatedTradingPairs({ page_size: 100 });
-        return response.trading_pairs.find((pair) => pair.symbol === symbol);
+    async getTradingPairBySymbol(symbol, marketType) {
+        // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter.
+        // An optional marketType narrows the listing so a symbol present in both
+        // SPOT and MARGIN resolves unambiguously instead of returning the first match.
+        const response = await this.getPaginatedTradingPairs({ pageSize: 100, marketType: marketType });
+        return response.tradingPairs.find((pair) => pair.symbol === symbol);
     }
     async getCandlesticks(tradingPairId, interval, params) {
         // Validate inputs using the trading pair ID schema
@@ -55,10 +57,10 @@ export class MarketAPIImpl extends BaseAPI {
         });
         const searchParams = new URLSearchParams();
         if (params?.startTime !== undefined) {
-            searchParams.append("start_time", params.startTime.toString());
+            searchParams.append("startTime", params.startTime.toString());
         }
         if (params?.endTime !== undefined) {
-            searchParams.append("end_time", params.endTime.toString());
+            searchParams.append("endTime", params.endTime.toString());
         }
         if (params?.limit !== undefined) {
             searchParams.append("limit", params.limit.toString());

package/dist/api/orderbook/api.js

@@ -5,34 +5,34 @@ export class OrderbookAPIImpl extends BaseAPI {
         const params = new URLSearchParams();
         params.set("levels", String(depth));
         if (tradingMode)
-            params.set("trading_mode", tradingMode);
+            params.set("tradingMode", tradingMode);
         if (magnitude !== undefined)
             params.set("magnitude", String(magnitude));
         if (denomination)
             params.set("denomination", denomination.toLowerCase());
         const response = await this.makePublicRequest(`/api/v1/orderbook/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return {
-            // `trading_pair_id` is the pair UUID; `symbol` is the display string.
-            tradingPairId: response.trading_pair_id,
-            tradingMode: response.trading_mode,
+            // `tradingPairId` is the pair UUID; `symbol` is the display string.
+            tradingPairId: response.tradingPairId,
+            tradingMode: response.tradingMode,
             bids: response.data.bids.map((level) => ({
                 price: level.price,
                 quantity: level.quantity,
-                orderCount: level.order_count,
+                orderCount: level.orderCount,
             })),
             asks: response.data.asks.map((level) => ({
                 price: level.price,
                 quantity: level.quantity,
-                orderCount: level.order_count,
+                orderCount: level.orderCount,
             })),
-            bestBid: response.data.best_bid,
-            bestAsk: response.data.best_ask,
-            bidVolume: response.data.bid_volume,
-            askVolume: response.data.ask_volume,
-            baseDecimals: response.base_decimals,
-            quoteDecimals: response.quote_decimals,
+            bestBid: response.data.bestBid,
+            bestAsk: response.data.bestAsk,
+            bidVolume: response.data.bidVolume,
+            askVolume: response.data.askVolume,
+            baseDecimals: response.baseDecimals,
+            quoteDecimals: response.quoteDecimals,
             timestamp: response.timestamp,
-            sequence: response.sequence_number,
+            sequence: response.sequenceNumber,
         };
     }
 }