@0xmonaco/core 0.8.14 → 0.8.16

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,14 +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, marketType) {
         // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter.
-        // An optional market_type narrows the listing so a symbol present in both
+        // 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({ page_size: 100, market_type: marketType });
-        return response.trading_pairs.find((pair) => pair.symbol === symbol);
+        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
@@ -57,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,
         };
     }
 }

package/dist/api/perp/routes.d.ts

@@ -3,11 +3,11 @@ export declare const perpRoutes: {
         readonly create: () => string;
         readonly list: (params?: {
             page?: number;
-            page_size?: number;
+            pageSize?: number;
             status?: string;
-            trading_pair?: string;
-            trading_mode?: string;
-            margin_account_id?: string;
+            tradingPair?: string;
+            tradingMode?: string;
+            marginAccountId?: string;
         }) => string;
         readonly get: (orderId: string) => string;
         readonly replace: (orderId: string) => string;
@@ -18,11 +18,11 @@ export declare const perpRoutes: {
         readonly batchCreate: () => string;
         readonly batchReplace: () => string;
         readonly listConditional: (params?: {
-            margin_account_id?: string;
-            trading_pair_id?: string;
+            marginAccountId?: string;
+            tradingPairId?: string;
             state?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
         readonly cancelConditional: (conditionalOrderId: string) => string;
     };
@@ -35,20 +35,24 @@ export declare const perpRoutes: {
     readonly withdrawals: {
         readonly initiate: () => string;
         readonly byIndex: (withdrawalIndex: number) => string;
+        readonly list: (params?: {
+            page?: number;
+            pageSize?: number;
+        }) => string;
     };
     readonly market: {
         readonly listTradingPairs: (params?: {
             page?: number;
             limit?: number;
-            market_type?: string;
-            base_token?: string;
-            quote_token?: string;
-            is_active?: boolean;
+            marketType?: string;
+            baseToken?: string;
+            quoteToken?: string;
+            isActive?: boolean;
         }) => string;
         readonly getTradingPair: (tradingPairId: string) => string;
         readonly getCandles: (tradingPairId: string, interval: string, params?: {
-            start_time?: number;
-            end_time?: number;
+            startTime?: number;
+            endTime?: number;
             limit?: number;
         }) => string;
         readonly getMarketMetadata: (tradingPairId: string) => string;
@@ -58,17 +62,17 @@ export declare const perpRoutes: {
         readonly getIndexPrice: (tradingPairId: string) => string;
         readonly getFundingState: (tradingPairId: string) => string;
         readonly listFundingHistory: (tradingPairId: string, params?: {
-            start_time?: string;
-            end_time?: string;
+            startTime?: string;
+            endTime?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
         readonly getOpenInterest: (tradingPairId: string) => string;
         readonly getScreener: (params?: {
             page?: number;
-            page_size?: number;
-            market_type?: string;
-            is_active?: boolean;
+            pageSize?: number;
+            marketType?: string;
+            isActive?: boolean;
             category?: string;
         }) => string;
         readonly getMarketStats: () => string;
@@ -76,7 +80,7 @@ export declare const perpRoutes: {
     readonly orderbook: {
         readonly get: (tradingPairId: string, params?: {
             levels?: number;
-            trading_mode?: string;
+            tradingMode?: string;
             magnitude?: string | number;
             denomination?: string;
         }) => string;
@@ -88,42 +92,42 @@ export declare const perpRoutes: {
         }) => string;
         readonly byId: (tradeId: string) => string;
         readonly user: (params?: {
-            margin_account_id?: string;
-            trading_pair_id?: string;
+            marginAccountId?: string;
+            tradingPairId?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
     };
     readonly applications: {
         readonly orders: (params?: {
             page?: number;
-            page_size?: number;
+            pageSize?: number;
             status?: string;
-            user_id?: string;
-            trading_pair_id?: string;
+            userId?: string;
+            tradingPairId?: string;
             side?: string;
-            order_type?: string;
+            orderType?: string;
         }) => string;
         readonly users: (params?: {
             page?: number;
-            page_size?: number;
-            is_active?: boolean;
-            account_type?: string;
+            pageSize?: number;
+            isActive?: boolean;
+            accountType?: string;
             address?: string;
         }) => string;
         readonly movements: (params?: {
             page?: number;
-            page_size?: number;
-            user_id?: string;
-            transaction_type?: string;
-            entry_type?: string;
-            asset_id?: string;
+            pageSize?: number;
+            userId?: string;
+            transactionType?: string;
+            entryType?: string;
+            assetId?: string;
         }) => string;
         readonly balances: (params?: {
             page?: number;
-            page_size?: number;
-            user_id?: string;
-            asset_id?: string;
+            pageSize?: number;
+            userId?: string;
+            assetId?: string;
         }) => string;
         readonly stats: (params?: {
             since?: string;
@@ -143,11 +147,11 @@ export declare const perpRoutes: {
     };
     readonly positions: {
         readonly list: (params?: {
-            margin_account_id?: string;
-            trading_pair_id?: string;
+            marginAccountId?: string;
+            tradingPairId?: string;
             status?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
         readonly get: (positionId: string) => string;
         readonly close: (positionId: string) => string;
@@ -157,25 +161,25 @@ export declare const perpRoutes: {
         readonly reduceMargin: (positionId: string) => string;
         readonly attachTpSl: (positionId: string) => string;
         readonly history: (params?: {
-            position_id?: string;
-            margin_account_id?: string;
-            trading_pair_id?: string;
+            positionId?: string;
+            marginAccountId?: string;
+            tradingPairId?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
     };
     readonly marginAccounts: {
         readonly list: (params?: {
             page?: number;
-            page_size?: number;
+            pageSize?: number;
             state?: string;
-            trading_pair_id?: string;
+            tradingPairId?: string;
         }) => string;
         readonly parentSummary: (params?: {
-            trading_pair_id?: string;
+            tradingPairId?: string;
         }) => string;
         readonly summary: (marginAccountId: string, params?: {
-            trading_pair_id?: string;
+            tradingPairId?: string;
         }) => string;
         readonly availableCollateral: (params?: {
             asset?: string;
@@ -186,14 +190,14 @@ export declare const perpRoutes: {
         readonly transferOut: (marginAccountId: string) => string;
         readonly transferOutParent: () => string;
         readonly movements: (marginAccountId: string, params?: {
-            movement_type?: string;
+            movementType?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
         readonly parentMovements: (params?: {
-            movement_type?: string;
+            movementType?: string;
             page?: number;
-            page_size?: number;
+            pageSize?: number;
         }) => string;
         readonly simulateParentMarginOrderRisk: () => string;
         readonly simulateOrderRisk: (marginAccountId: string) => string;

package/dist/api/perp/routes.js

@@ -38,6 +38,7 @@ export const perpRoutes = {
     withdrawals: {
         initiate: () => `${API_V1}/withdrawals`,
         byIndex: (withdrawalIndex) => `${API_V1}/withdrawals/${encodeSegment(String(withdrawalIndex))}`,
+        list: (params) => withQuery(`${API_V1}/withdrawals`, params),
     },
     market: {
         listTradingPairs: (params) => withQuery(`${API_V1}/market/pairs`, params),

package/dist/api/positions/api.js

@@ -17,9 +17,9 @@ export class PositionsAPIImpl extends BaseAPI {
         return await this.makeAuthenticatedRequest(perpRoutes.positions.close(positionId), {
             method: "POST",
             body: JSON.stringify({
-                close_type: request.closeType,
-                limit_price: request.limitPrice,
-                slippage_tolerance_bps: request.slippageToleranceBps,
+                closeType: request.closeType,
+                limitPrice: request.limitPrice,
+                slippageToleranceBps: request.slippageToleranceBps,
                 quantity: request.quantity,
             }),
         });
@@ -31,8 +31,8 @@ export class PositionsAPIImpl extends BaseAPI {
         return await this.makeAuthenticatedRequest(perpRoutes.positions.batchCloseAll(), {
             method: "POST",
             body: JSON.stringify({
-                trading_pair_id: request?.tradingPairId,
-                slippage_tolerance_bps: request?.slippageToleranceBps,
+                tradingPairId: request?.tradingPairId,
+                slippageToleranceBps: request?.slippageToleranceBps,
             }),
         });
     }
@@ -64,26 +64,26 @@ export class PositionsAPIImpl extends BaseAPI {
         return await this.makeAuthenticatedRequest(perpRoutes.positions.attachTpSl(positionId), {
             method: "POST",
             body: JSON.stringify({
-                take_profit: request.takeProfit
+                takeProfit: request.takeProfit
                     ? {
-                        trigger_price: request.takeProfit.triggerPrice,
-                        order_type: request.takeProfit.orderType,
-                        limit_price: request.takeProfit.limitPrice,
+                        triggerPrice: request.takeProfit.triggerPrice,
+                        orderType: request.takeProfit.orderType,
+                        limitPrice: request.takeProfit.limitPrice,
                         quantity: request.takeProfit.quantity,
-                        time_in_force: request.takeProfit.timeInForce,
-                        slippage_tolerance_bps: request.takeProfit.slippageToleranceBps,
-                        expires_at: request.takeProfit.expiresAt,
+                        timeInForce: request.takeProfit.timeInForce,
+                        slippageToleranceBps: request.takeProfit.slippageToleranceBps,
+                        expiresAt: request.takeProfit.expiresAt,
                     }
                     : undefined,
-                stop_loss: request.stopLoss
+                stopLoss: request.stopLoss
                     ? {
-                        trigger_price: request.stopLoss.triggerPrice,
-                        order_type: request.stopLoss.orderType,
-                        limit_price: request.stopLoss.limitPrice,
+                        triggerPrice: request.stopLoss.triggerPrice,
+                        orderType: request.stopLoss.orderType,
+                        limitPrice: request.stopLoss.limitPrice,
                         quantity: request.stopLoss.quantity,
-                        time_in_force: request.stopLoss.timeInForce,
-                        slippage_tolerance_bps: request.stopLoss.slippageToleranceBps,
-                        expires_at: request.stopLoss.expiresAt,
+                        timeInForce: request.stopLoss.timeInForce,
+                        slippageToleranceBps: request.stopLoss.slippageToleranceBps,
+                        expiresAt: request.stopLoss.expiresAt,
                     }
                     : undefined,
             }),

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

@@ -39,8 +39,8 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * 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}`);
      * ```
      */
     getProfile(): Promise<UserProfile>;
@@ -53,27 +53,27 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * @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" });
      * ```
      */
     getPaginatedUserMovements(params?: GetUserMovementsParams): Promise<GetPaginatedUserMovementsResponse>;
@@ -85,7 +85,7 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *
      * @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
      *
@@ -95,11 +95,11 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * 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`);
      * ```
      */
@@ -107,7 +107,7 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
     /**
      * 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)
@@ -118,9 +118,9 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * ```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}`);
      * ```
      */
     getUserBalanceByAssetId(assetId: string): Promise<AccountBalance>;
@@ -139,7 +139,7 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * 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}`);
      * ```
      */
     getPortfolioStats(period: PortfolioPeriod): Promise<PortfolioStats>;
@@ -171,8 +171,8 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *
      * @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
@@ -184,7 +184,7 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * 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" });
      * ```
      */
     getUserTrades(params?: GetUserTradesParams): Promise<GetUserTradesResponse>;
@@ -200,7 +200,7 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *
      * @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}`);
      * ```
      */