@0xmonaco/core 0.8.7-develop.5d0e403 → 0.8.7-develop.a107b34

package/README.md

@@ -62,26 +62,17 @@ npm install viem@^2.31.7
 
 ## Network Support
 
-The SDK supports the following preset networks. Configure the network by providing the `network` and `seiRpcUrl` parameters:
+The SDK supports the following documented preset networks. Configure the network by providing the `network` and `seiRpcUrl` parameters:
 
 **Preset Networks:**
-- `"development"` - Development environment (https://develop.apimonaco.xyz)
 - `"staging"` - Staging environment (https://staging.apimonaco.xyz)
 - `"mainnet"` - Production environment (https://api.monaco.xyz)
-- `"local"` - Local development (http://localhost:8080)
 
 WebSocket URLs are automatically resolved per network.
 
 ```typescript
 import { MonacoSDK } from "@0xmonaco/core";
 
-// Development configuration
-const devSdk = new MonacoSDK({
-  walletClient,
-  network: "development",
-  seiRpcUrl: "https://evm-rpc-testnet.sei-apis.com",
-});
-
 // Staging configuration
 const stagingSdk = new MonacoSDK({
   walletClient,
@@ -114,7 +105,7 @@ const walletClient = createWalletClient({
 
 const monaco = new MonacoSDK({
   walletClient,
-  network: "development", // or "staging", "mainnet", "local"
+  network: "staging", // or "mainnet"
   seiRpcUrl: "https://evm-rpc-testnet.sei-apis.com", // or https://evm-rpc.sei-apis.com for mainnet
 });
 
@@ -251,7 +242,7 @@ interface SDKConfig {
   /** Wallet client for signing operations (optional - can be set later via setWalletClient) */
   walletClient?: WalletClient;
   
-  /** Network preset: "local", "development", "staging", or "mainnet" */
+  /** Use "staging" for public testnet or "mainnet" for production. */
   network: Network;
   
   /** RPC URL for Sei blockchain interactions */

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

@@ -1,14 +1,18 @@
-import type { EnsureParentMarginAccountRequest, EnsureParentMarginAccountResponse, 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>;
-    ensureParentMarginAccount(request?: EnsureParentMarginAccountRequest): Promise<EnsureParentMarginAccountResponse>;
-    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 { EnsureParentMarginAccountSchema, 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 {
@@ -15,19 +15,13 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }
             : undefined));
     }
-    async ensureParentMarginAccount(request) {
-        validate(EnsureParentMarginAccountSchema, request);
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.ensureParent(), {
-            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, { trading_pair_id: 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({ trading_pair_id: params?.tradingPairId }));
     }
     async getAvailableCollateral(params) {
         validate(GetAvailableCollateralSchema, params);
@@ -40,12 +34,24 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
+                trading_pair_id: request.tradingPairId,
+                strategy_key: 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,
+            }),
+        });
+    }
+    async transferCollateralToRiskBucket(request) {
+        validate(TransferCollateralToRiskBucketSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInRiskBucket(), {
             method: "POST",
             body: JSON.stringify({
                 asset: request.asset,
@@ -58,6 +64,18 @@ export class MarginAccountsAPIImpl extends BaseAPI {
     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,
+                trading_pair_id: request.tradingPairId,
+                strategy_key: request.strategyKey,
+            }),
+        });
+    }
+    async transferCollateralFromParentMarginAccount(request) {
+        validate(TransferCollateralFromParentMarginAccountSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferOutParent(), {
             method: "POST",
             body: JSON.stringify({
                 asset: request.asset,
@@ -69,13 +87,16 @@ 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,
                 side: request.side,
                 position_side: request.positionSide,
                 order_type: request.orderType,
@@ -86,9 +107,25 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }),
         });
     }
-    async simulateAutoMarginOrderRisk(request) {
-        validate(SimulateAutoMarginOrderRiskSchema, { request });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateOrderRiskAuto(), {
+    async simulateParentMarginOrderRisk(request) {
+        validate(SimulateParentMarginOrderRiskSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateParentMarginOrderRisk(), {
+            method: "POST",
+            body: JSON.stringify({
+                trading_pair_id: request.tradingPairId,
+                side: request.side,
+                position_side: request.positionSide,
+                order_type: request.orderType,
+                price: request.price,
+                quantity: request.quantity,
+                leverage: request.leverage,
+                reduce_only: request.reduceOnly,
+            }),
+        });
+    }
+    async simulateRiskBucketOrderRisk(request) {
+        validate(SimulateRiskBucketOrderRiskSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateRiskBucketOrderRisk(), {
             method: "POST",
             body: JSON.stringify({
                 trading_pair_id: request.tradingPairId,

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, 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>;
@@ -19,4 +19,5 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     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

@@ -27,6 +27,9 @@ export class MarketAPIImpl extends BaseAPI {
         if (params?.is_active !== undefined) {
             searchParams.append("is_active", params.is_active.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);
@@ -36,9 +39,11 @@ export class MarketAPIImpl extends BaseAPI {
         const response = await this.makePublicRequest(perpRoutes.market.getTradingPair(tradingPairId));
         return response.trading_pair;
     }
-    async getTradingPairBySymbol(symbol) {
-        // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter
-        const response = await this.getPaginatedTradingPairs({ page_size: 100 });
+    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
+        // 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);
     }
     async getCandlesticks(tradingPairId, interval, params) {
@@ -102,4 +107,7 @@ export class MarketAPIImpl extends BaseAPI {
     async getScreener(params) {
         return await this.makePublicRequest(perpRoutes.market.getScreener(params));
     }
+    async getMarketStats() {
+        return await this.makePublicRequest(perpRoutes.market.getMarketStats());
+    }
 }

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

@@ -17,7 +17,6 @@ export declare const perpRoutes: {
         readonly batchCancelAllByPair: (tradingPairId: string) => string;
         readonly batchCreate: () => string;
         readonly batchReplace: () => string;
-        readonly createConditional: () => string;
         readonly listConditional: (params?: {
             margin_account_id?: string;
             trading_pair_id?: string;
@@ -70,7 +69,9 @@ export declare const perpRoutes: {
             page_size?: number;
             market_type?: string;
             is_active?: boolean;
+            category?: string;
         }) => string;
+        readonly getMarketStats: () => string;
     };
     readonly orderbook: {
         readonly get: (tradingPairId: string, params?: {
@@ -150,6 +151,7 @@ export declare const perpRoutes: {
         }) => string;
         readonly get: (positionId: string) => string;
         readonly close: (positionId: string) => string;
+        readonly batchCloseAll: () => string;
         readonly risk: (positionId: string) => string;
         readonly addMargin: (positionId: string) => string;
         readonly reduceMargin: (positionId: string) => string;
@@ -169,21 +171,33 @@ export declare const perpRoutes: {
             state?: string;
             trading_pair_id?: string;
         }) => string;
-        readonly ensureParent: () => string;
-        readonly summary: (marginAccountId: string) => string;
+        readonly parentSummary: (params?: {
+            trading_pair_id?: string;
+        }) => string;
+        readonly summary: (marginAccountId: string, params?: {
+            trading_pair_id?: string;
+        }) => string;
         readonly availableCollateral: (params?: {
             asset?: string;
         }) => string;
         readonly transferIn: (marginAccountId: string) => string;
-        readonly transferInAuto: () => string;
+        readonly transferInParent: () => string;
+        readonly transferInRiskBucket: () => string;
         readonly transferOut: (marginAccountId: string) => string;
+        readonly transferOutParent: () => string;
         readonly movements: (marginAccountId: string, params?: {
             movement_type?: string;
             page?: number;
             page_size?: number;
         }) => string;
+        readonly parentMovements: (params?: {
+            movement_type?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+        readonly simulateParentMarginOrderRisk: () => string;
         readonly simulateOrderRisk: (marginAccountId: string) => string;
-        readonly simulateOrderRiskAuto: () => string;
+        readonly simulateRiskBucketOrderRisk: () => string;
     };
     readonly streams: {
         readonly orderbook: () => string;
@@ -193,7 +207,6 @@ export declare const perpRoutes: {
         readonly privateTrades: () => string;
         readonly orders: () => string;
         readonly positions: () => string;
-        readonly marginAccount: () => string;
         readonly funding: () => string;
         readonly liquidationAlerts: () => string;
     };

package/dist/api/perp/routes.js

@@ -26,7 +26,6 @@ export const perpRoutes = {
         batchCancelAllByPair: (tradingPairId) => `${API_V1}/orders/batch-cancel-all/${encodeSegment(tradingPairId)}`,
         batchCreate: () => `${API_V1}/orders/batch-create`,
         batchReplace: () => `${API_V1}/orders/batch-replace`,
-        createConditional: () => `${API_V1}/orders/conditional`,
         listConditional: (params) => withQuery(`${API_V1}/orders/conditional`, params),
         cancelConditional: (conditionalOrderId) => `${API_V1}/orders/conditional/${encodeSegment(conditionalOrderId)}`,
     },
@@ -53,6 +52,7 @@ export const perpRoutes = {
         listFundingHistory: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding/history`, params),
         getOpenInterest: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/open-interest`,
         getScreener: (params) => withQuery(`${API_V1}/market/screener`, params),
+        getMarketStats: () => `${API_V1}/market/stats`,
     },
     orderbook: {
         get: (tradingPairId, params) => withQuery(`${API_V1}/orderbook/${encodeSegment(tradingPairId)}`, params),
@@ -85,6 +85,7 @@ export const perpRoutes = {
         list: (params) => withQuery(`${API_V1}/positions`, params),
         get: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}`,
         close: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/close`,
+        batchCloseAll: () => `${API_V1}/positions/batch-close-all`,
         risk: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/risk`,
         addMargin: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/margin/add`,
         reduceMargin: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/margin/reduce`,
@@ -93,15 +94,19 @@ export const perpRoutes = {
     },
     marginAccounts: {
         list: (params) => withQuery(`${API_V1}/margin/accounts`, params),
-        ensureParent: () => `${API_V1}/margin/accounts`,
-        summary: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}`,
+        parentSummary: (params) => withQuery(`${API_V1}/margin/parent-margin-account`, params),
+        summary: (marginAccountId, params) => withQuery(`${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}`, params),
         availableCollateral: (params) => withQuery(`${API_V1}/margin/collateral/available`, params),
         transferIn: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-in`,
-        transferInAuto: () => `${API_V1}/margin/collateral/transfer-in`,
+        transferInParent: () => `${API_V1}/margin/parent-margin-account/collateral/transfer-in`,
+        transferInRiskBucket: () => `${API_V1}/margin/risk-buckets/collateral/transfer-in`,
         transferOut: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-out`,
+        transferOutParent: () => `${API_V1}/margin/parent-margin-account/collateral/transfer-out`,
         movements: (marginAccountId, params) => withQuery(`${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/movements`, params),
+        parentMovements: (params) => withQuery(`${API_V1}/margin/parent-margin-account/movements`, params),
+        simulateParentMarginOrderRisk: () => `${API_V1}/margin/parent-margin-account/simulate-order-risk`,
         simulateOrderRisk: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/simulate-order-risk`,
-        simulateOrderRiskAuto: () => `${API_V1}/margin/simulate-order-risk`,
+        simulateRiskBucketOrderRisk: () => `${API_V1}/margin/risk-buckets/simulate-order-risk`,
     },
     streams: {
         orderbook: () => `${API_V1}/streaming/orderbook`,
@@ -111,7 +116,6 @@ export const perpRoutes = {
         privateTrades: () => `${API_V1}/streaming/private-trades`,
         orders: () => `${API_V1}/streaming/orders`,
         positions: () => `${API_V1}/streaming/positions`,
-        marginAccount: () => `${API_V1}/streaming/margin-account`,
         funding: () => `${API_V1}/streaming/funding`,
         liquidationAlerts: () => `${API_V1}/streaming/liquidation-alerts`,
     },

package/dist/api/positions/api.d.ts

@@ -1,9 +1,10 @@
-import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, ClosePositionRequest, ClosePositionResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionMarginResponse, PositionRisk, PositionsAPI, ReducePositionMarginRequest } from "@0xmonaco/types";
+import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, BatchCloseAllRequest, BatchCloseAllResponse, ClosePositionRequest, ClosePositionResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionMarginResponse, PositionRisk, PositionsAPI, ReducePositionMarginRequest } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class PositionsAPIImpl extends BaseAPI implements PositionsAPI {
     listPositions(params?: ListPositionsParams): Promise<ListPositionsResponse>;
     getPosition(positionId: string): Promise<GetPositionResponse>;
     closePosition(positionId: string, request: ClosePositionRequest): Promise<ClosePositionResponse>;
+    batchCloseAllPositions(request?: BatchCloseAllRequest): Promise<BatchCloseAllResponse>;
     getPositionRisk(positionId: string): Promise<PositionRisk>;
     addPositionMargin(positionId: string, request: AddPositionMarginRequest): Promise<PositionMarginResponse>;
     reducePositionMargin(positionId: string, request: ReducePositionMarginRequest): Promise<PositionMarginResponse>;

package/dist/api/positions/api.js

@@ -1,4 +1,4 @@
-import { AddPositionMarginSchema, AttachPositionTpSlSchema, ClosePositionSchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, ReducePositionMarginSchema, validate, } from "@0xmonaco/types";
+import { AddPositionMarginSchema, AttachPositionTpSlSchema, BatchCloseAllSchema, ClosePositionSchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, ReducePositionMarginSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 export class PositionsAPIImpl extends BaseAPI {
@@ -24,6 +24,18 @@ export class PositionsAPIImpl extends BaseAPI {
             }),
         });
     }
+    async batchCloseAllPositions(request) {
+        if (request) {
+            validate(BatchCloseAllSchema, request);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.batchCloseAll(), {
+            method: "POST",
+            body: JSON.stringify({
+                trading_pair_id: request?.tradingPairId,
+                slippage_tolerance_bps: request?.slippageToleranceBps,
+            }),
+        });
+    }
     async getPositionRisk(positionId) {
         validate(GetPositionRiskSchema, { positionId });
         return await this.makeAuthenticatedRequest(perpRoutes.positions.risk(positionId));

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

@@ -17,7 +17,7 @@
  * console.log(`User: ${profile.username} (${profile.address})`);
  * ```
  */
-import type { AccountBalance, GetPaginatedUserMovementsResponse, GetUserBalancesParams, GetUserBalancesResponse, GetUserMovementsParams, GetUserTradesParams, GetUserTradesResponse, PortfolioChartResponse, PortfolioMetric, PortfolioPeriod, PortfolioStats, ProfileAPI, UserProfile } from "@0xmonaco/types";
+import type { AccountBalance, GetPaginatedUserMovementsResponse, GetUserBalancesParams, GetUserBalancesResponse, GetUserMovementsParams, GetUserTradesParams, GetUserTradesResponse, ListFundingPaymentsParams, ListFundingPaymentsResponse, PortfolioChartResponse, PortfolioMetric, PortfolioPeriod, PortfolioStats, ProfileAPI, UserProfile } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
     /**
@@ -188,4 +188,21 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * ```
      */
     getUserTrades(params?: GetUserTradesParams): Promise<GetUserTradesResponse>;
+    /**
+     * List the current user's funding payment history with pagination and filters.
+     *
+     * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
+     * Requires a valid access token to be set.
+     *
+     * @param params - Optional query parameters for pagination and filtering
+     * @returns Promise resolving to paginated funding payments response
+     * @throws {APIError} When the request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const funding = await profileAPI.listFundingPayments({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * console.log(`Total funding payments: ${funding.total}`);
+     * ```
+     */
+    listFundingPayments(params?: ListFundingPaymentsParams): Promise<ListFundingPaymentsResponse>;
 }

package/dist/api/profile/api.js

@@ -17,7 +17,7 @@
  * console.log(`User: ${profile.username} (${profile.address})`);
  * ```
  */
-import { GetUserMovementsSchema, GetUserTradesSchema, validate } from "@0xmonaco/types";
+import { GetUserMovementsSchema, GetUserTradesSchema, ListFundingPaymentsSchema, validate } from "@0xmonaco/types";
 import { APIError } from "../../errors";
 import { BaseAPI } from "../base";
 export class ProfileAPIImpl extends BaseAPI {
@@ -256,4 +256,44 @@ export class ProfileAPIImpl extends BaseAPI {
         const url = queryString ? `/api/v1/accounts/trades?${queryString}` : "/api/v1/accounts/trades";
         return await this.makeAuthenticatedRequest(url);
     }
+    /**
+     * List the current user's funding payment history with pagination and filters.
+     *
+     * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
+     * Requires a valid access token to be set.
+     *
+     * @param params - Optional query parameters for pagination and filtering
+     * @returns Promise resolving to paginated funding payments response
+     * @throws {APIError} When the request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const funding = await profileAPI.listFundingPayments({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * console.log(`Total funding payments: ${funding.total}`);
+     * ```
+     */
+    async listFundingPayments(params) {
+        if (params) {
+            validate(ListFundingPaymentsSchema, params);
+        }
+        const searchParams = new URLSearchParams();
+        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?.trading_pair_id !== undefined) {
+            searchParams.append("trading_pair_id", params.trading_pair_id);
+        }
+        if (params?.position_id !== undefined) {
+            searchParams.append("position_id", params.position_id);
+        }
+        if (params?.margin_account_id !== undefined) {
+            searchParams.append("margin_account_id", params.margin_account_id);
+        }
+        const queryString = searchParams.toString();
+        const url = queryString ? `/api/v1/accounts/funding-payments?${queryString}` : "/api/v1/accounts/funding-payments";
+        return await this.makeAuthenticatedRequest(url);
+    }
 }

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

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateConditionalOrderParams, CreateConditionalOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -80,8 +80,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
-        marginBucketId?: string;
-        marginBucketCollateral?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -134,8 +134,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
-        marginBucketId?: string;
-        marginBucketCollateral?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -160,7 +160,6 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     cancelOrder(orderId: string): Promise<CancelOrderResponse>;
-    createConditionalOrder(params: CreateConditionalOrderParams): Promise<CreateConditionalOrderResponse>;
     cancelConditionalOrder(conditionalOrderId: string): Promise<CancelConditionalOrderResponse>;
     listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**

