@0xmonaco/core 0.6.3 → 0.7.1

package/dist/api/index.d.ts

@@ -6,8 +6,11 @@
 export * from "./applications/index";
 export * from "./base";
 export * from "./fees";
+export * from "./margin-accounts";
 export * from "./market";
 export * from "./orderbook";
+export * from "./perp";
+export * from "./positions";
 export * from "./profile";
 export * from "./trades";
 export * from "./trading";

package/dist/api/index.js

@@ -6,8 +6,11 @@
 export * from "./applications/index";
 export * from "./base";
 export * from "./fees";
+export * from "./margin-accounts";
 export * from "./market";
 export * from "./orderbook";
+export * from "./perp";
+export * from "./positions";
 export * from "./profile";
 export * from "./trades";
 export * from "./trading";

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

@@ -0,0 +1,12 @@
+import type { CreateMarginAccountRequest, CreateMarginAccountResponse, GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateOrderRiskRequest, SimulateOrderRiskResponse, TransferCollateralRequest, TransferCollateralResponse } 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>;
+    getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
+    transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
+    simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+}

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

@@ -0,0 +1,69 @@
+import { CreateMarginAccountSchema, GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateOrderRiskSchema, TransferCollateralSchema, validate, } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
+export class MarginAccountsAPIImpl extends BaseAPI {
+    async listMarginAccounts(params) {
+        if (params) {
+            validate(ListMarginAccountsSchema, params);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.list(params));
+    }
+    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) {
+        validate(GetMarginAccountSummarySchema, { marginAccountId });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId));
+    }
+    async getAvailableCollateral(params) {
+        validate(GetAvailableCollateralSchema, params);
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.availableCollateral(params));
+    }
+    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,
+            }),
+        });
+    }
+    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,
+            }),
+        });
+    }
+    async getMarginAccountMovements(marginAccountId, params) {
+        validate(GetMarginAccountMovementsSchema, { marginAccountId, ...params });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.movements(marginAccountId, 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,
+                side: request.side,
+                position_side: request.positionSide,
+                order_type: request.orderType,
+                price: request.price,
+                quantity: request.quantity,
+                leverage: request.leverage,
+                reduce_only: request.reduceOnly,
+            }),
+        });
+    }
+}

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { Candlestick, GetCandlesticksParams, GetTradingPairsParams, GetTradingPairsResponse, Interval, MarketAPI, MarketMetadata, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -10,4 +10,11 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getTradingPairBySymbol(symbol: string): Promise<TradingPair | undefined>;
     getCandlesticks(tradingPairId: string, interval: Interval, params?: GetCandlesticksParams): Promise<Candlestick[]>;
     getMarketMetadata(tradingPairId: string): Promise<MarketMetadata>;
+    getPerpMarketConfig(tradingPairId: string): Promise<PerpMarketConfig>;
+    getPerpMarketSummary(tradingPairId: string): Promise<PerpMarketSummary>;
+    getMarkPrice(tradingPairId: string): Promise<MarkPrice>;
+    getIndexPrice(tradingPairId: string): Promise<IndexPrice>;
+    getFundingState(tradingPairId: string): Promise<FundingState>;
+    listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
+    getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
 }

package/dist/api/market/api.js

