@0xmonaco/core 0.6.2 → 0.7.0

package/dist/api/auth/api.d.ts

@@ -182,14 +182,15 @@ export declare class AuthAPIImpl extends BaseAPI implements AuthAPI {
      */
     refreshToken(refreshToken: string): Promise<TokenRefreshResponse>;
     /**
-     * Revokes a refresh token.
+     * Revokes the current session's refresh token.
      *
-     * Invalidates a refresh token, preventing it from being used to obtain
-     * new access tokens. This is useful for logout functionality or when
-     * a token has been compromised.
+     * Invalidates the refresh token associated with the current access token,
+     * preventing it from being used to obtain new access tokens. This is useful
+     * for logout functionality or when a token has been compromised.
+     *
+     * The server identifies the token to revoke from the access token in the
+     * Authorization header — no request body is needed.
      *
-     * **Important:** Pass the `refreshToken` from the authentication response.
-     * @param refreshToken - The refresh token to revoke (from authResult.refreshToken)
      * @returns Promise resolving when the token is revoked
      * @throws {APIError} When token revocation fails
      *
@@ -197,9 +198,9 @@ export declare class AuthAPIImpl extends BaseAPI implements AuthAPI {
      * ```typescript
      * // After authentication
      * const authResult = await authAPI.authenticate(clientId);
-     * await authAPI.revokeToken(authResult.refreshToken);
+     * await authAPI.revokeToken();
      * console.log("Token revoked successfully");
      * ```
      */
-    revokeToken(refreshToken: string): Promise<void>;
+    revokeToken(): Promise<void>;
 }

package/dist/api/auth/api.js

@@ -277,14 +277,15 @@ export class AuthAPIImpl extends BaseAPI {
         };
     }
     /**
-     * Revokes a refresh token.
+     * Revokes the current session's refresh token.
      *
-     * Invalidates a refresh token, preventing it from being used to obtain
-     * new access tokens. This is useful for logout functionality or when
-     * a token has been compromised.
+     * Invalidates the refresh token associated with the current access token,
+     * preventing it from being used to obtain new access tokens. This is useful
+     * for logout functionality or when a token has been compromised.
+     *
+     * The server identifies the token to revoke from the access token in the
+     * Authorization header — no request body is needed.
      *
-     * **Important:** Pass the `refreshToken` from the authentication response.
-     * @param refreshToken - The refresh token to revoke (from authResult.refreshToken)
      * @returns Promise resolving when the token is revoked
      * @throws {APIError} When token revocation fails
      *
@@ -292,16 +293,13 @@ export class AuthAPIImpl extends BaseAPI {
      * ```typescript
      * // After authentication
      * const authResult = await authAPI.authenticate(clientId);
-     * await authAPI.revokeToken(authResult.refreshToken);
+     * await authAPI.revokeToken();
      * console.log("Token revoked successfully");
      * ```
      */
-    async revokeToken(refreshToken) {
+    async revokeToken() {
         await this.makeAuthenticatedRequest("/api/v1/auth/revoke", {
             method: "POST",
-            body: JSON.stringify({
-                refresh_token: refreshToken,
-            }),
         });
     }
 }

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
  *
@@ -33,7 +34,7 @@ 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({ page_size: 100 });
-        return response.data.data.find((pair) => pair.symbol === symbol);
+        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,88 @@
+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({
+                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/trades/api.d.ts

@@ -5,7 +5,7 @@ import { BaseAPI } from "../base";
  */
 interface RawTradeEvent {
     event_type: string;
-    pair_id: string;
+    trading_pair_id: string;
     trading_mode: string;
     data: {
         trade_id: string;

package/dist/api/trades/api.js

@@ -5,7 +5,7 @@ import { BaseAPI } from "../base";
 export function parseRawTradeEvent(raw) {
     return {
         eventType: "trade",
-        tradingPairId: raw.pair_id,
+        tradingPairId: raw.trading_pair_id,
         tradingMode: raw.trading_mode.toUpperCase(),
         data: {
             tradeId: raw.data.trade_id,
@@ -37,6 +37,6 @@ export class TradesAPIImpl extends BaseAPI {
         }
         params.set("page_size", String(page_size));
         const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
-        return response.data.trades.map(parseRawTradeEvent);
+        return response.trades.map(parseRawTradeEvent);
     }
 }