package/dist/api/trading/api.js

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, CreateConditionalOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
+import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 function parentTpSlLegToRequest(leg) {
@@ -107,8 +107,8 @@ export class TradingAPIImpl extends BaseAPI {
             expiration_date: options?.expirationDate,
             time_in_force: options?.timeInForce,
             margin_account_id: options?.marginAccountId,
-            margin_bucket_id: options?.marginBucketId,
-            margin_bucket_collateral: options?.marginBucketCollateral,
+            risk_bucket_id: options?.riskBucketId,
+            risk_bucket_collateral: options?.riskBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -179,8 +179,8 @@ export class TradingAPIImpl extends BaseAPI {
             quantity,
             trading_mode: options?.tradingMode || "SPOT",
             margin_account_id: options?.marginAccountId,
-            margin_bucket_id: options?.marginBucketId,
-            margin_bucket_collateral: options?.marginBucketCollateral,
+            risk_bucket_id: options?.riskBucketId,
+            risk_bucket_collateral: options?.riskBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -220,29 +220,6 @@ export class TradingAPIImpl extends BaseAPI {
             body: JSON.stringify(requestBody),
         });
     }
-    async createConditionalOrder(params) {
-        validate(CreateConditionalOrderSchema, params);
-        const requestBody = {
-            trading_pair_id: params.tradingPairId,
-            margin_account_id: params.marginAccountId,
-            condition_type: params.conditionType,
-            trigger_price: params.triggerPrice,
-            trigger_source: params.triggerSource ?? "MARK_PRICE",
-            side: params.side,
-            position_side: params.positionSide,
-            order_type: params.orderType,
-            limit_price: params.limitPrice,
-            quantity: params.quantity,
-            reduce_only: params.reduceOnly ?? true,
-            time_in_force: params.timeInForce,
-            slippage_tolerance_bps: params.slippageToleranceBps,
-            expires_at: params.expiresAt,
-        };
-        return await this.makeAuthenticatedRequest(perpRoutes.orders.createConditional(), {
-            method: "POST",
-            body: JSON.stringify(requestBody),
-        });
-    }
     async cancelConditionalOrder(conditionalOrderId) {
         validate(CancelConditionalOrderSchema, { conditionalOrderId });
         return await this.makeAuthenticatedRequest(perpRoutes.orders.cancelConditional(conditionalOrderId), {
@@ -367,8 +344,8 @@ export class TradingAPIImpl extends BaseAPI {
                 expiration_date: order.expirationDate,
                 time_in_force: order.timeInForce,
                 margin_account_id: order.marginAccountId,
-                margin_bucket_id: order.marginBucketId,
-                margin_bucket_collateral: order.marginBucketCollateral,
+                risk_bucket_id: order.riskBucketId,
+                risk_bucket_collateral: order.riskBucketCollateral,
                 strategy_key: order.strategyKey,
                 position_side: order.positionSide,
                 leverage: order.leverage,