@@ -1,5 +1,6 @@
 import { GetCandlesticksByPairIdSchema, GetMarketMetadataSchema, validate } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
 /**
  * Market API Implementation
  *
@@ -11,8 +12,8 @@ export class MarketAPIImpl extends BaseAPI {
         if (params?.page !== undefined) {
             searchParams.append("page", params.page.toString());
         }
-        if (params?.limit !== undefined) {
-            searchParams.append("limit", params.limit.toString());
+        if (params?.page_size !== undefined) {
+            searchParams.append("page_size", params.page_size.toString());
         }
         if (params?.market_type) {
             searchParams.append("market_type", params.market_type);
@@ -32,8 +33,8 @@ export class MarketAPIImpl extends BaseAPI {
     }
     async getTradingPairBySymbol(symbol) {
         // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter
-        const response = await this.getPaginatedTradingPairs({ limit: 100 });
-        return response.data.data.find((pair) => pair.symbol === symbol);
+        const response = await this.getPaginatedTradingPairs({ page_size: 100 });
+        return response.trading_pairs.find((pair) => pair.symbol === symbol);
     }
     async getCandlesticks(tradingPairId, interval, params) {
         // Validate inputs using the trading pair ID schema
@@ -63,7 +64,34 @@ export class MarketAPIImpl extends BaseAPI {
     }
     async getMarketMetadata(tradingPairId) {
         validate(GetMarketMetadataSchema, { tradingPairId });
-        const url = `/api/v1/market/pairs/${tradingPairId}/metadata`;
-        return await this.makePublicRequest(url);
+        return await this.makePublicRequest(perpRoutes.market.getMarketMetadata(tradingPairId));
+    }
+    async getPerpMarketConfig(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getPerpMarketConfig(tradingPairId));
+    }
+    async getPerpMarketSummary(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getPerpMarketSummary(tradingPairId));
+    }
+    async getMarkPrice(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getMarkPrice(tradingPairId));
+    }
+    async getIndexPrice(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getIndexPrice(tradingPairId));
+    }
+    async getFundingState(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getFundingState(tradingPairId));
+    }
+    async listFundingHistory(tradingPairId, params) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.listFundingHistory(tradingPairId, params));
+    }
+    async getOpenInterest(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        return await this.makePublicRequest(perpRoutes.market.getOpenInterest(tradingPairId));
     }
 }

package/dist/api/orderbook/api.js

@@ -12,7 +12,7 @@ export class OrderbookAPIImpl extends BaseAPI {
             params.set("denomination", denomination.toLowerCase());
         const response = await this.makePublicRequest(`/api/v1/orderbook/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return {
-            tradingPairId: response.pair,
+            tradingPairId: response.symbol,
             tradingMode: response.trading_mode,
             bids: response.data.bids.map((level) => ({
                 price: level.price,

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

@@ -0,0 +1 @@
+export { perpRoutes } from "./routes";

package/dist/api/perp/index.js

@@ -0,0 +1 @@
+export { perpRoutes } from "./routes";

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

@@ -0,0 +1,133 @@
+export declare const perpRoutes: {
+    readonly orders: {
+        readonly create: () => string;
+        readonly list: (params?: {
+            page?: number;
+            page_size?: number;
+            status?: string;
+            trading_pair?: string;
+            trading_mode?: string;
+            margin_account_id?: string;
+        }) => string;
+        readonly get: (orderId: string) => string;
+        readonly replace: (orderId: string) => string;
+        readonly cancel: () => string;
+        readonly batchCancel: () => string;
+        readonly batchCancelAll: () => string;
+        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;
+            state?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+        readonly cancelConditional: (conditionalOrderId: string) => string;
+    };
+    readonly market: {
+        readonly listTradingPairs: (params?: {
+            page?: number;
+            limit?: number;
+            market_type?: string;
+            base_token?: string;
+            quote_token?: string;
+            is_active?: boolean;
+        }) => string;
+        readonly getTradingPair: (tradingPairId: string) => string;
+        readonly getCandles: (tradingPairId: string, interval: string, params?: {
+            start_time?: number;
+            end_time?: number;
+            limit?: number;
+        }) => string;
+        readonly getMarketMetadata: (tradingPairId: string) => string;
+        readonly getPerpMarketConfig: (tradingPairId: string) => string;
+        readonly getPerpMarketSummary: (tradingPairId: string) => string;
+        readonly getMarkPrice: (tradingPairId: string) => string;
+        readonly getIndexPrice: (tradingPairId: string) => string;
+        readonly getFundingState: (tradingPairId: string) => string;
+        readonly listFundingHistory: (tradingPairId: string, params?: {
+            start_time?: string;
+            end_time?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+        readonly getOpenInterest: (tradingPairId: string) => string;
+    };
+    readonly orderbook: {
+        readonly get: (tradingPairId: string, params?: {
+            levels?: number;
+            trading_mode?: string;
+            magnitude?: string | number;
+            denomination?: string;
+        }) => string;
+    };
+    readonly trades: {
+        readonly publicByPair: (tradingPairId: string, params?: {
+            skip?: number;
+            limit?: number;
+        }) => string;
+        readonly user: (params?: {
+            margin_account_id?: string;
+            trading_pair_id?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+    };
+    readonly positions: {
+        readonly list: (params?: {
+            margin_account_id?: string;
+            trading_pair_id?: string;
+            status?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+        readonly get: (positionId: string) => string;
+        readonly close: (positionId: string) => string;
+        readonly risk: (positionId: string) => string;
+        readonly addMargin: (positionId: string) => string;
+        readonly reduceMargin: (positionId: string) => string;
+        readonly attachTpSl: (positionId: string) => string;
+        readonly history: (params?: {
+            position_id?: string;
+            margin_account_id?: string;
+            trading_pair_id?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+    };
+    readonly marginAccounts: {
+        readonly list: (params?: {
+            page?: number;
+            page_size?: number;
+            state?: string;
+        }) => string;
+        readonly create: () => string;
+        readonly summary: (marginAccountId: string) => string;
+        readonly availableCollateral: (params?: {
+            asset?: string;
+        }) => string;
+        readonly transferIn: (marginAccountId: string) => string;
+        readonly transferOut: (marginAccountId: string) => string;
+        readonly movements: (marginAccountId: string, params?: {
+            movement_type?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+        readonly simulateOrderRisk: (marginAccountId: string) => string;
+    };
+    readonly streams: {
+        readonly orderbook: () => string;
+        readonly trades: () => string;
+        readonly perpMarketSummaries: () => string;
+        readonly markPrices: () => string;
+        readonly privateTrades: () => string;
+        readonly orders: () => string;
+        readonly positions: () => string;
+        readonly marginAccount: () => string;
+        readonly funding: () => string;
+        readonly liquidationAlerts: () => string;
+    };
+};

package/dist/api/perp/routes.js

@@ -0,0 +1,85 @@
+const API_V1 = "/api/v1";
+function encodeSegment(value) {
+    return encodeURIComponent(value);
+}
+function withQuery(path, params) {
+    if (!params)
+        return path;
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            searchParams.set(key, String(value));
+        }
+    }
+    const query = searchParams.toString();
+    return query ? `${path}?${query}` : path;
+}
+export const perpRoutes = {
+    orders: {
+        create: () => `${API_V1}/orders`,
+        list: (params) => withQuery(`${API_V1}/orders`, params),
+        get: (orderId) => `${API_V1}/orders/${encodeSegment(orderId)}`,
+        replace: (orderId) => `${API_V1}/orders/${encodeSegment(orderId)}`,
+        cancel: () => `${API_V1}/orders/cancel`,
+        batchCancel: () => `${API_V1}/orders/batch-cancel`,
+        batchCancelAll: () => `${API_V1}/orders/batch-cancel-all`,
+        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)}`,
+    },
+    market: {
+        listTradingPairs: (params) => withQuery(`${API_V1}/market/pairs`, params),
+        getTradingPair: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}`,
+        getCandles: (tradingPairId, interval, params) => withQuery(`${API_V1}/market/pairs/charts/candlestick/${encodeSegment(tradingPairId)}/${encodeSegment(interval)}`, params),
+        getMarketMetadata: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/metadata`,
+        getPerpMarketConfig: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/perp/config`,
+        getPerpMarketSummary: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/perp/summary`,
+        getMarkPrice: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/mark-price`,
+        getIndexPrice: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/index-price`,
+        getFundingState: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding`,
+        listFundingHistory: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding/history`, params),
+        getOpenInterest: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/open-interest`,
+    },
+    orderbook: {
+        get: (tradingPairId, params) => withQuery(`${API_V1}/orderbook/${encodeSegment(tradingPairId)}`, params),
+    },
+    trades: {
+        publicByPair: (tradingPairId, params) => withQuery(`${API_V1}/trades/${encodeSegment(tradingPairId)}`, params),
+        user: (params) => withQuery(`${API_V1}/accounts/trades`, params),
+    },
+    positions: {
+        list: (params) => withQuery(`${API_V1}/positions`, params),
+        get: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}`,
+        close: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/close`,
+        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`,
+        attachTpSl: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/tp-sl`,
+        history: (params) => withQuery(`${API_V1}/positions/history`, params),
+    },
+    marginAccounts: {
+        list: (params) => withQuery(`${API_V1}/margin/accounts`, params),
+        create: () => `${API_V1}/margin/accounts`,
+        summary: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}`,
+        availableCollateral: (params) => withQuery(`${API_V1}/margin/collateral/available`, params),
+        transferIn: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-in`,
+        transferOut: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-out`,
+        movements: (marginAccountId, params) => withQuery(`${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/movements`, params),
+        simulateOrderRisk: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/simulate-order-risk`,
+    },
+    streams: {
+        orderbook: () => `${API_V1}/streaming/orderbook`,
+        trades: () => `${API_V1}/streaming/trades`,
+        perpMarketSummaries: () => `${API_V1}/streaming/perp-market-summaries`,
+        markPrices: () => `${API_V1}/streaming/mark-prices`,
+        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

@@ -0,0 +1,12 @@
+import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, 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>;
+    getPositionRisk(positionId: string): Promise<PositionRisk>;
+    addPositionMargin(positionId: string, request: AddPositionMarginRequest): Promise<PositionMarginResponse>;
+    reducePositionMargin(positionId: string, request: ReducePositionMarginRequest): Promise<PositionMarginResponse>;
+    attachPositionTpSl(positionId: string, request: AttachPositionTpSlRequest): Promise<AttachPositionTpSlResponse>;
+    listPositionHistory(params?: ListPositionHistoryParams): Promise<ListPositionHistoryResponse>;
+}

package/dist/api/positions/api.js

@@ -0,0 +1,89 @@
+import { AddPositionMarginSchema, AttachPositionTpSlSchema, ClosePositionSchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, ReducePositionMarginSchema, validate, } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
+export class PositionsAPIImpl extends BaseAPI {
+    async listPositions(params) {
+        if (params) {
+            validate(ListPositionsSchema, params);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.list(params));
+    }
+    async getPosition(positionId) {
+        validate(GetPositionSchema, { positionId });
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.get(positionId));
+    }
+    async closePosition(positionId, request) {
+        validate(ClosePositionSchema, { positionId, request });
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.close(positionId), {
+            method: "POST",
+            body: JSON.stringify({
+                position_id: positionId,
+                close_type: request.closeType,
+                limit_price: request.limitPrice,
+                slippage_tolerance_bps: request.slippageToleranceBps,
+                quantity: request.quantity,
+            }),
+        });
+    }
+    async getPositionRisk(positionId) {
+        validate(GetPositionRiskSchema, { positionId });
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.risk(positionId));
+    }
+    async addPositionMargin(positionId, request) {
+        validate(AddPositionMarginSchema, { positionId, request });
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.addMargin(positionId), {
+            method: "POST",
+            body: JSON.stringify({
+                position_id: positionId,
+                amount: request.amount,
+                asset: request.asset,
+            }),
+        });
+    }
+    async reducePositionMargin(positionId, request) {
+        validate(ReducePositionMarginSchema, { positionId, request });
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.reduceMargin(positionId), {
+            method: "POST",
+            body: JSON.stringify({
+                position_id: positionId,
+                amount: request.amount,
+            }),
+        });
+    }
+    async attachPositionTpSl(positionId, request) {
+        validate(AttachPositionTpSlSchema, { positionId, request });
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.attachTpSl(positionId), {
+            method: "POST",
+            body: JSON.stringify({
+                take_profit: request.takeProfit
+                    ? {
+                        trigger_price: request.takeProfit.triggerPrice,
+                        order_type: request.takeProfit.orderType,
+                        limit_price: request.takeProfit.limitPrice,
+                        quantity: request.takeProfit.quantity,
+                        time_in_force: request.takeProfit.timeInForce,
+                        slippage_tolerance_bps: request.takeProfit.slippageToleranceBps,
+                        expires_at: request.takeProfit.expiresAt,
+                    }
+                    : undefined,
+                stop_loss: request.stopLoss
+                    ? {
+                        trigger_price: request.stopLoss.triggerPrice,
+                        order_type: request.stopLoss.orderType,
+                        limit_price: request.stopLoss.limitPrice,
+                        quantity: request.stopLoss.quantity,
+                        time_in_force: request.stopLoss.timeInForce,
+                        slippage_tolerance_bps: request.stopLoss.slippageToleranceBps,
+                        expires_at: request.stopLoss.expiresAt,
+                    }
+                    : undefined,
+            }),
+        });
+    }
+    async listPositionHistory(params) {
+        if (params) {
+            validate(ListPositionHistorySchema, params);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.history(params));
+    }
+}

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

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

package/dist/api/positions/index.js

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

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

@@ -61,12 +61,12 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *
      * @example
      * ```typescript
-     * // Get first page with default limit (20)
+     * // Get first page with default page_size (20)
      * const movements = await profileAPI.getPaginatedUserMovements();
-     * console.log(`Total movements: ${movements.total_count}`);
+     * console.log(`Total movements: ${movements.total}`);
      *
-     * // Get second page with custom limit
-     * const page2 = await profileAPI.getPaginatedUserMovements({ page: 2, limit: 50 });
+     * // 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}`);
      *
      * // Filter by entry type and transaction type
@@ -84,8 +84,8 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * Requires a valid access token to be set.
      *
      * @param params - Optional query parameters for pagination
-     * @param params.limit - Number of items to return (default: 20)
-     * @param params.offset - Number of items to skip (default: 0)
+     * @param params.page - Page number (starts from 1, default: 1)
+     * @param params.page_size - 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
      *
@@ -98,8 +98,8 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *   console.log(`${balance.symbol}: ${balance.available_balance}`);
      * });
      *
-     * // Get next 50 balances with offset
-     * const nextBalances = await profileAPI.getUserBalances({ limit: 50, offset: 20 });
+     * // Get page 2 with 50 items per page
+     * const nextBalances = await profileAPI.getUserBalances({ page: 2, page_size: 50 });
      * console.log(`Returned ${nextBalances.balances.length} balances`);
      * ```
      */
@@ -171,7 +171,7 @@ 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.page_size - Number of items per page (default: 20, max: 100)
      * @param params.trading_pair_id - Filter by trading pair ID (UUID)
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
@@ -181,7 +181,7 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * ```typescript
      * // Get first page of trades
      * const trades = await profileAPI.getUserTrades();
-     * console.log(`Total trades: ${trades.total_count}`);
+     * console.log(`Total trades: ${trades.total}`);
      *
      * // Filter by trading pair
      * const pairTrades = await profileAPI.getUserTrades({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });