@0xmonaco/core 0.7.7 → 0.7.9

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

@@ -0,0 +1,20 @@
+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
+ *
+ * Provides read-only market metadata endpoints such as trading pair listings.
+ */
+export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
+    getPaginatedTradingPairs(params?: GetTradingPairsParams): Promise<GetTradingPairsResponse>;
+    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

@@ -0,0 +1,97 @@
+import { GetCandlesticksByPairIdSchema, GetMarketMetadataSchema, validate } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
+/**
+ * Market API Implementation
+ *
+ * Provides read-only market metadata endpoints such as trading pair listings.
+ */
+export class MarketAPIImpl extends BaseAPI {
+    async getPaginatedTradingPairs(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?.market_type) {
+            searchParams.append("market_type", params.market_type);
+        }
+        if (params?.base_token) {
+            searchParams.append("base_token", params.base_token);
+        }
+        if (params?.quote_token) {
+            searchParams.append("quote_token", params.quote_token);
+        }
+        if (params?.is_active !== undefined) {
+            searchParams.append("is_active", params.is_active.toString());
+        }
+        const queryString = searchParams.toString();
+        const url = queryString ? `/api/v1/market/pairs?${queryString}` : "/api/v1/market/pairs";
+        return await this.makePublicRequest(url);
+    }
+    async getTradingPairBySymbol(symbol) {
+        // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter
+        const response = await this.getPaginatedTradingPairs({ page_size: 100 });
+        return response.trading_pairs.find((pair) => pair.symbol === symbol);
+    }
+    async getCandlesticks(tradingPairId, interval, params) {
+        // Validate inputs using the trading pair ID schema
+        validate(GetCandlesticksByPairIdSchema, {
+            tradingPairId,
+            interval,
+            startTime: params?.startTime,
+            endTime: params?.endTime,
+            limit: params?.limit,
+        });
+        const searchParams = new URLSearchParams();
+        if (params?.startTime !== undefined) {
+            searchParams.append("start_time", params.startTime.toString());
+        }
+        if (params?.endTime !== undefined) {
+            searchParams.append("end_time", params.endTime.toString());
+        }
+        if (params?.limit !== undefined) {
+            searchParams.append("limit", params.limit.toString());
+        }
+        const queryString = searchParams.toString();
+        const url = queryString
+            ? `/api/v1/market/pairs/charts/candlestick/${encodeURIComponent(tradingPairId)}/${interval}?${queryString}`
+            : `/api/v1/market/pairs/charts/candlestick/${encodeURIComponent(tradingPairId)}/${interval}`;
+        const response = await this.makePublicRequest(url);
+        return response.data || [];
+    }
+    async getMarketMetadata(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        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/market/index.d.ts

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

package/dist/api/market/index.js

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

package/dist/api/orderbook/api.d.ts

@@ -0,0 +1,15 @@
+import type { OrderbookEvent, OrderbookQuotationMode, TradingMode } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export interface GetOrderbookOptions {
+    /** Number of price levels to return (max 100). Defaults to 10. */
+    depth?: number;
+    /** Trading mode: 'Spot' or 'Margin'. Defaults to 'Spot'. */
+    tradingMode?: TradingMode;
+    /** Price grouping magnitude. Valid values: 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000. */
+    magnitude?: number;
+    /** Quantity denomination: 'BASE' or 'QUOTE'. When 'QUOTE', quantities are multiplied by price. */
+    denomination?: OrderbookQuotationMode;
+}
+export declare class OrderbookAPIImpl extends BaseAPI {
+    getOrderbook(tradingPairId: string, options?: GetOrderbookOptions): Promise<OrderbookEvent>;
+}

package/dist/api/orderbook/api.js

@@ -0,0 +1,37 @@
+import { BaseAPI } from "../base";
+export class OrderbookAPIImpl extends BaseAPI {
+    async getOrderbook(tradingPairId, options = {}) {
+        const { depth = 10, tradingMode, magnitude, denomination } = options;
+        const params = new URLSearchParams();
+        params.set("levels", String(depth));
+        if (tradingMode)
+            params.set("trading_mode", tradingMode);
+        if (magnitude !== undefined)
+            params.set("magnitude", String(magnitude));
+        if (denomination)
+            params.set("denomination", denomination.toLowerCase());
+        const response = await this.makePublicRequest(`/api/v1/orderbook/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
+        return {
+            tradingPairId: response.symbol,
+            tradingMode: response.trading_mode,
+            bids: response.data.bids.map((level) => ({
+                price: level.price,
+                quantity: level.quantity,
+                orderCount: level.order_count,
+            })),
+            asks: response.data.asks.map((level) => ({
+                price: level.price,
+                quantity: level.quantity,
+                orderCount: level.order_count,
+            })),
+            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,
+            timestamp: response.timestamp,
+            sequence: response.sequence_number,
+        };
+    }
+}

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

@@ -0,0 +1 @@
+export { type GetOrderbookOptions, OrderbookAPIImpl } from "./api";

package/dist/api/orderbook/index.js

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

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,86 @@
+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({
+                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({
+                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({
+                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";