@0xmonaco/core 0.8.5 → 0.8.7-develop.0f12336

package/dist/api/faucet/api.js

@@ -0,0 +1,29 @@
+/**
+ * Faucet API Implementation
+ *
+ * Testnet token faucet. Session-authenticated. Performs real on-chain mints
+ * from a backend-operator-funded signer and is rate-limited per user
+ * (default 1 request / 24h). It is unavailable if the gateway operator has not
+ * configured a signer — the SDK caller has no control over that.
+ *
+ * @example
+ * ```typescript
+ * const { minted, failed, remainingRequests24h } = await sdk.faucet.mint();
+ * ```
+ */
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
+export class FaucetAPIImpl extends BaseAPI {
+    /**
+     * Mints the full set of testnet tokens to the authenticated user.
+     *
+     * Partial success is possible — inspect `minted` and `failed` in the response.
+     *
+     * @returns Promise resolving to the minted/failed tokens and remaining quota
+     */
+    async mint() {
+        return await this.makeAuthenticatedRequest(perpRoutes.faucet.mint(), {
+            method: "POST",
+        });
+    }
+}

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

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

package/dist/api/faucet/index.js

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

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/index.d.ts

@@ -6,6 +6,7 @@
 export * from "./applications/index";
 export * from "./base";
 export * from "./delegated-agents";
+export * from "./faucet";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";
@@ -13,7 +14,10 @@ export * from "./orderbook";
 export * from "./perp";
 export * from "./positions";
 export * from "./profile";
+export * from "./sub-accounts";
 export * from "./trades";
 export * from "./trading";
 export * from "./vault";
 export * from "./websocket";
+export * from "./whitelist";
+export * from "./withdrawals";

package/dist/api/index.js

@@ -6,6 +6,7 @@
 export * from "./applications/index";
 export * from "./base";
 export * from "./delegated-agents";
+export * from "./faucet";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";
@@ -13,7 +14,10 @@ export * from "./orderbook";
 export * from "./perp";
 export * from "./positions";
 export * from "./profile";
+export * from "./sub-accounts";
 export * from "./trades";
 export * from "./trading";
 export * from "./vault";
 export * from "./websocket";
+export * from "./whitelist";
+export * from "./withdrawals";

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

@@ -1,14 +1,18 @@
-import type { CreateMarginAccountRequest, CreateMarginAccountResponse, GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, 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>;
-    createMarginAccount(request?: CreateMarginAccountRequest): Promise<CreateMarginAccountResponse>;
-    getMarginAccountSummary(marginAccountId: string): Promise<MarginAccountSummary>;
+    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: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateParentMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateRiskBucketOrderRisk(request: SimulateRiskBucketOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }

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

@@ -1,4 +1,4 @@
-import { CreateMarginAccountSchema, 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,25 +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 createMarginAccount(request) {
-        validate(CreateMarginAccountSchema, request);
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.create(), {
-            method: "POST",
-            body: JSON.stringify({
-                label: request?.label,
-                collateral_asset: request?.collateralAsset,
-            }),
-        });
+    async getMarginAccountSummary(marginAccountId, params) {
+        validate(GetMarginAccountSummarySchema, { marginAccountId, ...params });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId, { tradingPairId: params?.tradingPairId }));
     }
-    async getMarginAccountSummary(marginAccountId) {
-        validate(GetMarginAccountSummarySchema, { marginAccountId });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId));
+    async getParentMarginAccountSummary(params) {
+        validate(GetParentMarginAccountSummarySchema, params);
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.parentSummary({ tradingPairId: params?.tradingPairId }));
     }
     async getAvailableCollateral(params) {
         validate(GetAvailableCollateralSchema, params);
@@ -36,6 +30,18 @@ export class MarginAccountsAPIImpl extends BaseAPI {
     async transferCollateralToMarginAccount(marginAccountId, request) {
         validate(TransferCollateralSchema, { marginAccountId, request });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferIn(marginAccountId), {
+            method: "POST",
+            body: JSON.stringify({
+                asset: request.asset,
+                amount: request.amount,
+                tradingPairId: request.tradingPairId,
+                strategyKey: request.strategyKey,
+            }),
+        });
+    }
+    async transferCollateralToParentMarginAccount(request) {
+        validate(TransferCollateralToParentMarginAccountSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInParent(), {
             method: "POST",
             body: JSON.stringify({
                 asset: request.asset,
@@ -43,21 +49,33 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }),
         });
     }
-    async transferCollateralToAutoMarginAccount(request) {
-        validate(TransferCollateralToAutoMarginAccountSchema, { request });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInAuto(), {
+    async transferCollateralToRiskBucket(request) {
+        validate(TransferCollateralToRiskBucketSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInRiskBucket(), {
             method: "POST",
             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 transferCollateralFromMarginAccount(marginAccountId, request) {
         validate(TransferCollateralSchema, { marginAccountId, request });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferOut(marginAccountId), {
+            method: "POST",
+            body: JSON.stringify({
+                asset: request.asset,
+                amount: request.amount,
+                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,
@@ -69,37 +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,
-                strategy_key: request.strategyKey,
+                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, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, 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
@@ -7,7 +7,8 @@ import { BaseAPI } from "../base";
  */
 export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getPaginatedTradingPairs(params?: GetTradingPairsParams): Promise<GetTradingPairsResponse>;
-    getTradingPairBySymbol(symbol: string): Promise<TradingPair | undefined>;
+    getTradingPair(tradingPairId: string): Promise<TradingPair>;
+    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>;
@@ -17,4 +18,6 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getFundingState(tradingPairId: string): Promise<FundingState>;
     listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
+    getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
+    getMarketStats(): Promise<MarketStats>;
 }

package/dist/api/market/api.js

@@ -12,29 +12,39 @@ 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);
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/market/pairs?${queryString}` : "/api/v1/market/pairs";
         return await this.makePublicRequest(url);
     }
-    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 getTradingPair(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        const response = await this.makePublicRequest(perpRoutes.market.getTradingPair(tradingPairId));
+        return response.tradingPair;
+    }
+    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
@@ -47,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());
@@ -94,4 +104,10 @@ export class MarketAPIImpl extends BaseAPI {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.getOpenInterest(tradingPairId));
     }
+    async getScreener(params) {
+        return await this.makePublicRequest(perpRoutes.market.getScreener(params));
+    }
+    async getMarketStats() {
+        return await this.makePublicRequest(perpRoutes.market.getMarketStats());
+    }
 }

package/dist/api/orderbook/api.js

@@ -5,33 +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 {
-            tradingPairId: response.symbol,
-            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,
         };
     }
 }